#include <SkFont.h>

Public Types
enum class	Edging { kAlias , kAntiAlias , kSubpixelAntiAlias }

using	sk_is_trivially_relocatable = std::true_type

Public Member Functions
	SkFont ()

	SkFont (sk_sp< SkTypeface > typeface, SkScalar size)

	SkFont (sk_sp< SkTypeface > typeface)

	SkFont (sk_sp< SkTypeface > typeface, SkScalar size, SkScalar scaleX, SkScalar skewX)

bool	operator== (const SkFont &font) const

bool	operator!= (const SkFont &font) const

bool	isForceAutoHinting () const

bool	isEmbeddedBitmaps () const

bool	isSubpixel () const

bool	isLinearMetrics () const

bool	isEmbolden () const

bool	isBaselineSnap () const

void	setForceAutoHinting (bool forceAutoHinting)

void	setEmbeddedBitmaps (bool embeddedBitmaps)

void	setSubpixel (bool subpixel)

void	setLinearMetrics (bool linearMetrics)

void	setEmbolden (bool embolden)

void	setBaselineSnap (bool baselineSnap)

Edging	getEdging () const

void	setEdging (Edging edging)

void	setHinting (SkFontHinting hintingLevel)

SkFontHinting	getHinting () const

SkFont	makeWithSize (SkScalar size) const

SkTypeface *	getTypeface () const

SkScalar	getSize () const

SkScalar	getScaleX () const

SkScalar	getSkewX () const

sk_sp< SkTypeface >	refTypeface () const

void	setTypeface (sk_sp< SkTypeface > tf)

void	setSize (SkScalar textSize)

void	setScaleX (SkScalar scaleX)

void	setSkewX (SkScalar skewX)

int	textToGlyphs (const void *text, size_t byteLength, SkTextEncoding encoding, SkGlyphID glyphs[], int maxGlyphCount) const

SkGlyphID	unicharToGlyph (SkUnichar uni) const

void	unicharsToGlyphs (const SkUnichar uni[], int count, SkGlyphID glyphs[]) const

int	countText (const void *text, size_t byteLength, SkTextEncoding encoding) const

SkScalar	measureText (const void text, size_t byteLength, SkTextEncoding encoding, SkRect bounds=nullptr) const

SkScalar	measureText (const void text, size_t byteLength, SkTextEncoding encoding, SkRect bounds, const SkPaint *paint) const

void	getWidths (const SkGlyphID glyphs[], int count, SkScalar widths[], SkRect bounds[]) const

void	getWidths (const SkGlyphID glyphs[], int count, SkScalar widths[], std::nullptr_t) const

void	getWidths (const SkGlyphID glyphs[], int count, SkScalar widths[]) const

void	getWidthsBounds (const SkGlyphID glyphs[], int count, SkScalar widths[], SkRect bounds[], const SkPaint *paint) const

void	getBounds (const SkGlyphID glyphs[], int count, SkRect bounds[], const SkPaint *paint) const

void	getPos (const SkGlyphID glyphs[], int count, SkPoint pos[], SkPoint origin={0, 0}) const

void	getXPos (const SkGlyphID glyphs[], int count, SkScalar xpos[], SkScalar origin=0) const

std::vector< SkScalar >	getIntercepts (const SkGlyphID glyphs[], int count, const SkPoint pos[], SkScalar top, SkScalar bottom, const SkPaint *=nullptr) const

bool	getPath (SkGlyphID glyphID, SkPath *path) const

void	getPaths (const SkGlyphID glyphIDs[], int count, void(glyphPathProc)(const SkPath pathOrNull, const SkMatrix &mx, void ctx), void ctx) const

SkScalar	getMetrics (SkFontMetrics *metrics) const

SkScalar	getSpacing () const

void	dump () const

Friends
class	SkFontPriv

class	SkGlyphRunListPainterCPU

class	SkStrikeSpec

class	SkRemoteGlyphCacheTest

Detailed Description

SkFont controls options applied when drawing and measuring text.

Definition at line 35 of file SkFont.h.

Member Typedef Documentation

◆ sk_is_trivially_relocatable

using SkFont::sk_is_trivially_relocatable = std::true_type

Definition at line 501 of file SkFont.h.

Member Enumeration Documentation

◆ Edging

enum class SkFont::Edging

strong

Whether edge pixels draw opaque or with partial transparency.

Enumerator
kAlias	no transparent pixels on glyph edges
kAntiAlias	may have transparent pixels on glyph edges
kSubpixelAntiAlias	glyph positioned in pixel using transparency

Definition at line 39 of file SkFont.h.

                      {
        kAlias,              //!< no transparent pixels on glyph edges
        kAntiAlias,          //!< may have transparent pixels on glyph edges
        kSubpixelAntiAlias,  //!< glyph positioned in pixel using transparency
    };

