#include <SkTypeface_fontations_priv.h>

Inheritance diagram for SkTypeface_Fontations:

Public Member Functions
const fontations_ffi::BridgeFontRef &	getBridgeFontRef ()

const fontations_ffi::BridgeNormalizedCoords &	getBridgeNormalizedCoords ()

const fontations_ffi::BridgeOutlineCollection &	getOutlines ()

SkSpan< const SkColor >	getPalette () 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 sk_sp< SkTypeface >	MakeFromData (sk_sp< SkData > fontData, const SkFontArguments &)

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', 'n', 't', 'a')

Protected Member Functions
std::unique_ptr< SkStreamAsset >	onOpenStream (int *ttcIndex) const override

sk_sp< SkTypeface >	onMakeClone (const SkFontArguments &args) const override

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

void	onFilterRec (SkScalerContextRec *) const override

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

void	onGetFontDescriptor (SkFontDescriptor , bool ) const override

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

int	onCountGlyphs () const override

void	getPostScriptGlyphNames (SkString *) const override

void	getGlyphToUnicodeMap (SkUnichar *) const override

int	onGetUPEM () const override

void	onGetFamilyName (SkString *familyName) const override

bool	onGetPostScriptName (SkString *) const override

SkTypeface::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, size_t, void *) const override

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< SkScalerContext >	onCreateScalerContext (const SkScalerContextEffects &, const SkDescriptor *) const =0

virtual void	onFilterRec (SkScalerContextRec *) const =0

virtual std::unique_ptr< SkAdvancedTypefaceMetrics >	onGetAdvancedMetrics () const =0

virtual void	getPostScriptGlyphNames (SkString *) const =0

virtual void	getGlyphToUnicodeMap (SkUnichar *dstArray) const =0

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

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

virtual bool	onGlyphMaskNeedsCurrentColor () const =0

virtual int	onGetVariationDesignPosition (SkFontArguments::VariationPosition::Coordinate coordinates[], int coordinateCount) const =0

virtual int	onGetVariationDesignParameters (SkFontParameters::Variation::Axis parameters[], int parameterCount) const =0

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

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

virtual int	onCountGlyphs () const =0

virtual int	onGetUPEM () const =0

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

virtual void	onGetFamilyName (SkString *familyName) const =0

virtual bool	onGetPostScriptName (SkString *) const =0

virtual LocalizedStrings *	onCreateFamilyNameIterator () const =0

virtual int	onGetTableTags (SkFontTableTag tags[]) const =0

virtual size_t	onGetTableData (SkFontTableTag, size_t offset, size_t length, void *data) const =0

virtual sk_sp< SkData >	onCopyTableData (SkFontTableTag) const

virtual bool	onComputeBounds (SkRect *) const

virtual void *	onGetCTFontRef () const

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

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

using	FactoryId = SkFourByteTag

Detailed Description

SkTypeface implementation based on Google Fonts Fontations Rust libraries.

Definition at line 205 of file SkTypeface_fontations_priv.h.

Member Function Documentation

◆ getBridgeFontRef()

const fontations_ffi::BridgeFontRef & SkTypeface_Fontations::getBridgeFontRef ( )

inline

Definition at line 217 of file SkTypeface_fontations_priv.h.

217{ return *fBridgeFontRef; }

◆ getBridgeNormalizedCoords()

const fontations_ffi::BridgeNormalizedCoords & SkTypeface_Fontations::getBridgeNormalizedCoords ( )

inline

Definition at line 218 of file SkTypeface_fontations_priv.h.

                                                                            {
        return *fBridgeNormalizedCoords;
    }

◆ getGlyphToUnicodeMap()

void SkTypeface_Fontations::getGlyphToUnicodeMap ( SkUnichar * codepointForGlyphMap ) const

overrideprotectedvirtual

Implements SkTypeface.

