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

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

@@ -0,0 +1,246 @@
+/*
+ * 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/base/geometry/size.h"
+#pragma once
+
+#include <iomanip>
+#include <limits>
+#include <sstream>
+#include <string>
+
+#include "utils/SvgUtils.h"
+
+namespace rnoh {
+namespace svg {
+
+class Size {
+public:
+    static constexpr double INFINITE_SIZE = std::numeric_limits<double>::max();
+    Size() = default;
+    ~Size() = default;
+    Size(double width, double height) : width_(width), height_(height) {}
+
+    inline static bool IsValueInfinite(double inputValue)
+    {
+        return NearEqual(inputValue, INFINITE_SIZE);
+    }
+
+    static Size ErrorSize()
+    {
+        return Size((std::numeric_limits<double>::max)(), (std::numeric_limits<double>::max)());
+    }
+
+    bool IsErrorSize() const
+    {
+        return operator==(ErrorSize());
+    }
+
+    double Width() const
+    {
+        return width_;
+    }
+
+    double Height() const
+    {
+        return height_;
+    }
+
+    void SetWidth(double width)
+    {
+        width_ = width;
+    }
+
+    void SetHeight(double height)
+    {
+        height_ = height;
+    }
+
+    void SetSize(const Size& size)
+    {
+        width_ = size.Width();
+        height_ = size.Height();
+    }
+
+    bool IsWidthInfinite() const
+    {
+        return NearEqual(width_, INFINITE_SIZE);
+    }
+
+    bool IsHeightInfinite() const
+    {
+        return NearEqual(height_, INFINITE_SIZE);
+    }
+
+    bool IsInfinite() const
+    {
+        return NearEqual(width_, INFINITE_SIZE) || NearEqual(height_, INFINITE_SIZE);
+    }
+
+    bool IsEmpty() const
+    {
+        return NearEqual(width_, 0.0) || NearEqual(height_, 0.0);
+    }
+
+    Size& AddHeight(double height)
+    {
+        height_ += height;
+        return *this;
+    }
+
+    Size& AddWidth(double value)
+    {
+        width_ += value;
+        return *this;
+    }
+
+    Size& MinusHeight(double height)
+    {
+        height_ -= height;
+        return *this;
+    }
+
+    Size& MinusWidth(double width)
+    {
+        width_ -= width;
+        return *this;
+    }
+
+    bool IsValid() const
+    {
+        return width_ > 0.0 && height_ > 0.0;
+    }
+
+    Size operator+(const Size& size) const
+    {
+        return Size(width_ + size.Width(), height_ + size.Height());
+    }
+
+    Size operator-(const Size& size) const
+    {
+        return Size(width_ - size.Width(), height_ - size.Height());
+    }
+
+    Size operator*(double value) const
+    {
+        return Size(width_ * value, height_ * value);
+    }
+
+    Size operator/(double value) const
+    {
+        if (NearZero(value)) {
+            return ErrorSize();
+        }
+        return Size(width_ / value, height_ / value);
+    }
+
+    bool operator==(const Size& size) const
+    {
+        return NearEqual(width_, size.width_) && NearEqual(height_, size.height_);
+    }
+
+    bool operator!=(const Size& size) const
+    {
+        return !operator==(size);
+    }
+
+    Size operator+=(const Size& size)
+    {
+        width_ += size.Width();
+        height_ += size.Height();
+        return *this;
+    }
+
+    Size operator-=(const Size& size)
+    {
+        width_ -= size.Width();
+        height_ -= size.Height();
+        return *this;
+    }
+
+    void ApplyScale(double scale)
+    {
+        width_ *= scale;
+        height_ *= scale;
+    }
+
+    /*
+     * Please make sure that two sizes are both valid.
+     * You can use IsValid() to see if a size is valid.
+     */
+    bool operator>(const Size& size) const
+    {
+        if (IsValid() && size.IsValid()) {
+            return GreatOrEqual(width_, size.width_) && GreatOrEqual(height_, size.height_);
+        } else {
+            return false;
+        }
+    }
+
+    /*
+     * Please make sure that two sizes are both valid.
+     * You can use IsValid() to see if a size is valid.
+     */
+    bool operator<(const Size& size) const
+    {
+        if (IsValid() && size.IsValid()) {
+            return LessOrEqual(width_, size.width_) && LessOrEqual(height_, size.height_);
+        } else {
+            return false;
+        }
+    }
+
+    template<class T>
+    static double CalcRatio(const T& rectangle)
+    {
+        if (NearZero(static_cast<double>(rectangle.Height()))) {
+            return INFINITE_SIZE;
+        }
+        return static_cast<double>(rectangle.Width()) / static_cast<double>(rectangle.Height());
+    }
+
+    std::string ToString() const
+    {
+        std::stringstream ss;
+        ss << "[" << std::fixed << std::setprecision(2);
+        if (NearEqual(width_, INFINITE_SIZE)) {
+            ss << "INFINITE";
+        } else {
+            ss << width_;
+        }
+        ss << " x ";
+        if (NearEqual(height_, INFINITE_SIZE)) {
+            ss << "INFINITE";
+        } else {
+            ss << height_;
+        }
+        ss << "]";
+        std::string output = ss.str();
+        return output;
+    }
+
+private:
+    double width_ = 0.0;
+    double height_ = 0.0;
+};
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,452 @@
+/*
+ * 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/common/properties/svg_paint_state.h"
+#pragma once
+
+#include "Decoration.h"
+#include "properties/Color.h"
+#include "properties/PaintState.h"
+#include "properties/Decoration.h"
+#include <native_drawing/drawing_path.h>
+#include <glog/logging.h>
+
+namespace rnoh {
+namespace svg {
+
+const char ATTR_NAME_FILL[] = "fill";
+const char ATTR_NAME_STROKE[] = "stroke";
+const char ATTR_NAME_STROKE_WIDTH[] = "stroke-width";
+const char ATTR_NAME_MITER_LIMIT[] = "stroke-miterlimit";
+const char ATTR_NAME_STROKE_DASH_OFFSET[] = "stroke-dashoffset";
+const char ATTR_NAME_FONT_SIZE[] = "font-size";
+const char ATTR_NAME_FILL_OPACITY[] = "fill-opacity";
+const char ATTR_NAME_STROKE_OPACITY[] = "stroke-opacity";
+const char ATTR_NAME_LETTER_SPACING[] = "letter-spacing";
+const char ANIMATOR_TYPE_MOTION[] = "motion";
+const char ATTR_NAME_FILL_RULE_EVENODD[] = "evenodd";
+
+class FillState {
+public:
+    enum class FillRule {
+        FILL_RULE_EVEN_ODD = 0,
+        FILL_RULE_NONZERO = 1
+    };
+
+    const Color &GetColor() const { return color_; }
+
+    /**
+     * set fill color
+     * @param color
+     * @param isSelf if false the color value inherited from the parent node, otherwise the value is setted by self
+     */
+    void SetColor(const Color &color, bool isSelf) {
+        color_ = Color(color);
+        hasColor_ = isSelf;
+    }
+
+    std::optional<Gradient> &GetGradient() { return gradient_; }
+
+    const std::optional<Gradient> &GetGradient() const { return gradient_; }
+
+    void SetGradient(const Gradient &gradient, bool isSelf) {
+        gradient_ = std::make_optional(gradient);
+        hasGradient_ = isSelf;
+    }
+
+    void SetGradient(const std::optional<Gradient> &gradient, bool isSelf) {
+        gradient_ = gradient;
+        hasGradient_ = isSelf;
+    }
+
+    std::shared_ptr<PatternAttr> &GetPatternAttr() { return patternAttr_; }
+    
+    const std::shared_ptr<PatternAttr> &GetPatternAttr() const { return patternAttr_; }
+
+    void SetPattern(std::shared_ptr<PatternAttr> patternAttr) {
+        patternAttr_ = patternAttr;
+    }
+
+    void SetOpacity(double opacity, bool isSelf) {
+        opacity_ = opacity;
+        hasOpacity_ = isSelf;
+    }
+
+    double GetOpacity() const { return opacity_; }
+
+    void SetFillRule(const FillState::FillRule fillRule , bool isSelf) {
+        fillRule_ = fillRule;
+        hasFillRule_ = isSelf;
+    }
+
+    const FillState::FillRule &GetFillRule() const { return fillRule_; }
+    
+    OH_Drawing_PathFillType GetFillRuleForDraw() const{
+        if (IsEvenodd()) {
+            return OH_Drawing_PathFillType::PATH_FILL_TYPE_EVEN_ODD;
+        } else {
+            return OH_Drawing_PathFillType::PATH_FILL_TYPE_WINDING;
+        }
+    }
+    
+    bool IsEvenodd() const { return fillRule_ == FillRule::FILL_RULE_EVEN_ODD; }
+    //
+    void Inherit(const FillState &parent) {
+        if (!hasColor_) {
+            color_ = parent.GetColor();
+        }
+        if (!hasOpacity_) {
+            opacity_ = parent.GetOpacity();
+        }
+        if (!hasFillRule_) {
+            fillRule_ = parent.GetFillRule();
+        }
+        if (!hasGradient_) {
+            gradient_ = parent.GetGradient();
+        }
+    }
+
+    bool HasColor() const { return hasColor_; }
+
+    bool HasOpacity() const { return hasOpacity_; }
+
+    void SetHref(const std::string &href) { href_ = href; }
+
+    const std::string &GetHref() const { return href_; }
+
+protected:
+    Color color_ = Color(Color::BLACK);
+    double opacity_ = double(1.0);
+    FillState::FillRule fillRule_;
+    std::optional<Gradient> gradient_;
+    std::shared_ptr<PatternAttr> patternAttr_;
+    bool hasColor_ = false;
+    bool hasOpacity_ = false;
+    bool hasFillRule_ = false;
+    bool hasGradient_ = false;
+    std::string href_;
+};
+
+class StrokeState {
+public:
+    const Color& GetColor() const
+    {
+        return color_;
+    }
+
+    void SetColor(const Color& color, bool isSelf)
+    {
+        color_ = color;
+        hasColor_ = isSelf;
+    }
+
+    std::optional<Gradient> &GetGradient() { return gradient_; }
+
+    const std::optional<Gradient> &GetGradient() const { return gradient_; }
+
+    void SetGradient(const Gradient &gradient, bool isSelf) {
+        gradient_ = std::make_optional(gradient);
+        hasGradient_ = isSelf;
+    }
+
+    void SetGradient(const std::optional<Gradient> &gradient, bool isSelf) {
+        gradient_ = gradient;
+        hasGradient_ = isSelf;
+    }
+
+    void SetOpacity(double opacity, bool isSelf)
+    {
+        opacity_ = opacity;
+        hasOpacity_ = isSelf;
+    }
+
+    double GetOpacity() const
+    {
+        return opacity_;
+    }
+
+    LineCapStyle GetLineCap() const
+    {
+        return lineCap_;
+    }
+
+    void SetLineCap(LineCapStyle lineCap, bool isSelf)
+    {
+        lineCap_ = lineCap;
+        hasLineCap_ = isSelf;
+    }
+
+    LineJoinStyle GetLineJoin() const
+    {
+        return lineJoin_;
+    }
+
+    void SetLineJoin(LineJoinStyle lineJoin, bool isSelf)
+    {
+        lineJoin_ = lineJoin;
+        hasLineJoin_ = isSelf;
+    }
+
+    const double& GetLineWidth() const
+    {
+        return lineWidth_;
+    }
+
+    void SetLineWidth(double lineWidth, bool isSelf)
+    {
+        lineWidth_ = lineWidth;
+        hasLineWidth_ = isSelf;
+    }
+
+    double GetMiterLimit() const
+    {
+        return miterLimit_;
+    }
+
+    void SetMiterLimit(double miterLimit, bool isSelf)
+    {
+        miterLimit_ = miterLimit;
+        hasMiterLimit_ = isSelf;
+    }
+
+    const LineDashParam& GetLineDash() const
+    {
+        return lineDash_;
+    }
+
+    void SetLineDash(const LineDashParam& lineDash, bool isSelf)
+    {
+        lineDash_ = lineDash;
+        hasLineDash_ = isSelf;
+    }
+
+    void SetLineDashOffset(double offset, bool isSelf)
+    {
+        lineDash_.dashOffset = offset;
+        hasDashOffset_ = isSelf;
+    }
+
+    void SetLineDash(const std::vector<double>& segments, bool isSelf)
+    {
+        lineDash_.lineDash = segments;
+        hasLineDash_ = isSelf;
+    }
+
+    void SetStrokeDashOffset(const double& offset, bool isSelf)
+    {
+        strokeDashOffset_ = offset;
+        hasStrokeDashOffset_ = isSelf;
+    }
+
+    void SetStrokeDashArray(const std::vector<double>& segments, bool isSelf)
+    {
+        strokeDashArray_ = segments;
+        hasStrokeDashArray_ = isSelf;
+    }
+
+    const double& GetStrokeDashOffset() const
+    {
+        return strokeDashOffset_;
+    }
+
+    const std::vector<double>& GetStrokeDashArray() const
+    {
+        return strokeDashArray_;
+    }
+
+    bool HasStroke() const
+    {
+        // The text outline is drawn only when stroke is set
+        return color_ != Color::TRANSPARENT;
+    }
+
+    void SetVectorEffect(int VectorEffect)
+    {
+        vectorEffect_ = VectorEffect;
+    }
+
+    const int GetVectorEffect() const
+    {
+        return vectorEffect_;
+    }
+
+    void Inherit(const StrokeState& strokeState)
+    {
+        if (!hasColor_) {
+            color_ = strokeState.GetColor();
+        }
+        if (!hasOpacity_) {
+            opacity_ = strokeState.GetOpacity();
+        }
+        if (!hasLineCap_) {
+            lineCap_ = strokeState.GetLineCap();
+        }
+        if (!hasLineJoin_) {
+            lineJoin_ = strokeState.GetLineJoin();
+        }
+        DLOG(INFO) << "hasLineWIdth = " << hasLineWidth_ << " to inherit : " << strokeState.GetLineWidth();
+        if (!hasLineWidth_) {
+            lineWidth_ = strokeState.GetLineWidth();
+        }
+        if (!hasMiterLimit_) {
+            miterLimit_ = strokeState.GetMiterLimit();
+        }
+        if (!hasLineDash_) {
+            lineDash_.lineDash = strokeState.GetLineDash().lineDash;
+        }
+        if (!hasDashOffset_) {
+            lineDash_.dashOffset = strokeState.GetLineDash().dashOffset;
+        }
+        if (!hasStrokeDashArray_) {
+            strokeDashArray_ = strokeState.GetStrokeDashArray();
+        }
+        if (!hasStrokeDashOffset_) {
+            strokeDashOffset_ = strokeState.GetStrokeDashOffset();
+        }
+        if (!hasGradient_) {
+            gradient_ = strokeState.GetGradient();
+        }
+    }
+
+    bool HasColor() const
+    {
+        return hasColor_;
+    }
+
+    bool HasOpacity() const
+    {
+        return hasOpacity_;
+    }
+
+    bool HasLineWidth() const
+    {
+        return hasLineWidth_;
+    }
+
+    bool HasMiterLimit() const
+    {
+        return hasMiterLimit_;
+    }
+
+    bool HasDashOffset() const
+    {
+        return hasDashOffset_;
+    }
+
+    void SetHref(const std::string& href)
+    {
+        href_ = href;
+    }
+
+    const std::string& GetHref() const
+    {
+        return href_;
+    }
+
+private:
+    Color color_ = Color::TRANSPARENT;
+    double opacity_ = 1.0;
+    LineCapStyle lineCap_ = LineCapStyle::BUTT;
+    LineJoinStyle lineJoin_ = LineJoinStyle::MITER;
+    double lineWidth_ = 1.0;
+    double miterLimit_ = 4.0;
+    LineDashParam lineDash_;
+    std::vector<double> strokeDashArray_;
+    double strokeDashOffset_;
+    std::string href_;
+    int vectorEffect_ = 0;
+    std::optional<Gradient> gradient_;
+
+    bool hasColor_ = false;
+    bool hasOpacity_ = false;
+    bool hasLineCap_ = false;
+    bool hasLineJoin_ = false;
+    bool hasLineWidth_ = false;
+    bool hasMiterLimit_ = false;
+    bool hasLineDash_ = false;
+    bool hasDashOffset_ = false;
+    bool hasStrokeDashArray_ = false;
+    bool hasStrokeDashOffset_ = false;
+    bool hasGradient_ = false;
+};
+
+class ClipState {
+public:
+    enum class ClipRule {
+        CLIP_RULE_EVENODD = 0,
+        CLIP_RULE_NONZERO
+    };
+
+    void SetClipRule(const ClipState::ClipRule clipRule, bool isSelf)
+    {
+        clipRule_ = clipRule;
+        hasClipRule_ = isSelf;
+    }
+
+    const ClipState::ClipRule GetClipRule() const
+    {
+        return clipRule_;
+    }
+
+    // Convert different interface values (FILL_RULE_NONZERO <===> PATH_FILL_TYPE_WINDING)
+    OH_Drawing_PathFillType GetClipRuleForDraw() {
+        if (IsEvenodd()) {
+            return OH_Drawing_PathFillType::PATH_FILL_TYPE_EVEN_ODD;
+        } else {
+            return OH_Drawing_PathFillType::PATH_FILL_TYPE_WINDING;
+        }
+    }
+
+    bool IsEvenodd() const
+    {
+        return clipRule_ == ClipRule::CLIP_RULE_EVENODD;
+    }
+
+    void SetHref(const std::string& href, bool isSelf)
+    {
+        href_ = href;
+        hasHref_ = isSelf;
+    }
+
+    const std::string& GetHref() const
+    {
+        return href_;
+    }
+
+    void Inherit(const ClipState& clipState)
+    {
+        if (!hasClipRule_) {
+            clipRule_ = clipState.GetClipRule();
+        }
+        if (!hasHref_) {
+            href_ = clipState.GetHref();
+        }
+    }
+
+private:
+    ClipState::ClipRule clipRule_ = ClipState::ClipRule::CLIP_RULE_NONZERO;
+    std::string href_;
+    bool hasClipRule_ = false;
+    bool hasHref_ = false;
+};
+
+} // namespace svg
+} // namespace rnoh