Constructor & Destructor Documentation

◆ SkFont() [1/4]

SkFont::SkFont ( )

Constructs SkFont with default values.

Returns: default initialized SkFont

Definition at line 68 of file SkFont.cpp.

68: SkFont(nullptr, kDefault_Size) {}

kDefault_Size

#define kDefault_Size

Definition SkFont.cpp:42

SkFont::SkFont

SkFont()

Definition SkFont.cpp:68

◆ SkFont() [2/4]

SkFont::SkFont	(	sk_sp< SkTypeface >	typeface,
		SkScalar	size
	)

Constructs SkFont with default values with SkTypeface and size in points.

Parameters

typeface	font and style used to draw and measure text
size	typographic height of text

Returns: initialized SkFont

Definition at line 64 of file SkFont.cpp.

64: SkFont(std::move(face), size, 1, 0) {}

◆ SkFont() [3/4]

SkFont::SkFont ( sk_sp< SkTypeface > typeface )

explicit

Constructs SkFont with default values with SkTypeface.

Parameters

typeface font and style used to draw and measure text

Returns: initialized SkFont

Definition at line 66 of file SkFont.cpp.

66: SkFont(std::move(face), kDefault_Size, 1, 0) {}

◆ SkFont() [4/4]

SkFont::SkFont	(	sk_sp< SkTypeface >	typeface,
		SkScalar	size,
		SkScalar	scaleX,
		SkScalar	skewX
	)

Constructs SkFont with default values with SkTypeface and size in points, horizontal scale, and horizontal skew. Horizontal scale emulates condensed and expanded fonts. Horizontal skew emulates oblique fonts.

Parameters

typeface	font and style used to draw and measure text
size	typographic height of text
scaleX	text horizontal scale
skewX	additional shear on x-axis relative to y-axis

Returns: initialized SkFont

Definition at line 51 of file SkFont.cpp.

    : fTypeface(std::move(face))
    , fSize(valid_size(size))
    , fScaleX(scaleX)
    , fSkewX(skewX)
    , fFlags(kDefault_Flags)
    , fEdging(static_cast<unsigned>(kDefault_Edging))
    , fHinting(static_cast<unsigned>(kDefault_Hinting)) {
    if (!fTypeface) {
        fTypeface = SkTypeface::MakeEmpty();
    }
}

Member Function Documentation

◆ countText()

int SkFont::countText	(	const void *	text,
		size_t	byteLength,
		SkTextEncoding	encoding
	)		const

inline

Returns number of glyphs represented by text.

If encoding is SkTextEncoding::kUTF8, SkTextEncoding::kUTF16, or SkTextEncoding::kUTF32; then each Unicode codepoint is mapped to a single glyph.

Parameters

text	character storage encoded with SkTextEncoding
byteLength	length of character storage in bytes

Returns: number of glyphs represented by text of length byteLength

Definition at line 323 of file SkFont.h.

                                                                                      {
        return this->textToGlyphs(text, byteLength, encoding, nullptr, 0);
    }

◆ dump()

void SkFont::dump ( ) const

Dumps fields of the font to SkDebugf. May change its output over time, so clients should not rely on this for anything specific. Used to aid in debugging.

Definition at line 80 of file SkFont.cpp.

                        {
    SkDebugf("typeface %p\n", fTypeface.get());
    SkDebugf("size %g\n", fSize);
    SkDebugf("skewx %g\n", fSkewX);
    SkDebugf("scalex %g\n", fScaleX);
    SkDebugf("flags 0x%X\n", fFlags);
    SkDebugf("edging %u\n", (unsigned)fEdging);
    SkDebugf("hinting %u\n", (unsigned)fHinting);
}

◆ getBounds()

void SkFont::getBounds	(	const SkGlyphID	glyphs[],
		int	count,
		SkRect	bounds[],
		const SkPaint *	paint
	)		const

inline

Retrieves the bounds for each glyph in glyphs. bounds must be an array of count entries. If paint is not nullptr, its stroking, SkPathEffect, and SkMaskFilter fields are respected.

Parameters

glyphs	array of glyph indices to be measured
count	number of glyphs
bounds	returns bounds for each glyph relative to (0, 0); may be nullptr
paint	optional, specifies stroking, SkPathEffect, and SkMaskFilter

Definition at line 412 of file SkFont.h.

                                               {
        this->getWidthsBounds(glyphs, count, nullptr, bounds, paint);
    }

◆ getEdging()

Edging SkFont::getEdging ( ) const

inline

Whether edge pixels draw opaque or with partial transparency.

Definition at line 180 of file SkFont.h.

180{ return (Edging)fEdging; }

