SkFontMgr_fontconfig Class Reference

Inheritance diagram for SkFontMgr_fontconfig:

Public Member Functions
	SkFontMgr_fontconfig (FcConfig *config)
	~SkFontMgr_fontconfig () override
Public Member Functions inherited from SkFontMgr
int	countFamilies () const
void	getFamilyName (int index, SkString *familyName) const
sk_sp< SkFontStyleSet >	createStyleSet (int index) const
sk_sp< SkFontStyleSet >	matchFamily (const char familyName[]) const
sk_sp< SkTypeface >	matchFamilyStyle (const char familyName[], const SkFontStyle &) const
sk_sp< SkTypeface >	matchFamilyStyleCharacter (const char familyName[], const SkFontStyle &, const char *bcp47[], int bcp47Count, SkUnichar character) const
sk_sp< SkTypeface >	makeFromData (sk_sp< SkData >, int ttcIndex=0) const
sk_sp< SkTypeface >	makeFromStream (std::unique_ptr< SkStreamAsset >, int ttcIndex=0) const
sk_sp< SkTypeface >	makeFromStream (std::unique_ptr< SkStreamAsset >, const SkFontArguments &) const
sk_sp< SkTypeface >	makeFromFile (const char path[], int ttcIndex=0) const
sk_sp< SkTypeface >	legacyMakeTypeface (const char familyName[], SkFontStyle style) const
Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()
virtual	~SkRefCntBase ()
bool	unique () const
void	ref () const
void	unref () const

Protected Member Functions
int	onCountFamilies () const override
void	onGetFamilyName (int index, SkString *familyName) const override
sk_sp< SkFontStyleSet >	onCreateStyleSet (int index) const override
bool	FontAccessible (FcPattern *font) const
sk_sp< SkFontStyleSet >	onMatchFamily (const char familyName[]) const override
sk_sp< SkTypeface >	onMatchFamilyStyle (const char familyName[], const SkFontStyle &style) const override
sk_sp< SkTypeface >	onMatchFamilyStyleCharacter (const char familyName[], const SkFontStyle &style, const char *bcp47[], int bcp47Count, SkUnichar character) const override
sk_sp< SkTypeface >	onMakeFromStreamIndex (std::unique_ptr< SkStreamAsset > stream, int ttcIndex) const override
sk_sp< SkTypeface >	onMakeFromStreamArgs (std::unique_ptr< SkStreamAsset > stream, const SkFontArguments &args) const override
sk_sp< SkTypeface >	onMakeFromData (sk_sp< SkData > data, int ttcIndex) const override
sk_sp< SkTypeface >	onMakeFromFile (const char path[], int ttcIndex) const override
sk_sp< SkTypeface >	onLegacyMakeTypeface (const char familyName[], SkFontStyle style) const override

Static Protected Member Functions
static bool	AnyStringMatching (FcPattern *font, FcPattern *pattern, const char *object)
static bool	FontFamilyNameMatches (FcPattern *font, FcPattern *pattern)
static bool	FontContainsCharacter (FcPattern *font, uint32_t character)

Additional Inherited Members
Static Public Member Functions inherited from SkFontMgr
static sk_sp< SkFontMgr >	RefEmpty ()

Detailed Description

Definition at line 535 of file SkFontMgr_fontconfig.cpp.

Constructor & Destructor Documentation

SkFontMgr_fontconfig()

SkFontMgr_fontconfig::SkFontMgr_fontconfig ( FcConfig *  config )

inlineexplicit

Takes control of the reference to 'config'.

Definition at line 691 of file SkFontMgr_fontconfig.cpp.

        : fFC(config ? config : FcInitLoadConfigAndFonts())
        , fSysroot(reinterpret_cast<const char*>(FcConfigGetSysRoot(fFC)))
        , fFamilyNames(GetFamilyNames(fFC)) { }

~SkFontMgr_fontconfig()

SkFontMgr_fontconfig::~SkFontMgr_fontconfig ( )

inlineoverride

Definition at line 696 of file SkFontMgr_fontconfig.cpp.

                                     {
        // Hold the lock while unrefing the config.
        FCLocker lock;
        fFC.reset();
    }

Member Function Documentation

AnyStringMatching()

static bool SkFontMgr_fontconfig::AnyStringMatching ( FcPattern *  font, FcPattern *  pattern, const char *  object  )

inlinestaticprotected

True if any string object value in the font is the same as a string object value in the pattern.

