/*
* Load the configuration files
*/
FcConfig *
FcInitLoadOwnConfig (FcConfig *config)
{
if (!config)
{
config = FcConfigCreate ();
if (!config)
return NULL;
}
FcInitDebug ();
if (!FcConfigParseAndLoad (config, 0, FcTrue))
{
FcConfigDestroy (config);
return FcInitFallbackConfig ();
}
if (config->cacheDirs && config->cacheDirs->num == 0)
{
FcChar8 *prefix, *p;
size_t plen;
fprintf (stderr,
"Fontconfig warning: no <cachedir> elements found. Check configuration.\n");
fprintf (stderr,
"Fontconfig warning: adding <cachedir>%s</cachedir>\n",
FC_CACHEDIR);
prefix = FcConfigXdgCacheHome ();
if (!prefix)
goto bail;
plen = strlen ((const char *)prefix);
p = realloc (prefix, plen + 12);
if (!p)
goto bail;
prefix = p;
memcpy (&prefix[plen], FC_DIR_SEPARATOR_S "fontconfig", 11);
prefix[plen + 11] = 0;
fprintf (stderr,
"Fontconfig warning: adding <cachedir prefix=\"xdg\">fontconfig</cachedir>\n");
if (!FcConfigAddCacheDir (config, (FcChar8 *) FC_CACHEDIR) ||
!FcConfigAddCacheDir (config, (FcChar8 *) prefix))
{
bail:
fprintf (stderr,
"Fontconfig error: out of memory");
if (prefix)
FcStrFree (prefix);
FcConfigDestroy (config);
return FcInitFallbackConfig ();
}
FcStrFree (prefix);
}
return config;
}
/**
* \brief Init fontconfig.
* \param library libass library object
* \param ftlibrary freetype library object
* \param family default font family
* \param path default font path
* \param fc whether fontconfig should be used
* \param config path to a fontconfig configuration file, or NULL
* \param update whether the fontconfig cache should be built/updated
* \return pointer to fontconfig private data
*/
FCInstance *fontconfig_init(ASS_Library *library,
FT_Library ftlibrary, const char *family,
const char *path, int fc, const char *config,
int update)
{
int rc;
FCInstance *priv = calloc(1, sizeof(FCInstance));
const char *dir = library->fonts_dir;
int i;
if (!fc) {
ass_msg(library, MSGL_WARN,
"Fontconfig disabled, only default font will be used.");
goto exit;
}
priv->config = FcConfigCreate();
rc = FcConfigParseAndLoad(priv->config, (unsigned char *) config, FcTrue);
if (!rc) {
ass_msg(library, MSGL_WARN, "No usable fontconfig configuration "
"file found, using fallback.");
FcConfigDestroy(priv->config);
priv->config = FcInitLoadConfig();
rc++;
}
if (rc && update) {
FcConfigBuildFonts(priv->config);
}
if (!rc || !priv->config) {
ass_msg(library, MSGL_FATAL,
"No valid fontconfig configuration found!");
FcConfigDestroy(priv->config);
goto exit;
}
for (i = 0; i < library->num_fontdata; ++i)
process_fontdata(priv, library, ftlibrary, i);
if (dir) {
ass_msg(library, MSGL_V, "Updating font cache");
rc = FcConfigAppFontAddDir(priv->config, (const FcChar8 *) dir);
if (!rc) {
ass_msg(library, MSGL_WARN, "%s failed", "FcConfigAppFontAddDir");
}
}
priv->family_default = family ? strdup(family) : NULL;
exit:
priv->path_default = path ? strdup(path) : NULL;
priv->index_default = 0;
return priv;
}
void
FcConfigFini (void)
{
FcConfig *cfg = fc_atomic_ptr_get (&_fcConfig);
if (cfg && fc_atomic_ptr_cmpexch (&_fcConfig, cfg, NULL))
FcConfigDestroy (cfg);
}
static void load_font_from_fontconfig(void)
{
FcConfig* config = FcInitLoadConfigAndFonts();
FcFontSet* fontset = NULL;
// get application fonts
fontset = FcConfigGetFonts(config, FcSetApplication);
if (fontset) {
FcValue fvalue, dvalue;
for (int i = 0; i < fontset->nfont; i++) {
if (FcResultMatch == FcPatternGet(fontset->fonts[i], FC_FAMILY, 0, &fvalue)) {
if (FcResultMatch == FcPatternGet(fontset->fonts[i], FC_FILE, 0, &dvalue)) {
font_item* font = get_font_item((const char*)fvalue.u.s, (const char*)dvalue.u.s);
g_font_map.add(font);
}
}
}
}
// get system fonts
fontset = FcConfigGetFonts(config, FcSetSystem);
if (fontset) {
FcValue fvalue, dvalue;
for (int i = 0; i < fontset->nfont; i++) {
if (FcResultMatch == FcPatternGet(fontset->fonts[i], FC_FAMILY, 0, &fvalue)) {
if (FcResultMatch == FcPatternGet(fontset->fonts[i], FC_FILE, 0, &dvalue)) {
font_item* font = get_font_item((const char*)fvalue.u.s, (const char*)dvalue.u.s);
g_font_map.add(font);
}
}
}
}
FcConfigDestroy(config);
}
static void
Py_Config_dealloc(Py_Config* self)
{
FcConfigDestroy(self->x);
Py_TYPE(self)->tp_clear((PyObject*)self);
Py_TYPE(self)->tp_free((PyObject*)self);
}
static void
gimp_fonts_load_func (FcConfig *config)
{
if (! FcConfigBuildFonts (config))
FcConfigDestroy (config);
else
FcConfigSetCurrent (config);
}
/*
* Free all library-allocated data structures.
*/
void
FcFini (void)
{
if (_fcConfig)
FcConfigDestroy (_fcConfig);
FcPatternFini ();
FcCacheFini ();
}
std::string PdfFontCache::GetFontPath( const char* pszFontName, bool bBold, bool bItalic )
{
#if defined(HAVE_FONTCONFIG)
FcConfig* pConfig = FcInitLoadConfigAndFonts();
std::string sPath = this->GetFontConfigFontPath( pConfig, pszFontName, bBold, bItalic );
FcConfigDestroy( pConfig );
#else
std::string sPath = "";
#endif
return sPath;
}
/*
* Free all library-allocated data structures.
*/
void
FcFini (void)
{
if (_fcConfig)
FcConfigDestroy (_fcConfig);
FcPatternFini ();
FcCacheFini ();
if (FcDebug() & FC_DBG_MEMORY)
FcMemReport ();
}
/*
* Load the configuration files
*/
FcConfig *
FcInitLoadConfig (void)
{
FcConfig *config;
FcInitDebug ();
config = FcConfigCreate ();
if (!config)
return FcFalse;
if (!FcConfigParseAndLoad (config, 0, FcTrue))
{
FcConfigDestroy (config);
return FcInitFallbackConfig ();
}
if (config->cacheDirs && config->cacheDirs->num == 0)
{
fprintf (stderr,
"Fontconfig warning: no <cachedir> elements found. Check configuration.\n");
fprintf (stderr,
"Fontconfig warning: adding <cachedir>%s</cachedir>\n",
FC_CACHEDIR);
fprintf (stderr,
"Fontconfig warning: adding <cachedir>~/.fontconfig</cachedir>\n");
if (!FcConfigAddCacheDir (config, (FcChar8 *) FC_CACHEDIR) ||
!FcConfigAddCacheDir (config, (FcChar8 *) "~/.fontconfig"))
{
fprintf (stderr,
"Fontconfig error: out of memory");
FcConfigDestroy (config);
return FcInitFallbackConfig ();
}
}
printf("4\n");
return config;
}
/*
* Load the configuration files and scan for available fonts
*/
FcConfig *
FcInitLoadOwnConfigAndFonts (FcConfig *config)
{
config = FcInitLoadOwnConfig (config);
if (!config)
return 0;
if (!FcConfigBuildFonts (config))
{
FcConfigDestroy (config);
return 0;
}
return config;
}
void fontconfig_done(FCInstance *priv)
{
if (priv) {
#ifdef CONFIG_FONTCONFIG
if (priv->config)
FcConfigDestroy(priv->config);
#endif
free(priv->path_default);
free(priv->family_default);
}
free(priv);
}
/*
* Load the configuration files and scan for available fonts
*/
FcConfig *
FcInitLoadConfigAndFonts (void)
{
FcConfig *config = FcInitLoadConfig ();
FcInitDebug ();
if (!config)
return 0;
if (!FcConfigBuildFonts (config))
{
FcConfigDestroy (config);
return 0;
}
return config;
}
PdfFontCache::~PdfFontCache()
{
this->EmptyCache();
#if defined(HAVE_FONTCONFIG)
FcConfigDestroy( static_cast<FcConfig*>(m_pFcConfig) );
#endif
if( m_ftLibrary )
{
FT_Done_FreeType( m_ftLibrary );
m_ftLibrary = NULL;
}
}
void
gimp_fonts_load (Gimp *gimp)
{
FcConfig *config;
GFile *fonts_conf;
GList *path;
g_return_if_fail (GIMP_IS_FONT_LIST (gimp->fonts));
gimp_set_busy (gimp);
if (gimp->be_verbose)
g_print ("Loading fonts\n");
gimp_container_freeze (GIMP_CONTAINER (gimp->fonts));
gimp_container_clear (GIMP_CONTAINER (gimp->fonts));
config = FcInitLoadConfig ();
if (! config)
goto cleanup;
fonts_conf = gimp_directory_file (CONF_FNAME, NULL);
if (! gimp_fonts_load_fonts_conf (config, fonts_conf))
goto cleanup;
fonts_conf = gimp_sysconf_directory_file (CONF_FNAME, NULL);
if (! gimp_fonts_load_fonts_conf (config, fonts_conf))
goto cleanup;
path = gimp_config_path_expand_to_files (gimp->config->font_path, FALSE);
gimp_fonts_add_directories (config, path);
g_list_free_full (path, (GDestroyNotify) g_object_unref);
if (! FcConfigBuildFonts (config))
{
FcConfigDestroy (config);
goto cleanup;
}
FcConfigSetCurrent (config);
gimp_font_list_restore (GIMP_FONT_LIST (gimp->fonts));
cleanup:
gimp_container_thaw (GIMP_CONTAINER (gimp->fonts));
gimp_unset_busy (gimp);
}
void
gimp_fonts_load (Gimp *gimp)
{
FcConfig *config;
gchar *fonts_conf;
gchar *path;
g_return_if_fail (GIMP_IS_FONT_LIST (gimp->fonts));
gimp_set_busy (gimp);
if (gimp->be_verbose)
g_print ("Loading fonts\n");
gimp_container_freeze (GIMP_CONTAINER (gimp->fonts));
gimp_container_clear (GIMP_CONTAINER (gimp->fonts));
config = FcInitLoadConfig ();
if (! config)
goto cleanup;
fonts_conf = gimp_personal_rc_file (CONF_FNAME);
if (! gimp_fonts_load_fonts_conf (config, fonts_conf))
goto cleanup;
fonts_conf = g_build_filename (gimp_sysconf_directory (), CONF_FNAME, NULL);
if (! gimp_fonts_load_fonts_conf (config, fonts_conf))
goto cleanup;
path = gimp_config_path_expand (gimp->config->font_path, TRUE, NULL);
gimp_fonts_add_directories (config, path);
g_free (path);
if (! FcConfigBuildFonts (config))
{
FcConfigDestroy (config);
goto cleanup;
}
FcConfigSetCurrent (config);
gimp_font_list_restore (GIMP_FONT_LIST (gimp->fonts));
cleanup:
gimp_container_thaw (GIMP_CONTAINER (gimp->fonts));
gimp_unset_busy (gimp);
}
FcBool
FcConfigSetCurrent (FcConfig *config)
{
if (config == _fcConfig)
return FcTrue;
if (!config->fonts)
if (!FcConfigBuildFonts (config))
return FcFalse;
if (_fcConfig)
FcConfigDestroy (_fcConfig);
_fcConfig = config;
return FcTrue;
}
static gboolean
gimp_fonts_load_fonts_conf (FcConfig *config,
gchar *fonts_conf)
{
gboolean ret = TRUE;
if (! FcConfigParseAndLoad (config, (const guchar *) fonts_conf, FcFalse))
{
FcConfigDestroy (config);
ret = FALSE;
}
g_free (fonts_conf);
return ret;
}
void
evas_font_dir_cache_free(void)
{
if (font_dirs)
{
eina_hash_foreach(font_dirs, font_cache_dir_free, NULL);
eina_hash_free(font_dirs);
font_dirs = NULL;
}
#ifdef HAVE_FONTCONFIG
if (fc_config)
{
FcConfigDestroy(fc_config);
fc_config = NULL;
}
#endif
}
static FcConfig *
FcConfigEnsure (void)
{
FcConfig *config;
retry:
config = fc_atomic_ptr_get (&_fcConfig);
if (!config)
{
config = FcInitLoadConfigAndFonts ();
if (!fc_atomic_ptr_cmpexch (&_fcConfig, NULL, config)) {
FcConfigDestroy (config);
goto retry;
}
}
return config;
}
static gboolean
gimp_fonts_load_fonts_conf (FcConfig *config,
GFile *fonts_conf)
{
gchar *path = g_file_get_path (fonts_conf);
gboolean ret = TRUE;
if (! FcConfigParseAndLoad (config, (const guchar *) path, FcFalse))
{
FcConfigDestroy (config);
ret = FALSE;
}
g_free (path);
g_object_unref (fonts_conf);
return ret;
}
static FcConfig *
FcInitFallbackConfig (void)
{
FcConfig *config;
config = FcConfigCreate ();
if (!config)
goto bail0;
if (!FcConfigAddDir (config, (FcChar8 *) FC_DEFAULT_FONTS))
goto bail1;
if (!FcConfigAddCacheDir (config, (FcChar8 *) FC_CACHEDIR))
goto bail1;
return config;
bail1:
FcConfigDestroy (config);
bail0:
return 0;
}
// coverity[+free : arg-0]
GpStatus
GdipDeletePrivateFontCollection (GpFontCollection **font_collection)
{
if (!font_collection)
return InvalidParameter;
if (*font_collection) {
if ((*font_collection)->fontset != NULL) {
FcFontSetDestroy ((*font_collection)->fontset);
(*font_collection)->fontset = NULL;
}
if ((*font_collection)->config != NULL) {
FcConfigDestroy ((*font_collection)->config);
(*font_collection)->config = NULL;
}
GdipFree ((void *)*font_collection);
}
return Ok;
}
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;
}
void free_info_rec(p_info_rec* p_info)
{
info_rec* info;
if (*p_info == NULL)
return;
info = *p_info;
if (info->face != NULL)
{
FT_Done_Face(info->face);
info->face = NULL;
}
FT_Done_FreeType(info->library);
if (info->config != NULL)
{
FcConfigDestroy(info->config);
info->config = NULL;
}
free(info);
*p_info = NULL;
}
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;
}
FcBool
FcConfigSetCurrent (FcConfig *config)
{
FcConfig *cfg;
retry:
cfg = fc_atomic_ptr_get (&_fcConfig);
if (config == cfg)
return FcTrue;
if (config && !config->fonts[FcSetSystem])
if (!FcConfigBuildFonts (config))
return FcFalse;
if (!fc_atomic_ptr_cmpexch (&_fcConfig, cfg, config))
goto retry;
if (cfg)
FcConfigDestroy (cfg);
return FcTrue;
}
gboolean
FcCacheUpdate (void) {
FcConfigDestroy(FcConfigGetCurrent());
return !FcConfigUptoDate(NULL) && FcInitReinitialize();
}
FontconfigFontProvider::~FontconfigFontProvider() {
if (_config) {
FcConfigDestroy(_config);
FcFini();
}
}
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,
MaxTextExtent);
}
}
type_info->name=ConstantString(name);
(void) SubstituteString(&type_info->name," ","-");
type_info->family=ConstantString((const char *) family);
status=FcPatternGetInteger(font_set->fonts[i],FC_SLANT,0,&slant);
type_info->style=NormalStyle;
if (slant == FC_SLANT_ITALIC)
type_info->style=ItalicStyle;
if (slant == FC_SLANT_OBLIQUE)
type_info->style=ObliqueStyle;
status=FcPatternGetInteger(font_set->fonts[i],FC_WIDTH,0,&width);
type_info->stretch=NormalStretch;
if (width >= FC_WIDTH_ULTRACONDENSED)
type_info->stretch=UltraCondensedStretch;
if (width >= FC_WIDTH_EXTRACONDENSED)
type_info->stretch=ExtraCondensedStretch;
if (width >= FC_WIDTH_CONDENSED)
type_info->stretch=CondensedStretch;
if (width >= FC_WIDTH_SEMICONDENSED)
type_info->stretch=SemiCondensedStretch;
if (width >= FC_WIDTH_NORMAL)
type_info->stretch=NormalStretch;
if (width >= FC_WIDTH_SEMIEXPANDED)
type_info->stretch=SemiExpandedStretch;
if (width >= FC_WIDTH_EXPANDED)
type_info->stretch=ExpandedStretch;
if (width >= FC_WIDTH_EXTRAEXPANDED)
type_info->stretch=ExtraExpandedStretch;
if (width >= FC_WIDTH_ULTRAEXPANDED)
type_info->stretch=UltraExpandedStretch;
type_info->weight=400;
status=FcPatternGetInteger(font_set->fonts[i],FC_WEIGHT,0,&weight);
if (weight >= FC_WEIGHT_THIN)
type_info->weight=100;
if (weight >= FC_WEIGHT_EXTRALIGHT)
type_info->weight=200;
if (weight >= FC_WEIGHT_LIGHT)
type_info->weight=300;
if (weight >= FC_WEIGHT_NORMAL)
type_info->weight=400;
if (weight >= FC_WEIGHT_MEDIUM)
type_info->weight=500;
if (weight >= FC_WEIGHT_DEMIBOLD)
type_info->weight=600;
if (weight >= FC_WEIGHT_BOLD)
type_info->weight=700;
if (weight >= FC_WEIGHT_EXTRABOLD)
type_info->weight=800;
if (weight >= FC_WEIGHT_BLACK)
type_info->weight=900;
type_info->glyphs=ConstantString((const char *) file);
(void) AddValueToSplayTree(type_list,type_info->name,type_info);
}
FcFontSetDestroy(font_set);
FcConfigDestroy(font_config);
return(MagickTrue);
}
