#include <SkTypeface_FreeType.h>

Inheritance diagram for SkTypeface_FreeType:

Classes
class	FaceRec

Public Member Functions
std::unique_ptr< SkFontData >	makeFontData () const

FaceRec *	getFaceRec () const

Public Member Functions inherited from SkTypeface
SkFontStyle	fontStyle () const

bool	isBold () const

bool	isItalic () const

bool	isFixedPitch () const

int	getVariationDesignPosition (SkFontArguments::VariationPosition::Coordinate coordinates[], int coordinateCount) const

int	getVariationDesignParameters (SkFontParameters::Variation::Axis parameters[], int parameterCount) const

SkTypefaceID	uniqueID () const

sk_sp< SkTypeface >	makeClone (const SkFontArguments &) const

void	serialize (SkWStream *, SerializeBehavior=SerializeBehavior::kIncludeDataIfLocal) const

sk_sp< SkData >	serialize (SerializeBehavior=SerializeBehavior::kIncludeDataIfLocal) const

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

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

SkGlyphID	unicharToGlyph (SkUnichar unichar) const

int	countGlyphs () const

int	countTables () const

int	getTableTags (SkFontTableTag tags[]) const

size_t	getTableSize (SkFontTableTag) const

size_t	getTableData (SkFontTableTag tag, size_t offset, size_t length, void *data) const

sk_sp< SkData >	copyTableData (SkFontTableTag tag) const

int	getUnitsPerEm () const

bool	getKerningPairAdjustments (const SkGlyphID glyphs[], int count, int32_t adjustments[]) const

LocalizedStrings *	createFamilyNameIterator () const

void	getFamilyName (SkString *name) const

bool	getPostScriptName (SkString *name) const

std::unique_ptr< SkStreamAsset >	openStream (int *ttcIndex) const

std::unique_ptr< SkStreamAsset >	openExistingStream (int *ttcIndex) const

std::unique_ptr< SkScalerContext >	createScalerContext (const SkScalerContextEffects &, const SkDescriptor *) const

SkRect	getBounds () const

void	filterRec (SkScalerContextRec *rec) const

void	getFontDescriptor (SkFontDescriptor desc, bool isLocal) const

void *	internal_private_getCTFontRef () const

Public Member Functions inherited from SkWeakRefCnt
	SkWeakRefCnt ()

	~SkWeakRefCnt () override

bool	try_ref () const

void	weak_ref () const

void	weak_unref () const

bool	weak_expired () const

Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()

virtual	~SkRefCntBase ()

bool	unique () const

void	ref () const

void	unref () const

Static Public Member Functions
static int	GetUnitsPerEm (FT_Face face)

static sk_sp< SkTypeface >	MakeFromStream (std::unique_ptr< SkStreamAsset >, const SkFontArguments &)

Static Public Member Functions inherited from SkTypeface
static bool	Equal (const SkTypeface facea, const SkTypeface faceb)

static sk_sp< SkTypeface >	MakeEmpty ()

static sk_sp< SkTypeface >	MakeDeserialize (SkStream *, sk_sp< SkFontMgr > lastResortMgr)

static void	Register (FactoryId id, sk_sp< SkTypeface >(*make)(std::unique_ptr< SkStreamAsset >, const SkFontArguments &))

Static Public Attributes
static constexpr SkTypeface::FactoryId	FactoryId = SkSetFourByteTag('f','r','e','e')

Protected Member Functions
	SkTypeface_FreeType (const SkFontStyle &style, bool isFixedPitch)

	~SkTypeface_FreeType () override

std::unique_ptr< SkFontData >	cloneFontData (const SkFontArguments &, SkFontStyle *style) const

std::unique_ptr< SkScalerContext >	onCreateScalerContext (const SkScalerContextEffects &, const SkDescriptor *) const override

void	onFilterRec (SkScalerContextRec *) const override

void	getGlyphToUnicodeMap (SkUnichar *) const override

std::unique_ptr< SkAdvancedTypefaceMetrics >	onGetAdvancedMetrics () const override

void	getPostScriptGlyphNames (SkString *dstArray) const override

bool	onGetPostScriptName (SkString *) const override

