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

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

@@ -0,0 +1,35 @@
+/*
+ * 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 "SvgTextPath.h"
+#include "SvgTSpan.h"
+
+namespace rnoh {
+namespace svg {
+
+void SvgTextPath::OnDraw(OH_Drawing_Canvas *canvas) {
+    if (!glyphCtx_) {
+        InitGlyph(canvas, scale_);
+    }
+    for (auto const &child : children_) {
+        if (auto tSpan = std::dynamic_pointer_cast<SvgTSpan>(child)) {
+            tSpan->SetGlyphContext(glyphCtx_);
+            tSpan->SetTextPathRef(std::dynamic_pointer_cast<SvgTextPath>(shared_from_this()));
+        }
+    }
+}
+
+drawing::Path SvgTextPath::getTextPath() {
+    auto node = context_->GetSvgNodeById(href_);
+    if (node) {
+        return node->AsPath();
+    }
+    DLOG(INFO) << "TEXT_PATH ref node missing, href = " << href_;
+    return drawing::Path();
+}
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,51 @@
+/*
+ * 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 "SvgGroup.h"
+#include "SvgText.h"
+#include <native_drawing/drawing_text_typography.h>
+#include "utils/GlyphContext.h"
+#include "properties/Font.h"
+#include "TextBase.h"
+
+namespace rnoh {
+namespace svg {
+
+class SvgTextPath : public SvgGroup, public TextBase {
+public:
+    SvgTextPath() {
+        hrefFill_ = true;
+        hrefRender_ = true;
+        passStyle_ = true;
+        inheritStyle_ = true;
+        drawTraversed_ = true;
+    }
+    ~SvgTextPath() override = default;
+
+    void OnDraw(OH_Drawing_Canvas *canvas) override;
+
+    void SetContext(std::shared_ptr<GlyphContext> context) { glyphCtx_ = context; }
+
+    drawing::Path getTextPath();
+
+    TextPathMidLine getMidLine() const { return midLine_; }
+
+    TextPathSide getSide() const { return side_; }
+
+    double getStartOffset() const { return startOffset_; }
+
+    TextPathSide side_{TextPathSide::left};
+    TextPathMidLine midLine_{TextPathMidLine::sharp};
+    TextPathMethod method_{TextPathMethod::align};
+    TextPathSpacing spacing_{TextPathSpacing::Exact};
+    double startOffset_;
+    std::string href_;
+};
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,65 @@
+/*
+ * 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 "SvgUse.h"
+
+namespace rnoh {
+namespace svg {
+
+void SvgUse::OnDraw(OH_Drawing_Canvas *canvas) {
+    auto svgContext = GetContext();
+    if (!svgContext) {
+        return;
+    }
+
+    auto refSvgNode = svgContext->GetSvgNodeById(href);
+    if (!refSvgNode) {
+        return;
+    }
+
+    if (x != 0 || y != 0) {
+        OH_Drawing_CanvasTranslate(canvas, x * scale_, y * scale_);
+    }
+
+    AttributeScope scope(refSvgNode);
+    std::shared_ptr<SvgSymbol> svgSymbol = std::dynamic_pointer_cast<SvgSymbol>(refSvgNode);
+
+    refSvgNode->InheritUseAttr(attributes_);
+    if (svgSymbol != nullptr) {
+        svgSymbol->drawSymbol(canvas, width, height);
+    } else {
+        refSvgNode->Draw(canvas);
+    }
+
+    return;
+}
+
+drawing::Path SvgUse::AsPath() {
+    drawing::Path path;
+    auto svgContext = GetContext();
+    if (!svgContext) {
+        return path;
+    }
+    auto refSvgNode = svgContext->GetSvgNodeById(href);
+    if (!refSvgNode) {
+        return path;
+    }
+    path = refSvgNode->AsPath();
+    return path;
+}
+
+SvgUse::AttributeScope::AttributeScope(const std::shared_ptr<SvgNode> &node) : node_(node) {
+    auto nodeAttr = node->GetBaseAttributes();
+    attributes_ = nodeAttr;
+}
+
+SvgUse::AttributeScope::~AttributeScope() {
+    // TODO : check null ptr
+    node_->SetBaseAttributes(attributes_);
+}
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,46 @@
+/*
+ * 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"
+#include <native_drawing/drawing_point.h>
+#include <native_drawing/drawing_canvas.h>
+#include <native_drawing/drawing_path.h>
+#include "SvgSymbol.h"
+
+namespace rnoh {
+namespace svg {
+
+    class SvgUse : public SvgGraphic {
+    public:
+        SvgUse() = default;
+        ~SvgUse() override = default;
+        float x;
+        float y;
+        float width;
+        float height;
+        float opacity;
+        std::string href;
+
+        void OnDraw(OH_Drawing_Canvas *canvas) override;
+    
+        drawing::Path AsPath() override;
+    private:
+        class AttributeScope {
+            public:
+                explicit AttributeScope(const std::shared_ptr<SvgNode>& node);
+                ~AttributeScope();
+
+            private:
+                SvgBaseAttribute attributes_;
+                std::shared_ptr<SvgNode> node_;
+            };
+                // SvgAttributes useAttr_;
+        };
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,36 @@
+/*
+ * 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 "SvgViewManager.h"
+
+namespace rnoh {
+namespace svg {
+void SvgViewManager::setSvgView(int tag, std::weak_ptr<SvgSvg> svg) {
+    mTagToSvgViewMap.insert(std::make_pair(tag, svg));
+}
+
+std::weak_ptr<SvgSvg> SvgViewManager::getSvgViewByTag(int tag) {
+    std::weak_ptr<SvgSvg> svgSvg;
+    auto it = mTagToSvgViewMap.find(tag);
+    if (it != mTagToSvgViewMap.end()) {
+        svgSvg = it->second;
+    }
+    return svgSvg;
+}
+
+void SvgViewManager::onDropView(int tag) {
+    // 将svgview从容器中删除
+    mTagToSvgViewMap.erase(tag);
+}
+
+SvgViewManager::~SvgViewManager() {
+    if (mTagToSvgViewMap.empty() == false) {
+        mTagToSvgViewMap.clear();
+    }
+}
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,37 @@
+/*
+ * 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 <future>
+#include "SvgSvg.h"
+#include <native_drawing/drawing_bitmap.h>
+
+namespace rnoh {
+namespace svg {
+
+class SvgViewManager {
+public:
+    static SvgViewManager &getInstance() {
+        // 单例模式
+        static SvgViewManager instance;
+        return instance;
+    }
+    void setSvgView(int tag, std::weak_ptr<SvgSvg> svg);
+
+    std::weak_ptr<SvgSvg> getSvgViewByTag(int tag);
+
+    void onDropView(int tag);
+
+private:
+    SvgViewManager() {}
+    SvgViewManager(const SvgViewManager &) = delete;
+    SvgViewManager &operator=(const SvgViewManager &) = delete;
+    ~SvgViewManager();
+    std::map<int, std::weak_ptr<SvgSvg>> mTagToSvgViewMap;
+};
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,20 @@
+/*
+ * 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 "TextBase.h"
+#include "drawing/Rect.h"
+
+namespace rnoh {
+namespace svg {
+
+void TextBase::InitGlyph(OH_Drawing_Canvas *canvas, double scale) {
+    drawing::Rect rect;
+    OH_Drawing_CanvasGetLocalClipBounds(canvas, rect.get());
+    glyphCtx_ = std::make_shared<GlyphContext>(scale, rect.GetWidth(), rect.GetHeight());
+}
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,114 @@
+/*
+ * 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 "utils/StringUtils.h"
+#include "utils/GlyphContext.h"
+#include "properties/TextProperties.h"
+#include <native_drawing/drawing_text_typography.h>
+#include <optional>
+
+namespace rnoh {
+namespace svg {
+
+class TextBase {
+public:
+    template <typename T> void UpdateTextProps(const std::shared_ptr<T> &props) {
+        x_.clear();
+        for (auto const &value : props->x) {
+            x_.push_back(StringUtils::FromString(DynamicUtils::DynamicToString(value)));
+        }
+        y_.clear();
+        for (auto const &value : props->y) {
+            y_.push_back(StringUtils::FromString(DynamicUtils::DynamicToString(value)));
+        }
+        dx_.clear();
+        for (auto const &value : props->dx) {
+            dx_.push_back(StringUtils::FromString(DynamicUtils::DynamicToString(value)));
+        }
+        dy_.clear();
+        for (auto const &value : props->dy) {
+            dy_.push_back(StringUtils::FromString(DynamicUtils::DynamicToString(value)));
+        }
+        rotate_.clear();
+        for (auto const &value : props->rotate) {
+            rotate_.push_back(StringUtils::FromString(DynamicUtils::DynamicToString(value)));
+        }
+        if (props->inlineSize.empty()) {
+            inlineSize_.reset();
+        } else {
+            inlineSize_ = StringUtils::FromString(DynamicUtils::DynamicToString(props->inlineSize));
+        }
+
+        if (props->textLength.empty()) {
+            textLength_.reset();
+        } else {
+            textLength_ = StringUtils::FromString(DynamicUtils::DynamicToString(props->textLength));
+        }
+
+        hasBaselineShift_ = false;
+        hasAlign_ = false;
+        if (!props->verticalAlign.empty()) {
+            auto align = DynamicUtils::DynamicToString(props->verticalAlign);
+            align.erase(0, align.find_first_not_of(" \t\r\n"));
+            align.erase(align.find_last_not_of(" \t\r\n") + 1);
+            size_t i = align.find_last_of(' ');
+            align_ = alignmentBaselineFromStr(align.substr(i));
+            baselineShift_ = align.substr(0, i);
+            hasAlign_ = true;
+            hasBaselineShift_ = true;
+        } else {
+            align_ = AlignmentBaseline::baseline;
+            baselineShift_.clear();
+            hasAlign_ = false;
+            hasBaselineShift_ = false;
+        }
+
+        if (!props->baselineShift.empty()) {
+            baselineShift_ = DynamicUtils::DynamicToString(props->baselineShift);
+            hasBaselineShift_ = true;
+        }
+        if (!props->alignmentBaseline.empty()) {
+            align_ = alignmentBaselineFromStr(props->alignmentBaseline);
+            hasAlign_ = true;
+        }
+
+        lengthAdjust_ = textLengthAdjustFromStr(props->lengthAdjust);
+    }
+
+    void SetGlyphContext(const std::shared_ptr<GlyphContext> &ctx) { glyphCtx_ = ctx; }
+    
+    void setAlignmentBaseline(const AlignmentBaseline &alignmentBaseline) { align_ = alignmentBaseline; }
+    
+    bool hasAlignmentBaseline() { return hasAlign_; }
+    
+    void setBaselineShift(const std::string &baselineShift) { baselineShift_ = baselineShift; }
+    
+    bool hasBaselineShift() { return hasBaselineShift_; }
+
+protected:
+    void InitGlyph(OH_Drawing_Canvas *canvas, double scale);
+
+    std::vector<Dimension> x_;
+    std::vector<Dimension> y_;
+    std::vector<Dimension> dx_;
+    std::vector<Dimension> dy_;
+    std::vector<Dimension> rotate_;
+    std::optional<Dimension> inlineSize_;
+    std::optional<Dimension> textLength_;
+
+    std::string baselineShift_;
+    bool hasBaselineShift_ = false;
+    TextLengthAdjust lengthAdjust_ = TextLengthAdjust::spacing;
+    AlignmentBaseline align_ = AlignmentBaseline::baseline;
+    bool hasAlign_ = false;
+
+    std::shared_ptr<GlyphContext> glyphCtx_;
+};
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/cpp/componentInstances/RNSVGBaseComponentInstance.h

@@ -0,0 +1,212 @@
+/*
+ * 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 "RNOH/CppComponentInstance.h"
+#include "SvgArkUINode.h"
+#include "SvgHost.h"
+#include "RNSVGSvgViewComponentInstance.h"
+#include "utils/StringUtils.h"
+#include <glog/logging.h>
+
+#include <type_traits>
+
+namespace rnoh {
+namespace svg {
+
+template <typename T> class RNSVGBaseComponentInstance : public CppComponentInstance<T>, public SvgHost {
+public:
+    RNSVGBaseComponentInstance(ComponentInstance::Context context) : CppComponentInstance<T>(std::move(context)) {}
+    virtual ~RNSVGBaseComponentInstance() = default;
+
+    void onPropsChanged(typename CppComponentInstance<T>::SharedConcreteProps const &props) override {
+        if constexpr (std::is_same_v<decltype(props->pointerEvents), std::string>) {
+            pointerEvents_ = props->pointerEvents.empty() ? "auto" : props->pointerEvents;
+        } else if constexpr (std::is_same_v<decltype(props->pointerEvents), facebook::react::PointerEventsMode>) {
+            pointerEvents_ = convertPointerEventsModeToString(props->pointerEvents);
+        }
+    }
+
+    void onFinalizeUpdates() override {
+        if (GetSvgNode()) {
+            GetSvgNode()->SetScale(CppComponentInstance<T>::m_layoutMetrics.pointScaleFactor);
+        }
+        UpdateElementProps();
+        svgMarkDirty();
+    }
+
+    void onCreate() override {}
+
+    void onChildRemoved(ComponentInstance::Shared const &childComponentInstance) override {
+        CppComponentInstance<T>::onChildRemoved(childComponentInstance);
+        OnChildRemoveCommon(std::dynamic_pointer_cast<SvgHost>(childComponentInstance));
+    }
+
+    void onChildInserted(ComponentInstance::Shared const &childComponentInstance, std::size_t index) override {
+        CppComponentInstance<T>::onChildInserted(childComponentInstance, index);
+        OnChildInsertCommon(std::dynamic_pointer_cast<SvgHost>(childComponentInstance));
+    }
+
+    void setLayout(facebook::react::LayoutMetrics layoutMetrics) override {
+        CppComponentInstance<T>::m_layoutMetrics = layoutMetrics;
+    };
+
+    std::shared_ptr<RNSVGSvgViewComponentInstance> getParentSvgView() const {
+        auto parent = CppComponentInstance<T>::getParent().lock();
+        while (parent) {
+            auto svgView = std::dynamic_pointer_cast<RNSVGSvgViewComponentInstance>(parent);
+            if (svgView) {
+                return svgView;
+            }
+            parent = parent->getParent().lock();
+        }
+        return nullptr;
+    }
+
+    void svgMarkDirty() {
+        auto svgView = m_svgViewComponentInstance.lock();
+        if (svgView == nullptr) {
+            svgView = getParentSvgView();
+        }
+        if (svgView != nullptr) {
+            m_svgViewComponentInstance = svgView;
+            svgView->getLocalRootArkUINode().markDirty();
+        }
+    }
+
+    /*
+    check if it can handle the touch itself.
+    */
+    bool containsPoint(facebook::react::Point const &point) const override {
+        if (isInvisible(CppComponentInstance<T>::getComponentName())) {
+            return false;
+        }
+        auto const &node = SvgHost::GetSvgNode();
+        if (node == nullptr) {
+            return false;
+        }
+        DLOG(INFO) << "[SvgTouch] name: " << CppComponentInstance<T>::getComponentName();
+        // For debug
+        auto rect = node->AsBounds();
+        DLOG(INFO) << "[SvgTouch] asBound x: " << rect.Left() << ", y: " << rect.Top() << ", width: " << rect.Width()
+                   << ", height: " << rect.Height();
+
+        auto invertedTransform = node->lastCanvasMatrix_.Invert();
+        if (!invertedTransform.has_value()) {
+            return false;
+        }
+        auto transformed = invertedTransform.value().MapPoint(
+            {float(CppComponentInstance<T>::m_layoutMetrics.pointScaleFactor * point.x),
+             float(CppComponentInstance<T>::m_layoutMetrics.pointScaleFactor * point.y)});
+        return node->AsPath().Contains(transformed.x, transformed.y);
+    }
+
+    /*
+    check if any of its children can potentially handle the touch (the "bounding box" is a rectangle which contains the
+    component and all of its children -- if overflow is visible, they can extend beyond the View, so this is an
+    optimization to avoid walking the whole component tree). It also calls canChildrenHandleTouch to check for other
+    reasons why it shouldn't check its children (such as pointer events).
+    Can just return true from it since it's only used as an optimization to avoid walking the whole tree.
+    */
+    bool containsPointInBoundingBox(facebook::react::Point const &point) override {
+        if (isInvisible(CppComponentInstance<T>::getComponentName())) {
+            return false;
+        }
+        return true;
+    }
+
+    std::vector<TouchTarget::Shared> getTouchTargetChildren() override {
+        auto children = CppComponentInstance<T>::getChildren();
+        return std::vector<TouchTarget::Shared>(children.begin(), children.end());
+    }
+
+    facebook::react::Transform getTransform() const override { return facebook::react::Transform::Identity(); }
+
+    facebook::react::Point computeChildPoint(facebook::react::Point const &point,
+                                             TouchTarget::Shared const &child) const override {
+        return point;
+    }
+
+    bool canHandleTouch() const override {
+        if (isInvisible(CppComponentInstance<T>::getComponentName())) {
+            return false;
+        }
+        if (CppComponentInstance<T>::m_props != nullptr) {
+            return pointerEvents_ == "auto" || pointerEvents_ == "box-only" || pointerEvents_ == "box-none";
+        }
+        return true;
+    };
+
+    bool canChildrenHandleTouch() const override {
+        if (isInvisible(CppComponentInstance<T>::getComponentName())) {
+            return false;
+        }
+        if (CppComponentInstance<T>::m_props != nullptr) {
+            return pointerEvents_ == "auto" || pointerEvents_ == "box-none";
+        }
+        return true;
+    };
+
+    bool isInvisible(const std::string &name) const {
+        if (name == "RNSVGLinearGradient") {
+            return true;
+        }
+        if (name == "RNSVGRadialGradient") {
+            return true;
+        }
+        if (name == "RNSVGDefs") {
+            return true;
+        }
+        if (name == "RNSVGClipPath") {
+            return true;
+        }
+        if (name == "RNSVGMask") {
+            return true;
+        }
+        if (name == "RNSVGUse") {
+            return true;
+        }
+        if (name == "RNSVGMarker") {
+            return true;
+        }
+        if (name == "RNSVGPattern") {
+            return true;
+        }
+        if (name == "RNSVGSymbol") {
+            return true;
+        }
+        if (name == "RNSVGFilter") {
+            return true;
+        }
+        return false;
+    }
+
+protected:
+    virtual void UpdateElementProps() = 0;
+    SvgArkUINode &getLocalRootArkUINode() override { return getParentSvgView()->getLocalRootArkUINode(); }
+
+private:
+    std::string convertPointerEventsModeToString(const facebook::react::PointerEventsMode& mode) {
+        switch (mode) {
+            case facebook::react::PointerEventsMode::Auto:
+                return "auto";
+            case facebook::react::PointerEventsMode::None:
+                return "none";
+            case facebook::react::PointerEventsMode::BoxNone:
+                return "box-none";
+            case facebook::react::PointerEventsMode::BoxOnly:
+                return "box-only";
+            default:
+                return "auto";
+        }
+    }
+    std::weak_ptr<RNSVGSvgViewComponentInstance> m_svgViewComponentInstance;
+    std::string pointerEvents_ = "auto";
+};
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/cpp/componentInstances/RNSVGCircleComponentInstance.cpp

