path: root/src/fcdefault.c

/*
 * fontconfig/src/fcdefault.c
 *
 * Copyright © 2001 Keith Packard
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of the author(s) not be used in
 * advertising or publicity pertaining to distribution of the software without
 * specific, written prior permission.  The authors make no
 * representations about the suitability of this software for any purpose.  It
 * is provided "as is" without express or implied warranty.
 *
 * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

#include "fcint.h"
#include <limits.h>
#include <string.h>
#ifdef ENABLE_LIBLANGTAG
#include <liblangtag/langtag.h>
#endif

/* MT-safe */

static const struct {
    FcObject	field;
    FcBool	value;
} FcBoolDefaults[] = {
    { FC_HINTING_OBJECT,	   FcTrue	},  /* !FT_LOAD_NO_HINTING */
    { FC_VERTICAL_LAYOUT_OBJECT,   FcFalse	},  /* FC_LOAD_VERTICAL_LAYOUT */
    { FC_AUTOHINT_OBJECT,	   FcFalse	},  /* FC_LOAD_FORCE_AUTOHINT */
    { FC_GLOBAL_ADVANCE_OBJECT,    FcTrue	},  /* !FC_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH */
    { FC_EMBEDDED_BITMAP_OBJECT,   FcTrue 	},  /* !FC_LOAD_NO_BITMAP */
    { FC_DECORATIVE_OBJECT,	   FcFalse	},
    { FC_SYMBOL_OBJECT,		   FcFalse	},
    { FC_VARIABLE_OBJECT,	   FcFalse	},
};

#define NUM_FC_BOOL_DEFAULTS	(int) (sizeof FcBoolDefaults / sizeof FcBoolDefaults[0])

#ifdef ENABLE_LIBLANGTAG
FcPtrSet *default_langtags;
lt_tag_t *default_langtag;

static int
_tagcmp(const void *a, const void *b)
{
    return !lt_tag_compare (a, b);
}

FcPtrSet *
FcGetDefaultLangtags (void)
{
    FcPtrSet *result;

retry:
    result = (FcPtrSet *) fc_atomic_ptr_get (&default_langtags);
    if (!result)
    {
	char *langs;
	static char *posix = "POSIX";
	const char *p, *next;
	char *s = NULL;
	size_t len;
	lt_tag_t *tag = NULL;
	lt_error_t *error = NULL;

	result = FcPtrSetCreate ((FcPtrSetDestroyFunc) lt_tag_unref, _tagcmp);

	langs = getenv ("FC_LANG");
	if (!langs || !langs[0])
	    langs = getenv ("LC_ALL");
	if (!langs || !langs[0])
	    langs = getenv ("LC_CTYPE");
	if (!langs || !langs[0])
	    langs = getenv ("LANG");
	if (!langs || !langs[0])
	    langs = posix;

	p = langs;
	while ((next = strchr (p, ':')))
	{
	    len = next - p;
	    s = malloc (sizeof (char) * (len + 1));
	    if (!s)
		goto bail0;
	    memcpy (s, p, len);
	    s[len] = 0;
	    if (*s)
	    {
		if (strchr (s, '@') || strchr (s, '_') || !strchr(s, '-'))
		{
		    /* it may follows usual locale syntax */
		    tag = lt_tag_convert_from_locale_string (s, &error);
		    if (!tag)
		    {
			/* fallback to langtag */
			goto parse_tag;
		    }
		}
		else
		{
		parse_tag:
		    tag = lt_tag_new ();
		    if (!lt_tag_parse (tag, s, &error))
		    {
			lt_tag_unref (tag);
			goto bail;
		    }
		}
		if (!FcPtrSetAdd (result, tag))
		    goto bail;
	    }
	    free (s);
	}
	if (*p)
	{
	    if (strchr (p, '@') || strchr (p, '_') || !strchr(p, '-'))
	    {
		/* it may follows usual locale syntax */
		tag = lt_tag_convert_from_locale_string (p, &error);
		if (!tag)
		{
		    /* fallback to langtag */
		    goto parse_tag2;
		}
	    }
	    else
	    {
	    parse_tag2:
		tag = lt_tag_new ();
		if (!lt_tag_parse (tag, p, &error))
		{
		    lt_tag_unref (tag);
		    goto bail;
		}
	    }
	    if (!FcPtrSetAdd (result, tag))
		goto bail;
	}
    bail:
	if (lt_error_is_set (error, LT_ERR_ANY))
	{
	    lt_error_unref (error);
	bail0:
	    FcPtrSetDestroy (result);
	    result = NULL;
	}
	else
	{
	    FcPtrSetConst (result);
	    if (!fc_atomic_ptr_cmpexch (&default_langtags, NULL, result))
	    {
		FcPtrSetRefReset (result);
		FcPtrSetDestroy (result);
		goto retry;
	    }
	}
    }

    return  result;
}