Definition at line 718 of file SkFontMgr_fontconfig.cpp.

                                                                                           {
        auto getStrings = [](FcPattern* p, const char* object, STArray<32, FcChar8*>& strings) {
            // Set an arbitrary (but high) limit on the number of pattern object values to consider.
            static constexpr const int maxId = 65536;
            for (int patternId = 0; patternId < maxId; ++patternId) {
                FcChar8* patternString;
                FcResult result = FcPatternGetString(p, object, patternId, &patternString);
                if (result == FcResultNoId) {
                    break;
                }
                if (result == FcResultMatch) {
                    strings.push_back(patternString);
                }
            }
        };
        auto compareStrings = [](FcChar8* a, FcChar8* b) -> bool {
            return FcStrCmpIgnoreCase(a, b) < 0;
        };
 
        STArray<32, FcChar8*> fontStrings;
        STArray<32, FcChar8*> patternStrings;
        getStrings(font, object, fontStrings);
        getStrings(pattern, object, patternStrings);
 
        SkTQSort(fontStrings.begin(), fontStrings.end(), compareStrings);
        SkTQSort(patternStrings.begin(), patternStrings.end(), compareStrings);
 
        FcChar8** fontString = fontStrings.begin();
        FcChar8** patternString = patternStrings.begin();
        while (fontString != fontStrings.end() && patternString != patternStrings.end()) {
            int cmp = FcStrCmpIgnoreCase(*fontString, *patternString);
            if (cmp < 0) {
                ++fontString;
            } else if (cmp > 0) {
                ++patternString;
            } else {
                return true;
            }
        }
        return false;
    }

FontAccessible()

bool SkFontMgr_fontconfig::FontAccessible ( FcPattern *  font ) const

inlineprotected

Definition at line 760 of file SkFontMgr_fontconfig.cpp.

                                               {
        // FontConfig can return fonts which are unreadable.
        const char* filename = get_string(font, FC_FILE, nullptr);
        if (nullptr == filename) {
            return false;
        }
 
        // When sysroot was implemented in e96d7760886a3781a46b3271c76af99e15cb0146 (before 2.11.0)
        // it was broken;  mostly fixed in d17f556153fbaf8fe57fdb4fc1f0efa4313f0ecf (after 2.11.1).
        // This leaves Debian 8 and 9 with broken support for this feature.
        // As a result, this feature should not be used until at least 2.11.91.
        // The broken support is mostly around not making all paths relative to the sysroot.
        // However, even at 2.13.1 it is possible to get a mix of sysroot and non-sysroot paths,
        // as any added file path not lexically starting with the sysroot will be unchanged.
        // To allow users to add local app files outside the sysroot,
        // prefer the sysroot but also look without the sysroot.
        if (!fSysroot.isEmpty()) {
            SkString resolvedFilename;
            resolvedFilename = fSysroot;
            resolvedFilename += filename;
            if (sk_exists(resolvedFilename.c_str(), kRead_SkFILE_Flag)) {
                return true;
            }
        }
        return sk_exists(filename, kRead_SkFILE_Flag);
    }

FontContainsCharacter()

static bool SkFontMgr_fontconfig::FontContainsCharacter ( FcPattern *  font, uint32_t  character  )

inlinestaticprotected

Definition at line 791 of file SkFontMgr_fontconfig.cpp.

                                                                           {
        FcResult result;
        FcCharSet* matchCharSet;
        for (int charSetId = 0; ; ++charSetId) {
            result = FcPatternGetCharSet(font, FC_CHARSET, charSetId, &matchCharSet);
            if (FcResultNoId == result) {
                break;
            }
            if (FcResultMatch != result) {
                continue;
            }
            if (FcCharSetHasChar(matchCharSet, character)) {
                return true;
            }
        }
        return false;
    }

FontFamilyNameMatches()

static bool SkFontMgr_fontconfig::FontFamilyNameMatches ( FcPattern *  font, FcPattern *  pattern  )

inlinestaticprotected

Definition at line 787 of file SkFontMgr_fontconfig.cpp.

                                                                           {
        return AnyStringMatching(font, pattern, FC_FAMILY);
    }

onCountFamilies()

int SkFontMgr_fontconfig::onCountFamilies ( ) const

inlineoverrideprotectedvirtual

Implements SkFontMgr.

Definition at line 703 of file SkFontMgr_fontconfig.cpp.

                                         {
        return fFamilyNames->count();
    }

onCreateStyleSet()

sk_sp< SkFontStyleSet > SkFontMgr_fontconfig::onCreateStyleSet ( int  index ) const

