@react-native-ohos/react-native-svg 15.12.1-rc.1

package/harmony/svg/src/main/cpp/drawing/Brush.cpp

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#include "Brush.h"
+
+namespace rnoh::drawing {
+
+Brush::Brush() : brush_(UniqueNativeBrush(OH_Drawing_BrushCreate(), &OH_Drawing_BrushDestroy)) {}
+
+Brush::Brush(Brush const &other)
+    : brush_(UniqueNativeBrush(OH_Drawing_BrushCopy(other.brush_.get()), &OH_Drawing_BrushDestroy)) {}
+
+Brush &Brush::operator=(Brush const &) {
+    brush_ = UniqueNativeBrush(OH_Drawing_BrushCopy(brush_.get()), &OH_Drawing_BrushDestroy);
+    return *this;
+}
+
+void Brush::SetAntiAlias(bool antiAlias) { OH_Drawing_BrushSetAntiAlias(brush_.get(), antiAlias); }
+
+void Brush::SetColor(uint32_t color) { OH_Drawing_BrushSetColor(brush_.get(), color); }
+
+void Brush::SetAlpha(uint8_t alpha) { OH_Drawing_BrushSetAlpha(brush_.get(), alpha); }
+
+void Brush::SetLinearShaderEffect(const OH_Drawing_Point2D *startPt, const OH_Drawing_Point2D *endPt,
+                                  const uint32_t *colors, const float *pos, uint32_t size, OH_Drawing_TileMode mode,
+                                  const OH_Drawing_Matrix *mat) {
+    brushShaderEffect_.ShaderEffectCreateLinearGradient(startPt, endPt, colors, pos, size, mode, mat);
+    OH_Drawing_BrushSetShaderEffect(brush_.get(), brushShaderEffect_.get());
+}
+
+void Brush::SetRadialShaderEffect(const OH_Drawing_Point2D *startPt, float startRadius, const OH_Drawing_Point2D *endPt,
+                                  float endRadius, const uint32_t *colors, const float *pos, uint32_t size,
+                                  OH_Drawing_TileMode mode, const OH_Drawing_Matrix *mat) {
+    brushShaderEffect_.ShaderEffectCreateRadialGradient(startPt, startRadius, endPt, endRadius, colors, pos, size, mode,
+                                                        mat);
+    OH_Drawing_BrushSetShaderEffect(brush_.get(), brushShaderEffect_.get());
+}
+
+void Brush::SetImageShaderEffect(OH_Drawing_Image *image, OH_Drawing_TileMode tileX, OH_Drawing_TileMode tileY,
+                                 const OH_Drawing_SamplingOptions *opt, const OH_Drawing_Matrix *mat) {
+    brushShaderEffect_.ShaderEffectCreateImageShader(image, tileX, tileY, opt, mat);
+    OH_Drawing_BrushSetShaderEffect(brush_.get(), brushShaderEffect_.get());
+}
+
+void Brush::Reset() { OH_Drawing_BrushReset(brush_.get()); }
+
+} // namespace rnoh::drawing

package/harmony/svg/src/main/cpp/drawing/Brush.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+
+#include <memory>
+#include <native_drawing/drawing_brush.h>
+#include "ShaderEffect.h"
+
+namespace rnoh::drawing {
+
+class Brush final {
+
+    using UniqueNativeBrush = std::unique_ptr<OH_Drawing_Brush, decltype(&OH_Drawing_BrushDestroy)>;
+
+public:
+    Brush();
+
+    Brush(Brush const &);
+    Brush &operator=(Brush const &);
+
+    Brush(Brush &&) = default;
+    Brush &operator=(Brush &&) = default;
+
+    ~Brush() noexcept = default;
+
+    void SetAntiAlias(bool antiAlias);
+    void SetColor(uint32_t color);
+    void SetAlpha(uint8_t alpha);
+
+    void SetLinearShaderEffect(const OH_Drawing_Point2D *startPt, const OH_Drawing_Point2D *endPt,
+                               const uint32_t *colors, const float *pos, uint32_t size, OH_Drawing_TileMode mode,
+                               const OH_Drawing_Matrix *mat);
+    void SetRadialShaderEffect(const OH_Drawing_Point2D *startPt, float startRadius, const OH_Drawing_Point2D *endPt,
+                               float endRadius, const uint32_t *colors, const float *pos, uint32_t size,
+                               OH_Drawing_TileMode mode, const OH_Drawing_Matrix *mat);
+    void SetImageShaderEffect(OH_Drawing_Image *image, OH_Drawing_TileMode tileX, OH_Drawing_TileMode tileY,
+                              const OH_Drawing_SamplingOptions *opt, const OH_Drawing_Matrix *mat);
+
+    void Reset();
+
+    OH_Drawing_Brush *get() const { return brush_.get(); }
+
+private:
+    UniqueNativeBrush brush_;
+    ShaderEffect brushShaderEffect_;
+};
+
+} // namespace rnoh::drawing

