Description: paint ability of canvas move down to gfx

IssueNo: https://gitee.com/openharmony/graphic_ui/issues/I58ZFB
Feature or Bugfix: Feature
Binary Source:No
Signed-off-by: Nlancer <haoshuo@huawei.com>

BUILD.gn

@@ -167,6 +167,7 @@ lite_library("ui") {
     "frameworks/dock/virtual_input_device.cpp",
     "frameworks/draw/clip_utils.cpp",
     "frameworks/draw/draw_arc.cpp",
+    "frameworks/draw/draw_canvas.cpp",
     "frameworks/draw/draw_curve.cpp",
     "frameworks/draw/draw_image.cpp",
     "frameworks/draw/draw_label.cpp",

frameworks/components/root_view.cpp

@@ -824,7 +824,7 @@ void RootView::InitMapBufferInfo(BufferInfo* bufferInfo)
 void RootView::DestroyMapBufferInfo()
 {
     if (dc_.mapBufferInfo != nullptr) {
-        BaseGfxEngine::GetInstance()->FreeBuffer(static_cast<uint8_t*>(dc_.mapBufferInfo->virAddr));
+        BaseGfxEngine::GetInstance()->FreeBuffer(static_cast<uint8_t*>(dc_.mapBufferInfo->virAddr), BUFFER_MAP_SURFACE);
         dc_.mapBufferInfo->virAddr = dc_.mapBufferInfo->phyAddr = nullptr;
         delete dc_.mapBufferInfo;
         dc_.mapBufferInfo = nullptr;

frameworks/draw/draw_canvas.cpp

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "draw/draw_canvas.h"
+#include "common/typed_text.h"
+#include "draw/clip_utils.h"
+#include "gfx_utils/diagram/depiction/depict_curve.h"
+#include "gfx_utils/diagram/spancolorfill/fill_gradient.h"
+#include "gfx_utils/diagram/spancolorfill/fill_interpolator.h"
+
+namespace OHOS {
+/**
+ * Renders monochrome polygon paths and fills
+ */
+void RenderSolid(const Paint& paint, RasterizerScanlineAntialias& rasterizer, RenderBase& renBase, const bool& isStroke)
+{
+    GeometryScanline scanline;
+    Rgba8T color;
+    DrawCanvas::RenderBlendSolid(paint, color, isStroke);
+    RenderScanlinesAntiAliasSolid(rasterizer, scanline, renBase, color);
+}
+
+void DrawCanvas::DoRender(BufferInfo& gfxDstBuffer,
+                          void* param,
+                          const Paint& paint,
+                          const Rect& rect,
+                          const Rect& invalidatedArea,
+                          const Style& style,
+                          const bool& isStroke)
+{
+    if (param == nullptr) {
+        return;
+    }
+#if GRAPHIC_ENABLE_SHADOW_EFFECT_FLAG
+    if (paint.HaveShadow()) {
+        DrawCanvas::DoDrawShadow(gfxDstBuffer, param, paint, rect, invalidatedArea, style, isStroke);
+    }
+#endif
+    TransAffine transform;
+    RenderBuffer renderBuffer;
+    InitRenderAndTransform(gfxDstBuffer, renderBuffer, rect, transform, style, paint);
+
+    RasterizerScanlineAntialias rasterizer;
+    GeometryScanline scanline;
+
+    PathParam* pathParam = static_cast<PathParam*>(param);
+    rasterizer.ClipBox(0, 0, gfxDstBuffer.width, gfxDstBuffer.height);
+    SetRasterizer(*pathParam->vertices, paint, rasterizer, transform, isStroke);
+
+    RenderPixfmtRgbaBlend pixFormat(renderBuffer);
+    RenderBase renBase(pixFormat);
+    FillBase allocator;
+
+    renBase.ResetClipping(true);
+    renBase.ClipBox(invalidatedArea.GetLeft(), invalidatedArea.GetTop(), invalidatedArea.GetRight(),
+                    invalidatedArea.GetBottom());
+
+    if (paint.GetStyle() == Paint::STROKE_STYLE || paint.GetStyle() == Paint::FILL_STYLE ||
+        paint.GetStyle() == Paint::STROKE_FILL_STYLE) {
+        RenderSolid(paint, rasterizer, renBase, isStroke);
+    }
+
+#if GRAPHIC_ENABLE_GRADIENT_FILL_FLAG
+    if (paint.GetStyle() == Paint::GRADIENT) {
+        RenderGradient(paint, rasterizer, transform, renBase, renderBuffer, allocator, invalidatedArea);
+    }
+#endif
+#if GRAPHIC_ENABLE_PATTERN_FILL_FLAG
+    if (paint.GetStyle() == Paint::PATTERN) {
+        RenderPattern(paint, pathParam->imageParam, rasterizer, renBase, allocator, rect);
+    }
+#endif
+}
+
+#if GRAPHIC_ENABLE_SHADOW_EFFECT_FLAG
+void DrawCanvas::DoDrawShadow(BufferInfo& gfxDstBuffer,
+                              void* param,
+                              const Paint& paint,
+                              const Rect& rect,
+                              const Rect& invalidatedArea,
+                              const Style& style,
+                              const bool& isStroke)
+{
+    if (param == nullptr) {
+        return;
+    }
+
+    TransAffine transform;
+    RenderBuffer renderBuffer;
+    DrawCanvas::InitRenderAndTransform(gfxDstBuffer, renderBuffer, rect, transform, style, paint);
+
+    transform.Translate(paint.GetShadowOffsetX(), paint.GetShadowOffsetY());
+
+    RasterizerScanlineAntialias rasterizer;
+    GeometryScanline scanline;
+    PathParam* pathParam = static_cast<PathParam*>(param);
+    rasterizer.ClipBox(0, 0, gfxDstBuffer.width, gfxDstBuffer.height);
+    DrawCanvas::SetRasterizer(*pathParam->vertices, paint, rasterizer, transform, isStroke);
+    Rect bbox(rasterizer.GetMinX(), rasterizer.GetMinY(), rasterizer.GetMaxX(), rasterizer.GetMaxY());
+
+    RenderPixfmtRgbaBlend pixFormat(renderBuffer);
+    RenderBase renBase(pixFormat);
+    FillBase allocator;
+
+    renBase.ResetClipping(true);
+    renBase.ClipBox(invalidatedArea.GetLeft(), invalidatedArea.GetTop(), invalidatedArea.GetRight(),
+                    invalidatedArea.GetBottom());
+
+    Rgba8T shadowColor;
+    DrawCanvas::ChangeColor(shadowColor, paint.GetShadowColor(), paint.GetShadowColor().alpha * paint.GetGlobalAlpha());
+
+    RenderScanlinesAntiAliasSolid(rasterizer, scanline, renBase, shadowColor);
+#if GRAPHIC_ENABLE_BLUR_EFFECT_FLAG
+    bbox.SetLeft(bbox.GetLeft() - paint.GetShadowBlur());
+    bbox.SetTop(bbox.GetTop() - paint.GetShadowBlur());
+    bbox.SetRight(bbox.GetRight() + paint.GetShadowBlur());
+    bbox.SetBottom(bbox.GetBottom() + paint.GetShadowBlur());
+    RenderBuffer shadowBuffer;
+    RenderPixfmtRgbaBlend pixf2(shadowBuffer);
+    Rect shadowRect = {int16_t(bbox.GetLeft()), int16_t(bbox.GetTop()), int16_t(bbox.GetRight()),
+                       int16_t(bbox.GetBottom())};
+    shadowRect.Intersect(shadowRect, invalidatedArea);
+    pixf2.Attach(pixFormat, shadowRect.GetLeft(), shadowRect.GetTop(), shadowRect.GetRight(), shadowRect.GetBottom());
+    uint8_t pixelByteSize = DrawUtils::GetPxSizeByColorMode(gfxDstBuffer.mode) >> 3; // 3: Shift right 3 bits
+
+    paint.GetDrawBoxBlur().BoxBlur(pixf2, MATH_UROUND(paint.GetShadowBlur()), pixelByteSize, gfxDstBuffer.stride);
+
+#endif // GRAPHIC_ENABLE_BLUR_EFFECT_FLAG
+}
+#endif // GRAPHIC_ENABLE_SHADOW_EFFECT_FLAG
+
+void DrawCanvas::InitRenderAndTransform(BufferInfo& gfxDstBuffer,
+                                        RenderBuffer& renderBuffer,
+                                        const Rect& rect,
+                                        TransAffine& transform,
+                                        const Style& style,
+                                        const Paint& paint)
+{
+    int16_t realLeft = rect.GetLeft() + style.paddingLeft_ + style.borderWidth_;
+    int16_t realTop = rect.GetTop() + style.paddingTop_ + style.borderWidth_;
+    transform.Reset();
+    transform *= paint.GetTransAffine();
+    transform.Translate(realLeft, realTop);
+    renderBuffer.Attach(static_cast<uint8_t*>(gfxDstBuffer.virAddr), gfxDstBuffer.width, gfxDstBuffer.height,
+                        gfxDstBuffer.stride);
+}
+
+void DrawCanvas::SetRasterizer(UICanvasVertices& vertices,
+                               const Paint& paint,
+                               RasterizerScanlineAntialias& rasterizer,
+                               TransAffine& transform,
+                               const bool& isStroke)
+{
+    DepictCurve canvasPath(vertices);
+    if (isStroke) {
+#if GRAPHIC_ENABLE_DASH_GENERATE_FLAG
+        if (paint.IsLineDash()) {
+            using DashStyle = DepictDash;
+            using StrokeDashStyle = DepictStroke<DashStyle>;
+            using StrokeDashTransform = DepictTransform<StrokeDashStyle>;
+            DashStyle dashStyle(canvasPath);
+            LineDashStyleCalc(dashStyle, paint);
+            StrokeDashStyle strokeDashStyle(dashStyle);
+            LineStyleCalc(strokeDashStyle, paint);
+            StrokeDashTransform strokeDashTransform(strokeDashStyle, transform);
+            rasterizer.Reset();
+            rasterizer.AddPath(strokeDashTransform);
+            return;
+        }
+#endif
+        using StrokeLineStyle = DepictStroke<DepictCurve>;
+        StrokeLineStyle strokeLineStyle(canvasPath);
+        LineStyleCalc(strokeLineStyle, paint);
+
+        DepictTransform<StrokeLineStyle> strokeTransform(strokeLineStyle, transform);
+        rasterizer.Reset();
+        rasterizer.AddPath(strokeTransform);
+    } else {
+        DepictTransform<DepictCurve> pathTransform(canvasPath, transform);
+        rasterizer.Reset();
+        rasterizer.AddPath(pathTransform);
+    }
+}
+
+#if GRAPHIC_ENABLE_GRADIENT_FILL_FLAG
+void DrawCanvas::RenderGradient(const Paint& paint,
+                                RasterizerScanlineAntialias& rasterizer,
+                                TransAffine& transform,
+                                RenderBase& renBase,
+                                RenderBuffer& renderBuffer,
+                                FillBase& allocator,
+                                const Rect& invalidatedArea)
+{
+    GeometryScanline scanline;
+
+    RenderPixfmtRgbaBlend pixFormatComp(renderBuffer);
+    RenderBase m_renBaseComp(pixFormatComp);
+
+    m_renBaseComp.ResetClipping(true);
+    m_renBaseComp.ClipBox(invalidatedArea.GetLeft(), invalidatedArea.GetTop(), invalidatedArea.GetRight(),
+                          invalidatedArea.GetBottom());
+    TransAffine gradientMatrix;
+    FillInterpolator interpolatorType(gradientMatrix);
+    FillGradientLut gradientColorMode;
+    BuildGradientColor(paint, gradientColorMode);
+    if (paint.GetGradient() == Paint::Linear) {
+        float distance = 0;
+        BuildLineGradientMatrix(paint, gradientMatrix, transform, distance);
+        GradientLinearCalculate gradientLinearCalculate;
+        FillGradient span(interpolatorType, gradientLinearCalculate, gradientColorMode, 0, distance);
+        RenderScanlinesAntiAlias(rasterizer, scanline, renBase, allocator, span);
+    }
+
+    if (paint.GetGradient() == Paint::Radial) {
+        Paint::RadialGradientPoint radialPoint = paint.GetRadialGradientPoint();
+        float startRadius = 0;
+        float endRadius = 0;
+        BuildRadialGradientMatrix(paint, gradientMatrix, transform, startRadius, endRadius);
+        GradientRadialCalculate gradientRadialCalculate(radialPoint.r1, radialPoint.x0 - radialPoint.x1,
+                                                        radialPoint.y0 - radialPoint.y1);
+        FillGradient span(interpolatorType, gradientRadialCalculate, gradientColorMode, startRadius, endRadius);
+        RenderScanlinesAntiAlias(rasterizer, scanline, renBase, allocator, span);
+    }
+}
+
+void DrawCanvas::BuildGradientColor(const Paint& paint, FillGradientLut& gradientColorMode)
+{
+    gradientColorMode.RemoveAll();
+    ListNode<Paint::StopAndColor>* iter = paint.getStopAndColor().Begin();
+    uint16_t count = 0;
+    for (; count < paint.getStopAndColor().Size(); count++) {
+        ColorType stopColor = iter->data_.color;
+        Rgba8T sRgba8;
+        ChangeColor(sRgba8, stopColor, stopColor.alpha * paint.GetGlobalAlpha());
+        gradientColorMode.AddColor(iter->data_.stop, sRgba8);
+        iter = iter->next_;
+    }
+    gradientColorMode.BuildLut();
+}
+
+void DrawCanvas::BuildRadialGradientMatrix(const Paint& paint,
+                                           TransAffine& gradientMatrix,
+                                           TransAffine& transform,
+                                           float& startRadius,
+                                           float& endRadius)
+{
+    Paint::RadialGradientPoint radialPoint = paint.GetRadialGradientPoint();
+    gradientMatrix.Reset();
+    gradientMatrix *= TransAffine::TransAffineTranslation(radialPoint.x1, radialPoint.y1);
+    gradientMatrix *= transform;
+    gradientMatrix.Invert();
+    startRadius = radialPoint.r0;
+    endRadius = radialPoint.r1;
+}
+#endif // GRAPHIC_ENABLE_GRADIENT_FILL_FLAG
+
+#if GRAPHIC_ENABLE_PATTERN_FILL_FLAG
+void DrawCanvas::RenderPattern(const Paint& paint,
+                               void* param,
+                               RasterizerScanlineAntialias& rasterizer,
+                               RenderBase& renBase,
+                               FillBase& allocator,
+                               const Rect& rect)
+{
+    if (param == nullptr) {
+        return;
+    }
+    ImageParam* imageParam = static_cast<ImageParam*>(param);
+    if (imageParam->image == nullptr) {
+        return;
+    }
+    GeometryScanline scanline;
+    FillPatternRgba spanPattern(imageParam->image->GetImageInfo(), paint.GetPatternRepeatMode(), rect.GetLeft(),
+                                rect.GetTop());
+    RenderScanlinesAntiAlias(rasterizer, scanline, renBase, allocator, spanPattern);
+}
+#endif // GRAPHIC_ENABLE_PATTERN_FILL_FLAG
+
+} // namespace OHOS

frameworks/draw/draw_canvas.h

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef GRAPHIC_LITE_DRAW_CANVAS_H
+#define GRAPHIC_LITE_DRAW_CANVAS_H
+
+#include "common/image.h"
+#include "gfx_utils/diagram/common/paint.h"
+#include "gfx_utils/diagram/depiction/depict_dash.h"
+#include "gfx_utils/diagram/depiction/depict_stroke.h"
+#include "gfx_utils/diagram/rasterizer/rasterizer_scanline_antialias.h"
+#include "gfx_utils/diagram/spancolorfill/fill_gradient_lut.h"
+
+
+namespace OHOS {
+
+struct ImageParam : public HeapBase {
+    Point start;
+    uint16_t height;
+    uint16_t width;
+    int16_t newWidth;
+    int16_t newHeight;
+    Image* image;
+};
+
+struct PathParam : public HeapBase {
+    UICanvasVertices* vertices;
+    ImageParam* imageParam = nullptr;
+    bool isStroke;
+};
+
+class RenderBuffer;
+class RenderBase;
+class DrawCanvas : public HeapBase {
+public:
+    static void DoRender(BufferInfo& gfxDstBuffer,
+                         void* param,
+                         const Paint& paint,
+                         const Rect& rect,
+                         const Rect& invalidatedArea,
+                         const Style& style,
+                         const bool& isStroke);
+
+#if GRAPHIC_ENABLE_SHADOW_EFFECT_FLAG
+    static void DoDrawShadow(BufferInfo& gfxDstBuffer,
+                             void* param,
+                             const Paint& paint,
+                             const Rect& rect,
+                             const Rect& invalidatedArea,
+                             const Style& style,
+                             const bool& isStroke);
+#endif
+
+    static void InitRenderAndTransform(BufferInfo& gfxDstBuffer,
+                                       RenderBuffer& renderBuffer,
+                                       const Rect& rect,
+                                       TransAffine& transform,
+                                       const Style& style,
+                                       const Paint& paint);
+
+    static void SetRasterizer(UICanvasVertices& vertices,
+                              const Paint& paint,
+                              RasterizerScanlineAntialias& rasterizer,
+                              TransAffine& transform,
+                              const bool& isStroke);
+
+#if GRAPHIC_ENABLE_GRADIENT_FILL_FLAG
+    /**
+     * Render gradient
+     */
+    static void RenderGradient(const Paint& paint,
+                               RasterizerScanlineAntialias& rasterizer,
+                               TransAffine& transform,
+                               RenderBase& renBase,
+                               RenderBuffer& renderBuffer,
+                               FillBase& allocator,
+                               const Rect& invalidatedArea);
+
+    static void BuildGradientColor(const Paint& paint, FillGradientLut& gradientColorMode);
+
+    static void BuildLineGradientMatrix(const Paint& paint,
+                                        TransAffine& gradientMatrix,
+                                        TransAffine& transform,
+                                        float& distance)
+    {
+        Paint::LinearGradientPoint linearPoint = paint.GetLinearGradientPoint();
+        float angle = FastAtan2F(linearPoint.y1 - linearPoint.y0, linearPoint.x1 - linearPoint.x0);
+        gradientMatrix.Reset();
+        gradientMatrix *= TransAffine::TransAffineRotation(angle);
+        gradientMatrix *= TransAffine::TransAffineTranslation(linearPoint.x0, linearPoint.y0);
+        gradientMatrix *= transform;
+        gradientMatrix.Invert();
+        distance = Sqrt((linearPoint.x1 - linearPoint.x0) * (linearPoint.x1 - linearPoint.x0) +
+                        (linearPoint.y1 - linearPoint.y0) * (linearPoint.y1 - linearPoint.y0));
+    }
+
+    static void BuildRadialGradientMatrix(const Paint& paint,
+                                          TransAffine& gradientMatrix,
+                                          TransAffine& transform,
+                                          float& startRadius,
+                                          float& endRadius);
+#endif // GRAPHIC_ENABLE_GRADIENT_FILL_FLAG
+
+#if GRAPHIC_ENABLE_PATTERN_FILL_FLAG
+    /**
+     * Render pattern mode
+     */
+    static void RenderPattern(const Paint& paint,
+                              void* param,
+                              RasterizerScanlineAntialias& rasterizer,
+                              RenderBase& renBase,
+                              FillBase& allocator,
+                              const Rect& rect);
+#endif // GRAPHIC_ENABLE_PATTERN_FILL_FLAG
+
+    static void ChangeColor(Rgba8T& color, ColorType colorType, uint8_t alpha)
+    {
+        color.red = colorType.red;
+        color.green = colorType.green;
+        color.blue = colorType.blue;
+        color.alpha = alpha;
+    }
+
+    static void RenderBlendSolid(const Paint& paint, Rgba8T& color, const bool& isStroke)
+    {
+        if (isStroke) {
+            if (paint.GetStyle() == Paint::STROKE_STYLE || paint.GetStyle() == Paint::STROKE_FILL_STYLE) {
+                ChangeColor(color, paint.GetStrokeColor(),
+                            static_cast<uint8_t>(paint.GetStrokeColor().alpha * paint.GetGlobalAlpha()));
+            }
+        } else {
+            if (paint.GetStyle() == Paint::FILL_STYLE || paint.GetStyle() == Paint::STROKE_FILL_STYLE) {
+                ChangeColor(color, paint.GetFillColor(),
+                            static_cast<uint8_t>(paint.GetFillColor().alpha * paint.GetGlobalAlpha()));
+            }
+        }
+    }
+
+    /**
+     * Assembly parameter setting lineweight，LineCap，LineJoin
+     */
+    template <class LineStyle> static void LineStyleCalc(DepictStroke<LineStyle>& strokeLineStyle, const Paint& paint)
+    {
+        strokeLineStyle.SetWidth(paint.GetStrokeWidth()); // Line style related
+#if GRAPHIC_ENABLE_LINECAP_FLAG
+        strokeLineStyle.SetLineCap(paint.GetLineCap());
+#endif
+#if GRAPHIC_ENABLE_LINEJOIN_FLAG
+        strokeLineStyle.SetLineJoin(paint.GetLineJoin());
+        if (paint.GetMiterLimit() > 0) {
+            strokeLineStyle.SetMiterLimit(paint.GetMiterLimit());
+        }
+#endif
+    };
+
+#if GRAPHIC_ENABLE_DASH_GENERATE_FLAG
+    /**
+     * Set linedash style
+     */
+    static void LineDashStyleCalc(DepictDash& dashStyle, const Paint& paint)
+    {
+        for (uint32_t i = 0; i < paint.GetLineDashCount(); i += TWO_STEP) {
+            dashStyle.AddDash(paint.GetLineDash()[i], paint.GetLineDash()[i + 1]);
+        }
+        dashStyle.DashStart(paint.GetLineDashOffset());
+    };
+#endif
+};
+} // namespace OHOS
+#endif // GRAPHIC_LITE_DRAW_CANVAS_H

frameworks/engines/gfx/gfx_engine_manager.cpp

@@ -19,10 +19,12 @@
 
 #include "draw/clip_utils.h"
 #include "draw/draw_arc.h"
+#include "draw/draw_canvas.h"
 #include "draw/draw_curve.h"
 #include "draw/draw_line.h"
 #include "draw/draw_rect.h"
 
+
 namespace OHOS {
 BaseGfxEngine* BaseGfxEngine::baseEngine_ = nullptr;
 void BaseGfxEngine::DrawArc(BufferInfo& dst,
@@ -115,12 +117,32 @@ void BaseGfxEngine::Fill(BufferInfo& dst, const Rect& fillArea, const ColorType
     DrawUtils::GetInstance()->FillAreaWithSoftWare(dst, fillArea, color, opacity);
 }
 
+void BaseGfxEngine::DrawPath(BufferInfo& dst,
+                             void* param,
+                             const Paint& paint,
+                             const Rect& rect,
+                             const Rect& invalidatedArea,
+                             const Style& style)
+{
+    DrawCanvas::DoRender(dst, param, paint, rect, invalidatedArea, style, true);
+}
+
+void BaseGfxEngine::FillPath(BufferInfo& dst,
+                             void* param,
+                             const Paint& paint,
+                             const Rect& rect,
+                             const Rect& invalidatedArea,
+                             const Style& style)
+{
+    DrawCanvas::DoRender(dst, param, paint, rect, invalidatedArea, style, false);
+}
+
 uint8_t* BaseGfxEngine::AllocBuffer(uint32_t size, uint32_t usage)
 {
     return static_cast<uint8_t *>(malloc(size));
 }
 
-void BaseGfxEngine::FreeBuffer(uint8_t* buffer)
+void BaseGfxEngine::FreeBuffer(uint8_t* buffer, uint32_t usage)
 {
     free(buffer);
 }

interfaces/innerkits/engines/gfx/gfx_engine_manager.h

@@ -16,6 +16,7 @@
 #ifndef GRAPHIC_LITE_GFX_ENGINE_MANAGER_H
 #define GRAPHIC_LITE_GFX_ENGINE_MANAGER_H
 
+#include "gfx_utils/diagram/common/paint.h"
 #include "gfx_utils/geometry2d.h"
 #include "gfx_utils/graphic_buffer.h"
 #include "gfx_utils/graphic_math.h"
@@ -128,9 +129,23 @@ public:
                       const ColorType color,
                       const OpacityType opacity);
 
+    virtual void DrawPath(BufferInfo& dst,
+                          void* param,
+                          const Paint& paint,
+                          const Rect& rect,
+                          const Rect& invalidatedArea,
+                          const Style& style);
+
+    virtual void FillPath(BufferInfo& dst,
+                          void* param,
+                          const Paint& paint,
+                          const Rect& rect,
+                          const Rect& invalidatedArea,
+                          const Style& style);
+
     virtual uint8_t* AllocBuffer(uint32_t size, uint32_t usage);
 
-    virtual void FreeBuffer(uint8_t* buffer);
+    virtual void FreeBuffer(uint8_t* buffer, uint32_t usage);
 
     virtual BufferInfo* GetFBBufferInfo()
     {

test/unittest/components/ui_canvas_unit_test.cpp

@@ -2147,6 +2147,7 @@ HWTEST_F(UICanvasTest, UICanvasSetRotate_002, TestSize.Level1)
  * @tc.name: UICanvasInitDash_001
  * @tc.desc: Verify InitDash function, equal.
  * @tc.type: FUNC
+ * @tc.require: AR000H8BAB
  */
 HWTEST_F(UICanvasTest, UICanvasInitDash_001, TestSize.Level0)
 {
@@ -2183,8 +2184,6 @@ HWTEST_F(UICanvasTest, UICanvasInitDash_001, TestSize.Level0)
     EXPECT_EQ(paint1->GetStyle(), Paint::PaintStyle::STROKE_FILL_STYLE);
 
     paint1->GetTransAffine();
-    paint1->SetUICanvas(canvas_);
-    EXPECT_EQ(paint1->GetUICanvas(), canvas_);
 
     EXPECT_EQ(paint1->HaveComposite(), false);
     delete paint1;

tools/qt/simulator/libui/libui.pro

@@ -126,6 +126,7 @@ SOURCES += \
     ../../../../frameworks/engines/gfx/gfx_engine_manager.cpp \
     ../../../../frameworks/draw/clip_utils.cpp \
     ../../../../frameworks/draw/draw_arc.cpp \
+    ../../../../frameworks/draw/draw_canvas.cpp \
     ../../../../frameworks/draw/draw_curve.cpp \
     ../../../../frameworks/draw/draw_image.cpp \
     ../../../../frameworks/draw/draw_label.cpp \
@@ -181,6 +182,7 @@ HEADERS += \
     ../../../../../utils/interfaces/kits/gfx_utils/diagram/common/common_basics.h \
     ../../../../../utils/interfaces/kits/gfx_utils/diagram/common/common_clip_operate.h \
     ../../../../../utils/interfaces/kits/gfx_utils/diagram/common/common_math.h \
+    ../../../../../utils/interfaces/kits/gfx_utils/diagram/common/paint.h \
     ../../../../../utils/interfaces/kits/gfx_utils/diagram/depiction/depict_adaptor_vertex_generate.h \
     ../../../../../utils/interfaces/kits/gfx_utils/diagram/depiction/depict_curve.h \
     ../../../../../utils/interfaces/kits/gfx_utils/diagram/depiction/depict_dash.h \
@@ -221,6 +223,7 @@ HEADERS += \
     ../../../../frameworks/dock/virtual_input_device.h \
     ../../../../frameworks/draw/clip_utils.h \
     ../../../../frameworks/draw/draw_arc.h \
+    ../../../../frameworks/draw/draw_canvas.h \
     ../../../../frameworks/draw/draw_curve.h \
     ../../../../frameworks/draw/draw_image.h \
     ../../../../frameworks/draw/draw_label.h \

ui.gni

@@ -88,6 +88,7 @@ graphic_ui_sources = [
   "$GRAPHIC_UI_PATH/frameworks/dock/virtual_input_device.cpp",
   "$GRAPHIC_UI_PATH/frameworks/draw/clip_utils.cpp",
   "$GRAPHIC_UI_PATH/frameworks/draw/draw_arc.cpp",
+  "$GRAPHIC_UI_PATH/frameworks/draw/draw_canvas.cpp",
   "$GRAPHIC_UI_PATH/frameworks/draw/draw_curve.cpp",
   "$GRAPHIC_UI_PATH/frameworks/draw/draw_image.cpp",
   "$GRAPHIC_UI_PATH/frameworks/draw/draw_label.cpp",