skia::textlayout::Run Class Reference

#include <Run.h>

Public Types
using	ClusterVisitor = std::function< void(Cluster *cluster)>

Public Member Functions
	Run (ParagraphImpl *owner, const SkShaper::RunHandler::RunInfo &info, size_t firstChar, SkScalar heightMultiplier, bool useHalfLeading, SkScalar baselineShift, size_t index, SkScalar shiftX)
	Run (const Run &)=default
Run &	operator= (const Run &)=delete
	Run (Run &&)=default
Run &	operator= (Run &&)=delete
	~Run ()=default
void	setOwner (ParagraphImpl *owner)
SkShaper::RunHandler::Buffer	newRunBuffer ()
SkScalar	posX (size_t index) const
void	addX (size_t index, SkScalar shift)
SkScalar	posY (size_t index) const
size_t	size () const
void	setWidth (SkScalar width)
void	setHeight (SkScalar height)
void	shift (SkScalar shiftX, SkScalar shiftY)
SkVector	advance () const
SkVector	offset () const
SkScalar	ascent () const
SkScalar	descent () const
SkScalar	leading () const
SkScalar	correctAscent () const
SkScalar	correctDescent () const
SkScalar	correctLeading () const
const SkFont &	font () const
bool	leftToRight () const
TextDirection	getTextDirection () const
size_t	index () const
SkScalar	heightMultiplier () const
bool	useHalfLeading () const
SkScalar	baselineShift () const
PlaceholderStyle *	placeholderStyle () const
bool	isPlaceholder () const
size_t	clusterIndex (size_t pos) const
size_t	globalClusterIndex (size_t pos) const
SkScalar	positionX (size_t pos) const
TextRange	textRange () const
ClusterRange	clusterRange () const
ParagraphImpl *	owner () const
bool	isEllipsis () const
void	calculateMetrics ()
void	updateMetrics (InternalLineMetrics *endlineMetrics)
void	setClusterRange (size_t from, size_t to)
SkRect	clip () const
void	addSpacesAtTheEnd (SkScalar space, Cluster *cluster)
SkScalar	addSpacesEvenly (SkScalar space, Cluster *cluster)
SkScalar	addSpacesEvenly (SkScalar space)
void	shift (const Cluster *cluster, SkScalar offset)
void	extend (const Cluster *cluster, SkScalar offset)
SkScalar	calculateHeight (LineMetricStyle ascentStyle, LineMetricStyle descentStyle) const
SkScalar	calculateWidth (size_t start, size_t end, bool clip) const
void	copyTo (SkTextBlobBuilder &builder, size_t pos, size_t size) const
template<typename Visitor >
void	iterateThroughClustersInTextOrder (Visitor visitor)
void	iterateThroughClusters (const ClusterVisitor &visitor)
std::tuple< bool, ClusterIndex, ClusterIndex >	findLimitingClusters (TextRange text) const
std::tuple< bool, TextIndex, TextIndex >	findLimitingGlyphClusters (TextRange text) const
std::tuple< bool, TextIndex, TextIndex >	findLimitingGraphemes (TextRange text) const
SkSpan< const SkGlyphID >	glyphs () const
SkSpan< const SkPoint >	positions () const
SkSpan< const SkPoint >	offsets () const
SkSpan< const uint32_t >	clusterIndexes () const
void	commit ()
void	resetJustificationShifts ()
bool	isResolved () const

Friends
class	ParagraphImpl
class	TextLine
class	InternalLineMetrics
class	ParagraphCache
class	OneLineShaper

Detailed Description

Definition at line 55 of file Run.h.

Member Typedef Documentation

ClusterVisitor

using skia::textlayout::Run::ClusterVisitor = std::function<void(Cluster* cluster)>

Definition at line 143 of file Run.h.

Constructor & Destructor Documentation

Run() [1/3]

