#include <ParagraphImpl.h>

Inheritance diagram for skia::textlayout::ParagraphImpl:

Public Member Functions
	ParagraphImpl (const SkString &text, ParagraphStyle style, skia_private::TArray< Block, true > blocks, skia_private::TArray< Placeholder, true > placeholders, sk_sp< FontCollection > fonts, sk_sp< SkUnicode > unicode)

	ParagraphImpl (const std::u16string &utf16text, ParagraphStyle style, skia_private::TArray< Block, true > blocks, skia_private::TArray< Placeholder, true > placeholders, sk_sp< FontCollection > fonts, sk_sp< SkUnicode > unicode)

	~ParagraphImpl () override

void	layout (SkScalar width) override

void	paint (SkCanvas *canvas, SkScalar x, SkScalar y) override

void	paint (ParagraphPainter *canvas, SkScalar x, SkScalar y) override

std::vector< TextBox >	getRectsForRange (unsigned start, unsigned end, RectHeightStyle rectHeightStyle, RectWidthStyle rectWidthStyle) override

std::vector< TextBox >	getRectsForPlaceholders () override

void	getLineMetrics (std::vector< LineMetrics > &) override

PositionWithAffinity	getGlyphPositionAtCoordinate (SkScalar dx, SkScalar dy) override

SkRange< size_t >	getWordBoundary (unsigned offset) override

bool	getApplyRoundingHack () const

size_t	lineNumber () override

TextLine &	addLine (SkVector offset, SkVector advance, TextRange textExcludingSpaces, TextRange text, TextRange textIncludingNewlines, ClusterRange clusters, ClusterRange clustersWithGhosts, SkScalar widthWithSpaces, InternalLineMetrics sizes)

SkSpan< const char >	text () const

InternalState	state () const

SkSpan< Run >	runs ()

SkSpan< Block >	styles ()

SkSpan< Placeholder >	placeholders ()

SkSpan< TextLine >	lines ()

const ParagraphStyle &	paragraphStyle () const

SkSpan< Cluster >	clusters ()

sk_sp< FontCollection >	fontCollection () const

void	formatLines (SkScalar maxWidth)

void	ensureUTF16Mapping ()

skia_private::TArray< TextIndex >	countSurroundingGraphemes (TextRange textRange) const

TextIndex	findNextGraphemeBoundary (TextIndex utf8) const

TextIndex	findPreviousGraphemeBoundary (TextIndex utf8) const

TextIndex	findNextGlyphClusterBoundary (TextIndex utf8) const

TextIndex	findPreviousGlyphClusterBoundary (TextIndex utf8) const

size_t	getUTF16Index (TextIndex index) const

bool	strutEnabled () const

bool	strutForceHeight () const

bool	strutHeightOverride () const

InternalLineMetrics	strutMetrics () const

SkString	getEllipsis () const

SkSpan< const char >	text (TextRange textRange)

SkSpan< Cluster >	clusters (ClusterRange clusterRange)

Cluster &	cluster (ClusterIndex clusterIndex)

ClusterIndex	clusterIndex (TextIndex textIndex)

Run &	run (RunIndex runIndex)

Run &	runByCluster (ClusterIndex clusterIndex)

SkSpan< Block >	blocks (BlockRange blockRange)

Block &	block (BlockIndex blockIndex)

skia_private::TArray< ResolvedFontDescriptor >	resolvedFonts () const

void	markDirty () override

int32_t	unresolvedGlyphs () override

std::unordered_set< SkUnichar >	unresolvedCodepoints () override

void	addUnresolvedCodepoints (TextRange textRange)

void	setState (InternalState state)

sk_sp< SkPicture >	getPicture ()

SkScalar	widthWithTrailingSpaces ()

void	resetContext ()

void	resolveStrut ()

bool	computeCodeUnitProperties ()

void	applySpacingAndBuildClusterTable ()

void	buildClusterTable ()

bool	shapeTextIntoEndlessLine ()

void	breakShapedTextIntoLines (SkScalar maxWidth)

void	updateTextAlign (TextAlign textAlign) override

void	updateFontSize (size_t from, size_t to, SkScalar fontSize) override

void	updateForegroundPaint (size_t from, size_t to, SkPaint paint) override

void	updateBackgroundPaint (size_t from, size_t to, SkPaint paint) override

void	visit (const Visitor &) override

void	extendedVisit (const ExtendedVisitor &) override

int	getPath (int lineNumber, SkPath *dest) override

bool	containsColorFontOrBitmap (SkTextBlob *textBlob) override

bool	containsEmoji (SkTextBlob *textBlob) override

int	getLineNumberAt (TextIndex codeUnitIndex) const override

int	getLineNumberAtUTF16Offset (size_t codeUnitIndex) override

bool	getLineMetricsAt (int lineNumber, LineMetrics *lineMetrics) const override

TextRange	getActualTextRange (int lineNumber, bool includeSpaces) const override

bool	getGlyphClusterAt (TextIndex codeUnitIndex, GlyphClusterInfo *glyphInfo) override

bool	getClosestGlyphClusterAt (SkScalar dx, SkScalar dy, GlyphClusterInfo *glyphInfo) override

bool	getGlyphInfoAtUTF16Offset (size_t codeUnitIndex, GlyphInfo *graphemeInfo) override

bool	getClosestUTF16GlyphInfoAt (SkScalar dx, SkScalar dy, GlyphInfo *graphemeInfo) override

SkFont	getFontAt (TextIndex codeUnitIndex) const override

SkFont	getFontAtUTF16Offset (size_t codeUnitIndex) override

std::vector< FontInfo >	getFonts () const override

InternalLineMetrics	getEmptyMetrics () const

InternalLineMetrics	getStrutMetrics () const

BlockRange	findAllBlocks (TextRange textRange)

void	resetShifts ()

bool	codeUnitHasProperty (size_t index, SkUnicode::CodeUnitFlags property) const

sk_sp< SkUnicode >	getUnicode ()

Public Member Functions inherited from skia::textlayout::Paragraph
	Paragraph (ParagraphStyle style, sk_sp< FontCollection > fonts)

virtual	~Paragraph ()=default

SkScalar	getMaxWidth ()

SkScalar	getHeight ()

SkScalar	getMinIntrinsicWidth ()

SkScalar	getMaxIntrinsicWidth ()

SkScalar	getAlphabeticBaseline ()

SkScalar	getIdeographicBaseline ()

SkScalar	getLongestLine ()

bool	didExceedMaxLines ()

virtual void	layout (SkScalar width)=0

virtual void	paint (SkCanvas *canvas, SkScalar x, SkScalar y)=0

virtual void	paint (ParagraphPainter *painter, SkScalar x, SkScalar y)=0

virtual std::vector< TextBox >	getRectsForRange (unsigned start, unsigned end, RectHeightStyle rectHeightStyle, RectWidthStyle rectWidthStyle)=0

virtual std::vector< TextBox >	getRectsForPlaceholders ()=0

virtual PositionWithAffinity	getGlyphPositionAtCoordinate (SkScalar dx, SkScalar dy)=0

virtual SkRange< size_t >	getWordBoundary (unsigned offset)=0

virtual void	getLineMetrics (std::vector< LineMetrics > &)=0

virtual size_t	lineNumber ()=0

virtual void	markDirty ()=0

virtual int32_t	unresolvedGlyphs ()=0

virtual std::unordered_set< SkUnichar >	unresolvedCodepoints ()=0

virtual void	updateTextAlign (TextAlign textAlign)=0

virtual void	updateFontSize (size_t from, size_t to, SkScalar fontSize)=0

virtual void	updateForegroundPaint (size_t from, size_t to, SkPaint paint)=0

virtual void	updateBackgroundPaint (size_t from, size_t to, SkPaint paint)=0

virtual void	visit (const Visitor &)=0

virtual void	extendedVisit (const ExtendedVisitor &)=0

virtual int	getPath (int lineNumber, SkPath *dest)=0

virtual bool	containsEmoji (SkTextBlob *textBlob)=0

virtual bool	containsColorFontOrBitmap (SkTextBlob *textBlob)=0

virtual int	getLineNumberAt (TextIndex codeUnitIndex) const =0

virtual int	getLineNumberAtUTF16Offset (size_t codeUnitIndex)=0

virtual bool	getLineMetricsAt (int lineNumber, LineMetrics *lineMetrics) const =0

virtual TextRange	getActualTextRange (int lineNumber, bool includeSpaces) const =0

virtual bool	getGlyphClusterAt (TextIndex codeUnitIndex, GlyphClusterInfo *glyphInfo)=0

virtual bool	getClosestGlyphClusterAt (SkScalar dx, SkScalar dy, GlyphClusterInfo *glyphInfo)=0

virtual bool	getGlyphInfoAtUTF16Offset (size_t codeUnitIndex, GlyphInfo *glyphInfo)=0

virtual bool	getClosestUTF16GlyphInfoAt (SkScalar dx, SkScalar dy, GlyphInfo *glyphInfo)=0

virtual SkFont	getFontAt (TextIndex codeUnitIndex) const =0

virtual SkFont	getFontAtUTF16Offset (size_t codeUnitIndex)=0

virtual std::vector< FontInfo >	getFonts () const =0

Friends
class	ParagraphBuilder

class	ParagraphCacheKey

class	ParagraphCacheValue

class	ParagraphCache

class	TextWrapper

class	OneLineShaper

Additional Inherited Members
Public Types inherited from skia::textlayout::Paragraph
enum	VisitorFlags { kWhiteSpace_VisitorFlag = 1 << 0 }

using	Visitor = std::function< void(int lineNumber, const VisitorInfo *)>

using	ExtendedVisitor = std::function< void(int lineNumber, const ExtendedVisitorInfo *)>

Static Public Member Functions inherited from skia::textlayout::Paragraph
static SkPath	GetPath (SkTextBlob *textBlob)

Protected Attributes inherited from skia::textlayout::Paragraph
sk_sp< FontCollection >	fFontCollection

ParagraphStyle	fParagraphStyle

SkScalar	fAlphabeticBaseline

SkScalar	fIdeographicBaseline

SkScalar	fHeight

SkScalar	fWidth

SkScalar	fMaxIntrinsicWidth

SkScalar	fMinIntrinsicWidth

SkScalar	fLongestLine

bool	fExceededMaxLines

Detailed Description

Definition at line 88 of file ParagraphImpl.h.

Constructor & Destructor Documentation

◆ ParagraphImpl() [1/2]

