SkFontMgr_fontconfig.cpp File Reference

#include "include/core/SkDataTable.h"
#include "include/core/SkFontArguments.h"
#include "include/core/SkFontMgr.h"
#include "include/core/SkFontStyle.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkScalar.h"
#include "include/core/SkStream.h"
#include "include/core/SkString.h"
#include "include/core/SkTypeface.h"
#include "include/core/SkTypes.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkMutex.h"
#include "include/private/base/SkTArray.h"
#include "include/private/base/SkTDArray.h"
#include "include/private/base/SkTemplates.h"
#include "include/private/base/SkThreadAnnotations.h"
#include "src/base/SkTSort.h"
#include "src/core/SkAdvancedTypefaceMetrics.h"
#include "src/core/SkFontDescriptor.h"
#include "src/core/SkOSFile.h"
#include "src/core/SkScalerContext.h"
#include "src/core/SkTypefaceCache.h"
#include "src/ports/SkTypeface_FreeType.h"
#include <fontconfig/fontconfig.h>
#include <string.h>
#include <array>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <utility>

Go to the source code of this file.

Classes
class	SkAutoFc< T, C, D >
struct	MapRanges
class	SkTypeface_fontconfig
class	SkFontMgr_fontconfig

Macros
#define	FC_POSTSCRIPT_NAME   "postscriptname"
#define	FC_WEIGHT_DEMILIGHT   65

Typedefs
typedef SkAutoFc< FcCharSet, FcCharSetCreate, FcCharSetDestroy >	SkAutoFcCharSet
typedef SkAutoFc< FcConfig, FcConfigCreate, FcConfigDestroy >	SkAutoFcConfig
typedef SkAutoFc< FcFontSet, FcFontSetCreate, FcFontSetDestroy >	SkAutoFcFontSet
typedef SkAutoFc< FcLangSet, FcLangSetCreate, FcLangSetDestroy >	SkAutoFcLangSet
typedef SkAutoFc< FcObjectSet, FcObjectSetCreate, FcObjectSetDestroy >	SkAutoFcObjectSet
typedef SkAutoFc< FcPattern, FcPatternCreate, FcPatternDestroy >	SkAutoFcPattern

Enumerations
enum	SkWeakReturn { kIsWeak_WeakReturn , kIsStrong_WeakReturn , kNoId_WeakReturn }

Functions
template<typename T , void(*)(T *) D>
void	FcTDestroy (T *t)
static bool	get_bool (FcPattern *pattern, const char object[], bool missing=false)
static int	get_int (FcPattern *pattern, const char object[], int missing)
static const char *	get_string (FcPattern *pattern, const char object[], const char *missing="")
static const FcMatrix *	get_matrix (FcPattern *pattern, const char object[])
static SkWeakReturn	is_weak (FcPattern *pattern, const char object[], int id)
static void	remove_weak (FcPattern *pattern, const char object[])
static int	map_range (SkScalar value, SkScalar old_min, SkScalar old_max, SkScalar new_min, SkScalar new_max)
static SkScalar	map_ranges (SkScalar val, MapRanges const ranges[], int rangesCount)
static SkFontStyle	skfontstyle_from_fcpattern (FcPattern *pattern)
static void	fcpattern_from_skfontstyle (SkFontStyle style, FcPattern *pattern)
sk_sp< SkFontMgr >	SkFontMgr_New_FontConfig (FcConfig *fc)

Macro Definition Documentation

FC_POSTSCRIPT_NAME

#define FC_POSTSCRIPT_NAME   "postscriptname"

Definition at line 52 of file SkFontMgr_fontconfig.cpp.

FC_WEIGHT_DEMILIGHT

#define FC_WEIGHT_DEMILIGHT   65

Definition at line 316 of file SkFontMgr_fontconfig.cpp.

Typedef Documentation

SkAutoFcCharSet

typedef SkAutoFc<FcCharSet, FcCharSetCreate, FcCharSetDestroy> SkAutoFcCharSet

Definition at line 128 of file SkFontMgr_fontconfig.cpp.

SkAutoFcConfig

typedef SkAutoFc<FcConfig, FcConfigCreate, FcConfigDestroy> SkAutoFcConfig

