The Tor Browser: gfx/thebes/gfxFontconfigUtils.h@6474c204b198 (annotated)

gfx/thebes/gfxFontconfigUtils.h@6474c204b198 (annotated)

gfx/thebes/gfxFontconfigUtils.h

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- 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 / annotate

gfx/thebes/gfxFontconfigUtils.h@6474c204b198 (annotated)

gfx/thebes/gfxFontconfigUtils.h