summaryrefslogtreecommitdiffstats
path: root/gfx/thebes/gfxFontconfigUtils.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /gfx/thebes/gfxFontconfigUtils.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'gfx/thebes/gfxFontconfigUtils.cpp')
-rw-r--r--gfx/thebes/gfxFontconfigUtils.cpp1100
1 files changed, 1100 insertions, 0 deletions
diff --git a/gfx/thebes/gfxFontconfigUtils.cpp b/gfx/thebes/gfxFontconfigUtils.cpp
new file mode 100644
index 000000000..5bf606c13
--- /dev/null
+++ b/gfx/thebes/gfxFontconfigUtils.cpp
@@ -0,0 +1,1100 @@
+/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/ArrayUtils.h"
+
+#include "gfxFontconfigUtils.h"
+#include "gfxFont.h"
+#include "nsGkAtoms.h"
+
+#include <locale.h>
+#include <fontconfig/fontconfig.h>
+
+#include "nsServiceManagerUtils.h"
+#include "nsILanguageAtomService.h"
+#include "nsTArray.h"
+#include "mozilla/Preferences.h"
+#include "nsDirectoryServiceUtils.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsAppDirectoryServiceDefs.h"
+
+#include "nsIAtom.h"
+#include "nsCRT.h"
+#include "gfxFontConstants.h"
+#include "mozilla/gfx/2D.h"
+
+using namespace mozilla;
+
+/* static */ gfxFontconfigUtils* gfxFontconfigUtils::sUtils = nullptr;
+static nsILanguageAtomService* gLangService = nullptr;
+
+/* static */ void
+gfxFontconfigUtils::Shutdown() {
+ if (sUtils) {
+ delete sUtils;
+ sUtils = nullptr;
+ }
+ NS_IF_RELEASE(gLangService);
+}
+
+/* static */ uint8_t
+gfxFontconfigUtils::FcSlantToThebesStyle(int aFcSlant)
+{
+ switch (aFcSlant) {
+ case FC_SLANT_ITALIC:
+ return NS_FONT_STYLE_ITALIC;
+ case FC_SLANT_OBLIQUE:
+ return NS_FONT_STYLE_OBLIQUE;
+ default:
+ return NS_FONT_STYLE_NORMAL;
+ }
+}
+
+/* static */ uint8_t
+gfxFontconfigUtils::GetThebesStyle(FcPattern *aPattern)
+{
+ int slant;
+ if (FcPatternGetInteger(aPattern, FC_SLANT, 0, &slant) != FcResultMatch) {
+ return NS_FONT_STYLE_NORMAL;
+ }
+
+ return FcSlantToThebesStyle(slant);
+}
+
+/* static */ int
+gfxFontconfigUtils::GetFcSlant(const gfxFontStyle& aFontStyle)
+{
+ if (aFontStyle.style == NS_FONT_STYLE_ITALIC)
+ return FC_SLANT_ITALIC;
+ if (aFontStyle.style == NS_FONT_STYLE_OBLIQUE)
+ return FC_SLANT_OBLIQUE;
+
+ return FC_SLANT_ROMAN;
+}
+
+// OS/2 weight classes were introduced in fontconfig-2.1.93 (2003).
+#ifndef FC_WEIGHT_THIN
+#define FC_WEIGHT_THIN 0 // 2.1.93
+#define FC_WEIGHT_EXTRALIGHT 40 // 2.1.93
+#define FC_WEIGHT_REGULAR 80 // 2.1.93
+#define FC_WEIGHT_EXTRABOLD 205 // 2.1.93
+#endif
+// book was introduced in fontconfig-2.2.90 (and so fontconfig-2.3.0 in 2005)
+#ifndef FC_WEIGHT_BOOK
+#define FC_WEIGHT_BOOK 75
+#endif
+// extra black was introduced in fontconfig-2.4.91 (2007)
+#ifndef FC_WEIGHT_EXTRABLACK
+#define FC_WEIGHT_EXTRABLACK 215
+#endif
+
+/* static */ uint16_t
+gfxFontconfigUtils::GetThebesWeight(FcPattern *aPattern)
+{
+ int weight;
+ if (FcPatternGetInteger(aPattern, FC_WEIGHT, 0, &weight) != FcResultMatch)
+ return NS_FONT_WEIGHT_NORMAL;
+
+ if (weight <= (FC_WEIGHT_THIN + FC_WEIGHT_EXTRALIGHT) / 2)
+ return 100;
+ if (weight <= (FC_WEIGHT_EXTRALIGHT + FC_WEIGHT_LIGHT) / 2)
+ return 200;
+ if (weight <= (FC_WEIGHT_LIGHT + FC_WEIGHT_BOOK) / 2)
+ return 300;
+ if (weight <= (FC_WEIGHT_REGULAR + FC_WEIGHT_MEDIUM) / 2)
+ // This includes FC_WEIGHT_BOOK
+ return 400;
+ if (weight <= (FC_WEIGHT_MEDIUM + FC_WEIGHT_DEMIBOLD) / 2)
+ return 500;
+ if (weight <= (FC_WEIGHT_DEMIBOLD + FC_WEIGHT_BOLD) / 2)
+ return 600;
+ if (weight <= (FC_WEIGHT_BOLD + FC_WEIGHT_EXTRABOLD) / 2)
+ return 700;
+ if (weight <= (FC_WEIGHT_EXTRABOLD + FC_WEIGHT_BLACK) / 2)
+ return 800;
+ if (weight <= FC_WEIGHT_BLACK)
+ return 900;
+
+ // including FC_WEIGHT_EXTRABLACK
+ return 901;
+}
+
+/* static */ int
+gfxFontconfigUtils::FcWeightForBaseWeight(int8_t aBaseWeight)
+{
+ NS_PRECONDITION(aBaseWeight >= 0 && aBaseWeight <= 10,
+ "base weight out of range");
+
+ switch (aBaseWeight) {
+ case 2:
+ return FC_WEIGHT_EXTRALIGHT;
+ case 3:
+ return FC_WEIGHT_LIGHT;
+ case 4:
+ return FC_WEIGHT_REGULAR;
+ case 5:
+ return FC_WEIGHT_MEDIUM;
+ case 6:
+ return FC_WEIGHT_DEMIBOLD;
+ case 7:
+ return FC_WEIGHT_BOLD;
+ case 8:
+ return FC_WEIGHT_EXTRABOLD;
+ case 9:
+ return FC_WEIGHT_BLACK;
+ }
+
+ // extremes
+ return aBaseWeight < 2 ? FC_WEIGHT_THIN : FC_WEIGHT_EXTRABLACK;
+}
+
+/* static */ int16_t
+gfxFontconfigUtils::GetThebesStretch(FcPattern *aPattern)
+{
+ int width;
+ if (FcPatternGetInteger(aPattern, FC_WIDTH, 0, &width) != FcResultMatch) {
+ return NS_FONT_STRETCH_NORMAL;
+ }
+
+ if (width <= (FC_WIDTH_ULTRACONDENSED + FC_WIDTH_EXTRACONDENSED) / 2) {
+ return NS_FONT_STRETCH_ULTRA_CONDENSED;
+ }
+ if (width <= (FC_WIDTH_EXTRACONDENSED + FC_WIDTH_CONDENSED) / 2) {
+ return NS_FONT_STRETCH_EXTRA_CONDENSED;
+ }
+ if (width <= (FC_WIDTH_CONDENSED + FC_WIDTH_SEMICONDENSED) / 2) {
+ return NS_FONT_STRETCH_CONDENSED;
+ }
+ if (width <= (FC_WIDTH_SEMICONDENSED + FC_WIDTH_NORMAL) / 2) {
+ return NS_FONT_STRETCH_SEMI_CONDENSED;
+ }
+ if (width <= (FC_WIDTH_NORMAL + FC_WIDTH_SEMIEXPANDED) / 2) {
+ return NS_FONT_STRETCH_NORMAL;
+ }
+ if (width <= (FC_WIDTH_SEMIEXPANDED + FC_WIDTH_EXPANDED) / 2) {
+ return NS_FONT_STRETCH_SEMI_EXPANDED;
+ }
+ if (width <= (FC_WIDTH_EXPANDED + FC_WIDTH_EXTRAEXPANDED) / 2) {
+ return NS_FONT_STRETCH_EXPANDED;
+ }
+ if (width <= (FC_WIDTH_EXTRAEXPANDED + FC_WIDTH_ULTRAEXPANDED) / 2) {
+ return NS_FONT_STRETCH_EXTRA_EXPANDED;
+ }
+ return NS_FONT_STRETCH_ULTRA_EXPANDED;
+}
+
+/* static */ int
+gfxFontconfigUtils::FcWidthForThebesStretch(int16_t aStretch)
+{
+ switch (aStretch) {
+ default: // this will catch "normal" (0) as well as out-of-range values
+ return FC_WIDTH_NORMAL;
+ case NS_FONT_STRETCH_ULTRA_CONDENSED:
+ return FC_WIDTH_ULTRACONDENSED;
+ case NS_FONT_STRETCH_EXTRA_CONDENSED:
+ return FC_WIDTH_EXTRACONDENSED;
+ case NS_FONT_STRETCH_CONDENSED:
+ return FC_WIDTH_CONDENSED;
+ case NS_FONT_STRETCH_SEMI_CONDENSED:
+ return FC_WIDTH_SEMICONDENSED;
+ case NS_FONT_STRETCH_SEMI_EXPANDED:
+ return FC_WIDTH_SEMIEXPANDED;
+ case NS_FONT_STRETCH_EXPANDED:
+ return FC_WIDTH_EXPANDED;
+ case NS_FONT_STRETCH_EXTRA_EXPANDED:
+ return FC_WIDTH_EXTRAEXPANDED;
+ case NS_FONT_STRETCH_ULTRA_EXPANDED:
+ return FC_WIDTH_ULTRAEXPANDED;
+ }
+}
+
+// This makes a guess at an FC_WEIGHT corresponding to a base weight and
+// offset (without any knowledge of which weights are available).
+
+/* static */ int
+GuessFcWeight(const gfxFontStyle& aFontStyle)
+{
+ /*
+ * weights come in two parts crammed into one
+ * integer -- the "base" weight is weight / 100,
+ * the rest of the value is the "offset" from that
+ * weight -- the number of steps to move to adjust
+ * the weight in the list of supported font weights,
+ * this value can be negative or positive.
+ */
+ int8_t weight = aFontStyle.ComputeWeight();
+
+ // ComputeWeight trimmed the range of weights for us
+ NS_ASSERTION(weight >= 0 && weight <= 10,
+ "base weight out of range");
+
+ return gfxFontconfigUtils::FcWeightForBaseWeight(weight);
+}
+
+static void
+AddString(FcPattern *aPattern, const char *object, const char *aString)
+{
+ FcPatternAddString(aPattern, object,
+ gfxFontconfigUtils::ToFcChar8(aString));
+}
+
+static void
+AddWeakString(FcPattern *aPattern, const char *object, const char *aString)
+{
+ FcValue value;
+ value.type = FcTypeString;
+ value.u.s = gfxFontconfigUtils::ToFcChar8(aString);
+
+ FcPatternAddWeak(aPattern, object, value, FcTrue);
+}
+
+static void
+AddLangGroup(FcPattern *aPattern, nsIAtom *aLangGroup)
+{
+ // Translate from mozilla's internal mapping into fontconfig's
+ nsAutoCString lang;
+ gfxFontconfigUtils::GetSampleLangForGroup(aLangGroup, &lang);
+
+ if (!lang.IsEmpty()) {
+ AddString(aPattern, FC_LANG, lang.get());
+ }
+}
+
+nsReturnRef<FcPattern>
+gfxFontconfigUtils::NewPattern(const nsTArray<nsString>& aFamilies,
+ const gfxFontStyle& aFontStyle,
+ const char *aLang)
+{
+ static const char* sFontconfigGenerics[] =
+ { "sans-serif", "serif", "monospace", "fantasy", "cursive" };
+
+ nsAutoRef<FcPattern> pattern(FcPatternCreate());
+ if (!pattern)
+ return nsReturnRef<FcPattern>();
+
+ FcPatternAddDouble(pattern, FC_PIXEL_SIZE, aFontStyle.size);
+ FcPatternAddInteger(pattern, FC_SLANT, GetFcSlant(aFontStyle));
+ FcPatternAddInteger(pattern, FC_WEIGHT, GuessFcWeight(aFontStyle));
+ FcPatternAddInteger(pattern, FC_WIDTH, FcWidthForThebesStretch(aFontStyle.stretch));
+
+ if (aLang) {
+ AddString(pattern, FC_LANG, aLang);
+ }
+
+ bool useWeakBinding = false;
+ for (uint32_t i = 0; i < aFamilies.Length(); ++i) {
+ NS_ConvertUTF16toUTF8 family(aFamilies[i]);
+ if (!useWeakBinding) {
+ AddString(pattern, FC_FAMILY, family.get());
+
+ // fontconfig generic families are typically implemented with weak
+ // aliases (so that the preferred font depends on language).
+ // However, this would give them lower priority than subsequent
+ // non-generic families in the list. To ensure that subsequent
+ // families do not have a higher priority, they are given weak
+ // bindings.
+ for (uint32_t g = 0;
+ g < ArrayLength(sFontconfigGenerics);
+ ++g) {
+ if (0 == FcStrCmpIgnoreCase(ToFcChar8(sFontconfigGenerics[g]),
+ ToFcChar8(family.get()))) {
+ useWeakBinding = true;
+ break;
+ }
+ }
+ } else {
+ AddWeakString(pattern, FC_FAMILY, family.get());
+ }
+ }
+
+ return pattern.out();
+}
+
+gfxFontconfigUtils::gfxFontconfigUtils()
+ : mFontsByFamily(32)
+ , mFontsByFullname(32)
+ , mLangSupportTable(32)
+ , mLastConfig(nullptr)
+#ifdef MOZ_BUNDLED_FONTS
+ , mBundledFontsInitialized(false)
+#endif
+{
+ UpdateFontListInternal();
+}
+
+nsresult
+gfxFontconfigUtils::GetFontList(nsIAtom *aLangGroup,
+ const nsACString& aGenericFamily,
+ nsTArray<nsString>& aListOfFonts)
+{
+ aListOfFonts.Clear();
+
+ nsTArray<nsCString> fonts;
+ nsresult rv = GetFontListInternal(fonts, aLangGroup);
+ if (NS_FAILED(rv))
+ return rv;
+
+ for (uint32_t i = 0; i < fonts.Length(); ++i) {
+ aListOfFonts.AppendElement(NS_ConvertUTF8toUTF16(fonts[i]));
+ }
+
+ aListOfFonts.Sort();
+
+ int32_t serif = 0, sansSerif = 0, monospace = 0;
+
+ // Fontconfig supports 3 generic fonts, "serif", "sans-serif", and
+ // "monospace", slightly different from CSS's 5.
+ if (aGenericFamily.IsEmpty())
+ serif = sansSerif = monospace = 1;
+ else if (aGenericFamily.LowerCaseEqualsLiteral("serif"))
+ serif = 1;
+ else if (aGenericFamily.LowerCaseEqualsLiteral("sans-serif"))
+ sansSerif = 1;
+ else if (aGenericFamily.LowerCaseEqualsLiteral("monospace"))
+ monospace = 1;
+ else if (aGenericFamily.LowerCaseEqualsLiteral("cursive") ||
+ aGenericFamily.LowerCaseEqualsLiteral("fantasy"))
+ serif = sansSerif = 1;
+ else
+ NS_NOTREACHED("unexpected CSS generic font family");
+
+ // The first in the list becomes the default in
+ // FontBuilder.readFontSelection() if the preference-selected font is not
+ // available, so put system configured defaults first.
+ if (monospace)
+ aListOfFonts.InsertElementAt(0, NS_LITERAL_STRING("monospace"));
+ if (sansSerif)
+ aListOfFonts.InsertElementAt(0, NS_LITERAL_STRING("sans-serif"));
+ if (serif)
+ aListOfFonts.InsertElementAt(0, NS_LITERAL_STRING("serif"));
+
+ return NS_OK;
+}
+
+struct MozLangGroupData {
+ nsIAtom* const& mozLangGroup;
+ const char *defaultLang;
+};
+
+const MozLangGroupData MozLangGroups[] = {
+ { nsGkAtoms::x_western, "en" },
+ { nsGkAtoms::x_cyrillic, "ru" },
+ { nsGkAtoms::x_devanagari, "hi" },
+ { nsGkAtoms::x_tamil, "ta" },
+ { nsGkAtoms::x_armn, "hy" },
+ { nsGkAtoms::x_beng, "bn" },
+ { nsGkAtoms::x_cans, "iu" },
+ { nsGkAtoms::x_ethi, "am" },
+ { nsGkAtoms::x_geor, "ka" },
+ { nsGkAtoms::x_gujr, "gu" },
+ { nsGkAtoms::x_guru, "pa" },
+ { nsGkAtoms::x_khmr, "km" },
+ { nsGkAtoms::x_knda, "kn" },
+ { nsGkAtoms::x_mlym, "ml" },
+ { nsGkAtoms::x_orya, "or" },
+ { nsGkAtoms::x_sinh, "si" },
+ { nsGkAtoms::x_telu, "te" },
+ { nsGkAtoms::x_tibt, "bo" },
+ { nsGkAtoms::Unicode, 0 },
+};
+
+static bool
+TryLangForGroup(const nsACString& aOSLang, nsIAtom *aLangGroup,
+ nsACString *aFcLang)
+{
+ // Truncate at '.' or '@' from aOSLang, and convert '_' to '-'.
+ // aOSLang is in the form "language[_territory][.codeset][@modifier]".
+ // fontconfig takes languages in the form "language-territory".
+ // nsILanguageAtomService takes languages in the form language-subtag,
+ // where subtag may be a territory. fontconfig and nsILanguageAtomService
+ // handle case-conversion for us.
+ const char *pos, *end;
+ aOSLang.BeginReading(pos);
+ aOSLang.EndReading(end);
+ aFcLang->Truncate();
+ while (pos < end) {
+ switch (*pos) {
+ case '.':
+ case '@':
+ end = pos;
+ break;
+ case '_':
+ aFcLang->Append('-');
+ break;
+ default:
+ aFcLang->Append(*pos);
+ }
+ ++pos;
+ }
+
+ nsIAtom *atom =
+ gLangService->LookupLanguage(*aFcLang);
+
+ return atom == aLangGroup;
+}
+
+/* static */ void
+gfxFontconfigUtils::GetSampleLangForGroup(nsIAtom *aLangGroup,
+ nsACString *aFcLang)
+{
+ NS_PRECONDITION(aFcLang != nullptr, "aFcLang must not be NULL");
+
+ const MozLangGroupData *langGroup = nullptr;
+
+ for (unsigned int i = 0; i < ArrayLength(MozLangGroups); ++i) {
+ if (aLangGroup == MozLangGroups[i].mozLangGroup) {
+ langGroup = &MozLangGroups[i];
+ break;
+ }
+ }
+
+ if (!langGroup) {
+ // Not a special mozilla language group.
+ // Use aLangGroup as a language code.
+ aLangGroup->ToUTF8String(*aFcLang);
+ return;
+ }
+
+ // Check the environment for the users preferred language that corresponds
+ // to this langGroup.
+ if (!gLangService) {
+ CallGetService(NS_LANGUAGEATOMSERVICE_CONTRACTID, &gLangService);
+ }
+
+ if (gLangService) {
+ const char *languages = getenv("LANGUAGE");
+ if (languages) {
+ const char separator = ':';
+
+ for (const char *pos = languages; true; ++pos) {
+ if (*pos == '\0' || *pos == separator) {
+ if (languages < pos &&
+ TryLangForGroup(Substring(languages, pos),
+ aLangGroup, aFcLang))
+ return;
+
+ if (*pos == '\0')
+ break;
+
+ languages = pos + 1;
+ }
+ }
+ }
+ const char *ctype = setlocale(LC_CTYPE, nullptr);
+ if (ctype &&
+ TryLangForGroup(nsDependentCString(ctype), aLangGroup, aFcLang))
+ return;
+ }
+
+ if (langGroup->defaultLang) {
+ aFcLang->Assign(langGroup->defaultLang);
+ } else {
+ aFcLang->Truncate();
+ }
+}
+
+nsresult
+gfxFontconfigUtils::GetFontListInternal(nsTArray<nsCString>& aListOfFonts,
+ nsIAtom *aLangGroup)
+{
+ FcPattern *pat = nullptr;
+ FcObjectSet *os = nullptr;
+ FcFontSet *fs = nullptr;
+ nsresult rv = NS_ERROR_FAILURE;
+
+ aListOfFonts.Clear();
+
+ pat = FcPatternCreate();
+ if (!pat)
+ goto end;
+
+ os = FcObjectSetBuild(FC_FAMILY, nullptr);
+ if (!os)
+ goto end;
+
+ // take the pattern and add the lang group to it
+ if (aLangGroup) {
+ AddLangGroup(pat, aLangGroup);
+ }
+
+ fs = FcFontList(nullptr, pat, os);
+ if (!fs)
+ goto end;
+
+ for (int i = 0; i < fs->nfont; i++) {
+ char *family;
+
+ if (FcPatternGetString(fs->fonts[i], FC_FAMILY, 0,
+ (FcChar8 **) &family) != FcResultMatch)
+ {
+ continue;
+ }
+
+ // Remove duplicates...
+ nsAutoCString strFamily(family);
+ if (aListOfFonts.Contains(strFamily))
+ continue;
+
+ aListOfFonts.AppendElement(strFamily);
+ }
+
+ rv = NS_OK;
+
+ end:
+ if (NS_FAILED(rv))
+ aListOfFonts.Clear();
+
+ if (pat)
+ FcPatternDestroy(pat);
+ if (os)
+ FcObjectSetDestroy(os);
+ if (fs)
+ FcFontSetDestroy(fs);
+
+ return rv;
+}
+
+nsresult
+gfxFontconfigUtils::UpdateFontList()
+{
+ return UpdateFontListInternal(true);
+}
+
+nsresult
+gfxFontconfigUtils::UpdateFontListInternal(bool aForce)
+{
+ if (!aForce) {
+ // This checks periodically according to fontconfig's configured
+ // <rescan> interval.
+ FcInitBringUptoDate();
+ } else if (!FcConfigUptoDate(nullptr)) { // check now with aForce
+ mLastConfig = nullptr;
+ FcInitReinitialize();
+ }
+
+ // FcInitReinitialize() (used by FcInitBringUptoDate) creates a new config
+ // before destroying the old config, so the only way that we'd miss an
+ // update is if fontconfig did more than one update and the memory for the
+ // most recent config happened to be at the same location as the original
+ // config.
+ FcConfig *currentConfig = FcConfigGetCurrent();
+ if (currentConfig == mLastConfig)
+ return NS_OK;
+
+#ifdef MOZ_BUNDLED_FONTS
+ ActivateBundledFonts();
+#endif
+
+ // These FcFontSets are owned by fontconfig
+ FcFontSet *fontSets[] = {
+ FcConfigGetFonts(currentConfig, FcSetSystem)
+#ifdef MOZ_BUNDLED_FONTS
+ , FcConfigGetFonts(currentConfig, FcSetApplication)
+#endif
+ };
+
+ mFontsByFamily.Clear();
+ mFontsByFullname.Clear();
+ mLangSupportTable.Clear();
+
+ // Record the existing font families
+ for (unsigned fs = 0; fs < ArrayLength(fontSets); ++fs) {
+ FcFontSet *fontSet = fontSets[fs];
+ if (!fontSet) { // the application set might not exist
+ continue;
+ }
+ for (int f = 0; f < fontSet->nfont; ++f) {
+ FcPattern *font = fontSet->fonts[f];
+
+ FcChar8 *family;
+ for (int v = 0;
+ FcPatternGetString(font, FC_FAMILY, v, &family) == FcResultMatch;
+ ++v) {
+ FontsByFcStrEntry *entry = mFontsByFamily.PutEntry(family);
+ if (entry) {
+ bool added = entry->AddFont(font);
+
+ if (!entry->mKey) {
+ // The reference to the font pattern keeps the pointer
+ // to string for the key valid. If adding the font
+ // failed then the entry must be removed.
+ if (added) {
+ entry->mKey = family;
+ } else {
+ mFontsByFamily.RemoveEntry(entry);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ mLastConfig = currentConfig;
+ return NS_OK;
+}
+
+nsresult
+gfxFontconfigUtils::GetStandardFamilyName(const nsAString& aFontName, nsAString& aFamilyName)
+{
+ aFamilyName.Truncate();
+
+ // The fontconfig has generic family names in the font list.
+ if (aFontName.EqualsLiteral("serif") ||
+ aFontName.EqualsLiteral("sans-serif") ||
+ aFontName.EqualsLiteral("monospace")) {
+ aFamilyName.Assign(aFontName);
+ return NS_OK;
+ }
+
+ nsresult rv = UpdateFontListInternal();
+ if (NS_FAILED(rv))
+ return rv;
+
+ NS_ConvertUTF16toUTF8 fontname(aFontName);
+
+ // return empty string if no such family exists
+ if (!IsExistingFamily(fontname))
+ return NS_OK;
+
+ FcPattern *pat = nullptr;
+ FcObjectSet *os = nullptr;
+ FcFontSet *givenFS = nullptr;
+ nsTArray<nsCString> candidates;
+ FcFontSet *candidateFS = nullptr;
+ rv = NS_ERROR_FAILURE;
+
+ pat = FcPatternCreate();
+ if (!pat)
+ goto end;
+
+ FcPatternAddString(pat, FC_FAMILY, (FcChar8 *)fontname.get());
+
+ os = FcObjectSetBuild(FC_FAMILY, FC_FILE, FC_INDEX, nullptr);
+ if (!os)
+ goto end;
+
+ givenFS = FcFontList(nullptr, pat, os);
+ if (!givenFS)
+ goto end;
+
+ // The first value associated with a FC_FAMILY property is the family
+ // returned by GetFontList(), so use this value if appropriate.
+
+ // See if there is a font face with first family equal to the given family.
+ for (int i = 0; i < givenFS->nfont; ++i) {
+ char *firstFamily;
+ if (FcPatternGetString(givenFS->fonts[i], FC_FAMILY, 0,
+ (FcChar8 **) &firstFamily) != FcResultMatch)
+ continue;
+
+ nsDependentCString first(firstFamily);
+ if (!candidates.Contains(first)) {
+ candidates.AppendElement(first);
+
+ if (fontname.Equals(first)) {
+ aFamilyName.Assign(aFontName);
+ rv = NS_OK;
+ goto end;
+ }
+ }
+ }
+
+ // See if any of the first family names represent the same set of font
+ // faces as the given family.
+ for (uint32_t j = 0; j < candidates.Length(); ++j) {
+ FcPatternDel(pat, FC_FAMILY);
+ FcPatternAddString(pat, FC_FAMILY, (FcChar8 *)candidates[j].get());
+
+ candidateFS = FcFontList(nullptr, pat, os);
+ if (!candidateFS)
+ goto end;
+
+ if (candidateFS->nfont != givenFS->nfont)
+ continue;
+
+ bool equal = true;
+ for (int i = 0; i < givenFS->nfont; ++i) {
+ if (!FcPatternEqual(candidateFS->fonts[i], givenFS->fonts[i])) {
+ equal = false;
+ break;
+ }
+ }
+ if (equal) {
+ AppendUTF8toUTF16(candidates[j], aFamilyName);
+ rv = NS_OK;
+ goto end;
+ }
+ }
+
+ // No match found; return empty string.
+ rv = NS_OK;
+
+ end:
+ if (pat)
+ FcPatternDestroy(pat);
+ if (os)
+ FcObjectSetDestroy(os);
+ if (givenFS)
+ FcFontSetDestroy(givenFS);
+ if (candidateFS)
+ FcFontSetDestroy(candidateFS);
+
+ return rv;
+}
+
+bool
+gfxFontconfigUtils::IsExistingFamily(const nsCString& aFamilyName)
+{
+ return mFontsByFamily.GetEntry(ToFcChar8(aFamilyName)) != nullptr;
+}
+
+const nsTArray< nsCountedRef<FcPattern> >&
+gfxFontconfigUtils::GetFontsForFamily(const FcChar8 *aFamilyName)
+{
+ FontsByFcStrEntry *entry = mFontsByFamily.GetEntry(aFamilyName);
+
+ if (!entry)
+ return mEmptyPatternArray;
+
+ return entry->GetFonts();
+}
+
+// Fontconfig only provides a fullname property for fonts in formats with SFNT
+// wrappers. For other font formats (including PCF and PS Type 1), a fullname
+// must be generated from the family and style properties. Only the first
+// family and style is checked, but that should be OK, as I don't expect
+// non-SFNT fonts to have multiple families or styles.
+bool
+gfxFontconfigUtils::GetFullnameFromFamilyAndStyle(FcPattern *aFont,
+ nsACString *aFullname)
+{
+ FcChar8 *family;
+ if (FcPatternGetString(aFont, FC_FAMILY, 0, &family) != FcResultMatch)
+ return false;
+
+ aFullname->Truncate();
+ aFullname->Append(ToCString(family));
+
+ FcChar8 *style;
+ if (FcPatternGetString(aFont, FC_STYLE, 0, &style) == FcResultMatch &&
+ strcmp(ToCString(style), "Regular") != 0) {
+ aFullname->Append(' ');
+ aFullname->Append(ToCString(style));
+ }
+
+ return true;
+}
+
+bool
+gfxFontconfigUtils::FontsByFullnameEntry::KeyEquals(KeyTypePointer aKey) const
+{
+ const FcChar8 *key = mKey;
+ // If mKey is nullptr, key comes from the style and family of the first
+ // font.
+ nsAutoCString fullname;
+ if (!key) {
+ NS_ASSERTION(mFonts.Length(), "No font in FontsByFullnameEntry!");
+ GetFullnameFromFamilyAndStyle(mFonts[0], &fullname);
+
+ key = ToFcChar8(fullname);
+ }
+
+ return FcStrCmpIgnoreCase(aKey, key) == 0;
+}
+
+void
+gfxFontconfigUtils::AddFullnameEntries()
+{
+ // These FcFontSets are owned by fontconfig
+ FcFontSet *fontSets[] = {
+ FcConfigGetFonts(nullptr, FcSetSystem)
+#ifdef MOZ_BUNDLED_FONTS
+ , FcConfigGetFonts(nullptr, FcSetApplication)
+#endif
+ };
+
+ for (unsigned fs = 0; fs < ArrayLength(fontSets); ++fs) {
+ FcFontSet *fontSet = fontSets[fs];
+ if (!fontSet) {
+ continue;
+ }
+ // Record the existing font families
+ for (int f = 0; f < fontSet->nfont; ++f) {
+ FcPattern *font = fontSet->fonts[f];
+
+ int v = 0;
+ FcChar8 *fullname;
+ while (FcPatternGetString(font,
+ FC_FULLNAME, v, &fullname) == FcResultMatch) {
+ FontsByFullnameEntry *entry =
+ mFontsByFullname.PutEntry(fullname);
+ if (entry) {
+ // entry always has space for one font, so the first
+ // AddFont will always succeed, and so the entry will
+ // always have a font from which to obtain the key.
+ bool added = entry->AddFont(font);
+ // The key may be nullptr either if this is the first
+ // font, or if the first font does not have a fullname
+ // property, and so the key is obtained from the font.
+ // Set the key in both cases. The check that AddFont
+ // succeeded is required for the second case.
+ if (!entry->mKey && added) {
+ entry->mKey = fullname;
+ }
+ }
+
+ ++v;
+ }
+
+ // Fontconfig does not provide a fullname property for all fonts.
+ if (v == 0) {
+ nsAutoCString name;
+ if (!GetFullnameFromFamilyAndStyle(font, &name))
+ continue;
+
+ FontsByFullnameEntry *entry =
+ mFontsByFullname.PutEntry(ToFcChar8(name));
+ if (entry) {
+ entry->AddFont(font);
+ // Either entry->mKey has been set for a previous font or it
+ // remains nullptr to indicate that the key is obtained from
+ // the first font.
+ }
+ }
+ }
+ }
+}
+
+const nsTArray< nsCountedRef<FcPattern> >&
+gfxFontconfigUtils::GetFontsForFullname(const FcChar8 *aFullname)
+{
+ if (mFontsByFullname.Count() == 0) {
+ AddFullnameEntries();
+ }
+
+ FontsByFullnameEntry *entry = mFontsByFullname.GetEntry(aFullname);
+
+ if (!entry)
+ return mEmptyPatternArray;
+
+ return entry->GetFonts();
+}
+
+static FcLangResult
+CompareLangString(const FcChar8 *aLangA, const FcChar8 *aLangB) {
+ FcLangResult result = FcLangDifferentLang;
+ for (uint32_t i = 0; ; ++i) {
+ FcChar8 a = FcToLower(aLangA[i]);
+ FcChar8 b = FcToLower(aLangB[i]);
+
+ if (a != b) {
+ if ((a == '\0' && b == '-') || (a == '-' && b == '\0'))
+ return FcLangDifferentCountry;
+
+ return result;
+ }
+ if (a == '\0')
+ return FcLangEqual;
+
+ if (a == '-') {
+ result = FcLangDifferentCountry;
+ }
+ }
+}
+
+/* static */
+FcLangResult
+gfxFontconfigUtils::GetLangSupport(FcPattern *aFont, const FcChar8 *aLang)
+{
+ // When fontconfig builds a pattern for a system font, it will set a
+ // single LangSet property value for the font. That value may be removed
+ // and additional string values may be added through FcConfigSubsitute
+ // with FcMatchScan. Values that are neither LangSet nor string are
+ // considered errors in fontconfig sort and match functions.
+ //
+ // If no string nor LangSet value is found, then either the font is a
+ // system font and the LangSet has been removed through FcConfigSubsitute,
+ // or the font is a web font and its language support is unknown.
+ // Returning FcLangDifferentLang for these fonts ensures that this font
+ // will not be assumed to satisfy the language, and so language will be
+ // prioritized in sorting fallback fonts.
+ FcValue value;
+ FcLangResult best = FcLangDifferentLang;
+ for (int v = 0;
+ FcPatternGet(aFont, FC_LANG, v, &value) == FcResultMatch;
+ ++v) {
+
+ FcLangResult support;
+ switch (value.type) {
+ case FcTypeLangSet:
+ support = FcLangSetHasLang(value.u.l, aLang);
+ break;
+ case FcTypeString:
+ support = CompareLangString(value.u.s, aLang);
+ break;
+ default:
+ // error. continue to see if there is a useful value.
+ continue;
+ }
+
+ if (support < best) { // lower is better
+ if (support == FcLangEqual)
+ return support;
+ best = support;
+ }
+ }
+
+ return best;
+}
+
+gfxFontconfigUtils::LangSupportEntry *
+gfxFontconfigUtils::GetLangSupportEntry(const FcChar8 *aLang, bool aWithFonts)
+{
+ // Currently any unrecognized languages from documents will be converted
+ // to x-unicode by nsILanguageAtomService, so there is a limit on the
+ // langugages that will be added here. Reconsider when/if document
+ // languages are passed to this routine.
+
+ LangSupportEntry *entry = mLangSupportTable.PutEntry(aLang);
+ if (!entry)
+ return nullptr;
+
+ FcLangResult best = FcLangDifferentLang;
+
+ if (!entry->IsKeyInitialized()) {
+ entry->InitKey(aLang);
+ } else {
+ // mSupport is already initialized.
+ if (!aWithFonts)
+ return entry;
+
+ best = entry->mSupport;
+ // If there is support for this language, an empty font list indicates
+ // that the list hasn't been initialized yet.
+ if (best == FcLangDifferentLang || entry->mFonts.Length() > 0)
+ return entry;
+ }
+
+ // These FcFontSets are owned by fontconfig
+ FcFontSet *fontSets[] = {
+ FcConfigGetFonts(nullptr, FcSetSystem)
+#ifdef MOZ_BUNDLED_FONTS
+ , FcConfigGetFonts(nullptr, FcSetApplication)
+#endif
+ };
+
+ AutoTArray<FcPattern*,100> fonts;
+
+ for (unsigned fs = 0; fs < ArrayLength(fontSets); ++fs) {
+ FcFontSet *fontSet = fontSets[fs];
+ if (!fontSet) {
+ continue;
+ }
+ for (int f = 0; f < fontSet->nfont; ++f) {
+ FcPattern *font = fontSet->fonts[f];
+
+ FcLangResult support = GetLangSupport(font, aLang);
+
+ if (support < best) { // lower is better
+ best = support;
+ if (aWithFonts) {
+ fonts.Clear();
+ } else if (best == FcLangEqual) {
+ break;
+ }
+ }
+
+ // The font list in the LangSupportEntry is expected to be used
+ // only when no default fonts support the language. There would
+ // be a large number of fonts in entries for languages using Latin
+ // script but these do not need to be created because default
+ // fonts already support these languages.
+ if (aWithFonts && support != FcLangDifferentLang &&
+ support == best) {
+ fonts.AppendElement(font);
+ }
+ }
+ }
+
+ entry->mSupport = best;
+ if (aWithFonts) {
+ if (fonts.Length() != 0) {
+ entry->mFonts.AppendElements(fonts.Elements(), fonts.Length());
+ } else if (best != FcLangDifferentLang) {
+ // Previously there was a font that supported this language at the
+ // level of entry->mSupport, but it has now disappeared. At least
+ // entry->mSupport needs to be recalculated, but this is an
+ // indication that the set of installed fonts has changed, so
+ // update all caches.
+ mLastConfig = nullptr; // invalidates caches
+ UpdateFontListInternal(true);
+ return GetLangSupportEntry(aLang, aWithFonts);
+ }
+ }
+
+ return entry;
+}
+
+FcLangResult
+gfxFontconfigUtils::GetBestLangSupport(const FcChar8 *aLang)
+{
+ UpdateFontListInternal();
+
+ LangSupportEntry *entry = GetLangSupportEntry(aLang, false);
+ if (!entry)
+ return FcLangEqual;
+
+ return entry->mSupport;
+}
+
+const nsTArray< nsCountedRef<FcPattern> >&
+gfxFontconfigUtils::GetFontsForLang(const FcChar8 *aLang)
+{
+ LangSupportEntry *entry = GetLangSupportEntry(aLang, true);
+ if (!entry)
+ return mEmptyPatternArray;
+
+ return entry->mFonts;
+}
+
+#ifdef MOZ_BUNDLED_FONTS
+
+void
+gfxFontconfigUtils::ActivateBundledFonts()
+{
+ if (!mBundledFontsInitialized) {
+ mBundledFontsInitialized = true;
+ nsCOMPtr<nsIFile> localDir;
+ nsresult rv = NS_GetSpecialDirectory(NS_GRE_DIR, getter_AddRefs(localDir));
+ if (NS_FAILED(rv)) {
+ return;
+ }
+ if (NS_FAILED(localDir->Append(NS_LITERAL_STRING("fonts")))) {
+ return;
+ }
+ bool isDir;
+ if (NS_FAILED(localDir->IsDirectory(&isDir)) || !isDir) {
+ return;
+ }
+ if (NS_FAILED(localDir->GetNativePath(mBundledFontsPath))) {
+ return;
+ }
+ }
+ if (!mBundledFontsPath.IsEmpty()) {
+ FcConfigAppFontAddDir(nullptr, (const FcChar8*)mBundledFontsPath.get());
+ }
+}
+
+#endif
+
+gfxFontconfigFontBase::gfxFontconfigFontBase(cairo_scaled_font_t *aScaledFont,
+ FcPattern *aPattern,
+ gfxFontEntry *aFontEntry,
+ const gfxFontStyle *aFontStyle)
+ : gfxFT2FontBase(aScaledFont, aFontEntry, aFontStyle)
+ , mPattern(aPattern)
+{
+}
+