SkFontPriv Class Reference

#include <SkFontPriv.h>

Static Public Member Functions
static SkMatrix	MakeTextMatrix (SkScalar size, SkScalar scaleX, SkScalar skewX)
static SkMatrix	MakeTextMatrix (const SkFont &font)
static void	ScaleFontMetrics (SkFontMetrics *, SkScalar)
static SkRect	GetFontBounds (const SkFont &)
static SkScalar	ApproximateTransformedTextSize (const SkFont &font, const SkMatrix &matrix, const SkPoint &textLocation)
static bool	IsFinite (const SkFont &font)
static int	CountTextElements (const void *text, size_t byteLength, SkTextEncoding)
static void	GlyphsToUnichars (const SkFont &, const uint16_t glyphs[], int count, SkUnichar[])
static void	Flatten (const SkFont &, SkWriteBuffer &buffer)
static bool	Unflatten (SkFont *, SkReadBuffer &buffer)
static uint8_t	Flags (const SkFont &font)

Static Public Attributes
static constexpr int	kCanonicalTextSizeForPaths = 64

Detailed Description

Definition at line 20 of file SkFontPriv.h.

Member Function Documentation

ApproximateTransformedTextSize()

SkScalar SkFontPriv::ApproximateTransformedTextSize ( const SkFont &  font, const SkMatrix &  matrix, const SkPoint &  textLocation  )

static

Return the approximate largest dimension of typical text when transformed by the matrix.

Parameters

matrix	used to transform size
textLocation	location of the text prior to matrix transformation. Used if the matrix has perspective.

Returns

typical largest dimension

Definition at line 366 of file SkFont.cpp.

                                                                                 {
    if (!matrix.hasPerspective()) {
        return font.getSize() * matrix.getMaxScale();
    } else {
        // approximate the scale since we can't get it directly from the matrix
        SkScalar maxScaleSq = SkMatrixPriv::DifferentialAreaScale(matrix, textLocation);
        if (SkIsFinite(maxScaleSq) && !SkScalarNearlyZero(maxScaleSq)) {
            return font.getSize() * SkScalarSqrt(maxScaleSq);
        } else {
            return -font.getSize();
        }
    }
}

CountTextElements()

int SkFontPriv::CountTextElements ( const void *  text, size_t  byteLength, SkTextEncoding  encoding  )

static

Definition at line 381 of file SkFont.cpp.

                                                                                              {
    switch (encoding) {
        case SkTextEncoding::kUTF8:
            return SkUTF::CountUTF8(reinterpret_cast<const char*>(text), byteLength);
        case SkTextEncoding::kUTF16:
            return SkUTF::CountUTF16(reinterpret_cast<const uint16_t*>(text), byteLength);
        case SkTextEncoding::kUTF32:
            return byteLength >> 2;
        case SkTextEncoding::kGlyphID:
            return byteLength >> 1;
    }
    SkASSERT(false);
    return 0;
}

Flags()

static uint8_t SkFontPriv::Flags ( const SkFont &  font )

inlinestatic

Definition at line 90 of file SkFontPriv.h.

{ return font.fFlags; }

Flatten()

void SkFontPriv::Flatten ( const SkFont &  font, SkWriteBuffer &  buffer  )

static

Definition at line 48 of file SkFont_serial.cpp.

                                                                  {
    SkASSERT(font.fFlags <= SkFont::kAllFlags);
    SkASSERT((font.fFlags & ~kMask_For_Flags) == 0);
    SkASSERT((font.fEdging & ~kMask_For_Edging) == 0);
    SkASSERT((font.fHinting & ~kMask_For_Hinting) == 0);
 
    uint32_t packed = 0;
    packed |= font.fFlags << kShift_For_Flags;
    packed |= font.fEdging << kShift_For_Edging;
    packed |= font.fHinting << kShift_For_Hinting;
 
    if (scalar_is_byte(font.fSize)) {
        packed |= kSize_Is_Byte_Bit;
        packed |= (int)font.fSize << kShift_for_Size;
    }
    if (font.fScaleX != 1) {
        packed |= kHas_ScaleX_Bit;
    }
    if (font.fSkewX != 0) {
        packed |= kHas_SkewX_Bit;
    }
    if (font.fTypeface) {
        packed |= kHas_Typeface_Bit;
    }
 
    buffer.write32(packed);
    if (!(packed & kSize_Is_Byte_Bit)) {
        buffer.writeScalar(font.fSize);
    }
    if (packed & kHas_ScaleX_Bit) {
        buffer.writeScalar(font.fScaleX);
    }
    if (packed & kHas_SkewX_Bit) {
        buffer.writeScalar(font.fSkewX);
    }
    if (packed & kHas_Typeface_Bit) {
        buffer.writeTypeface(font.fTypeface.get());
    }
}

GetFontBounds()

SkRect SkFontPriv::GetFontBounds ( const SkFont &  font )

static

Returns the union of bounds of all glyphs. Returned dimensions are computed by font manager from font data, ignoring SkPaint::Hinting. Includes font metrics, but not fake bold or SkPathEffect.

If text size is large, text scale is one, and text skew is zero, returns the bounds as: { SkFontMetrics::fXMin, SkFontMetrics::fTop, SkFontMetrics::fXMax, SkFontMetrics::fBottom }.