SkFont::Edging

Edging

Definition SkFont.h:39

◆ getHinting()

SkFontHinting SkFont::getHinting ( ) const

inline

Returns level of glyph outline adjustment.

Definition at line 194 of file SkFont.h.

194{ return (SkFontHinting)fHinting; }

SkFontHinting

Definition SkFontTypes.h:18

◆ getIntercepts()

std::vector< SkScalar > SkFont::getIntercepts	(	const SkGlyphID	glyphs[],
		int	count,
		const SkPoint	pos[],
		SkScalar	top,
		SkScalar	bottom,
		const SkPaint *	paintPtr = `nullptr`
	)		const

Returns intervals [start, end] describing lines parallel to the advance that intersect with the glyphs.

Parameters

glyphs	the glyphs to intersect
count	the number of glyphs and positions
pos	the position of each glyph
top	the top of the line intersecting
bottom	the bottom of the line intersecting

Returns: array of pairs of x values [start, end]. May be empty.

Definition at line 950 of file SkTextBlob.cpp.

                                                                           {
    if (count <= 0) {
        return std::vector<SkScalar>();
    }
 
    const SkPaint paint(paintPtr ? *paintPtr : SkPaint());
    const SkScalar bounds[] = {top, bottom};
    const sktext::GlyphRun run(*this,
                         {positions, size_t(count)}, {glyphs, size_t(count)},
                         {nullptr, 0}, {nullptr, 0}, {nullptr, 0});
 
    std::vector<SkScalar> result;
    result.resize(count * 2);   // worst case allocation
    int intervalCount = 0;
    intervalCount = get_glyph_run_intercepts(run, paint, bounds, result.data(), &intervalCount);
    result.resize(intervalCount);
    return result;
}

◆ getMetrics()

SkScalar SkFont::getMetrics ( SkFontMetrics * metrics ) const

Returns SkFontMetrics associated with SkTypeface. The return value is the recommended spacing between lines: the sum of metrics descent, ascent, and leading. If metrics is not nullptr, SkFontMetrics is copied to metrics. Results are scaled by text size but does not take into account dimensions required by text scale, text skew, fake bold, style stroke, and SkPathEffect.

Parameters

metrics storage for SkFontMetrics; may be nullptr

Returns: recommended spacing between lines

Definition at line 316 of file SkFont.cpp.

                                                        {
 
    auto [strikeSpec, strikeToSourceScale] = SkStrikeSpec::MakeCanonicalized(*this, nullptr);
 
    SkFontMetrics storage;
    if (nullptr == metrics) {
        metrics = &storage;
    }
 
    auto cache = strikeSpec.findOrCreateStrike();
    *metrics = cache->getFontMetrics();
 
    if (strikeToSourceScale != 1) {
        SkFontPriv::ScaleFontMetrics(metrics, strikeToSourceScale);
    }
    return metrics->fDescent - metrics->fAscent + metrics->fLeading;
}

◆ getPath()

bool SkFont::getPath	(	SkGlyphID	glyphID,
		SkPath *	path
	)		const

Modifies path to be the outline of the glyph. If the glyph has an outline, modifies path to be the glyph's outline and returns true. The glyph outline may be empty. Degenerate contours in the glyph outline will be skipped. If glyph is described by a bitmap, returns false and ignores path parameter.

Parameters

glyphID	index of glyph
path	pointer to existing SkPath

Returns: true if glyphID is described by path

Definition at line 300 of file SkFont.cpp.

                                                          {
    struct Pair {
        SkPath* fPath;
        bool    fWasSet;
    } pair = { path, false };
 
    this->getPaths(&glyphID, 1, [](const SkPath* orig, const SkMatrix& mx, void* ctx) {
        Pair* pair = static_cast<Pair*>(ctx);
        if (orig) {
            orig->transform(mx, pair->fPath);
            pair->fWasSet = true;
        }
    }, &pair);
    return pair.fWasSet;
}

◆ getPaths()

void SkFont::getPaths	(	const SkGlyphID	glyphIDs[],
		int	count,
		void()(const SkPath pathOrNull, const SkMatrix &mx, void *ctx)	glyphPathProc,
		void *	ctx
	)		const

Returns path corresponding to glyph array.

Parameters

glyphIDs	array of glyph indices
count	number of glyphs
glyphPathProc	function returning one glyph description as path
ctx	function context

Definition at line 285 of file SkFont.cpp.

                                                                                            {
    SkFont font(*this);
    SkScalar scale = font.setupForAsPaths(nullptr);
    const SkMatrix mx = SkMatrix::Scale(scale, scale);
 
    SkStrikeSpec strikeSpec = SkStrikeSpec::MakeWithNoDevice(font);
    SkBulkGlyphMetricsAndPaths paths{strikeSpec};
    SkSpan<const SkGlyph*> glyphs = paths.glyphs(SkSpan(glyphIDs, count));
 
    for (auto glyph : glyphs) {
        proc(glyph->path(), mx, ctx);
    }
}

