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

static voidcreate_file_monitors (FontViewModel *self){    FcConfig *config;    FcStrList *str_list;    FcChar8 *path;    GFile *file;    GFileMonitor *monitor;    config = FcConfigGetCurrent ();    str_list = FcConfigGetFontDirs (config);    while ((path = FcStrListNext (str_list)) != NULL) {        file = g_file_new_for_path ((const gchar *) path);        monitor = g_file_monitor (file, G_FILE_MONITOR_NONE,                                  NULL, NULL);        if (monitor != NULL) {            self->priv->monitors = g_list_prepend (self->priv->monitors, monitor);            g_signal_connect (monitor, "changed",                              G_CALLBACK (file_monitor_changed_cb), self);        }        g_object_unref (file);    }    FcStrListDone (str_list);}

void manager::init() const{	LOG_FT << "Cairo version: " << cairo_version_string() << std::endl;	LOG_FT << "Pango version: " << pango_version_string() << std::endl;#ifdef CAIRO_HAS_FT_FONT	if (!FcConfigAppFontAddDir(FcConfigGetCurrent(),		reinterpret_cast<const FcChar8 *>((game_config::path + "/fonts").c_str())))	{		ERR_FT << "Could not load the true type fonts" << std::endl;		throw error();	}#endif#if CAIRO_HAS_WIN32_FONT	BOOST_FOREACH(const std::string& path, filesystem::get_binary_paths("fonts")) {		std::vector<std::string> files;		if(filesystem::is_directory(path))			filesystem::get_files_in_dir(path, &files, NULL, filesystem::ENTIRE_FILE_PATH);		BOOST_FOREACH(const std::string& file, files) {			if(file.substr(file.length() - 4) == ".ttf" || file.substr(file.length() - 4) == ".ttc")			{				utf16::string ufile = unicode_cast<utf16::string>(file);				std::wstring wfile(ufile.begin(), ufile.end());				AddFontResourceW(wfile.c_str());			}		}	}#endif}

voidXeTeXFontMgr_FC::initialize(){	if (FcInit() == FcFalse) {		fprintf(stderr, "fontconfig initialization failed!/n");		exit(9);	}	if (gFreeTypeLibrary == 0 && FT_Init_FreeType(&gFreeTypeLibrary) != 0) {		fprintf(stderr, "FreeType initialization failed!/n");		exit(9);	}	UErrorCode	err = U_ZERO_ERROR;	macRomanConv = ucnv_open("macintosh", &err);	utf16beConv = ucnv_open("UTF16BE", &err);	utf8Conv = ucnv_open("UTF8", &err);	if (err != 0) {		fprintf(stderr, "internal error; cannot read font names/n");		exit(3);	}	FcPattern*		pat = FcNameParse((const FcChar8*)":outline=true");	FcObjectSet*	os = FcObjectSetBuild(FC_FAMILY, FC_STYLE, FC_FILE, FC_INDEX,											FC_FULLNAME, FC_WEIGHT, FC_WIDTH, FC_SLANT, NULL);	allFonts = FcFontList(FcConfigGetCurrent(), pat, os);	FcObjectSetDestroy(os);	FcPatternDestroy(pat);		cachedAll = false;}

FcBoolFcConfigUptoDate (FcConfig *config){    FcFileTime	config_time, config_dir_time, font_time;    time_t	now = time(0);    if (!config)    {	config = FcConfigGetCurrent ();	if (!config)	    return FcFalse;    }    config_time = FcConfigNewestFile (config->configFiles);    config_dir_time = FcConfigNewestFile (config->configDirs);    font_time = FcConfigNewestFile (config->fontDirs);    if ((config_time.set && config_time.time - config->rescanTime > 0) ||	(config_dir_time.set && (config_dir_time.time - config->rescanTime) > 0) ||	(font_time.set && (font_time.time - config->rescanTime) > 0))    {	/* We need to check for potential clock problems here (OLPC ticket #6046) */	if ((config_time.set && (config_time.time - now) > 0) ||    	(config_dir_time.set && (config_dir_time.time - now) > 0) ||        (font_time.set && (font_time.time - now) > 0))	{	    fprintf (stderr,                    "Fontconfig warning: Directory/file mtime in the future. New fonts may not be detected./n");	    config->rescanTime = now;	    return FcTrue;	}	else	    return FcFalse;    }    config->rescanTime = now;    return FcTrue;}

bool sui_font_fromfc(sui_font *font, sui_library *l, char **error, FcPattern *pattern){    FcResult res;    FcConfig *config = FcConfigGetCurrent();    if (!FcConfigSubstitute(config, pattern, FcMatchFont)) {        *error = sui_aprintf("FcConfigSubstitute: Allocation failure");        return false;    }    FcDefaultSubstitute(pattern);    FcPattern *match = FcFontMatch(config, pattern, &res);    if (res != FcResultMatch) {        *error = sui_aprintf("FcFontMatch: %s", sui_result_name(res));        return false;    }    FcChar8 *file;    int index;    res = FcPatternGetString(match, FC_FILE, 0, &file);    if (res != FcResultMatch) {        *error = sui_aprintf("FcPatternGetString FC_FILE: %s", sui_result_name(res));        return false;    }    res = FcPatternGetInteger(match, FC_INDEX, 0, &index);    if (res != FcResultMatch) {        *error = sui_aprintf("FcPatternGetInteger FC_INDEX: %s", sui_result_name(res));        return false;    }    FT_Error fterr;    if ((fterr = FT_New_Face(l->library, (const char*)file, index, &font->face))) {        *error = sui_aprintf("FT_New_Face: Error code %i", fterr);        return false;    }    return font_fromfont(font, l, error, font->face);}

FcBoolFcConfigBuildFonts (FcConfig *config){    FcFontSet	    *fonts;    if (!config)    {      config = FcConfigGetCurrent ();      if (!config)        return FcFalse;    }    fonts = FcFontSetCreate ();    if (!fonts)      return FcFalse;    FcConfigSetFonts (config, fonts, FcSetSystem);  if (!FcConfigAddDirList (config, FcSetSystem, config->fontDirs)) {    if(FcDebug ())      fprintf(stderr,"Failed to get list of available fonts.");    return FcFalse;  }    //if (FcDebug () & FC_DBG_FONTSET)#ifdef DEBUG  FcFontSetPrint (fonts);#endif  return FcTrue;}

gbooleanFcLoadConfig(const gchar * filepath){    g_assert(FcInit());    gboolean result = FcConfigParseAndLoad(FcConfigGetCurrent(), (FcChar8 *) filepath, FALSE);    return result;}

FcBoolFcFileScan (FcFontSet	    *set,	    FcStrSet	    *dirs,	    FcFileCache	    *cache, /* XXX unused */	    FcBlanks	    *blanks,	    const FcChar8   *file,	    FcBool	    force){    return FcFileScanConfig (set, dirs, blanks, file, FcConfigGetCurrent ());}

FcStrList *FcConfigGetCacheDirs (const FcConfig *config){    if (!config)    {	config = FcConfigGetCurrent ();	if (!config)	    return 0;    }    return FcStrListCreate (config->cacheDirs);}

VALUEshoes_font_list(){  VALUE ary = rb_ary_new();  FcConfig *fc = FcConfigGetCurrent();  FcFontSet *fonts = FcConfigGetFonts(fc, FcSetApplication);  if (fonts) shoes_make_font_list(fonts, ary);  fonts = FcConfigGetFonts(fc, FcSetSystem);  if (fonts) shoes_make_font_list(fonts, ary);  return ary;}

FcStrList *FcConfigGetConfigFiles (FcConfig    *config){    if (!config)    {	config = FcConfigGetCurrent ();	if (!config)	    return 0;    }    return FcStrListCreate (config->configFiles);}

intFcConfigGetRescanInterval (FcConfig *config){    if (!config)    {	config = FcConfigGetCurrent ();	if (!config)	    return 0;    }    return config->rescanInterval;}

FcBlanks *FcConfigGetBlanks (FcConfig	*config){    if (!config)    {	config = FcConfigGetCurrent ();	if (!config)	    return 0;    }    return config->blanks;}

FcStrList *FcConfigGetFontDirs (FcConfig	*config){    if (!config)    {	config = FcConfigGetCurrent ();	if (!config)	    return 0;    }    return FcStrListCreate (config->fontDirs);}

manager::manager(){#ifdef CAIRO_HAS_FT_FONT    std::string font_path = game_config::path + "/fonts";    if (!FcConfigAppFontAddDir(FcConfigGetCurrent(),                               reinterpret_cast<const FcChar8 *>(font_path.c_str())))    {        ERR_FT << "Could not load the true type fonts" << std::endl;        throw font::error("font config lib failed to add the font path: '" + font_path + "'");    }    std::string font_file = font_path + "/fonts.conf";    if(!FcConfigParseAndLoad(FcConfigGetCurrent(),                             reinterpret_cast<const FcChar8*>(font_file.c_str()),                             FcFalse))    {        ERR_FT << "Could not load local font configuration/n";        throw font::error("font config lib failed to find font.conf: '" + font_file + "'");    }    else    {        LOG_FT << "Local font configuration loaded/n";    }#endif#if CAIRO_HAS_WIN32_FONT    for(const std::string& path : filesystem::get_binary_paths("fonts")) {        std::vector<std::string> files;        if(filesystem::is_directory(path)) {            filesystem::get_files_in_dir(path, &files, nullptr, filesystem::ENTIRE_FILE_PATH);        }        for(const std::string& file : files) {            if(file.substr(file.length() - 4) == ".ttf" || file.substr(file.length() - 4) == ".ttc")            {                const std::wstring wfile = unicode_cast<std::wstring>(file);                AddFontResourceExW(wfile.c_str(), FR_PRIVATE, nullptr);            }        }    }#endif}

FcBoolFcConfigSetRescanInterval (FcConfig *config, int rescanInterval){    if (!config)    {	config = FcConfigGetCurrent ();	if (!config)	    return FcFalse;    }    config->rescanInterval = rescanInterval;    return FcTrue;}

FcFontSet *FcConfigGetFonts (FcConfig	*config,		  FcSetName	set){    if (!config)    {	config = FcConfigGetCurrent ();	if (!config)	    return 0;    }    return config->fonts[set];}

FcBoolFcDirScan (FcFontSet	    *set,	   FcStrSet	    *dirs,	   FcFileCache	    *cache, /* XXX unused */	   FcBlanks	    *blanks,	   const FcChar8    *dir,	   FcBool	    force /* XXX unused */){    if (cache || !force)	return FcFalse;    return FcDirScanConfig (set, dirs, blanks, dir, force, FcConfigGetCurrent ());}

FcConfig *FcConfigReference (FcConfig *config){    if (!config)    {	config = FcConfigGetCurrent ();	if (!config)	    return 0;    }    FcRefInc (&config->ref);    return config;}

FcConfig *FcConfigReference (FcConfig *config){    if (!config)    {	config = FcConfigGetCurrent ();	if (!config)	    return 0;    }    config->ref++;    return config;}

intmain (int argc, char **argv){    FcConfig *config;    FcConfigFileInfoIter iter;#if HAVE_GETOPT_LONG || HAVE_GETOPT    int		c;    setlocale (LC_ALL, "");#if HAVE_GETOPT_LONG    while ((c = getopt_long (argc, argv, "Vh", longopts, NULL)) != -1)#else    while ((c = getopt (argc, argv, "Vh")) != -1)#endif    {	switch (c) {	case 'V':	    fprintf (stderr, "fontconfig version %d.%d.%d/n",		     FC_MAJOR, FC_MINOR, FC_REVISION);	    exit (0);	case 'h':	    usage (argv[0], 0);	default:	    usage (argv[0], 1);	}    }#endif    config = FcConfigGetCurrent ();    FcConfigFileInfoIterInit (config, &iter);    do    {	FcChar8 *name, *desc;	FcBool enabled;	if (FcConfigFileInfoIterGet (config, &iter, &name, &desc, &enabled))	{	    printf ("%c %s: %s/n", enabled ? '+' : '-', name, desc);	    FcStrFree (name);	    FcStrFree (desc);	}    } while (FcConfigFileInfoIterNext (config, &iter));    FcFini ();    return 0;}

FcCache *FcDirCacheLoadFile (const FcChar8 *cache_file, struct stat *file_stat){    int	fd;    FcCache *cache;    struct stat	my_file_stat;    if (!file_stat)	file_stat = &my_file_stat;    fd = FcDirCacheOpenFile (cache_file, file_stat);    if (fd < 0)	return NULL;    cache = FcDirCacheMapFd (FcConfigGetCurrent (), fd, file_stat, NULL);    close (fd);    return cache;}

void manager::deinit() const{#ifdef CAIRO_HAS_FT_FONT	FcConfigAppFontClear(FcConfigGetCurrent());#endif#if CAIRO_HAS_WIN32_FONT	foreach(const std::string& path, get_binary_paths("fonts")) {		std::vector<std::string> files;		get_files_in_dir(path, &files, NULL, ENTIRE_FILE_PATH);		foreach(const std::string& file, files)			if(file.substr(file.length() - 4) == ".ttf" || file.substr(file.length() - 4) == ".ttc")				RemoveFontResource(file.c_str());	}#endif}

static claro_font_backend_t * claro_ft2_init(){    claro_ft2_backend * ft2_backend;    gboolean res;    ft2_backend = (claro_ft2_backend *)smalloc(sizeof(claro_ft2_backend));    //g_assert(FcInit());    ft2_backend->config = FcConfigGetCurrent();    g_assert(ft2_backend->config != NULL);        ft2_backend->font_families = claro_list_create();    res = _claro_ft2_list_families(ft2_backend);    g_assert(res == TRUE);            return (claro_font_backend_t *)ft2_backend;}

	void configureFontConfig()	{		if (fontConfigHasBeenInitialized)			return ;		fontConfigHasBeenInitialized = true;		if (!FcInit())		{			INCD_ERROR("could not initialize fontconfig.");			return ;		}		fontConfigConfig = FcConfigGetCurrent();		FcConfigSetRescanInterval(fontConfigConfig, 0);		fontConfigPattern = FcPatternCreate();		fontConfigObjectSet = FcObjectSetBuild(FC_FAMILY, FC_FILE, (char *)0);		fontConfigFontSet = FcFontList(fontConfigConfig, fontConfigPattern, fontConfigObjectSet);	}

//// Obtain location of config file to use.//// For system, prefer the following:////     <...>/config.d/00kde.conf   = preferred method from FCConfig >= 2.3//     <...>/local.conf//// Non-system, prefer:////     $HOME/<...>/.fonts.conf//     $HOME/<...>/fonts.conf//QString getConfigFile(bool system){#if (FC_VERSION>=20300)    static const char constKdeRootFcFile[] = "00kde.conf";#endif    FcStrList   *list=FcConfigGetConfigFiles(FcConfigGetCurrent());    QStringList files;    FcChar8     *file;    QString     home(Misc::dirSyntax(QDir::homePath()));    while((file=FcStrListNext(list)))    {        QString f((const char *)file);        if(Misc::fExists(f))        {            // For nonsystem, only consider file within $HOME            if(system || 0==Misc::fileSyntax(f).indexOf(home))                files.append(f);        }#if (FC_VERSION>=20300)        if(system && Misc::dExists(f) && (f.contains(QRegExp("/conf//.d/?$")) ||                                          f.contains(QRegExp("/conf//.d?$"))) )            return Misc::dirSyntax(f)+constKdeRootFcFile;   // This ones good enough for me!#endif    }    //    // Go through list of files, looking for the preferred one...    if(files.count())    {        QStringList::const_iterator it(files.begin()),                              end(files.end());        for(; it!=end; ++it)            if(-1!=(*it).indexOf(QRegExp(system ? "/local//.conf$" : "///.?fonts//.conf$")))                return *it;        return files.front();  // Just return the 1st one...    }    else // Hmmm... no known files?        return system ? "/etc/fonts/local.conf" : Misc::fileSyntax(home+"/.fonts.conf");}

VALUEshoes_load_font(const char *filename){  FcConfig *fc = FcConfigGetCurrent();  FcFontSet *fonts = FcFontSetCreate();  if (!FcFileScan(fonts, NULL, NULL, NULL, (const FcChar8 *)filename, FcTrue))    return Qnil;  VALUE ary = rb_ary_new();  shoes_make_font_list(fonts, ary);  FcFontSetDestroy(fonts);  if (!FcConfigAppFontAddFile(fc, (const FcChar8 *)filename))    return Qnil;  // refresh the FONTS list  shoes_update_fonts(shoes_font_list());  return ary;}

manager::~manager(){#ifdef CAIRO_HAS_FT_FONT    FcConfigAppFontClear(FcConfigGetCurrent());#endif#if CAIRO_HAS_WIN32_FONT    for(const std::string& path : filesystem::get_binary_paths("fonts")) {        std::vector<std::string> files;        if(filesystem::is_directory(path))            filesystem::get_files_in_dir(path, &files, nullptr, filesystem::ENTIRE_FILE_PATH);        for(const std::string& file : files) {            if(file.substr(file.length() - 4) == ".ttf" || file.substr(file.length() - 4) == ".ttc")            {                const std::wstring wfile = unicode_cast<std::wstring>(file);                RemoveFontResourceExW(wfile.c_str(), FR_PRIVATE, nullptr);            }        }    }#endif}

void manager::init() const{#ifdef CAIRO_HAS_FT_FONT	if (!FcConfigAppFontAddDir(FcConfigGetCurrent(),		reinterpret_cast<const FcChar8 *>((game_config::path + "/fonts").c_str())))	{		ERR_FT << "Could not load the true type fonts/n";		throw error();	}#endif#if CAIRO_HAS_WIN32_FONT	foreach(const std::string& path, get_binary_paths("fonts")) {		std::vector<std::string> files;		get_files_in_dir(path, &files, NULL, ENTIRE_FILE_PATH);		foreach(const std::string& file, files)			if(file.substr(file.length() - 4) == ".ttf" || file.substr(file.length() - 4) == ".ttc")				AddFontResource(file.c_str());	}#endif}

FcFontSet *FcFontList (FcConfig	*config,	    FcPattern	*p,	    FcObjectSet *os){    FcFontSet	*sets[2];    int		nsets;    if (!config)    {	config = FcConfigGetCurrent ();	if (!config)	    return 0;    }    nsets = 0;    if (config->fonts[FcSetSystem])	sets[nsets++] = config->fonts[FcSetSystem];    if (config->fonts[FcSetApplication])	sets[nsets++] = config->fonts[FcSetApplication];    return FcFontSetList (config, sets, nsets, p, os);}