inlineoverrideprotectedvirtual

Implements SkFontMgr.

Definition at line 711 of file SkFontMgr_fontconfig.cpp.

                                                                     {
        return this->onMatchFamily(fFamilyNames->atStr(index));
    }

onGetFamilyName()

void SkFontMgr_fontconfig::onGetFamilyName ( int  index, SkString *  familyName  ) const

inlineoverrideprotectedvirtual

Implements SkFontMgr.

Definition at line 707 of file SkFontMgr_fontconfig.cpp.

                                                                         {
        familyName->set(fFamilyNames->atStr(index));
    }

onLegacyMakeTypeface()

sk_sp< SkTypeface > SkFontMgr_fontconfig::onLegacyMakeTypeface ( const char  familyName[], SkFontStyle  style  ) const

inlineoverrideprotectedvirtual

Implements SkFontMgr.

Definition at line 960 of file SkFontMgr_fontconfig.cpp.

                                                                                                      {
        sk_sp<SkTypeface> typeface(this->matchFamilyStyle(familyName, style));
        if (typeface) {
            return typeface;
        }
 
        return sk_sp<SkTypeface>(this->matchFamilyStyle(nullptr, style));
    }

onMakeFromData()

sk_sp< SkTypeface > SkFontMgr_fontconfig::onMakeFromData ( sk_sp< SkData >  data, int  ttcIndex  ) const

inlineoverrideprotectedvirtual

Implements SkFontMgr.

Definition at line 952 of file SkFontMgr_fontconfig.cpp.

                                                                                      {
        return this->makeFromStream(std::make_unique<SkMemoryStream>(std::move(data)), ttcIndex);
    }

onMakeFromFile()

sk_sp< SkTypeface > SkFontMgr_fontconfig::onMakeFromFile ( const char  path[], int  ttcIndex  ) const

inlineoverrideprotectedvirtual

Implements SkFontMgr.

Definition at line 956 of file SkFontMgr_fontconfig.cpp.

                                                                                     {
        return this->makeFromStream(SkStream::MakeFromFile(path), ttcIndex);
    }

onMakeFromStreamArgs()

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

inlineoverrideprotectedvirtual

Implements SkFontMgr.

Definition at line 943 of file SkFontMgr_fontconfig.cpp.

                                                                                       {
        const size_t length = stream->getLength();
        if (length <= 0 || (1u << 30) < length) {
            return nullptr;
        }
        return SkTypeface_FreeType::MakeFromStream(std::move(stream), args);
    }

onMakeFromStreamIndex()

sk_sp< SkTypeface > SkFontMgr_fontconfig::onMakeFromStreamIndex ( std::unique_ptr< SkStreamAsset >  stream, int  ttcIndex  ) const

inlineoverrideprotectedvirtual

Implements SkFontMgr.

Definition at line 937 of file SkFontMgr_fontconfig.cpp.

                                                                         {
        return this->makeFromStream(std::move(stream),
                                    SkFontArguments().setCollectionIndex(ttcIndex));
    }

onMatchFamily()

sk_sp< SkFontStyleSet > SkFontMgr_fontconfig::onMatchFamily ( const char  familyName[] ) const

inlineoverrideprotectedvirtual

May return NULL if the name is not found.

Implements SkFontMgr.

Definition at line 809 of file SkFontMgr_fontconfig.cpp.

                                                                                {
        if (!familyName) {
            return nullptr;
        }
        FCLocker lock;
 
        SkAutoFcPattern pattern;
        FcPatternAddString(pattern, FC_FAMILY, (const FcChar8*)familyName);
        FcConfigSubstitute(fFC, pattern, FcMatchPattern);
        FcDefaultSubstitute(pattern);
 
        FcPattern* matchPattern;
        SkAutoFcPattern strongPattern(nullptr);
        if (familyName) {
            strongPattern.reset(FcPatternDuplicate(pattern));
            remove_weak(strongPattern, FC_FAMILY);
            matchPattern = strongPattern;
        } else {
            matchPattern = pattern;
        }
 
        SkAutoFcFontSet matches;
        // TODO: Some families have 'duplicates' due to symbolic links.
        // The patterns are exactly the same except for the FC_FILE.
        // It should be possible to collapse these patterns by normalizing.
        static const FcSetName fcNameSet[] = { FcSetSystem, FcSetApplication };
        for (int setIndex = 0; setIndex < (int)std::size(fcNameSet); ++setIndex) {
            // Return value of FcConfigGetFonts must not be destroyed.
            FcFontSet* allFonts(FcConfigGetFonts(fFC, fcNameSet[setIndex]));
            if (nullptr == allFonts) {
                continue;
            }
 
            for (int fontIndex = 0; fontIndex < allFonts->nfont; ++fontIndex) {
                FcPattern* font = allFonts->fonts[fontIndex];
                if (FontAccessible(font) && FontFamilyNameMatches(font, matchPattern)) {
                    FcFontSetAdd(matches, FcFontRenderPrepare(fFC, pattern, font));
                }
            }
        }
 
        return sk_sp<SkFontStyleSet>(new StyleSet(sk_ref_sp(this), std::move(matches)));
    }