package/harmony/svg/src/main/cpp/drawing/GlyPathBag.cpp

@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#include "GlyPathBag.h"
+#include "Path.h"
+
+namespace rnoh::drawing {
+
+
+int GlyPathBag::getIndex(char ch) {
+    auto it = data.find(ch);
+    return it == data.end() ? 0 : it->second;
+}
+
+drawing::Path GlyPathBag::getOrCreateAndCache(const char &ch, const std::string &current) { return drawing::Path(); }
+
+} // namespace rnoh::drawing

package/harmony/svg/src/main/cpp/drawing/GlyPathBag.h

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+
+#include <unordered_map>
+#include <vector>
+#include "drawing/Path.h"
+#include "drawing/Pen.h"
+
+namespace rnoh::drawing {
+
+class GlyPathBag {
+private:
+    int getIndex(char ch);
+    std::vector<drawing::Path> paths;
+    std::unordered_map<char, int> data;
+    drawing::Pen paint;
+
+public:
+    GlyPathBag(drawing::Pen const &paint) {
+        // Make indexed-by-one, to allow zero to represent non-cached
+        paths.push_back(drawing::Path());
+    }
+    drawing::Path getOrCreateAndCache(const char &ch, const std::string &current);
+};
+
+} // namespace rnoh::drawing

package/harmony/svg/src/main/cpp/drawing/Matrix.cpp

