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         char buf[PATH_MAX + 1];
 151         int len;
 152         char *p = NULL;
 153
 154         len = readlink ("/proc/self/exe", buf, sizeof (buf) - 1);
 155         if (len != -1)
 156         {
 157             buf[len] = '\0';
 158             p = buf;
 159         }
 160
 161         if (p)
 162         {
 163             char *r = strrchr (p, '/');
 164             if (r)
 165                 r++;
 166             else
 167                 r = p;
 168
 169             prgname = FcStrdup (r);
 170         }
 171
 172         if (!prgname)
 173             prgname = FcStrdup ("");
 174 #endif
 175
 176         if (!fc_atomic_ptr_cmpexch (&default_prgname, NULL, prgname)) {
 177             free (prgname);
 178             goto retry;
 179         }
 180     }
 181
 182     if (prgname && !prgname[0])
 183         return NULL;
 184
 185     return prgname;
 186 }
 187
 188 void
 189 FcDefaultFini (void)
 190 {
 191     FcChar8  *lang;
 192     FcStrSet *langs;
 193     FcChar8  *prgname;
 194
 195     lang = fc_atomic_ptr_get (&default_lang);
 196     if (lang && fc_atomic_ptr_cmpexch (&default_lang, lang, NULL)) {
 197         free (lang);
 198     }
 199
 200     langs = fc_atomic_ptr_get (&default_langs);
 201     if (langs && fc_atomic_ptr_cmpexch (&default_langs, langs, NULL)) {
 202         FcRefInit (&langs->ref, 1);
 203         FcStrSetDestroy (langs);
 204     }
 205
 206     prgname = fc_atomic_ptr_get (&default_prgname);
 207     if (prgname && fc_atomic_ptr_cmpexch (&default_prgname, prgname, NULL)) {
 208         free (prgname);
 209     }
 210 }
 211
 212 void
 213 FcDefaultSubstitute (FcPattern *pattern)
 214 {
 215     FcValue v, namelang, v2;
 216     int     i;
 217
 218     if (FcPatternObjectGet (pattern, FC_WEIGHT_OBJECT, 0, &v) == FcResultNoMatch )
 219         FcPatternObjectAddInteger (pattern, FC_WEIGHT_OBJECT, FC_WEIGHT_MEDIUM);
 220
 221     if (FcPatternObjectGet (pattern, FC_SLANT_OBJECT, 0, &v) == FcResultNoMatch)
 222         FcPatternObjectAddInteger (pattern, FC_SLANT_OBJECT, FC_SLANT_ROMAN);
 223
 224     if (FcPatternObjectGet (pattern, FC_WIDTH_OBJECT, 0, &v) == FcResultNoMatch)
 225         FcPatternObjectAddInteger (pattern, FC_WIDTH_OBJECT, FC_WIDTH_NORMAL);
 226
 227     for (i = 0; i < NUM_FC_BOOL_DEFAULTS; i++)
 228         if (FcPatternObjectGet (pattern, FcBoolDefaults[i].field, 0, &v) == FcResultNoMatch)
 229             FcPatternObjectAddBool (pattern, FcBoolDefaults[i].field, FcBoolDefaults[i].value);
 230
 231     if (FcPatternObjectGet (pattern, FC_PIXEL_SIZE_OBJECT, 0, &v) == FcResultNoMatch)
 232     {
 233         double  dpi, size, scale;
 234
 235         if (FcPatternObjectGetDouble (pattern, FC_SIZE_OBJECT, 0, &size) != FcResultMatch)
 236         {
 237             size = 12.0;
 238             (void) FcPatternObjectDel (pattern, FC_SIZE_OBJECT);
 239             FcPatternObjectAddDouble (pattern, FC_SIZE_OBJECT, size);
 240         }
 241         if (FcPatternObjectGetDouble (pattern, FC_SCALE_OBJECT, 0, &scale) != FcResultMatch)
 242         {
 243             scale = 1.0;
 244             (void) FcPatternObjectDel (pattern, FC_SCALE_OBJECT);
 245             FcPatternObjectAddDouble (pattern, FC_SCALE_OBJECT, scale);
 246         }
 247         size *= scale;
 248         if (FcPatternObjectGetDouble (pattern, FC_DPI_OBJECT, 0, &dpi) != FcResultMatch)
 249         {
 250             dpi = 75.0;
 251             (void) FcPatternObjectDel (pattern, FC_DPI_OBJECT);
 252             FcPatternObjectAddDouble (pattern, FC_DPI_OBJECT, dpi);
 253         }
 254         size *= dpi / 72.0;
 255         FcPatternObjectAddDouble (pattern, FC_PIXEL_SIZE_OBJECT, size);
 256     }
 257
 258     if (FcPatternObjectGet (pattern, FC_FONTVERSION_OBJECT, 0, &v) == FcResultNoMatch)
 259     {
 260         FcPatternObjectAddInteger (pattern, FC_FONTVERSION_OBJECT, 0x7fffffff);
 261     }
 262
 263     if (FcPatternObjectGet (pattern, FC_HINT_STYLE_OBJECT, 0, &v) == FcResultNoMatch)
 264     {
 265         FcPatternObjectAddInteger (pattern, FC_HINT_STYLE_OBJECT, FC_HINT_FULL);
 266     }
 267     if (FcPatternObjectGet (pattern, FC_NAMELANG_OBJECT, 0, &v) == FcResultNoMatch)
 268     {
 269         FcPatternObjectAddString (pattern, FC_NAMELANG_OBJECT, FcGetDefaultLang ());
 270     }
 271     /* shouldn't be failed. */
 272     FcPatternObjectGet (pattern, FC_NAMELANG_OBJECT, 0, &namelang);
 273     /* Add a fallback to ensure the english name when the requested language
 274      * isn't available. this would helps for the fonts that have non-English
 275      * name at the beginning.
 276      */
 277     /* Set "en-us" instead of "en" to avoid giving higher score to "en".
 278      * This is a hack for the case that the orth is not like ll-cc, because,
 279      * if no namelang isn't explicitly set, it will has something like ll-cc
 280      * according to current locale. which may causes FcLangDifferentTerritory
 281      * at FcLangCompare(). thus, the English name is selected so that
 282      * exact matched "en" has higher score than ll-cc.
 283      */
 284     v2.type = FcTypeString;
 285     v2.u.s = (FcChar8 *) "en-us";
 286     if (FcPatternObjectGet (pattern, FC_FAMILYLANG_OBJECT, 0, &v) == FcResultNoMatch)
 287     {
 288         FcPatternObjectAdd (pattern, FC_FAMILYLANG_OBJECT, namelang, FcTrue);
 289         FcPatternObjectAddWithBinding (pattern, FC_FAMILYLANG_OBJECT, v2, FcValueBindingWeak, FcTrue);
 290     }
 291     if (FcPatternObjectGet (pattern, FC_STYLELANG_OBJECT, 0, &v) == FcResultNoMatch)
 292     {
 293         FcPatternObjectAdd (pattern, FC_STYLELANG_OBJECT, namelang, FcTrue);
 294         FcPatternObjectAddWithBinding (pattern, FC_STYLELANG_OBJECT, v2, FcValueBindingWeak, FcTrue);
 295     }
 296     if (FcPatternObjectGet (pattern, FC_FULLNAMELANG_OBJECT, 0, &v) == FcResultNoMatch)
 297     {
 298         FcPatternObjectAdd (pattern, FC_FULLNAMELANG_OBJECT, namelang, FcTrue);
 299         FcPatternObjectAddWithBinding (pattern, FC_FULLNAMELANG_OBJECT, v2, FcValueBindingWeak, FcTrue);
 300     }
 301
 302     if (FcPatternObjectGet (pattern, FC_PRGNAME_OBJECT, 0, &v) == FcResultNoMatch)
 303     {
 304         FcChar8 *prgname = FcGetPrgname ();
 305         if (prgname)
 306             FcPatternObjectAddString (pattern, FC_PRGNAME_OBJECT, prgname);
 307     }
 308 }
 309 #define __fcdefault__
 310 #include "fcaliastail.h"
 311 #undef __fcdefault__