@react-native-ohos/react-native-clippathview 1.1.9-rc.1 → 1.1.9

package/harmony/clipPath/src/main/cpp/ClipPathViewNoneNode.cpp

@@ -1,6 +1,17 @@
-//
-// Created on 2024/6/25.
-//
+/*
+ * 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.
+ */
 // Node APIs are not fully supported. To solve the compilation error of the interface cannot be found,
 // please include "napi/native_api.h".
 
@@ -22,45 +33,51 @@
 
 namespace rnoh {
 ClipPathViewNoneNode::ClipPathViewNoneNode()
-    : ArkUINode(NativeNodeApi::getInstance()->createNode(ArkUI_NodeType::ARKUI_NODE_CUSTOM)) {
+    : ArkUINode(NativeNodeApi::getInstance()->createNode(ArkUI_NodeType::ARKUI_NODE_CUSTOM))
+{
     canvasCallback_ = new CanvasCallback();
     canvasCallback_->callback = [this](ArkUI_NodeCustomEvent *event) {
         auto type = OH_ArkUI_NodeCustomEvent_GetEventType(event);
         switch (type) {
-        case ARKUI_NODE_CUSTOM_EVENT_ON_FOREGROUND_DRAW:
-            OnDraw(event);
-            break;
-        case ARKUI_NODE_CUSTOM_EVENT_ON_MEASURE: {
-            int32_t width = getSavedWidth();
-            int32_t height = getSavedHeight();
-            maybeThrow(NativeNodeApi::getInstance()->setMeasuredSize(m_nodeHandle, width, height));
-            setRectF(mBounds, 0, 0, width, height);
-        } break;
-        default:
-            break;
+            case ARKUI_NODE_CUSTOM_EVENT_ON_FOREGROUND_DRAW:
+                OnDraw(event);
+                break;
+            case ARKUI_NODE_CUSTOM_EVENT_ON_MEASURE: {
+                int32_t width = getSavedWidth();
+                int32_t height = getSavedHeight();
+                maybeThrow(NativeNodeApi::getInstance()->setMeasuredSize(m_nodeHandle, width, height));
+                setRectF(mBounds, 0, 0, width, height);
+            } break;
+            default:
+                break;
         }
     };
     eventReceiver = [](ArkUI_NodeCustomEvent *event) {
         int32_t targetId = OH_ArkUI_NodeCustomEvent_GetEventTargetId(event);
-        if (targetId == 10001 || targetId == 10002) {
+        int count10001 = 10001;
+        int count10002 = 10002;
+        if (targetId == count10001 || targetId == count10002) {
             auto *userData = reinterpret_cast<CanvasCallback *>(OH_ArkUI_NodeCustomEvent_GetUserData(event));
             if (userData != nullptr && userData->callback != nullptr) {
                 userData->callback(event);
             }
         }
     };
+    int count101 = 10001;
+    int count102 = 10002;
     maybeThrow(NativeNodeApi::getInstance()->addNodeCustomEventReceiver(m_nodeHandle, eventReceiver));
-    maybeThrow(NativeNodeApi::getInstance()->registerNodeCustomEvent(
-        m_nodeHandle, ARKUI_NODE_CUSTOM_EVENT_ON_FOREGROUND_DRAW, 10001, canvasCallback_));
+    maybeThrow(NativeNodeApi::getInstance()->registerNodeCustomEvent(m_nodeHandle,
+        ARKUI_NODE_CUSTOM_EVENT_ON_FOREGROUND_DRAW, count101, canvasCallback_));
     maybeThrow(NativeNodeApi::getInstance()->registerNodeCustomEvent(m_nodeHandle, ARKUI_NODE_CUSTOM_EVENT_ON_MEASURE,
-                                                                     10002, canvasCallback_));
+        count102, canvasCallback_));
     OH_Drawing_PenIsAntiAlias(mPaint);
     OH_Drawing_PenIsAntiAlias(mPaintStroke);
     OH_Drawing_PenSetColor(mPaint, 0xffffffff);
     OH_Drawing_PenSetColor(mPaintStroke, 0xffffffff);
 }
 
-ClipPathViewNoneNode::~ClipPathViewNoneNode() {
+ClipPathViewNoneNode::~ClipPathViewNoneNode()
+{
     NativeNodeApi::getInstance()->removeNodeCustomEventReceiver(m_nodeHandle, eventReceiver);
     NativeNodeApi::getInstance()->unregisterNodeCustomEvent(m_nodeHandle, ARKUI_NODE_CUSTOM_EVENT_ON_FOREGROUND_DRAW);
     NativeNodeApi::getInstance()->unregisterNodeCustomEvent(m_nodeHandle, ARKUI_NODE_CUSTOM_EVENT_ON_MEASURE);
@@ -77,35 +94,38 @@ ClipPathViewNoneNode::~ClipPathViewNoneNode() {
     delete mProps;
     canvasCallback_ = nullptr;
     mProps = nullptr;
-    canvas =nullptr;
+    canvas = nullptr;
 }
 
-void ClipPathViewNoneNode::insertChild(ArkUINode &child, std::size_t index) {
+void ClipPathViewNoneNode::InsertChild(ArkUINode &child, std::size_t index)
+{
     maybeThrow(NativeNodeApi::getInstance()->insertChildAt(m_nodeHandle, child.getArkUINodeHandle(), index));
 }
 
-void ClipPathViewNoneNode::removeChild(ArkUINode &child) {
+void ClipPathViewNoneNode::RemoveChild(ArkUINode &child)
+{
     maybeThrow(NativeNodeApi::getInstance()->removeChild(m_nodeHandle, child.getArkUINodeHandle()));
 }
 
-void ClipPathViewNoneNode::setPanStyleMode(OH_Drawing_Canvas *canvas, int type) {
-
+void ClipPathViewNoneNode::setPanStyleMode(OH_Drawing_Canvas *canvas, int type)
+{
     auto cBrush = OH_Drawing_BrushCreate();
     switch (type) {
-    case CLIP_PEN_STYLE_FILL:
-        OH_Drawing_BrushSetColor(cBrush, OH_Drawing_ColorSetArgb(0xff, 0xff, 0xff, 0xff));
-        break;
-    case CLIP_PEN_STYLE_STROKE:
-        OH_Drawing_BrushSetColor(cBrush, OH_Drawing_ColorSetArgb(0x00, 0x00, 0x00, 0x00));
-        break;
-    default:
-        break;
+        case CLIP_PEN_STYLE_FILL:
+            OH_Drawing_BrushSetColor(cBrush, OH_Drawing_ColorSetArgb(0xff, 0xff, 0xff, 0xff));
+            break;
+        case CLIP_PEN_STYLE_STROKE:
+            OH_Drawing_BrushSetColor(cBrush, OH_Drawing_ColorSetArgb(0x00, 0x00, 0x00, 0x00));
+            break;
+        default:
+            break;
     }
     OH_Drawing_CanvasAttachBrush(canvas, cBrush);
     OH_Drawing_BrushDestroy(cBrush);
 }
 
-void ClipPathViewNoneNode::OnDraw(ArkUI_NodeCustomEvent *event) {
+void ClipPathViewNoneNode::OnDraw(ArkUI_NodeCustomEvent *event)
+{
     auto *drawContext = OH_ArkUI_NodeCustomEvent_GetDrawContextInDraw(event);
     canvas = reinterpret_cast<OH_Drawing_Canvas *>(OH_ArkUI_DrawContext_GetCanvas(drawContext));
     auto width_ = OH_Drawing_CanvasGetWidth(canvas);
@@ -127,7 +147,8 @@ void ClipPathViewNoneNode::OnDraw(ArkUI_NodeCustomEvent *event) {
     OH_Drawing_BrushDestroy(cBrush_);
 }
 
-void ClipPathViewNoneNode::drawPath(OH_Drawing_Canvas *canvas) {
+void ClipPathViewNoneNode::drawPath(OH_Drawing_Canvas *canvas)
+{
     setupPath(canvas);
     viewBoxTransform();
     setPaintStrokeProps();
@@ -151,7 +172,8 @@ void ClipPathViewNoneNode::drawPath(OH_Drawing_Canvas *canvas) {
     OH_Drawing_CanvasRestore(canvas);
 }
 
-void ClipPathViewNoneNode::setupPath(OH_Drawing_Canvas *canvas) {
+void ClipPathViewNoneNode::setupPath(OH_Drawing_Canvas *canvas)
+{
     if (!canvas || mD.empty()) {
         return;
     }
@@ -161,155 +183,209 @@ void ClipPathViewNoneNode::setupPath(OH_Drawing_Canvas *canvas) {
     SVGPathParser::mScale = ModUtil::getDensity();
     mPath = SVGPathParser::parse(mD);
 }
-void ClipPathViewNoneNode::setD(const std::string d) {
+void ClipPathViewNoneNode::SetD(const std::string d)
+{
     mD = d;
     markDirty();
 }
-void ClipPathViewNoneNode::setStrokeWidth(float const width) { mProps->mStrokeWidth = width; }
-void ClipPathViewNoneNode::setStrokeCap(std::string const cap) { mProps->mStrokeCap = cap; }
-void ClipPathViewNoneNode::setStrokeJoin(std::string const join) { mProps->mStrokeJoin = join; }
-void ClipPathViewNoneNode::setStrokeMiter(float const miter) { mProps->mStrokeMiter = miter; }
-void ClipPathViewNoneNode::setStrokeStart(float const start) { mProps->mStrokeStart = start; }
-void ClipPathViewNoneNode::setStrokeEnd(float const end) { mProps->mStrokeEnd = end; }
-float ClipPathViewNoneNode::toDip(float value) { return value * ModUtil::getDensity(); }
-void ClipPathViewNoneNode::setFillRule(std::string v) { mProps->mFillRule = v.empty() ? "none" : v; }
-void ClipPathViewNoneNode::setAlign(std::string v) { mAlign = v.empty() ? "xMidYMid" : v; }
-void ClipPathViewNoneNode::setAspect(std::string v) {
-    mAspect = v.empty()
-                  ? SVGViewBox::MOS_MEET
-                  : (v.compare("slice") == 0 ? SVGViewBox::MOS_SLICE
-                                             : (v.compare("none") == 0 ? SVGViewBox::MOS_NONE : SVGViewBox::MOS_MEET));
-}
-void ClipPathViewNoneNode::setRect(OH_Drawing_Rect *target, OH_Drawing_Rect *src) {
+void ClipPathViewNoneNode::SetStrokeWidth(float const width)
+{
+    mProps->mStrokeWidth = width;
+}
+void ClipPathViewNoneNode::SetStrokeCap(std::string const cap)
+{
+    mProps->mStrokeCap = cap;
+}
+void ClipPathViewNoneNode::SetStrokeJoin(std::string const join)
+{
+    mProps->mStrokeJoin = join;
+}
+void ClipPathViewNoneNode::SetStrokeMiter(float const miter)
+{
+    mProps->mStrokeMiter = miter;
+}
+void ClipPathViewNoneNode::SetStrokeStart(float const start)
+{
+    mProps->mStrokeStart = start;
+}
+void ClipPathViewNoneNode::SetStrokeEnd(float const end)
+{
+    mProps->mStrokeEnd = end;
+}
+float ClipPathViewNoneNode::toDip(float value)
+{
+    return value * ModUtil::getDensity();
+}
+void ClipPathViewNoneNode::SetFillRule(std::string v)
+{
+    mProps->mFillRule = v.empty() ? "none" : v;
+}
+void ClipPathViewNoneNode::SetAlign(std::string v)
+{
+    mAlign = v.empty() ? "xMidYMid" : v;
+}
+void ClipPathViewNoneNode::SetAspect(std::string v)
+{
+    mAspect = v.empty() ?
+        SVGViewBox::MOS_MEET :
+        (v.compare("slice") == 0 ? SVGViewBox::MOS_SLICE :
+                                   (v.compare("none") == 0 ? SVGViewBox::MOS_NONE : SVGViewBox::MOS_MEET));
+}
+void ClipPathViewNoneNode::setRect(OH_Drawing_Rect *target, OH_Drawing_Rect *src)
+{
     OH_Drawing_RectSetLeft(target, OH_Drawing_RectGetLeft(src));
     OH_Drawing_RectSetTop(target, OH_Drawing_RectGetTop(src));
     OH_Drawing_RectSetRight(target, OH_Drawing_RectGetRight(src));
     OH_Drawing_RectSetBottom(target, OH_Drawing_RectGetBottom(src));
 }
 
-void ClipPathViewNoneNode::setRectF(OH_Drawing_Rect *target, float left, float top, float right, float bottom) {
+void ClipPathViewNoneNode::setRectF(OH_Drawing_Rect *target, float left, float top, float right, float bottom)
+{
     setRect(target, OH_Drawing_RectCreate(left, top, right, bottom));
 }
 
-void ClipPathViewNoneNode::setTranslateZ(float z) {
+void ClipPathViewNoneNode::SetTranslateZ(float z)
+{
     ArkUI_NumberValue translateValue[] = {{.f32 = z}};
-    ArkUI_AttributeItem translateItem = {translateValue, sizeof(translateValue) / sizeof(ArkUI_NumberValue)};
+    ArkUI_AttributeItem translateItem = { translateValue, sizeof(translateValue) / sizeof(ArkUI_NumberValue) };
     uint32_t code = NativeNodeApi::getInstance()->setAttribute(m_nodeHandle, NODE_Z_INDEX, &translateItem);
 }
-void ClipPathViewNoneNode::setTransX(float v) {
+void ClipPathViewNoneNode::SetTransX(float v)
+{
     if (mTranslationX != v) {
         mTranslationX = v;
     }
 }
-void ClipPathViewNoneNode::setTransY(float v) {
+void ClipPathViewNoneNode::SetTransY(float v)
+{
     if (mTranslationY != v) {
         mTranslationY = v;
     }
 }
-void ClipPathViewNoneNode::setTransPercentageValue(bool v) {
+void ClipPathViewNoneNode::SetTransPercentageValue(bool v)
+{
     if (mTranslationIsPercent != v) {
         mTranslationIsPercent = v;
     }
 }
 
-void ClipPathViewNoneNode::setRot(float v) {
+void ClipPathViewNoneNode::SetRot(float v)
+{
     if (mRotation != v) {
         mRotation = v;
     }
 }
-void ClipPathViewNoneNode::setRotO(float v) {
+void ClipPathViewNoneNode::SetRotO(float v)
+{
     if (mRotationOx != v || mRotationOy != v) {
         mRotationOx = v;
         mRotationOy = v;
     }
 }
-void ClipPathViewNoneNode::setRotOx(float v) {
+void ClipPathViewNoneNode::SetRotOx(float v)
+{
     if (mRotationOx != v) {
         mRotationOx = v;
     }
 }
-void ClipPathViewNoneNode::setRotOy(float v) {
+void ClipPathViewNoneNode::SetRotOy(float v)
+{
     if (mRotationOy != v) {
         mRotationOy = v;
     }
 }
-void ClipPathViewNoneNode::setRotPercentageValue(bool v) {
+void ClipPathViewNoneNode::SetRotPercentageValue(bool v)
+{
     if (mRotationIsPercent != v) {
         mRotationIsPercent = v;
     }
 }
-void ClipPathViewNoneNode::setSc(float v) {
+void ClipPathViewNoneNode::SetSc(float v)
+{
     if (mScaleX != v || mScaleY != v) {
         mScaleX = v;
         mScaleY = v;
     }
 }
-void ClipPathViewNoneNode::setScX(float v) {
+void ClipPathViewNoneNode::SetScX(float v)
+{
     if (mScaleX != v) {
         mScaleX = v;
     }
 }
 
-void ClipPathViewNoneNode::setScY(float v) {
+void ClipPathViewNoneNode::SetScY(float v)
+{
     if (mScaleY != v) {
         mScaleY = v;
     }
 }
 
-void ClipPathViewNoneNode::setScO(float v) {
+void ClipPathViewNoneNode::SetScO(float v)
+{
     if (mScaleOriginX != v || mScaleOriginY != v) {
         mScaleOriginX = v;
         mScaleOriginY = v;
     }
 }
-void ClipPathViewNoneNode::setScOx(float v) {
+void ClipPathViewNoneNode::SetScOx(float v)
+{
     if (mScaleOriginX != v) {
         mScaleOriginX = v;
     }
 }
-void ClipPathViewNoneNode::setScOy(float v) {
+void ClipPathViewNoneNode::SetScOy(float v)
+{
     if (mScaleOriginY != v) {
         mScaleOriginY = v;
     }
 }
-void ClipPathViewNoneNode::setScPercentageValue(bool v) {
+void ClipPathViewNoneNode::SetScPercentageValue(bool v)
+{
     if (mScaleIsPercent != v) {
         mScaleIsPercent = v;
     }
 }
 
-void ClipPathViewNoneNode::setViewBox(std::vector<float> viewBox) {
+void ClipPathViewNoneNode::SetViewBox(std::vector<float> viewBox)
+{
     if (viewBox.empty()) {
         return;
     }
     float density = ModUtil::getDensity();
-    setRectF(mRectVb, viewBox[0], viewBox[1], (viewBox[0] + viewBox[2]), (viewBox[1] + viewBox[3]));
-    setRectF(mRectVbDensity, viewBox[0] * density, viewBox[1] * density, (viewBox[0] + viewBox[2]) * density,
-             (viewBox[1] + viewBox[3]) * density);
+    int count0 = 0;
+    int count1 = 1;
+    int count2 = 2;
+    int count3 = 3;
+    setRectF(mRectVb, viewBox[count0], viewBox[count1], (viewBox[count0] + viewBox[count2]),
+            (viewBox[count1] + viewBox[count3]));
+    setRectF(mRectVbDensity, viewBox[count0] * density, viewBox[count1] * density,
+            (viewBox[count0] + viewBox[count2]) * density, (viewBox[count1] + viewBox[count3]) * density);
 }
 
-void ClipPathViewNoneNode::viewBoxTransform() {
+void ClipPathViewNoneNode::viewBoxTransform()
+{
     float density = ModUtil::getDensity();
     if (validateViewBox()) {
         setRect(mRectPath, mRectVbDensity);
         SVGViewBox::transform(mRectVb, mBounds, mAlign, mAspect, density, mMatrix);
         OH_Drawing_PathTransform(mPath, mMatrix);
         OH_Drawing_MatrixMapRect(mMatrix, mRectPath, mRectPath);
-
     } else {
         setRect(mRectPath, mBounds);
     }
 }
-bool ClipPathViewNoneNode::validateViewBox() {
+bool ClipPathViewNoneNode::validateViewBox()
+{
     return OH_Drawing_RectGetWidth(mRectVb) >= 0.0f && OH_Drawing_RectGetHeight(mRectVb) >= 0.0f;
 }
 
-void ClipPathViewNoneNode::setPaintStrokeProps() {
+void ClipPathViewNoneNode::setPaintStrokeProps()
+{
     OH_Drawing_PathSetFillType(mPath, mProps->getFillRule());
-    float sw = validateViewBox()
-                   ? ModUtil::viewBoxToMax(mProps->getStrokeWidth(), mRectVb, OH_Drawing_RectGetWidth(mRectPath),
-                                           OH_Drawing_RectGetHeight(mRectPath))
-                   : toDip(mProps->getStrokeWidth());
+    float sw = validateViewBox() ? ModUtil::viewBoxToMax(mProps->getStrokeWidth(), mRectVb,
+        OH_Drawing_RectGetWidth(mRectPath), OH_Drawing_RectGetHeight(mRectPath)) :
+                                   toDip(mProps->getStrokeWidth());
     OH_Drawing_PenSetWidth(mPaintStroke, sw);
     OH_Drawing_PenSetCap(mPaintStroke, mProps->getStrokeCap());
     OH_Drawing_PenSetJoin(mPaintStroke, mProps->getStrokeJoin());
@@ -318,12 +394,13 @@ void ClipPathViewNoneNode::setPaintStrokeProps() {
     mPath2 = OH_Drawing_PathCopy(mPath);
     if (mProps->getStrokeStart() != 0.0f || mProps->getStrokeEnd() != 1.0f) {
         OH_Drawing_PathMoveTo(mPath2, OH_Drawing_PathGetLength(mPath2, false) * mProps->getStrokeStart(),
-                              OH_Drawing_PathGetLength(mPath2, false) * mProps->getStrokeEnd());
+            OH_Drawing_PathGetLength(mPath2, false) * mProps->getStrokeEnd());
         OH_Drawing_PathLineTo(mPath2, 0.0f, 0.0f);
     }
 }
 
-void ClipPathViewNoneNode::canvasTransform() {
+void ClipPathViewNoneNode::canvasTransform()
+{
     OH_Drawing_MatrixReset(mMatrix);
     if (mRotation != 0.0f) {
         float rotX;
@@ -333,9 +410,9 @@ void ClipPathViewNoneNode::canvasTransform() {
             rotY = (mRotationOy * getSavedHeight());
         } else if (validateViewBox()) {
             rotX = OH_Drawing_RectGetLeft(mRectPath) +
-                   ModUtil::viewBoxToWidth(mRotationOx, mRectVb, OH_Drawing_RectGetWidth(mRectPath));
+                ModUtil::viewBoxToWidth(mRotationOx, mRectVb, OH_Drawing_RectGetWidth(mRectPath));
             rotY = OH_Drawing_RectGetTop(mRectPath) +
-                   ModUtil::viewBoxToHeight(mRotationOy, mRectVb, OH_Drawing_RectGetHeight(mRectPath));
+                ModUtil::viewBoxToHeight(mRotationOy, mRectVb, OH_Drawing_RectGetHeight(mRectPath));
         } else {
             rotX = toDip(mRotationOx);
             rotY = toDip(mRotationOy);
@@ -351,9 +428,9 @@ void ClipPathViewNoneNode::canvasTransform() {
             oY = (mScaleOriginY * getSavedHeight());
         } else if (validateViewBox()) {
             oX = OH_Drawing_RectGetLeft(mRectPath) +
-                 ModUtil::viewBoxToWidth(mScaleOriginX, mRectVb, OH_Drawing_RectGetWidth(mRectPath));
+                ModUtil::viewBoxToWidth(mScaleOriginX, mRectVb, OH_Drawing_RectGetWidth(mRectPath));
             oY = OH_Drawing_RectGetTop(mRectPath) +
-                 ModUtil::viewBoxToHeight(mScaleOriginY, mRectVb, OH_Drawing_RectGetHeight(mRectPath));
+                ModUtil::viewBoxToHeight(mScaleOriginY, mRectVb, OH_Drawing_RectGetHeight(mRectPath));
         } else {
             oX = toDip(mScaleOriginX);
             oY = toDip(mScaleOriginY);
@@ -377,5 +454,4 @@ void ClipPathViewNoneNode::canvasTransform() {
         OH_Drawing_MatrixPostTranslate(mMatrix, transX, transY);
     }
 }
-
 } // namespace rnoh

package/harmony/clipPath/src/main/cpp/ClipPathViewNoneNode.h

@@ -1,8 +1,22 @@
-//
-// Created on 2024/6/25.
-//
+/*
+ * 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.
+ */
 // Node APIs are not fully supported. To solve the compilation error of the interface cannot be found,
 // please include "napi/native_api.h".
+#ifndef CLIPPATHVIEWNONENODE_H
+#define CLIPPATHVIEWNONENODE_H
+
 #pragma once
 
 #include "RNOH/arkui/ArkUINode.h"
@@ -13,86 +27,88 @@
 #include "ClipPathProps.h"
 #include "SVGViewBox.h"
 namespace rnoh {
+struct CanvasCallback {
+    std::function<void(ArkUI_NodeCustomEvent *event)> callback;
+};
+
+class ClipPathViewNoneNode : public ArkUINode {
+public:
+    ClipPathViewNoneNode();
+    ~ClipPathViewNoneNode() override;
+    void InsertChild(ArkUINode &child, std::size_t index);
+    void RemoveChild(ArkUINode &child);
+    void SetD(const std::string d);
+    void SetStrokeWidth(float const width);
+    void SetStrokeCap(std::string const cap);
+    void SetStrokeJoin(std::string const join);
+    void SetStrokeMiter(float const miter);
+    void SetStrokeStart(float const start);
+    void SetStrokeEnd(float const end);
+    void SetViewBox(std::vector<float> viewBox);
+    void SetAlign(std::string v);
+    void SetAspect(std::string v);
+    void SetFillRule(std::string v);
+    // transFrom
+    void SetTransX(float v);
+    void SetTransY(float v);
+    void SetTransPercentageValue(bool v);
+    void SetRot(float v);
+    void SetRotO(float v);
+    void SetRotOx(float v);
+    void SetRotOy(float v);
+    void SetRotPercentageValue(bool v);
+    void SetSc(float v);
+    void SetScX(float v);
+    void SetScY(float v);
+    void SetScO(float v);
+    void SetScOx(float v);
+    void SetScOy(float v);
+    void SetTranslateZ(float z);
+    void SetScPercentageValue(bool v);
+
+private:
+    void (*eventReceiver)(ArkUI_NodeCustomEvent *event);
+    void OnDraw(ArkUI_NodeCustomEvent *event);
+    void setupPath(OH_Drawing_Canvas *canvas);
+    void viewBoxTransform();
+    bool validateViewBox();
+    void setRect(OH_Drawing_Rect *target, OH_Drawing_Rect *src);
+    void setRectF(OH_Drawing_Rect *target, float left, float top, float right, float bottom);
+    void setPaintStrokeProps();
+    float toDip(float value);
+    void canvasTransform();
+    void drawPath(OH_Drawing_Canvas *canvas);
+    void setPanStyleMode(OH_Drawing_Canvas *canvas, int type);
 
-    struct CanvasCallback {
-        std::function<void(ArkUI_NodeCustomEvent *event)> callback;
-    };
+private:
+    std::string mD{ "" };
+    std::string mAlign{ "xMinYMin" };
+    CanvasCallback *canvasCallback_{ nullptr };
+    int mAspect{ SVGViewBox::MOS_MEET };
+    ClipPathProps *mProps{ new ClipPathProps() };
+    OH_Drawing_Rect *mRectVb{ OH_Drawing_RectCreate(0.0f, 0.0f, -1.0f, -1.0f) };
+    OH_Drawing_Rect *mRectVbDensity{ OH_Drawing_RectCreate(0.0f, 0.0f, -1.0f, -1.0f) };
+    OH_Drawing_Rect *mRectPath{ OH_Drawing_RectCreate(0.0f, 0.0f, 0.0f, 0.0f) };
+    OH_Drawing_Rect *mBounds{ OH_Drawing_RectCreate(0.0f, 0.0f, 0.0f, 0.0f) };
+    OH_Drawing_Matrix *mMatrix{ OH_Drawing_MatrixCreate() };
+    OH_Drawing_Path *mPath{};
+    OH_Drawing_Path *mPath2{ OH_Drawing_PathCreate() };
+    OH_Drawing_Pen *mPaint{ OH_Drawing_PenCreate() };
+    OH_Drawing_Pen *mPaintStroke{ OH_Drawing_PenCreate() };
+    OH_Drawing_Canvas *canvas{ nullptr };
+    float mTranslationX{ 0.0f };
+    float mTranslationY{ 0.0f };
+    bool mTranslationIsPercent{ false };
+    float mRotation{ 0.0f };
+    float mRotationOx{ 0.0f };
+    float mRotationOy{ 0.0f };
+    bool mRotationIsPercent{ false };
+    float mScaleX{ 1.0f };
+    float mScaleY{ 1.0f };
+    float mScaleOriginX{ 0.0f };
+    float mScaleOriginY{ 0.0f };
+    bool mScaleIsPercent{ false };
+};
+} // namespace rnoh
 
-    class ClipPathViewNoneNode : public ArkUINode {
-    public:
-        ClipPathViewNoneNode();
-        ~ClipPathViewNoneNode() override;
-        void insertChild(ArkUINode &child, std::size_t index);
-        void removeChild(ArkUINode &child);
-        void setD(const std::string d);
-        void setStrokeWidth(float const width);
-        void setStrokeCap(std::string const cap);
-        void setStrokeJoin(std::string const join);
-        void setStrokeMiter(float const miter);
-        void setStrokeStart(float const start);
-        void setStrokeEnd(float const end);
-        void setViewBox(std::vector<float> viewBox);
-        void setAlign(std::string v);
-        void setAspect(std::string v);
-        void setFillRule(std::string v);
-        // transFrom
-        void setTransX(float v);
-        void setTransY(float v);
-        void setTransPercentageValue(bool v);
-        void setRot(float v);
-        void setRotO(float v);
-        void setRotOx(float v);
-        void setRotOy(float v);
-        void setRotPercentageValue(bool v);
-        void setSc(float v);
-        void setScX(float v);
-        void setScY(float v);
-        void setScO(float v);
-        void setScOx(float v);
-        void setScOy(float v);
-        void setTranslateZ(float z);
-        void setScPercentageValue(bool v);
- private:
-        void (*eventReceiver)(ArkUI_NodeCustomEvent *event);
-        void OnDraw(ArkUI_NodeCustomEvent *event);
-        void setupPath(OH_Drawing_Canvas *canvas);
-        void viewBoxTransform();
-        bool validateViewBox();
-        void setRect(OH_Drawing_Rect *target, OH_Drawing_Rect *src);
-        void setRectF(OH_Drawing_Rect *target, float left, float top, float right, float bottom);
-        void setPaintStrokeProps();
-        float toDip(float value);
-        void canvasTransform();
-        void drawPath(OH_Drawing_Canvas *canvas);
-        void setPanStyleMode(OH_Drawing_Canvas *canvas,int type);    
-    
-    private:
-        std::string mD{""};
-        std::string mAlign{"xMinYMin"};
-        CanvasCallback *canvasCallback_{nullptr};
-        int mAspect{SVGViewBox::MOS_MEET};
-        ClipPathProps *mProps{new ClipPathProps()};
-        OH_Drawing_Rect *mRectVb{OH_Drawing_RectCreate(0.0f, 0.0f, -1.0f, -1.0f)};
-        OH_Drawing_Rect *mRectVbDensity{OH_Drawing_RectCreate(0.0f, 0.0f, -1.0f, -1.0f)};
-        OH_Drawing_Rect *mRectPath{OH_Drawing_RectCreate(0.0f, 0.0f, 0.0f, 0.0f)};
-        OH_Drawing_Rect *mBounds{OH_Drawing_RectCreate(0.0f, 0.0f, 0.0f, 0.0f)};
-        OH_Drawing_Matrix *mMatrix{OH_Drawing_MatrixCreate()};
-        OH_Drawing_Path *mPath{};
-        OH_Drawing_Path *mPath2{OH_Drawing_PathCreate()};
-        OH_Drawing_Pen *mPaint{OH_Drawing_PenCreate()};
-        OH_Drawing_Pen *mPaintStroke{OH_Drawing_PenCreate()};
-        OH_Drawing_Canvas *canvas{nullptr};
-        float mTranslationX{0.0f};
-        float mTranslationY{0.0f};
-        bool mTranslationIsPercent{false};
-        float mRotation{0.0f};
-        float mRotationOx{0.0f};
-        float mRotationOy{0.0f};
-        bool mRotationIsPercent{false};
-        float mScaleX{1.0f};
-        float mScaleY{1.0f};
-        float mScaleOriginX{0.0f};
-        float mScaleOriginY{0.0f};
-        bool mScaleIsPercent{false};
-    };
-} // namespace rnoh
+#endif

package/harmony/clipPath/src/main/cpp/RNCClipPathTurboModule.cpp

@@ -27,12 +27,12 @@
 using namespace rnoh;
 using namespace facebook;
 
-static jsi::Value __hostFunction_RNCClipPathTurboModule_getDensity(jsi::Runtime &rt, react::TurboModule &turboModule,
+static jsi::Value hostFunction_RNCClipPathTurboModule_getDensity(jsi::Runtime &rt, react::TurboModule &turboModule,
                                                                    const jsi::Value *args, size_t count) {
     return static_cast<ArkTSTurboModule &>(turboModule).call(rt, "getDensity", args, count);
 }
 
 RNCClipPathTurboModule::RNCClipPathTurboModule(const ArkTSTurboModule::Context ctx, const std::string name)
     : ArkTSTurboModule(ctx, name) {
-    methodMap_["getDensity"] = MethodMetadata{0, __hostFunction_RNCClipPathTurboModule_getDensity};
+    methodMap_["getDensity"] = MethodMetadata{0, hostFunction_RNCClipPathTurboModule_getDensity};
 }