mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-24 05:11:16 +00:00
9fc2aa47fc
Now that cbindgen and rust support const generics, it seems more simple. This centralizes all the relevant font constants etc in rust and avoids conversions when going from rust to C++ and vice versa. Differential Revision: https://phabricator.services.mozilla.com/D148847
2599 lines
86 KiB
C++
2599 lines
86 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/. */
|
|
|
|
#include "mozilla/ArrayUtils.h"
|
|
#include "mozilla/FontPropertyTypes.h"
|
|
#include "mozilla/MemoryReporting.h"
|
|
#include "mozilla/intl/OSPreferences.h"
|
|
|
|
#include "gfxDWriteFontList.h"
|
|
#include "gfxDWriteFonts.h"
|
|
#include "nsUnicharUtils.h"
|
|
#include "nsServiceManagerUtils.h"
|
|
#include "nsCharSeparatedTokenizer.h"
|
|
#include "mozilla/Preferences.h"
|
|
#include "mozilla/ProfilerLabels.h"
|
|
#include "mozilla/Sprintf.h"
|
|
#include "mozilla/StaticPrefs_gfx.h"
|
|
#include "mozilla/Telemetry.h"
|
|
#include "mozilla/WindowsProcessMitigations.h"
|
|
#include "mozilla/WindowsVersion.h"
|
|
#include "nsDirectoryServiceUtils.h"
|
|
#include "nsDirectoryServiceDefs.h"
|
|
#include "nsAppDirectoryServiceDefs.h"
|
|
|
|
#include "gfxGDIFontList.h"
|
|
|
|
#include "harfbuzz/hb.h"
|
|
|
|
#include "StandardFonts-win10.inc"
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::gfx;
|
|
using mozilla::intl::OSPreferences;
|
|
|
|
#define LOG_FONTLIST(args) \
|
|
MOZ_LOG(gfxPlatform::GetLog(eGfxLog_fontlist), LogLevel::Debug, args)
|
|
#define LOG_FONTLIST_ENABLED() \
|
|
MOZ_LOG_TEST(gfxPlatform::GetLog(eGfxLog_fontlist), LogLevel::Debug)
|
|
|
|
#define LOG_FONTINIT(args) \
|
|
MOZ_LOG(gfxPlatform::GetLog(eGfxLog_fontinit), LogLevel::Debug, args)
|
|
#define LOG_FONTINIT_ENABLED() \
|
|
MOZ_LOG_TEST(gfxPlatform::GetLog(eGfxLog_fontinit), LogLevel::Debug)
|
|
|
|
#define LOG_CMAPDATA_ENABLED() \
|
|
MOZ_LOG_TEST(gfxPlatform::GetLog(eGfxLog_cmapdata), LogLevel::Debug)
|
|
|
|
static __inline void BuildKeyNameFromFontName(nsACString& aName) {
|
|
ToLowerCase(aName);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// gfxDWriteFontFamily
|
|
|
|
gfxDWriteFontFamily::~gfxDWriteFontFamily() {}
|
|
|
|
static bool GetNameAsUtf8(nsACString& aName, IDWriteLocalizedStrings* aStrings,
|
|
UINT32 aIndex) {
|
|
AutoTArray<WCHAR, 32> name;
|
|
UINT32 length;
|
|
HRESULT hr = aStrings->GetStringLength(aIndex, &length);
|
|
if (FAILED(hr)) {
|
|
return false;
|
|
}
|
|
if (!name.SetLength(length + 1, fallible)) {
|
|
return false;
|
|
}
|
|
hr = aStrings->GetString(aIndex, name.Elements(), length + 1);
|
|
if (FAILED(hr)) {
|
|
return false;
|
|
}
|
|
aName.Truncate();
|
|
AppendUTF16toUTF8(
|
|
Substring(reinterpret_cast<const char16_t*>(name.Elements()),
|
|
name.Length() - 1),
|
|
aName);
|
|
return true;
|
|
}
|
|
|
|
static bool GetEnglishOrFirstName(nsACString& aName,
|
|
IDWriteLocalizedStrings* aStrings) {
|
|
UINT32 englishIdx = 0;
|
|
BOOL exists;
|
|
HRESULT hr = aStrings->FindLocaleName(L"en-us", &englishIdx, &exists);
|
|
if (FAILED(hr) || !exists) {
|
|
// Use 0 index if english is not found.
|
|
englishIdx = 0;
|
|
}
|
|
return GetNameAsUtf8(aName, aStrings, englishIdx);
|
|
}
|
|
|
|
static HRESULT GetDirectWriteFontName(IDWriteFont* aFont,
|
|
nsACString& aFontName) {
|
|
HRESULT hr;
|
|
|
|
RefPtr<IDWriteLocalizedStrings> names;
|
|
hr = aFont->GetFaceNames(getter_AddRefs(names));
|
|
if (FAILED(hr)) {
|
|
return hr;
|
|
}
|
|
|
|
if (!GetEnglishOrFirstName(aFontName, names)) {
|
|
return E_FAIL;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
#define FULLNAME_ID DWRITE_INFORMATIONAL_STRING_FULL_NAME
|
|
#define PSNAME_ID DWRITE_INFORMATIONAL_STRING_POSTSCRIPT_NAME
|
|
|
|
// for use in reading postscript or fullname
|
|
static HRESULT GetDirectWriteFaceName(IDWriteFont* aFont,
|
|
DWRITE_INFORMATIONAL_STRING_ID aWhichName,
|
|
nsACString& aFontName) {
|
|
HRESULT hr;
|
|
|
|
BOOL exists;
|
|
RefPtr<IDWriteLocalizedStrings> infostrings;
|
|
hr = aFont->GetInformationalStrings(aWhichName, getter_AddRefs(infostrings),
|
|
&exists);
|
|
if (FAILED(hr) || !exists) {
|
|
return E_FAIL;
|
|
}
|
|
|
|
if (!GetEnglishOrFirstName(aFontName, infostrings)) {
|
|
return E_FAIL;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
void gfxDWriteFontFamily::FindStyleVariationsLocked(
|
|
FontInfoData* aFontInfoData) {
|
|
HRESULT hr;
|
|
if (mHasStyles) {
|
|
return;
|
|
}
|
|
|
|
mHasStyles = true;
|
|
|
|
gfxPlatformFontList* fp = gfxPlatformFontList::PlatformFontList();
|
|
|
|
bool skipFaceNames =
|
|
mFaceNamesInitialized || !fp->NeedFullnamePostscriptNames();
|
|
bool fontInfoShouldHaveFaceNames = !mFaceNamesInitialized &&
|
|
fp->NeedFullnamePostscriptNames() &&
|
|
aFontInfoData;
|
|
|
|
for (UINT32 i = 0; i < mDWFamily->GetFontCount(); i++) {
|
|
RefPtr<IDWriteFont> font;
|
|
hr = mDWFamily->GetFont(i, getter_AddRefs(font));
|
|
if (FAILED(hr)) {
|
|
// This should never happen.
|
|
NS_WARNING("Failed to get existing font from family.");
|
|
continue;
|
|
}
|
|
|
|
if (font->GetSimulations() != DWRITE_FONT_SIMULATIONS_NONE) {
|
|
// We don't want these in the font list; we'll apply simulations
|
|
// on the fly when appropriate.
|
|
continue;
|
|
}
|
|
|
|
// name
|
|
nsCString fullID(mName);
|
|
nsAutoCString faceName;
|
|
hr = GetDirectWriteFontName(font, faceName);
|
|
if (FAILED(hr)) {
|
|
continue;
|
|
}
|
|
fullID.Append(' ');
|
|
fullID.Append(faceName);
|
|
|
|
// Ignore italic style's "Meiryo" because "Meiryo (Bold) Italic" has
|
|
// non-italic style glyphs as Japanese characters. However, using it
|
|
// causes serious problem if web pages wants some elements to be
|
|
// different style from others only with font-style. For example,
|
|
// <em> and <i> should be rendered as italic in the default style.
|
|
if (fullID.EqualsLiteral("Meiryo Italic") ||
|
|
fullID.EqualsLiteral("Meiryo Bold Italic")) {
|
|
continue;
|
|
}
|
|
|
|
gfxDWriteFontEntry* fe =
|
|
new gfxDWriteFontEntry(fullID, font, mIsSystemFontFamily);
|
|
fe->SetForceGDIClassic(mForceGDIClassic);
|
|
|
|
fe->SetupVariationRanges();
|
|
|
|
AddFontEntryLocked(fe);
|
|
|
|
// postscript/fullname if needed
|
|
nsAutoCString psname, fullname;
|
|
if (fontInfoShouldHaveFaceNames) {
|
|
aFontInfoData->GetFaceNames(fe->Name(), fullname, psname);
|
|
if (!fullname.IsEmpty()) {
|
|
fp->AddFullname(fe, fullname);
|
|
}
|
|
if (!psname.IsEmpty()) {
|
|
fp->AddPostscriptName(fe, psname);
|
|
}
|
|
} else if (!skipFaceNames) {
|
|
hr = GetDirectWriteFaceName(font, PSNAME_ID, psname);
|
|
if (FAILED(hr)) {
|
|
skipFaceNames = true;
|
|
} else if (psname.Length() > 0) {
|
|
fp->AddPostscriptName(fe, psname);
|
|
}
|
|
|
|
hr = GetDirectWriteFaceName(font, FULLNAME_ID, fullname);
|
|
if (FAILED(hr)) {
|
|
skipFaceNames = true;
|
|
} else if (fullname.Length() > 0) {
|
|
fp->AddFullname(fe, fullname);
|
|
}
|
|
}
|
|
|
|
if (LOG_FONTLIST_ENABLED()) {
|
|
nsAutoCString weightString;
|
|
fe->Weight().ToString(weightString);
|
|
LOG_FONTLIST(
|
|
("(fontlist) added (%s) to family (%s)"
|
|
" with style: %s weight: %s stretch: %d psname: %s fullname: %s",
|
|
fe->Name().get(), Name().get(),
|
|
(fe->IsItalic()) ? "italic"
|
|
: (fe->IsOblique() ? "oblique" : "normal"),
|
|
weightString.get(), fe->Stretch().AsScalar(), psname.get(),
|
|
fullname.get()));
|
|
}
|
|
}
|
|
|
|
// assume that if no error, all postscript/fullnames were initialized
|
|
if (!skipFaceNames) {
|
|
mFaceNamesInitialized = true;
|
|
}
|
|
|
|
if (!mAvailableFonts.Length()) {
|
|
NS_WARNING("Family with no font faces in it.");
|
|
}
|
|
|
|
if (mIsBadUnderlineFamily) {
|
|
SetBadUnderlineFonts();
|
|
}
|
|
|
|
CheckForSimpleFamily();
|
|
if (mIsSimpleFamily) {
|
|
for (auto& f : mAvailableFonts) {
|
|
if (f) {
|
|
static_cast<gfxDWriteFontEntry*>(f.get())->mMayUseGDIAccess = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void gfxDWriteFontFamily::ReadFaceNames(gfxPlatformFontList* aPlatformFontList,
|
|
bool aNeedFullnamePostscriptNames,
|
|
FontInfoData* aFontInfoData) {
|
|
// if all needed names have already been read, skip
|
|
if (mOtherFamilyNamesInitialized &&
|
|
(mFaceNamesInitialized || !aNeedFullnamePostscriptNames)) {
|
|
return;
|
|
}
|
|
|
|
// If we've been passed a FontInfoData, we skip the DWrite implementation
|
|
// here and fall back to the generic code which will use that info.
|
|
if (!aFontInfoData) {
|
|
// DirectWrite version of this will try to read
|
|
// postscript/fullnames via DirectWrite API
|
|
FindStyleVariations();
|
|
}
|
|
|
|
// fallback to looking up via name table
|
|
if (!mOtherFamilyNamesInitialized || !mFaceNamesInitialized) {
|
|
gfxFontFamily::ReadFaceNames(aPlatformFontList,
|
|
aNeedFullnamePostscriptNames, aFontInfoData);
|
|
}
|
|
}
|
|
|
|
void gfxDWriteFontFamily::LocalizedName(nsACString& aLocalizedName) {
|
|
aLocalizedName = Name(); // just return canonical name in case of failure
|
|
|
|
if (!mDWFamily) {
|
|
return;
|
|
}
|
|
|
|
HRESULT hr;
|
|
nsAutoCString locale;
|
|
// We use system locale here because it's what user expects to see.
|
|
// See bug 1349454 for details.
|
|
RefPtr<OSPreferences> osprefs = OSPreferences::GetInstanceAddRefed();
|
|
if (!osprefs) {
|
|
return;
|
|
}
|
|
osprefs->GetSystemLocale(locale);
|
|
|
|
RefPtr<IDWriteLocalizedStrings> names;
|
|
|
|
hr = mDWFamily->GetFamilyNames(getter_AddRefs(names));
|
|
if (FAILED(hr)) {
|
|
return;
|
|
}
|
|
UINT32 idx = 0;
|
|
BOOL exists;
|
|
hr =
|
|
names->FindLocaleName(NS_ConvertUTF8toUTF16(locale).get(), &idx, &exists);
|
|
if (FAILED(hr)) {
|
|
return;
|
|
}
|
|
if (!exists) {
|
|
// Use english is localized is not found.
|
|
hr = names->FindLocaleName(L"en-us", &idx, &exists);
|
|
if (FAILED(hr)) {
|
|
return;
|
|
}
|
|
if (!exists) {
|
|
// Use 0 index if english is not found.
|
|
idx = 0;
|
|
}
|
|
}
|
|
AutoTArray<WCHAR, 32> famName;
|
|
UINT32 length;
|
|
|
|
hr = names->GetStringLength(idx, &length);
|
|
if (FAILED(hr)) {
|
|
return;
|
|
}
|
|
|
|
if (!famName.SetLength(length + 1, fallible)) {
|
|
// Eeep - running out of memory. Unlikely to end well.
|
|
return;
|
|
}
|
|
|
|
hr = names->GetString(idx, famName.Elements(), length + 1);
|
|
if (FAILED(hr)) {
|
|
return;
|
|
}
|
|
|
|
aLocalizedName = NS_ConvertUTF16toUTF8((const char16_t*)famName.Elements(),
|
|
famName.Length() - 1);
|
|
}
|
|
|
|
bool gfxDWriteFontFamily::IsSymbolFontFamily() const {
|
|
// Just check the first font in the family
|
|
if (mDWFamily->GetFontCount() > 0) {
|
|
RefPtr<IDWriteFont> font;
|
|
if (SUCCEEDED(mDWFamily->GetFont(0, getter_AddRefs(font)))) {
|
|
return font->IsSymbolFont();
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void gfxDWriteFontFamily::AddSizeOfExcludingThis(MallocSizeOf aMallocSizeOf,
|
|
FontListSizes* aSizes) const {
|
|
gfxFontFamily::AddSizeOfExcludingThis(aMallocSizeOf, aSizes);
|
|
// TODO:
|
|
// This doesn't currently account for |mDWFamily|
|
|
}
|
|
|
|
void gfxDWriteFontFamily::AddSizeOfIncludingThis(MallocSizeOf aMallocSizeOf,
|
|
FontListSizes* aSizes) const {
|
|
aSizes->mFontListSize += aMallocSizeOf(this);
|
|
AddSizeOfExcludingThis(aMallocSizeOf, aSizes);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// gfxDWriteFontEntry
|
|
|
|
gfxFontEntry* gfxDWriteFontEntry::Clone() const {
|
|
MOZ_ASSERT(!IsUserFont(), "we can only clone installed fonts!");
|
|
gfxDWriteFontEntry* fe = new gfxDWriteFontEntry(Name(), mFont);
|
|
fe->mWeightRange = mWeightRange;
|
|
fe->mStretchRange = mStretchRange;
|
|
fe->mStyleRange = mStyleRange;
|
|
return fe;
|
|
}
|
|
|
|
gfxDWriteFontEntry::~gfxDWriteFontEntry() {}
|
|
|
|
static bool UsingArabicOrHebrewScriptSystemLocale() {
|
|
LANGID langid = PRIMARYLANGID(::GetSystemDefaultLangID());
|
|
switch (langid) {
|
|
case LANG_ARABIC:
|
|
case LANG_DARI:
|
|
case LANG_PASHTO:
|
|
case LANG_PERSIAN:
|
|
case LANG_SINDHI:
|
|
case LANG_UIGHUR:
|
|
case LANG_URDU:
|
|
case LANG_HEBREW:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
nsresult gfxDWriteFontEntry::CopyFontTable(uint32_t aTableTag,
|
|
nsTArray<uint8_t>& aBuffer) {
|
|
gfxDWriteFontList* pFontList = gfxDWriteFontList::PlatformFontList();
|
|
const uint32_t tagBE = NativeEndian::swapToBigEndian(aTableTag);
|
|
|
|
// Don't use GDI table loading for symbol fonts or for
|
|
// italic fonts in Arabic-script system locales because of
|
|
// potential cmap discrepancies, see bug 629386.
|
|
// Ditto for Hebrew, bug 837498.
|
|
if (mFont && mMayUseGDIAccess && pFontList->UseGDIFontTableAccess() &&
|
|
!(!IsUpright() && UsingArabicOrHebrewScriptSystemLocale()) &&
|
|
!mFont->IsSymbolFont()) {
|
|
LOGFONTW logfont = {0};
|
|
if (InitLogFont(mFont, &logfont)) {
|
|
AutoDC dc;
|
|
AutoSelectFont font(dc.GetDC(), &logfont);
|
|
if (font.IsValid()) {
|
|
uint32_t tableSize = ::GetFontData(dc.GetDC(), tagBE, 0, nullptr, 0);
|
|
if (tableSize != GDI_ERROR) {
|
|
if (aBuffer.SetLength(tableSize, fallible)) {
|
|
::GetFontData(dc.GetDC(), tagBE, 0, aBuffer.Elements(),
|
|
aBuffer.Length());
|
|
return NS_OK;
|
|
}
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
RefPtr<IDWriteFontFace> fontFace;
|
|
nsresult rv = CreateFontFace(getter_AddRefs(fontFace));
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
|
|
uint8_t* tableData;
|
|
uint32_t len;
|
|
void* tableContext = nullptr;
|
|
BOOL exists;
|
|
HRESULT hr = fontFace->TryGetFontTable(tagBE, (const void**)&tableData, &len,
|
|
&tableContext, &exists);
|
|
if (FAILED(hr) || !exists) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
if (aBuffer.SetLength(len, fallible)) {
|
|
memcpy(aBuffer.Elements(), tableData, len);
|
|
rv = NS_OK;
|
|
} else {
|
|
rv = NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
if (tableContext) {
|
|
fontFace->ReleaseFontTable(&tableContext);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
// Access to font tables packaged in hb_blob_t form
|
|
|
|
// object attached to the Harfbuzz blob, used to release
|
|
// the table when the blob is destroyed
|
|
class FontTableRec {
|
|
public:
|
|
FontTableRec(IDWriteFontFace* aFontFace, void* aContext)
|
|
: mFontFace(aFontFace), mContext(aContext) {
|
|
MOZ_COUNT_CTOR(FontTableRec);
|
|
}
|
|
|
|
~FontTableRec() {
|
|
MOZ_COUNT_DTOR(FontTableRec);
|
|
mFontFace->ReleaseFontTable(mContext);
|
|
}
|
|
|
|
private:
|
|
RefPtr<IDWriteFontFace> mFontFace;
|
|
void* mContext;
|
|
};
|
|
|
|
static void DestroyBlobFunc(void* aUserData) {
|
|
FontTableRec* ftr = static_cast<FontTableRec*>(aUserData);
|
|
delete ftr;
|
|
}
|
|
|
|
hb_blob_t* gfxDWriteFontEntry::GetFontTable(uint32_t aTag) {
|
|
// try to avoid potentially expensive DWrite call if we haven't actually
|
|
// created the font face yet, by using the gfxFontEntry method that will
|
|
// use CopyFontTable and then cache the data
|
|
if (!mFontFace) {
|
|
return gfxFontEntry::GetFontTable(aTag);
|
|
}
|
|
|
|
const void* data;
|
|
UINT32 size;
|
|
void* context;
|
|
BOOL exists;
|
|
HRESULT hr = mFontFace->TryGetFontTable(NativeEndian::swapToBigEndian(aTag),
|
|
&data, &size, &context, &exists);
|
|
if (SUCCEEDED(hr) && exists) {
|
|
FontTableRec* ftr = new FontTableRec(mFontFace, context);
|
|
return hb_blob_create(static_cast<const char*>(data), size,
|
|
HB_MEMORY_MODE_READONLY, ftr, DestroyBlobFunc);
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
nsresult gfxDWriteFontEntry::ReadCMAP(FontInfoData* aFontInfoData) {
|
|
AUTO_PROFILER_LABEL("gfxDWriteFontEntry::ReadCMAP", GRAPHICS);
|
|
|
|
// attempt this once, if errors occur leave a blank cmap
|
|
if (mCharacterMap || mShmemCharacterMap) {
|
|
return NS_OK;
|
|
}
|
|
|
|
RefPtr<gfxCharacterMap> charmap;
|
|
nsresult rv;
|
|
|
|
uint32_t uvsOffset = 0;
|
|
if (aFontInfoData &&
|
|
(charmap = GetCMAPFromFontInfo(aFontInfoData, uvsOffset))) {
|
|
rv = NS_OK;
|
|
} else {
|
|
uint32_t kCMAP = TRUETYPE_TAG('c', 'm', 'a', 'p');
|
|
charmap = new gfxCharacterMap();
|
|
AutoTable cmapTable(this, kCMAP);
|
|
|
|
if (cmapTable) {
|
|
uint32_t cmapLen;
|
|
const uint8_t* cmapData = reinterpret_cast<const uint8_t*>(
|
|
hb_blob_get_data(cmapTable, &cmapLen));
|
|
rv = gfxFontUtils::ReadCMAP(cmapData, cmapLen, *charmap, uvsOffset);
|
|
} else {
|
|
rv = NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
}
|
|
mUVSOffset.exchange(uvsOffset);
|
|
|
|
bool setCharMap = true;
|
|
if (NS_SUCCEEDED(rv)) {
|
|
// Bug 969504: exclude U+25B6 from Segoe UI family, because it's used
|
|
// by sites to represent a "Play" icon, but the glyph in Segoe UI Light
|
|
// and Semibold on Windows 7 is too thin. (Ditto for leftward U+25C0.)
|
|
// Fallback to Segoe UI Symbol is preferred.
|
|
if (FamilyName().EqualsLiteral("Segoe UI")) {
|
|
charmap->clear(0x25b6);
|
|
charmap->clear(0x25c0);
|
|
}
|
|
gfxPlatformFontList* pfl = gfxPlatformFontList::PlatformFontList();
|
|
fontlist::FontList* sharedFontList = pfl->SharedFontList();
|
|
if (!IsUserFont() && mShmemFace) {
|
|
mShmemFace->SetCharacterMap(sharedFontList, charmap); // async
|
|
if (TrySetShmemCharacterMap()) {
|
|
setCharMap = false;
|
|
}
|
|
} else {
|
|
charmap = pfl->FindCharMap(charmap);
|
|
}
|
|
mHasCmapTable = true;
|
|
} else {
|
|
// if error occurred, initialize to null cmap
|
|
charmap = new gfxCharacterMap();
|
|
mHasCmapTable = false;
|
|
}
|
|
if (setCharMap) {
|
|
// Temporarily retain charmap, until the shared version is
|
|
// ready for use.
|
|
if (mCharacterMap.compareExchange(nullptr, charmap.get())) {
|
|
Unused << charmap.forget();
|
|
}
|
|
}
|
|
|
|
LOG_FONTLIST(("(fontlist-cmap) name: %s, size: %zu hash: %8.8x%s\n",
|
|
mName.get(), charmap->SizeOfIncludingThis(moz_malloc_size_of),
|
|
charmap->mHash, mCharacterMap == charmap ? " new" : ""));
|
|
if (LOG_CMAPDATA_ENABLED()) {
|
|
char prefix[256];
|
|
SprintfLiteral(prefix, "(cmapdata) name: %.220s", mName.get());
|
|
charmap->Dump(prefix, eGfxLog_cmapdata);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
bool gfxDWriteFontEntry::HasVariations() {
|
|
if (mHasVariationsInitialized) {
|
|
return mHasVariations;
|
|
}
|
|
mHasVariationsInitialized = true;
|
|
mHasVariations = false;
|
|
|
|
if (!gfxPlatform::GetPlatform()->HasVariationFontSupport()) {
|
|
return mHasVariations;
|
|
}
|
|
|
|
if (!mFontFace) {
|
|
// CreateFontFace will initialize the mFontFace field, and also
|
|
// mFontFace5 if available on the current DWrite version.
|
|
RefPtr<IDWriteFontFace> fontFace;
|
|
if (NS_FAILED(CreateFontFace(getter_AddRefs(fontFace)))) {
|
|
return mHasVariations;
|
|
}
|
|
}
|
|
if (mFontFace5) {
|
|
mHasVariations = mFontFace5->HasVariations();
|
|
}
|
|
return mHasVariations;
|
|
}
|
|
|
|
void gfxDWriteFontEntry::GetVariationAxes(
|
|
nsTArray<gfxFontVariationAxis>& aAxes) {
|
|
if (!HasVariations()) {
|
|
return;
|
|
}
|
|
// HasVariations() will have ensured the mFontFace5 interface is available;
|
|
// so we can get an IDWriteFontResource and ask it for the axis info.
|
|
RefPtr<IDWriteFontResource> resource;
|
|
HRESULT hr = mFontFace5->GetFontResource(getter_AddRefs(resource));
|
|
if (FAILED(hr) || !resource) {
|
|
return;
|
|
}
|
|
|
|
uint32_t count = resource->GetFontAxisCount();
|
|
AutoTArray<DWRITE_FONT_AXIS_VALUE, 4> defaultValues;
|
|
AutoTArray<DWRITE_FONT_AXIS_RANGE, 4> ranges;
|
|
defaultValues.SetLength(count);
|
|
ranges.SetLength(count);
|
|
resource->GetDefaultFontAxisValues(defaultValues.Elements(), count);
|
|
resource->GetFontAxisRanges(ranges.Elements(), count);
|
|
for (uint32_t i = 0; i < count; ++i) {
|
|
gfxFontVariationAxis axis;
|
|
MOZ_ASSERT(ranges[i].axisTag == defaultValues[i].axisTag);
|
|
DWRITE_FONT_AXIS_ATTRIBUTES attrs = resource->GetFontAxisAttributes(i);
|
|
if (attrs & DWRITE_FONT_AXIS_ATTRIBUTES_HIDDEN) {
|
|
continue;
|
|
}
|
|
if (!(attrs & DWRITE_FONT_AXIS_ATTRIBUTES_VARIABLE)) {
|
|
continue;
|
|
}
|
|
// Extract the 4 chars of the tag from DWrite's packed version,
|
|
// and reassemble them in the order we use for TRUETYPE_TAG.
|
|
uint32_t t = defaultValues[i].axisTag;
|
|
axis.mTag = TRUETYPE_TAG(t & 0xff, (t >> 8) & 0xff, (t >> 16) & 0xff,
|
|
(t >> 24) & 0xff);
|
|
// Try to get a human-friendly name (may not be present)
|
|
RefPtr<IDWriteLocalizedStrings> names;
|
|
resource->GetAxisNames(i, getter_AddRefs(names));
|
|
if (names) {
|
|
GetEnglishOrFirstName(axis.mName, names);
|
|
}
|
|
axis.mMinValue = ranges[i].minValue;
|
|
axis.mMaxValue = ranges[i].maxValue;
|
|
axis.mDefaultValue = defaultValues[i].value;
|
|
aAxes.AppendElement(axis);
|
|
}
|
|
}
|
|
|
|
void gfxDWriteFontEntry::GetVariationInstances(
|
|
nsTArray<gfxFontVariationInstance>& aInstances) {
|
|
gfxFontUtils::GetVariationData(this, nullptr, &aInstances);
|
|
}
|
|
|
|
gfxFont* gfxDWriteFontEntry::CreateFontInstance(
|
|
const gfxFontStyle* aFontStyle) {
|
|
// We use the DirectWrite bold simulation for installed fonts, but NOT for
|
|
// webfonts; those will use multi-strike synthetic bold instead.
|
|
bool useBoldSim = false;
|
|
if (aFontStyle->NeedsSyntheticBold(this)) {
|
|
switch (StaticPrefs::gfx_font_rendering_directwrite_bold_simulation()) {
|
|
case 0: // never use the DWrite simulation
|
|
break;
|
|
case 1: // use DWrite simulation for installed fonts but not webfonts
|
|
useBoldSim = !mIsDataUserFont;
|
|
break;
|
|
default: // always use DWrite bold simulation
|
|
useBoldSim = true;
|
|
break;
|
|
}
|
|
}
|
|
DWRITE_FONT_SIMULATIONS sims =
|
|
useBoldSim ? DWRITE_FONT_SIMULATIONS_BOLD : DWRITE_FONT_SIMULATIONS_NONE;
|
|
ThreadSafeWeakPtr<UnscaledFontDWrite>& unscaledFontPtr =
|
|
useBoldSim ? mUnscaledFontBold : mUnscaledFont;
|
|
RefPtr<UnscaledFontDWrite> unscaledFont(unscaledFontPtr);
|
|
if (!unscaledFont) {
|
|
RefPtr<IDWriteFontFace> fontFace;
|
|
nsresult rv =
|
|
CreateFontFace(getter_AddRefs(fontFace), nullptr, sims, nullptr);
|
|
if (NS_FAILED(rv)) {
|
|
return nullptr;
|
|
}
|
|
// Only pass in the underlying IDWriteFont if the unscaled font doesn't
|
|
// reflect a data font. This signals whether or not we can safely query
|
|
// a descriptor to represent the font for various transport use-cases.
|
|
unscaledFont =
|
|
new UnscaledFontDWrite(fontFace, !mIsDataUserFont ? mFont : nullptr);
|
|
unscaledFontPtr = unscaledFont;
|
|
}
|
|
RefPtr<IDWriteFontFace> fontFace;
|
|
if (HasVariations()) {
|
|
// Get the variation settings needed to instantiate the fontEntry
|
|
// for a particular fontStyle.
|
|
AutoTArray<gfxFontVariation, 4> vars;
|
|
GetVariationsForStyle(vars, *aFontStyle);
|
|
|
|
if (!vars.IsEmpty()) {
|
|
nsresult rv =
|
|
CreateFontFace(getter_AddRefs(fontFace), aFontStyle, sims, &vars);
|
|
if (NS_FAILED(rv)) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
}
|
|
return new gfxDWriteFont(unscaledFont, this, aFontStyle, fontFace);
|
|
}
|
|
|
|
nsresult gfxDWriteFontEntry::CreateFontFace(
|
|
IDWriteFontFace** aFontFace, const gfxFontStyle* aFontStyle,
|
|
DWRITE_FONT_SIMULATIONS aSimulations,
|
|
const nsTArray<gfxFontVariation>* aVariations) {
|
|
// Convert an OpenType font tag from our uint32_t representation
|
|
// (as constructed by TRUETYPE_TAG(...)) to the order DWrite wants.
|
|
auto makeDWriteAxisTag = [](uint32_t aTag) {
|
|
return DWRITE_MAKE_FONT_AXIS_TAG((aTag >> 24) & 0xff, (aTag >> 16) & 0xff,
|
|
(aTag >> 8) & 0xff, aTag & 0xff);
|
|
};
|
|
|
|
// initialize mFontFace if this hasn't been done before
|
|
if (!mFontFace) {
|
|
HRESULT hr;
|
|
if (mFont) {
|
|
hr = mFont->CreateFontFace(getter_AddRefs(mFontFace));
|
|
} else if (mFontFile) {
|
|
IDWriteFontFile* fontFile = mFontFile.get();
|
|
hr = Factory::GetDWriteFactory()->CreateFontFace(
|
|
mFaceType, 1, &fontFile, 0, DWRITE_FONT_SIMULATIONS_NONE,
|
|
getter_AddRefs(mFontFace));
|
|
} else {
|
|
MOZ_ASSERT_UNREACHABLE("invalid font entry");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
if (FAILED(hr)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
// Also get the IDWriteFontFace5 interface if we're running on a
|
|
// sufficiently new DWrite version where it is available.
|
|
if (mFontFace) {
|
|
mFontFace->QueryInterface(__uuidof(IDWriteFontFace5),
|
|
(void**)getter_AddRefs(mFontFace5));
|
|
if (!mVariationSettings.IsEmpty()) {
|
|
// If the font entry has variations specified, mFontFace5 will
|
|
// be a distinct face that has the variations applied.
|
|
RefPtr<IDWriteFontResource> resource;
|
|
HRESULT hr = mFontFace5->GetFontResource(getter_AddRefs(resource));
|
|
if (SUCCEEDED(hr) && resource) {
|
|
AutoTArray<DWRITE_FONT_AXIS_VALUE, 4> fontAxisValues;
|
|
for (const auto& v : mVariationSettings) {
|
|
DWRITE_FONT_AXIS_VALUE axisValue = {makeDWriteAxisTag(v.mTag),
|
|
v.mValue};
|
|
fontAxisValues.AppendElement(axisValue);
|
|
}
|
|
resource->CreateFontFace(
|
|
mFontFace->GetSimulations(), fontAxisValues.Elements(),
|
|
fontAxisValues.Length(), getter_AddRefs(mFontFace5));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Do we need to modify DWrite simulations from what mFontFace has?
|
|
bool needSimulations =
|
|
(aSimulations & DWRITE_FONT_SIMULATIONS_BOLD) &&
|
|
!(mFontFace->GetSimulations() & DWRITE_FONT_SIMULATIONS_BOLD);
|
|
|
|
// If the IDWriteFontFace5 interface is available, we can try using
|
|
// IDWriteFontResource to create a new modified face.
|
|
if (mFontFace5 && (HasVariations() || needSimulations)) {
|
|
RefPtr<IDWriteFontResource> resource;
|
|
HRESULT hr = mFontFace5->GetFontResource(getter_AddRefs(resource));
|
|
if (SUCCEEDED(hr) && resource) {
|
|
AutoTArray<DWRITE_FONT_AXIS_VALUE, 4> fontAxisValues;
|
|
|
|
// Copy variation settings to DWrite's type.
|
|
if (aVariations) {
|
|
for (const auto& v : *aVariations) {
|
|
DWRITE_FONT_AXIS_VALUE axisValue = {makeDWriteAxisTag(v.mTag),
|
|
v.mValue};
|
|
fontAxisValues.AppendElement(axisValue);
|
|
}
|
|
}
|
|
|
|
IDWriteFontFace5* ff5;
|
|
resource->CreateFontFace(aSimulations, fontAxisValues.Elements(),
|
|
fontAxisValues.Length(), &ff5);
|
|
if (ff5) {
|
|
*aFontFace = ff5;
|
|
return NS_OK;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Do we need to add DWrite simulations to the face?
|
|
if (needSimulations) {
|
|
// if so, we need to return not mFontFace itself but a version that
|
|
// has the Bold simulation - unfortunately, old DWrite doesn't provide
|
|
// a simple API for this
|
|
UINT32 numberOfFiles = 0;
|
|
if (FAILED(mFontFace->GetFiles(&numberOfFiles, nullptr))) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
AutoTArray<IDWriteFontFile*, 1> files;
|
|
files.AppendElements(numberOfFiles);
|
|
if (FAILED(mFontFace->GetFiles(&numberOfFiles, files.Elements()))) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
HRESULT hr = Factory::GetDWriteFactory()->CreateFontFace(
|
|
mFontFace->GetType(), numberOfFiles, files.Elements(),
|
|
mFontFace->GetIndex(), aSimulations, aFontFace);
|
|
for (UINT32 i = 0; i < numberOfFiles; ++i) {
|
|
files[i]->Release();
|
|
}
|
|
return FAILED(hr) ? NS_ERROR_FAILURE : NS_OK;
|
|
}
|
|
|
|
// no simulation: we can just add a reference to mFontFace5 (if present)
|
|
// or mFontFace (otherwise) and return that
|
|
if (mFontFace5) {
|
|
*aFontFace = mFontFace5;
|
|
} else {
|
|
*aFontFace = mFontFace;
|
|
}
|
|
(*aFontFace)->AddRef();
|
|
return NS_OK;
|
|
}
|
|
|
|
bool gfxDWriteFontEntry::InitLogFont(IDWriteFont* aFont, LOGFONTW* aLogFont) {
|
|
HRESULT hr;
|
|
|
|
BOOL isInSystemCollection;
|
|
IDWriteGdiInterop* gdi =
|
|
gfxDWriteFontList::PlatformFontList()->GetGDIInterop();
|
|
hr = gdi->ConvertFontToLOGFONT(aFont, aLogFont, &isInSystemCollection);
|
|
// If the font is not in the system collection, GDI will be unable to
|
|
// select it and load its tables, so we return false here to indicate
|
|
// failure, and let CopyFontTable fall back to DWrite native methods.
|
|
return (SUCCEEDED(hr) && isInSystemCollection);
|
|
}
|
|
|
|
bool gfxDWriteFontEntry::IsCJKFont() {
|
|
if (mIsCJK != UNINITIALIZED_VALUE) {
|
|
return mIsCJK;
|
|
}
|
|
|
|
mIsCJK = false;
|
|
|
|
const uint32_t kOS2Tag = TRUETYPE_TAG('O', 'S', '/', '2');
|
|
hb_blob_t* blob = GetFontTable(kOS2Tag);
|
|
if (!blob) {
|
|
return mIsCJK;
|
|
}
|
|
// |blob| is an owning reference, but is not RAII-managed, so it must be
|
|
// explicitly freed using |hb_blob_destroy| before we return. (Beware of
|
|
// adding any early-return codepaths!)
|
|
|
|
uint32_t len;
|
|
const OS2Table* os2 =
|
|
reinterpret_cast<const OS2Table*>(hb_blob_get_data(blob, &len));
|
|
// ulCodePageRange bit definitions for the CJK codepages,
|
|
// from http://www.microsoft.com/typography/otspec/os2.htm#cpr
|
|
const uint32_t CJK_CODEPAGE_BITS =
|
|
(1 << 17) | // codepage 932 - JIS/Japan
|
|
(1 << 18) | // codepage 936 - Chinese (simplified)
|
|
(1 << 19) | // codepage 949 - Korean Wansung
|
|
(1 << 20) | // codepage 950 - Chinese (traditional)
|
|
(1 << 21); // codepage 1361 - Korean Johab
|
|
if (len >= offsetof(OS2Table, sxHeight)) {
|
|
if ((uint32_t(os2->codePageRange1) & CJK_CODEPAGE_BITS) != 0) {
|
|
mIsCJK = true;
|
|
}
|
|
}
|
|
hb_blob_destroy(blob);
|
|
|
|
return mIsCJK;
|
|
}
|
|
|
|
void gfxDWriteFontEntry::AddSizeOfExcludingThis(MallocSizeOf aMallocSizeOf,
|
|
FontListSizes* aSizes) const {
|
|
gfxFontEntry::AddSizeOfExcludingThis(aMallocSizeOf, aSizes);
|
|
// TODO:
|
|
// This doesn't currently account for the |mFont| and |mFontFile| members
|
|
}
|
|
|
|
void gfxDWriteFontEntry::AddSizeOfIncludingThis(MallocSizeOf aMallocSizeOf,
|
|
FontListSizes* aSizes) const {
|
|
aSizes->mFontListSize += aMallocSizeOf(this);
|
|
AddSizeOfExcludingThis(aMallocSizeOf, aSizes);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// gfxDWriteFontList
|
|
|
|
gfxDWriteFontList::gfxDWriteFontList() : mForceGDIClassicMaxFontSize(0.0) {
|
|
CheckFamilyList(kBaseFonts);
|
|
CheckFamilyList(kLangPackFonts);
|
|
}
|
|
|
|
// bug 602792 - CJK systems default to large CJK fonts which cause excessive
|
|
// I/O strain during cold startup due to dwrite caching bugs. Default to
|
|
// Arial to avoid this.
|
|
|
|
FontFamily gfxDWriteFontList::GetDefaultFontForPlatform(
|
|
nsPresContext* aPresContext, const gfxFontStyle* aStyle,
|
|
nsAtom* aLanguage) {
|
|
// try Arial first
|
|
FontFamily ff;
|
|
ff = FindFamily(aPresContext, "Arial"_ns);
|
|
if (!ff.IsNull()) {
|
|
return ff;
|
|
}
|
|
|
|
// otherwise, use local default
|
|
NONCLIENTMETRICSW ncm;
|
|
ncm.cbSize = sizeof(ncm);
|
|
BOOL status =
|
|
::SystemParametersInfoW(SPI_GETNONCLIENTMETRICS, sizeof(ncm), &ncm, 0);
|
|
|
|
if (status) {
|
|
ff = FindFamily(aPresContext,
|
|
NS_ConvertUTF16toUTF8(ncm.lfMessageFont.lfFaceName));
|
|
}
|
|
|
|
return ff;
|
|
}
|
|
|
|
gfxFontEntry* gfxDWriteFontList::LookupLocalFont(
|
|
nsPresContext* aPresContext, const nsACString& aFontName,
|
|
WeightRange aWeightForEntry, StretchRange aStretchForEntry,
|
|
SlantStyleRange aStyleForEntry) {
|
|
AutoLock lock(mLock);
|
|
|
|
if (SharedFontList()) {
|
|
return LookupInSharedFaceNameList(aPresContext, aFontName, aWeightForEntry,
|
|
aStretchForEntry, aStyleForEntry);
|
|
}
|
|
|
|
gfxFontEntry* lookup;
|
|
|
|
lookup = LookupInFaceNameLists(aFontName);
|
|
if (!lookup) {
|
|
return nullptr;
|
|
}
|
|
|
|
gfxDWriteFontEntry* dwriteLookup = static_cast<gfxDWriteFontEntry*>(lookup);
|
|
gfxDWriteFontEntry* fe =
|
|
new gfxDWriteFontEntry(lookup->Name(), dwriteLookup->mFont,
|
|
aWeightForEntry, aStretchForEntry, aStyleForEntry);
|
|
fe->SetForceGDIClassic(dwriteLookup->GetForceGDIClassic());
|
|
return fe;
|
|
}
|
|
|
|
gfxFontEntry* gfxDWriteFontList::MakePlatformFont(
|
|
const nsACString& aFontName, WeightRange aWeightForEntry,
|
|
StretchRange aStretchForEntry, SlantStyleRange aStyleForEntry,
|
|
const uint8_t* aFontData, uint32_t aLength) {
|
|
RefPtr<IDWriteFontFileStream> fontFileStream;
|
|
RefPtr<IDWriteFontFile> fontFile;
|
|
HRESULT hr = gfxDWriteFontFileLoader::CreateCustomFontFile(
|
|
aFontData, aLength, getter_AddRefs(fontFile),
|
|
getter_AddRefs(fontFileStream));
|
|
free((void*)aFontData);
|
|
NS_ASSERTION(SUCCEEDED(hr), "Failed to create font file reference");
|
|
if (FAILED(hr)) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsAutoString uniqueName;
|
|
nsresult rv = gfxFontUtils::MakeUniqueUserFontName(uniqueName);
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "Failed to make unique user font name");
|
|
if (NS_FAILED(rv)) {
|
|
return nullptr;
|
|
}
|
|
|
|
BOOL isSupported;
|
|
DWRITE_FONT_FILE_TYPE fileType;
|
|
UINT32 numFaces;
|
|
|
|
auto entry = MakeUnique<gfxDWriteFontEntry>(
|
|
NS_ConvertUTF16toUTF8(uniqueName), fontFile, fontFileStream,
|
|
aWeightForEntry, aStretchForEntry, aStyleForEntry);
|
|
|
|
hr = fontFile->Analyze(&isSupported, &fileType, &entry->mFaceType, &numFaces);
|
|
NS_ASSERTION(SUCCEEDED(hr), "IDWriteFontFile::Analyze failed");
|
|
if (FAILED(hr)) {
|
|
return nullptr;
|
|
}
|
|
NS_ASSERTION(isSupported, "Unsupported font file");
|
|
if (!isSupported) {
|
|
return nullptr;
|
|
}
|
|
NS_ASSERTION(numFaces == 1, "Font file does not contain exactly 1 face");
|
|
if (numFaces != 1) {
|
|
// We don't know how to deal with 0 faces either.
|
|
return nullptr;
|
|
}
|
|
|
|
return entry.release();
|
|
}
|
|
|
|
bool gfxDWriteFontList::UseGDIFontTableAccess() const {
|
|
// Using GDI font table access for DWrite is controlled by a pref, but also we
|
|
// must be able to make win32k calls.
|
|
return mGDIFontTableAccess && !IsWin32kLockedDown();
|
|
}
|
|
|
|
static void GetPostScriptNameFromNameTable(IDWriteFontFace* aFace,
|
|
nsCString& aName) {
|
|
const auto kNAME =
|
|
NativeEndian::swapToBigEndian(TRUETYPE_TAG('n', 'a', 'm', 'e'));
|
|
const char* data;
|
|
UINT32 size;
|
|
void* context;
|
|
BOOL exists;
|
|
if (SUCCEEDED(aFace->TryGetFontTable(kNAME, (const void**)&data, &size,
|
|
&context, &exists)) &&
|
|
exists) {
|
|
if (NS_FAILED(gfxFontUtils::ReadCanonicalName(
|
|
data, size, gfxFontUtils::NAME_ID_POSTSCRIPT, aName))) {
|
|
aName.Truncate(0);
|
|
}
|
|
aFace->ReleaseFontTable(context);
|
|
}
|
|
}
|
|
|
|
gfxFontEntry* gfxDWriteFontList::CreateFontEntry(
|
|
fontlist::Face* aFace, const fontlist::Family* aFamily) {
|
|
IDWriteFontCollection* collection =
|
|
#ifdef MOZ_BUNDLED_FONTS
|
|
aFamily->IsBundled() ? mBundledFonts : mSystemFonts;
|
|
#else
|
|
mSystemFonts;
|
|
#endif
|
|
RefPtr<IDWriteFontFamily> family;
|
|
bool foundExpectedFamily = false;
|
|
const nsCString& familyName =
|
|
aFamily->DisplayName().AsString(SharedFontList());
|
|
if (aFamily->Index() < collection->GetFontFamilyCount()) {
|
|
HRESULT hr =
|
|
collection->GetFontFamily(aFamily->Index(), getter_AddRefs(family));
|
|
// Check that the family name is what we expected; if not, fall back to
|
|
// search by name. It's sad we have to do this, but it is possible for
|
|
// Windows to have given different versions of the system font collection
|
|
// to the parent and child processes.
|
|
if (SUCCEEDED(hr) && family) {
|
|
RefPtr<IDWriteLocalizedStrings> names;
|
|
hr = family->GetFamilyNames(getter_AddRefs(names));
|
|
if (SUCCEEDED(hr) && names) {
|
|
nsAutoCString name;
|
|
if (GetEnglishOrFirstName(name, names)) {
|
|
foundExpectedFamily = name.Equals(familyName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!foundExpectedFamily) {
|
|
// Try to get family by name instead of index (to deal with the case of
|
|
// collection mismatch).
|
|
UINT32 index;
|
|
BOOL exists;
|
|
NS_ConvertUTF8toUTF16 name16(familyName);
|
|
HRESULT hr = collection->FindFamilyName(
|
|
reinterpret_cast<const WCHAR*>(name16.BeginReading()), &index, &exists);
|
|
if (FAILED(hr) || !exists || index == UINT_MAX ||
|
|
FAILED(collection->GetFontFamily(index, getter_AddRefs(family))) ||
|
|
!family) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
// Retrieve the required face by index within the family.
|
|
RefPtr<IDWriteFont> font;
|
|
if (FAILED(family->GetFont(aFace->mIndex, getter_AddRefs(font))) || !font) {
|
|
return nullptr;
|
|
}
|
|
|
|
// Retrieve the psName from the font, so we can check we've found the
|
|
// expected face.
|
|
nsAutoCString psName;
|
|
if (FAILED(GetDirectWriteFaceName(font, PSNAME_ID, psName))) {
|
|
RefPtr<IDWriteFontFace> dwFontFace;
|
|
if (SUCCEEDED(font->CreateFontFace(getter_AddRefs(dwFontFace)))) {
|
|
GetPostScriptNameFromNameTable(dwFontFace, psName);
|
|
}
|
|
}
|
|
|
|
// If it doesn't match, DirectWrite must have shuffled the order of faces
|
|
// returned for the family; search by name as a fallback.
|
|
nsCString faceName = aFace->mDescriptor.AsString(SharedFontList());
|
|
if (psName != faceName) {
|
|
gfxWarning() << "Face name mismatch for index " << aFace->mIndex
|
|
<< " in family " << familyName.get() << ": expected "
|
|
<< faceName.get() << ", found " << psName.get();
|
|
for (uint32_t i = 0; i < family->GetFontCount(); ++i) {
|
|
if (i == aFace->mIndex) {
|
|
continue; // this was the face we already tried
|
|
}
|
|
if (FAILED(family->GetFont(i, getter_AddRefs(font))) || !font) {
|
|
return nullptr; // this font family is broken!
|
|
}
|
|
if (FAILED(GetDirectWriteFaceName(font, PSNAME_ID, psName))) {
|
|
RefPtr<IDWriteFontFace> dwFontFace;
|
|
if (SUCCEEDED(font->CreateFontFace(getter_AddRefs(dwFontFace)))) {
|
|
GetPostScriptNameFromNameTable(dwFontFace, psName);
|
|
}
|
|
}
|
|
if (psName == faceName) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (psName != faceName) {
|
|
return nullptr;
|
|
}
|
|
|
|
auto fe = new gfxDWriteFontEntry(faceName, font, !aFamily->IsBundled());
|
|
fe->InitializeFrom(aFace, aFamily);
|
|
fe->mForceGDIClassic = aFamily->IsForceClassic();
|
|
fe->mMayUseGDIAccess = aFamily->IsSimple();
|
|
return fe;
|
|
}
|
|
|
|
FontVisibility gfxDWriteFontList::GetVisibilityForFamily(
|
|
const nsACString& aName) const {
|
|
if (FamilyInList(aName, kBaseFonts)) {
|
|
return FontVisibility::Base;
|
|
}
|
|
if (FamilyInList(aName, kLangPackFonts)) {
|
|
return FontVisibility::LangPack;
|
|
}
|
|
return FontVisibility::User;
|
|
}
|
|
|
|
void gfxDWriteFontList::AppendFamiliesFromCollection(
|
|
IDWriteFontCollection* aCollection,
|
|
nsTArray<fontlist::Family::InitData>& aFamilies,
|
|
const nsTArray<nsCString>* aForceClassicFams) {
|
|
auto allFacesUltraBold = [](IDWriteFontFamily* aFamily) -> bool {
|
|
for (UINT32 i = 0; i < aFamily->GetFontCount(); i++) {
|
|
RefPtr<IDWriteFont> font;
|
|
HRESULT hr = aFamily->GetFont(i, getter_AddRefs(font));
|
|
if (FAILED(hr)) {
|
|
NS_WARNING("Failed to get existing font from family.");
|
|
continue;
|
|
}
|
|
nsAutoCString faceName;
|
|
hr = GetDirectWriteFontName(font, faceName);
|
|
if (FAILED(hr)) {
|
|
continue;
|
|
}
|
|
if (faceName.Find("Ultra Bold"_ns) == kNotFound) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
};
|
|
|
|
nsAutoCString locale;
|
|
OSPreferences::GetInstance()->GetSystemLocale(locale);
|
|
ToLowerCase(locale);
|
|
NS_ConvertUTF8toUTF16 loc16(locale);
|
|
|
|
for (unsigned i = 0; i < aCollection->GetFontFamilyCount(); ++i) {
|
|
RefPtr<IDWriteFontFamily> family;
|
|
aCollection->GetFontFamily(i, getter_AddRefs(family));
|
|
RefPtr<IDWriteLocalizedStrings> localizedNames;
|
|
HRESULT hr = family->GetFamilyNames(getter_AddRefs(localizedNames));
|
|
if (FAILED(hr)) {
|
|
gfxWarning() << "Failed to get names for font-family " << i;
|
|
continue;
|
|
}
|
|
|
|
auto addFamily = [&](const nsACString& name, bool altLocale = false) {
|
|
nsAutoCString key;
|
|
key = name;
|
|
BuildKeyNameFromFontName(key);
|
|
bool bad = mBadUnderlineFamilyNames.ContainsSorted(key);
|
|
bool classic =
|
|
aForceClassicFams && aForceClassicFams->ContainsSorted(key);
|
|
FontVisibility visibility;
|
|
// Special case: hide the "Gill Sans" family that contains only UltraBold
|
|
// faces, as this leads to breakage on sites with CSS that targeted the
|
|
// Gill Sans family as found on macOS. (Bug 551313, bug 1632738)
|
|
// TODO (jfkthame): the ultrabold faces from Gill Sans should be treated
|
|
// as belonging to the Gill Sans MT family.
|
|
if (key.EqualsLiteral("gill sans") && allFacesUltraBold(family)) {
|
|
visibility = FontVisibility::Hidden;
|
|
} else {
|
|
visibility = aCollection == mSystemFonts ? GetVisibilityForFamily(name)
|
|
: FontVisibility::Base;
|
|
}
|
|
aFamilies.AppendElement(fontlist::Family::InitData(
|
|
key, name, i, visibility, aCollection != mSystemFonts, bad, classic,
|
|
altLocale));
|
|
};
|
|
|
|
unsigned count = localizedNames->GetCount();
|
|
if (count == 1) {
|
|
// This is the common case: the great majority of fonts only provide an
|
|
// en-US family name.
|
|
nsAutoCString name;
|
|
if (!GetNameAsUtf8(name, localizedNames, 0)) {
|
|
gfxWarning() << "GetNameAsUtf8 failed for index 0 in font-family " << i;
|
|
continue;
|
|
}
|
|
addFamily(name);
|
|
} else {
|
|
AutoTArray<nsCString, 4> names;
|
|
int sysLocIndex = -1;
|
|
for (unsigned index = 0; index < count; ++index) {
|
|
nsAutoCString name;
|
|
if (!GetNameAsUtf8(name, localizedNames, index)) {
|
|
gfxWarning() << "GetNameAsUtf8 failed for index " << index
|
|
<< " in font-family " << i;
|
|
continue;
|
|
}
|
|
if (!names.Contains(name)) {
|
|
if (sysLocIndex == -1) {
|
|
WCHAR buf[32];
|
|
if (SUCCEEDED(localizedNames->GetLocaleName(index, buf, 32))) {
|
|
if (loc16.Equals(buf)) {
|
|
sysLocIndex = names.Length();
|
|
}
|
|
}
|
|
}
|
|
names.AppendElement(name);
|
|
}
|
|
}
|
|
// If we didn't find a name that matched the system locale, use the
|
|
// first (which is most often en-US).
|
|
if (sysLocIndex == -1) {
|
|
sysLocIndex = 0;
|
|
}
|
|
// Hack to work around EPSON fonts with bad names (tagged as MacRoman
|
|
// but actually contain MacJapanese data): if we've chosen the first
|
|
// name, *and* it is non-ASCII, *and* there is an alternative present,
|
|
// use the next option instead as being more likely to be valid.
|
|
if (sysLocIndex == 0 && names.Length() > 1 && !IsAscii(names[0])) {
|
|
sysLocIndex = 1;
|
|
}
|
|
for (unsigned index = 0; index < names.Length(); ++index) {
|
|
addFamily(names[index], index != static_cast<unsigned>(sysLocIndex));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void gfxDWriteFontList::GetFacesInitDataForFamily(
|
|
const fontlist::Family* aFamily, nsTArray<fontlist::Face::InitData>& aFaces,
|
|
bool aLoadCmaps) const {
|
|
IDWriteFontCollection* collection =
|
|
#ifdef MOZ_BUNDLED_FONTS
|
|
aFamily->IsBundled() ? mBundledFonts : mSystemFonts;
|
|
#else
|
|
mSystemFonts;
|
|
#endif
|
|
if (!collection) {
|
|
return;
|
|
}
|
|
RefPtr<IDWriteFontFamily> family;
|
|
collection->GetFontFamily(aFamily->Index(), getter_AddRefs(family));
|
|
for (unsigned i = 0; i < family->GetFontCount(); ++i) {
|
|
RefPtr<IDWriteFont> dwFont;
|
|
family->GetFont(i, getter_AddRefs(dwFont));
|
|
if (!dwFont || dwFont->GetSimulations() != DWRITE_FONT_SIMULATIONS_NONE) {
|
|
continue;
|
|
}
|
|
DWRITE_FONT_STYLE dwstyle = dwFont->GetStyle();
|
|
// Ignore italic styles of Meiryo because "Meiryo (Bold) Italic" has
|
|
// non-italic style glyphs as Japanese characters. However, using it
|
|
// causes serious problem if web pages wants some elements to be
|
|
// different style from others only with font-style. For example,
|
|
// <em> and <i> should be rendered as italic in the default style.
|
|
if (dwstyle != DWRITE_FONT_STYLE_NORMAL &&
|
|
aFamily->Key().AsString(SharedFontList()).EqualsLiteral("meiryo")) {
|
|
continue;
|
|
}
|
|
WeightRange weight(FontWeight::FromInt(dwFont->GetWeight()));
|
|
StretchRange stretch(FontStretchFromDWriteStretch(dwFont->GetStretch()));
|
|
// Try to read PSName as a unique face identifier; if this fails we'll get
|
|
// it directly from the 'name' table, and if that also fails we consider
|
|
// the face unusable.
|
|
MOZ_SEH_TRY {
|
|
nsAutoCString name;
|
|
RefPtr<gfxCharacterMap> charmap;
|
|
if (FAILED(GetDirectWriteFaceName(dwFont, PSNAME_ID, name)) ||
|
|
aLoadCmaps) {
|
|
RefPtr<IDWriteFontFace> dwFontFace;
|
|
if (SUCCEEDED(dwFont->CreateFontFace(getter_AddRefs(dwFontFace)))) {
|
|
if (name.IsEmpty()) {
|
|
GetPostScriptNameFromNameTable(dwFontFace, name);
|
|
}
|
|
const auto kCMAP =
|
|
NativeEndian::swapToBigEndian(TRUETYPE_TAG('c', 'm', 'a', 'p'));
|
|
const char* data;
|
|
UINT32 size;
|
|
void* context;
|
|
BOOL exists;
|
|
if (aLoadCmaps) {
|
|
if (SUCCEEDED(dwFontFace->TryGetFontTable(
|
|
kCMAP, (const void**)&data, &size, &context, &exists)) &&
|
|
exists) {
|
|
charmap = new gfxCharacterMap();
|
|
uint32_t offset;
|
|
gfxFontUtils::ReadCMAP((const uint8_t*)data, size, *charmap,
|
|
offset);
|
|
dwFontFace->ReleaseFontTable(context);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (name.IsEmpty()) {
|
|
gfxWarning() << "Failed to get name for face " << i << " in family "
|
|
<< aFamily->Key().AsString(SharedFontList()).get();
|
|
continue;
|
|
}
|
|
SlantStyleRange slant(
|
|
dwstyle == DWRITE_FONT_STYLE_NORMAL ? FontSlantStyle::NORMAL
|
|
: dwstyle == DWRITE_FONT_STYLE_ITALIC ? FontSlantStyle::ITALIC
|
|
: FontSlantStyle::OBLIQUE);
|
|
aFaces.AppendElement(fontlist::Face::InitData{
|
|
name, uint16_t(i), false, weight, stretch, slant, charmap});
|
|
}
|
|
MOZ_SEH_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
|
|
// Exception (e.g. disk i/o error) occurred when DirectWrite tried to use
|
|
// the font resource. We'll just skip the bad face.
|
|
gfxCriticalNote << "Exception occurred reading faces for "
|
|
<< aFamily->Key().AsString(SharedFontList()).get();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool gfxDWriteFontList::ReadFaceNames(fontlist::Family* aFamily,
|
|
fontlist::Face* aFace, nsCString& aPSName,
|
|
nsCString& aFullName) {
|
|
IDWriteFontCollection* collection =
|
|
#ifdef MOZ_BUNDLED_FONTS
|
|
aFamily->IsBundled() ? mBundledFonts : mSystemFonts;
|
|
#else
|
|
mSystemFonts;
|
|
#endif
|
|
RefPtr<IDWriteFontFamily> family;
|
|
if (FAILED(collection->GetFontFamily(aFamily->Index(),
|
|
getter_AddRefs(family)))) {
|
|
MOZ_ASSERT_UNREACHABLE("failed to get font-family");
|
|
return false;
|
|
}
|
|
RefPtr<IDWriteFont> dwFont;
|
|
if (FAILED(family->GetFont(aFace->mIndex, getter_AddRefs(dwFont)))) {
|
|
MOZ_ASSERT_UNREACHABLE("failed to get font from family");
|
|
return false;
|
|
}
|
|
HRESULT ps = GetDirectWriteFaceName(dwFont, PSNAME_ID, aPSName);
|
|
HRESULT full = GetDirectWriteFaceName(dwFont, FULLNAME_ID, aFullName);
|
|
if (FAILED(ps) || FAILED(full) || aPSName.IsEmpty() || aFullName.IsEmpty()) {
|
|
// We'll return true if either name was found, false if both fail.
|
|
// Note that on older Win7 systems, GetDirectWriteFaceName may "succeed"
|
|
// but return an empty string, so we have to check for non-empty strings
|
|
// to be sure we actually got a usable name.
|
|
|
|
// Initialize result to true if either name was already found.
|
|
bool result = (SUCCEEDED(ps) && !aPSName.IsEmpty()) ||
|
|
(SUCCEEDED(full) && !aFullName.IsEmpty());
|
|
RefPtr<IDWriteFontFace> dwFontFace;
|
|
if (FAILED(dwFont->CreateFontFace(getter_AddRefs(dwFontFace)))) {
|
|
NS_WARNING("failed to create font face");
|
|
return result;
|
|
}
|
|
void* context;
|
|
const char* data;
|
|
UINT32 size;
|
|
BOOL exists;
|
|
if (FAILED(dwFontFace->TryGetFontTable(
|
|
NativeEndian::swapToBigEndian(TRUETYPE_TAG('n', 'a', 'm', 'e')),
|
|
(const void**)&data, &size, &context, &exists)) ||
|
|
!exists) {
|
|
NS_WARNING("failed to get name table");
|
|
return result;
|
|
}
|
|
MOZ_SEH_TRY {
|
|
// Try to read the name table entries, and ensure result is true if either
|
|
// one succeeds.
|
|
if (FAILED(ps) || aPSName.IsEmpty()) {
|
|
if (NS_SUCCEEDED(gfxFontUtils::ReadCanonicalName(
|
|
data, size, gfxFontUtils::NAME_ID_POSTSCRIPT, aPSName))) {
|
|
result = true;
|
|
} else {
|
|
NS_WARNING("failed to read psname");
|
|
}
|
|
}
|
|
if (FAILED(full) || aFullName.IsEmpty()) {
|
|
if (NS_SUCCEEDED(gfxFontUtils::ReadCanonicalName(
|
|
data, size, gfxFontUtils::NAME_ID_FULL, aFullName))) {
|
|
result = true;
|
|
} else {
|
|
NS_WARNING("failed to read fullname");
|
|
}
|
|
}
|
|
}
|
|
MOZ_SEH_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
|
|
gfxCriticalNote << "Exception occurred reading face names for "
|
|
<< aFamily->Key().AsString(SharedFontList()).get();
|
|
}
|
|
if (dwFontFace && context) {
|
|
dwFontFace->ReleaseFontTable(context);
|
|
}
|
|
return result;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void gfxDWriteFontList::ReadFaceNamesForFamily(
|
|
fontlist::Family* aFamily, bool aNeedFullnamePostscriptNames) {
|
|
if (!aFamily->IsInitialized()) {
|
|
if (!InitializeFamily(aFamily)) {
|
|
return;
|
|
}
|
|
}
|
|
IDWriteFontCollection* collection =
|
|
#ifdef MOZ_BUNDLED_FONTS
|
|
aFamily->IsBundled() ? mBundledFonts : mSystemFonts;
|
|
#else
|
|
mSystemFonts;
|
|
#endif
|
|
RefPtr<IDWriteFontFamily> family;
|
|
if (FAILED(collection->GetFontFamily(aFamily->Index(),
|
|
getter_AddRefs(family)))) {
|
|
return;
|
|
}
|
|
fontlist::FontList* list = SharedFontList();
|
|
const fontlist::Pointer* facePtrs = aFamily->Faces(list);
|
|
nsAutoCString familyName(aFamily->DisplayName().AsString(list));
|
|
nsAutoCString key(aFamily->Key().AsString(list));
|
|
|
|
// Read PS-names and fullnames of the faces, and any alternate family names
|
|
// (either localizations or legacy subfamily names)
|
|
for (unsigned i = 0; i < aFamily->NumFaces(); ++i) {
|
|
auto face = static_cast<fontlist::Face*>(facePtrs[i].ToPtr(list));
|
|
if (!face) {
|
|
continue;
|
|
}
|
|
RefPtr<IDWriteFont> dwFont;
|
|
if (FAILED(family->GetFont(face->mIndex, getter_AddRefs(dwFont)))) {
|
|
continue;
|
|
}
|
|
RefPtr<IDWriteFontFace> dwFontFace;
|
|
if (FAILED(dwFont->CreateFontFace(getter_AddRefs(dwFontFace)))) {
|
|
continue;
|
|
}
|
|
|
|
const char* data;
|
|
UINT32 size;
|
|
void* context;
|
|
BOOL exists;
|
|
if (FAILED(dwFontFace->TryGetFontTable(
|
|
NativeEndian::swapToBigEndian(TRUETYPE_TAG('n', 'a', 'm', 'e')),
|
|
(const void**)&data, &size, &context, &exists)) ||
|
|
!exists) {
|
|
continue;
|
|
}
|
|
|
|
MOZ_SEH_TRY {
|
|
AutoTArray<nsCString, 4> otherFamilyNames;
|
|
gfxFontUtils::ReadOtherFamilyNamesForFace(familyName, data, size,
|
|
otherFamilyNames, false);
|
|
for (const auto& alias : otherFamilyNames) {
|
|
nsAutoCString key(alias);
|
|
ToLowerCase(key);
|
|
auto aliasData = mAliasTable.GetOrInsertNew(key);
|
|
aliasData->InitFromFamily(aFamily, familyName);
|
|
aliasData->mFaces.AppendElement(facePtrs[i]);
|
|
}
|
|
|
|
nsAutoCString psname, fullname;
|
|
if (NS_SUCCEEDED(gfxFontUtils::ReadCanonicalName(
|
|
data, size, gfxFontUtils::NAME_ID_POSTSCRIPT, psname))) {
|
|
ToLowerCase(psname);
|
|
mLocalNameTable.InsertOrUpdate(
|
|
psname, fontlist::LocalFaceRec::InitData(key, i));
|
|
}
|
|
if (NS_SUCCEEDED(gfxFontUtils::ReadCanonicalName(
|
|
data, size, gfxFontUtils::NAME_ID_FULL, fullname))) {
|
|
ToLowerCase(fullname);
|
|
if (fullname != psname) {
|
|
mLocalNameTable.InsertOrUpdate(
|
|
fullname, fontlist::LocalFaceRec::InitData(key, i));
|
|
}
|
|
}
|
|
}
|
|
MOZ_SEH_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
|
|
gfxCriticalNote << "Exception occurred reading names for "
|
|
<< familyName.get();
|
|
}
|
|
|
|
dwFontFace->ReleaseFontTable(context);
|
|
}
|
|
}
|
|
|
|
enum DWriteInitError {
|
|
errGDIInterop = 1,
|
|
errSystemFontCollection = 2,
|
|
errNoFonts = 3
|
|
};
|
|
|
|
void gfxDWriteFontList::InitSharedFontListForPlatform() {
|
|
mGDIFontTableAccess = Preferences::GetBool(
|
|
"gfx.font_rendering.directwrite.use_gdi_table_loading", false);
|
|
mForceGDIClassicMaxFontSize = Preferences::GetInt(
|
|
"gfx.font_rendering.cleartype_params.force_gdi_classic_max_size",
|
|
mForceGDIClassicMaxFontSize);
|
|
|
|
mSubstitutions.Clear();
|
|
mNonExistingFonts.Clear();
|
|
|
|
RefPtr<IDWriteFactory> factory = Factory::GetDWriteFactory();
|
|
HRESULT hr = factory->GetGdiInterop(getter_AddRefs(mGDIInterop));
|
|
if (FAILED(hr)) {
|
|
Telemetry::Accumulate(Telemetry::DWRITEFONT_INIT_PROBLEM,
|
|
uint32_t(errGDIInterop));
|
|
mSharedFontList.reset(nullptr);
|
|
return;
|
|
}
|
|
|
|
mSystemFonts = Factory::GetDWriteSystemFonts(true);
|
|
NS_ASSERTION(mSystemFonts != nullptr, "GetSystemFontCollection failed!");
|
|
if (!mSystemFonts) {
|
|
Telemetry::Accumulate(Telemetry::DWRITEFONT_INIT_PROBLEM,
|
|
uint32_t(errSystemFontCollection));
|
|
mSharedFontList.reset(nullptr);
|
|
return;
|
|
}
|
|
#ifdef MOZ_BUNDLED_FONTS
|
|
// We activate bundled fonts if the pref is > 0 (on) or < 0 (auto), only an
|
|
// explicit value of 0 (off) will disable them.
|
|
TimeStamp start1 = TimeStamp::Now();
|
|
if (StaticPrefs::gfx_bundled_fonts_activate_AtStartup() != 0) {
|
|
mBundledFonts = CreateBundledFontsCollection(factory);
|
|
}
|
|
TimeStamp end1 = TimeStamp::Now();
|
|
#endif
|
|
|
|
if (XRE_IsParentProcess()) {
|
|
nsAutoCString classicFamilies;
|
|
AutoTArray<nsCString, 16> forceClassicFams;
|
|
nsresult rv = Preferences::GetCString(
|
|
"gfx.font_rendering.cleartype_params.force_gdi_classic_for_families",
|
|
classicFamilies);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
for (auto name :
|
|
nsCCharSeparatedTokenizer(classicFamilies, ',').ToRange()) {
|
|
BuildKeyNameFromFontName(name);
|
|
forceClassicFams.AppendElement(name);
|
|
}
|
|
forceClassicFams.Sort();
|
|
}
|
|
nsTArray<fontlist::Family::InitData> families;
|
|
AppendFamiliesFromCollection(mSystemFonts, families, &forceClassicFams);
|
|
#ifdef MOZ_BUNDLED_FONTS
|
|
if (mBundledFonts) {
|
|
TimeStamp start2 = TimeStamp::Now();
|
|
AppendFamiliesFromCollection(mBundledFonts, families);
|
|
TimeStamp end2 = TimeStamp::Now();
|
|
Telemetry::Accumulate(
|
|
Telemetry::FONTLIST_BUNDLEDFONTS_ACTIVATE,
|
|
(end1 - start1).ToMilliseconds() + (end2 - start2).ToMilliseconds());
|
|
}
|
|
#endif
|
|
SharedFontList()->SetFamilyNames(families);
|
|
GetPrefsAndStartLoader();
|
|
}
|
|
|
|
if (!SharedFontList()->Initialized()) {
|
|
return;
|
|
}
|
|
|
|
GetDirectWriteSubstitutes();
|
|
GetFontSubstitutes();
|
|
}
|
|
|
|
nsresult gfxDWriteFontList::InitFontListForPlatform() {
|
|
LARGE_INTEGER frequency; // ticks per second
|
|
LARGE_INTEGER t1, t2, t3, t4, t5; // ticks
|
|
double elapsedTime, upTime;
|
|
char nowTime[256], nowDate[256];
|
|
|
|
if (LOG_FONTINIT_ENABLED()) {
|
|
GetTimeFormatA(LOCALE_INVARIANT, TIME_FORCE24HOURFORMAT, nullptr, nullptr,
|
|
nowTime, 256);
|
|
GetDateFormatA(LOCALE_INVARIANT, 0, nullptr, nullptr, nowDate, 256);
|
|
upTime = (double)GetTickCount();
|
|
}
|
|
QueryPerformanceFrequency(&frequency);
|
|
QueryPerformanceCounter(&t1); // start
|
|
|
|
HRESULT hr;
|
|
mGDIFontTableAccess = Preferences::GetBool(
|
|
"gfx.font_rendering.directwrite.use_gdi_table_loading", false);
|
|
|
|
mFontSubstitutes.Clear();
|
|
mNonExistingFonts.Clear();
|
|
|
|
RefPtr<IDWriteFactory> factory = Factory::GetDWriteFactory();
|
|
|
|
hr = factory->GetGdiInterop(getter_AddRefs(mGDIInterop));
|
|
if (FAILED(hr)) {
|
|
Telemetry::Accumulate(Telemetry::DWRITEFONT_INIT_PROBLEM,
|
|
uint32_t(errGDIInterop));
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
QueryPerformanceCounter(&t2); // base-class/interop initialization
|
|
|
|
mSystemFonts = Factory::GetDWriteSystemFonts(true);
|
|
NS_ASSERTION(mSystemFonts != nullptr, "GetSystemFontCollection failed!");
|
|
|
|
if (!mSystemFonts) {
|
|
Telemetry::Accumulate(Telemetry::DWRITEFONT_INIT_PROBLEM,
|
|
uint32_t(errSystemFontCollection));
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
#ifdef MOZ_BUNDLED_FONTS
|
|
// Get bundled fonts before the system collection, so that in the case of
|
|
// duplicate names, we have recorded the family as bundled (and therefore
|
|
// available regardless of visibility settings).
|
|
// We activate bundled fonts if the pref is > 0 (on) or < 0 (auto), only an
|
|
// explicit value of 0 (off) will disable them.
|
|
if (StaticPrefs::gfx_bundled_fonts_activate_AtStartup() != 0) {
|
|
TimeStamp start = TimeStamp::Now();
|
|
mBundledFonts = CreateBundledFontsCollection(factory);
|
|
if (mBundledFonts) {
|
|
GetFontsFromCollection(mBundledFonts);
|
|
}
|
|
TimeStamp end = TimeStamp::Now();
|
|
Telemetry::Accumulate(Telemetry::FONTLIST_BUNDLEDFONTS_ACTIVATE,
|
|
(end - start).ToMilliseconds());
|
|
}
|
|
#endif
|
|
const uint32_t kBundledCount = mFontFamilies.Count();
|
|
|
|
QueryPerformanceCounter(&t3); // system font collection
|
|
|
|
GetFontsFromCollection(mSystemFonts);
|
|
|
|
// if no fonts found, something is out of whack, bail and use GDI backend
|
|
NS_ASSERTION(mFontFamilies.Count() > kBundledCount,
|
|
"no fonts found in the system fontlist -- holy crap batman!");
|
|
if (mFontFamilies.Count() == kBundledCount) {
|
|
Telemetry::Accumulate(Telemetry::DWRITEFONT_INIT_PROBLEM,
|
|
uint32_t(errNoFonts));
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
QueryPerformanceCounter(&t4); // iterate over system fonts
|
|
|
|
mOtherFamilyNamesInitialized = true;
|
|
GetFontSubstitutes();
|
|
|
|
// bug 642093 - DirectWrite does not support old bitmap (.fon)
|
|
// font files, but a few of these such as "Courier" and "MS Sans Serif"
|
|
// are frequently specified in shoddy CSS, without appropriate fallbacks.
|
|
// By mapping these to TrueType equivalents, we provide better consistency
|
|
// with both pre-DW systems and with IE9, which appears to do the same.
|
|
GetDirectWriteSubstitutes();
|
|
|
|
// bug 551313 - DirectWrite creates a Gill Sans family out of
|
|
// poorly named members of the Gill Sans MT family containing
|
|
// only Ultra Bold weights. This causes big problems for pages
|
|
// using Gill Sans which is usually only available on OSX
|
|
|
|
nsAutoCString nameGillSans("Gill Sans");
|
|
nsAutoCString nameGillSansMT("Gill Sans MT");
|
|
BuildKeyNameFromFontName(nameGillSans);
|
|
BuildKeyNameFromFontName(nameGillSansMT);
|
|
|
|
gfxFontFamily* gillSansFamily = mFontFamilies.GetWeak(nameGillSans);
|
|
gfxFontFamily* gillSansMTFamily = mFontFamilies.GetWeak(nameGillSansMT);
|
|
|
|
if (gillSansFamily && gillSansMTFamily) {
|
|
gillSansFamily->FindStyleVariations();
|
|
|
|
gillSansFamily->ReadLock();
|
|
const auto& faces = gillSansFamily->GetFontList();
|
|
|
|
bool allUltraBold = true;
|
|
for (const auto& face : faces) {
|
|
// does the face have 'Ultra Bold' in the name?
|
|
if (face->Name().Find("Ultra Bold"_ns) == -1) {
|
|
allUltraBold = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// if all the Gill Sans faces are Ultra Bold ==> move faces
|
|
// for Gill Sans into Gill Sans MT family
|
|
if (allUltraBold) {
|
|
// add faces to Gill Sans MT
|
|
for (const auto& face : faces) {
|
|
// change the entry's family name to match its adoptive family
|
|
face->mFamilyName = gillSansMTFamily->Name();
|
|
gillSansMTFamily->AddFontEntry(face);
|
|
|
|
if (LOG_FONTLIST_ENABLED()) {
|
|
nsAutoCString weightString;
|
|
face->Weight().ToString(weightString);
|
|
LOG_FONTLIST(
|
|
("(fontlist) moved (%s) to family (%s)"
|
|
" with style: %s weight: %s stretch: %d",
|
|
face->Name().get(), gillSansMTFamily->Name().get(),
|
|
(face->IsItalic()) ? "italic"
|
|
: (face->IsOblique() ? "oblique" : "normal"),
|
|
weightString.get(), face->Stretch().AsScalar()));
|
|
}
|
|
}
|
|
gillSansFamily->ReadUnlock();
|
|
|
|
// remove Gill Sans
|
|
mFontFamilies.Remove(nameGillSans);
|
|
} else {
|
|
gillSansFamily->ReadUnlock();
|
|
}
|
|
}
|
|
|
|
nsAutoCString classicFamilies;
|
|
nsresult rv = Preferences::GetCString(
|
|
"gfx.font_rendering.cleartype_params.force_gdi_classic_for_families",
|
|
classicFamilies);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
nsCCharSeparatedTokenizer tokenizer(classicFamilies, ',');
|
|
while (tokenizer.hasMoreTokens()) {
|
|
nsAutoCString name(tokenizer.nextToken());
|
|
BuildKeyNameFromFontName(name);
|
|
gfxFontFamily* family = mFontFamilies.GetWeak(name);
|
|
if (family) {
|
|
static_cast<gfxDWriteFontFamily*>(family)->SetForceGDIClassic(true);
|
|
}
|
|
}
|
|
}
|
|
mForceGDIClassicMaxFontSize = Preferences::GetInt(
|
|
"gfx.font_rendering.cleartype_params.force_gdi_classic_max_size",
|
|
mForceGDIClassicMaxFontSize);
|
|
|
|
GetPrefsAndStartLoader();
|
|
|
|
QueryPerformanceCounter(&t5); // misc initialization
|
|
|
|
if (LOG_FONTINIT_ENABLED()) {
|
|
// determine dwrite version
|
|
nsAutoString dwriteVers;
|
|
gfxWindowsPlatform::GetDLLVersion(L"dwrite.dll", dwriteVers);
|
|
LOG_FONTINIT(("(fontinit) Start: %s %s\n", nowDate, nowTime));
|
|
LOG_FONTINIT(("(fontinit) Uptime: %9.3f s\n", upTime / 1000));
|
|
LOG_FONTINIT(("(fontinit) dwrite version: %s\n",
|
|
NS_ConvertUTF16toUTF8(dwriteVers).get()));
|
|
}
|
|
|
|
elapsedTime = (t5.QuadPart - t1.QuadPart) * 1000.0 / frequency.QuadPart;
|
|
Telemetry::Accumulate(Telemetry::DWRITEFONT_DELAYEDINITFONTLIST_TOTAL,
|
|
elapsedTime);
|
|
Telemetry::Accumulate(Telemetry::DWRITEFONT_DELAYEDINITFONTLIST_COUNT,
|
|
mSystemFonts->GetFontFamilyCount());
|
|
LOG_FONTINIT((
|
|
"(fontinit) Total time in InitFontList: %9.3f ms (families: %d, %s)\n",
|
|
elapsedTime, mSystemFonts->GetFontFamilyCount(),
|
|
(mGDIFontTableAccess ? "gdi table access" : "dwrite table access")));
|
|
|
|
elapsedTime = (t2.QuadPart - t1.QuadPart) * 1000.0 / frequency.QuadPart;
|
|
LOG_FONTINIT(
|
|
("(fontinit) --- base/interop obj initialization init: %9.3f ms\n",
|
|
elapsedTime));
|
|
|
|
elapsedTime = (t3.QuadPart - t2.QuadPart) * 1000.0 / frequency.QuadPart;
|
|
Telemetry::Accumulate(Telemetry::DWRITEFONT_DELAYEDINITFONTLIST_COLLECT,
|
|
elapsedTime);
|
|
LOG_FONTINIT(
|
|
("(fontinit) --- GetSystemFontCollection: %9.3f ms\n", elapsedTime));
|
|
|
|
elapsedTime = (t4.QuadPart - t3.QuadPart) * 1000.0 / frequency.QuadPart;
|
|
LOG_FONTINIT(
|
|
("(fontinit) --- iterate over families: %9.3f ms\n", elapsedTime));
|
|
|
|
elapsedTime = (t5.QuadPart - t4.QuadPart) * 1000.0 / frequency.QuadPart;
|
|
LOG_FONTINIT(
|
|
("(fontinit) --- misc initialization: %9.3f ms\n", elapsedTime));
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
void gfxDWriteFontList::GetFontsFromCollection(
|
|
IDWriteFontCollection* aCollection) {
|
|
for (UINT32 i = 0; i < aCollection->GetFontFamilyCount(); i++) {
|
|
RefPtr<IDWriteFontFamily> family;
|
|
aCollection->GetFontFamily(i, getter_AddRefs(family));
|
|
|
|
RefPtr<IDWriteLocalizedStrings> names;
|
|
HRESULT hr = family->GetFamilyNames(getter_AddRefs(names));
|
|
if (FAILED(hr)) {
|
|
continue;
|
|
}
|
|
|
|
nsAutoCString name;
|
|
if (!GetEnglishOrFirstName(name, names)) {
|
|
continue;
|
|
}
|
|
nsAutoCString familyName(
|
|
name); // keep a copy before we lowercase it as a key
|
|
|
|
BuildKeyNameFromFontName(name);
|
|
|
|
RefPtr<gfxFontFamily> fam;
|
|
|
|
if (mFontFamilies.GetWeak(name)) {
|
|
continue;
|
|
}
|
|
|
|
FontVisibility visibility = aCollection == mSystemFonts
|
|
? GetVisibilityForFamily(familyName)
|
|
: FontVisibility::Base;
|
|
|
|
fam = new gfxDWriteFontFamily(familyName, visibility, family,
|
|
aCollection == mSystemFonts);
|
|
if (!fam) {
|
|
continue;
|
|
}
|
|
|
|
if (mBadUnderlineFamilyNames.ContainsSorted(name)) {
|
|
fam->SetBadUnderlineFamily();
|
|
}
|
|
mFontFamilies.InsertOrUpdate(name, RefPtr{fam});
|
|
|
|
// now add other family name localizations, if present
|
|
uint32_t nameCount = names->GetCount();
|
|
uint32_t nameIndex;
|
|
|
|
if (nameCount > 1) {
|
|
UINT32 englishIdx = 0;
|
|
BOOL exists;
|
|
// if this fails/doesn't exist, we'll have used name index 0,
|
|
// so that's the one we'll want to skip here
|
|
names->FindLocaleName(L"en-us", &englishIdx, &exists);
|
|
AutoTArray<nsCString, 4> otherFamilyNames;
|
|
for (nameIndex = 0; nameIndex < nameCount; nameIndex++) {
|
|
UINT32 nameLen;
|
|
AutoTArray<WCHAR, 32> localizedName;
|
|
|
|
// only add other names
|
|
if (nameIndex == englishIdx) {
|
|
continue;
|
|
}
|
|
|
|
hr = names->GetStringLength(nameIndex, &nameLen);
|
|
if (FAILED(hr)) {
|
|
continue;
|
|
}
|
|
|
|
if (!localizedName.SetLength(nameLen + 1, fallible)) {
|
|
continue;
|
|
}
|
|
|
|
hr = names->GetString(nameIndex, localizedName.Elements(), nameLen + 1);
|
|
if (FAILED(hr)) {
|
|
continue;
|
|
}
|
|
|
|
NS_ConvertUTF16toUTF8 locName(localizedName.Elements());
|
|
|
|
if (!familyName.Equals(locName)) {
|
|
otherFamilyNames.AppendElement(locName);
|
|
}
|
|
}
|
|
if (!otherFamilyNames.IsEmpty()) {
|
|
AddOtherFamilyNames(fam, otherFamilyNames);
|
|
}
|
|
}
|
|
|
|
// at this point, all family names have been read in
|
|
fam->SetOtherFamilyNamesInitialized();
|
|
}
|
|
}
|
|
|
|
static void RemoveCharsetFromFontSubstitute(nsACString& aName) {
|
|
int32_t comma = aName.FindChar(',');
|
|
if (comma >= 0) aName.Truncate(comma);
|
|
}
|
|
|
|
#define MAX_VALUE_NAME 512
|
|
#define MAX_VALUE_DATA 512
|
|
|
|
nsresult gfxDWriteFontList::GetFontSubstitutes() {
|
|
HKEY hKey;
|
|
DWORD i, rv, lenAlias, lenActual, valueType;
|
|
WCHAR aliasName[MAX_VALUE_NAME];
|
|
WCHAR actualName[MAX_VALUE_DATA];
|
|
|
|
if (RegOpenKeyExW(
|
|
HKEY_LOCAL_MACHINE,
|
|
L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes",
|
|
0, KEY_READ, &hKey) != ERROR_SUCCESS) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
for (i = 0, rv = ERROR_SUCCESS; rv != ERROR_NO_MORE_ITEMS; i++) {
|
|
aliasName[0] = 0;
|
|
lenAlias = ArrayLength(aliasName);
|
|
actualName[0] = 0;
|
|
lenActual = sizeof(actualName);
|
|
rv = RegEnumValueW(hKey, i, aliasName, &lenAlias, nullptr, &valueType,
|
|
(LPBYTE)actualName, &lenActual);
|
|
|
|
if (rv != ERROR_SUCCESS || valueType != REG_SZ || lenAlias == 0) {
|
|
continue;
|
|
}
|
|
|
|
if (aliasName[0] == WCHAR('@')) {
|
|
continue;
|
|
}
|
|
|
|
NS_ConvertUTF16toUTF8 substituteName((char16_t*)aliasName);
|
|
NS_ConvertUTF16toUTF8 actualFontName((char16_t*)actualName);
|
|
RemoveCharsetFromFontSubstitute(substituteName);
|
|
BuildKeyNameFromFontName(substituteName);
|
|
RemoveCharsetFromFontSubstitute(actualFontName);
|
|
BuildKeyNameFromFontName(actualFontName);
|
|
if (SharedFontList()) {
|
|
// Skip substitution if the original font is available, unless the option
|
|
// to apply substitutions unconditionally is enabled.
|
|
if (!StaticPrefs::gfx_windows_font_substitutes_always_AtStartup()) {
|
|
// Font substitutions are recorded for the canonical family names; we
|
|
// don't need FindFamily to consider localized aliases when searching.
|
|
if (SharedFontList()->FindFamily(substituteName,
|
|
/*aPrimaryNameOnly*/ true)) {
|
|
continue;
|
|
}
|
|
}
|
|
if (SharedFontList()->FindFamily(actualFontName,
|
|
/*aPrimaryNameOnly*/ true)) {
|
|
mSubstitutions.InsertOrUpdate(substituteName,
|
|
MakeUnique<nsCString>(actualFontName));
|
|
} else if (mSubstitutions.Get(actualFontName)) {
|
|
mSubstitutions.InsertOrUpdate(
|
|
substituteName,
|
|
MakeUnique<nsCString>(*mSubstitutions.Get(actualFontName)));
|
|
} else {
|
|
mNonExistingFonts.AppendElement(substituteName);
|
|
}
|
|
} else {
|
|
gfxFontFamily* ff;
|
|
if (!actualFontName.IsEmpty() &&
|
|
(ff = mFontFamilies.GetWeak(actualFontName))) {
|
|
mFontSubstitutes.InsertOrUpdate(substituteName, RefPtr{ff});
|
|
} else {
|
|
mNonExistingFonts.AppendElement(substituteName);
|
|
}
|
|
}
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
struct FontSubstitution {
|
|
const char* aliasName;
|
|
const char* actualName;
|
|
};
|
|
|
|
static const FontSubstitution sDirectWriteSubs[] = {
|
|
{"MS Sans Serif", "Microsoft Sans Serif"},
|
|
{"MS Serif", "Times New Roman"},
|
|
{"Courier", "Courier New"},
|
|
{"Small Fonts", "Arial"},
|
|
{"Roman", "Times New Roman"},
|
|
{"Script", "Mistral"}};
|
|
|
|
void gfxDWriteFontList::GetDirectWriteSubstitutes() {
|
|
for (uint32_t i = 0; i < ArrayLength(sDirectWriteSubs); ++i) {
|
|
const FontSubstitution& sub(sDirectWriteSubs[i]);
|
|
nsAutoCString substituteName(sub.aliasName);
|
|
BuildKeyNameFromFontName(substituteName);
|
|
if (SharedFontList()) {
|
|
// Skip substitution if the original font is available, unless the option
|
|
// to apply substitutions unconditionally is enabled.
|
|
if (!StaticPrefs::gfx_windows_font_substitutes_always_AtStartup()) {
|
|
// We don't need FindFamily to consider localized aliases when searching
|
|
// for the DirectWrite substitutes, we know the canonical names.
|
|
if (SharedFontList()->FindFamily(substituteName,
|
|
/*aPrimaryNameOnly*/ true)) {
|
|
continue;
|
|
}
|
|
}
|
|
nsAutoCString actualFontName(sub.actualName);
|
|
BuildKeyNameFromFontName(actualFontName);
|
|
if (SharedFontList()->FindFamily(actualFontName,
|
|
/*aPrimaryNameOnly*/ true)) {
|
|
mSubstitutions.InsertOrUpdate(substituteName,
|
|
MakeUnique<nsCString>(actualFontName));
|
|
} else {
|
|
mNonExistingFonts.AppendElement(substituteName);
|
|
}
|
|
} else {
|
|
if (nullptr != mFontFamilies.GetWeak(substituteName)) {
|
|
// don't do the substitution if user actually has a usable font
|
|
// with this name installed
|
|
continue;
|
|
}
|
|
nsAutoCString actualFontName(sub.actualName);
|
|
BuildKeyNameFromFontName(actualFontName);
|
|
gfxFontFamily* ff;
|
|
if (nullptr != (ff = mFontFamilies.GetWeak(actualFontName))) {
|
|
mFontSubstitutes.InsertOrUpdate(substituteName, RefPtr{ff});
|
|
} else {
|
|
mNonExistingFonts.AppendElement(substituteName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool gfxDWriteFontList::FindAndAddFamiliesLocked(
|
|
nsPresContext* aPresContext, StyleGenericFontFamily aGeneric,
|
|
const nsACString& aFamily, nsTArray<FamilyAndGeneric>* aOutput,
|
|
FindFamiliesFlags aFlags, gfxFontStyle* aStyle, nsAtom* aLanguage,
|
|
gfxFloat aDevToCssSize) {
|
|
nsAutoCString keyName(aFamily);
|
|
BuildKeyNameFromFontName(keyName);
|
|
|
|
if (SharedFontList()) {
|
|
nsACString* subst = mSubstitutions.Get(keyName);
|
|
if (subst) {
|
|
keyName = *subst;
|
|
}
|
|
} else {
|
|
gfxFontFamily* ff = mFontSubstitutes.GetWeak(keyName);
|
|
FontVisibility level =
|
|
aPresContext ? aPresContext->GetFontVisibility() : FontVisibility::User;
|
|
if (ff && IsVisibleToCSS(*ff, level)) {
|
|
aOutput->AppendElement(FamilyAndGeneric(ff, aGeneric));
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (mNonExistingFonts.Contains(keyName)) {
|
|
return false;
|
|
}
|
|
|
|
return gfxPlatformFontList::FindAndAddFamiliesLocked(
|
|
aPresContext, aGeneric, keyName, aOutput, aFlags, aStyle, aLanguage,
|
|
aDevToCssSize);
|
|
}
|
|
|
|
void gfxDWriteFontList::AddSizeOfExcludingThis(MallocSizeOf aMallocSizeOf,
|
|
FontListSizes* aSizes) const {
|
|
gfxPlatformFontList::AddSizeOfExcludingThis(aMallocSizeOf, aSizes);
|
|
|
|
AutoLock lock(mLock);
|
|
|
|
// We are a singleton, so include the font loader singleton's memory.
|
|
MOZ_ASSERT(static_cast<const gfxPlatformFontList*>(this) ==
|
|
gfxPlatformFontList::PlatformFontList());
|
|
gfxDWriteFontFileLoader* loader = static_cast<gfxDWriteFontFileLoader*>(
|
|
gfxDWriteFontFileLoader::Instance());
|
|
aSizes->mLoaderSize += loader->SizeOfIncludingThis(aMallocSizeOf);
|
|
|
|
aSizes->mFontListSize +=
|
|
SizeOfFontFamilyTableExcludingThis(mFontSubstitutes, aMallocSizeOf);
|
|
|
|
aSizes->mFontListSize +=
|
|
mNonExistingFonts.ShallowSizeOfExcludingThis(aMallocSizeOf);
|
|
for (uint32_t i = 0; i < mNonExistingFonts.Length(); ++i) {
|
|
aSizes->mFontListSize +=
|
|
mNonExistingFonts[i].SizeOfExcludingThisIfUnshared(aMallocSizeOf);
|
|
}
|
|
}
|
|
|
|
void gfxDWriteFontList::AddSizeOfIncludingThis(MallocSizeOf aMallocSizeOf,
|
|
FontListSizes* aSizes) const {
|
|
aSizes->mFontListSize += aMallocSizeOf(this);
|
|
AddSizeOfExcludingThis(aMallocSizeOf, aSizes);
|
|
}
|
|
|
|
static HRESULT GetFamilyName(IDWriteFont* aFont, nsCString& aFamilyName) {
|
|
HRESULT hr;
|
|
RefPtr<IDWriteFontFamily> family;
|
|
|
|
// clean out previous value
|
|
aFamilyName.Truncate();
|
|
|
|
hr = aFont->GetFontFamily(getter_AddRefs(family));
|
|
if (FAILED(hr)) {
|
|
return hr;
|
|
}
|
|
|
|
RefPtr<IDWriteLocalizedStrings> familyNames;
|
|
|
|
hr = family->GetFamilyNames(getter_AddRefs(familyNames));
|
|
if (FAILED(hr)) {
|
|
return hr;
|
|
}
|
|
|
|
if (!GetEnglishOrFirstName(aFamilyName, familyNames)) {
|
|
return E_FAIL;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
// bug 705594 - the method below doesn't actually do any "drawing", it's only
|
|
// used to invoke the DirectWrite layout engine to determine the fallback font
|
|
// for a given character.
|
|
|
|
IFACEMETHODIMP DWriteFontFallbackRenderer::DrawGlyphRun(
|
|
void* clientDrawingContext, FLOAT baselineOriginX, FLOAT baselineOriginY,
|
|
DWRITE_MEASURING_MODE measuringMode, DWRITE_GLYPH_RUN const* glyphRun,
|
|
DWRITE_GLYPH_RUN_DESCRIPTION const* glyphRunDescription,
|
|
IUnknown* clientDrawingEffect) {
|
|
if (!mSystemFonts) {
|
|
return E_FAIL;
|
|
}
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
RefPtr<IDWriteFont> font;
|
|
hr = mSystemFonts->GetFontFromFontFace(glyphRun->fontFace,
|
|
getter_AddRefs(font));
|
|
if (FAILED(hr)) {
|
|
return hr;
|
|
}
|
|
|
|
// copy the family name
|
|
hr = GetFamilyName(font, mFamilyName);
|
|
if (FAILED(hr)) {
|
|
return hr;
|
|
}
|
|
|
|
// Arial is used as the default fallback font
|
|
// so if it matches ==> no font found
|
|
if (mFamilyName.EqualsLiteral("Arial")) {
|
|
mFamilyName.Truncate();
|
|
return E_FAIL;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
gfxFontEntry* gfxDWriteFontList::PlatformGlobalFontFallback(
|
|
nsPresContext* aPresContext, const uint32_t aCh, Script aRunScript,
|
|
const gfxFontStyle* aMatchStyle, FontFamily& aMatchedFamily) {
|
|
HRESULT hr;
|
|
|
|
RefPtr<IDWriteFactory> dwFactory = Factory::GetDWriteFactory();
|
|
if (!dwFactory) {
|
|
return nullptr;
|
|
}
|
|
|
|
// initialize fallback renderer
|
|
if (!mFallbackRenderer) {
|
|
mFallbackRenderer = new DWriteFontFallbackRenderer(dwFactory);
|
|
}
|
|
if (!mFallbackRenderer->IsValid()) {
|
|
return nullptr;
|
|
}
|
|
|
|
// initialize text format
|
|
if (!mFallbackFormat) {
|
|
hr = dwFactory->CreateTextFormat(
|
|
L"Arial", nullptr, DWRITE_FONT_WEIGHT_REGULAR, DWRITE_FONT_STYLE_NORMAL,
|
|
DWRITE_FONT_STRETCH_NORMAL, 72.0f, L"en-us",
|
|
getter_AddRefs(mFallbackFormat));
|
|
if (FAILED(hr)) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
// set up string with fallback character
|
|
wchar_t str[16];
|
|
uint32_t strLen;
|
|
|
|
if (IS_IN_BMP(aCh)) {
|
|
str[0] = static_cast<wchar_t>(aCh);
|
|
str[1] = 0;
|
|
strLen = 1;
|
|
} else {
|
|
str[0] = static_cast<wchar_t>(H_SURROGATE(aCh));
|
|
str[1] = static_cast<wchar_t>(L_SURROGATE(aCh));
|
|
str[2] = 0;
|
|
strLen = 2;
|
|
}
|
|
|
|
// set up layout
|
|
RefPtr<IDWriteTextLayout> fallbackLayout;
|
|
|
|
hr = dwFactory->CreateTextLayout(str, strLen, mFallbackFormat, 200.0f, 200.0f,
|
|
getter_AddRefs(fallbackLayout));
|
|
if (FAILED(hr)) {
|
|
return nullptr;
|
|
}
|
|
|
|
// call the draw method to invoke the DirectWrite layout functions
|
|
// which determine the fallback font
|
|
MOZ_SEH_TRY {
|
|
hr = fallbackLayout->Draw(nullptr, mFallbackRenderer, 50.0f, 50.0f);
|
|
if (FAILED(hr)) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
MOZ_SEH_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
|
|
gfxCriticalNote << "Exception occurred during DWrite font fallback";
|
|
return nullptr;
|
|
}
|
|
|
|
FontFamily family =
|
|
FindFamily(aPresContext, mFallbackRenderer->FallbackFamilyName());
|
|
if (!family.IsNull()) {
|
|
gfxFontEntry* fontEntry = nullptr;
|
|
if (family.mIsShared) {
|
|
auto face =
|
|
family.mShared->FindFaceForStyle(SharedFontList(), *aMatchStyle);
|
|
if (face) {
|
|
fontEntry = GetOrCreateFontEntry(face, family.mShared);
|
|
}
|
|
} else {
|
|
fontEntry = family.mUnshared->FindFontForStyle(*aMatchStyle);
|
|
}
|
|
if (fontEntry && fontEntry->HasCharacter(aCh)) {
|
|
aMatchedFamily = family;
|
|
return fontEntry;
|
|
}
|
|
Telemetry::Accumulate(Telemetry::BAD_FALLBACK_FONT, true);
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
// used to load system-wide font info on off-main thread
|
|
class DirectWriteFontInfo : public FontInfoData {
|
|
public:
|
|
DirectWriteFontInfo(bool aLoadOtherNames, bool aLoadFaceNames,
|
|
bool aLoadCmaps, IDWriteFontCollection* aSystemFonts
|
|
#ifdef MOZ_BUNDLED_FONTS
|
|
,
|
|
IDWriteFontCollection* aBundledFonts
|
|
#endif
|
|
)
|
|
: FontInfoData(aLoadOtherNames, aLoadFaceNames, aLoadCmaps),
|
|
mSystemFonts(aSystemFonts)
|
|
#ifdef MOZ_BUNDLED_FONTS
|
|
,
|
|
mBundledFonts(aBundledFonts)
|
|
#endif
|
|
{
|
|
}
|
|
|
|
virtual ~DirectWriteFontInfo() = default;
|
|
|
|
// loads font data for all members of a given family
|
|
virtual void LoadFontFamilyData(const nsACString& aFamilyName);
|
|
|
|
private:
|
|
RefPtr<IDWriteFontCollection> mSystemFonts;
|
|
#ifdef MOZ_BUNDLED_FONTS
|
|
RefPtr<IDWriteFontCollection> mBundledFonts;
|
|
#endif
|
|
};
|
|
|
|
void DirectWriteFontInfo::LoadFontFamilyData(const nsACString& aFamilyName) {
|
|
// lookup the family
|
|
NS_ConvertUTF8toUTF16 famName(aFamilyName);
|
|
|
|
HRESULT hr;
|
|
BOOL exists = false;
|
|
|
|
uint32_t index;
|
|
RefPtr<IDWriteFontFamily> family;
|
|
hr = mSystemFonts->FindFamilyName((const wchar_t*)famName.get(), &index,
|
|
&exists);
|
|
if (SUCCEEDED(hr) && exists) {
|
|
mSystemFonts->GetFontFamily(index, getter_AddRefs(family));
|
|
if (!family) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
#ifdef MOZ_BUNDLED_FONTS
|
|
if (!family && mBundledFonts) {
|
|
hr = mBundledFonts->FindFamilyName((const wchar_t*)famName.get(), &index,
|
|
&exists);
|
|
if (SUCCEEDED(hr) && exists) {
|
|
mBundledFonts->GetFontFamily(index, getter_AddRefs(family));
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (!family) {
|
|
return;
|
|
}
|
|
|
|
// later versions of DirectWrite support querying the fullname/psname
|
|
bool loadFaceNamesUsingDirectWrite = mLoadFaceNames;
|
|
|
|
for (uint32_t i = 0; i < family->GetFontCount(); i++) {
|
|
// get the font
|
|
RefPtr<IDWriteFont> dwFont;
|
|
hr = family->GetFont(i, getter_AddRefs(dwFont));
|
|
if (FAILED(hr)) {
|
|
// This should never happen.
|
|
NS_WARNING("Failed to get existing font from family.");
|
|
continue;
|
|
}
|
|
|
|
if (dwFont->GetSimulations() != DWRITE_FONT_SIMULATIONS_NONE) {
|
|
// We don't want these in the font list; we'll apply simulations
|
|
// on the fly when appropriate.
|
|
continue;
|
|
}
|
|
|
|
mLoadStats.fonts++;
|
|
|
|
// get the name of the face
|
|
nsCString fullID(aFamilyName);
|
|
nsAutoCString fontName;
|
|
hr = GetDirectWriteFontName(dwFont, fontName);
|
|
if (FAILED(hr)) {
|
|
continue;
|
|
}
|
|
fullID.Append(' ');
|
|
fullID.Append(fontName);
|
|
|
|
FontFaceData fontData;
|
|
bool haveData = true;
|
|
RefPtr<IDWriteFontFace> dwFontFace;
|
|
|
|
if (mLoadFaceNames) {
|
|
// try to load using DirectWrite first
|
|
if (loadFaceNamesUsingDirectWrite) {
|
|
hr =
|
|
GetDirectWriteFaceName(dwFont, PSNAME_ID, fontData.mPostscriptName);
|
|
if (FAILED(hr)) {
|
|
loadFaceNamesUsingDirectWrite = false;
|
|
}
|
|
hr = GetDirectWriteFaceName(dwFont, FULLNAME_ID, fontData.mFullName);
|
|
if (FAILED(hr)) {
|
|
loadFaceNamesUsingDirectWrite = false;
|
|
}
|
|
}
|
|
|
|
// if DirectWrite read fails, load directly from name table
|
|
if (!loadFaceNamesUsingDirectWrite) {
|
|
hr = dwFont->CreateFontFace(getter_AddRefs(dwFontFace));
|
|
if (SUCCEEDED(hr)) {
|
|
uint32_t kNAME =
|
|
NativeEndian::swapToBigEndian(TRUETYPE_TAG('n', 'a', 'm', 'e'));
|
|
const char* nameData;
|
|
BOOL exists;
|
|
void* ctx;
|
|
uint32_t nameSize;
|
|
|
|
hr = dwFontFace->TryGetFontTable(kNAME, (const void**)&nameData,
|
|
&nameSize, &ctx, &exists);
|
|
if (SUCCEEDED(hr) && nameData && nameSize > 0) {
|
|
MOZ_SEH_TRY {
|
|
gfxFontUtils::ReadCanonicalName(nameData, nameSize,
|
|
gfxFontUtils::NAME_ID_FULL,
|
|
fontData.mFullName);
|
|
gfxFontUtils::ReadCanonicalName(nameData, nameSize,
|
|
gfxFontUtils::NAME_ID_POSTSCRIPT,
|
|
fontData.mPostscriptName);
|
|
}
|
|
MOZ_SEH_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
|
|
gfxCriticalNote << "Exception occurred reading names for "
|
|
<< PromiseFlatCString(aFamilyName).get();
|
|
}
|
|
dwFontFace->ReleaseFontTable(ctx);
|
|
}
|
|
}
|
|
}
|
|
|
|
haveData =
|
|
!fontData.mPostscriptName.IsEmpty() || !fontData.mFullName.IsEmpty();
|
|
if (haveData) {
|
|
mLoadStats.facenames++;
|
|
}
|
|
}
|
|
|
|
// cmaps
|
|
if (mLoadCmaps) {
|
|
if (!dwFontFace) {
|
|
hr = dwFont->CreateFontFace(getter_AddRefs(dwFontFace));
|
|
if (!SUCCEEDED(hr)) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
uint32_t kCMAP =
|
|
NativeEndian::swapToBigEndian(TRUETYPE_TAG('c', 'm', 'a', 'p'));
|
|
const uint8_t* cmapData;
|
|
BOOL exists;
|
|
void* ctx;
|
|
uint32_t cmapSize;
|
|
|
|
hr = dwFontFace->TryGetFontTable(kCMAP, (const void**)&cmapData,
|
|
&cmapSize, &ctx, &exists);
|
|
|
|
if (SUCCEEDED(hr) && exists) {
|
|
bool cmapLoaded = false;
|
|
RefPtr<gfxCharacterMap> charmap = new gfxCharacterMap();
|
|
uint32_t offset;
|
|
MOZ_SEH_TRY {
|
|
if (cmapData && cmapSize > 0 &&
|
|
NS_SUCCEEDED(gfxFontUtils::ReadCMAP(cmapData, cmapSize, *charmap,
|
|
offset))) {
|
|
fontData.mCharacterMap = charmap;
|
|
fontData.mUVSOffset = offset;
|
|
cmapLoaded = true;
|
|
mLoadStats.cmaps++;
|
|
}
|
|
}
|
|
MOZ_SEH_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
|
|
gfxCriticalNote << "Exception occurred reading cmaps for "
|
|
<< PromiseFlatCString(aFamilyName).get();
|
|
}
|
|
dwFontFace->ReleaseFontTable(ctx);
|
|
haveData = haveData || cmapLoaded;
|
|
}
|
|
}
|
|
|
|
// if have data, load
|
|
if (haveData) {
|
|
mFontFaceData.InsertOrUpdate(fullID, fontData);
|
|
}
|
|
}
|
|
}
|
|
|
|
already_AddRefed<FontInfoData> gfxDWriteFontList::CreateFontInfoData() {
|
|
bool loadCmaps = !UsesSystemFallback() ||
|
|
gfxPlatform::GetPlatform()->UseCmapsDuringSystemFallback();
|
|
|
|
RefPtr<DirectWriteFontInfo> fi = new DirectWriteFontInfo(
|
|
false, NeedFullnamePostscriptNames(), loadCmaps, mSystemFonts
|
|
#ifdef MOZ_BUNDLED_FONTS
|
|
,
|
|
mBundledFonts
|
|
#endif
|
|
);
|
|
|
|
return fi.forget();
|
|
}
|
|
|
|
gfxFontFamily* gfxDWriteFontList::CreateFontFamily(
|
|
const nsACString& aName, FontVisibility aVisibility) const {
|
|
return new gfxDWriteFontFamily(aName, aVisibility, nullptr);
|
|
}
|
|
|
|
#ifdef MOZ_BUNDLED_FONTS
|
|
|
|
# define IMPL_QI_FOR_DWRITE(_interface) \
|
|
public: \
|
|
IFACEMETHOD(QueryInterface)(IID const& riid, void** ppvObject) { \
|
|
if (__uuidof(_interface) == riid) { \
|
|
*ppvObject = this; \
|
|
} else if (__uuidof(IUnknown) == riid) { \
|
|
*ppvObject = this; \
|
|
} else { \
|
|
*ppvObject = nullptr; \
|
|
return E_NOINTERFACE; \
|
|
} \
|
|
this->AddRef(); \
|
|
return S_OK; \
|
|
}
|
|
|
|
class BundledFontFileEnumerator : public IDWriteFontFileEnumerator {
|
|
IMPL_QI_FOR_DWRITE(IDWriteFontFileEnumerator)
|
|
|
|
NS_INLINE_DECL_REFCOUNTING(BundledFontFileEnumerator)
|
|
|
|
public:
|
|
BundledFontFileEnumerator(IDWriteFactory* aFactory, nsIFile* aFontDir);
|
|
|
|
IFACEMETHODIMP MoveNext(BOOL* hasCurrentFile);
|
|
|
|
IFACEMETHODIMP GetCurrentFontFile(IDWriteFontFile** fontFile);
|
|
|
|
private:
|
|
BundledFontFileEnumerator() = delete;
|
|
BundledFontFileEnumerator(const BundledFontFileEnumerator&) = delete;
|
|
BundledFontFileEnumerator& operator=(const BundledFontFileEnumerator&) =
|
|
delete;
|
|
virtual ~BundledFontFileEnumerator() = default;
|
|
|
|
RefPtr<IDWriteFactory> mFactory;
|
|
|
|
nsCOMPtr<nsIFile> mFontDir;
|
|
nsCOMPtr<nsIDirectoryEnumerator> mEntries;
|
|
nsCOMPtr<nsISupports> mCurrent;
|
|
};
|
|
|
|
BundledFontFileEnumerator::BundledFontFileEnumerator(IDWriteFactory* aFactory,
|
|
nsIFile* aFontDir)
|
|
: mFactory(aFactory), mFontDir(aFontDir) {
|
|
mFontDir->GetDirectoryEntries(getter_AddRefs(mEntries));
|
|
}
|
|
|
|
IFACEMETHODIMP
|
|
BundledFontFileEnumerator::MoveNext(BOOL* aHasCurrentFile) {
|
|
bool hasMore = false;
|
|
if (mEntries) {
|
|
if (NS_SUCCEEDED(mEntries->HasMoreElements(&hasMore)) && hasMore) {
|
|
if (NS_SUCCEEDED(mEntries->GetNext(getter_AddRefs(mCurrent)))) {
|
|
hasMore = true;
|
|
}
|
|
}
|
|
}
|
|
*aHasCurrentFile = hasMore;
|
|
return S_OK;
|
|
}
|
|
|
|
IFACEMETHODIMP
|
|
BundledFontFileEnumerator::GetCurrentFontFile(IDWriteFontFile** aFontFile) {
|
|
nsCOMPtr<nsIFile> file = do_QueryInterface(mCurrent);
|
|
if (!file) {
|
|
return E_FAIL;
|
|
}
|
|
nsString path;
|
|
if (NS_FAILED(file->GetPath(path))) {
|
|
return E_FAIL;
|
|
}
|
|
return mFactory->CreateFontFileReference((const WCHAR*)path.get(), nullptr,
|
|
aFontFile);
|
|
}
|
|
|
|
class BundledFontLoader : public IDWriteFontCollectionLoader {
|
|
IMPL_QI_FOR_DWRITE(IDWriteFontCollectionLoader)
|
|
|
|
NS_INLINE_DECL_REFCOUNTING(BundledFontLoader)
|
|
|
|
public:
|
|
BundledFontLoader() {}
|
|
|
|
IFACEMETHODIMP CreateEnumeratorFromKey(
|
|
IDWriteFactory* aFactory, const void* aCollectionKey,
|
|
UINT32 aCollectionKeySize,
|
|
IDWriteFontFileEnumerator** aFontFileEnumerator);
|
|
|
|
private:
|
|
BundledFontLoader(const BundledFontLoader&) = delete;
|
|
BundledFontLoader& operator=(const BundledFontLoader&) = delete;
|
|
virtual ~BundledFontLoader() = default;
|
|
};
|
|
|
|
IFACEMETHODIMP
|
|
BundledFontLoader::CreateEnumeratorFromKey(
|
|
IDWriteFactory* aFactory, const void* aCollectionKey,
|
|
UINT32 aCollectionKeySize,
|
|
IDWriteFontFileEnumerator** aFontFileEnumerator) {
|
|
nsIFile* fontDir = *(nsIFile**)aCollectionKey;
|
|
*aFontFileEnumerator = new BundledFontFileEnumerator(aFactory, fontDir);
|
|
NS_ADDREF(*aFontFileEnumerator);
|
|
return S_OK;
|
|
}
|
|
|
|
already_AddRefed<IDWriteFontCollection>
|
|
gfxDWriteFontList::CreateBundledFontsCollection(IDWriteFactory* aFactory) {
|
|
nsCOMPtr<nsIFile> localDir;
|
|
nsresult rv = NS_GetSpecialDirectory(NS_GRE_DIR, getter_AddRefs(localDir));
|
|
if (NS_FAILED(rv)) {
|
|
return nullptr;
|
|
}
|
|
if (NS_FAILED(localDir->Append(u"fonts"_ns))) {
|
|
return nullptr;
|
|
}
|
|
bool isDir;
|
|
if (NS_FAILED(localDir->IsDirectory(&isDir)) || !isDir) {
|
|
return nullptr;
|
|
}
|
|
|
|
RefPtr<BundledFontLoader> loader = new BundledFontLoader();
|
|
if (FAILED(aFactory->RegisterFontCollectionLoader(loader))) {
|
|
return nullptr;
|
|
}
|
|
|
|
const void* key = localDir.get();
|
|
RefPtr<IDWriteFontCollection> collection;
|
|
HRESULT hr = aFactory->CreateCustomFontCollection(loader, &key, sizeof(key),
|
|
getter_AddRefs(collection));
|
|
|
|
aFactory->UnregisterFontCollectionLoader(loader);
|
|
|
|
if (FAILED(hr)) {
|
|
return nullptr;
|
|
} else {
|
|
return collection.forget();
|
|
}
|
|
}
|
|
|
|
#endif
|