skia::textlayout::ParagraphImpl::ParagraphImpl	(	const SkString &	text,
		ParagraphStyle	style,
		skia_private::TArray< Block, true >	blocks,
		skia_private::TArray< Placeholder, true >	placeholders,
		sk_sp< FontCollection >	fonts,
		sk_sp< SkUnicode >	unicode
	)

Definition at line 73 of file ParagraphImpl.cpp.

        : Paragraph(std::move(style), std::move(fonts))
        , fTextStyles(std::move(blocks))
        , fPlaceholders(std::move(placeholders))
        , fText(text)
        , fState(kUnknown)
        , fUnresolvedGlyphs(0)
        , fPicture(nullptr)
        , fStrutMetrics(false)
        , fOldWidth(0)
        , fOldHeight(0)
        , fUnicode(std::move(unicode))
        , fHasLineBreaks(false)
        , fHasWhitespacesInside(false)
        , fTrailingSpaces(0)
{
    SkASSERT(fUnicode);
}

◆ ParagraphImpl() [2/2]

skia::textlayout::ParagraphImpl::ParagraphImpl	(	const std::u16string &	utf16text,
		ParagraphStyle	style,
		skia_private::TArray< Block, true >	blocks,
		skia_private::TArray< Placeholder, true >	placeholders,
		sk_sp< FontCollection >	fonts,
		sk_sp< SkUnicode >	unicode
	)

Definition at line 97 of file ParagraphImpl.cpp.

        : ParagraphImpl(SkString(),
                        std::move(style),
                        std::move(blocks),
                        std::move(placeholders),
                        std::move(fonts),
                        std::move(unicode))
{
    SkASSERT(fUnicode);
    fText =  SkUnicode::convertUtf16ToUtf8(utf16text);
}

◆ ~ParagraphImpl()

skia::textlayout::ParagraphImpl::~ParagraphImpl ( )

overridedefault

Member Function Documentation

◆ addLine()

TextLine & skia::textlayout::ParagraphImpl::addLine	(	SkVector	offset,
		SkVector	advance,
		TextRange	textExcludingSpaces,
		TextRange	text,
		TextRange	textIncludingNewlines,
		ClusterRange	clusters,
		ClusterRange	clustersWithGhosts,
		SkScalar	widthWithSpaces,
		InternalLineMetrics	sizes
	)

Definition at line 763 of file ParagraphImpl.cpp.

                                                            {
    // Define a list of styles that covers the line
    auto blocks = findAllBlocks(textExcludingSpaces);
    return fLines.emplace_back(this, offset, advance, blocks,
                               textExcludingSpaces, text, textIncludingNewLines,
                               clusters, clustersWithGhosts, widthWithSpaces, sizes);
}

◆ addUnresolvedCodepoints()

void skia::textlayout::ParagraphImpl::addUnresolvedCodepoints ( TextRange textRange )

Definition at line 128 of file ParagraphImpl.cpp.

                                                               {
    fUnicode->forEachCodepoint(
        &fText[textRange.start], textRange.width(),
        [&](SkUnichar unichar, int32_t start, int32_t end, int32_t count) {
            fUnresolvedCodepoints.emplace(unichar);
        }
    );
}

◆ applySpacingAndBuildClusterTable()

void skia::textlayout::ParagraphImpl::applySpacingAndBuildClusterTable ( )

Definition at line 397 of file ParagraphImpl.cpp.

                                                     {
 
    // Check all text styles to see what we have to do (if anything)
    size_t letterSpacingStyles = 0;
    bool hasWordSpacing = false;
    for (auto& block : fTextStyles) {
        if (block.fRange.width() > 0) {
            if (!SkScalarNearlyZero(block.fStyle.getLetterSpacing())) {
                ++letterSpacingStyles;
            }
            if (!SkScalarNearlyZero(block.fStyle.getWordSpacing())) {
                hasWordSpacing = true;
            }
        }
    }
 
    if (letterSpacingStyles == 0 && !hasWordSpacing) {
        // We don't have to do anything about spacing (most common case)
        this->buildClusterTable();
        return;
    }
 
    if (letterSpacingStyles == 1 && !hasWordSpacing && fTextStyles.size() == 1 &&
        fTextStyles[0].fRange.width() == fText.size() && fRuns.size() == 1) {
        // We have to letter space the entire paragraph (second most common case)
        auto& run = fRuns[0];
        auto& style = fTextStyles[0].fStyle;
        run.addSpacesEvenly(style.getLetterSpacing());
        this->buildClusterTable();
        // This is something Flutter requires
        for (auto& cluster : fClusters) {
            cluster.setHalfLetterSpacing(style.getLetterSpacing()/2);
        }
        return;
    }
 
    // The complex case: many text styles with spacing (possibly not adjusted to glyphs)
    this->buildClusterTable();
 
    // Walk through all the clusters in the direction of shaped text
    // (we have to walk through the styles in the same order, too)
    // Not breaking the iteration on every run!
    SkScalar shift = 0;
    bool soFarWhitespacesOnly = true;
    bool wordSpacingPending = false;
    Cluster* lastSpaceCluster = nullptr;
    for (auto& run : fRuns) {
 
        // Skip placeholder runs
        if (run.isPlaceholder()) {
            continue;
        }
 
        run.iterateThroughClusters([this, &run, &shift, &soFarWhitespacesOnly, &wordSpacingPending, &lastSpaceCluster](Cluster* cluster) {
            // Shift the cluster (shift collected from the previous clusters)
            run.shift(cluster, shift);
 
            // Synchronize styles (one cluster can be covered by few styles)
            Block* currentStyle = fTextStyles.begin();
            while (!cluster->startsIn(currentStyle->fRange)) {
                currentStyle++;
                SkASSERT(currentStyle != fTextStyles.end());
            }
 
            SkASSERT(!currentStyle->fStyle.isPlaceholder());
 
            // Process word spacing
            if (currentStyle->fStyle.getWordSpacing() != 0) {
                if (cluster->isWhitespaceBreak() && cluster->isSoftBreak()) {
                    if (!soFarWhitespacesOnly) {
                        lastSpaceCluster = cluster;
                        wordSpacingPending = true;
                    }
                } else if (wordSpacingPending) {
                    SkScalar spacing = currentStyle->fStyle.getWordSpacing();
                    if (cluster->fRunIndex != lastSpaceCluster->fRunIndex) {
                        // If the last space cluster belongs to the previous run
                        // we have to extend that cluster and that run
                        lastSpaceCluster->run().addSpacesAtTheEnd(spacing, lastSpaceCluster);
                        lastSpaceCluster->run().extend(lastSpaceCluster, spacing);
                    } else {
                        run.addSpacesAtTheEnd(spacing, lastSpaceCluster);
                    }
 
                    run.shift(cluster, spacing);
                    shift += spacing;
                    wordSpacingPending = false;
                }
            }
            // Process letter spacing
            if (currentStyle->fStyle.getLetterSpacing() != 0) {
                shift += run.addSpacesEvenly(currentStyle->fStyle.getLetterSpacing(), cluster);
            }
 
            if (soFarWhitespacesOnly && !cluster->isWhitespaceBreak()) {
                soFarWhitespacesOnly = false;
            }
        });
    }
}

◆ block()

Block & skia::textlayout::ParagraphImpl::block ( BlockIndex blockIndex )

Definition at line 966 of file ParagraphImpl.cpp.

                                                 {
    SkASSERT(blockIndex < SkToSizeT(fTextStyles.size()));
    return fTextStyles[blockIndex];
}

◆ blocks()

SkSpan< Block > skia::textlayout::ParagraphImpl::blocks ( BlockRange blockRange )

Definition at line 960 of file ParagraphImpl.cpp.

                                                         {
    SkASSERT(blockRange.start < SkToSizeT(fTextStyles.size()) &&
             blockRange.end <= SkToSizeT(fTextStyles.size()));
    return SkSpan<Block>(&fTextStyles[blockRange.start], blockRange.width());
}

◆ breakShapedTextIntoLines()

void skia::textlayout::ParagraphImpl::breakShapedTextIntoLines ( SkScalar maxWidth )

Definition at line 573 of file ParagraphImpl.cpp.

                                                              {
 
    if (!fHasLineBreaks &&
        !fHasWhitespacesInside &&
        fPlaceholders.size() == 1 &&
        fRuns.size() == 1 && fRuns[0].fAdvance.fX <= maxWidth) {
        // This is a short version of a line breaking when we know that:
        // 1. We have only one line of text
        // 2. It's shaped into a single run
        // 3. There are no placeholders
        // 4. There are no linebreaks (which will format text into multiple lines)
        // 5. There are no whitespaces so the minIntrinsicWidth=maxIntrinsicWidth
        // (To think about that, the last condition is not quite right;
        // we should calculate minIntrinsicWidth by soft line breaks.
        // However, it's how it's done in Flutter now)
        auto& run = this->fRuns[0];
        auto advance = run.advance();
        auto textRange = TextRange(0, this->text().size());
        auto textExcludingSpaces = TextRange(0, fTrailingSpaces);
        InternalLineMetrics metrics(this->strutForceHeight());
        metrics.add(&run);
        auto disableFirstAscent = this->paragraphStyle().getTextHeightBehavior() &
                                  TextHeightBehavior::kDisableFirstAscent;
        auto disableLastDescent = this->paragraphStyle().getTextHeightBehavior() &
                                  TextHeightBehavior::kDisableLastDescent;
        if (disableFirstAscent) {
            metrics.fAscent = metrics.fRawAscent;
        }
        if (disableLastDescent) {
            metrics.fDescent = metrics.fRawDescent;
        }
        if (this->strutEnabled()) {
            this->strutMetrics().updateLineMetrics(metrics);
        }
        ClusterIndex trailingSpaces = fClusters.size();
        do {
            --trailingSpaces;
            auto& cluster = fClusters[trailingSpaces];
            if (!cluster.isWhitespaceBreak()) {
                ++trailingSpaces;
                break;
            }
            advance.fX -= cluster.width();
        } while (trailingSpaces != 0);
 
        advance.fY = metrics.height();
        auto clusterRange = ClusterRange(0, trailingSpaces);
        auto clusterRangeWithGhosts = ClusterRange(0, this->clusters().size() - 1);
        this->addLine(SkPoint::Make(0, 0), advance,
                      textExcludingSpaces, textRange, textRange,
                      clusterRange, clusterRangeWithGhosts, run.advance().x(),
                      metrics);
 
        fLongestLine = nearlyZero(advance.fX) ? run.advance().fX : advance.fX;
        fHeight = advance.fY;
        fWidth = maxWidth;
        fMaxIntrinsicWidth = run.advance().fX;
        fMinIntrinsicWidth = advance.fX;
        fAlphabeticBaseline = fLines.empty() ? fEmptyMetrics.alphabeticBaseline() : fLines.front().alphabeticBaseline();
        fIdeographicBaseline = fLines.empty() ? fEmptyMetrics.ideographicBaseline() : fLines.front().ideographicBaseline();
        fExceededMaxLines = false;
        return;
    }
 
    TextWrapper textWrapper;
    textWrapper.breakTextIntoLines(
            this,
            maxWidth,
            [&](TextRange textExcludingSpaces,
                TextRange text,
                TextRange textWithNewlines,
                ClusterRange clusters,
                ClusterRange clustersWithGhosts,
                SkScalar widthWithSpaces,
                size_t startPos,
                size_t endPos,
                SkVector offset,
                SkVector advance,
                InternalLineMetrics metrics,
                bool addEllipsis) {
                // TODO: Take in account clipped edges
                auto& line = this->addLine(offset, advance, textExcludingSpaces, text, textWithNewlines, clusters, clustersWithGhosts, widthWithSpaces, metrics);
                if (addEllipsis) {
                    line.createEllipsis(maxWidth, this->getEllipsis(), true);
                }
                fLongestLine = std::max(fLongestLine, nearlyZero(advance.fX) ? widthWithSpaces : advance.fX);
            });
 
    fHeight = textWrapper.height();
    fWidth = maxWidth;
    fMaxIntrinsicWidth = textWrapper.maxIntrinsicWidth();
    fMinIntrinsicWidth = textWrapper.minIntrinsicWidth();
    fAlphabeticBaseline = fLines.empty() ? fEmptyMetrics.alphabeticBaseline() : fLines.front().alphabeticBaseline();
    fIdeographicBaseline = fLines.empty() ? fEmptyMetrics.ideographicBaseline() : fLines.front().ideographicBaseline();
    fExceededMaxLines = textWrapper.exceededMaxLines();
}

