skia::textlayout::OneLineShaper Class Reference

#include <OneLineShaper.h>

Inheritance diagram for skia::textlayout::OneLineShaper:

Public Member Functions
	OneLineShaper (ParagraphImpl *paragraph)
bool	shape ()
size_t	unresolvedGlyphs ()
Public Member Functions inherited from SkShaper::RunHandler
virtual	~RunHandler ()=default

Static Public Member Functions
static SkUnichar	getEmojiSequenceStart (SkUnicode *unicode, const char **begin, const char *end)

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

Detailed Description

Definition at line 16 of file OneLineShaper.h.

Constructor & Destructor Documentation

OneLineShaper()

skia::textlayout::OneLineShaper::OneLineShaper ( ParagraphImpl *  paragraph )

inlineexplicit

Definition at line 18 of file OneLineShaper.h.

        : fParagraph(paragraph)
        , fHeight(0.0f)
        , fUseHalfLeading(false)
        , fBaselineShift(0.0f)
        , fAdvance(SkPoint::Make(0.0f, 0.0f))
        , fUnresolvedGlyphs(0)
        , fUniqueRunId(paragraph->fRuns.size()){ }

Member Function Documentation

beginLine()

void skia::textlayout::OneLineShaper::beginLine ( )

inlineoverrideprivatevirtual

Called when beginning a line.

Implements SkShaper::RunHandler.

Definition at line 86 of file OneLineShaper.h.

{}

commitLine()

void skia::textlayout::OneLineShaper::commitLine ( )

inlineoverrideprivatevirtual

Called when ending a line.

Implements SkShaper::RunHandler.

Definition at line 89 of file OneLineShaper.h.

{}

commitRunBuffer()

void skia::textlayout::OneLineShaper::commitRunBuffer ( const RunInfo &  info )

overrideprivatevirtual

Called after each runBuffer is filled out.

Implements SkShaper::RunHandler.

Definition at line 17 of file OneLineShaper.cpp.

                                                  {
 
    fCurrentRun->commit();
 
    auto oldUnresolvedCount = fUnresolvedBlocks.size();
/*
    SkDebugf("Run [%zu:%zu)\n", fCurrentRun->fTextRange.start, fCurrentRun->fTextRange.end);
    for (size_t i = 0; i < fCurrentRun->size(); ++i) {
        SkDebugf("[%zu] %hu %u %f\n", i, fCurrentRun->fGlyphs[i], fCurrentRun->fClusterIndexes[i], fCurrentRun->fPositions[i].fX);
    }
*/
    // Find all unresolved blocks
    sortOutGlyphs([&](GlyphRange block){
        if (block.width() == 0) {
            return;
        }
        addUnresolvedWithRun(block);
    });
 
    // Fill all the gaps between unresolved blocks with resolved ones
    if (oldUnresolvedCount == fUnresolvedBlocks.size()) {
        // No unresolved blocks added - we resolved the block with one run entirely
        addFullyResolved();
        return;
    } else if (oldUnresolvedCount == fUnresolvedBlocks.size() - 1) {
        auto& unresolved = fUnresolvedBlocks.back();
        if (fCurrentRun->textRange() == unresolved.fText) {
            // Nothing was resolved; preserve the initial run if it makes sense
            auto& front = fUnresolvedBlocks.front();
            if (front.fRun != nullptr) {
               unresolved.fRun = front.fRun;
               unresolved.fGlyphs = front.fGlyphs;
            }
            return;
        }
    }
 
    fillGaps(oldUnresolvedCount);
}

commitRunInfo()

void skia::textlayout::OneLineShaper::commitRunInfo ( )

inlineoverrideprivatevirtual

Called after all runInfo calls for a line.

Implements SkShaper::RunHandler.

Definition at line 88 of file OneLineShaper.h.

{}

getEmojiSequenceStart()

SkUnichar skia::textlayout::OneLineShaper::getEmojiSequenceStart ( SkUnicode *  unicode, const char **  begin, const char *  end  )

static

