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

package/harmony/svg/src/main/cpp/properties/Dimension.h

@@ -0,0 +1,257 @@
+/*
+ * 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/dimension.h"
+#pragma once
+
+#include <cmath>
+#include <string>
+#include "Size.h"
+
+#define NEAR_ZERO(value) ((value > 0.0) ? ((value - 0.0) <= 0.000001f) : ((0.0 - value) <= 0.000001f))
+
+namespace rnoh {
+namespace svg {
+
+enum class DimensionUnit {
+    /*
+     * Unit is invalid.
+     */
+    INVALID = -2,
+    /*
+     * Unit is empty.
+     */
+    NONE = -1,
+    /*
+     * Logical pixel used in Ace1.0. It's based on frontend design width.
+     * For example, when a frontend with 750px design width running on a
+     * device with 1080 pixels width, 1px represents 1.44 pixels.
+     */
+    PX = 0,
+    /*
+     * Density independent pixels, one vp is one pixel on a 160 dpi screen.
+     */
+    VP,
+    /*
+     * Scale independent pixels. This is like VP but will be scaled by
+     * user's font size preference.
+     */
+    FP,
+    /*
+     * The percentage of either a value from the element's parent or from
+     * another property of the element itself.
+     */
+    PERCENT,
+    /*
+     * logic pixels used in ACE2.0 instead of PX, and PX is the physical pixels in ACE2.0
+     */
+    LPX,
+    /*
+     * The value is calculated from the element's parent and another property of the element itself.
+     */
+    AUTO,
+    /*
+     * The value is expression.
+     */
+    CALC,
+};
+
+enum class SvgLengthType {
+    HORIZONTAL,
+    VERTICAL,
+    OTHER,
+};
+
+/*
+ * Dimension contains a value and an unit to represent different
+ * scales in one class.
+ */
+class Dimension {
+public:
+    constexpr Dimension() = default;
+    ~Dimension() = default;
+    constexpr explicit Dimension(double value, DimensionUnit unit = DimensionUnit::PX) : value_(value), unit_(unit) {}
+
+    void Reset() {
+        value_ = 0.0;
+        unit_ = DimensionUnit::PX;
+    }
+
+    void ResetInvalidValue() {
+        if (std::isnan(value_)) {
+            Reset();
+        }
+    }
+
+    constexpr double Value() const { return value_; }
+
+    void SetValue(double value) { value_ = value; }
+
+    constexpr DimensionUnit Unit() const { return unit_; }
+
+    void SetUnit(DimensionUnit unit) { unit_ = unit; }
+
+    double RelativeConvertToPx(double baseLen, double scale) const;
+
+    double ConvertToPx(const Size &viewPort, SvgLengthType type, double scale) const;
+
+    // Percentage unit conversion is not supported.
+    double ConvertToVp(double scale) const {
+        if (unit_ == DimensionUnit::VP) {
+            return value_;
+        }
+        if (unit_ == DimensionUnit::PX) {
+            return value_ / scale;
+        }
+        return 0.0;
+    };
+
+    // Percentage unit conversion is not supported.
+    double ConvertToPx(double scale) const {
+        if (unit_ == DimensionUnit::NONE) {
+            return value_;
+        }
+        if (unit_ == DimensionUnit::PX) {
+            return value_;
+        }
+        if (unit_ == DimensionUnit::VP) {
+            return value_ * scale;
+        }
+        if (unit_ == DimensionUnit::FP) {
+            return value_ * scale;
+        }
+        return 0.0;
+    };
+
+    double ParsePropsToPx(double relative, float pointScaleFactor){
+        if (unit_ == DimensionUnit::NONE) {
+            return value_*pointScaleFactor;
+        }
+        if (unit_ == DimensionUnit::PERCENT) {
+            return value_*relative - pointScaleFactor;
+        }
+        if (unit_ == DimensionUnit::VP) {
+            return value_*pointScaleFactor;
+        } else {
+            return value_;
+        }  
+    }
+    
+    double GetNativeValue(DimensionUnit unit, double scale) const {
+        if (unit_ == unit) {
+            return value_;
+        } else if (unit == DimensionUnit::PX) {
+            return ConvertToPx(scale);
+        } else {
+            return ConvertToVp(scale);
+        }
+    }
+
+    double FromRelative(bool isObjectBoundingBoxUnit, double relative, double scale);
+
+    bool NormalizeToPx(double vpScale, double fpScale, double lpxScale, double parentLength, double &result) const;
+
+    constexpr Dimension operator*(double value) const { return Dimension(value_ * value, unit_); }
+
+    constexpr Dimension operator/(double value) const {
+        // NearZero cannot be used in a constant expression
+        if (NEAR_ZERO(value)) {
+            return {};
+        }
+        return Dimension(value_ / value, unit_);
+    }
+
+    bool operator==(const Dimension &dimension) const {
+        return (unit_ == dimension.unit_) && value_ == dimension.value_;
+    }
+
+    bool operator!=(const Dimension &dimension) const { return !operator==(dimension); }
+
+    /*
+     * Add two dimensions using the same unit.
+     */
+    constexpr Dimension operator+(const Dimension &dimension) const {
+        if (NEAR_ZERO(dimension.Value())) {
+            return *this;
+        }
+        return Dimension(value_ + dimension.value_, unit_);
+    }
+
+    /*
+     * Add a new dimension to itself using same unit.
+     */
+    Dimension &operator+=(const Dimension &dimension) {
+        value_ += dimension.value_;
+        return *this;
+    }
+
+    /*
+     * Minus a dimension using the same unit.
+     */
+    constexpr Dimension operator-(const Dimension &dimension) const {
+        if (NEAR_ZERO(dimension.Value())) {
+            return *this;
+        }
+        return Dimension(value_ - dimension.value_, unit_);
+    }
+
+    /*
+     * The opposite of dimension.
+     */
+    constexpr Dimension operator-() const { return Dimension(-value_, unit_); }
+
+    /*
+     * Minus a dimension to itself using the same unit.
+     */
+    Dimension &operator-=(const Dimension &dimension) {
+        value_ -= dimension.value_;
+        return *this;
+    }
+
+    bool operator>(const Dimension &dimension) const { return (value_ > dimension.value_); }
+
+    bool operator<(const Dimension &dimension) const { return (value_ < dimension.value_); }
+
+    std::string ToString() const;
+
+private:
+    double value_ = 0.0;
+    DimensionUnit unit_ = DimensionUnit::PX;
+};
+
+// literal operators for dimension
+inline constexpr Dimension operator""_vp(long double value) {
+    return Dimension(static_cast<double>(value), DimensionUnit::VP);
+}
+
+inline constexpr Dimension operator""_px(long double value) {
+    return Dimension(static_cast<double>(value), DimensionUnit::PX);
+}
+
+inline constexpr Dimension operator""_fp(long double value) {
+    return Dimension(static_cast<double>(value), DimensionUnit::FP);
+}
+
+inline constexpr Dimension operator""_pct(long double value) {
+    return Dimension(static_cast<double>(value), DimensionUnit::PERCENT);
+}
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/cpp/properties/Font.cpp

