diff options
Diffstat (limited to 'src/gui/text/qfontdatabase_p.h')
| -rw-r--r-- | src/gui/text/qfontdatabase_p.h | 270 |
1 files changed, 270 insertions, 0 deletions
diff --git a/src/gui/text/qfontdatabase_p.h b/src/gui/text/qfontdatabase_p.h new file mode 100644 index 0000000000..38e1b4ad20 --- /dev/null +++ b/src/gui/text/qfontdatabase_p.h @@ -0,0 +1,270 @@ +// Copyright (C) 2020 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#ifndef QFONTDATABASE_P_H +#define QFONTDATABASE_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists for the convenience +// of internal files. This header file may change from version to version +// without notice, or even be removed. +// +// We mean it. +// + +#include <QtCore/qcache.h> + +#include <QtGui/qfontdatabase.h> +#include <QtCore/private/qglobal_p.h> + +QT_BEGIN_NAMESPACE + +struct QtFontDesc; + +struct QtFontFallbacksCacheKey +{ + QString family; + QFont::Style style; + QFont::StyleHint styleHint; + QChar::Script script; +}; + +inline bool operator==(const QtFontFallbacksCacheKey &lhs, const QtFontFallbacksCacheKey &rhs) noexcept +{ + return lhs.script == rhs.script && + lhs.styleHint == rhs.styleHint && + lhs.style == rhs.style && + lhs.family == rhs.family; +} + +inline bool operator!=(const QtFontFallbacksCacheKey &lhs, const QtFontFallbacksCacheKey &rhs) noexcept +{ + return !operator==(lhs, rhs); +} + +inline size_t qHash(const QtFontFallbacksCacheKey &key, size_t seed = 0) noexcept +{ + QtPrivate::QHashCombine hash; + seed = hash(seed, key.family); + seed = hash(seed, int(key.style)); + seed = hash(seed, int(key.styleHint)); + seed = hash(seed, int(key.script)); + return seed; +} + +struct Q_GUI_EXPORT QtFontSize +{ + void *handle; + unsigned short pixelSize : 16; +}; + +struct Q_GUI_EXPORT QtFontStyle +{ + struct Key + { + Key(const QString &styleString); + + Key() + : style(QFont::StyleNormal) + , weight(QFont::Normal) + , stretch(0) + {} + + Key(const Key &o) + : style(o.style) + , weight(o.weight) + , stretch(o.stretch) + {} + + uint style : 2; + uint weight : 10; + signed int stretch : 12; + + bool operator==(const Key &other) const noexcept + { + return (style == other.style && weight == other.weight && + (stretch == 0 || other.stretch == 0 || stretch == other.stretch)); + } + + bool operator!=(const Key &other) const noexcept + { + return !operator==(other); + } + }; + + QtFontStyle(const Key &k) + : key(k) + , bitmapScalable(false) + , smoothScalable(false) + , count(0) + , pixelSizes(nullptr) + { + } + + ~QtFontStyle(); + + QtFontSize *pixelSize(unsigned short size, bool = false); + + Key key; + bool bitmapScalable : 1; + bool smoothScalable : 1; + signed int count : 30; + QtFontSize *pixelSizes; + QString styleName; + bool antialiased; +}; + +struct Q_GUI_EXPORT QtFontFoundry +{ + QtFontFoundry(const QString &n) + : name(n) + , count(0) + , styles(nullptr) + {} + + ~QtFontFoundry() + { + while (count--) + delete styles[count]; + free(styles); + } + + QString name; + int count; + QtFontStyle **styles; + QtFontStyle *style(const QtFontStyle::Key &, const QString & = QString(), bool = false); +}; + +struct Q_GUI_EXPORT QtFontFamily +{ + enum WritingSystemStatus { + Unknown = 0, + Supported = 1, + UnsupportedFT = 2, + Unsupported = UnsupportedFT + }; + + QtFontFamily(const QString &n) + : + populated(false), + fixedPitch(false), + name(n), count(0), foundries(nullptr) + { + memset(writingSystems, 0, sizeof(writingSystems)); + } + ~QtFontFamily() { + while (count--) + delete foundries[count]; + free(foundries); + } + + bool populated : 1; + bool fixedPitch : 1; + + QString name; + QStringList aliases; + int count; + QtFontFoundry **foundries; + + unsigned char writingSystems[QFontDatabase::WritingSystemsCount]; + + bool matchesFamilyName(const QString &familyName) const; + QtFontFoundry *foundry(const QString &f, bool = false); + + bool ensurePopulated(); +}; + +class Q_GUI_EXPORT QFontDatabasePrivate +{ +public: + QFontDatabasePrivate() + : count(0) + , families(nullptr) + , fallbacksCache(64) + { } + + ~QFontDatabasePrivate() { + clearFamilies(); + } + + void clearFamilies(); + + enum FamilyRequestFlags { + RequestFamily = 0, + EnsureCreated, + EnsurePopulated + }; + + QtFontFamily *family(const QString &f, FamilyRequestFlags flags = EnsurePopulated); + + int count; + QtFontFamily **families; + bool populated = false; + + QHash<QChar::Script, QStringList> applicationFallbackFontFamilies; + + QCache<QtFontFallbacksCacheKey, QStringList> fallbacksCache; + struct ApplicationFont { + QString fileName; + + // Note: The data may be implicitly shared throughout the + // font database and platform font database, so be careful + // to never detach when accessing this member! + QByteArray data; + + bool isNull() const { return fileName.isEmpty(); } + bool isPopulated() const { return !properties.isEmpty(); } + + struct Properties { + QString familyName; + QString styleName; + int weight = 0; + QFont::Style style = QFont::StyleNormal; + int stretch = QFont::Unstretched; + }; + + QList<Properties> properties; + }; + QList<ApplicationFont> applicationFonts; + int addAppFont(const QByteArray &fontData, const QString &fileName); + bool isApplicationFont(const QString &fileName); + + static QFontDatabasePrivate *instance(); + + static void parseFontName(const QString &name, QString &foundry, QString &family); + static QString resolveFontFamilyAlias(const QString &family); + static QFontEngine *findFont(const QFontDef &request, + int script /* QChar::Script */, + bool preferScriptOverFamily = false); + static void load(const QFontPrivate *d, int script /* QChar::Script */); + static QFontDatabasePrivate *ensureFontDatabase(); + + void invalidate(); + +private: + static int match(int script, const QFontDef &request, const QString &family_name, + const QString &foundry_name, QtFontDesc *desc, const QList<int> &blacklistedFamilies, + unsigned int *resultingScore = nullptr); + + static unsigned int bestFoundry(int script, unsigned int score, int styleStrategy, + const QtFontFamily *family, const QString &foundry_name, + QtFontStyle::Key styleKey, int pixelSize, char pitch, + QtFontDesc *desc, const QString &styleName = QString()); + + static QFontEngine *loadSingleEngine(int script, const QFontDef &request, + QtFontFamily *family, QtFontFoundry *foundry, + QtFontStyle *style, QtFontSize *size); + + static QFontEngine *loadEngine(int script, const QFontDef &request, + QtFontFamily *family, QtFontFoundry *foundry, + QtFontStyle *style, QtFontSize *size); + +}; +Q_DECLARE_TYPEINFO(QFontDatabasePrivate::ApplicationFont, Q_RELOCATABLE_TYPE); + +QT_END_NAMESPACE + +#endif // QFONTDATABASE_P_H |