Create FC_FONTFORMAT from FT_Get_X11_Font_Format function where available.

[fontconfig.git] / src / fcname.c

diff --git a/src/fcname.c b/src/fcname.c
index fc8c3a41b0d5739c34c7d8774200f03ad14e50f9..c3b7698b8d1dfb44daa3183b7c3f87dcd9a8d4b7 100644 (file)
--- a/src/fcname.c
+++ b/src/fcname.c
@@ -1,7 +1,7 @@
 /*
- * $XFree86: xc/lib/fontconfig/src/fcname.c,v 1.10 2002/06/29 20:31:02 keithp Exp $
+ * $RCSId: xc/lib/fontconfig/src/fcname.c,v 1.15 2002/09/26 00:17:28 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
@@ -30,9 +30,14 @@
 
 static const FcObjectType _FcBaseObjectTypes[] = {
     { FC_FAMILY,       FcTypeString, },
+    { FC_FAMILYLANG,   FcTypeString, },
     { FC_STYLE,                FcTypeString, },
+    { FC_STYLELANG,    FcTypeString, },
+    { FC_FULLNAME,     FcTypeString, },
+    { FC_FULLNAMELANG, FcTypeString, },
     { FC_SLANT,                FcTypeInteger, },
     { FC_WEIGHT,       FcTypeInteger, },
+    { FC_WIDTH,                FcTypeInteger, },
     { FC_SIZE,         FcTypeDouble, },
     { FC_ASPECT,       FcTypeDouble, },
     { FC_PIXEL_SIZE,   FcTypeDouble, },
@@ -40,6 +45,7 @@ static const FcObjectType _FcBaseObjectTypes[] = {
     { FC_FOUNDRY,      FcTypeString, },
 /*    { FC_CORE,               FcTypeBool, }, */
     { FC_ANTIALIAS,    FcTypeBool, },
+    { FC_HINT_STYLE,    FcTypeInteger, },
     { FC_HINTING,      FcTypeBool, },
     { FC_VERTICAL_LAYOUT,   FcTypeBool, },
     { FC_AUTOHINT,     FcTypeBool, },
@@ -59,7 +65,10 @@ static const FcObjectType _FcBaseObjectTypes[] = {
     { FC_CHAR_HEIGHT,  FcTypeInteger },
     { FC_MATRIX,       FcTypeMatrix },
     { FC_CHARSET,      FcTypeCharSet },
-    { FC_LANG,         FcTypeString },
+    { FC_LANG,         FcTypeLangSet },
+    { FC_FONTVERSION,  FcTypeInteger },
+    { FC_CAPABILITY,   FcTypeString },
+    { FC_FONTFORMAT,   FcTypeString },
 };
 
 #define NUM_OBJECT_TYPES    (sizeof _FcBaseObjectTypes / sizeof _FcBaseObjectTypes[0])
@@ -88,6 +97,7 @@ FcNameRegisterObjectTypes (const FcObjectType *types, int ntypes)
     l = (FcObjectTypeList *) malloc (sizeof (FcObjectTypeList));
     if (!l)
        return FcFalse;
+    FcMemAlloc (FC_MEM_OBJECTTYPE, sizeof (FcObjectTypeList));
     l->types = types;
     l->ntypes = ntypes;
     l->next = _FcObjectTypes;
@@ -107,6 +117,7 @@ FcNameUnregisterObjectTypes (const FcObjectType *types, int ntypes)
        if (l->types == types && l->ntypes == ntypes)
        {
            *prev = l->next;
+           FcMemFree (FC_MEM_OBJECTTYPE, sizeof (FcObjectTypeList));
            free ((void *) l);
            return FcTrue;
        }