@@ -0,0 +1,166 @@
+/*
+ * 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 "Font.h"
+#include "utils/StringUtils.h"
+
+namespace rnoh {
+namespace svg {
+
+double FontData::toAbsolute(const std::string &value, double scale, double fontSz, double relative) {
+    auto val = StringUtils::FromString(value);
+    return val.RelativeConvertToPx(fontSz, scale);
+}
+
+void FontData::setInheritedWeight(const FontData &parent) {
+    absoluteFontWeight = parent.absoluteFontWeight;
+    fontWeight = parent.fontWeight;
+}
+
+void FontData::handleNumericWeight(const FontData &parent, double number) {
+    long weight = static_cast<long>(number);
+    if (weight >= 1 && weight <= 1000) {
+        absoluteFontWeight = static_cast<int>(weight);
+        fontWeight = nearestFontWeight(absoluteFontWeight);
+    } else {
+        setInheritedWeight(parent);
+    }
+}
+
+FontData::FontData(const FontProps &props, const FontData &parent, double scale) {
+    double parentFontSize = parent.fontSize;
+
+    if (!props.fontSize.empty()) {
+        fontSize = toAbsolute(props.fontSize, scale, parentFontSize, parentFontSize);
+    } else {
+        fontSize = parentFontSize;
+    }
+
+    if (!props.fontWeight.empty()) {
+        fontWeight = fontWeightFromStr(props.fontWeight);
+        if (fontWeight != FontWeight::unknown) {
+            absoluteFontWeight = from(fontWeight, parent);
+            fontWeight = nearestFontWeight(absoluteFontWeight);
+        } else {
+            handleNumericWeight(parent, StringUtils::FromString(props.fontWeight).Value());
+        }
+    } else {
+        setInheritedWeight(parent);
+    }
+
+    fontFamily = !props.fontFamily.empty() ? props.fontFamily : parent.fontFamily;
+    fontStyle = !props.fontStyle.empty() ? fontStyleFromStr(props.fontStyle) : parent.fontStyle;
+    fontFeatureSettings = !props.fontFeatureSettings.empty() ? props.fontFeatureSettings : parent.fontFeatureSettings;
+    fontVariationSettings =
+        !props.fontVariationSettings.empty() ? props.fontVariationSettings : parent.fontVariationSettings;
+    fontVariantLigatures = !props.fontVariantLigatures.empty() ? fontVariantFromStr(props.fontVariantLigatures)
+                                                               : parent.fontVariantLigatures;
+
+    textAnchor = !props.textAnchor.empty() ? textAnchorFromStr(props.textAnchor) : parent.textAnchor;
+    textDecoration =
+        !props.textDecoration.empty() ? textDecorationFromStr(props.textDecoration) : parent.textDecoration;
+
+    bool hasKerning = !props.kerning.empty();
+    manualKerning = hasKerning || parent.manualKerning;
+
+    kerning = hasKerning ? toAbsolute(props.kerning, scale, fontSize, 0) : parent.kerning;
+    wordSpacing = !props.wordSpacing.empty() ? toAbsolute(props.wordSpacing, scale, fontSize, 0) : parent.wordSpacing;
+    letterSpacing =
+        !props.letterSpacing.empty() ? toAbsolute(props.letterSpacing, scale, fontSize, 0) : parent.letterSpacing;
+}
+
+const double FontData::DEFAULT_FONT_SIZE = 3.25 * 12.0;
+const double FontData::DEFAULT_KERNING = 0.0;
+const double FontData::DEFAULT_WORD_SPACING = 0.0;
+const double FontData::DEFAULT_LETTER_SPACING = 0.0;
+
+const FontWeight FontData::WEIGHTS[] = {FontWeight::w100,   FontWeight::w200, FontWeight::w300,
+                                        FontWeight::normal, FontWeight::w500, FontWeight::w600,
+                                        FontWeight::bold,   FontWeight::w800, FontWeight::w900};
+
+const int FontData::absoluteFontWeights[] = {400, 700, 100, 200, 300, 400, 500, 600, 700, 800, 900};
+
+FontStyle fontStyleFromStr(const std::string &str) {
+    if (str == "normal") {
+        return FontStyle::normal;
+    } else if (str == "italic") {
+        return FontStyle::italic;
+    } else if (str == "oblique") {
+        return FontStyle::oblique;
+    } else {
+        // Default case
+        return FontStyle::normal;
+    }
+}
+
+FontWeight fontWeightFromStr(const std::string &str) {
+    if (str == "w100") {
+        return FontWeight::w100;
+    } else if (str == "w200") {
+        return FontWeight::w200;
+    } else if (str == "w300") {
+        return FontWeight::w300;
+    } else if (str == "normal") {
+        return FontWeight::normal;
+    } else if (str == "w500") {
+        return FontWeight::w500;
+    } else if (str == "w600") {
+        return FontWeight::w600;
+    } else if (str == "bold") {
+        return FontWeight::bold;
+    } else if (str == "w800") {
+        return FontWeight::w800;
+    } else if (str == "w900") {
+        return FontWeight::w900;
+    } else if (str == "lighter") {
+        return FontWeight::lighter;
+    } else if (str == "bolder") {
+        return FontWeight::bolder;
+    }
+    return FontWeight::unknown;
+}
+
+TextAnchor textAnchorFromStr(const std::string &str) {
+    if (str == "start") {
+        return TextAnchor::start;
+    } else if (str == "middle") {
+        return TextAnchor::middle;
+    } else if (str == "end") {
+        return TextAnchor::end;
+    } else {
+        // Default case
+        return TextAnchor::start;
+    }
+}
+
+TextDecoration textDecorationFromStr(const std::string &str) {
+    if (str == "None") {
+        return TextDecoration::None;
+    } else if (str == "Underline") {
+        return TextDecoration::Underline;
+    } else if (str == "Overline") {
+        return TextDecoration::Overline;
+    } else if (str == "LineThrough") {
+        return TextDecoration::LineThrough;
+    } else {
+        // Default case
+        return TextDecoration::None;
+    }
+}
+
+FontVariantLigatures fontVariantFromStr(const std::string &str) {
+    if (str == "normal") {
+        return FontVariantLigatures::normal;
+    } else if (str == "none") {
+        return FontVariantLigatures::none;
+    } else {
+        // Default case
+        return FontVariantLigatures::normal;
+    }
+}
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/cpp/properties/Font.h

@@ -0,0 +1,163 @@
+/*
+ * 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 <string>
+
+namespace rnoh {
+namespace svg {
+
+constexpr int LIGHTER_THRESHOLD_550 = 550;
+constexpr int LIGHTER_THRESHOLD_750 = 750;
+constexpr int BOLDER_THRESHOLD_350 = 350;
+constexpr int BOLDER_THRESHOLD_550 = 550;
+constexpr int BOLDER_THRESHOLD_900 = 900;
+constexpr int DEFAULT_BOLDER_WEIGHT = 400;
+constexpr int DEFAULT_LIGHTER_WEIGHT = 100;
+constexpr int DEFAULT_MEDIUM_WEIGHT = 400;
+constexpr int DEFAULT_BOLDER_WEIGHT_700 = 700;
+constexpr int DEFAULT_BOLDER_WEIGHT_900 = 900;
+
+enum class FontStyle { normal, italic, oblique };
+
+enum class FontWeight {
+    w100,
+    w200,
+    w300,
+    normal,
+    w500,
+    w600,
+    bold,
+    w800,
+    w900,
+    bolder,
+    lighter,
+    unknown,
+};
+
+// match with <native_drawing/drawing_text_typography.h>
+enum class TextAnchor { start = 4, middle = 2, end = 5 };
+
+// match with <native_drawing/drawing_text_typography.h>
+enum class TextDecoration { None = 0x0, Underline = 0x1, Overline = 0x2, LineThrough = 0x4 };
+
+enum class FontVariantLigatures { normal, none };
+
+FontStyle fontStyleFromStr(const std::string &str);
+FontWeight fontWeightFromStr(const std::string &str);
+TextAnchor textAnchorFromStr(const std::string &str);
+TextDecoration textDecorationFromStr(const std::string &str);
+FontVariantLigatures fontVariantFromStr(const std::string &str);
+
+// intermediate data to store in Svg nodes
+struct FontProps {
+    std::string fontStyle;
+    std::string fontVariant;
+    std::string fontWeight;
+    std::string fontStretch;
+    std::string fontSize;
+    std::string fontFamily;
+    std::string textAnchor;
+    std::string textDecoration;
+    std::string letterSpacing;
+    std::string wordSpacing;
+    std::string kerning;
+    std::string fontFeatureSettings;
+    std::string fontVariantLigatures;
+    std::string fontVariationSettings;
+
+    inline bool Empty() const {
+        return fontStyle.empty() && fontVariant.empty() && fontWeight.empty() && fontStretch.empty() &&
+               fontSize.empty() && fontFamily.empty() && textAnchor.empty() && textDecoration.empty() &&
+               letterSpacing.empty() && wordSpacing.empty() && kerning.empty() && fontFeatureSettings.empty() &&
+               fontVariantLigatures.empty() && fontVariationSettings.empty();
+    }
+};
+
+class FontData {
+public:
+    FontData() = default;
+    FontData(const FontProps &props, const FontData &parent, double scale);
+
+    static const double DEFAULT_FONT_SIZE;
+    static const double DEFAULT_KERNING;
+    static const double DEFAULT_WORD_SPACING;
+    static const double DEFAULT_LETTER_SPACING;
+
+    /* ------- Props -------- */
+    double fontSize = DEFAULT_FONT_SIZE;
+    std::string fontFamily;
+    FontStyle fontStyle = FontStyle::normal;
+    FontWeight fontWeight = FontWeight::normal;
+    int absoluteFontWeight = 400;
+    std::string fontFeatureSettings;
+    std::string fontVariationSettings;
+    FontVariantLigatures fontVariantLigatures = FontVariantLigatures::normal;
+    TextAnchor textAnchor = TextAnchor::start;
+    TextDecoration textDecoration = TextDecoration::None;
+
+    double kerning = DEFAULT_KERNING;
+    double wordSpacing = DEFAULT_WORD_SPACING;
+    double letterSpacing = DEFAULT_LETTER_SPACING;
+
+    bool manualKerning = false;
+    /* -------------------- */
+
+    double toAbsolute(const std::string &value, double scale, double fontSize, double relative);
+
+    void setInheritedWeight(const FontData &parent);
+
+    void handleNumericWeight(const FontData &parent, double number);
+
+private:
+    static const int normal = 400;
+
+    static const FontWeight WEIGHTS[];
+
+    static FontWeight nearestFontWeight(int abFontWeight) {
+        return WEIGHTS[static_cast<int>(abFontWeight / 100.0f)];
+    }
+
+    static const int absoluteFontWeights[];
+
+    static int from(FontWeight fontW, const FontData &parent) {
+        if (fontW == FontWeight::bolder) {
+            return WeightToBolder(parent.absoluteFontWeight);
+        } else if (fontW == FontWeight::lighter) {
+            return lighter(parent.absoluteFontWeight);
+        } else {
+            return absoluteFontWeights[static_cast<int>(fontW)];
+        }
+    }
+
+    static int WeightToBolder(int inherited) {
+        if (inherited < BOLDER_THRESHOLD_350) {
+            return DEFAULT_BOLDER_WEIGHT;
+        } else if (inherited < BOLDER_THRESHOLD_550) {
+            return DEFAULT_BOLDER_WEIGHT_700;
+        } else if (inherited < BOLDER_THRESHOLD_900) {
+            return DEFAULT_BOLDER_WEIGHT_900;
+        } else {
+            return inherited;
+        }
+    }
+
+    static int lighter(int inherited) {
+        if (inherited < DEFAULT_LIGHTER_WEIGHT) {
+            return inherited;
+        } else if (inherited < LIGHTER_THRESHOLD_550) {
+            return DEFAULT_LIGHTER_WEIGHT;
+        } else if (inherited < LIGHTER_THRESHOLD_750) {
+            return DEFAULT_MEDIUM_WEIGHT;
+        } else {
+            return DEFAULT_BOLDER_WEIGHT_700;
+        }
+    }
+};
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/cpp/properties/Offset.h