@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#include "Matrix.h"
+
+namespace rnoh::drawing {
+
+Matrix::Matrix() : matrix_(UniqueNativeMatrix(OH_Drawing_MatrixCreate(), &OH_Drawing_MatrixDestroy)) {}
+
+Matrix::Matrix(Matrix const &other) : Matrix() { *this = other; }
+
+Matrix &Matrix::operator=(Matrix const &other) {
+    if (this != &other) {
+        auto scaleX = OH_Drawing_MatrixGetValue(other.matrix_.get(), 0);
+        auto skewX = OH_Drawing_MatrixGetValue(other.matrix_.get(), 1);
+        auto transX = OH_Drawing_MatrixGetValue(other.matrix_.get(), 2);
+        auto skewY = OH_Drawing_MatrixGetValue(other.matrix_.get(), 3);
+        auto scaleY = OH_Drawing_MatrixGetValue(other.matrix_.get(), 4);
+        auto transY = OH_Drawing_MatrixGetValue(other.matrix_.get(), 5);
+        auto persp0 = OH_Drawing_MatrixGetValue(other.matrix_.get(), 6);
+        auto persp1 = OH_Drawing_MatrixGetValue(other.matrix_.get(), 7);
+        auto persp2 = OH_Drawing_MatrixGetValue(other.matrix_.get(), 8);
+        OH_Drawing_MatrixSetMatrix(matrix_.get(), scaleX, skewX, transX, skewY, scaleY, transY, persp0, persp1, persp2);
+    }
+    return *this;
+}
+
+
+Matrix Matrix::CreateRotation(float deg, float x, float y) {
+    return Matrix(OH_Drawing_MatrixCreateRotation(deg, x, y));
+}
+Matrix Matrix::CreateScale(float sx, float sy, float px, float py) {
+    return Matrix(OH_Drawing_MatrixCreateScale(sx, sy, px, py));
+}
+Matrix Matrix::CreateTranslation(float dx, float dy) { return Matrix(OH_Drawing_MatrixCreateTranslation(dx, dy)); }
+
+void Matrix::PreRotate(float degree, float px, float py) { OH_Drawing_MatrixPreRotate(matrix_.get(), degree, px, py); }
+void Matrix::PreScale(float sx, float sy, float px, float py) {
+    OH_Drawing_MatrixPreScale(matrix_.get(), sx, sy, px, py);
+}
+void Matrix::PreTranslate(float dx, float dy) { OH_Drawing_MatrixPreTranslate(matrix_.get(), dx, dy); }
+
+void Matrix::PostRotate(float degree, float px, float py) {
+    OH_Drawing_MatrixPostRotate(matrix_.get(), degree, px, py);
+}
+void Matrix::PostScale(float sx, float sy, float px, float py) {
+    OH_Drawing_MatrixPostScale(matrix_.get(), sx, sy, px, py);
+}
+void Matrix::PostTranslate(float dx, float dy) { OH_Drawing_MatrixPostTranslate(matrix_.get(), dx, dy); }
+
+void Matrix::Rotate(float degree, float px, float py) { OH_Drawing_MatrixRotate(matrix_.get(), degree, px, py); }
+void Matrix::Translate(float dx, float dy) { OH_Drawing_MatrixTranslate(matrix_.get(), dx, dy); }
+void Matrix::Scale(float sx, float sy, float px, float py) { OH_Drawing_MatrixScale(matrix_.get(), sx, sy, px, py); }
+
+Matrix Matrix::Concat(const Matrix &other) const {
+    Matrix result;
+    OH_Drawing_MatrixConcat(result.matrix_.get(), matrix_.get(), other.matrix_.get());
+    return result;
+}
+
+std::optional<Matrix> Matrix::Invert() const {
+    Matrix result;
+    if (OH_Drawing_MatrixInvert(matrix_.get(), result.matrix_.get())) {
+        return result;
+    }
+    return std::nullopt;
+}
+
+float Matrix::GetValue(int index) const { return OH_Drawing_MatrixGetValue(matrix_.get(), index); }
+
+void Matrix::SetMatrix(float scaleX, float skewX, float transX, float skewY, float scaleY, float transY, float persp0,
+                       float persp1, float persp2) {
+    OH_Drawing_MatrixSetMatrix(matrix_.get(), scaleX, skewX, transX, skewY, scaleY, transY, persp0, persp1, persp2);
+}
+
+Matrix::Point drawing::Matrix::MapPoint(const Matrix::Point &point) const {
+    Point result;
+    OH_Drawing_MatrixMapPoints(matrix_.get(), &point, &result, 1);
+    return result;
+}
+
+std::vector<Matrix::Point> drawing::Matrix::MapPoints(const std::vector<Matrix::Point> &points) const {
+    std::vector<Matrix::Point> result(points.size());
+    OH_Drawing_MatrixMapPoints(matrix_.get(), points.data(), result.data(), points.size());
+    return result;
+}
+
+drawing::Rect drawing::Matrix::MapRect(const drawing::Rect &rect) const {
+    Rect result;
+    OH_Drawing_MatrixMapRect(matrix_.get(), rect.get(), result.get());
+    return result;
+}
+
+void Matrix::Reset() { OH_Drawing_MatrixReset(matrix_.get()); }
+
+
+} // namespace rnoh::drawing