This method is based on definition of https://unicode.org/reports/tr51/#def_emoji_sequence It determines if the string begins with an emoji sequence and, if so, return the first codepoint, moving 'begin' pointer to the next once. Otherwise it does not move the pointer and returns -1.

Definition at line 805 of file OneLineShaper.cpp.

                                                                                                      {
    const char* next = *begin;
    auto codepoint1 = SkUTF::NextUTF8WithReplacement(&next, end);
 
    if (!unicode->isEmoji(codepoint1)) {
        // This is not a basic emoji nor it an emoji sequence
        return -1;
    }
 
    if (!unicode->isEmojiComponent(codepoint1)) {
        // This is an emoji sequence start
        *begin = next;
        return codepoint1;
    }
 
    // Now we need to look at the next codepoint to see what is going on
    const char* last = next;
    auto codepoint2 = SkUTF::NextUTF8WithReplacement(&last, end);
 
    // emoji_flag_sequence
    if (unicode->isRegionalIndicator(codepoint2)) {
        // We expect a second regional indicator here
        if (unicode->isRegionalIndicator(codepoint2)) {
            *begin = next;
            return codepoint1;
        } else {
            // That really should not happen assuming correct UTF8 text
            return -1;
        }
    }
 
    // emoji_keycap_sequence
    if (codepoint2 == 0xFE0F) {
        auto codepoint3 = SkUTF::NextUTF8WithReplacement(&last, end);
        if (codepoint3 == 0x20E3) {
            *begin = next;
            return codepoint1;
        }
    }
 
    return -1;
}

runBuffer()

Buffer skia::textlayout::OneLineShaper::runBuffer ( const RunInfo &  info )

inlineoverrideprivatevirtual

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

Implements SkShaper::RunHandler.

Definition at line 91 of file OneLineShaper.h.

                                                   {
        fCurrentRun = std::make_shared<Run>(fParagraph,
                                           info,
                                           fCurrentText.start,
                                           fHeight,
                                           fUseHalfLeading,
                                           fBaselineShift,
                                           ++fUniqueRunId,
                                           fAdvance.fX);
        return fCurrentRun->newRunBuffer();
    }

runInfo()

void skia::textlayout::OneLineShaper::runInfo ( const RunInfo &  info )

inlineoverrideprivatevirtual

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

Implements SkShaper::RunHandler.

Definition at line 87 of file OneLineShaper.h.

{}

shape()

bool skia::textlayout::OneLineShaper::shape

(

)