skia::textlayout::Run::Run	(	ParagraphImpl *	owner,
		const SkShaper::RunHandler::RunInfo &	info,
		size_t	firstChar,
		SkScalar	heightMultiplier,
		bool	useHalfLeading,
		SkScalar	baselineShift,
		size_t	index,
		SkScalar	shiftX
	)

Definition at line 17 of file Run.cpp.

    : fOwner(owner)
    , fTextRange(firstChar + info.utf8Range.begin(), firstChar + info.utf8Range.end())
    , fClusterRange(EMPTY_CLUSTERS)
    , fFont(info.fFont)
    , fClusterStart(firstChar)
    , fGlyphData(std::make_shared<GlyphData>())
    , fGlyphs(fGlyphData->glyphs)
    , fPositions(fGlyphData->positions)
    , fOffsets(fGlyphData->offsets)
    , fClusterIndexes(fGlyphData->clusterIndexes)
    , fHeightMultiplier(heightMultiplier)
    , fUseHalfLeading(useHalfLeading)
    , fBaselineShift(baselineShift)
{
    fBidiLevel = info.fBidiLevel;
    fAdvance = info.fAdvance;
    fIndex = index;
    fUtf8Range = info.utf8Range;
    fOffset = SkVector::Make(offsetX, 0);
 
    fGlyphs.push_back_n(info.glyphCount);
    fPositions.push_back_n(info.glyphCount + 1);
    fOffsets.push_back_n(info.glyphCount + 1);
    fClusterIndexes.push_back_n(info.glyphCount + 1);
    info.fFont.getMetrics(&fFontMetrics);
 
    this->calculateMetrics();
 
    // To make edge cases easier:
    fPositions[info.glyphCount] = fOffset + fAdvance;
    fOffsets[info.glyphCount] = {0, 0};
    fClusterIndexes[info.glyphCount] = this->leftToRight() ? info.utf8Range.end() : info.utf8Range.begin();
    fEllipsis = false;
    fPlaceholderIndex = std::numeric_limits<size_t>::max();
}

Run() [2/3]

skia::textlayout::Run::Run ( const Run &  )

default

Run() [3/3]

skia::textlayout::Run::Run ( Run &&  )

default

~Run()

skia::textlayout::Run::~Run ( )

default

Member Function Documentation

addSpacesAtTheEnd()

void skia::textlayout::Run::addSpacesAtTheEnd	(	SkScalar	space,
		Cluster *	cluster
	)

Definition at line 164 of file Run.cpp.

                                                            {
    // Increment the run width
    fAdvance.fX += space;
    // Increment the cluster width
    cluster->space(space);
}

addSpacesEvenly() [1/2]

SkScalar skia::textlayout::Run::addSpacesEvenly

(

SkScalar

space

)

Definition at line 171 of file Run.cpp.

                                            {
    SkScalar shift = 0;
    for (size_t i = 0; i < this->size(); ++i) {
        fPositions[i].fX += shift;
        shift += space;
    }
    fPositions[this->size()].fX += shift;
    fAdvance.fX += shift;
    return shift;
}

addSpacesEvenly() [2/2]

SkScalar skia::textlayout::Run::addSpacesEvenly	(	SkScalar	space,
		Cluster *	cluster
	)

Definition at line 182 of file Run.cpp.

                                                              {
    // Offset all the glyphs in the cluster
    SkScalar shift = 0;
    for (size_t i = cluster->startPos(); i < cluster->endPos(); ++i) {
        fPositions[i].fX += shift;
        shift += space;
    }
    if (this->size() == cluster->endPos()) {
        // To make calculations easier
        fPositions[cluster->endPos()].fX += shift;
    }
    // Increment the run width
    fAdvance.fX += shift;
    // Increment the cluster width
    cluster->space(shift);
    cluster->setHalfLetterSpacing(space / 2);
 
    return shift;
}

addX()

void skia::textlayout::Run::addX ( size_t  index, SkScalar  shift  )

inline

