自学教程：C++ FcPatternGetString函数代码示例

	std::string FontConfig::match_font(const std::string &typeface_name, const FontDescription &desc) const	{		FcPattern * fc_pattern = nullptr;		FcPattern * fc_match = nullptr;		try		{			int weight = static_cast<int>(desc.get_weight());			// Build font matching pattern.			fc_pattern = FcPatternBuild(nullptr,				FC_FAMILY, FcTypeString, typeface_name.c_str(),				FC_PIXEL_SIZE, FcTypeDouble, (double)std::abs(desc.get_height()),				FC_WEIGHT, FcTypeInteger, (weight > 0) ? (int)(weight * (FC_WEIGHT_HEAVY / 900.0)) : FC_WEIGHT_NORMAL,				FC_SLANT, FcTypeInteger, (desc.get_style() == clan::FontStyle::italic) ? FC_SLANT_ITALIC : ((desc.get_style() == clan::FontStyle::oblique) ? FC_SLANT_OBLIQUE : FC_SLANT_ROMAN),				FC_SPACING, FcTypeInteger, FC_PROPORTIONAL,				(char*) nullptr				);			if (!fc_pattern)			{				throw Exception("CL_FontConfig: Building FontConfig pattern failed.");			}			// Execute any needed param substitutions required by the system config.			if (FcTrue != FcConfigSubstitute(fc_config, fc_pattern, FcMatchPattern))			{				throw Exception("CL_FontConfig: Font config substitutions failed.");			}			// Supply default values for underspecified font patterns. Never fails.			FcDefaultSubstitute(fc_pattern);			// Find best match for pattern and extract filename.			FcResult match_result; // Doesn't appear to be actually updated.			fc_match = FcFontMatch(fc_config, fc_pattern, &match_result);			FcChar8 * fc_font_file_path = nullptr;			if (FcResultMatch != FcPatternGetString(fc_match, FC_FILE, 0, &fc_font_file_path))			{				throw Exception("CL_FontConfig: Could not resolve font pattern to a font file.");			}			// Release resources and return results.			std::string cl_font_file_path((char*)fc_font_file_path);			FcPatternDestroy(fc_match);			FcPatternDestroy(fc_pattern);			return cl_font_file_path;		}		catch (...)		{			// If any exceptions thrown, ensure fontconfig resources are released.			if (fc_match) FcPatternDestroy(fc_match);			if (fc_pattern) FcPatternDestroy(fc_pattern);			throw;		}	}

FontFileLister::CollectionResult FontConfigFontFileLister::GetFontPaths(std::string const& facename, int bold, bool italic, std::set<wxUniChar> const& characters) {	CollectionResult ret;	std::string family(facename);	if (family[0] == '@')		family.erase(0, 1);	boost::to_lower(family);	int weight = bold == 0 ? 80 :	             bold == 1 ? 200 :	                         bold;	int slant  = italic ? 110 : 0;	// Create a fontconfig pattern to match the desired weight/slant	agi::scoped_holder<FcPattern*> pat(FcPatternCreate(), FcPatternDestroy);	if (!pat) return ret;	FcPatternAddBool(pat, FC_OUTLINE, true);	FcPatternAddInteger(pat, FC_SLANT, slant);	FcPatternAddInteger(pat, FC_WEIGHT, weight);	FcDefaultSubstitute(pat);	if (!FcConfigSubstitute(config, pat, FcMatchPattern)) return ret;	// Create a font set with only correctly named fonts	// This is needed because the patterns returned by font matching only	// include the first family and fullname, so we can't always verify that	// we got the actual font we were asking for after the fact	agi::scoped_holder<FcFontSet*> fset(FcFontSetCreate(), FcFontSetDestroy);	find_font(FcConfigGetFonts(config, FcSetApplication), fset, family);	find_font(FcConfigGetFonts(config, FcSetSystem), fset, family);	// Get the best match from fontconfig	FcResult result;	FcFontSet *sets[] = { (FcFontSet*)fset };	agi::scoped_holder<FcPattern*> match(FcFontSetMatch(config, sets, 1, pat, &result), FcPatternDestroy);	if (!match)		return ret;	FcChar8 *file;	if(FcPatternGetString(match, FC_FILE, 0, &file) != FcResultMatch)		return ret;	FcCharSet *charset;	if (FcPatternGetCharSet(match, FC_CHARSET, 0, &charset) == FcResultMatch) {		for (wxUniChar chr : characters) {			if (!FcCharSetHasChar(charset, chr))				ret.missing += chr;		}	}	ret.paths.emplace_back((const char *)file);	return ret;}

std::stringXeTeXFontMgr_FC::getPlatformFontDesc(PlatformFontRef font) const{    std::string path;    FcChar8* s;    if (FcPatternGetString(font, FC_FILE, 0, (FcChar8**)&s) == FcResultMatch)        path = (char*)s;    else        path = "[unknown]";    return path;}

// This method just need to bypass the cache as we could register our alternative font.// This is a pity but is required to have asian fonts working.PassRefPtr<SimpleFontData> FontCache::getFontDataForCharacters(const Font& font, const UChar* characters, int length){    // Avoid copying FontPlatformData.    RefPtr<FontPlatformData> primaryFontPlatformData = font.primaryFont()->m_font;    // Check if the cache was already filled.    if (fallbacks.contains(&font)) {        ASSERT(primaryFontPlatformData->m_fallbacks);        FontFallbackCache::iterator it = fallbacks.find(&font);        return it->second;    }    if (!primaryFontPlatformData->m_fallbacks) {        FcResult fresult;        primaryFontPlatformData->m_fallbacks = FcFontSort(NULL, primaryFontPlatformData->m_pattern, FcTrue, NULL, &fresult);    }    FcFontSet* fs = primaryFontPlatformData->m_fallbacks;        for (int i = 0; i < fs->nfont; i++) {        FcPattern* fin = FcFontRenderPrepare(0, primaryFontPlatformData->m_pattern, fs->fonts[i]);        FcChar8* fc_filename;        if (FcPatternGetString(fin, FC_FILE, 0, &fc_filename) != FcResultMatch)            continue;        char* filename = (char *) fc_filename; // Use C cast as FcChar is a fontconfig type.        int id;        if (FcPatternGetInteger(fin, FC_INDEX, 0, &id) != FcResultMatch)            continue;        FT_Face face;        if (FT_Error error = FT_New_Face(FontPlatformData::m_library, filename, id, &face)) {            printf("FT_New_Face failed for filename = %s with FT_Error = %d/n", filename, error);            continue;        }        // FIXME: is it really necessary ?        FT_Set_Pixel_Sizes(face, 0, static_cast<uint> (font.fontDescription().computedSize()));        RefPtr<FontPlatformData> platformData = adoptRef(new FontPlatformData(face, font.fontDescription().computedPixelSize(), false, false));        platformData->m_pattern = fin;        if (platformData->containsCharacters(characters, length)) {            RefPtr<SimpleFontData> fontData = adoptRef(new SimpleFontData(platformData.get()));            fallbacks.add(&font, fontData);            return fontData;        }    }    // Fallback: use the font in the main cache.    RefPtr<SimpleFontData> fontData = getCachedFontData(font.fontDescription(), font.family().family());    return fontData;}

static void family_info(const FcPattern *pattern, family_info_t *fi){  FcChar8 *str;  fi->fontformat[0] = '/0';  fi->capability[0] = '/0';  fi->foundry[0] = '/0';    if (FcPatternGetString(pattern, FC_FONTFORMAT, 0, &str) == FcResultMatch)    snprintf(fi->fontformat, FONTFORMAT_MAX, "%s", str);  if (FcPatternGetString(pattern, FC_CAPABILITY, 0, &str) == FcResultMatch)    snprintf(fi->capability, CAPABILITY_MAX, "%s", str);  if (FcPatternGetString(pattern, FC_FOUNDRY, 0, &str) == FcResultMatch)    if (strcmp((char *)str, "unknown") != 0)      snprintf(fi->foundry, FOUNDRY_MAX, "%s", str);  return;}

FcResult fcinfo_get_translated_string(const FcPattern *pattern,                                       const char *object,                                       const FcChar8 *lang, FcChar8 **s){  FcChar8 *l;  int n;  FcResult r;  const char *lang_object;  if (strcmp(object, FC_FAMILY) == 0)    lang_object = FC_FAMILYLANG;  else if (strcmp(object, FC_STYLE) == 0)    lang_object = FC_STYLELANG;  else if (strcmp(object, FC_FULLNAME))    lang_object = FC_FULLNAMELANG;  else  {    fprintf(stderr, "fcinfo_get_translated_string():"                    " no translatable string/n");    exit (1);  }  if (FcPatternGetString(pattern, lang_object, 0, &l) != FcResultMatch)  {    /* no *_LANG element */    return FcPatternGetString(pattern, object, 0, s);  }  n = 0;  while ((r = FcPatternGetString(pattern, lang_object, n, &l)) == FcResultMatch)    if (FcStrCmp(l, lang) == 0)      break;    else      n++;      if (r != FcResultMatch)    n = 0; /* no lang found */    return FcPatternGetString(pattern, object, n, s);}

void Rcairo_set_font(int i, const char *fcname){	FcFontSet	*fs;	FcPattern   *pat, *match;	FcResult	result;	FcChar8	*file;	int j;	if (Rcairo_fonts[i].face != NULL){		cairo_font_face_destroy(Rcairo_fonts[i].face);		Rcairo_fonts[i].face = NULL;	}	pat = FcNameParse((FcChar8 *)fcname);	if (!pat){		error("Problem with font config library in Rcairo_set_font/n");		return;	}	FcConfigSubstitute (0, pat, FcMatchPattern);	FcDefaultSubstitute (pat);	fs = FcFontSetCreate ();	match = FcFontMatch (0, pat, &result);	FcPatternDestroy (pat);	if (match) {		FcFontSetAdd (fs, match);	} else {		error("No font found in Rcairo_set_font");		FcFontSetDestroy (fs);		return;	}	/* should be at least one font face in fontset */	if (fs) {		for (j = 0; j < fs->nfont; j++) {			/* Need to make sure a real font file exists */			if (FcPatternGetString (fs->fonts[j], FC_FILE, 0, &file) == FcResultMatch){				Rcairo_fonts[i].face = Rcairo_set_font_face(i,(const char *)file);				break;			}		}		FcFontSetDestroy (fs);		Rcairo_fonts[i].updated = 1;	} else {		error("No font found Rcairo_set_font");	}}

const std::string find_font(const char* name) {	std::string font_file;	FcConfig* config = FcInitLoadConfigAndFonts();	FcPattern* pattern = FcNameParse((const FcChar8*) (name));	FcConfigSubstitute(config, pattern, FcMatchPattern);	FcDefaultSubstitute(pattern);	FcPattern* font = FcFontMatch(config, pattern, NULL);	if (font) {		FcChar8* file = NULL;		if (FcPatternGetString(font, FC_FILE, 0, &file) == FcResultMatch)			font_file = std::string((char*) file);		FcPatternDestroy(font);	}	FcPatternDestroy(pattern);	return font_file;}

/** * /brief Case-insensitive match ASS/SSA font family against full name. (also * known as "name for humans") * * /param lib library instance * /param priv fontconfig instance * /param family font fullname * /param bold weight attribute * /param italic italic attribute * /return font set */static FcFontSet *match_fullname(ASS_Library *lib, FCInstance *priv, const char *family,               unsigned bold, unsigned italic){    FcFontSet *sets[2];    FcFontSet *result = FcFontSetCreate();    int nsets = 0;    int i, fi;    if (!result)        return NULL;    if ((sets[nsets] = FcConfigGetFonts(priv->config, FcSetSystem)))        nsets++;    if ((sets[nsets] = FcConfigGetFonts(priv->config, FcSetApplication)))        nsets++;    // Run over font sets and patterns and try to match against full name    for (i = 0; i < nsets; i++) {        FcFontSet *set = sets[i];        for (fi = 0; fi < set->nfont; fi++) {            FcPattern *pat = set->fonts[fi];            char *fullname;            int pi = 0, at;            FcBool ol;            while (FcPatternGetString(pat, FC_FULLNAME, pi++,                   (FcChar8 **) &fullname) == FcResultMatch) {                if (FcPatternGetBool(pat, FC_OUTLINE, 0, &ol) != FcResultMatch                    || ol != FcTrue)                    continue;                if (FcPatternGetInteger(pat, FC_SLANT, 0, &at) != FcResultMatch                    || at < italic)                    continue;                if (FcPatternGetInteger(pat, FC_WEIGHT, 0, &at) != FcResultMatch                    || at < bold)                    continue;                if (strcasecmp(fullname, family) == 0) {                    FcFontSetAdd(result, FcPatternDuplicate(pat));                    break;                }            }        }    }    return result;}

static const char * claro_ft2_get_family(claro_font_pattern_t * pattern){    FcPattern * fc_pattern;    FcResult res;    FcChar8 * family;    g_return_val_if_fail(pattern != NULL, NULL);    fc_pattern = (FcPattern *)pattern->native;    res = FcPatternGetString (fc_pattern, FC_FAMILY, 0, &family);    if(res != FcResultMatch)        return NULL;    else        return (const char *)family;}

/** * using fontconfig for just getting the font file name by a wanted font name and style. */char *get_font_filename(const char *family, const char *style) {	//initialize fontconfig	if (!FcInit()) {		throw util::Error{MSG(err) << "Failed to initialize fontconfig."};	}	//FcPattern *font_pattern = FcNameParse((const unsigned char *)"DejaVu Serif:style=Book");	FcPattern *font_pattern = FcPatternBuild(nullptr, FC_FAMILY, FcTypeString, family, nullptr);	FcPatternBuild(font_pattern, FC_STYLE, FcTypeString, style, nullptr);	//debug output: display above pattern as parsable string.	FcChar8 *query_string = FcNameUnparse(font_pattern);	log::log(MSG(info) << "Font queried: " << query_string);	free(query_string);	//tell fontconfig to find the best match	FcResult font_match_result;	FcPattern *font_match = FcFontMatch(nullptr, font_pattern, &font_match_result);	/*	//debug output: display matching font pattern as parsable string	FcChar8 *match_string = FcNameUnparse(font_match);	log::dbg2("resulting font: %s", match_string);	free(match_string);	*/	//get attibute FC_FILE (= filename) of best-matched font	FcChar8 *font_filename_tmp;	if (FcPatternGetString(font_match, FC_FILE, 0, &font_filename_tmp) != FcResultMatch) {		throw util::Error(MSG(err) << "Fontconfig could not provide font " << family << " " << style);	}	//copy the font filename because it will be freed when the pattern is destroyed.	char *font_filename = util::copy((const char *)font_filename_tmp);	log::log(MSG(info) << "Font file: " << font_filename);	//deinitialize fontconfig.	FcPatternDestroy(font_match);	FcPatternDestroy(font_pattern);	FcFini();	return font_filename;}

/** Find a font file from its family name. * @param font_config fontconfig instance * @param font_name name of the font * @return full path to the font file */gchar* find_font_file (FcConfig* font_config, const gchar* font_name) {	const FcChar8* name;	FcPattern* search_pattern;	FcPattern* font;	FcChar8* file;	gchar* path;	FcObjectSet* font_properties;	FcFontSet* fonts;	int i;	if (font_config == NULL) {		g_warning("Font config not loaded.");		return NULL;	}		path = NULL;	name = font_name;	search_pattern = FcPatternCreate ();	FcPatternAddString (search_pattern, FC_FAMILY, name);	FcPatternAddBool (search_pattern, FC_SCALABLE, FcTrue);	FcPatternAddInteger (search_pattern, FC_WEIGHT, FC_WEIGHT_MEDIUM);	FcPatternAddInteger (search_pattern, FC_SLANT, FC_SLANT_ROMAN);			font_properties = FcObjectSetBuild (FC_FILE, NULL);	fonts = FcFontList (font_config, search_pattern, font_properties);		if (fonts->nfont > 0) {		for (i = 0; i < fonts->nfont; i++) {			font = fonts->fonts[i];						if (FcPatternGetString(font, FC_FILE, 0, &file) == FcResultMatch) {				path = g_strdup ((gchar*) file);				break;			}		}		FcPatternDestroy (font);	}	FcPatternDestroy (search_pattern);		return path;}

const SimpleFontData* FontCache::getFontDataForCharacters(const Font& font, const UChar* characters, int length){    FcResult fresult;    // Avoid copying FontPlatformData.    FontPlatformData* prim = const_cast<FontPlatformData*>(&font.primaryFont()->m_font);    if (!prim->m_fallbacks)        prim->m_fallbacks = FcFontSort(NULL, prim->m_pattern, FcTrue, NULL, &fresult);    FcFontSet* fs = prim->m_fallbacks;        FT_Library library = FontPlatformData::m_library;    FcChar8* fc_filename;    char* filename;    int id;    FT_Face face;    for (int i = 0; i < fs->nfont; i++) {        FcPattern* fin = FcFontRenderPrepare(0, prim->m_pattern, fs->fonts[i]);        if (FcPatternGetString(fin, FC_FILE, 0, &fc_filename) != FcResultMatch)            continue;        filename = (char *) fc_filename; // Use C cast as FcChar is a fontconfig type.        if (FcPatternGetInteger(fin, FC_INDEX, 0, &id) != FcResultMatch)            continue;        if (FT_Error error = FT_New_Face(library, filename, id, &face))            continue;        // FIXME: is it really necessary ?        FT_Set_Pixel_Sizes(face, 0, static_cast<uint> (font.fontDescription().computedSize()));        FontPlatformData alternateFont(face, font.fontDescription().computedPixelSize(), false, false);        // FIXME: FT_Done_Face(face); we should clean the face correctly the FT_Face but we can't do that here...        alternateFont.m_pattern = fin;        SimpleFontData* sfd = getCachedFontData(&alternateFont);        if (sfd->containsCharacters(characters, length))            return sfd;    }    return 0;}

Vector<String> FontCache::systemFontFamilies(){    RefPtr<FcPattern> scalablesOnlyPattern = adoptRef(FcPatternCreate());    FcPatternAddBool(scalablesOnlyPattern.get(), FC_SCALABLE, FcTrue);    FcUniquePtr<FcObjectSet> familiesOnly(FcObjectSetBuild(FC_FAMILY, nullptr));    FcUniquePtr<FcFontSet> fontSet(FcFontList(nullptr, scalablesOnlyPattern.get(), familiesOnly.get()));    Vector<String> fontFamilies;    for (int i = 0; i < fontSet->nfont; i++) {        FcPattern* pattern = fontSet->fonts[i];        FcChar8* family = nullptr;        FcPatternGetString(pattern, FC_FAMILY, 0, &family);        if (family)            fontFamilies.appendVector(patternToFamilies(*pattern));    }    return fontFamilies;}

FcStrSet *fcinfo_fontformats(const FcPattern *filter){  FcFontSet *fontset;  FcStrSet *result;  FcChar8 *format;  int f;  FcInit();  fontset = fcinfo(NULL, filter, FcFalse, 1, FC_FONTFORMAT);  result = FcStrSetCreate();  for (f = 0; f < fontset->nfont; f++)  {    assert(FcPatternGetString(fontset->fonts[f], FC_FONTFORMAT, 0, &format)             == FcResultMatch);    FcStrSetAdd(result, format);  }  return result;}

bool platform_get_font_path(TTFFontDescriptor *font, utf8 *buffer, size_t size){    assert(buffer != NULL);    assert(font != NULL);    log_verbose("Looking for font %s with FontConfig.", font->font_name);    FcConfig* config = FcInitLoadConfigAndFonts();    if (!config)    {        log_error("Failed to initialize FontConfig library");        FcFini();        return false;    }    FcPattern* pat = FcNameParse((const FcChar8*) font->font_name);    FcConfigSubstitute(config, pat, FcMatchPattern);    FcDefaultSubstitute(pat);    bool found = false;    FcResult result = FcResultNoMatch;    FcPattern* match = FcFontMatch(config, pat, &result);    if (match)    {        FcChar8* filename = NULL;        if (FcPatternGetString(match, FC_FILE, 0, &filename) == FcResultMatch)        {            found = true;            safe_strcpy(buffer, (utf8*) filename, size);            log_verbose("FontConfig provided font %s", filename);        }        FcPatternDestroy(match);    } else {        log_warning("Failed to find required font.");    }    FcPatternDestroy(pat);    FcConfigDestroy(config);    FcFini();    return found;}

static int find_font(info_rec* info, char* family, char* path){    FcPattern*	pattern;    FcPattern*	matchedPattern;    FcResult	result;    FcChar8*	s;    pattern = FcPatternBuild(NULL, FC_FAMILY, FcTypeString, family,                             (char*) NULL);    if (pattern == NULL)        return YUV_fontconfig;    if (FcConfigSubstitute(info->config, pattern, FcMatchPattern) != FcTrue)        return YUV_fontconfig;    FcDefaultSubstitute(pattern);    matchedPattern = FcFontMatch(info->config, pattern, &result);    FcPatternDestroy(pattern);    if (FcPatternGetString(matchedPattern, FC_FILE, 0, &s) != FcResultMatch)        return YUV_fontconfig;    strcpy(path, (char*)s);    FcPatternDestroy(matchedPattern);    return YUV_OK;}

value fcFindFont( value _familyName, value _weight, value _slant, value _size ) {	val_check(_familyName,string);	val_check(_weight,number);	val_check(_slant,number);	val_check(_size,number);        const char *familyName = val_string(_familyName);    int weight = val_number(_weight);    int slant = val_number(_slant);    float size = val_number(_size);    	FcPattern *pattern;	pattern = FcNameParse( (FcChar8*)familyName );	FcDefaultSubstitute( pattern );	FcConfigSubstitute( FcConfigGetCurrent(), pattern, FcMatchPattern );		FcResult result;	FcPattern *match = FcFontMatch( 0, pattern, &result );		FcPatternDestroy( pattern );		if( !match ) val_throw(alloc_string("Could not find font"));		FcChar8 *temp;	int id;	pattern = FcPatternDuplicate(match);	if( FcPatternGetString( pattern, FC_FILE, 0, &temp ) != FcResultMatch ||	    FcPatternGetInteger( pattern, FC_INDEX, 0, &id ) != FcResultMatch ) {		val_throw(alloc_string("Could not load font"));	}	value ret = alloc_string((const char *)temp);	FcPatternDestroy( pattern );	FcPatternDestroy( match );		return ret;}

TTF_Font *load_font(const char *font_spec){  int font_size;  char *font_name;  /* figure out font size from name, or default to 24 */  char *sep = strchr(font_spec, ':');  if(sep) {    font_name = strndup(font_spec, sep - font_spec);    font_size = strtol(sep+1, NULL, 10);  } else {    font_name = strdup(font_spec);    font_size = 24;  }  FcConfig *cfg = FcInitLoadConfigAndFonts();  FcPattern *pattern = FcNameParse((const FcChar8*)font_name);  FcConfigSubstitute(cfg, pattern, FcMatchPattern);  FcDefaultSubstitute(pattern);  TTF_Font *ret = NULL;  FcResult result = FcResultNoMatch;  FcPattern* font = FcFontMatch(cfg, pattern, &result);  if (font) {    FcChar8 *path = NULL;    if (FcPatternGetString(font, FC_FILE, 0, &path) == FcResultMatch) {      ret = TTF_OpenFont((char*)path, font_size);    }    FcPatternDestroy(font);  }  FcPatternDestroy(pattern);  FcConfigDestroy(cfg);  free(font_name);  return ret;}

GeeArrayList *FcListFamilies(void){    int          i;    FcPattern    * pattern;    FcFontSet    * fontset;    FcObjectSet  * objectset = 0;    GeeArrayList * famlist = gee_array_list_new(G_TYPE_STRING,                                                (GBoxedCopyFunc) g_strdup,                                                (GDestroyNotify) g_free0,                                                NULL,                                                NULL,                                                NULL);    g_assert(FcInit());    pattern = FcNameParse((FcChar8 *) ":");    objectset = FcObjectSetBuild (FC_FAMILY, NULL);    fontset = FcFontList(NULL, pattern, objectset);    for (i = 0; i < fontset->nfont; i++) {        FcChar8 * family;        if (FcPatternGetString(fontset->fonts[i], FC_FAMILY, 0, &family) == FcResultMatch) {            if (gee_abstract_collection_contains((GeeAbstractCollection *) famlist, family))                continue;            else                gee_abstract_collection_add((GeeAbstractCollection *) famlist, family);        }    }    if (objectset)        FcObjectSetDestroy(objectset);    if (pattern)        FcPatternDestroy(pattern);    if (fontset)        FcFontSetDestroy(fontset);    return famlist;}

const SimpleFontData* FontCache::getFontDataForCharacters(const Font& font,                                                          const UChar* characters,                                                          int length){    FcCharSet* cset = FcCharSetCreate();    for (int i = 0; i < length; ++i)        FcCharSetAddChar(cset, characters[i]);    FcPattern* pattern = FcPatternCreate();    FcValue fcvalue;    fcvalue.type = FcTypeCharSet;    fcvalue.u.c = cset;    FcPatternAdd(pattern, FC_CHARSET, fcvalue, 0);    FcConfigSubstitute(0, pattern, FcMatchPattern);    FcDefaultSubstitute(pattern);    FcResult result;    FcPattern* match = FcFontMatch(0, pattern, &result);    FcPatternDestroy(pattern);    SimpleFontData* ret = 0;    if (match) {        FcChar8* family;        if (FcPatternGetString(match, FC_FAMILY, 0, &family) == FcResultMatch) {            AtomicString fontFamily(reinterpret_cast<char*>(family));            ret = getCachedFontData(getCachedFontPlatformData(font.fontDescription(), fontFamily, false));        }        FcPatternDestroy(match);    }    FcCharSetDestroy(cset);    return ret;}

int BC_Resources::find_font_by_char(FT_ULong char_code, char *path_new, const FT_Face oldface){	FcPattern *font, *ofont;	FcChar8 *file;	int result = 0;	*path_new = 0;	// Do not search control codes	if(char_code < ' ')		return 0;	if( (ofont = FcFreeTypeQueryFace(oldface, (const FcChar8*)"", 4097, 0)) != 0 ) {		if( (font = find_similar_font(char_code, ofont)) != 0 ) {			if(FcPatternGetString(font, FC_FILE, 0, &file) == FcResultMatch) {				strcpy(path_new, (char*)file);				result = 1;			}			FcPatternDestroy(font);		}		FcPatternDestroy(ofont);	}	return result;}

/** * @brief Tries to find a system font. */static char *gl_fontFind( const char *fname ){   FcConfig* config;   FcPattern *pat, *font;   FcResult result;   FcChar8* file;   char *fontFile;      config = FcInitLoadConfigAndFonts();   pat = FcNameParse( (const FcChar8*)fname );   FcConfigSubstitute( config, pat, FcMatchPattern );   FcDefaultSubstitute(pat);   font = FcFontMatch(config, pat, &result);   if (font) {      file = NULL;      if (FcPatternGetString(font, FC_FILE, 0, &file) == FcResultMatch) {         fontFile = strdup( (char*)file );         FcPatternDestroy(pat);         return fontFile;      }   }   FcPatternDestroy(pat);   return NULL;}

voidXeTeXFontMgr_FC::cacheFamilyMembers(const std::list<std::string>& familyNames){	if (familyNames.size() == 0)		return;	for (int f = 0; f < allFonts->nfont; ++f) {		FcPattern*	pat = allFonts->fonts[f];		if (platformRefToFont.find(pat) != platformRefToFont.end())			continue;		char*	s;		for (int i = 0; FcPatternGetString(pat, FC_FAMILY, i, (FcChar8**)&s) == FcResultMatch; ++i) {			for (std::list<std::string>::const_iterator j = familyNames.begin(); j != familyNames.end(); ++j) {				if (*j == s) {					NameCollection*	names = readNames(pat);					addToMaps(pat, names);					delete names;					goto cached;				}			}		}	cached:		;	}}

Common::SeekableReadStream *FontconfigFontProvider::createReadStreamForFont(const Common::String &name, uint32 style) {	if (!_config)		return 0;	Common::String styleName = makeStyleString(style);	FcPattern *pattern = FcPatternCreate();	// Match on the family name	FcValue value;	value.type = FcTypeString;	value.u.s = reinterpret_cast<const FcChar8 *>(name.c_str());	if (!FcPatternAdd(pattern, FC_FAMILY, value, FcFalse)) {		FcPatternDestroy(pattern);		return 0;	}	// Match on the style string	value.u.s = reinterpret_cast<const FcChar8 *>(styleName.c_str());	if (!FcPatternAdd(pattern, FC_STYLE, value, FcFalse)) {		FcPatternDestroy(pattern);		return 0;	}	// Only allow TrueType fonts	// Might change in the future.	value.u.s = reinterpret_cast<const FcChar8 *>("TrueType");	if (!FcPatternAdd(pattern, FC_FONTFORMAT, value, FcFalse)) {		FcPatternDestroy(pattern);		return 0;	}	// Call these functions	// Might be doing pattern matching. Documentation is awful.	FcConfigSubstitute(0, pattern, FcMatchPattern);	FcDefaultSubstitute(pattern);	// Fetch the match	FcResult result;	FcFontSet* fontSet = FcFontSort(0, pattern, 0, 0, &result);	FcPatternDestroy(pattern);	if (!fontSet)		return 0;	for (int i = 0; i < fontSet->nfont; i++) {		FcPattern *foundPattern = fontSet->fonts[i];		// Get the family name of the font		FcChar8 *familyName;		if (FcPatternGetString(foundPattern, FC_FAMILY, 0, &familyName) != FcResultMatch)			continue;		// If we don't actually match, bail out. We don't want to end		// up with the default fontconfig font, which would look horrible.		if (!name.equalsIgnoreCase(reinterpret_cast<const char *>(familyName)))			continue;		// Get the name of the font		FcChar8 *fileName;		if (FcPatternGetString(foundPattern, FC_FILE, 0, &fileName) != FcResultMatch)			continue;		// Let's make sure we can actually get that		Common::FSNode fontNode(reinterpret_cast<const char *>(fileName));		if (!fontNode.exists() || !fontNode.isReadable())			continue;		debug(1, "Matched %s %s -> '%s'", name.c_str(), styleName.c_str(), fontNode.getPath().c_str());		FcFontSetDestroy(fontSet);		return fontNode.createReadStream();	}	// We ain't found s#&t	FcFontSetDestroy(fontSet);	return 0;}

MagickExport MagickBooleanType LoadFontConfigFonts(SplayTreeInfo *type_list,  ExceptionInfo *exception){#if !defined(FC_FULLNAME)#define FC_FULLNAME "fullname"#endif  char    extension[MaxTextExtent],    name[MaxTextExtent];  FcChar8    *family,    *file,    *fullname,    *style;  FcConfig    *font_config;  FcFontSet    *font_set;  FcObjectSet    *object_set;  FcPattern    *pattern;  FcResult    status;  int    slant,    width,    weight;  register ssize_t    i;  TypeInfo    *type_info;  /*    Load system fonts.  */  (void) exception;  font_config=FcInitLoadConfigAndFonts();  if (font_config == (FcConfig *) NULL)    return(MagickFalse);  font_set=(FcFontSet *) NULL;  object_set=FcObjectSetBuild(FC_FULLNAME,FC_FAMILY,FC_STYLE,FC_SLANT,    FC_WIDTH,FC_WEIGHT,FC_FILE,(char *) NULL);  if (object_set != (FcObjectSet *) NULL)    {      pattern=FcPatternCreate();      if (pattern != (FcPattern *) NULL)        {          font_set=FcFontList(0,pattern,object_set);          FcPatternDestroy(pattern);        }      FcObjectSetDestroy(object_set);    }  if (font_set == (FcFontSet *) NULL)    {      FcConfigDestroy(font_config);      return(MagickFalse);    }  for (i=0; i < (ssize_t) font_set->nfont; i++)  {    status=FcPatternGetString(font_set->fonts[i],FC_FAMILY,0,&family);    if (status != FcResultMatch)      continue;    status=FcPatternGetString(font_set->fonts[i],FC_FILE,0,&file);    if (status != FcResultMatch)      continue;    *extension='/0';    GetPathComponent((const char *) file,ExtensionPath,extension);    if ((*extension != '/0') && (LocaleCompare(extension,"gz") == 0))      continue;    type_info=(TypeInfo *) AcquireMagickMemory(sizeof(*type_info));    if (type_info == (TypeInfo *) NULL)      continue;    (void) ResetMagickMemory(type_info,0,sizeof(*type_info));    type_info->path=ConstantString("System Fonts");    type_info->signature=MagickSignature;    (void) CopyMagickString(name,"Unknown",MaxTextExtent);    status=FcPatternGetString(font_set->fonts[i],FC_FULLNAME,0,&fullname);    if ((status == FcResultMatch) && (fullname != (FcChar8 *) NULL))      (void) CopyMagickString(name,(const char *) fullname,MaxTextExtent);    else      {        if (family != (FcChar8 *) NULL)          (void) CopyMagickString(name,(const char *) family,MaxTextExtent);        status=FcPatternGetString(font_set->fonts[i],FC_STYLE,0,&style);        if ((status == FcResultMatch) && (style != (FcChar8 *) NULL) &&            (LocaleCompare((const char *) style,"Regular") != 0))          {            (void) ConcatenateMagickString(name," ",MaxTextExtent);            (void) ConcatenateMagickString(name,(const char *) style,//.........这里部分代码省略.........

//.........这里部分代码省略.........	char tmpstring[BCTEXTLEN];	if(!FcInit())		return 1;	config = FcConfigGetCurrent();	FcConfigSetRescanInterval(config, 0);	pat = FcPatternCreate();	os = FcObjectSetBuild ( FC_FAMILY, FC_FILE, FC_FOUNDRY, FC_WEIGHT,		FC_WIDTH, FC_SLANT, FC_FONTFORMAT, FC_SPACING, FC_STYLE, (char *) 0);	FcPatternAddBool(pat, FC_SCALABLE, true);	if(language[0]) {		char langstr[LEN_LANG * 3];		strcpy(langstr, language);		if(region[0]) {			strcat(langstr, "-");			strcat(langstr, region);		}		FcLangSet *ls =  FcLangSetCreate();		if(FcLangSetAdd(ls, (const FcChar8*)langstr))		if(FcPatternAddLangSet(pat, FC_LANG, ls))		FcLangSetDestroy(ls);	}	fs = FcFontList(config, pat, os);	FcPatternDestroy(pat);	FcObjectSetDestroy(os);	for (i = 0; fs && i < fs->nfont; i++) {		FcPattern *font = fs->fonts[i];		force_style = 0;		FcPatternGetString(font, FC_FONTFORMAT, 0, &format);		//on this point you can limit font search		if(limit_to_trutype && strcmp((char *)format, "TrueType"))			continue;		sprintf(tmpstring, "%s", format);		BC_FontEntry *entry = new BC_FontEntry;		if(FcPatternGetString(font, FC_FILE, 0, &file) == FcResultMatch) {			entry->path = cstrdup((char*)file);		}		if(FcPatternGetString(font, FC_FOUNDRY, 0, &foundry) == FcResultMatch) {			entry->foundry = cstrdup((char*)foundry);		}		if(FcPatternGetInteger(font, FC_WEIGHT, 0, &weight) == FcResultMatch) {			switch(weight) {			case FC_WEIGHT_THIN:			case FC_WEIGHT_EXTRALIGHT:			case FC_WEIGHT_LIGHT:			case FC_WEIGHT_BOOK:				force_style = 1;				entry->weight = cstrdup("medium");				break;			case FC_WEIGHT_NORMAL:			case FC_WEIGHT_MEDIUM:			default:				entry->weight = cstrdup("medium");				break;			case FC_WEIGHT_BLACK:			case FC_WEIGHT_SEMIBOLD: