/*
- * $XFree86: xc/lib/fontconfig/src/fccfg.c,v 1.15 2002/06/21 06:14:45 keithp Exp $
+ * $RCSId: xc/lib/fontconfig/src/fccfg.c,v 1.23 2002/08/31 22:17:32 keithp Exp $
*
- * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.
+ * 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
+#include <windows.h>
+#undef STRICT
+#endif
+
+#if defined (_WIN32) && !defined (R_OK)
+#define R_OK 4
+#endif
FcConfig *_fcConfig;
if (!config->fontDirs)
goto bail3;
- config->cache = 0;
- if (!FcConfigSetCache (config, (FcChar8 *) ("~/" FC_USER_CACHE_FILE)))
+ config->acceptGlobs = FcStrSetCreate ();
+ if (!config->acceptGlobs)
goto bail4;
+ config->rejectGlobs = FcStrSetCreate ();
+ if (!config->rejectGlobs)
+ goto bail5;
+
+ config->acceptPatterns = FcFontSetCreate ();
+ if (!config->acceptPatterns)
+ goto bail6;
+
+ config->rejectPatterns = FcFontSetCreate ();
+ if (!config->rejectPatterns)
+ goto bail7;
+
+ config->cache = 0;
+ if (FcConfigHome())
+ if (!FcConfigSetCache (config, (FcChar8 *) ("~/" FC_USER_CACHE_FILE)))
+ goto bail8;
+
+#ifdef _WIN32
+ if (config->cache == 0)
+ {
+ /* If no home, use the temp folder. */
+ FcChar8 dummy[1];
+ int templen = GetTempPath (1, dummy);
+ FcChar8 *temp = malloc (templen + 1);
+
+ if (temp)
+ {
+ FcChar8 *cache_dir;
+
+ GetTempPath (templen + 1, temp);
+ cache_dir = FcStrPlus (temp, FC_USER_CACHE_FILE);
+ free (temp);
+ if (!FcConfigSetCache (config, cache_dir))
+ {
+ FcStrFree (cache_dir);
+ goto bail8;
+ }
+ FcStrFree (cache_dir);
+ }
+ }
+#endif
+
+ config->cacheDirs = FcStrSetCreate ();
+ if (!config->cacheDirs)
+ goto bail9;
+
config->blanks = 0;
config->substPattern = 0;
return config;
+bail9:
+ FcStrFree (config->cache);
+bail8:
+ FcFontSetDestroy (config->rejectPatterns);
+bail7:
+ FcFontSetDestroy (config->acceptPatterns);
+bail6:
+ FcStrSetDestroy (config->rejectGlobs);
+bail5:
+ FcStrSetDestroy (config->acceptGlobs);
bail4:
FcStrSetDestroy (config->fontDirs);
bail3:
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;
}
+FcFileTime
+FcConfigModifiedTime (FcConfig *config)
+{
+ if (!config)
+ {
+ FcFileTime v = { 0, FcFalse };
+ config = FcConfigGetCurrent ();
+ if (!config)
+ return v;
+ }
+ return FcConfigNewestFile (config->configFiles);
+}
+
FcBool
FcConfigUptoDate (FcConfig *config)
{
return FcFalse;
}
config_time = FcConfigNewestFile (config->configFiles);
- font_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)
+ (font_time.set && (font_time.time - config->rescanTime) > 0))
{
return FcFalse;
}
while (s)
{
n = s->next;
- FcTestDestroy (s->test);
- FcEditDestroy (s->edit);
+ if (s->test)
+ 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);
- FcStrFree (config->cache);
+ if (config->blanks)
+ FcBlanksDestroy (config->blanks);
+
+ if (config->cache)
+ FcStrFree (config->cache);
FcSubstDestroy (config->substPattern);
FcSubstDestroy (config->substFont);
for (set = FcSetSystem; set <= FcSetApplication; set++)
if (config->fonts[set])
FcFontSetDestroy (config->fonts[set]);
+
free (config);
FcMemFree (FC_MEM_CONFIG, sizeof (FcConfig));
}
FcBool
FcConfigBuildFonts (FcConfig *config)
{
- FcFontSet *fonts;
+ FcFontSet *fonts, *cached_fonts;
FcGlobalCache *cache;
FcStrList *list;
+ FcStrSet *oldDirs;
FcChar8 *dir;
fonts = FcFontSetCreate ();
if (!cache)
goto bail1;
- FcGlobalCacheLoad (cache, config->cache);
+ oldDirs = FcStrSetCreate ();
+ if (!oldDirs)
+ goto bail2;
- list = FcConfigGetFontDirs (config);
- if (!list)
- goto bail1;
+ if (config->cache)
+ FcGlobalCacheLoad (cache, oldDirs, config->cache, config);
- while ((dir = FcStrListNext (list)))
+ cached_fonts = FcCacheRead(config, cache);
+ if (!cached_fonts)
{
- if (FcDebug () & FC_DBG_FONTSET)
- printf ("scan dir %s\n", dir);
- FcDirScan (fonts, config->fontDirs, cache, config->blanks, dir, FcFalse);
+ list = FcConfigGetFontDirs (config);
+ if (!list)
+ goto bail3;
+
+ while ((dir = FcStrListNext (list)))
+ {
+ if (FcDebug () & FC_DBG_FONTSET)
+ printf ("build scan dir %s\n", dir);
+ FcDirScanConfig (fonts, config->fontDirs, cache,
+ config->blanks, dir, FcFalse, config);
+ }
+
+ FcStrListDone (list);
+ }
+ else
+ {
+ int i;
+
+ for (i = 0; i < oldDirs->num; i++)
+ {
+ if (FcDebug () & FC_DBG_FONTSET)
+ printf ("scan dir %s\n", oldDirs->strs[i]);
+ FcDirScanConfig (fonts, config->fontDirs, cache,
+ config->blanks, oldDirs->strs[i],
+ FcFalse, config);
+ }
+
+ for (i = 0; i < cached_fonts->nfont; i++)
+ {
+ FcChar8 *cfn;
+ FcPatternGetString (cached_fonts->fonts[i], FC_FILE, 0, &cfn);
+
+ if (FcConfigAcceptFont (config, cached_fonts->fonts[i]) &&
+ (cfn && FcConfigAcceptFilename (config, cfn)))
+ FcFontSetAdd (fonts, cached_fonts->fonts[i]);
+
+ cached_fonts->fonts[i] = 0; /* prevent free in FcFontSetDestroy */
+ }
+ cached_fonts->nfont = 0;
+ FcFontSetDestroy (cached_fonts);
}
-
- FcStrListDone (list);
if (FcDebug () & FC_DBG_FONTSET)
FcFontSetPrint (fonts);
- FcGlobalCacheSave (cache, config->cache);
+ if (config->cache)
+ FcGlobalCacheSave (cache, config->cache, config);
FcGlobalCacheDestroy (cache);
+ FcStrSetDestroy (oldDirs);
FcConfigSetFonts (config, fonts, FcSetSystem);
return FcTrue;
+bail3:
+ FcStrSetDestroy (oldDirs);
+bail2:
+ FcGlobalCacheDestroy (cache);
bail1:
FcFontSetDestroy (fonts);
bail0:
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)
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;
}
subst = (FcSubst *) malloc (sizeof (FcSubst));
if (!subst)
return FcFalse;
+ FcMemAlloc (FC_MEM_SUBST, sizeof (FcSubst));
if (kind == FcMatchPattern)
prev = &config->substPattern;
else
subst->next = 0;
subst->test = test;
subst->edit = edit;
- if (FcDebug () & FC_DBG_EDIT)
- {
- printf ("Add Subst ");
- FcSubstPrint (subst);
- }
num = 0;
for (t = test; t; t = t->next)
+ {
+ if (t->kind == FcMatchDefault)
+ t->kind = kind;
num++;
+ }
if (config->maxObjects < num)
config->maxObjects = num;
+ if (FcDebug () & FC_DBG_EDIT)
+ {
+ printf ("Add Subst ");
+ FcSubstPrint (subst);
+ }
return FcTrue;
}
v.u.m = &FcIdentityMatrix;
v.type = FcTypeMatrix;
}
+ else if (v.type == FcTypeString && u.type == FcTypeLangSet)
+ {
+ v.u.l = FcLangSetPromote (v.u.s);
+ v.type = FcTypeLangSet;
+ }
return v;
}
FcBool
-FcConfigCompareValue (FcValue m,
- FcOp op,
- FcValue v)
+FcConfigCompareValue (const FcValue *left_o,
+ FcOp op,
+ const FcValue *right_o)
{
- FcBool ret = FcFalse;
+ FcValue left = FcValueCanonicalize(left_o);
+ FcValue right = FcValueCanonicalize(right_o);
+ FcBool ret = FcFalse;
- m = FcConfigPromote (m, v);
- v = FcConfigPromote (v, m);
- if (m.type == v.type)
+ left = FcConfigPromote (left, right);
+ right = FcConfigPromote (right, left);
+ if (left.type == right.type)
{
- ret = FcFalse;
- switch (m.type) {
+ switch (left.type) {
case FcTypeInteger:
break; /* FcConfigPromote prevents this from happening */
case FcTypeDouble:
switch (op) {
case FcOpEqual:
case FcOpContains:
- ret = m.u.d == v.u.d;
+ case FcOpListing:
+ ret = left.u.d == right.u.d;
break;
- case FcOpNotEqual:
- ret = m.u.d != v.u.d;
+ case FcOpNotEqual:
+ case FcOpNotContains:
+ ret = left.u.d != right.u.d;
break;
case FcOpLess:
- ret = m.u.d < v.u.d;
+ ret = left.u.d < right.u.d;
break;
case FcOpLessEqual:
- ret = m.u.d <= v.u.d;
+ ret = left.u.d <= right.u.d;
break;
case FcOpMore:
- ret = m.u.d > v.u.d;
+ ret = left.u.d > right.u.d;
break;
case FcOpMoreEqual:
- ret = m.u.d >= v.u.d;
+ ret = left.u.d >= right.u.d;
break;
default:
break;
switch (op) {
case FcOpEqual:
case FcOpContains:
- ret = m.u.b == v.u.b;
+ case FcOpListing:
+ ret = left.u.b == right.u.b;
break;
- case FcOpNotEqual:
- ret = m.u.b != v.u.b;
+ case FcOpNotEqual:
+ case FcOpNotContains:
+ ret = left.u.b != right.u.b;
break;
default:
break;
case FcTypeString:
switch (op) {
case FcOpEqual:
+ case FcOpListing:
+ ret = FcStrCmpIgnoreCase (left.u.s, right.u.s) == 0;
+ break;
case FcOpContains:
- ret = FcStrCmpIgnoreCase (m.u.s, v.u.s) == 0;
+ ret = FcStrStrIgnoreCase (left.u.s, right.u.s) != 0;
+ break;
+ case FcOpNotEqual:
+ ret = FcStrCmpIgnoreCase (left.u.s, right.u.s) != 0;
break;
- case FcOpNotEqual:
- ret = FcStrCmpIgnoreCase (m.u.s, v.u.s) != 0;
+ case FcOpNotContains:
+ ret = FcStrCmpIgnoreCase (left.u.s, right.u.s) == 0;
break;
default:
break;
switch (op) {
case FcOpEqual:
case FcOpContains:
- ret = FcMatrixEqual (m.u.m, v.u.m);
+ case FcOpListing:
+ ret = FcMatrixEqual (left.u.m, right.u.m);
break;
case FcOpNotEqual:
- ret = !FcMatrixEqual (m.u.m, v.u.m);
+ case FcOpNotContains:
+ ret = !FcMatrixEqual (left.u.m, right.u.m);
break;
default:
break;
case FcTypeCharSet:
switch (op) {
case FcOpContains:
- /* m contains v if v is a subset of m */
- ret = FcCharSetIsSubset (v.u.c, m.u.c);
+ case FcOpListing:
+ /* left contains right if right is a subset of left */
+ ret = FcCharSetIsSubset (right.u.c, left.u.c);
+ break;
+ case FcOpNotContains:
+ /* left contains right if right is a subset of left */
+ ret = !FcCharSetIsSubset (right.u.c, left.u.c);
+ break;
+ case FcOpEqual:
+ ret = FcCharSetEqual (left.u.c, right.u.c);
+ break;
+ case FcOpNotEqual:
+ ret = !FcCharSetEqual (left.u.c, right.u.c);
+ break;
+ default:
+ break;
+ }
+ break;
+ case FcTypeLangSet:
+ switch (op) {
+ case FcOpContains:
+ case FcOpListing:
+ ret = FcLangSetContains (left.u.l, right.u.l);
+ break;
+ case FcOpNotContains:
+ ret = !FcLangSetContains (left.u.l, right.u.l);
break;
case FcOpEqual:
- ret = FcCharSetEqual (m.u.c, v.u.c);
+ ret = FcLangSetEqual (left.u.l, right.u.l);
break;
case FcOpNotEqual:
- ret = !FcCharSetEqual (m.u.c, v.u.c);
+ ret = !FcLangSetEqual (left.u.l, right.u.l);
break;
default:
break;
switch (op) {
case FcOpEqual:
case FcOpContains:
+ case FcOpListing:
ret = FcTrue;
break;
default:
case FcTypeFTFace:
switch (op) {
case FcOpEqual:
- ret = m.u.f == v.u.f;
+ case FcOpContains:
+ case FcOpListing:
+ ret = left.u.f == right.u.f;
break;
case FcOpNotEqual:
- ret = m.u.f != v.u.f;
+ case FcOpNotContains:
+ ret = left.u.f != right.u.f;
break;
default:
break;
}
+ break;
}
}
else
{
- if (op == FcOpNotEqual)
+ if (op == FcOpNotEqual || op == FcOpNotContains)
ret = FcTrue;
}
return ret;
}
+#define _FcDoubleFloor(d) ((int) (d))
+#define _FcDoubleCeil(d) ((double) (int) (d) == (d) ? (int) (d) : (int) ((d) + 1))
+#define FcDoubleFloor(d) ((d) >= 0 ? _FcDoubleFloor(d) : -_FcDoubleCeil(-(d)))
+#define FcDoubleCeil(d) ((d) >= 0 ? _FcDoubleCeil(d) : -_FcDoubleFloor(-(d)))
+#define FcDoubleRound(d) FcDoubleFloor ((d) + 0.5)
+#define FcDoubleTrunc(d) ((d) >= 0 ? _FcDoubleFloor (d) : -_FcDoubleFloor (-(d)))
+
static FcValue
FcConfigEvaluate (FcPattern *p, FcExpr *e)
{
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;
r = FcPatternGet (p, e->u.field, 0, &v);
if (r != FcResultMatch)
v.type = FcTypeVoid;
+ v = FcValueSave (v);
break;
case FcOpConst:
if (FcNameConstant (e->u.constant, &v.u.i))
v.type = FcTypeVoid;
FcValueDestroy (vl);
break;
- case FcOpOr:
- case FcOpAnd:
case FcOpEqual:
- case FcOpContains:
case FcOpNotEqual:
case FcOpLess:
case FcOpLessEqual:
case FcOpMore:
case FcOpMoreEqual:
+ case FcOpContains:
+ case FcOpNotContains:
+ case FcOpListing:
+ 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);
+ FcValueDestroy (vl);
+ FcValueDestroy (vr);
+ break;
+ case FcOpOr:
+ case FcOpAnd:
case FcOpPlus:
case FcOpMinus:
case FcOpTimes:
v.type = FcTypeDouble;
v.u.d = vl.u.d / vr.u.d;
break;
- case FcOpEqual:
- case FcOpContains:
- v.type = FcTypeBool;
- v.u.b = vl.u.d == vr.u.d;
- break;
- case FcOpNotEqual:
- v.type = FcTypeBool;
- v.u.b = vl.u.d != vr.u.d;
- break;
- case FcOpLess:
- v.type = FcTypeBool;
- v.u.b = vl.u.d < vr.u.d;
- break;
- case FcOpLessEqual:
- v.type = FcTypeBool;
- v.u.b = vl.u.d <= vr.u.d;
- break;
- case FcOpMore:
- v.type = FcTypeBool;
- v.u.b = vl.u.d > vr.u.d;
- break;
- case FcOpMoreEqual:
- v.type = FcTypeBool;
- v.u.b = vl.u.d >= vr.u.d;
- break;
default:
v.type = FcTypeVoid;
break;
v.type = FcTypeBool;
v.u.b = vl.u.b && vr.u.b;
break;
- case FcOpEqual:
- case FcOpContains:
- v.type = FcTypeBool;
- v.u.b = vl.u.b == vr.u.b;
- break;
- case FcOpNotEqual:
- v.type = FcTypeBool;
- v.u.b = vl.u.b != vr.u.b;
- break;
default:
v.type = FcTypeVoid;
break;
break;
case FcTypeString:
switch (e->op) {
- case FcOpEqual:
- case FcOpContains:
- v.type = FcTypeBool;
- v.u.b = FcStrCmpIgnoreCase (vl.u.s, vr.u.s) == 0;
- break;
- case FcOpNotEqual:
- v.type = FcTypeBool;
- v.u.b = FcStrCmpIgnoreCase (vl.u.s, vr.u.s) != 0;
- break;
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;
break;
case FcTypeMatrix:
switch (e->op) {
- case FcOpEqual:
- case FcOpContains:
- v.type = FcTypeBool;
- v.u.b = FcMatrixEqual (vl.u.m, vr.u.m);
- break;
- case FcOpNotEqual:
- v.type = FcTypeBool;
- v.u.b = FcMatrixEqual (vl.u.m, vr.u.m);
- break;
case FcOpTimes:
v.type = FcTypeMatrix;
m = malloc (sizeof (FcMatrix));
break;
}
break;
- case FcTypeCharSet:
- switch (e->op) {
- case FcOpContains:
- /* vl contains vr if vr is a subset of vl */
- v.type = FcTypeBool;
- v.u.b = FcCharSetIsSubset (vr.u.c, vl.u.c);
- break;
- case FcOpEqual:
- v.type = FcTypeBool;
- v.u.b = FcCharSetEqual (vl.u.c, vr.u.c);
- break;
- case FcOpNotEqual:
- v.type = FcTypeBool;
- v.u.b = !FcCharSetEqual (vl.u.c, vr.u.c);
- break;
- default:
- v.type = FcTypeVoid;
- break;
- }
- break;
default:
v.type = FcTypeVoid;
break;
}
FcValueDestroy (vl);
break;
+ case FcOpFloor:
+ vl = FcConfigEvaluate (p, e->u.tree.left);
+ switch (vl.type) {
+ case FcTypeInteger:
+ v = vl;
+ break;
+ case FcTypeDouble:
+ v.type = FcTypeInteger;
+ v.u.i = FcDoubleFloor (vl.u.d);
+ break;
+ default:
+ v.type = FcTypeVoid;
+ break;
+ }
+ FcValueDestroy (vl);
+ break;
+ case FcOpCeil:
+ vl = FcConfigEvaluate (p, e->u.tree.left);
+ switch (vl.type) {
+ case FcTypeInteger:
+ v = vl;
+ break;
+ case FcTypeDouble:
+ v.type = FcTypeInteger;
+ v.u.i = FcDoubleCeil (vl.u.d);
+ break;
+ default:
+ v.type = FcTypeVoid;
+ break;
+ }
+ FcValueDestroy (vl);
+ break;
+ case FcOpRound:
+ vl = FcConfigEvaluate (p, e->u.tree.left);
+ switch (vl.type) {
+ case FcTypeInteger:
+ v = vl;
+ break;
+ case FcTypeDouble:
+ v.type = FcTypeInteger;
+ v.u.i = FcDoubleRound (vl.u.d);
+ break;
+ default:
+ v.type = FcTypeVoid;
+ break;
+ }
+ FcValueDestroy (vl);
+ break;
+ case FcOpTrunc:
+ vl = FcConfigEvaluate (p, e->u.tree.left);
+ switch (vl.type) {
+ case FcTypeInteger:
+ v = vl;
+ break;
+ case FcTypeDouble:
+ v.type = FcTypeInteger;
+ v.u.i = FcDoubleTrunc (vl.u.d);
+ break;
+ default:
+ v.type = FcTypeVoid;
+ break;
+ }
+ FcValueDestroy (vl);
+ break;
default:
v.type = FcTypeVoid;
break;
while (e)
{
+ /* Compute the value of the match expression */
if (e->op == FcOpComma)
{
value = FcConfigEvaluate (p, e->u.tree.left);
e = 0;
}
- for (v = values; v; v = v->next)
+ for (v = values; v; v = FcValueListPtrU(v->next))
{
- if (FcConfigCompareValue (v->value, t->op, value))
+ /* Compare the pattern value to the match expression value */
+ if (FcConfigCompareValue (&v->value, t->op, &value))
{
if (!ret)
ret = v;
}
static FcValueList *
-FcConfigValues (FcPattern *p, FcExpr *e)
+FcConfigValues (FcPattern *p, FcExpr *e, FcValueBinding binding)
{
FcValueList *l;
if (e->op == FcOpComma)
{
l->value = FcConfigEvaluate (p, e->u.tree.left);
- l->next = FcConfigValues (p, e->u.tree.right);
+ l->next = FcValueListPtrCreateDynamic(FcConfigValues (p, e->u.tree.right, binding));
}
else
{
l->value = FcConfigEvaluate (p, e);
- l->next = 0;
+ l->next = FcValueListPtrCreateDynamic(0);
}
- l->binding = FcValueBindingWeak;
- while (l && l->value.type == FcTypeVoid)
+ l->binding = binding;
+ if (l->value.type == FcTypeVoid)
{
- FcValueList *next = l->next;
-
+ FcValueList *next = FcValueListPtrU(l->next);
+
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;
+ FcValueListPtr *prev, last, v;
+ FcValueBinding sameBinding;
+ if (position)
+ sameBinding = position->binding;
+ else
+ sameBinding = FcValueBindingWeak;
+ for (v = FcValueListPtrCreateDynamic(new); FcValueListPtrU(v);
+ v = FcValueListPtrU(v)->next)
+ if (FcValueListPtrU(v)->binding == FcValueBindingSame)
+ FcValueListPtrU(v)->binding = sameBinding;
if (append)
{
if (position)
prev = &position->next;
else
- for (prev = head; *prev; prev = &(*prev)->next)
+ for (prev = head; FcValueListPtrU(*prev);
+ prev = &(FcValueListPtrU(*prev)->next))
;
}
else
{
if (position)
{
- for (prev = head; *prev; prev = &(*prev)->next)
+ for (prev = head; FcValueListPtrU(*prev);
+ prev = &(FcValueListPtrU(*prev)->next))
{
- if (*prev == position)
+ if (FcValueListPtrU(*prev) == position)
break;
}
}
if (FcDebug () & FC_DBG_EDIT)
{
- if (!*prev)
+ if (!FcValueListPtrU(*prev))
printf ("position not on list\n");
}
}
if (new)
{
- last = new;
- while (last->next)
- last = last->next;
+ last = FcValueListPtrCreateDynamic(new);
+ while (FcValueListPtrU(FcValueListPtrU(last)->next))
+ last = FcValueListPtrU(last)->next;
- last->next = *prev;
- *prev = new;
+ FcValueListPtrU(last)->next = *prev;
+ *prev = FcValueListPtrCreateDynamic(new);
}
if (FcDebug () & FC_DBG_EDIT)
}
static void
-FcConfigDel (FcValueList **head,
+FcConfigDel (FcValueListPtr *head,
FcValueList *position)
{
- FcValueList **prev;
+ FcValueListPtr *prev;
- for (prev = head; *prev; prev = &(*prev)->next)
+ for (prev = head; FcValueListPtrU(*prev);
+ prev = &(FcValueListPtrU(*prev)->next))
{
- if (*prev == position)
+ if (FcValueListPtrU(*prev) == position)
{
*prev = position->next;
- position->next = 0;
- FcValueListDestroy (position);
+ position->next = FcValueListPtrCreateDynamic(0);
+ FcValueListDestroy (FcValueListPtrCreateDynamic(position));
break;
}
}
FcPatternElt *e = FcPatternFindElt (p, object);
if (!e)
return;
- while (e->values)
- FcConfigDel (&e->values, e->values);
+ while (FcValueListPtrU(e->values))
+ FcConfigDel (&e->values, FcValueListPtrU(e->values));
}
static void
FcPatternElt *e = FcPatternFindElt (p, object);
if (!e)
return;
- if (!e->values)
+ if (!FcValueListPtrU(e->values))
FcPatternDel (p, object);
}
FcBool
-FcConfigSubstitute (FcConfig *config,
- FcPattern *p,
- FcMatchKind kind)
+FcConfigSubstituteWithPat (FcConfig *config,
+ FcPattern *p,
+ FcPattern *p_pat,
+ FcMatchKind kind)
{
FcSubst *s;
FcSubState *st;
FcTest *t;
FcEdit *e;
FcValueList *l;
+ FcPattern *m;
if (!config)
{
printf ("FcConfigSubstitute test ");
FcTestPrint (t);
}
- st[i].elt = FcPatternFindElt (p, t->field);
+ st[i].elt = 0;
+ if (kind == FcMatchFont && t->kind == FcMatchPattern)
+ m = p_pat;
+ else
+ m = p;
+ if (m)
+ st[i].elt = FcPatternFindElt (m, t->field);
+ else
+ st[i].elt = 0;
/*
* If there's no such field in the font,
* then FcQualAll matches while FcQualAny does not
* Check to see if there is a match, mark the location
* to apply match-relative edits
*/
- st[i].value = FcConfigMatchValueList (p, t, st[i].elt->values);
+ st[i].value = FcConfigMatchValueList (m, t, FcValueListPtrU(st[i].elt->values));
if (!st[i].value)
break;
- if (t->qual == FcQualFirst && st[i].value != st[i].elt->values)
+ if (t->qual == FcQualFirst && st[i].value != FcValueListPtrU(st[i].elt->values))
break;
- if (t->qual == FcQualNotFirst && st[i].value == st[i].elt->values)
+ if (t->qual == FcQualNotFirst && st[i].value == FcValueListPtrU(st[i].elt->values))
break;
}
if (t)
/*
* Evaluate the list of expressions
*/
- l = FcConfigValues (p, e->expr);
+ l = FcConfigValues (p, e->expr, e->binding);
/*
- * Locate any test associated with this field
+ * Locate any test associated with this field, skipping
+ * tests associated with the pattern when substituting in
+ * the font
*/
for (t = s->test, i = 0; t; t = t->next, i++)
- if (!FcStrCmpIgnoreCase ((FcChar8 *) t->field, (FcChar8 *) e->field))
+ {
+ if ((t->kind == FcMatchFont || kind == FcMatchPattern) &&
+ !FcStrCmpIgnoreCase ((FcChar8 *) t->field,
+ (FcChar8 *) e->field))
+ {
+ /*
+ * KLUDGE - the pattern may have been reallocated or
+ * things may have been inserted or deleted above
+ * this element by other edits. Go back and find
+ * the element again
+ */
+ if (e != s->edit && st[i].elt)
+ st[i].elt = FcPatternFindElt (p, t->field);
+ if (!st[i].elt)
+ t = 0;
break;
+ }
+ }
switch (e->op) {
case FcOpAssign:
/*
if (t)
{
FcValueList *thisValue = st[i].value;
- FcValueList *nextValue = thisValue ? thisValue->next : 0;
+ FcValueList *nextValue = thisValue ? FcValueListPtrU(thisValue->next) : 0;
/*
* 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
FcConfigPatternAdd (p, e->field, l, FcTrue);
break;
default:
+ FcValueListDestroy (FcValueListPtrCreateDynamic(l));
break;
}
}
return FcTrue;
}
-#ifndef FONTCONFIG_PATH
-#define FONTCONFIG_PATH "/etc/fonts"
-#endif
+FcBool
+FcConfigSubstitute (FcConfig *config,
+ FcPattern *p,
+ FcMatchKind kind)
+{
+ return FcConfigSubstituteWithPat (config, p, 0, kind);
+}
+
+#if defined (_WIN32) && (defined (PIC) || defined (DLL_EXPORT))
+
+static FcChar8 fontconfig_path[1000] = "";
+
+BOOL WINAPI
+DllMain (HINSTANCE hinstDLL,
+ DWORD fdwReason,
+ LPVOID lpvReserved)
+{
+ FcChar8 *p;
+
+ switch (fdwReason) {
+ case DLL_PROCESS_ATTACH:
+ if (!GetModuleFileName ((HMODULE) hinstDLL, fontconfig_path,
+ sizeof (fontconfig_path)))
+ break;
+
+ /* If the fontconfig DLL is in a "bin" or "lib" subfolder,
+ * assume it's a Unix-style installation tree, and use
+ * "etc/fonts" in there as FONTCONFIG_PATH. Otherwise use the
+ * folder where the DLL is as FONTCONFIG_PATH.
+ */
+ p = strrchr (fontconfig_path, '\\');
+ if (p)
+ {
+ *p = '\0';
+ p = strrchr (fontconfig_path, '\\');
+ if (p && (FcStrCmpIgnoreCase (p + 1, "bin") == 0 ||
+ FcStrCmpIgnoreCase (p + 1, "lib") == 0))
+ *p = '\0';
+ strcat (fontconfig_path, "\\etc\\fonts");
+ }
+ else
+ fontconfig_path[0] = '\0';
+
+ break;
+ }
+
+ return TRUE;
+}
+
+#undef FONTCONFIG_PATH
+#define FONTCONFIG_PATH fontconfig_path
+
+#else /* !(_WIN32 && PIC) */
+
+#endif /* !(_WIN32 && PIC) */
#ifndef FONTCONFIG_FILE
#define FONTCONFIG_FILE "fonts.conf"
return 0;
strcpy ((char *) path, (const char *) dir);
- /* make sure there's a single separating / */
+ /* make sure there's a single separator */
+#ifdef _WIN32
+ if ((!path[0] || (path[strlen((char *) path)-1] != '/' &&
+ path[strlen((char *) path)-1] != '\\')) &&
+ !(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] != '/')
strcat ((char *) path, "/");
+#endif
strcat ((char *) path, (char *) file);
+ FcMemAlloc (FC_MEM_STRING, strlen ((char *) path) + 1);
if (access ((char *) path, R_OK) == 0)
return path;
- free (path);
+ FcStrFree (path);
return 0;
}
e = env;
npath++;
while (*e)
- if (*e++ == ':')
+ if (*e++ == FC_SEARCH_PATH_SEPARATOR)
npath++;
}
path = calloc (npath, sizeof (FcChar8 *));
e = env;
while (*e)
{
- colon = (FcChar8 *) strchr ((char *) e, ':');
+ colon = (FcChar8 *) strchr ((char *) e, FC_SEARCH_PATH_SEPARATOR);
if (!colon)
colon = e + strlen ((char *) e);
path[i] = malloc (colon - e + 1);
free (path);
}
+static FcBool _FcConfigHomeEnabled = FcTrue;
+
+FcChar8 *
+FcConfigHome (void)
+{
+ if (_FcConfigHomeEnabled)
+ {
+ char *home = getenv ("HOME");
+
+#ifdef _WIN32
+ if (home == NULL)
+ home = getenv ("USERPROFILE");
+#endif
+
+ return (FcChar8 *) home;
+ }
+ return 0;
+}
+
+FcBool
+FcConfigEnableHome (FcBool enable)
+{
+ FcBool prev = _FcConfigHomeEnabled;
+ _FcConfigHomeEnabled = enable;
+ return prev;
+}
+
FcChar8 *
FcConfigFilename (const FcChar8 *url)
{
url = (FcChar8 *) FONTCONFIG_FILE;
}
file = 0;
+
+#ifdef _WIN32
+ if (isalpha (*url) &&
+ url[1] == ':' &&
+ (url[2] == '/' || url[2] == '\\'))
+ goto absolute_path;
+#endif
+
switch (*url) {
case '~':
- dir = (FcChar8 *) getenv ("HOME");
+ dir = FcConfigHome ();
if (dir)
file = FcConfigFileExists (dir, url + 1);
else
file = 0;
break;
+#ifdef _WIN32
+ case '\\':
+ absolute_path:
+#endif
case '/':
file = FcConfigFileExists (0, url);
break;
FcConfigSetFonts (config, set, FcSetApplication);
}
- if (!FcFileScan (set, subdirs, 0, config->blanks, file, FcFalse))
+ if (!FcFileScanConfig (set, subdirs, 0, config->blanks, file, FcFalse, config))
{
FcStrSetDestroy (subdirs);
return FcFalse;
}
FcStrListDone (sublist);
}
+ FcStrSetDestroy (subdirs);
return FcTrue;
}
FcConfigSetFonts (config, set, FcSetApplication);
}
- if (!FcDirScan (set, subdirs, 0, config->blanks, dir, FcFalse))
+ if (!FcDirScanConfig (set, subdirs, 0, config->blanks, dir, FcFalse, config))
{
FcStrSetDestroy (subdirs);
return FcFalse;
}
FcStrListDone (sublist);
}
+ FcStrSetDestroy (subdirs);
return FcTrue;
}
void
FcConfigAppFontClear (FcConfig *config)
{
+ if (!config)
+ {
+ config = FcConfigGetCurrent ();
+ if (!config)
+ return;
+ }
+
FcConfigSetFonts (config, 0, FcSetApplication);
}
+
+/*
+ * Manage filename-based font source selectors
+ */
+
+FcBool
+FcConfigGlobAdd (FcConfig *config,
+ const FcChar8 *glob,
+ FcBool accept)
+{
+ FcStrSet *set = accept ? config->acceptGlobs : config->rejectGlobs;
+
+ return FcStrSetAdd (set, glob);
+}
+
+static FcBool
+FcConfigGlobMatch (const FcChar8 *glob,
+ const FcChar8 *string)
+{
+ FcChar8 c;
+
+ while ((c = *glob++))
+ {
+ switch (c) {
+ case '*':
+ /* short circuit common case */
+ if (!*glob)
+ return FcTrue;
+ /* short circuit another common case */
+ if (strchr ((char *) glob, '*') == 0)
+ string += strlen ((char *) string) - strlen ((char *) glob);
+ while (*string)
+ {
+ if (FcConfigGlobMatch (glob, string))
+ return FcTrue;
+ string++;
+ }
+ return FcFalse;
+ case '?':
+ if (*string++ == '\0')
+ return FcFalse;
+ break;
+ default:
+ if (*string++ != c)
+ return FcFalse;
+ break;
+ }
+ }
+ return *string == '\0';
+}
+
+static FcBool
+FcConfigGlobsMatch (const FcStrSet *globs,
+ const FcChar8 *string)
+{
+ int i;
+
+ for (i = 0; i < globs->num; i++)
+ if (FcConfigGlobMatch (globs->strs[i], string))
+ return FcTrue;
+ return FcFalse;
+}
+
+FcBool
+FcConfigAcceptFilename (FcConfig *config,
+ const FcChar8 *filename)
+{
+ if (FcConfigGlobsMatch (config->acceptGlobs, filename))
+ return FcTrue;
+ if (FcConfigGlobsMatch (config->rejectGlobs, filename))
+ 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;
+}