Definition at line 76 of file Run.h.

{ fPositions[index].fX += shift; }

advance()

SkVector skia::textlayout::Run::advance ( ) const

inline

Definition at line 85 of file Run.h.

                             {
        return SkVector::Make(fAdvance.fX, fFontMetrics.fDescent - fFontMetrics.fAscent + fFontMetrics.fLeading);
    }

ascent()

SkScalar skia::textlayout::Run::ascent ( ) const

inline

Definition at line 89 of file Run.h.

{ return fFontMetrics.fAscent + fBaselineShift; }

baselineShift()

SkScalar skia::textlayout::Run::baselineShift ( ) const

inline

Definition at line 101 of file Run.h.

{ return fBaselineShift; }

calculateHeight()

SkScalar skia::textlayout::Run::calculateHeight ( LineMetricStyle  ascentStyle, LineMetricStyle  descentStyle  ) const

inline

Definition at line 129 of file Run.h.

                                                                                              {
        auto ascent = ascentStyle == LineMetricStyle::Typographic ? this->ascent()
                                    : this->correctAscent();
        auto descent = descentStyle == LineMetricStyle::Typographic ? this->descent()
                                      : this->correctDescent();
        return descent - ascent;
    }

calculateMetrics()

void skia::textlayout::Run::calculateMetrics

(

)

Definition at line 61 of file Run.cpp.

                           {
    fCorrectAscent = fFontMetrics.fAscent - fFontMetrics.fLeading * 0.5;
    fCorrectDescent = fFontMetrics.fDescent + fFontMetrics.fLeading * 0.5;
    fCorrectLeading = 0;
    if (SkScalarNearlyZero(fHeightMultiplier)) {
        return;
    }
    const auto runHeight = fHeightMultiplier * fFont.getSize();
    const auto fontIntrinsicHeight = fCorrectDescent - fCorrectAscent;
    if (fUseHalfLeading) {
        const auto extraLeading = (runHeight - fontIntrinsicHeight) / 2;
        fCorrectAscent -= extraLeading;
        fCorrectDescent += extraLeading;
    } else {
        const auto multiplier = runHeight / fontIntrinsicHeight;
        fCorrectAscent *= multiplier;
        fCorrectDescent *= multiplier;
    }
    // If we shift the baseline we need to make sure the shifted text fits the line
    fCorrectAscent += fBaselineShift;
    fCorrectDescent += fBaselineShift;
}

calculateWidth()

SkScalar skia::textlayout::Run::calculateWidth	(	size_t	start,
		size_t	end,
		bool	clip
	)		const

Definition at line 383 of file ParagraphImpl.cpp.

                                                                      {
    SkASSERT(start <= end);
    // clip |= end == size();  // Clip at the end of the run?
    auto correction = 0.0f;
    if (end > start && !fJustificationShifts.empty()) {
        // This is not a typo: we are using Point as a pair of SkScalars
        correction = fJustificationShifts[end - 1].fX -
                     fJustificationShifts[start].fY;
    }
    return posX(end) - posX(start) + correction;
}

clip()

SkRect skia::textlayout::Run::clip ( ) const

inline

Definition at line 119 of file Run.h.

                        {
        return SkRect::MakeXYWH(fOffset.fX, fOffset.fY, fAdvance.fX, fAdvance.fY);
    }

clusterIndex()

size_t skia::textlayout::Run::clusterIndex ( size_t  pos ) const

inline

Definition at line 104 of file Run.h.

{ return fClusterIndexes[pos]; }

clusterIndexes()

SkSpan< const uint32_t > skia::textlayout::Run::clusterIndexes ( ) const

inline

Definition at line 158 of file Run.h.

                                                  {
        return SkSpan<const uint32_t>(fClusterIndexes.begin(), fClusterIndexes.size());
    }

clusterRange()

ClusterRange skia::textlayout::Run::clusterRange ( ) const

inline

Definition at line 109 of file Run.h.

