/*
* $RCSId: xc/lib/fontconfig/src/fccfg.c,v 1.23 2002/08/31 22:17:32 keithp Exp $
*
- * Copyright © 2000 Keith Packard
+ * Copyright © 2000 Keith Packard
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
*/
#include "fcint.h"
+#include <dirent.h>
+#include <sys/types.h>
#if defined (_WIN32) && (defined (PIC) || defined (DLL_EXPORT))
#define STRICT
if (!config->rejectGlobs)
goto bail5;
- config->cache = 0;
- if (FcConfigHome())
- if (!FcConfigSetCache (config, (FcChar8 *) ("~/" FC_USER_CACHE_FILE)))
- goto bail6;
+ config->acceptPatterns = FcFontSetCreate ();
+ if (!config->acceptPatterns)
+ goto bail6;
+
+ config->rejectPatterns = FcFontSetCreate ();
+ if (!config->rejectPatterns)
+ goto bail7;
+ config->cacheDirs = FcStrSetCreate ();
+ if (!config->cacheDirs)
+ goto bail8;
+
config->blanks = 0;
config->substPattern = 0;
config->substFont = 0;
+ config->substScan = 0;
config->maxObjects = 0;
for (set = FcSetSystem; set <= FcSetApplication; set++)
config->fonts[set] = 0;
return config;
+bail8:
+ FcFontSetDestroy (config->rejectPatterns);
+bail7:
+ FcFontSetDestroy (config->acceptPatterns);
bail6:
FcStrSetDestroy (config->rejectGlobs);
bail5:
return 0;
}
-typedef struct _FcFileTime {
- time_t time;
- FcBool set;
-} FcFileTime;
-
static FcFileTime
FcConfigNewestFile (FcStrSet *files)
{
while ((file = FcStrListNext (list)))
if (stat ((char *) file, &statb) == 0)
if (!newest.set || statb.st_mtime - newest.time > 0)
+ {
+ newest.set = FcTrue;
newest.time = statb.st_mtime;
+ }
FcStrListDone (list);
}
return newest;
FcBool
FcConfigUptoDate (FcConfig *config)
{
- FcFileTime config_time, font_time;
+ FcFileTime config_time, config_dir_time, font_time;
time_t now = time(0);
if (!config)
{
return FcFalse;
}
config_time = FcConfigNewestFile (config->configFiles);
- font_time = FcConfigNewestFile (config->configDirs);
+ config_dir_time = FcConfigNewestFile (config->configDirs);
+ font_time = FcConfigNewestFile (config->fontDirs);
if ((config_time.set && config_time.time - config->rescanTime > 0) ||
- (font_time.set && font_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))
{
return FcFalse;
}
FcTestDestroy (s->test);
if (s->edit)
FcEditDestroy (s->edit);
+ free (s);
+ FcMemFree (FC_MEM_SUBST, sizeof (FcSubst));
s = n;
}
}
FcStrSetDestroy (config->configDirs);
FcStrSetDestroy (config->fontDirs);
+ FcStrSetDestroy (config->cacheDirs);
FcStrSetDestroy (config->configFiles);
FcStrSetDestroy (config->acceptGlobs);
FcStrSetDestroy (config->rejectGlobs);
+ FcFontSetDestroy (config->acceptPatterns);
+ FcFontSetDestroy (config->rejectPatterns);
- if (config->cache)
- FcStrFree (config->cache);
+ if (config->blanks)
+ FcBlanksDestroy (config->blanks);
FcSubstDestroy (config->substPattern);
FcSubstDestroy (config->substFont);
+ FcSubstDestroy (config->substScan);
for (set = FcSetSystem; set <= FcSetApplication; set++)
if (config->fonts[set])
FcFontSetDestroy (config->fonts[set]);
+
free (config);
FcMemFree (FC_MEM_CONFIG, sizeof (FcConfig));
}
/*
- * Scan the current list of directories in the configuration
- * and build the set of available fonts. Update the
- * per-user cache file to reflect the new configuration
+ * Add cache to configuration, adding fonts and directories
*/
FcBool
-FcConfigBuildFonts (FcConfig *config)
+FcConfigAddCache (FcConfig *config, FcCache *cache,
+ FcSetName set, FcStrSet *dirSet)
{
- FcFontSet *fonts;
- FcGlobalCache *cache;
- FcStrList *list;
- FcChar8 *dir;
+ FcFontSet *fs;
+ intptr_t *dirs;
+ int i;
+
+ /*
+ * Add fonts
+ */
+ fs = FcCacheSet (cache);
+ if (fs)
+ {
+ int nref = 0;
+
+ for (i = 0; i < fs->nfont; i++)
+ {
+ FcPattern *font = FcFontSetFont (fs, i);
+ FcChar8 *font_file;
- fonts = FcFontSetCreate ();
- if (!fonts)
- goto bail0;
+ /*
+ * Check to see if font is banned by filename
+ */
+ if (FcPatternObjectGetString (font, FC_FILE_OBJECT,
+ 0, &font_file) == FcResultMatch &&
+ !FcConfigAcceptFilename (config, font_file))
+ {
+ continue;
+ }
+
+ /*
+ * Check to see if font is banned by pattern
+ */
+ if (!FcConfigAcceptFont (config, font))
+ continue;
+
+ nref++;
+ FcFontSetAdd (config->fonts[set], font);
+ }
+ FcDirCacheReference (cache, nref);
+ }
+
+ /*
+ * Add directories
+ */
+ dirs = FcCacheDirs (cache);
+ if (dirs)
+ {
+ for (i = 0; i < cache->dirs_count; i++)
+ {
+ FcChar8 *dir = FcOffsetToPtr (dirs, dirs[i], FcChar8);
+ if (FcConfigAcceptFilename (config, dir))
+ FcStrSetAddFilename (dirSet, dir);
+ }
+ }
+ return FcTrue;
+}
+
+static FcBool
+FcConfigAddDirList (FcConfig *config, FcSetName set, FcStrSet *dirSet)
+{
+ FcStrList *dirlist;
+ FcChar8 *dir;
+ FcCache *cache;
- cache = FcGlobalCacheCreate ();
- if (!cache)
- goto bail1;
+ dirlist = FcStrListCreate (dirSet);
+ if (!dirlist)
+ return FcFalse;
+
+ while ((dir = FcStrListNext (dirlist)))
+ {
+ if (FcDebug () & FC_DBG_FONTSET)
+ printf ("adding fonts from%s\n", dir);
+ cache = FcDirCacheRead (dir, FcFalse, config);
+ if (!cache)
+ continue;
+ FcConfigAddCache (config, cache, set, dirSet);
+ FcDirCacheUnload (cache);
+ }
+ FcStrListDone (dirlist);
+ return FcTrue;
+}
- if (config->cache)
- FcGlobalCacheLoad (cache, config->cache);
+/*
+ * Scan the current list of directories in the configuration
+ * and build the set of available fonts.
+ */
- list = FcConfigGetFontDirs (config);
- if (!list)
- goto bail1;
+FcBool
+FcConfigBuildFonts (FcConfig *config)
+{
+ FcFontSet *fonts;
- while ((dir = FcStrListNext (list)))
+ if (!config)
{
- if (FcDebug () & FC_DBG_FONTSET)
- printf ("scan dir %s\n", dir);
- FcDirScanConfig (fonts, config->fontDirs, cache,
- config->blanks, dir, FcFalse, config);
+ config = FcConfigGetCurrent ();
+ if (!config)
+ return FcFalse;
}
+
+ fonts = FcFontSetCreate ();
+ if (!fonts)
+ return FcFalse;
- FcStrListDone (list);
+ FcConfigSetFonts (config, fonts, FcSetSystem);
+ if (!FcConfigAddDirList (config, FcSetSystem, config->fontDirs))
+ return FcFalse;
if (FcDebug () & FC_DBG_FONTSET)
FcFontSetPrint (fonts);
-
- if (config->cache)
- FcGlobalCacheSave (cache, config->cache);
- FcGlobalCacheDestroy (cache);
-
- FcConfigSetFonts (config, fonts, FcSetSystem);
-
return FcTrue;
-bail1:
- FcFontSetDestroy (fonts);
-bail0:
- return FcFalse;
}
FcBool
return FcStrListCreate (config->fontDirs);
}
+FcBool
+FcConfigAddCacheDir (FcConfig *config,
+ const FcChar8 *d)
+{
+ return FcStrSetAddFilename (config->cacheDirs, d);
+}
+
+FcStrList *
+FcConfigGetCacheDirs (FcConfig *config)
+{
+ if (!config)
+ {
+ config = FcConfigGetCurrent ();
+ if (!config)
+ return 0;
+ }
+ return FcStrListCreate (config->cacheDirs);
+}
+
FcBool
FcConfigAddConfigFile (FcConfig *config,
const FcChar8 *f)
return FcStrListCreate (config->configFiles);
}
-FcBool
-FcConfigSetCache (FcConfig *config,
- const FcChar8 *c)
-{
- FcChar8 *new = FcStrCopyFilename (c);
-
- if (!new)
- return FcFalse;
- if (config->cache)
- FcStrFree (config->cache);
- config->cache = new;
- return FcTrue;
-}
-
FcChar8 *
FcConfigGetCache (FcConfig *config)
{
- if (!config)
- {
- config = FcConfigGetCurrent ();
- if (!config)
- return 0;
- }
- return config->cache;
+ return NULL;
}
FcFontSet *
config->fonts[set] = fonts;
}
-
-
FcBlanks *
FcConfigGetBlanks (FcConfig *config)
{
FcConfigAddBlank (FcConfig *config,
FcChar32 blank)
{
- FcBlanks *b;
+ FcBlanks *b, *freeme = 0;
b = config->blanks;
if (!b)
{
- b = FcBlanksCreate ();
+ freeme = b = FcBlanksCreate ();
if (!b)
return FcFalse;
}
if (!FcBlanksAdd (b, blank))
+ {
+ if (freeme)
+ FcBlanksDestroy (freeme);
return FcFalse;
+ }
config->blanks = b;
return FcTrue;
}
int
-FcConfigGetRescanInverval (FcConfig *config)
+FcConfigGetRescanInterval (FcConfig *config)
{
if (!config)
{
}
FcBool
-FcConfigSetRescanInverval (FcConfig *config, int rescanInterval)
+FcConfigSetRescanInterval (FcConfig *config, int rescanInterval)
{
if (!config)
{
FcTest *t;
int num;
+ switch (kind) {
+ case FcMatchPattern:
+ prev = &config->substPattern;
+ break;
+ case FcMatchFont:
+ prev = &config->substFont;
+ break;
+ case FcMatchScan:
+ prev = &config->substScan;
+ break;
+ default:
+ return FcFalse;
+ }
subst = (FcSubst *) malloc (sizeof (FcSubst));
if (!subst)
return FcFalse;
FcMemAlloc (FC_MEM_SUBST, sizeof (FcSubst));
- if (kind == FcMatchPattern)
- prev = &config->substPattern;
- else
- prev = &config->substFont;
for (; *prev; prev = &(*prev)->next);
*prev = subst;
subst->next = 0;
}
FcBool
-FcConfigCompareValue (const FcValue left_o,
+FcConfigCompareValue (const FcValue *left_o,
FcOp op,
- const FcValue right_o)
+ const FcValue *right_o)
{
- FcValue left = left_o;
- FcValue right = right_o;
+ FcValue left = FcValueCanonicalize(left_o);
+ FcValue right = FcValueCanonicalize(right_o);
FcBool ret = FcFalse;
left = FcConfigPromote (left, right);
ret = FcStrStrIgnoreCase (left.u.s, right.u.s) != 0;
break;
case FcOpNotEqual:
- case FcOpNotContains:
ret = FcStrCmpIgnoreCase (left.u.s, right.u.s) != 0;
break;
+ case FcOpNotContains:
+ ret = FcStrCmpIgnoreCase (left.u.s, right.u.s) == 0;
+ break;
default:
break;
}
ret = FcLangSetContains (left.u.l, right.u.l);
break;
case FcOpNotContains:
- ret = FcLangSetContains (left.u.l, right.u.l);
+ ret = !FcLangSetContains (left.u.l, right.u.l);
break;
case FcOpEqual:
ret = FcLangSetEqual (left.u.l, right.u.l);
FcValue v, vl, vr;
FcResult r;
FcMatrix *m;
+ FcChar8 *str;
switch (e->op) {
case FcOpInteger:
break;
case FcOpString:
v.type = FcTypeString;
- v.u.s = e->u.sval;
- v = FcValueSave (v);
+ v.u.s = FcStrStaticName(e->u.sval);
break;
case FcOpMatrix:
v.type = FcTypeMatrix;
v.u.b = e->u.bval;
break;
case FcOpField:
- r = FcPatternGet (p, e->u.field, 0, &v);
+ r = FcPatternObjectGet (p, e->u.object, 0, &v);
if (r != FcResultMatch)
v.type = FcTypeVoid;
+ v = FcValueSave (v);
break;
case FcOpConst:
if (FcNameConstant (e->u.constant, &v.u.i))
vl = FcConfigEvaluate (p, e->u.tree.left);
vr = FcConfigEvaluate (p, e->u.tree.right);
v.type = FcTypeBool;
- v.u.b = FcConfigCompareValue (vl, e->op, vr);
+ v.u.b = FcConfigCompareValue (&vl, e->op, &vr);
FcValueDestroy (vl);
FcValueDestroy (vr);
break;
switch (e->op) {
case FcOpPlus:
v.type = FcTypeString;
- v.u.s = FcStrPlus (vl.u.s, vr.u.s);
+ str = FcStrPlus (vl.u.s, vr.u.s);
+ v.u.s = FcStrStaticName (str);
+ FcStrFree (str);
+
if (!v.u.s)
v.type = FcTypeVoid;
break;
e = 0;
}
- for (v = values; v; v = v->next)
+ for (v = values; v; v = FcValueListNext(v))
{
/* Compare the pattern value to the match expression value */
- if (FcConfigCompareValue (v->value, t->op, value))
+ if (FcConfigCompareValue (&v->value, t->op, &value))
{
if (!ret)
ret = v;
if (e->op == FcOpComma)
{
l->value = FcConfigEvaluate (p, e->u.tree.left);
- l->next = FcConfigValues (p, e->u.tree.right, binding);
+ l->next = FcConfigValues (p, e->u.tree.right, binding);
}
else
{
l->value = FcConfigEvaluate (p, e);
- l->next = 0;
+ l->next = NULL;
}
l->binding = binding;
- while (l && l->value.type == FcTypeVoid)
+ if (l->value.type == FcTypeVoid)
{
- FcValueList *next = l->next;
-
+ FcValueList *next = FcValueListNext(l);
+
FcMemFree (FC_MEM_VALLIST, sizeof (FcValueList));
free (l);
l = next;
}
+
return l;
}
static FcBool
-FcConfigAdd (FcValueList **head,
+FcConfigAdd (FcValueListPtr *head,
FcValueList *position,
FcBool append,
FcValueList *new)
{
- FcValueList **prev, *last, *v;
+ FcValueListPtr *prev, last, v;
FcValueBinding sameBinding;
if (position)
sameBinding = position->binding;
else
sameBinding = FcValueBindingWeak;
- for (v = new; v; v = v->next)
+ for (v = new; v != NULL; v = FcValueListNext(v))
if (v->binding == FcValueBindingSame)
v->binding = sameBinding;
if (append)
if (position)
prev = &position->next;
else
- for (prev = head; *prev; prev = &(*prev)->next)
+ for (prev = head; *prev != NULL;
+ prev = &(*prev)->next)
;
}
else
{
if (position)
{
- for (prev = head; *prev; prev = &(*prev)->next)
+ for (prev = head; *prev != NULL;
+ prev = &(*prev)->next)
{
if (*prev == position)
break;
if (FcDebug () & FC_DBG_EDIT)
{
- if (!*prev)
+ if (*prev == NULL)
printf ("position not on list\n");
}
}
if (new)
{
last = new;
- while (last->next)
+ while (last->next != NULL)
last = last->next;
last->next = *prev;
}
static void
-FcConfigDel (FcValueList **head,
+FcConfigDel (FcValueListPtr *head,
FcValueList *position)
{
- FcValueList **prev;
+ FcValueListPtr *prev;
- for (prev = head; *prev; prev = &(*prev)->next)
+ for (prev = head; *prev != NULL; prev = &(*prev)->next)
{
if (*prev == position)
{
*prev = position->next;
- position->next = 0;
+ position->next = NULL;
FcValueListDestroy (position);
break;
}
static void
FcConfigPatternAdd (FcPattern *p,
- const char *object,
+ FcObject object,
FcValueList *list,
FcBool append)
{
if (list)
{
- FcPatternElt *e = FcPatternInsertElt (p, object);
+ FcPatternElt *e = FcPatternObjectInsertElt (p, object);
if (!e)
return;
*/
static void
FcConfigPatternDel (FcPattern *p,
- const char *object)
+ FcObject object)
{
- FcPatternElt *e = FcPatternFindElt (p, object);
+ FcPatternElt *e = FcPatternObjectFindElt (p, object);
if (!e)
return;
- while (e->values)
+ while (e->values != NULL)
FcConfigDel (&e->values, e->values);
}
static void
FcConfigPatternCanon (FcPattern *p,
- const char *object)
+ FcObject object)
{
- FcPatternElt *e = FcPatternFindElt (p, object);
+ FcPatternElt *e = FcPatternObjectFindElt (p, object);
if (!e)
return;
- if (!e->values)
- FcPatternDel (p, object);
+ if (e->values == NULL)
+ FcPatternObjectDel (p, object);
}
FcBool
return FcFalse;
}
+ switch (kind) {
+ case FcMatchPattern:
+ s = config->substPattern;
+ break;
+ case FcMatchFont:
+ s = config->substFont;
+ break;
+ case FcMatchScan:
+ s = config->substScan;
+ break;
+ default:
+ return FcFalse;
+ }
+
st = (FcSubState *) malloc (config->maxObjects * sizeof (FcSubState));
if (!st && config->maxObjects)
return FcFalse;
printf ("FcConfigSubstitute ");
FcPatternPrint (p);
}
- if (kind == FcMatchPattern)
- s = config->substPattern;
- else
- s = config->substFont;
for (; s; s = s->next)
{
/*
else
m = p;
if (m)
- st[i].elt = FcPatternFindElt (m, t->field);
+ st[i].elt = FcPatternObjectFindElt (m, t->object);
else
st[i].elt = 0;
/*
for (t = s->test, i = 0; t; t = t->next, i++)
{
if ((t->kind == FcMatchFont || kind == FcMatchPattern) &&
- !FcStrCmpIgnoreCase ((FcChar8 *) t->field,
- (FcChar8 *) e->field))
+ t->object == e->object)
{
/*
* KLUDGE - the pattern may have been reallocated or
* the element again
*/
if (e != s->edit && st[i].elt)
- st[i].elt = FcPatternFindElt (p, t->field);
+ st[i].elt = FcPatternObjectFindElt (p, t->object);
if (!st[i].elt)
t = 0;
break;
if (t)
{
FcValueList *thisValue = st[i].value;
- FcValueList *nextValue = thisValue ? thisValue->next : 0;
+ FcValueList *nextValue = thisValue;
/*
* Append the new list of values after the current value
/*
* Delete the marked value
*/
- FcConfigDel (&st[i].elt->values, thisValue);
+ if (thisValue)
+ FcConfigDel (&st[i].elt->values, thisValue);
/*
* Adjust any pointers into the value list to ensure
* future edits occur at the same place
* Delete all of the values and insert
* the new set
*/
- FcConfigPatternDel (p, e->field);
- FcConfigPatternAdd (p, e->field, l, FcTrue);
+ FcConfigPatternDel (p, e->object);
+ FcConfigPatternAdd (p, e->object, l, FcTrue);
/*
* Adjust any pointers into the value list as they no
* longer point to anything valid
}
/* fall through ... */
case FcOpPrependFirst:
- FcConfigPatternAdd (p, e->field, l, FcFalse);
+ FcConfigPatternAdd (p, e->object, l, FcFalse);
break;
case FcOpAppend:
if (t)
}
/* fall through ... */
case FcOpAppendLast:
- FcConfigPatternAdd (p, e->field, l, FcTrue);
+ FcConfigPatternAdd (p, e->object, l, FcTrue);
break;
default:
+ FcValueListDestroy (l);
break;
}
}
* any properties without data
*/
for (e = s->edit; e; e = e->next)
- FcConfigPatternCanon (p, e->field);
+ FcConfigPatternCanon (p, e->object);
if (FcDebug () & FC_DBG_EDIT)
{
#ifdef _WIN32
if ((!path[0] || (path[strlen((char *) path)-1] != '/' &&
path[strlen((char *) path)-1] != '\\')) &&
- (file[0] != '/' && file[0] != '\\'))
+ !(file[0] == '/' ||
+ file[0] == '\\' ||
+ (isalpha (file[0]) && file[1] == ':' && (file[2] == '/' || file[2] == '\\'))))
strcat ((char *) path, "\\");
#else
if ((!path[0] || path[strlen((char *) path)-1] != '/') && file[0] != '/')
home = getenv ("USERPROFILE");
#endif
- return home;
+ return (FcChar8 *) home;
}
return 0;
}
FcConfigSetFonts (config, set, FcSetApplication);
}
- if (!FcFileScanConfig (set, subdirs, 0, config->blanks, file, FcFalse, config))
+ if (!FcFileScanConfig (set, subdirs, config->blanks, file, config))
{
FcStrSetDestroy (subdirs);
return FcFalse;
}
FcStrListDone (sublist);
}
+ FcStrSetDestroy (subdirs);
return FcTrue;
}
const FcChar8 *dir)
{
FcFontSet *set;
- FcStrSet *subdirs;
- FcStrList *sublist;
- FcChar8 *subdir;
+ FcStrSet *dirs;
if (!config)
{
if (!config)
return FcFalse;
}
- subdirs = FcStrSetCreate ();
- if (!subdirs)
+
+ dirs = FcStrSetCreate ();
+ if (!dirs)
return FcFalse;
set = FcConfigGetFonts (config, FcSetApplication);
set = FcFontSetCreate ();
if (!set)
{
- FcStrSetDestroy (subdirs);
+ FcStrSetDestroy (dirs);
return FcFalse;
}
FcConfigSetFonts (config, set, FcSetApplication);
}
- if (!FcDirScanConfig (set, subdirs, 0, config->blanks, dir, FcFalse, config))
+ FcStrSetAddFilename (dirs, dir);
+
+ if (!FcConfigAddDirList (config, FcSetApplication, dirs))
{
- FcStrSetDestroy (subdirs);
+ FcStrSetDestroy (dirs);
return FcFalse;
}
- if ((sublist = FcStrListCreate (subdirs)))
- {
- while ((subdir = FcStrListNext (sublist)))
- {
- FcConfigAppFontAddDir (config, subdir);
- }
- FcStrListDone (sublist);
- }
+ FcStrSetDestroy (dirs);
return FcTrue;
}
void
FcConfigAppFontClear (FcConfig *config)
{
+ if (!config)
+ {
+ config = FcConfigGetCurrent ();
+ if (!config)
+ return;
+ }
+
FcConfigSetFonts (config, 0, FcSetApplication);
}
return FcFalse;
return FcTrue;
}
+
+/*
+ * Manage font-pattern based font source selectors
+ */
+
+FcBool
+FcConfigPatternsAdd (FcConfig *config,
+ FcPattern *pattern,
+ FcBool accept)
+{
+ FcFontSet *set = accept ? config->acceptPatterns : config->rejectPatterns;
+
+ return FcFontSetAdd (set, pattern);
+}
+
+static FcBool
+FcConfigPatternsMatch (const FcFontSet *patterns,
+ const FcPattern *font)
+{
+ int i;
+
+ for (i = 0; i < patterns->nfont; i++)
+ if (FcListPatternMatchAny (patterns->fonts[i], font))
+ return FcTrue;
+ return FcFalse;
+}
+
+FcBool
+FcConfigAcceptFont (FcConfig *config,
+ const FcPattern *font)
+{
+ if (FcConfigPatternsMatch (config->acceptPatterns, font))
+ return FcTrue;
+ if (FcConfigPatternsMatch (config->rejectPatterns, font))
+ return FcFalse;
+ return FcTrue;
+}
+#define __fccfg__
+#include "fcaliastail.h"
+#undef __fccfg__
git.wh0rd.org / fontconfig.git / blobdiff