-
Notifications
You must be signed in to change notification settings - Fork 54
/
gfxMacPlatformFontList.h
251 lines (189 loc) · 8.95 KB
/
gfxMacPlatformFontList.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* 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 gfxMacPlatformFontList_H_
#define gfxMacPlatformFontList_H_
#include <CoreFoundation/CoreFoundation.h>
#include "mozilla/FontPropertyTypes.h"
#include "mozilla/MemoryReporting.h"
#include "nsDataHashtable.h"
#include "nsRefPtrHashtable.h"
#include "gfxPlatformFontList.h"
#include "gfxPlatform.h"
#include "gfxPlatformMac.h"
#include "nsUnicharUtils.h"
#include "nsTArray.h"
#include "mozilla/LookAndFeel.h"
#include "mozilla/gfx/UnscaledFontMac.h"
class gfxMacPlatformFontList;
// a single member of a font family (i.e. a single face, such as Times Italic)
class MacOSFontEntry : public gfxFontEntry {
public:
friend class gfxMacPlatformFontList;
friend class gfxMacFont;
MacOSFontEntry(const nsACString& aPostscriptName, WeightRange aWeight,
bool aIsStandardFace = false, double aSizeHint = 0.0);
// for use with data fonts
MacOSFontEntry(const nsACString& aPostscriptName, CGFontRef aFontRef,
WeightRange aWeight, StretchRange aStretch,
SlantStyleRange aStyle, bool aIsDataUserFont, bool aIsLocal);
virtual ~MacOSFontEntry() {
if (mTrakTable) {
hb_blob_destroy(mTrakTable);
}
::CGFontRelease(mFontRef);
}
gfxFontEntry* Clone() const override;
CGFontRef GetFontRef();
// override gfxFontEntry table access function to bypass table cache,
// use CGFontRef API to get direct access to system font data
hb_blob_t* GetFontTable(uint32_t aTag) override;
void AddSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf,
FontListSizes* aSizes) const override;
nsresult ReadCMAP(FontInfoData* aFontInfoData = nullptr) override;
bool RequiresAATLayout() const { return mRequiresAAT; }
bool HasVariations() override;
void GetVariationAxes(
nsTArray<gfxFontVariationAxis>& aVariationAxes) override;
void GetVariationInstances(
nsTArray<gfxFontVariationInstance>& aInstances) override;
bool IsCFF();
// Return true if the font has a 'trak' table (and we can successfully
// interpret it), otherwise false. This will load and cache the table
// the first time it is called.
bool HasTrackingTable();
bool SupportsOpenTypeFeature(Script aScript, uint32_t aFeatureTag) override;
// Return the tracking (in font units) to be applied for the given size.
// (This is a floating-point number because of possible interpolation.)
float TrackingForCSSPx(float aPointSize) const;
protected:
gfxFont* CreateFontInstance(const gfxFontStyle* aFontStyle) override;
bool HasFontTable(uint32_t aTableTag) override;
// Helper for HasTrackingTable; check/parse the table and cache pointers
// to the subtables we need. Returns false on failure, in which case the
// table is unusable.
bool ParseTrakTable();
static void DestroyBlobFunc(void* aUserData);
CGFontRef
mFontRef; // owning reference to the CGFont, released on destruction
double mSizeHint;
bool mFontRefInitialized;
bool mRequiresAAT;
bool mIsCFF;
bool mIsCFFInitialized;
bool mHasVariations;
bool mHasVariationsInitialized;
bool mHasAATSmallCaps;
bool mHasAATSmallCapsInitialized;
bool mCheckedForTracking;
// To work around Core Text's mishandling of the default value for 'opsz',
// we need to record whether the font has an a optical size axis, what its
// range and default values are, and a usable close-to-default alternative.
// (See bug 1457417 for details.)
// These fields are used by gfxMacFont, but stored in the font entry so
// that only a single font instance needs to inspect the available
// variations.
bool mCheckedForOpszAxis;
bool mHasOpszAxis;
gfxFontVariationAxis mOpszAxis;
float mAdjustedDefaultOpsz;
nsTHashtable<nsUint32HashKey> mAvailableTables;
mozilla::ThreadSafeWeakPtr<mozilla::gfx::UnscaledFontMac> mUnscaledFont;
// For AAT font being shaped by Core Text, a strong reference to the 'trak'
// table (if present).
hb_blob_t* mTrakTable;
// Cached pointers to tables within 'trak', initialized by ParseTrakTable.
const mozilla::AutoSwap_PRInt16* mTrakValues;
const mozilla::AutoSwap_PRInt32* mTrakSizeTable;
uint16_t mNumTrakSizes;
};
class gfxMacPlatformFontList : public gfxPlatformFontList {
public:
static gfxMacPlatformFontList* PlatformFontList() {
return static_cast<gfxMacPlatformFontList*>(sPlatformFontList);
}
gfxFontFamily* CreateFontFamily(const nsACString& aName) const override;
static int32_t AppleWeightToCSSWeight(int32_t aAppleWeight);
bool GetStandardFamilyName(const nsCString& aFontName,
nsACString& aFamilyName) override;
gfxFontEntry* LookupLocalFont(const nsACString& aFontName,
WeightRange aWeightForEntry,
StretchRange aStretchForEntry,
SlantStyleRange aStyleForEntry) override;
gfxFontEntry* MakePlatformFont(const nsACString& aFontName,
WeightRange aWeightForEntry,
StretchRange aStretchForEntry,
SlantStyleRange aStyleForEntry,
const uint8_t* aFontData,
uint32_t aLength) override;
bool FindAndAddFamilies(const nsACString& aFamily,
nsTArray<FamilyAndGeneric>* aOutput,
FindFamiliesFlags aFlags,
gfxFontStyle* aStyle = nullptr,
gfxFloat aDevToCssSize = 1.0) override;
// lookup the system font for a particular system font type and set
// the name and style characteristics
void LookupSystemFont(mozilla::LookAndFeel::FontID aSystemFontID,
nsACString& aSystemFontName, gfxFontStyle& aFontStyle,
float aDevPixPerCSSPixel);
// Values for the entryType field in FontFamilyListEntry records passed
// from chrome to content process.
enum FontFamilyEntryType {
kStandardFontFamily = 0, // a standard installed font family
kHiddenSystemFontFamily = 1, // hidden system family, not exposed to UI
kTextSizeSystemFontFamily = 2, // name of 'system' font at text sizes
kDisplaySizeSystemFontFamily = 3 // 'system' font at display sizes
};
void ReadSystemFontList(
InfallibleTArray<mozilla::dom::SystemFontListEntry>* aList);
protected:
gfxFontFamily* GetDefaultFontForPlatform(const gfxFontStyle* aStyle) override;
private:
friend class gfxPlatformMac;
gfxMacPlatformFontList();
virtual ~gfxMacPlatformFontList();
// initialize font lists
nsresult InitFontListForPlatform() override;
// special case font faces treated as font families (set via prefs)
void InitSingleFaceList();
// initialize system fonts
void InitSystemFontNames();
// helper function to lookup in both hidden system fonts and normal fonts
gfxFontFamily* FindSystemFontFamily(const nsACString& aFamily);
static void RegisteredFontsChangedNotificationCallback(
CFNotificationCenterRef center, void* observer, CFStringRef name,
const void* object, CFDictionaryRef userInfo);
// attempt to use platform-specific fallback for the given character
// return null if no usable result found
gfxFontEntry* PlatformGlobalFontFallback(
const uint32_t aCh, Script aRunScript, const gfxFontStyle* aMatchStyle,
gfxFontFamily** aMatchedFamily) override;
bool UsesSystemFallback() override { return true; }
already_AddRefed<FontInfoData> CreateFontInfoData() override;
// Add the specified family to mSystemFontFamilies or mFontFamilies.
// Ideally we'd use NSString* instead of CFStringRef here, but this header
// file is included in .cpp files, so we can't use objective C classes here.
// But CFStringRef and NSString* are the same thing anyway (they're
// toll-free bridged).
void AddFamily(CFStringRef aFamily);
void AddFamily(const nsACString& aFamilyName, bool aSystemFont);
void ActivateFontsFromDir(nsIFile* aDir);
#ifdef MOZ_BUNDLED_FONTS
void ActivateBundledFonts();
#endif
enum { kATSGenerationInitial = -1 };
// default font for use with system-wide font fallback
CTFontRef mDefaultFont;
// hidden system fonts used within UI elements, there may be a whole set
// for different locales (e.g. .Helvetica Neue UI, .SF NS Text)
FontFamilyTable mSystemFontFamilies;
// font families that -apple-system maps to
// Pre-10.11 this was always a single font family, such as Lucida Grande
// or Helvetica Neue. For OSX 10.11, Apple uses pair of families
// for the UI, one for text sizes and another for display sizes
bool mUseSizeSensitiveSystemFont;
nsCString mSystemTextFontFamilyName;
nsCString mSystemDisplayFontFamilyName; // only used on OSX 10.11
};
#endif /* gfxMacPlatformFontList_H_ */