qplatformfontdatabase.cpp

Go to the documentation of this file.

// Copyright (C) 2016 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
 
#include "qplatformfontdatabase.h"
#include <QtGui/private/qfontengine_p.h>
#include <QtGui/private/qfontdatabase_p.h>
#include <QtGui/QGuiApplication>
#include <QtGui/QScreen>
#include <qpa/qplatformscreen.h>
#include <QtCore/QLibraryInfo>
#include <QtCore/QDir>
#include <QtCore/QMetaEnum>
#include <QtCore/qendian.h>
 
#include <algorithm>
#include <iterator>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
Q_LOGGING_CATEGORY(lcQpaFonts, "qt.qpa.fonts")
 
void qt_registerFont(const QString &familyname, const QString &stylename,
                     const QString &foundryname, int weight,
                     QFont::Style style, int stretch, bool antialiased,
                     bool scalable, int pixelSize, bool fixedPitch,
                     const QSupportedWritingSystems &writingSystems, void *hanlde);
 
void qt_registerFontFamily(const QString &familyName);
void qt_registerAliasToFontFamily(const QString &familyName, const QString &alias);
bool qt_isFontFamilyPopulated(const QString &familyName);
 
void QPlatformFontDatabase::registerFont(const QString &familyname, const QString &stylename,
                                         const QString &foundryname, QFont::Weight weight,
                                         QFont::Style style, QFont::Stretch stretch, bool antialiased,
                                         bool scalable, int pixelSize, bool fixedPitch,
                                         const QSupportedWritingSystems &writingSystems, void *usrPtr)
{
    if (scalable)
        pixelSize = 0;
 
    qt_registerFont(familyname, stylename, foundryname, weight, style,
                    stretch, antialiased, scalable, pixelSize,
                    fixedPitch, writingSystems, usrPtr);
}
 
void QPlatformFontDatabase::registerFontFamily(const QString &familyName)
{
    qt_registerFontFamily(familyName);
}
 
class QWritingSystemsPrivate
{
public:
    QWritingSystemsPrivate()
        : ref(1)
        , list(QFontDatabase::WritingSystemsCount, false)
    {
    }
 
    QWritingSystemsPrivate(const QWritingSystemsPrivate *other)
        : ref(1)
        , list(other->list)
    {
    }
 
    QAtomicInt ref;
    QList<bool> list;
};
 
QSupportedWritingSystems::QSupportedWritingSystems()
{
    d = new QWritingSystemsPrivate;
}
 
QSupportedWritingSystems::QSupportedWritingSystems(const QSupportedWritingSystems &other)
{
    d = other.d;
    d->ref.ref();
}
 
QSupportedWritingSystems &QSupportedWritingSystems::operator=(const QSupportedWritingSystems &other)
{
    if (d != other.d) {
        other.d->ref.ref();
        if (!d->ref.deref())
            delete d;
        d = other.d;
    }
    return *this;
}
 
bool operator==(const QSupportedWritingSystems &lhs, const QSupportedWritingSystems &rhs)
{
    return !(lhs != rhs);
}
 
bool operator!=(const QSupportedWritingSystems &lhs, const QSupportedWritingSystems &rhs)
{
    if (lhs.d == rhs.d)
        return false;
 
    Q_ASSERT(lhs.d->list.size() == rhs.d->list.size());
    Q_ASSERT(lhs.d->list.size() == QFontDatabase::WritingSystemsCount);
    for (int i = 0; i < QFontDatabase::WritingSystemsCount; ++i) {
        if (lhs.d->list.at(i) != rhs.d->list.at(i))
            return true;
    }
 
    return false;
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug debug, const QSupportedWritingSystems &sws)
{
    const QMetaObject *mo = &QFontDatabase::staticMetaObject;
    QMetaEnum me = mo->enumerator(mo->indexOfEnumerator("WritingSystem"));
 
    QDebugStateSaver saver(debug);
    debug.nospace() << "QSupportedWritingSystems(";
    int i = sws.d->list.indexOf(true);
    while (i > 0) {
        debug << me.valueToKey(i);
        i = sws.d->list.indexOf(true, i + 1);
        if (i > 0)
            debug << ", ";
    }
    debug << ")";
    return debug;
}
#endif
 
