Revision control
Copy as Markdown
// 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 <QtCore/qloggingcategory.h>
#include <QtGui/qfontdatabase.h>
#include <QtCore/private/qglobal_p.h>
QT_BEGIN_NAMESPACE
Q_DECLARE_LOGGING_CATEGORY(lcFontDb)
Q_DECLARE_LOGGING_CATEGORY(lcFontMatch)
struct QtFontDesc;
struct QtFontFallbacksCacheKey
{
QString family;
QFont::Style style;
QFont::StyleHint styleHint;
int 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::QHashCombineWithSeed hash(seed);
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;
enum StyleRetrievalFlags : quint8 {
NoRetrievalFlags = 0,
AddWhenMissing = 1,
MatchAllProperties = 2,
AllRetrievalFlags = 3,
};
QtFontStyle *style(const QtFontStyle::Key &,
const QString & = QString(),
StyleRetrievalFlags flags = NoRetrievalFlags);
};
struct Q_GUI_EXPORT QtFontFamily
{
enum WritingSystemStatus {
Unknown = 0,
Supported = 1,
UnsupportedFT = 2,
Unsupported = UnsupportedFT
};
QtFontFamily(const QString &n)
:
populated(false),
fixedPitch(false),
colorFont(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;
bool colorFont : 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
};
// Expands QChar::Script by adding a special "script" for emoji sequences
enum ExtendedScript {
Script_Common = QChar::Script_Common,
Script_Latin = QChar::Script_Latin,
Script_Emoji = QChar::ScriptCount,
ScriptCount
};
QtFontFamily *family(const QString &f, FamilyRequestFlags flags = EnsurePopulated);
int count;
QtFontFamily **families;
bool populated = false;
QHash<ExtendedScript, QStringList> applicationFallbackFontFamiliesHash;
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);
void setApplicationFallbackFontFamilies(ExtendedScript script, const QStringList &familyNames);
QStringList applicationFallbackFontFamilies(ExtendedScript script);
bool removeApplicationFallbackFontFamily(ExtendedScript script, const QString &familyName);
void addApplicationFallbackFontFamily(ExtendedScript script, const QString &familyName);
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 /* QFontDatabasePrivate::ExtendedScript */,
bool preferScriptOverFamily = false);
static void load(const QFontPrivate *d, int script /* QFontDatabasePrivate::ExtendedScript */);
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