◆ getPos()

void SkFont::getPos	(	const SkGlyphID	glyphs[],
		int	count,
		SkPoint	pos[],
		SkPoint	origin = `{0, 0}`
	)		const

Retrieves the positions for each glyph, beginning at the specified origin. The caller must allocated at least count number of elements in the pos[] array.

Parameters

glyphs	array of glyph indices to be positioned
count	number of glyphs
pos	returns glyphs positions
origin	location of the first glyph. Defaults to {0, 0}.

Definition at line 258 of file SkFont.cpp.

                                                                                              {
    auto [strikeSpec, strikeToSourceScale] = SkStrikeSpec::MakeCanonicalized(*this);
    SkBulkGlyphMetrics metrics{strikeSpec};
    SkSpan<const SkGlyph*> glyphs = metrics.glyphs(SkSpan(glyphIDs, count));
 
    SkPoint sum = origin;
    for (auto glyph : glyphs) {
        *pos++ = sum;
        sum += glyph->advanceVector() * strikeToSourceScale;
    }
}

◆ getScaleX()

SkScalar SkFont::getScaleX ( ) const

inline

Returns text scale on x-axis. Default value is 1.

Returns: text horizontal scale

Definition at line 224 of file SkFont.h.

224{ return fScaleX; }

◆ getSize()

SkScalar SkFont::getSize ( ) const

inline

Returns text size in points.

Returns: typographic height of text

Definition at line 217 of file SkFont.h.

217{ return fSize; }

◆ getSkewX()

SkScalar SkFont::getSkewX ( ) const

inline

Returns text skew on x-axis. Default value is zero.

Returns: additional shear on x-axis relative to y-axis

Definition at line 231 of file SkFont.h.

231{ return fSkewX; }

◆ getSpacing()

SkScalar SkFont::getSpacing ( ) const

inline

Returns the recommended spacing between lines: the sum of metrics descent, ascent, and leading. Result is scaled by text size but does not take into account dimensions required by stroking and SkPathEffect. Returns the same result as getMetrics().

Returns: recommended spacing between lines

Definition at line 494 of file SkFont.h.

494{ return this->getMetrics(nullptr); }

SkFont::getMetrics

SkScalar getMetrics(SkFontMetrics *metrics) const

Definition SkFont.cpp:316

◆ getTypeface()

SkTypeface * SkFont::getTypeface ( ) const

inline

Does not alter SkTypeface SkRefCnt.

Returns: non-null SkTypeface

Definition at line 208 of file SkFont.h.

                                    {
        SkASSERT(fTypeface);
        return fTypeface.get();
    }

◆ getWidths() [1/3]

void SkFont::getWidths	(	const SkGlyphID	glyphs[],
		int	count,
		SkScalar	widths[]
	)		const

inline

Retrieves the advance and bounds for each glyph in glyphs. Both widths and bounds may be nullptr. If widths is not nullptr, widths must be an array of count entries. if bounds is not nullptr, bounds must be an array of count entries.

Parameters

glyphs	array of glyph indices to be measured
count	number of glyphs
widths	returns text advances for each glyph

Definition at line 384 of file SkFont.h.

                                                                                 {
        this->getWidthsBounds(glyphs, count, widths, nullptr, nullptr);
    }

◆ getWidths() [2/3]

void SkFont::getWidths	(	const SkGlyphID	glyphs[],
		int	count,
		SkScalar	widths[],
		SkRect	bounds[]
	)		const

inline

DEPRECATED Retrieves the advance and bounds for each glyph in glyphs. Both widths and bounds may be nullptr. If widths is not nullptr, widths must be an array of count entries. if bounds is not nullptr, bounds must be an array of count entries.

Parameters

glyphs	array of glyph indices to be measured
count	number of glyphs
widths	returns text advances for each glyph; may be nullptr
bounds	returns bounds for each glyph relative to (0, 0); may be nullptr

Definition at line 366 of file SkFont.h.

                                                                                                  {
        this->getWidthsBounds(glyphs, count, widths, bounds, nullptr);
    }

◆ getWidths() [3/3]

void SkFont::getWidths	(	const SkGlyphID	glyphs[],
		int	count,
		SkScalar	widths[],
		std::nullptr_t
	)		const

inline

Definition at line 371 of file SkFont.h.

                                                                                               {
        this->getWidths(glyphs, count, widths);
    }

◆ getWidthsBounds()