QSupportedWritingSystems::~QSupportedWritingSystems()
{
    if (!d->ref.deref())
        delete d;
}
 
void QSupportedWritingSystems::detach()
{
    if (d->ref.loadRelaxed() != 1) {
        QWritingSystemsPrivate *newd = new QWritingSystemsPrivate(d);
        if (!d->ref.deref())
            delete d;
        d = newd;
    }
}
 
void QSupportedWritingSystems::setSupported(QFontDatabase::WritingSystem writingSystem, bool support)
{
    detach();
    d->list[writingSystem] = support;
}
 
bool QSupportedWritingSystems::supported(QFontDatabase::WritingSystem writingSystem) const
{
    return d->list.at(writingSystem);
}
 
QPlatformFontDatabase::~QPlatformFontDatabase()
{
}
 
void QPlatformFontDatabase::populateFontDatabase()
{
}
 
void QPlatformFontDatabase::populateFamily(const QString &familyName)
{
    Q_UNUSED(familyName);
}
 
void QPlatformFontDatabase::invalidate()
{
}
 
QFontEngineMulti *QPlatformFontDatabase::fontEngineMulti(QFontEngine *fontEngine, QChar::Script script)
{
    return new QFontEngineMulti(fontEngine, script);
}
 
QFontEngine *QPlatformFontDatabase::fontEngine(const QFontDef &fontDef, void *handle)
{
    Q_UNUSED(fontDef);
    Q_UNUSED(handle);
    qWarning("This plugin does not support loading system fonts.");
    return nullptr;
}
 
QFontEngine *QPlatformFontDatabase::fontEngine(const QByteArray &fontData, qreal pixelSize,
                                               QFont::HintingPreference hintingPreference)
{
    Q_UNUSED(fontData);
    Q_UNUSED(pixelSize);
    Q_UNUSED(hintingPreference);
    qWarning("This plugin does not support font engines created directly from font data");
    return nullptr;
}
 
QStringList QPlatformFontDatabase::addApplicationFont(const QByteArray &fontData, const QString &fileName, QFontDatabasePrivate::ApplicationFont *applicationFont)
{
    Q_UNUSED(fontData);
    Q_UNUSED(fileName);
    Q_UNUSED(applicationFont);
 
    if (applicationFont != nullptr)
        applicationFont->properties.clear();
 
    qWarning("This plugin does not support application fonts");
 
    return QStringList();
}
 
void QPlatformFontDatabase::releaseHandle(void *handle)
{
    QByteArray *fileDataPtr = static_cast<QByteArray *>(handle);
    delete fileDataPtr;
}
 
QString QPlatformFontDatabase::fontDir() const
{
    QString fontpath = QString::fromLocal8Bit(qgetenv("QT_QPA_FONTDIR"));
    if (fontpath.isEmpty())
        fontpath = QLibraryInfo::path(QLibraryInfo::LibrariesPath) + "/fonts"_L1;
 
    return fontpath;
}
 
bool QPlatformFontDatabase::isPrivateFontFamily(const QString &family) const
{
    Q_UNUSED(family);
    return false;
}
 
QFont QPlatformFontDatabase::defaultFont() const
{
    return QFont("Helvetica"_L1);
}
 
 
QString qt_resolveFontFamilyAlias(const QString &alias);
 
QString QPlatformFontDatabase::resolveFontFamilyAlias(const QString &family) const
{
    return qt_resolveFontFamilyAlias(family);
}
 
bool QPlatformFontDatabase::fontsAlwaysScalable() const
{
    return false;
}
 
 QList<int> QPlatformFontDatabase::standardSizes() const
{
    QList<int> ret;
    static const quint8 standard[] =
        { 6, 7, 8, 9, 10, 11, 12, 14, 16, 18, 20, 22, 24, 26, 28, 36, 48, 72 };
    static const int num_standards = int(sizeof standard / sizeof *standard);
    ret.reserve(num_standards);
    std::copy(standard, standard + num_standards, std::back_inserter(ret));
    return ret;
}
 
