@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/SvgContext.h

@@ -0,0 +1,71 @@
+/*
+ * 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 <memory>
+#include <string>
+#include <unordered_map>
+#include "properties/Rect.h"
+#include "properties/Size.h"
+#include "properties/Color.h"
+
+namespace rnoh {
+namespace svg {
+
+using AttrMap = std::unordered_map<std::string, std::string>;
+using ClassStyleMap = std::unordered_map<std::string, AttrMap>;
+class SvgNode;
+class SvgContext {
+public:
+    void Push(const std::string &value, const std::shared_ptr<SvgNode> &svgNode) { idMapper_.emplace(value, svgNode); }
+
+    std::shared_ptr<SvgNode> GetSvgNodeById(const std::string &id) const;
+
+    void PushStyle(const std::string &styleName, const std::pair<std::string, std::string> &attrPair);
+
+    const AttrMap &GetAttrMap(const std::string &key) const;
+
+    void SetRootViewBox(const Rect &viewBox) { rootViewBox_ = viewBox; }
+
+    const Rect &GetRootViewBox() const;
+
+    void SetSvgSize(const Size &size) { svgSize_ = size; }
+
+    const Size &GetSvgSize() const { return svgSize_; }
+
+    void SetSvgColor(const Color &svgColor) { svgColor_ = svgColor; }
+
+    const Color &GetSvgColor() { return svgColor_; }
+
+    void SetCanvasBounds(const Rect &canvasClipBounds) { canvasClipBounds_ = canvasClipBounds; }
+
+    const Rect getCanvasBounds() { return canvasClipBounds_; }
+
+    void SetCanvasScale(const double &canvasScaleX, const double &canvasScaleY) {
+        canvasScaleX_ = canvasScaleX;
+        canvasScaleY_ = canvasScaleY;
+    }
+
+    const double getCanvasScaleX() { return canvasScaleX_; }
+
+    const double getCanvasScaleY() { return canvasScaleY_; }
+
+    void ClearIdMap() { idMapper_.clear(); }
+
+private:
+    std::unordered_map<std::string, std::weak_ptr<SvgNode>> idMapper_;
+    ClassStyleMap styleMap_;
+    Rect rootViewBox_;
+    Size svgSize_;
+    Color svgColor_ = Color::WHITE; // 默认白色
+    Rect canvasClipBounds_;
+    double canvasScaleX_ = 1;
+    double canvasScaleY_ = 1;
+};
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,46 @@
+/*
+ * 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 "SvgNode.h"
+#include "SvgGraphic.h"
+
+namespace rnoh {
+namespace svg {
+
+class SvgDefs : public SvgNode {
+public:
+    SvgDefs() : SvgNode() { InitDefsFlag(); }
+    ~SvgDefs() override = default;
+
+    void InitDefsFlag() {
+        hrefFill_ = false;
+        hrefRender_ = false;
+        inheritStyle_ = false;
+        drawTraversed_ = false;
+    }
+
+    drawing::Path AsPath() override {
+        drawing::Path path;
+        // Early return if there are no children
+        if (children_.empty()) {
+            return path;
+        }
+        for (const auto& child : children_) {
+            if (!child) {
+                DLOG(WARNING) << "[SvgDefs:AsPath] Encountered a null child node";
+                continue;
+            }
+            auto childPath = child->AsPath();
+            path.Union(childPath);
+        }
+        return path;
+    }
+};
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,32 @@
+/*
+ * 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 "SvgEllipse.h"
+#include "drawing/Rect.h"
+
+namespace rnoh {
+namespace svg {
+
+drawing::Path SvgEllipse::AsPath() {
+    drawing::Path path;
+    double cx = relativeOnWidth(ellipseAttribute_.cx);
+    double cy = relativeOnHeight(ellipseAttribute_.cy);
+    double rx = relativeOnWidth(ellipseAttribute_.rx);
+    double ry = relativeOnHeight(ellipseAttribute_.ry);
+
+    drawing::Rect rect(cx - rx, cy - ry, cx + rx, cy + ry);
+    path.AddOval(rect, PATH_DIRECTION_CW);
+
+    elements_ = {PathElement(ElementType::kCGPathElementMoveToPoint, {Point(cx, cy - ry)}),
+                 PathElement(ElementType::kCGPathElementAddLineToPoint, {Point(cx, cy - ry), Point(cx + rx, cy)}),
+                 PathElement(ElementType::kCGPathElementAddLineToPoint, {Point(cx + rx, cy), Point(cx, cy + ry)}),
+                 PathElement(ElementType::kCGPathElementAddLineToPoint, {Point(cx, cy + ry), Point(cx - rx, cy)}),
+                 PathElement(ElementType::kCGPathElementAddLineToPoint, {Point(cx - rx, cy), Point(cx, cy - ry)})};
+    return path;
+};
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,34 @@
+/*
+ * 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 SvgEllipse : public SvgGraphic {
+public:
+    using Float = facebook::react::Float;
+    SvgEllipse() = default;
+    ~SvgEllipse() override = default;
+    
+    drawing::Path AsPath() override;
+    void SetCX(const std::string &cx) { ellipseAttribute_.cx = SvgAttributesParser::ParseDimension(cx, true); }
+    void SetCY(const std::string &cy) { ellipseAttribute_.cy = SvgAttributesParser::ParseDimension(cy, true); }
+    void SetRX(const std::string &rx) { ellipseAttribute_.rx = SvgAttributesParser::ParseDimension(rx, true); }
+    void SetRY(const std::string &ry) { ellipseAttribute_.ry = SvgAttributesParser::ParseDimension(ry, true); }
+
+private:
+    SvgEllipseAttribute ellipseAttribute_;
+};
+
+} // namespace svg
+} // namespace rnoh
+
+

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

@@ -0,0 +1,505 @@
+/*
+ * 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 "SvgFilter.h"
+#include <native_drawing/drawing_mask_filter.h>
+#include <native_drawing/drawing_color_filter.h>
+#include <native_drawing/drawing_image_filter.h>
+#include <native_drawing/drawing_shadow_layer.h>
+#include <native_drawing/drawing_brush.h>
+#include <native_drawing/drawing_pen.h>
+#include <native_drawing/drawing_types.h>
+#include <glog/logging.h>
+#include <algorithm>
+#include <cmath>
+#include <string>
+#include <stdexcept>
+#include <sstream>
+#include <vector>
+#include <set>
+#include <map>
+#include <memory>
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+namespace rnoh {
+namespace svg {
+
+struct InputSource {
+    std::string name;
+    OH_Drawing_ImageFilter* imageFilter = nullptr;
+    OH_Drawing_ColorFilter* colorFilter = nullptr;
+    OH_Drawing_MaskFilter* maskFilter = nullptr;
+    OH_Drawing_Filter* combinedFilter = nullptr;
+    bool ownsFilters = false;
+    
+    ~InputSource() {
+    }
+    
+    void cleanup() {
+        if (ownsFilters) {
+            if (imageFilter) {
+                OH_Drawing_ImageFilterDestroy(imageFilter);
+                imageFilter = nullptr;
+            }
+            if (colorFilter) {
+                OH_Drawing_ColorFilterDestroy(colorFilter);
+                colorFilter = nullptr;
+            }
+            if (maskFilter) {
+                OH_Drawing_MaskFilterDestroy(maskFilter);
+                maskFilter = nullptr;
+            }
+            if (combinedFilter) {
+                OH_Drawing_FilterDestroy(combinedFilter);
+                combinedFilter = nullptr;
+            }
+            ownsFilters = false;
+        }
+    }
+};
+
+class InputSourceManager {
+private:
+    std::map<std::string, std::shared_ptr<InputSource>> sources_;
+    
+public:
+    void RegisterSource(const std::string& name, OH_Drawing_ImageFilter* imageFilter = nullptr, 
+                       OH_Drawing_ColorFilter* colorFilter = nullptr, OH_Drawing_MaskFilter* maskFilter = nullptr) {
+        auto source = std::make_shared<InputSource>();
+        source->name = name;
+        source->imageFilter = imageFilter;
+        source->colorFilter = colorFilter;
+        source->maskFilter = maskFilter;
+
+        if (imageFilter || colorFilter || maskFilter) {
+            source->combinedFilter = OH_Drawing_FilterCreate();
+            if (source->combinedFilter) {
+                if (imageFilter) OH_Drawing_FilterSetImageFilter(source->combinedFilter, imageFilter);
+                if (colorFilter) OH_Drawing_FilterSetColorFilter(source->combinedFilter, colorFilter);
+                if (maskFilter) OH_Drawing_FilterSetMaskFilter(source->combinedFilter, maskFilter);
+            }
+        }
+        
+        sources_[name] = source;
+    }
+    
+    std::shared_ptr<InputSource> GetSource(const std::string& name) {
+        if (name.empty()) {
+            return nullptr;
+        }
+        
+        auto it = sources_.find(name);
+        if (it != sources_.end()) {
+            return it->second;
+        }
+
+        if (name == "SourceGraphic") {
+            return GetOrCreateStandardSource("SourceGraphic");
+        } else if (name == "SourceAlpha") {
+            return GetOrCreateStandardSource("SourceAlpha");
+        } else if (name == "BackgroundImage") {
+            return GetOrCreateStandardSource("BackgroundImage");
+        } else if (name == "BackgroundAlpha") {
+            return GetOrCreateStandardSource("BackgroundAlpha");
+        } else if (name == "FillPaint") {
+            return GetOrCreateStandardSource("FillPaint");
+        } else if (name == "StrokePaint") {
+            return GetOrCreateStandardSource("StrokePaint");
+        }
+        DLOG(WARNING) << "[SvgFilter] Input source not found: " << name;
+        return nullptr;
+    }
+    
+    void Clear() {
+        for (auto& pair : sources_) {
+            if (pair.second) {
+                pair.second->cleanup();
+            }
+        }
+        sources_.clear();
+    }
+    
+private:
+    std::shared_ptr<InputSource> GetOrCreateStandardSource(const std::string& name) {
+        auto it = sources_.find(name);
+        if (it != sources_.end()) {
+            return it->second;
+        }
+        
+        auto source = std::make_shared<InputSource>();
+        source->name = name;
+        if (name == "SourceAlpha") {
+            float alphaMatrix[20] = {
+                0, 0, 0, 0, 0,
+                0, 0, 0, 0, 0,
+                0, 0, 0, 0, 0,
+                0, 0, 0, 1, 0
+            };
+            source->colorFilter = OH_Drawing_ColorFilterCreateMatrix(alphaMatrix);
+        } else if (name == "BackgroundImage") {
+        } else if (name == "BackgroundAlpha") {
+            float backgroundAlphaMatrix[20] = {
+                0, 0, 0, 0, 0,
+                0, 0, 0, 0, 0,
+                0, 0, 0, 0, 0,
+                0, 0, 0, 1, 0
+            };
+            source->colorFilter = OH_Drawing_ColorFilterCreateMatrix(backgroundAlphaMatrix);
+        } else if (name == "FillPaint" || name == "StrokePaint") {
+            float matrix[20] = {
+                1, 0, 0, 0, 0,
+                0, 1, 0, 0, 0,
+                0, 0, 1, 0, 0,
+                0, 0, 0, 1, 0
+            };
+            source->colorFilter = OH_Drawing_ColorFilterCreateMatrix(matrix);
+        }
+        
+        sources_[name] = source;
+        return source;
+    }
+};
+
+static InputSourceManager g_inputSourceManager;
+OH_Drawing_ImageFilter* SvgFilter::GetInputImageFilter(const std::string& inputName) {
+    if (inputName.empty() || inputName == "SourceGraphic") {
+        return nullptr;
+    }
+    
+    auto source = g_inputSourceManager.GetSource(inputName);
+    return source ? source->imageFilter : nullptr;
+}
+
+OH_Drawing_ColorFilter* SvgFilter::GetInputColorFilter(const std::string& inputName) {
+    if (inputName.empty() || inputName == "SourceGraphic") {
+        return nullptr;
+    }
+    
+    auto source = g_inputSourceManager.GetSource(inputName);
+    if (source) {
+        return source->colorFilter;
+    } 
+    return nullptr;
+}
+
+OH_Drawing_Filter* SvgFilter::GetInputFilter(const std::string& inputName) {
+    if (inputName.empty() || inputName == "SourceGraphic") {
+        return nullptr;
+    }
+    
+    auto source = g_inputSourceManager.GetSource(inputName);
+    return source ? source->combinedFilter : nullptr;
+}
+
+OH_Drawing_ColorFilter* SvgFilter::CombineWithInputColor(OH_Drawing_ColorFilter* newFilter, const std::string& inputName) {
+    if (inputName.empty() || inputName == "SourceGraphic" || !newFilter) {
+        return newFilter;
+    }
+    
+    auto inputFilter = GetInputColorFilter(inputName);
+    if (inputFilter) {
+        return OH_Drawing_ColorFilterCreateCompose(newFilter, inputFilter);
+    }
+    
+    return newFilter;
+}
+
+void SvgFilter::RegisterFilterResult(const std::string& resultId, OH_Drawing_ImageFilter* imageFilter, 
+                                   OH_Drawing_ColorFilter* colorFilter, OH_Drawing_MaskFilter* maskFilter) {
+    if (!resultId.empty()) {
+        g_inputSourceManager.RegisterSource(resultId, imageFilter, colorFilter, maskFilter);
+    }
+}
+
+void SvgFilter::AddFilterEffect(const FilterEffect& effect) {
+    effects_.push_back(effect);
+}
+
+void SvgFilter::ApplyToBrush(rnoh::drawing::Brush& brush, const std::string& extra) {
+    if (effects_.empty()) {
+        return;
+    }
+    
+    g_inputSourceManager.Clear();
+    auto* mainFilter = OH_Drawing_FilterCreate();
+    if (!mainFilter) {
+        DLOG(WARNING) << "[SvgFilter] Failed to create main filter";
+        return;
+    }
+
+    for (const auto& effect : effects_) {
+        ApplySingleEffectToFilter(mainFilter, effect, &brush, nullptr, extra);
+    }
+
+    OH_Drawing_BrushSetFilter(brush.get(), mainFilter);
+}
+
+void SvgFilter::ApplyToPen(rnoh::drawing::Pen& pen) {
+    if (effects_.empty()) {
+        return;
+    }
+
+    g_inputSourceManager.Clear();
+    auto* mainFilter = OH_Drawing_FilterCreate();
+    if (!mainFilter) {
+        DLOG(WARNING) << "[SvgFilter] Failed to create main filter";
+        return;
+    }
+    
+    for (const auto& effect : effects_) {
+        ApplySingleEffectToFilter(mainFilter, effect, nullptr, &pen);
+    }
+    OH_Drawing_PenSetFilter(pen.get(), mainFilter);
+}
+
+void SvgFilter::ApplySingleEffectToFilter(OH_Drawing_Filter* filter, const FilterEffect& effect,
+    rnoh::drawing::Brush* brush, rnoh::drawing::Pen* pen, const std::string& extra) {
+    if (!filter) {
+        DLOG(WARNING) << "[SvgFilter] Null filter passed to ApplySingleEffectToFilter";
+        return;
+    }
+    switch (effect.filterType) {
+        case FilterType::GAUSSIAN_BLUR: {
+            if (extra == "image") {
+                auto* imageFilter = CreateGaussianBlurFilter(effect);
+                if (imageFilter) {
+                    OH_Drawing_FilterSetImageFilter(filter, imageFilter);
+                }
+            } else {
+                auto* maskFilter = CreateBlurFilter(effect);
+                if (maskFilter) {
+                    OH_Drawing_FilterSetMaskFilter(filter, maskFilter);
+                }
+            }
+            break;
+        }
+        case FilterType::COLOR_MATRIX: {
+            auto* colorFilter = CreateColorMatrixFilter(effect);
+            if (colorFilter) {
+                float identityMatrix[20] = {
+                    1,0,0,0,0,  0,1,0,0,0,  0,0,1,0,0,  0,0,0,1,0
+                };    
+                OH_Drawing_ColorFilter* existingColorFilter = OH_Drawing_ColorFilterCreateMatrix(identityMatrix);
+                OH_Drawing_FilterGetColorFilter(filter,existingColorFilter);
+                if (existingColorFilter) {
+                    auto* composedColorFilter = OH_Drawing_ColorFilterCreateCompose(colorFilter, existingColorFilter);
+                    if (composedColorFilter) {
+                        OH_Drawing_FilterSetColorFilter(filter, composedColorFilter);
+                    }
+                } else {
+                    OH_Drawing_FilterSetColorFilter(filter, colorFilter);
+                }
+            }
+            break;
+        }
+        case FilterType::FEFLOOD: {
+            break;
+        }
+        case FilterType::FEOFFSET: {
+            break;
+        }
+        case FilterType::BLUR: {
+            auto* maskFilter = CreateBlurFilter(effect);
+            if (maskFilter) {
+                OH_Drawing_FilterSetMaskFilter(filter, maskFilter);
+            }
+            break;
+        }
+        case FilterType::DROP_SHADOW: {
+            auto* shadowLayer = CreateDropShadowFilter(effect);
+            if (shadowLayer) {
+                if (brush) {
+                    OH_Drawing_BrushSetShadowLayer(brush->get(), shadowLayer);
+                } else if (pen) {
+                    OH_Drawing_PenSetShadowLayer(pen->get(), shadowLayer);
+                }
+            }
+            break;
+        }
+        case FilterType::BLEND: {
+            break;
+        }
+        case FilterType::COMPOSITE: {
+            break;
+        }
+        case FilterType::MERGE:
+            break;
+        default:
+            DLOG(WARNING) << "[SvgFilter] Unsupported filter type: " << static_cast<int>(effect.filterType);
+            break;
+    }
+}
+
+OH_Drawing_ImageFilter* SvgFilter::CreateGaussianBlurFilter(const FilterEffect& effect) {
+    auto inputFilter = GetInputImageFilter(effect.in);
+    auto* blurFilter = OH_Drawing_ImageFilterCreateBlur(
+        static_cast<double>(effect.stdDeviationX_),
+        static_cast<double>(effect.stdDeviationY_),
+        OH_Drawing_TileMode::CLAMP,
+        inputFilter
+    );
+
+    if (!effect.result.empty()) {
+        RegisterFilterResult(effect.result, blurFilter, nullptr, nullptr);
+    }
+    
+    return blurFilter;
+}
+
+OH_Drawing_MaskFilter* SvgFilter::CreateBlurFilter(const FilterEffect& effect) {
+    if (effect.values.size() >= 1) {
+        auto* maskFilter = OH_Drawing_MaskFilterCreateBlur(
+            OH_Drawing_BlurType::NORMAL,
+            static_cast<double>(effect.values[0]),
+            false
+        );
+        
+        if (!effect.result.empty()) {
+            RegisterFilterResult(effect.result, nullptr, nullptr, maskFilter);
+        }
+        
+        return maskFilter;
+    }
+    return nullptr;
+}
+
+OH_Drawing_ColorFilter* SvgFilter::CreateColorMatrixFilter(const FilterEffect& effect) {
+    OH_Drawing_ColorFilter* colorFilter = nullptr;
+    if (effect.type == "matrix") {
+        colorFilter = CreateMatrixFilter(effect.values);
+    } else if (effect.type == "saturate") {
+        colorFilter = CreateSaturateFilter(effect.values);
+    } else if (effect.type == "hueRotate") {
+        colorFilter = CreateHueRotateFilter(effect.values);
+    } else if (effect.type == "luminanceToAlpha") {
+        colorFilter = CreateLuminanceToAlphaFilter();
+    } else {
+        float identityMatrix[20] = {
+            1,0,0,0,0,  0,1,0,0,0,  0,0,1,0,0,  0,0,0,1,0
+        };
+        colorFilter = OH_Drawing_ColorFilterCreateMatrix(identityMatrix);
+    }
+    
+    colorFilter = CombineWithInputColor(colorFilter, effect.in);
+    if (!effect.result.empty()) {
+        RegisterFilterResult(effect.result, nullptr, colorFilter, nullptr);
+    }
+    return colorFilter;
+}
+
+OH_Drawing_ColorFilter* SvgFilter::CreateMatrixFilter(const std::vector<float>& values) {
+    if (values.size() >= 20) {
+        return OH_Drawing_ColorFilterCreateMatrix(values.data());
+    } else {
+        float identityMatrix[20] = {
+            1,0,0,0,0,  0,1,0,0,0,  0,0,1,0,0,  0,0,0,1,0
+        };
+        return OH_Drawing_ColorFilterCreateMatrix(identityMatrix);
+    }
+}
+
+OH_Drawing_ColorFilter* SvgFilter::CreateSaturateFilter(const std::vector<float>& values) {
+    float saturation = values.empty() ? 1.0f : values[0];
+    saturation = std::max(0.0f, saturation);
+    const float rWeight = 0.213f;
+    const float gWeight = 0.715f;
+    const float bWeight = 0.072f;
+    
+    float colorMatrix[20] = {
+        rWeight + (1.0f - rWeight) * saturation, gWeight * (1.0f - saturation), bWeight * (1.0f - saturation), 0.0f, 0.0f,
+        rWeight * (1.0f - saturation), gWeight + (1.0f - gWeight) * saturation, bWeight * (1.0f - saturation), 0.0f, 0.0f,
+        rWeight * (1.0f - saturation), gWeight * (1.0f - saturation), bWeight + (1.0f - bWeight) * saturation, 0.0f, 0.0f,
+        0.0f, 0.0f, 0.0f, 1.0f, 0.0f
+    };
+    
+    return OH_Drawing_ColorFilterCreateMatrix(colorMatrix);
+}
+
+OH_Drawing_ColorFilter* SvgFilter::CreateHueRotateFilter(const std::vector<float>& values) {
+    float angle = values.empty() ? 0.0f : values[0];
+    float radians = angle * M_PI / 180.0f;
+    float cosA = cos(radians);
+    float sinA = sin(radians);
+    float colorMatrix[20] = {
+        0.213f + 0.787f * cosA - 0.213f * sinA, 0.715f - 0.715f * cosA - 0.715f * sinA, 0.072f - 0.072f * cosA + 0.928f * sinA, 0.0f, 0.0f,
+        0.213f - 0.213f * cosA + 0.143f * sinA, 0.715f + 0.285f * cosA + 0.140f * sinA, 0.072f - 0.072f * cosA - 0.283f * sinA, 0.0f, 0.0f,
+        0.213f - 0.213f * cosA - 0.787f * sinA, 0.715f - 0.715f * cosA + 0.715f * sinA, 0.072f + 0.928f * cosA + 0.072f * sinA, 0.0f, 0.0f,
+        0.0f, 0.0f, 0.0f, 1.0f, 0.0f
+    };
+    
+    return OH_Drawing_ColorFilterCreateMatrix(colorMatrix);
+}
+
+OH_Drawing_ColorFilter* SvgFilter::CreateLuminanceToAlphaFilter() {
+    float colorMatrix[20] = {
+        0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+        0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+        0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+        0.2125f, 0.7154f, 0.0721f, 0.0f, 0.0f
+    };
+    
+    return OH_Drawing_ColorFilterCreateMatrix(colorMatrix);
+}
+
+OH_Drawing_ShadowLayer* SvgFilter::CreateDropShadowFilter(const FilterEffect& effect) {
+    uint32_t shadowColor = 0xFF000000;
+    if (!effect.floodColor.empty() && effect.floodColor != "none") {
+        uint32_t baseColor = 0x000000;
+        
+        if (effect.floodColor.find("0x") == 0 || effect.floodColor.find("0X") == 0) {
+            try {
+                baseColor = static_cast<uint32_t>(std::stoul(effect.floodColor, nullptr, 16));
+                if (effect.floodColor.length() > 8) {
+                    baseColor = baseColor & 0x00FFFFFF;
+                }
+            } catch (const std::exception& e) {
+                baseColor = 0x000000;
+            }
+        } else if (effect.floodColor.front() == '#') {
+            std::string hex = effect.floodColor.substr(1);
+            try {
+                if (hex.length() == 6) {
+                    baseColor = static_cast<uint32_t>(std::stoul(hex, nullptr, 16));
+                } else if (hex.length() == 3) {
+                    uint32_t r = std::stoul(hex.substr(0, 1), nullptr, 16);
+                    uint32_t g = std::stoul(hex.substr(1, 1), nullptr, 16);
+                    uint32_t b = std::stoul(hex.substr(2, 1), nullptr, 16);
+                    baseColor = (r << 20) | (r << 16) | (g << 12) | (g << 8) | (b << 4) | b;
+                }
+            } catch (const std::exception& e) {
+                baseColor = 0x000000;
+            }
+        }
+
+        uint32_t red = (baseColor >> 16) & 0xFF;
+        uint32_t green = (baseColor >> 8) & 0xFF;
+        uint32_t blue = baseColor & 0xFF;
+        float opacity = std::max(0.0f, std::min(1.0f, effect.floodOpacity));
+        
+        red = static_cast<uint32_t>(red * opacity + 255 * (1.0f - opacity));
+        green = static_cast<uint32_t>(green * opacity + 255 * (1.0f - opacity));
+        blue = static_cast<uint32_t>(blue * opacity + 255 * (1.0f - opacity));
+        
+        red = std::min(red, 255u);
+        green = std::min(green, 255u);
+        blue = std::min(blue, 255u);
+        
+        uint32_t alpha = 0xFF;
+        shadowColor = (alpha << 24) | (red << 16) | (green << 8) | blue;
+    }
+
+    return OH_Drawing_ShadowLayerCreate(
+        static_cast<double>(effect.stdDeviationX_),
+        static_cast<double>(effect.dx_),
+        static_cast<double>(effect.dy_),
+        shadowColor
+    );
+}
+}
+}