void SkFont::getWidthsBounds	(	const SkGlyphID	glyphs[],
		int	count,
		SkScalar	widths[],
		SkRect	bounds[],
		const SkPaint *	paint
	)		const

Retrieves the advance and bounds for each glyph in glyphs. Both widths and bounds may be nullptr. If widths is not nullptr, widths must be an array of count entries. if bounds is not nullptr, bounds must be an array of count entries.

Parameters

glyphs	array of glyph indices to be measured
count	number of glyphs
widths	returns text advances for each glyph; may be nullptr
bounds	returns bounds for each glyph relative to (0, 0); may be nullptr
paint	optional, specifies stroking, SkPathEffect and SkMaskFilter

Definition at line 233 of file SkFont.cpp.

                                                         {
    auto [strikeSpec, strikeToSourceScale] = SkStrikeSpec::MakeCanonicalized(*this, paint);
    SkBulkGlyphMetrics metrics{strikeSpec};
    SkSpan<const SkGlyph*> glyphs = metrics.glyphs(SkSpan(glyphIDs, count));
 
    if (bounds) {
        SkMatrix scaleMat = SkMatrix::Scale(strikeToSourceScale, strikeToSourceScale);
        SkRect* cursor = bounds;
        for (auto glyph : glyphs) {
            scaleMat.mapRectScaleTranslate(cursor++, glyph->rect());
        }
    }
 
    if (widths) {
        SkScalar* cursor = widths;
        for (auto glyph : glyphs) {
            *cursor++ = glyph->advanceX() * strikeToSourceScale;
        }
    }
}

◆ getXPos()

void SkFont::getXPos	(	const SkGlyphID	glyphs[],
		int	count,
		SkScalar	xpos[],
		SkScalar	origin = `0`
	)		const

Retrieves the x-positions for each glyph, beginning at the specified origin. The caller must allocated at least count number of elements in the xpos[] array.

Parameters

glyphs	array of glyph indices to be positioned
count	number of glyphs
xpos	returns glyphs x-positions
origin	x-position of the first glyph. Defaults to 0.

Definition at line 270 of file SkFont.cpp.

                                                                                       {
 
    auto [strikeSpec, strikeToSourceScale] = SkStrikeSpec::MakeCanonicalized(*this);
    SkBulkGlyphMetrics metrics{strikeSpec};
    SkSpan<const SkGlyph*> glyphs = metrics.glyphs(SkSpan(glyphIDs, count));
 
    SkScalar loc = origin;
    SkScalar* cursor = xpos;
    for (auto glyph : glyphs) {
        *cursor++ = loc;
        loc += glyph->advanceX() * strikeToSourceScale;
    }
}

◆ isBaselineSnap()

bool SkFont::isBaselineSnap ( ) const

inline

Returns true if baselines will be snapped to pixel positions when the current transformation matrix is axis aligned.

Returns: baselines may be snapped to pixels

Definition at line 133 of file SkFont.h.

133{ return SkToBool(fFlags & kBaselineSnap_PrivFlag); }

SkToBool

static constexpr bool SkToBool(const T &x)

Definition SkTo.h:35

◆ isEmbeddedBitmaps()

bool SkFont::isEmbeddedBitmaps ( ) const

inline

Returns true if font engine may return glyphs from font bitmaps instead of from outlines.

Returns: true if glyphs may be font bitmaps

Definition at line 107 of file SkFont.h.

107{ return SkToBool(fFlags & kEmbeddedBitmaps_PrivFlag); }

◆ isEmbolden()

bool SkFont::isEmbolden ( ) const

inline

Returns true if bold is approximated by increasing the stroke width when creating glyph bitmaps from outlines.

Returns: bold is approximated through stroke width

Definition at line 126 of file SkFont.h.

126{ return SkToBool(fFlags & kEmbolden_PrivFlag); }

◆ isForceAutoHinting()

bool SkFont::isForceAutoHinting ( ) const

inline

If true, instructs the font manager to always hint glyphs. Returned value is only meaningful if platform uses FreeType as the font manager.

Returns: true if all glyphs are hinted

Definition at line 101 of file SkFont.h.

101{ return SkToBool(fFlags & kForceAutoHinting_PrivFlag); }

◆ isLinearMetrics()

bool SkFont::isLinearMetrics ( ) const

inline

Returns true if font and glyph metrics are requested to be linearly scalable.

Returns: true if font and glyph metrics are requested to be linearly scalable.

Definition at line 119 of file SkFont.h.

119{ return SkToBool(fFlags & kLinearMetrics_PrivFlag); }

◆ isSubpixel()

bool SkFont::isSubpixel ( ) const

inline

Returns true if glyphs may be drawn at sub-pixel offsets.

Returns: true if glyphs may be drawn at sub-pixel offsets.

