SkSVGTextContext Class Reference

#include <SkSVGTextPriv.h>

Inheritance diagram for SkSVGTextContext:

Classes
class	PosAttrs
class	ScopedPosResolver

Public Types
using	ShapedTextCallback = std::function< void(const SkSVGRenderContext &, const sk_sp< SkTextBlob > &, const SkPaint *, const SkPaint *)>

Public Member Functions
	SkSVGTextContext (const SkSVGRenderContext &, const ShapedTextCallback &, const SkSVGTextPath *=nullptr)
	~SkSVGTextContext () override
void	shapeFragment (const SkString &, const SkSVGRenderContext &, SkSVGXmlSpace)
void	flushChunk (const SkSVGRenderContext &ctx)
const ShapedTextCallback &	getCallback () const

Private Member Functions
void	beginLine () override
void	runInfo (const RunInfo &) override
void	commitRunInfo () override
Buffer	runBuffer (const RunInfo &ri) override
void	commitRunBuffer (const RunInfo &ri) override
void	commitLine () override

Detailed Description

Definition at line 34 of file SkSVGTextPriv.h.

Member Typedef Documentation

ShapedTextCallback

using SkSVGTextContext::ShapedTextCallback = std::function<void(const SkSVGRenderContext&, const sk_sp<SkTextBlob>&, const SkPaint*, const SkPaint*)>

Definition at line 36 of file SkSVGTextPriv.h.

Constructor & Destructor Documentation

SkSVGTextContext()

SkSVGTextContext::SkSVGTextContext	(	const SkSVGRenderContext &	ctx,
		const ShapedTextCallback &	cb,
		const SkSVGTextPath *	tpath = nullptr
	)

Definition at line 274 of file SkSVGText.cpp.

        : fRenderContext(ctx)
        , fCallback(cb)
        , fShaper(ctx.makeShaper())
        , fChunkAlignmentFactor(ComputeAlignmentFactor(ctx.presentationContext())) {
    // If the shaper callback returns null, fallback to the primitive shaper and
    // signal that we should not use the other callbacks in shapePendingBuffer
    if (!fShaper) {
        fShaper = SkShapers::Primitive::PrimitiveText();
        fForcePrimitiveShaping = true;
    }
    if (tpath) {
        fPathData = std::make_unique<PathData>(ctx, *tpath);
 
        // https://www.w3.org/TR/SVG11/text.html#TextPathElementStartOffsetAttribute
        auto resolve_offset = [this](const SkSVGLength& offset) {
            if (offset.unit() != SkSVGLength::Unit::kPercentage) {
                // "If a <length> other than a percentage is given, then the ‘startOffset’
                // represents a distance along the path measured in the current user coordinate
                // system."
                return fRenderContext.lengthContext()
                                     .resolve(offset, SkSVGLengthContext::LengthType::kHorizontal);
            }
 
            // "If a percentage is given, then the ‘startOffset’ represents a percentage distance
            // along the entire path."
            return offset.value() * fPathData->length() / 100;
        };
 
        // startOffset acts as an initial absolute position
        fChunkPos.fX = resolve_offset(tpath->getStartOffset());
    }
}

~SkSVGTextContext()

SkSVGTextContext::~SkSVGTextContext ( )

override

Definition at line 310 of file SkSVGText.cpp.

                                    {
    this->flushChunk(fRenderContext);
}

Member Function Documentation

beginLine()

void SkSVGTextContext::beginLine ( )

inlineoverrideprivatevirtual

Called when beginning a line.

Implements SkShaper::RunHandler.

Definition at line 177 of file SkSVGTextPriv.h.

{}

commitLine()

void SkSVGTextContext::commitLine ( )

overrideprivatevirtual

Called when ending a line.

Implements SkShaper::RunHandler.

Definition at line 524 of file SkSVGText.cpp.

                                  {
    if (!fShapeBuffer.fUtf8PosAdjust.empty()) {
        // Offset adjustments are cumulative - only advance the current chunk with the last value.
        fChunkAdvance += fShapeBuffer.fUtf8PosAdjust.back().offset;
    }
}

commitRunBuffer()

void SkSVGTextContext::commitRunBuffer ( const RunInfo &  info )

overrideprivatevirtual

Called after each runBuffer is filled out.

Implements SkShaper::RunHandler.

Definition at line 512 of file SkSVGText.cpp.

                                                        {
    const auto& current_run = fRuns.back();
 
    // stash position adjustments
    for (size_t i = 0; i < ri.glyphCount; ++i) {
        const auto utf8_index = fShapeClusterBuffer[i];
        current_run.glyhPosAdjust[i] = fShapeBuffer.fUtf8PosAdjust[SkToInt(utf8_index)];
    }
 
    fChunkAdvance += ri.fAdvance;
}

commitRunInfo()

void SkSVGTextContext::commitRunInfo ( )

inlineoverrideprivatevirtual

Called after all runInfo calls for a line.

Implements SkShaper::RunHandler.

Definition at line 179 of file SkSVGTextPriv.h.

{}

flushChunk()

void SkSVGTextContext::flushChunk

(

const SkSVGRenderContext &

ctx

)

Definition at line 463 of file SkSVGText.cpp.

                                                               {
    SkTextBlobBuilder blobBuilder;
 
    for (const auto& run : fRuns) {
        const auto& buf = blobBuilder.allocRunRSXform(run.font, SkToInt(run.glyphCount));
        std::copy(run.glyphs.get(), run.glyphs.get() + run.glyphCount, buf.glyphs);
        for (size_t i = 0; i < run.glyphCount; ++i) {
            buf.xforms()[i] = this->computeGlyphXform(run.glyphs[i],
                                                      run.font,
                                                      run.glyphPos[i],
                                                      run.glyhPosAdjust[i]);
        }
 
        fCallback(ctx, blobBuilder.make(), run.fillPaint.get(), run.strokePaint.get());
    }
 
    fChunkPos += fChunkAdvance;
    fChunkAdvance = {0,0};
    fChunkAlignmentFactor = ComputeAlignmentFactor(ctx.presentationContext());
 
    fRuns.clear();
}