int	onGetUPEM () const override

bool	onGetKerningPairAdjustments (const uint16_t glyphs[], int count, int32_t adjustments[]) const override

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

int	onCountGlyphs () const override

LocalizedStrings *	onCreateFamilyNameIterator () const override

bool	onGlyphMaskNeedsCurrentColor () const override

int	onGetVariationDesignPosition (SkFontArguments::VariationPosition::Coordinate coordinates[], int coordinateCount) const override

int	onGetVariationDesignParameters (SkFontParameters::Variation::Axis parameters[], int parameterCount) const override

int	onGetTableTags (SkFontTableTag tags[]) const override

size_t	onGetTableData (SkFontTableTag, size_t offset, size_t length, void *data) const override

sk_sp< SkData >	onCopyTableData (SkFontTableTag) const override

virtual std::unique_ptr< SkFontData >	onMakeFontData () const =0

Protected Member Functions inherited from SkTypeface
	SkTypeface (const SkFontStyle &style, bool isFixedPitch=false)

	~SkTypeface () override

virtual sk_sp< SkTypeface >	onMakeClone (const SkFontArguments &) const =0

void	setIsFixedPitch (bool isFixedPitch)

void	setFontStyle (SkFontStyle style)

virtual std::unique_ptr< SkStreamAsset >	onOpenStream (int *ttcIndex) const =0

virtual std::unique_ptr< SkStreamAsset >	onOpenExistingStream (int *ttcIndex) const

virtual void	onGetFontDescriptor (SkFontDescriptor , bool isLocal) const =0

virtual void	onCharsToGlyphs (const SkUnichar *chars, int count, SkGlyphID glyphs[]) const =0

virtual void	onGetFamilyName (SkString *familyName) const =0

virtual bool	onComputeBounds (SkRect *) const

virtual void *	onGetCTFontRef () const

Protected Member Functions inherited from SkWeakRefCnt
virtual void	weak_dispose () const

Static Protected Member Functions
static void	FontDataPaletteToDescriptorPalette (const SkFontData &, SkFontDescriptor *)

Additional Inherited Members
Public Types inherited from SkTypeface
enum class	SerializeBehavior { kDoIncludeData , kDontIncludeData , kIncludeDataIfLocal }

using	FactoryId = SkFourByteTag

Detailed Description

Definition at line 32 of file SkTypeface_FreeType.h.

Constructor & Destructor Documentation

◆ SkTypeface_FreeType()

SkTypeface_FreeType::SkTypeface_FreeType	(	const SkFontStyle &	style,
		bool	isFixedPitch
	)

protected

Definition at line 1706 of file SkFontHost_FreeType.cpp.

1707 : INHERITED(style, isFixedPitch)

1708{}

SkTypeface::isFixedPitch

bool isFixedPitch() const

Definition SkTypeface.h:68

◆ ~SkTypeface_FreeType()

SkTypeface_FreeType::~SkTypeface_FreeType ( )

overrideprotected

Definition at line 1710 of file SkFontHost_FreeType.cpp.

                                          {
    if (fFaceRec) {
        SkAutoMutexExclusive ac(f_t_mutex());
        fFaceRec.reset();
    }
}

Member Function Documentation

◆ cloneFontData()

std::unique_ptr< SkFontData > SkTypeface_FreeType::cloneFontData	(	const SkFontArguments &	args,
		SkFontStyle *	style
	)		const

protected

Definition at line 749 of file SkFontHost_FreeType.cpp.

                                                                                         {
    AutoFTAccess fta(this);
    FT_Face face = fta.face();
    if (!face) {
        return nullptr;
    }
 
    SkFontScanner::AxisDefinitions axisDefinitions;
    if (!SkFontScanner_FreeType::GetAxes(face, &axisDefinitions)) {
        return nullptr;
    }
    int axisCount = axisDefinitions.size();
 
    AutoSTMalloc<4, SkFontArguments::VariationPosition::Coordinate> currentPosition(axisCount);
    int currentAxisCount = GetVariationDesignPosition(fta, currentPosition, axisCount);
 
    SkString name;
    AutoSTMalloc<4, SkFixed> axisValues(axisCount);
    SkFontScanner_FreeType::computeAxisValues(
            axisDefinitions,
            args.getVariationDesignPosition(),
            axisValues,
            name, style,
            currentAxisCount == axisCount ? currentPosition.get() : nullptr);
 
    int ttcIndex;
    std::unique_ptr<SkStreamAsset> stream = this->openStream(&ttcIndex);
 
    return std::make_unique<SkFontData>(std::move(stream),
                                        ttcIndex,
                                        args.getPalette().index,
                                        axisValues.get(),
                                        axisCount,
                                        args.getPalette().overrides,
                                        args.getPalette().overrideCount);
}

