qquickfontloader.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 "qquickfontloader_p.h"
 
#include <qqmlcontext.h>
#include <qqmlengine.h>
 
#include <QStringList>
#include <QUrl>
#include <QDebug>
 
#include <QFontDatabase>
 
#include <private/qobject_p.h>
#include <qqmlinfo.h>
#include <qqmlfile.h>
 
#if QT_CONFIG(qml_network)
#include <QNetworkRequest>
#include <QNetworkReply>
#endif
 
#include <QtCore/QCoreApplication>
#include <QtCore/private/qduplicatetracker_p.h>
 
#include <QtGui/private/qfontdatabase_p.h>
 
QT_BEGIN_NAMESPACE
 
class QQuickFontObject : public QObject
{
Q_OBJECT
 
public:
    explicit QQuickFontObject(int _id = -1);
 
#if QT_CONFIG(qml_network)
    void download(const QUrl &url, QNetworkAccessManager *manager);
 
Q_SIGNALS:
    void fontDownloaded(int id);
 
private:
    QNetworkReply *reply = nullptr;
 
private Q_SLOTS:
    void replyFinished();
#endif // qml_network
 
public:
    int id;
 
    Q_DISABLE_COPY(QQuickFontObject)
};
 
QQuickFontObject::QQuickFontObject(int _id)
    : QObject(nullptr), id(_id)
{
}
 
#if QT_CONFIG(qml_network)
void QQuickFontObject::download(const QUrl &url, QNetworkAccessManager *manager)
{
    QNetworkRequest req(url);
    req.setAttribute(QNetworkRequest::HttpPipeliningAllowedAttribute, true);
    reply = manager->get(req);
    QObject::connect(reply, SIGNAL(finished()), this, SLOT(replyFinished()));
}
 
void QQuickFontObject::replyFinished()
{
    if (reply) {
        if (!reply->error()) {
            id = QFontDatabase::addApplicationFontFromData(reply->readAll());
            emit fontDownloaded(id);
        } else {
            qWarning("%s: Unable to load font '%s': %s", Q_FUNC_INFO,
                     qPrintable(reply->url().toString()), qPrintable(reply->errorString()));
            emit fontDownloaded(-1);
        }
        reply->deleteLater();
        reply = nullptr;
    }
}
#endif // qml_network
 
class QQuickFontLoaderPrivate : public QObjectPrivate
{
    Q_DECLARE_PUBLIC(QQuickFontLoader)
 
public:
    QQuickFontLoaderPrivate() {}
 
    QUrl url;
    QFont font;
    QQuickFontLoader::Status status = QQuickFontLoader::Null;
};
 
static void q_QFontLoaderFontsStaticReset();
static void q_QFontLoaderFontsAddReset()
{
    qAddPostRoutine(q_QFontLoaderFontsStaticReset);
}
class QFontLoaderFonts
{
public:
    QFontLoaderFonts()
    {
        qAddPostRoutine(q_QFontLoaderFontsStaticReset);
        qAddPreRoutine(q_QFontLoaderFontsAddReset);
    }
 
    ~QFontLoaderFonts()
    {
        qRemovePostRoutine(q_QFontLoaderFontsStaticReset);
        reset();
    }
 
 
    void reset()
    {
        QDuplicateTracker<QQuickFontObject *, 256> deleted(map.size());
        for (QQuickFontObject *fo : std::as_const(map)) {
            if (!deleted.hasSeen(fo))
                delete fo;
        }
        map.clear();
    }
 
    QHash<QUrl, QQuickFontObject *> map;
};
Q_GLOBAL_STATIC(QFontLoaderFonts, fontLoaderFonts);
 
static void q_QFontLoaderFontsStaticReset()
{
    fontLoaderFonts()->reset();
}
 
QQuickFontLoader::QQuickFontLoader(QObject *parent)
    : QObject(*(new QQuickFontLoaderPrivate), parent)
{
    connect(this, &QQuickFontLoader::fontChanged, this, &QQuickFontLoader::nameChanged);
}
 