{ return fClusterRange; }

commit()

void skia::textlayout::Run::commit ( )

inline

Definition at line 162 of file Run.h.

{ }

copyTo()

void skia::textlayout::Run::copyTo	(	SkTextBlobBuilder &	builder,
		size_t	pos,
		size_t	size
	)		const

Definition at line 88 of file Run.cpp.

                                                                          {
    SkASSERT(pos + size <= this->size());
    const auto& blobBuffer = builder.allocRunPos(fFont, SkToInt(size));
    sk_careful_memcpy(blobBuffer.glyphs, fGlyphs.data() + pos, size * sizeof(SkGlyphID));
 
    for (size_t i = 0; i < size; ++i) {
        auto point = fPositions[i + pos];
        if (!fJustificationShifts.empty()) {
            point.fX += fJustificationShifts[i + pos].fX;
        }
        point += fOffsets[i + pos];
        blobBuffer.points()[i] = point;
    }
}

correctAscent()

SkScalar skia::textlayout::Run::correctAscent ( ) const

inline

Definition at line 92 of file Run.h.

{ return fCorrectAscent + fBaselineShift; }

correctDescent()

SkScalar skia::textlayout::Run::correctDescent ( ) const

inline

Definition at line 93 of file Run.h.

{ return fCorrectDescent + fBaselineShift; }

correctLeading()

SkScalar skia::textlayout::Run::correctLeading ( ) const

inline

Definition at line 94 of file Run.h.

{ return fCorrectLeading; }

descent()

SkScalar skia::textlayout::Run::descent ( ) const

inline

Definition at line 90 of file Run.h.

{ return fFontMetrics.fDescent + fBaselineShift; }

extend()

void skia::textlayout::Run::extend	(	const Cluster *	cluster,
		SkScalar	offset
	)

Definition at line 215 of file Run.cpp.

                                                        {
    // Extend the cluster at the end
    fPositions[cluster->endPos()].fX += offset;
}

findLimitingClusters()

std::tuple< bool, ClusterIndex, ClusterIndex > skia::textlayout::Run::findLimitingClusters

(

TextRange

text

)

const

Definition at line 106 of file Run.cpp.

                                                                                         {
    if (text.width() == 0) {
        // Special Flutter case for "\n" and "...\n"
        if (text.end > this->fTextRange.start) {
            ClusterIndex index = fOwner->clusterIndex(text.end - 1);
            return std::make_tuple(true, index, index);
        } else {
            return std::make_tuple(false, 0, 0);
        }
    }
 
    ClusterRange clusterRange;
    bool found = true;
    // Deal with the case when either start or end are not align with glyph cluster edge
    // In such case we shift the text range to the right
    // (cutting from the left and adding to the right)
    if (leftToRight()) {
        // LTR: [start:end)
        found = clusterRange.start != fClusterRange.end;
        clusterRange.start = fOwner->clusterIndex(text.start);
        clusterRange.end = fOwner->clusterIndex(text.end - 1);
    } else {
        // RTL: (start:end]
        clusterRange.start = fOwner->clusterIndex(text.end);
        clusterRange.end = fOwner->clusterIndex(text.start + 1);
        found = clusterRange.end != fClusterRange.start;
    }
 
    return std::make_tuple(
            found,
            clusterRange.start,
            clusterRange.end);
}

findLimitingGlyphClusters()

std::tuple< bool, TextIndex, TextIndex > skia::textlayout::Run::findLimitingGlyphClusters

(

TextRange

text

)

const

Definition at line 140 of file Run.cpp.

                                                                                        {
    TextIndex start = fOwner->findPreviousGlyphClusterBoundary(text.start);
    TextIndex end = fOwner->findNextGlyphClusterBoundary(text.end);
    return std::make_tuple(true, start, end);
}

findLimitingGraphemes()

std::tuple< bool, TextIndex, TextIndex > skia::textlayout::Run::findLimitingGraphemes

