summaryrefslogtreecommitdiffstats
path: root/gfx/thebes/gfxFcPlatformFontList.h
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/gfxFcPlatformFontList.h
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/gfxFcPlatformFontList.h')
-rw-r--r--gfx/thebes/gfxFcPlatformFontList.h330
1 files changed, 330 insertions, 0 deletions
diff --git a/gfx/thebes/gfxFcPlatformFontList.h b/gfx/thebes/gfxFcPlatformFontList.h
new file mode 100644
index 000000000..1bc35021e
--- /dev/null
+++ b/gfx/thebes/gfxFcPlatformFontList.h
@@ -0,0 +1,330 @@
+/* -*- 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 GFXFCPLATFORMFONTLIST_H_
+#define GFXFCPLATFORMFONTLIST_H_
+
+#include "gfxFont.h"
+#include "gfxFontEntry.h"
+#include "gfxFT2FontBase.h"
+#include "gfxPlatformFontList.h"
+#include "mozilla/mozalloc.h"
+#include "nsClassHashtable.h"
+
+#include <fontconfig/fontconfig.h>
+#include "ft2build.h"
+#include FT_FREETYPE_H
+#include FT_TRUETYPE_TABLES_H
+#include <cairo.h>
+#include <cairo-ft.h>
+
+#include "gfxFontconfigUtils.h" // xxx - only for nsAutoRefTraits<FcPattern>, etc.
+
+template <>
+class nsAutoRefTraits<FcObjectSet> : public nsPointerRefTraits<FcObjectSet>
+{
+public:
+ static void Release(FcObjectSet *ptr) { FcObjectSetDestroy(ptr); }
+};
+
+template <>
+class nsAutoRefTraits<FcConfig> : public nsPointerRefTraits<FcConfig>
+{
+public:
+ static void Release(FcConfig *ptr) { FcConfigDestroy(ptr); }
+ static void AddRef(FcConfig *ptr) { FcConfigReference(ptr); }
+};
+
+// Helper classes used for clearning out user font data when cairo font
+// face is destroyed. Since multiple faces may use the same data, be
+// careful to assure that the data is only cleared out when all uses
+// expire. The font entry object contains a refptr to FTUserFontData and
+// each cairo font created from that font entry contains a
+// FTUserFontDataRef with a refptr to that same FTUserFontData object.
+
+class FTUserFontData {
+public:
+ NS_INLINE_DECL_REFCOUNTING(FTUserFontData)
+
+ explicit FTUserFontData(FT_Face aFace, const uint8_t* aData)
+ : mFace(aFace), mFontData(aData)
+ {
+ }
+
+ const uint8_t *FontData() const { return mFontData; }
+
+private:
+ ~FTUserFontData()
+ {
+ FT_Done_Face(mFace);
+ if (mFontData) {
+ NS_Free((void*)mFontData);
+ }
+ }
+
+ FT_Face mFace;
+ const uint8_t *mFontData;
+};
+
+class FTUserFontDataRef {
+public:
+ explicit FTUserFontDataRef(FTUserFontData *aUserFontData)
+ : mUserFontData(aUserFontData)
+ {
+ }
+
+ static void Destroy(void* aData) {
+ FTUserFontDataRef* aUserFontDataRef =
+ static_cast<FTUserFontDataRef*>(aData);
+ delete aUserFontDataRef;
+ }
+
+private:
+ RefPtr<FTUserFontData> mUserFontData;
+};
+
+// The names for the font entry and font classes should really
+// the common 'Fc' abbreviation but the gfxPangoFontGroup code already
+// defines versions of these, so use the verbose name for now.
+
+class gfxFontconfigFontEntry : public gfxFontEntry {
+public:
+ // used for system fonts with explicit patterns
+ explicit gfxFontconfigFontEntry(const nsAString& aFaceName,
+ FcPattern* aFontPattern,
+ bool aIgnoreFcCharmap);
+
+ // used for data fonts where the fontentry takes ownership
+ // of the font data and the FT_Face
+ explicit gfxFontconfigFontEntry(const nsAString& aFaceName,
+ uint16_t aWeight,
+ int16_t aStretch,
+ uint8_t aStyle,
+ const uint8_t *aData,
+ FT_Face aFace);
+
+ // used for @font-face local system fonts with explicit patterns
+ explicit gfxFontconfigFontEntry(const nsAString& aFaceName,
+ FcPattern* aFontPattern,
+ uint16_t aWeight,
+ int16_t aStretch,
+ uint8_t aStyle);
+
+ FcPattern* GetPattern() { return mFontPattern; }
+
+ bool SupportsLangGroup(nsIAtom *aLangGroup) const override;
+
+ nsresult ReadCMAP(FontInfoData *aFontInfoData = nullptr) override;
+ bool TestCharacterMap(uint32_t aCh) override;
+
+ hb_blob_t* GetFontTable(uint32_t aTableTag) override;
+
+ void ForgetHBFace() override;
+ void ReleaseGrFace(gr_face* aFace) override;
+
+ double GetAspect();
+
+protected:
+ virtual ~gfxFontconfigFontEntry();
+
+ gfxFont *CreateFontInstance(const gfxFontStyle *aFontStyle,
+ bool aNeedsBold) override;
+
+ // helper method for creating cairo font from pattern
+ cairo_scaled_font_t*
+ CreateScaledFont(FcPattern* aRenderPattern,
+ gfxFloat aAdjustedSize,
+ const gfxFontStyle *aStyle,
+ bool aNeedsBold);
+
+ // override to pull data from FTFace
+ virtual nsresult
+ CopyFontTable(uint32_t aTableTag,
+ nsTArray<uint8_t>& aBuffer) override;
+
+ // if HB or GR faces are gone, close down the FT_Face
+ void MaybeReleaseFTFace();
+
+ // pattern for a single face of a family
+ nsCountedRef<FcPattern> mFontPattern;
+
+ // user font data, when needed
+ RefPtr<FTUserFontData> mUserFontData;
+
+ // FTFace - initialized when needed
+ FT_Face mFTFace;
+ bool mFTFaceInitialized;
+
+ // Whether TestCharacterMap should check the actual cmap rather than asking
+ // fontconfig about character coverage.
+ // We do this for app-bundled (rather than system) fonts, as they may
+ // include color glyphs that fontconfig would overlook, and for fonts
+ // loaded via @font-face.
+ bool mIgnoreFcCharmap;
+
+ double mAspect;
+
+ // data font
+ const uint8_t* mFontData;
+};
+
+class gfxFontconfigFontFamily : public gfxFontFamily {
+public:
+ explicit gfxFontconfigFontFamily(const nsAString& aName) :
+ gfxFontFamily(aName),
+ mContainsAppFonts(false),
+ mHasNonScalableFaces(false)
+ { }
+
+ void FindStyleVariations(FontInfoData *aFontInfoData = nullptr) override;
+
+ // Families are constructed initially with just references to patterns.
+ // When necessary, these are enumerated within FindStyleVariations.
+ void AddFontPattern(FcPattern* aFontPattern);
+
+ void SetFamilyContainsAppFonts(bool aContainsAppFonts)
+ {
+ mContainsAppFonts = aContainsAppFonts;
+ }
+
+ void
+ FindAllFontsForStyle(const gfxFontStyle& aFontStyle,
+ nsTArray<gfxFontEntry*>& aFontEntryList,
+ bool& aNeedsSyntheticBold) override;
+
+protected:
+ virtual ~gfxFontconfigFontFamily() { }
+
+ nsTArray<nsCountedRef<FcPattern> > mFontPatterns;
+
+ bool mContainsAppFonts;
+ bool mHasNonScalableFaces;
+};
+
+class gfxFontconfigFont : public gfxFontconfigFontBase {
+public:
+ gfxFontconfigFont(cairo_scaled_font_t *aScaledFont,
+ FcPattern *aPattern,
+ gfxFloat aAdjustedSize,
+ gfxFontEntry *aFontEntry,
+ const gfxFontStyle *aFontStyle,
+ bool aNeedsBold);
+
+protected:
+ virtual ~gfxFontconfigFont();
+};
+
+class nsILanguageAtomService;
+
+class gfxFcPlatformFontList : public gfxPlatformFontList {
+public:
+ gfxFcPlatformFontList();
+
+ static gfxFcPlatformFontList* PlatformFontList() {
+ return static_cast<gfxFcPlatformFontList*>(sPlatformFontList);
+ }
+
+ // initialize font lists
+ virtual nsresult InitFontListForPlatform() override;
+
+ void GetFontList(nsIAtom *aLangGroup,
+ const nsACString& aGenericFamily,
+ nsTArray<nsString>& aListOfFonts) override;
+
+
+ gfxFontEntry*
+ LookupLocalFont(const nsAString& aFontName, uint16_t aWeight,
+ int16_t aStretch, uint8_t aStyle) override;
+
+ gfxFontEntry*
+ MakePlatformFont(const nsAString& aFontName, uint16_t aWeight,
+ int16_t aStretch,
+ uint8_t aStyle,
+ const uint8_t* aFontData,
+ uint32_t aLength) override;
+
+ bool FindAndAddFamilies(const nsAString& aFamily,
+ nsTArray<gfxFontFamily*>* aOutput,
+ gfxFontStyle* aStyle = nullptr,
+ gfxFloat aDevToCssSize = 1.0) override;
+
+ bool GetStandardFamilyName(const nsAString& aFontName,
+ nsAString& aFamilyName) override;
+
+ FcConfig* GetLastConfig() const { return mLastConfig; }
+
+ // override to use fontconfig lookup for generics
+ void AddGenericFonts(mozilla::FontFamilyType aGenericType,
+ nsIAtom* aLanguage,
+ nsTArray<gfxFontFamily*>& aFamilyList) override;
+
+ void ClearLangGroupPrefFonts() override;
+
+ // clear out cached generic-lang ==> family-list mappings
+ void ClearGenericMappings() {
+ mGenericMappings.Clear();
+ }
+
+ static FT_Library GetFTLibrary();
+
+protected:
+ virtual ~gfxFcPlatformFontList();
+
+ // Add all the font families found in a font set.
+ // aAppFonts indicates whether this is the system or application fontset.
+ void AddFontSetFamilies(FcFontSet* aFontSet, bool aAppFonts);
+
+ // figure out which families fontconfig maps a generic to
+ // (aGeneric assumed already lowercase)
+ PrefFontList* FindGenericFamilies(const nsAString& aGeneric,
+ nsIAtom* aLanguage);
+
+ // are all pref font settings set to use fontconfig generics?
+ bool PrefFontListsUseOnlyGenerics();
+
+ static void CheckFontUpdates(nsITimer *aTimer, void *aThis);
+
+ virtual gfxFontFamily*
+ GetDefaultFontForPlatform(const gfxFontStyle* aStyle) override;
+
+#ifdef MOZ_BUNDLED_FONTS
+ void ActivateBundledFonts();
+ nsCString mBundledFontsPath;
+ bool mBundledFontsInitialized;
+#endif
+
+ // to avoid enumerating all fonts, maintain a mapping of local font
+ // names to family
+ nsBaseHashtable<nsStringHashKey,
+ nsCountedRef<FcPattern>,
+ FcPattern*> mLocalNames;
+
+ // caching generic/lang ==> font family list
+ nsClassHashtable<nsCStringHashKey,
+ PrefFontList> mGenericMappings;
+
+ // Caching family lookups as found by FindAndAddFamilies after resolving
+ // substitutions. The gfxFontFamily objects cached here are owned by the
+ // gfxFcPlatformFontList via its mFamilies table; note that if the main
+ // font list is rebuilt (e.g. due to a fontconfig configuration change),
+ // these pointers will be invalidated. InitFontList() flushes the cache
+ // in this case.
+ nsDataHashtable<nsCStringHashKey,
+ nsTArray<gfxFontFamily*>> mFcSubstituteCache;
+
+ nsCOMPtr<nsITimer> mCheckFontUpdatesTimer;
+ nsCountedRef<FcConfig> mLastConfig;
+
+ // By default, font prefs under Linux are set to simply lookup
+ // via fontconfig the appropriate font for serif/sans-serif/monospace.
+ // Rather than check each time a font pref is used, check them all at startup
+ // and set a boolean to flag the case that non-default user font prefs exist
+ // Note: langGroup == x-math is handled separately
+ bool mAlwaysUseFontconfigGenerics;
+
+ static FT_Library sCairoFTLibrary;
+};
+
+#endif /* GFXPLATFORMFONTLIST_H_ */