package/harmony/svg/src/main/cpp/drawing/Matrix.h

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+
+#include "Rect.h"
+#include <memory>
+#include <optional>
+#include <vector>
+#include <native_drawing/drawing_matrix.h>
+
+namespace rnoh::drawing {
+
+class Matrix final {
+    using UniqueNativeMatrix = std::unique_ptr<OH_Drawing_Matrix, decltype(&OH_Drawing_MatrixDestroy)>;
+    using Point = OH_Drawing_Point2D;
+
+public:
+    Matrix();
+
+    Matrix(Matrix const &);
+    Matrix &operator=(Matrix const &);
+
+    Matrix(Matrix &&) = default;
+    Matrix &operator=(Matrix &&) = default;
+
+    ~Matrix() noexcept = default;
+
+    static Matrix CreateRotation(float deg, float x, float y);
+    static Matrix CreateScale(float sx, float sy, float px, float py);
+    static Matrix CreateTranslation(float dx, float dy);
+    void PreRotate(float degree, float px, float py);
+    void PreScale(float sx, float sy, float px, float py);
+    void PreTranslate(float dx, float dy);
+    void PostRotate(float degree, float px, float py);
+    void PostScale(float sx, float sy, float px, float py);
+    void PostTranslate(float dx, float dy);
+    void Rotate(float degree, float px, float py);
+    void Translate(float dx, float dy);
+    void Scale(float sx, float sy, float px, float py);
+
+    Matrix Concat(const Matrix &other) const;
+    std::optional<Matrix> Invert() const;
+
+    float GetValue(int index) const;
+
+    void SetMatrix(float scaleX, float skewX, float transX, float skewY, float scaleY, float transY, float persp0,
+                   float persp1, float persp2);
+
+    Point MapPoint(const Point &point) const;
+    std::vector<Point> MapPoints(const std::vector<Point> &points) const;
+
+    drawing::Rect MapRect(const drawing::Rect &rect) const;
+
+    void Reset();
+
+    OH_Drawing_Matrix *get() const { return matrix_.get(); }
+
+private:
+    Matrix(OH_Drawing_Matrix *rawMatrix) : matrix_(UniqueNativeMatrix(rawMatrix, &OH_Drawing_MatrixDestroy)) {}
+
+    UniqueNativeMatrix matrix_;
+};
+
+} // namespace rnoh::drawing

package/harmony/svg/src/main/cpp/drawing/Path.cpp