Definition at line 113 of file SkFont.h.

113{ return SkToBool(fFlags & kSubpixel_PrivFlag); }

◆ makeWithSize()

SkFont SkFont::makeWithSize ( SkScalar size ) const

Returns a font with the same attributes of this font, but with the specified size. Returns nullptr if size is less than zero, infinite, or NaN.

Parameters

size	typographic height of text

Returns: initialized SkFont

Definition at line 139 of file SkFont.cpp.

                                                  {
    SkFont font = *this;
    font.setSize(newSize);
    return font;
}

◆ measureText() [1/2]

SkScalar SkFont::measureText	(	const void *	text,
		size_t	byteLength,
		SkTextEncoding	encoding,
		SkRect *	bounds,
		const SkPaint *	paint
	)		const

Returns the advance width of text. The advance is the normal distance to move before drawing additional text. Returns the bounding box of text if bounds is not nullptr. The paint stroke settings, mask filter, or path effect may modify the bounds.

Parameters

text	character storage encoded with SkTextEncoding
byteLength	length of character storage in bytes
bounds	returns bounding box relative to (0, 0) if not nullptr
paint	optional; may be nullptr

Returns: the sum of the default advance widths

Definition at line 187 of file SkFont.cpp.

                                                                         {
 
    SkAutoToGlyphs atg(*this, text, length, encoding);
    const int glyphCount = atg.count();
    if (glyphCount == 0) {
        if (bounds) {
            bounds->setEmpty();
        }
        return 0;
    }
    const SkGlyphID* glyphIDs = atg.glyphs();
 
    auto [strikeSpec, strikeToSourceScale] = SkStrikeSpec::MakeCanonicalized(*this, paint);
    SkBulkGlyphMetrics metrics{strikeSpec};
    SkSpan<const SkGlyph*> glyphs = metrics.glyphs(SkSpan(glyphIDs, glyphCount));
 
    SkScalar width = 0;
    if (bounds) {
        *bounds = glyphs[0]->rect();
        width = glyphs[0]->advanceX();
        for (int i = 1; i < glyphCount; ++i) {
            SkRect r = glyphs[i]->rect();
            r.offset(width, 0);
            bounds->join(r);
            width += glyphs[i]->advanceX();
        }
    } else {
        for (auto glyph : glyphs) {
            width += glyph->advanceX();
        }
    }
 
    if (strikeToSourceScale != 1) {
        width *= strikeToSourceScale;
        if (bounds) {
            bounds->fLeft   *= strikeToSourceScale;
            bounds->fTop    *= strikeToSourceScale;
            bounds->fRight  *= strikeToSourceScale;
            bounds->fBottom *= strikeToSourceScale;
        }
    }
 
    return width;
}

◆ measureText() [2/2]

SkScalar SkFont::measureText	(	const void *	text,
		size_t	byteLength,
		SkTextEncoding	encoding,
		SkRect *	bounds = `nullptr`
	)		const

inline

Returns the advance width of text. The advance is the normal distance to move before drawing additional text. Returns the bounding box of text if bounds is not nullptr.

Parameters

text	character storage encoded with SkTextEncoding
byteLength	length of character storage in bytes
bounds	returns bounding box relative to (0, 0) if not nullptr

Returns: the sum of the default advance widths

Definition at line 336 of file SkFont.h.

                                                         {
        return this->measureText(text, byteLength, encoding, bounds, nullptr);
    }

◆ operator!=()

bool SkFont::operator!= ( const SkFont & font ) const

inline

Compares SkFont and font, and returns true if they are not equivalent. May return true if SkTypeface has identical contents but different pointers.

Parameters

font	font to compare

Returns: true if SkFont pair are not equivalent

Definition at line 94 of file SkFont.h.

94{ return !(*this == font); }

◆ operator==()

bool SkFont::operator== ( const SkFont & font ) const

Compares SkFont and font, and returns true if they are equivalent. May return false if SkTypeface has identical contents but different pointers.

Parameters

font	font to compare

Returns: true if SkFont pair are equivalent

Definition at line 70 of file SkFont.cpp.

                                             {
    return  fTypeface.get() == b.fTypeface.get() &&
            fSize           == b.fSize &&
            fScaleX         == b.fScaleX &&
            fSkewX          == b.fSkewX &&
            fFlags          == b.fFlags &&
            fEdging         == b.fEdging &&
            fHinting        == b.fHinting;
}

◆ refTypeface()

sk_sp< SkTypeface > SkFont::refTypeface ( ) const

inline

Increases SkTypeface SkRefCnt by one.

Returns: A non-null SkTypeface.

Definition at line 237 of file SkFont.h.

                                          {
        SkASSERT(fTypeface);
        return fTypeface;
    }