onMatchFamilyStyle()

sk_sp< SkTypeface > SkFontMgr_fontconfig::onMatchFamilyStyle ( const char  familyName[], const SkFontStyle &  style  ) const

inlineoverrideprotectedvirtual

Implements SkFontMgr.

Definition at line 853 of file SkFontMgr_fontconfig.cpp.

    {
        SkAutoFcPattern font([this, &familyName, &style]() {
            FCLocker lock;
 
            SkAutoFcPattern pattern;
            FcPatternAddString(pattern, FC_FAMILY, (const FcChar8*)familyName);
            fcpattern_from_skfontstyle(style, pattern);
            FcConfigSubstitute(fFC, pattern, FcMatchPattern);
            FcDefaultSubstitute(pattern);
 
            // We really want to match strong (preferred) and same (acceptable) only here.
            // If a family name was specified, assume that any weak matches after the last strong
            // match are weak (default) and ignore them.
            // After substitution the pattern for 'sans-serif' looks like "wwwwwwwwwwwwwwswww" where
            // there are many weak but preferred names, followed by defaults.
            // So it is possible to have weakly matching but preferred names.
            // In aliases, bindings are weak by default, so this is easy and common.
            // If no family name was specified, we'll probably only get weak matches, but that's ok.
            FcPattern* matchPattern;
            SkAutoFcPattern strongPattern(nullptr);
            if (familyName) {
                strongPattern.reset(FcPatternDuplicate(pattern));
                remove_weak(strongPattern, FC_FAMILY);
                matchPattern = strongPattern;
            } else {
                matchPattern = pattern;
            }
 
            FcResult result;
            SkAutoFcPattern font(FcFontMatch(fFC, pattern, &result));
            if (!font || !FontAccessible(font) || !FontFamilyNameMatches(font, matchPattern)) {
                font.reset();
            }
            return font;
        }());
        return createTypefaceFromFcPattern(std::move(font));
    }

onMatchFamilyStyleCharacter()

sk_sp< SkTypeface > SkFontMgr_fontconfig::onMatchFamilyStyleCharacter ( const char  familyName[], const SkFontStyle &  style, const char *  bcp47[], int  bcp47Count, SkUnichar  character  ) const

inlineoverrideprotectedvirtual

Implements SkFontMgr.

Definition at line 893 of file SkFontMgr_fontconfig.cpp.

    {
        SkAutoFcPattern font([&](){
            FCLocker lock;
 
            SkAutoFcPattern pattern;
            if (familyName) {
                FcValue familyNameValue;
                familyNameValue.type = FcTypeString;
                familyNameValue.u.s = reinterpret_cast<const FcChar8*>(familyName);
                FcPatternAddWeak(pattern, FC_FAMILY, familyNameValue, FcFalse);
            }
            fcpattern_from_skfontstyle(style, pattern);
 
            SkAutoFcCharSet charSet;
            FcCharSetAddChar(charSet, character);
            FcPatternAddCharSet(pattern, FC_CHARSET, charSet);
 
            if (bcp47Count > 0) {
                SkASSERT(bcp47);
                SkAutoFcLangSet langSet;
                for (int i = bcp47Count; i --> 0;) {
                    FcLangSetAdd(langSet, (const FcChar8*)bcp47[i]);
                }
                FcPatternAddLangSet(pattern, FC_LANG, langSet);
            }
 
            FcConfigSubstitute(fFC, pattern, FcMatchPattern);
            FcDefaultSubstitute(pattern);
 
            FcResult result;
            SkAutoFcPattern font(FcFontMatch(fFC, pattern, &result));
            if (!font || !FontAccessible(font) || !FontContainsCharacter(font, character)) {
                font.reset();
            }
            return font;
        }());
        return createTypefaceFromFcPattern(std::move(font));
    }

---

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

• third_party/skia/src/ports/SkFontMgr_fontconfig.cpp