◆ buildClusterTable()

void skia::textlayout::ParagraphImpl::buildClusterTable ( )

Definition at line 499 of file ParagraphImpl.cpp.

                                      {
    // It's possible that one grapheme includes few runs; we cannot handle it
    // so we break graphemes by the runs instead
    // It's not the ideal solution and has to be revisited later
    int cluster_count = 1;
    for (auto& run : fRuns) {
        cluster_count += run.isPlaceholder() ? 1 : run.size();
        fCodeUnitProperties[run.fTextRange.start] |= SkUnicode::CodeUnitFlags::kGraphemeStart;
        fCodeUnitProperties[run.fTextRange.start] |= SkUnicode::CodeUnitFlags::kGlyphClusterStart;
    }
    if (!fRuns.empty()) {
        fCodeUnitProperties[fRuns.back().textRange().end] |= SkUnicode::CodeUnitFlags::kGraphemeStart;
        fCodeUnitProperties[fRuns.back().textRange().end] |= SkUnicode::CodeUnitFlags::kGlyphClusterStart;
    }
    fClusters.reserve_exact(fClusters.size() + cluster_count);
 
    // Walk through all the run in the direction of input text
    for (auto& run : fRuns) {
        auto runIndex = run.index();
        auto runStart = fClusters.size();
        if (run.isPlaceholder()) {
            // Add info to cluster indexes table (text -> cluster)
            for (auto i = run.textRange().start; i < run.textRange().end; ++i) {
              fClustersIndexFromCodeUnit[i] = fClusters.size();
            }
            // There are no glyphs but we want to have one cluster
            fClusters.emplace_back(this, runIndex, 0ul, 1ul, this->text(run.textRange()), run.advance().fX, run.advance().fY);
            fCodeUnitProperties[run.textRange().start] |= SkUnicode::CodeUnitFlags::kSoftLineBreakBefore;
            fCodeUnitProperties[run.textRange().end] |= SkUnicode::CodeUnitFlags::kSoftLineBreakBefore;
        } else {
            // Walk through the glyph in the direction of input text
            run.iterateThroughClustersInTextOrder([runIndex, this](size_t glyphStart,
                                                                   size_t glyphEnd,
                                                                   size_t charStart,
                                                                   size_t charEnd,
                                                                   SkScalar width,
                                                                   SkScalar height) {
                SkASSERT(charEnd >= charStart);
                // Add info to cluster indexes table (text -> cluster)
                for (auto i = charStart; i < charEnd; ++i) {
                  fClustersIndexFromCodeUnit[i] = fClusters.size();
                }
                SkSpan<const char> text(fText.c_str() + charStart, charEnd - charStart);
                fClusters.emplace_back(this, runIndex, glyphStart, glyphEnd, text, width, height);
                fCodeUnitProperties[charStart] |= SkUnicode::CodeUnitFlags::kGlyphClusterStart;
            });
        }
        fCodeUnitProperties[run.textRange().start] |= SkUnicode::CodeUnitFlags::kGlyphClusterStart;
 
        run.setClusterRange(runStart, fClusters.size());
        fMaxIntrinsicWidth += run.advance().fX;
    }
    fClustersIndexFromCodeUnit[fText.size()] = fClusters.size();
    fClusters.emplace_back(this, EMPTY_RUN, 0, 0, this->text({fText.size(), fText.size()}), 0, 0);
}

◆ cluster()

Cluster & skia::textlayout::ParagraphImpl::cluster ( ClusterIndex clusterIndex )

Definition at line 950 of file ParagraphImpl.cpp.

                                                         {
    SkASSERT(clusterIndex < SkToSizeT(fClusters.size()));
    return fClusters[clusterIndex];
}

◆ clusterIndex()

ClusterIndex skia::textlayout::ParagraphImpl::clusterIndex ( TextIndex textIndex )

inline

Definition at line 167 of file ParagraphImpl.h.

                                                   {
        auto clusterIndex = this->fClustersIndexFromCodeUnit[textIndex];
        SkASSERT(clusterIndex != EMPTY_INDEX);
        return clusterIndex;
    }

◆ clusters() [1/2]

SkSpan< Cluster > skia::textlayout::ParagraphImpl::clusters ( )

inline

Definition at line 140 of file ParagraphImpl.h.

140{ return SkSpan<Cluster>(fClusters.begin(), fClusters.size()); }

◆ clusters() [2/2]

SkSpan< Cluster > skia::textlayout::ParagraphImpl::clusters ( ClusterRange clusterRange )

Definition at line 944 of file ParagraphImpl.cpp.

                                                                 {
    SkASSERT(clusterRange.start < SkToSizeT(fClusters.size()) &&
             clusterRange.end <= SkToSizeT(fClusters.size()));
    return SkSpan<Cluster>(&fClusters[clusterRange.start], clusterRange.width());
}

◆ codeUnitHasProperty()

bool skia::textlayout::ParagraphImpl::codeUnitHasProperty	(	size_t	index,
		SkUnicode::CodeUnitFlags	property
	)		const

inline

Definition at line 243 of file ParagraphImpl.h.

                                                                                  {
        return (fCodeUnitProperties[index] & property) == property;
    }

◆ computeCodeUnitProperties()

bool skia::textlayout::ParagraphImpl::computeCodeUnitProperties ( )

Definition at line 267 of file ParagraphImpl.cpp.

                                              {
 
    if (nullptr == fUnicode) {
        return false;
    }
 
    // Get bidi regions
    auto textDirection = fParagraphStyle.getTextDirection() == TextDirection::kLtr
                              ? SkUnicode::TextDirection::kLTR
                              : SkUnicode::TextDirection::kRTL;
    if (!fUnicode->getBidiRegions(fText.c_str(), fText.size(), textDirection, &fBidiRegions)) {
        return false;
    }
 
    // Collect all spaces and some extra information
    // (and also substitute \t with a space while we are at it)
    if (!fUnicode->computeCodeUnitFlags(&fText[0],
                                        fText.size(),
                                        this->paragraphStyle().getReplaceTabCharacters(),
                                        &fCodeUnitProperties)) {
        return false;
    }
 
    // Get some information about trailing spaces / hard line breaks
    fTrailingSpaces = fText.size();
    TextIndex firstWhitespace = EMPTY_INDEX;
    for (int i = 0; i < fCodeUnitProperties.size(); ++i) {
        auto flags = fCodeUnitProperties[i];
        if (SkUnicode::hasPartOfWhiteSpaceBreakFlag(flags)) {
            if (fTrailingSpaces  == fText.size()) {
                fTrailingSpaces = i;
            }
            if (firstWhitespace == EMPTY_INDEX) {
                firstWhitespace = i;
            }
        } else {
            fTrailingSpaces = fText.size();
        }
        if (SkUnicode::hasHardLineBreakFlag(flags)) {
            fHasLineBreaks = true;
        }
    }
 
    if (firstWhitespace < fTrailingSpaces) {
        fHasWhitespacesInside = true;
    }
 
    return true;
}

◆ containsColorFontOrBitmap()

bool skia::textlayout::ParagraphImpl::containsColorFontOrBitmap ( SkTextBlob * textBlob )

overridevirtual

Implements skia::textlayout::Paragraph.

Definition at line 1545 of file ParagraphImpl.cpp.

                                                                  {
    SkTextBlobRunIterator iter(textBlob);
    bool flag = false;
    while (!iter.done() && !flag) {
        iter.font().getPaths(
            (const SkGlyphID*) iter.glyphs(),
            iter.glyphCount(),
            [](const SkPath* path, const SkMatrix& mx, void* ctx) {
                if (path == nullptr) {
                    bool* flag1 = (bool*)ctx;
                    *flag1 = true;
                }
            }, &flag);
        iter.next();
    }
    return flag;
}

◆ containsEmoji()

bool skia::textlayout::ParagraphImpl::containsEmoji ( SkTextBlob * textBlob )

overridevirtual

Implements skia::textlayout::Paragraph.

Definition at line 1529 of file ParagraphImpl.cpp.

                                                      {
    bool result = false;
    SkTextBlobRunIterator iter(textBlob);
    while (!iter.done() && !result) {
        // Walk through all the text by codepoints
        this->getUnicode()->forEachCodepoint(iter.text(), iter.textSize(),
           [&](SkUnichar unichar, int32_t start, int32_t end, int32_t count) {
                if (this->getUnicode()->isEmoji(unichar)) {
                    result = true;
                }
            });
        iter.next();
    }
    return result;
}

◆ countSurroundingGraphemes()