lt_tag_t *
FcGetDefaultLangtag (void)
{
    lt_tag_t *tag;
retry:
    tag = fc_atomic_ptr_get (&default_langtag);
    if (!tag)
    {
	FcPtrSet *tags = FcGetDefaultLangtags ();
	
	tag = FcPtrSetIndex (tags, 0);
	if (!fc_atomic_ptr_cmpexch (&default_langtag, NULL, tag)) {
	    goto retry;
	}
    }

    return tag;
}
#else
FcPtrSet *
FcGetDefaultLangtags (void)
{
    return NULL;
}

lt_tag_t *
FcGetDefaultLangtag (void)
{
    return NULL;
}

#endif

FcStrSet *default_langs;
static FcChar8 *default_lang; /* MT-safe */

FcStrSet *
FcGetDefaultLangs (void)
{
    FcStrSet *result;
retry:
    result = (FcStrSet *) fc_atomic_ptr_get (&default_langs);
    if (!result)
    {
#ifdef ENABLE_LIBLANGTAG
	FcPtrSet *tags = FcGetDefaultLangtags ();
	FcPtrList *list = FcPtrListCreate (tags);
	lt_tag_t *tag;

	result = FcStrSetCreate ();

	while ((tag = FcPtrListNext (list)))
	{
	    lt_error_t *error = NULL;
	    char *lang = lt_tag_convert_to_locale (tag, &error);

	    if (lt_error_is_set (error, LT_ERR_ANY))
		FcStrSetAdd (result, (const FcChar8 *) "en");
	    else
		if (!FcStrSetAddLangs (result, lang))
		    FcStrSetAdd (result, (const FcChar8 *) "en");
	    if (lang)
		free (lang);
	}
	FcPtrListDone (list);
#else
	char *langs;

	result = FcStrSetCreate ();

	langs = getenv ("FC_LANG");
	if (!langs || !langs[0])
	    langs = getenv ("LC_ALL");
	if (!langs || !langs[0])
	    langs = getenv ("LC_CTYPE");
	if (!langs || !langs[0])
	    langs = getenv ("LANG");
	if (langs && langs[0])
	{
	    if (!FcStrSetAddLangs (result, langs))
		FcStrSetAdd (result, (const FcChar8 *) "en");
	}
	else
	    FcStrSetAdd (result, (const FcChar8 *) "en");
#endif

	FcStrSetConst (result);
	if (!fc_atomic_ptr_cmpexch (&default_langs, NULL, result)) {
	    FcStrSetRefReset (result);
	    FcStrSetDestroy (result);
	    goto retry;
	}
    }

    return result;
}

FcChar8 *
FcGetDefaultLang (void)
{
    FcChar8 *lang;
retry:
    lang = fc_atomic_ptr_get (&default_lang);
    if (!lang)
    {
#ifdef ENABLE_LIBLANGTAG
	lt_tag_t *tag = FcGetDefaultLangtag ();

	if (tag)
	{
	    char *l = lt_tag_convert_to_locale (tag, NULL);

	    if (l)
	    {
		lang = FcLangNormalize ((const FcChar8 *) l);
		free (l);
	    }
	}
#else
	FcStrSet *langs = FcGetDefaultLangs ();
	lang = FcStrdup (FcStrSetIndex (langs, 0));
#endif

	if (!fc_atomic_ptr_cmpexch (&default_lang, NULL, lang)) {
	    free (lang);
	    goto retry;
	}
    }

    return lang;
}

static FcChar8 *default_prgname;

