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 };
  42
  43 #define NUM_FC_BOOL_DEFAULTS    (int) (sizeof FcBoolDefaults / sizeof FcBoolDefaults[0])
  44
  45 FcStrSet *default_langs;
  46
  47 FcStrSet *
  48 FcGetDefaultLangs (void)
  49 {
  50     FcStrSet *result;
  51 retry:
  52     result = (FcStrSet *) fc_atomic_ptr_get (&default_langs);
  53     if (!result)
  54     {
  55         char *langs;
  56
  57         result = FcStrSetCreate ();
  58
  59         langs = getenv ("FC_LANG");
  60         if (!langs || !langs[0])
  61             langs = getenv ("LC_ALL");
  62         if (!langs || !langs[0])
  63             langs = getenv ("LC_CTYPE");
  64         if (!langs || !langs[0])
  65             langs = getenv ("LANG");
  66         if (langs && langs[0])
  67         {
  68             if (!FcStrSetAddLangs (result, langs))
  69                 FcStrSetAdd (result, (const FcChar8 *) "en");
  70         }
  71         else
  72             FcStrSetAdd (result, (const FcChar8 *) "en");
  73
  74         FcRefSetConst (&result->ref);
  75         if (!fc_atomic_ptr_cmpexch (&default_langs, NULL, result)) {
  76             FcRefInit (&result->ref, 1);
  77             FcStrSetDestroy (result);
  78             goto retry;
  79         }
  80     }
  81
  82     return result;
  83 }
  84
  85 static FcChar8 *default_lang; /* MT-safe */
  86
  87 FcChar8 *
  88 FcGetDefaultLang (void)
  89 {
  90     FcChar8 *lang;
  91 retry:
  92     lang = fc_atomic_ptr_get (&default_lang);
  93     if (!lang)
  94     {
  95         FcStrSet *langs = FcGetDefaultLangs ();
  96         lang = FcStrdup (langs->strs[0]);
  97         FcStrSetDestroy (langs);
  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 # else
 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 # endif
 164         if (p)
 165         {
 166             char *r = strrchr (p, '/');
 167             if (r)
 168                 r++;
 169             else
 170                 r = p;
 171
 172             prgname = FcStrdup (r);
 173         }
 174
 175         if (!prgname)
 176             prgname = FcStrdup ("");
 177 #endif
 178
 179         if (!fc_atomic_ptr_cmpexch (&default_prgname, NULL, prgname)) {
 180             free (prgname);
 181             goto retry;
 182         }
 183     }
 184
 185     if (prgname && !prgname[0])
 186         return NULL;
 187
 188     return prgname;
 189 }
 190
 191 void
 192 FcDefaultFini (void)
 193 {
 194     FcChar8  *lang;
 195     FcStrSet *langs;
 196     FcChar8  *prgname;
 197
 198     lang = fc_atomic_ptr_get (&default_lang);
 199     if (lang && fc_atomic_ptr_cmpexch (&default_lang, lang, NULL)) {
 200         free (lang);
 201     }
 202
 203     langs = fc_atomic_ptr_get (&default_langs);
 204     if (langs && fc_atomic_ptr_cmpexch (&default_langs, langs, NULL)) {
 205         FcRefInit (&langs->ref, 1);
 206         FcStrSetDestroy (langs);
 207     }
 208
 209     prgname = fc_atomic_ptr_get (&default_prgname);
 210     if (prgname && fc_atomic_ptr_cmpexch (&default_prgname, prgname, NULL)) {
 211         free (prgname);
 212     }
 213 }
 214
 215 void
 216 FcDefaultSubstitute (FcPattern *pattern)
 217 {
 218     FcValue v, namelang, v2;
 219     int     i;
 220
 221     if (FcPatternObjectGet (pattern, FC_WEIGHT_OBJECT, 0, &v) == FcResultNoMatch )
 222         FcPatternObjectAddInteger (pattern, FC_WEIGHT_OBJECT, FC_WEIGHT_NORMAL);
 223
 224     if (FcPatternObjectGet (pattern, FC_SLANT_OBJECT, 0, &v) == FcResultNoMatch)
 225         FcPatternObjectAddInteger (pattern, FC_SLANT_OBJECT, FC_SLANT_ROMAN);
 226
 227     if (FcPatternObjectGet (pattern, FC_WIDTH_OBJECT, 0, &v) == FcResultNoMatch)
 228         FcPatternObjectAddInteger (pattern, FC_WIDTH_OBJECT, FC_WIDTH_NORMAL);
 229
 230     for (i = 0; i < NUM_FC_BOOL_DEFAULTS; i++)
 231         if (FcPatternObjectGet (pattern, FcBoolDefaults[i].field, 0, &v) == FcResultNoMatch)
 232             FcPatternObjectAddBool (pattern, FcBoolDefaults[i].field, FcBoolDefaults[i].value);
 233
 234     if (FcPatternObjectGet (pattern, FC_PIXEL_SIZE_OBJECT, 0, &v) == FcResultNoMatch)
 235     {
 236         double  dpi, size, scale;
 237
 238         if (FcPatternObjectGetDouble (pattern, FC_SIZE_OBJECT, 0, &size) != FcResultMatch)
 239         {
 240             size = 12.0;
 241             (void) FcPatternObjectDel (pattern, FC_SIZE_OBJECT);
 242             FcPatternObjectAddDouble (pattern, FC_SIZE_OBJECT, size);
 243         }
 244         if (FcPatternObjectGetDouble (pattern, FC_SCALE_OBJECT, 0, &scale) != FcResultMatch)
 245         {
 246             scale = 1.0;
 247             (void) FcPatternObjectDel (pattern, FC_SCALE_OBJECT);
 248             FcPatternObjectAddDouble (pattern, FC_SCALE_OBJECT, scale);
 249         }
 250         size *= scale;
 251         if (FcPatternObjectGetDouble (pattern, FC_DPI_OBJECT, 0, &dpi) != FcResultMatch)
 252         {
 253             dpi = 75.0;
 254             (void) FcPatternObjectDel (pattern, FC_DPI_OBJECT);
 255             FcPatternObjectAddDouble (pattern, FC_DPI_OBJECT, dpi);
 256         }
 257         size *= dpi / 72.0;
 258         FcPatternObjectAddDouble (pattern, FC_PIXEL_SIZE_OBJECT, size);
 259     }
 260
 261     if (FcPatternObjectGet (pattern, FC_FONTVERSION_OBJECT, 0, &v) == FcResultNoMatch)
 262     {
 263         FcPatternObjectAddInteger (pattern, FC_FONTVERSION_OBJECT, 0x7fffffff);
 264     }
 265
 266     if (FcPatternObjectGet (pattern, FC_HINT_STYLE_OBJECT, 0, &v) == FcResultNoMatch)
 267     {
 268         FcPatternObjectAddInteger (pattern, FC_HINT_STYLE_OBJECT, FC_HINT_FULL);
 269     }
 270     if (FcPatternObjectGet (pattern, FC_NAMELANG_OBJECT, 0, &v) == FcResultNoMatch)
 271     {
 272         FcPatternObjectAddString (pattern, FC_NAMELANG_OBJECT, FcGetDefaultLang ());
 273     }
 274     /* shouldn't be failed. */
 275     FcPatternObjectGet (pattern, FC_NAMELANG_OBJECT, 0, &namelang);
 276     /* Add a fallback to ensure the english name when the requested language
 277      * isn't available. this would helps for the fonts that have non-English
 278      * name at the beginning.
 279      */
 280     /* Set "en-us" instead of "en" to avoid giving higher score to "en".
 281      * This is a hack for the case that the orth is not like ll-cc, because,
 282      * if no namelang isn't explicitly set, it will has something like ll-cc
 283      * according to current locale. which may causes FcLangDifferentTerritory
 284      * at FcLangCompare(). thus, the English name is selected so that
 285      * exact matched "en" has higher score than ll-cc.
 286      */
 287     v2.type = FcTypeString;
 288     v2.u.s = (FcChar8 *) "en-us";
 289     if (FcPatternObjectGet (pattern, FC_FAMILYLANG_OBJECT, 0, &v) == FcResultNoMatch)
 290     {
 291         FcPatternObjectAdd (pattern, FC_FAMILYLANG_OBJECT, namelang, FcTrue);
 292         FcPatternObjectAddWithBinding (pattern, FC_FAMILYLANG_OBJECT, v2, FcValueBindingWeak, FcTrue);
 293     }
 294     if (FcPatternObjectGet (pattern, FC_STYLELANG_OBJECT, 0, &v) == FcResultNoMatch)
 295     {
 296         FcPatternObjectAdd (pattern, FC_STYLELANG_OBJECT, namelang, FcTrue);
 297         FcPatternObjectAddWithBinding (pattern, FC_STYLELANG_OBJECT, v2, FcValueBindingWeak, FcTrue);
 298     }
 299     if (FcPatternObjectGet (pattern, FC_FULLNAMELANG_OBJECT, 0, &v) == FcResultNoMatch)
 300     {
 301         FcPatternObjectAdd (pattern, FC_FULLNAMELANG_OBJECT, namelang, FcTrue);
 302         FcPatternObjectAddWithBinding (pattern, FC_FULLNAMELANG_OBJECT, v2, FcValueBindingWeak, FcTrue);
 303     }
 304
 305     if (FcPatternObjectGet (pattern, FC_PRGNAME_OBJECT, 0, &v) == FcResultNoMatch)
 306     {
 307         FcChar8 *prgname = FcGetPrgname ();
 308         if (prgname)
 309             FcPatternObjectAddString (pattern, FC_PRGNAME_OBJECT, prgname);
 310     }
 311 }
 312 #define __fcdefault__
 313 #include "fcaliastail.h"
 314 #undef __fcdefault__