◆ FontDataPaletteToDescriptorPalette()

void SkTypeface_FreeType::FontDataPaletteToDescriptorPalette	(	const SkFontData &	fontData,
		SkFontDescriptor *	desc
	)

staticprotected

Utility to fill out the SkFontDescriptor palette information from the SkFontData.

Definition at line 1941 of file SkFontHost_FreeType.cpp.

                                                                                     {
    desc->setPaletteIndex(fontData.getPaletteIndex());
    int paletteOverrideCount = fontData.getPaletteOverrideCount();
    auto overrides = desc->setPaletteEntryOverrides(paletteOverrideCount);
    for (int i = 0; i < paletteOverrideCount; ++i) {
        overrides[i] = fontData.getPaletteOverrides()[i];
    }
}

◆ getFaceRec()

SkTypeface_FreeType::FaceRec * SkTypeface_FreeType::getFaceRec ( ) const

Definition at line 1931 of file SkFontHost_FreeType.cpp.

                                                                  {
    f_t_mutex().assertHeld();
    fFTFaceOnce([this]{ fFaceRec = SkTypeface_FreeType::FaceRec::Make(this); });
    return fFaceRec.get();
}

◆ getGlyphToUnicodeMap()

void SkTypeface_FreeType::getGlyphToUnicodeMap ( SkUnichar * dstArray ) const

overrideprotectedvirtual

Implements SkTypeface.

Definition at line 620 of file SkFontHost_FreeType.cpp.

                                                                        {
    AutoFTAccess fta(this);
    FT_Face face = fta.face();
    if (!face) {
        return;
    }
 
    FT_Long numGlyphs = face->num_glyphs;
    if (!dstArray) { SkASSERT(numGlyphs == 0); }
    sk_bzero(dstArray, sizeof(SkUnichar) * numGlyphs);
 
    FT_UInt glyphIndex;
    SkUnichar charCode = FT_Get_First_Char(face, &glyphIndex);
    while (glyphIndex) {
        SkASSERT(glyphIndex < SkToUInt(numGlyphs));
        // Use the first character that maps to this glyphID. https://crbug.com/359065
        if (0 == dstArray[glyphIndex]) {
            dstArray[glyphIndex] = charCode;
        }
        charCode = FT_Get_Next_Char(face, charCode, &glyphIndex);
    }
}

◆ getPostScriptGlyphNames()

void SkTypeface_FreeType::getPostScriptGlyphNames ( SkString * dstArray ) const

overrideprotectedvirtual

Implements SkTypeface.

Definition at line 643 of file SkFontHost_FreeType.cpp.

                                                                          {
    AutoFTAccess fta(this);
    FT_Face face = fta.face();
    if (!face) {
        return;
    }
 
    FT_Long numGlyphs = face->num_glyphs;
    if (!dstArray) { SkASSERT(numGlyphs == 0); }
 
    if (FT_HAS_GLYPH_NAMES(face)) {
        for (int gID = 0; gID < numGlyphs; ++gID) {
            char glyphName[128];  // PS limit for names is 127 bytes.
            FT_Get_Glyph_Name(face, gID, glyphName, 128);
            dstArray[gID] = glyphName;
        }
    }
}

◆ GetUnitsPerEm()

int SkTypeface_FreeType::GetUnitsPerEm ( FT_Face face )

static

Fetch units/EM from "head" table if needed (ie for bitmap fonts)