Definition at line 304 of file SkTypeface_fontations.cpp.

                                                                                      {
    size_t numGlyphs = SkToSizeT(onCountGlyphs());
    if (!codepointForGlyphMap) {
        SkASSERT(numGlyphs == 0);
    }
    rust::Slice<uint32_t> codepointForGlyphSlice{reinterpret_cast<uint32_t*>(codepointForGlyphMap),
                                                 numGlyphs};
    fontations_ffi::fill_glyph_to_unicode_map(*fBridgeFontRef, codepointForGlyphSlice);
}

◆ getOutlines()

const fontations_ffi::BridgeOutlineCollection & SkTypeface_Fontations::getOutlines ( )

inline

Definition at line 221 of file SkTypeface_fontations_priv.h.

221{ return *fOutlines; }

◆ getPalette()

SkSpan< const SkColor > SkTypeface_Fontations::getPalette ( ) const

inline

Definition at line 222 of file SkTypeface_fontations_priv.h.

                                             {
        return SkSpan(reinterpret_cast<const SkColor*>(fPalette.data()), fPalette.size());
    }

◆ getPostScriptGlyphNames()

void SkTypeface_Fontations::getPostScriptGlyphNames ( SkString * ) const

inlineoverrideprotectedvirtual

Implements SkTypeface.

Definition at line 241 of file SkTypeface_fontations_priv.h.

241{}

◆ MakeFromData()

sk_sp< SkTypeface > SkTypeface_Fontations::MakeFromData	(	sk_sp< SkData >	fontData,
		const SkFontArguments &	args
	)

static

Definition at line 118 of file SkTypeface_fontations.cpp.

                                                                                   {
    uint32_t ttcIndex = args.getCollectionIndex();
    rust::Box<fontations_ffi::BridgeFontRef> bridgeFontRef = make_bridge_font_ref(data, ttcIndex);
    if (!fontations_ffi::font_ref_is_valid(*bridgeFontRef)) {
        return nullptr;
    }
 
    rust::Box<fontations_ffi::BridgeMappingIndex> mappingIndex =
            fontations_ffi::make_mapping_index(*bridgeFontRef);
 
    SkFontArguments::VariationPosition variationPosition = args.getVariationDesignPosition();
    std::unique_ptr<SkFontArguments::VariationPosition::Coordinate[]> concatenatedCoords = nullptr;
    // Handle FreeType behaviour of upper 15 bits of collection index
    // representing a named instance choice. If so, prepopulate the variation
    // coordinates with the values from the named instance and append the user
    // coordinates after that so they can override the named instance's
    // coordinates.
    if (args.getCollectionIndex() & 0xFFFF0000) {
        size_t numNamedInstanceCoords =
                fontations_ffi::coordinates_for_shifted_named_instance_index(
                        *bridgeFontRef,
                        args.getCollectionIndex(),
                        rust::cxxbridge1::Slice<fontations_ffi::SkiaDesignCoordinate>());
        concatenatedCoords.reset(
                new SkFontArguments::VariationPosition::Coordinate
                        [numNamedInstanceCoords + variationPosition.coordinateCount]);
 
        rust::cxxbridge1::Slice<fontations_ffi::SkiaDesignCoordinate> targetSlice(
                reinterpret_cast<fontations_ffi::SkiaDesignCoordinate*>(concatenatedCoords.get()),
                numNamedInstanceCoords);
        size_t retrievedNamedInstanceCoords =
                fontations_ffi::coordinates_for_shifted_named_instance_index(
                        *bridgeFontRef, args.getCollectionIndex(), targetSlice);
        if (numNamedInstanceCoords != retrievedNamedInstanceCoords) {
            return nullptr;
        }
        for (int i = 0; i < variationPosition.coordinateCount; ++i) {
            concatenatedCoords[numNamedInstanceCoords + i] = variationPosition.coordinates[i];
        }
        variationPosition.coordinateCount += numNamedInstanceCoords;
        variationPosition.coordinates = concatenatedCoords.get();
    }
 
    rust::Box<fontations_ffi::BridgeNormalizedCoords> normalizedCoords =
            make_normalized_coords(*bridgeFontRef, variationPosition);
    SkFontStyle style;
    fontations_ffi::BridgeFontStyle fontStyle;
    if (fontations_ffi::get_font_style(*bridgeFontRef, *normalizedCoords, fontStyle)) {
        style = SkFontStyle(fontStyle.weight,
                            fontStyle.width,
                            static_cast<SkFontStyle::Slant>(fontStyle.slant));
    }
    rust::Box<fontations_ffi::BridgeOutlineCollection> outlines =
            fontations_ffi::get_outline_collection(*bridgeFontRef);
 
    rust::Slice<const fontations_ffi::PaletteOverride> paletteOverrides(
            reinterpret_cast<const ::fontations_ffi::PaletteOverride*>(args.getPalette().overrides),
            args.getPalette().overrideCount);
    rust::Vec<uint32_t> palette =
            resolve_palette(*bridgeFontRef, args.getPalette().index, paletteOverrides);
 
    return sk_sp<SkTypeface>(new SkTypeface_Fontations(data,
                                                       style,
                                                       ttcIndex,
                                                       std::move(bridgeFontRef),
                                                       std::move(mappingIndex),
                                                       std::move(normalizedCoords),
                                                       std::move(outlines),
                                                       std::move(palette)));
}

