SkFontConfigInterfaceDirect Class Reference

#include <SkFontConfigInterface_direct.h>

Inheritance diagram for SkFontConfigInterfaceDirect:

Public Member Functions
	SkFontConfigInterfaceDirect (FcConfig *fc)
	~SkFontConfigInterfaceDirect () override
bool	matchFamilyName (const char familyName[], SkFontStyle requested, FontIdentity *outFontIdentifier, SkString *outFamilyName, SkFontStyle *outStyle) override
SkStreamAsset *	openStream (const FontIdentity &) override
Public Member Functions inherited from SkFontConfigInterface
virtual sk_sp< SkTypeface >	makeTypeface (const FontIdentity &identity, sk_sp< SkFontMgr > mgr)
Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()
virtual	~SkRefCntBase ()
bool	unique () const
void	ref () const
void	unref () const

Protected Member Functions
virtual bool	isAccessible (const char *filename)

Additional Inherited Members
Public Types inherited from SkFontConfigInterface
using	INHERITED = SkRefCnt
Static Public Member Functions inherited from SkFontConfigInterface
static sk_sp< SkFontConfigInterface >	RefGlobal ()
static void	SetGlobal (sk_sp< SkFontConfigInterface > fc)
static SkFontConfigInterface *	GetSingletonDirectInterface ()

Detailed Description

Definition at line 16 of file SkFontConfigInterface_direct.h.

Constructor & Destructor Documentation

SkFontConfigInterfaceDirect()

SkFontConfigInterfaceDirect::SkFontConfigInterfaceDirect

(

FcConfig *

fc

)

Create around a FontConfig instance. If 'fc' is nullptr, each method call will use the current config. Takes ownership of 'fc' and will call FcConfigDestroy on it.

Definition at line 496 of file SkFontConfigInterface_direct.cpp.

                                                                     : fFC(fc)
{
    SkDEBUGCODE(fontconfiginterface_unittest();)
}

~SkFontConfigInterfaceDirect()

SkFontConfigInterfaceDirect::~SkFontConfigInterfaceDirect ( )

override

Definition at line 501 of file SkFontConfigInterface_direct.cpp.

                                                          {
    if (fFC) {
        FcConfigDestroy(fFC);
    }
}

Member Function Documentation

isAccessible()

bool SkFontConfigInterfaceDirect::isAccessible ( const char *  filename )

protectedvirtual

Definition at line 507 of file SkFontConfigInterface_direct.cpp.

                                                                   {
    if (access(filename, R_OK) != 0) {
        return false;
    }
    return true;
}

matchFamilyName()

bool SkFontConfigInterfaceDirect::matchFamilyName ( const char  familyName[], SkFontStyle  requested, FontIdentity *  outFontIdentifier, SkString *  outFamilyName, SkFontStyle *  outStyle  )

overridevirtual

Given a familyName and style, find the best match.

If a match is found, return true and set its outFontIdentifier. If outFamilyName is not null, assign the found familyName to it (which may differ from the requested familyName). If outStyle is not null, assign the found style to it (which may differ from the requested style).

If a match is not found, return false, and ignore all out parameters.

Implements SkFontConfigInterface.

Definition at line 588 of file SkFontConfigInterface_direct.cpp.

                                                                         {
    SkString familyStr(familyName ? familyName : "");
    if (familyStr.size() > kMaxFontFamilyLength) {
        return false;
    }
 
    FcConfig* fc = fFC;
    UniqueFCConfig fcStorage;
    if (!fc) {
        fcStorage.reset(FcConfigReference(nullptr));
        fc = fcStorage.get();
    }
 
    FCLocker lock;
    FcPattern* pattern = FcPatternCreate();
 
    if (familyName) {
        FcPatternAddString(pattern, FC_FAMILY, (const FcChar8*)familyName);
    }
    fcpattern_from_skfontstyle(style, pattern);
 
    FcPatternAddBool(pattern, FC_SCALABLE, FcTrue);
 
    FcConfigSubstitute(fc, pattern, FcMatchPattern);
    FcDefaultSubstitute(pattern);
 
    // Font matching:
    // CSS often specifies a fallback list of families:
    //    font-family: a, b, c, serif;
    // However, fontconfig will always do its best to find *a* font when asked
    // for something so we need a way to tell if the match which it has found is
    // "good enough" for us. Otherwise, we can return nullptr which gets piped up
    // and lets WebKit know to try the next CSS family name. However, fontconfig
    // configs allow substitutions (mapping "Arial -> Helvetica" etc) and we
    // wish to support that.
    //
    // Thus, if a specific family is requested we set @family_requested. Then we
    // record two strings: the family name after config processing and the
    // family name after resolving. If the two are equal, it's a good match.
    //
    // So consider the case where a user has mapped Arial to Helvetica in their
    // config.
    //    requested family: "Arial"
    //    post_config_family: "Helvetica"
    //    post_match_family: "Helvetica"
    //      -> good match
    //
    // and for a missing font:
    //    requested family: "Monaco"
    //    post_config_family: "Monaco"
    //    post_match_family: "Times New Roman"
    //      -> BAD match
    //
    // However, we special-case fallback fonts; see IsFallbackFontAllowed().
 
    const char* post_config_family = get_string(pattern, FC_FAMILY);
    if (!post_config_family) {
        // we can just continue with an empty name, e.g. default font
        post_config_family = "";
    }
 
    FcResult result;
    FcFontSet* font_set = FcFontSort(fc, pattern, 0, nullptr, &result);
    if (!font_set) {
        FcPatternDestroy(pattern);
        return false;
    }
 
    FcPattern* match = this->MatchFont(font_set, post_config_family, familyStr);
    if (!match) {
        FcPatternDestroy(pattern);
        FcFontSetDestroy(font_set);
        return false;
    }
 
    FcPatternDestroy(pattern);
 
    // From here out we just extract our results from 'match'
 
    post_config_family = get_string(match, FC_FAMILY);
    if (!post_config_family) {
        FcFontSetDestroy(font_set);
        return false;
    }
 
    const char* c_filename = get_string(match, FC_FILE);
    if (!c_filename) {
        FcFontSetDestroy(font_set);
        return false;
    }
    const char* sysroot = (const char*)FcConfigGetSysRoot(fc);
    SkString resolvedFilename;
    if (sysroot) {
        resolvedFilename = sysroot;
        resolvedFilename += c_filename;
        c_filename = resolvedFilename.c_str();
    }
 
    int face_index = get_int(match, FC_INDEX, 0);
 
    FcFontSetDestroy(font_set);
 
    if (outIdentity) {
        outIdentity->fTTCIndex = face_index;
        outIdentity->fString.set(c_filename);
    }
    if (outFamilyName) {
        outFamilyName->set(post_config_family);
    }
    if (outStyle) {
        *outStyle = skfontstyle_from_fcpattern(match);
    }
    return true;
}

openStream()

SkStreamAsset * SkFontConfigInterfaceDirect::openStream ( const FontIdentity &  )

overridevirtual

Given a FontRef, open a stream to access its data, or return null if the FontRef's data is not available. The caller is responsible for deleting the stream when it is done accessing the data.

Implements SkFontConfigInterface.

Definition at line 707 of file SkFontConfigInterface_direct.cpp.

                                                                                   {
    return SkStream::MakeFromFile(identity.fString.c_str()).release();
}

---

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

• third_party/skia/src/ports/SkFontConfigInterface_direct.h
• third_party/skia/src/ports/SkFontConfigInterface_direct.cpp