Definition at line 817 of file SkFontHost_FreeType.cpp.

                                                   {
    SkASSERT(face);
 
    SkScalar upem = SkIntToScalar(face->units_per_EM);
    // At least some versions of FreeType set face->units_per_EM to 0 for bitmap only fonts.
    if (upem == 0) {
        TT_Header* ttHeader = (TT_Header*)FT_Get_Sfnt_Table(face, ft_sfnt_head);
        if (ttHeader) {
            upem = SkIntToScalar(ttHeader->Units_Per_EM);
        }
    }
    return upem;
}

◆ makeFontData()

std::unique_ptr< SkFontData > SkTypeface_FreeType::makeFontData ( ) const

Return the font data, or nullptr on failure.

Definition at line 1937 of file SkFontHost_FreeType.cpp.

                                                                  {
    return this->onMakeFontData();
}

◆ MakeFromStream()

sk_sp< SkTypeface > SkTypeface_FreeType::MakeFromStream	(	std::unique_ptr< SkStreamAsset >	stream,
		const SkFontArguments &	args
	)

static

Definition at line 1999 of file SkFontHost_FreeType.cpp.

                                                                                   {
    static SkFontScanner_FreeType scanner;
    bool isFixedPitch;
    SkFontStyle style;
    SkString name;
    SkFontScanner::AxisDefinitions axisDefinitions;
    if (!scanner.scanInstance(stream.get(), args.getCollectionIndex(), 0,
                              &name, &style, &isFixedPitch, &axisDefinitions)) {
        return nullptr;
    }
 
    const SkFontArguments::VariationPosition position = args.getVariationDesignPosition();
    AutoSTMalloc<4, SkFixed> axisValues(axisDefinitions.size());
    SkFontScanner_FreeType::computeAxisValues(axisDefinitions, position, axisValues, name, &style);
 
    auto data = std::make_unique<SkFontData>(
        std::move(stream), args.getCollectionIndex(), args.getPalette().index,
        axisValues.get(), axisDefinitions.size(),
        args.getPalette().overrides, args.getPalette().overrideCount);
    return sk_make_sp<SkTypeface_FreeTypeStream>(std::move(data), name, style, isFixedPitch);
}

◆ onCharsToGlyphs()

void SkTypeface_FreeType::onCharsToGlyphs	(	const SkUnichar	uni[],
		int	count,
		SkGlyphID	glyphs[]
	)		const

overrideprotected

Definition at line 1720 of file SkFontHost_FreeType.cpp.

                                                                    {
    // Try the cache first, *before* accessing freetype lib/face, as that
    // can be very slow. If we do need to compute a new glyphID, then
    // access those freetype objects and continue the loop.
 
    int i;
    {
        // Optimistically use a shared lock.
        SkAutoSharedMutexShared ama(fC2GCacheMutex);
        for (i = 0; i < count; ++i) {
            int index = fC2GCache.findGlyphIndex(uni[i]);
            if (index < 0) {
                break;
            }
            glyphs[i] = SkToU16(index);
        }
        if (i == count) {
            // we're done, no need to access the freetype objects
            return;
        }
    }
 
    // Need to add more so grab an exclusive lock.
    SkAutoSharedMutexExclusive ama(fC2GCacheMutex);
    AutoFTAccess fta(this);
    FT_Face face = fta.face();
    if (!face) {
        sk_bzero(glyphs, count * sizeof(glyphs[0]));
        return;
    }
 
    for (; i < count; ++i) {
        SkUnichar c = uni[i];
        int index = fC2GCache.findGlyphIndex(c);
        if (index >= 0) {
            glyphs[i] = SkToU16(index);
        } else {
            glyphs[i] = SkToU16(FT_Get_Char_Index(face, c));
            fC2GCache.insertCharAndGlyph(~index, c, glyphs[i]);
        }
    }
 
    if (fC2GCache.count() > kMaxC2GCacheCount) {
        fC2GCache.reset();
    }
}

◆ onCopyTableData()

sk_sp< SkData > SkTypeface_FreeType::onCopyTableData ( SkFontTableTag tag ) const

overrideprotectedvirtual

Reimplemented from SkTypeface.

