@react-native-ohos/react-native-clippathview 1.1.9-rc.2 → 1.2.0

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

@@ -1,17 +1,6 @@
-/*
- * 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.
- */
+//
+// Created on 2024/6/25.
+//
 // Node APIs are not fully supported. To solve the compilation error of the interface cannot be found,
 // please include "napi/native_api.h".
 
@@ -33,51 +22,45 @@
 
 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);
-        int count10001 = 10001;
-        int count10002 = 10002;
-        if (targetId == count10001 || targetId == count10002) {
+        if (targetId == 10001 || targetId == 10002) {
             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, count101, canvasCallback_));
+    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_MEASURE,
-        count102, canvasCallback_));
+                                                                     10002, 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);
@@ -94,38 +77,35 @@ 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);
@@ -147,8 +127,7 @@ 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();
@@ -172,8 +151,7 @@ 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;
     }
@@ -183,209 +161,155 @@ 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();
-    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);
+    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);
 }
 
-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());
@@ -394,13 +318,12 @@ 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;
@@ -410,9 +333,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);
@@ -428,9 +351,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);
@@ -454,4 +377,5 @@ void ClipPathViewNoneNode::canvasTransform()
         OH_Drawing_MatrixPostTranslate(mMatrix, transX, transY);
     }
 }
+
 } // namespace rnoh

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

@@ -1,22 +1,8 @@
-/*
- * 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.
- */
+//
+// Created on 2024/6/25.
+//
 // 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"
@@ -27,88 +13,86 @@
 #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);
 
-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
+    struct CanvasCallback {
+        std::function<void(ArkUI_NodeCustomEvent *event)> callback;
+    };
 
-#endif
+    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

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};
 }