@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#include "Path.h"
+#include <native_drawing/drawing_rect.h>
+
+namespace rnoh {
+namespace drawing {
+
+Path::Path() : path_(UniqueNativePath(OH_Drawing_PathCreate(), &OH_Drawing_PathDestroy)) {}
+
+Path::Path(Path const &other)
+    : path_(UniqueNativePath(OH_Drawing_PathCopy(other.path_.get()), &OH_Drawing_PathDestroy)) {}
+
+Path &Path::operator=(Path const &other) {
+    if (this != &other) {
+        path_ = UniqueNativePath(OH_Drawing_PathCopy(other.path_.get()), &OH_Drawing_PathDestroy);
+    }
+    return *this;
+}
+
+void Path::Reset() { OH_Drawing_PathReset(path_.get()); }
+
+void Path::MoveTo(float x, float y) { OH_Drawing_PathMoveTo(get(), x, y); }
+
+void Path::LineTo(float x, float y) { OH_Drawing_PathLineTo(get(), x, y); }
+
+void Path::ArcTo(float x1, float y1, float x2, float y2, float startDeg, float sweepDeg) {
+    OH_Drawing_PathArcTo(get(), x1, y1, x2, y2, startDeg, sweepDeg);
+}
+
+void Path::QuadTo(float ctrlX, float ctrlY, float endX, float endY) {
+    OH_Drawing_PathQuadTo(get(), ctrlX, ctrlY, endX, endY);
+}
+
+void Path::ConicTo(float ctrlX, float ctrlY, float endX, float endY, float weight) {
+    OH_Drawing_PathConicTo(get(), ctrlX, ctrlY, endX, endY, weight);
+}
+
+void Path::CubicTo(float ctrlX1, float ctrlY1, float ctrlX2, float ctrlY2, float endX, float endY) {
+    OH_Drawing_PathCubicTo(get(), ctrlX1, ctrlY1, ctrlX2, ctrlY2, endX, endY);
+}
+
+void Path::RMoveTo(float x, float y) { OH_Drawing_PathRMoveTo(get(), x, y); }
+
+void Path::RLineTo(float x, float y) { OH_Drawing_PathRLineTo(get(), x, y); }
+
+void Path::RQuadTo(float ctrlX, float ctrlY, float endX, float endY) {
+    OH_Drawing_PathRQuadTo(get(), ctrlX, ctrlY, endX, endY);
+}
+
+void Path::RConicTo(float ctrlX, float ctrlY, float endX, float endY, float weight) {
+    OH_Drawing_PathRConicTo(get(), ctrlX, ctrlY, endX, endY, weight);
+}
+
+void Path::RCubicTo(float ctrlX1, float ctrlY1, float ctrlX2, float ctrlY2, float endX, float endY) {
+    OH_Drawing_PathRCubicTo(get(), ctrlX1, ctrlY1, ctrlX2, ctrlY2, endX, endY);
+}
+
+void Path::AddRect(float left, float top, float right, float bottom, Direction direction) {
+    OH_Drawing_PathAddRect(get(), left, top, right, bottom, direction);
+}
+
+void Path::AddRectWithInitialCorner(const Rect &rect, Direction direction, uint32_t start) {
+    OH_Drawing_PathAddRectWithInitialCorner(get(), rect.get(), direction, start);
+}
+
+void Path::AddRoundRect(const RoundRect &roundRect, Direction direction) {
+    OH_Drawing_PathAddRoundRect(get(), roundRect.get(), direction);
+}
+
+void Path::AddOvalWithInitialPoint(const Rect &rect, uint32_t start, Direction direction) {
+    OH_Drawing_PathAddOvalWithInitialPoint(get(), rect.get(), start, direction);
+}
+
+void Path::AddOval(const Rect &rect, Direction direction) { OH_Drawing_PathAddOval(get(), rect.get(), direction); }
+
+void Path::AddArc(const Rect &rect, float startAngle, float sweepAngle) {
+    OH_Drawing_PathAddArc(get(), rect.get(), startAngle, sweepAngle);
+}
+
+void Path::AddPath(const Path &src) { OH_Drawing_PathAddPath(get(), src.get(), nullptr); }
+
+void Path::AddPath(const Path &src, const Matrix &matrix) { OH_Drawing_PathAddPath(get(), src.get(), matrix.get()); }
+
+void Path::AddPathWithMatrixAndMode(const Path &src, const Matrix &matrix, AddMode mode) {
+    OH_Drawing_PathAddPathWithMatrixAndMode(get(), src.get(), matrix.get(), mode);
+}
+
+void Path::AddPathWithMode(const Path &src, AddMode mode) { OH_Drawing_PathAddPathWithMode(get(), src.get(), mode); }
+
+void Path::AddPathWithOffsetAndMode(const Path &src, float dx, float dy, AddMode mode) {
+    OH_Drawing_PathAddPathWithOffsetAndMode(get(), src.get(), dx, dy, mode);
+}
+
+void Path::AddPolygon(const OH_Drawing_Point2D *points, uint32_t count, bool isClosed) {
+    OH_Drawing_PathAddPolygon(get(), points, count, isClosed);
+}
+
+void Path::AddCircle(float x, float y, float radius, Direction direction) {
+    OH_Drawing_PathAddCircle(get(), x, y, radius, direction);
+}
+
+std::optional<Path> Path::BuildFromSvgString(const char *str) {
+    Path path;
+    if (OH_Drawing_PathBuildFromSvgString(path.get(), str)) {
+        return path;
+    } else {
+        return std::nullopt;
+    }
+}
+
+bool Path::Contains(float x, float y) { return OH_Drawing_PathContains(get(), x, y); }
+
+void Path::Transform(const Matrix &matrix) { OH_Drawing_PathTransform(get(), matrix.get()); }
+
+Path Path::TransformWithPerspectiveClip(const Matrix &matrix, bool applyPerspectiveClip) {
+    Path path;
+    OH_Drawing_PathTransformWithPerspectiveClip(get(), matrix.get(), path.get(), applyPerspectiveClip);
+    return path;
+}
+
+void Path::SetFillType(FillType fillType) { OH_Drawing_PathSetFillType(get(), fillType); }
+
+float Path::GetLength(bool forceClosed) { return OH_Drawing_PathGetLength(get(), forceClosed); }
+
+Rect Path::GetBounds() {
+    Rect bounds;
+    OH_Drawing_PathGetBounds(get(), bounds.get());
+    return bounds;
+}
+
+void Path::Close() { OH_Drawing_PathClose(get()); }
+
+Path Path::Offset(float dx, float dy) {
+    Path path;
+    OH_Drawing_PathOffset(get(), path.get(), dx, dy);
+    return path;
+}
+
+bool Path::IsClosed(bool forceClosed) { return OH_Drawing_PathIsClosed(get(), forceClosed); }
+
+bool Path::GetPositionTangent(bool forceClosed, float distance, OH_Drawing_Point2D *position,
+                              OH_Drawing_Point2D *tangent) {
+    return OH_Drawing_PathGetPositionTangent(get(), forceClosed, distance, position, tangent);
+}
+
+bool Path::Op(Path &source, OpMode mode) { return OH_Drawing_PathOp(get(), source.get(), mode); }
+
+bool Path::Difference(Path &source) { return Op(source, PATH_OP_MODE_DIFFERENCE); }
+
+bool Path::Intersect(Path &source) { return Op(source, PATH_OP_MODE_INTERSECT); }
+
+bool Path::Union(Path &source) { return Op(source, PATH_OP_MODE_UNION); }
+
+bool Path::Xor(Path &source) { return Op(source, PATH_OP_MODE_XOR); }
+
+bool Path::ReverseDifference(Path &source) { return Op(source, PATH_OP_MODE_REVERSE_DIFFERENCE); }
+
+std::optional<Matrix> Path::GetMatrix(bool forceClosed, float distance, MeasureMatrixFlags flag) {
+    Matrix matrix;
+    if (OH_Drawing_PathGetMatrix(get(), forceClosed, distance, matrix.get(), flag)) {
+        return matrix;
+    } else {
+        return std::nullopt;
+    }
+}
+
+} // namespace drawing
+} // namespace rnoh