Definition at line 1904 of file SkFontHost_FreeType.cpp.

                                                                           {
    AutoFTAccess fta(this);
    FT_Face face = fta.face();
    if (!face) {
        return nullptr;
    }
 
    FT_ULong tableLength = 0;
    FT_Error error;
 
    // When 'length' is 0 it is overwritten with the full table length; 'offset' is ignored.
    error = FT_Load_Sfnt_Table(face, tag, 0, nullptr, &tableLength);
    if (error) {
        return nullptr;
    }
 
    sk_sp<SkData> data = SkData::MakeUninitialized(tableLength);
    if (data) {
        error = FT_Load_Sfnt_Table(face, tag, 0,
                                   reinterpret_cast<FT_Byte*>(data->writable_data()), &tableLength);
        if (error) {
            data.reset();
        }
    }
    return data;
}

◆ onCountGlyphs()

int SkTypeface_FreeType::onCountGlyphs ( ) const

overrideprotectedvirtual

Implements SkTypeface.

Definition at line 1768 of file SkFontHost_FreeType.cpp.

                                             {
    AutoFTAccess fta(this);
    FT_Face face = fta.face();
    return face ? face->num_glyphs : 0;
}

◆ onCreateFamilyNameIterator()

SkTypeface::LocalizedStrings * SkTypeface_FreeType::onCreateFamilyNameIterator ( ) const

overrideprotectedvirtual

Returns an iterator over the family names in the font.

Implements SkTypeface.

Definition at line 1774 of file SkFontHost_FreeType.cpp.

                                                                                  {
    sk_sp<SkTypeface::LocalizedStrings> nameIter =
        SkOTUtils::LocalizedStrings_NameTable::MakeForFamilyNames(*this);
    if (!nameIter) {
        SkString familyName;
        this->getFamilyName(&familyName);
        SkString language("und"); //undetermined
        nameIter = sk_make_sp<SkOTUtils::LocalizedStrings_SingleName>(familyName, language);
    }
    return nameIter.release();
}

◆ onCreateScalerContext()

std::unique_ptr< SkScalerContext > SkTypeface_FreeType::onCreateScalerContext	(	const SkScalerContextEffects &	effects,
		const SkDescriptor *	desc
	)		const

overrideprotectedvirtual

Implements SkTypeface.

Definition at line 692 of file SkFontHost_FreeType.cpp.

{
    auto c = std::make_unique<SkScalerContext_FreeType>(
            sk_ref_sp(const_cast<SkTypeface_FreeType*>(this)), effects, desc);
    if (c->success()) {
        return c;
    }
    return SkScalerContext::MakeEmpty(
            sk_ref_sp(const_cast<SkTypeface_FreeType*>(this)), effects, desc);
}

◆ onFilterRec()

void SkTypeface_FreeType::onFilterRec ( SkScalerContextRec * rec ) const

overrideprotectedvirtual

Implements SkTypeface.

Definition at line 787 of file SkFontHost_FreeType.cpp.

                                                                   {
    //BOGUS: http://code.google.com/p/chromium/issues/detail?id=121119
    //Cap the requested size as larger sizes give bogus values.
    //Remove when http://code.google.com/p/skia/issues/detail?id=554 is fixed.
    //Note that this also currently only protects against large text size requests,
    //the total matrix is not taken into account here.
    if (rec->fTextSize > SkIntToScalar(1 << 14)) {
        rec->fTextSize = SkIntToScalar(1 << 14);
    }
 
    SkFontHinting h = rec->getHinting();
    if (SkFontHinting::kFull == h && !isLCD(*rec)) {
        // collapse full->normal hinting if we're not doing LCD
        h = SkFontHinting::kNormal;
    }
 
    // rotated text looks bad with hinting, so we disable it as needed
    if (!isAxisAligned(*rec)) {
        h = SkFontHinting::kNone;
    }
    rec->setHinting(h);
 
#ifndef SK_GAMMA_APPLY_TO_A8
    if (!isLCD(*rec)) {
        // SRGBTODO: Is this correct? Do we want contrast boost?
        rec->ignorePreBlend();
    }
#endif
}

◆ onGetAdvancedMetrics()

std::unique_ptr< SkAdvancedTypefaceMetrics > SkTypeface_FreeType::onGetAdvancedMetrics ( ) const

overrideprotectedvirtual