@@ -134,25 +145,50 @@ FcNameGetObjectType (const char *object)
 }
 
 static const FcConstant _FcBaseConstants[] = {
+    { (FcChar8 *) "thin",          "weight",   FC_WEIGHT_THIN, },
+    { (FcChar8 *) "extralight",            "weight",   FC_WEIGHT_EXTRALIGHT, },
+    { (FcChar8 *) "ultralight",            "weight",   FC_WEIGHT_EXTRALIGHT, },
     { (FcChar8 *) "light",         "weight",   FC_WEIGHT_LIGHT, },
+    { (FcChar8 *) "book",          "weight",   FC_WEIGHT_BOOK, },
+    { (FcChar8 *) "regular",       "weight",   FC_WEIGHT_REGULAR, },
     { (FcChar8 *) "medium",        "weight",   FC_WEIGHT_MEDIUM, },
     { (FcChar8 *) "demibold",      "weight",   FC_WEIGHT_DEMIBOLD, },
+    { (FcChar8 *) "semibold",      "weight",   FC_WEIGHT_DEMIBOLD, },
     { (FcChar8 *) "bold",          "weight",   FC_WEIGHT_BOLD, },
+    { (FcChar8 *) "extrabold",     "weight",   FC_WEIGHT_EXTRABOLD, },
+    { (FcChar8 *) "ultrabold",     "weight",   FC_WEIGHT_EXTRABOLD, },
     { (FcChar8 *) "black",         "weight",   FC_WEIGHT_BLACK, },
 
     { (FcChar8 *) "roman",         "slant",    FC_SLANT_ROMAN, },
     { (FcChar8 *) "italic",        "slant",    FC_SLANT_ITALIC, },
     { (FcChar8 *) "oblique",       "slant",    FC_SLANT_OBLIQUE, },
 
+    { (FcChar8 *) "ultracondensed", "width",   FC_WIDTH_ULTRACONDENSED },
+    { (FcChar8 *) "extracondensed", "width",   FC_WIDTH_EXTRACONDENSED },
+    { (FcChar8 *) "condensed",     "width",    FC_WIDTH_CONDENSED },
+    { (FcChar8 *) "semicondensed", "width",    FC_WIDTH_SEMICONDENSED },
+    { (FcChar8 *) "normal",        "width",    FC_WIDTH_NORMAL },
+    { (FcChar8 *) "semiexpanded",   "width",   FC_WIDTH_SEMIEXPANDED },
+    { (FcChar8 *) "expanded",      "width",    FC_WIDTH_EXPANDED },
+    { (FcChar8 *) "extraexpanded",  "width",   FC_WIDTH_EXTRAEXPANDED },
+    { (FcChar8 *) "ultraexpanded",  "width",   FC_WIDTH_ULTRAEXPANDED },
+    
     { (FcChar8 *) "proportional",   "spacing",  FC_PROPORTIONAL, },
+    { (FcChar8 *) "dual",          "spacing",  FC_DUAL, },
     { (FcChar8 *) "mono",          "spacing",  FC_MONO, },
     { (FcChar8 *) "charcell",      "spacing",  FC_CHARCELL, },
 
-    { (FcChar8 *) "none",          "rgba",         FC_RGBA_NONE },
+    { (FcChar8 *) "unknown",       "rgba",         FC_RGBA_UNKNOWN },
     { (FcChar8 *) "rgb",           "rgba",         FC_RGBA_RGB, },
     { (FcChar8 *) "bgr",           "rgba",         FC_RGBA_BGR, },
     { (FcChar8 *) "vrgb",          "rgba",         FC_RGBA_VRGB },
     { (FcChar8 *) "vbgr",          "rgba",         FC_RGBA_VBGR },
+    { (FcChar8 *) "none",          "rgba",         FC_RGBA_NONE },
+
+    { (FcChar8 *) "hintnone",      "hintstyle",   FC_HINT_NONE },
+    { (FcChar8 *) "hintslight",            "hintstyle",   FC_HINT_SLIGHT },
+    { (FcChar8 *) "hintmedium",            "hintstyle",   FC_HINT_MEDIUM },
+    { (FcChar8 *) "hintfull",      "hintstyle",   FC_HINT_FULL },
 };
 
 #define NUM_FC_CONSTANTS   (sizeof _FcBaseConstants/sizeof _FcBaseConstants[0])