◆ MakeFromStream()

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

static

Definition at line 113 of file SkTypeface_fontations.cpp.

                                                                                     {
    return MakeFromData(streamToData(stream), args);
}

◆ onCharsToGlyphs()

void SkTypeface_Fontations::onCharsToGlyphs	(	const SkUnichar *	chars,
		int	count,
		SkGlyphID	glyphs[]
	)		const

overrideprotectedvirtual

Implements SkTypeface.

Definition at line 291 of file SkTypeface_fontations.cpp.

                                                                      {
    sk_bzero(glyphs, count * sizeof(glyphs[0]));
 
    for (int i = 0; i < count; ++i) {
        glyphs[i] = fontations_ffi::lookup_glyph_or_zero(*fBridgeFontRef, *fMappingIndex, chars[i]);
    }
}

◆ onCountGlyphs()

int SkTypeface_Fontations::onCountGlyphs ( ) const

overrideprotectedvirtual

Implements SkTypeface.

Definition at line 300 of file SkTypeface_fontations.cpp.

                                               {
    return fontations_ffi::num_glyphs(*fBridgeFontRef);
}

◆ onCreateFamilyNameIterator()

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

overrideprotectedvirtual

Returns an iterator over the family names in the font.

Implements SkTypeface.

Definition at line 350 of file SkTypeface_fontations.cpp.

                                                                                    {
    return new SkrifaLocalizedStrings(fontations_ffi::get_localized_strings(*fBridgeFontRef));
}

◆ onCreateScalerContext()

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

overrideprotectedvirtual

Implements SkTypeface.

Definition at line 913 of file SkTypeface_fontations.cpp.

                                                                               {
    return std::make_unique<SkFontationsScalerContext>(
            sk_ref_sp(const_cast<SkTypeface_Fontations*>(this)), effects, desc);
}

◆ onFilterRec()

void SkTypeface_Fontations::onFilterRec ( SkScalerContextRec * rec ) const

overrideprotectedvirtual

Implements SkTypeface.

Definition at line 314 of file SkTypeface_fontations.cpp.

                                                                     {
    // Opportunistic hinting downgrades copied from SkFontHost_FreeType.cpp
    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);
}

◆ onGetAdvancedMetrics()

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

overrideprotectedvirtual

Implements SkTypeface.