Implements SkTypeface.

Definition at line 549 of file SkFontHost_FreeType.cpp.

                                                                                         {
    AutoFTAccess fta(this);
    FT_Face face = fta.face();
    if (!face) {
        return nullptr;
    }
 
    std::unique_ptr<SkAdvancedTypefaceMetrics> info(new SkAdvancedTypefaceMetrics);
    info->fPostScriptName.set(FT_Get_Postscript_Name(face));
 
    if (FT_HAS_MULTIPLE_MASTERS(face)) {
        info->fFlags |= SkAdvancedTypefaceMetrics::kVariable_FontFlag;
    }
    if (!canEmbed(face)) {
        info->fFlags |= SkAdvancedTypefaceMetrics::kNotEmbeddable_FontFlag;
    }
    if (!canSubset(face)) {
        info->fFlags |= SkAdvancedTypefaceMetrics::kNotSubsettable_FontFlag;
    }
 
    info->fType = get_font_type(face);
    if ((info->fType == SkAdvancedTypefaceMetrics::kTrueType_Font ||
         info->fType == SkAdvancedTypefaceMetrics::kCFF_Font) &&
        !is_opentype_font_data_standard_format(*this))
    {
        info->fFlags |= SkAdvancedTypefaceMetrics::kAltDataFormat_FontFlag;
    }
 
    info->fStyle = (SkAdvancedTypefaceMetrics::StyleFlags)0;
    if (FT_IS_FIXED_WIDTH(face)) {
        info->fStyle |= SkAdvancedTypefaceMetrics::kFixedPitch_Style;
    }
    if (face->style_flags & FT_STYLE_FLAG_ITALIC) {
        info->fStyle |= SkAdvancedTypefaceMetrics::kItalic_Style;
    }
 
    PS_FontInfoRec psFontInfo;
    TT_Postscript* postTable;
    if (FT_Get_PS_Font_Info(face, &psFontInfo) == 0) {
        info->fItalicAngle = psFontInfo.italic_angle;
    } else if ((postTable = (TT_Postscript*)FT_Get_Sfnt_Table(face, ft_sfnt_post)) != nullptr) {
        info->fItalicAngle = SkFixedFloorToInt(postTable->italicAngle);
    } else {
        info->fItalicAngle = 0;
    }
 
    info->fAscent = face->ascender;
    info->fDescent = face->descender;
 
    TT_PCLT* pcltTable;
    TT_OS2* os2Table;
    if ((pcltTable = (TT_PCLT*)FT_Get_Sfnt_Table(face, ft_sfnt_pclt)) != nullptr) {
        info->fCapHeight = pcltTable->CapHeight;
        uint8_t serif_style = pcltTable->SerifStyle & 0x3F;
        if (2 <= serif_style && serif_style <= 6) {
            info->fStyle |= SkAdvancedTypefaceMetrics::kSerif_Style;
        } else if (9 <= serif_style && serif_style <= 12) {
            info->fStyle |= SkAdvancedTypefaceMetrics::kScript_Style;
        }
    } else if (((os2Table = (TT_OS2*)FT_Get_Sfnt_Table(face, ft_sfnt_os2)) != nullptr) &&
               // sCapHeight is available only when version 2 or later.
               os2Table->version != 0xFFFF &&
               os2Table->version >= 2)
    {
        info->fCapHeight = os2Table->sCapHeight;
    }
    info->fBBox = SkIRect::MakeLTRB(face->bbox.xMin, face->bbox.yMax,
                                    face->bbox.xMax, face->bbox.yMin);
    return info;
}

◆ onGetKerningPairAdjustments()

bool SkTypeface_FreeType::onGetKerningPairAdjustments	(	const uint16_t	glyphs[],
		int	count,
		int32_t	adjustments[]
	)		const

overrideprotectedvirtual

Reimplemented from SkTypeface.

Definition at line 840 of file SkFontHost_FreeType.cpp.

                                                                              {
    AutoFTAccess fta(this);
    FT_Face face = fta.face();
    if (!face || !FT_HAS_KERNING(face)) {
        return false;
    }
 
    for (int i = 0; i < count - 1; ++i) {
        FT_Vector delta;
        FT_Error err = FT_Get_Kerning(face, glyphs[i], glyphs[i+1],
                                      FT_KERNING_UNSCALED, &delta);
        if (err) {
            return false;
        }
        adjustments[i] = delta.x;
    }
    return true;
}

