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

package/harmony/svg/src/main/cpp/SvgGroup.cpp

@@ -0,0 +1,86 @@
+/*
+ * 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 "SvgGroup.h"
+#include "SvgFilter.h"
+
+namespace rnoh {
+namespace svg {
+
+void SvgGroup::InitGroupFlag() {
+    hrefFill_ = true;
+    hrefRender_ = true;
+    passStyle_ = true;
+    inheritStyle_ = true;
+    drawTraversed_ = true;
+}
+
+void SvgGroup::OnInitStyle() {
+    if (!font_) {
+        InitFont(GetScale());
+    }
+    for (auto &child : children_) {
+        if (auto childG = std::dynamic_pointer_cast<FontHolderBase>(child)) {
+            childG->InheritFont(font_, child->GetScale());
+        }
+    }
+}
+
+void SvgGroup::OnDraw(OH_Drawing_Canvas *canvas) {
+    OnDrawTraversed(canvas);
+}
+
+void SvgGroup::ApplyFilterToChildren(std::shared_ptr<SvgFilter> filter) {
+    if (!filter) {
+        return;
+    }
+    originalFilters_.clear();
+    
+    for (auto& child : children_) {
+        if (child) {
+            originalFilters_.push_back(child->GetBaseAttributes().filterId);
+            auto childAttrs = child->GetBaseAttributes();
+            childAttrs.filterId = attributes_.filterId;
+            childAttrs.hasInheritedFilter = true;
+            child->SetBaseAttributes(childAttrs);
+        }
+    }
+}
+
+void SvgGroup::RestoreChildrenFilter() {
+    for (size_t i = 0; i < children_.size() && i < originalFilters_.size(); ++i) {
+        if (children_[i]) {
+            auto childAttrs = children_[i]->GetBaseAttributes();
+            childAttrs.filterId = originalFilters_[i];
+            childAttrs.hasInheritedFilter = false;
+            children_[i]->SetBaseAttributes(childAttrs);
+        }
+    }
+    
+    originalFilters_.clear();
+}
+
+Rect SvgGroup::AsBounds() {
+    if (children_.empty()) {
+        return Rect(0, 0, 0, 0);
+    }
+    
+    auto bounds = children_[0]->AsBounds();
+    for (size_t i = 1; i < children_.size(); ++i) {
+        auto childBounds = children_[i]->AsBounds();
+        // 合并边界
+        float left = std::min(bounds.Left(), childBounds.Left());
+        float top = std::min(bounds.Top(), childBounds.Top());
+        float right = std::max(bounds.Right(), childBounds.Right());
+        float bottom = std::max(bounds.Bottom(), childBounds.Bottom());
+        bounds = Rect(left, top, right - left, bottom - top);
+    }
+    
+    return bounds;
+}
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/cpp/SvgGroup.h

@@ -0,0 +1,41 @@
+/*
+ * 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 "properties/Font.h"
+#include "FontHolderBase.h"
+#include <native_drawing/drawing_canvas.h>
+
+namespace rnoh {
+namespace svg {
+
+class SvgFilter; // 前置声明
+
+class SvgGroup : public SvgNode, public FontHolderBase {
+
+public:
+    SvgGroup() : SvgNode() { InitGroupFlag(); }
+    ~SvgGroup() override = default;
+
+    Rect AsBounds() override;
+
+protected:
+    void OnDraw(OH_Drawing_Canvas *canvas) override;
+
+private:
+    // svg g, use
+    void InitGroupFlag();
+    void OnInitStyle() override;
+    void ApplyFilterToChildren(std::shared_ptr<SvgFilter> filter);
+    void RestoreChildrenFilter();
+    // 用于保存子节点的原始filter设置
+    std::vector<std::string> originalFilters_;
+};
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/cpp/SvgHost.cpp

@@ -0,0 +1,27 @@
+/*
+ * 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 "SvgHost.h"
+
+namespace rnoh {
+namespace svg {
+    
+void SvgHost::OnChildInsertCommon(const std::shared_ptr<SvgHost> &childSvgHost) {
+    if (!childSvgHost) {
+        return;
+    }
+    GetSvgNode()->AppendChild(childSvgHost->GetSvgNode());
+}
+
+void SvgHost::OnChildRemoveCommon(const std::shared_ptr<SvgHost> &childSvgHost) {
+    if (!childSvgHost) {
+        return;
+    }
+    GetSvgNode()->removeChild(childSvgHost->GetSvgNode());
+}
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/cpp/SvgHost.h

@@ -0,0 +1,38 @@
+/*
+ * 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 "SvgNode.h"
+
+namespace rnoh {
+namespace svg {
+
+class SvgHost {
+ public:
+     SvgHost() = default;
+     virtual ~SvgHost() = default;
+     void SetSvgNode(const std::shared_ptr<SvgNode> &svgNode) { 
+        std::lock_guard<std::mutex> lock(mtx);
+        m_svgNode = svgNode;
+    };
+     const std::shared_ptr<SvgNode> &GetSvgNode() const { 
+        std::lock_guard<std::mutex> lock(mtx);
+        return m_svgNode;
+    };
+
+     void OnChildInsertCommon(const std::shared_ptr<SvgHost> &childSvgHost);
+
+     void OnChildRemoveCommon(const std::shared_ptr<SvgHost> &childSvgHost);
+
+ private:
+  std::shared_ptr<SvgNode> m_svgNode{nullptr};
+  mutable std::mutex mtx;
+};
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/cpp/SvgImage.cpp

@@ -0,0 +1,168 @@
+/*
+ * 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 "SvgImage.h"
+#include "SvgFilter.h"
+#include "utils/StringUtils.h"
+#include "properties/ViewBox.h"
+#include <multimedia/image_framework/image_mdk_common.h>
+#include <multimedia/image_framework/image/image_source_native.h>
+#include <multimedia/image_framework/image_pixel_map_mdk.h>
+#include <glog/logging.h>
+#include <native_drawing/drawing_image.h>
+#include <native_drawing/drawing_rect.h>
+#include <native_drawing/drawing_pixel_map.h>
+#include <native_drawing/drawing_sampling_options.h>
+#include <native_drawing/drawing_filter.h>
+#include <rawfile/raw_file.h>
+
+const char *ASSET_PREFIX = "asset://";
+const char *RAWFILE_PREFIX = "assets/";
+
+namespace rnoh {
+namespace svg {
+
+void SvgImage::OnDraw(OH_Drawing_Canvas *canvas) {
+    auto uriString = imageAttribute_.src.uri;
+
+    if (uriString.empty()) {
+        DLOG(WARNING) << "[SvgImage] imageAttribute_.src.uri is empty!";
+        return;
+    }
+
+    double width =
+        imageAttribute_.width.Value() == 0 ? imageAttribute_.src.size.width : relativeOnWidth(imageAttribute_.width);
+    double height = imageAttribute_.height.Value() == 0 ? imageAttribute_.src.size.height
+                                                        : relativeOnHeight(imageAttribute_.height);
+    double x = relativeOnWidth(imageAttribute_.x);
+    double y = relativeOnHeight(imageAttribute_.y);
+
+    if (!uriString.empty() && uriString.find("http", 0) != 0) {
+        OH_ImageSourceNative *res;
+        OH_PixelmapNative *pixelMap;
+        OH_DecodingOptions *options;
+
+        char *srcUri = const_cast<char *>(uriString.c_str());
+
+        OH_DecodingOptions_Create(&options);
+
+        Image_ErrorCode createFromUriStatus;
+        if (uriString.find(ASSET_PREFIX, 0) == 0) {
+            auto file = uriString.replace(0, 8, RAWFILE_PREFIX);
+            DLOG(INFO) << "[SvgImage] file: " << file;
+            auto rawFile = OH_ResourceManager_OpenRawFile(mgr_, file.c_str());
+            if (rawFile == nullptr) {
+                LOG(ERROR) << "[SvgImage] get rawfile fail";
+                return;
+            }
+            RawFileDescriptor descriptor;
+            auto getRawFileStatus = OH_ResourceManager_GetRawFileDescriptor(rawFile, descriptor);
+            if (!getRawFileStatus) {
+                LOG(ERROR) << "[SvgImage] get rawfile descriptor fail";
+                return;
+            }
+            createFromUriStatus = OH_ImageSourceNative_CreateFromRawFile(&descriptor, &res);
+        } else {
+            createFromUriStatus = OH_ImageSourceNative_CreateFromUri(srcUri, uriString.size(), &res);
+        }
+        auto createPixelmapStatus = OH_ImageSourceNative_CreatePixelmap(res, options, &pixelMap);
+        DLOG(INFO) << "[SvgImage] code: " << createPixelmapStatus;
+
+        if (createPixelmapStatus == IMAGE_SUCCESS) {
+            /* Temporarily disable the feature to set opacity.
+             * Currently, there is an issue where setting opacity on
+             * transparent pixels results in them turning black.
+             */
+            if (LessNotEqual(attributes_.opacity, 1.0f)) {
+                OH_PixelmapNative_Opacity(pixelMap, attributes_.opacity);
+            }
+
+            // get the real width and height from pixelmap(OH_PixelmapNative *).
+            OH_Pixelmap_ImageInfo *info;
+            OH_PixelmapImageInfo_Create(&info);
+            OH_PixelmapNative_GetImageInfo(pixelMap, info);
+
+            // get the resource properties: width and height
+            uint32_t *imageWidth_ = new uint32_t;
+            uint32_t *imageHeight_ = new uint32_t;
+            OH_PixelmapImageInfo_GetWidth(info, imageWidth_);
+            OH_PixelmapImageInfo_GetHeight(info, imageHeight_);
+
+            auto imageWidth = static_cast<double>(*imageWidth_);
+            auto imageHeight = static_cast<double>(*imageHeight_);
+            delete imageWidth_;
+            delete imageHeight_;
+
+            const auto vbRect = Rect(0, 0, imageWidth, imageHeight);
+            const auto renderRect = Rect(x, y, width, height);
+
+            drawing::Matrix transformMatrix;
+            if (vbRect.IsValid()) {
+                transformMatrix =
+                    ViewBox::getTransform(vbRect, renderRect, imageAttribute_.align, imageAttribute_.meetOrSlice);
+            }
+
+            // set source Rect and destination Rect
+            OH_Drawing_PixelMap *ohPixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMap);
+            drawing::Rect srcPixelMap(0, 0, imageWidth, imageHeight);
+            auto dstPixelMap = transformMatrix.MapRect(srcPixelMap);
+
+            // set SamplingOptions
+            OH_Drawing_FilterMode filterMode = FILTER_MODE_NEAREST;
+            OH_Drawing_MipmapMode mipMapMode = MIPMAP_MODE_NONE;
+            OH_Drawing_SamplingOptions *samplingOptions = OH_Drawing_SamplingOptionsCreate(filterMode, mipMapMode);
+
+            // Draw picture by type OH_Drawing_PixelMap
+            OH_Drawing_CanvasSave(canvas);
+            
+            drawing::Rect clipRect(x, y, x + width, y + height);
+            OH_Drawing_CanvasClipRect(canvas, clipRect.get(), OH_Drawing_CanvasClipOp::INTERSECT, true);
+            
+            // Apply SVG filter if specified
+            if (!attributes_.filterId.empty()) {
+                DLOG(INFO) << "[SvgImage] Applying filter: " << attributes_.filterId;
+                auto svgContext = GetContext();
+                if (svgContext) {
+                    auto filterNode = svgContext->GetSvgNodeById(attributes_.filterId);
+                    auto svgFilter = std::dynamic_pointer_cast<SvgFilter>(filterNode);
+                    if (svgFilter) {
+                        // Create a temporary brush and apply filter to it
+                        drawing::Brush tmpBrush;
+                        svgFilter->ApplyToBrush(tmpBrush, "image");
+                        
+                        // Attach the filtered brush to canvas
+                        OH_Drawing_CanvasAttachBrush(canvas, tmpBrush.get());
+                        DLOG(INFO) << "[SvgImage] Filter applied to brush successfully";
+                    }
+                }
+            }
+            
+            // Draw the pixelmap
+            OH_Drawing_CanvasDrawPixelMapRect(canvas, ohPixelMap, srcPixelMap.get(), dstPixelMap.get(),
+                                              samplingOptions);
+            
+            // Detach brush if filter was applied
+            if (!attributes_.filterId.empty()) {
+                OH_Drawing_CanvasDetachBrush(canvas);
+            }
+            
+            OH_Drawing_CanvasRestore(canvas);
+
+            // clear data
+            OH_PixelmapImageInfo_Release(info);
+            OH_Drawing_SamplingOptionsDestroy(samplingOptions);
+            OH_Drawing_PixelMapDissolve(ohPixelMap);
+            OH_PixelmapNative_Release(pixelMap);
+        }
+        if (createFromUriStatus == IMAGE_SUCCESS) {
+            OH_ImageSourceNative_Release(res);
+        }
+        OH_DecodingOptions_Release(options);
+    }
+}
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/cpp/SvgImage.h