◆ setBaselineSnap()

void SkFont::setBaselineSnap ( bool baselineSnap )

Requests that baselines be snapped to pixels when the current transformation matrix is axis aligned.

Parameters

baselineSnap setting for baseline snapping to pixels

Definition at line 118 of file SkFont.cpp.

                                           {
    fFlags = set_clear_mask(fFlags, predicate, kBaselineSnap_PrivFlag);
}

◆ setEdging()

void SkFont::setEdging ( Edging edging )

Requests, but does not require, that edge pixels draw opaque or with partial transparency.

Definition at line 121 of file SkFont.cpp.

                               {
    fEdging = SkToU8(e);
}

◆ setEmbeddedBitmaps()

void SkFont::setEmbeddedBitmaps ( bool embeddedBitmaps )

Requests, but does not require, to use bitmaps in fonts instead of outlines.

Parameters

embeddedBitmaps setting to use bitmaps in fonts

Definition at line 106 of file SkFont.cpp.

                                              {
    fFlags = set_clear_mask(fFlags, predicate, kEmbeddedBitmaps_PrivFlag);
}

◆ setEmbolden()

void SkFont::setEmbolden ( bool embolden )

Increases stroke width when creating glyph bitmaps to approximate a bold typeface.

Parameters

embolden setting for bold approximation

Definition at line 115 of file SkFont.cpp.

                                       {
    fFlags = set_clear_mask(fFlags, predicate, kEmbolden_PrivFlag);
}

◆ setForceAutoHinting()

void SkFont::setForceAutoHinting ( bool forceAutoHinting )

Sets whether to always hint glyphs. If forceAutoHinting is set, instructs the font manager to always hint glyphs.

Only affects platforms that use FreeType as the font manager.

Parameters

forceAutoHinting setting to always hint glyphs

Definition at line 103 of file SkFont.cpp.

                                               {
    fFlags = set_clear_mask(fFlags, predicate, kForceAutoHinting_PrivFlag);
}

◆ setHinting()

void SkFont::setHinting ( SkFontHinting hintingLevel )

Sets level of glyph outline adjustment. Does not check for valid values of hintingLevel.

Definition at line 125 of file SkFont.cpp.

                                       {
    fHinting = SkToU8(h);
}

◆ setLinearMetrics()

void SkFont::setLinearMetrics ( bool linearMetrics )

Requests, but does not require, linearly scalable font and glyph metrics.

For outline fonts 'true' means font and glyph metrics should ignore hinting and rounding. Note that some bitmap formats may not be able to scale linearly and will ignore this flag.

Parameters

linearMetrics setting for linearly scalable font and glyph metrics.

Definition at line 112 of file SkFont.cpp.

                                            {
    fFlags = set_clear_mask(fFlags, predicate, kLinearMetrics_PrivFlag);
}

◆ setScaleX()

void SkFont::setScaleX ( SkScalar scaleX )

Sets text scale on x-axis. Default value is 1.

Parameters

scaleX text horizontal scale

Definition at line 132 of file SkFont.cpp.

                                     {
    fScaleX = scale;
}

◆ setSize()

void SkFont::setSize ( SkScalar textSize )

Sets text size in points. Has no effect if textSize is not greater than or equal to zero.

Parameters

textSize typographic height of text

Definition at line 129 of file SkFont.cpp.

                                  {
    fSize = valid_size(size);
}

◆ setSkewX()

void SkFont::setSkewX ( SkScalar skewX )

Sets text skew on x-axis. Default value is zero.

Parameters

skewX additional shear on x-axis relative to y-axis

Definition at line 135 of file SkFont.cpp.

                                   {
    fSkewX = skew;
}

◆ setSubpixel()

void SkFont::setSubpixel ( bool subpixel )

Requests, but does not require, that glyphs respect sub-pixel positioning.

Parameters

subpixel setting for sub-pixel positioning

Definition at line 109 of file SkFont.cpp.

                                       {
    fFlags = set_clear_mask(fFlags, predicate, kSubpixel_PrivFlag);
}

◆ setTypeface()

void SkFont::setTypeface ( sk_sp< SkTypeface > tf )

Sets SkTypeface to typeface, decreasing SkRefCnt of the previous SkTypeface. Pass nullptr to clear SkTypeface and use an empty typeface (which draws nothing). Increments tf SkRefCnt by one.

Parameters

tf	font and style used to draw text

Definition at line 90 of file SkFont.cpp.

                                             {
    fTypeface = std::move(tf);
    if (!fTypeface) {
        fTypeface = SkTypeface::MakeEmpty();
    }
}

◆ textToGlyphs()

int SkFont::textToGlyphs	(	const void *	text,
		size_t	byteLength,
		SkTextEncoding	encoding,
		SkGlyphID	glyphs[],
		int	maxGlyphCount
	)		const