@@ -0,0 +1,119 @@
+/*
+ * 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/offset.h"
+#pragma once
+
+#include <cmath>
+#include <limits>
+
+#include "properties/Size.h"
+#include "utils/SvgUtils.h"
+
+namespace rnoh {
+namespace svg {
+
+class Offset {
+public:
+    Offset() = default;
+    ~Offset() = default;
+    Offset(double deltaX, double deltaY) : deltaX_(deltaX), deltaY_(deltaY) {}
+
+    void Reset() {
+        deltaX_ = 0.0;
+        deltaY_ = 0.0;
+    }
+
+    static Offset Zero() { return Offset(); }
+
+    static Offset ErrorOffset() {
+        return Offset((std::numeric_limits<double>::max)(), (std::numeric_limits<double>::max)());
+    }
+
+    bool IsZero() const { return operator==(Offset()); }
+
+    bool IsErrorOffset() const { return operator==(ErrorOffset()); }
+
+    double GetX() const { return deltaX_; }
+
+    double GetY() const { return deltaY_; }
+
+    void SetX(double x) { deltaX_ = x; }
+
+    void SetY(double y) { deltaY_ = y; }
+
+    void AddX(double x) { deltaX_ += x; }
+
+    void AddY(double y) { deltaY_ += y; }
+
+    double GetDistance() const { return std::sqrt((deltaX_ * deltaX_) + (deltaY_ * deltaY_)); }
+
+    Offset operator+(const Offset &offset) const { return Offset(deltaX_ + offset.deltaX_, deltaY_ + offset.deltaY_); }
+
+    Offset operator+(const Size &size) const { return Offset(deltaX_ + size.Width(), deltaY_ + size.Height()); }
+
+    Offset operator-(const Offset &offset) const { return Offset(deltaX_ - offset.deltaX_, deltaY_ - offset.deltaY_); }
+
+    Offset operator-(const Size &size) const { return Offset(deltaX_ - size.Width(), deltaY_ - size.Height()); }
+
+    Offset operator*(double value) const { return Offset(deltaX_ * value, deltaY_ * value); }
+
+    Offset operator/(double value) const {
+        if (NearZero(value)) {
+            return ErrorOffset();
+        }
+        return Offset(deltaX_ / value, deltaY_ / value);
+    }
+
+    Offset &operator+=(const Offset &offset) {
+        deltaX_ += offset.deltaX_;
+        deltaY_ += offset.deltaY_;
+        return *this;
+    }
+
+    Offset &operator-=(const Offset &offset) {
+        deltaX_ -= offset.deltaX_;
+        deltaY_ -= offset.deltaY_;
+        return *this;
+    }
+
+    bool operator==(const Offset &offset) const {
+        return NearEqual(deltaX_, offset.deltaX_) && NearEqual(deltaY_, offset.deltaY_);
+    }
+
+    bool operator!=(const Offset &offset) const { return !operator==(offset); }
+
+    std::string ToString() const {
+        std::stringstream ss;
+        ss << "Offset (" << std::fixed << std::setprecision(2) << deltaX_ << ", " << deltaY_ << ")";
+        std::string output = ss.str();
+        return output;
+    }
+
+    bool IsPositiveOffset() const { return deltaX_ >= 0 && deltaY_ >= 0; }
+
+private:
+    double deltaX_ = 0.0;
+    double deltaY_ = 0.0;
+};
+
+} // namespace svg
+} // namespace rnoh