X-Git-Url: https://git.wh0rd.org/?a=blobdiff_plain;f=src%2Ffccfg.c;h=3cea2c9406940244facfb3b3ccfb28f8085648d8;hb=c2c6976d1a88cc35143ffcc34f3c38d0a28d34f4;hp=238edd3a1fc9150d0d0508adce4d457035913a0d;hpb=f45d39b1fda93c949f4625a9fcee0c482b5cacd7;p=fontconfig.git diff --git a/src/fccfg.c b/src/fccfg.c index 238edd3..3cea2c9 100644 --- a/src/fccfg.c +++ b/src/fccfg.c @@ -1,7 +1,7 @@ /* * $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 @@ -23,13 +23,19 @@ */ #include "fcint.h" +#include +#include -#if defined (_WIN32) && defined (PIC) +#if defined (_WIN32) && (defined (PIC) || defined (DLL_EXPORT)) #define STRICT #include #undef STRICT #endif +#if defined (_WIN32) && !defined (R_OK) +#define R_OK 4 +#endif + FcConfig *_fcConfig; FcConfig * @@ -55,11 +61,26 @@ FcConfigCreate (void) if (!config->fontDirs) goto bail3; - config->cache = 0; - if (FcConfigHome()) - if (!FcConfigSetCache (config, (FcChar8 *) ("~/" FC_USER_CACHE_FILE))) - goto bail4; + 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->cacheDirs = FcStrSetCreate (); + if (!config->cacheDirs) + goto bail8; + config->blanks = 0; config->substPattern = 0; @@ -68,11 +89,21 @@ FcConfigCreate (void) for (set = FcSetSystem; set <= FcSetApplication; set++) config->fonts[set] = 0; + config->caches = NULL; + 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: @@ -86,11 +117,6 @@ bail0: return 0; } -typedef struct _FcFileTime { - time_t time; - FcBool set; -} FcFileTime; - static FcFileTime FcConfigNewestFile (FcStrSet *files) { @@ -104,12 +130,28 @@ 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) { @@ -122,9 +164,9 @@ 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; } @@ -144,6 +186,8 @@ FcSubstDestroy (FcSubst *s) FcTestDestroy (s->test); if (s->edit) FcEditDestroy (s->edit); + free (s); + FcMemFree (FC_MEM_SUBST, sizeof (FcSubst)); s = n; } } @@ -152,74 +196,155 @@ void FcConfigDestroy (FcConfig *config) { FcSetName set; + FcCacheList *cl, *cl_next; if (config == _fcConfig) _fcConfig = 0; 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); FcSubstDestroy (config->substPattern); FcSubstDestroy (config->substFont); for (set = FcSetSystem; set <= FcSetApplication; set++) if (config->fonts[set]) FcFontSetDestroy (config->fonts[set]); + + for (cl = config->caches; cl; cl = cl_next) + { + cl_next = cl->next; + FcDirCacheUnload (cl->cache); + free (cl); + } + free (config); FcMemFree (FC_MEM_CONFIG, sizeof (FcConfig)); } +/* + * Add cache to configuration, adding fonts and directories + */ + +FcBool +FcConfigAddCache (FcConfig *config, FcCache *cache) +{ + FcCacheList *cl = malloc (sizeof (FcCacheList)); + FcFontSet *fs; + intptr_t *dirs; + int i; + + /* + * Add to cache list + */ + if (!cl) + return FcFalse; + cl->cache = cache; + cl->next = config->caches; + config->caches = cl; + + /* + * Add fonts + */ + fs = FcCacheSet (cache); + if (fs) + { + for (i = 0; i < fs->nfont; i++) + { + FcPattern *font = FcFontSetFont (fs, i); + FcChar8 *font_file; + + /* + * 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; + + FcFontSetAdd (config->fonts[FcSetSystem], font); + } + } + + /* + * 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)) + FcConfigAddFontDir (config, dir); + } + } + return FcTrue; +} + /* * 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 + * and build the set of available fonts. */ FcBool FcConfigBuildFonts (FcConfig *config) { FcFontSet *fonts; - FcGlobalCache *cache; - FcStrList *list; + FcStrList *dirlist; FcChar8 *dir; + FcCache *cache; + if (!config) + { + config = FcConfigGetCurrent (); + if (!config) + return FcFalse; + } + fonts = FcFontSetCreate (); if (!fonts) - goto bail0; + goto bail; - cache = FcGlobalCacheCreate (); - if (!cache) - goto bail1; - - FcGlobalCacheLoad (cache, config->cache); - - list = FcConfigGetFontDirs (config); - if (!list) - goto bail1; - - while ((dir = FcStrListNext (list))) + FcConfigSetFonts (config, fonts, FcSetSystem); + + dirlist = FcStrListCreate (config->fontDirs); + if (!dirlist) + goto bail; + + while ((dir = FcStrListNext (dirlist))) { if (FcDebug () & FC_DBG_FONTSET) - printf ("scan dir %s\n", dir); - FcDirScan (fonts, config->fontDirs, cache, config->blanks, dir, FcFalse); + printf ("adding fonts from%s\n", dir); + cache = FcDirCacheRead (dir, FcFalse, config); + if (!cache) + continue; + FcConfigAddCache (config, cache); } - FcStrListDone (list); + FcStrListDone (dirlist); if (FcDebug () & FC_DBG_FONTSET) FcFontSetPrint (fonts); - FcGlobalCacheSave (cache, config->cache); - FcGlobalCacheDestroy (cache); - - FcConfigSetFonts (config, fonts, FcSetSystem); - return FcTrue; -bail1: - FcFontSetDestroy (fonts); -bail0: +bail: return FcFalse; } @@ -291,6 +416,25 @@ FcConfigGetFontDirs (FcConfig *config) 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) @@ -318,30 +462,10 @@ FcConfigGetConfigFiles (FcConfig *config) 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 * @@ -367,8 +491,6 @@ FcConfigSetFonts (FcConfig *config, config->fonts[set] = fonts; } - - FcBlanks * FcConfigGetBlanks (FcConfig *config) { @@ -385,17 +507,21 @@ FcBool 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; } @@ -435,14 +561,23 @@ FcConfigAddEdit (FcConfig *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; @@ -492,42 +627,43 @@ FcConfigPromote (FcValue v, FcValue u) } FcBool -FcConfigCompareValue (const FcValue m_o, +FcConfigCompareValue (const FcValue *left_o, FcOp op, - const FcValue v_o) + const FcValue *right_o) { - FcValue m = m_o; - FcValue v = v_o; + 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) { - 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: case FcOpNotContains: - ret = m.u.d != v.u.d; + 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; @@ -537,11 +673,12 @@ FcConfigCompareValue (const FcValue m_o, 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: case FcOpNotContains: - ret = m.u.b != v.u.b; + ret = left.u.b != right.u.b; break; default: break; @@ -550,12 +687,17 @@ FcConfigCompareValue (const FcValue m_o, 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 FcOpNotContains: - ret = FcStrCmpIgnoreCase (m.u.s, v.u.s) != 0; + ret = FcStrCmpIgnoreCase (left.u.s, right.u.s) == 0; break; default: break; @@ -565,11 +707,12 @@ FcConfigCompareValue (const FcValue m_o, 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: case FcOpNotContains: - ret = !FcMatrixEqual (m.u.m, v.u.m); + ret = !FcMatrixEqual (left.u.m, right.u.m); break; default: break; @@ -578,18 +721,19 @@ FcConfigCompareValue (const FcValue m_o, case FcTypeCharSet: switch (op) { case FcOpContains: - /* v contains m if m is a subset of v */ - ret = FcCharSetIsSubset (m.u.c, v.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: - /* v contains m if m is a subset of v */ - ret = !FcCharSetIsSubset (m.u.c, v.u.c); + /* left contains right if right is a subset of left */ + ret = !FcCharSetIsSubset (right.u.c, left.u.c); break; case FcOpEqual: - ret = FcCharSetEqual (m.u.c, v.u.c); + ret = FcCharSetEqual (left.u.c, right.u.c); break; case FcOpNotEqual: - ret = !FcCharSetEqual (m.u.c, v.u.c); + ret = !FcCharSetEqual (left.u.c, right.u.c); break; default: break; @@ -598,16 +742,17 @@ FcConfigCompareValue (const FcValue m_o, case FcTypeLangSet: switch (op) { case FcOpContains: - ret = FcLangSetContains (v.u.l, m.u.l); + case FcOpListing: + ret = FcLangSetContains (left.u.l, right.u.l); break; case FcOpNotContains: - ret = FcLangSetContains (v.u.l, m.u.l); + ret = !FcLangSetContains (left.u.l, right.u.l); break; case FcOpEqual: - ret = FcLangSetEqual (v.u.l, m.u.l); + ret = FcLangSetEqual (left.u.l, right.u.l); break; case FcOpNotEqual: - ret = !FcLangSetEqual (v.u.l, m.u.l); + ret = !FcLangSetEqual (left.u.l, right.u.l); break; default: break; @@ -617,6 +762,7 @@ FcConfigCompareValue (const FcValue m_o, switch (op) { case FcOpEqual: case FcOpContains: + case FcOpListing: ret = FcTrue; break; default: @@ -627,11 +773,12 @@ FcConfigCompareValue (const FcValue m_o, switch (op) { case FcOpEqual: case FcOpContains: - ret = m.u.f == v.u.f; + case FcOpListing: + ret = left.u.f == right.u.f; break; case FcOpNotEqual: case FcOpNotContains: - ret = m.u.f != v.u.f; + ret = left.u.f != right.u.f; break; default: break; @@ -661,6 +808,7 @@ FcConfigEvaluate (FcPattern *p, FcExpr *e) FcValue v, vl, vr; FcResult r; FcMatrix *m; + FcChar8 *str; switch (e->op) { case FcOpInteger: @@ -673,8 +821,7 @@ FcConfigEvaluate (FcPattern *p, FcExpr *e) 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; @@ -691,9 +838,10 @@ FcConfigEvaluate (FcPattern *p, FcExpr *e) 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)) @@ -722,10 +870,11 @@ FcConfigEvaluate (FcPattern *p, FcExpr *e) 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); + v.u.b = FcConfigCompareValue (&vl, e->op, &vr); FcValueDestroy (vl); FcValueDestroy (vr); break; @@ -790,7 +939,10 @@ FcConfigEvaluate (FcPattern *p, FcExpr *e) 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; @@ -926,6 +1078,7 @@ FcConfigMatchValueList (FcPattern *p, while (e) { + /* Compute the value of the match expression */ if (e->op == FcOpComma) { value = FcConfigEvaluate (p, e->u.tree.left); @@ -937,9 +1090,10 @@ FcConfigMatchValueList (FcPattern *p, e = 0; } - for (v = values; v; v = v->next) + for (v = values; v; v = FcValueListNext(v)) { - 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; @@ -972,39 +1126,40 @@ FcConfigValues (FcPattern *p, FcExpr *e, FcValueBinding binding) 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) @@ -1012,14 +1167,16 @@ FcConfigAdd (FcValueList **head, 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; @@ -1030,7 +1187,7 @@ FcConfigAdd (FcValueList **head, if (FcDebug () & FC_DBG_EDIT) { - if (!*prev) + if (*prev == NULL) printf ("position not on list\n"); } } @@ -1045,7 +1202,7 @@ FcConfigAdd (FcValueList **head, if (new) { last = new; - while (last->next) + while (last->next != NULL) last = last->next; last->next = *prev; @@ -1063,17 +1220,17 @@ FcConfigAdd (FcValueList **head, } 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; } @@ -1082,13 +1239,13 @@ FcConfigDel (FcValueList **head, 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; @@ -1101,24 +1258,24 @@ FcConfigPatternAdd (FcPattern *p, */ 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 @@ -1142,6 +1299,20 @@ FcConfigSubstituteWithPat (FcConfig *config, 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; @@ -1152,10 +1323,6 @@ FcConfigSubstituteWithPat (FcConfig *config, printf ("FcConfigSubstitute "); FcPatternPrint (p); } - if (kind == FcMatchPattern) - s = config->substPattern; - else - s = config->substFont; for (; s; s = s->next) { /* @@ -1175,7 +1342,7 @@ FcConfigSubstituteWithPat (FcConfig *config, else m = p; if (m) - st[i].elt = FcPatternFindElt (m, t->field); + st[i].elt = FcPatternObjectFindElt (m, t->object); else st[i].elt = 0; /* @@ -1229,8 +1396,7 @@ FcConfigSubstituteWithPat (FcConfig *config, 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 @@ -1239,7 +1405,7 @@ FcConfigSubstituteWithPat (FcConfig *config, * 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; @@ -1254,7 +1420,7 @@ FcConfigSubstituteWithPat (FcConfig *config, 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 @@ -1263,7 +1429,8 @@ FcConfigSubstituteWithPat (FcConfig *config, /* * 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 @@ -1281,8 +1448,8 @@ FcConfigSubstituteWithPat (FcConfig *config, * 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 @@ -1305,7 +1472,7 @@ FcConfigSubstituteWithPat (FcConfig *config, } /* fall through ... */ case FcOpPrependFirst: - FcConfigPatternAdd (p, e->field, l, FcFalse); + FcConfigPatternAdd (p, e->object, l, FcFalse); break; case FcOpAppend: if (t) @@ -1315,9 +1482,10 @@ FcConfigSubstituteWithPat (FcConfig *config, } /* fall through ... */ case FcOpAppendLast: - FcConfigPatternAdd (p, e->field, l, FcTrue); + FcConfigPatternAdd (p, e->object, l, FcTrue); break; default: + FcValueListDestroy (l); break; } } @@ -1326,7 +1494,7 @@ FcConfigSubstituteWithPat (FcConfig *config, * 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) { @@ -1352,7 +1520,7 @@ FcConfigSubstitute (FcConfig *config, return FcConfigSubstituteWithPat (config, p, 0, kind); } -#if defined (_WIN32) && defined (PIC) +#if defined (_WIN32) && (defined (PIC) || defined (DLL_EXPORT)) static FcChar8 fontconfig_path[1000] = ""; @@ -1420,7 +1588,9 @@ FcConfigFileExists (const FcChar8 *dir, const FcChar8 *file) #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] != '/') @@ -1520,7 +1690,7 @@ FcConfigHome (void) home = getenv ("USERPROFILE"); #endif - return home; + return (FcChar8 *) home; } return 0; } @@ -1620,7 +1790,7 @@ FcConfigAppFontAddFile (FcConfig *config, FcConfigSetFonts (config, set, FcSetApplication); } - if (!FcFileScan (set, subdirs, 0, config->blanks, file, FcFalse)) + if (!FcFileScanConfig (set, subdirs, config->blanks, file, config)) { FcStrSetDestroy (subdirs); return FcFalse; @@ -1633,6 +1803,7 @@ FcConfigAppFontAddFile (FcConfig *config, } FcStrListDone (sublist); } + FcStrSetDestroy (subdirs); return FcTrue; } @@ -1667,7 +1838,7 @@ FcConfigAppFontAddDir (FcConfig *config, FcConfigSetFonts (config, set, FcSetApplication); } - if (!FcDirScan (set, subdirs, 0, config->blanks, dir, FcFalse)) + if (!FcDirScanConfig (set, subdirs, config->blanks, dir, FcFalse, config)) { FcStrSetDestroy (subdirs); return FcFalse; @@ -1680,11 +1851,129 @@ FcConfigAppFontAddDir (FcConfig *config, } 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; +}