TArray< TextIndex > skia::textlayout::ParagraphImpl::countSurroundingGraphemes ( TextRange textRange ) const

Definition at line 1123 of file ParagraphImpl.cpp.

                                                                                    {
    textRange = textRange.intersection({0, fText.size()});
    TArray<TextIndex> graphemes;
    if ((fCodeUnitProperties[textRange.start] & SkUnicode::CodeUnitFlags::kGraphemeStart) == 0) {
        // Count the previous partial grapheme
        graphemes.emplace_back(textRange.start);
    }
    for (auto index = textRange.start; index < textRange.end; ++index) {
        if ((fCodeUnitProperties[index] & SkUnicode::CodeUnitFlags::kGraphemeStart) != 0) {
            graphemes.emplace_back(index);
        }
    }
    return graphemes;
}

◆ ensureUTF16Mapping()

void skia::textlayout::ParagraphImpl::ensureUTF16Mapping ( )

Definition at line 1170 of file ParagraphImpl.cpp.

                                       {
    fillUTF16MappingOnce([&] {
        SkUnicode::extractUtfConversionMapping(
                this->text(),
                [&](size_t index) { fUTF8IndexForUTF16Index.emplace_back(index); },
                [&](size_t index) { fUTF16IndexForUTF8Index.emplace_back(index); });
    });
}

◆ extendedVisit()

void skia::textlayout::ParagraphImpl::extendedVisit ( const ExtendedVisitor & visitor )

overridevirtual

Implements skia::textlayout::Paragraph.

Definition at line 1390 of file ParagraphImpl.cpp.

                                                                {
    int lineNumber = 0;
    for (auto& line : fLines) {
        line.iterateThroughVisualRuns(
            false,
            [&](const Run* run,
                SkScalar runOffsetInLine,
                TextRange textRange,
                SkScalar* runWidthInLine) {
                *runWidthInLine = line.iterateThroughSingleRunByStyles(
                TextLine::TextAdjustment::GlyphCluster,
                run,
                runOffsetInLine,
                textRange,
                StyleType::kNone,
                [&](TextRange textRange,
                    const TextStyle& style,
                    const TextLine::ClipContext& context) {
                    SkScalar correctedBaseline = SkScalarFloorToScalar(
                        line.baseline() + style.getBaselineShift() + 0.5);
                    SkPoint offset =
                        SkPoint::Make(line.offset().fX + context.fTextShift,
                                      line.offset().fY + correctedBaseline);
                    SkRect rect = context.clip.makeOffset(line.offset());
                    AutoSTArray<16, SkRect> glyphBounds;
                    glyphBounds.reset(SkToInt(run->size()));
                    run->font().getBounds(run->glyphs().data(),
                                          SkToInt(run->size()),
                                          glyphBounds.data(),
                                          nullptr);
                    STArray<128, uint32_t> clusterStorage;
                    const uint32_t* clusterPtr = run->clusterIndexes().data();
                    if (run->fClusterStart > 0) {
                        clusterStorage.reset(context.size);
                        for (size_t i = 0; i < context.size; ++i) {
                          clusterStorage[i] =
                              run->fClusterStart + run->fClusterIndexes[i];
                        }
                        clusterPtr = &clusterStorage[0];
                    }
                    const Paragraph::ExtendedVisitorInfo info = {
                        run->font(),
                        offset,
                        SkSize::Make(rect.width(), rect.height()),
                        SkToS16(context.size),
                        &run->glyphs()[context.pos],
                        &run->fPositions[context.pos],
                        &glyphBounds[context.pos],
                        clusterPtr,
                        0,  // flags
                    };
                    visitor(lineNumber, &info);
                });
            return true;
            });
        visitor(lineNumber, nullptr);   // signal end of line
        lineNumber += 1;
    }
}

◆ findAllBlocks()

BlockRange skia::textlayout::ParagraphImpl::findAllBlocks ( TextRange textRange )

Definition at line 737 of file ParagraphImpl.cpp.

                                                           {
    BlockIndex begin = EMPTY_BLOCK;
    BlockIndex end = EMPTY_BLOCK;
    for (int index = 0; index < fTextStyles.size(); ++index) {
        auto& block = fTextStyles[index];
        if (block.fRange.end <= textRange.start) {
            continue;
        }
        if (block.fRange.start >= textRange.end) {
            break;
        }
        if (begin == EMPTY_BLOCK) {
            begin = index;
        }
        end = index;
    }
 
    if (begin == EMPTY_INDEX || end == EMPTY_INDEX) {
        // It's possible if some text is not covered with any text style
        // Not in Flutter but in direct use of SkParagraph
        return EMPTY_RANGE;
    }
 
    return { begin, end + 1 };
}

◆ findNextGlyphClusterBoundary()

TextIndex skia::textlayout::ParagraphImpl::findNextGlyphClusterBoundary ( TextIndex utf8 ) const

Definition at line 1154 of file ParagraphImpl.cpp.

                                                                          {
    while (utf8 < fText.size() &&
          (fCodeUnitProperties[utf8] & SkUnicode::CodeUnitFlags::kGlyphClusterStart) == 0) {
        ++utf8;
    }
    return utf8;
}

◆ findNextGraphemeBoundary()

TextIndex skia::textlayout::ParagraphImpl::findNextGraphemeBoundary ( TextIndex utf8 ) const

Definition at line 1146 of file ParagraphImpl.cpp.

                                                                      {
    while (utf8 < fText.size() &&
          (fCodeUnitProperties[utf8] & SkUnicode::CodeUnitFlags::kGraphemeStart) == 0) {
        ++utf8;
    }
    return utf8;
}

◆ findPreviousGlyphClusterBoundary()

TextIndex skia::textlayout::ParagraphImpl::findPreviousGlyphClusterBoundary ( TextIndex utf8 ) const

Definition at line 1162 of file ParagraphImpl.cpp.

                                                                              {
    while (utf8 > 0 &&
          (fCodeUnitProperties[utf8] & SkUnicode::CodeUnitFlags::kGlyphClusterStart) == 0) {
        --utf8;
    }
    return utf8;
}

◆ findPreviousGraphemeBoundary()

TextIndex skia::textlayout::ParagraphImpl::findPreviousGraphemeBoundary ( TextIndex utf8 ) const

Definition at line 1138 of file ParagraphImpl.cpp.

                                                                          {
    while (utf8 > 0 &&
          (fCodeUnitProperties[utf8] & SkUnicode::CodeUnitFlags::kGraphemeStart) == 0) {
        --utf8;
    }
    return utf8;
}

◆ fontCollection()

sk_sp< FontCollection > skia::textlayout::ParagraphImpl::fontCollection ( ) const

inline

Definition at line 141 of file ParagraphImpl.h.

141{ return fFontCollection; }

skia::textlayout::Paragraph::fFontCollection

sk_sp< FontCollection > fFontCollection

Definition: Paragraph.h:273

◆ formatLines()

void skia::textlayout::ParagraphImpl::formatLines ( SkScalar maxWidth )

Definition at line 670 of file ParagraphImpl.cpp.

                                                 {
    auto effectiveAlign = fParagraphStyle.effective_align();
    const bool isLeftAligned = effectiveAlign == TextAlign::kLeft
        || (effectiveAlign == TextAlign::kJustify && fParagraphStyle.getTextDirection() == TextDirection::kLtr);
 
    if (!SkIsFinite(maxWidth) && !isLeftAligned) {
        // Special case: clean all text in case of maxWidth == INF & align != left
        // We had to go through shaping though because we need all the measurement numbers
        fLines.clear();
        return;
    }
 
    for (auto& line : fLines) {
        line.format(effectiveAlign, maxWidth);
    }
}

◆ getActualTextRange()

TextRange skia::textlayout::ParagraphImpl::getActualTextRange	(	int	lineNumber,
		bool	includeSpaces
	)		const

overridevirtual

Implements skia::textlayout::Paragraph.

Definition at line 1270 of file ParagraphImpl.cpp.

                                                                                    {
    if (lineNumber < 0 || lineNumber >= fLines.size()) {
        return EMPTY_TEXT;
    }
    auto& line = fLines[lineNumber];
    return includeSpaces ? line.text() : line.trimmedText();
}

◆ getApplyRoundingHack()

bool skia::textlayout::ParagraphImpl::getApplyRoundingHack ( ) const

inline

Definition at line 120 of file ParagraphImpl.h.

120{ return fParagraphStyle.getApplyRoundingHack(); }

skia::textlayout::ParagraphStyle::getApplyRoundingHack

bool getApplyRoundingHack() const

Definition: ParagraphStyle.h:127

◆ getClosestGlyphClusterAt()

bool skia::textlayout::ParagraphImpl::getClosestGlyphClusterAt	(	SkScalar	dx,
		SkScalar	dy,
		GlyphClusterInfo *	glyphInfo
	)

overridevirtual

Finds the closest glyph cluster for a visual text position

Parameters

dx	x coordinate
dy	y coordinate
glyphInfo	a glyph cluster info filled if not null

Returns: true if glyph cluster was found; false if not (which usually means the paragraph is empty)

Implements skia::textlayout::Paragraph.

Definition at line 1303 of file ParagraphImpl.cpp.

                                                                          {
    const PositionWithAffinity res = this->getGlyphPositionAtCoordinate(dx, dy);
    SkASSERT(res.position != 0 || res.affinity != Affinity::kUpstream);
    const size_t utf16Offset = res.position + (res.affinity == Affinity::kDownstream ? 0 : -1);
    this->ensureUTF16Mapping();
    SkASSERT(utf16Offset < SkToSizeT(fUTF8IndexForUTF16Index.size()));
    return this->getGlyphClusterAt(fUTF8IndexForUTF16Index[utf16Offset], glyphInfo);
}

◆ getClosestUTF16GlyphInfoAt()

bool skia::textlayout::ParagraphImpl::getClosestUTF16GlyphInfoAt	(	SkScalar	dx,
		SkScalar	dy,
		GlyphInfo *	glyphInfo
	)

overridevirtual

Finds the information associated with the closest glyph to the given paragraph coordinates.

Parameters

dx	x coordinate
dy	y coordinate
glyphInfo	an optional GlyphInfo struct to hold the information associated with the glyph found. The text indices and text ranges are described using UTF-16 offsets

Returns: true if a graphme cluster was found; false if not (which usually means the paragraph is empty)

Implements skia::textlayout::Paragraph.

