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

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

@@ -0,0 +1,102 @@
+/*
+ * 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 "ClipPathViewNoneComponentInstance.h"
+#include "ModUtil.h"
+#include <glog/logging.h>
+namespace rnoh {
+ClipPathViewNoneComponentInstance::ClipPathViewNoneComponentInstance(Context context)
+    : CppComponentInstance(std::move(context)) {
+    auto rnInstancePtr = this->m_deps->rnInstance.lock();
+    if (rnInstancePtr != nullptr) {
+        auto turboModule = rnInstancePtr->getTurboModule("RNCClipPathContext");
+        auto arkTsTurboModule = std::dynamic_pointer_cast<rnoh::ArkTSTurboModule>(turboModule);
+        folly::dynamic result = arkTsTurboModule->callSync("getDensity", {});
+        ModUtil::setDensity(static_cast<float>(result.asDouble()));
+    }
+}
+void ClipPathViewNoneComponentInstance::onChildInserted(ComponentInstance::Shared const &childComponentInstance,
+                                                        std::size_t index) {
+    CppComponentInstance::onChildInserted(childComponentInstance, index);
+    mClipPathNode.insertChild(childComponentInstance->getLocalRootArkUINode(), index);
+}
+
+void ClipPathViewNoneComponentInstance::onChildRemoved(ComponentInstance::Shared const &childComponentInstance) {
+    CppComponentInstance::onChildRemoved(childComponentInstance);
+    mClipPathNode.removeChild(childComponentInstance->getLocalRootArkUINode());
+};
+
+ClipPathViewNoneNode &ClipPathViewNoneComponentInstance::getLocalRootArkUINode() { return mClipPathNode; }
+
+void ClipPathViewNoneComponentInstance::onPropsChanged(SharedConcreteProps const &props) {
+    CppComponentInstance::onPropsChanged(props);
+    if (auto p = std::dynamic_pointer_cast<const facebook::react::RNCClipPathViewNoneProps>(props)) {
+        mClipPathNode.setD(p->d);
+        mClipPathNode.setViewBox(p->viewBox);
+        if (p->translateZ != 0) {
+            mClipPathNode.setTranslateZ(p->translateZ);
+        }
+        mClipPathNode.setAlign(p->align);
+        mClipPathNode.setAspect(p->aspect);
+
+        mClipPathNode.setStrokeCap(p->strokeCap);
+        mClipPathNode.setStrokeJoin(p->strokeJoin);
+        mClipPathNode.setStrokeWidth(p->strokeWidth);
+        mClipPathNode.setStrokeMiter(p->strokeMiter);
+        mClipPathNode.setStrokeStart(p->strokeStart);
+        mClipPathNode.setStrokeEnd(p->strokeEnd);
+        mClipPathNode.setFillRule(p->fillRule);
+
+        if (p->rot != 0.0f) {
+            mClipPathNode.setRot(p->rot);
+        }
+        if (p->rotO != 0.0f) {
+            mClipPathNode.setRotO(p->rotO);
+        }
+        if (p->rotOx != 0.0f) {
+            mClipPathNode.setRotOx(p->rotOx);
+        }
+        if (p->rotOy != 0.0f) {
+            mClipPathNode.setRotOy(p->rotOy);
+        }
+
+        mClipPathNode.setRotPercentageValue(p->rotPercentageValue);
+        if (p->sc != 1.0f) {
+            mClipPathNode.setSc(p->sc);
+        }
+        if (p->scX != 1.0f) {
+            mClipPathNode.setScX(p->scX);
+        }
+        if (p->scY != 1.0f) {
+            mClipPathNode.setScY(p->scY);
+        }
+
+        if (p->scO != 0.0f) {
+            mClipPathNode.setScO(p->scO);
+        }
+        if (p->scOx != 0.0f) {
+            mClipPathNode.setScOx(p->scOx);
+        }
+        if (p->scOy != 0.0f) {
+            mClipPathNode.setScOy(p->scOy);
+        }
+        mClipPathNode.setScPercentageValue(p->scPercentageValue);
+
+        mClipPathNode.setTransX(p->transX);
+        mClipPathNode.setTransY(p->transY);
+        mClipPathNode.setTransPercentageValue(p->transPercentageValue);
+    }
+}
+} // namespace rnoh

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

@@ -0,0 +1,38 @@
+/*
+ * 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 HARMONY_CLIPPATHVIEWNONECOMPONENTINSTANCE_H
+#define HARMONY_CLIPPATHVIEWNONECOMPONENTINSTANCE_H
+
+#include "ClipPathViewNoneNode.h"
+#include "RNOH/CppComponentInstance.h"
+#include "ShadowNodes.h"
+
+namespace rnoh {
+class ClipPathViewNoneComponentInstance : public CppComponentInstance<facebook::react::RNCClipPathViewNoneShadowNode> {
+private:
+    ClipPathViewNoneNode mClipPathNode;
+
+public:
+    ClipPathViewNoneComponentInstance(Context context);
+    void onChildInserted(ComponentInstance::Shared const &childComponentInstance, std::size_t index) override;
+
+    void onChildRemoved(ComponentInstance::Shared const &childComponentInstance) override;
+    ClipPathViewNoneNode &getLocalRootArkUINode() override;
+    void onPropsChanged(SharedConcreteProps const &props) override;
+};
+} // namespace rnoh
+
+#endif // HARMONY_CLIPPATHVIEWCOMPONENTINSTANCE_H

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

@@ -0,0 +1,61 @@
+/*
+ * 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 HARMONY_CLIP_PATH_VIEW_SRC_MAIN_CPP_CLIPPATHVIEWNONEJSIBINDER_H
+#define HARMONY_CLIP_PATH_VIEW_SRC_MAIN_CPP_CLIPPATHVIEWNONEJSIBINDER_H
+
+#include "RNOHCorePackage/ComponentBinders/ViewComponentJSIBinder.h"
+
+namespace rnoh {
+class ClipPathViewNoneJSIBinder : public ViewComponentJSIBinder {
+    facebook::jsi::Object createNativeProps(facebook::jsi::Runtime &rt) override {
+        auto object = ViewComponentJSIBinder::createNativeProps(rt);
+        object.setProperty(rt, "d", "string");
+        object.setProperty(rt, "viewBox", "array");
+        object.setProperty(rt, "aspect", "string");
+        object.setProperty(rt, "align", "string");
+        object.setProperty(rt, "translateZ", "float");
+        object.setProperty(rt, "fillRule", "string");
+        object.setProperty(rt, "strokeWidth", "float");
+        object.setProperty(rt, "strokeCap", "string");
+        object.setProperty(rt, "strokeJoin", "string");
+        object.setProperty(rt, "strokeMiter", "float");
+        object.setProperty(rt, "strokeStart", "float");
+        object.setProperty(rt, "strokeEnd", "float");
+
+        object.setProperty(rt, "sc", "float");
+        object.setProperty(rt, "scX", "float");
+        object.setProperty(rt, "scY", "float");
+        object.setProperty(rt, "scO", "float");
+        object.setProperty(rt, "scOx", "float");
+        object.setProperty(rt, "scOy", "float");
+        object.setProperty(rt, "scPercentageValue", "float");
+
+        object.setProperty(rt, "rot", "float");
+        object.setProperty(rt, "rotO", "float");
+        object.setProperty(rt, "rotOx", "float");
+        object.setProperty(rt, "rotOy", "float");
+        object.setProperty(rt, "rotPercentageValue", "bool");
+
+        object.setProperty(rt, "transX", "float");
+        object.setProperty(rt, "transY", "float");
+        object.setProperty(rt, "transPercentageValue", "bool");
+
+        return object;
+    }
+};
+} // namespace  rnoh
+#endif

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

@@ -0,0 +1,80 @@
+/*
+ * 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 HARMONY_CLIP_PATH_VIEW_SRC_MAIN_CPP_CLIPPATHVIEWNONENAPIBINDER_H
+#define HARMONY_CLIP_PATH_VIEW_SRC_MAIN_CPP_CLIPPATHVIEWNONENAPIBINDER_H
+#include "RNOHCorePackage/ComponentBinders/ViewComponentNapiBinder.h"
+#include "Props.h"
+
+namespace rnoh {
+
+    class ClipPathViewNoneNapiBinder : public ViewComponentNapiBinder {
+    public:
+        napi_value createProps(napi_env env, facebook::react::ShadowView const shadowView) override {
+            napi_value napiViewProps = ViewComponentNapiBinder::createProps(env, shadowView);
+            auto propsObjBuilder = ArkJS(env).getObjectBuilder(napiViewProps);
+
+            if (auto props = std::dynamic_pointer_cast<const facebook::react::RNCClipPathViewNoneProps>(shadowView.props)) {
+                propsObjBuilder.addProperty("d", props->d);
+                propsObjBuilder.addProperty("aspect", props->aspect);
+                propsObjBuilder.addProperty("align", props->align);
+                propsObjBuilder.addProperty("translateZ", props->translateZ);
+            
+                propsObjBuilder.addProperty("fillRule", props->fillRule);
+                propsObjBuilder.addProperty("strokeWidth", props->strokeWidth);
+                propsObjBuilder.addProperty("strokeCap", props->strokeCap);
+                propsObjBuilder.addProperty("strokeJoin", props->strokeJoin);
+                propsObjBuilder.addProperty("strokeMiter", props->strokeMiter);
+                propsObjBuilder.addProperty("strokeStart", props->strokeStart);
+                propsObjBuilder.addProperty("strokeEnd", props->strokeEnd);
+    
+                propsObjBuilder.addProperty("sc", props->sc);
+                propsObjBuilder.addProperty("scX", props->scX);
+                propsObjBuilder.addProperty("scY", props->scY);
+                propsObjBuilder.addProperty("scO", props->scO);
+                propsObjBuilder.addProperty("scOx", props->scOx);
+                propsObjBuilder.addProperty("scOy", props->scOy);
+                propsObjBuilder.addProperty("scPercentageValue", props->scPercentageValue);
+            
+                propsObjBuilder.addProperty("rot", props->rot);
+                propsObjBuilder.addProperty("rotO", props->rotO);
+                propsObjBuilder.addProperty("rotOx", props->rotOx);
+                propsObjBuilder.addProperty("rotOy", props->rotOy);
+                   propsObjBuilder.addProperty("rotPercentageValue", props->rotPercentageValue);
+            
+              
+                propsObjBuilder.addProperty("transX", props->transX);
+                propsObjBuilder.addProperty("transY", props->transY);
+                propsObjBuilder.addProperty("transPercentageValue", props->transPercentageValue);
+                auto boxArray = std::vector<napi_value>();
+                auto boxArrayRaw = props->viewBox;
+
+                for (auto item : boxArrayRaw) {
+                    auto itemObjBuilder = ArkJS(env).createDouble(item);
+                    boxArray.push_back(itemObjBuilder);
+                }
+
+                auto boxArrayArray = ArkJS(env).createArray(boxArray);
+
+                propsObjBuilder.addProperty("viewBox", boxArrayArray);
+
+                return propsObjBuilder.build();
+            }
+            return napiViewProps;
+        };
+    };
+
+} // namespace rnoh
+#endif

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

@@ -0,0 +1,381 @@
+//
+// 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".
+
+#include "ModUtil.h"
+#include "RNOH/arkui/NativeNodeApi.h"
+#include "ClipPathViewNoneNode.h"
+#include "SVGPathParser.h"
+#include "SVGViewBox.h"
+#include "pen_style_node.h"
+#include <native_drawing/drawing_brush.h>
+#include <native_drawing/drawing_canvas.h>
+#include <native_drawing/drawing_color.h>
+#include <native_drawing/drawing_path.h>
+#include <native_drawing/drawing_pen.h>
+#include <native_drawing/drawing_point.h>
+#include <native_drawing/drawing_rect.h>
+#include <native_drawing/drawing_shader_effect.h>
+#include <native_drawing/drawing_types.h>
+
+namespace rnoh {
+ClipPathViewNoneNode::ClipPathViewNoneNode()
+    : 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;
+        }
+    };
+    eventReceiver = [](ArkUI_NodeCustomEvent *event) {
+        int32_t targetId = OH_ArkUI_NodeCustomEvent_GetEventTargetId(event);
+        if (targetId == 10001 || targetId == 10002) {
+            auto *userData = reinterpret_cast<CanvasCallback *>(OH_ArkUI_NodeCustomEvent_GetUserData(event));
+            if (userData != nullptr && userData->callback != nullptr) {
+                userData->callback(event);
+            }
+        }
+    };
+    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_MEASURE,
+                                                                     10002, canvasCallback_));
+    OH_Drawing_PenIsAntiAlias(mPaint);
+    OH_Drawing_PenIsAntiAlias(mPaintStroke);
+    OH_Drawing_PenSetColor(mPaint, 0xffffffff);
+    OH_Drawing_PenSetColor(mPaintStroke, 0xffffffff);
+}
+
+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);
+    OH_Drawing_RectDestroy(mRectVb);
+    OH_Drawing_RectDestroy(mRectVbDensity);
+    OH_Drawing_RectDestroy(mBounds);
+    OH_Drawing_RectDestroy(mRectPath);
+    OH_Drawing_PathDestroy(mPath);
+    OH_Drawing_PathDestroy(mPath2);
+    OH_Drawing_MatrixDestroy(mMatrix);
+    OH_Drawing_PenDestroy(mPaint);
+    OH_Drawing_PenDestroy(mPaintStroke);
+    delete canvasCallback_;
+    delete mProps;
+    canvasCallback_ = nullptr;
+    mProps = nullptr;
+    canvas =nullptr;
+}
+
+void ClipPathViewNoneNode::insertChild(ArkUINode &child, std::size_t index) {
+    maybeThrow(NativeNodeApi::getInstance()->insertChildAt(m_nodeHandle, child.getArkUINodeHandle(), index));
+}
+
+void ClipPathViewNoneNode::removeChild(ArkUINode &child) {
+    maybeThrow(NativeNodeApi::getInstance()->removeChild(m_nodeHandle, child.getArkUINodeHandle()));
+}
+
+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;
+    }
+    OH_Drawing_CanvasAttachBrush(canvas, cBrush);
+    OH_Drawing_BrushDestroy(cBrush);
+}
+
+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);
+    auto height_ = OH_Drawing_CanvasGetHeight(canvas);
+
+    auto canvasRect = OH_Drawing_RectCreate(0.0f, 0.0f, width_, height_);
+    OH_Drawing_CanvasSaveLayer(canvas, canvasRect, nullptr);
+    OH_Drawing_Brush *cBrush_back = OH_Drawing_BrushCreate();
+    OH_Drawing_BrushSetColor(cBrush_back, OH_Drawing_ColorSetArgb(0xff, 0xff, 0xff, 0xff));
+    OH_Drawing_CanvasDrawBackground(canvas, cBrush_back);
+
+    OH_Drawing_Brush *cBrush_ = OH_Drawing_BrushCreate();
+    OH_Drawing_BrushSetBlendMode(cBrush_, BLEND_MODE_DST_OUT);
+    OH_Drawing_CanvasSaveLayer(canvas, canvasRect, cBrush_);
+
+    drawPath(canvas);
+    OH_Drawing_RectDestroy(canvasRect);
+    OH_Drawing_BrushDestroy(cBrush_back);
+    OH_Drawing_BrushDestroy(cBrush_);
+}
+
+void ClipPathViewNoneNode::drawPath(OH_Drawing_Canvas *canvas) {
+    setupPath(canvas);
+    viewBoxTransform();
+    setPaintStrokeProps();
+    canvasTransform();
+    OH_Drawing_CanvasSave(canvas);
+    OH_Drawing_CanvasConcatMatrix(canvas, mMatrix);
+
+    uint32_t count = OH_Drawing_CanvasGetSaveCount(canvas);
+    OH_Drawing_CanvasAttachPen(canvas, mPaint);
+    setPanStyleMode(canvas, CLIP_PEN_STYLE_FILL);
+    OH_Drawing_CanvasDrawPath(canvas, mPath);
+    OH_Drawing_CanvasDetachPen(canvas);
+
+    OH_Drawing_CanvasAttachPen(canvas, mPaintStroke);
+    setPanStyleMode(canvas, CLIP_PEN_STYLE_STROKE);
+    OH_Drawing_CanvasDrawPath(canvas, mPath2);
+    OH_Drawing_CanvasDetachPen(canvas);
+
+    OH_Drawing_CanvasRestoreToCount(canvas, count);
+    OH_Drawing_CanvasRestore(canvas);
+    OH_Drawing_CanvasRestore(canvas);
+}
+
+void ClipPathViewNoneNode::setupPath(OH_Drawing_Canvas *canvas) {
+    if (!canvas || mD.empty()) {
+        return;
+    }
+    if (mPath) {
+        OH_Drawing_PathReset(mPath);
+    }
+    SVGPathParser::mScale = ModUtil::getDensity();
+    mPath = SVGPathParser::parse(mD);
+}
+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) {
+    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) {
+    setRect(target, OH_Drawing_RectCreate(left, top, right, bottom));
+}
+
+void ClipPathViewNoneNode::setTranslateZ(float z) {
+    ArkUI_NumberValue translateValue[] = {{.f32 = z}};
+    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) {
+    if (mTranslationX != v) {
+        mTranslationX = v;
+    }
+}
+void ClipPathViewNoneNode::setTransY(float v) {
+    if (mTranslationY != v) {
+        mTranslationY = v;
+    }
+}
+void ClipPathViewNoneNode::setTransPercentageValue(bool v) {
+    if (mTranslationIsPercent != v) {
+        mTranslationIsPercent = v;
+    }
+}
+
+void ClipPathViewNoneNode::setRot(float v) {
+    if (mRotation != v) {
+        mRotation = v;
+    }
+}
+void ClipPathViewNoneNode::setRotO(float v) {
+    if (mRotationOx != v || mRotationOy != v) {
+        mRotationOx = v;
+        mRotationOy = v;
+    }
+}
+void ClipPathViewNoneNode::setRotOx(float v) {
+    if (mRotationOx != v) {
+        mRotationOx = v;
+    }
+}
+void ClipPathViewNoneNode::setRotOy(float v) {
+    if (mRotationOy != v) {
+        mRotationOy = v;
+    }
+}
+void ClipPathViewNoneNode::setRotPercentageValue(bool v) {
+    if (mRotationIsPercent != v) {
+        mRotationIsPercent = v;
+    }
+}
+void ClipPathViewNoneNode::setSc(float v) {
+    if (mScaleX != v || mScaleY != v) {
+        mScaleX = v;
+        mScaleY = v;
+    }
+}
+void ClipPathViewNoneNode::setScX(float v) {
+    if (mScaleX != v) {
+        mScaleX = v;
+    }
+}
+
+void ClipPathViewNoneNode::setScY(float v) {
+    if (mScaleY != v) {
+        mScaleY = v;
+    }
+}
+
+void ClipPathViewNoneNode::setScO(float v) {
+    if (mScaleOriginX != v || mScaleOriginY != v) {
+        mScaleOriginX = v;
+        mScaleOriginY = v;
+    }
+}
+void ClipPathViewNoneNode::setScOx(float v) {
+    if (mScaleOriginX != v) {
+        mScaleOriginX = v;
+    }
+}
+void ClipPathViewNoneNode::setScOy(float v) {
+    if (mScaleOriginY != v) {
+        mScaleOriginY = v;
+    }
+}
+void ClipPathViewNoneNode::setScPercentageValue(bool v) {
+    if (mScaleIsPercent != v) {
+        mScaleIsPercent = v;
+    }
+}
+
+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);
+}
+
+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() {
+    return OH_Drawing_RectGetWidth(mRectVb) >= 0.0f && OH_Drawing_RectGetHeight(mRectVb) >= 0.0f;
+}
+
+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());
+    OH_Drawing_PenSetWidth(mPaintStroke, sw);
+    OH_Drawing_PenSetCap(mPaintStroke, mProps->getStrokeCap());
+    OH_Drawing_PenSetJoin(mPaintStroke, mProps->getStrokeJoin());
+    OH_Drawing_PenSetMiterLimit(mPaintStroke, mProps->getStrokeMiter());
+    OH_Drawing_PathReset(mPath2);
+    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_PathLineTo(mPath2, 0.0f, 0.0f);
+    }
+}
+
+void ClipPathViewNoneNode::canvasTransform() {
+    OH_Drawing_MatrixReset(mMatrix);
+    if (mRotation != 0.0f) {
+        float rotX;
+        float rotY;
+        if (mRotationIsPercent) {
+            rotX = (mRotationOx * getSavedWidth());
+            rotY = (mRotationOy * getSavedHeight());
+        } else if (validateViewBox()) {
+            rotX = OH_Drawing_RectGetLeft(mRectPath) +
+                   ModUtil::viewBoxToWidth(mRotationOx, mRectVb, OH_Drawing_RectGetWidth(mRectPath));
+            rotY = OH_Drawing_RectGetTop(mRectPath) +
+                   ModUtil::viewBoxToHeight(mRotationOy, mRectVb, OH_Drawing_RectGetHeight(mRectPath));
+        } else {
+            rotX = toDip(mRotationOx);
+            rotY = toDip(mRotationOy);
+        }
+        OH_Drawing_MatrixPostRotate(mMatrix, mRotation, rotX, rotY);
+    }
+
+    if (mScaleX != 1.0f || mScaleY != 1.0f) {
+        float oX;
+        float oY;
+        if (mScaleIsPercent) {
+            oX = (mScaleOriginX * getSavedWidth());
+            oY = (mScaleOriginY * getSavedHeight());
+        } else if (validateViewBox()) {
+            oX = OH_Drawing_RectGetLeft(mRectPath) +
+                 ModUtil::viewBoxToWidth(mScaleOriginX, mRectVb, OH_Drawing_RectGetWidth(mRectPath));
+            oY = OH_Drawing_RectGetTop(mRectPath) +
+                 ModUtil::viewBoxToHeight(mScaleOriginY, mRectVb, OH_Drawing_RectGetHeight(mRectPath));
+        } else {
+            oX = toDip(mScaleOriginX);
+            oY = toDip(mScaleOriginY);
+        }
+        OH_Drawing_MatrixPostScale(mMatrix, mScaleX, mScaleY, oX, oY);
+    }
+
+    if (mTranslationX != 0.0f || mTranslationY != 0.0f) {
+        float transX;
+        float transY;
+        if (mTranslationIsPercent) {
+            transX = (mTranslationX * getSavedWidth());
+            transY = (mTranslationY * getSavedHeight());
+        } else if (validateViewBox()) {
+            transX = (mTranslationX / OH_Drawing_RectGetWidth(mRectVb)) * OH_Drawing_RectGetWidth(mRectPath);
+            transY = (mTranslationY / OH_Drawing_RectGetHeight(mRectVb)) * OH_Drawing_RectGetHeight(mRectPath);
+        } else {
+            transX = toDip(mTranslationX);
+            transY = toDip(mTranslationY);
+        }
+        OH_Drawing_MatrixPostTranslate(mMatrix, transX, transY);
+    }
+}
+
+} // namespace rnoh