(

TextRange

text

)

const

Definition at line 149 of file Run.cpp.

                                                                                    {
    TextIndex start = fOwner->findPreviousGraphemeBoundary(text.start);
    TextIndex end = fOwner->findNextGraphemeBoundary(text.end);
    return std::make_tuple(true, start, end);
}

font()

const SkFont & skia::textlayout::Run::font ( ) const

inline

Definition at line 95 of file Run.h.

{ return fFont; }

getTextDirection()

TextDirection skia::textlayout::Run::getTextDirection ( ) const

inline

Definition at line 97 of file Run.h.

{ return leftToRight() ? TextDirection::kLtr : TextDirection::kRtl; }

globalClusterIndex()

size_t skia::textlayout::Run::globalClusterIndex ( size_t  pos ) const

inline

Definition at line 105 of file Run.h.

{ return fClusterStart + fClusterIndexes[pos]; }

glyphs()

SkSpan< const SkGlyphID > skia::textlayout::Run::glyphs ( ) const

inline

Definition at line 149 of file Run.h.

                                           {
        return SkSpan<const SkGlyphID>(fGlyphs.begin(), fGlyphs.size());
    }

heightMultiplier()

SkScalar skia::textlayout::Run::heightMultiplier ( ) const

inline

Definition at line 99 of file Run.h.

{ return fHeightMultiplier; }

index()

size_t skia::textlayout::Run::index ( ) const

inline

Definition at line 98 of file Run.h.

{ return fIndex; }

isEllipsis()

bool skia::textlayout::Run::isEllipsis ( ) const

inline

Definition at line 113 of file Run.h.

{ return fEllipsis; }

isPlaceholder()

bool skia::textlayout::Run::isPlaceholder ( ) const

inline

Definition at line 103 of file Run.h.

{ return fPlaceholderIndex != std::numeric_limits<size_t>::max(); }

isResolved()

bool skia::textlayout::Run::isResolved

(

)

const

Definition at line 320 of file Run.cpp.

                           {
    for (auto& glyph :fGlyphs) {
        if (glyph == 0) {
            return false;
        }
    }
    return true;
}

iterateThroughClusters()

void skia::textlayout::Run::iterateThroughClusters

(

const ClusterVisitor &

visitor

)

Definition at line 155 of file Run.cpp.

                                                              {
 
    for (size_t index = 0; index < fClusterRange.width(); ++index) {
        auto correctIndex = leftToRight() ? fClusterRange.start + index : fClusterRange.end - index - 1;
        auto cluster = &fOwner->cluster(correctIndex);
        visitor(cluster);
    }
}

iterateThroughClustersInTextOrder()

template<typename Visitor >

void skia::textlayout::Run::iterateThroughClustersInTextOrder

(

Visitor

visitor

)

Definition at line 218 of file Run.h.

                                                           {
    // Can't figure out how to do it with one code for both cases without 100 ifs
    // Can't go through clusters because there are no cluster table yet
    if (leftToRight()) {
        size_t start = 0;
        size_t cluster = this->clusterIndex(start);
        for (size_t glyph = 1; glyph <= this->size(); ++glyph) {
            auto nextCluster = this->clusterIndex(glyph);
            if (nextCluster <= cluster) {
                continue;
            }
 
            visitor(start,
                    glyph,
                    fClusterStart + cluster,
                    fClusterStart + nextCluster,
                    this->calculateWidth(start, glyph, glyph == size()),
                    this->calculateHeight(LineMetricStyle::CSS, LineMetricStyle::CSS));
 
            start = glyph;
            cluster = nextCluster;
        }
    } else {
        size_t glyph = this->size();
        size_t cluster = this->fUtf8Range.begin();
        for (int32_t start = this->size() - 1; start >= 0; --start) {
            size_t nextCluster =
                    start == 0 ? this->fUtf8Range.end() : this->clusterIndex(start - 1);
            if (nextCluster <= cluster) {
                continue;
            }
 
            visitor(start,
                    glyph,
                    fClusterStart + cluster,
                    fClusterStart + nextCluster,
                    this->calculateWidth(start, glyph, glyph == 0),
                    this->calculateHeight(LineMetricStyle::CSS, LineMetricStyle::CSS));
 
            glyph = start;
            cluster = nextCluster;
        }
    }
}