package/harmony/svg/src/main/cpp/drawing/Path.h

@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+
+#include <memory>
+#include <native_drawing/drawing_path.h>
+#include "Matrix.h"
+#include "Rect.h"
+#include "RoundRect.h"
+
+namespace rnoh::drawing {
+
+class Path final {
+    using UniqueNativePath = std::unique_ptr<OH_Drawing_Path, decltype(&OH_Drawing_PathDestroy)>;
+
+public:
+    using Direction = OH_Drawing_PathDirection;
+    using AddMode = OH_Drawing_PathAddMode;
+    using FillType = OH_Drawing_PathFillType;
+    using MeasureMatrixFlags = OH_Drawing_PathMeasureMatrixFlags;
+    using OpMode = OH_Drawing_PathOpMode;
+
+    Path();
+
+    Path(Path const &);
+    Path &operator=(Path const &);
+
+    Path(Path &&) = default;
+    Path &operator=(Path &&) = default;
+
+    ~Path() noexcept = default;
+
+    void Reset();
+
+    void MoveTo(float x, float y);
+
+    void LineTo(float x, float y);
+
+    void ArcTo(float x1, float y1, float x2, float y2, float startDeg, float sweepDeg);
+
+    void QuadTo(float ctrlX, float ctrlY, float endX, float endY);
+
+    void ConicTo(float ctrlX, float ctrlY, float endX, float endY, float weight);
+
+    void CubicTo(float ctrlX1, float ctrlY1, float ctrlX2, float ctrlY2, float endX, float endY);
+
+    void RMoveTo(float x, float y);
+
+    void RLineTo(float x, float y);
+
+    void RQuadTo(float ctrlX, float ctrlY, float endX, float endY);
+
+    void RConicTo(float ctrlX, float ctrlY, float endX, float endY, float weight);
+
+    void RCubicTo(float ctrlX1, float ctrlY1, float ctrlX2, float ctrlY2, float endX, float endY);
+
+    void AddRect(float left, float top, float right, float bottom, Direction);
+    void AddRectWithInitialCorner(const Rect &, Direction, uint32_t start);
+    void AddRoundRect(const RoundRect &roundRect, Direction);
+
+    void AddOvalWithInitialPoint(const Rect &, uint32_t start, Direction);
+    void AddOval(const Rect &, Direction);
+
+    void AddArc(const Rect &, float startAngle, float sweepAngle);
+
+    void AddPath(const Path &src);
+    void AddPath(const Path &src, const Matrix &);
+
+    void AddPathWithMatrixAndMode(const Path &src, const Matrix &, AddMode);
+    void AddPathWithMode(const Path &src, AddMode);
+
+    void AddPathWithOffsetAndMode(const Path &src, float dx, float dy, AddMode);
+    void AddPolygon(const OH_Drawing_Point2D *points, uint32_t count, bool isClosed);
+
+    void AddCircle(float x, float y, float radius, Direction);
+
+    static std::optional<Path> BuildFromSvgString(const char *str);
+
+    bool Contains(float x, float y);
+
+
+    void Transform(const Matrix &);
+
+
+    Path TransformWithPerspectiveClip(const Matrix &, bool applyPerspectiveClip);
+
+
+    void SetFillType(FillType);
+
+    float GetLength(bool forceClosed);
+
+    Rect GetBounds();
+
+    void Close();
+
+    Path Offset(float dx, float dy);
+
+    bool IsClosed(bool forceClosed);
+
+    bool GetPositionTangent(bool forceClosed, float distance, OH_Drawing_Point2D *position,
+                            OH_Drawing_Point2D *tangent);
+
+    bool Op(Path &source, OpMode mode);
+
+    bool Difference(Path &source);
+
+    bool Intersect(Path &source);
+
+    bool Union(Path &source);
+
+    bool Xor(Path &source);
+
+    bool ReverseDifference(Path &source);
+
+    std::optional<Matrix> GetMatrix(bool forceClosed, float distance, MeasureMatrixFlags flag);
+
+    OH_Drawing_Path *get() const { return path_.get(); }
+
+private:
+    UniqueNativePath path_;
+};
+
+} // namespace rnoh::drawing

