2002-02-15 00:34:13 +01:00
|
|
|
/*
|
2003-03-05 06:51:27 +01:00
|
|
|
* $RCSId: xc/lib/fontconfig/src/fcmatch.c,v 1.20 2002/08/31 22:17:32 keithp Exp $
|
2002-02-15 00:34:13 +01:00
|
|
|
*
|
2004-12-07 02:14:46 +01:00
|
|
|
* Copyright © 2000 Keith Packard
|
2002-02-15 00:34:13 +01:00
|
|
|
*
|
|
|
|
* 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
|
|
|
|
* advertising or publicity pertaining to distribution of the software without
|
|
|
|
* specific, written prior permission. Keith Packard makes 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,
|
|
|
|
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
|
|
|
* EVENT SHALL KEITH PACKARD 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 <string.h>
|
|
|
|
#include <ctype.h>
|
|
|
|
#include "fcint.h"
|
|
|
|
#include <stdio.h>
|
|
|
|
|
|
|
|
static double
|
2005-11-25 04:00:51 +01:00
|
|
|
FcCompareNumber (FcValue *value1, FcValue *value2)
|
2002-02-15 00:34:13 +01:00
|
|
|
{
|
2003-02-26 20:13:17 +01:00
|
|
|
double v1, v2, v;
|
2002-02-15 00:34:13 +01:00
|
|
|
|
2005-08-24 08:21:30 +02:00
|
|
|
switch (value1->type) {
|
2003-02-26 20:13:17 +01:00
|
|
|
case FcTypeInteger:
|
2005-08-24 08:21:30 +02:00
|
|
|
v1 = (double) value1->u.i;
|
2003-02-26 20:13:17 +01:00
|
|
|
break;
|
|
|
|
case FcTypeDouble:
|
2005-08-24 08:21:30 +02:00
|
|
|
v1 = value1->u.d;
|
2003-02-26 20:13:17 +01:00
|
|
|
break;
|
|
|
|
default:
|
2002-02-15 00:34:13 +01:00
|
|
|
return -1.0;
|
2003-02-26 20:13:17 +01:00
|
|
|
}
|
2005-08-24 08:21:30 +02:00
|
|
|
switch (value2->type) {
|
2003-02-26 20:13:17 +01:00
|
|
|
case FcTypeInteger:
|
2005-08-24 08:21:30 +02:00
|
|
|
v2 = (double) value2->u.i;
|
2003-02-26 20:13:17 +01:00
|
|
|
break;
|
|
|
|
case FcTypeDouble:
|
2005-08-24 08:21:30 +02:00
|
|
|
v2 = value2->u.d;
|
2003-02-26 20:13:17 +01:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -1.0;
|
|
|
|
}
|
|
|
|
v = v2 - v1;
|
2002-02-15 00:34:13 +01:00
|
|
|
if (v < 0)
|
|
|
|
v = -v;
|
2005-11-24 21:20:26 +01:00
|
|
|
return v;
|
2002-02-15 00:34:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static double
|
2005-11-25 04:00:51 +01:00
|
|
|
FcCompareString (FcValue *v1, FcValue *v2)
|
2002-02-15 00:34:13 +01:00
|
|
|
{
|
2005-11-24 22:40:20 +01:00
|
|
|
return (double) FcStrCmpIgnoreCase (fc_value_string(v1), fc_value_string(v2)) != 0;
|
2002-02-15 00:34:13 +01:00
|
|
|
}
|
|
|
|
|
2002-07-07 01:47:44 +02:00
|
|
|
static double
|
2005-11-25 04:00:51 +01:00
|
|
|
FcCompareFamily (FcValue *v1, FcValue *v2)
|
2002-07-07 01:47:44 +02:00
|
|
|
{
|
2005-11-24 21:20:26 +01:00
|
|
|
/* rely on the guarantee in FcPatternAddWithBinding that
|
|
|
|
* families are always FcTypeString. */
|
|
|
|
const FcChar8* v1_string = fc_value_string(v1);
|
|
|
|
const FcChar8* v2_string = fc_value_string(v2);
|
|
|
|
|
|
|
|
if (FcToLower(*v1_string) != FcToLower(*v2_string))
|
|
|
|
return 1.0;
|
|
|
|
|
|
|
|
return (double) FcStrCmpIgnoreBlanksAndCase (v1_string, v2_string) != 0;
|
2002-07-07 01:47:44 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static double
|
2005-11-25 04:00:51 +01:00
|
|
|
FcCompareLang (FcValue *v1, FcValue *v2)
|
2002-07-07 01:47:44 +02:00
|
|
|
{
|
|
|
|
FcLangResult result;
|
2005-08-24 08:21:30 +02:00
|
|
|
FcValue value1 = FcValueCanonicalize(v1), value2 = FcValueCanonicalize(v2);
|
2002-07-07 01:47:44 +02:00
|
|
|
|
2002-08-22 09:36:45 +02:00
|
|
|
switch (value1.type) {
|
|
|
|
case FcTypeLangSet:
|
|
|
|
switch (value2.type) {
|
|
|
|
case FcTypeLangSet:
|
2005-08-24 08:21:30 +02:00
|
|
|
result = FcLangSetCompare (value1.u.l, value2.u.l);
|
2002-08-22 09:36:45 +02:00
|
|
|
break;
|
|
|
|
case FcTypeString:
|
2005-08-24 08:21:30 +02:00
|
|
|
result = FcLangSetHasLang (value1.u.l,
|
|
|
|
value2.u.s);
|
2002-08-22 09:36:45 +02:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -1.0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case FcTypeString:
|
|
|
|
switch (value2.type) {
|
|
|
|
case FcTypeLangSet:
|
2005-08-24 08:21:30 +02:00
|
|
|
result = FcLangSetHasLang (value2.u.l, value1.u.s);
|
2002-08-22 09:36:45 +02:00
|
|
|
break;
|
|
|
|
case FcTypeString:
|
2005-08-24 08:21:30 +02:00
|
|
|
result = FcLangCompare (value1.u.s,
|
|
|
|
value2.u.s);
|
2002-08-22 09:36:45 +02:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -1.0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
2002-07-07 01:47:44 +02:00
|
|
|
return -1.0;
|
2002-08-22 09:36:45 +02:00
|
|
|
}
|
2002-07-07 01:47:44 +02:00
|
|
|
switch (result) {
|
|
|
|
case FcLangEqual:
|
|
|
|
return 0;
|
|
|
|
case FcLangDifferentCountry:
|
|
|
|
return 1;
|
|
|
|
case FcLangDifferentLang:
|
|
|
|
default:
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-02-15 00:34:13 +01:00
|
|
|
static double
|
2005-11-25 04:00:51 +01:00
|
|
|
FcCompareBool (FcValue *v1, FcValue *v2)
|
2002-02-15 00:34:13 +01:00
|
|
|
{
|
2005-11-24 22:40:20 +01:00
|
|
|
if (fc_storage_type(v2) != FcTypeBool || fc_storage_type(v1) != FcTypeBool)
|
2002-02-15 00:34:13 +01:00
|
|
|
return -1.0;
|
2005-11-24 22:40:20 +01:00
|
|
|
return (double) v2->u.b != v1->u.b;
|
2002-02-15 00:34:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static double
|
2005-11-25 04:00:51 +01:00
|
|
|
FcCompareCharSet (FcValue *v1, FcValue *v2)
|
2002-02-15 00:34:13 +01:00
|
|
|
{
|
2005-11-24 22:40:20 +01:00
|
|
|
return (double) FcCharSetSubtractCount (fc_value_charset(v1), fc_value_charset(v2));
|
2002-02-15 00:34:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static double
|
2005-11-25 04:00:51 +01:00
|
|
|
FcCompareSize (FcValue *value1, FcValue *value2)
|
2002-02-15 00:34:13 +01:00
|
|
|
{
|
|
|
|
double v1, v2, v;
|
|
|
|
|
2005-08-24 08:21:30 +02:00
|
|
|
switch (value1->type) {
|
2002-02-15 00:34:13 +01:00
|
|
|
case FcTypeInteger:
|
2005-08-24 08:21:30 +02:00
|
|
|
v1 = value1->u.i;
|
2002-02-15 00:34:13 +01:00
|
|
|
break;
|
|
|
|
case FcTypeDouble:
|
2005-08-24 08:21:30 +02:00
|
|
|
v1 = value1->u.d;
|
2002-02-15 00:34:13 +01:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -1;
|
|
|
|
}
|
2005-08-24 08:21:30 +02:00
|
|
|
switch (value2->type) {
|
2002-02-15 00:34:13 +01:00
|
|
|
case FcTypeInteger:
|
2005-08-24 08:21:30 +02:00
|
|
|
v2 = value2->u.i;
|
2002-02-15 00:34:13 +01:00
|
|
|
break;
|
|
|
|
case FcTypeDouble:
|
2005-08-24 08:21:30 +02:00
|
|
|
v2 = value2->u.d;
|
2002-02-15 00:34:13 +01:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (v2 == 0)
|
|
|
|
return 0;
|
|
|
|
v = v2 - v1;
|
|
|
|
if (v < 0)
|
|
|
|
v = -v;
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
2002-06-29 22:31:02 +02:00
|
|
|
typedef struct _FcMatcher {
|
2005-09-23 01:45:53 +02:00
|
|
|
const char *object;
|
2005-11-25 17:33:58 +01:00
|
|
|
FcObjectPtr objectPtr;
|
2005-11-25 04:00:51 +01:00
|
|
|
double (*compare) (FcValue *value1, FcValue *value2);
|
2002-06-29 22:31:02 +02:00
|
|
|
int strong, weak;
|
|
|
|
} FcMatcher;
|
|
|
|
|
2002-02-15 00:34:13 +01:00
|
|
|
/*
|
|
|
|
* Order is significant, it defines the precedence of
|
|
|
|
* each value, earlier values are more significant than
|
|
|
|
* later values
|
|
|
|
*/
|
|
|
|
static FcMatcher _FcMatchers [] = {
|
2005-11-25 17:33:58 +01:00
|
|
|
{ FC_FOUNDRY, 0, FcCompareString, 0, 0 },
|
2002-06-29 22:31:02 +02:00
|
|
|
#define MATCH_FOUNDRY 0
|
2004-12-14 01:12:25 +01:00
|
|
|
#define MATCH_FOUNDRY_INDEX 0
|
2002-05-30 00:07:33 +02:00
|
|
|
|
2005-11-25 17:33:58 +01:00
|
|
|
{ FC_CHARSET, 0, FcCompareCharSet, 1, 1 },
|
2002-06-29 22:31:02 +02:00
|
|
|
#define MATCH_CHARSET 1
|
2004-12-14 01:12:25 +01:00
|
|
|
#define MATCH_CHARSET_INDEX 1
|
2002-05-30 00:07:33 +02:00
|
|
|
|
2005-11-25 17:33:58 +01:00
|
|
|
{ FC_FAMILY, 0, FcCompareFamily, 2, 4 },
|
2002-06-29 22:31:02 +02:00
|
|
|
#define MATCH_FAMILY 2
|
2004-12-14 01:12:25 +01:00
|
|
|
#define MATCH_FAMILY_STRONG_INDEX 2
|
|
|
|
#define MATCH_FAMILY_WEAK_INDEX 4
|
2002-05-30 00:07:33 +02:00
|
|
|
|
2005-11-25 17:33:58 +01:00
|
|
|
{ FC_LANG, 0, FcCompareLang, 3, 3 },
|
2002-06-29 22:31:02 +02:00
|
|
|
#define MATCH_LANG 3
|
2004-12-14 01:12:25 +01:00
|
|
|
#define MATCH_LANG_INDEX 3
|
2002-05-30 00:07:33 +02:00
|
|
|
|
2005-11-25 17:33:58 +01:00
|
|
|
{ FC_SPACING, 0, FcCompareNumber, 5, 5 },
|
2002-06-29 22:31:02 +02:00
|
|
|
#define MATCH_SPACING 4
|
2004-12-14 01:12:25 +01:00
|
|
|
#define MATCH_SPACING_INDEX 5
|
2002-05-30 00:07:33 +02:00
|
|
|
|
2005-11-25 17:33:58 +01:00
|
|
|
{ FC_PIXEL_SIZE, 0, FcCompareSize, 6, 6 },
|
2002-06-29 22:31:02 +02:00
|
|
|
#define MATCH_PIXEL_SIZE 5
|
2004-12-14 01:12:25 +01:00
|
|
|
#define MATCH_PIXEL_SIZE_INDEX 6
|
2002-05-30 00:07:33 +02:00
|
|
|
|
2005-11-25 17:33:58 +01:00
|
|
|
{ FC_STYLE, 0, FcCompareString, 7, 7 },
|
2002-06-29 22:31:02 +02:00
|
|
|
#define MATCH_STYLE 6
|
2004-12-14 01:12:25 +01:00
|
|
|
#define MATCH_STYLE_INDEX 7
|
2002-05-30 00:07:33 +02:00
|
|
|
|
2005-11-25 17:33:58 +01:00
|
|
|
{ FC_SLANT, 0, FcCompareNumber, 8, 8 },
|
2002-06-29 22:31:02 +02:00
|
|
|
#define MATCH_SLANT 7
|
2004-12-14 01:12:25 +01:00
|
|
|
#define MATCH_SLANT_INDEX 8
|
2002-05-30 00:07:33 +02:00
|
|
|
|
2005-11-25 17:33:58 +01:00
|
|
|
{ FC_WEIGHT, 0, FcCompareNumber, 9, 9 },
|
2002-06-29 22:31:02 +02:00
|
|
|
#define MATCH_WEIGHT 8
|
2004-12-14 01:12:25 +01:00
|
|
|
#define MATCH_WEIGHT_INDEX 9
|
2002-06-19 00:23:05 +02:00
|
|
|
|
2005-11-25 17:33:58 +01:00
|
|
|
{ FC_WIDTH, 0, FcCompareNumber, 10, 10 },
|
2003-03-12 23:16:43 +01:00
|
|
|
#define MATCH_WIDTH 9
|
2004-12-14 01:12:25 +01:00
|
|
|
#define MATCH_WIDTH_INDEX 10
|
2002-05-30 00:07:33 +02:00
|
|
|
|
2005-11-25 17:33:58 +01:00
|
|
|
{ FC_ANTIALIAS, 0, FcCompareBool, 11, 11 },
|
2003-03-12 23:16:43 +01:00
|
|
|
#define MATCH_ANTIALIAS 10
|
2004-12-14 01:12:25 +01:00
|
|
|
#define MATCH_ANTIALIAS_INDEX 11
|
2002-05-30 00:07:33 +02:00
|
|
|
|
2005-11-25 17:33:58 +01:00
|
|
|
{ FC_RASTERIZER, 0, FcCompareString, 12, 12 },
|
2003-03-12 23:16:43 +01:00
|
|
|
#define MATCH_RASTERIZER 11
|
2004-12-14 01:12:25 +01:00
|
|
|
#define MATCH_RASTERIZER_INDEX 12
|
|
|
|
|
2005-11-25 17:33:58 +01:00
|
|
|
{ FC_OUTLINE, 0, FcCompareBool, 13, 13 },
|
2003-03-12 23:16:43 +01:00
|
|
|
#define MATCH_OUTLINE 12
|
2004-12-14 01:12:25 +01:00
|
|
|
#define MATCH_OUTLINE_INDEX 13
|
2002-09-26 02:17:28 +02:00
|
|
|
|
2005-11-25 17:33:58 +01:00
|
|
|
{ FC_FONTVERSION, 0, FcCompareNumber, 14, 14 },
|
2003-03-12 23:16:43 +01:00
|
|
|
#define MATCH_FONTVERSION 13
|
2004-12-14 01:12:25 +01:00
|
|
|
#define MATCH_FONTVERSION_INDEX 14
|
2002-02-15 00:34:13 +01:00
|
|
|
};
|
|
|
|
|
2003-03-12 23:16:43 +01:00
|
|
|
#define NUM_MATCH_VALUES 15
|
2002-02-15 00:34:13 +01:00
|
|
|
|
2005-11-25 17:33:58 +01:00
|
|
|
static FcBool matchObjectPtrsInit = FcFalse;
|
|
|
|
|
|
|
|
static void
|
|
|
|
FcMatchObjectPtrsInit (void)
|
|
|
|
{
|
|
|
|
_FcMatchers[MATCH_FOUNDRY].objectPtr = FcObjectToPtr(FC_FOUNDRY);
|
|
|
|
_FcMatchers[MATCH_CHARSET].objectPtr = FcObjectToPtr(FC_CHARSET);
|
|
|
|
_FcMatchers[MATCH_FAMILY].objectPtr = FcObjectToPtr(FC_FAMILY);
|
|
|
|
_FcMatchers[MATCH_LANG].objectPtr = FcObjectToPtr(FC_LANG);
|
|
|
|
_FcMatchers[MATCH_SPACING].objectPtr = FcObjectToPtr(FC_SPACING);
|
|
|
|
_FcMatchers[MATCH_PIXEL_SIZE].objectPtr = FcObjectToPtr(FC_PIXEL_SIZE);
|
|
|
|
_FcMatchers[MATCH_STYLE].objectPtr = FcObjectToPtr(FC_STYLE);
|
|
|
|
_FcMatchers[MATCH_SLANT].objectPtr = FcObjectToPtr(FC_SLANT);
|
|
|
|
_FcMatchers[MATCH_WEIGHT].objectPtr = FcObjectToPtr(FC_WEIGHT);
|
|
|
|
_FcMatchers[MATCH_WIDTH].objectPtr = FcObjectToPtr(FC_WIDTH);
|
|
|
|
_FcMatchers[MATCH_ANTIALIAS].objectPtr = FcObjectToPtr(FC_ANTIALIAS);
|
|
|
|
_FcMatchers[MATCH_RASTERIZER].objectPtr = FcObjectToPtr(FC_RASTERIZER);
|
|
|
|
_FcMatchers[MATCH_OUTLINE].objectPtr = FcObjectToPtr(FC_OUTLINE);
|
|
|
|
_FcMatchers[MATCH_FONTVERSION].objectPtr = FcObjectToPtr(FC_FONTVERSION);
|
|
|
|
matchObjectPtrsInit = FcTrue;
|
|
|
|
}
|
|
|
|
|
2005-11-28 02:40:53 +01:00
|
|
|
static FcMatcher*
|
|
|
|
FcObjectPtrToMatcher (FcObjectPtr o)
|
2002-02-15 00:34:13 +01:00
|
|
|
{
|
2005-11-28 02:40:53 +01:00
|
|
|
int i;
|
|
|
|
const char *object = FcObjectPtrU(o);
|
2005-11-25 16:54:24 +01:00
|
|
|
|
2002-05-30 00:07:33 +02:00
|
|
|
i = -1;
|
2005-11-25 16:54:24 +01:00
|
|
|
switch (object[0]) {
|
2002-05-30 00:07:33 +02:00
|
|
|
case 'f':
|
2005-11-25 16:54:24 +01:00
|
|
|
switch (object[1]) {
|
2002-05-30 00:07:33 +02:00
|
|
|
case 'o':
|
2005-11-25 16:54:24 +01:00
|
|
|
switch (object[2]) {
|
2002-09-26 02:17:28 +02:00
|
|
|
case 'u':
|
|
|
|
i = MATCH_FOUNDRY; break;
|
|
|
|
case 'n':
|
|
|
|
i = MATCH_FONTVERSION; break;
|
|
|
|
}
|
|
|
|
break;
|
2002-05-30 00:07:33 +02:00
|
|
|
case 'a':
|
|
|
|
i = MATCH_FAMILY; break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'c':
|
|
|
|
i = MATCH_CHARSET; break;
|
|
|
|
case 'a':
|
|
|
|
i = MATCH_ANTIALIAS; break;
|
|
|
|
case 'l':
|
|
|
|
i = MATCH_LANG; break;
|
|
|
|
case 's':
|
2005-11-25 16:54:24 +01:00
|
|
|
switch (object[1]) {
|
2002-05-30 00:07:33 +02:00
|
|
|
case 'p':
|
|
|
|
i = MATCH_SPACING; break;
|
|
|
|
case 't':
|
|
|
|
i = MATCH_STYLE; break;
|
|
|
|
case 'l':
|
|
|
|
i = MATCH_SLANT; break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'p':
|
|
|
|
i = MATCH_PIXEL_SIZE; break;
|
|
|
|
case 'w':
|
2005-11-25 16:54:24 +01:00
|
|
|
switch (object[1]) {
|
2003-03-12 23:16:43 +01:00
|
|
|
case 'i':
|
|
|
|
i = MATCH_WIDTH; break;
|
|
|
|
case 'e':
|
|
|
|
i = MATCH_WEIGHT; break;
|
|
|
|
}
|
|
|
|
break;
|
2002-05-30 00:07:33 +02:00
|
|
|
case 'r':
|
|
|
|
i = MATCH_RASTERIZER; break;
|
|
|
|
case 'o':
|
|
|
|
i = MATCH_OUTLINE; break;
|
|
|
|
}
|
2005-11-25 17:33:58 +01:00
|
|
|
|
2005-11-28 02:40:53 +01:00
|
|
|
if (i < 0)
|
|
|
|
return 0;
|
|
|
|
|
2005-11-25 17:33:58 +01:00
|
|
|
if (!matchObjectPtrsInit)
|
|
|
|
FcMatchObjectPtrsInit();
|
|
|
|
|
2005-11-28 02:40:53 +01:00
|
|
|
if (o != _FcMatchers[i].objectPtr)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return _FcMatchers+i;
|
|
|
|
}
|
|
|
|
|
|
|
|
static FcBool
|
|
|
|
FcCompareValueList (FcObjectPtr o,
|
|
|
|
FcValueListPtr v1orig, /* pattern */
|
|
|
|
FcValueListPtr v2orig, /* target */
|
|
|
|
FcValue *bestValue,
|
|
|
|
double *value,
|
|
|
|
FcResult *result)
|
|
|
|
{
|
|
|
|
FcValueListPtr v1, v2;
|
|
|
|
FcValueList *v1_ptrU, *v2_ptrU;
|
|
|
|
double v, best, bestStrong, bestWeak;
|
|
|
|
int j;
|
|
|
|
const char *object = FcObjectPtrU(o);
|
|
|
|
FcMatcher *match = FcObjectPtrToMatcher(o);
|
|
|
|
|
|
|
|
if (!match)
|
2002-05-30 00:07:33 +02:00
|
|
|
{
|
|
|
|
if (bestValue)
|
2005-08-24 08:21:30 +02:00
|
|
|
*bestValue = FcValueCanonicalize(&FcValueListPtrU(v2orig)->value);
|
2002-05-30 00:07:33 +02:00
|
|
|
return FcTrue;
|
|
|
|
}
|
2005-11-28 02:40:53 +01:00
|
|
|
|
2002-02-15 00:34:13 +01:00
|
|
|
best = 1e99;
|
2002-06-29 22:31:02 +02:00
|
|
|
bestStrong = 1e99;
|
|
|
|
bestWeak = 1e99;
|
2002-02-15 00:34:13 +01:00
|
|
|
j = 0;
|
2005-11-22 05:46:55 +01:00
|
|
|
for (v1 = v1orig, v1_ptrU = FcValueListPtrU(v1); v1_ptrU;
|
2005-11-26 06:05:14 +01:00
|
|
|
v1 = v1_ptrU->next, v1_ptrU = FcValueListPtrU(v1))
|
2002-02-15 00:34:13 +01:00
|
|
|
{
|
2005-11-26 06:05:14 +01:00
|
|
|
for (v2 = v2orig, v2_ptrU = FcValueListPtrU(v2); v2_ptrU;
|
|
|
|
v2 = v2_ptrU->next, v2_ptrU = FcValueListPtrU(v2))
|
2002-02-15 00:34:13 +01:00
|
|
|
{
|
2005-11-28 02:40:53 +01:00
|
|
|
v = (match->compare) (&v1_ptrU->value, &v2_ptrU->value);
|
2002-02-15 00:34:13 +01:00
|
|
|
if (v < 0)
|
|
|
|
{
|
|
|
|
*result = FcResultTypeMismatch;
|
|
|
|
return FcFalse;
|
|
|
|
}
|
|
|
|
v = v * 100 + j;
|
|
|
|
if (v < best)
|
|
|
|
{
|
|
|
|
if (bestValue)
|
2005-11-22 05:46:55 +01:00
|
|
|
*bestValue = FcValueCanonicalize(&v2_ptrU->value);
|
2002-02-15 00:34:13 +01:00
|
|
|
best = v;
|
|
|
|
}
|
2005-11-22 05:46:55 +01:00
|
|
|
if (v1_ptrU->binding == FcValueBindingStrong)
|
2002-06-29 22:31:02 +02:00
|
|
|
{
|
|
|
|
if (v < bestStrong)
|
|
|
|
bestStrong = v;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (v < bestWeak)
|
|
|
|
bestWeak = v;
|
|
|
|
}
|
2002-02-15 00:34:13 +01:00
|
|
|
}
|
|
|
|
j++;
|
|
|
|
}
|
|
|
|
if (FcDebug () & FC_DBG_MATCHV)
|
|
|
|
{
|
|
|
|
printf (" %s: %g ", object, best);
|
|
|
|
FcValueListPrint (v1orig);
|
|
|
|
printf (", ");
|
|
|
|
FcValueListPrint (v2orig);
|
|
|
|
printf ("\n");
|
|
|
|
}
|
2002-06-08 19:32:05 +02:00
|
|
|
if (value)
|
2002-06-29 22:31:02 +02:00
|
|
|
{
|
2005-11-28 02:40:53 +01:00
|
|
|
int weak = match->weak;
|
|
|
|
int strong = match->strong;
|
2002-06-29 22:31:02 +02:00
|
|
|
if (weak == strong)
|
|
|
|
value[strong] += best;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
value[weak] += bestWeak;
|
|
|
|
value[strong] += bestStrong;
|
|
|
|
}
|
|
|
|
}
|
2002-02-15 00:34:13 +01:00
|
|
|
return FcTrue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return a value indicating the distance between the two lists of
|
|
|
|
* values
|
|
|
|
*/
|
|
|
|
|
|
|
|
static FcBool
|
|
|
|
FcCompare (FcPattern *pat,
|
|
|
|
FcPattern *fnt,
|
|
|
|
double *value,
|
|
|
|
FcResult *result)
|
|
|
|
{
|
|
|
|
int i, i1, i2;
|
|
|
|
|
2002-06-29 22:31:02 +02:00
|
|
|
for (i = 0; i < NUM_MATCH_VALUES; i++)
|
2002-02-15 00:34:13 +01:00
|
|
|
value[i] = 0.0;
|
|
|
|
|
2002-05-30 00:07:33 +02:00
|
|
|
i1 = 0;
|
|
|
|
i2 = 0;
|
|
|
|
while (i1 < pat->num && i2 < fnt->num)
|
2002-02-15 00:34:13 +01:00
|
|
|
{
|
2005-11-25 04:00:51 +01:00
|
|
|
FcPatternElt *elt_i1 = FcPatternEltU(pat->elts)+i1;
|
|
|
|
FcPatternElt *elt_i2 = FcPatternEltU(fnt->elts)+i2;
|
|
|
|
|
|
|
|
i = FcObjectPtrCompare(elt_i1->object, elt_i2->object);
|
2002-05-30 00:07:33 +02:00
|
|
|
if (i > 0)
|
|
|
|
i2++;
|
|
|
|
else if (i < 0)
|
|
|
|
i1++;
|
|
|
|
else
|
2002-02-15 00:34:13 +01:00
|
|
|
{
|
2005-11-25 16:54:24 +01:00
|
|
|
if (!FcCompareValueList (elt_i1->object,
|
2005-11-25 04:00:51 +01:00
|
|
|
elt_i1->values, elt_i2->values,
|
|
|
|
0, value, result))
|
2002-05-30 00:07:33 +02:00
|
|
|
return FcFalse;
|
|
|
|
i1++;
|
|
|
|
i2++;
|
2002-02-15 00:34:13 +01:00
|
|
|
}
|
2002-05-30 00:07:33 +02:00
|
|
|
}
|
|
|
|
return FcTrue;
|
2002-02-15 00:34:13 +01:00
|
|
|
}
|
|
|
|
|
2002-03-03 19:39:05 +01:00
|
|
|
FcPattern *
|
|
|
|
FcFontRenderPrepare (FcConfig *config,
|
|
|
|
FcPattern *pat,
|
|
|
|
FcPattern *font)
|
|
|
|
{
|
|
|
|
FcPattern *new;
|
|
|
|
int i;
|
|
|
|
FcPatternElt *fe, *pe;
|
|
|
|
FcValue v;
|
|
|
|
FcResult result;
|
|
|
|
|
|
|
|
new = FcPatternCreate ();
|
|
|
|
if (!new)
|
|
|
|
return 0;
|
|
|
|
for (i = 0; i < font->num; i++)
|
|
|
|
{
|
2005-06-28 05:41:02 +02:00
|
|
|
fe = FcPatternEltU(font->elts)+i;
|
|
|
|
pe = FcPatternFindElt (pat, FcObjectPtrU(fe->object));
|
2002-03-03 19:39:05 +01:00
|
|
|
if (pe)
|
|
|
|
{
|
2005-11-25 16:54:24 +01:00
|
|
|
if (!FcCompareValueList (pe->object, pe->values,
|
2002-08-11 20:11:04 +02:00
|
|
|
fe->values, &v, 0, &result))
|
2002-03-03 19:39:05 +01:00
|
|
|
{
|
|
|
|
FcPatternDestroy (new);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
2005-08-24 08:21:30 +02:00
|
|
|
v = FcValueCanonicalize(&FcValueListPtrU(fe->values)->value);
|
2005-06-28 05:41:02 +02:00
|
|
|
FcPatternAdd (new, FcObjectPtrU(fe->object), v, FcFalse);
|
2002-03-03 19:39:05 +01:00
|
|
|
}
|
|
|
|
for (i = 0; i < pat->num; i++)
|
|
|
|
{
|
2005-06-28 05:41:02 +02:00
|
|
|
pe = FcPatternEltU(pat->elts)+i;
|
|
|
|
fe = FcPatternFindElt (font, FcObjectPtrU(pe->object));
|
2002-03-03 19:39:05 +01:00
|
|
|
if (!fe)
|
2005-06-28 05:41:02 +02:00
|
|
|
FcPatternAdd (new, FcObjectPtrU(pe->object),
|
2005-08-24 08:21:30 +02:00
|
|
|
FcValueCanonicalize(&FcValueListPtrU(pe->values)->value), FcTrue);
|
2002-03-03 19:39:05 +01:00
|
|
|
}
|
2005-11-01 07:57:25 +01:00
|
|
|
|
|
|
|
if (FcPatternFindElt (font, FC_FILE))
|
|
|
|
FcPatternTransferFullFname (new, font);
|
|
|
|
|
2002-08-19 21:32:05 +02:00
|
|
|
FcConfigSubstituteWithPat (config, new, pat, FcMatchFont);
|
2002-03-03 19:39:05 +01:00
|
|
|
return new;
|
|
|
|
}
|
|
|
|
|
2002-02-15 00:34:13 +01:00
|
|
|
FcPattern *
|
2002-02-28 17:51:48 +01:00
|
|
|
FcFontSetMatch (FcConfig *config,
|
|
|
|
FcFontSet **sets,
|
|
|
|
int nsets,
|
|
|
|
FcPattern *p,
|
|
|
|
FcResult *result)
|
2002-02-15 00:34:13 +01:00
|
|
|
{
|
2005-11-28 02:40:53 +01:00
|
|
|
double score;
|
|
|
|
double bestscore;
|
2002-02-15 00:34:13 +01:00
|
|
|
int f;
|
|
|
|
FcFontSet *s;
|
|
|
|
FcPattern *best;
|
2005-11-28 02:40:53 +01:00
|
|
|
int scoring_index;
|
2006-01-08 11:58:30 +01:00
|
|
|
int *sets_offset;
|
2002-03-03 19:39:05 +01:00
|
|
|
int set;
|
2006-01-08 11:58:30 +01:00
|
|
|
int nfonts;
|
|
|
|
int fonts_left;
|
|
|
|
FcMatcher *matcher;
|
|
|
|
FcMatcher *strong_matchers[NUM_MATCH_VALUES];
|
|
|
|
FcMatcher *weak_matchers[NUM_MATCH_VALUES];
|
|
|
|
FcPatternElt *pat_elts[NUM_MATCH_VALUES];
|
|
|
|
int pat_elt;
|
2006-02-11 05:50:46 +01:00
|
|
|
int *match_blocked;
|
2006-01-08 11:58:30 +01:00
|
|
|
int block_start;
|
|
|
|
|
|
|
|
if (!nsets || !sets || !p)
|
|
|
|
{
|
|
|
|
*result = FcResultNoMatch;
|
|
|
|
return 0;
|
|
|
|
}
|
2002-02-15 00:34:13 +01:00
|
|
|
|
|
|
|
if (FcDebug () & FC_DBG_MATCH)
|
|
|
|
{
|
|
|
|
printf ("Match ");
|
|
|
|
FcPatternPrint (p);
|
|
|
|
}
|
|
|
|
if (!config)
|
|
|
|
{
|
|
|
|
config = FcConfigGetCurrent ();
|
|
|
|
if (!config)
|
2004-05-29 21:32:41 +02:00
|
|
|
{
|
|
|
|
*result = FcResultOutOfMemory;
|
2002-02-15 00:34:13 +01:00
|
|
|
return 0;
|
2004-05-29 21:32:41 +02:00
|
|
|
}
|
2002-02-15 00:34:13 +01:00
|
|
|
}
|
2006-01-08 11:58:30 +01:00
|
|
|
|
|
|
|
sets_offset = (int *)calloc(nsets, sizeof (int));
|
|
|
|
|
|
|
|
nfonts = 0;
|
|
|
|
for (set = 0; set < nsets; ++set)
|
|
|
|
{
|
|
|
|
sets_offset[set] = nfonts;
|
|
|
|
if (sets[set])
|
|
|
|
nfonts += sets[set]->nfont;
|
|
|
|
}
|
|
|
|
|
|
|
|
fonts_left = nfonts;
|
|
|
|
|
2006-02-11 05:50:46 +01:00
|
|
|
match_blocked = (int*)calloc(nfonts, sizeof(int));
|
2006-01-08 11:58:30 +01:00
|
|
|
|
|
|
|
/* Find out all necessary matchers first, so we don't need to find them
|
|
|
|
* in every loop.
|
|
|
|
*/
|
|
|
|
|
|
|
|
memset(strong_matchers, 0, sizeof (FcMatcher*) * NUM_MATCH_VALUES);
|
|
|
|
memset(weak_matchers, 0, sizeof (FcMatcher*) * NUM_MATCH_VALUES);
|
|
|
|
memset(pat_elts, 0, sizeof (FcPatternElt*) * NUM_MATCH_VALUES);
|
|
|
|
|
|
|
|
for (pat_elt = 0; pat_elt < p->num; ++pat_elt)
|
|
|
|
{
|
|
|
|
matcher = FcObjectPtrToMatcher
|
|
|
|
((FcPatternEltU(p->elts)+pat_elt)->object);
|
|
|
|
if (matcher)
|
|
|
|
{
|
|
|
|
strong_matchers[matcher->strong] = matcher;
|
|
|
|
weak_matchers[matcher->weak] = matcher;
|
|
|
|
pat_elts [matcher->strong] = pat_elts [matcher->weak] =
|
|
|
|
(FcPatternEltU(p->elts)+pat_elt);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The old algorithm checked if each font beat 'best',
|
|
|
|
* scanning all of the value lists for all of the pattern elts. */
|
|
|
|
/* This algorithm checks each font on a element-by-element basis
|
|
|
|
* and blocks fonts that have already lost on some element from
|
|
|
|
* further consideration from being best. Basically, we've
|
|
|
|
* swapped the order of loops and short-circuited fonts that
|
|
|
|
* are out of contention right away.
|
|
|
|
* This saves a lot of time! */
|
|
|
|
best = 0;
|
|
|
|
block_start = 0;
|
|
|
|
for (scoring_index = 0; scoring_index < NUM_MATCH_VALUES; ++scoring_index)
|
2002-02-15 00:34:13 +01:00
|
|
|
{
|
2006-01-08 11:58:30 +01:00
|
|
|
FcValueListPtr v1;
|
|
|
|
FcValueList *v1_ptrU;
|
|
|
|
int v1_offset = 0;
|
2005-11-28 11:54:11 +01:00
|
|
|
|
2006-01-08 11:58:30 +01:00
|
|
|
if (!strong_matchers [scoring_index] && !weak_matchers [scoring_index])
|
2002-02-15 00:34:13 +01:00
|
|
|
continue;
|
2005-11-28 02:40:53 +01:00
|
|
|
|
2006-01-08 11:58:30 +01:00
|
|
|
for (v1 = pat_elts[scoring_index]->values, v1_ptrU = FcValueListPtrU(v1);
|
|
|
|
v1_ptrU;
|
|
|
|
v1 = v1_ptrU->next, v1_ptrU = FcValueListPtrU(v1), ++v1_offset)
|
|
|
|
{
|
|
|
|
matcher = (v1_ptrU->binding == FcValueBindingWeak) ?
|
|
|
|
weak_matchers[scoring_index] : strong_matchers[scoring_index];
|
|
|
|
|
|
|
|
if (!matcher) continue;
|
|
|
|
|
|
|
|
bestscore = 1e99;
|
|
|
|
|
|
|
|
if (FcDebug () & FC_DBG_MATCHV)
|
|
|
|
{
|
|
|
|
printf("Scoring Index %d, Value %d: %d(%d) fonts left\n",
|
|
|
|
scoring_index, v1_offset, fonts_left, nfonts);
|
2002-02-15 00:34:13 +01:00
|
|
|
}
|
2005-11-28 02:40:53 +01:00
|
|
|
|
2006-01-08 11:58:30 +01:00
|
|
|
for (set = 0; set < nsets; ++set)
|
|
|
|
{
|
|
|
|
s = sets[set];
|
|
|
|
if (!s) continue;
|
2005-11-28 11:54:11 +01:00
|
|
|
|
2006-01-08 11:58:30 +01:00
|
|
|
/* All fonts before block_start should have been knocked out. */
|
|
|
|
for (f = (block_start > sets_offset[set]) ? (block_start - sets_offset[set]) : 0;
|
|
|
|
f < s->nfont; ++f)
|
|
|
|
{
|
|
|
|
int cand_elt;
|
|
|
|
FcPatternElt *cand_elts;
|
2005-11-28 02:40:53 +01:00
|
|
|
|
2006-02-11 05:50:46 +01:00
|
|
|
if (match_blocked[f + sets_offset[set]] == 1)
|
2006-01-08 11:58:30 +01:00
|
|
|
continue;
|
2005-11-28 02:40:53 +01:00
|
|
|
|
2006-01-08 11:58:30 +01:00
|
|
|
score = 1e99;
|
2005-11-28 02:40:53 +01:00
|
|
|
cand_elts = FcPatternEltU(s->fonts[f]->elts);
|
2006-01-08 11:58:30 +01:00
|
|
|
|
2005-11-28 02:40:53 +01:00
|
|
|
/* Look for the appropriate element in this candidate
|
|
|
|
* pattern 'f' and evaluate its score wrt 'p'. */
|
2006-01-08 11:58:30 +01:00
|
|
|
for (cand_elt = 0; cand_elt < s->fonts[f]->num; ++cand_elt)
|
2005-11-28 02:40:53 +01:00
|
|
|
{
|
2006-01-08 11:58:30 +01:00
|
|
|
if (cand_elts[cand_elt].object == pat_elts[scoring_index]->object)
|
|
|
|
{
|
2005-11-28 02:40:53 +01:00
|
|
|
FcValueListPtr v2;
|
2006-01-08 11:58:30 +01:00
|
|
|
FcValueList *v2_ptrU;
|
2005-11-28 02:40:53 +01:00
|
|
|
|
2006-01-08 11:58:30 +01:00
|
|
|
for (v2 = cand_elts[cand_elt].values, v2_ptrU = FcValueListPtrU(v2);
|
|
|
|
v2_ptrU;
|
|
|
|
v2 = v2_ptrU->next, v2_ptrU = FcValueListPtrU(v2))
|
2005-11-28 02:40:53 +01:00
|
|
|
{
|
2006-01-08 11:58:30 +01:00
|
|
|
double v = (matcher->compare)(&v1_ptrU->value, &v2_ptrU->value);
|
2005-11-28 02:40:53 +01:00
|
|
|
|
|
|
|
if (v < 0)
|
|
|
|
{
|
|
|
|
*result = FcResultTypeMismatch;
|
2006-01-08 11:58:30 +01:00
|
|
|
free (match_blocked);
|
|
|
|
free (sets_offset);
|
2005-11-28 02:40:53 +01:00
|
|
|
return 0;
|
|
|
|
}
|
2006-01-08 11:58:30 +01:00
|
|
|
|
2005-11-28 02:40:53 +01:00
|
|
|
/* I'm actually kind of surprised that
|
|
|
|
* this isn't v + 100 * v1_offset. -PL */
|
|
|
|
v = v * 100 + v1_offset;
|
2006-01-08 11:58:30 +01:00
|
|
|
/* The old patch said score += v, which
|
|
|
|
* seems to be wrong when you have
|
|
|
|
* multiple matchers. This takes the
|
|
|
|
* best score it can find for that font. */
|
|
|
|
if (v < score)
|
|
|
|
score = v;
|
2005-11-28 02:40:53 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-02-10 20:40:11 +01:00
|
|
|
/* We had no matching, just try the next one */
|
|
|
|
if (score == 1e99)
|
2006-02-11 05:50:46 +01:00
|
|
|
{
|
|
|
|
match_blocked[f + sets_offset[set]] = 2;
|
2006-02-10 20:40:11 +01:00
|
|
|
continue;
|
2006-02-11 05:50:46 +01:00
|
|
|
}
|
|
|
|
match_blocked[f + sets_offset[set]] = 0;
|
2005-11-28 02:40:53 +01:00
|
|
|
/* If there's a previous champion, and current score
|
|
|
|
* beats previous best score, on this element, then
|
|
|
|
* knock out the previous champion and anything
|
|
|
|
* else that we would have visited previous to f;
|
|
|
|
* clearly anything previous to f would have been
|
|
|
|
* less than f on this score. */
|
|
|
|
if (!best || score < bestscore)
|
|
|
|
{
|
|
|
|
if (best)
|
|
|
|
{
|
|
|
|
int b;
|
2006-01-08 11:58:30 +01:00
|
|
|
for (b = block_start; b < f + sets_offset[set]; ++b)
|
|
|
|
if (!match_blocked[b])
|
|
|
|
{
|
2006-02-11 05:50:46 +01:00
|
|
|
match_blocked[b] = 1;
|
2006-01-08 11:58:30 +01:00
|
|
|
--fonts_left;
|
|
|
|
}
|
2005-11-28 02:40:53 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
bestscore = score;
|
|
|
|
best = s->fonts[f];
|
2006-02-11 05:50:46 +01:00
|
|
|
/* This kills too many fonts, unfortunately. */
|
|
|
|
/* block_start = f + sets_offset[set]; */
|
2005-11-28 02:40:53 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* If f loses, then it's out too. */
|
|
|
|
if (best && score > bestscore)
|
2006-01-08 11:58:30 +01:00
|
|
|
{
|
2006-02-11 05:50:46 +01:00
|
|
|
match_blocked[f + sets_offset[set]] = 1;
|
2006-01-08 11:58:30 +01:00
|
|
|
--fonts_left;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If there is only 1 font left and the best is set,
|
|
|
|
* then just return this font
|
|
|
|
*/
|
|
|
|
if (fonts_left == 1 && best)
|
|
|
|
goto end;
|
2005-11-28 02:40:53 +01:00
|
|
|
|
|
|
|
/* Otherwise, f is equal to best on this element.
|
|
|
|
* Carry on to next pattern element. */
|
2002-02-15 00:34:13 +01:00
|
|
|
}
|
2006-01-08 11:58:30 +01:00
|
|
|
}
|
|
|
|
if ((FcDebug () & FC_DBG_MATCHV) && best)
|
|
|
|
{
|
|
|
|
printf ("Best match (scoring index %d) candidate %d ", scoring_index, block_start);
|
|
|
|
FcPatternPrint (best);
|
|
|
|
}
|
|
|
|
}
|
2002-02-15 00:34:13 +01:00
|
|
|
}
|
2006-01-08 11:58:30 +01:00
|
|
|
|
|
|
|
end:
|
|
|
|
free (match_blocked);
|
|
|
|
free (sets_offset);
|
|
|
|
|
2005-11-28 11:54:11 +01:00
|
|
|
if ((FcDebug () & FC_DBG_MATCH) && best)
|
|
|
|
{
|
2006-01-08 11:58:30 +01:00
|
|
|
printf ("Best match (scoring index %d) %d ", scoring_index, block_start);
|
2005-11-28 11:54:11 +01:00
|
|
|
FcPatternPrint (best);
|
|
|
|
}
|
2002-02-15 00:34:13 +01:00
|
|
|
if (!best)
|
|
|
|
{
|
|
|
|
*result = FcResultNoMatch;
|
|
|
|
return 0;
|
|
|
|
}
|
2002-03-03 19:39:05 +01:00
|
|
|
return FcFontRenderPrepare (config, p, best);
|
2002-02-15 00:34:13 +01:00
|
|
|
}
|
2002-02-28 17:51:48 +01:00
|
|
|
|
|
|
|
FcPattern *
|
|
|
|
FcFontMatch (FcConfig *config,
|
|
|
|
FcPattern *p,
|
|
|
|
FcResult *result)
|
|
|
|
{
|
|
|
|
FcFontSet *sets[2];
|
|
|
|
int nsets;
|
|
|
|
|
|
|
|
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 FcFontSetMatch (config, sets, nsets, p, result);
|
|
|
|
}
|
2002-03-03 19:39:05 +01:00
|
|
|
|
|
|
|
typedef struct _FcSortNode {
|
|
|
|
FcPattern *pattern;
|
2002-06-29 22:31:02 +02:00
|
|
|
double score[NUM_MATCH_VALUES];
|
2002-03-03 19:39:05 +01:00
|
|
|
} FcSortNode;
|
|
|
|
|
2002-05-22 06:37:07 +02:00
|
|
|
static int
|
|
|
|
FcSortCompare (const void *aa, const void *ab)
|
2002-03-03 19:39:05 +01:00
|
|
|
{
|
2002-05-22 06:37:07 +02:00
|
|
|
FcSortNode *a = *(FcSortNode **) aa;
|
|
|
|
FcSortNode *b = *(FcSortNode **) ab;
|
2002-05-30 00:07:33 +02:00
|
|
|
double *as = &a->score[0];
|
|
|
|
double *bs = &b->score[0];
|
2002-06-02 23:07:57 +02:00
|
|
|
double ad = 0, bd = 0;
|
2002-05-22 06:37:07 +02:00
|
|
|
int i;
|
2002-03-03 19:39:05 +01:00
|
|
|
|
2002-06-29 22:31:02 +02:00
|
|
|
i = NUM_MATCH_VALUES;
|
2002-05-30 00:07:33 +02:00
|
|
|
while (i-- && (ad = *as++) == (bd = *bs++))
|
|
|
|
;
|
|
|
|
return ad < bd ? -1 : ad > bd ? 1 : 0;
|
2002-03-03 19:39:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static FcBool
|
2002-05-22 06:37:07 +02:00
|
|
|
FcSortWalk (FcSortNode **n, int nnode, FcFontSet *fs, FcCharSet **cs, FcBool trim)
|
2002-03-03 19:39:05 +01:00
|
|
|
{
|
|
|
|
FcCharSet *ncs;
|
2002-05-22 06:37:07 +02:00
|
|
|
FcSortNode *node;
|
|
|
|
|
|
|
|
while (nnode--)
|
2002-03-03 19:39:05 +01:00
|
|
|
{
|
2002-05-22 06:37:07 +02:00
|
|
|
node = *n++;
|
|
|
|
if (FcPatternGetCharSet (node->pattern, FC_CHARSET, 0, &ncs) ==
|
|
|
|
FcResultMatch)
|
2002-03-03 19:39:05 +01:00
|
|
|
{
|
2002-05-29 10:21:33 +02:00
|
|
|
/*
|
|
|
|
* If this font isn't a subset of the previous fonts,
|
|
|
|
* add it to the list
|
|
|
|
*/
|
|
|
|
if (!trim || !*cs || !FcCharSetIsSubset (ncs, *cs))
|
2002-03-03 19:39:05 +01:00
|
|
|
{
|
2002-05-22 06:37:07 +02:00
|
|
|
if (*cs)
|
|
|
|
{
|
|
|
|
ncs = FcCharSetUnion (ncs, *cs);
|
|
|
|
if (!ncs)
|
|
|
|
return FcFalse;
|
|
|
|
FcCharSetDestroy (*cs);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
ncs = FcCharSetCopy (ncs);
|
|
|
|
*cs = ncs;
|
2002-06-19 22:08:22 +02:00
|
|
|
FcPatternReference (node->pattern);
|
2002-07-07 01:47:44 +02:00
|
|
|
if (FcDebug () & FC_DBG_MATCH)
|
|
|
|
{
|
|
|
|
printf ("Add ");
|
|
|
|
FcPatternPrint (node->pattern);
|
|
|
|
}
|
2002-05-22 06:37:07 +02:00
|
|
|
if (!FcFontSetAdd (fs, node->pattern))
|
2002-06-19 22:08:22 +02:00
|
|
|
{
|
|
|
|
FcPatternDestroy (node->pattern);
|
2002-03-03 19:39:05 +01:00
|
|
|
return FcFalse;
|
2002-06-19 22:08:22 +02:00
|
|
|
}
|
2002-03-03 19:39:05 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return FcTrue;
|
|
|
|
}
|
|
|
|
|
2002-05-29 10:21:33 +02:00
|
|
|
void
|
|
|
|
FcFontSetSortDestroy (FcFontSet *fs)
|
|
|
|
{
|
|
|
|
FcFontSetDestroy (fs);
|
|
|
|
}
|
|
|
|
|
2002-03-03 19:39:05 +01:00
|
|
|
FcFontSet *
|
|
|
|
FcFontSetSort (FcConfig *config,
|
|
|
|
FcFontSet **sets,
|
|
|
|
int nsets,
|
|
|
|
FcPattern *p,
|
|
|
|
FcBool trim,
|
|
|
|
FcCharSet **csp,
|
|
|
|
FcResult *result)
|
|
|
|
{
|
|
|
|
FcFontSet *ret;
|
|
|
|
FcFontSet *s;
|
|
|
|
FcSortNode *nodes;
|
2002-05-22 06:37:07 +02:00
|
|
|
FcSortNode **nodeps, **nodep;
|
2002-03-03 19:39:05 +01:00
|
|
|
int nnodes;
|
|
|
|
FcSortNode *new;
|
|
|
|
FcCharSet *cs;
|
|
|
|
int set;
|
|
|
|
int f;
|
|
|
|
int i;
|
2004-12-14 01:12:25 +01:00
|
|
|
int nPatternLang;
|
|
|
|
FcBool *patternLangSat;
|
|
|
|
FcValue patternLang;
|
2002-03-03 19:39:05 +01:00
|
|
|
|
2002-07-07 01:47:44 +02:00
|
|
|
if (FcDebug () & FC_DBG_MATCH)
|
|
|
|
{
|
|
|
|
printf ("Sort ");
|
|
|
|
FcPatternPrint (p);
|
|
|
|
}
|
2002-03-03 19:39:05 +01:00
|
|
|
nnodes = 0;
|
|
|
|
for (set = 0; set < nsets; set++)
|
|
|
|
{
|
|
|
|
s = sets[set];
|
|
|
|
if (!s)
|
|
|
|
continue;
|
|
|
|
nnodes += s->nfont;
|
|
|
|
}
|
|
|
|
if (!nnodes)
|
|
|
|
goto bail0;
|
2004-12-14 01:12:25 +01:00
|
|
|
|
|
|
|
for (nPatternLang = 0;
|
|
|
|
FcPatternGet (p, FC_LANG, nPatternLang, &patternLang) == FcResultMatch;
|
|
|
|
nPatternLang++)
|
|
|
|
;
|
|
|
|
|
2002-09-01 00:17:32 +02:00
|
|
|
/* freed below */
|
2004-12-14 01:12:25 +01:00
|
|
|
nodes = malloc (nnodes * sizeof (FcSortNode) +
|
|
|
|
nnodes * sizeof (FcSortNode *) +
|
|
|
|
nPatternLang * sizeof (FcBool));
|
2002-03-03 19:39:05 +01:00
|
|
|
if (!nodes)
|
|
|
|
goto bail0;
|
2002-05-29 10:21:33 +02:00
|
|
|
nodeps = (FcSortNode **) (nodes + nnodes);
|
2004-12-14 01:12:25 +01:00
|
|
|
patternLangSat = (FcBool *) (nodeps + nnodes);
|
2002-03-03 19:39:05 +01:00
|
|
|
|
|
|
|
new = nodes;
|
2002-05-22 06:37:07 +02:00
|
|
|
nodep = nodeps;
|
2002-03-03 19:39:05 +01:00
|
|
|
for (set = 0; set < nsets; set++)
|
|
|
|
{
|
|
|
|
s = sets[set];
|
|
|
|
if (!s)
|
|
|
|
continue;
|
|
|
|
for (f = 0; f < s->nfont; f++)
|
|
|
|
{
|
|
|
|
if (FcDebug () & FC_DBG_MATCHV)
|
|
|
|
{
|
|
|
|
printf ("Font %d ", f);
|
|
|
|
FcPatternPrint (s->fonts[f]);
|
|
|
|
}
|
|
|
|
new->pattern = s->fonts[f];
|
|
|
|
if (!FcCompare (p, new->pattern, new->score, result))
|
|
|
|
goto bail1;
|
|
|
|
if (FcDebug () & FC_DBG_MATCHV)
|
|
|
|
{
|
|
|
|
printf ("Score");
|
2002-06-29 22:31:02 +02:00
|
|
|
for (i = 0; i < NUM_MATCH_VALUES; i++)
|
2002-03-03 19:39:05 +01:00
|
|
|
{
|
|
|
|
printf (" %g", new->score[i]);
|
|
|
|
}
|
|
|
|
printf ("\n");
|
|
|
|
}
|
2002-05-22 06:37:07 +02:00
|
|
|
*nodep = new;
|
2002-03-03 19:39:05 +01:00
|
|
|
new++;
|
2002-05-22 06:37:07 +02:00
|
|
|
nodep++;
|
2002-03-03 19:39:05 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-05-22 06:37:07 +02:00
|
|
|
nnodes = new - nodes;
|
|
|
|
|
2002-05-29 10:21:33 +02:00
|
|
|
qsort (nodeps, nnodes, sizeof (FcSortNode *),
|
2002-05-22 06:37:07 +02:00
|
|
|
FcSortCompare);
|
2004-12-14 01:12:25 +01:00
|
|
|
|
|
|
|
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] < nPatternLang)
|
|
|
|
{
|
|
|
|
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)
|
|
|
|
{
|
2005-11-25 04:00:51 +01:00
|
|
|
double compare = FcCompareLang (&patternLang, &nodeLang);
|
2004-12-14 01:12:25 +01:00
|
|
|
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] = 1000.0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Re-sort once the language issues have been settled
|
|
|
|
*/
|
|
|
|
qsort (nodeps, nnodes, sizeof (FcSortNode *),
|
|
|
|
FcSortCompare);
|
2002-05-22 06:37:07 +02:00
|
|
|
|
2002-03-03 19:39:05 +01:00
|
|
|
ret = FcFontSetCreate ();
|
|
|
|
if (!ret)
|
|
|
|
goto bail1;
|
|
|
|
|
|
|
|
cs = 0;
|
|
|
|
|
2002-05-22 06:37:07 +02:00
|
|
|
if (!FcSortWalk (nodeps, nnodes, ret, &cs, trim))
|
2002-03-03 19:39:05 +01:00
|
|
|
goto bail2;
|
|
|
|
|
2002-06-08 19:32:05 +02:00
|
|
|
if (csp)
|
|
|
|
*csp = cs;
|
|
|
|
else
|
|
|
|
FcCharSetDestroy (cs);
|
2002-03-03 19:39:05 +01:00
|
|
|
|
2002-05-29 10:21:33 +02:00
|
|
|
free (nodes);
|
|
|
|
|
2002-03-03 19:39:05 +01:00
|
|
|
return ret;
|
|
|
|
|
|
|
|
bail2:
|
|
|
|
if (cs)
|
|
|
|
FcCharSetDestroy (cs);
|
|
|
|
FcFontSetDestroy (ret);
|
|
|
|
bail1:
|
|
|
|
free (nodes);
|
|
|
|
bail0:
|
|
|
|
return 0;
|
|
|
|
}
|
2002-05-31 06:42:42 +02:00
|
|
|
|
|
|
|
FcFontSet *
|
|
|
|
FcFontSort (FcConfig *config,
|
|
|
|
FcPattern *p,
|
|
|
|
FcBool trim,
|
|
|
|
FcCharSet **csp,
|
|
|
|
FcResult *result)
|
|
|
|
{
|
|
|
|
FcFontSet *sets[2];
|
|
|
|
int nsets;
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|