@@ -0,0 +1,52 @@
+/*
+ * 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>
+#include "SvgGraphic.h"
+#include <rawfile/raw_file_manager.h>
+
+namespace rnoh {
+namespace svg {
+
+class SvgImage : public svg::SvgGraphic {
+public:
+    SvgImage() = default;
+    ~SvgImage() override = default;
+
+    using SvgNode::relativeOnWidth;
+    using SvgNode::relativeOnHeight;
+
+    void SetX(const std::string &x) { imageAttribute_.x = SvgAttributesParser::ParseDimension(x, true); }
+
+    void SetY(const std::string &y) { imageAttribute_.y = SvgAttributesParser::ParseDimension(y, true); }
+
+    void SetHeight(const std::string &height) {
+        imageAttribute_.height = SvgAttributesParser::ParseDimension(height, true);
+    }
+
+    void SetWidth(const std::string &width) {
+        imageAttribute_.width = SvgAttributesParser::ParseDimension(width, true);
+    }
+
+    void SetAlign(const std::string &align) { imageAttribute_.align = align; }
+
+    void SetMeetOrSlice(const int &meetOrSlice) { imageAttribute_.meetOrSlice = meetOrSlice; }
+
+    void SetImageSource(const facebook::react::ImageSource &src) { imageAttribute_.src = src; }
+
+    void setNativeResourceManager(const NativeResourceManager *mgr) { mgr_ = mgr; }
+
+    void OnDraw(OH_Drawing_Canvas *canvas) override;
+
+private:
+    SvgImageAttribute imageAttribute_;
+    const NativeResourceManager *mgr_;
+};
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/cpp/SvgLine.cpp

@@ -0,0 +1,28 @@
+/*
+ * 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 "SvgLine.h"
+
+namespace rnoh {
+namespace svg {
+
+drawing::Path SvgLine::AsPath() {
+    drawing::Path path;
+    double x1 = relativeOnWidth(lineAttribute_.x1);
+    double y1 = relativeOnHeight(lineAttribute_.y1);
+    double x2 = relativeOnWidth(lineAttribute_.x2);
+    double y2 = relativeOnHeight(lineAttribute_.y2);
+
+    path.MoveTo(x1, y1);
+    path.LineTo(x2, y2);
+
+    elements_ = {PathElement(ElementType::kCGPathElementMoveToPoint, {Point(x1, y1)}),
+                 PathElement(ElementType::kCGPathElementAddLineToPoint, {Point(x2, y2)})};
+    return path;
+};
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/cpp/SvgLine.h

@@ -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.
+ */
+
+#pragma once
+
+#include "SvgGraphic.h"
+#include "utils/SvgAttributesParser.h"
+
+namespace rnoh {
+namespace svg {
+
+class SvgLine : public SvgGraphic {
+public:
+    using Float = facebook::react::Float;
+    SvgLine() = default;
+    ~SvgLine() override = default;
+
+    drawing::Path AsPath() override;
+    void SetX1(const std::string &x1) { lineAttribute_.x1 = SvgAttributesParser::ParseDimension(x1, true); }
+    void SetY1(const std::string &y1) { lineAttribute_.y1 = SvgAttributesParser::ParseDimension(y1, true); }
+    void SetX2(const std::string &x2) { lineAttribute_.x2 = SvgAttributesParser::ParseDimension(x2, true); }
+    void SetY2(const std::string &y2) { lineAttribute_.y2 = SvgAttributesParser::ParseDimension(y2, true); }
+
+private:
+    SvgLineAttribute lineAttribute_;
+};
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/cpp/SvgMarker.cpp

@@ -0,0 +1,61 @@
+/*
+ * 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 "SvgMarker.h"
+#include "properties/Rect.h"
+#include "properties/ViewBox.h"
+#include <string>
+#include <cstdlib>
+#include <vector>
+
+namespace rnoh {
+namespace svg {
+
+void SvgMarker::renderMarker(OH_Drawing_Canvas *canvas, const SvgMarkerPosition &position, float strokeWidth) {
+    const auto count = OH_Drawing_CanvasGetSaveCount(canvas);
+    saveAndSetupCanvas(canvas, cTM_);
+
+    if (markerTransform.get() != nullptr) {
+        markerTransform.Reset();
+    }
+    Point origin = position.origin;
+    markerTransform.Translate(origin.x, origin.y);
+    double markerAngle = (markerAttribute_.orient == "auto") ? -1 : std::atof(markerAttribute_.orient.c_str());
+    float degrees = 180 + (markerAngle == -1 ? position.angle : static_cast<float>(markerAngle));
+    // fix me? float rad = deg2rad(angle); this code only in ios
+    markerTransform.PreRotate(degrees, 0, 0);
+
+    if (markerAttribute_.markerUnits == "strokeWidth") {
+        markerTransform.PreScale(strokeWidth / scale_, strokeWidth / scale_, 0, 0);
+    }
+    if (!markerAttribute_.align.empty()) {
+        double width = relativeOnWidth(markerAttribute_.markerWidth) / scale_;
+        double height = relativeOnHeight(markerAttribute_.markerHeight) / scale_;
+        Rect eRect(0, 0, width, height);
+        Rect vbRect(markerAttribute_.minX.ConvertToPx(scale_), markerAttribute_.minY.ConvertToPx(scale_),
+                    markerAttribute_.minX.ConvertToPx(scale_) + markerAttribute_.vbWidth.ConvertToPx(scale_),
+                    markerAttribute_.minY.ConvertToPx(scale_) + markerAttribute_.vbHeight.ConvertToPx(scale_));
+        if (vbRect.IsValid()) {
+            drawing::Matrix viewBoxMatrix =
+                ViewBox::getTransform(vbRect, eRect, markerAttribute_.align, markerAttribute_.meetOrSlice);
+            float sx = viewBoxMatrix.GetValue(0);
+            float sy = viewBoxMatrix.GetValue(4);
+            markerTransform.PreScale(sx, sy, 0, 0);
+        }
+    }
+
+    double x = relativeOnWidth(markerAttribute_.refX);
+    double y = relativeOnHeight(markerAttribute_.refY);
+    markerTransform.PreTranslate(-x, -y);
+    OH_Drawing_CanvasConcatMatrix(canvas, markerTransform.get());
+
+    OnDrawTraversed(canvas);
+
+    OH_Drawing_CanvasRestoreToCount(canvas, count);
+}
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/cpp/SvgMarker.h

@@ -0,0 +1,86 @@
+/*
+ * 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 "SvgQuote.h"
+#include "properties/Dimension.h"
+#include "utils/SvgAttributesParser.h"
+#include "utils/SvgMarkerPositionUtils.h"
+#include <sstream>
+#include <string>
+#include <native_drawing/drawing_register_font.h>
+#include <native_drawing/drawing_text_typography.h>
+#include <native_drawing/drawing_matrix.h>
+
+namespace rnoh {
+namespace svg {
+
+class SvgMarker : public SvgQuote {
+public:
+    SvgMarker() = default;
+    ~SvgMarker() override = default;
+
+    void setRefX(const std::string &refX) { markerAttribute_.refX = SvgAttributesParser::ParseDimension(refX, true); }
+
+    void setRefY(const std::string &refY) { markerAttribute_.refY = SvgAttributesParser::ParseDimension(refY, true); }
+
+    void setMarkerWidth(const std::string &markerWidth) {
+        markerAttribute_.markerWidth = SvgAttributesParser::ParseDimension(markerWidth, true);
+    }
+
+    void setMarkerHeight(const std::string &markerHeight) {
+        markerAttribute_.markerHeight = SvgAttributesParser::ParseDimension(markerHeight, true);
+    }
+
+    void setMarkerUnits(const std::string &markerUnits) { markerAttribute_.markerUnits = markerUnits; }
+
+    void setOrient(const std::string &orient) { markerAttribute_.orient = orient; }
+
+    void setMinX(double minX) { markerAttribute_.minX = Dimension(minX, DimensionUnit::VP); }
+
+    void setMinY(double minY) { markerAttribute_.minY = Dimension(minY, DimensionUnit::VP); }
+
+    void setVbWidth(double vbWidth) { markerAttribute_.vbWidth = Dimension(vbWidth, DimensionUnit::VP); }
+
+    void setVbHeight(double vbHeight) { markerAttribute_.vbHeight = Dimension(vbHeight, DimensionUnit::VP); }
+
+    void setAlign(std::string align) { markerAttribute_.align = align; }
+
+    void setMeetOrSlice(int meetOrSlice) { markerAttribute_.meetOrSlice = meetOrSlice; }
+
+    void renderMarker(OH_Drawing_Canvas *canvas, const SvgMarkerPosition &position, float strokeWidth);
+
+    /**
+     * from VirtualView.saveAndSetupCanvas
+     *
+     * Sets up the transform matrix on the canvas before an element is drawn.
+     *
+     * <p>NB: for perf reasons this does not apply opacity, as that would mean creating a new canvas
+     * layer (which allocates an offscreen bitmap) and having it composited afterwards. Instead, the
+     * drawing code should apply opacity recursively.
+     *
+     * @param canvas the canvas to set up
+     * @param ctm current transformation matrix
+     */
+    void saveAndSetupCanvas(OH_Drawing_Canvas *canvas, drawing::Matrix ctm) {
+        OH_Drawing_CanvasSave(canvas);
+        cTM_ = mMatrix.Concat(mTransform);
+        OH_Drawing_CanvasConcatMatrix(canvas, cTM_.get());
+        cTM_ = cTM_.Concat(ctm);
+        mInvCTM = cTM_.Invert();
+    }
+
+private:
+    SvgMarkerAttribute markerAttribute_;
+    drawing::Matrix markerTransform;
+    drawing::Matrix mMatrix;
+    drawing::Matrix mTransform;
+    std::optional<drawing::Matrix> mInvCTM;
+};
+
+} // namespace svg
+} // namespace rnoh