Definition at line 919 of file SkTypeface_fontations.cpp.

                                                                                           {
    std::unique_ptr<SkAdvancedTypefaceMetrics> info(new SkAdvancedTypefaceMetrics);
 
    if (!fontations_ffi::is_embeddable(*fBridgeFontRef)) {
        info->fFlags |= SkAdvancedTypefaceMetrics::kNotEmbeddable_FontFlag;
    }
 
    if (!fontations_ffi::is_subsettable(*fBridgeFontRef)) {
        info->fFlags |= SkAdvancedTypefaceMetrics::kNotSubsettable_FontFlag;
    }
 
    if (fontations_ffi::table_data(
                *fBridgeFontRef, SkSetFourByteTag('f', 'v', 'a', 'r'), 0, rust::Slice<uint8_t>())) {
        info->fFlags |= SkAdvancedTypefaceMetrics::kVariable_FontFlag;
    }
 
    // Metrics information.
    fontations_ffi::Metrics metrics =
            fontations_ffi::get_unscaled_metrics(*fBridgeFontRef, *fBridgeNormalizedCoords);
    info->fAscent = metrics.ascent;
    info->fDescent = metrics.descent;
    info->fCapHeight = metrics.cap_height;
 
    info->fBBox = SkIRect::MakeLTRB((int32_t)metrics.x_min,
                                    (int32_t)metrics.top,
                                    (int32_t)metrics.x_max,
                                    (int32_t)metrics.bottom);
 
    // Style information.
    if (fontations_ffi::is_fixed_pitch(*fBridgeFontRef)) {
        info->fStyle |= SkAdvancedTypefaceMetrics::kFixedPitch_Style;
    }
 
    fontations_ffi::BridgeFontStyle fontStyle;
    if (fontations_ffi::get_font_style(*fBridgeFontRef, *fBridgeNormalizedCoords, fontStyle)) {
        if (fontStyle.slant == SkFontStyle::Slant::kItalic_Slant) {
            info->fStyle |= SkAdvancedTypefaceMetrics::kItalic_Style;
        }
    }
 
    if (fontations_ffi::is_serif_style(*fBridgeFontRef)) {
        info->fStyle |= SkAdvancedTypefaceMetrics::kSerif_Style;
    } else if (fontations_ffi::is_script_style(*fBridgeFontRef)) {
        info->fStyle |= SkAdvancedTypefaceMetrics::kScript_Style;
    }
 
    info->fItalicAngle = fontations_ffi::italic_angle(*fBridgeFontRef);
 
    return info;
}

◆ onGetFamilyName()

void SkTypeface_Fontations::onGetFamilyName ( SkString * familyName ) const

overrideprotectedvirtual

Returns the family name of the typeface as known by its font manager. This name may or may not be produced by the family name iterator.

Implements SkTypeface.

Definition at line 266 of file SkTypeface_fontations.cpp.

                                                                      {
    rust::String readFamilyName = fontations_ffi::family_name(*fBridgeFontRef);
    *familyName = SkString(readFamilyName.data(), readFamilyName.size());
}

◆ onGetFontDescriptor()

void SkTypeface_Fontations::onGetFontDescriptor	(	SkFontDescriptor *	desc,
		bool *	serialize
	)		const

overrideprotectedvirtual

Implements SkTypeface.

Definition at line 970 of file SkTypeface_fontations.cpp.

                                                                                             {
    SkString familyName;
    onGetFamilyName(&familyName);
    desc->setFamilyName(familyName.c_str());
    desc->setStyle(this->fontStyle());
    desc->setFactoryId(FactoryId);
 
    // TODO: keep the index to emit here
    desc->setPaletteIndex(0);
    SkSpan<const SkColor> palette = getPalette();
    // TODO: omit override when palette[n] == CPAL[paletteIndex][n]
    size_t paletteOverrideCount = palette.size();
    auto overrides = desc->setPaletteEntryOverrides(paletteOverrideCount);
    for (size_t i = 0; i < paletteOverrideCount; ++i) {
        overrides[i] = {(uint16_t)i, palette[i]};
    }
 
    *serialize = true;
}

◆ onGetPostScriptName()

bool SkTypeface_Fontations::onGetPostScriptName ( SkString * postscriptName ) const

overrideprotectedvirtual

