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
virtual void	beginLine ()=0
virtual void	runInfo (const RunInfo &)=0
virtual void	commitRunInfo ()=0
virtual Buffer	runBuffer (const RunInfo &)=0
virtual void	commitRunBuffer (const RunInfo &)=0
virtual void	commitLine ()=0

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

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

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

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