X-Git-Url: https://git.wh0rd.org/?a=blobdiff_plain;f=src%2Ffcmatch.c;h=422bc384d2ecbabc2df33e3d10122381d985d9df;hb=a18ca17b6211f62fbd1d893811b94b8c83db4cc0;hp=7ce4f060fb16ea8110e6a7c96b41be4db2cf1f8a;hpb=0ab36ca8f93f8f07ed81034caf453b79e2922122;p=fontconfig.git diff --git a/src/fcmatch.c b/src/fcmatch.c index 7ce4f06..422bc38 100644 --- a/src/fcmatch.c +++ b/src/fcmatch.c @@ -1,90 +1,167 @@ /* - * $XFree86: xc/lib/fontconfig/src/fcmatch.c,v 1.2 2002/02/15 06:01:28 keithp Exp $ + * fontconfig/src/fcmatch.c * - * 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 * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting - * documentation, and that the name of Keith Packard not be used in + * documentation, and that the name of the author(s) not be used in * advertising or publicity pertaining to distribution of the software without - * specific, written prior permission. Keith Packard makes no + * specific, written prior permission. The authors make no * representations about the suitability of this software for any purpose. It * is provided "as is" without express or implied warranty. * - * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO - * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. */ +#include "fcint.h" +#include #include #include -#include "fcint.h" #include static double -FcCompareInteger (char *object, FcValue value1, FcValue value2) +FcCompareNumber (FcValue *value1, FcValue *value2) { - int v; - - if (value2.type != FcTypeInteger || value1.type != FcTypeInteger) + double v1, v2, v; + + switch (value1->type) { + case FcTypeInteger: + v1 = (double) value1->u.i; + break; + case FcTypeDouble: + v1 = value1->u.d; + break; + default: return -1.0; - v = value2.u.i - value1.u.i; + } + switch (value2->type) { + case FcTypeInteger: + v2 = (double) value2->u.i; + break; + case FcTypeDouble: + v2 = value2->u.d; + break; + default: + return -1.0; + } + v = v2 - v1; if (v < 0) v = -v; - return (double) v; + return v; } static double -FcCompareString (char *object, FcValue value1, FcValue value2) +FcCompareString (FcValue *v1, FcValue *v2) { - if (value2.type != FcTypeString || value1.type != FcTypeString) - return -1.0; - return (double) FcStrCmpIgnoreCase (value1.u.s, value2.u.s) != 0; + return (double) FcStrCmpIgnoreCase (FcValueString(v1), FcValueString(v2)) != 0; } static double -FcCompareBool (char *object, FcValue value1, FcValue value2) +FcCompareFamily (FcValue *v1, FcValue *v2) { - if (value2.type != FcTypeBool || value1.type != FcTypeBool) + /* rely on the guarantee in FcPatternObjectAddWithBinding that + * families are always FcTypeString. */ + const FcChar8* v1_string = FcValueString(v1); + const FcChar8* v2_string = FcValueString(v2); + + if (FcToLower(*v1_string) != FcToLower(*v2_string) && + *v1_string != ' ' && *v2_string != ' ') + return 1.0; + + return (double) FcStrCmpIgnoreBlanksAndCase (v1_string, v2_string) != 0; +} + +static double +FcCompareLang (FcValue *v1, FcValue *v2) +{ + FcLangResult result; + FcValue value1 = FcValueCanonicalize(v1), value2 = FcValueCanonicalize(v2); + + switch (value1.type) { + case FcTypeLangSet: + switch (value2.type) { + case FcTypeLangSet: + result = FcLangSetCompare (value1.u.l, value2.u.l); + break; + case FcTypeString: + result = FcLangSetHasLang (value1.u.l, + value2.u.s); + break; + default: + return -1.0; + } + break; + case FcTypeString: + switch (value2.type) { + case FcTypeLangSet: + result = FcLangSetHasLang (value2.u.l, value1.u.s); + break; + case FcTypeString: + result = FcLangCompare (value1.u.s, + value2.u.s); + break; + default: + return -1.0; + } + break; + default: return -1.0; - return (double) value2.u.b != value1.u.b; + } + switch (result) { + case FcLangEqual: + return 0; + case FcLangDifferentCountry: + return 1; + case FcLangDifferentLang: + default: + return 2; + } } static double -FcCompareCharSet (char *object, FcValue value1, FcValue value2) +FcCompareBool (FcValue *v1, FcValue *v2) { - if (value2.type != FcTypeCharSet || value1.type != FcTypeCharSet) + if (v2->type != FcTypeBool || v1->type != FcTypeBool) return -1.0; - return (double) FcCharSetSubtractCount (value1.u.c, value2.u.c); + return (double) v2->u.b != v1->u.b; } static double -FcCompareSize (char *object, FcValue value1, FcValue value2) +FcCompareCharSet (FcValue *v1, FcValue *v2) +{ + return (double) FcCharSetSubtractCount (FcValueCharSet(v1), FcValueCharSet(v2)); +} + +static double +FcCompareSize (FcValue *value1, FcValue *value2) { double v1, v2, v; - switch (value1.type) { + switch (value1->type) { case FcTypeInteger: - v1 = value1.u.i; + v1 = value1->u.i; break; case FcTypeDouble: - v1 = value1.u.d; + v1 = value1->u.d; break; default: return -1; } - switch (value2.type) { + switch (value2->type) { case FcTypeInteger: - v2 = value2.u.i; + v2 = value2->u.i; break; case FcTypeDouble: - v2 = value2.u.d; + v2 = value2->u.d; break; default: return -1; @@ -97,89 +174,172 @@ FcCompareSize (char *object, FcValue value1, FcValue value2) return v; } +typedef struct _FcMatcher { + FcObject object; + double (*compare) (FcValue *value1, FcValue *value2); + int strong, weak; +} FcMatcher; + /* * Order is significant, it defines the precedence of * each value, earlier values are more significant than * later values */ -static FcMatcher _FcMatchers [] = { - { FC_FOUNDRY, FcCompareString, }, - { FC_CHARSET, FcCompareCharSet }, - { FC_ANTIALIAS, FcCompareBool, }, - { FC_LANG, FcCompareString }, - { FC_FAMILY, FcCompareString, }, - { FC_SPACING, FcCompareInteger, }, - { FC_PIXEL_SIZE, FcCompareSize, }, - { FC_STYLE, FcCompareString, }, - { FC_SLANT, FcCompareInteger, }, - { FC_WEIGHT, FcCompareInteger, }, - { FC_RASTERIZER, FcCompareString, }, - { FC_OUTLINE, FcCompareBool, }, +static const FcMatcher _FcMatchers [] = { + { FC_FOUNDRY_OBJECT, FcCompareString, 0, 0 }, +#define MATCH_FOUNDRY 0 + { FC_CHARSET_OBJECT, FcCompareCharSet, 1, 1 }, +#define MATCH_CHARSET 1 + { FC_FAMILY_OBJECT, FcCompareFamily, 2, 4 }, +#define MATCH_FAMILY 2 + { FC_LANG_OBJECT, FcCompareLang, 3, 3 }, +#define MATCH_LANG 3 +#define MATCH_LANG_INDEX 3 + { FC_SPACING_OBJECT, FcCompareNumber, 5, 5 }, +#define MATCH_SPACING 4 + { FC_PIXEL_SIZE_OBJECT, FcCompareSize, 6, 6 }, +#define MATCH_PIXEL_SIZE 5 + { FC_STYLE_OBJECT, FcCompareString, 7, 7 }, +#define MATCH_STYLE 6 + { FC_SLANT_OBJECT, FcCompareNumber, 8, 8 }, +#define MATCH_SLANT 7 + { FC_WEIGHT_OBJECT, FcCompareNumber, 9, 9 }, +#define MATCH_WEIGHT 8 + { FC_WIDTH_OBJECT, FcCompareNumber, 10, 10 }, +#define MATCH_WIDTH 9 + { FC_DECORATIVE_OBJECT, FcCompareBool, 11, 11 }, +#define MATCH_DECORATIVE 10 + { FC_ANTIALIAS_OBJECT, FcCompareBool, 12, 12 }, +#define MATCH_ANTIALIAS 11 + { FC_RASTERIZER_OBJECT, FcCompareString, 13, 13 }, +#define MATCH_RASTERIZER 12 + { FC_OUTLINE_OBJECT, FcCompareBool, 14, 14 }, +#define MATCH_OUTLINE 13 + { FC_FONTVERSION_OBJECT, FcCompareNumber, 15, 15 }, +#define MATCH_FONTVERSION 14 }; -#define NUM_MATCHER (sizeof _FcMatchers / sizeof _FcMatchers[0]) +#define NUM_MATCH_VALUES 16 + +static const FcMatcher* +FcObjectToMatcher (FcObject object) +{ + int i; + + i = -1; + switch (object) { + case FC_FOUNDRY_OBJECT: + i = MATCH_FOUNDRY; break; + case FC_FONTVERSION_OBJECT: + i = MATCH_FONTVERSION; break; + case FC_FAMILY_OBJECT: + i = MATCH_FAMILY; break; + case FC_CHARSET_OBJECT: + i = MATCH_CHARSET; break; + case FC_ANTIALIAS_OBJECT: + i = MATCH_ANTIALIAS; break; + case FC_LANG_OBJECT: + i = MATCH_LANG; break; + case FC_SPACING_OBJECT: + i = MATCH_SPACING; break; + case FC_STYLE_OBJECT: + i = MATCH_STYLE; break; + case FC_SLANT_OBJECT: + i = MATCH_SLANT; break; + case FC_PIXEL_SIZE_OBJECT: + i = MATCH_PIXEL_SIZE; break; + case FC_WIDTH_OBJECT: + i = MATCH_WIDTH; break; + case FC_WEIGHT_OBJECT: + i = MATCH_WEIGHT; break; + case FC_RASTERIZER_OBJECT: + i = MATCH_RASTERIZER; break; + case FC_OUTLINE_OBJECT: + i = MATCH_OUTLINE; break; + case FC_DECORATIVE_OBJECT: + i = MATCH_DECORATIVE; break; + } + + if (i < 0) + return NULL; + + return _FcMatchers+i; +} static FcBool -FcCompareValueList (const char *object, - FcValueList *v1orig, /* pattern */ - FcValueList *v2orig, /* target */ +FcCompareValueList (FcObject object, + FcValueListPtr v1orig, /* pattern */ + FcValueListPtr v2orig, /* target */ FcValue *bestValue, double *value, FcResult *result) { - FcValueList *v1, *v2; - double v, best; + FcValueListPtr v1, v2; + double v, best, bestStrong, bestWeak; int j; - int i; - - for (i = 0; i < NUM_MATCHER; i++) - { - if (!FcStrCmpIgnoreCase ((FcChar8 *) _FcMatchers[i].object, - (FcChar8 *) object)) - break; - } - if (i == NUM_MATCHER) + const FcMatcher *match = FcObjectToMatcher(object); + + if (!match) { if (bestValue) - *bestValue = v2orig->value; + *bestValue = FcValueCanonicalize(&v2orig->value); return FcTrue; } - + best = 1e99; - j = 0; - for (v1 = v1orig; v1; v1 = v1->next) + bestStrong = 1e99; + bestWeak = 1e99; + j = 1; + for (v1 = v1orig; v1; v1 = FcValueListNext(v1)) { - for (v2 = v2orig; v2; v2 = v2->next) + for (v2 = v2orig; v2; v2 = FcValueListNext(v2)) { - v = (*_FcMatchers[i].compare) (_FcMatchers[i].object, - v1->value, - v2->value); + v = (match->compare) (&v1->value, &v2->value); if (v < 0) { *result = FcResultTypeMismatch; return FcFalse; } - if (FcDebug () & FC_DBG_MATCHV) - printf (" v %g j %d ", v, j); - v = v * 100 + j; + v = v * 1000 + j; if (v < best) { if (bestValue) - *bestValue = v2->value; + *bestValue = FcValueCanonicalize(&v2->value); best = v; } + if (v1->binding == FcValueBindingStrong) + { + if (v < bestStrong) + bestStrong = v; + } + else + { + if (v < bestWeak) + bestWeak = v; + } } j++; } if (FcDebug () & FC_DBG_MATCHV) { - printf (" %s: %g ", object, best); + printf (" %s: %g ", FcObjectName (object), best); FcValueListPrint (v1orig); printf (", "); FcValueListPrint (v2orig); printf ("\n"); } - value[i] += best; + if (value) + { + int weak = match->weak; + int strong = match->strong; + if (weak == strong) + value[strong] += best; + else + { + value[weak] += bestWeak; + value[strong] += bestStrong; + } + } return FcTrue; } @@ -195,45 +355,32 @@ FcCompare (FcPattern *pat, FcResult *result) { int i, i1, i2; - - for (i = 0; i < NUM_MATCHER; i++) + + for (i = 0; i < NUM_MATCH_VALUES; i++) value[i] = 0.0; - - for (i1 = 0; i1 < pat->num; i1++) + + i1 = 0; + i2 = 0; + while (i1 < pat->num && i2 < fnt->num) { - for (i2 = 0; i2 < fnt->num; i2++) - { - if (!FcStrCmpIgnoreCase ((FcChar8 *) pat->elts[i1].object, - (FcChar8 *) fnt->elts[i2].object)) - { - if (!FcCompareValueList (pat->elts[i1].object, - pat->elts[i1].values, - fnt->elts[i2].values, - 0, - value, - result)) - return FcFalse; - break; - } - } -#if 0 - /* - * Overspecified patterns are slightly penalized in - * case some other font includes the requested field - */ - if (i2 == fnt->num) + FcPatternElt *elt_i1 = &FcPatternElts(pat)[i1]; + FcPatternElt *elt_i2 = &FcPatternElts(fnt)[i2]; + + i = FcObjectCompare(elt_i1->object, elt_i2->object); + if (i > 0) + i2++; + else if (i < 0) + i1++; + else { - for (i2 = 0; i2 < NUM_MATCHER; i2++) - { - if (!FcStrCmpIgnoreCase (_FcMatchers[i2].object, - pat->elts[i1].object)) - { - value[i2] = 1.0; - break; - } - } + if (!FcCompareValueList (elt_i1->object, + FcPatternEltValues(elt_i1), + FcPatternEltValues(elt_i2), + 0, value, result)) + return FcFalse; + i1++; + i2++; } -#endif } return FcTrue; } @@ -247,55 +394,61 @@ FcFontRenderPrepare (FcConfig *config, int i; FcPatternElt *fe, *pe; FcValue v; - double score[NUM_MATCHER]; FcResult result; - + + assert (pat != NULL); + assert (font != NULL); + new = FcPatternCreate (); if (!new) return 0; for (i = 0; i < font->num; i++) { - fe = &font->elts[i]; - pe = FcPatternFind (pat, fe->object, FcFalse); + fe = &FcPatternElts(font)[i]; + pe = FcPatternObjectFindElt (pat, fe->object); if (pe) { - if (!FcCompareValueList (pe->object, pe->values, - fe->values, &v, score, &result)) + if (!FcCompareValueList (pe->object, FcPatternEltValues(pe), + FcPatternEltValues(fe), &v, 0, &result)) { FcPatternDestroy (new); return 0; } } else - v = fe->values->value; - FcPatternAdd (new, fe->object, v, FcTrue); + v = FcValueCanonicalize(&FcPatternEltValues (fe)->value); + FcPatternObjectAdd (new, fe->object, v, FcFalse); } for (i = 0; i < pat->num; i++) { - pe = &pat->elts[i]; - fe = FcPatternFind (font, pe->object, FcFalse); + pe = &FcPatternElts(pat)[i]; + fe = FcPatternObjectFindElt (font, pe->object); if (!fe) - FcPatternAdd (new, pe->object, pe->values->value, FcTrue); + { + v = FcValueCanonicalize(&FcPatternEltValues(pe)->value); + FcPatternObjectAdd (new, pe->object, v, FcTrue); + } } - FcConfigSubstitute (config, new, FcMatchFont); + + FcConfigSubstituteWithPat (config, new, pat, FcMatchFont); return new; } -FcPattern * -FcFontSetMatch (FcConfig *config, - FcFontSet **sets, - int nsets, - FcPattern *p, - FcResult *result) +static FcPattern * +FcFontSetMatchInternal (FcConfig *config, + FcFontSet **sets, + int nsets, + FcPattern *p, + FcResult *result) { - double score[NUM_MATCHER], bestscore[NUM_MATCHER]; + double score[NUM_MATCH_VALUES], bestscore[NUM_MATCH_VALUES]; int f; FcFontSet *s; FcPattern *best; int i; int set; - for (i = 0; i < NUM_MATCHER; i++) + for (i = 0; i < NUM_MATCH_VALUES; i++) bestscore[i] = 0; best = 0; if (FcDebug () & FC_DBG_MATCH) @@ -303,12 +456,6 @@ FcFontSetMatch (FcConfig *config, printf ("Match "); FcPatternPrint (p); } - if (!config) - { - config = FcConfigGetCurrent (); - if (!config) - return 0; - } for (set = 0; set < nsets; set++) { s = sets[set]; @@ -326,19 +473,19 @@ FcFontSetMatch (FcConfig *config, if (FcDebug () & FC_DBG_MATCHV) { printf ("Score"); - for (i = 0; i < NUM_MATCHER; i++) + for (i = 0; i < NUM_MATCH_VALUES; i++) { printf (" %g", score[i]); } printf ("\n"); } - for (i = 0; i < NUM_MATCHER; i++) + for (i = 0; i < NUM_MATCH_VALUES; i++) { if (best && bestscore[i] < score[i]) break; if (!best || score[i] < bestscore[i]) { - for (i = 0; i < NUM_MATCHER; i++) + for (i = 0; i < NUM_MATCH_VALUES; i++) bestscore[i] = score[i]; best = s->fonts[f]; break; @@ -349,8 +496,9 @@ FcFontSetMatch (FcConfig *config, if (FcDebug () & FC_DBG_MATCH) { printf ("Best score"); - for (i = 0; i < NUM_MATCHER; i++) + for (i = 0; i < NUM_MATCH_VALUES; i++) printf (" %g", bestscore[i]); + printf ("\n"); FcPatternPrint (best); } if (!best) @@ -358,16 +506,46 @@ FcFontSetMatch (FcConfig *config, *result = FcResultNoMatch; return 0; } - return FcFontRenderPrepare (config, p, best); + return best; +} + +FcPattern * +FcFontSetMatch (FcConfig *config, + FcFontSet **sets, + int nsets, + FcPattern *p, + FcResult *result) +{ + FcPattern *best; + + assert (sets != NULL); + assert (p != NULL); + assert (result != NULL); + + if (!config) + { + config = FcConfigGetCurrent (); + if (!config) + return 0; + } + best = FcFontSetMatchInternal (config, sets, nsets, p, result); + if (best) + return FcFontRenderPrepare (config, p, best); + else + return NULL; } FcPattern * FcFontMatch (FcConfig *config, - FcPattern *p, + FcPattern *p, FcResult *result) { FcFontSet *sets[2]; int nsets; + FcPattern *best; + + assert (p != NULL); + assert (result != NULL); if (!config) { @@ -380,12 +558,17 @@ FcFontMatch (FcConfig *config, sets[nsets++] = config->fonts[FcSetSystem]; if (config->fonts[FcSetApplication]) sets[nsets++] = config->fonts[FcSetApplication]; - return FcFontSetMatch (config, sets, nsets, p, result); + + best = FcFontSetMatchInternal (config, sets, nsets, p, result); + if (best) + return FcFontRenderPrepare (config, p, best); + else + return NULL; } typedef struct _FcSortNode { FcPattern *pattern; - double score[NUM_MATCHER]; + double score[NUM_MATCH_VALUES]; } FcSortNode; static int @@ -393,48 +576,89 @@ FcSortCompare (const void *aa, const void *ab) { FcSortNode *a = *(FcSortNode **) aa; FcSortNode *b = *(FcSortNode **) ab; + double *as = &a->score[0]; + double *bs = &b->score[0]; + double ad = 0, bd = 0; int i; - for (i = 0; i < NUM_MATCHER; i++) - { - if (a->score[i] > b->score[i]) - return -1; - if (a->score[i] < b->score[i]) - return 1; - } - return 0; + i = NUM_MATCH_VALUES; + while (i-- && (ad = *as++) == (bd = *bs++)) + ; + return ad < bd ? -1 : ad > bd ? 1 : 0; } static FcBool -FcSortWalk (FcSortNode **n, int nnode, FcFontSet *fs, FcCharSet **cs, FcBool trim) +FcSortWalk (FcSortNode **n, int nnode, FcFontSet *fs, FcCharSet **csp, FcBool trim) { - FcCharSet *ncs; - FcSortNode *node; + FcBool ret = FcFalse; + FcCharSet *cs; + + cs = 0; + if (trim || csp) + { + cs = FcCharSetCreate (); + if (cs == NULL) + goto bail; + } while (nnode--) { - node = *n++; - if (FcPatternGetCharSet (node->pattern, FC_CHARSET, 0, &ncs) == - FcResultMatch) + FcSortNode *node = *n++; + FcBool adds_chars = FcFalse; + + /* + * Only fetch node charset if we'd need it + */ + if (cs) { - if (!trim || !*cs || FcCharSetSubtractCount (ncs, *cs) != 0) + FcCharSet *ncs; + + if (FcPatternGetCharSet (node->pattern, FC_CHARSET, 0, &ncs) != + FcResultMatch) + continue; + + if (!FcCharSetMerge (cs, ncs, &adds_chars)) + goto bail; + } + + /* + * If this font isn't a subset of the previous fonts, + * add it to the list + */ + if (!trim || adds_chars) + { + FcPatternReference (node->pattern); + if (FcDebug () & FC_DBG_MATCHV) { - if (*cs) - { - ncs = FcCharSetUnion (ncs, *cs); - if (!ncs) - return FcFalse; - FcCharSetDestroy (*cs); - } - else - ncs = FcCharSetCopy (ncs); - *cs = ncs; - if (!FcFontSetAdd (fs, node->pattern)) - return FcFalse; + printf ("Add "); + FcPatternPrint (node->pattern); + } + if (!FcFontSetAdd (fs, node->pattern)) + { + FcPatternDestroy (node->pattern); + goto bail; } } } - return FcTrue; + if (csp) + { + *csp = cs; + cs = 0; + } + + ret = FcTrue; + +bail: + if (cs) + FcCharSetDestroy (cs); + + return ret; +} + +void +FcFontSetSortDestroy (FcFontSet *fs) +{ + FcFontSetDestroy (fs); } FcFontSet * @@ -452,11 +676,31 @@ FcFontSetSort (FcConfig *config, FcSortNode **nodeps, **nodep; int nnodes; FcSortNode *new; - FcCharSet *cs; int set; int f; int i; + int nPatternLang; + FcBool *patternLangSat; + FcValue patternLang; + assert (sets != NULL); + assert (p != NULL); + assert (result != NULL); + + /* There are some implementation that relying on the result of + * "result" to check if the return value of FcFontSetSort + * is valid or not. + * So we should initialize it to the conservative way since + * this function doesn't return NULL anymore. + */ + if (result) + *result = FcResultNoMatch; + + if (FcDebug () & FC_DBG_MATCH) + { + printf ("Sort "); + FcPatternPrint (p); + } nnodes = 0; for (set = 0; set < nsets; set++) { @@ -466,12 +710,22 @@ FcFontSetSort (FcConfig *config, nnodes += s->nfont; } if (!nnodes) - goto bail0; - nodes = malloc (nnodes * sizeof (FcSortNode) + nnodes * sizeof (FcSortNode *)); + return FcFontSetCreate (); + + for (nPatternLang = 0; + FcPatternGet (p, FC_LANG, nPatternLang, &patternLang) == FcResultMatch; + nPatternLang++) + ; + + /* freed below */ + nodes = malloc (nnodes * sizeof (FcSortNode) + + nnodes * sizeof (FcSortNode *) + + nPatternLang * sizeof (FcBool)); if (!nodes) goto bail0; - nodeps = (FcSortNode **) nodes + nnodes; - + nodeps = (FcSortNode **) (nodes + nnodes); + patternLangSat = (FcBool *) (nodeps + nnodes); + new = nodes; nodep = nodeps; for (set = 0; set < nsets; set++) @@ -492,7 +746,7 @@ FcFontSetSort (FcConfig *config, if (FcDebug () & FC_DBG_MATCHV) { printf ("Score"); - for (i = 0; i < NUM_MATCHER; i++) + for (i = 0; i < NUM_MATCH_VALUES; i++) { printf (" %g", new->score[i]); } @@ -505,29 +759,109 @@ FcFontSetSort (FcConfig *config, } nnodes = new - nodes; - - qsort (nodeps, sizeof (FcSortNode *), nnodes, + + qsort (nodeps, nnodes, sizeof (FcSortNode *), + FcSortCompare); + + for (i = 0; i < nPatternLang; i++) + patternLangSat[i] = FcFalse; + + for (f = 0; f < nnodes; f++) + { + FcBool satisfies = FcFalse; + /* + * If this node matches any language, go check + * which ones and satisfy those entries + */ + if (nodeps[f]->score[MATCH_LANG_INDEX] < 2000) + { + for (i = 0; i < nPatternLang; i++) + { + FcValue nodeLang; + + if (!patternLangSat[i] && + FcPatternGet (p, FC_LANG, i, &patternLang) == FcResultMatch && + FcPatternGet (nodeps[f]->pattern, FC_LANG, 0, &nodeLang) == FcResultMatch) + { + double compare = FcCompareLang (&patternLang, &nodeLang); + if (compare >= 0 && compare < 2) + { + if (FcDebug () & FC_DBG_MATCHV) + { + FcChar8 *family; + FcChar8 *style; + + if (FcPatternGetString (nodeps[f]->pattern, FC_FAMILY, 0, &family) == FcResultMatch && + FcPatternGetString (nodeps[f]->pattern, FC_STYLE, 0, &style) == FcResultMatch) + printf ("Font %s:%s matches language %d\n", family, style, i); + } + patternLangSat[i] = FcTrue; + satisfies = FcTrue; + break; + } + } + } + } + if (!satisfies) + nodeps[f]->score[MATCH_LANG_INDEX] = 10000.0; + } + + /* + * Re-sort once the language issues have been settled + */ + qsort (nodeps, nnodes, sizeof (FcSortNode *), FcSortCompare); ret = FcFontSetCreate (); if (!ret) goto bail1; - cs = 0; - - if (!FcSortWalk (nodeps, nnodes, ret, &cs, trim)) + if (!FcSortWalk (nodeps, nnodes, ret, csp, trim)) goto bail2; - *csp = cs; + free (nodes); + if (FcDebug() & FC_DBG_MATCH) + { + printf ("First font "); + FcPatternPrint (ret->fonts[0]); + } return ret; bail2: - if (cs) - FcCharSetDestroy (cs); FcFontSetDestroy (ret); bail1: free (nodes); bail0: return 0; } + +FcFontSet * +FcFontSort (FcConfig *config, + FcPattern *p, + FcBool trim, + FcCharSet **csp, + FcResult *result) +{ + FcFontSet *sets[2]; + int nsets; + + assert (p != NULL); + assert (result != NULL); + + if (!config) + { + config = FcConfigGetCurrent (); + if (!config) + return 0; + } + nsets = 0; + if (config->fonts[FcSetSystem]) + sets[nsets++] = config->fonts[FcSetSystem]; + if (config->fonts[FcSetApplication]) + sets[nsets++] = config->fonts[FcSetApplication]; + return FcFontSetSort (config, sets, nsets, p, trim, csp, result); +} +#define __fcmatch__ +#include "fcaliastail.h" +#undef __fcmatch__