FcChar8 *
FcGetPrgname (void)
{
    FcChar8 *prgname;
retry:
    prgname = fc_atomic_ptr_get (&default_prgname);
    if (!prgname)
    {
#ifdef _WIN32
	char buf[MAX_PATH+1];

	/* TODO This is ASCII-only; fix it. */
	if (GetModuleFileNameA (GetModuleHandle (NULL), buf, sizeof (buf) / sizeof (buf[0])) > 0)
	{
	    char *p;
	    unsigned int len;

	    p = strrchr (buf, '\\');
	    if (p)
		p++;
	    else
		p = buf;

	    len = strlen (p);

	    if (len > 4 && 0 == strcmp (p + len - 4, ".exe"))
	    {
		len -= 4;
		buf[len] = '\0';
	    }

	    prgname = FcStrdup (p);
	}
#elif defined (HAVE_GETPROGNAME)
	const char *q = getprogname ();
	if (q)
	    prgname = FcStrdup (q);
	else
	    prgname = FcStrdup ("");
#else
# if defined (HAVE_GETEXECNAME)
	char *p = FcStrdup(getexecname ());
# elif defined (HAVE_READLINK)
	size_t size = FC_PATH_MAX;
	char *p = NULL;

	while (1)
	{
	    char *buf = malloc (size);
	    ssize_t len;

	    if (!buf)
		break;

	    len = readlink ("/proc/self/exe", buf, size - 1);
	    if (len < 0)
	    {
		free (buf);
		break;
	    }
	    if (len < size - 1)
	    {
		buf[len] = 0;
		p = buf;
		break;
	    }

	    free (buf);
	    size *= 2;
	}
# else
	char *p = NULL;
# endif
	if (p)
	{
	    char *r = strrchr (p, '/');
	    if (r)
		r++;
	    else
		r = p;

	    prgname = FcStrdup (r);
	}

	if (!prgname)
	    prgname = FcStrdup ("");

	if (p)
	    free (p);
#endif

	if (!fc_atomic_ptr_cmpexch (&default_prgname, NULL, prgname)) {
	    free (prgname);
	    goto retry;
	}
    }

    if (prgname && !prgname[0])
	return NULL;

    return prgname;
}

void
FcDefaultFini (void)
{
#ifdef ENABLE_LIBLANGTAG
    lt_tag_t *lang;
    FcPtrSet *langs;
#else
    FcChar8  *lang;
    FcStrSet *langs;
#endif
    FcChar8  *prgname;

    lang = fc_atomic_ptr_get (&default_lang);
    if (lang && fc_atomic_ptr_cmpexch (&default_lang, lang, NULL)) {
#ifdef ENABLE_LIBLANGTAG
	lt_tag_unref (lang);
#else
	free (lang);
#endif
    }

    langs = fc_atomic_ptr_get (&default_langs);
    if (langs && fc_atomic_ptr_cmpexch (&default_langs, langs, NULL)) {
#ifdef ENABLE_LIBLANGTAG
	FcPtrSetRefReset (langs);
	FcPtrSetDestroy (langs);
#else
	FcStrSetRefReset (langs);
	FcStrSetDestroy (langs);
#endif
    }

    prgname = fc_atomic_ptr_get (&default_prgname);
    if (prgname && fc_atomic_ptr_cmpexch (&default_prgname, prgname, NULL)) {
	free (prgname);
    }
}