Returns

union of bounds of all glyphs

Definition at line 354 of file SkFont.cpp.

                                                   {
    SkMatrix m;
    m.setScale(font.getSize() * font.getScaleX(), font.getSize());
    m.postSkew(font.getSkewX(), 0);
 
    SkTypeface* typeface = font.getTypeface();
 
    SkRect bounds;
    m.mapRect(&bounds, typeface->getBounds());
    return bounds;
}

GlyphsToUnichars()

void SkFontPriv::GlyphsToUnichars ( const SkFont &  font, const uint16_t  glyphs[], int  count, SkUnichar  text[]  )

static

Definition at line 396 of file SkFont.cpp.

                                                    {
    if (count <= 0) {
        return;
    }
 
    auto typeface = font.getTypeface();
    const unsigned numGlyphsInTypeface = typeface->countGlyphs();
    AutoTArray<SkUnichar> unichars(static_cast<size_t>(numGlyphsInTypeface));
    typeface->getGlyphToUnicodeMap(unichars.get());
 
    for (int i = 0; i < count; ++i) {
        unsigned id = glyphs[i];
        text[i] = (id < numGlyphsInTypeface) ? unichars[id] : 0xFFFD;
    }
}

IsFinite()

static bool SkFontPriv::IsFinite ( const SkFont &  font )

inlinestatic

Definition at line 78 of file SkFontPriv.h.

                                             {
        return SkIsFinite(font.getSize(), font.getScaleX(), font.getSkewX());
    }

MakeTextMatrix() [1/2]

static SkMatrix SkFontPriv::MakeTextMatrix ( const SkFont &  font )

inlinestatic

Definition at line 49 of file SkFontPriv.h.

                                                       {
        return MakeTextMatrix(font.getSize(), font.getScaleX(), font.getSkewX());
    }

MakeTextMatrix() [2/2]

static SkMatrix SkFontPriv::MakeTextMatrix ( SkScalar  size, SkScalar  scaleX, SkScalar  skewX  )

inlinestatic

Return a matrix that applies the paint's text values: size, scale, skew

Definition at line 41 of file SkFontPriv.h.

                                                                                   {
        SkMatrix m = SkMatrix::Scale(size * scaleX, size);
        if (skewX) {
            m.postSkew(skewX, 0);
        }
        return m;
    }

ScaleFontMetrics()

void SkFontPriv::ScaleFontMetrics ( SkFontMetrics *  metrics, SkScalar  scale  )

static

Definition at line 336 of file SkFont.cpp.

                                                                        {
    metrics->fTop *= scale;
    metrics->fAscent *= scale;
    metrics->fDescent *= scale;
    metrics->fBottom *= scale;
    metrics->fLeading *= scale;
    metrics->fAvgCharWidth *= scale;
    metrics->fMaxCharWidth *= scale;
    metrics->fXMin *= scale;
    metrics->fXMax *= scale;
    metrics->fXHeight *= scale;
    metrics->fCapHeight *= scale;
    metrics->fUnderlineThickness *= scale;
    metrics->fUnderlinePosition *= scale;
    metrics->fStrikeoutThickness *= scale;
    metrics->fStrikeoutPosition *= scale;
}

Unflatten()

bool SkFontPriv::Unflatten ( SkFont *  font, SkReadBuffer &  buffer  )

static

Definition at line 88 of file SkFont_serial.cpp.

                                                             {
    const uint32_t packed = buffer.read32();
 
    if (packed & kSize_Is_Byte_Bit) {
        font->fSize = (packed >> kShift_for_Size) & kMask_For_Size;
    } else {
        font->fSize = buffer.readScalar();
    }
    if (packed & kHas_ScaleX_Bit) {
        font->fScaleX = buffer.readScalar();
    }
    if (packed & kHas_SkewX_Bit) {
        font->fSkewX = buffer.readScalar();
    }
    if (packed & kHas_Typeface_Bit) {
        font->setTypeface(buffer.readTypeface());
    }
 
    SkASSERT(SkFont::kAllFlags <= kMask_For_Flags);
    // we & with kAllFlags, to clear out any unknown flag bits
    font->fFlags = SkToU8((packed >> kShift_For_Flags) & SkFont::kAllFlags);
 
    unsigned edging = (packed >> kShift_For_Edging) & kMask_For_Edging;
    if (edging > (unsigned)SkFont::Edging::kSubpixelAntiAlias) {
        edging = 0;
    }
    font->fEdging = SkToU8(edging);
 
    unsigned hinting = (packed >> kShift_For_Hinting) & kMask_For_Hinting;
    if (hinting > (unsigned)SkFontHinting::kFull) {
        hinting = 0;
    }
    font->fHinting = SkToU8(hinting);
 
    return buffer.isValid();
}

Member Data Documentation

kCanonicalTextSizeForPaths

constexpr int SkFontPriv::kCanonicalTextSizeForPaths = 64

inlinestaticconstexpr

Definition at line 36 of file SkFontPriv.h.

---

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

• third_party/skia/src/core/SkFontPriv.h
• third_party/skia/src/core/SkFont.cpp
• third_party/skia/src/core/SkFont_serial.cpp