package/harmony/svg/src/main/cpp/drawing/Pen.cpp

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#include "Pen.h"
+
+namespace rnoh::drawing {
+
+Pen::Pen() : pen_(UniqueNativePen(OH_Drawing_PenCreate(), &OH_Drawing_PenDestroy)) {}
+
+Pen::Pen(Pen const &other) : pen_(UniqueNativePen(OH_Drawing_PenCopy(other.pen_.get()), &OH_Drawing_PenDestroy)) {}
+
+Pen &Pen::operator=(Pen const &) {
+    pen_ = UniqueNativePen(OH_Drawing_PenCopy(pen_.get()), &OH_Drawing_PenDestroy);
+    return *this;
+}
+
+void Pen::SetAntiAlias(bool antiAlias) { OH_Drawing_PenSetAntiAlias(pen_.get(), antiAlias); }
+
+void Pen::SetColor(uint32_t color) { OH_Drawing_PenSetColor(pen_.get(), color); }
+
+void Pen::SetAlpha(uint8_t alpha) { OH_Drawing_PenSetAlpha(pen_.get(), alpha); }
+
+void Pen::SetWidth(double width) { OH_Drawing_PenSetWidth(pen_.get(), width); }
+
+void Pen::SetMiterLimit(float miterLimit) { OH_Drawing_PenSetMiterLimit(pen_.get(), miterLimit); }
+
+void Pen::SetLineCap(LineCapStyle lineCap) { OH_Drawing_PenSetCap(pen_.get(), lineCap); }
+
+void Pen::SetLineJoin(LineJoinStyle lineJoin) { OH_Drawing_PenSetJoin(pen_.get(), lineJoin); }
+
+void Pen::SetLinearShaderEffect(const OH_Drawing_Point2D *startPt, const OH_Drawing_Point2D *endPt,
+                                const uint32_t *colors, const float *pos, uint32_t size, OH_Drawing_TileMode mode,
+                                const OH_Drawing_Matrix *mat) {
+    penShaderEffect_.ShaderEffectCreateLinearGradient(startPt, endPt, colors, pos, size, mode, mat);
+    OH_Drawing_PenSetShaderEffect(pen_.get(), penShaderEffect_.get());
+}
+
+void Pen::SetRadialShaderEffect(const OH_Drawing_Point2D *startPt, float startRadius, const OH_Drawing_Point2D *endPt,
+                                float endRadius, const uint32_t *colors, const float *pos, uint32_t size,
+                                OH_Drawing_TileMode mode, const OH_Drawing_Matrix *mat) {
+    penShaderEffect_.ShaderEffectCreateRadialGradient(startPt, startRadius, endPt, endRadius, colors, pos, size, mode,
+                                                      mat);
+    OH_Drawing_PenSetShaderEffect(pen_.get(), penShaderEffect_.get());
+}
+
+void Pen::SetImageShaderEffect(OH_Drawing_Image *image, OH_Drawing_TileMode tileX, OH_Drawing_TileMode tileY,
+                               const OH_Drawing_SamplingOptions *opt, const OH_Drawing_Matrix *mat) {
+    penShaderEffect_.ShaderEffectCreateImageShader(image, tileX, tileY, opt, mat);
+    OH_Drawing_PenSetShaderEffect(pen_.get(), penShaderEffect_.get());
+}
+
+void Pen::Reset() {}
+
+} // namespace rnoh::drawing