mirror of
https://github.com/mozilla/gecko-dev.git
synced 2025-02-25 20:01:50 +00:00
1e295dc3cc
This replaces and extends the "hidden" flag we currently use on macOS to mark internal system fonts like .LastResort and .Keyboard that should not be exposed; rather than just a boolean "hidden" flag we'll have several levels of visibility, some of which the user may opt in to exposing (at the cost of potentially becoming more fingerprintable). The current patch assumes three levels besides always-hidden: Base - fonts that are part of the base OS install and always available LangPack - fonts that are provided by the OS subject to user's chosen language options User - user-installed fonts that were not provided by the OS (This categorization may be subject to revision as we learn more about real-world needs and configurations.) Differential Revision: https://phabricator.services.mozilla.com/D66124 --HG-- extra : moz-landing-system : lando
355 lines
11 KiB
C++
355 lines
11 KiB
C++
/* -*- 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 GFX_GDIFONTLIST_H
|
|
#define GFX_GDIFONTLIST_H
|
|
|
|
#include "mozilla/FontPropertyTypes.h"
|
|
#include "mozilla/MemoryReporting.h"
|
|
#include "gfxWindowsPlatform.h"
|
|
#include "gfxPlatformFontList.h"
|
|
#include "nsGkAtoms.h"
|
|
#include "mozilla/gfx/UnscaledFontGDI.h"
|
|
|
|
#include <windows.h>
|
|
|
|
class AutoDC // get the global device context, and auto-release it on
|
|
// destruction
|
|
{
|
|
public:
|
|
AutoDC() { mDC = ::GetDC(nullptr); }
|
|
|
|
~AutoDC() { ::ReleaseDC(nullptr, mDC); }
|
|
|
|
HDC GetDC() { return mDC; }
|
|
|
|
private:
|
|
HDC mDC;
|
|
};
|
|
|
|
class AutoSelectFont // select a font into the given DC, and auto-restore
|
|
{
|
|
public:
|
|
AutoSelectFont(HDC aDC, LOGFONTW* aLogFont) : mOwnsFont(false) {
|
|
mFont = ::CreateFontIndirectW(aLogFont);
|
|
if (mFont) {
|
|
mOwnsFont = true;
|
|
mDC = aDC;
|
|
mOldFont = (HFONT)::SelectObject(aDC, mFont);
|
|
} else {
|
|
mOldFont = nullptr;
|
|
}
|
|
}
|
|
|
|
AutoSelectFont(HDC aDC, HFONT aFont) : mOwnsFont(false) {
|
|
mDC = aDC;
|
|
mFont = aFont;
|
|
mOldFont = (HFONT)::SelectObject(aDC, aFont);
|
|
}
|
|
|
|
~AutoSelectFont() {
|
|
if (mOldFont) {
|
|
::SelectObject(mDC, mOldFont);
|
|
if (mOwnsFont) {
|
|
::DeleteObject(mFont);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool IsValid() const { return mFont != nullptr; }
|
|
|
|
HFONT GetFont() const { return mFont; }
|
|
|
|
private:
|
|
HDC mDC;
|
|
HFONT mFont;
|
|
HFONT mOldFont;
|
|
bool mOwnsFont;
|
|
};
|
|
|
|
/**
|
|
* List of different types of fonts we support on Windows.
|
|
* These can generally be lumped in to 3 categories where we have to
|
|
* do special things: Really old fonts bitmap and vector fonts (device
|
|
* and raster), Type 1 fonts, and TrueType/OpenType fonts.
|
|
*
|
|
* This list is sorted in order from least prefered to most prefered.
|
|
* We prefer Type1 fonts over OpenType fonts to avoid falling back to
|
|
* things like Arial (opentype) when you ask for Helvetica (type1)
|
|
**/
|
|
enum gfxWindowsFontType {
|
|
GFX_FONT_TYPE_UNKNOWN = 0,
|
|
GFX_FONT_TYPE_DEVICE,
|
|
GFX_FONT_TYPE_RASTER,
|
|
GFX_FONT_TYPE_TRUETYPE,
|
|
GFX_FONT_TYPE_PS_OPENTYPE,
|
|
GFX_FONT_TYPE_TT_OPENTYPE,
|
|
GFX_FONT_TYPE_TYPE1
|
|
};
|
|
|
|
// A single member of a font family (i.e. a single face, such as Times Italic)
|
|
// represented as a LOGFONT that will resolve to the correct face.
|
|
// This replaces FontEntry from gfxWindowsFonts.h/cpp.
|
|
class GDIFontEntry final : public gfxFontEntry {
|
|
public:
|
|
LPLOGFONTW GetLogFont() { return &mLogFont; }
|
|
|
|
nsresult ReadCMAP(FontInfoData* aFontInfoData = nullptr) override;
|
|
|
|
void FillLogFont(LOGFONTW* aLogFont, LONG aWeight, gfxFloat aSize);
|
|
|
|
static gfxWindowsFontType DetermineFontType(const NEWTEXTMETRICW& metrics,
|
|
DWORD fontType) {
|
|
gfxWindowsFontType feType;
|
|
if (metrics.ntmFlags & NTM_TYPE1)
|
|
feType = GFX_FONT_TYPE_TYPE1;
|
|
else if (metrics.ntmFlags & NTM_PS_OPENTYPE)
|
|
feType = GFX_FONT_TYPE_PS_OPENTYPE;
|
|
else if (metrics.ntmFlags & NTM_TT_OPENTYPE)
|
|
feType = GFX_FONT_TYPE_TT_OPENTYPE;
|
|
else if (fontType == TRUETYPE_FONTTYPE)
|
|
feType = GFX_FONT_TYPE_TRUETYPE;
|
|
else if (fontType == RASTER_FONTTYPE)
|
|
feType = GFX_FONT_TYPE_RASTER;
|
|
else if (fontType == DEVICE_FONTTYPE)
|
|
feType = GFX_FONT_TYPE_DEVICE;
|
|
else
|
|
feType = GFX_FONT_TYPE_UNKNOWN;
|
|
|
|
return feType;
|
|
}
|
|
|
|
bool IsType1() const { return (mFontType == GFX_FONT_TYPE_TYPE1); }
|
|
|
|
bool IsTrueType() const {
|
|
return (mFontType == GFX_FONT_TYPE_TRUETYPE ||
|
|
mFontType == GFX_FONT_TYPE_PS_OPENTYPE ||
|
|
mFontType == GFX_FONT_TYPE_TT_OPENTYPE);
|
|
}
|
|
|
|
virtual bool SupportsRange(uint8_t range) {
|
|
return mUnicodeRanges.test(range);
|
|
}
|
|
|
|
virtual bool SkipDuringSystemFallback() {
|
|
return !HasCmapTable(); // explicitly skip non-SFNT fonts
|
|
}
|
|
|
|
virtual bool TestCharacterMap(uint32_t aCh);
|
|
|
|
virtual void AddSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf,
|
|
FontListSizes* aSizes) const;
|
|
|
|
gfxFontEntry* Clone() const override;
|
|
|
|
// GDI backend doesn't support font variations:
|
|
bool HasVariations() override { return false; }
|
|
void GetVariationAxes(nsTArray<gfxFontVariationAxis>&) override {}
|
|
void GetVariationInstances(nsTArray<gfxFontVariationInstance>&) override {}
|
|
|
|
// create a font entry for a font with a given name
|
|
static GDIFontEntry* CreateFontEntry(const nsACString& aName,
|
|
gfxWindowsFontType aFontType,
|
|
SlantStyleRange aStyle,
|
|
WeightRange aWeight,
|
|
StretchRange aStretch,
|
|
gfxUserFontData* aUserFontData);
|
|
|
|
gfxWindowsFontType mFontType;
|
|
bool mForceGDI;
|
|
|
|
gfxSparseBitSet mUnicodeRanges;
|
|
|
|
protected:
|
|
friend class gfxGDIFont;
|
|
|
|
GDIFontEntry(const nsACString& aFaceName, gfxWindowsFontType aFontType,
|
|
SlantStyleRange aStyle, WeightRange aWeight,
|
|
StretchRange aStretch, gfxUserFontData* aUserFontData);
|
|
|
|
void InitLogFont(const nsACString& aName, gfxWindowsFontType aFontType);
|
|
|
|
gfxFont* CreateFontInstance(const gfxFontStyle* aFontStyle) override;
|
|
|
|
virtual nsresult CopyFontTable(uint32_t aTableTag,
|
|
nsTArray<uint8_t>& aBuffer) override;
|
|
|
|
already_AddRefed<mozilla::gfx::UnscaledFontGDI> LookupUnscaledFont(
|
|
HFONT aFont);
|
|
|
|
LOGFONTW mLogFont;
|
|
|
|
mozilla::ThreadSafeWeakPtr<mozilla::gfx::UnscaledFontGDI> mUnscaledFont;
|
|
};
|
|
|
|
// a single font family, referencing one or more faces
|
|
class GDIFontFamily final : public gfxFontFamily {
|
|
public:
|
|
GDIFontFamily(const nsACString& aName, FontVisibility aVisibility)
|
|
: gfxFontFamily(aName, aVisibility),
|
|
mWindowsFamily(0),
|
|
mWindowsPitch(0),
|
|
mCharset() {}
|
|
|
|
virtual void FindStyleVariations(FontInfoData* aFontInfoData = nullptr);
|
|
|
|
bool FilterForFontList(nsAtom* aLangGroup,
|
|
const nsACString& aGeneric) const final {
|
|
return !IsSymbolFontFamily() && SupportsLangGroup(aLangGroup) &&
|
|
MatchesGenericFamily(aGeneric);
|
|
}
|
|
|
|
protected:
|
|
friend class gfxGDIFontList;
|
|
|
|
// helpers for FilterForFontList
|
|
bool IsSymbolFontFamily() const { return mCharset.test(SYMBOL_CHARSET); }
|
|
|
|
bool MatchesGenericFamily(const nsACString& aGeneric) const {
|
|
if (aGeneric.IsEmpty()) {
|
|
return true;
|
|
}
|
|
|
|
// Japanese 'Mincho' fonts do not belong to FF_MODERN even if
|
|
// they are fixed pitch because they have variable stroke width.
|
|
if (mWindowsFamily == FF_ROMAN && mWindowsPitch & FIXED_PITCH) {
|
|
return aGeneric.EqualsLiteral("monospace");
|
|
}
|
|
|
|
// Japanese 'Gothic' fonts do not belong to FF_SWISS even if
|
|
// they are variable pitch because they have constant stroke width.
|
|
if (mWindowsFamily == FF_MODERN && mWindowsPitch & VARIABLE_PITCH) {
|
|
return aGeneric.EqualsLiteral("sans-serif");
|
|
}
|
|
|
|
// All other fonts will be grouped correctly using family...
|
|
switch (mWindowsFamily) {
|
|
case FF_DONTCARE:
|
|
return false;
|
|
case FF_ROMAN:
|
|
return aGeneric.EqualsLiteral("serif");
|
|
case FF_SWISS:
|
|
return aGeneric.EqualsLiteral("sans-serif");
|
|
case FF_MODERN:
|
|
return aGeneric.EqualsLiteral("monospace");
|
|
case FF_SCRIPT:
|
|
return aGeneric.EqualsLiteral("cursive");
|
|
case FF_DECORATIVE:
|
|
return aGeneric.EqualsLiteral("fantasy");
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool SupportsLangGroup(nsAtom* aLangGroup) const {
|
|
if (!aLangGroup || aLangGroup == nsGkAtoms::Unicode) {
|
|
return true;
|
|
}
|
|
|
|
int16_t bit = -1;
|
|
|
|
/* map our langgroup names in to Windows charset bits */
|
|
if (aLangGroup == nsGkAtoms::x_western) {
|
|
bit = ANSI_CHARSET;
|
|
} else if (aLangGroup == nsGkAtoms::Japanese) {
|
|
bit = SHIFTJIS_CHARSET;
|
|
} else if (aLangGroup == nsGkAtoms::ko) {
|
|
bit = HANGEUL_CHARSET;
|
|
} else if (aLangGroup == nsGkAtoms::zh_cn) {
|
|
bit = GB2312_CHARSET;
|
|
} else if (aLangGroup == nsGkAtoms::zh_tw) {
|
|
bit = CHINESEBIG5_CHARSET;
|
|
} else if (aLangGroup == nsGkAtoms::el) {
|
|
bit = GREEK_CHARSET;
|
|
} else if (aLangGroup == nsGkAtoms::he) {
|
|
bit = HEBREW_CHARSET;
|
|
} else if (aLangGroup == nsGkAtoms::ar) {
|
|
bit = ARABIC_CHARSET;
|
|
} else if (aLangGroup == nsGkAtoms::x_cyrillic) {
|
|
bit = RUSSIAN_CHARSET;
|
|
} else if (aLangGroup == nsGkAtoms::th) {
|
|
bit = THAI_CHARSET;
|
|
}
|
|
|
|
if (bit != -1) {
|
|
return mCharset.test(bit);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
uint8_t mWindowsFamily;
|
|
uint8_t mWindowsPitch;
|
|
|
|
gfxSparseBitSet mCharset;
|
|
|
|
private:
|
|
static int CALLBACK FamilyAddStylesProc(const ENUMLOGFONTEXW* lpelfe,
|
|
const NEWTEXTMETRICEXW* nmetrics,
|
|
DWORD fontType, LPARAM data);
|
|
};
|
|
|
|
class gfxGDIFontList final : public gfxPlatformFontList {
|
|
public:
|
|
static gfxGDIFontList* PlatformFontList() {
|
|
return static_cast<gfxGDIFontList*>(sPlatformFontList);
|
|
}
|
|
|
|
// initialize font lists
|
|
virtual nsresult InitFontListForPlatform() override;
|
|
|
|
gfxFontFamily* CreateFontFamily(const nsACString& aName,
|
|
FontVisibility aVisibility) const override;
|
|
|
|
bool FindAndAddFamilies(mozilla::StyleGenericFontFamily aGeneric,
|
|
const nsACString& aFamily,
|
|
nsTArray<FamilyAndGeneric>* aOutput,
|
|
FindFamiliesFlags aFlags,
|
|
gfxFontStyle* aStyle = nullptr,
|
|
gfxFloat aDevToCssSize = 1.0) override;
|
|
|
|
virtual gfxFontEntry* LookupLocalFont(const nsACString& aFontName,
|
|
WeightRange aWeightForEntry,
|
|
StretchRange aStretchForEntry,
|
|
SlantStyleRange aStyleForEntry);
|
|
|
|
virtual gfxFontEntry* MakePlatformFont(const nsACString& aFontName,
|
|
WeightRange aWeightForEntry,
|
|
StretchRange aStretchForEntry,
|
|
SlantStyleRange aStyleForEntry,
|
|
const uint8_t* aFontData,
|
|
uint32_t aLength);
|
|
|
|
virtual void AddSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf,
|
|
FontListSizes* aSizes) const;
|
|
virtual void AddSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf,
|
|
FontListSizes* aSizes) const;
|
|
|
|
protected:
|
|
FontFamily GetDefaultFontForPlatform(const gfxFontStyle* aStyle) override;
|
|
|
|
private:
|
|
friend class gfxWindowsPlatform;
|
|
|
|
gfxGDIFontList();
|
|
|
|
nsresult GetFontSubstitutes();
|
|
|
|
static int CALLBACK EnumFontFamExProc(ENUMLOGFONTEXW* lpelfe,
|
|
NEWTEXTMETRICEXW* lpntme,
|
|
DWORD fontType, LPARAM lParam);
|
|
|
|
virtual already_AddRefed<FontInfoData> CreateFontInfoData();
|
|
|
|
#ifdef MOZ_BUNDLED_FONTS
|
|
void ActivateBundledFonts();
|
|
#endif
|
|
|
|
FontFamilyTable mFontSubstitutes;
|
|
nsTArray<nsCString> mNonExistingFonts;
|
|
};
|
|
|
|
#endif /* GFX_GDIFONTLIST_H */
|