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 # 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
 223     if (FcPatternObjectGet (pattern, FC_WEIGHT_OBJECT, 0, &v) == FcResultNoMatch )
 224         FcPatternObjectAddInteger (pattern, FC_WEIGHT_OBJECT, FC_WEIGHT_NORMAL);
 225
 226     if (FcPatternObjectGet (pattern, FC_SLANT_OBJECT, 0, &v) == FcResultNoMatch)
 227         FcPatternObjectAddInteger (pattern, FC_SLANT_OBJECT, FC_SLANT_ROMAN);
 228
 229     if (FcPatternObjectGet (pattern, FC_WIDTH_OBJECT, 0, &v) == FcResultNoMatch)
 230         FcPatternObjectAddInteger (pattern, FC_WIDTH_OBJECT, FC_WIDTH_NORMAL);
 231
 232     for (i = 0; i < NUM_FC_BOOL_DEFAULTS; i++)
 233         if (FcPatternObjectGet (pattern, FcBoolDefaults[i].field, 0, &v) == FcResultNoMatch)
 234             FcPatternObjectAddBool (pattern, FcBoolDefaults[i].field, FcBoolDefaults[i].value);
 235
 236     if (FcPatternObjectGet (pattern, FC_PIXEL_SIZE_OBJECT, 0, &v) == FcResultNoMatch)
 237     {
 238         double  dpi, size, scale;
 239
 240         if (FcPatternObjectGetDouble (pattern, FC_SIZE_OBJECT, 0, &size) != FcResultMatch)
 241         {
 242             size = 12.0;
 243             (void) FcPatternObjectDel (pattern, FC_SIZE_OBJECT);
 244             FcPatternObjectAddDouble (pattern, FC_SIZE_OBJECT, size);
 245         }
 246         if (FcPatternObjectGetDouble (pattern, FC_SCALE_OBJECT, 0, &scale) != FcResultMatch)
 247         {
 248             scale = 1.0;
 249             (void) FcPatternObjectDel (pattern, FC_SCALE_OBJECT);
 250             FcPatternObjectAddDouble (pattern, FC_SCALE_OBJECT, scale);
 251         }
 252         size *= scale;
 253         if (FcPatternObjectGetDouble (pattern, FC_DPI_OBJECT, 0, &dpi) != FcResultMatch)
 254         {
 255             dpi = 75.0;
 256             (void) FcPatternObjectDel (pattern, FC_DPI_OBJECT);
 257             FcPatternObjectAddDouble (pattern, FC_DPI_OBJECT, dpi);
 258         }
 259         size *= dpi / 72.0;
 260         FcPatternObjectAddDouble (pattern, FC_PIXEL_SIZE_OBJECT, size);
 261     }
 262
 263     if (FcPatternObjectGet (pattern, FC_FONTVERSION_OBJECT, 0, &v) == FcResultNoMatch)
 264     {
 265         FcPatternObjectAddInteger (pattern, FC_FONTVERSION_OBJECT, 0x7fffffff);
 266     }
 267
 268     if (FcPatternObjectGet (pattern, FC_HINT_STYLE_OBJECT, 0, &v) == FcResultNoMatch)
 269     {
 270         FcPatternObjectAddInteger (pattern, FC_HINT_STYLE_OBJECT, FC_HINT_FULL);
 271     }
 272     if (FcPatternObjectGet (pattern, FC_NAMELANG_OBJECT, 0, &v) == FcResultNoMatch)
 273     {
 274         FcPatternObjectAddString (pattern, FC_NAMELANG_OBJECT, FcGetDefaultLang ());
 275     }
 276     /* shouldn't be failed. */
 277     FcPatternObjectGet (pattern, FC_NAMELANG_OBJECT, 0, &namelang);
 278     /* Add a fallback to ensure the english name when the requested language
 279      * isn't available. this would helps for the fonts that have non-English
 280      * name at the beginning.
 281      */
 282     /* Set "en-us" instead of "en" to avoid giving higher score to "en".
 283      * This is a hack for the case that the orth is not like ll-cc, because,
 284      * if no namelang isn't explicitly set, it will has something like ll-cc
 285      * according to current locale. which may causes FcLangDifferentTerritory
 286      * at FcLangCompare(). thus, the English name is selected so that
 287      * exact matched "en" has higher score than ll-cc.
 288      */
 289     v2.type = FcTypeString;
 290     v2.u.s = (FcChar8 *) "en-us";
 291     if (FcPatternObjectGet (pattern, FC_FAMILYLANG_OBJECT, 0, &v) == FcResultNoMatch)
 292     {
 293         FcPatternObjectAdd (pattern, FC_FAMILYLANG_OBJECT, namelang, FcTrue);
 294         FcPatternObjectAddWithBinding (pattern, FC_FAMILYLANG_OBJECT, v2, FcValueBindingWeak, FcTrue);
 295     }
 296     if (FcPatternObjectGet (pattern, FC_STYLELANG_OBJECT, 0, &v) == FcResultNoMatch)
 297     {
 298         FcPatternObjectAdd (pattern, FC_STYLELANG_OBJECT, namelang, FcTrue);
 299         FcPatternObjectAddWithBinding (pattern, FC_STYLELANG_OBJECT, v2, FcValueBindingWeak, FcTrue);
 300     }
 301     if (FcPatternObjectGet (pattern, FC_FULLNAMELANG_OBJECT, 0, &v) == FcResultNoMatch)
 302     {
 303         FcPatternObjectAdd (pattern, FC_FULLNAMELANG_OBJECT, namelang, FcTrue);
 304         FcPatternObjectAddWithBinding (pattern, FC_FULLNAMELANG_OBJECT, v2, FcValueBindingWeak, FcTrue);
 305     }
 306
 307     if (FcPatternObjectGet (pattern, FC_PRGNAME_OBJECT, 0, &v) == FcResultNoMatch)
 308     {
 309         FcChar8 *prgname = FcGetPrgname ();
 310         if (prgname)
 311             FcPatternObjectAddString (pattern, FC_PRGNAME_OBJECT, prgname);
 312     }
 313 }
 314 #define __fcdefault__
 315 #include "fcaliastail.h"
 316 #undef __fcdefault__