// see the Unicode subset bitfields in the MSDN docs
static const quint8 requiredUnicodeBits[QFontDatabase::WritingSystemsCount][2] = {
    { 127, 127 }, // Any
    { 0, 127 },   // Latin
    { 7, 127 },   // Greek
    { 9, 127 },   // Cyrillic
    { 10, 127 },  // Armenian
    { 11, 127 },  // Hebrew
    { 13, 127 },  // Arabic
    { 71, 127 },  // Syriac
    { 72, 127 },  // Thaana
    { 15, 127 },  // Devanagari
    { 16, 127 },  // Bengali
    { 17, 127 },  // Gurmukhi
    { 18, 127 },  // Gujarati
    { 19, 127 },  // Oriya
    { 20, 127 },  // Tamil
    { 21, 127 },  // Telugu
    { 22, 127 },  // Kannada
    { 23, 127 },  // Malayalam
    { 73, 127 },  // Sinhala
    { 24, 127 },  // Thai
    { 25, 127 },  // Lao
    { 70, 127 },  // Tibetan
    { 74, 127 },  // Myanmar
    { 26, 127 },  // Georgian
    { 80, 127 },  // Khmer
    { 126, 127 }, // SimplifiedChinese
    { 126, 127 }, // TraditionalChinese
    { 126, 127 }, // Japanese
    { 56, 127 },  // Korean
    { 0, 127 },   // Vietnamese (same as latin1)
    { 126, 127 }, // Other
    { 78, 127 },  // Ogham
    { 79, 127 },  // Runic
    { 14, 127 },  // Nko
};
 
enum CsbBits {
    Latin1CsbBit = 0,
    CentralEuropeCsbBit = 1,
    TurkishCsbBit = 4,
    BalticCsbBit = 7,
    CyrillicCsbBit = 2,
    GreekCsbBit = 3,
    HebrewCsbBit = 5,
    ArabicCsbBit = 6,
    VietnameseCsbBit = 8,
    SimplifiedChineseCsbBit = 18,
    TraditionalChineseCsbBit = 20,
    ThaiCsbBit = 16,
    JapaneseCsbBit = 17,
    KoreanCsbBit = 19,
    KoreanJohabCsbBit = 21,
    SymbolCsbBit = 31
};
 
QSupportedWritingSystems QPlatformFontDatabase::writingSystemsFromOS2Table(const char *os2Table, size_t length)
{
    if (length >= 86)  {
        quint32 unicodeRange[4] = {
            qFromBigEndian<quint32>(os2Table + 42),
            qFromBigEndian<quint32>(os2Table + 46),
            qFromBigEndian<quint32>(os2Table + 50),
            qFromBigEndian<quint32>(os2Table + 54)
        };
        quint32 codePageRange[2] = {
            qFromBigEndian<quint32>(os2Table + 78),
            qFromBigEndian<quint32>(os2Table + 82)
        };
 
        return writingSystemsFromTrueTypeBits(unicodeRange, codePageRange);
    }
 
    return QSupportedWritingSystems();
}
 
