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

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

@@ -0,0 +1,72 @@
+/*
+ * 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 "SvgMask.h"
+#include "drawing/Brush.h"
+#include <native_drawing/drawing_color_filter.h>
+#include <native_drawing/drawing_filter.h>
+#include <native_drawing/drawing_canvas.h>
+#include <native_drawing/drawing_color.h>
+
+namespace rnoh {
+namespace svg {
+
+void SvgMask::OnDrawTraversedBefore(OH_Drawing_Canvas *canvas) {
+    DLOG(INFO) << "[RNSVGMask] OnDrawTraversedBefore";
+    // TODO implement proper support for units
+    auto nodeBounds = AsBounds();
+    DLOG(INFO) << "[RNSVGMask] Left0: " << nodeBounds.Left();
+    DLOG(INFO) << "[RNSVGMask] Top0: " << nodeBounds.Top();
+    DLOG(INFO) << "[RNSVGMask] Width0: " << nodeBounds.Width();
+    DLOG(INFO) << "[RNSVGMask] Height0: " << nodeBounds.Height();
+    auto left = static_cast<float>(ParseUnitsAttr(maskAttribute_.x, nodeBounds.Width()));
+    auto top = static_cast<float>(ParseUnitsAttr(maskAttribute_.y, nodeBounds.Height()));
+    auto width = static_cast<float>(ParseUnitsAttr(maskAttribute_.width, nodeBounds.Width()));
+    auto height = static_cast<float>(ParseUnitsAttr(maskAttribute_.height, nodeBounds.Height()));
+    drawing::Rect maskBounds(left, top, width + left, height + top);
+    maskBounds_ = maskBounds;
+
+    // create mask layer
+    OH_Drawing_CanvasSaveLayer(canvas, maskBounds_.get(), nullptr);
+    // ready to render mask content
+    canvasLayerCount_ = OH_Drawing_CanvasGetSaveCount(canvas);
+
+    // set mask
+    auto outerFilter = OH_Drawing_ColorFilterCreateLuma();
+    auto innerFilter = OH_Drawing_ColorFilterCreateSrgbGammaToLinear();
+    auto colorFilter = OH_Drawing_ColorFilterCreateCompose(outerFilter, innerFilter);
+    auto *filter = OH_Drawing_FilterCreate();
+    OH_Drawing_FilterSetColorFilter(filter, colorFilter);
+
+    drawing::Brush maskFilter;
+    OH_Drawing_BrushSetFilter(maskFilter.get(), filter);
+    OH_Drawing_CanvasSaveLayer(canvas, nullptr, maskFilter.get());
+}
+
+void SvgMask::OnDrawTraversedAfter(OH_Drawing_Canvas *canvas) {
+    DLOG(INFO) << "[RNSVGMask] OnDrawTraversedAfter";
+    OH_Drawing_CanvasRestoreToCount(canvas, canvasLayerCount_);
+    // create content layer and render content
+    drawing::Brush maskBrush;
+    OH_Drawing_BrushSetBlendMode(maskBrush.get(), BLEND_MODE_SRC_IN);
+
+    OH_Drawing_CanvasSaveLayer(canvas, maskBounds_.get(), maskBrush.get());
+    OH_Drawing_CanvasClipRect(canvas, maskBounds_.get(), INTERSECT, true);
+}
+
+
+void SvgMask::OnInitStyle() { DLOG(INFO) << "[RNSVGMask] OnInitStyle"; }
+
+double SvgMask::ParseUnitsAttr(const Dimension &attr, double value) {
+    // percent and px
+    if (attr.Unit() == DimensionUnit::PERCENT) {
+        return value * attr.Value();
+    }
+    return attr.ConvertToPx(scale_);
+}
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,68 @@
+/*
+ * 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 "drawing/Rect.h"
+#include "properties/Dimension.h"
+#include "SvgQuote.h"
+
+namespace rnoh {
+namespace svg {
+
+class SvgMask : public SvgQuote {
+public:
+    SvgMask() = default;
+    ~SvgMask() override = default;
+
+    void setMaskX(const std::string &x) {
+        maskAttribute_.x = StringUtils::StringToDimensionWithUnit(x, defaultDimensionUnit_);
+    }
+
+    void setMaskY(const std::string &y) {
+        maskAttribute_.y = StringUtils::StringToDimensionWithUnit(y, defaultDimensionUnit_);
+    }
+
+    void setMaskHeight(const std::string &height) {
+        maskAttribute_.height = StringUtils::StringToDimensionWithUnit(height, defaultDimensionUnit_);
+    }
+
+    void setMaskWidth(const std::string &width) {
+        maskAttribute_.width = StringUtils::StringToDimensionWithUnit(width, defaultDimensionUnit_);
+    }
+
+    void isDefaultMaskUnits(bool isDefaultMaskUnits) { isDefaultMaskUnits_ = isDefaultMaskUnits; }
+
+    void isDefaultMaskContentUnits(bool isDefaultMaskContentUnits) {
+        isDefaultMaskContentUnits_ = isDefaultMaskContentUnits;
+    }
+
+    void setMaskUnits(const int &maskUnits) {
+        maskAttribute_.maskUnits = ToUnit(maskUnits);
+        isDefaultMaskUnits(maskAttribute_.maskUnits == Unit::objectBoundingBox);
+    }
+
+    void setMaskContentUnits(const int &maskContentUnits) {
+        maskAttribute_.maskContentUnits = ToUnit(maskContentUnits);
+        isDefaultMaskContentUnits(maskAttribute_.maskContentUnits == Unit::userSpaceOnUse);
+    }
+
+protected:
+    void OnInitStyle() override;
+    void OnDrawTraversedBefore(OH_Drawing_Canvas *canvas) override;
+    void OnDrawTraversedAfter(OH_Drawing_Canvas *canvas) override;
+    double ParseUnitsAttr(const Dimension &attr, double value);
+
+private:
+    bool isDefaultMaskUnits_ = true;
+    bool isDefaultMaskContentUnits_ = true;
+    SvgMaskAttribute maskAttribute_;
+
+    drawing::Rect maskBounds_;
+    int canvasLayerCount_ = -1;
+    DimensionUnit defaultDimensionUnit_ = DimensionUnit::VP;
+};
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,395 @@
+/*
+ * 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.
+ */
+
+#include "SvgNode.h"
+#include "utils/SvgUtils.h"
+#include "SvgGradient.h"
+#include "SvgPattern.h"
+#include "properties/ViewBox.h"
+#include "SvgFilter.h"
+#include <native_drawing/drawing_matrix.h>
+#include <native_drawing/drawing_path.h>
+#include <regex>
+#include <string>
+#include <native_drawing/drawing_pixel_map.h>
+
+namespace rnoh {
+namespace svg {
+
+constexpr size_t MIN_TRANSFORM_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;
+constexpr double MATRIX_Z_VALUE = 1.0;
+
+void SvgNode::InitStyle(const SvgBaseAttribute &attr) {
+    static thread_local int recursionDepth = 0;
+    static constexpr int MAX_RECURSION_DEPTH = 100;
+    
+    if (recursionDepth >= MAX_RECURSION_DEPTH) {
+        return;
+    }
+    
+    recursionDepth++;
+    
+    // reset gradient to null
+    attributes_.fillState.SetGradient(std::nullopt, false);
+    attributes_.strokeState.SetGradient(std::nullopt, false);
+    InheritAttr(attr);
+    if (hrefFill_) {
+        auto fillHref = attributes_.fillState.GetHref();
+        if (!fillHref.empty()) {
+            auto gradient = GetGradient(fillHref);
+            if (gradient) {
+                attributes_.fillState.SetGradient(gradient.value(), true);
+            }
+            auto pattern = GetPatternAttr(fillHref);
+            if (pattern) {
+                attributes_.fillState.SetPattern(pattern);
+            }
+        }
+        auto strokeHref = attributes_.strokeState.GetHref();
+        if (!strokeHref.empty()) {
+            auto gradient = GetGradient(strokeHref);
+            if (gradient) {
+                attributes_.strokeState.SetGradient(gradient.value(), true);
+            }
+        }
+    }
+    OnInitStyle();
+    if (passStyle_) {
+        for (auto &node : children_) {
+            if (node) {
+                node->InitStyle((node->inheritStyle_) ? attributes_ : SvgBaseAttribute());
+            }
+        }
+    }
+    
+    recursionDepth--;
+}
+
+void SvgNode::OnDrawTraversed(OH_Drawing_Canvas *canvas) {
+    auto smoothEdge = GetSmoothEdge();
+    for (auto &node : children_) {
+        if (node && node->drawTraversed_) {
+            if (GreatNotEqual(smoothEdge, 0.0f)) {
+                node->SetSmoothEdge(smoothEdge);
+            }
+            node->Draw(canvas);
+        }
+    }
+}
+
+const Rect &SvgNode::GetRootViewBox() const {
+    if (!context_) {
+        static Rect empty;
+        return empty;
+    }
+    return context_->GetRootViewBox();
+}
+
+void SvgNode::OnClipPath(OH_Drawing_Canvas *canvas) {
+    DLOG(INFO) << "[SvgNode] Draw OnClipPath enter";
+    if (!context_) {
+        DLOG(WARNING) << "[SvgNode] OnClipPath: Context is null!";
+        return;
+    }
+    auto refSvgNode = context_->GetSvgNodeById(hrefClipPath_);
+    if (!refSvgNode) {
+        DLOG(WARNING) << "[SvgNode] OnClipPath: SvgNode is null!";
+        return;
+    };
+    auto clipPath = refSvgNode->AsPath();
+
+    // maybe return optional from AsPath?
+
+    // Set clipRule through Drawing API
+    clipPath.SetFillType(attributes_.clipState.GetClipRuleForDraw());
+    OH_Drawing_CanvasClipPath(canvas, clipPath.get(), OH_Drawing_CanvasClipOp::INTERSECT, true);
+}
+
+void SvgNode::OnMask(OH_Drawing_Canvas *canvas) {
+    if (!context_) {
+        DLOG(INFO) << "NO CONTEXT";
+        return;
+    }
+    auto refMask = context_->GetSvgNodeById(attributes_.maskId);
+    if (!refMask) {
+        return;
+    };
+    refMask->Draw(canvas);
+}
+
+void SvgNode::OnTransform(OH_Drawing_Canvas *canvas, std::vector<double> transform) {
+    // input transfrom: (float scaleX, float skewY, float skewX, float scaleY, float transX, float transY)
+    /* (OH_Drawing_Matrix* , float scaleX, float skewX, float transX, float skewY, float scaleY, float transY, float
+    persp0, float persp1, float persp2 )
+    */
+    if (!attributes_.strokeState.GetVectorEffect() && transform.size() >= MIN_TRANSFORM_SIZE) {
+        cTM_.SetMatrix(transform[TRANSFORM_SCALE_X_INDEX], transform[TRANSFORM_SKEW_X_INDEX],
+                       transform[TRANSFORM_TRANSLATE_X_INDEX] * scale_, transform[TRANSFORM_SKEW_Y_INDEX],
+                       transform[TRANSFORM_SCALE_Y_INDEX], transform[TRANSFORM_TRANSLATE_Y_INDEX] * scale_, 0, 0,
+                       MATRIX_Z_VALUE);
+        OH_Drawing_CanvasConcatMatrix(canvas, cTM_.get());
+    }
+}
+
+std::optional<Gradient> SvgNode::GetGradient(const std::string &href) {
+    if (!context_) {
+        DLOG(INFO) << "NO CONTEXT";
+        return std::nullopt;
+    }
+    auto refSvgNode = context_->GetSvgNodeById(href);
+    CHECK_NULL_RETURN(refSvgNode, std::nullopt);
+    auto svgGradient = std::dynamic_pointer_cast<SvgGradient>(refSvgNode);
+    if (svgGradient) {
+        return std::make_optional(svgGradient->GetGradient());
+    }
+    return std::nullopt;
+}
+
+std::shared_ptr<PatternAttr> SvgNode::GetPatternAttr(const std::string &href) {
+    if (!context_) {
+        DLOG(INFO) << "NO CONTEXT";
+        return nullptr;
+    }
+    auto refSvgNode = context_->GetSvgNodeById(href);
+    CHECK_NULL_RETURN(refSvgNode, nullptr);
+    auto svgPattern = std::dynamic_pointer_cast<SvgPattern>(refSvgNode);
+    if (svgPattern) {
+        return svgPattern->GetPatternAttr();
+    }
+    return nullptr;
+}
+
+void SvgNode::Draw(OH_Drawing_Canvas *canvas) {
+    if (!display_) {
+        return;
+    }
+    // mask and filter create extra layers, need to record initial layer count
+    const auto count = OH_Drawing_CanvasGetSaveCount(canvas);
+    OH_Drawing_CanvasSave(canvas);
+    if (!attributes_.transform.empty()) {
+        OnTransform(canvas, attributes_.transform);
+    }
+    if (!hrefClipPath_.empty()) {
+        OnClipPath(canvas);
+    }
+    if (!attributes_.maskId.empty()) {
+        OnMask(canvas);
+    }
+    
+    OH_Drawing_CanvasGetTotalMatrix(canvas, lastCanvasMatrix_.get());
+
+    OnDraw(canvas);
+    // on marker
+
+    OnDrawTraversed(canvas);
+    
+    if (_foreignPropsArray.size() > 0) {
+        for (ForeignProps _foreignProps : _foreignPropsArray) {
+            DrawForeignPixelMap(canvas, _foreignProps);
+        }
+        _foreignPropsArray.clear();
+    }
+    OH_Drawing_CanvasRestoreToCount(canvas, count);
+}
+
+Rect SvgNode::AsBounds() {
+    auto path = AsPath();
+    auto ohRect = path.GetBounds();
+    float x = ohRect.GetLeft();
+    float y = ohRect.GetTop();
+    float width = ohRect.GetWidth();
+    float height = ohRect.GetHeight();
+    auto rect = Rect(x, y, width, height);
+    return rect;
+}
+
+void SvgNode::ContextTraversal() {
+    static thread_local int recursionDepth = 0;
+    static constexpr int MAX_RECURSION_DEPTH = 100;
+    
+    if (recursionDepth >= MAX_RECURSION_DEPTH) {
+        return;
+    }
+    
+    recursionDepth++;
+    
+    if (!context_) {
+        DLOG(INFO) << "NO CONTEXT";
+        recursionDepth--;
+        return;
+    }
+    if (!attributes_.id.empty()) {
+        context_->Push(attributes_.id, shared_from_this());
+    }
+    for (const auto &child : children_) {
+        if (child) {
+            child->SetContext(context_);
+            child->ContextTraversal();
+        }
+    }
+    
+    recursionDepth--;
+}
+
+double SvgNode::relativeOnWidth(Dimension length) { return length.RelativeConvertToPx(getCanvasWidth(), scale_); }
+
+double SvgNode::relativeOnHeight(Dimension length) { return length.RelativeConvertToPx(getCanvasHeight(), scale_); }
+
+double SvgNode::relativeOnOther(Dimension length) { return length.RelativeConvertToPx(getCanvasDiagonal(), scale_); }
+
+double SvgNode::getCanvasWidth() {
+    if (canvasWidth_ != -1) {
+        return canvasWidth_;
+    }
+    // to be done? if root is text root
+    if (context_) {
+        canvasWidth_ = context_->getCanvasBounds().Width() / context_->getCanvasScaleX();
+        return canvasWidth_;
+    }
+    return 0;
+}
+
+double SvgNode::getCanvasHeight() {
+    if (canvasHeight_ != -1) {
+        return canvasHeight_;
+    }
+    // to be done? if root is text root
+    if (context_) {
+        canvasHeight_ = context_->getCanvasBounds().Height() / context_->getCanvasScaleY();
+        return canvasHeight_;
+    }
+    return 0;
+}
+
+double SvgNode::getCanvasDiagonal() {
+    if (canvasDiagonal_ != -1) {
+        return canvasDiagonal_;
+    }
+    double powX = pow((getCanvasWidth()), 2);
+    double powY = pow((getCanvasHeight()), 2);
+    canvasDiagonal_ = sqrt(powX + powY) * M_SQRT1_2l;
+    return canvasDiagonal_;
+}
+
+void SvgNode::DrawForeignClip(OH_Drawing_Canvas *canvas,const std::string &id,int clipRule) {
+    if (!context_) {
+        DLOG(INFO) << "[svgForeignNode] NO CONTEXT";
+        return;
+    }
+    auto refSvgNode = context_->GetSvgNodeById(id);
+    if (!refSvgNode) {
+        DLOG(WARNING) << "[svgForeignNode] clipPath: SvgNode is null!";
+        return;
+    };
+    auto clipPath = refSvgNode->AsPath();
+    drawing::Path::FillType fillType = clipRule == 0
+                                           ? OH_Drawing_PathFillType::PATH_FILL_TYPE_EVEN_ODD
+                                           : OH_Drawing_PathFillType::PATH_FILL_TYPE_WINDING;
+    clipPath.SetFillType(fillType);
+    OH_Drawing_CanvasClipPath(canvas, clipPath.get(), OH_Drawing_CanvasClipOp::INTERSECT, true);
+}
+
+void SvgNode::DrawForeignMask(OH_Drawing_Canvas *canvas, const std::string &id) {
+    if (!context_) {
+        DLOG(INFO) << "[svgForeignNode] NO CONTEXT";
+        return;
+    }
+    auto refMask = context_->GetSvgNodeById(id);
+    if (!refMask) {
+        return;
+    };
+    refMask->Draw(canvas);
+}
+
+void SvgNode::DrawForeignPixelMap(OH_Drawing_Canvas *canvas, ForeignProps _foreignProps) {
+    if (!_foreignProps.foreignPixelMap) {
+        DLOG(INFO) << "[svgForeignNode] foreignPixelMap is null";
+        return;
+    }
+    if (!_foreignProps.transform.empty()) {
+        OnTransform(canvas, _foreignProps.transform);
+    }
+    if (!_foreignProps.path.empty()) {
+        DrawForeignClip(canvas,_foreignProps.path, _foreignProps.clipRule);
+    }
+    
+    if (!_foreignProps.mask.empty()) {
+        DrawForeignMask(canvas,_foreignProps.mask);
+    }
+    double postionX = _foreignProps.x.ParsePropsToPx(OH_Drawing_CanvasGetWidth(canvas), _foreignProps.pointScaleFactor);
+    double postionY = _foreignProps.y.ParsePropsToPx(OH_Drawing_CanvasGetHeight(canvas), _foreignProps.pointScaleFactor);
+    double foreignW = _foreignProps.width.ParsePropsToPx(OH_Drawing_CanvasGetWidth(canvas), _foreignProps.pointScaleFactor);
+    double foreignH = _foreignProps.height.ParsePropsToPx(OH_Drawing_CanvasGetHeight(canvas), _foreignProps.pointScaleFactor);
+    OH_Pixelmap_ImageInfo *imageInfo;
+    OH_PixelmapImageInfo_Create(&imageInfo);
+
+    OH_PixelmapNative_GetImageInfo(_foreignProps.foreignPixelMap, imageInfo);
+    uint32_t originalWidth = 0, originalHeight = 0;
+    OH_PixelmapImageInfo_GetWidth(imageInfo, &originalWidth);
+    OH_PixelmapImageInfo_GetHeight(imageInfo, &originalHeight);
+    OH_PixelmapImageInfo_Release(imageInfo);
+
+    if (originalWidth == 0 || originalHeight == 0) {
+        DLOG(WARNING) << "[svgForeignNode] Invalid pixelmap size";
+        OH_PixelmapNative_Release(_foreignProps.foreignPixelMap);
+        return;
+    }
+    float  originalRelWidth  = originalWidth > foreignW ? foreignW : originalWidth;
+    float  originalRelHeight  = originalHeight > foreignH ? foreignH : originalHeight;
+    DLOG(INFO) << "[svgForeignNode] DrawForeignPixelMap start , foreignH:" << foreignH << ";originalHeight:" << originalHeight <<";originalRelHeight:" << originalRelHeight;
+    OH_Drawing_PixelMap *ohPixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(_foreignProps.foreignPixelMap);
+    if (!ohPixelMap) {
+        DLOG(WARNING) << "[svgForeignNode] Failed to get OH_Drawing_PixelMap";
+        OH_PixelmapNative_Release(_foreignProps.foreignPixelMap);
+        return;
+    }
+
+    OH_Drawing_CanvasSave(canvas);
+
+    OH_Drawing_CanvasTranslate(canvas, postionX, postionY);
+    
+    OH_Drawing_CanvasScale(canvas, 1, 1);
+
+    OH_Drawing_Rect *srcRect = OH_Drawing_RectCreate(0, 0, originalRelWidth, originalRelHeight);
+    OH_Drawing_Rect *dstRect = OH_Drawing_RectCreate(0, 0, originalRelWidth, originalRelHeight);
+    OH_Drawing_SamplingOptions *sampling = OH_Drawing_SamplingOptionsCreate(FILTER_MODE_LINEAR, MIPMAP_MODE_LINEAR);
+    OH_Drawing_CanvasDrawPixelMapRect(canvas, ohPixelMap, srcRect, dstRect, sampling);
+
+
+    OH_Drawing_CanvasRestore(canvas);
+    OH_Drawing_PixelMapDissolve(ohPixelMap);
+    OH_PixelmapNative_Release(_foreignProps.foreignPixelMap);
+    OH_Drawing_RectDestroy(srcRect);
+    OH_Drawing_RectDestroy(dstRect);
+    OH_Drawing_SamplingOptionsDestroy(sampling);
+
+    _foreignProps.foreignPixelMap = nullptr;
+    DLOG(INFO) << "[svgForeignNode] DrawForeignPixelMap end";
+}
+
+} // namespace svg
+} // namespace rnoh