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

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

@@ -1,458 +0,0 @@
-/*
- * 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/color.cpp"
-#pragma once
-
-#include <cstdint>
-#include <regex>
-#include "Color.h"
-#include "utils/SvgUtils.h"
-#include "utils/StringUtils.h"
-#include "utils/LinearMap.h"
-
-namespace rnoh {
-namespace svg {
-
-namespace {
-
-constexpr uint32_t COLOR_ALPHA_OFFSET = 24;
-constexpr uint32_t COLOR_STRING_SIZE_STANDARD = 8;
-constexpr uint32_t COLOR_STRING_BASE = 16;
-constexpr uint32_t RGB_SUB_MATCH_SIZE = 4;
-constexpr uint32_t RGBA_SUB_MATCH_SIZE = 5;
-
-const std::regex COLOR_WITH_MAGIC("#[0-9A-Fa-f]{6,8}");
-const std::regex COLOR_WITH_MAGIC_MINI("#[0-9A-Fa-f]{3,4}");
-const std::regex COLOR_WITH_RGB(R"(rgb\(([0-9]{1,3})\,([0-9]{1,3})\,([0-9]{1,3})\))", std::regex::icase);
-const std::regex COLOR_WITH_RGBA(R"(rgba\(([0-9]{1,3})\,([0-9]{1,3})\,([0-9]{1,3})\,(\d+\.?\d*)\))", std::regex::icase);
-constexpr double GAMMA_FACTOR = 2.2;
-constexpr float MAX_ALPHA = 255.0f;
-constexpr char HEX[] = "0123456789ABCDEF";
-constexpr uint8_t BIT_LENGTH_INT32 = 8;
-constexpr uint8_t MIN_RGB_VALUE = 0;
-constexpr uint8_t MAX_RGB_VALUE = 255;
-constexpr double MIN_RGBA_OPACITY = 0.0;
-constexpr double MAX_RGBA_OPACITY = 1.0;
-
-} // namespace
-
-const Color Color::TRANSPARENT = Color(0x00000000);
-const Color Color::WHITE = Color(0xffffffff);
-const Color Color::BLACK = Color(0xff000000);
-const Color Color::RED = Color(0xffff0000);
-const Color Color::GREEN = Color(0xff00ff00);
-const Color Color::BLUE = Color(0xff0000ff);
-const Color Color::GRAY = Color(0xffc0c0c0);
-const Color Color::FOREGROUND = Color(0x00000001); // foreground color and foreground color strategy identification
-
-Color Color::FromString(std::string colorStr, uint32_t maskAlpha, Color defaultColor) {
-    if (colorStr.empty()) {
-        // empty string, return transparent
-        return Color::TRANSPARENT;
-    }
-
-    // Remove all " ".
-    colorStr.erase(std::remove(colorStr.begin(), colorStr.end(), ' '), colorStr.end());
-
-    std::smatch matches;
-    // Regex match for #909090 or #90909090.
-    if (std::regex_match(colorStr, matches, COLOR_WITH_MAGIC)) {
-        colorStr.erase(0, 1);
-        auto value = stoul(colorStr, nullptr, COLOR_STRING_BASE);
-        if (colorStr.length() < COLOR_STRING_SIZE_STANDARD) {
-            // no alpha specified, set alpha to 0xff
-            value |= maskAlpha;
-        }
-        return Color(value);
-    }
-    // Regex match for #rgb or #rgba.
-    if (std::regex_match(colorStr, matches, COLOR_WITH_MAGIC_MINI)) {
-        colorStr.erase(0, 1);
-        std::string newColorStr;
-        // translate #rgb or #rgba to #rrggbb or #rrggbbaa
-        for (auto &c : colorStr) {
-            newColorStr += c;
-            newColorStr += c;
-        }
-        auto value = stoul(newColorStr, nullptr, COLOR_STRING_BASE);
-        if (newColorStr.length() < COLOR_STRING_SIZE_STANDARD) {
-            // no alpha specified, set alpha to 0xff
-            value |= maskAlpha;
-        }
-        return Color(value);
-    }
-    // Regex match for rgb(90,254,180).
-    if (std::regex_match(colorStr, matches, COLOR_WITH_RGB)) {
-        if (matches.size() == RGB_SUB_MATCH_SIZE) {
-            auto red = static_cast<uint8_t>(std::stoi(matches[1]));   // red value.
-            auto green = static_cast<uint8_t>(std::stoi(matches[2])); // green value.
-            auto blue = static_cast<uint8_t>(std::stoi(matches[3]));  // blue value.
-            return FromRGB(red, green, blue);
-        }
-    }
-    // Regex match for rgba(90,254,180,0.5).
-    if (std::regex_match(colorStr, matches, COLOR_WITH_RGBA)) {
-        if (matches.size() == RGBA_SUB_MATCH_SIZE) {
-            auto red = static_cast<uint8_t>(std::stoi(matches[1]));
-            auto green = static_cast<uint8_t>(std::stoi(matches[2]));
-            auto blue = static_cast<uint8_t>(std::stoi(matches[3]));
-            auto opacity = static_cast<double>(std::stod(matches[4]));
-            return FromRGBO(red, green, blue, opacity);
-        }
-    }
-    // match for special string
-    static const LinearMapNode<Color> colorTable[] = {
-        {"black", Color(0xff000000)}, {"blue", Color(0xff0000ff)}, {"gray", Color(0xffc0c0c0)},
-        {"green", Color(0xff00ff00)}, {"red", Color(0xffff0000)},  {"white", Color(0xffffffff)},
-    };
-    int64_t colorIndex = BinarySearchFindIndex(colorTable, ArraySize(colorTable), colorStr.c_str());
-    if (colorIndex != -1) {
-        return colorTable[colorIndex].value;
-    }
-
-    // parse uint32_t color string.
-    auto uint32Color = StringUtils::StringToUint(colorStr);
-    if (uint32Color > 0) {
-        Color value;
-        if (uint32Color >> COLOR_ALPHA_OFFSET == 0) {
-            value = Color(uint32Color).ChangeAlpha(MAX_ALPHA);
-        } else {
-            value = Color(uint32Color);
-        }
-        return value;
-    }
-
-    // Default color.
-    return defaultColor;
-}
-
-Color Color::FromARGB(uint8_t alpha, uint8_t red, uint8_t green, uint8_t blue)
-{
-    ColorParam colorValue {
-#if BIG_ENDIANNESS
-        .argb = { .alpha = alpha, .red = red, .green = green, .blue = blue }
-#else
-        .argb = { .blue = blue, .green = green, .red = red, .alpha = alpha }
-#endif
-    };
-    return Color(colorValue);
-}
-
-Color Color::FromRGBO(uint8_t red, uint8_t green, uint8_t blue, double opacity)
-{
-    return FromARGB(static_cast<uint8_t>(round(opacity * 0xff)) & 0xff, red, green, blue);
-}
-
-Color Color::FromRGB(uint8_t red, uint8_t green, uint8_t blue)
-{
-    return FromARGB(0xff, red, green, blue);
-}
-
-Color Color::BlendColor(const Color& overlayColor) const
-{
-    if (GetValue() == Color::TRANSPARENT.GetValue()) {
-        return overlayColor;
-    }
-    if (GetAlpha() < static_cast<uint8_t>(MAX_ALPHA)) {
-        return BlendColorWithAlpha(overlayColor);
-    }
-    auto alphaRate = static_cast<float>(overlayColor.GetAlpha()) / MAX_ALPHA;
-    auto newRed = static_cast<uint8_t>(GetRed() * (1.0f - alphaRate) + overlayColor.GetRed() * alphaRate);
-    auto newGreen = static_cast<uint8_t>(GetGreen() * (1.0f - alphaRate) + overlayColor.GetGreen() * alphaRate);
-    auto newBlue = static_cast<uint8_t>(GetBlue() * (1.0f - alphaRate) + overlayColor.GetBlue() * alphaRate);
-    return Color::FromRGB(newRed, newGreen, newBlue);
-}
-
-float Color::CalculateBlend(float alphaLeft, float alphaRight, float valueLeft, float valueRight) const
-{
-    return (valueLeft * alphaLeft * (1.0 - alphaRight) + valueRight * alphaRight) /
-           (alphaLeft + alphaRight - alphaLeft * alphaRight);
-}
-
-Color Color::BlendColorWithAlpha(const Color& overlayColor) const
-{
-    float alphaA = GetAlpha() / 255.0;
-    float alphaB = overlayColor.GetAlpha() / 255.0;
-    float blendAlpha = alphaA + alphaB - alphaA * alphaB;
-    float blendRed = CalculateBlend(alphaA, alphaB, GetRed() / 255.0, overlayColor.GetRed() / 255.0);
-    float blendGreen = CalculateBlend(alphaA, alphaB, GetGreen() / 255.0, overlayColor.GetGreen() / 255.0);
-    float blendBlue = CalculateBlend(alphaA, alphaB, GetBlue() / 255.0, overlayColor.GetBlue() / 255.0);
-
-    return Color::FromARGB(blendAlpha * 255, blendRed * 255, blendGreen * 255, blendBlue * 255);
-}
-
-const Color Color::LineColorTransition(const Color& startColor, const Color& endColor, double percent)
-{
-    uint8_t red = 0;
-    uint8_t green = 0;
-    uint8_t blue = 0;
-    uint8_t alpha = 0;
-
-    red = static_cast<uint8_t>((endColor.GetRed()- startColor.GetRed()) * percent) + startColor.GetRed();
-    green = static_cast<uint8_t>((endColor.GetGreen() - startColor.GetGreen()) * percent) + startColor.GetGreen();
-    blue = static_cast<uint8_t>((endColor.GetBlue() - startColor.GetBlue()) * percent) + startColor.GetBlue();
-    alpha = static_cast<uint8_t>((endColor.GetAlpha() - startColor.GetAlpha()) * percent) + startColor.GetAlpha();
-
-    return Color::FromARGB(alpha, red, green, blue);
-}
-
-Color Color::BlendOpacity(double opacityRatio) const
-{
-    int32_t alpha = static_cast<int32_t>(GetAlpha() * opacityRatio);
-    alpha = std::clamp(alpha, 0, UINT8_MAX);
-    return Color::FromARGB(alpha, GetRed(), GetGreen(), GetBlue());
-}
-
-Color Color::ChangeOpacity(double opacity) const
-{
-    return Color::FromRGBO(GetRed(), GetGreen(), GetBlue(), opacity);
-}
-
-Color Color::ChangeAlpha(uint8_t alpha) const
-{
-    return Color::FromARGB(alpha, GetRed(), GetGreen(), GetBlue());
-}
-
-Color Color::operator+(const Color& color) const
-{
-    // convert first color from ARGB to linear
-    double firstLinearRed = 0.0;
-    double firstLinearGreen = 0.0;
-    double firstLinearBlue = 0.0;
-    ConvertGammaToLinear(*this, firstLinearRed, firstLinearGreen, firstLinearBlue);
-
-    // convert second color from ARGB to linear
-    double secondLinearRed = 0.0;
-    double secondLinearGreen = 0.0;
-    double secondLinearBlue = 0.0;
-    ConvertGammaToLinear(color, secondLinearRed, secondLinearGreen, secondLinearBlue);
-
-    // get linear result and convert to gamma
-    return ConvertLinearToGamma(GetAlpha() + color.GetAlpha(), firstLinearRed + secondLinearRed,
-        firstLinearGreen + secondLinearGreen, firstLinearBlue + secondLinearBlue);
-}
-
-Color Color::operator-(const Color& color) const
-{
-    // convert first color from ARGB to linear
-    double firstLinearRed = 0.0;
-    double firstLinearGreen = 0.0;
-    double firstLinearBlue = 0.0;
-    ConvertGammaToLinear(*this, firstLinearRed, firstLinearGreen, firstLinearBlue);
-
-    // convert second color from ARGB to linear
-    double secondLinearRed = 0.0;
-    double secondLinearGreen = 0.0;
-    double secondLinearBlue = 0.0;
-    ConvertGammaToLinear(color, secondLinearRed, secondLinearGreen, secondLinearBlue);
-
-    // get linear result and convert to gamma
-    return ConvertLinearToGamma(GetAlpha() - color.GetAlpha(), firstLinearRed - secondLinearRed,
-        firstLinearGreen - secondLinearGreen, firstLinearBlue - secondLinearBlue);
-}
-
-Color Color::operator*(double value) const
-{
-    // convert color from ARGB to linear
-    double linearRed = 0.0;
-    double linearGreen = 0.0;
-    double linearBlue = 0.0;
-    ConvertGammaToLinear(*this, linearRed, linearGreen, linearBlue);
-
-    // get linear result and convert to gamma
-    return ConvertLinearToGamma(GetAlpha() * value, linearRed * value, linearGreen * value, linearBlue * value);
-}
-
-Color Color::operator/(double value) const
-{
-    if (NearZero(value)) {
-        return *this;
-    }
-    // convert color from ARGB to linear
-    double linearRed = 0.0;
-    double linearGreen = 0.0;
-    double LinearBlue = 0.0;
-    ConvertGammaToLinear(*this, linearRed, linearGreen, LinearBlue);
-
-    // get linear result and convert to gamma
-    return ConvertLinearToGamma(GetAlpha() / value, linearRed / value, linearGreen / value, LinearBlue / value);
-}
-
-double Color::ConvertGammaToLinear(uint8_t value)
-{
-    return std::pow(value, GAMMA_FACTOR);
-}
-
-uint8_t Color::ConvertLinearToGamma(double value)
-{
-    return std::clamp(static_cast<int32_t>(round(std::pow(value, 1.0 / GAMMA_FACTOR))), 0, UINT8_MAX);
-}
-
-void Color::ConvertGammaToLinear(const Color& gammaColor, double& linearRed, double& linearGreen, double& linearBlue)
-{
-    linearRed = ConvertGammaToLinear(gammaColor.GetRed());
-    linearGreen = ConvertGammaToLinear(gammaColor.GetGreen());
-    linearBlue = ConvertGammaToLinear(gammaColor.GetBlue());
-}
-
-Color Color::ConvertLinearToGamma(double alpha, double linearRed, double linearGreen, double linearBlue)
-{
-    uint8_t gammaRed = ConvertLinearToGamma(linearRed);
-    uint8_t gammaGreen = ConvertLinearToGamma(linearGreen);
-    uint8_t gammaBlue = ConvertLinearToGamma(linearBlue);
-    uint8_t gammaAlpha = std::clamp(static_cast<int32_t>(round(alpha)), 0, UINT8_MAX);
-
-    return FromARGB(gammaAlpha, gammaRed, gammaGreen, gammaBlue);
-}
-
-bool Color::MatchColorWithMagic(std::string& colorStr, uint32_t maskAlpha, Color& color)
-{
-    std::smatch matches;
-    // Regex match for #909090 or #90909090.
-    if (std::regex_match(colorStr, matches, COLOR_WITH_MAGIC)) {
-        colorStr.erase(0, 1);
-        auto value = stoul(colorStr, nullptr, COLOR_STRING_BASE);
-        if (colorStr.length() < COLOR_STRING_SIZE_STANDARD) {
-            // no alpha specified, set alpha to 0xff
-            value |= maskAlpha;
-        }
-        color = Color(value);
-        return true;
-    }
-
-    return false;
-}
-
-bool Color::MatchColorWithMagicMini(std::string& colorStr, uint32_t maskAlpha, Color& color)
-{
-    std::smatch matches;
-    if (std::regex_match(colorStr, matches, COLOR_WITH_MAGIC_MINI)) {
-        colorStr.erase(0, 1);
-        std::string newColorStr;
-        // translate #rgb or #rgba to #rrggbb or #rrggbbaa
-        for (auto& c : colorStr) {
-            newColorStr += c;
-            newColorStr += c;
-        }
-        auto value = stoul(newColorStr, nullptr, COLOR_STRING_BASE);
-        if (newColorStr.length() < COLOR_STRING_SIZE_STANDARD) {
-            // no alpha specified, set alpha to 0xff
-            value |= maskAlpha;
-        }
-        color = Color(value);
-        return true;
-    }
-
-    return false;
-}
-
-bool Color::MatchColorWithRGB(const std::string& colorStr, Color& color)
-{
-    std::smatch matches;
-    if (std::regex_match(colorStr, matches, COLOR_WITH_RGB)) {
-        if (matches.size() == RGB_SUB_MATCH_SIZE) {
-            auto redInt = std::stoi(matches[1]);
-            auto greenInt = std::stoi(matches[2]);
-            auto blueInt = std::stoi(matches[3]);
-            if (!IsRGBValid(redInt) || !IsRGBValid(greenInt) || !IsRGBValid(blueInt)) {
-                return false;
-            }
-
-            auto red = static_cast<uint8_t>(redInt);
-            auto green = static_cast<uint8_t>(greenInt);
-            auto blue = static_cast<uint8_t>(blueInt);
-            color = FromRGB(red, green, blue);
-            return true;
-        }
-    }
-    return false;
-}
-
-bool Color::MatchColorWithRGBA(const std::string& colorStr, Color& color)
-{
-    std::smatch matches;
-    if (std::regex_match(colorStr, matches, COLOR_WITH_RGBA)) {
-        if (matches.size() == RGBA_SUB_MATCH_SIZE) {
-            auto redInt = std::stoi(matches[1]);
-            auto greenInt = std::stoi(matches[2]);
-            auto blueInt = std::stoi(matches[3]);
-            auto opacityDouble = std::stod(matches[4]);
-            if (!IsRGBValid(redInt) || !IsRGBValid(greenInt) || !IsRGBValid(blueInt) ||
-                !IsOpacityValid(opacityDouble)) {
-                return false;
-            }
-
-            auto red = static_cast<uint8_t>(redInt);
-            auto green = static_cast<uint8_t>(greenInt);
-            auto blue = static_cast<uint8_t>(blueInt);
-            auto opacity = static_cast<double>(opacityDouble);
-
-            color = FromRGBO(red, green, blue, opacity);
-            return true;
-        }
-    }
-
-    return false;
-}
-
-bool Color::ParseUintColorString(const std::string& colorStr, Color& color, const Color& defaultColor)
-{
-    auto uint32Color = StringUtils::StringToUintCheck(colorStr, defaultColor.GetValue());
-    if (uint32Color > 0) {
-        if (uint32Color >> COLOR_ALPHA_OFFSET == 0) {
-            color = Color(uint32Color).ChangeAlpha(MAX_ALPHA);
-        } else {
-            color = Color(uint32Color);
-        }
-        return true;
-    }
-
-    return false;
-}
-
-bool Color::ParseUintColorString(const std::string& colorStr, Color& color)
-{
-    auto uint32Color = StringUtils::StringToUint(colorStr);
-    if (uint32Color > 0) {
-        if (uint32Color >> COLOR_ALPHA_OFFSET == 0) {
-            color = Color(uint32Color).ChangeAlpha(MAX_ALPHA);
-        } else {
-            color = Color(uint32Color);
-        }
-        return true;
-    }
-
-    return false;
-}
-
-bool Color::IsRGBValid(int value)
-{
-    return value >= MIN_RGB_VALUE && value <= MAX_RGB_VALUE;
-}
-
-bool Color::IsOpacityValid(double value)
-{
-    return value >= MIN_RGBA_OPACITY && value <= MAX_RGBA_OPACITY;
-}
-
-} // namespace svg
-} // namespace rnoh

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

@@ -1,144 +0,0 @@
-/*
- * 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/color.h"
-#pragma once
-
-#include <cstdint>
-#include <string>
-namespace rnoh {
-namespace svg {
-
-constexpr uint32_t COLOR_ALPHA_MASK = 0xff000000;
-
-union ColorParam {
-#if BIG_ENDIANNESS
-    struct {
-        uint8_t alpha;
-        uint8_t red;
-        uint8_t green;
-        uint8_t blue;
-    } argb;
-#else
-    struct {
-        uint8_t blue;
-        uint8_t green;
-        uint8_t red;
-        uint8_t alpha;
-    } argb;
-#endif
-    uint32_t value;
-};
-
-enum class ForegroundColorStrategy : char {
-    NONE,
-    INVERT,
-};
-
-class Color {
-public:
-    Color() = default;
-    constexpr explicit Color(uint32_t value) : colorValue_(ColorParam{.value = value}) {}
-    ~Color() = default;
-
-    static Color FromARGB(uint8_t alpha, uint8_t red, uint8_t green, uint8_t blue);
-    static Color FromRGBO(uint8_t red, uint8_t green, uint8_t blue, double opacity);
-    static Color FromRGB(uint8_t red, uint8_t green, uint8_t blue);
-    // Need to change the input parameters, it is more appropriate to use the passed value here.
-    static Color FromString(std::string colorStr, uint32_t maskAlpha = COLOR_ALPHA_MASK,
-                            Color defaultColor = Color::BLACK);
-    // Return the linear transition color from startColor to endColor.
-    static const Color LineColorTransition(const Color &startColor, const Color &endColor, double percent);
-
-    static const Color TRANSPARENT;
-    static const Color WHITE;
-    static const Color BLACK;
-    static const Color RED;
-    static const Color GREEN;
-    static const Color BLUE;
-    static const Color GRAY;
-    static const Color FOREGROUND;
-
-    Color BlendColor(const Color &overlayColor) const;
-
-    Color BlendColorWithAlpha(const Color &overlayColor) const;
-    Color BlendOpacity(double opacityRatio) const;
-    Color ChangeOpacity(double opacity) const;
-    Color ChangeAlpha(uint8_t alpha) const;
-
-    void SetValue(uint32_t value) { colorValue_.value = value; }
-
-    uint32_t GetValue() const { return colorValue_.value; }
-
-    uint8_t GetAlpha() const { return colorValue_.argb.alpha; }
-
-    uint8_t GetRed() const { return colorValue_.argb.red; }
-
-    uint8_t GetGreen() const { return colorValue_.argb.green; }
-
-    uint8_t GetBlue() const { return colorValue_.argb.blue; }
-
-    bool operator==(const Color &color) const { return colorValue_.value == color.GetValue(); }
-
-    bool operator!=(const Color &color) const { return !operator==(color); }
-
-    Color operator+(const Color &color) const;
-
-    Color operator-(const Color &color) const;
-
-    Color operator*(double value) const;
-
-    Color operator/(double value) const;
-
-    std::string ToString() const {
-        return "[ARGB](" + std::to_string(colorValue_.argb.alpha) + ", " + std::to_string(colorValue_.argb.red) + ", " +
-               std::to_string(colorValue_.argb.green) + ", " + std::to_string(colorValue_.argb.blue) + ")";
-    }
-
-    void SetUseCurrentColor(const bool& useCurrentColor) { UseCurrentColor = useCurrentColor; }
-
-    bool IsUseCurrentColor() const { return UseCurrentColor; }
-
-private:
-    constexpr explicit Color(ColorParam colorValue) : colorValue_(colorValue) {}
-
-    static double ConvertGammaToLinear(uint8_t value);
-    static void ConvertGammaToLinear(const Color &gammaColor, double &linearRed, double &linearGreen,
-                                     double &linearBlue);
-    static uint8_t ConvertLinearToGamma(double value);
-    static Color ConvertLinearToGamma(double alpha, double linearRed, double linearGreen, double linearBlue);
-    static bool MatchColorWithMagic(std::string &colorStr, uint32_t maskAlpha, Color &color);
-    static bool MatchColorWithMagicMini(std::string &colorStr, uint32_t maskAlpha, Color &color);
-    static bool MatchColorWithRGB(const std::string &colorStr, Color &color);
-    static bool MatchColorWithRGBA(const std::string &colorStr, Color &color);
-    static bool MatchColorSpecialString(const std::string &colorStr, Color &color);
-    static bool ParseUintColorString(const std::string &colorStr, Color &color);
-    static bool ParseUintColorString(const std::string &colorStr, Color &color, const Color &defaultColor);
-    static bool IsRGBValid(int value);
-    static bool IsOpacityValid(double value);
-
-    float CalculateBlend(float alphaLeft, float alphaRight, float valueLeft, float valueRight) const;
-    ColorParam colorValue_{.value = 0xff000000};
-    bool UseCurrentColor{false};
-};
-
-} // namespace svg
-} // namespace rnoh

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

@@ -1,41 +0,0 @@
-/*
- * 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/decoration.cpp"
-#pragma once
-
-#include "Decoration.h"
-
-namespace rnoh {
-namespace svg {
-
-void Gradient::AddColor(const GradientColor& color)
-{
-    colors_.push_back(color);
-}
-
-void Gradient::ClearColors()
-{
-    colors_.clear();
-}
-
-} // namespace svg
-} // namespace rnoh