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

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

@@ -0,0 +1,45 @@
+/*
+ * 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 "SvgHost.h"
+#include "RNOH/arkui/ArkUINode.h"
+#include "arkui/native_node.h"
+
+namespace rnoh {
+namespace svg {
+
+struct UserCallback {
+    std::function<void(ArkUI_NodeCustomEvent *event)> callback;
+};
+
+// ArkUINode
+class SvgArkUINode : public ArkUINode {
+private:
+    void OnDraw(ArkUI_NodeCustomEvent *event);
+    
+    std::weak_ptr<SvgNode> root_;
+    ArkUI_NativeNodeAPI_1 *nativeModule_ = nullptr;
+    UserCallback *userCallback_ = nullptr;
+    void (*eventReceiver)(ArkUI_NodeCustomEvent *event);
+
+public:
+    SvgArkUINode();
+    ~SvgArkUINode() override;
+
+    void SetSvgNode(const std::weak_ptr<SvgNode>& node)
+    {
+        root_ = node;
+    }
+    void ResetNodeHandle() {
+        
+    }
+};
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,83 @@
+/*
+ * 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/declaration/svg/svg_base_declaration.h"
+#pragma once
+
+#include "Attribute.h"
+#include "properties/SvgPaintState.h"
+#include <string>
+#include <vector>
+
+namespace rnoh {
+namespace svg {
+
+const char VALUE_NONE[] = "none";
+
+struct SvgBaseAttribute : Attribute {
+    double selfOpacity = 1.0; // opacity declared in tag attribute
+    double opacity = 1.0; // multiplied with parent opacity. The actual opacity to be drawn
+    float smoothEdge = 0.0f;
+    FillState fillState;
+    StrokeState strokeState;
+//     SvgTextStyle textStyle;
+    std::vector<double> transform; // transform matrix
+    std::string transformOrigin;
+    std::string filterId;
+    std::string maskId;
+    std::string id;
+    std::string markerStart;
+    std::string markerMid;
+    std::string markerEnd;
+    std::string clipPath;
+    ClipState clipState;
+    bool hasInheritedFilter = false; // Indicates if the filterId is inherited from parent node
+    bool hasFilter = false; 
+
+    void InheritFromUse(const SvgBaseAttribute& parent)
+    {
+        opacity = selfOpacity * parent.opacity;
+        fillState.Inherit(parent.fillState);
+        strokeState.Inherit(parent.strokeState);
+        clipState.Inherit(parent.clipState);
+        // 继承filter属性
+        if (filterId.empty()) {
+            filterId = parent.filterId;
+            hasInheritedFilter = parent.hasInheritedFilter;
+        }
+    }
+
+    void Inherit(const SvgBaseAttribute& parent)
+    {
+        opacity = selfOpacity * parent.opacity;
+        fillState.Inherit(parent.fillState);
+        strokeState.Inherit(parent.strokeState);
+        clipState.Inherit(parent.clipState);
+        // 继承filter属性
+        if (filterId.empty()) {
+            filterId = parent.filterId;
+            hasInheritedFilter = parent.hasInheritedFilter;
+        }
+    }
+};
+
+} // namespace svg
+} // namespace rnoh

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

@@ -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.
+ */
+
+#include "SvgCircle.h"
+
+namespace rnoh {
+namespace svg {
+
+drawing::Path SvgCircle::AsPath() {
+    drawing::Path path;
+    double x = relativeOnWidth(circleAttribute_.cx);
+    double y = relativeOnHeight(circleAttribute_.cy);
+    double r = relativeOnOther(circleAttribute_.r);
+    
+    path.AddCircle(x, y, r, PATH_DIRECTION_CW);
+    
+    elements_ = {PathElement(ElementType::kCGPathElementMoveToPoint, {Point(x, y - r)}),
+                       PathElement(ElementType::kCGPathElementAddLineToPoint, {Point(x, y - r), Point(x + r, y)}),
+                       PathElement(ElementType::kCGPathElementAddLineToPoint, {Point(x + r, y), Point(x, y + r)}),
+                       PathElement(ElementType::kCGPathElementAddLineToPoint, {Point(x, y + r), Point(x - r, y)}),
+                       PathElement(ElementType::kCGPathElementAddLineToPoint, {Point(x - r, y), Point(x, y - r)})};
+    return path;
+}
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/cpp/SvgCircle.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"
+#include "utils/SvgAttributesParser.h"
+
+namespace rnoh {
+namespace svg {
+
+class SvgCircle : public SvgGraphic {
+public:
+    SvgCircle() = default;
+    ~SvgCircle() override = default;
+
+    void SetX(const std::string &x) { circleAttribute_.cx = SvgAttributesParser::ParseDimension(x, true); }
+    void SetY(const std::string &y) { circleAttribute_.cy = SvgAttributesParser::ParseDimension(y, true); }
+    void SetR(const std::string &r) { circleAttribute_.r = SvgAttributesParser::ParseDimension(r, true); }
+    drawing::Path AsPath() override;
+private:
+    SvgCircleAttribute circleAttribute_;
+};
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,22 @@
+/*
+ * 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 "SvgQuote.h"
+
+namespace rnoh {
+namespace svg {
+
+    class SvgClipPath : public SvgQuote {
+
+    public:
+        SvgClipPath() = default;
+        ~SvgClipPath() override = default;
+    };
+    
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,56 @@
+/*
+ * 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 <iostream>
+#include "SvgNode.h"
+
+namespace rnoh {
+namespace svg {
+std::shared_ptr<SvgNode> SvgContext::GetSvgNodeById(const std::string &id) const {
+    auto item = idMapper_.find(id);
+    if (item != idMapper_.end()) {
+        auto node = item->second.lock();
+        if (node) {
+            return node;
+        }
+    }
+    return nullptr;
+}
+
+void SvgContext::PushStyle(const std::string &styleName, const std::pair<std::string, std::string> &attrPair) {
+    const auto &arrMapIter = styleMap_.find(styleName);
+    if (arrMapIter == styleMap_.end()) {
+        AttrMap attrMap;
+        attrMap.emplace(attrPair);
+        styleMap_.emplace(std::make_pair(styleName, attrMap));
+    } else {
+        if (arrMapIter->second.find(attrPair.first) != arrMapIter->second.end()) {
+            arrMapIter->second.erase(attrPair.first);
+        }
+        arrMapIter->second.emplace(attrPair);
+    }
+}
+
+const AttrMap &SvgContext::GetAttrMap(const std::string &key) const {
+    auto styleClassIter = styleMap_.find(key);
+    if (styleClassIter != styleMap_.end()) {
+        return styleClassIter->second;
+    }
+    static AttrMap emptyMap;
+    return emptyMap;
+}
+
+const Rect &SvgContext::GetRootViewBox() const {
+    if (!rootViewBox_.IsValid()) {
+        static Rect rect;
+        rect = Rect(0, 0, svgSize_.Width(), svgSize_.Height());
+        return rect;
+    }
+    return rootViewBox_;
+}
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,71 @@
+/*
+ * 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 <memory>
+#include <string>
+#include <unordered_map>
+#include "properties/Rect.h"
+#include "properties/Size.h"
+#include "properties/Color.h"
+
+namespace rnoh {
+namespace svg {
+
+using AttrMap = std::unordered_map<std::string, std::string>;
+using ClassStyleMap = std::unordered_map<std::string, AttrMap>;
+class SvgNode;
+class SvgContext {
+public:
+    void Push(const std::string &value, const std::shared_ptr<SvgNode> &svgNode) { idMapper_.emplace(value, svgNode); }
+
+    std::shared_ptr<SvgNode> GetSvgNodeById(const std::string &id) const;
+
+    void PushStyle(const std::string &styleName, const std::pair<std::string, std::string> &attrPair);
+
+    const AttrMap &GetAttrMap(const std::string &key) const;
+
+    void SetRootViewBox(const Rect &viewBox) { rootViewBox_ = viewBox; }
+
+    const Rect &GetRootViewBox() const;
+
+    void SetSvgSize(const Size &size) { svgSize_ = size; }
+
+    const Size &GetSvgSize() const { return svgSize_; }
+
+    void SetSvgColor(const Color &svgColor) { svgColor_ = svgColor; }
+
+    const Color &GetSvgColor() { return svgColor_; }
+
+    void SetCanvasBounds(const Rect &canvasClipBounds) { canvasClipBounds_ = canvasClipBounds; }
+
+    const Rect getCanvasBounds() { return canvasClipBounds_; }
+
+    void SetCanvasScale(const double &canvasScaleX, const double &canvasScaleY) {
+        canvasScaleX_ = canvasScaleX;
+        canvasScaleY_ = canvasScaleY;
+    }
+
+    const double getCanvasScaleX() { return canvasScaleX_; }
+
+    const double getCanvasScaleY() { return canvasScaleY_; }
+
+    void ClearIdMap() { idMapper_.clear(); }
+
+private:
+    std::unordered_map<std::string, std::weak_ptr<SvgNode>> idMapper_;
+    ClassStyleMap styleMap_;
+    Rect rootViewBox_;
+    Size svgSize_;
+    Color svgColor_ = Color::WHITE; // 默认白色
+    Rect canvasClipBounds_;
+    double canvasScaleX_ = 1;
+    double canvasScaleY_ = 1;
+};
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/cpp/SvgDefs.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 "SvgNode.h"
+#include "SvgGraphic.h"
+
+namespace rnoh {
+namespace svg {
+
+class SvgDefs : public SvgNode {
+public:
+    SvgDefs() : SvgNode() { InitDefsFlag(); }
+    ~SvgDefs() override = default;
+
+    void InitDefsFlag() {
+        hrefFill_ = false;
+        hrefRender_ = false;
+        inheritStyle_ = false;
+        drawTraversed_ = false;
+    }
+
+    drawing::Path AsPath() override {
+        drawing::Path path;
+        // Early return if there are no children
+        if (children_.empty()) {
+            return path;
+        }
+        for (const auto& child : children_) {
+            if (!child) {
+                DLOG(WARNING) << "[SvgDefs:AsPath] Encountered a null child node";
+                continue;
+            }
+            auto childPath = child->AsPath();
+            path.Union(childPath);
+        }
+        return path;
+    }
+};
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,32 @@
+/*
+ * 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 "SvgEllipse.h"
+#include "drawing/Rect.h"
+
+namespace rnoh {
+namespace svg {
+
+drawing::Path SvgEllipse::AsPath() {
+    drawing::Path path;
+    double cx = relativeOnWidth(ellipseAttribute_.cx);
+    double cy = relativeOnHeight(ellipseAttribute_.cy);
+    double rx = relativeOnWidth(ellipseAttribute_.rx);
+    double ry = relativeOnHeight(ellipseAttribute_.ry);
+
+    drawing::Rect rect(cx - rx, cy - ry, cx + rx, cy + ry);
+    path.AddOval(rect, PATH_DIRECTION_CW);
+
+    elements_ = {PathElement(ElementType::kCGPathElementMoveToPoint, {Point(cx, cy - ry)}),
+                 PathElement(ElementType::kCGPathElementAddLineToPoint, {Point(cx, cy - ry), Point(cx + rx, cy)}),
+                 PathElement(ElementType::kCGPathElementAddLineToPoint, {Point(cx + rx, cy), Point(cx, cy + ry)}),
+                 PathElement(ElementType::kCGPathElementAddLineToPoint, {Point(cx, cy + ry), Point(cx - rx, cy)}),
+                 PathElement(ElementType::kCGPathElementAddLineToPoint, {Point(cx - rx, cy), Point(cx, cy - ry)})};
+    return path;
+};
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,34 @@
+/*
+ * 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 "utils/SvgAttributesParser.h"
+
+namespace rnoh {
+namespace svg {
+
+class SvgEllipse : public SvgGraphic {
+public:
+    using Float = facebook::react::Float;
+    SvgEllipse() = default;
+    ~SvgEllipse() override = default;
+    
+    drawing::Path AsPath() override;
+    void SetCX(const std::string &cx) { ellipseAttribute_.cx = SvgAttributesParser::ParseDimension(cx, true); }
+    void SetCY(const std::string &cy) { ellipseAttribute_.cy = SvgAttributesParser::ParseDimension(cy, true); }
+    void SetRX(const std::string &rx) { ellipseAttribute_.rx = SvgAttributesParser::ParseDimension(rx, true); }
+    void SetRY(const std::string &ry) { ellipseAttribute_.ry = SvgAttributesParser::ParseDimension(ry, true); }
+
+private:
+    SvgEllipseAttribute ellipseAttribute_;
+};
+
+} // namespace svg
+} // namespace rnoh
+
+