/*
- * $XFree86: $
+ * $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
* PERFORMANCE OF THIS SOFTWARE.
*/
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
#include "fcint.h"
-static FcConfig *fcConfig;
+#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;
FcConfig *
FcConfigCreate (void)
config = malloc (sizeof (FcConfig));
if (!config)
goto bail0;
+ FcMemAlloc (FC_MEM_CONFIG, sizeof (FcConfig));
- config->dirs = malloc (sizeof (char *));
- if (!config->dirs)
+ config->configDirs = FcStrSetCreate ();
+ if (!config->configDirs)
goto bail1;
- config->dirs[0] = 0;
- config->configFiles = malloc (sizeof (char *));
+ config->configFiles = FcStrSetCreate ();
if (!config->configFiles)
goto bail2;
- config->configFiles[0] = 0;
- config->cache = 0;
- if (!FcConfigSetCache (config, "~/" FC_USER_CACHE_FILE))
+ config->fontDirs = FcStrSetCreate ();
+ if (!config->fontDirs)
goto bail3;
+
+ 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 bail6;
+ }
+ FcStrFree (cache_dir);
+ }
+ }
+#endif
config->blanks = 0;
config->maxObjects = 0;
for (set = FcSetSystem; set <= FcSetApplication; set++)
config->fonts[set] = 0;
+
+ config->rescanTime = time(0);
+ config->rescanInterval = 30;
return config;
+bail8:
+ FcFontSetDestroy (config->rejectPatterns);
+bail7:
+ FcFontSetDestroy (config->acceptPatterns);
+bail6:
+ FcStrSetDestroy (config->rejectGlobs);
+bail5:
+ FcStrSetDestroy (config->acceptGlobs);
+bail4:
+ FcStrSetDestroy (config->fontDirs);
bail3:
- free (config->configFiles);
+ FcStrSetDestroy (config->configFiles);
bail2:
- free (config->dirs);
+ FcStrSetDestroy (config->configDirs);
bail1:
free (config);
+ FcMemFree (FC_MEM_CONFIG, sizeof (FcConfig));
bail0:
return 0;
}
+typedef struct _FcFileTime {
+ time_t time;
+ FcBool set;
+} FcFileTime;
+
+static FcFileTime
+FcConfigNewestFile (FcStrSet *files)
+{
+ FcStrList *list = FcStrListCreate (files);
+ FcFileTime newest = { 0, FcFalse };
+ FcChar8 *file;
+ struct stat statb;
+
+ if (list)
+ {
+ 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;
+ time_t now = time(0);
+ if (!config)
+ {
+ config = FcConfigGetCurrent ();
+ if (!config)
+ return FcFalse;
+ }
+ config_time = FcConfigNewestFile (config->configFiles);
+ font_time = FcConfigNewestFile (config->fontDirs);
+ if ((config_time.set && config_time.time - config->rescanTime > 0) ||
+ (font_time.set && (font_time.time - config->rescanTime) > 0))
+ {
+ return FcFalse;
+ }
+ config->rescanTime = now;
+ return FcTrue;
+}
+
static void
FcSubstDestroy (FcSubst *s)
{
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;
}
}
-static void
-FcConfigDestroyStrings (char **strings)
-{
- char **s;
-
- for (s = strings; s && *s; s++)
- free (*s);
- if (strings)
- free (strings);
-}
-
-static FcBool
-FcConfigAddString (char ***strings, char *string)
-{
- int n;
- char **s;
-
- n = 0;
- for (s = *strings; s && *s; s++)
- n++;
- s = malloc ((n + 2) * sizeof (char *));
- if (!s)
- return FcFalse;
- s[n] = string;
- s[n+1] = 0;
- memcpy (s, *strings, n * sizeof (char *));
- free (*strings);
- *strings = s;
- return FcTrue;
-}
-
void
FcConfigDestroy (FcConfig *config)
{
FcSetName set;
- FcConfigDestroyStrings (config->dirs);
- FcConfigDestroyStrings (config->configFiles);
- free (config->cache);
+ if (config == _fcConfig)
+ _fcConfig = 0;
+
+ FcStrSetDestroy (config->configDirs);
+ FcStrSetDestroy (config->fontDirs);
+ FcStrSetDestroy (config->configFiles);
+ FcStrSetDestroy (config->acceptGlobs);
+ FcStrSetDestroy (config->rejectGlobs);
+ FcFontSetDestroy (config->acceptPatterns);
+ FcFontSetDestroy (config->rejectPatterns);
+
+ 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;
- FcFileCache *cache;
- char **d;
+ FcFontSet *fonts;
+ FcGlobalCache *cache;
+ FcStrList *list;
+ FcChar8 *dir;
fonts = FcFontSetCreate ();
if (!fonts)
goto bail0;
- cache = FcFileCacheCreate ();
+ cache = FcGlobalCacheCreate ();
if (!cache)
goto bail1;
- FcFileCacheLoad (cache, config->cache);
+ if (config->cache)
+ FcGlobalCacheLoad (cache, config->cache);
+
+ list = FcConfigGetFontDirs (config);
+ if (!list)
+ goto bail1;
- for (d = config->dirs; d && *d; d++)
+ while ((dir = FcStrListNext (list)))
{
if (FcDebug () & FC_DBG_FONTSET)
- printf ("scan dir %s\n", *d);
- FcDirScan (fonts, cache, config->blanks, *d, FcFalse);
+ printf ("scan dir %s\n", dir);
+ FcDirScanConfig (fonts, config->fontDirs, cache,
+ config->blanks, dir, FcFalse, config);
}
+ FcStrListDone (list);
+
if (FcDebug () & FC_DBG_FONTSET)
FcFontSetPrint (fonts);
- FcFileCacheSave (cache, config->cache);
- FcFileCacheDestroy (cache);
+ if (config->cache)
+ FcGlobalCacheSave (cache, config->cache);
+ FcGlobalCacheDestroy (cache);
FcConfigSetFonts (config, fonts, FcSetSystem);
if (!FcConfigBuildFonts (config))
return FcFalse;
- if (fcConfig)
- FcConfigDestroy (fcConfig);
- fcConfig = config;
+ if (_fcConfig)
+ FcConfigDestroy (_fcConfig);
+ _fcConfig = config;
return FcTrue;
}
FcConfig *
FcConfigGetCurrent (void)
{
- return fcConfig;
+ if (!_fcConfig)
+ if (!FcInit ())
+ return 0;
+ return _fcConfig;
}
FcBool
-FcConfigAddDir (FcConfig *config,
- const char *d)
+FcConfigAddConfigDir (FcConfig *config,
+ const FcChar8 *d)
{
- char *dir;
- char *h;
+ return FcStrSetAddFilename (config->configDirs, d);
+}
- if (*d == '~')
- {
- h = getenv ("HOME");
- if (!h)
- return FcFalse;
- dir = (char *) malloc (strlen (h) + strlen (d));
- if (!dir)
- return FcFalse;
- strcpy (dir, h);
- strcat (dir, d+1);
- }
- else
- {
- dir = (char *) malloc (strlen (d) + 1);
- if (!dir)
- return FcFalse;
- strcpy (dir, d);
- }
- if (!FcConfigAddString (&config->dirs, dir))
+FcStrList *
+FcConfigGetConfigDirs (FcConfig *config)
+{
+ if (!config)
{
- free (dir);
- return FcFalse;
+ config = FcConfigGetCurrent ();
+ if (!config)
+ return 0;
}
- return FcTrue;
+ return FcStrListCreate (config->configDirs);
+}
+
+FcBool
+FcConfigAddFontDir (FcConfig *config,
+ const FcChar8 *d)
+{
+ return FcStrSetAddFilename (config->fontDirs, d);
+}
+
+FcBool
+FcConfigAddDir (FcConfig *config,
+ const FcChar8 *d)
+{
+ return (FcConfigAddConfigDir (config, d) &&
+ FcConfigAddFontDir (config, d));
}
-char **
-FcConfigGetDirs (FcConfig *config)
+FcStrList *
+FcConfigGetFontDirs (FcConfig *config)
{
if (!config)
{
if (!config)
return 0;
}
- return config->dirs;
+ return FcStrListCreate (config->fontDirs);
}
FcBool
FcConfigAddConfigFile (FcConfig *config,
- const char *f)
+ const FcChar8 *f)
{
- char *file;
- file = FcConfigFilename (f);
+ FcBool ret;
+ FcChar8 *file = FcConfigFilename (f);
+
if (!file)
return FcFalse;
- if (!FcConfigAddString (&config->configFiles, file))
- {
- free (file);
- return FcFalse;
- }
- return FcTrue;
+
+ ret = FcStrSetAdd (config->configFiles, file);
+ FcStrFree (file);
+ return ret;
}
-char **
+FcStrList *
FcConfigGetConfigFiles (FcConfig *config)
{
if (!config)
if (!config)
return 0;
}
- return config->configFiles;
+ return FcStrListCreate (config->configFiles);
}
FcBool
FcConfigSetCache (FcConfig *config,
- const char *c)
+ const FcChar8 *c)
{
- char *new;
- char *h;
-
- if (*c == '~')
- {
- h = getenv ("HOME");
- if (!h)
- return FcFalse;
- new = (char *) malloc (strlen (h) + strlen (c));
- if (!new)
- return FcFalse;
- strcpy (new, h);
- strcat (new, c+1);
- }
- else
- {
- new = FcStrCopy (c);
- }
+ FcChar8 *new = FcStrCopyFilename (c);
+
+ if (!new)
+ return FcFalse;
if (config->cache)
- free (config->cache);
+ FcStrFree (config->cache);
config->cache = new;
return FcTrue;
}
-char *
+FcChar8 *
FcConfigGetCache (FcConfig *config)
{
if (!config)
config->fonts[set] = fonts;
}
+
+
FcBlanks *
FcConfigGetBlanks (FcConfig *config)
{
return FcTrue;
}
+int
+FcConfigGetRescanInverval (FcConfig *config)
+{
+ if (!config)
+ {
+ config = FcConfigGetCurrent ();
+ if (!config)
+ return 0;
+ }
+ return config->rescanInterval;
+}
+
+FcBool
+FcConfigSetRescanInverval (FcConfig *config, int rescanInterval)
+{
+ if (!config)
+ {
+ config = FcConfigGetCurrent ();
+ if (!config)
+ return FcFalse;
+ }
+ config->rescanInterval = rescanInterval;
+ return FcTrue;
+}
+
FcBool
FcConfigAddEdit (FcConfig *config,
FcTest *test,
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;
}
FcValueList *value;
} FcSubState;
-static const FcMatrix FcIdentityMatrix = { 1, 0, 0, 1 };
-
static FcValue
FcConfigPromote (FcValue v, FcValue u)
{
}
else if (v.type == FcTypeVoid && u.type == FcTypeMatrix)
{
- v.u.m = (FcMatrix *) &FcIdentityMatrix;
+ 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 = left_o;
+ FcValue right = 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 (m.u.s, v.u.s) != 0;
+ case FcOpNotEqual:
+ 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 - m is empty */
- ret = FcCharSetSubtractCount (v.u.c, m.u.c) == 0;
+ 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:
break;
}
break;
+ case FcTypeFTFace:
+ switch (op) {
+ case FcOpEqual:
+ case FcOpContains:
+ case FcOpListing:
+ ret = left.u.f == right.u.f;
+ break;
+ case FcOpNotEqual:
+ 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 *s;
switch (e->op) {
case FcOpInteger:
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);
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 - vl is empty */
- v.type = FcTypeBool;
- v.u.b = FcCharSetSubtractCount (vr.u.c, vl.u.c) == 0;
- 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;
static FcValueList *
FcConfigMatchValueList (FcPattern *p,
FcTest *t,
- FcValueList *v)
+ FcValueList *values)
{
- FcValueList *ret = 0;
- FcValue value = FcConfigEvaluate (p, t->expr);
+ FcValueList *ret = 0;
+ FcExpr *e = t->expr;
+ FcValue value;
+ FcValueList *v;
- for (; v; v = v->next)
+ while (e)
{
- if (FcConfigCompareValue (v->value, t->op, value))
+ /* Compute the value of the match expression */
+ if (e->op == FcOpComma)
{
- if (!ret)
- ret = v;
+ value = FcConfigEvaluate (p, e->u.tree.left);
+ e = e->u.tree.right;
}
else
{
- if (t->qual == FcQualAll)
+ value = FcConfigEvaluate (p, e);
+ e = 0;
+ }
+
+ for (v = values; v; v = v->next)
+ {
+ /* Compare the pattern value to the match expression value */
+ if (FcConfigCompareValue (v->value, t->op, value))
{
- ret = 0;
- break;
+ if (!ret)
+ ret = v;
+ }
+ else
+ {
+ if (t->qual == FcQualAll)
+ {
+ ret = 0;
+ break;
+ }
}
}
+ FcValueDestroy (value);
}
- FcValueDestroy (value);
return ret;
}
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 = FcConfigValues (p, e->u.tree.right, binding);
}
else
{
l->value = FcConfigEvaluate (p, e);
l->next = 0;
}
- while (l->value.type == FcTypeVoid)
+ l->binding = binding;
+ while (l && l->value.type == FcTypeVoid)
{
FcValueList *next = l->next;
FcBool append,
FcValueList *new)
{
- FcValueList **prev, *last;
+ FcValueList **prev, *last, *v;
+ FcValueBinding sameBinding;
+ if (position)
+ sameBinding = position->binding;
+ else
+ sameBinding = FcValueBindingWeak;
+ for (v = new; v; v = v->next)
+ if (v->binding == FcValueBindingSame)
+ v->binding = sameBinding;
if (append)
{
if (position)
{
if (list)
{
- FcPatternElt *e = FcPatternFind (p, object, FcTrue);
+ FcPatternElt *e = FcPatternInsertElt (p, object);
if (!e)
return;
FcConfigPatternDel (FcPattern *p,
const char *object)
{
- FcPatternElt *e = FcPatternFind (p, object, FcFalse);
+ FcPatternElt *e = FcPatternFindElt (p, object);
if (!e)
return;
while (e->values)
FcConfigPatternCanon (FcPattern *p,
const char *object)
{
- FcPatternElt *e = FcPatternFind (p, object, FcFalse);
+ FcPatternElt *e = FcPatternFindElt (p, object);
if (!e)
return;
if (!e->values)
}
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 = FcPatternFind (p, t->field, FcFalse);
+ 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, st[i].elt->values);
if (!st[i].value)
break;
+ if (t->qual == FcQualFirst && st[i].value != st[i].elt->values)
+ break;
+ if (t->qual == FcQualNotFirst && st[i].value == 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 (t->field, 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:
/*
* Append the new list of values after the current value
*/
FcConfigAdd (&st[i].elt->values, thisValue, FcTrue, l);
+ /*
+ * Delete the marked value
+ */
+ FcConfigDel (&st[i].elt->values, thisValue);
/*
* Adjust any pointers into the value list to ensure
* future edits occur at the same place
if (st[i].value == thisValue)
st[i].value = nextValue;
}
- /*
- * Delete the marked value
- */
- FcConfigDel (&st[i].elt->values, thisValue);
break;
}
/* fall through ... */
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"
#endif
-static char *
-FcConfigFileExists (const char *dir, const char *file)
+static FcChar8 *
+FcConfigFileExists (const FcChar8 *dir, const FcChar8 *file)
{
- char *path;
+ FcChar8 *path;
if (!dir)
- dir = "";
- path = malloc (strlen (dir) + 1 + strlen (file) + 1);
+ dir = (FcChar8 *) "";
+ path = malloc (strlen ((char *) dir) + 1 + strlen ((char *) file) + 1);
if (!path)
return 0;
- strcpy (path, dir);
- /* make sure there's a single separating / */
- if ((!path[0] || path[strlen(path)-1] != '/') && file[0] != '/')
- strcat (path, "/");
- strcat (path, file);
+ strcpy ((char *) path, (const char *) dir);
+ /* 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] != '\\'))
+ strcat ((char *) path, "\\");
+#else
+ if ((!path[0] || path[strlen((char *) path)-1] != '/') && file[0] != '/')
+ strcat ((char *) path, "/");
+#endif
+ strcat ((char *) path, (char *) file);
- if (access (path, R_OK) == 0)
+ FcMemAlloc (FC_MEM_STRING, strlen ((char *) path) + 1);
+ if (access ((char *) path, R_OK) == 0)
return path;
- free (path);
+ FcStrFree (path);
return 0;
}
-static char **
+static FcChar8 **
FcConfigGetPath (void)
{
- char **path;
- char *env, *e, *colon;
- char *dir;
+ FcChar8 **path;
+ FcChar8 *env, *e, *colon;
+ FcChar8 *dir;
int npath;
int i;
npath = 2; /* default dir + null */
- env = getenv ("FONTCONFIG_PATH");
+ env = (FcChar8 *) getenv ("FONTCONFIG_PATH");
if (env)
{
e = env;
npath++;
while (*e)
- if (*e++ == ':')
+ if (*e++ == FC_SEARCH_PATH_SEPARATOR)
npath++;
}
- path = calloc (npath, sizeof (char *));
+ path = calloc (npath, sizeof (FcChar8 *));
if (!path)
goto bail0;
i = 0;
e = env;
while (*e)
{
- colon = strchr (e, ':');
+ colon = (FcChar8 *) strchr ((char *) e, FC_SEARCH_PATH_SEPARATOR);
if (!colon)
- colon = e + strlen (e);
+ colon = e + strlen ((char *) e);
path[i] = malloc (colon - e + 1);
if (!path[i])
goto bail1;
- strncpy (path[i], e, colon - e);
+ strncpy ((char *) path[i], (const char *) e, colon - e);
path[i][colon - e] = '\0';
if (*colon)
e = colon + 1;
}
}
- dir = FONTCONFIG_PATH;
- path[i] = malloc (strlen (dir) + 1);
+ dir = (FcChar8 *) FONTCONFIG_PATH;
+ path[i] = malloc (strlen ((char *) dir) + 1);
if (!path[i])
goto bail1;
- strcpy (path[i], dir);
+ strcpy ((char *) path[i], (const char *) dir);
return path;
bail1:
}
static void
-FcConfigFreePath (char **path)
+FcConfigFreePath (FcChar8 **path)
{
- char **p;
+ FcChar8 **p;
for (p = path; *p; p++)
free (*p);
free (path);
}
-char *
-FcConfigFilename (const char *url)
+static FcBool _FcConfigHomeEnabled = FcTrue;
+
+FcChar8 *
+FcConfigHome (void)
+{
+ if (_FcConfigHomeEnabled)
+ {
+ char *home = getenv ("HOME");
+
+#ifdef _WIN32
+ if (home == NULL)
+ home = getenv ("USERPROFILE");
+#endif
+
+ return home;
+ }
+ return 0;
+}
+
+FcBool
+FcConfigEnableHome (FcBool enable)
{
- char *file, *dir, **path, **p;
+ FcBool prev = _FcConfigHomeEnabled;
+ _FcConfigHomeEnabled = enable;
+ return prev;
+}
+
+FcChar8 *
+FcConfigFilename (const FcChar8 *url)
+{
+ FcChar8 *file, *dir, **path, **p;
if (!url || !*url)
{
- url = getenv ("FONTCONFIG_FILE");
+ url = (FcChar8 *) getenv ("FONTCONFIG_FILE");
if (!url)
- url = FONTCONFIG_FILE;
+ 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 = 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;
FcBool
FcConfigAppFontAddFile (FcConfig *config,
- const char *file)
+ const FcChar8 *file)
{
FcFontSet *set;
+ FcStrSet *subdirs;
+ FcStrList *sublist;
+ FcChar8 *subdir;
if (!config)
{
return FcFalse;
}
+ subdirs = FcStrSetCreate ();
+ if (!subdirs)
+ return FcFalse;
+
set = FcConfigGetFonts (config, FcSetApplication);
if (!set)
{
set = FcFontSetCreate ();
if (!set)
+ {
+ FcStrSetDestroy (subdirs);
return FcFalse;
+ }
FcConfigSetFonts (config, set, FcSetApplication);
}
- return FcFileScan (set, 0, config->blanks, file, FcFalse);
+
+ if (!FcFileScanConfig (set, subdirs, 0, config->blanks, file, FcFalse, config))
+ {
+ FcStrSetDestroy (subdirs);
+ return FcFalse;
+ }
+ if ((sublist = FcStrListCreate (subdirs)))
+ {
+ while ((subdir = FcStrListNext (sublist)))
+ {
+ FcConfigAppFontAddDir (config, subdir);
+ }
+ FcStrListDone (sublist);
+ }
+ return FcTrue;
}
FcBool
FcConfigAppFontAddDir (FcConfig *config,
- const char *dir)
+ const FcChar8 *dir)
{
FcFontSet *set;
+ FcStrSet *subdirs;
+ FcStrList *sublist;
+ FcChar8 *subdir;
if (!config)
{
if (!config)
return FcFalse;
}
+ subdirs = FcStrSetCreate ();
+ if (!subdirs)
+ return FcFalse;
+
set = FcConfigGetFonts (config, FcSetApplication);
if (!set)
{
set = FcFontSetCreate ();
if (!set)
+ {
+ FcStrSetDestroy (subdirs);
return FcFalse;
+ }
FcConfigSetFonts (config, set, FcSetApplication);
}
- return FcDirScan (set, 0, config->blanks, dir, FcFalse);
+
+ if (!FcDirScanConfig (set, subdirs, 0, config->blanks, dir, FcFalse, config))
+ {
+ FcStrSetDestroy (subdirs);
+ return FcFalse;
+ }
+ if ((sublist = FcStrListCreate (subdirs)))
+ {
+ while ((subdir = FcStrListNext (sublist)))
+ {
+ FcConfigAppFontAddDir (config, subdir);
+ }
+ FcStrListDone (sublist);
+ }
+ 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;
+}
git.wh0rd.org / fontconfig.git / blobdiff