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     { FC_VARIABLE_OBJECT,          FcFalse      },
  43 };
  44
  45 #define NUM_FC_BOOL_DEFAULTS    (int) (sizeof FcBoolDefaults / sizeof FcBoolDefaults[0])
  46
  47 FcStrSet *default_langs;
  48
  49 FcStrSet *
  50 FcGetDefaultLangs (void)
  51 {
  52     FcStrSet *result;
  53 retry:
  54     result = (FcStrSet *) fc_atomic_ptr_get (&default_langs);
  55     if (!result)
  56     {
  57         char *langs;
  58
  59         result = FcStrSetCreate ();
  60
  61         langs = getenv ("FC_LANG");
  62         if (!langs || !langs[0])
  63             langs = getenv ("LC_ALL");
  64         if (!langs || !langs[0])
  65             langs = getenv ("LC_CTYPE");
  66         if (!langs || !langs[0])
  67             langs = getenv ("LANG");
  68         if (langs && langs[0])
  69         {
  70             if (!FcStrSetAddLangs (result, langs))
  71                 FcStrSetAdd (result, (const FcChar8 *) "en");
  72         }
  73         else
  74             FcStrSetAdd (result, (const FcChar8 *) "en");
  75
  76         FcRefSetConst (&result->ref);
  77         if (!fc_atomic_ptr_cmpexch (&default_langs, NULL, result)) {
  78             FcRefInit (&result->ref, 1);
  79             FcStrSetDestroy (result);
  80             goto retry;
  81         }
  82     }
  83
  84     return result;
  85 }
  86
  87 static FcChar8 *default_lang; /* MT-safe */
  88
  89 FcChar8 *
  90 FcGetDefaultLang (void)
  91 {
  92     FcChar8 *lang;
  93 retry:
  94     lang = fc_atomic_ptr_get (&default_lang);
  95     if (!lang)
  96     {
  97         FcStrSet *langs = FcGetDefaultLangs ();
  98         lang = FcStrdup (langs->strs[0]);
  99
 100         if (!fc_atomic_ptr_cmpexch (&default_lang, NULL, lang)) {
 101             free (lang);
 102             goto retry;
 103         }
 104     }
 105
 106     return lang;
 107 }
 108
 109 static FcChar8 *default_prgname;
 110
 111 FcChar8 *
 112 FcGetPrgname (void)
 113 {
 114     FcChar8 *prgname;
 115 retry:
 116     prgname = fc_atomic_ptr_get (&default_prgname);
 117     if (!prgname)
 118     {
 119 #ifdef _WIN32
 120         char buf[MAX_PATH+1];
 121
 122         /* TODO This is ASCII-only; fix it. */
 123         if (GetModuleFileNameA (GetModuleHandle (NULL), buf, sizeof (buf) / sizeof (buf[0])) > 0)
 124         {
 125             char *p;
 126             unsigned int len;
 127
 128             p = strrchr (buf, '\\');
 129             if (p)
 130                 p++;
 131             else
 132                 p = buf;
 133
 134             len = strlen (p);
 135
 136             if (len > 4 && 0 == strcmp (p + len - 4, ".exe"))
 137             {
 138                 len -= 4;
 139                 buf[len] = '\0';
 140             }
 141
 142             prgname = FcStrdup (p);
 143         }
 144 #elif defined (HAVE_GETPROGNAME)
 145         const char *q = getprogname ();
 146         if (q)
 147             prgname = FcStrdup (q);
 148         else
 149             prgname = FcStrdup ("");
 150 #else
 151 # if defined (HAVE_GETEXECNAME)
 152         char *p = FcStrdup(getexecname ());
 153 # elif defined (HAVE_READLINK)
 154         size_t size = FC_PATH_MAX;
 155         char *p = NULL;
 156
 157         while (1)
 158         {
 159             char *buf = malloc (size);
 160             ssize_t len;
 161
 162             if (!buf)
 163                 break;
 164
 165             len = readlink ("/proc/self/exe", buf, size - 1);
 166             if (len < 0)
 167             {
 168                 free (buf);
 169                 break;
 170             }
 171             if (len < size - 1)
 172             {
 173                 buf[len] = 0;
 174                 p = buf;
 175                 break;
 176             }
 177
 178             free (buf);
 179             size *= 2;
 180         }
 181 # else
 182         char *p = NULL;
 183 # endif
 184         if (p)
 185         {
 186             char *r = strrchr (p, '/');
 187             if (r)
 188                 r++;
 189             else
 190                 r = p;
 191
 192             prgname = FcStrdup (r);
 193         }
 194
 195         if (!prgname)
 196             prgname = FcStrdup ("");
 197
 198         if (p)
 199             free (p);
 200 #endif
 201
 202         if (!fc_atomic_ptr_cmpexch (&default_prgname, NULL, prgname)) {
 203             free (prgname);
 204             goto retry;
 205         }
 206     }
 207
 208     if (prgname && !prgname[0])
 209         return NULL;
 210
 211     return prgname;
 212 }
 213
 214 void
 215 FcDefaultFini (void)
 216 {
 217     FcChar8  *lang;
 218     FcStrSet *langs;
 219     FcChar8  *prgname;
 220
 221     lang = fc_atomic_ptr_get (&default_lang);
 222     if (lang && fc_atomic_ptr_cmpexch (&default_lang, lang, NULL)) {
 223         free (lang);
 224     }
 225
 226     langs = fc_atomic_ptr_get (&default_langs);
 227     if (langs && fc_atomic_ptr_cmpexch (&default_langs, langs, NULL)) {
 228         FcRefInit (&langs->ref, 1);
 229         FcStrSetDestroy (langs);
 230     }
 231
 232     prgname = fc_atomic_ptr_get (&default_prgname);
 233     if (prgname && fc_atomic_ptr_cmpexch (&default_prgname, prgname, NULL)) {
 234         free (prgname);
 235     }
 236 }
 237
 238 void
 239 FcDefaultSubstitute (FcPattern *pattern)
 240 {
 241     FcValue v, namelang, v2;
 242     int     i;
 243     double      dpi, size, scale, pixelsize;
 244
 245     if (FcPatternObjectGet (pattern, FC_WEIGHT_OBJECT, 0, &v) == FcResultNoMatch )
 246         FcPatternObjectAddInteger (pattern, FC_WEIGHT_OBJECT, FC_WEIGHT_NORMAL);
 247
 248     if (FcPatternObjectGet (pattern, FC_SLANT_OBJECT, 0, &v) == FcResultNoMatch)
 249         FcPatternObjectAddInteger (pattern, FC_SLANT_OBJECT, FC_SLANT_ROMAN);
 250
 251     if (FcPatternObjectGet (pattern, FC_WIDTH_OBJECT, 0, &v) == FcResultNoMatch)
 252         FcPatternObjectAddInteger (pattern, FC_WIDTH_OBJECT, FC_WIDTH_NORMAL);
 253
 254     for (i = 0; i < NUM_FC_BOOL_DEFAULTS; i++)
 255         if (FcPatternObjectGet (pattern, FcBoolDefaults[i].field, 0, &v) == FcResultNoMatch)
 256             FcPatternObjectAddBool (pattern, FcBoolDefaults[i].field, FcBoolDefaults[i].value);
 257
 258     if (FcPatternObjectGetDouble (pattern, FC_SIZE_OBJECT, 0, &size) != FcResultMatch)
 259     {
 260         FcRange *r;
 261         double b, e;
 262         if (FcPatternObjectGetRange (pattern, FC_SIZE_OBJECT, 0, &r) == FcResultMatch && FcRangeGetDouble (r, &b, &e))
 263             size = (b + e) * .5;
 264         else
 265             size = 12.0L;
 266     }
 267     if (FcPatternObjectGetDouble (pattern, FC_SCALE_OBJECT, 0, &scale) != FcResultMatch)
 268         scale = 1.0;
 269     if (FcPatternObjectGetDouble (pattern, FC_DPI_OBJECT, 0, &dpi) != FcResultMatch)
 270         dpi = 75.0;
 271
 272     if (FcPatternObjectGet (pattern, FC_PIXEL_SIZE_OBJECT, 0, &v) != FcResultMatch)
 273     {
 274         (void) FcPatternObjectDel (pattern, FC_SCALE_OBJECT);
 275         FcPatternObjectAddDouble (pattern, FC_SCALE_OBJECT, scale);
 276         pixelsize = size * scale;
 277         (void) FcPatternObjectDel (pattern, FC_DPI_OBJECT);
 278         FcPatternObjectAddDouble (pattern, FC_DPI_OBJECT, dpi);
 279         pixelsize *= dpi / 72.0;
 280         FcPatternObjectAddDouble (pattern, FC_PIXEL_SIZE_OBJECT, pixelsize);
 281     }
 282     else
 283     {
 284         size = v.u.d;
 285         size = size / dpi * 72.0 / scale;
 286     }
 287     (void) FcPatternObjectDel (pattern, FC_SIZE_OBJECT);
 288     FcPatternObjectAddDouble (pattern, FC_SIZE_OBJECT, size);
 289
 290     if (FcPatternObjectGet (pattern, FC_FONTVERSION_OBJECT, 0, &v) == FcResultNoMatch)
 291     {
 292         FcPatternObjectAddInteger (pattern, FC_FONTVERSION_OBJECT, 0x7fffffff);
 293     }
 294
 295     if (FcPatternObjectGet (pattern, FC_HINT_STYLE_OBJECT, 0, &v) == FcResultNoMatch)
 296     {
 297         FcPatternObjectAddInteger (pattern, FC_HINT_STYLE_OBJECT, FC_HINT_FULL);
 298     }
 299     if (FcPatternObjectGet (pattern, FC_NAMELANG_OBJECT, 0, &v) == FcResultNoMatch)
 300     {
 301         FcPatternObjectAddString (pattern, FC_NAMELANG_OBJECT, FcGetDefaultLang ());
 302     }
 303     /* shouldn't be failed. */
 304     FcPatternObjectGet (pattern, FC_NAMELANG_OBJECT, 0, &namelang);
 305     /* Add a fallback to ensure the english name when the requested language
 306      * isn't available. this would helps for the fonts that have non-English
 307      * name at the beginning.
 308      */
 309     /* Set "en-us" instead of "en" to avoid giving higher score to "en".
 310      * This is a hack for the case that the orth is not like ll-cc, because,
 311      * if no namelang isn't explicitly set, it will has something like ll-cc
 312      * according to current locale. which may causes FcLangDifferentTerritory
 313      * at FcLangCompare(). thus, the English name is selected so that
 314      * exact matched "en" has higher score than ll-cc.
 315      */
 316     v2.type = FcTypeString;
 317     v2.u.s = (FcChar8 *) "en-us";
 318     if (FcPatternObjectGet (pattern, FC_FAMILYLANG_OBJECT, 0, &v) == FcResultNoMatch)
 319     {
 320         FcPatternObjectAdd (pattern, FC_FAMILYLANG_OBJECT, namelang, FcTrue);
 321         FcPatternObjectAddWithBinding (pattern, FC_FAMILYLANG_OBJECT, v2, FcValueBindingWeak, FcTrue);
 322     }
 323     if (FcPatternObjectGet (pattern, FC_STYLELANG_OBJECT, 0, &v) == FcResultNoMatch)
 324     {
 325         FcPatternObjectAdd (pattern, FC_STYLELANG_OBJECT, namelang, FcTrue);
 326         FcPatternObjectAddWithBinding (pattern, FC_STYLELANG_OBJECT, v2, FcValueBindingWeak, FcTrue);
 327     }
 328     if (FcPatternObjectGet (pattern, FC_FULLNAMELANG_OBJECT, 0, &v) == FcResultNoMatch)
 329     {
 330         FcPatternObjectAdd (pattern, FC_FULLNAMELANG_OBJECT, namelang, FcTrue);
 331         FcPatternObjectAddWithBinding (pattern, FC_FULLNAMELANG_OBJECT, v2, FcValueBindingWeak, FcTrue);
 332     }
 333
 334     if (FcPatternObjectGet (pattern, FC_PRGNAME_OBJECT, 0, &v) == FcResultNoMatch)
 335     {
 336         FcChar8 *prgname = FcGetPrgname ();
 337         if (prgname)
 338             FcPatternObjectAddString (pattern, FC_PRGNAME_OBJECT, prgname);
 339     }
 340 }
 341 #define __fcdefault__
 342 #include "fcaliastail.h"
 343 #undef __fcdefault__