Definition at line 129 of file SkFontMgr_fontconfig.cpp.

SkAutoFcFontSet

typedef SkAutoFc<FcFontSet, FcFontSetCreate, FcFontSetDestroy> SkAutoFcFontSet

Definition at line 130 of file SkFontMgr_fontconfig.cpp.

SkAutoFcLangSet

typedef SkAutoFc<FcLangSet, FcLangSetCreate, FcLangSetDestroy> SkAutoFcLangSet

Definition at line 131 of file SkFontMgr_fontconfig.cpp.

SkAutoFcObjectSet

typedef SkAutoFc<FcObjectSet, FcObjectSetCreate, FcObjectSetDestroy> SkAutoFcObjectSet

Definition at line 132 of file SkFontMgr_fontconfig.cpp.

SkAutoFcPattern

typedef SkAutoFc<FcPattern, FcPatternCreate, FcPatternDestroy> SkAutoFcPattern

Definition at line 133 of file SkFontMgr_fontconfig.cpp.

Enumeration Type Documentation

SkWeakReturn

enum SkWeakReturn

Enumerator
kIsWeak_WeakReturn
kIsStrong_WeakReturn
kNoId_WeakReturn

Definition at line 167 of file SkFontMgr_fontconfig.cpp.

                  {
    kIsWeak_WeakReturn,
    kIsStrong_WeakReturn,
    kNoId_WeakReturn
};

Function Documentation

fcpattern_from_skfontstyle()

static void fcpattern_from_skfontstyle ( SkFontStyle  style, FcPattern *  pattern  )

static

Definition at line 365 of file SkFontMgr_fontconfig.cpp.

                                                                              {
    FCLocker::AssertHeld();
 
    typedef SkFontStyle SkFS;
 
    // FcWeightFromOpenType was buggy until 2.12.4
    static constexpr MapRanges weightRanges[] = {
        { SkFS::kThin_Weight,       FC_WEIGHT_THIN },
        { SkFS::kExtraLight_Weight, FC_WEIGHT_EXTRALIGHT },
        { SkFS::kLight_Weight,      FC_WEIGHT_LIGHT },
        { 350,                      FC_WEIGHT_DEMILIGHT },
        { 380,                      FC_WEIGHT_BOOK },
        { SkFS::kNormal_Weight,     FC_WEIGHT_REGULAR },
        { SkFS::kMedium_Weight,     FC_WEIGHT_MEDIUM },
        { SkFS::kSemiBold_Weight,   FC_WEIGHT_DEMIBOLD },
        { SkFS::kBold_Weight,       FC_WEIGHT_BOLD },
        { SkFS::kExtraBold_Weight,  FC_WEIGHT_EXTRABOLD },
        { SkFS::kBlack_Weight,      FC_WEIGHT_BLACK },
        { SkFS::kExtraBlack_Weight, FC_WEIGHT_EXTRABLACK },
    };
    int weight = map_ranges(style.weight(), weightRanges, std::size(weightRanges));
 
    static constexpr MapRanges widthRanges[] = {
        { SkFS::kUltraCondensed_Width, FC_WIDTH_ULTRACONDENSED },
        { SkFS::kExtraCondensed_Width, FC_WIDTH_EXTRACONDENSED },
        { SkFS::kCondensed_Width,      FC_WIDTH_CONDENSED },
        { SkFS::kSemiCondensed_Width,  FC_WIDTH_SEMICONDENSED },
        { SkFS::kNormal_Width,         FC_WIDTH_NORMAL },
        { SkFS::kSemiExpanded_Width,   FC_WIDTH_SEMIEXPANDED },
        { SkFS::kExpanded_Width,       FC_WIDTH_EXPANDED },
        { SkFS::kExtraExpanded_Width,  FC_WIDTH_EXTRAEXPANDED },
        { SkFS::kUltraExpanded_Width,  FC_WIDTH_ULTRAEXPANDED },
    };
    int width = map_ranges(style.width(), widthRanges, std::size(widthRanges));
 
    int slant = FC_SLANT_ROMAN;
    switch (style.slant()) {
        case SkFS::kUpright_Slant: slant = FC_SLANT_ROMAN  ; break;
        case SkFS::kItalic_Slant : slant = FC_SLANT_ITALIC ; break;
        case SkFS::kOblique_Slant: slant = FC_SLANT_OBLIQUE; break;
        default: SkASSERT(false); break;
    }
 
    FcPatternAddInteger(pattern, FC_WEIGHT, weight);
    FcPatternAddInteger(pattern, FC_WIDTH , width);
    FcPatternAddInteger(pattern, FC_SLANT , slant);
}

