1	/****************************************************************************
2	**
3	** Copyright (C) 2016 The Qt Company Ltd.
4	** Contact: https://www.qt.io/licensing/
5	**
6	** This file is part of the QtGui module of the Qt Toolkit.
7	**
8	** $QT_BEGIN_LICENSE:LGPL$
9	** Commercial License Usage
10	** Licensees holding valid commercial Qt licenses may use this file in
11	** accordance with the commercial license agreement provided with the
12	** Software or, alternatively, in accordance with the terms contained in
13	** a written agreement between you and The Qt Company. For licensing terms
14	** and conditions see https://www.qt.io/terms-conditions. For further
15	** information use the contact form at https://www.qt.io/contact-us.
16	**
17	** GNU Lesser General Public License Usage
18	** Alternatively, this file may be used under the terms of the GNU Lesser
19	** General Public License version 3 as published by the Free Software
20	** Foundation and appearing in the file LICENSE.LGPL3 included in the
21	** packaging of this file. Please review the following information to
22	** ensure the GNU Lesser General Public License version 3 requirements
23	** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
24	**
25	** GNU General Public License Usage
26	** Alternatively, this file may be used under the terms of the GNU
27	** General Public License version 2.0 or (at your option) the GNU General
28	** Public license version 3 or any later version approved by the KDE Free
29	** Qt Foundation. The licenses are as published by the Free Software
30	** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
31	** included in the packaging of this file. Please review the following
32	** information to ensure the GNU General Public License requirements will
33	** be met: https://www.gnu.org/licenses/gpl-2.0.html and
34	** https://www.gnu.org/licenses/gpl-3.0.html.
35	**
36	** $QT_END_LICENSE$
37	**
38	****************************************************************************/
39
40	#include "qfontdatabase.h"
41	#include "qloggingcategory.h"
42	#include "qalgorithms.h"
43	#include "qguiapplication.h"
44	#include "qvarlengtharray.h" // here or earlier - workaround for VC++6
45	#include "qthread.h"
46	#include "qmutex.h"
47	#include "qfile.h"
48	#include "qfileinfo.h"
49	#include "qfontengine_p.h"
50	#include <qpa/qplatformintegration.h>
51
52	#include <QtGui/private/qguiapplication_p.h>
53	#include <qpa/qplatformfontdatabase.h>
54	#include <qpa/qplatformtheme.h>
55
56	#include <QtCore/qcache.h>
57	#include <QtCore/qmath.h>
58
59	#include <stdlib.h>
60	#include <algorithm>
61
62	#include <qtgui_tracepoints_p.h>
63
64	QT_BEGIN_NAMESPACE
65
66	Q_LOGGING_CATEGORY(lcFontDb, "qt.text.font.db")
67	Q_LOGGING_CATEGORY(lcFontMatch, "qt.text.font.match")
68
69	#define SMOOTH_SCALABLE 0xffff
70
71	#if defined(QT_BUILD_INTERNAL)
72	bool qt_enable_test_font = false;
73
74	Q_AUTOTEST_EXPORT void qt_setQtEnableTestFont(bool value)
75	{
76	qt_enable_test_font = value;
77	}
78	#endif
79
80	static int getFontWeight(const QString &weightString)
81	{
82	QString s = weightString.toLower();
83
84	// Order here is important. We want to match the common cases first, but we
85	// must also take care to acknowledge the cost of our tests.
86	//
87	// As a result, we test in two orders; the order of commonness, and the
88	// order of "expense".
89	//
90	// A simple string test is the cheapest, so let's do that first.
91	// Test in decreasing order of commonness
92	if (s == QLatin1String("normal") || s == QLatin1String("regular"))
93	return QFont::Normal;
94	if (s == QLatin1String("bold"))
95	return QFont::Bold;
96	if (s == QLatin1String("semibold") || s == QLatin1String("semi bold")
97	|| s == QLatin1String("demibold") || s == QLatin1String("demi bold"))
98	return QFont::DemiBold;
99	if (s == QLatin1String("medium"))
100	return QFont::Medium;
101	if (s == QLatin1String("black"))
102	return QFont::Black;
103	if (s == QLatin1String("light"))
104	return QFont::Light;
105	if (s == QLatin1String("thin"))
106	return QFont::Thin;
107	const QStringRef s2 = s.midRef(position: 2);
108	if (s.startsWith(s: QLatin1String("ex")) || s.startsWith(s: QLatin1String("ul"))) {
109	if (s2 == QLatin1String("tralight") || s == QLatin1String("tra light"))
110	return QFont::ExtraLight;
111	if (s2 == QLatin1String("trabold") || s2 == QLatin1String("tra bold"))
112	return QFont::ExtraBold;
113	}
114
115	// Next up, let's see if contains() matches: slightly more expensive, but
116	// still fast enough.
117	if (s.contains(s: QLatin1String("bold"))) {
118	if (s.contains(s: QLatin1String("demi")))
119	return QFont::DemiBold;
120	return QFont::Bold;
121	}
122	if (s.contains(s: QLatin1String("thin")))
123	return QFont::Thin;
124	if (s.contains(s: QLatin1String("light")))
125	return QFont::Light;
126	if (s.contains(s: QLatin1String("black")))
127	return QFont::Black;
128
129	// Now, we perform string translations & comparisons with those.
130	// These are (very) slow compared to simple string ops, so we do these last.
131	// As using translated values for such things is not very common, this should
132	// not be too bad.
133	if (s.compare(s: QCoreApplication::translate(context: "QFontDatabase", key: "Normal", disambiguation: "The Normal or Regular font weight"), cs: Qt::CaseInsensitive) == 0)
134	return QFont::Normal;
135	const QString translatedBold = QCoreApplication::translate(context: "QFontDatabase", key: "Bold").toLower();
136	if (s == translatedBold)
137	return QFont::Bold;
138	if (s.compare(s: QCoreApplication::translate(context: "QFontDatabase", key: "Demi Bold"), cs: Qt::CaseInsensitive) == 0)
139	return QFont::DemiBold;
140	if (s.compare(s: QCoreApplication::translate(context: "QFontDatabase", key: "Medium", disambiguation: "The Medium font weight"), cs: Qt::CaseInsensitive) == 0)
141	return QFont::Medium;
142	if (s.compare(s: QCoreApplication::translate(context: "QFontDatabase", key: "Black"), cs: Qt::CaseInsensitive) == 0)
143	return QFont::Black;
144	const QString translatedLight = QCoreApplication::translate(context: "QFontDatabase", key: "Light").toLower();
145	if (s == translatedLight)
146	return QFont::Light;
147	if (s.compare(s: QCoreApplication::translate(context: "QFontDatabase", key: "Thin"), cs: Qt::CaseInsensitive) == 0)
148	return QFont::Thin;
149	if (s.compare(s: QCoreApplication::translate(context: "QFontDatabase", key: "Extra Light"), cs: Qt::CaseInsensitive) == 0)
150	return QFont::ExtraLight;
151	if (s.compare(s: QCoreApplication::translate(context: "QFontDatabase", key: "Extra Bold"), cs: Qt::CaseInsensitive) == 0)
152	return QFont::ExtraBold;
153
154	// And now the contains() checks for the translated strings.
155	//: The word for "Extra" as in "Extra Bold, Extra Thin" used as a pattern for string searches
156	const QString translatedExtra = QCoreApplication::translate(context: "QFontDatabase", key: "Extra").toLower();
157	if (s.contains(s: translatedBold)) {
158	//: The word for "Demi" as in "Demi Bold" used as a pattern for string searches
159	QString translatedDemi = QCoreApplication::translate(context: "QFontDatabase", key: "Demi").toLower();
160	if (s .contains(s: translatedDemi))
161	return QFont::DemiBold;
162	if (s.contains(s: translatedExtra))
163	return QFont::ExtraBold;
164	return QFont::Bold;
165	}
166
167	if (s.contains(s: translatedLight)) {
168	if (s.contains(s: translatedExtra))
169	return QFont::ExtraLight;
170	return QFont::Light;
171	}
172	return QFont::Normal;
173	}
174
175
176	struct QtFontSize
177	{
178
179	void *handle;
180
181	unsigned short pixelSize : 16;
182	};
183
184
185
186	struct QtFontStyle
187	{
188	struct Key {
189	Key(const QString &styleString);
190	Key() : style(QFont::StyleNormal),
191	weight(QFont::Normal), stretch(0) { }
192	Key(const Key &o) : style(o.style), weight(o.weight), stretch(o.stretch) { }
193	uint style : 2;
194	signed int weight : 8;
195	signed int stretch : 12;
196
197	bool operator==(const Key & other) {
198	return (style == other.style && weight == other.weight &&
199	(stretch == 0 || other.stretch == 0 || stretch == other.stretch));
200	}
201	bool operator!=(const Key &other) {
202	return !operator==(other);
203	}
204	bool operator <(const Key &o) {
205	int x = (style << 12) + (weight << 14) + stretch;
206	int y = (o.style << 12) + (o.weight << 14) + o.stretch;
207	return (x < y);
208	}
209	};
210
211	QtFontStyle(const Key &k)
212	: key(k), bitmapScalable(false), smoothScalable(false),
213	count(0), pixelSizes(nullptr)
214	{
215	}
216
217	~QtFontStyle() {
218	while (count) {
219	// bitfield count-- in while condition does not work correctly in mwccsym2
220	count--;
221	QPlatformIntegration *integration = QGuiApplicationPrivate::platformIntegration();
222	if (integration) {
223	integration->fontDatabase()->releaseHandle(handle: pixelSizes[count].handle);
224	}
225	}
226	free(ptr: pixelSizes);
227	}
228
229	Key key;
230	bool bitmapScalable : 1;
231	bool smoothScalable : 1;
232	signed int count : 30;
233	QtFontSize *pixelSizes;
234	QString styleName;
235
236	bool antialiased;
237
238	QtFontSize *pixelSize(unsigned short size, bool = false);
239	};
240
241	QtFontStyle::Key::Key(const QString &styleString)
242	: style(QFont::StyleNormal), weight(QFont::Normal), stretch(0)
243	{
244	weight = getFontWeight(weightString: styleString);
245
246	if (!styleString.isEmpty()) {
247	// First the straightforward no-translation checks, these are fast.
248	if (styleString.contains(s: QLatin1String("Italic")))
249	style = QFont::StyleItalic;
250	else if (styleString.contains(s: QLatin1String("Oblique")))
251	style = QFont::StyleOblique;
252
253	// Then the translation checks. These aren't as fast.
254	else if (styleString.contains(s: QCoreApplication::translate(context: "QFontDatabase", key: "Italic")))
255	style = QFont::StyleItalic;
256	else if (styleString.contains(s: QCoreApplication::translate(context: "QFontDatabase", key: "Oblique")))
257	style = QFont::StyleOblique;
258	}
259	}
260
261	QtFontSize *QtFontStyle::pixelSize(unsigned short size, bool add)
262	{
263	for (int i = 0; i < count; i++) {
264	if (pixelSizes[i].pixelSize == size)
265	return pixelSizes + i;
266	}
267	if (!add)
268	return nullptr;
269
270	if (!pixelSizes) {
271	// Most style have only one font size, we avoid waisting memory
272	QtFontSize *newPixelSizes = (QtFontSize *)malloc(size: sizeof(QtFontSize));
273	Q_CHECK_PTR(newPixelSizes);
274	pixelSizes = newPixelSizes;
275	} else if (!(count % 8) || count == 1) {
276	QtFontSize *newPixelSizes = (QtFontSize *)
277	realloc(ptr: pixelSizes,
278	size: (((count+8) >> 3) << 3) * sizeof(QtFontSize));
279	Q_CHECK_PTR(newPixelSizes);
280	pixelSizes = newPixelSizes;
281	}
282	pixelSizes[count].pixelSize = size;
283	pixelSizes[count].handle = nullptr;
284	return pixelSizes + (count++);
285	}
286
287	struct QtFontFoundry
288	{
289	QtFontFoundry(const QString &n) : name(n), count(0), styles(nullptr) {}
290	~QtFontFoundry() {
291	while (count--)
292	delete styles[count];
293	free(ptr: styles);
294	}
295
296	QString name;
297
298	int count;
299	QtFontStyle **styles;
300	QtFontStyle *style(const QtFontStyle::Key &, const QString & = QString(), bool = false);
301	};
302
303	QtFontStyle *QtFontFoundry::style(const QtFontStyle::Key &key, const QString &styleName, bool create)
304	{
305	int pos = 0;
306	for (; pos < count; pos++) {
307	bool hasStyleName = !styleName.isEmpty(); // search styleName first if available
308	if (hasStyleName && !styles[pos]->styleName.isEmpty()) {
309	if (styles[pos]->styleName == styleName)
310	return styles[pos];
311	} else {
312	if (styles[pos]->key == key)
313	return styles[pos];
314	}
315	}
316	if (!create)
317	return nullptr;
318
319	// qDebug("adding key (weight=%d, style=%d, oblique=%d stretch=%d) at %d", key.weight, key.style, key.oblique, key.stretch, pos);
320	if (!(count % 8)) {
321	QtFontStyle **newStyles = (QtFontStyle **)
322	realloc(ptr: styles, size: (((count+8) >> 3) << 3) * sizeof(QtFontStyle *));
323	Q_CHECK_PTR(newStyles);
324	styles = newStyles;
325	}
326
327	QtFontStyle *style = new QtFontStyle(key);
328	style->styleName = styleName;
329	styles[pos] = style;
330	count++;
331	return styles[pos];
332	}
333
334
335	struct QtFontFamily
336	{
337	enum WritingSystemStatus {
338	Unknown = 0,
339	Supported = 1,
340	UnsupportedFT = 2,
341	Unsupported = UnsupportedFT
342	};
343
344	QtFontFamily(const QString &n)
345	:
346	populated(false),
347	fixedPitch(false),
348	name(n), count(0), foundries(nullptr)
349	{
350	memset(s: writingSystems, c: 0, n: sizeof(writingSystems));
351	}
352	~QtFontFamily() {
353	while (count--)
354	delete foundries[count];
355	free(ptr: foundries);
356	}
357
358	bool populated : 1;
359	bool fixedPitch : 1;
360
361	QString name;
362	QStringList aliases;
363	int count;
364	QtFontFoundry **foundries;
365
366	unsigned char writingSystems[QFontDatabase::WritingSystemsCount];
367
368	bool matchesFamilyName(const QString &familyName) const;
369	QtFontFoundry *foundry(const QString &f, bool = false);
370
371	void ensurePopulated();
372	};
373
374	QtFontFoundry *QtFontFamily::foundry(const QString &f, bool create)
375	{
376	if (f.isNull() && count == 1)
377	return foundries[0];
378
379	for (int i = 0; i < count; i++) {
380	if (foundries[i]->name.compare(s: f, cs: Qt::CaseInsensitive) == 0)
381	return foundries[i];
382	}
383	if (!create)
384	return nullptr;
385
386	if (!(count % 8)) {
387	QtFontFoundry **newFoundries = (QtFontFoundry **)
388	realloc(ptr: foundries,
389	size: (((count+8) >> 3) << 3) * sizeof(QtFontFoundry *));
390	Q_CHECK_PTR(newFoundries);
391	foundries = newFoundries;
392	}
393
394	foundries[count] = new QtFontFoundry(f);
395	return foundries[count++];
396	}
397
398	static inline bool equalsCaseInsensitive(const QString &a, const QString &b)
399	{
400	return a.size() == b.size() && a.compare(s: b, cs: Qt::CaseInsensitive) == 0;
401	}
402
403	bool QtFontFamily::matchesFamilyName(const QString &familyName) const
404	{
405	return equalsCaseInsensitive(a: name, b: familyName) || aliases.contains(str: familyName, cs: Qt::CaseInsensitive);
406	}
407
408	void QtFontFamily::ensurePopulated()
409	{
410	if (populated)
411	return;
412
413	QGuiApplicationPrivate::platformIntegration()->fontDatabase()->populateFamily(familyName: name);
414	Q_ASSERT_X(populated, Q_FUNC_INFO, qPrintable(name));
415	}
416
417	/*!
418	\internal
419
420	Tests if the given family \a family supports writing system \a writingSystem,
421	including the special case for Han script mapping to several subsequent writing systems
422	*/
423	static bool familySupportsWritingSystem(QtFontFamily *family, size_t writingSystem)
424	{
425	Q_ASSERT(family != nullptr);
426	Q_ASSERT(writingSystem != QFontDatabase::Any && writingSystem < QFontDatabase::WritingSystemsCount);
427
428	size_t ws = writingSystem;
429	do {
430	if ((family->writingSystems[ws] & QtFontFamily::Supported) != 0)
431	return true;
432	} while (writingSystem >= QFontDatabase::SimplifiedChinese && writingSystem <= QFontDatabase::Japanese && ++ws <= QFontDatabase::Japanese);
433
434	return false;
435	}
436
437	struct FallbacksCacheKey {
438	QString family;
439	QFont::Style style;
440	QFont::StyleHint styleHint;
441	QChar::Script script;
442	};
443
444	inline bool operator==(const FallbacksCacheKey &lhs, const FallbacksCacheKey &rhs) noexcept
445	{
446	return lhs.script == rhs.script &&
447	lhs.styleHint == rhs.styleHint &&
448	lhs.style == rhs.style &&
449	lhs.family == rhs.family;
450	}
451
452	inline bool operator!=(const FallbacksCacheKey &lhs, const FallbacksCacheKey &rhs) noexcept
453	{
454	return !operator==(lhs, rhs);
455	}
456
457	inline uint qHash(const FallbacksCacheKey &key, uint seed = 0) noexcept
458	{
459	QtPrivate::QHashCombine hash;
460	seed = hash(seed, key.family);
461	seed = hash(seed, int(key.style));
462	seed = hash(seed, int(key.styleHint));
463	seed = hash(seed, int(key.script));
464	return seed;
465	}
466
467
468	class QFontDatabasePrivate
469	{
470	public:
471	QFontDatabasePrivate()
472	: count(0), families(nullptr),
473	fallbacksCache(64)
474	{ }
475
476	~QFontDatabasePrivate() {
477	free();
478	}
479
480	enum FamilyRequestFlags {
481	RequestFamily = 0,
482	EnsureCreated,
483	EnsurePopulated
484	};
485
486	QtFontFamily *family(const QString &f, FamilyRequestFlags flags = EnsurePopulated);
487	void free() {
488	while (count--)
489	delete families[count];
490	::free(ptr: families);
491	families = nullptr;
492	count = 0;
493	// don't clear the memory fonts!
494	}
495
496	int count;
497	QtFontFamily **families;
498
499	QCache<FallbacksCacheKey, QStringList> fallbacksCache;
500
501
502	struct ApplicationFont {
503	QString fileName;
504	QByteArray data;
505	QStringList families;
506	};
507	QVector<ApplicationFont> applicationFonts;
508	int addAppFont(const QByteArray &fontData, const QString &fileName);
509	bool isApplicationFont(const QString &fileName);
510
511	void invalidate();
512	};
513	Q_DECLARE_TYPEINFO(QFontDatabasePrivate::ApplicationFont, Q_MOVABLE_TYPE);
514
515	void QFontDatabasePrivate::invalidate()
516	{
517	QFontCache::instance()->clear();
518
519	fallbacksCache.clear();
520	free();
521	QGuiApplicationPrivate::platformIntegration()->fontDatabase()->invalidate();
522	emit static_cast<QGuiApplication *>(QCoreApplication::instance())->fontDatabaseChanged();
523	}
524
525	QtFontFamily *QFontDatabasePrivate::family(const QString &f, FamilyRequestFlags flags)
526	{
527	QtFontFamily *fam = nullptr;
528
529	int low = 0;
530	int high = count;
531	int pos = count / 2;
532	int res = 1;
533	if (count) {
534	while ((res = families[pos]->name.compare(s: f, cs: Qt::CaseInsensitive)) && pos != low) {
535	if (res > 0)
536	high = pos;
537	else
538	low = pos;
539	pos = (high + low) / 2;
540	}
541	if (!res)
542	fam = families[pos];
543	}
544
545	if (!fam && (flags & EnsureCreated)) {
546	if (res < 0)
547	pos++;
548
549	// qDebug() << "adding family " << f.toLatin1() << " at " << pos << " total=" << count;
550	if (!(count % 8)) {
551	QtFontFamily **newFamilies = (QtFontFamily **)
552	realloc(ptr: families,
553	size: (((count+8) >> 3) << 3) * sizeof(QtFontFamily *));
554	Q_CHECK_PTR(newFamilies);
555	families = newFamilies;
556	}
557
558	QtFontFamily *family = new QtFontFamily(f);
559	memmove(dest: families + pos + 1, src: families + pos, n: (count-pos)*sizeof(QtFontFamily *));
560	families[pos] = family;
561	count++;
562
563	fam = families[pos];
564	}
565
566	if (fam && (flags & EnsurePopulated))
567	fam->ensurePopulated();
568
569	return fam;
570	}
571
572
573
574	static const int scriptForWritingSystem[] = {
575	QChar::Script_Common, // Any
576	QChar::Script_Latin, // Latin
577	QChar::Script_Greek, // Greek
578	QChar::Script_Cyrillic, // Cyrillic
579	QChar::Script_Armenian, // Armenian
580	QChar::Script_Hebrew, // Hebrew
581	QChar::Script_Arabic, // Arabic
582	QChar::Script_Syriac, // Syriac
583	QChar::Script_Thaana, // Thaana
584	QChar::Script_Devanagari, // Devanagari
585	QChar::Script_Bengali, // Bengali
586	QChar::Script_Gurmukhi, // Gurmukhi
587	QChar::Script_Gujarati, // Gujarati
588	QChar::Script_Oriya, // Oriya
589	QChar::Script_Tamil, // Tamil
590	QChar::Script_Telugu, // Telugu
591	QChar::Script_Kannada, // Kannada
592	QChar::Script_Malayalam, // Malayalam
593	QChar::Script_Sinhala, // Sinhala
594	QChar::Script_Thai, // Thai
595	QChar::Script_Lao, // Lao
596	QChar::Script_Tibetan, // Tibetan
597	QChar::Script_Myanmar, // Myanmar
598	QChar::Script_Georgian, // Georgian
599	QChar::Script_Khmer, // Khmer
600	QChar::Script_Han, // SimplifiedChinese
601	QChar::Script_Han, // TraditionalChinese
602	QChar::Script_Han, // Japanese
603	QChar::Script_Hangul, // Korean
604	QChar::Script_Latin, // Vietnamese
605	QChar::Script_Common, // Symbol
606	QChar::Script_Ogham, // Ogham
607	QChar::Script_Runic, // Runic
608	QChar::Script_Nko // Nko
609	};
610
611	Q_STATIC_ASSERT(sizeof(scriptForWritingSystem) / sizeof(scriptForWritingSystem[0]) == QFontDatabase::WritingSystemsCount);
612
613	Q_GUI_EXPORT int qt_script_for_writing_system(QFontDatabase::WritingSystem writingSystem)
614	{
615	return scriptForWritingSystem[writingSystem];
616	}
617
618
619
620
621	/*!
622	\internal
623
624	This makes sense of the font family name:
625
626	if the family name contains a '[' and a ']', then we take the text
627	between the square brackets as the foundry, and the text before the
628	square brackets as the family (ie. "Arial [Monotype]")
629	*/
630	static void parseFontName(const QString &name, QString &foundry, QString &family)
631	{
632	int i = name.indexOf(c: QLatin1Char('['));
633	int li = name.lastIndexOf(c: QLatin1Char(']'));
634	if (i >= 0 && li >= 0 && i < li) {
635	foundry = name.mid(position: i + 1, n: li - i - 1);
636	if (i > 0 && name[i - 1] == QLatin1Char(' '))
637	i--;
638	family = name.left(n: i);
639	} else {
640	foundry.clear();
641	family = name;
642	}
643
644	// capitalize the family/foundry names
645	bool space = true;
646	QChar *s = family.data();
647	int len = family.length();
648	while(len--) {
649	if (space) *s = s->toUpper();
650	space = s->isSpace();
651	++s;
652	}
653
654	space = true;
655	s = foundry.data();
656	len = foundry.length();
657	while(len--) {
658	if (space) *s = s->toUpper();
659	space = s->isSpace();
660	++s;
661	}
662	}
663
664
665	struct QtFontDesc
666	{
667	inline QtFontDesc() : family(nullptr), foundry(nullptr), style(nullptr), size(nullptr) {}
668	QtFontFamily *family;
669	QtFontFoundry *foundry;
670	QtFontStyle *style;
671	QtFontSize *size;
672	};
673
674	static void initFontDef(const QtFontDesc &desc, const QFontDef &request, QFontDef *fontDef, bool multi)
675	{
676	fontDef->family = desc.family->name;
677	if (! desc.foundry->name.isEmpty() && desc.family->count > 1)
678	fontDef->family += QLatin1String(" [") + desc.foundry->name + QLatin1Char(']');
679
680	if (desc.style->smoothScalable
681	|| QGuiApplicationPrivate::platformIntegration()->fontDatabase()->fontsAlwaysScalable()
682	|| (desc.style->bitmapScalable && (request.styleStrategy & QFont::PreferMatch))) {
683	fontDef->pixelSize = request.pixelSize;
684	} else {
685	fontDef->pixelSize = desc.size->pixelSize;
686	}
687	fontDef->pointSize = request.pointSize;
688
689	fontDef->styleHint = request.styleHint;
690	fontDef->styleStrategy = request.styleStrategy;
691
692	if (!multi)
693	fontDef->weight = desc.style->key.weight;
694	if (!multi)
695	fontDef->style = desc.style->key.style;
696	fontDef->fixedPitch = desc.family->fixedPitch;
697	fontDef->ignorePitch = false;
698	}
699
700	static QStringList familyList(const QFontDef &req)
701	{
702	// list of families to try
703	QStringList family_list;
704
705	family_list << req.families;
706	if (!req.family.isEmpty()) {
707	const auto list = req.family.splitRef(sep: QLatin1Char(','));
708	const int numFamilies = list.size();
709	family_list.reserve(alloc: numFamilies);
710	for (int i = 0; i < numFamilies; ++i) {
711	QStringRef str = list.at(i).trimmed();
712	if ((str.startsWith(c: QLatin1Char('"')) && str.endsWith(c: QLatin1Char('"')))
713	|| (str.startsWith(c: QLatin1Char('\'')) && str.endsWith(c: QLatin1Char('\''))))
714	str = str.mid(pos: 1, n: str.length() - 2);
715	if (!family_list.contains(str))
716	family_list << str.toString();
717	}
718	}
719	// append the substitute list for each family in family_list
720	for (int i = 0, size = family_list.size(); i < size; ++i)
721	family_list += QFont::substitutes(family_list.at(i));
722
723	return family_list;
724	}
725
726	Q_GLOBAL_STATIC(QFontDatabasePrivate, privateDb)
727	Q_GLOBAL_STATIC(QRecursiveMutex, fontDatabaseMutex)
728
729	// used in qguiapplication.cpp
730	void qt_cleanupFontDatabase()
731	{
732	QFontDatabasePrivate *db = privateDb();
733	if (db) {
734	db->fallbacksCache.clear();
735	db->free();
736	}
737	}
738
739	// used in qfont.cpp
740	QRecursiveMutex *qt_fontdatabase_mutex()
741	{
742	return fontDatabaseMutex();
743	}
744
745
746	void qt_registerFont(const QString &familyName, const QString &stylename,
747	const QString &foundryname, int weight,
748	QFont::Style style, int stretch, bool antialiased,
749	bool scalable, int pixelSize, bool fixedPitch,
750	const QSupportedWritingSystems &writingSystems, void *handle)
751	{
752	QFontDatabasePrivate *d = privateDb();
753	qCDebug(lcFontDb) << "Adding font: familyName" << familyName << "stylename" << stylename << "weight" << weight
754	<< "style" << style << "pixelSize" << pixelSize << "antialiased" << antialiased << "fixed" << fixedPitch;
755	QtFontStyle::Key styleKey;
756	styleKey.style = style;
757	styleKey.weight = weight;
758	styleKey.stretch = stretch;
759	QtFontFamily *f = d->family(f: familyName, flags: QFontDatabasePrivate::EnsureCreated);
760	f->fixedPitch = fixedPitch;
761
762	for (int i = 0; i < QFontDatabase::WritingSystemsCount; ++i) {
763	if (writingSystems.supported(QFontDatabase::WritingSystem(i)))
764	f->writingSystems[i] = QtFontFamily::Supported;
765	}
766
767	QtFontFoundry *foundry = f->foundry(f: foundryname, create: true);
768	QtFontStyle *fontStyle = foundry->style(key: styleKey, styleName: stylename, create: true);
769	fontStyle->smoothScalable = scalable;
770	fontStyle->antialiased = antialiased;
771	QtFontSize *size = fontStyle->pixelSize(size: pixelSize ? pixelSize : SMOOTH_SCALABLE, add: true);
772	if (size->handle) {
773	QPlatformIntegration *integration = QGuiApplicationPrivate::platformIntegration();
774	if (integration)
775	integration->fontDatabase()->releaseHandle(handle: size->handle);
776	}
777	size->handle = handle;
778	f->populated = true;
779	}
780
781	void qt_registerFontFamily(const QString &familyName)
782	{
783	// Create uninitialized/unpopulated family
784	privateDb()->family(f: familyName, flags: QFontDatabasePrivate::EnsureCreated);
785	}
786
787	void qt_registerAliasToFontFamily(const QString &familyName, const QString &alias)
788	{
789	if (alias.isEmpty())
790	return;
791
792	QFontDatabasePrivate *d = privateDb();
793	QtFontFamily *f = d->family(f: familyName, flags: QFontDatabasePrivate::RequestFamily);
794	if (!f)
795	return;
796
797	if (f->aliases.contains(str: alias, cs: Qt::CaseInsensitive))
798	return;
799
800	f->aliases.push_back(t: alias);
801	}
802
803	QString qt_resolveFontFamilyAlias(const QString &alias)
804	{
805	if (!alias.isEmpty()) {
806	const QFontDatabasePrivate *d = privateDb();
807	for (int i = 0; i < d->count; ++i)
808	if (d->families[i]->matchesFamilyName(familyName: alias))
809	return d->families[i]->name;
810	}
811	return alias;
812	}
813
814	bool qt_isFontFamilyPopulated(const QString &familyName)
815	{
816	QFontDatabasePrivate *d = privateDb();
817	QtFontFamily *f = d->family(f: familyName, flags: QFontDatabasePrivate::RequestFamily);
818	return f != nullptr && f->populated;
819	}
820
821	/*!
822	Returns a list of alternative fonts for the specified \a family and
823	\a style and \a script using the \a styleHint given.
824
825	Default implementation returns a list of fonts for which \a style and \a script support
826	has been reported during the font database population.
827	*/
828	QStringList QPlatformFontDatabase::fallbacksForFamily(const QString &family, QFont::Style style, QFont::StyleHint styleHint, QChar::Script script) const
829	{
830	Q_UNUSED(family);
831	Q_UNUSED(styleHint);
832
833	QStringList preferredFallbacks;
834	QStringList otherFallbacks;
835
836	size_t writingSystem = std::find(first: scriptForWritingSystem,
837	last: scriptForWritingSystem + QFontDatabase::WritingSystemsCount,
838	val: script) - scriptForWritingSystem;
839	if (writingSystem >= QFontDatabase::WritingSystemsCount)
840	writingSystem = QFontDatabase::Any;
841
842	QFontDatabasePrivate *db = privateDb();
843	for (int i = 0; i < db->count; ++i) {
844	QtFontFamily *f = db->families[i];
845
846	f->ensurePopulated();
847
848	if (writingSystem > QFontDatabase::Any && !familySupportsWritingSystem(family: f, writingSystem))
849	continue;
850
851	for (int j = 0; j < f->count; ++j) {
852	QtFontFoundry *foundry = f->foundries[j];
853
854	for (int k = 0; k < foundry->count; ++k) {
855	QString name = foundry->name.isEmpty()
856	? f->name
857	: f->name + QLatin1String(" [") + foundry->name + QLatin1Char(']');
858	if (style == foundry->styles[k]->key.style)
859	preferredFallbacks.append(t: name);
860	else
861	otherFallbacks.append(t: name);
862	}
863	}
864	}
865
866	return preferredFallbacks + otherFallbacks;
867	}
868
869	static void initializeDb();
870
871	static QStringList fallbacksForFamily(const QString &family, QFont::Style style, QFont::StyleHint styleHint, QChar::Script script)
872	{
873	QFontDatabasePrivate *db = privateDb();
874	if (!db->count)
875	initializeDb();
876
877	const FallbacksCacheKey cacheKey = { .family: family, .style: style, .styleHint: styleHint, .script: script };
878
879	if (const QStringList *fallbacks = db->fallbacksCache.object(key: cacheKey))
880	return *fallbacks;
881
882	// make sure that the db has all fallback families
883	QStringList retList = QGuiApplicationPrivate::platformIntegration()->fontDatabase()->fallbacksForFamily(family,style,styleHint,script);
884
885	QStringList::iterator i;
886	for (i = retList.begin(); i != retList.end(); ++i) {
887	bool contains = false;
888	for (int j = 0; j < db->count; j++) {
889	if (db->families[j]->matchesFamilyName(familyName: *i)) {
890	contains = true;
891	break;
892	}
893	}
894	if (!contains) {
895	i = retList.erase(it: i);
896	--i;
897	}
898	}
899
900	db->fallbacksCache.insert(akey: cacheKey, aobject: new QStringList(retList));
901
902	return retList;
903	}
904
905	QStringList qt_fallbacksForFamily(const QString &family, QFont::Style style, QFont::StyleHint styleHint, QChar::Script script)
906	{
907	QMutexLocker locker(fontDatabaseMutex());
908	return fallbacksForFamily(family, style, styleHint, script);
909	}
910
911	static void registerFont(QFontDatabasePrivate::ApplicationFont *fnt);
912
913	static void initializeDb()
914	{
915	QFontDatabasePrivate *db = privateDb();
916
917	// init by asking for the platformfontdb for the first time or after invalidation
918	if (!db->count) {
919	QGuiApplicationPrivate::platformIntegration()->fontDatabase()->populateFontDatabase();
920	for (int i = 0; i < db->applicationFonts.count(); i++) {
921	if (!db->applicationFonts.at(i).families.isEmpty())
922	registerFont(fnt: &db->applicationFonts[i]);
923	}
924	}
925	}
926
927	static inline void load(const QString & = QString(), int = -1)
928	{
929	// Only initialize the database if it has been cleared or not initialized yet
930	if (!privateDb()->count)
931	initializeDb();
932	}
933
934	static
935	QFontEngine *loadSingleEngine(int script,
936	const QFontDef &request,
937	QtFontFamily *family, QtFontFoundry *foundry,
938	QtFontStyle *style, QtFontSize *size)
939	{
940	Q_UNUSED(foundry);
941
942	Q_ASSERT(size);
943	QPlatformFontDatabase *pfdb = QGuiApplicationPrivate::platformIntegration()->fontDatabase();
944	int pixelSize = size->pixelSize;
945	if (!pixelSize || (style->smoothScalable && pixelSize == SMOOTH_SCALABLE)
946	|| pfdb->fontsAlwaysScalable()) {
947	pixelSize = request.pixelSize;
948	}
949
950	QFontDef def = request;
951	def.pixelSize = pixelSize;
952
953	QFontCache *fontCache = QFontCache::instance();
954
955	QFontCache::Key key(def,script);
956	QFontEngine *engine = fontCache->findEngine(key);
957	if (!engine) {
958	const bool cacheForCommonScript = script != QChar::Script_Common
959	&& (family->writingSystems[QFontDatabase::Latin] & QtFontFamily::Supported) != 0;
960
961	if (Q_LIKELY(cacheForCommonScript)) {
962	// fast path: check if engine was loaded for another script
963	key.script = QChar::Script_Common;
964	engine = fontCache->findEngine(key);
965	key.script = script;
966	if (engine) {
967	// Also check for OpenType tables when using complex scripts
968	if (Q_UNLIKELY(!engine->supportsScript(QChar::Script(script)))) {
969	qWarning(msg: " OpenType support missing for \"%s\", script %d",
970	qPrintable(def.family), script);
971	return nullptr;
972	}
973
974	engine->isSmoothlyScalable = style->smoothScalable;
975	fontCache->insertEngine(key, engine);
976	return engine;
977	}
978	}
979
980	// To avoid synthesized stretch we need a matching stretch to be 100 after this point.
981	// If stretch didn't match exactly we need to calculate the new stretch factor.
982	// This only done if not matched by styleName.
983	if (style->key.stretch != 0 && request.stretch != 0
984	&& (request.styleName.isEmpty() || request.styleName != style->styleName)) {
985	def.stretch = (request.stretch * 100 + style->key.stretch / 2) / style->key.stretch;
986	} else {
987	def.stretch = 100;
988	}
989
990	engine = pfdb->fontEngine(fontDef: def, handle: size->handle);
991	if (engine) {
992	// Also check for OpenType tables when using complex scripts
993	if (!engine->supportsScript(script: QChar::Script(script))) {
994	qWarning(msg: " OpenType support missing for \"%s\", script %d",
995	+ qPrintable(def.family), script);
996	if (engine->ref.loadRelaxed() == 0)
997	delete engine;
998	return nullptr;
999	}
1000
1001	engine->isSmoothlyScalable = style->smoothScalable;
1002	fontCache->insertEngine(key, engine);
1003
1004	if (Q_LIKELY(cacheForCommonScript && !engine->symbol)) {
1005	// cache engine for Common script as well
1006	key.script = QChar::Script_Common;
1007	if (!fontCache->findEngine(key))
1008	fontCache->insertEngine(key, engine);
1009	}
1010	}
1011	}
1012	return engine;
1013	}
1014
1015	static
1016	QFontEngine *loadEngine(int script, const QFontDef &request,
1017	QtFontFamily *family, QtFontFoundry *foundry,
1018	QtFontStyle *style, QtFontSize *size)
1019	{
1020	QFontEngine *engine = loadSingleEngine(script, request, family, foundry, style, size);
1021
1022	if (engine && !(request.styleStrategy & QFont::NoFontMerging) && !engine->symbol) {
1023	Q_TRACE(QFontDatabase_loadEngine, request.family, request.pointSize);
1024
1025	QPlatformFontDatabase *pfdb = QGuiApplicationPrivate::platformIntegration()->fontDatabase();
1026	QFontEngineMulti *pfMultiEngine = pfdb->fontEngineMulti(fontEngine: engine, script: QChar::Script(script));
1027	if (!request.fallBackFamilies.isEmpty()) {
1028	QStringList fallbacks = request.fallBackFamilies;
1029
1030	QFont::StyleHint styleHint = QFont::StyleHint(request.styleHint);
1031	if (styleHint == QFont::AnyStyle && request.fixedPitch)
1032	styleHint = QFont::TypeWriter;
1033
1034	fallbacks += fallbacksForFamily(family: family->name, style: QFont::Style(style->key.style), styleHint, script: QChar::Script(script));
1035
1036	pfMultiEngine->setFallbackFamiliesList(fallbacks);
1037	}
1038	engine = pfMultiEngine;
1039
1040	// Cache Multi font engine as well in case we got the single
1041	// font engine when we are actually looking for a Multi one
1042	QFontCache::Key key(request, script, 1);
1043	QFontCache::instance()->insertEngine(key, engine);
1044	}
1045
1046	return engine;
1047	}
1048
1049	static void registerFont(QFontDatabasePrivate::ApplicationFont *fnt)
1050	{
1051	fnt->families = QGuiApplicationPrivate::platformIntegration()->fontDatabase()->addApplicationFont(fontData: fnt->data,fileName: fnt->fileName);
1052	}
1053
1054	static QtFontStyle *bestStyle(QtFontFoundry *foundry, const QtFontStyle::Key &styleKey,
1055	const QString &styleName = QString())
1056	{
1057	int best = 0;
1058	int dist = 0xffff;
1059
1060	for ( int i = 0; i < foundry->count; i++ ) {
1061	QtFontStyle *style = foundry->styles[i];
1062
1063	if (!styleName.isEmpty() && styleName == style->styleName) {
1064	dist = 0;
1065	best = i;
1066	break;
1067	}
1068
1069	int d = qAbs( t: styleKey.weight - style->key.weight );
1070
1071	if ( styleKey.stretch != 0 && style->key.stretch != 0 ) {
1072	d += qAbs( t: styleKey.stretch - style->key.stretch );
1073	}
1074
1075	if (styleKey.style != style->key.style) {
1076	if (styleKey.style != QFont::StyleNormal && style->key.style != QFont::StyleNormal)
1077	// one is italic, the other oblique
1078	d += 0x0001;
1079	else
1080	d += 0x1000;
1081	}
1082
1083	if ( d < dist ) {
1084	best = i;
1085	dist = d;
1086	}
1087	}
1088
1089	qCDebug(lcFontMatch, " best style has distance 0x%x", dist );
1090	return foundry->styles[best];
1091	}
1092
1093
1094	static
1095	unsigned int bestFoundry(int script, unsigned int score, int styleStrategy,
1096	const QtFontFamily *family, const QString &foundry_name,
1097	QtFontStyle::Key styleKey, int pixelSize, char pitch,
1098	QtFontDesc *desc, const QString &styleName = QString())
1099	{
1100	Q_UNUSED(script);
1101	Q_UNUSED(pitch);
1102
1103	desc->foundry = nullptr;
1104	desc->style = nullptr;
1105	desc->size = nullptr;
1106
1107
1108	qCDebug(lcFontMatch, " REMARK: looking for best foundry for family '%s' [%d]", family->name.toLatin1().constData(), family->count);
1109
1110	for (int x = 0; x < family->count; ++x) {
1111	QtFontFoundry *foundry = family->foundries[x];
1112	if (!foundry_name.isEmpty() && foundry->name.compare(s: foundry_name, cs: Qt::CaseInsensitive) != 0)
1113	continue;
1114
1115	qCDebug(lcFontMatch, " looking for matching style in foundry '%s' %d",
1116	foundry->name.isEmpty() ? "-- none --" : foundry->name.toLatin1().constData(), foundry->count);
1117
1118	QtFontStyle *style = bestStyle(foundry, styleKey, styleName);
1119
1120	if (!style->smoothScalable && (styleStrategy & QFont::ForceOutline)) {
1121	qCDebug(lcFontMatch, " ForceOutline set, but not smoothly scalable");
1122	continue;
1123	}
1124
1125	int px = -1;
1126	QtFontSize *size = nullptr;
1127
1128	// 1. see if we have an exact matching size
1129	if (!(styleStrategy & QFont::ForceOutline)) {
1130	size = style->pixelSize(size: pixelSize);
1131	if (size) {
1132	qCDebug(lcFontMatch, " found exact size match (%d pixels)", size->pixelSize);
1133	px = size->pixelSize;
1134	}
1135	}
1136
1137	// 2. see if we have a smoothly scalable font
1138	if (!size && style->smoothScalable && ! (styleStrategy & QFont::PreferBitmap)) {
1139	size = style->pixelSize(SMOOTH_SCALABLE);
1140	if (size) {
1141	qCDebug(lcFontMatch, " found smoothly scalable font (%d pixels)", pixelSize);
1142	px = pixelSize;
1143	}
1144	}
1145
1146	// 3. see if we have a bitmap scalable font
1147	if (!size && style->bitmapScalable && (styleStrategy & QFont::PreferMatch)) {
1148	size = style->pixelSize(size: 0);
1149	if (size) {
1150	qCDebug(lcFontMatch, " found bitmap scalable font (%d pixels)", pixelSize);
1151	px = pixelSize;
1152	}
1153	}
1154
1155
1156	// 4. find closest size match
1157	if (! size) {
1158	unsigned int distance = ~0u;
1159	for (int x = 0; x < style->count; ++x) {
1160
1161	unsigned int d;
1162	if (style->pixelSizes[x].pixelSize < pixelSize) {
1163	// penalize sizes that are smaller than the
1164	// requested size, due to truncation from floating
1165	// point to integer conversions
1166	d = pixelSize - style->pixelSizes[x].pixelSize + 1;
1167	} else {
1168	d = style->pixelSizes[x].pixelSize - pixelSize;
1169	}
1170
1171	if (d < distance) {
1172	distance = d;
1173	size = style->pixelSizes + x;
1174	qCDebug(lcFontMatch, " best size so far: %3d (%d)", size->pixelSize, pixelSize);
1175	}
1176	}
1177
1178	if (!size) {
1179	qCDebug(lcFontMatch, " no size supports the script we want");
1180	continue;
1181	}
1182
1183	if (style->bitmapScalable && ! (styleStrategy & QFont::PreferQuality) &&
1184	(distance * 10 / pixelSize) >= 2) {
1185	// the closest size is not close enough, go ahead and
1186	// use a bitmap scaled font
1187	size = style->pixelSize(size: 0);
1188	px = pixelSize;
1189	} else {
1190	px = size->pixelSize;
1191	}
1192	}
1193
1194
1195	unsigned int this_score = 0x0000;
1196	enum {
1197	PitchMismatch = 0x4000,
1198	StyleMismatch = 0x2000,
1199	BitmapScaledPenalty = 0x1000
1200	};
1201	if (pitch != '*') {
1202	if ((pitch == 'm' && !family->fixedPitch)
1203	|| (pitch == 'p' && family->fixedPitch))
1204	this_score += PitchMismatch;
1205	}
1206	if (styleKey != style->key)
1207	this_score += StyleMismatch;
1208	if (!style->smoothScalable && px != size->pixelSize) // bitmap scaled
1209	this_score += BitmapScaledPenalty;
1210	if (px != pixelSize) // close, but not exact, size match
1211	this_score += qAbs(t: px - pixelSize);
1212
1213	if (this_score < score) {
1214	qCDebug(lcFontMatch, " found a match: score %x best score so far %x",
1215	this_score, score);
1216
1217	score = this_score;
1218	desc->foundry = foundry;
1219	desc->style = style;
1220	desc->size = size;
1221	} else {
1222	qCDebug(lcFontMatch, " score %x no better than best %x", this_score, score);
1223	}
1224	}
1225
1226	return score;
1227	}
1228
1229	static bool matchFamilyName(const QString &familyName, QtFontFamily *f)
1230	{
1231	if (familyName.isEmpty())
1232	return true;
1233	return f->matchesFamilyName(familyName);
1234	}
1235
1236	/*!
1237	\internal
1238
1239	Tries to find the best match for a given request and family/foundry
1240	*/
1241	static int match(int script,
1242	const QFontDef &request,
1243	const QString &family_name,
1244	const QString &foundry_name,
1245	QtFontDesc *desc,
1246	const QList<int> &blacklistedFamilies,
1247	unsigned int *resultingScore = nullptr)
1248	{
1249	int result = -1;
1250
1251	QtFontStyle::Key styleKey;
1252	styleKey.style = request.style;
1253	styleKey.weight = request.weight;
1254	// Prefer a stretch closest to 100.
1255	styleKey.stretch = request.stretch ? request.stretch : 100;
1256	char pitch = request.ignorePitch ? '*' : request.fixedPitch ? 'm' : 'p';
1257
1258
1259	qCDebug(lcFontMatch, "QFontDatabase::match\n"
1260	" request:\n"
1261	" family: %s [%s], script: %d\n"
1262	" weight: %d, style: %d\n"
1263	" stretch: %d\n"
1264	" pixelSize: %g\n"
1265	" pitch: %c",
1266	family_name.isEmpty() ? "-- first in script --" : family_name.toLatin1().constData(),
1267	foundry_name.isEmpty() ? "-- any --" : foundry_name.toLatin1().constData(),
1268	script, request.weight, request.style, request.stretch, request.pixelSize, pitch);
1269
1270	desc->family = nullptr;
1271	desc->foundry = nullptr;
1272	desc->style = nullptr;
1273	desc->size = nullptr;
1274
1275	unsigned int score = ~0u;
1276
1277	load(family_name, script);
1278
1279	size_t writingSystem = std::find(first: scriptForWritingSystem, last: scriptForWritingSystem +
1280	QFontDatabase::WritingSystemsCount, val: script) - scriptForWritingSystem;
1281	if (writingSystem >= QFontDatabase::WritingSystemsCount)
1282	writingSystem = QFontDatabase::Any;
1283
1284	QFontDatabasePrivate *db = privateDb();
1285	for (int x = 0; x < db->count; ++x) {
1286	if (blacklistedFamilies.contains(t: x))
1287	continue;
1288	QtFontDesc test;
1289	test.family = db->families[x];
1290
1291	if (!matchFamilyName(familyName: family_name, f: test.family))
1292	continue;
1293
1294	test.family->ensurePopulated();
1295
1296	// Check if family is supported in the script we want
1297	if (writingSystem != QFontDatabase::Any
1298	&& !familySupportsWritingSystem(family: test.family, writingSystem)) {
1299	continue;
1300	}
1301
1302	// as we know the script is supported, we can be sure
1303	// to find a matching font here.
1304	unsigned int newscore =
1305	bestFoundry(script, score, styleStrategy: request.styleStrategy,
1306	family: test.family, foundry_name, styleKey, pixelSize: request.pixelSize, pitch,
1307	desc: &test, styleName: request.styleName);
1308	if (test.foundry == nullptr && !foundry_name.isEmpty()) {
1309	// the specific foundry was not found, so look for
1310	// any foundry matching our requirements
1311	newscore = bestFoundry(script, score, styleStrategy: request.styleStrategy, family: test.family,
1312	foundry_name: QString(), styleKey, pixelSize: request.pixelSize,
1313	pitch, desc: &test, styleName: request.styleName);
1314	}
1315
1316	if (newscore < score) {
1317	result = x;
1318	score = newscore;
1319	*desc = test;
1320	}
1321	if (newscore < 10) // xlfd instead of FT... just accept it
1322	break;
1323	}
1324
1325	if (resultingScore != nullptr)
1326	*resultingScore = score;
1327
1328	return result;
1329	}
1330
1331	static QString styleStringHelper(int weight, QFont::Style style)
1332	{
1333	QString result;
1334	if (weight > QFont::Normal) {
1335	if (weight >= QFont::Black)
1336	result = QCoreApplication::translate(context: "QFontDatabase", key: "Black");
1337	else if (weight >= QFont::ExtraBold)
1338	result = QCoreApplication::translate(context: "QFontDatabase", key: "Extra Bold");
1339	else if (weight >= QFont::Bold)
1340	result = QCoreApplication::translate(context: "QFontDatabase", key: "Bold");
1341	else if (weight >= QFont::DemiBold)
1342	result = QCoreApplication::translate(context: "QFontDatabase", key: "Demi Bold");
1343	else if (weight >= QFont::Medium)
1344	result = QCoreApplication::translate(context: "QFontDatabase", key: "Medium", disambiguation: "The Medium font weight");
1345	} else {
1346	if (weight <= QFont::Thin)
1347	result = QCoreApplication::translate(context: "QFontDatabase", key: "Thin");
1348	else if (weight <= QFont::ExtraLight)
1349	result = QCoreApplication::translate(context: "QFontDatabase", key: "Extra Light");
1350	else if (weight <= QFont::Light)
1351	result = QCoreApplication::translate(context: "QFontDatabase", key: "Light");
1352	}
1353
1354	if (style == QFont::StyleItalic)
1355	result += QLatin1Char(' ') + QCoreApplication::translate(context: "QFontDatabase", key: "Italic");
1356	else if (style == QFont::StyleOblique)
1357	result += QLatin1Char(' ') + QCoreApplication::translate(context: "QFontDatabase", key: "Oblique");
1358
1359	if (result.isEmpty())
1360	result = QCoreApplication::translate(context: "QFontDatabase", key: "Normal", disambiguation: "The Normal or Regular font weight");
1361
1362	return result.simplified();
1363	}
1364
1365	/*!
1366	Returns a string that describes the style of the \a font. For
1367	example, "Bold Italic", "Bold", "Italic" or "Normal". An empty
1368	string may be returned.
1369	*/
1370	QString QFontDatabase::styleString(const QFont &font)
1371	{
1372	return font.styleName().isEmpty() ? styleStringHelper(weight: font.weight(), style: font.style())
1373	: font.styleName();
1374	}
1375
1376	/*!
1377	Returns a string that describes the style of the \a fontInfo. For
1378	example, "Bold Italic", "Bold", "Italic" or "Normal". An empty
1379	string may be returned.
1380	*/
1381	QString QFontDatabase::styleString(const QFontInfo &fontInfo)
1382	{
1383	return fontInfo.styleName().isEmpty() ? styleStringHelper(weight: fontInfo.weight(), style: fontInfo.style())
1384	: fontInfo.styleName();
1385	}
1386
1387
1388	/*!
1389	\class QFontDatabase
1390	\threadsafe
1391	\inmodule QtGui
1392
1393	\brief The QFontDatabase class provides information about the fonts available in the underlying window system.
1394
1395	\ingroup appearance
1396
1397	The most common uses of this class are to query the database for
1398	the list of font families() and for the pointSizes() and styles()
1399	that are available for each family. An alternative to pointSizes()
1400	is smoothSizes() which returns the sizes at which a given family
1401	and style will look attractive.
1402
1403	If the font family is available from two or more foundries the
1404	foundry name is included in the family name; for example:
1405	"Helvetica [Adobe]" and "Helvetica [Cronyx]". When you specify a
1406	family, you can either use the old hyphenated "foundry-family"
1407	format or the bracketed "family [foundry]" format; for example:
1408	"Cronyx-Helvetica" or "Helvetica [Cronyx]". If the family has a
1409	foundry it is always returned using the bracketed format, as is
1410	the case with the value returned by families().
1411
1412	The font() function returns a QFont given a family, style and
1413	point size.
1414
1415	A family and style combination can be checked to see if it is
1416	italic() or bold(), and to retrieve its weight(). Similarly we can
1417	call isBitmapScalable(), isSmoothlyScalable(), isScalable() and
1418	isFixedPitch().
1419
1420	Use the styleString() to obtain a text version of a style.
1421
1422	The QFontDatabase class also supports some static functions, for
1423	example, standardSizes(). You can retrieve the description of a
1424	writing system using writingSystemName(), and a sample of
1425	characters in a writing system with writingSystemSample().
1426
1427	Example:
1428
1429	\snippet qfontdatabase/main.cpp 0
1430	\snippet qfontdatabase/main.cpp 1
1431
1432	This example gets the list of font families, the list of
1433	styles for each family, and the point sizes that are available for
1434	each combination of family and style, displaying this information
1435	in a tree view.
1436
1437	\sa QFont, QFontInfo, QFontMetrics, {Character Map Example}
1438	*/
1439
1440	/*!
1441	Creates a font database object.
1442	*/
1443	QFontDatabase::QFontDatabase()
1444	{
1445	if (Q_UNLIKELY(!qApp || !QGuiApplicationPrivate::platformIntegration()))
1446	qFatal(msg: "QFontDatabase: Must construct a QGuiApplication before accessing QFontDatabase");
1447
1448	QMutexLocker locker(fontDatabaseMutex());
1449	createDatabase();
1450	d = privateDb();
1451	}
1452
1453	/*!
1454	\enum QFontDatabase::WritingSystem
1455
1456	\value Any
1457	\value Latin
1458	\value Greek
1459	\value Cyrillic
1460	\value Armenian
1461	\value Hebrew
1462	\value Arabic
1463	\value Syriac
1464	\value Thaana
1465	\value Devanagari
1466	\value Bengali
1467	\value Gurmukhi
1468	\value Gujarati
1469	\value Oriya
1470	\value Tamil
1471	\value Telugu
1472	\value Kannada
1473	\value Malayalam
1474	\value Sinhala
1475	\value Thai
1476	\value Lao
1477	\value Tibetan
1478	\value Myanmar
1479	\value Georgian
1480	\value Khmer
1481	\value SimplifiedChinese
1482	\value TraditionalChinese
1483	\value Japanese
1484	\value Korean
1485	\value Vietnamese
1486	\value Symbol
1487	\value Other (the same as Symbol)
1488	\value Ogham
1489	\value Runic
1490	\value Nko
1491
1492	\omitvalue WritingSystemsCount
1493	*/
1494
1495	/*!
1496	\enum QFontDatabase::SystemFont
1497
1498	\value GeneralFont The default system font.
1499	\value FixedFont The fixed font that the system recommends.
1500	\value TitleFont The system standard font for titles.
1501	\value SmallestReadableFont The smallest readable system font.
1502
1503	\since 5.2
1504	*/
1505
1506	/*!
1507	Returns a sorted list of the available writing systems. This is
1508	list generated from information about all installed fonts on the
1509	system.
1510
1511	\sa families()
1512	*/
1513	QList<QFontDatabase::WritingSystem> QFontDatabase::writingSystems() const
1514	{
1515	QMutexLocker locker(fontDatabaseMutex());
1516
1517	QT_PREPEND_NAMESPACE(load)();
1518
1519	quint64 writingSystemsFound = 0;
1520	Q_STATIC_ASSERT(WritingSystemsCount < 64);
1521
1522	for (int i = 0; i < d->count; ++i) {
1523	QtFontFamily *family = d->families[i];
1524	family->ensurePopulated();
1525
1526	if (family->count == 0)
1527	continue;
1528	for (uint x = Latin; x < uint(WritingSystemsCount); ++x) {
1529	if (family->writingSystems[x] & QtFontFamily::Supported)
1530	writingSystemsFound |= quint64(1) << x;
1531	}
1532	}
1533
1534	// mutex protection no longer needed - just working on local data now:
1535	locker.unlock();
1536
1537	QList<WritingSystem> list;
1538	list.reserve(alloc: qPopulationCount(v: writingSystemsFound));
1539	for (uint x = Latin ; x < uint(WritingSystemsCount); ++x) {
1540	if (writingSystemsFound & (quint64(1) << x))
1541	list.push_back(t: WritingSystem(x));
1542	}
1543	return list;
1544	}
1545
1546
1547	/*!
1548	Returns a sorted list of the writing systems supported by a given
1549	font \a family.
1550
1551	\sa families()
1552	*/
1553	QList<QFontDatabase::WritingSystem> QFontDatabase::writingSystems(const QString &family) const
1554	{
1555	QString familyName, foundryName;
1556	parseFontName(name: family, foundry&: foundryName, family&: familyName);
1557
1558	QMutexLocker locker(fontDatabaseMutex());
1559
1560	QT_PREPEND_NAMESPACE(load)();
1561
1562	QList<WritingSystem> list;
1563	QtFontFamily *f = d->family(f: familyName);
1564	if (!f || f->count == 0)
1565	return list;
1566
1567	for (int x = Latin; x < WritingSystemsCount; ++x) {
1568	const WritingSystem writingSystem = WritingSystem(x);
1569	if (f->writingSystems[writingSystem] & QtFontFamily::Supported)
1570	list.append(t: writingSystem);
1571	}
1572	return list;
1573	}
1574
1575
1576	/*!
1577	Returns a sorted list of the available font families which support
1578	the \a writingSystem.
1579
1580	If a family exists in several foundries, the returned name for
1581	that font is in the form "family [foundry]". Examples: "Times
1582	[Adobe]", "Times [Cronyx]", "Palatino".
1583
1584	\sa writingSystems()
1585	*/
1586	QStringList QFontDatabase::families(WritingSystem writingSystem) const
1587	{
1588	QMutexLocker locker(fontDatabaseMutex());
1589
1590	QT_PREPEND_NAMESPACE(load)();
1591
1592	QStringList flist;
1593	for (int i = 0; i < d->count; i++) {
1594	QtFontFamily *f = d->families[i];
1595	if (f->populated && f->count == 0)
1596	continue;
1597	if (writingSystem != Any) {
1598	f->ensurePopulated();
1599	if (f->writingSystems[writingSystem] != QtFontFamily::Supported)
1600	continue;
1601	}
1602	if (!f->populated || f->count == 1) {
1603	flist.append(t: f->name);
1604	} else {
1605	for (int j = 0; j < f->count; j++) {
1606	QString str = f->name;
1607	QString foundry = f->foundries[j]->name;
1608	if (!foundry.isEmpty()) {
1609	str += QLatin1String(" [");
1610	str += foundry;
1611	str += QLatin1Char(']');
1612	}
1613	flist.append(t: str);
1614	}
1615	}
1616	}
1617	return flist;
1618	}
1619
1620	/*!
1621	Returns a list of the styles available for the font family \a
1622	family. Some example styles: "Light", "Light Italic", "Bold",
1623	"Oblique", "Demi". The list may be empty.
1624
1625	\sa families()
1626	*/
1627	QStringList QFontDatabase::styles(const QString &family) const
1628	{
1629	QString familyName, foundryName;
1630	parseFontName(name: family, foundry&: foundryName, family&: familyName);
1631
1632	QMutexLocker locker(fontDatabaseMutex());
1633
1634	QT_PREPEND_NAMESPACE(load)(familyName);
1635
1636	QStringList l;
1637	QtFontFamily *f = d->family(f: familyName);
1638	if (!f)
1639	return l;
1640
1641	QtFontFoundry allStyles(foundryName);
1642	for (int j = 0; j < f->count; j++) {
1643	QtFontFoundry *foundry = f->foundries[j];
1644	if (foundryName.isEmpty() || foundry->name.compare(s: foundryName, cs: Qt::CaseInsensitive) == 0) {
1645	for (int k = 0; k < foundry->count; k++) {
1646	QtFontStyle::Key ke(foundry->styles[k]->key);
1647	ke.stretch = 0;
1648	allStyles.style(key: ke, styleName: foundry->styles[k]->styleName, create: true);
1649	}
1650	}
1651	}
1652
1653	l.reserve(alloc: allStyles.count);
1654	for (int i = 0; i < allStyles.count; i++) {
1655	l.append(t: allStyles.styles[i]->styleName.isEmpty() ?
1656	styleStringHelper(weight: allStyles.styles[i]->key.weight,
1657	style: (QFont::Style)allStyles.styles[i]->key.style) :
1658	allStyles.styles[i]->styleName);
1659	}
1660	return l;
1661	}
1662
1663	/*!
1664	Returns \c true if the font that has family \a family and style \a
1665	style is fixed pitch; otherwise returns \c false.
1666	*/
1667
1668	bool QFontDatabase::isFixedPitch(const QString &family,
1669	const QString &style) const
1670	{
1671	Q_UNUSED(style);
1672
1673	QString familyName, foundryName;
1674	parseFontName(name: family, foundry&: foundryName, family&: familyName);
1675
1676	QMutexLocker locker(fontDatabaseMutex());
1677
1678	QT_PREPEND_NAMESPACE(load)(familyName);
1679
1680	QtFontFamily *f = d->family(f: familyName);
1681	return (f && f->fixedPitch);
1682	}
1683
1684	/*!
1685	Returns \c true if the font that has family \a family and style \a
1686	style is a scalable bitmap font; otherwise returns \c false. Scaling
1687	a bitmap font usually produces an unattractive hardly readable
1688	result, because the pixels of the font are scaled. If you need to
1689	scale a bitmap font it is better to scale it to one of the fixed
1690	sizes returned by smoothSizes().
1691
1692	\sa isScalable(), isSmoothlyScalable()
1693	*/
1694	bool QFontDatabase::isBitmapScalable(const QString &family,
1695	const QString &style) const
1696	{
1697	bool bitmapScalable = false;
1698	QString familyName, foundryName;
1699	parseFontName(name: family, foundry&: foundryName, family&: familyName);
1700
1701	QMutexLocker locker(fontDatabaseMutex());
1702
1703	QT_PREPEND_NAMESPACE(load)(familyName);
1704
1705	QtFontFamily *f = d->family(f: familyName);
1706	if (!f) return bitmapScalable;
1707
1708	QtFontStyle::Key styleKey(style);
1709	for (int j = 0; j < f->count; j++) {
1710	QtFontFoundry *foundry = f->foundries[j];
1711	if (foundryName.isEmpty() || foundry->name.compare(s: foundryName, cs: Qt::CaseInsensitive) == 0) {
1712	for (int k = 0; k < foundry->count; k++)
1713	if ((style.isEmpty() ||
1714	foundry->styles[k]->styleName == style ||
1715	foundry->styles[k]->key == styleKey)
1716	&& foundry->styles[k]->bitmapScalable && !foundry->styles[k]->smoothScalable) {
1717	bitmapScalable = true;
1718	goto end;
1719	}
1720	}
1721	}
1722	end:
1723	return bitmapScalable;
1724	}
1725
1726
1727	/*!
1728	Returns \c true if the font that has family \a family and style \a
1729	style is smoothly scalable; otherwise returns \c false. If this
1730	function returns \c true, it's safe to scale this font to any size,
1731	and the result will always look attractive.
1732
1733	\sa isScalable(), isBitmapScalable()
1734	*/
1735	bool QFontDatabase::isSmoothlyScalable(const QString &family, const QString &style) const
1736	{
1737	bool smoothScalable = false;
1738	QString familyName, foundryName;
1739	parseFontName(name: family, foundry&: foundryName, family&: familyName);
1740
1741	QMutexLocker locker(fontDatabaseMutex());
1742
1743	QT_PREPEND_NAMESPACE(load)(familyName);
1744
1745	QtFontFamily *f = d->family(f: familyName);
1746	if (!f) {
1747	for (int i = 0; i < d->count; i++) {
1748	if (d->families[i]->matchesFamilyName(familyName)) {
1749	f = d->families[i];
1750	f->ensurePopulated();
1751	break;
1752	}
1753	}
1754	}
1755	if (!f) return smoothScalable;
1756
1757	QtFontStyle::Key styleKey(style);
1758	for (int j = 0; j < f->count; j++) {
1759	QtFontFoundry *foundry = f->foundries[j];
1760	if (foundryName.isEmpty() || foundry->name.compare(s: foundryName, cs: Qt::CaseInsensitive) == 0) {
1761	for (int k = 0; k < foundry->count; k++) {
1762	QtFontStyle *fontStyle = foundry->styles[k];
1763	smoothScalable =
1764	fontStyle->smoothScalable
1765	&& ((style.isEmpty()
1766	|| fontStyle->styleName == style
1767	|| fontStyle->key == styleKey)
1768	|| (fontStyle->styleName.isEmpty()
1769	&& style == styleStringHelper(weight: fontStyle->key.weight,
1770	style: QFont::Style(fontStyle->key.style))));
1771	if (smoothScalable)
1772	goto end;
1773	}
1774	}
1775	}
1776	end:
1777	return smoothScalable;
1778	}
1779
1780	/*!
1781	Returns \c true if the font that has family \a family and style \a
1782	style is scalable; otherwise returns \c false.
1783
1784	\sa isBitmapScalable(), isSmoothlyScalable()
1785	*/
1786	bool QFontDatabase::isScalable(const QString &family,
1787	const QString &style) const
1788	{
1789	QMutexLocker locker(fontDatabaseMutex());
1790	if (isSmoothlyScalable(family, style))
1791	return true;
1792	return isBitmapScalable(family, style);
1793	}
1794
1795
1796	/*!
1797	Returns a list of the point sizes available for the font that has
1798	family \a family and style \a styleName. The list may be empty.
1799
1800	\sa smoothSizes(), standardSizes()
1801	*/
1802	QList<int> QFontDatabase::pointSizes(const QString &family,
1803	const QString &styleName)
1804	{
1805	if (QGuiApplicationPrivate::platformIntegration()->fontDatabase()->fontsAlwaysScalable())
1806	return standardSizes();
1807
1808	bool smoothScalable = false;
1809	QString familyName, foundryName;
1810	parseFontName(name: family, foundry&: foundryName, family&: familyName);
1811
1812	QMutexLocker locker(fontDatabaseMutex());
1813
1814	QT_PREPEND_NAMESPACE(load)(familyName);
1815
1816	QList<int> sizes;
1817
1818	QtFontFamily *fam = d->family(f: familyName);
1819	if (!fam) return sizes;
1820
1821
1822	const int dpi = qt_defaultDpiY(); // embedded
1823
1824	QtFontStyle::Key styleKey(styleName);
1825	for (int j = 0; j < fam->count; j++) {
1826	QtFontFoundry *foundry = fam->foundries[j];
1827	if (foundryName.isEmpty() || foundry->name.compare(s: foundryName, cs: Qt::CaseInsensitive) == 0) {
1828	QtFontStyle *style = foundry->style(key: styleKey, styleName);
1829	if (!style) continue;
1830
1831	if (style->smoothScalable) {
1832	smoothScalable = true;
1833	goto end;
1834	}
1835	for (int l = 0; l < style->count; l++) {
1836	const QtFontSize *size = style->pixelSizes + l;
1837
1838	if (size->pixelSize != 0 && size->pixelSize != SMOOTH_SCALABLE) {
1839	const uint pointSize = qRound(d: size->pixelSize * 72.0 / dpi);
1840	if (! sizes.contains(t: pointSize))
1841	sizes.append(t: pointSize);
1842	}
1843	}
1844	}
1845	}
1846	end:
1847	if (smoothScalable)
1848	return standardSizes();
1849
1850	std::sort(first: sizes.begin(), last: sizes.end());
1851	return sizes;
1852	}
1853
1854	/*!
1855	Returns a QFont object that has family \a family, style \a style
1856	and point size \a pointSize. If no matching font could be created,
1857	a QFont object that uses the application's default font is
1858	returned.
1859	*/
1860	QFont QFontDatabase::font(const QString &family, const QString &style,
1861	int pointSize) const
1862	{
1863	QString familyName, foundryName;
1864	parseFontName(name: family, foundry&: foundryName, family&: familyName);
1865
1866	QMutexLocker locker(fontDatabaseMutex());
1867
1868	QT_PREPEND_NAMESPACE(load)(familyName);
1869
1870	QtFontFoundry allStyles(foundryName);
1871	QtFontFamily *f = d->family(f: familyName);
1872	if (!f) return QGuiApplication::font();
1873
1874	for (int j = 0; j < f->count; j++) {
1875	QtFontFoundry *foundry = f->foundries[j];
1876	if (foundryName.isEmpty() || foundry->name.compare(s: foundryName, cs: Qt::CaseInsensitive) == 0) {
1877	for (int k = 0; k < foundry->count; k++)
1878	allStyles.style(key: foundry->styles[k]->key, styleName: foundry->styles[k]->styleName, create: true);
1879	}
1880	}
1881
1882	QtFontStyle::Key styleKey(style);
1883	QtFontStyle *s = bestStyle(foundry: &allStyles, styleKey, styleName: style);
1884
1885	if (!s) // no styles found?
1886	return QGuiApplication::font();
1887
1888	QFont fnt(family, pointSize, s->key.weight);
1889	fnt.setStyle((QFont::Style)s->key.style);
1890	if (!s->styleName.isEmpty())
1891	fnt.setStyleName(s->styleName);
1892	return fnt;
1893	}
1894
1895
1896	/*!
1897	Returns the point sizes of a font that has family \a family and
1898	style \a styleName that will look attractive. The list may be empty.
1899	For non-scalable fonts and bitmap scalable fonts, this function
1900	is equivalent to pointSizes().
1901
1902	\sa pointSizes(), standardSizes()
1903	*/
1904	QList<int> QFontDatabase::smoothSizes(const QString &family,
1905	const QString &styleName)
1906	{
1907	if (QGuiApplicationPrivate::platformIntegration()->fontDatabase()->fontsAlwaysScalable())
1908	return standardSizes();
1909
1910	bool smoothScalable = false;
1911	QString familyName, foundryName;
1912	parseFontName(name: family, foundry&: foundryName, family&: familyName);
1913
1914	QMutexLocker locker(fontDatabaseMutex());
1915
1916	QT_PREPEND_NAMESPACE(load)(familyName);
1917
1918	QList<int> sizes;
1919
1920	QtFontFamily *fam = d->family(f: familyName);
1921	if (!fam)
1922	return sizes;
1923
1924	const int dpi = qt_defaultDpiY(); // embedded
1925
1926	QtFontStyle::Key styleKey(styleName);
1927	for (int j = 0; j < fam->count; j++) {
1928	QtFontFoundry *foundry = fam->foundries[j];
1929	if (foundryName.isEmpty() || foundry->name.compare(s: foundryName, cs: Qt::CaseInsensitive) == 0) {
1930	QtFontStyle *style = foundry->style(key: styleKey, styleName);
1931	if (!style) continue;
1932
1933	if (style->smoothScalable) {
1934	smoothScalable = true;
1935	goto end;
1936	}
1937	for (int l = 0; l < style->count; l++) {
1938	const QtFontSize *size = style->pixelSizes + l;
1939
1940	if (size->pixelSize != 0 && size->pixelSize != SMOOTH_SCALABLE) {
1941	const uint pointSize = qRound(d: size->pixelSize * 72.0 / dpi);
1942	if (! sizes.contains(t: pointSize))
1943	sizes.append(t: pointSize);
1944	}
1945	}
1946	}
1947	}
1948	end:
1949	if (smoothScalable)
1950	return QFontDatabase::standardSizes();
1951
1952	std::sort(first: sizes.begin(), last: sizes.end());
1953	return sizes;
1954	}
1955
1956
1957	/*!
1958	Returns a list of standard font sizes.
1959
1960	\sa smoothSizes(), pointSizes()
1961	*/
1962	QList<int> QFontDatabase::standardSizes()
1963	{
1964	return QGuiApplicationPrivate::platformIntegration()->fontDatabase()->standardSizes();
1965	}
1966
1967
1968	/*!
1969	Returns \c true if the font that has family \a family and style \a
1970	style is italic; otherwise returns \c false.
1971
1972	\sa weight(), bold()
1973	*/
1974	bool QFontDatabase::italic(const QString &family, const QString &style) const
1975	{
1976	QString familyName, foundryName;
1977	parseFontName(name: family, foundry&: foundryName, family&: familyName);
1978
1979	QMutexLocker locker(fontDatabaseMutex());
1980
1981	QT_PREPEND_NAMESPACE(load)(familyName);
1982
1983	QtFontFoundry allStyles(foundryName);
1984	QtFontFamily *f = d->family(f: familyName);
1985	if (!f) return false;
1986
1987	for (int j = 0; j < f->count; j++) {
1988	QtFontFoundry *foundry = f->foundries[j];
1989	if (foundryName.isEmpty() || foundry->name.compare(s: foundryName, cs: Qt::CaseInsensitive) == 0) {
1990	for (int k = 0; k < foundry->count; k++)
1991	allStyles.style(key: foundry->styles[k]->key, styleName: foundry->styles[k]->styleName, create: true);
1992	}
1993	}
1994
1995	QtFontStyle::Key styleKey(style);
1996	QtFontStyle *s = allStyles.style(key: styleKey, styleName: style);
1997	return s && s->key.style == QFont::StyleItalic;
1998	}
1999
2000
2001	/*!
2002	Returns \c true if the font that has family \a family and style \a
2003	style is bold; otherwise returns \c false.
2004
2005	\sa italic(), weight()
2006	*/
2007	bool QFontDatabase::bold(const QString &family,
2008	const QString &style) const
2009	{
2010	QString familyName, foundryName;
2011	parseFontName(name: family, foundry&: foundryName, family&: familyName);
2012
2013	QMutexLocker locker(fontDatabaseMutex());
2014
2015	QT_PREPEND_NAMESPACE(load)(familyName);
2016
2017	QtFontFoundry allStyles(foundryName);
2018	QtFontFamily *f = d->family(f: familyName);
2019	if (!f) return false;
2020
2021	for (int j = 0; j < f->count; j++) {
2022	QtFontFoundry *foundry = f->foundries[j];
2023	if (foundryName.isEmpty() ||
2024	foundry->name.compare(s: foundryName, cs: Qt::CaseInsensitive) == 0) {
2025	for (int k = 0; k < foundry->count; k++)
2026	allStyles.style(key: foundry->styles[k]->key, styleName: foundry->styles[k]->styleName, create: true);
2027	}
2028	}
2029
2030	QtFontStyle::Key styleKey(style);
2031	QtFontStyle *s = allStyles.style(key: styleKey, styleName: style);
2032	return s && s->key.weight >= QFont::Bold;
2033	}
2034
2035
2036	/*!
2037	Returns the weight of the font that has family \a family and style
2038	\a style. If there is no such family and style combination,
2039	returns -1.
2040
2041	\sa italic(), bold()
2042	*/
2043	int QFontDatabase::weight(const QString &family,
2044	const QString &style) const
2045	{
2046	QString familyName, foundryName;
2047	parseFontName(name: family, foundry&: foundryName, family&: familyName);
2048
2049	QMutexLocker locker(fontDatabaseMutex());
2050
2051	QT_PREPEND_NAMESPACE(load)(familyName);
2052
2053	QtFontFoundry allStyles(foundryName);
2054	QtFontFamily *f = d->family(f: familyName);
2055	if (!f) return -1;
2056
2057	for (int j = 0; j < f->count; j++) {
2058	QtFontFoundry *foundry = f->foundries[j];
2059	if (foundryName.isEmpty() ||
2060	foundry->name.compare(s: foundryName, cs: Qt::CaseInsensitive) == 0) {
2061	for (int k = 0; k < foundry->count; k++)
2062	allStyles.style(key: foundry->styles[k]->key, styleName: foundry->styles[k]->styleName, create: true);
2063	}
2064	}
2065
2066	QtFontStyle::Key styleKey(style);
2067	QtFontStyle *s = allStyles.style(key: styleKey, styleName: style);
2068	return s ? s->key.weight : -1;
2069	}
2070
2071
2072	/*! \internal */
2073	bool QFontDatabase::hasFamily(const QString &family) const
2074	{
2075	QString parsedFamily, foundry;
2076	parseFontName(name: family, foundry, family&: parsedFamily);
2077	const QString familyAlias = resolveFontFamilyAlias(family: parsedFamily);
2078	return families().contains(str: familyAlias, cs: Qt::CaseInsensitive);
2079	}
2080
2081
2082	/*!
2083	\since 5.5
2084
2085	Returns \c true if and only if the \a family font family is private.
2086
2087	This happens, for instance, on \macos and iOS, where the system UI fonts are not
2088	accessible to the user. For completeness, QFontDatabase::families() returns all
2089	font families, including the private ones. You should use this function if you
2090	are developing a font selection control in order to keep private fonts hidden.
2091
2092	\sa families()
2093	*/
2094	bool QFontDatabase::isPrivateFamily(const QString &family) const
2095	{
2096	return QGuiApplicationPrivate::platformIntegration()->fontDatabase()->isPrivateFontFamily(family);
2097	}
2098
2099
2100	/*!
2101	Returns the names the \a writingSystem (e.g. for displaying to the
2102	user in a dialog).
2103	*/
2104	QString QFontDatabase::writingSystemName(WritingSystem writingSystem)
2105	{
2106	const char *name = nullptr;
2107	switch (writingSystem) {
2108	case Any:
2109	name = QT_TRANSLATE_NOOP("QFontDatabase", "Any");
2110	break;
2111	case Latin:
2112	name = QT_TRANSLATE_NOOP("QFontDatabase", "Latin");
2113	break;
2114	case Greek:
2115	name = QT_TRANSLATE_NOOP("QFontDatabase", "Greek");
2116	break;
2117	case Cyrillic:
2118	name = QT_TRANSLATE_NOOP("QFontDatabase", "Cyrillic");
2119	break;
2120	case Armenian:
2121	name = QT_TRANSLATE_NOOP("QFontDatabase", "Armenian");
2122	break;
2123	case Hebrew:
2124	name = QT_TRANSLATE_NOOP("QFontDatabase", "Hebrew");
2125	break;
2126	case Arabic:
2127	name = QT_TRANSLATE_NOOP("QFontDatabase", "Arabic");
2128	break;
2129	case Syriac:
2130	name = QT_TRANSLATE_NOOP("QFontDatabase", "Syriac");
2131	break;
2132	case Thaana:
2133	name = QT_TRANSLATE_NOOP("QFontDatabase", "Thaana");
2134	break;
2135	case Devanagari:
2136	name = QT_TRANSLATE_NOOP("QFontDatabase", "Devanagari");
2137	break;
2138	case Bengali:
2139	name = QT_TRANSLATE_NOOP("QFontDatabase", "Bengali");
2140	break;
2141	case Gurmukhi:
2142	name = QT_TRANSLATE_NOOP("QFontDatabase", "Gurmukhi");
2143	break;
2144	case Gujarati:
2145	name = QT_TRANSLATE_NOOP("QFontDatabase", "Gujarati");
2146	break;
2147	case Oriya:
2148	name = QT_TRANSLATE_NOOP("QFontDatabase", "Oriya");
2149	break;
2150	case Tamil:
2151	name = QT_TRANSLATE_NOOP("QFontDatabase", "Tamil");
2152	break;
2153	case Telugu:
2154	name = QT_TRANSLATE_NOOP("QFontDatabase", "Telugu");
2155	break;
2156	case Kannada:
2157	name = QT_TRANSLATE_NOOP("QFontDatabase", "Kannada");
2158	break;
2159	case Malayalam:
2160	name = QT_TRANSLATE_NOOP("QFontDatabase", "Malayalam");
2161	break;
2162	case Sinhala:
2163	name = QT_TRANSLATE_NOOP("QFontDatabase", "Sinhala");
2164	break;
2165	case Thai:
2166	name = QT_TRANSLATE_NOOP("QFontDatabase", "Thai");
2167	break;
2168	case Lao:
2169	name = QT_TRANSLATE_NOOP("QFontDatabase", "Lao");
2170	break;
2171	case Tibetan:
2172	name = QT_TRANSLATE_NOOP("QFontDatabase", "Tibetan");
2173	break;
2174	case Myanmar:
2175	name = QT_TRANSLATE_NOOP("QFontDatabase", "Myanmar");
2176	break;
2177	case Georgian:
2178	name = QT_TRANSLATE_NOOP("QFontDatabase", "Georgian");
2179	break;
2180	case Khmer:
2181	name = QT_TRANSLATE_NOOP("QFontDatabase", "Khmer");
2182	break;
2183	case SimplifiedChinese:
2184	name = QT_TRANSLATE_NOOP("QFontDatabase", "Simplified Chinese");
2185	break;
2186	case TraditionalChinese:
2187	name = QT_TRANSLATE_NOOP("QFontDatabase", "Traditional Chinese");
2188	break;
2189	case Japanese:
2190	name = QT_TRANSLATE_NOOP("QFontDatabase", "Japanese");
2191	break;
2192	case Korean:
2193	name = QT_TRANSLATE_NOOP("QFontDatabase", "Korean");
2194	break;
2195	case Vietnamese:
2196	name = QT_TRANSLATE_NOOP("QFontDatabase", "Vietnamese");
2197	break;
2198	case Symbol:
2199	name = QT_TRANSLATE_NOOP("QFontDatabase", "Symbol");
2200	break;
2201	case Ogham:
2202	name = QT_TRANSLATE_NOOP("QFontDatabase", "Ogham");
2203	break;
2204	case Runic:
2205	name = QT_TRANSLATE_NOOP("QFontDatabase", "Runic");
2206	break;
2207	case Nko:
2208	name = QT_TRANSLATE_NOOP("QFontDatabase", "N'Ko");
2209	break;
2210	default:
2211	Q_ASSERT_X(false, "QFontDatabase::writingSystemName", "invalid 'writingSystem' parameter");
2212	break;
2213	}
2214	return QCoreApplication::translate(context: "QFontDatabase", key: name);
2215	}
2216
2217
2218	/*!
2219	Returns a string with sample characters from \a writingSystem.
2220	*/
2221	QString QFontDatabase::writingSystemSample(WritingSystem writingSystem)
2222	{
2223	QString sample;
2224	switch (writingSystem) {
2225	case Any:
2226	case Symbol:
2227	// show only ascii characters
2228	sample += QLatin1String("AaBbzZ");
2229	break;
2230	case Latin:
2231	// This is cheating... we only show latin-1 characters so that we don't
2232	// end up loading lots of fonts - at least on X11...
2233	sample = QLatin1String("Aa");
2234	sample += QChar(0x00C3);
2235	sample += QChar(0x00E1);
2236	sample += QLatin1String("Zz");
2237	break;
2238	case Greek:
2239	sample += QChar(0x0393);
2240	sample += QChar(0x03B1);
2241	sample += QChar(0x03A9);
2242	sample += QChar(0x03C9);
2243	break;
2244	case Cyrillic:
2245	sample += QChar(0x0414);
2246	sample += QChar(0x0434);
2247	sample += QChar(0x0436);
2248	sample += QChar(0x044f);
2249	break;
2250	case Armenian:
2251	sample += QChar(0x053f);
2252	sample += QChar(0x054f);
2253	sample += QChar(0x056f);
2254	sample += QChar(0x057f);
2255	break;
2256	case Hebrew:
2257	sample += QChar(0x05D0);
2258	sample += QChar(0x05D1);
2259	sample += QChar(0x05D2);
2260	sample += QChar(0x05D3);
2261	break;
2262	case Arabic:
2263	sample += QChar(0x0623);
2264	sample += QChar(0x0628);
2265	sample += QChar(0x062C);
2266	sample += QChar(0x062F);
2267	sample += QChar(0x064A);
2268	sample += QChar(0x0629);
2269	sample += QChar(0x0020);
2270	sample += QChar(0x0639);
2271	sample += QChar(0x0631);
2272	sample += QChar(0x0628);
2273	sample += QChar(0x064A);
2274	sample += QChar(0x0629);
2275	break;
2276	case Syriac:
2277	sample += QChar(0x0715);
2278	sample += QChar(0x0725);
2279	sample += QChar(0x0716);
2280	sample += QChar(0x0726);
2281	break;
2282	case Thaana:
2283	sample += QChar(0x0784);
2284	sample += QChar(0x0794);
2285	sample += QChar(0x078c);
2286	sample += QChar(0x078d);
2287	break;
2288	case Devanagari:
2289	sample += QChar(0x0905);
2290	sample += QChar(0x0915);
2291	sample += QChar(0x0925);
2292	sample += QChar(0x0935);
2293	break;
2294	case Bengali:
2295	sample += QChar(0x0986);
2296	sample += QChar(0x0996);
2297	sample += QChar(0x09a6);
2298	sample += QChar(0x09b6);
2299	break;
2300	case Gurmukhi:
2301	sample += QChar(0x0a05);
2302	sample += QChar(0x0a15);
2303	sample += QChar(0x0a25);
2304	sample += QChar(0x0a35);
2305	break;
2306	case Gujarati:
2307	sample += QChar(0x0a85);
2308	sample += QChar(0x0a95);
2309	sample += QChar(0x0aa5);
2310	sample += QChar(0x0ab5);
2311	break;
2312	case Oriya:
2313	sample += QChar(0x0b06);
2314	sample += QChar(0x0b16);
2315	sample += QChar(0x0b2b);
2316	sample += QChar(0x0b36);
2317	break;
2318	case Tamil:
2319	sample += QChar(0x0b89);
2320	sample += QChar(0x0b99);
2321	sample += QChar(0x0ba9);
2322	sample += QChar(0x0bb9);
2323	break;
2324	case Telugu:
2325	sample += QChar(0x0c05);
2326	sample += QChar(0x0c15);
2327	sample += QChar(0x0c25);
2328	sample += QChar(0x0c35);
2329	break;
2330	case Kannada:
2331	sample += QChar(0x0c85);
2332	sample += QChar(0x0c95);
2333	sample += QChar(0x0ca5);
2334	sample += QChar(0x0cb5);
2335	break;
2336	case Malayalam:
2337	sample += QChar(0x0d05);
2338	sample += QChar(0x0d15);
2339	sample += QChar(0x0d25);
2340	sample += QChar(0x0d35);
2341	break;
2342	case Sinhala:
2343	sample += QChar(0x0d90);
2344	sample += QChar(0x0da0);
2345	sample += QChar(0x0db0);
2346	sample += QChar(0x0dc0);
2347	break;
2348	case Thai:
2349	sample += QChar(0x0e02);
2350	sample += QChar(0x0e12);
2351	sample += QChar(0x0e22);
2352	sample += QChar(0x0e32);
2353	break;
2354	case Lao:
2355	sample += QChar(0x0e8d);
2356	sample += QChar(0x0e9d);
2357	sample += QChar(0x0ead);
2358	sample += QChar(0x0ebd);
2359	break;
2360	case Tibetan:
2361	sample += QChar(0x0f00);
2362	sample += QChar(0x0f01);
2363	sample += QChar(0x0f02);
2364	sample += QChar(0x0f03);
2365	break;
2366	case Myanmar:
2367	sample += QChar(0x1000);
2368	sample += QChar(0x1001);
2369	sample += QChar(0x1002);
2370	sample += QChar(0x1003);
2371	break;
2372	case Georgian:
2373	sample += QChar(0x10a0);
2374	sample += QChar(0x10b0);
2375	sample += QChar(0x10c0);
2376	sample += QChar(0x10d0);
2377	break;
2378	case Khmer:
2379	sample += QChar(0x1780);
2380	sample += QChar(0x1790);
2381	sample += QChar(0x17b0);
2382	sample += QChar(0x17c0);
2383	break;
2384	case SimplifiedChinese:
2385	sample += QChar(0x4e2d);
2386	sample += QChar(0x6587);
2387	sample += QChar(0x8303);
2388	sample += QChar(0x4f8b);
2389	break;
2390	case TraditionalChinese:
2391	sample += QChar(0x4e2d);
2392	sample += QChar(0x6587);
2393	sample += QChar(0x7bc4);
2394	sample += QChar(0x4f8b);
2395	break;
2396	case Japanese:
2397	sample += QChar(0x30b5);
2398	sample += QChar(0x30f3);
2399	sample += QChar(0x30d7);
2400	sample += QChar(0x30eb);
2401	sample += QChar(0x3067);
2402	sample += QChar(0x3059);
2403	break;
2404	case Korean:
2405	sample += QChar(0xac00);
2406	sample += QChar(0xac11);
2407	sample += QChar(0xac1a);
2408	sample += QChar(0xac2f);
2409	break;
2410	case Vietnamese:
2411	{
2412	static const char vietnameseUtf8[] = {
2413	char(0xef), char(0xbb), char(0xbf), char(0xe1), char(0xbb), char(0x97),
2414	char(0xe1), char(0xbb), char(0x99),
2415	char(0xe1), char(0xbb), char(0x91),
2416	char(0xe1), char(0xbb), char(0x93),
2417	};
2418	sample += QString::fromUtf8(str: vietnameseUtf8, size: sizeof(vietnameseUtf8));
2419	break;
2420	}
2421	case Ogham:
2422	sample += QChar(0x1681);
2423	sample += QChar(0x1682);
2424	sample += QChar(0x1683);
2425	sample += QChar(0x1684);
2426	break;
2427	case Runic:
2428	sample += QChar(0x16a0);
2429	sample += QChar(0x16a1);
2430	sample += QChar(0x16a2);
2431	sample += QChar(0x16a3);
2432	break;
2433	case Nko:
2434	sample += QChar(0x7ca);
2435	sample += QChar(0x7cb);
2436	sample += QChar(0x7cc);
2437	sample += QChar(0x7cd);
2438	break;
2439	default:
2440	break;
2441	}
2442	return sample;
2443	}
2444
2445
2446	void QFontDatabase::parseFontName(const QString &name, QString &foundry, QString &family)
2447	{
2448	QT_PREPEND_NAMESPACE(parseFontName)(name, foundry, family);
2449	}
2450
2451	void QFontDatabase::createDatabase()
2452	{ initializeDb(); }
2453
2454	// used from qfontengine_ft.cpp
2455	Q_GUI_EXPORT QByteArray qt_fontdata_from_index(int index)
2456	{
2457	QMutexLocker locker(fontDatabaseMutex());
2458	return privateDb()->applicationFonts.value(i: index).data;
2459	}
2460
2461	int QFontDatabasePrivate::addAppFont(const QByteArray &fontData, const QString &fileName)
2462	{
2463	QFontDatabasePrivate::ApplicationFont font;
2464	font.data = fontData;
2465	font.fileName = fileName;
2466
2467	Q_TRACE(QFontDatabasePrivate_addAppFont, fileName);
2468
2469	int i;
2470	for (i = 0; i < applicationFonts.count(); ++i)
2471	if (applicationFonts.at(i).families.isEmpty())
2472	break;
2473	if (i >= applicationFonts.count()) {
2474	applicationFonts.append(t: ApplicationFont());
2475	i = applicationFonts.count() - 1;
2476	}
2477
2478	if (font.fileName.isEmpty() && !fontData.isEmpty())
2479	font.fileName = QLatin1String(":qmemoryfonts/") + QString::number(i);
2480
2481	bool wasEmpty = privateDb()->count == 0;
2482	registerFont(fnt: &font);
2483	if (font.families.isEmpty())
2484	return -1;
2485
2486	applicationFonts[i] = font;
2487
2488	// If the cache has not yet been populated, we need to reload the application font later
2489	if (wasEmpty)
2490	invalidate();
2491	else
2492	emit qApp->fontDatabaseChanged();
2493	return i;
2494	}
2495
2496	bool QFontDatabasePrivate::isApplicationFont(const QString &fileName)
2497	{
2498	for (int i = 0; i < applicationFonts.count(); ++i)
2499	if (applicationFonts.at(i).fileName == fileName)
2500	return true;
2501	return false;
2502	}
2503
2504	/*!
2505	\since 4.2
2506
2507	Loads the font from the file specified by \a fileName and makes it available to
2508	the application. An ID is returned that can be used to remove the font again
2509	with removeApplicationFont() or to retrieve the list of family names contained
2510	in the font.
2511
2512	//! [add-application-font-doc]
2513	The function returns -1 if the font could not be loaded.
2514
2515	Currently only TrueType fonts, TrueType font collections, and OpenType fonts are
2516	supported.
2517	//! [add-application-font-doc]
2518
2519	\sa addApplicationFontFromData(), applicationFontFamilies(), removeApplicationFont()
2520	*/
2521	int QFontDatabase::addApplicationFont(const QString &fileName)
2522	{
2523	QByteArray data;
2524	if (!QFileInfo(fileName).isNativePath()) {
2525	QFile f(fileName);
2526	if (!f.open(flags: QIODevice::ReadOnly))
2527	return -1;
2528
2529	Q_TRACE(QFontDatabase_addApplicationFont, fileName);
2530
2531	data = f.readAll();
2532	}
2533	QMutexLocker locker(fontDatabaseMutex());
2534	return privateDb()->addAppFont(fontData: data, fileName);
2535	}
2536
2537	/*!
2538	\since 4.2
2539
2540	Loads the font from binary data specified by \a fontData and makes it available to
2541	the application. An ID is returned that can be used to remove the font again
2542	with removeApplicationFont() or to retrieve the list of family names contained
2543	in the font.
2544
2545	\include qfontdatabase.cpp add-application-font-doc
2546
2547	\sa addApplicationFont(), applicationFontFamilies(), removeApplicationFont()
2548	*/
2549	int QFontDatabase::addApplicationFontFromData(const QByteArray &fontData)
2550	{
2551	QMutexLocker locker(fontDatabaseMutex());
2552	return privateDb()->addAppFont(fontData, fileName: QString() /* fileName */);
2553	}
2554
2555	/*!
2556	\since 4.2
2557
2558	Returns a list of font families for the given application font identified by
2559	\a id.
2560
2561	\sa addApplicationFont(), addApplicationFontFromData()
2562	*/
2563	QStringList QFontDatabase::applicationFontFamilies(int id)
2564	{
2565	QMutexLocker locker(fontDatabaseMutex());
2566	return privateDb()->applicationFonts.value(i: id).families;
2567	}
2568
2569	/*!
2570	\since 5.2
2571
2572	Returns the most adequate font for a given \a type case for proper integration
2573	with the system's look and feel.
2574
2575	\sa QGuiApplication::font()
2576	*/
2577
2578	QFont QFontDatabase::systemFont(QFontDatabase::SystemFont type)
2579	{
2580	const QFont *font = nullptr;
2581	if (const QPlatformTheme *theme = QGuiApplicationPrivate::platformTheme()) {
2582	switch (type) {
2583	case GeneralFont:
2584	font = theme->font(type: QPlatformTheme::SystemFont);
2585	break;
2586	case FixedFont:
2587	font = theme->font(type: QPlatformTheme::FixedFont);
2588	break;
2589	case TitleFont:
2590	font = theme->font(type: QPlatformTheme::TitleBarFont);
2591	break;
2592	case SmallestReadableFont:
2593	font = theme->font(type: QPlatformTheme::MiniFont);
2594	break;
2595	}
2596	}
2597
2598	if (font)
2599	return *font;
2600	else if (QPlatformIntegration *integration = QGuiApplicationPrivate::platformIntegration())
2601	return integration->fontDatabase()->defaultFont();
2602	else
2603	return QFont();
2604	}
2605
2606	/*!
2607	\fn bool QFontDatabase::removeApplicationFont(int id)
2608	\since 4.2
2609
2610	Removes the previously loaded application font identified by \a
2611	id. Returns \c true if unloading of the font succeeded; otherwise
2612	returns \c false.
2613
2614	\sa removeAllApplicationFonts(), addApplicationFont(),
2615	addApplicationFontFromData()
2616	*/
2617	bool QFontDatabase::removeApplicationFont(int handle)
2618	{
2619	QMutexLocker locker(fontDatabaseMutex());
2620
2621	QFontDatabasePrivate *db = privateDb();
2622	if (handle < 0 || handle >= db->applicationFonts.count())
2623	return false;
2624
2625	db->applicationFonts[handle] = QFontDatabasePrivate::ApplicationFont();
2626
2627	db->invalidate();
2628	return true;
2629	}
2630
2631	/*!
2632	\fn bool QFontDatabase::removeAllApplicationFonts()
2633	\since 4.2
2634
2635	Removes all application-local fonts previously added using addApplicationFont()
2636	and addApplicationFontFromData().
2637
2638	Returns \c true if unloading of the fonts succeeded; otherwise
2639	returns \c false.
2640
2641	\sa removeApplicationFont(), addApplicationFont(), addApplicationFontFromData()
2642	*/
2643	bool QFontDatabase::removeAllApplicationFonts()
2644	{
2645	QMutexLocker locker(fontDatabaseMutex());
2646
2647	QFontDatabasePrivate *db = privateDb();
2648	if (!db || db->applicationFonts.isEmpty())
2649	return false;
2650
2651	db->applicationFonts.clear();
2652	db->invalidate();
2653	return true;
2654	}
2655
2656	/*!
2657	\fn bool QFontDatabase::supportsThreadedFontRendering()
2658	\since 4.4
2659	\deprecated
2660
2661	Returns \c true if font rendering is supported outside the GUI
2662	thread, false otherwise. In other words, a return value of false
2663	means that all QPainter::drawText() calls outside the GUI thread
2664	will not produce readable output.
2665
2666	As of 5.0, always returns \c true.
2667
2668	\sa {Thread-Support in Qt Modules#Painting In Threads}{Painting In Threads}
2669	*/
2670	#if QT_DEPRECATED_SINCE(5, 2)
2671	bool QFontDatabase::supportsThreadedFontRendering()
2672	{
2673	return true;
2674	}
2675	#endif
2676
2677	/*!
2678	\internal
2679	*/
2680	QFontEngine *QFontDatabase::findFont(const QFontDef &request,
2681	int script,
2682	bool preferScriptOverFamily)
2683	{
2684	QMutexLocker locker(fontDatabaseMutex());
2685
2686	if (!privateDb()->count)
2687	initializeDb();
2688
2689	QFontEngine *engine;
2690
2691	#if defined(QT_BUILD_INTERNAL)
2692	// For testing purpose only, emulates an exact-matching monospace font
2693	if (qt_enable_test_font && request.family == QLatin1String("__Qt__Box__Engine__")) {
2694	engine = new QTestFontEngine(request.pixelSize);
2695	engine->fontDef = request;
2696	return engine;
2697	}
2698	#endif
2699
2700	QFontCache *fontCache = QFontCache::instance();
2701
2702	// Until we specifically asked not to, try looking for Multi font engine
2703	// first, the last '1' indicates that we want Multi font engine instead
2704	// of single ones
2705	bool multi = !(request.styleStrategy & QFont::NoFontMerging);
2706	QFontCache::Key key(request, script, multi ? 1 : 0);
2707	engine = fontCache->findEngine(key);
2708	if (engine) {
2709	qCDebug(lcFontMatch, "Cache hit level 1");
2710	return engine;
2711	}
2712
2713	if (request.pixelSize > 0xffff) {
2714	// Stop absurd requests reaching the engines; pixel size is assumed to fit ushort
2715	qCDebug(lcFontMatch, "Rejecting request for pixel size %g2, returning box engine", double(request.pixelSize));
2716	return new QFontEngineBox(32); // not request.pixelSize, to avoid overflow/DOS
2717	}
2718
2719	QString family_name, foundry_name;
2720	const QString requestFamily = request.families.size() > 0 ? request.families.at(i: 0) : request.family;
2721	parseFontName(name: requestFamily, foundry&: foundry_name, family&: family_name);
2722	QtFontDesc desc;
2723	QList<int> blackListed;
2724	unsigned int score = UINT_MAX;
2725	int index = match(script: multi ? QChar::Script_Common : script, request, family_name, foundry_name, desc: &desc, blacklistedFamilies: blackListed, resultingScore: &score);
2726	if (score > 0 && QGuiApplicationPrivate::platformIntegration()->fontDatabase()->populateFamilyAliases(missingFamily: family_name)) {
2727	// We populated familiy aliases (e.g. localized families), so try again
2728	index = match(script: multi ? QChar::Script_Common : script, request, family_name, foundry_name, desc: &desc, blacklistedFamilies: blackListed);
2729	}
2730
2731	// If we do not find a match and NoFontMerging is set, use the requested font even if it does
2732	// not support the script.
2733	//
2734	// (we do this at the end to prefer foundries that support the script if they exist)
2735	if (index < 0 && !multi && !preferScriptOverFamily)
2736	index = match(script: QChar::Script_Common, request, family_name, foundry_name, desc: &desc, blacklistedFamilies: blackListed);
2737
2738	if (index >= 0) {
2739	QFontDef fontDef = request;
2740
2741	// Don't pass empty family names to the platform font database, since it will then invoke its own matching
2742	// and we will be out of sync with the matched font.
2743	if (fontDef.families.isEmpty() && fontDef.family.isEmpty())
2744	fontDef.families = QStringList(desc.family->name);
2745
2746	engine = loadEngine(script, request: fontDef, family: desc.family, foundry: desc.foundry, style: desc.style, size: desc.size);
2747
2748	if (engine)
2749	initFontDef(desc, request, fontDef: &engine->fontDef, multi);
2750	else
2751	blackListed.append(t: index);
2752	} else {
2753	qCDebug(lcFontMatch, " NO MATCH FOUND\n");
2754	}
2755
2756	if (!engine) {
2757	if (!requestFamily.isEmpty()) {
2758	QFont::StyleHint styleHint = QFont::StyleHint(request.styleHint);
2759	if (styleHint == QFont::AnyStyle && request.fixedPitch)
2760	styleHint = QFont::TypeWriter;
2761
2762	QStringList fallbacks = request.fallBackFamilies
2763	+ fallbacksForFamily(family: requestFamily,
2764	style: QFont::Style(request.style),
2765	styleHint,
2766	script: QChar::Script(script));
2767	if (script > QChar::Script_Common)
2768	fallbacks += QString(); // Find the first font matching the specified script.
2769
2770	for (int i = 0; !engine && i < fallbacks.size(); i++) {
2771	QFontDef def = request;
2772	def.families.clear();
2773	def.family = fallbacks.at(i);
2774	QFontCache::Key key(def, script, multi ? 1 : 0);
2775	engine = fontCache->findEngine(key);
2776	if (!engine) {
2777	QtFontDesc desc;
2778	do {
2779	index = match(script: multi ? QChar::Script_Common : script, request: def, family_name: def.family, foundry_name: QLatin1String(""), desc: &desc, blacklistedFamilies: blackListed);
2780	if (index >= 0) {
2781	QFontDef loadDef = def;
2782	if (loadDef.families.isEmpty() && loadDef.family.isEmpty())
2783	loadDef.family = desc.family->name;
2784	engine = loadEngine(script, request: loadDef, family: desc.family, foundry: desc.foundry, style: desc.style, size: desc.size);
2785	if (engine)
2786	initFontDef(desc, request: loadDef, fontDef: &engine->fontDef, multi);
2787	else
2788	blackListed.append(t: index);
2789	}
2790	} while (index >= 0 && !engine);
2791	}
2792	}
2793	}
2794
2795	if (!engine)
2796	engine = new QFontEngineBox(request.pixelSize);
2797
2798	qCDebug(lcFontMatch, "returning box engine");
2799	}
2800
2801	return engine;
2802	}
2803
2804	void QFontDatabase::load(const QFontPrivate *d, int script)
2805	{
2806	QFontDef req = d->request;
2807
2808	if (req.pixelSize == -1) {
2809	req.pixelSize = std::floor(x: ((req.pointSize * d->dpi) / 72) * 100 + 0.5) / 100;
2810	req.pixelSize = qRound(d: req.pixelSize);
2811	}
2812	if (req.pointSize < 0)
2813	req.pointSize = req.pixelSize*72.0/d->dpi;
2814
2815	// respect the fallback families that might be passed through the request
2816	const QStringList fallBackFamilies = familyList(req);
2817
2818	if (!d->engineData) {
2819	QFontCache *fontCache = QFontCache::instance();
2820	// look for the requested font in the engine data cache
2821	// note: fallBackFamilies are not respected in the EngineData cache key;
2822	// join them with the primary selection family to avoid cache misses
2823	if (!d->request.family.isEmpty())
2824	req.family = fallBackFamilies.join(sep: QLatin1Char(','));
2825	if (!d->request.families.isEmpty())
2826	req.families = fallBackFamilies;
2827
2828	d->engineData = fontCache->findEngineData(def: req);
2829	if (!d->engineData) {
2830	// create a new one
2831	d->engineData = new QFontEngineData;
2832	fontCache->insertEngineData(def: req, engineData: d->engineData);
2833	}
2834	d->engineData->ref.ref();
2835	}
2836
2837	// the cached engineData could have already loaded the engine we want
2838	if (d->engineData->engines[script])
2839	return;
2840
2841	QFontEngine *fe = nullptr;
2842
2843	Q_TRACE(QFontDatabase_load, req.family, req.pointSize);
2844
2845	req.fallBackFamilies = fallBackFamilies;
2846	if (!req.fallBackFamilies.isEmpty())
2847	req.families = QStringList(req.fallBackFamilies.takeFirst());
2848
2849	// list of families to try
2850	QStringList family_list;
2851
2852	if (!req.families.isEmpty()) {
2853	// Add primary selection
2854	family_list << req.families.at(i: 0);
2855
2856	// add the default family
2857	QString defaultFamily = QGuiApplication::font().family();
2858	if (! family_list.contains(str: defaultFamily))
2859	family_list << defaultFamily;
2860
2861	}
2862
2863	// null family means find the first font matching the specified script
2864	family_list << QString();
2865
2866	QStringList::ConstIterator it = family_list.constBegin(), end = family_list.constEnd();
2867	for (; !fe && it != end; ++it) {
2868	req.families = QStringList(*it);
2869
2870	fe = QFontDatabase::findFont(request: req, script);
2871	if (fe) {
2872	if (fe->type() == QFontEngine::Box && !req.families.at(i: 0).isEmpty()) {
2873	if (fe->ref.loadRelaxed() == 0)
2874	delete fe;
2875	fe = nullptr;
2876	} else {
2877	if (d->dpi > 0)
2878	fe->fontDef.pointSize = qreal(double((fe->fontDef.pixelSize * 72) / d->dpi));
2879	}
2880	}
2881
2882	// No need to check requested fallback families again
2883	req.fallBackFamilies.clear();
2884	}
2885
2886	Q_ASSERT(fe);
2887	if (fe->symbol || (d->request.styleStrategy & QFont::NoFontMerging)) {
2888	for (int i = 0; i < QChar::ScriptCount; ++i) {
2889	if (!d->engineData->engines[i]) {
2890	d->engineData->engines[i] = fe;
2891	fe->ref.ref();
2892	}
2893	}
2894	} else {
2895	d->engineData->engines[script] = fe;
2896	fe->ref.ref();
2897	}
2898	}
2899
2900	QString QFontDatabase::resolveFontFamilyAlias(const QString &family)
2901	{
2902	return QGuiApplicationPrivate::platformIntegration()->fontDatabase()->resolveFontFamilyAlias(family);
2903	}
2904
2905	Q_GUI_EXPORT QStringList qt_sort_families_by_writing_system(QChar::Script script, const QStringList &families)
2906	{
2907	size_t writingSystem = std::find(first: scriptForWritingSystem,
2908	last: scriptForWritingSystem + QFontDatabase::WritingSystemsCount,
2909	val: script) - scriptForWritingSystem;
2910	if (writingSystem == QFontDatabase::Any
2911	|| writingSystem >= QFontDatabase::WritingSystemsCount) {
2912	return families;
2913	}
2914
2915	QFontDatabasePrivate *db = privateDb();
2916	QMultiMap<uint, QString> supported;
2917	for (int i = 0; i < families.size(); ++i) {
2918	const QString &family = families.at(i);
2919
2920	QtFontFamily *testFamily = nullptr;
2921	for (int x = 0; x < db->count; ++x) {
2922	if (Q_UNLIKELY(matchFamilyName(family, db->families[x]))) {
2923	testFamily = db->families[x];
2924	testFamily->ensurePopulated();
2925	break;
2926	}
2927	}
2928
2929	uint order = i;
2930	if (testFamily == nullptr || !familySupportsWritingSystem(family: testFamily, writingSystem))
2931	order |= 1u << 31;
2932
2933	supported.insert(akey: order, avalue: family);
2934	}
2935
2936	return supported.values();
2937	}
2938
2939	QT_END_NAMESPACE
2940
2941