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

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

@@ -0,0 +1,501 @@
+/*
+ * 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 <native_drawing/drawing_font_collection.h>
+#include <native_drawing/drawing_matrix.h>
+#include <native_drawing/drawing_text_blob.h>
+#include <vector>
+#include "SvgTSpan.h"
+#include "SvgFilter.h"
+#include "drawing/TextStyle.h"
+#include "drawing/Typography.h"
+#include "drawing/Matrix.h"
+#include "utils/TextPathHelper.h"
+
+namespace rnoh {
+namespace svg {
+
+constexpr double MATHEMATICAL_BASELINE_SHIFT_FACTOR = 0.5;
+constexpr double HANGING_BASELINE_SHIFT_FACTOR = 0.8;
+constexpr double ALIGN_START = 0.0;
+constexpr double ALIGN_MIDDLE = -0.5;
+constexpr double ALIGN_END = -1.0;
+
+void SvgTSpan::OnDraw(OH_Drawing_Canvas *canvas) {
+    if (!glyphCtx_) {
+        InitGlyph(canvas, scale_);
+    }
+    if (!font_) {
+        InitFont(scale_);
+    }
+    if (content_.empty()) {
+        for (const auto &child : children_) {
+            if (auto tSpan = std::dynamic_pointer_cast<SvgTSpan>(child); tSpan) {
+                tSpan->SetGlyphContext(glyphCtx_);
+                UpdateChildTextProps(tSpan);
+            }
+        }
+        return;
+    }
+
+    glyphCtx_->pushContext(false, shared_from_this(), x_, y_, dx_, dy_, rotate_);
+    if (!textPath_) {
+        DrawText(canvas);
+    } else {
+        DrawTextPath(canvas);
+    }
+    glyphCtx_->popContext();
+}
+
+void SvgTSpan::DrawText(OH_Drawing_Canvas *canvas) {
+    drawing::TextStyle textStyle;
+    textStyle.Update(font_);
+    drawing::TypographyStyle ts;
+    ts.Update(font_);
+
+    // create a typography to measure metrics for linear gradient
+    auto *fontCollection = OH_Drawing_CreateFontCollection();
+    auto *typographyHandler = OH_Drawing_CreateTypographyHandler(ts.typographyStyle_.get(), fontCollection);
+    OH_Drawing_TypographyHandlerPushTextStyle(typographyHandler, textStyle.textStyle_.get());
+    OH_Drawing_TypographyHandlerAddText(typographyHandler, content_.c_str());
+    auto *typographyForMetrics = OH_Drawing_CreateTypography(typographyHandler);
+    double maxWidth =
+        inlineSize_.value_or(Infinity<Dimension>()).RelativeConvertToPx(OH_Drawing_CanvasGetWidth(canvas), scale_);
+    OH_Drawing_TypographyLayout(typographyForMetrics, maxWidth);
+    double actualWidth = OH_Drawing_TypographyGetLongestLine(typographyForMetrics);
+
+    double scaleSpacingAndGlyphs = 1.0;
+    if (AdjustSpacing(canvas, actualWidth, scaleSpacingAndGlyphs)) {
+        OH_Drawing_SetTextStyleLetterSpacing(textStyle.textStyle_.get(), font_->letterSpacing);
+    }
+
+    OH_Drawing_Font_Metrics fm;
+    OH_Drawing_TextStyleGetFontMetrics(typographyForMetrics, textStyle.textStyle_.get(), &fm);
+    // Ceil the actual width to avoid small floating-point errors and ensure proper alignment
+    // when calculating the position of the next glyph and adjusting for the text anchor.
+    double dx = glyphCtx_->nextX(actualWidth) - std::ceil(actualWidth) + glyphCtx_->nextDeltaX() +
+                getTextAnchorOffset(font_->textAnchor, actualWidth);
+    // the position of typography is on the left-top
+    double dy = glyphCtx_->nextY() + glyphCtx_->nextDeltaY() +
+                CalcBaselineShift(typographyHandler, ts.textStyle_.get(), fm) -
+                OH_Drawing_TypographyGetAlphabeticBaseline(typographyForMetrics);
+    DLOG(INFO) << "TEXT GLYPH next X = " << dx << " next dy = " << dy;
+
+    boundsWidth_ = actualWidth;
+    boundsHeight_ = fm.capHeight;
+    boundsX_ = dx;
+    boundsY_ = dy + (OH_Drawing_TypographyGetIdeographicBaseline(typographyForMetrics) - fm.descent - fm.capHeight);
+
+    // draw the border of the area for debug
+    bool drawBounds = false;
+    if (drawBounds) {
+        OH_Drawing_CanvasDrawLine(canvas, boundsX_, boundsY_, boundsX_ + boundsWidth_, boundsY_);
+        OH_Drawing_CanvasDrawLine(canvas, boundsX_ + boundsWidth_, boundsY_, boundsX_ + boundsWidth_,
+                                  boundsY_ + boundsHeight_);
+        OH_Drawing_CanvasDrawLine(canvas, boundsX_ + boundsWidth_, boundsY_ + boundsHeight_, boundsX_,
+                                  boundsY_ + boundsHeight_);
+        OH_Drawing_CanvasDrawLine(canvas, boundsX_, boundsY_ + boundsHeight_, boundsX_, boundsY_);
+    }
+
+    UpdateGradient(attributes_.strokeState.GetGradient());
+    UpdateGradient(attributes_.fillState.GetGradient());
+    UpdateStrokeStyle();
+    auto fillOpaque = UpdateFillStyle();
+    if (!fillOpaque) {
+        fillBrush_.SetColor(Color::TRANSPARENT.GetValue());
+    }
+    textStyle.SetForegroundBrush(fillBrush_.get());
+    textStyle.SetForegroundPen(strokePen_.get());
+    ts.SetTextStyle(std::move(textStyle));
+
+    // create the typography for drawing
+    OH_Drawing_TypographyHandlerPopTextStyle(typographyHandler);
+    OH_Drawing_TypographyHandlerPushTextStyle(typographyHandler, ts.textStyle_.get());
+    OH_Drawing_TypographyHandlerAddText(typographyHandler, content_.c_str());
+    auto *typography = OH_Drawing_CreateTypography(typographyHandler);
+    OH_Drawing_TypographyLayout(typography, maxWidth);
+
+    double r = glyphCtx_->nextRotation();
+    drawing::Matrix mat;
+    mat.PreRotate(r, dx, dy);
+
+    // Apply filter if exists (similar to SvgGraphic::OnGraphicFill)
+    bool hasCustomFilter = !attributes_.filterId.empty();
+    if (hasCustomFilter) {
+        auto svgContext = GetContext();
+        if (svgContext) {
+            auto filterNode = svgContext->GetSvgNodeById(attributes_.filterId);
+            auto svgFilter = std::dynamic_pointer_cast<SvgFilter>(filterNode);
+            if (svgFilter) {
+                // Apply filter to the text style
+                auto tempFillBrush = fillBrush_;
+                svgFilter->ApplyToBrush(tempFillBrush);
+                
+                // Update text style with filtered brush
+                drawing::TextStyle filteredTextStyle;
+                filteredTextStyle.SetForegroundBrush(tempFillBrush.get());
+                filteredTextStyle.SetForegroundPen(strokePen_.get());
+                filteredTextStyle.Update(font_);
+                
+                // Create new typography with filtered style
+                drawing::TypographyStyle filteredTs;
+                filteredTs.SetTextStyle(std::move(filteredTextStyle));
+                filteredTs.Update(font_);
+                
+                auto *filteredFontCollection = OH_Drawing_CreateFontCollection();
+                auto *filteredTypographyHandler = OH_Drawing_CreateTypographyHandler(filteredTs.typographyStyle_.get(), filteredFontCollection);
+                OH_Drawing_TypographyHandlerPushTextStyle(filteredTypographyHandler, filteredTs.textStyle_.get());
+                OH_Drawing_TypographyHandlerAddText(filteredTypographyHandler, content_.c_str());
+                auto *filteredTypography = OH_Drawing_CreateTypography(filteredTypographyHandler);
+                OH_Drawing_TypographyLayout(filteredTypography, maxWidth);
+                
+                OH_Drawing_CanvasSave(canvas);
+                OH_Drawing_CanvasConcatMatrix(canvas, mat.get());
+                OH_Drawing_TypographyPaint(filteredTypography, canvas, dx, dy);
+                OH_Drawing_CanvasRestore(canvas);
+                
+                OH_Drawing_DestroyTypography(filteredTypography);
+                OH_Drawing_DestroyTypographyHandler(filteredTypographyHandler);
+                OH_Drawing_DestroyFontCollection(filteredFontCollection);
+            } else {
+                // No filter found, draw normally
+                OH_Drawing_CanvasSave(canvas);
+                OH_Drawing_CanvasConcatMatrix(canvas, mat.get());
+                OH_Drawing_TypographyPaint(typography, canvas, dx, dy);
+                OH_Drawing_CanvasRestore(canvas);
+            }
+        } else {
+            // No SVG context, draw normally
+            OH_Drawing_CanvasSave(canvas);
+            OH_Drawing_CanvasConcatMatrix(canvas, mat.get());
+            OH_Drawing_TypographyPaint(typography, canvas, dx, dy);
+            OH_Drawing_CanvasRestore(canvas);
+        }
+    } else {
+        // No filter, draw normally
+        OH_Drawing_CanvasSave(canvas);
+        OH_Drawing_CanvasConcatMatrix(canvas, mat.get());
+        OH_Drawing_TypographyPaint(typography, canvas, dx, dy);
+        OH_Drawing_CanvasRestore(canvas);
+    }
+
+    OH_Drawing_DestroyTypography(typographyForMetrics);
+    OH_Drawing_DestroyTypography(typography);
+    OH_Drawing_DestroyTypographyHandler(typographyHandler);
+    OH_Drawing_DestroyFontCollection(fontCollection);
+}
+
+double SvgTSpan::getTextAnchorOffset(TextAnchor textAnchor, const double &textMeasure) {
+    switch (textAnchor) {
+    default:
+    case TextAnchor::start:
+        return ALIGN_START;
+
+    case TextAnchor::middle:
+        return ALIGN_MIDDLE * textMeasure;
+
+    case TextAnchor::end:
+        return ALIGN_END * textMeasure;
+    }
+}
+
+drawing::TypographyStyle SvgTSpan::PrepareTypoStyle() {
+    UpdateStrokeStyle();
+    auto fillOpaque = UpdateFillStyle();
+    if (!fillOpaque) {
+        fillBrush_.SetColor(Color::TRANSPARENT.GetValue());
+    }
+
+    drawing::TextStyle textStyle;
+    textStyle.SetForegroundBrush(fillBrush_.get());
+    textStyle.SetForegroundPen(strokePen_.get());
+    textStyle.Update(font_);
+    drawing::TypographyStyle ts;
+    ts.SetTextStyle(std::move(textStyle));
+    ts.Update(font_);
+    return std::move(ts);
+}
+
+bool SvgTSpan::AdjustSpacing(OH_Drawing_Canvas *canvas, double textMeasure, double &scaleSpacingAndGlyphs) {
+    if (textLength_) {
+        double author = textLength_->RelativeConvertToPx(OH_Drawing_CanvasGetWidth(canvas), scale_);
+        switch (lengthAdjust_) {
+        default:
+        case TextLengthAdjust::spacing:
+            font_->letterSpacing += (author - textMeasure) / (content_.size() - 1);
+            return true;
+        case TextLengthAdjust::spacingAndGlyphs:
+            scaleSpacingAndGlyphs = author / textMeasure;
+            break;
+        }
+    }
+    return false;
+}
+
+void SvgTSpan::DrawTextPath(OH_Drawing_Canvas *canvas) {
+    if (content_.empty()) {
+        return;
+    }
+
+    TextPathHelper ph(textPath_, font_->textAnchor);
+    if (!ph.Valid()) {
+        return;
+    }
+
+    drawing::TypographyStyle ts = PrepareTypoStyle();
+    auto *fontCollection = OH_Drawing_CreateFontCollection();
+    auto *typographyHandler = OH_Drawing_CreateTypographyHandler(ts.typographyStyle_.get(), fontCollection);
+
+    OH_Drawing_TypographyHandlerAddText(typographyHandler, content_.c_str());
+    auto *typography = OH_Drawing_CreateTypography(typographyHandler);
+    OH_Drawing_TypographyLayout(typography, 1e9);
+    double textMeasure = OH_Drawing_TypographyGetLineWidth(typography, 0);
+    double offset = getTextAnchorOffset(font_->textAnchor, textMeasure);
+
+    offset += ph.GetStartOffset();
+
+    double scaleSpacingAndGlyphs = 1.0;
+    if (AdjustSpacing(canvas, textMeasure, scaleSpacingAndGlyphs)) {
+        DLOG(INFO) << "adjust spacing to " << font_->letterSpacing;
+        OH_Drawing_SetTextStyleLetterSpacing(ts.textStyle_.get(), font_->letterSpacing);
+    }
+    ph.SetScaleSpacingAndGlyphs(scaleSpacingAndGlyphs);
+
+    std::vector<bool> ligature(content_.size(), false);
+
+    OH_Drawing_Font_Metrics fm;
+    OH_Drawing_TextStyleGetFontMetrics(typography, ts.textStyle_.get(), &fm);
+    double baselineShift = CalcBaselineShift(typographyHandler, ts.textStyle_.get(), fm);
+
+    for (int i = 0; i < content_.size(); i++) {
+        std::string current = content_.substr(i, 1);
+
+        auto *fontCollection = OH_Drawing_CreateFontCollection();
+        auto *typographyHandler = OH_Drawing_CreateTypographyHandler(ts.typographyStyle_.get(), fontCollection);
+        OH_Drawing_TypographyHandlerAddText(typographyHandler, current.c_str());
+        drawing::Typography typography(typographyHandler);
+        OH_Drawing_TypographyLayout(&typography, 1e9);
+        double charWidth = OH_Drawing_TypographyGetLineWidth(&typography, 0);
+
+        bool alreadyRenderedGraphemeCluster = false;
+        bool hasLigature = false;
+
+        if (alreadyRenderedGraphemeCluster) {
+            current = "";
+        } else {
+            int nextIndex = i;
+            while (++nextIndex < content_.size()) {
+                float nextWidth = charWidth;
+                if (nextWidth > 0) {
+                    break;
+                }
+                std::string nextLigature = current + current[nextIndex];
+                ligature[nextIndex] = true;
+                current = nextLigature;
+                hasLigature = true;
+            }
+        }
+        bool autoKerning = !font_->manualKerning;
+        double kerning = font_->kerning;
+        if (autoKerning) {
+            double kerned = charWidth * scaleSpacingAndGlyphs;
+            kerning = kerned - charWidth;
+        }
+
+        bool isWordSeparator = current[0] == ' ';
+        double wordSpace = isWordSeparator ? font_->wordSpacing : 0;
+        double spacing = wordSpace + font_->letterSpacing;
+        double advance = charWidth + spacing;
+
+        double x = glyphCtx_->nextX(alreadyRenderedGraphemeCluster ? 0 : kerning + advance);
+        double y = glyphCtx_->nextY();
+        double dx = glyphCtx_->nextDeltaX();
+        double dy = glyphCtx_->nextDeltaY();
+        double r = glyphCtx_->nextRotation();
+
+        if (alreadyRenderedGraphemeCluster || isWordSeparator) {
+            // Skip rendering other grapheme clusters of ligatures (already rendered),
+            // But, make sure to increment index positions by making gc.next() calls.
+            OH_Drawing_DestroyFontCollection(fontCollection);
+            OH_Drawing_DestroyTypographyHandler(typographyHandler);
+            continue;
+        }
+        int side = ph.GetSide();
+        advance *= side;
+        charWidth *= side;
+        double cursor = offset + (x + dx) * side;
+        double startPoint = cursor - advance;
+
+        drawing::Matrix mid;
+        if (!ph.GetMatrixOnPath({charWidth, startPoint, y, dy + baselineShift}, mid)) {
+            OH_Drawing_DestroyFontCollection(fontCollection);
+            OH_Drawing_DestroyTypographyHandler(typographyHandler);
+            continue;
+        }
+        mid.PreRotate(r, 0, 0);
+
+        // Apply filter if exists (similar to SvgGraphic::OnGraphicFill)
+        bool hasCustomFilter = !attributes_.filterId.empty();
+        if (hasCustomFilter) {
+            auto svgContext = GetContext();
+            if (svgContext) {
+                auto filterNode = svgContext->GetSvgNodeById(attributes_.filterId);
+                auto svgFilter = std::dynamic_pointer_cast<SvgFilter>(filterNode);
+                if (svgFilter) {
+                    // Apply filter to the text style
+                    auto tempFillBrush = fillBrush_;
+                    svgFilter->ApplyToBrush(tempFillBrush);
+                    
+                    // Update text style with filtered brush
+                    drawing::TextStyle filteredTextStyle;
+                    filteredTextStyle.SetForegroundBrush(tempFillBrush.get());
+                    filteredTextStyle.SetForegroundPen(strokePen_.get());
+                    filteredTextStyle.Update(font_);
+                    
+                    // Create new typography with filtered style
+                    drawing::TypographyStyle filteredTs;
+                    filteredTs.SetTextStyle(std::move(filteredTextStyle));
+                    filteredTs.Update(font_);
+                    
+                    auto *filteredFontCollection = OH_Drawing_CreateFontCollection();
+                    auto *filteredTypographyHandler = OH_Drawing_CreateTypographyHandler(filteredTs.typographyStyle_.get(), filteredFontCollection);
+                    OH_Drawing_TypographyHandlerPushTextStyle(filteredTypographyHandler, filteredTs.textStyle_.get());
+                    OH_Drawing_TypographyHandlerAddText(filteredTypographyHandler, current.c_str());
+                    drawing::Typography filteredTypography(filteredTypographyHandler);
+                    OH_Drawing_TypographyLayout(&filteredTypography, 1e9);
+                    
+                    OH_Drawing_CanvasSave(canvas);
+                    OH_Drawing_CanvasConcatMatrix(canvas, mid.get());
+                    OH_Drawing_TypographyPaint(&filteredTypography, canvas, 0, 0);
+                    OH_Drawing_CanvasRestore(canvas);
+                    
+                    OH_Drawing_DestroyTypographyHandler(filteredTypographyHandler);
+                    OH_Drawing_DestroyFontCollection(filteredFontCollection);
+                } else {
+                    // No filter found, draw normally
+                    OH_Drawing_CanvasSave(canvas);
+                    OH_Drawing_CanvasConcatMatrix(canvas, mid.get());
+                    OH_Drawing_TypographyPaint(&typography, canvas, 0, 0);
+                    OH_Drawing_CanvasRestore(canvas);
+                }
+            } else {
+                // No SVG context, draw normally
+                OH_Drawing_CanvasSave(canvas);
+                OH_Drawing_CanvasConcatMatrix(canvas, mid.get());
+                OH_Drawing_TypographyPaint(&typography, canvas, 0, 0);
+                OH_Drawing_CanvasRestore(canvas);
+            }
+        } else {
+            // No filter, draw normally
+            OH_Drawing_CanvasSave(canvas);
+            OH_Drawing_CanvasConcatMatrix(canvas, mid.get());
+            OH_Drawing_TypographyPaint(&typography, canvas, 0, 0);
+            OH_Drawing_CanvasRestore(canvas);
+        }
+
+        OH_Drawing_DestroyFontCollection(fontCollection);
+        OH_Drawing_DestroyTypographyHandler(typographyHandler);
+    }
+    OH_Drawing_DestroyFontCollection(fontCollection);
+    OH_Drawing_DestroyTypographyHandler(typographyHandler);
+}
+
+double SvgTSpan::CalcBaselineShift(OH_Drawing_TypographyCreate *handler, OH_Drawing_TextStyle *style,
+                                   const OH_Drawing_Font_Metrics &fm) {
+    const double descenderDepth = fm.descent;
+    const double bottom = descenderDepth + fm.leading;
+    const double ascenderHeight = -fm.ascent + fm.leading;
+    const double top = -fm.top;
+    const double totalHeight = top + bottom;
+    double baselineShift = 0.0;
+    switch (align_) {
+    // https://wiki.apache.org/xmlgraphics-fop/LineLayout/AlignmentHandling
+    default:
+    case AlignmentBaseline::baseline:
+        // Use the dominant baseline choice of the parent.
+        // Match the box’s corresponding baseline to that of its parent.
+        baselineShift = 0;
+        break;
+
+    case AlignmentBaseline::textBottom:
+    case AlignmentBaseline::afterEdge:
+    case AlignmentBaseline::textAfterEdge:
+        // Match the bottom of the box to the bottom of the parent’s content area.
+        // text-after-edge = text-bottom
+        // text-after-edge = descender depth
+        baselineShift = -descenderDepth;
+        break;
+
+    case AlignmentBaseline::alphabetic:
+        // Match the box’s alphabetic baseline to that of its parent.
+        // alphabetic = 0
+        baselineShift = 0;
+        break;
+
+    case AlignmentBaseline::ideographic:
+        baselineShift = -descenderDepth;
+        break;
+
+    case AlignmentBaseline::middle: {
+        baselineShift = fm.xHeight / 2.0;
+        break;
+    }
+    case AlignmentBaseline::central:
+        baselineShift = (ascenderHeight - descenderDepth) / 2;
+        break;
+
+    case AlignmentBaseline::mathematical:
+        baselineShift = MATHEMATICAL_BASELINE_SHIFT_FACTOR * ascenderHeight;
+        break;
+
+    case AlignmentBaseline::hanging:
+        baselineShift = HANGING_BASELINE_SHIFT_FACTOR * ascenderHeight;
+        break;
+
+    case AlignmentBaseline::textTop:
+    case AlignmentBaseline::beforeEdge:
+    case AlignmentBaseline::textBeforeEdge:
+        baselineShift = ascenderHeight;
+        break;
+
+    case AlignmentBaseline::bottom:
+        baselineShift = bottom;
+        break;
+
+    case AlignmentBaseline::center:
+        baselineShift = totalHeight / 2;
+        break;
+
+    case AlignmentBaseline::top:
+        baselineShift = top;
+        break;
+    }
+
+    if (!baselineShift_.empty()) {
+        switch (align_) {
+        case AlignmentBaseline::top:
+        case AlignmentBaseline::bottom:
+            break;
+
+        default: {
+            if (baselineShift_ == "sub") {
+            } else if (baselineShift_ == "super") {
+            } else if (baselineShift_ == "baseline") {
+            } else {
+                baselineShift -=
+                    StringUtils::FromString(baselineShift_).RelativeConvertToPx(scale_ * font_->fontSize, scale_);
+            }
+            break;
+        }
+        }
+    }
+    return baselineShift;
+}
+
+Rect SvgTSpan::AsBounds() { return Rect(boundsX_, boundsY_, boundsWidth_, boundsHeight_); }
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,101 @@
+/*
+ * 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 <cmath>
+#include "SvgGraphic.h"
+#include "SvgText.h"
+#include <native_drawing/drawing_text_typography.h>
+#include "SvgTextPath.h"
+#include "utils/GlyphContext.h"
+#include "drawing/TypographyStyle.h"
+#include "TextBase.h"
+#include "FontHolderBase.h"
+
+namespace rnoh {
+namespace svg {
+
+class SvgTSpan : public SvgGraphic, public TextBase, public FontHolderBase {
+public:
+    SvgTSpan() {
+        hrefFill_ = true;
+        hrefRender_ = true;
+        passStyle_ = true;
+        inheritStyle_ = true;
+        drawTraversed_ = true;
+    }
+    ~SvgTSpan() override = default;
+
+    void OnDraw(OH_Drawing_Canvas *canvas) override;
+
+    void SetTextPathRef(std::shared_ptr<SvgTextPath> textPath) { textPath_ = textPath; }
+
+    double getTextAnchorOffset(TextAnchor textAnchor, const double &textMeasure);
+
+    std::string content_;
+
+    Rect AsBounds() override;
+
+    /**
+     * @brief TSpan also supports the scenario with child nodes. Updates the font properties of the child node,
+     *        inheriting from the parent node if the properties are empty.
+     */
+    void OnInitStyle() override {
+        if (!font_) {
+            InitFont(GetScale());
+        }
+        for (auto &child : children_) {
+            if (auto childG = std::dynamic_pointer_cast<FontHolderBase>(child)) {
+                childG->InheritFont(font_, child->GetScale());
+            }
+        }
+    };
+
+private:
+    /**
+     * @brief TSpan also supports the scenario with child nodes. Updates the text properties of the child node,
+     *        inheriting from the parent node if the properties are empty.
+     * @param child Represents the child node object.
+     */
+    void UpdateChildTextProps(std::shared_ptr<SvgTSpan> child) {
+        UpdateIfEmpty(child->y_, y_);
+        UpdateIfEmpty(child->x_, x_);
+        UpdateIfEmpty(child->dy_, dy_);
+        UpdateIfEmpty(child->dx_, dx_);
+        UpdateIfEmpty(child->rotate_, rotate_);
+    }
+
+    void UpdateIfEmpty(std::vector<Dimension> &childProp, const std::vector<Dimension> &parentProp) {
+        if (childProp.empty() && !parentProp.empty()) {
+            childProp = parentProp;
+        }
+    }
+
+    void DrawTextPath(OH_Drawing_Canvas *canvas);
+
+    void DrawText(OH_Drawing_Canvas *canvas);
+
+    drawing::TypographyStyle PrepareTypoStyle();
+
+    /**
+     * @return true if spacing needs to be adjusted.
+     */
+    bool AdjustSpacing(OH_Drawing_Canvas *canvas, double textMeasure, double &scaleSpacingAndGlyphs);
+
+    double CalcBaselineShift(OH_Drawing_TypographyCreate *handler, OH_Drawing_TextStyle *style,
+                             const OH_Drawing_Font_Metrics &fm);
+
+    std::shared_ptr<SvgTextPath> textPath_;
+
+    double boundsWidth_ = 0;
+    double boundsHeight_ = 0;
+    double boundsX_ = 0;
+    double boundsY_ = 0;
+};
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,48 @@
+/*
+ * 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 <memory>
+#include "SvgText.h"
+#include "drawing/TextStyle.h"
+#include "drawing/TypographyStyle.h"
+#include "SvgTSpan.h"
+
+namespace rnoh {
+namespace svg {
+
+void SvgText::GlyphTraversal(OH_Drawing_Canvas *canvas) {
+    if (!glyphCtx_) {
+        InitGlyph(canvas, scale_);
+    }
+    for (auto const &child : children_) {
+        if (auto span = std::dynamic_pointer_cast<TextBase>(child)) {
+            span->SetGlyphContext(glyphCtx_);
+            if (!span->hasAlignmentBaseline()) {
+                span->setAlignmentBaseline(align_);
+            }
+            if (!span->hasBaselineShift()) {
+                span->setBaselineShift(baselineShift_);
+            }
+        }
+    }
+}
+
+void SvgText::OnDraw(OH_Drawing_Canvas *canvas) {
+    GlyphTraversal(canvas);
+    glyphCtx_->pushContext(true, shared_from_this(), x_, y_, dx_, dy_, rotate_);
+}
+
+drawing::Path SvgText::AsPath() {
+    drawing::Path resultPath;
+    for (auto const &child : children_) {
+        if (auto span = std::dynamic_pointer_cast<SvgTSpan>(child)) {
+            std::string text = span->content_;
+        }
+    }
+    return resultPath;
+}
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,29 @@
+/*
+ * 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 "SvgGroup.h"
+#include "TextBase.h"
+
+namespace rnoh {
+namespace svg {
+
+class SvgText : public SvgGroup, public TextBase {
+public:
+    SvgText() = default;
+    ~SvgText() override = default;
+
+    void OnDraw(OH_Drawing_Canvas *canvas) override;
+
+    drawing::Path AsPath() override;
+
+private:
+    void GlyphTraversal(OH_Drawing_Canvas *canvas);
+};
+
+} // namespace svg
+} // namespace rnoh