QSupportedWritingSystems QPlatformFontDatabase::writingSystemsFromTrueTypeBits(quint32 unicodeRange[4], quint32 codePageRange[2])
{
    QSupportedWritingSystems writingSystems;
 
    bool hasScript = false;
    for (int i = 0; i < QFontDatabase::WritingSystemsCount; ++i) {
        int bit = requiredUnicodeBits[i][0];
        int index = bit/32;
        int flag = 1 << (bit&31);
        if (bit != 126 && (unicodeRange[index] & flag)) {
            bit = requiredUnicodeBits[i][1];
            index = bit/32;
 
            flag = 1 << (bit&31);
            if (bit == 127 || (unicodeRange[index] & flag)) {
                writingSystems.setSupported(QFontDatabase::WritingSystem(i));
                hasScript = true;
                // qDebug("font %s: index=%d, flag=%8x supports script %d", familyName.latin1(), index, flag, i);
            }
        }
    }
    if (codePageRange[0] & ((1 << Latin1CsbBit) | (1 << CentralEuropeCsbBit) | (1 << TurkishCsbBit) | (1 << BalticCsbBit))) {
        writingSystems.setSupported(QFontDatabase::Latin);
        hasScript = true;
        //qDebug("font %s supports Latin", familyName.latin1());
    }
    if (codePageRange[0] & (1 << CyrillicCsbBit)) {
        writingSystems.setSupported(QFontDatabase::Cyrillic);
        hasScript = true;
        //qDebug("font %s supports Cyrillic", familyName.latin1());
    }
    if (codePageRange[0] & (1 << GreekCsbBit)) {
        writingSystems.setSupported(QFontDatabase::Greek);
        hasScript = true;
        //qDebug("font %s supports Greek", familyName.latin1());
    }
    if (codePageRange[0] & (1 << HebrewCsbBit)) {
        writingSystems.setSupported(QFontDatabase::Hebrew);
        hasScript = true;
        //qDebug("font %s supports Hebrew", familyName.latin1());
    }
    if (codePageRange[0] & (1 << ArabicCsbBit)) {
        writingSystems.setSupported(QFontDatabase::Arabic);
        hasScript = true;
        //qDebug("font %s supports Arabic", familyName.latin1());
    }
    if (codePageRange[0] & (1 << ThaiCsbBit)) {
        writingSystems.setSupported(QFontDatabase::Thai);
        hasScript = true;
        //qDebug("font %s supports Thai", familyName.latin1());
    }
    if (codePageRange[0] & (1 << VietnameseCsbBit)) {
        writingSystems.setSupported(QFontDatabase::Vietnamese);
        hasScript = true;
        //qDebug("font %s supports Vietnamese", familyName.latin1());
    }
    if (codePageRange[0] & (1 << SimplifiedChineseCsbBit)) {
        writingSystems.setSupported(QFontDatabase::SimplifiedChinese);
        hasScript = true;
        //qDebug("font %s supports Simplified Chinese", familyName.latin1());
    }
    if (codePageRange[0] & (1 << TraditionalChineseCsbBit)) {
        writingSystems.setSupported(QFontDatabase::TraditionalChinese);
        hasScript = true;
        //qDebug("font %s supports Traditional Chinese", familyName.latin1());
    }
    if (codePageRange[0] & (1 << JapaneseCsbBit)) {
        writingSystems.setSupported(QFontDatabase::Japanese);
        hasScript = true;
        //qDebug("font %s supports Japanese", familyName.latin1());
    }
    if (codePageRange[0] & ((1 << KoreanCsbBit) | (1 << KoreanJohabCsbBit))) {
        writingSystems.setSupported(QFontDatabase::Korean);
        hasScript = true;
        //qDebug("font %s supports Korean", familyName.latin1());
    }
    if (codePageRange[0] & (1U << SymbolCsbBit)) {
        writingSystems = QSupportedWritingSystems();
        hasScript = false;
    }
 
    if (!hasScript)
        writingSystems.setSupported(QFontDatabase::Symbol);
 
    return writingSystems;
}
 
void QPlatformFontDatabase::registerAliasToFontFamily(const QString &familyName, const QString &alias)
{
    qt_registerAliasToFontFamily(familyName, alias);
}
 
void QPlatformFontDatabase::repopulateFontDatabase()
{
    QFontDatabasePrivate::instance()->invalidate();
}
 
bool QPlatformFontDatabase::isFamilyPopulated(const QString &familyName)
{
    return qt_isFontFamilyPopulated(familyName);
}
 
bool QPlatformFontDatabase::supportsVariableApplicationFonts() const
{
    return false;
}
 
 
QT_END_NAMESPACE