leading()

SkScalar skia::textlayout::Run::leading ( ) const

inline

Definition at line 91 of file Run.h.

{ return fFontMetrics.fLeading; }

leftToRight()

bool skia::textlayout::Run::leftToRight ( ) const

inline

Definition at line 96 of file Run.h.

{ return fBidiLevel % 2 == 0; }

newRunBuffer()

SkShaper::RunHandler::Buffer skia::textlayout::Run::newRunBuffer

(

)

Definition at line 84 of file Run.cpp.

                                           {
    return {fGlyphs.data(), fPositions.data(), fOffsets.data(), fClusterIndexes.data(), fOffset};
}

offset()

SkVector skia::textlayout::Run::offset ( ) const

inline

Definition at line 88 of file Run.h.

{ return fOffset; }

offsets()

SkSpan< const SkPoint > skia::textlayout::Run::offsets ( ) const

inline

Definition at line 155 of file Run.h.

                                          {
        return SkSpan<const SkPoint>(fOffsets.begin(), fOffsets.size());
    }

operator=() [1/2]

Run & skia::textlayout::Run::operator= ( const Run &  )

delete

operator=() [2/2]

Run & skia::textlayout::Run::operator= ( Run &&  )

delete

owner()

ParagraphImpl * skia::textlayout::Run::owner ( ) const

inline

Definition at line 111 of file Run.h.

{ return fOwner; }

placeholderStyle()

PlaceholderStyle * skia::textlayout::Run::placeholderStyle

(

)

const

Definition at line 312 of file Run.cpp.

                                              {
    if (isPlaceholder()) {
        return &fOwner->placeholders()[fPlaceholderIndex].fStyle;
    } else {
        return nullptr;
    }
}

positions()

SkSpan< const SkPoint > skia::textlayout::Run::positions ( ) const

inline

Definition at line 152 of file Run.h.

                                            {
        return SkSpan<const SkPoint>(fPositions.begin(), fPositions.size());
    }

positionX()

SkScalar skia::textlayout::Run::positionX

(

size_t

pos

)

const

Definition at line 308 of file Run.cpp.

                                        {
    return posX(pos) + (fJustificationShifts.empty() ? 0 : fJustificationShifts[pos].fY);
}

posX()

SkScalar skia::textlayout::Run::posX ( size_t  index ) const

inline

Definition at line 75 of file Run.h.

{ return fPositions[index].fX; }

posY()

SkScalar skia::textlayout::Run::posY ( size_t  index ) const

inline

Definition at line 77 of file Run.h.

{ return fPositions[index].fY; }

resetJustificationShifts()

void skia::textlayout::Run::resetJustificationShifts ( )

inline

Definition at line 164 of file Run.h.

                                    {
        fJustificationShifts.clear();
    }

setClusterRange()

void skia::textlayout::Run::setClusterRange ( size_t  from, size_t  to  )

inline

Definition at line 118 of file Run.h.

{ fClusterRange = ClusterRange(from, to); }

setHeight()

void skia::textlayout::Run::setHeight ( SkScalar  height )

inline

Definition at line 80 of file Run.h.

{ fAdvance.fY = height; }

setOwner()

void skia::textlayout::Run::setOwner ( ParagraphImpl *  owner )

inline

Definition at line 71 of file Run.h.

{ fOwner = owner; }

setWidth()

void skia::textlayout::Run::setWidth ( SkScalar  width )

inline

Definition at line 79 of file Run.h.

{ fAdvance.fX = width; }

shift() [1/2]