getCallback()

const ShapedTextCallback & SkSVGTextContext::getCallback ( ) const

inline

Definition at line 120 of file SkSVGTextPriv.h.

{ return fCallback; }

runBuffer()

SkShaper::RunHandler::Buffer SkSVGTextContext::runBuffer ( const RunInfo &  info )

overrideprivatevirtual

Called for each run in a line after commitRunInfo. The buffer will be filled out.

Implements SkShaper::RunHandler.

Definition at line 486 of file SkSVGText.cpp.

                                                                      {
    SkASSERT(ri.glyphCount);
 
    fRuns.push_back({
        ri.fFont,
        fCurrentFill.isValid()   ? std::make_unique<SkPaint>(*fCurrentFill)   : nullptr,
        fCurrentStroke.isValid() ? std::make_unique<SkPaint>(*fCurrentStroke) : nullptr,
        std::make_unique<SkGlyphID[]         >(ri.glyphCount),
        std::make_unique<SkPoint[]           >(ri.glyphCount),
        std::make_unique<PositionAdjustment[]>(ri.glyphCount),
        ri.glyphCount,
        ri.fAdvance,
    });
 
    // Ensure sufficient space to temporarily fetch cluster information.
    fShapeClusterBuffer.resize(std::max(fShapeClusterBuffer.size(), ri.glyphCount));
 
    return {
        fRuns.back().glyphs.get(),
        fRuns.back().glyphPos.get(),
        nullptr,
        fShapeClusterBuffer.data(),
        fChunkAdvance,
    };
}

runInfo()

void SkSVGTextContext::runInfo ( const RunInfo &  info )

inlineoverrideprivatevirtual

Called once for each run in a line. Can compute baselines and offsets.

Implements SkShaper::RunHandler.

Definition at line 178 of file SkSVGTextPriv.h.

{}

shapeFragment()

void SkSVGTextContext::shapeFragment	(	const SkString &	txt,
		const SkSVGRenderContext &	ctx,
		SkSVGXmlSpace	xs
	)

Definition at line 314 of file SkSVGText.cpp.

                                                       {
    // https://www.w3.org/TR/SVG11/text.html#WhiteSpace
    // https://www.w3.org/TR/2008/REC-xml-20081126/#NT-S
    auto filterWSDefault = [this](SkUnichar ch) -> SkUnichar {
        // Remove all newline chars.
        if (ch == '\n') {
            return -1;
        }
 
        // Convert tab chars to space.
        if (ch == '\t') {
            ch = ' ';
        }
 
        // Consolidate contiguous space chars and strip leading spaces (fPrevCharSpace
        // starts off as true).
        if (fPrevCharSpace && ch == ' ') {
            return -1;
        }
 
        // TODO: Strip trailing WS?  Doing this across chunks would require another buffering
        //   layer.  In general, trailing WS should have no rendering side effects. Skipping
        //   for now.
        return ch;
    };
    auto filterWSPreserve = [](SkUnichar ch) -> SkUnichar {
        // Convert newline and tab chars to space.
        if (ch == '\n' || ch == '\t') {
            ch = ' ';
        }
        return ch;
    };
 
    // Stash paints for access from SkShaper callbacks.
    fCurrentFill   = ctx.fillPaint();
    fCurrentStroke = ctx.strokePaint();
 
    const auto font = ResolveFont(ctx);
    fShapeBuffer.reserve(txt.size());
 
    const char* ch_ptr = txt.c_str();
    const char* ch_end = ch_ptr + txt.size();
 
    while (ch_ptr < ch_end) {
        auto ch = SkUTF::NextUTF8(&ch_ptr, ch_end);
        ch = (xs == SkSVGXmlSpace::kDefault)
                ? filterWSDefault(ch)
                : filterWSPreserve(ch);
 
        if (ch < 0) {
            // invalid utf or char filtered out
            continue;
        }
 
        SkASSERT(fPosResolver);
        const auto pos = fPosResolver->resolve(fCurrentCharIndex++);
 
        // Absolute position adjustments define a new chunk.
        // (https://www.w3.org/TR/SVG11/text.html#TextLayoutIntroduction)
        if (pos.has(PosAttrs::kX) || pos.has(PosAttrs::kY)) {
            this->shapePendingBuffer(ctx, font);
            this->flushChunk(ctx);
 
            // New chunk position.
            if (pos.has(PosAttrs::kX)) {
                fChunkPos.fX = pos[PosAttrs::kX];
            }
            if (pos.has(PosAttrs::kY)) {
                fChunkPos.fY = pos[PosAttrs::kY];
            }
        }
 
        fShapeBuffer.append(ch, {
            {
                pos.has(PosAttrs::kDx) ? pos[PosAttrs::kDx] : 0,
                pos.has(PosAttrs::kDy) ? pos[PosAttrs::kDy] : 0,
            },
            pos.has(PosAttrs::kRotate) ? SkDegreesToRadians(pos[PosAttrs::kRotate]) : 0,
        });
 
        fPrevCharSpace = (ch == ' ');
    }
 
    this->shapePendingBuffer(ctx, font);
 
    // Note: at this point we have shaped and buffered RunRecs for the current fragment.
    // The active text chunk continues until an explicit or implicit flush.
}

---

The documentation for this class was generated from the following files:

• third_party/skia/modules/svg/src/SkSVGTextPriv.h
• third_party/skia/modules/svg/src/SkSVGText.cpp