Implements SkTypeface.

Definition at line 271 of file SkTypeface_fontations.cpp.

                                                                              {
    rust::String readPsName;
    if (fontations_ffi::postscript_name(*fBridgeFontRef, readPsName)) {
        if (postscriptName) {
            *postscriptName = SkString(readPsName.data(), readPsName.size());
        }
        return true;
    }
 
    return false;
}

◆ onGetTableData()

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

overrideprotectedvirtual

Implements SkTypeface.

Definition at line 990 of file SkTypeface_fontations.cpp.

                                                               {
    rust::Slice<uint8_t> dataSlice;
    if (data) {
        dataSlice = rust::Slice<uint8_t>(reinterpret_cast<uint8_t*>(data), length);
    }
    size_t copied = fontations_ffi::table_data(*fBridgeFontRef, tag, offset, dataSlice);
    // If data is nullptr, the Rust side doesn't see a length limit.
    return std::min(copied, length);
}

◆ onGetTableTags()

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

overrideprotectedvirtual

Implements SkTypeface.

Definition at line 1003 of file SkTypeface_fontations.cpp.

                                                                     {
    uint16_t numTables = fontations_ffi::table_tags(*fBridgeFontRef, rust::Slice<uint32_t>());
    if (!tags) {
        return numTables;
    }
    rust::Slice<uint32_t> copyToTags(tags, numTables);
    return fontations_ffi::table_tags(*fBridgeFontRef, copyToTags);
}

◆ onGetUPEM()

int SkTypeface_Fontations::onGetUPEM ( ) const

overrideprotectedvirtual

Implements SkTypeface.

Definition at line 262 of file SkTypeface_fontations.cpp.

                                           {
    return fontations_ffi::units_per_em_or_zero(*fBridgeFontRef);
}

◆ onGetVariationDesignParameters()

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

overrideprotectedvirtual

Implements SkTypeface.

Definition at line 1023 of file SkTypeface_fontations.cpp.

                                                                              {
    sk_fontations::AxisWrapper axisWrapper(parameters, parameterCount);
    return fontations_ffi::populate_axes(*fBridgeFontRef, axisWrapper);
}

◆ onGetVariationDesignPosition()

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

overrideprotectedvirtual

Implements SkTypeface.

Definition at line 1012 of file SkTypeface_fontations.cpp.

                                                                                             {
    rust::Slice<fontations_ffi::SkiaDesignCoordinate> copyToCoordinates;
    if (coordinates) {
        copyToCoordinates = rust::Slice<fontations_ffi::SkiaDesignCoordinate>(
                reinterpret_cast<fontations_ffi::SkiaDesignCoordinate*>(coordinates),
                coordinateCount);
    }
    return fontations_ffi::variation_position(*fBridgeNormalizedCoords, copyToCoordinates);
}

◆ onGlyphMaskNeedsCurrentColor()

bool SkTypeface_Fontations::onGlyphMaskNeedsCurrentColor ( ) const

overrideprotectedvirtual

Implements SkTypeface.

Definition at line 283 of file SkTypeface_fontations.cpp.

                                                               {
    fGlyphMasksMayNeedCurrentColorOnce([this] {
        static constexpr SkFourByteTag COLRTag = SkSetFourByteTag('C', 'O', 'L', 'R');
        fGlyphMasksMayNeedCurrentColor = this->getTableSize(COLRTag) > 0;
    });
    return fGlyphMasksMayNeedCurrentColor;
}

◆ onMakeClone()

sk_sp< SkTypeface > SkTypeface_Fontations::onMakeClone ( const SkFontArguments & args ) const

overrideprotectedvirtual

Implements SkTypeface.