Definition at line 1350 of file ParagraphImpl.cpp.

                                                                                             {
    const PositionWithAffinity res = this->getGlyphPositionAtCoordinate(dx, dy);
    SkASSERT(res.position != 0 || res.affinity != Affinity::kUpstream);
    const size_t utf16Offset = res.position + (res.affinity == Affinity::kDownstream ? 0 : -1);
    return getGlyphInfoAtUTF16Offset(utf16Offset, glyphInfo);
}

◆ getEllipsis()

SkString skia::textlayout::ParagraphImpl::getEllipsis ( ) const

Definition at line 1066 of file ParagraphImpl.cpp.

                                          {
 
    auto ellipsis8 = fParagraphStyle.getEllipsis();
    auto ellipsis16 = fParagraphStyle.getEllipsisUtf16();
    if (!ellipsis8.isEmpty()) {
        return ellipsis8;
    } else {
        return SkUnicode::convertUtf16ToUtf8(fParagraphStyle.getEllipsisUtf16());
    }
}

◆ getEmptyMetrics()

InternalLineMetrics skia::textlayout::ParagraphImpl::getEmptyMetrics ( ) const

inline

Definition at line 232 of file ParagraphImpl.h.

232{ return fEmptyMetrics; }

◆ getFontAt()

SkFont skia::textlayout::ParagraphImpl::getFontAt ( TextIndex codeUnitIndex ) const

overridevirtual

Returns the font that is used to shape the text at the position

Parameters

codeUnitIndex text index

Returns: font info or an empty font info if the text is not found

Implements skia::textlayout::Paragraph.

Definition at line 1357 of file ParagraphImpl.cpp.

                                                             {
    for (auto& run : fRuns) {
        const auto textRange = run.textRange();
        if (textRange.start <= codeUnitIndex && codeUnitIndex < textRange.end) {
            return run.font();
        }
    }
    return SkFont();
}

◆ getFontAtUTF16Offset()

SkFont skia::textlayout::ParagraphImpl::getFontAtUTF16Offset ( size_t codeUnitIndex )

overridevirtual

Returns the font used to shape the text at the given UTF-16 offset.

Parameters

codeUnitIndex a UTF-16 offset in the paragraph

Returns: font info or an empty font info if the text is not found

Implements skia::textlayout::Paragraph.

Definition at line 1367 of file ParagraphImpl.cpp.

                                                               {
    ensureUTF16Mapping();
    if (codeUnitIndex >= SkToSizeT(fUTF8IndexForUTF16Index.size())) {
        return SkFont();
    }
    const TextIndex utf8 = fUTF8IndexForUTF16Index[codeUnitIndex];
    for (auto& run : fRuns) {
        const auto textRange = run.textRange();
        if (textRange.start <= utf8 && utf8 < textRange.end) {
            return run.font();
        }
    }
    return SkFont();
}

◆ getFonts()

std::vector< Paragraph::FontInfo > skia::textlayout::ParagraphImpl::getFonts ( ) const

overridevirtual

Returns the information about all the fonts used to shape the paragraph text

Returns: a list of fonts and text ranges

Implements skia::textlayout::Paragraph.

Definition at line 1382 of file ParagraphImpl.cpp.

                                                           {
    std::vector<FontInfo> results;
    for (auto& run : fRuns) {
        results.emplace_back(run.font(), run.textRange());
    }
    return results;
}

◆ getGlyphClusterAt()

bool skia::textlayout::ParagraphImpl::getGlyphClusterAt	(	TextIndex	codeUnitIndex,
		GlyphClusterInfo *	glyphInfo
	)

overridevirtual

Finds a glyph cluster for text index

Parameters

codeUnitIndex	a text index
glyphInfo	a glyph cluster info filled if not null

Returns: true if glyph cluster was found; false if not

Implements skia::textlayout::Paragraph.

Definition at line 1278 of file ParagraphImpl.cpp.

                                                                                          {
    const int lineNumber = getLineNumberAt(codeUnitIndex);
    if (lineNumber == -1) {
        return false;
    }
    auto& line = fLines[lineNumber];
    for (auto c = line.clustersWithSpaces().start; c < line.clustersWithSpaces().end; ++c) {
        auto& cluster = fClusters[c];
        if (cluster.contains(codeUnitIndex)) {
            std::vector<TextBox> boxes;
            line.getRectsForRange(cluster.textRange(),
                                    RectHeightStyle::kTight,
                                    RectWidthStyle::kTight,
                                    boxes);
            if (!boxes.empty()) {
                if (glyphInfo) {
                    *glyphInfo = {boxes[0].rect, cluster.textRange(), boxes[0].direction};
                }
                return true;
            }
        }
    }
    return false;
}

◆ getGlyphInfoAtUTF16Offset()

bool skia::textlayout::ParagraphImpl::getGlyphInfoAtUTF16Offset	(	size_t	codeUnitIndex,
		GlyphInfo *	glyphInfo
	)

overridevirtual

Retrives the information associated with the glyph located at the given codeUnitIndex.

Parameters

codeUnitIndex	a UTF-16 offset into the paragraph
glyphInfo	an optional GlyphInfo struct to hold the information associated with the glyph found at the given index

Returns: false only if the offset is out of bounds

Implements skia::textlayout::Paragraph.

Definition at line 1314 of file ParagraphImpl.cpp.

                                                                                        {
    this->ensureUTF16Mapping();
    if (codeUnitIndex >= SkToSizeT(fUTF8IndexForUTF16Index.size())) {
        return false;
    }
    const TextIndex utf8 = fUTF8IndexForUTF16Index[codeUnitIndex];
    const int lineNumber = getLineNumberAt(utf8);
    if (lineNumber == -1) {
        return false;
    }
    if (glyphInfo == nullptr) {
        return true;
    }
    const TextLine& line = fLines[lineNumber];
    const TextIndex startIndex = findPreviousGraphemeBoundary(utf8);
    const TextIndex endIndex = findNextGraphemeBoundary(utf8 + 1);
    const ClusterIndex glyphClusterIndex = clusterIndex(utf8);
    const Cluster& glyphCluster = cluster(glyphClusterIndex);
 
    // `startIndex` and `endIndex` must be on the same line.
    std::vector<TextBox> boxes;
    line.getRectsForRange({startIndex, endIndex}, RectHeightStyle::kTight, RectWidthStyle::kTight, boxes);
    // TODO: currently placeholders with height=0 and width=0 are ignored so boxes
    // can be empty. These placeholders should still be reported for their
    // offset information.
    if (glyphInfo && !boxes.empty()) {
        *glyphInfo = {
            boxes[0].rect,
            { fUTF16IndexForUTF8Index[startIndex], fUTF16IndexForUTF8Index[endIndex] },
            boxes[0].direction,
            glyphCluster.run().isEllipsis(),
        };
    }
    return true;
}

◆ getGlyphPositionAtCoordinate()

PositionWithAffinity skia::textlayout::ParagraphImpl::getGlyphPositionAtCoordinate	(	SkScalar	dx,
		SkScalar	dy
	)

overridevirtual

Implements skia::textlayout::Paragraph.

Definition at line 875 of file ParagraphImpl.cpp.

                                                                                         {
 
    if (fText.isEmpty()) {
        return {0, Affinity::kDownstream};
    }
 
    this->ensureUTF16Mapping();
 
    for (auto& line : fLines) {
        // Let's figure out if we can stop looking
        auto offsetY = line.offset().fY;
        if (dy >= offsetY + line.height() && &line != &fLines.back()) {
            // This line is not good enough
            continue;
        }
 
        // This is so far the the line vertically closest to our coordinates
        // (or the first one, or the only one - all the same)
 
        auto result = line.getGlyphPositionAtCoordinate(dx);
        //SkDebugf("getGlyphPositionAtCoordinate(%f, %f): %d %s\n", dx, dy, result.position,
        //   result.affinity == Affinity::kUpstream ? "up" : "down");
        return result;
    }
 
    return {0, Affinity::kDownstream};
}

◆ getLineMetrics()

void skia::textlayout::ParagraphImpl::getLineMetrics ( std::vector< LineMetrics > & metrics )

overridevirtual

Implements skia::textlayout::Paragraph.

Definition at line 931 of file ParagraphImpl.cpp.

                                                                  {
    metrics.clear();
    for (auto& line : fLines) {
        metrics.emplace_back(line.getMetrics());
    }
}

◆ getLineMetricsAt()

bool skia::textlayout::ParagraphImpl::getLineMetricsAt	(	int	lineNumber,
		LineMetrics *	lineMetrics
	)		const

overridevirtual

Implements skia::textlayout::Paragraph.

Definition at line 1259 of file ParagraphImpl.cpp.

                                                                                   {
    if (lineNumber < 0 || lineNumber >= fLines.size()) {
        return false;
    }
    auto& line = fLines[lineNumber];
    if (lineMetrics) {
        *lineMetrics = line.getMetrics();
    }
    return true;
}

◆ getLineNumberAt()

int skia::textlayout::ParagraphImpl::getLineNumberAt ( TextIndex codeUnitIndex ) const

overridevirtual

Implements skia::textlayout::Paragraph.

Definition at line 1224 of file ParagraphImpl.cpp.

                                                                {
    if (codeUnitIndex >= fText.size()) {
        return -1;
    }
    size_t startLine = 0;
    size_t endLine = fLines.size() - 1;
    if (fLines.empty() || fLines[endLine].textWithNewlines().end <= codeUnitIndex) {
        return -1;
    }
 
    while (endLine > startLine) {
        // startLine + 1 <= endLine, so we have startLine <= midLine <= endLine - 1.
        const size_t midLine = (endLine + startLine) / 2;
        const TextRange midLineRange = fLines[midLine].textWithNewlines();
        if (codeUnitIndex < midLineRange.start) {
            endLine = midLine - 1;
        } else if (midLineRange.end <= codeUnitIndex) {
            startLine = midLine + 1;
        } else {
            return midLine;
        }
    }
    SkASSERT(startLine == endLine);
    return startLine;
}

◆ getLineNumberAtUTF16Offset()

int skia::textlayout::ParagraphImpl::getLineNumberAtUTF16Offset ( size_t codeUnitIndex )

overridevirtual

Implements skia::textlayout::Paragraph.

Definition at line 1250 of file ParagraphImpl.cpp.

                                                                  {
    this->ensureUTF16Mapping();
    if (codeUnitIndex >= SkToSizeT(fUTF8IndexForUTF16Index.size())) {
        return -1;
    }
    const TextIndex utf8 = fUTF8IndexForUTF16Index[codeUnitIndex];
    return getLineNumberAt(utf8);
}

◆ getPath()

