Qt
Internal/Contributor docs for the Qt SDK. Note: These are NOT official API docs; those are found at https://doc.qt.io/
Loading...
Searching...
No Matches
qwindowsdirectwritefontdatabase.cpp
Go to the documentation of this file.
1// Copyright (C) 2020 The Qt Company Ltd.
2// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3
4#include "qwindowsdirectwritefontdatabase_p.h"
5#include "qwindowsfontenginedirectwrite_p.h"
6#include "qwindowsfontdatabase_p.h"
7
8#include <QtCore/qendian.h>
9#include <QtCore/qfile.h>
10#include <QtCore/qstringbuilder.h>
11#include <QtCore/qvarlengtharray.h>
12
13#include <dwrite_3.h>
14#include <d2d1.h>
15
16QT_BEGIN_NAMESPACE
17
18// Defined in gui/text/qfontdatabase.cpp
19Q_GUI_EXPORT QFontDatabase::WritingSystem qt_writing_system_for_script(int script);
20
21template<typename T>
22struct DirectWriteScope {
23 DirectWriteScope(T *res = nullptr) : m_res(res) {}
24 ~DirectWriteScope() {
25 if (m_res != nullptr)
26 m_res->Release();
27 }
28
29 T **operator&()
30 {
31 return &m_res;
32 }
33
34 T *operator->()
35 {
36 return m_res;
37 }
38
39 T *operator*() {
40 return m_res;
41 }
42
43private:
44 T *m_res;
45};
46
47QWindowsDirectWriteFontDatabase::QWindowsDirectWriteFontDatabase()
48{
49 qCDebug(lcQpaFonts) << "Creating DirectWrite database";
50}
51
52QWindowsDirectWriteFontDatabase::~QWindowsDirectWriteFontDatabase()
53{
54 for (auto it = m_populatedFonts.begin(); it != m_populatedFonts.end(); ++it)
55 it.value()->Release();
56}
57
58QString QWindowsDirectWriteFontDatabase::localeString(IDWriteLocalizedStrings *names,
59 wchar_t localeName[])
60{
61 uint index;
62 BOOL exists;
63 if (SUCCEEDED(names->FindLocaleName(localeName, &index, &exists)) && exists) {
64 uint length;
65 if (SUCCEEDED(names->GetStringLength(index, &length)) && length > 0) {
66 QVarLengthArray<wchar_t> buffer(int(length) + 1);
67 if (SUCCEEDED(names->GetString(index, buffer.data(), length + 1)))
68 return QString::fromWCharArray(buffer.data());
69 }
70 }
71
72 return QString();
73}
74
75QFont::Stretch QWindowsDirectWriteFontDatabase::fromDirectWriteStretch(DWRITE_FONT_STRETCH stretch)
76{
77 switch (stretch) {
78 case DWRITE_FONT_STRETCH_ULTRA_CONDENSED: return QFont::UltraCondensed;
79 case DWRITE_FONT_STRETCH_EXTRA_CONDENSED: return QFont::ExtraCondensed;
80 case DWRITE_FONT_STRETCH_CONDENSED: return QFont::Condensed;
81 case DWRITE_FONT_STRETCH_SEMI_CONDENSED: return QFont::SemiCondensed;
82 case DWRITE_FONT_STRETCH_NORMAL: return QFont::Unstretched;
83 case DWRITE_FONT_STRETCH_SEMI_EXPANDED: return QFont::SemiExpanded;
84 case DWRITE_FONT_STRETCH_EXPANDED: return QFont::Expanded;
85 case DWRITE_FONT_STRETCH_EXTRA_EXPANDED: return QFont::ExtraExpanded;
86 case DWRITE_FONT_STRETCH_ULTRA_EXPANDED: return QFont::UltraExpanded;
87 default: return QFont::AnyStretch;
88 }
89}
90
91QFont::Weight QWindowsDirectWriteFontDatabase::fromDirectWriteWeight(DWRITE_FONT_WEIGHT weight)
92{
93 return static_cast<QFont::Weight>(weight);
94}
95
96QFont::Style QWindowsDirectWriteFontDatabase::fromDirectWriteStyle(DWRITE_FONT_STYLE style)
97{
98 switch (style) {
99 case DWRITE_FONT_STYLE_NORMAL: return QFont::StyleNormal;
100 case DWRITE_FONT_STYLE_OBLIQUE: return QFont::StyleOblique;
101 case DWRITE_FONT_STYLE_ITALIC: return QFont::StyleItalic;
102 default: return QFont::StyleNormal;
103 }
104}
105
106void QWindowsDirectWriteFontDatabase::populateFamily(const QString &familyName)
107{
108 auto it = m_populatedFonts.find(familyName);
109 if (it == m_populatedFonts.end() && m_populatedBitmapFonts.contains(familyName)) {
110 qCDebug(lcQpaFonts) << "Populating bitmap font" << familyName;
111 QWindowsFontDatabase::populateFamily(familyName);
112 return;
113 }
114
115 IDWriteFontFamily *fontFamily = it != m_populatedFonts.end() ? it.value() : nullptr;
116 if (fontFamily == nullptr) {
117 qCWarning(lcQpaFonts) << "Cannot find" << familyName << "in list of fonts";
118 return;
119 }
120
121 qCDebug(lcQpaFonts) << "Populate family:" << familyName;
122
123 wchar_t defaultLocale[LOCALE_NAME_MAX_LENGTH];
124 bool hasDefaultLocale = GetUserDefaultLocaleName(defaultLocale, LOCALE_NAME_MAX_LENGTH) != 0;
125 wchar_t englishLocale[] = L"en-us";
126
127 static const int SMOOTH_SCALABLE = 0xffff;
128 const QString foundryName; // No such concept.
129 const bool scalable = true;
130 const bool antialias = false;
131 const int size = SMOOTH_SCALABLE;
132
133 DirectWriteScope<IDWriteFontList> matchingFonts;
134 if (SUCCEEDED(fontFamily->GetMatchingFonts(DWRITE_FONT_WEIGHT_REGULAR,
135 DWRITE_FONT_STRETCH_NORMAL,
136 DWRITE_FONT_STYLE_NORMAL,
137 &matchingFonts))) {
138 for (uint j = 0; j < matchingFonts->GetFontCount(); ++j) {
139 DirectWriteScope<IDWriteFont> font;
140 if (SUCCEEDED(matchingFonts->GetFont(j, &font))) {
141 DirectWriteScope<IDWriteFont2> font2;
142 if (!SUCCEEDED(font->QueryInterface(__uuidof(IDWriteFont2),
143 reinterpret_cast<void **>(&font2)))) {
144 qCWarning(lcQpaFonts) << "COM object does not support IDWriteFont1";
145 continue;
146 }
147
148 QString defaultLocaleFamilyName;
149 QString englishLocaleFamilyName;
150 QString defaultLocaleGdiCompatibleFamilyName;
151 QString englishLocaleGdiCompatibleFamilyName;
152
153 DirectWriteScope<IDWriteFontFamily> fontFamily2;
154 if (SUCCEEDED(font2->GetFontFamily(&fontFamily2))) {
155 DirectWriteScope<IDWriteLocalizedStrings> names;
156 if (SUCCEEDED(fontFamily2->GetFamilyNames(&names))) {
157 defaultLocaleFamilyName = hasDefaultLocale ? localeString(*names, defaultLocale) : QString();
158 englishLocaleFamilyName = localeString(*names, englishLocale);
159 }
160
161 BOOL ok;
162 if (SUCCEEDED(font->GetInformationalStrings(DWRITE_INFORMATIONAL_STRING_WIN32_FAMILY_NAMES, &names, &ok)) && ok) {
163 defaultLocaleGdiCompatibleFamilyName = hasDefaultLocale ? localeString(*names, defaultLocale) : QString();
164 englishLocaleGdiCompatibleFamilyName = localeString(*names, englishLocale);
165 }
166 }
167
168 if (defaultLocaleFamilyName.isEmpty()
169 && englishLocaleFamilyName.isEmpty()
170 && englishLocaleGdiCompatibleFamilyName.isEmpty()
171 && defaultLocaleGdiCompatibleFamilyName.isEmpty()) {
172 englishLocaleFamilyName = familyName;
173 }
174
175 QFont::Stretch stretch = fromDirectWriteStretch(font2->GetStretch());
176 QFont::Style style = fromDirectWriteStyle(font2->GetStyle());
177 QFont::Weight weight = fromDirectWriteWeight(font2->GetWeight());
178 bool fixed = font2->IsMonospacedFont();
179 bool color = font2->IsColorFont();
180
181 DirectWriteScope<IDWriteFontFace> face;
182 if (SUCCEEDED(font->CreateFontFace(&face))) {
183 QSupportedWritingSystems writingSystems = supportedWritingSystems(*face);
184
185 auto registerFontName = [&](const QString &rFamilyName,
186 const QString &rStyleName) {
187 qCDebug(lcQpaFonts) << "Family" << familyName << "has variant"
188 << rFamilyName << ", "
189 << rStyleName << ", "
190 << stretch << ", "
191 << style << ", "
192 << weight << ", "
193 << fixed << ", "
194 << writingSystems;
195 QPlatformFontDatabase::registerFont(rFamilyName,
196 rStyleName,
197 QString(),
198 weight,
199 style,
200 stretch,
201 antialias,
202 scalable,
203 size,
204 fixed,
205 color,
206 writingSystems,
207 new FontHandle(*face, rFamilyName));
208 };
209
210 // Register the standard face names
211 DirectWriteScope<IDWriteLocalizedStrings> names;
212 if (SUCCEEDED(font2->GetFaceNames(&names))) {
213 QString defaultLocaleStyleName = hasDefaultLocale ? localeString(*names, defaultLocale) : QString();
214 QString englishLocaleStyleName = localeString(*names, englishLocale);
215 qCDebug(lcQpaFonts) << ">>> Storing English locale names";
216 registerFontName(englishLocaleFamilyName, englishLocaleStyleName);
217
218 // If the font has another name in the current default locale, register
219 // this as well
220 if (!defaultLocaleFamilyName.isEmpty()
221 && defaultLocaleFamilyName != englishLocaleFamilyName) {
222 qCDebug(lcQpaFonts) << ">>> Storing default locale names";
223 registerFontName(defaultLocaleFamilyName, defaultLocaleStyleName);
224 }
225 }
226
227 // Register GDI compatible names if they differ from the main face names
228 if (!defaultLocaleGdiCompatibleFamilyName.isEmpty()
229 || !englishLocaleGdiCompatibleFamilyName.isEmpty()) {
230 QString defaultLocaleGdiCompatibleStyleName;
231 QString englishLocaleGdiCompatibleStyleName;
232
233 DirectWriteScope<IDWriteLocalizedStrings> names;
234 BOOL ok;
235 if (SUCCEEDED(font->GetInformationalStrings(DWRITE_INFORMATIONAL_STRING_WIN32_SUBFAMILY_NAMES, &names, &ok)) && ok) {
236 defaultLocaleGdiCompatibleStyleName = hasDefaultLocale ? localeString(*names, defaultLocale) : QString();
237 englishLocaleGdiCompatibleStyleName = localeString(*names, englishLocale);
238
239 if (!englishLocaleGdiCompatibleFamilyName.isEmpty()
240 && englishLocaleGdiCompatibleFamilyName != englishLocaleFamilyName) {
241 qCDebug(lcQpaFonts) << ">>> Storing English GDI compatible names";
242 registerFontName(englishLocaleGdiCompatibleFamilyName,
243 englishLocaleGdiCompatibleStyleName);
244 }
245
246 if (!defaultLocaleGdiCompatibleFamilyName.isEmpty()
247 && defaultLocaleGdiCompatibleFamilyName != englishLocaleGdiCompatibleFamilyName
248 && defaultLocaleGdiCompatibleFamilyName != defaultLocaleFamilyName) {
249 qCDebug(lcQpaFonts) << ">>> Storing Default locale GDI compatible names";
250 registerFontName(defaultLocaleGdiCompatibleFamilyName,
251 defaultLocaleGdiCompatibleStyleName);
252 }
253 }
254 }
255 }
256 }
257 }
258 }
259}
260
261QSupportedWritingSystems QWindowsDirectWriteFontDatabase::supportedWritingSystems(IDWriteFontFace *face) const
262{
263 QSupportedWritingSystems writingSystems;
264 writingSystems.setSupported(QFontDatabase::Any);
265
266 DirectWriteScope<IDWriteFontFace1> face1;
267 if (SUCCEEDED(face->QueryInterface(__uuidof(IDWriteFontFace1),
268 reinterpret_cast<void **>(&face1)))) {
269 const void *tableData = nullptr;
270 UINT32 tableSize;
271 void *tableContext = nullptr;
272 BOOL exists;
273 HRESULT hr = face->TryGetFontTable(qFromBigEndian(QFont::Tag("OS/2").value()),
274 &tableData,
275 &tableSize,
276 &tableContext,
277 &exists);
278 if (SUCCEEDED(hr) && exists) {
279 writingSystems = QPlatformFontDatabase::writingSystemsFromOS2Table(reinterpret_cast<const char *>(tableData), tableSize);
280 } else { // Fall back to checking first character of each Unicode range in font (may include too many writing systems)
281 quint32 rangeCount;
282 hr = face1->GetUnicodeRanges(0, nullptr, &rangeCount);
283
284 if (rangeCount > 0) {
285 QVarLengthArray<DWRITE_UNICODE_RANGE, QChar::ScriptCount> ranges(rangeCount);
286
287 hr = face1->GetUnicodeRanges(rangeCount, ranges.data(), &rangeCount);
288 if (SUCCEEDED(hr)) {
289 for (uint i = 0; i < rangeCount; ++i) {
290 QChar::Script script = QChar::script(ranges.at(i).first);
291
292 QFontDatabase::WritingSystem writingSystem = qt_writing_system_for_script(script);
293
294 if (writingSystem > QFontDatabase::Any && writingSystem < QFontDatabase::WritingSystemsCount)
295 writingSystems.setSupported(writingSystem);
296 }
297 } else {
298 const QString errorString = qt_error_string(int(hr));
299 qCWarning(lcQpaFonts) << "Failed to get unicode ranges for font:" << errorString;
300 }
301 }
302 }
303 }
304
305 return writingSystems;
306}
307
308bool QWindowsDirectWriteFontDatabase::populateFamilyAliases(const QString &missingFamily)
309{
310 // Skip over implementation in QWindowsFontDatabase
311 return QWindowsFontDatabaseBase::populateFamilyAliases(missingFamily);
312}
313
314QFontEngine *QWindowsDirectWriteFontDatabase::fontEngine(const QByteArray &fontData,
315 qreal pixelSize,
316 QFont::HintingPreference hintingPreference)
317{
318 // Skip over implementation in QWindowsFontDatabase
319 return QWindowsFontDatabaseBase::fontEngine(fontData, pixelSize, hintingPreference);
320}
321
322QFontEngine *QWindowsDirectWriteFontDatabase::fontEngine(const QFontDef &fontDef, void *handle)
323{
324 const FontHandle *fontHandle = static_cast<const FontHandle *>(handle);
325 IDWriteFontFace *face = fontHandle->fontFace;
326 if (face == nullptr) {
327 qCDebug(lcQpaFonts) << "Falling back to GDI";
328 return QWindowsFontDatabase::fontEngine(fontDef, handle);
329 }
330
331 DWRITE_FONT_SIMULATIONS simulations = DWRITE_FONT_SIMULATIONS_NONE;
332 if (fontDef.weight >= QFont::DemiBold || fontDef.style != QFont::StyleNormal) {
333 DirectWriteScope<IDWriteFontFace3> face3;
334 if (SUCCEEDED(face->QueryInterface(__uuidof(IDWriteFontFace3),
335 reinterpret_cast<void **>(&face3)))) {
336 if (fontDef.weight >= QFont::DemiBold && face3->GetWeight() < DWRITE_FONT_WEIGHT_DEMI_BOLD)
337 simulations |= DWRITE_FONT_SIMULATIONS_BOLD;
338
339 if (fontDef.style != QFont::StyleNormal && face3->GetStyle() == DWRITE_FONT_STYLE_NORMAL)
340 simulations |= DWRITE_FONT_SIMULATIONS_OBLIQUE;
341 }
342 }
343
344 DirectWriteScope<IDWriteFontFace5> newFace;
345 if (!fontDef.variableAxisValues.isEmpty() || simulations != DWRITE_FONT_SIMULATIONS_NONE) {
346 DirectWriteScope<IDWriteFontFace5> face5;
347 if (SUCCEEDED(face->QueryInterface(__uuidof(IDWriteFontFace5),
348 reinterpret_cast<void **>(&face5)))) {
349 DirectWriteScope<IDWriteFontResource> font;
350 if (SUCCEEDED(face5->GetFontResource(&font))) {
351 UINT32 fontAxisCount = font->GetFontAxisCount();
352 QVarLengthArray<DWRITE_FONT_AXIS_VALUE, 8> fontAxisValues(fontAxisCount);
353
354 if (!fontDef.variableAxisValues.isEmpty()) {
355 if (SUCCEEDED(face5->GetFontAxisValues(fontAxisValues.data(), fontAxisCount))) {
356 for (UINT32 i = 0; i < fontAxisCount; ++i) {
357 if (auto maybeTag = QFont::Tag::fromValue(qToBigEndian<UINT32>(fontAxisValues[i].axisTag))) {
358 if (fontDef.variableAxisValues.contains(*maybeTag))
359 fontAxisValues[i].value = fontDef.variableAxisValues.value(*maybeTag);
360 }
361 }
362 }
363 }
364
365 if (SUCCEEDED(font->CreateFontFace(simulations,
366 !fontDef.variableAxisValues.isEmpty() ? fontAxisValues.data() : nullptr,
367 !fontDef.variableAxisValues.isEmpty() ? fontAxisCount : 0,
368 &newFace))) {
369 face = *newFace;
370 } else {
371 qCWarning(lcQpaFonts) << "DirectWrite: Can't create font face for variable axis values";
372 }
373 }
374 }
375 }
376
377 QWindowsFontEngineDirectWrite *fontEngine = new QWindowsFontEngineDirectWrite(face, fontDef.pixelSize, data());
378 fontEngine->initFontInfo(fontDef, defaultVerticalDPI());
379
380 return fontEngine;
381}
382
383QStringList QWindowsDirectWriteFontDatabase::fallbacksForFamily(const QString &family,
384 QFont::Style style,
385 QFont::StyleHint styleHint,
386 QFontDatabasePrivate::ExtendedScript script) const
387{
388 QStringList result;
389 result.append(QWindowsFontDatabaseBase::familiesForScript(script));
390 result.append(familyForStyleHint(styleHint));
391 result.append(extraTryFontsForFamily(family));
392 result.append(QPlatformFontDatabase::fallbacksForFamily(family, style, styleHint, script));
393
394 qCDebug(lcQpaFonts) << __FUNCTION__ << family << style << styleHint
395 << script << result;
396 return result;
397}
398
399template<typename T>
400void QWindowsDirectWriteFontDatabase::collectAdditionalNames(T *font,
401 wchar_t *defaultLocale,
402 wchar_t *englishLocale,
403 std::function<void(const std::pair<QString, QString> &)> registerFamily)
404{
405 BOOL ok;
406 QString defaultLocaleGdiCompatibleFamilyName;
407 QString englishLocaleGdiCompatibleFamilyName;
408
409 const bool hasDefaultLocale = defaultLocale != nullptr;
410 Q_ASSERT(englishLocale != nullptr);
411
412 IDWriteLocalizedStrings *names = nullptr;
413 if (SUCCEEDED(font->GetInformationalStrings(DWRITE_INFORMATIONAL_STRING_WIN32_FAMILY_NAMES, &names, &ok)) && ok) {
414 defaultLocaleGdiCompatibleFamilyName = hasDefaultLocale ? localeString(names, defaultLocale) : QString();
415 englishLocaleGdiCompatibleFamilyName = localeString(names, englishLocale);
416
417 names->Release();
418 }
419
420 QString defaultLocaleGdiCompatibleStyleName;
421 QString englishLocaleGdiCompatibleStyleName;
422 if (SUCCEEDED(font->GetInformationalStrings(DWRITE_INFORMATIONAL_STRING_WIN32_SUBFAMILY_NAMES, &names, &ok)) && ok) {
423 defaultLocaleGdiCompatibleStyleName = hasDefaultLocale ? localeString(names, defaultLocale) : QString();
424 englishLocaleGdiCompatibleStyleName = localeString(names, englishLocale);
425
426 names->Release();
427 }
428
429 QString defaultLocaleTypographicFamilyName;
430 QString englishLocaleTypographicFamilyName;
431 if (SUCCEEDED(font->GetInformationalStrings(DWRITE_INFORMATIONAL_STRING_TYPOGRAPHIC_FAMILY_NAMES, &names, &ok)) && ok) {
432 defaultLocaleTypographicFamilyName = hasDefaultLocale ? localeString(names, defaultLocale) : QString();
433 englishLocaleTypographicFamilyName = localeString(names, englishLocale);
434
435 names->Release();
436 }
437
438 QString defaultLocaleTypographicStyleName;
439 QString englishLocaleTypographicStyleName;
440 if (SUCCEEDED(font->GetInformationalStrings(DWRITE_INFORMATIONAL_STRING_TYPOGRAPHIC_SUBFAMILY_NAMES, &names, &ok)) && ok) {
441 defaultLocaleTypographicStyleName = hasDefaultLocale ? localeString(names, defaultLocale) : QString();
442 englishLocaleTypographicStyleName = localeString(names, englishLocale);
443
444 names->Release();
445 }
446
447 {
448 const auto key = std::make_pair(englishLocaleGdiCompatibleFamilyName, englishLocaleGdiCompatibleStyleName);
449 if (!englishLocaleGdiCompatibleFamilyName.isEmpty())
450 registerFamily(key);
451 }
452
453 {
454 const auto key = std::make_pair(defaultLocaleGdiCompatibleFamilyName, defaultLocaleGdiCompatibleStyleName);
455 if (!defaultLocaleGdiCompatibleFamilyName.isEmpty())
456 registerFamily(key);
457 }
458
459 {
460 const auto key = std::make_pair(englishLocaleTypographicFamilyName, englishLocaleTypographicStyleName);
461 if (!englishLocaleTypographicFamilyName.isEmpty())
462 registerFamily(key);
463 }
464
465 {
466 const auto key = std::make_pair(defaultLocaleTypographicFamilyName, defaultLocaleTypographicStyleName);
467 if (!defaultLocaleTypographicFamilyName.isEmpty())
468 registerFamily(key);
469 }
470}
471
472QStringList QWindowsDirectWriteFontDatabase::addApplicationFont(const QByteArray &fontData, const QString &fileName, QFontDatabasePrivate::ApplicationFont *applicationFont)
473{
474 qCDebug(lcQpaFonts) << "Adding application font" << fileName;
475
476 QByteArray loadedData = fontData;
477 if (loadedData.isEmpty()) {
478 QFile file(fileName);
479 if (!file.open(QIODevice::ReadOnly)) {
480 qCWarning(lcQpaFonts) << "Cannot open" << fileName << "for reading.";
481 return QStringList();
482 }
483 loadedData = file.readAll();
484 }
485
486 QList<IDWriteFontFace *> faces = createDirectWriteFaces(loadedData, fileName);
487 if (faces.isEmpty()) {
488 qCWarning(lcQpaFonts) << "Failed to create DirectWrite face from font data. Font may be unsupported.";
489 return QStringList();
490 }
491
492 QSet<std::pair<QString, QString> > registeredFonts;
493 QSet<QString> ret;
494 for (int i = 0; i < faces.size(); ++i) {
495 IDWriteFontFace *face = faces.at(i);
496 wchar_t defaultLocale[LOCALE_NAME_MAX_LENGTH];
497 bool hasDefaultLocale = GetUserDefaultLocaleName(defaultLocale, LOCALE_NAME_MAX_LENGTH) != 0;
498 wchar_t englishLocale[] = L"en-us";
499
500 static const int SMOOTH_SCALABLE = 0xffff;
501 const bool scalable = true;
502 const bool antialias = false;
503 const int size = SMOOTH_SCALABLE;
504
505 QSupportedWritingSystems writingSystems = supportedWritingSystems(face);
506 DirectWriteScope<IDWriteFontFace3> face3;
507 if (SUCCEEDED(face->QueryInterface(__uuidof(IDWriteFontFace3),
508 reinterpret_cast<void **>(&face3)))) {
509
510 QFont::Stretch stretch = fromDirectWriteStretch(face3->GetStretch());
511 QFont::Style style = fromDirectWriteStyle(face3->GetStyle());
512 QFont::Weight weight = fromDirectWriteWeight(face3->GetWeight());
513 bool fixed = face3->IsMonospacedFont();
514 bool color = face3->IsColorFont();
515
516 auto registerFamilyAndStyle = [&](const std::pair<QString, QString> &familyAndStyle)
517 {
518 if (registeredFonts.contains(familyAndStyle))
519 return;
520 registeredFonts.insert(familyAndStyle);
521 ret.insert(familyAndStyle.first);
522
523 qCDebug(lcQpaFonts) << "\tRegistering alternative:" << familyAndStyle.first
524 << ":" << familyAndStyle.second;
525 if (applicationFont != nullptr) {
526 QFontDatabasePrivate::ApplicationFont::Properties properties;
527 properties.style = style;
528 properties.weight = weight;
529 properties.familyName = familyAndStyle.first;
530 properties.styleName = familyAndStyle.second;
531 applicationFont->properties.append(properties);
532 }
533
534 QPlatformFontDatabase::registerFont(familyAndStyle.first,
535 familyAndStyle.second,
536 QString(),
537 weight,
538 style,
539 stretch,
540 antialias,
541 scalable,
542 size,
543 fixed,
544 color,
545 writingSystems,
546 new FontHandle(face, familyAndStyle.first));
547 };
548
549 QString defaultLocaleFamilyName;
550 QString englishLocaleFamilyName;
551
552 IDWriteLocalizedStrings *names = nullptr;
553 if (SUCCEEDED(face3->GetFamilyNames(&names))) {
554 defaultLocaleFamilyName = hasDefaultLocale ? localeString(names, defaultLocale) : QString();
555 englishLocaleFamilyName = localeString(names, englishLocale);
556
557 names->Release();
558 }
559
560 QString defaultLocaleStyleName;
561 QString englishLocaleStyleName;
562 if (SUCCEEDED(face3->GetFaceNames(&names))) {
563 defaultLocaleStyleName = hasDefaultLocale ? localeString(names, defaultLocale) : QString();
564 englishLocaleStyleName = localeString(names, englishLocale);
565
566 names->Release();
567 }
568
569 qCDebug(lcQpaFonts) << "\tFont names:" << englishLocaleFamilyName << ", " << defaultLocaleFamilyName
570 << ", style names:" << englishLocaleStyleName << ", " << defaultLocaleStyleName
571 << ", stretch:" << stretch
572 << ", style:" << style
573 << ", weight:" << weight
574 << ", fixed:" << fixed;
575
576 {
577 const auto key = std::make_pair(englishLocaleFamilyName, englishLocaleStyleName);
578 if (!englishLocaleFamilyName.isEmpty())
579 registerFamilyAndStyle(key);
580 }
581
582 {
583 const auto key = std::make_pair(defaultLocaleFamilyName, defaultLocaleStyleName);
584 if (!defaultLocaleFamilyName.isEmpty())
585 registerFamilyAndStyle(key);
586 }
587
588 collectAdditionalNames(*face3,
589 hasDefaultLocale ? defaultLocale : nullptr,
590 englishLocale,
591 registerFamilyAndStyle);
592
593 } else {
594 qCWarning(lcQpaFonts) << "Unable to query IDWriteFontFace3 interface from font face.";
595 }
596
597 face->Release();
598 }
599
600 return ret.values();
601}
602
603bool QWindowsDirectWriteFontDatabase::isPrivateFontFamily(const QString &family) const
604{
605 Q_UNUSED(family);
606 return false;
607}
608
609static int QT_WIN_CALLBACK populateBitmapFonts(const LOGFONT *logFont,
610 const TEXTMETRIC *textmetric,
611 DWORD type,
612 LPARAM lparam)
613{
614 Q_UNUSED(textmetric);
615
616 // the "@family" fonts are just the same as "family". Ignore them.
617 const ENUMLOGFONTEX *f = reinterpret_cast<const ENUMLOGFONTEX *>(logFont);
618 const wchar_t *faceNameW = f->elfLogFont.lfFaceName;
619 if (faceNameW[0] && faceNameW[0] != L'@' && wcsncmp(faceNameW, L"WST_", 4)) {
620 const QString faceName = QString::fromWCharArray(faceNameW);
621 if (type & RASTER_FONTTYPE || type == 0) {
622 QWindowsDirectWriteFontDatabase *db = reinterpret_cast<QWindowsDirectWriteFontDatabase *>(lparam);
623 if (!db->hasPopulatedFont(faceName)) {
624 db->registerFontFamily(faceName);
625 db->registerBitmapFont(faceName);
626 }
627 }
628 }
629 return 1; // continue
630}
631
632void QWindowsDirectWriteFontDatabase::populateFontDatabase()
633{
634 wchar_t defaultLocale[LOCALE_NAME_MAX_LENGTH];
635 bool hasDefaultLocale = GetUserDefaultLocaleName(defaultLocale, LOCALE_NAME_MAX_LENGTH) != 0;
636 wchar_t englishLocale[] = L"en-us";
637
638 const QString defaultFontName = defaultFont().family();
639 const QString systemDefaultFontName = systemDefaultFont().family();
640
641 DirectWriteScope<IDWriteFontCollection2> fontCollection;
642 DirectWriteScope<IDWriteFactory6> factory6;
643 if (FAILED(data()->directWriteFactory->QueryInterface(__uuidof(IDWriteFactory6),
644 reinterpret_cast<void **>(&factory6)))) {
645 qCWarning(lcQpaFonts) << "Can't initialize IDWriteFactory6. Use GDI font engine instead.";
646 return;
647 }
648
649 if (SUCCEEDED(factory6->GetSystemFontCollection(false,
650 DWRITE_FONT_FAMILY_MODEL_TYPOGRAPHIC,
651 &fontCollection))) {
652 QSet<QString> registeredFamilies;
653 for (uint i = 0; i < fontCollection->GetFontFamilyCount(); ++i) {
654 DirectWriteScope<IDWriteFontFamily2> fontFamily;
655 if (SUCCEEDED(fontCollection->GetFontFamily(i, &fontFamily))) {
656 auto registerFamily = [&](const std::pair<QString, QString> &familyAndStyle) {
657 const QString registeredFamily = familyAndStyle.first;
658 if (registeredFamilies.contains(registeredFamily))
659 return;
660 registeredFamilies.insert(registeredFamily);
661
662 qCDebug(lcQpaFonts) << "Registering font family" << registeredFamily;
663 registerFontFamily(registeredFamily);
664 m_populatedFonts.insert(registeredFamily, *fontFamily);
665 fontFamily->AddRef();
666
667 if (registeredFamily == defaultFontName
668 && defaultFontName != systemDefaultFontName) {
669 qCDebug(lcQpaFonts) << "Adding default font" << systemDefaultFontName
670 << "as alternative to" << registeredFamily;
671
672 m_populatedFonts.insert(systemDefaultFontName, *fontFamily);
673 fontFamily->AddRef();
674 }
675 };
676
677 QString defaultLocaleName;
678 QString englishLocaleName;
679 DirectWriteScope<IDWriteLocalizedStrings> names;
680 if (SUCCEEDED(fontFamily->GetFamilyNames(&names))) {
681 if (hasDefaultLocale)
682 defaultLocaleName = localeString(*names, defaultLocale);
683 englishLocaleName = localeString(*names, englishLocale);
684 }
685
686 {
687 const auto key = std::make_pair(defaultLocaleName, QString{});
688 if (!defaultLocaleName.isEmpty())
689 registerFamily(key);
690 }
691
692 {
693 const auto key = std::make_pair(englishLocaleName, QString{});
694 if (!englishLocaleName.isEmpty())
695 registerFamily(key);
696 }
697
698 for (uint j = 0; j < fontFamily->GetFontCount(); ++j) {
699 DirectWriteScope<IDWriteFont3> font;
700 if (SUCCEEDED(fontFamily->GetFont(j, &font))) {
701 collectAdditionalNames(*font,
702 hasDefaultLocale ? defaultLocale : nullptr,
703 englishLocale,
704 registerFamily);
705 }
706 }
707 }
708 }
709 }
710
711 // Since bitmap fonts are not supported by DirectWrite, we need to populate these as well
712 {
713 HDC dummy = GetDC(0);
714 LOGFONT lf;
715 lf.lfCharSet = DEFAULT_CHARSET;
716 lf.lfFaceName[0] = 0;
717 lf.lfPitchAndFamily = 0;
718 EnumFontFamiliesEx(dummy, &lf, populateBitmapFonts, reinterpret_cast<intptr_t>(this), 0);
719 ReleaseDC(0, dummy);
720 }
721}
722
723bool QWindowsDirectWriteFontDatabase::supportsVariableApplicationFonts() const
724{
725 QSharedPointer<QWindowsFontEngineData> fontEngineData = data();
726 DirectWriteScope<IDWriteFactory5> factory5;
727 if (SUCCEEDED(fontEngineData->directWriteFactory->QueryInterface(__uuidof(IDWriteFactory5),
728 reinterpret_cast<void **>(&factory5)))) {
729 return true;
730 }
731
732 return false;
733}
734
735void QWindowsDirectWriteFontDatabase::invalidate()
736{
737 QWindowsFontDatabase::invalidate();
738
739 for (IDWriteFontFamily *value : m_populatedFonts)
740 value->Release();
741 m_populatedFonts.clear();
742 m_populatedFonts.squeeze();
743
744 m_populatedBitmapFonts.clear();
745 m_populatedBitmapFonts.squeeze();
746}
747
748QT_END_NAMESPACE
QT_BEGIN_NAMESPACE
Combined button and popup list for selecting options.
Definition qsequentialanimationgroup.cpp:47