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

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

@@ -0,0 +1,58 @@
+/*
+ * 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 "SvgRect.h"
+#include "drawing/Rect.h"
+
+namespace rnoh {
+namespace svg {
+
+drawing::Path SvgRect::AsPath() {
+    drawing::Path path;
+    double x = relativeOnWidth(rectAttribute_.x);
+    double y = relativeOnHeight(rectAttribute_.y);
+    double width = relativeOnWidth(rectAttribute_.width);
+    double height = relativeOnHeight(rectAttribute_.height);
+
+    if (rectAttribute_.rx != Dimension(-1.0, DimensionUnit::PX) ||
+        rectAttribute_.ry != Dimension(-1.0, DimensionUnit::PX)) {
+        double rx;
+        double ry;
+        if (rectAttribute_.rx == Dimension(-1.0, DimensionUnit::PX)) {
+            ry = relativeOnHeight(rectAttribute_.ry);
+            rx = ry;
+        } else if (rectAttribute_.ry == Dimension(-1.0, DimensionUnit::PX)) {
+            rx = relativeOnWidth(rectAttribute_.rx);
+            ry = rx;
+        } else {
+            rx = relativeOnWidth(rectAttribute_.rx);
+            ry = relativeOnHeight(rectAttribute_.ry);
+        }
+        
+        if (rx > width / 2.0) {
+            rx = width / 2.0;
+        }
+
+        if (ry > height / 2.0) {
+            ry = height / 2.0;
+        }
+        drawing::Rect rect(x, y, x + width, y + height);
+        drawing::RoundRect roundRect(std::move(rect), rx, ry);
+        path.AddRoundRect(roundRect, PATH_DIRECTION_CW);
+    } else {
+        path.AddRect(x, y, x + width, y + height, PATH_DIRECTION_CW);
+    }
+
+    elements_ = {PathElement(ElementType::kCGPathElementMoveToPoint, {Point(x, y)}),
+                 PathElement(ElementType::kCGPathElementAddLineToPoint, {Point(x + width, y)}),
+                 PathElement(ElementType::kCGPathElementAddLineToPoint, {Point(x + width, y + height)}),
+                 PathElement(ElementType::kCGPathElementAddLineToPoint, {Point(x, y + height)}),
+                 PathElement(ElementType::kCGPathElementAddLineToPoint, {Point(x, y)})};
+    return path;
+};
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,33 @@
+/*
+ * 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 SvgRect : public SvgGraphic {
+public:
+    using Float = facebook::react::Float;
+    SvgRect() = default;
+    ~SvgRect() override = default;
+
+    void SetX(const std::string &x) { rectAttribute_.x = SvgAttributesParser::ParseDimension(x, true); }
+    void SetY(const std::string &y) { rectAttribute_.y = SvgAttributesParser::ParseDimension(y, true); }
+    void SetRX(const std::string &rx) { rectAttribute_.rx = SvgAttributesParser::ParseDimension(rx, true); }
+    void SetRY(const std::string &ry) { rectAttribute_.ry = SvgAttributesParser::ParseDimension(ry, true); }
+    void SetWidth(const std::string &width) { rectAttribute_.width = SvgAttributesParser::ParseDimension(width, true); }
+    void SetHeight(const std::string &height) { rectAttribute_.height = SvgAttributesParser::ParseDimension(height, true); }
+    drawing::Path AsPath() override;
+private:
+    SvgRectAttribute rectAttribute_;
+};
+
+} // namespace svg
+} // namespace rnoh

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

@@ -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.
+ */
+
+#include "SvgSvg.h"
+#include "properties/Size.h"
+#include "utils/StringUtils.h"
+#include "properties/ViewBox.h"
+#include <native_drawing/drawing_rect.h>
+
+namespace rnoh {
+namespace svg {
+
+namespace {
+const int MOS_MEET = 0;
+const int MOS_SLICE = 1;
+const int MOS_NONE = 2;
+} // namespace
+
+SvgSvg::SvgSvg() : SvgGroup() {}
+
+drawing::Path SvgSvg::AsPath() {
+    drawing::Path path;
+    for (const auto &child : children_) {
+        auto childPath = child->AsPath();
+        path.Union(childPath);
+    }
+    return path;
+}
+
+Size SvgSvg::GetSize() const { return {width_, height_}; }
+
+Rect SvgSvg::GetViewBox() const {
+    return Rect(svgAttribute_.vbX.ConvertToPx(scale_), svgAttribute_.vbY.ConvertToPx(scale_),
+                svgAttribute_.vbWidth.ConvertToPx(scale_), svgAttribute_.vbHeight.ConvertToPx(scale_));
+}
+
+drawing::Matrix SvgSvg::FitCanvas(OH_Drawing_Canvas *canvas) {
+    const auto svgSize = GetSize();
+    const auto vbRect = GetViewBox(); // should be viewBox attribute
+    const auto eRect = Rect(svgAttribute_.x.ConvertToPx(scale_), svgAttribute_.y.ConvertToPx(scale_), svgSize.Width(),
+                            svgSize.Height());
+    DLOG(INFO) << "[FitCanvas] viewBox = " << vbRect.ToString() << " svgSize = " << svgSize.ToString()
+               << " canvas = " << OH_Drawing_CanvasGetWidth(canvas) << ", " << OH_Drawing_CanvasGetHeight(canvas);
+    drawing::Rect clipRect(0.0f, 0.0f, svgSize.Width(), svgSize.Height());
+    OH_Drawing_CanvasClipRect(canvas, clipRect.get(), OH_Drawing_CanvasClipOp::INTERSECT, true);
+    drawing::Matrix transformMatrix;
+    if (vbRect.IsValid()) {
+        transformMatrix = ViewBox::getTransform(vbRect, eRect, svgAttribute_.align, svgAttribute_.meetOrSlice);
+        OH_Drawing_CanvasConcatMatrix(canvas, transformMatrix.get());
+    }
+    return transformMatrix;
+}
+
+void SvgSvg::Draw(OH_Drawing_Canvas *canvas) {
+    float width = OH_Drawing_CanvasGetWidth(canvas);
+    float height = OH_Drawing_CanvasGetHeight(canvas);
+    context_->SetCanvasBounds(Rect(0.0f, 0.0f, width, height));
+    context_->SetRootViewBox(GetViewBox());
+    width_ = width;
+    height_ = height;
+    DLOG(INFO) << "[svgView] bbHeight: " << svgAttribute_.height.Value();
+    DLOG(INFO) << "[svgView] bbWidth: " << svgAttribute_.height.Value();
+    DLOG(INFO) << "[svgView] svg Height: " << height_;
+    DLOG(INFO) << "[svgView] svg Width: " << width_;
+    DLOG(INFO) << "[svgView] canvas Height: " << height;
+    DLOG(INFO) << "[svgView] canvas Width: " << width;
+    context_->SetSvgSize(Size(width_, height_));
+    // apply scale
+    OH_Drawing_CanvasSave(canvas);
+    auto canvasTransformMatrix = FitCanvas(canvas);
+    constexpr size_t matrixScaleXIndex = 0;
+    constexpr size_t matrixScaleYIndex = 4;
+    context_->SetCanvasScale(canvasTransformMatrix.GetValue(matrixScaleXIndex),
+                             canvasTransformMatrix.GetValue(matrixScaleYIndex));
+    SvgNode::Draw(canvas);
+    OH_Drawing_CanvasRestore(canvas);
+};
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,52 @@
+/*
+ * 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 <native_drawing/drawing_canvas.h>
+#include <native_drawing/drawing_path.h>
+#include "SvgGroup.h"
+#include "utils/SvgAttributesParser.h"
+
+namespace rnoh {
+namespace svg {
+
+class SvgSvg : public SvgGroup {
+public:
+    SvgSvg();
+    ~SvgSvg() override = default;
+
+    drawing::Path AsPath() override;
+
+    Size GetSize() const;
+    
+    Rect GetViewBox() const;
+    
+    void Draw(OH_Drawing_Canvas *canvas) override;
+
+    void SetVbX(const double &vbX) { svgAttribute_.vbX = Dimension(vbX, DimensionUnit::VP); }
+    void SetVbY(const double &vbY) { svgAttribute_.vbY = Dimension(vbY, DimensionUnit::VP); }
+    void SetVbWidth(const double &vbWidth) { svgAttribute_.vbWidth = Dimension(vbWidth, DimensionUnit::VP); }
+    void SetVbHeight(const double &vbHeight) { svgAttribute_.vbHeight = Dimension(vbHeight, DimensionUnit::VP); }
+    void SetX(const double &x) { svgAttribute_.x = Dimension(x, DimensionUnit::VP); }
+    void SetY(const double &y) { svgAttribute_.y = Dimension(y, DimensionUnit::VP); }
+    void SetWidth(const std::string &width) { svgAttribute_.width = SvgAttributesParser::ParseDimension(width, true); }
+    void SetHeight(const std::string &height) { svgAttribute_.height = SvgAttributesParser::ParseDimension(height, true); }
+    void SetAlign(const std::string &align) { svgAttribute_.align = align; }
+    void SetMeetOrSlice(const int &meetOrSlice) { svgAttribute_.meetOrSlice = meetOrSlice; }
+
+private:
+    SvgAttribute svgAttribute_;
+    
+    float width_ = 0;
+    
+    float height_ = 0;
+    
+    drawing::Matrix FitCanvas(OH_Drawing_Canvas *canvas);
+};
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,25 @@
+/*
+ * 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 "SvgSymbol.h"
+
+namespace rnoh {
+namespace svg {
+
+void SvgSymbol::drawSymbol(OH_Drawing_Canvas *canvas, float width, float height) {
+    if (!mAlign.empty()) {
+        Rect vbRect(mMinX * scale_, mMinY * scale_, mMinX + mVbWidth * scale_, mMinY + mVbHeight * scale_);
+        Rect eRect(0, 0, width * scale_, height * scale_);
+        if (vbRect.IsValid()) {
+            drawing::Matrix viewBoxMatrix = ViewBox::getTransform(vbRect, eRect, mAlign, mMeetOrSlice);
+            OH_Drawing_CanvasConcatMatrix(canvas, viewBoxMatrix.get());
+        }
+    }
+    Draw(canvas);
+}
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/cpp/SvgSymbol.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 "SvgGraphic.h"
+#include "properties/ViewBox.h"
+
+namespace rnoh {
+namespace svg {
+
+class SvgSymbol : public SvgGraphic {
+public:
+    SvgSymbol() : SvgGraphic() { InitSymbolFlag(); }
+    ~SvgSymbol() override = default;
+
+    void InitSymbolFlag() {
+        hrefFill_ = false;
+        hrefRender_ = true;
+        inheritStyle_ = false;
+        drawTraversed_ = false;
+    }
+    float mMinX = 0.0f;
+    float mMinY = 0.0f;
+    float mVbWidth = 0.0f;
+    float mVbHeight = 0.0f;
+    std::string mAlign;
+    int mMeetOrSlice = -1;
+    void InitDefsFlag();
+    void drawSymbol(OH_Drawing_Canvas *canvas, float width, float height);
+};
+
+} // namespace svg
+} // namespace rnoh