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

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

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; }

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