Converts text into glyph indices. Returns the number of glyph indices represented by text. SkTextEncoding specifies how text represents characters or glyphs. glyphs may be nullptr, to compute the glyph count.

Does not check text for valid character codes or valid glyph indices.

If byteLength equals zero, returns zero. If byteLength includes a partial character, the partial character is ignored.

If encoding is SkTextEncoding::kUTF8 and text contains an invalid UTF-8 sequence, zero is returned.

When encoding is SkTextEncoding::kUTF8, SkTextEncoding::kUTF16, or SkTextEncoding::kUTF32; then each Unicode codepoint is mapped to a single glyph. This function uses the default character-to-glyph mapping from the SkTypeface and maps characters not found in the SkTypeface to zero.

If maxGlyphCount is not sufficient to store all the glyphs, no glyphs are copied. The total glyph count is returned for subsequent buffer reallocation.

Parameters

text	character storage encoded with SkTextEncoding
byteLength	length of character storage in bytes
glyphs	storage for glyph indices; may be nullptr
maxGlyphCount	storage capacity

Returns: number of glyphs represented by text of length byteLength

Definition at line 181 of file SkFont.cpp.

                                                                      {
    return this->getTypeface()->textToGlyphs(text, byteLength, encoding,
                                             glyphs, maxGlyphCount);
}

◆ unicharsToGlyphs()

void SkFont::unicharsToGlyphs	(	const SkUnichar	uni[],
		int	count,
		SkGlyphID	glyphs[]
	)		const

Definition at line 177 of file SkFont.cpp.

                                                                                        {
    this->getTypeface()->unicharsToGlyphs(uni, count, glyphs);
}

◆ unicharToGlyph()

SkGlyphID SkFont::unicharToGlyph ( SkUnichar uni ) const

Returns glyph index for Unicode character.

If the character is not supported by the SkTypeface, returns 0.

Parameters

uni	Unicode character

Returns: glyph index

Definition at line 173 of file SkFont.cpp.

                                                    {
    return this->getTypeface()->unicharToGlyph(uni);
}

Friends And Related Symbol Documentation

◆ SkFontPriv

friend class SkFontPriv

friend

Definition at line 533 of file SkFont.h.

◆ SkGlyphRunListPainterCPU

friend class SkGlyphRunListPainterCPU

friend

Definition at line 534 of file SkFont.h.

◆ SkRemoteGlyphCacheTest

friend class SkRemoteGlyphCacheTest

friend

Definition at line 536 of file SkFont.h.

◆ SkStrikeSpec

friend class SkStrikeSpec

friend

Definition at line 535 of file SkFont.h.

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

third_party/skia/include/core/SkFont.h
third_party/skia/src/core/SkFont.cpp
third_party/skia/src/core/SkTextBlob.cpp

Public Types

Public Member Functions

Friends

Detailed Description

Member Typedef Documentation

◆ sk_is_trivially_relocatable

Member Enumeration Documentation

◆ Edging

Constructor & Destructor Documentation

◆ SkFont() [1/4]

◆ SkFont() [2/4]

◆ SkFont() [3/4]

◆ SkFont() [4/4]

Member Function Documentation

◆ countText()

◆ dump()

◆ getBounds()

◆ getEdging()

◆ getHinting()

◆ getIntercepts()

◆ getMetrics()

◆ getPath()

◆ getPaths()

◆ getPos()

◆ getScaleX()

◆ getSize()

◆ getSkewX()

◆ getSpacing()

◆ getTypeface()

◆ getWidths() [1/3]

◆ getWidths() [2/3]

◆ getWidths() [3/3]

◆ getWidthsBounds()

◆ getXPos()

◆ isBaselineSnap()

◆ isEmbeddedBitmaps()

◆ isEmbolden()

◆ isForceAutoHinting()

◆ isLinearMetrics()

◆ isSubpixel()

◆ makeWithSize()

◆ measureText() [1/2]

◆ measureText() [2/2]

◆ operator!=()

◆ operator==()

◆ refTypeface()

◆ setBaselineSnap()

◆ setEdging()

◆ setEmbeddedBitmaps()

◆ setEmbolden()

◆ setForceAutoHinting()

◆ setHinting()

◆ setLinearMetrics()

◆ setScaleX()

◆ setSize()

◆ setSkewX()

◆ setSubpixel()

◆ setTypeface()

◆ textToGlyphs()

◆ unicharsToGlyphs()

◆ unicharToGlyph()

Friends And Related Symbol Documentation

◆ SkFontPriv

◆ SkGlyphRunListPainterCPU

◆ SkRemoteGlyphCacheTest

◆ SkStrikeSpec