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

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

@@ -0,0 +1,347 @@
+/*
+ * 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.
+ *
+ * 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.
+ */
+
+// from ArkUI "frameworks/core/components_ng/svg/parse/svg_node.h"
+#pragma once
+
+#include <memory>
+#include <vector>
+#include <unordered_set>
+#include <type_traits>
+#include "SvgBaseAttribute.h"
+#include "SvgContext.h"
+#include "properties/Decoration.h"
+#include "properties/Dimension.h"
+#include "properties/Size.h"
+#include <react/renderer/components/react_native_svg/Props.h>
+#include "drawing/Path.h"
+#include "utils/StringUtils.h"
+#include "utils/SvgAttributesParser.h"
+#include <glog/logging.h>
+#include <native_drawing/drawing_canvas.h>
+#include <native_drawing/drawing_rect.h>
+#include "utils/DynamicUtils.h"
+
+namespace rnoh {
+namespace svg {
+
+constexpr int INHERIT_TYPE = 2;
+
+class SvgNode : public std::enable_shared_from_this<SvgNode> {
+public:
+    SvgNode() = default;
+    virtual ~SvgNode() = default;
+
+    std::shared_ptr<SvgContext> GetContext() { return context_; }
+    void SetContext(std::shared_ptr<SvgContext> context) { context_ = context; }
+
+    void ContextTraversal();
+    void InitStyle(const SvgBaseAttribute &attr);
+
+    virtual void Draw(OH_Drawing_Canvas *canvas);
+
+    virtual drawing::Path AsPath() {
+        DLOG(INFO) << "[SVGNode] AsPath";
+        return drawing::Path();
+    };
+
+    SvgBaseAttribute GetBaseAttributes() const { return attributes_; }
+
+    void SetBaseAttributes(const SvgBaseAttribute &attr) { attributes_ = attr; }
+
+    virtual void AppendChild(const std::shared_ptr<SvgNode> &child) { children_.emplace_back(child); }
+
+    virtual void removeChild(const std::shared_ptr<SvgNode> &child) {
+        auto it = std::find(children_.begin(), children_.end(), child);
+        if (it != children_.end()) {
+            children_.erase(it);
+        }
+    }
+
+    template <typename ConcreteProps> void UpdateHrefRenderProps(const std::shared_ptr<ConcreteProps> &props, bool inherit = false) {
+        if (!props) {
+            return;
+        }
+        
+        if (inherit) {
+            attributes_.hasInheritedFilter = true;
+        }
+        // Check which properties are available and update them
+        std::unordered_set<std::string> propSet;
+        if constexpr (requires { props->propList; }) {
+            propSet.insert(props->propList.begin(), props->propList.end());
+        }
+        
+        // Always set name and display if available
+        if constexpr (requires { props->name; }) {
+            attributes_.id = props->name;
+        }
+        if constexpr (requires { props->display; }) {
+            display_ = props->display != "none";
+        }
+
+        if (hrefRender_) {
+            // Only access properties that exist in this Props type
+            if constexpr (requires { props->matrix; }) {
+                attributes_.transform = props->matrix;
+            }
+            if constexpr (requires { props->mask; }) {
+                attributes_.maskId = props->mask;
+            }
+            if constexpr (requires { props->filter; } &&
+                        std::is_same_v<std::decay_t<decltype(props->filter)>, std::string>) {
+                    attributes_.filterId = props->filter;
+                    attributes_.hasInheritedFilter = inherit;
+            }
+            if constexpr (requires { props->opacity; }) {
+                attributes_.selfOpacity = props->opacity;
+            }
+            if constexpr (requires { props->markerStart; }) {
+                attributes_.markerStart = props->markerStart;
+            }
+            if constexpr (requires { props->markerMid; }) {
+                attributes_.markerMid = props->markerMid;
+            }
+            if constexpr (requires { props->markerEnd; }) {
+                attributes_.markerEnd = props->markerEnd;
+            }
+            if constexpr (requires { props->clipPath; }) {
+                if (!props->clipPath.empty()) {
+                    attributes_.clipPath = props->clipPath;
+                    hrefClipPath_ = props->clipPath;
+                }
+            }
+        }
+    }
+
+    template <typename ConcreteProps> void UpdateCommonProps(const std::shared_ptr<ConcreteProps> &props, bool inherit = false) {
+        UpdateHrefRenderProps(props, inherit);
+        std::unordered_set<std::string> set;
+        if constexpr (requires { props->propList; }) {
+            for (const auto &prop : props->propList) {
+                set.insert(prop);
+            }
+        }
+
+        // Handle fill properties - support both generic and text-specific structures
+        if constexpr (requires { props->fill; }) {
+            if (!props->fill.isNull() && props->fill.count("type") > 0 && props->fill.count("payload") > 0) {
+                int fillType = props->fill["type"].asInt();
+                if (fillType == INHERIT_TYPE) {
+                    Color color = Color(static_cast<uint32_t>(props->fill["payload"].asInt()));
+                    color.SetUseCurrentColor(true);
+                    attributes_.fillState.SetColor(color, true);
+                } else {
+                    uint32_t colorValue = static_cast<uint32_t>(props->fill["payload"].asInt());
+                    if (facebook::react::isColorMeaningful(facebook::react::SharedColor(colorValue))) {
+                        attributes_.fillState.SetColor(Color(colorValue), set.count("fill"));
+                    } else {
+                        attributes_.fillState.SetColor(Color::TRANSPARENT, set.count("fill"));
+                    }
+                }
+            } else if (!props->fill.isNull() && props->fill.count("payload") > 0) {
+                uint32_t colorValue = static_cast<uint32_t>(props->fill["payload"].asInt());
+                if (facebook::react::isColorMeaningful(facebook::react::SharedColor(colorValue))) {
+                    attributes_.fillState.SetColor(Color(colorValue), set.count("fill"));
+                } else {
+                    attributes_.fillState.SetColor(Color::TRANSPARENT, set.count("fill"));
+                }
+            } else {
+                attributes_.fillState.SetColor(Color::TRANSPARENT, set.count("fill"));
+            }
+            if (!props->fill.isNull() && props->fill.count("brushRef") > 0) {
+                attributes_.fillState.SetHref(props->fill["brushRef"].asString());
+            }
+        }
+
+        // Handle stroke properties - support both generic and text-specific structures
+        if constexpr (requires { props->stroke; }) {
+            if (!props->stroke.isNull() && props->stroke.count("type") > 0 && props->stroke.count("payload") > 0) {
+                int strokeType = props->stroke["type"].asInt();
+                if (strokeType == INHERIT_TYPE) {
+                    Color color = Color(static_cast<uint32_t>(props->stroke["payload"].asInt()));
+                    color.SetUseCurrentColor(true);
+                    attributes_.strokeState.SetColor(color, true);
+                } else {
+                    uint32_t colorValue = static_cast<uint32_t>(props->stroke["payload"].asInt());
+                    if (facebook::react::isColorMeaningful(facebook::react::SharedColor(colorValue))) {
+                        attributes_.strokeState.SetColor(Color(colorValue), set.count("stroke"));
+                    } else {
+                        attributes_.strokeState.SetColor(Color::TRANSPARENT, set.count("stroke"));
+                    }
+                }
+            } else if (!props->stroke.isNull() && props->stroke.count("payload") > 0) {
+                uint32_t colorValue = static_cast<uint32_t>(props->stroke["payload"].asInt());
+                if (facebook::react::isColorMeaningful(facebook::react::SharedColor(colorValue))) {
+                    attributes_.strokeState.SetColor(Color(colorValue), set.count("stroke"));
+                } else {
+                    attributes_.strokeState.SetColor(Color::TRANSPARENT, set.count("stroke"));
+                }
+            } else {
+                attributes_.strokeState.SetColor(Color::TRANSPARENT, set.count("stroke"));
+            }
+            if (!props->stroke.isNull() && props->stroke.count("brushRef") > 0) {
+                attributes_.strokeState.SetHref(props->stroke["brushRef"].asString());
+            }
+        }
+
+        if constexpr (requires { props->fillOpacity; }) {
+            attributes_.fillState.SetOpacity(std::clamp(props->fillOpacity, 0.0, 1.0), true);
+        }
+        if constexpr (requires { props->fillRule; }) {
+            attributes_.fillState.SetFillRule(static_cast<FillState::FillRule>(props->fillRule), true);
+        }
+        if constexpr (requires { props->strokeWidth; }) {
+            bool hasStrokeWidthInPropList = set.count("strokeWidth") > 0;
+            if (hasStrokeWidthInPropList) {
+                attributes_.strokeState.SetLineWidth(StringUtils::StringToDouble(DynamicUtils::DynamicToString(props->strokeWidth)) * scale_, true);
+            }
+        }
+        if constexpr (requires { props->strokeDasharray; }) {
+            attributes_.strokeState.SetStrokeDashArray(
+                StringUtils::stringVectorToDoubleVector(DynamicUtils::DynamicToStringVector(props->strokeDasharray), scale_), set.count("strokeDasharray"));
+        }
+        if constexpr (requires { props->strokeDashoffset; }) {
+            attributes_.strokeState.SetStrokeDashOffset(props->strokeDashoffset * scale_, set.count("strokeDashoffset"));
+        }
+        if constexpr (requires { props->strokeLinecap; }) {
+            attributes_.strokeState.SetLineCap(SvgAttributesParser::GetLineCapStyle(std::to_string(props->strokeLinecap)), set.count("strokeLinecap"));
+        }
+        if constexpr (requires { props->strokeLinejoin; }) {
+            attributes_.strokeState.SetLineJoin(
+                SvgAttributesParser::GetLineJoinStyle(std::to_string(props->strokeLinejoin)), set.count("strokeLinejoin"));
+        }
+        if constexpr (requires { props->vectorEffect; }) {
+            attributes_.strokeState.SetVectorEffect(props->vectorEffect);
+        }
+        if constexpr (requires { props->strokeMiterlimit; }) {
+            auto limit = props->strokeMiterlimit * scale_;
+            if (GreatOrEqual(limit, 1.0)) {
+                attributes_.strokeState.SetMiterLimit(limit, set.count("strokeMiterlimit"));
+            }
+        }
+        if constexpr (requires { props->strokeOpacity; }) {
+            attributes_.strokeState.SetOpacity(std::clamp(props->strokeOpacity, 0.0, 1.0), set.count("strokeOpacity"));
+        }
+        if constexpr (requires { props->clipRule; }) {
+            attributes_.clipState.SetClipRule(static_cast<ClipState::ClipRule>(props->clipRule), true);
+        }
+    }
+
+    virtual Rect AsBounds();
+
+    void SetScale(const double &scale) { scale_ = scale; }
+
+    double GetScale() const { return scale_; }
+
+    void InheritAttr(const SvgBaseAttribute &parent) {
+        attributes_.Inherit(parent);
+        // svg color -> current color
+        if (attributes_.strokeState.GetColor().IsUseCurrentColor()) {
+            attributes_.strokeState.SetColor(context_->GetSvgColor(), true);
+        }
+        if (attributes_.fillState.GetColor().IsUseCurrentColor()) {
+            attributes_.fillState.SetColor(context_->GetSvgColor(), true);
+        }
+    }
+
+    void InheritUseAttr(const SvgBaseAttribute &parent) { attributes_.InheritFromUse(parent); }
+
+    drawing::Matrix lastCanvasMatrix_;
+
+    double relativeOnWidth(Dimension length);
+    double relativeOnHeight(Dimension length);
+    double relativeOnOther(Dimension length);
+
+    double getCanvasWidth();
+    double getCanvasHeight();
+    double getCanvasDiagonal();
+
+protected:
+    // override as need by derived class
+    // called by function AppendChild
+    virtual void OnAppendChild(const std::shared_ptr<SvgNode> &child) {}
+    // called by function InitStyle
+    virtual void OnInitStyle() {}
+
+    virtual void OnDraw(OH_Drawing_Canvas *canvas) {}
+    virtual void OnDrawTraversed(OH_Drawing_Canvas *canvas);
+    void OnClipPath(OH_Drawing_Canvas *canvas);
+    void OnMask(OH_Drawing_Canvas *canvas);
+    void OnTransform(OH_Drawing_Canvas *canvas);
+
+    const Rect &GetRootViewBox() const;
+
+    void SetSmoothEdge(float edge) { attributes_.smoothEdge = edge; }
+    float GetSmoothEdge() const { return attributes_.smoothEdge; }
+
+    std::optional<Gradient> GetGradient(const std::string &href);
+
+    std::shared_ptr<PatternAttr> GetPatternAttr(const std::string &href);
+
+    void InitNoneFlag() {
+        hrefFill_ = false;
+        hrefRender_ = false;
+        passStyle_ = false;
+        inheritStyle_ = false;
+        drawTraversed_ = false;
+    }
+
+    SvgBaseAttribute attributes_;
+
+    std::shared_ptr<SvgContext> context_;
+
+    std::vector<std::shared_ptr<SvgNode>> children_;
+
+    std::string hrefClipPath_;
+    std::string imagePath_;
+
+    double scale_ = 3.25;
+
+    drawing::Matrix cTM_;
+
+    bool display_ = true;
+
+    bool hrefFill_ = true;      // get fill attributes from reference
+    bool hrefRender_ = true;    // get render attr (mask, filter, transform, opacity,
+                                // clip path) from reference
+    bool passStyle_ = false;     // pass style attributes to child node, TAGS
+                                // circle/path/line/... = false
+    bool inheritStyle_ = true;  // inherit style attributes from parent node, TAGS
+                                // mask/defs/pattern/filter = false
+    bool drawTraversed_ = true; // enable OnDraw, TAGS mask/defs/pattern/filter = false
+
+    double canvasHeight_ = -1;
+
+    double canvasWidth_ = -1;
+
+    double canvasDiagonal_ = -1;
+
+    /*
+      N[1/Sqrt[2], 36]
+      The inverse of the square root of 2.
+      Provide enough digits for the 128-bit IEEE quad (36 significant digits).
+  */
+    const double M_SQRT1_2l = 0.707106781186547524400844362104849039;
+};
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SvgPath.h"
+#include "utils/PathParserUtils.h"
+#include <native_drawing/drawing_matrix.h>
+#include "utils/PathParserUtils.h"
+
+namespace rnoh {
+namespace svg {
+
+void SvgPath::setD(const std::string &d) {
+    d_ = d;
+    PathParserUtils parser;
+    parser.mScale = scale_;
+    try {
+        path_ = std::move(parser.parse(d.c_str()));
+    } catch (const std::runtime_error &e) {
+        LOG(ERROR) << "[svgPath] Svg path d invalid, error message: " << e.what();
+        return;
+    }
+    elements_ = std::move(parser.elements);
+    for (PathElement &elem : elements_) {
+        for (Point &point : elem.points) {
+            point.x *= scale_;
+            point.y *= scale_;
+        }
+    }
+}
+
+drawing::Path SvgPath::AsPath() {
+    if (path_.get()) {
+        return path_;
+    }
+    return drawing::Path();
+}
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,29 @@
+/*
+ * 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 "SvgGraphic.h"
+
+namespace rnoh {
+namespace svg {
+
+class SvgPath : public SvgGraphic {
+private:
+    std::string d_;
+    drawing::Path path_{};
+
+public:
+    SvgPath() = default;
+    ~SvgPath() override = default;
+
+    void setD(const std::string &d);
+
+    drawing::Path AsPath() override;
+};
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SvgPattern.h"
+
+namespace rnoh {
+namespace svg {
+
+constexpr size_t PATTERN_TRANSFORM_MATRIX_SIZE = 6;
+constexpr int TRANSFORM_SCALE_X_INDEX = 0;
+constexpr int TRANSFORM_SKEW_Y_INDEX = 1;
+constexpr int TRANSFORM_SKEW_X_INDEX = 2;
+constexpr int TRANSFORM_SCALE_Y_INDEX = 3;
+constexpr int TRANSFORM_TRANSLATE_X_INDEX = 4;
+constexpr int TRANSFORM_TRANSLATE_Y_INDEX = 5;
+
+SvgPattern::SvgPattern() { DLOG(INFO) << "[SvgPattern] init"; }
+
+void SvgPattern::OnDrawTraversedBefore(OH_Drawing_Canvas *canvas) {
+    DLOG(INFO) << "[pattern] OnDrawTraversedBefore";
+}
+
+void SvgPattern::OnDrawTraversedAfter(OH_Drawing_Canvas *canvas) { DLOG(INFO) << "[pattern] OnDrawTraversedAfter"; }
+
+std::shared_ptr<PatternAttr> SvgPattern::GetPatternAttr() { return patternAttr; }
+
+void SvgPattern::setPatternX(Dimension x) { patternAttr->setPatternX(x); }
+
+void SvgPattern::setPatternY(Dimension y) { patternAttr->setPatternY(y); }
+
+void SvgPattern::setHeight(Dimension height) { patternAttr->setHeight(height); }
+
+void SvgPattern::setWidth(Dimension width) { patternAttr->setWidth(width); }
+
+void SvgPattern::setPatternContentUnits(int patternContentUnits) {
+    patternAttr->setPatternContentUnits(patternContentUnits);
+}
+
+void SvgPattern::setPatternUnits(int patternUnits) { patternAttr->setPatternUnits(patternUnits); }
+
+
+void SvgPattern::setViewBox(Rect viewBox) { patternAttr->setViewBox(viewBox); }
+
+void SvgPattern::setmMinX(float mMinX) { patternAttr->setmMinX(mMinX); }
+
+void SvgPattern::setmMinY(float mMinY) { patternAttr->setmMinY(mMinY); }
+
+void SvgPattern::setmVbWidth(float mVbWidth) { patternAttr->setmVbWidth(mVbWidth); }
+
+void SvgPattern::setmVbHeight(float mVbHeight) { patternAttr->setmVbHeight(mVbHeight); }
+
+void SvgPattern::setmAlign(std::string mAlign) { patternAttr->setmAlign(mAlign); }
+
+void SvgPattern::setmMeetOrSlice(int mMeetOrSlice) { patternAttr->setmMeetOrSlice(mMeetOrSlice); }
+
+void SvgPattern::setPatternTransforms(std::vector<Float> patternTransforms) {
+    std::vector<Float> newMatrix{
+        1, 0, 0, 0, 1, 0, 0, 0, 1,
+    };
+    if (patternTransforms.size() == PATTERN_TRANSFORM_MATRIX_SIZE) {
+        newMatrix[0] = (Float)patternTransforms[TRANSFORM_SCALE_X_INDEX];
+        newMatrix[1] = (Float)patternTransforms[TRANSFORM_SKEW_X_INDEX];
+        newMatrix[2] = (Float)patternTransforms[TRANSFORM_TRANSLATE_X_INDEX] * scale_;
+        newMatrix[3] = (Float)patternTransforms[TRANSFORM_SKEW_Y_INDEX];
+        newMatrix[4] = (Float)patternTransforms[TRANSFORM_SCALE_Y_INDEX];
+        newMatrix[5] = (Float)patternTransforms[TRANSFORM_TRANSLATE_Y_INDEX] * scale_;
+        patternAttr->setPatternTransform(std::move(newMatrix));
+    }
+}
+
+void SvgPattern::setImage(OH_Drawing_Image *image) { patternAttr->setImage(image); }
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,64 @@
+/*
+ * 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 <string>
+#include "SvgQuote.h"
+#include "utils/SvgAttributesParser.h"
+
+namespace rnoh {
+namespace svg {
+
+class SvgPattern : public SvgQuote {
+
+public:
+    using Float = facebook::react::Float;
+    SvgPattern();
+    ~SvgPattern() override = default;
+    
+    void OnDrawTraversedBefore(OH_Drawing_Canvas *canvas) override;
+    void OnDrawTraversedAfter(OH_Drawing_Canvas *canvas) override;
+    void SaveDefinition(OH_Drawing_Canvas *canvas);
+    void ConcatMatrix(OH_Drawing_Canvas *canvas);
+    std::shared_ptr<PatternAttr> GetPatternAttr();
+
+    void setPatternX(Dimension x);
+
+    void setPatternY(Dimension y);
+
+    void setHeight(Dimension height);
+
+    void setWidth(Dimension width);
+
+    void setPatternUnits(int patternUnits);
+
+    void setPatternContentUnits(int patternContentUnits);
+
+    void setViewBox(Rect viewBox);
+
+    void setImage(OH_Drawing_Image *image);
+
+    void setmMinX(float mMinX);
+
+    void setmMinY(float mMinUY);
+
+    void setmVbWidth(float mVbWidth);
+
+    void setmVbHeight(float mVbHeight);
+
+    void setmAlign(std::string mAlign);
+
+    void setmMeetOrSlice(int mMeetOrSlice);
+
+    void setPatternTransforms(std::vector<Float> gradientTransforms);
+private:
+    std::shared_ptr<PatternAttr> patternAttr = std::make_shared<PatternAttr>();
+    double scale_ = 3.25010318;
+  };
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,87 @@
+/*
+ * 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.
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include "SvgNode.h"
+#include <native_drawing/drawing_path.h>
+
+namespace rnoh {
+namespace svg {
+
+class SvgQuote : public SvgNode {
+public:
+    SvgQuote() : SvgNode() { InitHrefFlag(); }
+    ~SvgQuote() override = default;
+
+    drawing::Path getClipPath(drawing::Path path) {
+        DLOG(INFO) << "[SvgQuote] getClipPath";
+        for (const auto &child : children_) {
+            auto childPath = child->AsPath();
+            path.AddPath(childPath);
+        }
+        return path;
+    }
+
+    drawing::Path getClipPath(drawing::Path path, drawing::Path::OpMode op) {
+        DLOG(INFO) << "[SvgQuote] getClipPath with op, op = " << op;
+        for (const auto &child : children_) {
+            auto childPath = child->AsPath();
+            path.Op(childPath, op);
+        }
+        return path;
+    }
+
+    drawing::Path AsPath() override {
+        DLOG(INFO) << "[SvgQuote] AsPath";
+        drawing::Path path;
+
+        if (attributes_.clipState.IsEvenodd()) {
+            return getClipPath(path);
+        } else {
+            return getClipPath(path, drawing::Path::OpMode::PATH_OP_MODE_UNION);
+        }
+    }
+
+    void Draw(OH_Drawing_Canvas *canvas) override {
+        // render composition on other svg tags
+        DLOG(INFO) << "[SvgQuote] Draw";
+        OnDrawTraversedBefore(canvas);
+        OnDrawTraversed(canvas);
+        OnDrawTraversedAfter(canvas);
+    }
+
+protected:
+    virtual void OnDrawTraversedBefore(OH_Drawing_Canvas *canvas) {}
+    virtual void OnDrawTraversedAfter(OH_Drawing_Canvas *canvas) {}
+
+    // mask/pattern/filter/clipPath
+    void InitHrefFlag() {
+        hrefFill_ = true;
+        hrefRender_ = false;
+        passStyle_ = true;
+        inheritStyle_ = false;
+        drawTraversed_ = false;
+    }
+};
+
+} // namespace svg
+} // namespace rnoh