void skia::textlayout::Run::shift	(	const Cluster *	cluster,
		SkScalar	offset
	)

Definition at line 202 of file Run.cpp.

                                                       {
    if (offset == 0) {
        return;
    }
    for (size_t i = cluster->startPos(); i < cluster->endPos(); ++i) {
        fPositions[i].fX += offset;
    }
    if (this->size() == cluster->endPos()) {
        // To make calculations easier
        fPositions[cluster->endPos()].fX += offset;
    }
}

shift() [2/2]

void skia::textlayout::Run::shift ( SkScalar  shiftX, SkScalar  shiftY  )

inline

Definition at line 81 of file Run.h.

                                                 {
        fOffset.fX += shiftX;
        fOffset.fY += shiftY;
    }

size()

size_t skia::textlayout::Run::size ( ) const

inline

Definition at line 78 of file Run.h.

{ return fGlyphs.size(); }

textRange()

TextRange skia::textlayout::Run::textRange ( ) const

inline

Definition at line 108 of file Run.h.

{ return fTextRange; }

updateMetrics()

void skia::textlayout::Run::updateMetrics

(

InternalLineMetrics *

endlineMetrics

)

Definition at line 220 of file Run.cpp.

                                                           {
 
    SkASSERT(isPlaceholder());
    auto placeholderStyle = this->placeholderStyle();
    // Difference between the placeholder baseline and the line bottom
    SkScalar baselineAdjustment = 0;
    switch (placeholderStyle->fBaseline) {
        case TextBaseline::kAlphabetic:
            break;
 
        case TextBaseline::kIdeographic:
            baselineAdjustment = endlineMetrics->deltaBaselines() / 2;
            break;
    }
 
    auto height = placeholderStyle->fHeight;
    auto offset = placeholderStyle->fBaselineOffset;
 
    fFontMetrics.fLeading = 0;
    switch (placeholderStyle->fAlignment) {
        case PlaceholderAlignment::kBaseline:
            fFontMetrics.fAscent = baselineAdjustment - offset;
            fFontMetrics.fDescent = baselineAdjustment + height - offset;
            break;
 
        case PlaceholderAlignment::kAboveBaseline:
            fFontMetrics.fAscent = baselineAdjustment - height;
            fFontMetrics.fDescent = baselineAdjustment;
            break;
 
        case PlaceholderAlignment::kBelowBaseline:
            fFontMetrics.fAscent = baselineAdjustment;
            fFontMetrics.fDescent = baselineAdjustment + height;
            break;
 
        case PlaceholderAlignment::kTop:
            fFontMetrics.fDescent = height + fFontMetrics.fAscent;
            break;
 
        case PlaceholderAlignment::kBottom:
            fFontMetrics.fAscent = fFontMetrics.fDescent - height;
            break;
 
        case PlaceholderAlignment::kMiddle:
            auto mid = (-fFontMetrics.fDescent - fFontMetrics.fAscent)/2.0;
            fFontMetrics.fDescent = height/2.0 - mid;
            fFontMetrics.fAscent =  - height/2.0 - mid;
            break;
    }
 
    this->calculateMetrics();
 
    // Make sure the placeholder can fit the line
    endlineMetrics->add(this);
}

useHalfLeading()

bool skia::textlayout::Run::useHalfLeading ( ) const

inline

Definition at line 100 of file Run.h.

{ return fUseHalfLeading; }

Friends And Related Function Documentation

InternalLineMetrics

friend class InternalLineMetrics

friend

Definition at line 172 of file Run.h.

OneLineShaper

friend class OneLineShaper

friend

Definition at line 174 of file Run.h.

ParagraphCache

friend class ParagraphCache

friend

Definition at line 173 of file Run.h.

ParagraphImpl

friend class ParagraphImpl

friend

Definition at line 170 of file Run.h.

TextLine

friend class TextLine

friend

Definition at line 171 of file Run.h.

---

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

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