void
FcDefaultSubstitute (FcPattern *pattern)
{
    FcValue v, namelang, v2;
    int	    i;
    double	dpi, size, scale, pixelsize;

    if (FcPatternObjectGet (pattern, FC_WEIGHT_OBJECT, 0, &v) == FcResultNoMatch )
	FcPatternObjectAddInteger (pattern, FC_WEIGHT_OBJECT, FC_WEIGHT_NORMAL);

    if (FcPatternObjectGet (pattern, FC_SLANT_OBJECT, 0, &v) == FcResultNoMatch)
	FcPatternObjectAddInteger (pattern, FC_SLANT_OBJECT, FC_SLANT_ROMAN);

    if (FcPatternObjectGet (pattern, FC_WIDTH_OBJECT, 0, &v) == FcResultNoMatch)
	FcPatternObjectAddInteger (pattern, FC_WIDTH_OBJECT, FC_WIDTH_NORMAL);

    for (i = 0; i < NUM_FC_BOOL_DEFAULTS; i++)
	if (FcPatternObjectGet (pattern, FcBoolDefaults[i].field, 0, &v) == FcResultNoMatch)
	    FcPatternObjectAddBool (pattern, FcBoolDefaults[i].field, FcBoolDefaults[i].value);

    if (FcPatternObjectGetDouble (pattern, FC_SIZE_OBJECT, 0, &size) != FcResultMatch)
    {
	FcRange *r;
	double b, e;
	if (FcPatternObjectGetRange (pattern, FC_SIZE_OBJECT, 0, &r) == FcResultMatch && FcRangeGetDouble (r, &b, &e))
	    size = (b + e) * .5;
	else
	    size = 12.0L;
    }
    if (FcPatternObjectGetDouble (pattern, FC_SCALE_OBJECT, 0, &scale) != FcResultMatch)
	scale = 1.0;
    if (FcPatternObjectGetDouble (pattern, FC_DPI_OBJECT, 0, &dpi) != FcResultMatch)
	dpi = 75.0;

    if (FcPatternObjectGet (pattern, FC_PIXEL_SIZE_OBJECT, 0, &v) != FcResultMatch)
    {
	(void) FcPatternObjectDel (pattern, FC_SCALE_OBJECT);
	FcPatternObjectAddDouble (pattern, FC_SCALE_OBJECT, scale);
	pixelsize = size * scale;
	(void) FcPatternObjectDel (pattern, FC_DPI_OBJECT);
	FcPatternObjectAddDouble (pattern, FC_DPI_OBJECT, dpi);
	pixelsize *= dpi / 72.0;
	FcPatternObjectAddDouble (pattern, FC_PIXEL_SIZE_OBJECT, pixelsize);
    }
    else
    {
	size = v.u.d;
	size = size / dpi * 72.0 / scale;
    }
    (void) FcPatternObjectDel (pattern, FC_SIZE_OBJECT);
    FcPatternObjectAddDouble (pattern, FC_SIZE_OBJECT, size);

    if (FcPatternObjectGet (pattern, FC_FONTVERSION_OBJECT, 0, &v) == FcResultNoMatch)
    {
	FcPatternObjectAddInteger (pattern, FC_FONTVERSION_OBJECT, 0x7fffffff);
    }

    if (FcPatternObjectGet (pattern, FC_HINT_STYLE_OBJECT, 0, &v) == FcResultNoMatch)
    {
	FcPatternObjectAddInteger (pattern, FC_HINT_STYLE_OBJECT, FC_HINT_FULL);
    }
    if (FcPatternObjectGet (pattern, FC_NAMELANG_OBJECT, 0, &v) == FcResultNoMatch)
    {
	FcPatternObjectAddString (pattern, FC_NAMELANG_OBJECT, FcGetDefaultLang ());
    }
    /* shouldn't be failed. */
    FcPatternObjectGet (pattern, FC_NAMELANG_OBJECT, 0, &namelang);
    /* Add a fallback to ensure the english name when the requested language
     * isn't available. this would helps for the fonts that have non-English
     * name at the beginning.
     */
    /* Set "en-us" instead of "en" to avoid giving higher score to "en".
     * This is a hack for the case that the orth is not like ll-cc, because,
     * if no namelang isn't explicitly set, it will has something like ll-cc
     * according to current locale. which may causes FcLangDifferentTerritory
     * at FcLangCompare(). thus, the English name is selected so that
     * exact matched "en" has higher score than ll-cc.
     */
    v2.type = FcTypeString;
    v2.u.s = (FcChar8 *) "en-us";
    if (FcPatternObjectGet (pattern, FC_FAMILYLANG_OBJECT, 0, &v) == FcResultNoMatch)
    {
	FcPatternObjectAdd (pattern, FC_FAMILYLANG_OBJECT, namelang, FcTrue);
	FcPatternObjectAddWithBinding (pattern, FC_FAMILYLANG_OBJECT, v2, FcValueBindingWeak, FcTrue);
    }
    if (FcPatternObjectGet (pattern, FC_STYLELANG_OBJECT, 0, &v) == FcResultNoMatch)
    {
	FcPatternObjectAdd (pattern, FC_STYLELANG_OBJECT, namelang, FcTrue);
	FcPatternObjectAddWithBinding (pattern, FC_STYLELANG_OBJECT, v2, FcValueBindingWeak, FcTrue);
    }
    if (FcPatternObjectGet (pattern, FC_FULLNAMELANG_OBJECT, 0, &v) == FcResultNoMatch)
    {
	FcPatternObjectAdd (pattern, FC_FULLNAMELANG_OBJECT, namelang, FcTrue);
	FcPatternObjectAddWithBinding (pattern, FC_FULLNAMELANG_OBJECT, v2, FcValueBindingWeak, FcTrue);
    }

    if (FcPatternObjectGet (pattern, FC_PRGNAME_OBJECT, 0, &v) == FcResultNoMatch)
    {
	FcChar8 *prgname = FcGetPrgname ();
	if (prgname)
	    FcPatternObjectAddString (pattern, FC_PRGNAME_OBJECT, prgname);
    }
}
#define __fcdefault__
#include "fcaliastail.h"
#undef __fcdefault__