Definition at line 617 of file OneLineShaper.cpp.

                          {
 
    // The text can be broken into many shaping sequences
    // (by place holders, possibly, by hard line breaks or tabs, too)
    auto limitlessWidth = std::numeric_limits<SkScalar>::max();
 
    auto result = iterateThroughShapingRegions(
            [this, limitlessWidth]
            (TextRange textRange, SkSpan<Block> styleSpan, SkScalar& advanceX, TextIndex textStart, uint8_t defaultBidiLevel) {
 
        // Set up the shaper and shape the next
        auto shaper = SkShapers::HB::ShapeDontWrapOrReorder(fParagraph->fUnicode,
                                                            SkFontMgr::RefEmpty());  // no fallback
        if (shaper == nullptr) {
            // For instance, loadICU does not work. We have to stop the process
            return false;
        }
 
        iterateThroughFontStyles(textRange, styleSpan,
                [this, &shaper, defaultBidiLevel, limitlessWidth, &advanceX]
                (Block block, TArray<SkShaper::Feature> features) {
            auto blockSpan = SkSpan<Block>(&block, 1);
 
            // Start from the beginning (hoping that it's a simple case one block - one run)
            fHeight = block.fStyle.getHeightOverride() ? block.fStyle.getHeight() : 0;
            fUseHalfLeading = block.fStyle.getHalfLeading();
            fBaselineShift = block.fStyle.getBaselineShift();
            fAdvance = SkVector::Make(advanceX, 0);
            fCurrentText = block.fRange;
            fUnresolvedBlocks.emplace_back(RunBlock(block.fRange));
 
            this->matchResolvedFonts(block.fStyle, [&](sk_sp<SkTypeface> typeface) {
 
                // Create one more font to try
                SkFont font(std::move(typeface), block.fStyle.getFontSize());
                font.setEdging(SkFont::Edging::kAntiAlias);
                font.setHinting(SkFontHinting::kSlight);
                font.setSubpixel(true);
 
                // Apply fake bold and/or italic settings to the font if the
                // typeface's attributes do not match the intended font style.
                int wantedWeight = block.fStyle.getFontStyle().weight();
                bool fakeBold =
                    wantedWeight >= SkFontStyle::kSemiBold_Weight &&
                    wantedWeight - font.getTypeface()->fontStyle().weight() >= 200;
                bool fakeItalic =
                    block.fStyle.getFontStyle().slant() == SkFontStyle::kItalic_Slant &&
                    font.getTypeface()->fontStyle().slant() != SkFontStyle::kItalic_Slant;
                font.setEmbolden(fakeBold);
                font.setSkewX(fakeItalic ? -SK_Scalar1 / 4 : 0);
 
                // Walk through all the currently unresolved blocks
                // (ignoring those that appear later)
                auto resolvedCount = fResolvedBlocks.size();
                auto unresolvedCount = fUnresolvedBlocks.size();
                while (unresolvedCount-- > 0) {
                    auto unresolvedRange = fUnresolvedBlocks.front().fText;
                    if (unresolvedRange == EMPTY_TEXT) {
                        // Duplicate blocks should be ignored
                        fUnresolvedBlocks.pop_front();
                        continue;
                    }
                    auto unresolvedText = fParagraph->text(unresolvedRange);
 
                    SkShaper::TrivialFontRunIterator fontIter(font, unresolvedText.size());
                    LangIterator langIter(unresolvedText, blockSpan,
                                      fParagraph->paragraphStyle().getTextStyle());
                    SkShaper::TrivialBiDiRunIterator bidiIter(defaultBidiLevel, unresolvedText.size());
                    auto scriptIter = SkShapers::HB::ScriptRunIterator(unresolvedText.begin(),
                                                                       unresolvedText.size());
                    fCurrentText = unresolvedRange;
 
                    // Map the block's features to subranges within the unresolved range.
                    TArray<SkShaper::Feature> adjustedFeatures(features.size());
                    for (const SkShaper::Feature& feature : features) {
                        SkRange<size_t> featureRange(feature.start, feature.end);
                        if (unresolvedRange.intersects(featureRange)) {
                            SkRange<size_t> adjustedRange = unresolvedRange.intersection(featureRange);
                            adjustedRange.Shift(-static_cast<std::make_signed_t<size_t>>(unresolvedRange.start));
                            adjustedFeatures.push_back({feature.tag, feature.value, adjustedRange.start, adjustedRange.end});
                        }
                    }
 
                    shaper->shape(unresolvedText.begin(), unresolvedText.size(),
                            fontIter, bidiIter,*scriptIter, langIter,
                            adjustedFeatures.data(), adjustedFeatures.size(),
                            limitlessWidth, this);
 
                    // Take off the queue the block we tried to resolved -
                    // whatever happened, we have now smaller pieces of it to deal with
                    fUnresolvedBlocks.pop_front();
                }
 
                if (fUnresolvedBlocks.empty()) {
                    // In some cases it does not mean everything
                    // (when we excluded some hopeless blocks from the list)
                    return Resolved::Everything;
                } else if (resolvedCount < fResolvedBlocks.size()) {
                    return Resolved::Something;
                } else {
                    return Resolved::Nothing;
                }
            });
 
            this->finish(block, fHeight, advanceX);
        });
 
        return true;
    });
 
    return result;
}

unresolvedGlyphs()

size_t skia::textlayout::OneLineShaper::unresolvedGlyphs ( )

inline

Definition at line 29 of file OneLineShaper.h.

{ return fUnresolvedGlyphs; }

---

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

• third_party/skia/modules/skparagraph/src/OneLineShaper.h
• third_party/skia/modules/skparagraph/src/OneLineShaper.cpp