Definition at line 862 of file SkTypeface_fontations.cpp.

                                                                                      {
    // Matching DWrite implementation, return self if ttc index mismatches.
    if (fTtcIndex != SkTo<uint32_t>(args.getCollectionIndex())) {
        return sk_ref_sp(this);
    }
 
    int numAxes = onGetVariationDesignPosition(nullptr, 0);
    auto fusedDesignPosition =
            std::make_unique<SkFontArguments::VariationPosition::Coordinate[]>(numAxes);
    int retrievedAxes = onGetVariationDesignPosition(fusedDesignPosition.get(), numAxes);
    if (numAxes != retrievedAxes) {
        return nullptr;
    }
 
    // We know the internally retrieved axes are normalized, contain a value for every possible
    // axis, other axes do not exist, so we only need to override any of those.
    for (int i = 0; i < numAxes; ++i) {
        const SkFontArguments::VariationPosition& argPosition = args.getVariationDesignPosition();
        for (int j = 0; j < argPosition.coordinateCount; ++j) {
            if (fusedDesignPosition[i].axis == argPosition.coordinates[j].axis) {
                fusedDesignPosition[i].value = argPosition.coordinates[j].value;
            }
        }
    }
 
    SkFontArguments fusedArgs;
    fusedArgs.setVariationDesignPosition({fusedDesignPosition.get(), SkToInt(numAxes)});
    fusedArgs.setPalette(args.getPalette());
 
    rust::cxxbridge1::Box<fontations_ffi::BridgeNormalizedCoords> normalized_args =
            make_normalized_coords(*fBridgeFontRef, fusedArgs.getVariationDesignPosition());
 
    if (!fontations_ffi::normalized_coords_equal(*normalized_args, *fBridgeNormalizedCoords)) {
        return MakeFromData(fFontData, fusedArgs);
    }
 
    // TODO(crbug.com/skia/330149870): Palette differences are not fused, see DWrite backend impl.
    rust::Slice<const fontations_ffi::PaletteOverride> argPaletteOverrides(
            reinterpret_cast<const fontations_ffi::PaletteOverride*>(args.getPalette().overrides),
            args.getPalette().overrideCount);
    rust::Vec<uint32_t> newPalette =
            resolve_palette(*fBridgeFontRef, args.getPalette().index, argPaletteOverrides);
 
    if (fPalette.size() != newPalette.size() ||
        memcmp(fPalette.data(), newPalette.data(), fPalette.size() * sizeof(fPalette[0]))) {
        return MakeFromData(fFontData, fusedArgs);
    }
 
    return sk_ref_sp(this);
}

◆ onOpenStream()

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

overrideprotectedvirtual

Implements SkTypeface.

Definition at line 857 of file SkTypeface_fontations.cpp.

                                                                                    {
    *ttcIndex = fTtcIndex;
    return std::make_unique<SkMemoryStream>(fFontData);
}

Member Data Documentation

◆ FactoryId

constexpr SkTypeface::FactoryId SkTypeface_Fontations::FactoryId = SkSetFourByteTag('f', 'n', 't', 'a')

staticconstexpr

Definition at line 226 of file SkTypeface_fontations_priv.h.

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

third_party/skia/src/ports/SkTypeface_fontations_priv.h
third_party/skia/src/ports/SkTypeface_fontations.cpp

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ getBridgeFontRef()

◆ getBridgeNormalizedCoords()

◆ getGlyphToUnicodeMap()

◆ getOutlines()

◆ getPalette()

◆ getPostScriptGlyphNames()

◆ MakeFromData()

◆ MakeFromStream()

◆ onCharsToGlyphs()

◆ onCountGlyphs()

◆ onCreateFamilyNameIterator()

◆ onCreateScalerContext()

◆ onFilterRec()

◆ onGetAdvancedMetrics()

◆ onGetFamilyName()

◆ onGetFontDescriptor()

◆ onGetPostScriptName()

◆ onGetTableData()

◆ onGetTableTags()

◆ onGetUPEM()

◆ onGetVariationDesignParameters()

◆ onGetVariationDesignPosition()

◆ onGlyphMaskNeedsCurrentColor()

◆ onMakeClone()

◆ onOpenStream()

Member Data Documentation

◆ FactoryId