FcTDestroy()

template<typename T , void(*)(T *) D>

void FcTDestroy

(

T *

t

)

Definition at line 111 of file SkFontMgr_fontconfig.cpp.

                                                          {
    FCLocker::AssertHeld();
    D(t);
}

get_bool()

static bool get_bool ( FcPattern *  pattern, const char  object[], bool  missing = false  )

static

Definition at line 135 of file SkFontMgr_fontconfig.cpp.

                                                                                    {
    FcBool value;
    if (FcPatternGetBool(pattern, object, 0, &value) != FcResultMatch) {
        return missing;
    }
    return value;
}

get_int()

static int get_int ( FcPattern *  pattern, const char  object[], int  missing  )

static

Definition at line 143 of file SkFontMgr_fontconfig.cpp.

                                                                         {
    int value;
    if (FcPatternGetInteger(pattern, object, 0, &value) != FcResultMatch) {
        return missing;
    }
    return value;
}

get_matrix()

static const FcMatrix * get_matrix ( FcPattern *  pattern, const char  object[]  )

static

Definition at line 159 of file SkFontMgr_fontconfig.cpp.

                                                                           {
    FcMatrix* matrix;
    if (FcPatternGetMatrix(pattern, object, 0, &matrix) != FcResultMatch) {
        return nullptr;
    }
    return matrix;
}

get_string()

static const char * get_string ( FcPattern *  pattern, const char  object[], const char *  missing = ""  )

static

Definition at line 151 of file SkFontMgr_fontconfig.cpp.

                                                                                                 {
    FcChar8* value;
    if (FcPatternGetString(pattern, object, 0, &value) != FcResultMatch) {
        return missing;
    }
    return (const char*)value;
}

is_weak()

static SkWeakReturn is_weak ( FcPattern *  pattern, const char  object[], int  id  )

static

Ideally there would exist a call like FcResult FcPatternIsWeak(pattern, object, id, FcBool* isWeak); Sometime after 2.12.4 FcPatternGetWithBinding was added which can retrieve the binding.

However, there is no such call and as of Fc 2.11.0 even FcPatternEquals ignores the weak bit. Currently, the only reliable way of finding the weak bit is by its effect on matching. The weak bit only affects the matching of FC_FAMILY and FC_POSTSCRIPT_NAME object values. A element with the weak bit is scored after FC_LANG, without the weak bit is scored before. Note that the weak bit is stored on the element, not on the value it holds.