QUrl QQuickFontLoader::source() const
{
    Q_D(const QQuickFontLoader);
    return d->url;
}
 
void QQuickFontLoader::setSource(const QUrl &url)
{
    Q_D(QQuickFontLoader);
    if (url == d->url)
        return;
    d->url = url;
    emit sourceChanged();
 
    const QQmlContext *context = qmlContext(this);
    const QUrl &resolvedUrl = context ? context->resolvedUrl(d->url) : d->url;
    QString localFile = QQmlFile::urlToLocalFileOrQrc(resolvedUrl);
    if (!localFile.isEmpty()) {
        if (!fontLoaderFonts()->map.contains(resolvedUrl)) {
            int id = QFontDatabase::addApplicationFont(localFile);
            updateFontInfo(id);
            if (id != -1) {
                QQuickFontObject *fo = new QQuickFontObject(id);
                fontLoaderFonts()->map[resolvedUrl] = fo;
            }
        } else {
            updateFontInfo(fontLoaderFonts()->map.value(resolvedUrl)->id);
        }
    } else {
        if (!fontLoaderFonts()->map.contains(resolvedUrl)) {
            Q_ASSERT(context);
#if QT_CONFIG(qml_network)
            QQuickFontObject *fo = new QQuickFontObject;
            fontLoaderFonts()->map[resolvedUrl] = fo;
            fo->download(resolvedUrl, context->engine()->networkAccessManager());
            d->status = Loading;
            emit statusChanged();
            QObject::connect(fo, SIGNAL(fontDownloaded(int)),
                this, SLOT(updateFontInfo(int)));
#else
// Silently fail if compiled with no_network
#endif
        } else {
            QQuickFontObject *fo = fontLoaderFonts()->map.value(resolvedUrl);
            if (fo->id == -1) {
#if QT_CONFIG(qml_network)
                d->status = Loading;
                emit statusChanged();
                QObject::connect(fo, SIGNAL(fontDownloaded(int)),
                    this, SLOT(updateFontInfo(int)));
#else
// Silently fail if compiled with no_network
#endif
            }
            else
                updateFontInfo(fo->id);
        }
    }
}
 
void QQuickFontLoader::updateFontInfo(int id)
{
    Q_D(QQuickFontLoader);
 
    QFont font;
 
    QQuickFontLoader::Status status = Error;
    if (id >= 0) {
        QFontDatabasePrivate *p = QFontDatabasePrivate::instance();
        if (id < p->applicationFonts.size()) {
            const QFontDatabasePrivate::ApplicationFont &applicationFont = p->applicationFonts.at(id);
 
            if (!applicationFont.properties.isEmpty()) {
                const QFontDatabasePrivate::ApplicationFont::Properties &properties = applicationFont.properties.at(0);
                font.setFamily(properties.familyName);
                font.setStyleName(properties.styleName);
                font.setWeight(QFont::Weight(properties.weight));
                font.setStyle(properties.style);
                font.setStretch(properties.stretch);
            }
        }
 
        status = Ready;
    }
 
    if (font != d->font) {
        d->font = font;
        emit fontChanged();
    }
 
    if (status != d->status) {
        if (status == Error) {
            const QQmlContext *context = qmlContext(this);
            qmlWarning(this) << "Cannot load font: \""
                             << (context ? context->resolvedUrl(d->url) : d->url).toString() << '"';
        }
        d->status = status;
        emit statusChanged();
    }
}
 
QFont QQuickFontLoader::font() const
{
    Q_D(const QQuickFontLoader);
    return d->font;
}
 
QString QQuickFontLoader::name() const
{
    Q_D(const QQuickFontLoader);
    return d->font.resolveMask() == 0 ? QString() : d->font.family();
}
 
QQuickFontLoader::Status QQuickFontLoader::status() const
{
    Q_D(const QQuickFontLoader);
    return d->status;
}
 
QT_END_NAMESPACE
 
#include <qquickfontloader.moc>
 
#include "moc_qquickfontloader_p.cpp"