int skia::textlayout::ParagraphImpl::getPath	(	int	lineNumber,
		SkPath *	dest
	)

overridevirtual

Implements skia::textlayout::Paragraph.

Definition at line 1450 of file ParagraphImpl.cpp.

                                                       {
    int notConverted = 0;
    auto& line = fLines[lineNumber];
    line.iterateThroughVisualRuns(
              false,
              [&](const Run* run,
                  SkScalar runOffsetInLine,
                  TextRange textRange,
                  SkScalar* runWidthInLine) {
          *runWidthInLine = line.iterateThroughSingleRunByStyles(
          TextLine::TextAdjustment::GlyphCluster,
          run,
          runOffsetInLine,
          textRange,
          StyleType::kNone,
          [&](TextRange textRange,
              const TextStyle& style,
              const TextLine::ClipContext& context) {
              const SkFont& font = run->font();
              SkScalar correctedBaseline = SkScalarFloorToScalar(
                line.baseline() + style.getBaselineShift() + 0.5);
              SkPoint offset =
                  SkPoint::Make(line.offset().fX + context.fTextShift,
                                line.offset().fY + correctedBaseline);
              SkRect rect = context.clip.makeOffset(offset);
              struct Rec {
                  SkPath* fPath;
                  SkPoint fOffset;
                  const SkPoint* fPos;
                  int fNotConverted;
              } rec =
                  {dest, SkPoint::Make(rect.left(), rect.top()),
                   &run->positions()[context.pos], 0};
              font.getPaths(&run->glyphs()[context.pos], context.size,
                    [](const SkPath* path, const SkMatrix& mx, void* ctx) {
                        Rec* rec = reinterpret_cast<Rec*>(ctx);
                        if (path) {
                            SkMatrix total = mx;
                            total.postTranslate(rec->fPos->fX + rec->fOffset.fX,
                                                rec->fPos->fY + rec->fOffset.fY);
                            rec->fPath->addPath(*path, total);
                        } else {
                            rec->fNotConverted++;
                        }
                        rec->fPos += 1; // move to the next glyph's position
                    }, &rec);
              notConverted += rec.fNotConverted;
          });
        return true;
    });
 
    return notConverted;
}

◆ getPicture()

sk_sp< SkPicture > skia::textlayout::ParagraphImpl::getPicture ( )

inline

Definition at line 193 of file ParagraphImpl.h.

193{ return fPicture; }

◆ getRectsForPlaceholders()

std::vector< TextBox > skia::textlayout::ParagraphImpl::getRectsForPlaceholders ( )

overridevirtual

Implements skia::textlayout::Paragraph.

Definition at line 848 of file ParagraphImpl.cpp.

                                                          {
  std::vector<TextBox> boxes;
  if (fText.isEmpty()) {
       return boxes;
  }
  if (fPlaceholders.size() == 1) {
       // We always have one fake placeholder
       return boxes;
  }
  for (auto& line : fLines) {
      line.getRectsForPlaceholders(boxes);
  }
  /*
  SkDebugf("getRectsForPlaceholders('%s'): %d\n", fText.c_str(), boxes.size());
  for (auto& r : boxes) {
      r.rect.fLeft = littleRound(r.rect.fLeft);
      r.rect.fRight = littleRound(r.rect.fRight);
      r.rect.fTop = littleRound(r.rect.fTop);
      r.rect.fBottom = littleRound(r.rect.fBottom);
      SkDebugf("[%f:%f * %f:%f] %s\n", r.rect.fLeft, r.rect.fRight, r.rect.fTop, r.rect.fBottom,
               (r.direction == TextDirection::kLtr ? "left" : "right"));
  }
  */
  return boxes;
}

◆ getRectsForRange()

std::vector< TextBox > skia::textlayout::ParagraphImpl::getRectsForRange	(	unsigned	start,
		unsigned	end,
		RectHeightStyle	rectHeightStyle,
		RectWidthStyle	rectWidthStyle
	)

overridevirtual

Implements skia::textlayout::Paragraph.

Definition at line 781 of file ParagraphImpl.cpp.

                                                                                    {
    std::vector<TextBox> results;
    if (fText.isEmpty()) {
        if (start == 0 && end > 0) {
            // On account of implied "\n" that is always at the end of the text
            //SkDebugf("getRectsForRange(%d, %d): %f\n", start, end, fHeight);
            results.emplace_back(SkRect::MakeXYWH(0, 0, 0, fHeight), fParagraphStyle.getTextDirection());
        }
        return results;
    }
 
    this->ensureUTF16Mapping();
 
    if (start >= end || start > SkToSizeT(fUTF8IndexForUTF16Index.size()) || end == 0) {
        return results;
    }
 
    // Adjust the text to grapheme edges
    // Apparently, text editor CAN move inside graphemes but CANNOT select a part of it.
    // I don't know why - the solution I have here returns an empty box for every query that
    // does not contain an end of a grapheme.
    // Once a cursor is inside a complex grapheme I can press backspace and cause trouble.
    // To avoid any problems, I will not allow any selection of a part of a grapheme.
    // One flutter test fails because of it but the editing experience is correct
    // (although you have to press the cursor many times before it moves to the next grapheme).
    TextRange text(fText.size(), fText.size());
    // TODO: This is probably a temp change that makes SkParagraph work as TxtLib
    //  (so we can compare the results). We now include in the selection box only the graphemes
    //  that belongs to the given [start:end) range entirely (not the ones that intersect with it)
    if (start < SkToSizeT(fUTF8IndexForUTF16Index.size())) {
        auto utf8 = fUTF8IndexForUTF16Index[start];
        // If start points to a trailing surrogate, skip it
        if (start > 0 && fUTF8IndexForUTF16Index[start - 1] == utf8) {
            utf8 = fUTF8IndexForUTF16Index[start + 1];
        }
        text.start = this->findNextGraphemeBoundary(utf8);
    }
    if (end < SkToSizeT(fUTF8IndexForUTF16Index.size())) {
        auto utf8 = this->findPreviousGraphemeBoundary(fUTF8IndexForUTF16Index[end]);
        text.end = utf8;
    }
    //SkDebugf("getRectsForRange(%d,%d) -> (%d:%d)\n", start, end, text.start, text.end);
    for (auto& line : fLines) {
        auto lineText = line.textWithNewlines();
        auto intersect = lineText * text;
        if (intersect.empty() && lineText.start != text.start) {
            continue;
        }
 
        line.getRectsForRange(intersect, rectHeightStyle, rectWidthStyle, results);
    }
/*
    SkDebugf("getRectsForRange(%d, %d)\n", start, end);
    for (auto& r : results) {
        r.rect.fLeft = littleRound(r.rect.fLeft);
        r.rect.fRight = littleRound(r.rect.fRight);
        r.rect.fTop = littleRound(r.rect.fTop);
        r.rect.fBottom = littleRound(r.rect.fBottom);
        SkDebugf("[%f:%f * %f:%f]\n", r.rect.fLeft, r.rect.fRight, r.rect.fTop, r.rect.fBottom);
    }
*/
    return results;
}

◆ getStrutMetrics()

InternalLineMetrics skia::textlayout::ParagraphImpl::getStrutMetrics ( ) const

inline

Definition at line 233 of file ParagraphImpl.h.

233{ return fStrutMetrics; }

◆ getUnicode()

sk_sp< SkUnicode > skia::textlayout::ParagraphImpl::getUnicode ( )

inline

Definition at line 247 of file ParagraphImpl.h.

247{ return fUnicode; }

◆ getUTF16Index()

size_t skia::textlayout::ParagraphImpl::getUTF16Index ( TextIndex index ) const

inline

Definition at line 149 of file ParagraphImpl.h.

                                                {
        return fUTF16IndexForUTF8Index[index];
    }

◆ getWordBoundary()

SkRange< size_t > skia::textlayout::ParagraphImpl::getWordBoundary ( unsigned offset )

overridevirtual

Implements skia::textlayout::Paragraph.

Definition at line 906 of file ParagraphImpl.cpp.

                                                              {
 
    if (fWords.empty()) {
        if (!fUnicode->getWords(fText.c_str(), fText.size(), nullptr, &fWords)) {
            return {0, 0 };
        }
    }
 
    int32_t start = 0;
    int32_t end = 0;
    for (size_t i = 0; i < fWords.size(); ++i) {
        auto word = fWords[i];
        if (word <= offset) {
            start = word;
            end = word;
        } else if (word > offset) {
            end = word;
            break;
        }
    }
 
    //SkDebugf("getWordBoundary(%d): %d - %d\n", offset, start, end);
    return { SkToU32(start), SkToU32(end) };
}

◆ layout()

void skia::textlayout::ParagraphImpl::layout ( SkScalar width )

overridevirtual

Implements skia::textlayout::Paragraph.