Definition at line 182 of file SkFontMgr_fontconfig.cpp.

                                                                             {
    FCLocker::AssertHeld();
 
    FcResult result;
 
    // Create a copy of the pattern with only the value 'pattern'['object'['id']] in it.
    // Internally, FontConfig pattern objects are linked lists, so faster to remove from head.
    SkAutoFcObjectSet requestedObjectOnly(FcObjectSetBuild(object, nullptr));
    SkAutoFcPattern minimal(FcPatternFilter(pattern, requestedObjectOnly));
    FcBool hasId = true;
    for (int i = 0; hasId && i < id; ++i) {
        hasId = FcPatternRemove(minimal, object, 0);
    }
    if (!hasId) {
        return kNoId_WeakReturn;
    }
    FcValue value;
    result = FcPatternGet(minimal, object, 0, &value);
    if (result != FcResultMatch) {
        return kNoId_WeakReturn;
    }
    while (hasId) {
        hasId = FcPatternRemove(minimal, object, 1);
    }
 
    // Create a font set with two patterns.
    // 1. the same 'object' as minimal and a lang object with only 'nomatchlang'.
    // 2. a different 'object' from minimal and a lang object with only 'matchlang'.
    SkAutoFcFontSet fontSet;
 
    SkAutoFcLangSet strongLangSet;
    FcLangSetAdd(strongLangSet, (const FcChar8*)"nomatchlang");
    SkAutoFcPattern strong(FcPatternDuplicate(minimal));
    FcPatternAddLangSet(strong, FC_LANG, strongLangSet);
 
    SkAutoFcLangSet weakLangSet;
    FcLangSetAdd(weakLangSet, (const FcChar8*)"matchlang");
    SkAutoFcPattern weak;
    FcPatternAddString(weak, object, (const FcChar8*)"nomatchstring");
    FcPatternAddLangSet(weak, FC_LANG, weakLangSet);
 
    FcFontSetAdd(fontSet, strong.release());
    FcFontSetAdd(fontSet, weak.release());
 
    // Add 'matchlang' to the copy of the pattern.
    FcPatternAddLangSet(minimal, FC_LANG, weakLangSet);
 
    // Run a match against the copy of the pattern.
    // If the 'id' was weak, then we should match the pattern with 'matchlang'.
    // If the 'id' was strong, then we should match the pattern with 'nomatchlang'.
 
    // Note that this config is only used for FcFontRenderPrepare, which we don't even want.
    // However, there appears to be no way to match/sort without it.
    SkAutoFcConfig config;
    FcFontSet* fontSets[1] = { fontSet };
    SkAutoFcPattern match(FcFontSetMatch(config, fontSets, std::size(fontSets),
                                         minimal, &result));
 
    FcLangSet* matchLangSet;
    FcPatternGetLangSet(match, FC_LANG, 0, &matchLangSet);
    return FcLangEqual == FcLangSetHasLang(matchLangSet, (const FcChar8*)"matchlang")
                        ? kIsWeak_WeakReturn : kIsStrong_WeakReturn;
}

map_range()

static int map_range ( SkScalar  value, SkScalar  old_min, SkScalar  old_max, SkScalar  new_min, SkScalar  new_max  )

static

Definition at line 282 of file SkFontMgr_fontconfig.cpp.

{
    SkASSERT(old_min < old_max);
    SkASSERT(new_min <= new_max);
    return new_min + ((value - old_min) * (new_max - new_min) / (old_max - old_min));
}

map_ranges()

static SkScalar map_ranges ( SkScalar  val, MapRanges const  ranges[], int  rangesCount  )

static

Definition at line 296 of file SkFontMgr_fontconfig.cpp.

                                                                                    {
    // -Inf to [0]
    if (val < ranges[0].old_val) {
        return ranges[0].new_val;
    }
 
    // Linear from [i] to [i+1]
    for (int i = 0; i < rangesCount - 1; ++i) {
        if (val < ranges[i+1].old_val) {
            return map_range(val, ranges[i].old_val, ranges[i+1].old_val,
                                  ranges[i].new_val, ranges[i+1].new_val);
        }
    }
 
    // From [n] to +Inf
    // if (fcweight < Inf)
    return ranges[rangesCount-1].new_val;
}

remove_weak()

static void remove_weak ( FcPattern *  pattern, const char  object[]  )

static

Removes weak elements from either FC_FAMILY or FC_POSTSCRIPT_NAME objects in the property. This can be quite expensive, and should not be used more than once per font lookup. This removes all of the weak elements after the last strong element.

Definition at line 250 of file SkFontMgr_fontconfig.cpp.

                                                                 {
    FCLocker::AssertHeld();
 
    SkAutoFcObjectSet requestedObjectOnly(FcObjectSetBuild(object, nullptr));
    SkAutoFcPattern minimal(FcPatternFilter(pattern, requestedObjectOnly));
 
    int lastStrongId = -1;
    int numIds;
    SkWeakReturn result;
    for (int id = 0; ; ++id) {
        result = is_weak(minimal, object, 0);
        if (kNoId_WeakReturn == result) {
            numIds = id;
            break;
        }
        if (kIsStrong_WeakReturn == result) {
            lastStrongId = id;
        }
        SkAssertResult(FcPatternRemove(minimal, object, 0));
    }
 
    // If they were all weak, then leave the pattern alone.
    if (lastStrongId < 0) {
        return;
    }
 
    // Remove everything after the last strong.
    for (int id = lastStrongId + 1; id < numIds; ++id) {
        SkAssertResult(FcPatternRemove(pattern, object, lastStrongId + 1));
    }
}

