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

package/harmony/svg/src/main/cpp/SvgFilter.h

@@ -1,112 +1,112 @@
-/*
- * 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 "SvgNode.h"
-#include "drawing/Brush.h"
-#include "drawing/Pen.h"
-#include <native_drawing/drawing_canvas.h>
-#include <native_drawing/drawing_filter.h>
-
-namespace rnoh {
-namespace svg {
-
-enum class FilterType {
-    BLUR,
-    GAUSSIAN_BLUR,
-    DROP_SHADOW,
-    COLOR_MATRIX,
-    FEOFFSET,
-    FEFLOOD,
-    BLEND,
-    COMPOSITE,
-    MERGE,
-    UNKNOWN
-};
-
-struct FilterEffect {
-    FilterType filterType = FilterType::UNKNOWN;
-    std::vector<float> values;
-    std::string type = "";
-    std::string in = "SourceGraphic";
-    std::string in2 = "";
-    std::string result = "";
-
-    std::string mode = "";
-    std::string operator_ = "";
-    std::string floodColor = "black";
-    float floodOpacity = 1.0f;
-
-    float dx_ = 0.0f;
-    float dy_ = 0.0f;
-    float stdDeviationX_ = 0.0f;
-    float stdDeviationY_ = 0.0f;
-    std::string edgeMode_ = "duplicate";
-    std::string k1 = "";
-    std::string k2 = "";
-    std::string k3 = "";
-    std::string k4 = "";
-
-    FilterEffect() = default;
-    FilterEffect(FilterType t, const std::vector<float>& v) : filterType(t), values(v) {}
-    FilterEffect(FilterType t, const std::vector<float>& v, const std::string& inputSource, const std::string& inputType, const std::string& resultId) 
-        : filterType(t), values(v), in(inputSource), type(inputType), result(resultId) {}
-    FilterEffect(FilterType t, const std::string& inputSource, const std::string& inputSource2, const std::string& blendMode, const std::string& resultId)
-        : filterType(t), in(inputSource), in2(inputSource2), mode(blendMode), result(resultId) {}
-    FilterEffect(FilterType t, const std::string& inputSource, const std::string& color, float opacity, const std::string& resultId)
-        : filterType(t), in(inputSource), floodColor(color), floodOpacity(opacity), result(resultId) {}
-    FilterEffect(FilterType t, const std::string& inputSource, float dx, float dy, const std::string& resultId)
-        : filterType(t), in(inputSource), dx_(dx), dy_(dy), result(resultId) {}
-    FilterEffect(FilterType t, const std::string& inputSource, const std::string& inputSource2, const std::string& op,
-        const std::string& k1_, const std::string& k2_, const std::string& k3_, const std::string& k4_, const std::string& resultId)
-        : filterType(t), in(inputSource), in2(inputSource2), operator_(op), k1(k1_), k2(k2_), k3(k3_), k4(k4_), result(resultId) {}
-    FilterEffect(FilterType t, const std::string& inputSource, float stdDeviationX, float stdDeviationY, const std::string& edgeMode, const std::string& resultId)
-        : filterType(t), in(inputSource), stdDeviationX_(stdDeviationX), stdDeviationY_(stdDeviationY), edgeMode_(edgeMode), result(resultId) {}
-    
-    // DropShadow specific constructor
-    FilterEffect(FilterType t, const std::string& inputSource, float dx, float dy, float stdDeviation, const std::string& color, float opacity)
-        : filterType(t), in(inputSource), dx_(dx), dy_(dy), stdDeviationX_(stdDeviation), floodColor(color), floodOpacity(opacity) {}
-};
-
-class SvgFilter : virtual public SvgNode {
-public:
-    SvgFilter() : SvgNode() {}
-    ~SvgFilter() noexcept override = default;
-    void ApplyToBrush(rnoh::drawing::Brush& brush, const std::string& extra = "");
-    void ApplyToPen(rnoh::drawing::Pen& pen);
-
-    void AddFilterEffect(const FilterEffect& effect);
-    void ClearFilterEffects() {
-        effects_.clear();
-    }
-
-    void Draw(OH_Drawing_Canvas *canvas) override {}
-private:
-    std::vector<FilterEffect> effects_;
-    void ApplySingleEffectToFilter(OH_Drawing_Filter* filter, const FilterEffect& effect,
-        rnoh::drawing::Brush* brush = nullptr, rnoh::drawing::Pen* pen = nullptr, const std::string& extra = "");
-    
-    OH_Drawing_ImageFilter* CreateGaussianBlurFilter(const FilterEffect& effect);
-    OH_Drawing_MaskFilter* CreateBlurFilter(const FilterEffect& effect);
-    OH_Drawing_ColorFilter* CreateColorMatrixFilter(const FilterEffect& effect);
-    OH_Drawing_ShadowLayer* CreateDropShadowFilter(const FilterEffect& effect);
-
-    OH_Drawing_ColorFilter* CreateMatrixFilter(const std::vector<float>& values);
-    OH_Drawing_ColorFilter* CreateSaturateFilter(const std::vector<float>& values);
-    OH_Drawing_ColorFilter* CreateHueRotateFilter(const std::vector<float>& values);
-    OH_Drawing_ColorFilter* CreateLuminanceToAlphaFilter();
-
-    OH_Drawing_ImageFilter* GetInputImageFilter(const std::string& inputName);
-    OH_Drawing_ColorFilter* GetInputColorFilter(const std::string& inputName);
-    OH_Drawing_Filter* GetInputFilter(const std::string& inputName);
-    OH_Drawing_ColorFilter* CombineWithInputColor(OH_Drawing_ColorFilter* newFilter, const std::string& inputName);
-    void RegisterFilterResult(const std::string& resultId, OH_Drawing_ImageFilter* imageFilter = nullptr, 
-                             OH_Drawing_ColorFilter* colorFilter = nullptr, OH_Drawing_MaskFilter* maskFilter = nullptr);
-};
-
-} // namespace svg
-} // namespace rnoh
+/*
+ * 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 "SvgNode.h"
+#include "drawing/Brush.h"
+#include "drawing/Pen.h"
+#include <native_drawing/drawing_canvas.h>
+#include <native_drawing/drawing_filter.h>
+
+namespace rnoh {
+namespace svg {
+
+enum class FilterType {
+    BLUR,
+    GAUSSIAN_BLUR,
+    DROP_SHADOW,
+    COLOR_MATRIX,
+    FEOFFSET,
+    FEFLOOD,
+    BLEND,
+    COMPOSITE,
+    MERGE,
+    UNKNOWN
+};
+
+struct FilterEffect {
+    FilterType filterType = FilterType::UNKNOWN;
+    std::vector<float> values;
+    std::string type = "";
+    std::string in = "SourceGraphic";
+    std::string in2 = "";
+    std::string result = "";
+
+    std::string mode = "";
+    std::string operator_ = "";
+    std::string floodColor = "black";
+    float floodOpacity = 1.0f;
+
+    float dx_ = 0.0f;
+    float dy_ = 0.0f;
+    float stdDeviationX_ = 0.0f;
+    float stdDeviationY_ = 0.0f;
+    std::string edgeMode_ = "duplicate";
+    std::string k1 = "";
+    std::string k2 = "";
+    std::string k3 = "";
+    std::string k4 = "";
+
+    FilterEffect() = default;
+    FilterEffect(FilterType t, const std::vector<float>& v) : filterType(t), values(v) {}
+    FilterEffect(FilterType t, const std::vector<float>& v, const std::string& inputSource, const std::string& inputType, const std::string& resultId) 
+        : filterType(t), values(v), in(inputSource), type(inputType), result(resultId) {}
+    FilterEffect(FilterType t, const std::string& inputSource, const std::string& inputSource2, const std::string& blendMode, const std::string& resultId)
+        : filterType(t), in(inputSource), in2(inputSource2), mode(blendMode), result(resultId) {}
+    FilterEffect(FilterType t, const std::string& inputSource, const std::string& color, float opacity, const std::string& resultId)
+        : filterType(t), in(inputSource), floodColor(color), floodOpacity(opacity), result(resultId) {}
+    FilterEffect(FilterType t, const std::string& inputSource, float dx, float dy, const std::string& resultId)
+        : filterType(t), in(inputSource), dx_(dx), dy_(dy), result(resultId) {}
+    FilterEffect(FilterType t, const std::string& inputSource, const std::string& inputSource2, const std::string& op,
+        const std::string& k1_, const std::string& k2_, const std::string& k3_, const std::string& k4_, const std::string& resultId)
+        : filterType(t), in(inputSource), in2(inputSource2), operator_(op), k1(k1_), k2(k2_), k3(k3_), k4(k4_), result(resultId) {}
+    FilterEffect(FilterType t, const std::string& inputSource, float stdDeviationX, float stdDeviationY, const std::string& edgeMode, const std::string& resultId)
+        : filterType(t), in(inputSource), stdDeviationX_(stdDeviationX), stdDeviationY_(stdDeviationY), edgeMode_(edgeMode), result(resultId) {}
+    
+    // DropShadow specific constructor
+    FilterEffect(FilterType t, const std::string& inputSource, float dx, float dy, float stdDeviation, const std::string& color, float opacity)
+        : filterType(t), in(inputSource), dx_(dx), dy_(dy), stdDeviationX_(stdDeviation), floodColor(color), floodOpacity(opacity) {}
+};
+
+class SvgFilter : virtual public SvgNode {
+public:
+    SvgFilter() : SvgNode() {}
+    ~SvgFilter() noexcept override = default;
+    void ApplyToBrush(rnoh::drawing::Brush& brush, const std::string& extra = "");
+    void ApplyToPen(rnoh::drawing::Pen& pen);
+
+    void AddFilterEffect(const FilterEffect& effect);
+    void ClearFilterEffects() {
+        effects_.clear();
+    }
+
+    void Draw(OH_Drawing_Canvas *canvas) override {}
+private:
+    std::vector<FilterEffect> effects_;
+    void ApplySingleEffectToFilter(OH_Drawing_Filter* filter, const FilterEffect& effect,
+        rnoh::drawing::Brush* brush = nullptr, rnoh::drawing::Pen* pen = nullptr, const std::string& extra = "");
+    
+    OH_Drawing_ImageFilter* CreateGaussianBlurFilter(const FilterEffect& effect);
+    OH_Drawing_MaskFilter* CreateBlurFilter(const FilterEffect& effect);
+    OH_Drawing_ColorFilter* CreateColorMatrixFilter(const FilterEffect& effect);
+    OH_Drawing_ShadowLayer* CreateDropShadowFilter(const FilterEffect& effect);
+
+    OH_Drawing_ColorFilter* CreateMatrixFilter(const std::vector<float>& values);
+    OH_Drawing_ColorFilter* CreateSaturateFilter(const std::vector<float>& values);
+    OH_Drawing_ColorFilter* CreateHueRotateFilter(const std::vector<float>& values);
+    OH_Drawing_ColorFilter* CreateLuminanceToAlphaFilter();
+
+    OH_Drawing_ImageFilter* GetInputImageFilter(const std::string& inputName);
+    OH_Drawing_ColorFilter* GetInputColorFilter(const std::string& inputName);
+    OH_Drawing_Filter* GetInputFilter(const std::string& inputName);
+    OH_Drawing_ColorFilter* CombineWithInputColor(OH_Drawing_ColorFilter* newFilter, const std::string& inputName);
+    void RegisterFilterResult(const std::string& resultId, OH_Drawing_ImageFilter* imageFilter = nullptr, 
+                             OH_Drawing_ColorFilter* colorFilter = nullptr, OH_Drawing_MaskFilter* maskFilter = nullptr);
+};
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/cpp/SvgForeignObjectNode.cpp

@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2025 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.
+ *
+ * This file incorporates from the OpenHarmony project, licensed under
+ * the Apache License, Version 2.0. Specifically:
+ * - [OpenHarmony/arkui_ace_engine] (https://gitee.com/openharmony/arkui_ace_engine)
+ *
+ * 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 "SvgForeignObjectNode.h"
+#include "RNOH/arkui/NativeNodeApi.h"
+#include <deviceinfo.h>
+#include <info/application_target_sdk_version.h>
+namespace rnoh {
+namespace svg {
+SvgForeignObjectNode::SvgForeignObjectNode()
+    : ArkUINode(NativeNodeApi::getInstance()->createNode(ArkUI_NodeType::ARKUI_NODE_STACK)) {
+    mStackNode.setVisibility(ArkUI_Visibility::ARKUI_VISIBILITY_HIDDEN);
+    mStackNode.setClip(true);
+    maybeThrow(NativeNodeApi::getInstance()->addChild(m_nodeHandle, mStackNode.getArkUINodeHandle()));
+}
+
+SvgForeignObjectNode::~SvgForeignObjectNode() {
+    if (m_NodeDelegate) {
+        m_NodeDelegate = nullptr;
+    }
+    _isGeneratedPixelMap = false;
+}
+void SvgForeignObjectNode::insertChild(ArkUINode &child, std::size_t index) { mStackNode.insertChild(child, index); }
+
+void SvgForeignObjectNode::SetSnapHeight(Dimension height) { _height = height; }
+
+void SvgForeignObjectNode::SetSnapWidth(Dimension width) { _width = width; }
+
+void SvgForeignObjectNode::SetSnapPosition(Dimension x, Dimension y) {
+    _positionX = x;
+    _positionY = y;
+}
+
+void SvgForeignObjectNode::onNodeEvent(ArkUI_NodeEventType eventType, EventArgs &eventArgs) {
+    if (eventType == ArkUI_NodeEventType::NODE_EVENT_ON_AREA_CHANGE) {
+        if (m_NodeDelegate && _isGeneratedPixelMap) {
+            OH_PixelmapNative *pixelMap = GetNodePixelMap();
+            if (!pixelMap) {
+                LOG(ERROR) << "[svgForeignNode] get node snapshot pixelMap is null";
+                return;
+            }
+            _isGeneratedPixelMap = false;
+            ForeignProps foreignProps = {pixelMap, _width, _height, _positionX, 
+                _positionY, _path, _clipRule, _mask, pointScaleFactor_, transform_};
+            m_NodeDelegate->onDrawForeignImage(foreignProps);
+        }
+    }
+}
+
+OH_PixelmapNative *SvgForeignObjectNode::GetNodePixelMap() {
+#ifdef OH_CURRENT_API_VERSION
+    if (OH_CURRENT_API_VERSION < 15 || OH_GetSdkApiVersion() < 15) {
+        LOG(ERROR) << "[svgForeignNode] current sdk or rom cannot support ForeignObject";
+        return nullptr;
+    }
+    OH_PixelmapNative *pixelMap;
+    ArkUI_SnapshotOptions *options = OH_ArkUI_CreateSnapshotOptions();
+    OH_ArkUI_SnapshotOptions_SetScale(options, 1);
+    int32_t code = OH_ArkUI_GetNodeSnapshot(mStackNode.getArkUINodeHandle(), options, &pixelMap);
+    if (code == ARKUI_ERROR_CODE_NO_ERROR) {
+        return pixelMap;
+    }
+#endif
+    return nullptr;
+}
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/cpp/SvgForeignObjectNode.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2025 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.
+ *
+ * This file incorporates from the OpenHarmony project, licensed under
+ * the Apache License, Version 2.0. Specifically:
+ * - [OpenHarmony/arkui_ace_engine] (https://gitee.com/openharmony/arkui_ace_engine)
+ *
+ * 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_SVGFOREIGNOBJECTNODE_H
+#define HARMONY_SVGFOREIGNOBJECTNODE_H
+#include "RNOH/arkui/ArkUINode.h"
+#include "RNOH/arkui/StackNode.h"
+#include "SvgForeignObjectNodeDelegate.h"
+#include "properties/Dimension.h"
+
+namespace rnoh {
+namespace svg {
+class SvgForeignObjectNode : public ArkUINode {
+public:
+    SvgForeignObjectNode();
+    ~SvgForeignObjectNode() override;
+    void onNodeEvent(ArkUI_NodeEventType eventType, EventArgs &eventArgs) override;
+    StackNode &getSnapNode() { return mStackNode; }
+    void insertChild(ArkUINode &child, std::size_t index);
+    void SetSnapPosition(Dimension x, Dimension y);
+    void SetSnapWidth(Dimension width);
+    void SetSnapHeight(Dimension height);
+    void SetPointScaleFactor(float pointScaleFactor) {
+        pointScaleFactor_ = pointScaleFactor;
+    }
+    void SetTransform(std::vector<double> transform) {
+        transform_ = transform;
+    }
+    void setNodeSize(float w, float h){
+        mStackNode.setSize({w, h});
+    }
+    OH_PixelmapNative *GetNodePixelMap();
+    void SetForeignNodeDelegate(SvgForeignObjectNodeDelegate *delegate) { m_NodeDelegate = delegate; };
+    void SetGeneratedPixelMap(bool isNeed) {
+        _isGeneratedPixelMap = isNeed;
+    }
+    
+    void SetClipPath(std::string path,int clipRule) {
+        _path = path;
+        _clipRule = clipRule;
+    }
+     void SetMask(std::string mask) {
+        _mask = mask;
+    }
+    
+private:
+    StackNode mStackNode;
+    SvgForeignObjectNodeDelegate *m_NodeDelegate;
+    Dimension _width{0};
+    Dimension _height{0};
+    Dimension _positionX{0};
+    Dimension _positionY{0};
+    std::string _path{""};
+    std::string _mask{""};
+    std::vector<double> transform_;
+    int _clipRule{0};
+    float pointScaleFactor_{0};
+    bool _isGeneratedPixelMap{false}; //防止快照生成多次，导致性能影响
+};
+
+} // namespace svg
+} // namespace rnoh
+#endif // HARMONY_SVGFOREIGNOBJECTNODE_H

package/harmony/svg/src/main/cpp/SvgForeignObjectNodeDelegate.h

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2025 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.
+ *
+ * This file incorporates from the OpenHarmony project, licensed under
+ * the Apache License, Version 2.0. Specifically:
+ * - [OpenHarmony/arkui_ace_engine] (https://gitee.com/openharmony/arkui_ace_engine)
+ *
+ * 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_SVGFOREIGNOBJECTNODEDELEGATE_H
+#define HARMONY_SVGFOREIGNOBJECTNODEDELEGATE_H
+#include "SvgForeignProps.h"
+class SvgForeignObjectNodeDelegate {
+public:
+    virtual ~SvgForeignObjectNodeDelegate() = default;
+    virtual void onDrawForeignImage(ForeignProps props){};
+};
+#endif //HARMONY_SVGFOREIGNOBJECTNODEDELEGATE_H

package/harmony/svg/src/main/cpp/SvgForeignProps.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2025 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.
+ *
+ * This file incorporates from the OpenHarmony project, licensed under
+ * the Apache License, Version 2.0. Specifically:
+ * - [OpenHarmony/arkui_ace_engine] (https://gitee.com/openharmony/arkui_ace_engine)
+ *
+ * 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_FOREIGNPROPS_H
+#define HARMONY_FOREIGNPROPS_H
+#include "properties/Dimension.h"
+#include <multimedia/image_framework/image/pixelmap_native.h>
+#include <string>
+struct ForeignProps {
+    OH_PixelmapNative *foreignPixelMap{nullptr};
+    rnoh::svg::Dimension width;
+    rnoh::svg::Dimension height;
+    rnoh::svg::Dimension x;
+    rnoh::svg::Dimension y;
+    std::string path;
+    int clipRule;
+    std::string mask;
+    float pointScaleFactor;
+    std::vector<double> transform;
+};
+#endif //HARMONY_FOREIGNPROPS_H

package/harmony/svg/src/main/cpp/SvgGradient.cpp

@@ -70,6 +70,7 @@ void SvgGradient::SetAttrRy(const std::string& ry) {
 
 void SvgGradient::SetAttrGradient(std::vector<Float> gradient) {
     auto stopCount = gradient.size() / 2;
+    gradientAttr_.gradient.ClearColors();
     for (auto i = 0; i < stopCount; i++) {
         auto stopIndex = i * 2;
         GradientColor gradientColor;

package/harmony/svg/src/main/cpp/SvgGroup.cpp

@@ -6,6 +6,7 @@
 
 #include "SvgGroup.h"
 #include "SvgFilter.h"
+#include "drawing/Brush.h"
 
 namespace rnoh {
 namespace svg {
@@ -30,7 +31,13 @@ void SvgGroup::OnInitStyle() {
 }
 
 void SvgGroup::OnDraw(OH_Drawing_Canvas *canvas) {
-    OnDrawTraversed(canvas);
+    if (attributes_.selfOpacity < 1.0) {
+        drawing::Brush layerBrush;
+        uint8_t alpha= static_cast<uint8_t>(attributes_.selfOpacity* 255);
+        layerBrush.SetAlpha(alpha);
+        OH_Drawing_CanvasSaveLayer(canvas, nullptr, layerBrush.get());
+    }
+    SvgNode::OnDraw(canvas);
 }
 
 void SvgGroup::ApplyFilterToChildren(std::shared_ptr<SvgFilter> filter) {

package/harmony/svg/src/main/cpp/SvgNode.cpp

@@ -23,11 +23,13 @@
 #include "utils/SvgUtils.h"
 #include "SvgGradient.h"
 #include "SvgPattern.h"
+#include "properties/ViewBox.h"
 #include "SvgFilter.h"
 #include <native_drawing/drawing_matrix.h>
 #include <native_drawing/drawing_path.h>
 #include <regex>
 #include <string>
+#include <native_drawing/drawing_pixel_map.h>
 
 namespace rnoh {
 namespace svg {
@@ -75,6 +77,7 @@ void SvgNode::InitStyle(const SvgBaseAttribute &attr) {
             }
         }
     }
+    OnInitStyle();
     if (passStyle_) {
         for (auto &node : children_) {
             if (node) {
@@ -138,9 +141,8 @@ void SvgNode::OnMask(OH_Drawing_Canvas *canvas) {
     refMask->Draw(canvas);
 }
 
-void SvgNode::OnTransform(OH_Drawing_Canvas *canvas) {
+void SvgNode::OnTransform(OH_Drawing_Canvas *canvas, std::vector<double> transform) {
     // input transfrom: (float scaleX, float skewY, float skewX, float scaleY, float transX, float transY)
-    const auto &transform = attributes_.transform;
     /* (OH_Drawing_Matrix* , float scaleX, float skewX, float transX, float skewY, float scaleY, float transY, float
     persp0, float persp1, float persp2 )
     */