@@ -0,0 +1,31 @@
+/*
+ * 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 "RNSVGCircleComponentInstance.h"
+#include "utils/DynamicUtils.h"
+#include <react/renderer/components/react_native_svg/Props.h>
+
+namespace rnoh {
+namespace svg {
+
+RNSVGCircleComponentInstance::RNSVGCircleComponentInstance(Context context)
+    : RNSVGBaseComponentInstance(std::move(context)) {
+    SetSvgNode(m_svgCircle);
+}
+
+void RNSVGCircleComponentInstance::UpdateElementProps() {
+    // set attribute to svgCircle.
+    std::string cx = DynamicUtils::DynamicToString(m_props->cx);
+    std::string cy = DynamicUtils::DynamicToString(m_props->cy);
+    std::string r = DynamicUtils::DynamicToString(m_props->r);
+    m_svgCircle->UpdateCommonProps(m_props);
+    m_svgCircle->SetX(cx);
+    m_svgCircle->SetY(cy);
+    m_svgCircle->SetR(r);
+}
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/cpp/componentInstances/RNSVGCircleComponentInstance.h

@@ -0,0 +1,27 @@
+/*
+ * 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 "RNSVGBaseComponentInstance.h"
+#include "SvgCircle.h"
+
+namespace rnoh {
+namespace svg {
+
+class RNSVGCircleComponentInstance : public RNSVGBaseComponentInstance<facebook::react::RNSVGCircleShadowNode> {
+public:
+    explicit RNSVGCircleComponentInstance(Context context);
+
+protected:
+    void UpdateElementProps() override;
+
+private:
+    std::shared_ptr<SvgCircle> m_svgCircle = std::make_shared<SvgCircle>();
+};
+
+} // namespace svg
+} // namespace rnoh