SkFontMgr_New_FontConfig()

sk_sp< SkFontMgr > SkFontMgr_New_FontConfig

(

FcConfig *

fc

)

Create a font manager around a FontConfig instance. If 'fc' is NULL, will use a new default config. Takes ownership of 'fc' and will call FcConfigDestroy on it.

Definition at line 970 of file SkFontMgr_fontconfig.cpp.

                                                        {
    return sk_make_sp<SkFontMgr_fontconfig>(fc);
}

skfontstyle_from_fcpattern()

static SkFontStyle skfontstyle_from_fcpattern ( FcPattern *  pattern )

static

Definition at line 319 of file SkFontMgr_fontconfig.cpp.

                                                                  {
    typedef SkFontStyle SkFS;
 
    // FcWeightToOpenType was buggy until 2.12.4
    static constexpr MapRanges weightRanges[] = {
        { FC_WEIGHT_THIN,       SkFS::kThin_Weight },
        { FC_WEIGHT_EXTRALIGHT, SkFS::kExtraLight_Weight },
        { FC_WEIGHT_LIGHT,      SkFS::kLight_Weight },
        { FC_WEIGHT_DEMILIGHT,  350 },
        { FC_WEIGHT_BOOK,       380 },
        { FC_WEIGHT_REGULAR,    SkFS::kNormal_Weight },
        { FC_WEIGHT_MEDIUM,     SkFS::kMedium_Weight },
        { FC_WEIGHT_DEMIBOLD,   SkFS::kSemiBold_Weight },
        { FC_WEIGHT_BOLD,       SkFS::kBold_Weight },
        { FC_WEIGHT_EXTRABOLD,  SkFS::kExtraBold_Weight },
        { FC_WEIGHT_BLACK,      SkFS::kBlack_Weight },
        { FC_WEIGHT_EXTRABLACK, SkFS::kExtraBlack_Weight },
    };
    SkScalar weight = map_ranges(get_int(pattern, FC_WEIGHT, FC_WEIGHT_REGULAR),
                                 weightRanges, std::size(weightRanges));
 
    static constexpr MapRanges widthRanges[] = {
        { FC_WIDTH_ULTRACONDENSED, SkFS::kUltraCondensed_Width },
        { FC_WIDTH_EXTRACONDENSED, SkFS::kExtraCondensed_Width },
        { FC_WIDTH_CONDENSED,      SkFS::kCondensed_Width },
        { FC_WIDTH_SEMICONDENSED,  SkFS::kSemiCondensed_Width },
        { FC_WIDTH_NORMAL,         SkFS::kNormal_Width },
        { FC_WIDTH_SEMIEXPANDED,   SkFS::kSemiExpanded_Width },
        { FC_WIDTH_EXPANDED,       SkFS::kExpanded_Width },
        { FC_WIDTH_EXTRAEXPANDED,  SkFS::kExtraExpanded_Width },
        { FC_WIDTH_ULTRAEXPANDED,  SkFS::kUltraExpanded_Width },
    };
    SkScalar width = map_ranges(get_int(pattern, FC_WIDTH, FC_WIDTH_NORMAL),
                                widthRanges, std::size(widthRanges));
 
    SkFS::Slant slant = SkFS::kUpright_Slant;
    switch (get_int(pattern, FC_SLANT, FC_SLANT_ROMAN)) {
        case FC_SLANT_ROMAN:   slant = SkFS::kUpright_Slant; break;
        case FC_SLANT_ITALIC : slant = SkFS::kItalic_Slant ; break;
        case FC_SLANT_OBLIQUE: slant = SkFS::kOblique_Slant; break;
        default: SkASSERT(false); break;
    }
 
    return SkFontStyle(SkScalarRoundToInt(weight), SkScalarRoundToInt(width), slant);
}