Definition at line 137 of file ParagraphImpl.cpp.

                                            {
    // TODO: This rounding is done to match Flutter tests. Must be removed...
    auto floorWidth = rawWidth;
    if (getApplyRoundingHack()) {
        floorWidth = SkScalarFloorToScalar(floorWidth);
    }
 
    if ((!SkIsFinite(rawWidth) || fLongestLine <= floorWidth) &&
        fState >= kLineBroken &&
         fLines.size() == 1 && fLines.front().ellipsis() == nullptr) {
        // Most common case: one line of text (and one line is never justified, so no cluster shifts)
        // We cannot mark it as kLineBroken because the new width can be bigger than the old width
        fWidth = floorWidth;
        fState = kShaped;
    } else if (fState >= kLineBroken && fOldWidth != floorWidth) {
        // We can use the results from SkShaper but have to do EVERYTHING ELSE again
        fState = kShaped;
    } else {
        // Nothing changed case: we can reuse the data from the last layout
    }
 
    if (fState < kShaped) {
        // Check if we have the text in the cache and don't need to shape it again
        if (!fFontCollection->getParagraphCache()->findParagraph(this)) {
            if (fState < kIndexed) {
                // This only happens once at the first layout; the text is immutable
                // and there is no reason to repeat it
                if (this->computeCodeUnitProperties()) {
                    fState = kIndexed;
                }
            }
            this->fRuns.clear();
            this->fClusters.clear();
            this->fClustersIndexFromCodeUnit.clear();
            this->fClustersIndexFromCodeUnit.push_back_n(fText.size() + 1, EMPTY_INDEX);
            if (!this->shapeTextIntoEndlessLine()) {
                this->resetContext();
                // TODO: merge the two next calls - they always come together
                this->resolveStrut();
                this->computeEmptyMetrics();
                this->fLines.clear();
 
                // Set the important values that are not zero
                fWidth = floorWidth;
                fHeight = fEmptyMetrics.height();
                if (fParagraphStyle.getStrutStyle().getStrutEnabled() &&
                    fParagraphStyle.getStrutStyle().getForceStrutHeight()) {
                    fHeight = fStrutMetrics.height();
                }
                fAlphabeticBaseline = fEmptyMetrics.alphabeticBaseline();
                fIdeographicBaseline = fEmptyMetrics.ideographicBaseline();
                fLongestLine = FLT_MIN - FLT_MAX;  // That is what flutter has
                fMinIntrinsicWidth = 0;
                fMaxIntrinsicWidth = 0;
                this->fOldWidth = floorWidth;
                this->fOldHeight = this->fHeight;
 
                return;
            } else {
                // Add the paragraph to the cache
                fFontCollection->getParagraphCache()->updateParagraph(this);
            }
        }
        fState = kShaped;
    }
 
    if (fState == kShaped) {
        this->resetContext();
        this->resolveStrut();
        this->computeEmptyMetrics();
        this->fLines.clear();
        this->breakShapedTextIntoLines(floorWidth);
        fState = kLineBroken;
    }
 
    if (fState == kLineBroken) {
        // Build the picture lazily not until we actually have to paint (or never)
        this->resetShifts();
        this->formatLines(fWidth);
        fState = kFormatted;
    }
 
    this->fOldWidth = floorWidth;
    this->fOldHeight = this->fHeight;
 
    if (getApplyRoundingHack()) {
        // TODO: This rounding is done to match Flutter tests. Must be removed...
        fMinIntrinsicWidth = littleRound(fMinIntrinsicWidth);
        fMaxIntrinsicWidth = littleRound(fMaxIntrinsicWidth);
    }
 
    // TODO: This is strictly Flutter thing. Must be factored out into some flutter code
    if (fParagraphStyle.getMaxLines() == 1 ||
        (fParagraphStyle.unlimited_lines() && fParagraphStyle.ellipsized())) {
        fMinIntrinsicWidth = fMaxIntrinsicWidth;
    }
 
    // TODO: Since min and max are calculated differently it's possible to get a rounding error
    //  that would make min > max. Sort it out later, make it the same for now
    if (fMaxIntrinsicWidth < fMinIntrinsicWidth) {
        fMaxIntrinsicWidth = fMinIntrinsicWidth;
    }
 
    //SkDebugf("layout('%s', %f): %f %f\n", fText.c_str(), rawWidth, fMinIntrinsicWidth, fMaxIntrinsicWidth);
}

◆ lineNumber()

size_t skia::textlayout::ParagraphImpl::lineNumber ( )

inlineoverridevirtual

Implements skia::textlayout::Paragraph.

Definition at line 122 of file ParagraphImpl.h.

122{ return fLines.size(); }

◆ lines()

SkSpan< TextLine > skia::textlayout::ParagraphImpl::lines ( )

inline

Definition at line 138 of file ParagraphImpl.h.

138{ return SkSpan<TextLine>(fLines.data(), fLines.size()); }

◆ markDirty()

void skia::textlayout::ParagraphImpl::markDirty ( )

inlineoverridevirtual

Implements skia::textlayout::Paragraph.

Definition at line 182 of file ParagraphImpl.h.

                              {
        if (fState > kIndexed) {
            fState = kIndexed;
        }
    }

◆ paint() [1/2]

void skia::textlayout::ParagraphImpl::paint	(	ParagraphPainter *	canvas,
		SkScalar	x,
		SkScalar	y
	)

overridevirtual

Implements skia::textlayout::Paragraph.

Definition at line 248 of file ParagraphImpl.cpp.

                                                                           {
    for (auto& line : fLines) {
        line.paint(painter, x, y);
    }
}

◆ paint() [2/2]

void skia::textlayout::ParagraphImpl::paint	(	SkCanvas *	canvas,
		SkScalar	x,
		SkScalar	y
	)

overridevirtual

Implements skia::textlayout::Paragraph.

Definition at line 243 of file ParagraphImpl.cpp.

                                                                  {
    CanvasParagraphPainter painter(canvas);
    paint(&painter, x, y);
}

◆ paragraphStyle()

const ParagraphStyle & skia::textlayout::ParagraphImpl::paragraphStyle ( ) const

inline

Definition at line 139 of file ParagraphImpl.h.

139{ return fParagraphStyle; }

◆ placeholders()

SkSpan< Placeholder > skia::textlayout::ParagraphImpl::placeholders ( )

inline

Definition at line 135 of file ParagraphImpl.h.

                                       {
        return SkSpan<Placeholder>(fPlaceholders.data(), fPlaceholders.size());
    }

◆ resetContext()

void skia::textlayout::ParagraphImpl::resetContext ( )

Definition at line 254 of file ParagraphImpl.cpp.

                                 {
    fAlphabeticBaseline = 0;
    fHeight = 0;
    fWidth = 0;
    fIdeographicBaseline = 0;
    fMaxIntrinsicWidth = 0;
    fMinIntrinsicWidth = 0;
    fLongestLine = 0;
    fMaxWidthWithTrailingSpaces = 0;
    fExceededMaxLines = false;
}

◆ resetShifts()

void skia::textlayout::ParagraphImpl::resetShifts ( )

inline

Definition at line 237 of file ParagraphImpl.h.

                       {
        for (auto& run : fRuns) {
            run.resetJustificationShifts();
        }
    }

◆ resolvedFonts()

skia_private::TArray< ResolvedFontDescriptor > skia::textlayout::ParagraphImpl::resolvedFonts ( ) const

inline

Definition at line 180 of file ParagraphImpl.h.

180{ return fFontSwitches; }

◆ resolveStrut()

void skia::textlayout::ParagraphImpl::resolveStrut ( )

Definition at line 687 of file ParagraphImpl.cpp.

                                 {
    auto strutStyle = this->paragraphStyle().getStrutStyle();
    if (!strutStyle.getStrutEnabled() || strutStyle.getFontSize() < 0) {
        return;
    }
 
    std::vector<sk_sp<SkTypeface>> typefaces = fFontCollection->findTypefaces(strutStyle.getFontFamilies(), strutStyle.getFontStyle(), std::nullopt);
    if (typefaces.empty()) {
        SkDEBUGF("Could not resolve strut font\n");
        return;
    }
 
    SkFont font(typefaces.front(), strutStyle.getFontSize());
    SkFontMetrics metrics;
    font.getMetrics(&metrics);
    const SkScalar strutLeading = strutStyle.getLeading() < 0 ? 0 : strutStyle.getLeading() * strutStyle.getFontSize();
 
    if (strutStyle.getHeightOverride()) {
        SkScalar strutAscent = 0.0f;
        SkScalar strutDescent = 0.0f;
        // The half leading flag doesn't take effect unless there's height override.
        if (strutStyle.getHalfLeading()) {
            const auto occupiedHeight = metrics.fDescent - metrics.fAscent;
            auto flexibleHeight = strutStyle.getHeight() * strutStyle.getFontSize() - occupiedHeight;
            // Distribute the flexible height evenly over and under.
            flexibleHeight /= 2;
            strutAscent = metrics.fAscent - flexibleHeight;
            strutDescent = metrics.fDescent + flexibleHeight;
        } else {
            const SkScalar strutMetricsHeight = metrics.fDescent - metrics.fAscent + metrics.fLeading;
            const auto strutHeightMultiplier = strutMetricsHeight == 0
              ? strutStyle.getHeight()
              : strutStyle.getHeight() * strutStyle.getFontSize() / strutMetricsHeight;
            strutAscent = metrics.fAscent * strutHeightMultiplier;
            strutDescent = metrics.fDescent * strutHeightMultiplier;
        }
        fStrutMetrics = InternalLineMetrics(
            strutAscent,
            strutDescent,
            strutLeading,
            metrics.fAscent, metrics.fDescent, metrics.fLeading);
    } else {
        fStrutMetrics = InternalLineMetrics(
                metrics.fAscent,
                metrics.fDescent,
                strutLeading);
    }
    fStrutMetrics.setForceStrut(this->paragraphStyle().getStrutStyle().getForceStrutHeight());
}

◆ run()

Run & skia::textlayout::ParagraphImpl::run ( RunIndex runIndex )

inline

Definition at line 172 of file ParagraphImpl.h.

                                {
        SkASSERT(runIndex < SkToSizeT(fRuns.size()));
        return fRuns[runIndex];
    }

◆ runByCluster()

Run & skia::textlayout::ParagraphImpl::runByCluster ( ClusterIndex clusterIndex )

Definition at line 955 of file ParagraphImpl.cpp.

                                                          {
    auto start = cluster(clusterIndex);
    return this->run(start.fRunIndex);
}

◆ runs()

SkSpan< Run > skia::textlayout::ParagraphImpl::runs ( )

inline

Definition at line 131 of file ParagraphImpl.h.

131{ return SkSpan<Run>(fRuns.data(), fRuns.size()); }

◆ setState()

void skia::textlayout::ParagraphImpl::setState ( InternalState state )

Definition at line 971 of file ParagraphImpl.cpp.

                                                {
    if (fState <= state) {
        fState = state;
        return;
    }
 
    fState = state;
    switch (fState) {
        case kUnknown:
            SkASSERT(false);
            /*
            // The text is immutable and so are all the text indexing properties
            // taken from SkUnicode
            fCodeUnitProperties.reset();
            fWords.clear();
            fBidiRegions.clear();
            fUTF8IndexForUTF16Index.reset();
            fUTF16IndexForUTF8Index.reset();
            */
            [[fallthrough]];
 
        case kIndexed:
            fRuns.clear();
            fClusters.clear();
            [[fallthrough]];
 
        case kShaped:
            fLines.clear();
            [[fallthrough]];
 
        case kLineBroken:
            fPicture = nullptr;
            [[fallthrough]];
 
        default:
            break;
    }
}

◆ shapeTextIntoEndlessLine()

bool skia::textlayout::ParagraphImpl::shapeTextIntoEndlessLine ( )

Definition at line 555 of file ParagraphImpl.cpp.

                                             {
 
    if (fText.size() == 0) {
        return false;
    }
 
    fUnresolvedCodepoints.clear();
    fFontSwitches.clear();
 
    OneLineShaper oneLineShaper(this);
    auto result = oneLineShaper.shape();
    fUnresolvedGlyphs = oneLineShaper.unresolvedGlyphs();
 
    this->applySpacingAndBuildClusterTable();
 
    return result;
}

