src/fcdefault.c

   1 /*
   2  * fontconfig/src/fcdefault.c
   3  *
   4  * Copyright © 2001 Keith Packard
   5  *
   6  * Permission to use, copy, modify, distribute, and sell this software and its
   7  * documentation for any purpose is hereby granted without fee, provided that
   8  * the above copyright notice appear in all copies and that both that
   9  * copyright notice and this permission notice appear in supporting
  10  * documentation, and that the name of the author(s) not be used in
  11  * advertising or publicity pertaining to distribution of the software without
  12  * specific, written prior permission.  The authors make no
  13  * representations about the suitability of this software for any purpose.  It
  14  * is provided "as is" without express or implied warranty.
  15  *
  16  * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  17  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  18  * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  19  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  20  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  21  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  22  * PERFORMANCE OF THIS SOFTWARE.
  23  */
  24
  25 #include "fcint.h"
  26 #include <limits.h>
  27 #include <string.h>
  28
  29 /* MT-safe */
  30
  31 static const struct {
  32     FcObject    field;
  33     FcBool      value;
  34 } FcBoolDefaults[] = {
  35     { FC_HINTING_OBJECT,           FcTrue       },  /* !FT_LOAD_NO_HINTING */
  36     { FC_VERTICAL_LAYOUT_OBJECT,   FcFalse      },  /* FC_LOAD_VERTICAL_LAYOUT */
  37     { FC_AUTOHINT_OBJECT,          FcFalse      },  /* FC_LOAD_FORCE_AUTOHINT */
  38     { FC_GLOBAL_ADVANCE_OBJECT,    FcTrue       },  /* !FC_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH */
  39     { FC_EMBEDDED_BITMAP_OBJECT,   FcTrue       },  /* !FC_LOAD_NO_BITMAP */
  40     { FC_DECORATIVE_OBJECT,        FcFalse      },
  41     { FC_SYMBOL_OBJECT,            FcFalse      },
  42 };
  43
  44 #define NUM_FC_BOOL_DEFAULTS    (int) (sizeof FcBoolDefaults / sizeof FcBoolDefaults[0])
  45
  46 FcStrSet *default_langs;
  47
  48 FcStrSet *
  49 FcGetDefaultLangs (void)
  50 {
  51     FcStrSet *result;
  52 retry:
  53     result = (FcStrSet *) fc_atomic_ptr_get (&default_langs);
  54     if (!result)
  55     {
  56         char *langs;
  57
  58         result = FcStrSetCreate ();
  59
  60         langs = getenv ("FC_LANG");
  61         if (!langs || !langs[0])
  62             langs = getenv ("LC_ALL");
  63         if (!langs || !langs[0])
  64             langs = getenv ("LC_CTYPE");
  65         if (!langs || !langs[0])
  66             langs = getenv ("LANG");
  67         if (langs && langs[0])
  68         {
  69             if (!FcStrSetAddLangs (result, langs))
  70                 FcStrSetAdd (result, (const FcChar8 *) "en");
  71         }
  72         else
  73             FcStrSetAdd (result, (const FcChar8 *) "en");
  74
  75         FcRefSetConst (&result->ref);
  76         if (!fc_atomic_ptr_cmpexch (&default_langs, NULL, result)) {
  77             FcRefInit (&result->ref, 1);
  78             FcStrSetDestroy (result);
  79             goto retry;
  80         }
  81     }
  82
  83     return result;
  84 }
  85
  86 static FcChar8 *default_lang; /* MT-safe */
  87
  88 FcChar8 *
  89 FcGetDefaultLang (void)
  90 {
  91     FcChar8 *lang;
  92 retry:
  93     lang = fc_atomic_ptr_get (&default_lang);
  94     if (!lang)
  95     {
  96         FcStrSet *langs = FcGetDefaultLangs ();
  97         lang = FcStrdup (langs->strs[0]);
  98
  99         if (!fc_atomic_ptr_cmpexch (&default_lang, NULL, lang)) {
 100             free (lang);
 101             goto retry;
 102         }
 103     }
 104
 105     return lang;
 106 }
 107
 108 static FcChar8 *default_prgname;
 109
 110 FcChar8 *
 111 FcGetPrgname (void)
 112 {
 113     FcChar8 *prgname;
 114 retry:
 115     prgname = fc_atomic_ptr_get (&default_prgname);
 116     if (!prgname)
 117     {
 118 #ifdef _WIN32
 119         char buf[MAX_PATH+1];
 120
 121         /* TODO This is ASCII-only; fix it. */
 122         if (GetModuleFileNameA (GetModuleHandle (NULL), buf, sizeof (buf) / sizeof (buf[0])) > 0)
 123         {
 124             char *p;
 125             unsigned int len;
 126
 127             p = strrchr (buf, '\\');
 128             if (p)
 129                 p++;
 130             else
 131                 p = buf;
 132
 133             len = strlen (p);
 134
 135             if (len > 4 && 0 == strcmp (p + len - 4, ".exe"))
 136             {
 137                 len -= 4;
 138                 buf[len] = '\0';
 139             }
 140
 141             prgname = FcStrdup (p);
 142         }
 143 #elif defined (HAVE_GETPROGNAME)
 144         const char *q = getprogname ();
 145         if (q)
 146             prgname = FcStrdup (q);
 147         else
 148             prgname = FcStrdup ("");
 149 #else
 150 # if defined (HAVE_GETEXECNAME)
 151         const char *p = getexecname ();
 152 # elif defined (HAVE_READLINK)
 153         char buf[PATH_MAX + 1];
 154         int len;
 155         char *p = NULL;
 156
 157         len = readlink ("/proc/self/exe", buf, sizeof (buf) - 1);
 158         if (len != -1)
 159         {
 160             buf[len] = '\0';
 161             p = buf;
 162         }
 163 # else
 164         char *p = NULL;
 165 # endif
 166         if (p)
 167         {
 168             char *r = strrchr (p, '/');
 169             if (r)
 170                 r++;
 171             else
 172                 r = p;
 173
 174             prgname = FcStrdup (r);
 175         }
 176
 177         if (!prgname)
 178             prgname = FcStrdup ("");
 179 #endif
 180
 181         if (!fc_atomic_ptr_cmpexch (&default_prgname, NULL, prgname)) {
 182             free (prgname);
 183             goto retry;
 184         }
 185     }
 186
 187     if (prgname && !prgname[0])
 188         return NULL;
 189
 190     return prgname;
 191 }
 192
 193 void
 194 FcDefaultFini (void)
 195 {
 196     FcChar8  *lang;
 197     FcStrSet *langs;
 198     FcChar8  *prgname;
 199
 200     lang = fc_atomic_ptr_get (&default_lang);
 201     if (lang && fc_atomic_ptr_cmpexch (&default_lang, lang, NULL)) {
 202         free (lang);
 203     }
 204
 205     langs = fc_atomic_ptr_get (&default_langs);
 206     if (langs && fc_atomic_ptr_cmpexch (&default_langs, langs, NULL)) {
 207         FcRefInit (&langs->ref, 1);
 208         FcStrSetDestroy (langs);
 209     }
 210
 211     prgname = fc_atomic_ptr_get (&default_prgname);
 212     if (prgname && fc_atomic_ptr_cmpexch (&default_prgname, prgname, NULL)) {
 213         free (prgname);
 214     }
 215 }
 216
 217 void
 218 FcDefaultSubstitute (FcPattern *pattern)
 219 {
 220     FcValue v, namelang, v2;
 221     int     i;
 222     double      dpi, size, scale, pixelsize;
 223
 224     if (FcPatternObjectGet (pattern, FC_WEIGHT_OBJECT, 0, &v) == FcResultNoMatch )
 225         FcPatternObjectAddInteger (pattern, FC_WEIGHT_OBJECT, FC_WEIGHT_NORMAL);
 226
 227     if (FcPatternObjectGet (pattern, FC_SLANT_OBJECT, 0, &v) == FcResultNoMatch)
 228         FcPatternObjectAddInteger (pattern, FC_SLANT_OBJECT, FC_SLANT_ROMAN);
 229
 230     if (FcPatternObjectGet (pattern, FC_WIDTH_OBJECT, 0, &v) == FcResultNoMatch)
 231         FcPatternObjectAddInteger (pattern, FC_WIDTH_OBJECT, FC_WIDTH_NORMAL);
 232
 233     for (i = 0; i < NUM_FC_BOOL_DEFAULTS; i++)
 234         if (FcPatternObjectGet (pattern, FcBoolDefaults[i].field, 0, &v) == FcResultNoMatch)
 235             FcPatternObjectAddBool (pattern, FcBoolDefaults[i].field, FcBoolDefaults[i].value);
 236
 237     if (FcPatternObjectGetDouble (pattern, FC_SIZE_OBJECT, 0, &size) != FcResultMatch)
 238         size = 12.0L;
 239     if (FcPatternObjectGetDouble (pattern, FC_SCALE_OBJECT, 0, &scale) != FcResultMatch)
 240         scale = 1.0;
 241     if (FcPatternObjectGetDouble (pattern, FC_DPI_OBJECT, 0, &dpi) != FcResultMatch)
 242         dpi = 75.0;
 243
 244     if (FcPatternObjectGet (pattern, FC_PIXEL_SIZE_OBJECT, 0, &v) != FcResultMatch)
 245     {
 246         (void) FcPatternObjectDel (pattern, FC_SCALE_OBJECT);
 247         FcPatternObjectAddDouble (pattern, FC_SCALE_OBJECT, scale);
 248         pixelsize = size * scale;
 249         (void) FcPatternObjectDel (pattern, FC_DPI_OBJECT);
 250         FcPatternObjectAddDouble (pattern, FC_DPI_OBJECT, dpi);
 251         pixelsize *= dpi / 72.0;
 252         FcPatternObjectAddDouble (pattern, FC_PIXEL_SIZE_OBJECT, pixelsize);
 253     }
 254     else
 255     {
 256         size = v.u.d;
 257         size = size / dpi * 72.0 / scale;
 258     }
 259     (void) FcPatternObjectDel (pattern, FC_SIZE_OBJECT);
 260     FcPatternObjectAddDouble (pattern, FC_SIZE_OBJECT, size);
 261
 262     if (FcPatternObjectGet (pattern, FC_FONTVERSION_OBJECT, 0, &v) == FcResultNoMatch)
 263     {
 264         FcPatternObjectAddInteger (pattern, FC_FONTVERSION_OBJECT, 0x7fffffff);
 265     }
 266
 267     if (FcPatternObjectGet (pattern, FC_HINT_STYLE_OBJECT, 0, &v) == FcResultNoMatch)
 268     {
 269         FcPatternObjectAddInteger (pattern, FC_HINT_STYLE_OBJECT, FC_HINT_FULL);
 270     }
 271     if (FcPatternObjectGet (pattern, FC_NAMELANG_OBJECT, 0, &v) == FcResultNoMatch)
 272     {
 273         FcPatternObjectAddString (pattern, FC_NAMELANG_OBJECT, FcGetDefaultLang ());
 274     }
 275     /* shouldn't be failed. */
 276     FcPatternObjectGet (pattern, FC_NAMELANG_OBJECT, 0, &namelang);
 277     /* Add a fallback to ensure the english name when the requested language
 278      * isn't available. this would helps for the fonts that have non-English
 279      * name at the beginning.
 280      */
 281     /* Set "en-us" instead of "en" to avoid giving higher score to "en".
 282      * This is a hack for the case that the orth is not like ll-cc, because,
 283      * if no namelang isn't explicitly set, it will has something like ll-cc
 284      * according to current locale. which may causes FcLangDifferentTerritory
 285      * at FcLangCompare(). thus, the English name is selected so that
 286      * exact matched "en" has higher score than ll-cc.
 287      */
 288     v2.type = FcTypeString;
 289     v2.u.s = (FcChar8 *) "en-us";
 290     if (FcPatternObjectGet (pattern, FC_FAMILYLANG_OBJECT, 0, &v) == FcResultNoMatch)
 291     {
 292         FcPatternObjectAdd (pattern, FC_FAMILYLANG_OBJECT, namelang, FcTrue);
 293         FcPatternObjectAddWithBinding (pattern, FC_FAMILYLANG_OBJECT, v2, FcValueBindingWeak, FcTrue);
 294     }
 295     if (FcPatternObjectGet (pattern, FC_STYLELANG_OBJECT, 0, &v) == FcResultNoMatch)
 296     {
 297         FcPatternObjectAdd (pattern, FC_STYLELANG_OBJECT, namelang, FcTrue);
 298         FcPatternObjectAddWithBinding (pattern, FC_STYLELANG_OBJECT, v2, FcValueBindingWeak, FcTrue);
 299     }
 300     if (FcPatternObjectGet (pattern, FC_FULLNAMELANG_OBJECT, 0, &v) == FcResultNoMatch)
 301     {
 302         FcPatternObjectAdd (pattern, FC_FULLNAMELANG_OBJECT, namelang, FcTrue);
 303         FcPatternObjectAddWithBinding (pattern, FC_FULLNAMELANG_OBJECT, v2, FcValueBindingWeak, FcTrue);
 304     }
 305
 306     if (FcPatternObjectGet (pattern, FC_PRGNAME_OBJECT, 0, &v) == FcResultNoMatch)
 307     {
 308         FcChar8 *prgname = FcGetPrgname ();
 309         if (prgname)
 310             FcPatternObjectAddString (pattern, FC_PRGNAME_OBJECT, prgname);
 311     }
 312 }
 313 #define __fcdefault__
 314 #include "fcaliastail.h"
 315 #undef __fcdefault__