The Tor Browser: comparison gfx/thebes/gfxFontconfigUtils.h

--1:000000000000
+:78ff7f0602d8
+/* -*- 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/. */
+#ifndef GFX_FONTCONFIG_UTILS_H
+#define GFX_FONTCONFIG_UTILS_H
+#include "gfxPlatform.h"
+#include "mozilla/MathAlgorithms.h"
+#include "nsAutoRef.h"
+#include "nsTArray.h"
+#include "nsTHashtable.h"
+#include "nsISupportsImpl.h"
+#include <fontconfig/fontconfig.h>
+template <>
+class nsAutoRefTraits<FcPattern> : public nsPointerRefTraits<FcPattern>
+{
+public:
+static void Release(FcPattern *ptr) { FcPatternDestroy(ptr); }
+static void AddRef(FcPattern *ptr) { FcPatternReference(ptr); }
+};
+template <>
+class nsAutoRefTraits<FcFontSet> : public nsPointerRefTraits<FcFontSet>
+{
+public:
+static void Release(FcFontSet *ptr) { FcFontSetDestroy(ptr); }
+};
+template <>
+class nsAutoRefTraits<FcCharSet> : public nsPointerRefTraits<FcCharSet>
+{
+public:
+static void Release(FcCharSet *ptr) { FcCharSetDestroy(ptr); }
+};
+class gfxIgnoreCaseCStringComparator
+{
+public:
+bool Equals(const nsACString& a, const nsACString& b) const
+{
+return nsCString(a).Equals(b, nsCaseInsensitiveCStringComparator());
+}
+bool LessThan(const nsACString& a, const nsACString& b) const
+{
+return a < b;
+}
+};
+class gfxFontconfigUtils {
+public:
+gfxFontconfigUtils();
+static gfxFontconfigUtils* GetFontconfigUtils() {
+if (!sUtils)
+sUtils = new gfxFontconfigUtils();
+return sUtils;
+}
+static void Shutdown();
+nsresult GetFontList(nsIAtom *aLangGroup,
+const nsACString& aGenericFamily,
+nsTArray<nsString>& aListOfFonts);
+nsresult UpdateFontList();
+nsresult ResolveFontName(const nsAString& aFontName,
+gfxPlatform::FontResolverCallback aCallback,
+void *aClosure, bool& aAborted);
+nsresult GetStandardFamilyName(const nsAString& aFontName, nsAString& aFamilyName);
+const nsTArray< nsCountedRef<FcPattern> >&
+GetFontsForFamily(const FcChar8 *aFamilyName);
+const nsTArray< nsCountedRef<FcPattern> >&
+GetFontsForFullname(const FcChar8 *aFullname);
+// Returns the best support that any font offers for |aLang|.
+FcLangResult GetBestLangSupport(const FcChar8 *aLang);
+// Returns the fonts offering this best level of support.
+const nsTArray< nsCountedRef<FcPattern> >&
+GetFontsForLang(const FcChar8 *aLang);
+// Retuns the language support for a fontconfig font pattern
+static FcLangResult GetLangSupport(FcPattern *aFont, const FcChar8 *aLang);
+// Conversions between FcChar8*, which is unsigned char*,
+// and (signed) char*, that check the type of the argument.
+static const FcChar8 *ToFcChar8(const char *aCharPtr)
+{
+return reinterpret_cast<const FcChar8*>(aCharPtr);
+}
+static const FcChar8 *ToFcChar8(const nsCString& aCString)
+{
+return ToFcChar8(aCString.get());
+}
+static const char *ToCString(const FcChar8 *aChar8Ptr)
+{
+return reinterpret_cast<const char*>(aChar8Ptr);
+}
+static uint8_t FcSlantToThebesStyle(int aFcSlant);
+static uint8_t GetThebesStyle(FcPattern *aPattern); // slant
+static uint16_t GetThebesWeight(FcPattern *aPattern);
+static int16_t GetThebesStretch(FcPattern *aPattern);
+static int GetFcSlant(const gfxFontStyle& aFontStyle);
+// Returns a precise FC_WEIGHT from |aBaseWeight|,
+// which is a CSS absolute weight / 100.
+static int FcWeightForBaseWeight(int8_t aBaseWeight);
+static int FcWidthForThebesStretch(int16_t aStretch);
+static bool GetFullnameFromFamilyAndStyle(FcPattern *aFont,
+nsACString *aFullname);
+// This doesn't consider which faces exist, and so initializes the pattern
+// using a guessed weight, and doesn't consider sizeAdjust.
+static nsReturnRef<FcPattern>
+NewPattern(const nsTArray<nsString>& aFamilies,
+const gfxFontStyle& aFontStyle, const char *aLang);
+/**
+* @param aLangGroup [in] a Mozilla langGroup.
+* @param aFcLang [out] returns a language suitable for fontconfig
+*        matching |aLangGroup| or an empty string if no match is found.
+*/
+static void GetSampleLangForGroup(nsIAtom *aLangGroup,
+nsACString *aFcLang);
+protected:
+// Base class for hash table entries with case-insensitive FcChar8
+// string keys.
+class FcStrEntryBase : public PLDHashEntryHdr {
+public:
+typedef const FcChar8 *KeyType;
+typedef const FcChar8 *KeyTypePointer;
+static KeyTypePointer KeyToPointer(KeyType aKey) { return aKey; }
+// Case-insensitive hash.
+//
+// fontconfig always ignores case of ASCII characters in family
+// names and languages, but treatment of whitespace in families is
+// not consistent.  FcFontSort and FcFontMatch ignore whitespace
+// except for whitespace in the first character, while FcFontList
+// and config subsitution tests require whitespace to match
+// exactly.  CSS 2.1 implies that whitespace is important in the
+// font-family property.  FcStrCmpIgnoreCase considers whitespace
+// important.
+static PLDHashNumber HashKey(const FcChar8 *aKey) {
+uint32_t hash = 0;
+for (const FcChar8 *c = aKey; *c != '\0'; ++c) {
+hash = mozilla::RotateLeft(hash, 3) ^ FcToLower(*c);
+}
+return hash;
+}
+enum { ALLOW_MEMMOVE = true };
+};
+public:
+// Hash entry with a dependent const FcChar8* pointer to an external
+// string for a key (and no data).  The user must ensure that the string
+// associated with the pointer is not destroyed.  This entry type is
+// useful for family name keys as the family name string is held in the
+// font pattern.
+class DepFcStrEntry : public FcStrEntryBase {
+public:
+// When constructing a new entry in the hashtable, the key is left
+// nullptr.  The caller of PutEntry() must fill in mKey when nullptr.
+// This provides a mechanism for the caller of PutEntry() to determine
+// whether the entry has been initialized.
+DepFcStrEntry(KeyTypePointer aName)
+: mKey(nullptr) { }
+DepFcStrEntry(const DepFcStrEntry& toCopy)
+: mKey(toCopy.mKey) { }
+bool KeyEquals(KeyTypePointer aKey) const {
+return FcStrCmpIgnoreCase(aKey, mKey) == 0;
+}
+const FcChar8 *mKey;
+};
+// Hash entry that uses a copy of an FcChar8 string to store the key.
+// This entry type is useful for language keys, as languages are usually
+// not stored as strings in font patterns.
+class CopiedFcStrEntry : public FcStrEntryBase {
+public:
+// When constructing a new entry in the hashtable, the key is void.
+// The caller of PutEntry() must call InitKey() when IsKeyInitialized()
+// returns false.  This provides a mechanism for the caller of
+// PutEntry() to determine whether the entry has been initialized.
+CopiedFcStrEntry(KeyTypePointer aName) {
+mKey.SetIsVoid(true);
+}
+CopiedFcStrEntry(const CopiedFcStrEntry& toCopy)
+: mKey(toCopy.mKey) { }
+bool KeyEquals(KeyTypePointer aKey) const {
+return FcStrCmpIgnoreCase(aKey, ToFcChar8(mKey)) == 0;
+}
+bool IsKeyInitialized() { return !mKey.IsVoid(); }
+void InitKey(const FcChar8* aKey) { mKey.Assign(ToCString(aKey)); }
+private:
+nsCString mKey;
+};
+protected:
+class FontsByFcStrEntry : public DepFcStrEntry {
+public:
+FontsByFcStrEntry(KeyTypePointer aName)
+: DepFcStrEntry(aName) { }
+FontsByFcStrEntry(const FontsByFcStrEntry& toCopy)
+: DepFcStrEntry(toCopy), mFonts(toCopy.mFonts) { }
+bool AddFont(FcPattern *aFont) {
+return mFonts.AppendElement(aFont) != nullptr;
+}
+const nsTArray< nsCountedRef<FcPattern> >& GetFonts() {
+return mFonts;
+}
+private:
+nsTArray< nsCountedRef<FcPattern> > mFonts;
+};
+// FontsByFullnameEntry is similar to FontsByFcStrEntry (used for
+// mFontsByFamily) except for two differences:
+//
+// * The font does not always contain a single string for the fullname, so
+//   the key is sometimes a combination of family and style.
+//
+// * There is usually only one font.
+class FontsByFullnameEntry : public DepFcStrEntry {
+public:
+// When constructing a new entry in the hashtable, the key is left
+// nullptr.  The caller of PutEntry() is must fill in mKey when adding
+// the first font if the key is not derived from the family and style.
+// If the key is derived from family and style, a font must be added.
+FontsByFullnameEntry(KeyTypePointer aName)
+: DepFcStrEntry(aName) { }
+FontsByFullnameEntry(const FontsByFullnameEntry& toCopy)
+: DepFcStrEntry(toCopy), mFonts(toCopy.mFonts) { }
+bool KeyEquals(KeyTypePointer aKey) const;
+bool AddFont(FcPattern *aFont) {
+return mFonts.AppendElement(aFont) != nullptr;
+}
+const nsTArray< nsCountedRef<FcPattern> >& GetFonts() {
+return mFonts;
+}
+// Don't memmove the nsAutoTArray.
+enum { ALLOW_MEMMOVE = false };
+private:
+// There is usually only one font, but sometimes more.
+nsAutoTArray<nsCountedRef<FcPattern>,1> mFonts;
+};
+class LangSupportEntry : public CopiedFcStrEntry {
+public:
+LangSupportEntry(KeyTypePointer aName)
+: CopiedFcStrEntry(aName) { }
+LangSupportEntry(const LangSupportEntry& toCopy)
+: CopiedFcStrEntry(toCopy), mSupport(toCopy.mSupport) { }
+FcLangResult mSupport;
+nsTArray< nsCountedRef<FcPattern> > mFonts;
+};
+static gfxFontconfigUtils* sUtils;
+bool IsExistingFamily(const nsCString& aFamilyName);
+nsresult GetFontListInternal(nsTArray<nsCString>& aListOfFonts,
+nsIAtom *aLangGroup);
+nsresult UpdateFontListInternal(bool aForce = false);
+void AddFullnameEntries();
+LangSupportEntry *GetLangSupportEntry(const FcChar8 *aLang,
+bool aWithFonts);
+// mFontsByFamily and mFontsByFullname contain entries only for families
+// and fullnames for which there are fonts.
+nsTHashtable<FontsByFcStrEntry> mFontsByFamily;
+nsTHashtable<FontsByFullnameEntry> mFontsByFullname;
+// mLangSupportTable contains an entry for each language that has been
+// looked up through GetLangSupportEntry, even when the language is not
+// supported.
+nsTHashtable<LangSupportEntry> mLangSupportTable;
+const nsTArray< nsCountedRef<FcPattern> > mEmptyPatternArray;
+nsTArray<nsCString> mAliasForMultiFonts;
+FcConfig *mLastConfig;
+};
+#endif /* GFX_FONTCONFIG_UTILS_H */

The Tor Browser / file comparison

comparison: gfx/thebes/gfxFontconfigUtils.h

gfx/thebes/gfxFontconfigUtils.h