◆ onGetPostScriptName()

bool SkTypeface_FreeType::onGetPostScriptName ( SkString * skPostScriptName ) const

overrideprotectedvirtual

Implements SkTypeface.

Definition at line 662 of file SkFontHost_FreeType.cpp.

                                                                              {
    AutoFTAccess fta(this);
    FT_Face face = fta.face();
    if (!face) {
        return false;
    }
 
    const char* ftPostScriptName = FT_Get_Postscript_Name(face);
    if (!ftPostScriptName) {
        return false;
    }
    if (skPostScriptName) {
        *skPostScriptName = ftPostScriptName;
    }
    return true;
}

◆ onGetTableData()

size_t SkTypeface_FreeType::onGetTableData	(	SkFontTableTag	tag,
		size_t	offset,
		size_t	length,
		void *	data
	)		const

overrideprotectedvirtual

Implements SkTypeface.

Definition at line 1872 of file SkFontHost_FreeType.cpp.

{
    AutoFTAccess fta(this);
    FT_Face face = fta.face();
    if (!face) {
        return 0;
    }
 
    FT_ULong tableLength = 0;
    FT_Error error;
 
    // When 'length' is 0 it is overwritten with the full table length; 'offset' is ignored.
    error = FT_Load_Sfnt_Table(face, tag, 0, nullptr, &tableLength);
    if (error) {
        return 0;
    }
 
    if (offset > tableLength) {
        return 0;
    }
    FT_ULong size = std::min((FT_ULong)length, tableLength - (FT_ULong)offset);
    if (data) {
        error = FT_Load_Sfnt_Table(face, tag, offset, reinterpret_cast<FT_Byte*>(data), &size);
        if (error) {
            return 0;
        }
    }
 
    return size;
}

◆ onGetTableTags()

int SkTypeface_FreeType::onGetTableTags ( SkFontTableTag tags[] ) const

overrideprotectedvirtual

Implements SkTypeface.

Definition at line 1842 of file SkFontHost_FreeType.cpp.

                                                                   {
    AutoFTAccess fta(this);
    FT_Face face = fta.face();
    if (!face) {
        return 0;
    }
 
    FT_ULong tableCount = 0;
    FT_Error error;
 
    // When 'tag' is nullptr, returns number of tables in 'length'.
    error = FT_Sfnt_Table_Info(face, 0, nullptr, &tableCount);
    if (error) {
        return 0;
    }
 
    if (tags) {
        for (FT_ULong tableIndex = 0; tableIndex < tableCount; ++tableIndex) {
            FT_ULong tableTag;
            FT_ULong tablelength;
            error = FT_Sfnt_Table_Info(face, tableIndex, &tableTag, &tablelength);
            if (error) {
                return 0;
            }
            tags[tableIndex] = static_cast<SkFontTableTag>(tableTag);
        }
    }
    return tableCount;
}

◆ onGetUPEM()

int SkTypeface_FreeType::onGetUPEM ( ) const

overrideprotectedvirtual

Implements SkTypeface.

Definition at line 831 of file SkFontHost_FreeType.cpp.

                                         {
    AutoFTAccess fta(this);
    FT_Face face = fta.face();
    if (!face) {
        return 0;
    }
    return GetUnitsPerEm(face);
}

◆ onGetVariationDesignParameters()

int SkTypeface_FreeType::onGetVariationDesignParameters	(	SkFontParameters::Variation::Axis	parameters[],
		int	parameterCount
	)		const

overrideprotectedvirtual

Implements SkTypeface.

Definition at line 1805 of file SkFontHost_FreeType.cpp.