@@ -189,7 +191,7 @@ void SvgNode::Draw(OH_Drawing_Canvas *canvas) {
     const auto count = OH_Drawing_CanvasGetSaveCount(canvas);
     OH_Drawing_CanvasSave(canvas);
     if (!attributes_.transform.empty()) {
-        OnTransform(canvas);
+        OnTransform(canvas, attributes_.transform);
     }
     if (!hrefClipPath_.empty()) {
         OnClipPath(canvas);
@@ -204,6 +206,13 @@ void SvgNode::Draw(OH_Drawing_Canvas *canvas) {
     // on marker
 
     OnDrawTraversed(canvas);
+    
+    if (_foreignPropsArray.size() > 0) {
+        for (ForeignProps _foreignProps : _foreignPropsArray) {
+            DrawForeignPixelMap(canvas, _foreignProps);
+        }
+        _foreignPropsArray.clear();
+    }
     OH_Drawing_CanvasRestoreToCount(canvas, count);
 }
 
@@ -285,5 +294,102 @@ double SvgNode::getCanvasDiagonal() {
     canvasDiagonal_ = sqrt(powX + powY) * M_SQRT1_2l;
     return canvasDiagonal_;
 }
+
+void SvgNode::DrawForeignClip(OH_Drawing_Canvas *canvas,const std::string &id,int clipRule) {
+    if (!context_) {
+        DLOG(INFO) << "[svgForeignNode] NO CONTEXT";
+        return;
+    }
+    auto refSvgNode = context_->GetSvgNodeById(id);
+    if (!refSvgNode) {
+        DLOG(WARNING) << "[svgForeignNode] clipPath: SvgNode is null!";
+        return;
+    };
+    auto clipPath = refSvgNode->AsPath();
+    drawing::Path::FillType fillType = clipRule == 0
+                                           ? OH_Drawing_PathFillType::PATH_FILL_TYPE_EVEN_ODD
+                                           : OH_Drawing_PathFillType::PATH_FILL_TYPE_WINDING;
+    clipPath.SetFillType(fillType);
+    OH_Drawing_CanvasClipPath(canvas, clipPath.get(), OH_Drawing_CanvasClipOp::INTERSECT, true);
+}
+
+void SvgNode::DrawForeignMask(OH_Drawing_Canvas *canvas, const std::string &id) {
+    if (!context_) {
+        DLOG(INFO) << "[svgForeignNode] NO CONTEXT";
+        return;
+    }
+    auto refMask = context_->GetSvgNodeById(id);
+    if (!refMask) {
+        return;
+    };
+    refMask->Draw(canvas);
+}
+
+void SvgNode::DrawForeignPixelMap(OH_Drawing_Canvas *canvas, ForeignProps _foreignProps) {
+    if (!_foreignProps.foreignPixelMap) {
+        DLOG(INFO) << "[svgForeignNode] foreignPixelMap is null";
+        return;
+    }
+    if (!_foreignProps.transform.empty()) {
+        OnTransform(canvas, _foreignProps.transform);
+    }
+    if (!_foreignProps.path.empty()) {
+        DrawForeignClip(canvas,_foreignProps.path, _foreignProps.clipRule);
+    }
+    
+    if (!_foreignProps.mask.empty()) {
+        DrawForeignMask(canvas,_foreignProps.mask);
+    }
+    double postionX = _foreignProps.x.ParsePropsToPx(OH_Drawing_CanvasGetWidth(canvas), _foreignProps.pointScaleFactor);
+    double postionY = _foreignProps.y.ParsePropsToPx(OH_Drawing_CanvasGetHeight(canvas), _foreignProps.pointScaleFactor);
+    double foreignW = _foreignProps.width.ParsePropsToPx(OH_Drawing_CanvasGetWidth(canvas), _foreignProps.pointScaleFactor);
+    double foreignH = _foreignProps.height.ParsePropsToPx(OH_Drawing_CanvasGetHeight(canvas), _foreignProps.pointScaleFactor);
+    OH_Pixelmap_ImageInfo *imageInfo;
+    OH_PixelmapImageInfo_Create(&imageInfo);
+
+    OH_PixelmapNative_GetImageInfo(_foreignProps.foreignPixelMap, imageInfo);
+    uint32_t originalWidth = 0, originalHeight = 0;
+    OH_PixelmapImageInfo_GetWidth(imageInfo, &originalWidth);
+    OH_PixelmapImageInfo_GetHeight(imageInfo, &originalHeight);
+    OH_PixelmapImageInfo_Release(imageInfo);
+
+    if (originalWidth == 0 || originalHeight == 0) {
+        DLOG(WARNING) << "[svgForeignNode] Invalid pixelmap size";
+        OH_PixelmapNative_Release(_foreignProps.foreignPixelMap);
+        return;
+    }
+    float  originalRelWidth  = originalWidth > foreignW ? foreignW : originalWidth;
+    float  originalRelHeight  = originalHeight > foreignH ? foreignH : originalHeight;
+    DLOG(INFO) << "[svgForeignNode] DrawForeignPixelMap start , foreignH:" << foreignH << ";originalHeight:" << originalHeight <<";originalRelHeight:" << originalRelHeight;
+    OH_Drawing_PixelMap *ohPixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(_foreignProps.foreignPixelMap);
+    if (!ohPixelMap) {
+        DLOG(WARNING) << "[svgForeignNode] Failed to get OH_Drawing_PixelMap";
+        OH_PixelmapNative_Release(_foreignProps.foreignPixelMap);
+        return;
+    }
+
+    OH_Drawing_CanvasSave(canvas);
+
+    OH_Drawing_CanvasTranslate(canvas, postionX, postionY);
+    
+    OH_Drawing_CanvasScale(canvas, 1, 1);
+
+    OH_Drawing_Rect *srcRect = OH_Drawing_RectCreate(0, 0, originalRelWidth, originalRelHeight);
+    OH_Drawing_Rect *dstRect = OH_Drawing_RectCreate(0, 0, originalRelWidth, originalRelHeight);
+    OH_Drawing_SamplingOptions *sampling = OH_Drawing_SamplingOptionsCreate(FILTER_MODE_LINEAR, MIPMAP_MODE_LINEAR);
+    OH_Drawing_CanvasDrawPixelMapRect(canvas, ohPixelMap, srcRect, dstRect, sampling);
+
+
+    OH_Drawing_CanvasRestore(canvas);
+    OH_Drawing_PixelMapDissolve(ohPixelMap);
+    OH_PixelmapNative_Release(_foreignProps.foreignPixelMap);
+    OH_Drawing_RectDestroy(srcRect);
+    OH_Drawing_RectDestroy(dstRect);
+    OH_Drawing_SamplingOptionsDestroy(sampling);
+
+    _foreignProps.foreignPixelMap = nullptr;
+    DLOG(INFO) << "[svgForeignNode] DrawForeignPixelMap end";
+}
+
 } // namespace svg
 } // namespace rnoh