@@ -181,6 +217,7 @@ FcNameRegisterConstants (const FcConstant *consts, int nconsts)
     l = (FcConstantList *) malloc (sizeof (FcConstantList));
     if (!l)
        return FcFalse;
+    FcMemAlloc (FC_MEM_CONSTANT, sizeof (FcConstantList));
     l->consts = consts;
     l->nconsts = nconsts;
     l->next = _FcConstants;
@@ -200,6 +237,7 @@ FcNameUnregisterConstants (const FcConstant *consts, int nconsts)
        if (l->consts == consts && l->nconsts == nconsts)
        {
            *prev = l->next;
+           FcMemFree (FC_MEM_CONSTANT, sizeof (FcConstantList));
            free ((void *) l);
            return FcTrue;
        }
@@ -212,7 +250,7 @@ FcNameGetConstant (FcChar8 *string)
 {
     const FcConstantList    *l;
     int                            i;
-    
+
     for (l = _FcConstants; l; l = l->next)
     {
        for (i = 0; i < l->nconsts; i++)
@@ -241,8 +279,7 @@ FcNameBool (FcChar8 *v, FcBool *result)
     char    c0, c1;
 
     c0 = *v;
-    if (isupper (c0))
-       c0 = tolower (c0);
+    c0 = FcToLower (c0);
     if (c0 == 't' || c0 == 'y' || c0 == '1')
     {
        *result = FcTrue;
@@ -256,8 +293,7 @@ FcNameBool (FcChar8 *v, FcBool *result)
     if (c0 == 'o')
     {
        c1 = v[1];
-       if (isupper (c1))
-           c1 = tolower (c1);
+       c1 = FcToLower (c1);
        if (c1 == 'n')
        {
            *result = FcTrue;
@@ -300,6 +336,9 @@ FcNameConvert (FcType type, FcChar8 *string, FcMatrix *m)
     case FcTypeCharSet:
        v.u.c = FcNameParseCharSet (string);
        break;
+    case FcTypeLangSet:
+       v.u.l = FcNameParseLangSet (string);
+       break;
     default:
        break;
     }
@@ -344,6 +383,7 @@ FcNameParse (const FcChar8 *name)
     const FcObjectType *t;
     const FcConstant   *c;
 
+    /* freed below */
     save = malloc (strlen ((char *) name) + 1);
     if (!save)
        goto bail0;
@@ -393,12 +433,28 @@ FcNameParse (const FcChar8 *name)
                        v = FcNameConvert (t->type, save, &m);
                        if (!FcPatternAdd (pat, t->object, v, FcTrue))
                        {
-                           if (v.type == FcTypeCharSet)
+                           switch (v.type) {
+                           case FcTypeCharSet:
                                FcCharSetDestroy ((FcCharSet *) v.u.c);
+                               break;
+                           case FcTypeLangSet:
+                               FcLangSetDestroy ((FcLangSet *) v.u.l);
+                               break;
+                           default:
+                               break;
+                           }
                            goto bail2;
                        }
-                       if (v.type == FcTypeCharSet)
+                       switch (v.type) {
+                       case FcTypeCharSet:
                            FcCharSetDestroy ((FcCharSet *) v.u.c);
+                           break;
+                       case FcTypeLangSet:
+                           FcLangSetDestroy ((FcLangSet *) v.u.l);
+                           break;
+                       default:
+                           break;
+                       }
                    }
                    if (delim != ',')
                        break;
@@ -470,10 +526,10 @@ FcNameUnparseValue (FcStrBuf      *buf,
        return FcNameUnparseString (buf, temp, 0);
     case FcTypeCharSet:
        return FcNameUnparseCharSet (buf, v.u.c);
+    case FcTypeLangSet:
+       return FcNameUnparseLangSet (buf, v.u.l);
     case FcTypeFTFace:
        return FcTrue;
-    case FcTypePattern:
-       return FcTrue;
     }
     return FcFalse;
 }