{
    AutoFTAccess fta(this);
    FT_Face face = fta.face();
    if (!face) {
        return -1;
    }
 
    if (!(face->face_flags & FT_FACE_FLAG_MULTIPLE_MASTERS)) {
        return 0;
    }
 
    FT_MM_Var* variations = nullptr;
    if (FT_Get_MM_Var(face, &variations)) {
        return -1;
    }
    UniqueVoidPtr autoFreeVariations(variations);
 
    if (!parameters || parameterCount < SkToInt(variations->num_axis)) {
        return variations->num_axis;
    }
 
    for (FT_UInt i = 0; i < variations->num_axis; ++i) {
        parameters[i].tag = variations->axis[i].tag;
        parameters[i].min = SkFixedToScalar(variations->axis[i].minimum);
        parameters[i].def = SkFixedToScalar(variations->axis[i].def);
        parameters[i].max = SkFixedToScalar(variations->axis[i].maximum);
        FT_UInt flags = 0;
        bool hidden = !FT_Get_Var_Axis_Flags(variations, i, &flags) &&
                      (flags & FT_VAR_AXIS_FLAG_HIDDEN);
        parameters[i].setHidden(hidden);
    }
 
    return variations->num_axis;
}

◆ onGetVariationDesignPosition()

int SkTypeface_FreeType::onGetVariationDesignPosition	(	SkFontArguments::VariationPosition::Coordinate	coordinates[],
		int	coordinateCount
	)		const

overrideprotectedvirtual

Implements SkTypeface.

Definition at line 1798 of file SkFontHost_FreeType.cpp.

{
    AutoFTAccess fta(this);
    return GetVariationDesignPosition(fta, coordinates, coordinateCount);
}

◆ onGlyphMaskNeedsCurrentColor()

bool SkTypeface_FreeType::onGlyphMaskNeedsCurrentColor ( ) const

overrideprotectedvirtual

Implements SkTypeface.

Definition at line 1786 of file SkFontHost_FreeType.cpp.

                                                             {
    fGlyphMasksMayNeedCurrentColorOnce([this]{
        static constexpr SkFourByteTag COLRTag = SkSetFourByteTag('C', 'O', 'L', 'R');
        fGlyphMasksMayNeedCurrentColor = this->getTableSize(COLRTag) > 0;
#if defined(FT_CONFIG_OPTION_SVG)
        static constexpr SkFourByteTag SVGTag = SkSetFourByteTag('S', 'V', 'G', ' ');
        fGlyphMasksMayNeedCurrentColor |= this->getTableSize(SVGTag) > 0 ;
#endif  // FT_CONFIG_OPTION_SVG
    });
    return fGlyphMasksMayNeedCurrentColor;
}

◆ onMakeFontData()

virtual std::unique_ptr< SkFontData > SkTypeface_FreeType::onMakeFontData ( ) const

protectedpure virtual

Implemented in SkTypeface_FCI, SkTypeface_Empty, SkTypeface_File, SkTypeface_fontconfig, and SkTypeface_FreeTypeStream.

Member Data Documentation

◆ FactoryId

constexpr SkTypeface::FactoryId SkTypeface_FreeType::FactoryId = SkSetFourByteTag('f','r','e','e')

staticconstexpr

Definition at line 42 of file SkTypeface_FreeType.h.

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

third_party/skia/src/ports/SkTypeface_FreeType.h
third_party/skia/src/ports/SkFontHost_FreeType.cpp

Classes

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ SkTypeface_FreeType()

◆ ~SkTypeface_FreeType()

Member Function Documentation

◆ cloneFontData()

◆ FontDataPaletteToDescriptorPalette()

◆ getFaceRec()

◆ getGlyphToUnicodeMap()

◆ getPostScriptGlyphNames()

◆ GetUnitsPerEm()

◆ makeFontData()

◆ MakeFromStream()

◆ onCharsToGlyphs()

◆ onCopyTableData()

◆ onCountGlyphs()

◆ onCreateFamilyNameIterator()

◆ onCreateScalerContext()

◆ onFilterRec()

◆ onGetAdvancedMetrics()

◆ onGetKerningPairAdjustments()

◆ onGetPostScriptName()

◆ onGetTableData()

◆ onGetTableTags()

◆ onGetUPEM()

◆ onGetVariationDesignParameters()

◆ onGetVariationDesignPosition()

◆ onGlyphMaskNeedsCurrentColor()

◆ onMakeFontData()

Member Data Documentation

◆ FactoryId