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

package/harmony/svg/build/default/cache/default/default@PackageHar/src/main/cpp/SvgNode.h

@@ -1,377 +0,0 @@
-/*
- * 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 "SvgForeignProps.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 <multimedia/image_framework/image/pixelmap_native.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) {
-                int strokeType = props->stroke["type"].asInt();
-                if (strokeType == INHERIT_TYPE) {
-                    if (props->stroke.count("payload") > 0) {
-                        Color color = Color(static_cast<uint32_t>(props->stroke["payload"].asInt()));
-                        color.SetUseCurrentColor(true);
-                        attributes_.strokeState.SetColor(color, true);
-                    } else {
-                        if (props->color) {
-                            Color color = Color(*props->color);
-                            color.SetUseCurrentColor(true);
-                            attributes_.strokeState.SetColor(color, true);
-                        } else {
-                            Color color = Color::TRANSPARENT;
-                            color.SetUseCurrentColor(true);
-                            attributes_.strokeState.SetColor(color, true);
-                        }
-                    }
-                } else {
-                    if (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 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()) {
-            if(context_) {
-                attributes_.strokeState.SetColor(context_->GetSvgColor(), true);
-            }
-        }
-        if (attributes_.fillState.GetColor().IsUseCurrentColor()) {
-            if(context_) {
-                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();
-
-    void SetForeignObject(ForeignProps foreignProps) {
-        _foreignPropsArray.emplace_back(foreignProps);
-    }
-    
-
-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, std::vector<double> transform);
-
-    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 DrawForeignPixelMap(OH_Drawing_Canvas *canvas,ForeignProps _foreignProps);
-    void DrawForeignMask(OH_Drawing_Canvas *canvas, const std::string &id);
-    void DrawForeignClip(OH_Drawing_Canvas *canvas, const std::string &id, int clipRule);
-    
-    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;
-
-    std::vector<ForeignProps> _foreignPropsArray;
-};
-
-} // namespace svg
-} // namespace rnoh

package/harmony/svg/build/default/cache/default/default@PackageHar/src/main/cpp/SvgPath.cpp

@@ -1,42 +0,0 @@
-/*
- * 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/build/default/cache/default/default@PackageHar/src/main/cpp/SvgPath.h

@@ -1,29 +0,0 @@
-/*
- * 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/build/default/cache/default/default@PackageHar/src/main/cpp/SvgPattern.cpp

@@ -1,77 +0,0 @@
-/*
- * 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/build/default/cache/default/default@PackageHar/src/main/cpp/SvgPattern.h

@@ -1,64 +0,0 @@
-/*
- * 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/build/default/cache/default/default@PackageHar/src/main/cpp/SvgQuote.h

@@ -1,87 +0,0 @@
-/*
- * 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