◆ state()

InternalState skia::textlayout::ParagraphImpl::state ( ) const

inline

Definition at line 130 of file ParagraphImpl.h.

130{ return fState; }

◆ strutEnabled()

bool skia::textlayout::ParagraphImpl::strutEnabled ( ) const

inline

Definition at line 153 of file ParagraphImpl.h.

153{ return paragraphStyle().getStrutStyle().getStrutEnabled(); }

◆ strutForceHeight()

bool skia::textlayout::ParagraphImpl::strutForceHeight ( ) const

inline

Definition at line 154 of file ParagraphImpl.h.

                                  {
        return paragraphStyle().getStrutStyle().getForceStrutHeight();
    }

◆ strutHeightOverride()

bool skia::textlayout::ParagraphImpl::strutHeightOverride ( ) const

inline

Definition at line 157 of file ParagraphImpl.h.

                                     {
        return paragraphStyle().getStrutStyle().getHeightOverride();
    }

◆ strutMetrics()

InternalLineMetrics skia::textlayout::ParagraphImpl::strutMetrics ( ) const

inline

Definition at line 160 of file ParagraphImpl.h.

160{ return fStrutMetrics; }

◆ styles()

SkSpan< Block > skia::textlayout::ParagraphImpl::styles ( )

inline

Definition at line 132 of file ParagraphImpl.h.

                           {
        return SkSpan<Block>(fTextStyles.data(), fTextStyles.size());
    }

◆ text() [1/2]

SkSpan< const char > skia::textlayout::ParagraphImpl::text ( ) const

inline

Definition at line 129 of file ParagraphImpl.h.

129{ return SkSpan<const char>(fText.c_str(), fText.size()); }

◆ text() [2/2]

SkSpan< const char > skia::textlayout::ParagraphImpl::text ( TextRange textRange )

Definition at line 938 of file ParagraphImpl.cpp.

                                                          {
    SkASSERT(textRange.start <= fText.size() && textRange.end <= fText.size());
    auto start = fText.c_str() + textRange.start;
    return SkSpan<const char>(start, textRange.width());
}

◆ unresolvedCodepoints()

std::unordered_set< SkUnichar > skia::textlayout::ParagraphImpl::unresolvedCodepoints ( )

overridevirtual

Implements skia::textlayout::Paragraph.

Definition at line 124 of file ParagraphImpl.cpp.

                                                                {
    return fUnresolvedCodepoints;
}

◆ unresolvedGlyphs()

int32_t skia::textlayout::ParagraphImpl::unresolvedGlyphs ( )

overridevirtual

Implements skia::textlayout::Paragraph.

Definition at line 116 of file ParagraphImpl.cpp.

                                        {
    if (fState < kShaped) {
        return -1;
    }
 
    return fUnresolvedGlyphs;
}

◆ updateBackgroundPaint()

void skia::textlayout::ParagraphImpl::updateBackgroundPaint	(	size_t	from,
		size_t	to,
		SkPaint	paint
	)

overridevirtual

Implements skia::textlayout::Paragraph.

Definition at line 1112 of file ParagraphImpl.cpp.

                                                                               {
    SkASSERT(from == 0 && to == fText.size());
    auto defaultStyle = fParagraphStyle.getTextStyle();
    defaultStyle.setBackgroundColor(paint);
    fParagraphStyle.setTextStyle(defaultStyle);
 
    for (auto& textStyle : fTextStyles) {
        textStyle.fStyle.setBackgroundColor(paint);
    }
}

◆ updateFontSize()

void skia::textlayout::ParagraphImpl::updateFontSize	(	size_t	from,
		size_t	to,
		SkScalar	fontSize
	)

overridevirtual

Implements skia::textlayout::Paragraph.

Definition at line 1077 of file ParagraphImpl.cpp.

                                                                            {
 
  SkASSERT(from == 0 && to == fText.size());
  auto defaultStyle = fParagraphStyle.getTextStyle();
  defaultStyle.setFontSize(fontSize);
  fParagraphStyle.setTextStyle(defaultStyle);
 
  for (auto& textStyle : fTextStyles) {
    textStyle.fStyle.setFontSize(fontSize);
  }
 
  fState = std::min(fState, kIndexed);
  fOldWidth = 0;
  fOldHeight = 0;
}

◆ updateForegroundPaint()

void skia::textlayout::ParagraphImpl::updateForegroundPaint	(	size_t	from,
		size_t	to,
		SkPaint	paint
	)

overridevirtual

Implements skia::textlayout::Paragraph.

Definition at line 1101 of file ParagraphImpl.cpp.

                                                                               {
    SkASSERT(from == 0 && to == fText.size());
    auto defaultStyle = fParagraphStyle.getTextStyle();
    defaultStyle.setForegroundColor(paint);
    fParagraphStyle.setTextStyle(defaultStyle);
 
    for (auto& textStyle : fTextStyles) {
        textStyle.fStyle.setForegroundColor(paint);
    }
}

◆ updateTextAlign()

void skia::textlayout::ParagraphImpl::updateTextAlign ( TextAlign textAlign )

overridevirtual

Implements skia::textlayout::Paragraph.

Definition at line 1093 of file ParagraphImpl.cpp.

                                                       {
    fParagraphStyle.setTextAlign(textAlign);
 
    if (fState >= kLineBroken) {
        fState = kLineBroken;
    }
}

◆ visit()

void skia::textlayout::ParagraphImpl::visit ( const Visitor & visitor )

overridevirtual

Implements skia::textlayout::Paragraph.

Definition at line 1179 of file ParagraphImpl.cpp.

                                                {
    int lineNumber = 0;
    for (auto& line : fLines) {
        line.ensureTextBlobCachePopulated();
        for (auto& rec : line.fTextBlobCache) {
            if (rec.fBlob == nullptr) {
                continue;
            }
            SkTextBlob::Iter iter(*rec.fBlob);
            SkTextBlob::Iter::ExperimentalRun run;
 
            STArray<128, uint32_t> clusterStorage;
            const Run* R = rec.fVisitor_Run;
            const uint32_t* clusterPtr = &R->fClusterIndexes[0];
 
            if (R->fClusterStart > 0) {
                int count = R->fClusterIndexes.size();
                clusterStorage.reset(count);
                for (int i = 0; i < count; ++i) {
                    clusterStorage[i] = R->fClusterStart + R->fClusterIndexes[i];
                }
                clusterPtr = &clusterStorage[0];
            }
            clusterPtr += rec.fVisitor_Pos;
 
            while (iter.experimentalNext(&run)) {
                const Paragraph::VisitorInfo info = {
                    run.font,
                    rec.fOffset,
                    rec.fClipRect.fRight,
                    run.count,
                    run.glyphs,
                    run.positions,
                    clusterPtr,
                    0,  // flags
                };
                visitor(lineNumber, &info);
                clusterPtr += run.count;
            }
        }
        visitor(lineNumber, nullptr);   // signal end of line
        lineNumber += 1;
    }
}

◆ widthWithTrailingSpaces()

SkScalar skia::textlayout::ParagraphImpl::widthWithTrailingSpaces ( )

inline

Definition at line 195 of file ParagraphImpl.h.

195{ return fMaxWidthWithTrailingSpaces; }

Friends And Related Function Documentation

◆ OneLineShaper

friend class OneLineShaper

friend

Definition at line 256 of file ParagraphImpl.h.

◆ ParagraphBuilder

friend class ParagraphBuilder

friend

Definition at line 250 of file ParagraphImpl.h.

◆ ParagraphCache

friend class ParagraphCache

friend

Definition at line 253 of file ParagraphImpl.h.

◆ ParagraphCacheKey

friend class ParagraphCacheKey

friend

Definition at line 251 of file ParagraphImpl.h.

◆ ParagraphCacheValue

friend class ParagraphCacheValue

friend

Definition at line 252 of file ParagraphImpl.h.

◆ TextWrapper

friend class TextWrapper

friend

Definition at line 255 of file ParagraphImpl.h.

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

third_party/skia/modules/skparagraph/src/ParagraphImpl.h
third_party/skia/modules/skparagraph/src/ParagraphImpl.cpp

Public Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ParagraphImpl() [1/2]

◆ ParagraphImpl() [2/2]

◆ ~ParagraphImpl()

Member Function Documentation

◆ addLine()

◆ addUnresolvedCodepoints()

◆ applySpacingAndBuildClusterTable()

◆ block()

◆ blocks()

◆ breakShapedTextIntoLines()

◆ buildClusterTable()

◆ cluster()

◆ clusterIndex()

◆ clusters() [1/2]

◆ clusters() [2/2]

◆ codeUnitHasProperty()

◆ computeCodeUnitProperties()

◆ containsColorFontOrBitmap()

◆ containsEmoji()

◆ countSurroundingGraphemes()

◆ ensureUTF16Mapping()

◆ extendedVisit()

◆ findAllBlocks()

◆ findNextGlyphClusterBoundary()

◆ findNextGraphemeBoundary()

◆ findPreviousGlyphClusterBoundary()

◆ findPreviousGraphemeBoundary()

◆ fontCollection()

◆ formatLines()

◆ getActualTextRange()

◆ getApplyRoundingHack()

◆ getClosestGlyphClusterAt()

◆ getClosestUTF16GlyphInfoAt()

◆ getEllipsis()

◆ getEmptyMetrics()

◆ getFontAt()

◆ getFontAtUTF16Offset()

◆ getFonts()

◆ getGlyphClusterAt()

◆ getGlyphInfoAtUTF16Offset()

◆ getGlyphPositionAtCoordinate()

◆ getLineMetrics()

◆ getLineMetricsAt()

◆ getLineNumberAt()

◆ getLineNumberAtUTF16Offset()

◆ getPath()

◆ getPicture()

◆ getRectsForPlaceholders()

◆ getRectsForRange()

◆ getStrutMetrics()

◆ getUnicode()

◆ getUTF16Index()

◆ getWordBoundary()

◆ layout()

◆ lineNumber()

◆ lines()

◆ markDirty()

◆ paint() [1/2]

◆ paint() [2/2]

◆ paragraphStyle()

◆ placeholders()

◆ resetContext()

◆ resetShifts()

◆ resolvedFonts()

◆ resolveStrut()

◆ run()

◆ runByCluster()

◆ runs()

◆ setState()

◆ shapeTextIntoEndlessLine()

◆ state()

◆ strutEnabled()

◆ strutForceHeight()

◆ strutHeightOverride()

◆ strutMetrics()