qqmlapplicationengine.cpp

Go to the documentation of this file.

// Copyright (C) 2016 Research In Motion.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include <QtQml/qqmlfile.h>
#include <QtCore/QCoreApplication>
#include <QtCore/QTranslator>
#include <QQmlComponent>
#include "qqmlapplicationengine.h"
#include "qqmlapplicationengine_p.h"
#include <QtQml/private/qqmlcomponent_p.h>
#include <QtQml/private/qqmldirdata_p.h>
#include <QtQml/private/qqmlfileselector_p.h>
 
QT_BEGIN_NAMESPACE
 
QQmlApplicationEnginePrivate::QQmlApplicationEnginePrivate(QQmlEngine *e)
    : QQmlEnginePrivate(e)
{
    uiLanguage = QLocale().bcp47Name();
}
 
QQmlApplicationEnginePrivate::~QQmlApplicationEnginePrivate()
{
}
 
void QQmlApplicationEnginePrivate::ensureInitialized()
{
    if (!isInitialized) {
        init();
        isInitialized = true;
    }
}
 
void QQmlApplicationEnginePrivate::cleanUp()
{
    Q_Q(QQmlApplicationEngine);
    for (auto obj : std::as_const(objects))
        obj->disconnect(q);
 
    qDeleteAll(objects);
}
 
void QQmlApplicationEnginePrivate::init()
{
    Q_Q(QQmlApplicationEngine);
    q->connect(q, &QQmlApplicationEngine::quit, QCoreApplication::instance(),
               &QCoreApplication::quit, Qt::QueuedConnection);
    q->connect(q, &QQmlApplicationEngine::exit, QCoreApplication::instance(),
               &QCoreApplication::exit, Qt::QueuedConnection);
    QObject::connect(q, &QJSEngine::uiLanguageChanged, q, [this](){
        _q_loadTranslations();
    });
#if QT_CONFIG(translation)
    QTranslator* qtTranslator = new QTranslator(q);
    if (qtTranslator->load(QLocale(), QLatin1String("qt"), QLatin1String("_"), QLibraryInfo::path(QLibraryInfo::TranslationsPath), QLatin1String(".qm")))
        QCoreApplication::installTranslator(qtTranslator);
    else
        delete qtTranslator;
#endif
    auto *selector = new QQmlFileSelector(q,q);
    selector->setExtraSelectors(extraFileSelectors);
    QCoreApplication::instance()->setProperty("__qml_using_qqmlapplicationengine", QVariant(true));
}
 
void QQmlApplicationEnginePrivate::_q_loadTranslations()
{
#if QT_CONFIG(translation)
    Q_Q(QQmlApplicationEngine);
    if (translationsDirectory.isEmpty())
        return;
 
    auto translator = std::make_unique<QTranslator>();
    if (!uiLanguage.value().isEmpty()) {
        QLocale locale(uiLanguage);
        if (translator->load(locale, QLatin1String("qml"), QLatin1String("_"), translationsDirectory, QLatin1String(".qm"))) {
            if (activeTranslator)
                QCoreApplication::removeTranslator(activeTranslator.get());
            QCoreApplication::installTranslator(translator.get());
            activeTranslator.swap(translator);
        }
    } else {
        activeTranslator.reset();
    }
    q->retranslate();
#endif
}
 
void QQmlApplicationEnginePrivate::startLoad(const QUrl &url, const QByteArray &data, bool dataFlag)
{
    Q_Q(QQmlApplicationEngine);
 
    ensureInitialized();
 
    if (url.scheme() == QLatin1String("file") || url.scheme() == QLatin1String("qrc")) {
        QFileInfo fi(QQmlFile::urlToLocalFileOrQrc(url));
        translationsDirectory = fi.path() + QLatin1String("/i18n");
    } else {
        translationsDirectory.clear();
    }
 
    _q_loadTranslations(); //Translations must be loaded before the QML file is
    QQmlComponent *c = new QQmlComponent(q, q);
 
    if (dataFlag)
        c->setData(data,url);
    else
        c->loadUrl(url);
 
    ensureLoadingFinishes(c);
}
 
void QQmlApplicationEnginePrivate::startLoad(QAnyStringView uri, QAnyStringView typeName)
{
    Q_Q(QQmlApplicationEngine);
 
    QQmlComponent *c = new QQmlComponent(q, q);
 
    ensureInitialized();
 
    auto *componentPriv = QQmlComponentPrivate::get(c);
    const auto [status, type] = componentPriv->prepareLoadFromModule(uri, typeName);
 
    if (type.sourceUrl().isValid()) {
        const auto qmlDirData = typeLoader.getQmldir(type.sourceUrl());
        const QUrl url = qmlDirData->finalUrl();
        if (url.scheme() == QLatin1String("file") || url.scheme() == QLatin1String("qrc")) {
            QFileInfo fi(QQmlFile::urlToLocalFileOrQrc(url));
            translationsDirectory = fi.path() + QLatin1String("/i18n");
        } else {
            translationsDirectory.clear();
        }
    }
 
    /* Translations must be loaded before the QML file. They require translationDirectory to
     * already be resolved. But, in order to resolve the translationDirectory, the type of the
     * module to load needs to be known. Therefore, loadFromModule is split into resolution and
     * loading because the translation directory needs to be set in between.
     */
    _q_loadTranslations();
    componentPriv->completeLoadFromModule(uri, typeName, type, status);
 
    ensureLoadingFinishes(c);
}
 
void QQmlApplicationEnginePrivate::finishLoad(QQmlComponent *c)
{
    Q_Q(QQmlApplicationEngine);
    switch (c->status()) {
    case QQmlComponent::Error:
        qWarning() << "QQmlApplicationEngine failed to load component";
        warning(c->errors());
        q->objectCreated(nullptr, c->url());
        q->objectCreationFailed(c->url());
        break;
    case QQmlComponent::Ready: {
        auto newObj = initialProperties.empty() ? c->create() : c->createWithInitialProperties(initialProperties);
 
        if (c->isError()) {
           qWarning() << "QQmlApplicationEngine failed to create component";
           warning(c->errors());
           q->objectCreated(nullptr, c->url());
           q->objectCreationFailed(c->url());
           break;
        }
 
        objects << newObj;
        QObject::connect(newObj, &QObject::destroyed, q, [&](QObject *obj) { objects.removeAll(obj); });
        q->objectCreated(objects.constLast(), c->url());
        }
        break;
    case QQmlComponent::Loading:
    case QQmlComponent::Null:
        return; //These cases just wait for the next status update
    }
 
    c->deleteLater();
}
 
void QQmlApplicationEnginePrivate::ensureLoadingFinishes(QQmlComponent *c)
{
    Q_Q(QQmlApplicationEngine);
    if (!c->isLoading()) {
        finishLoad(c);
        return;
    }
    QObject::connect(c, &QQmlComponent::statusChanged, q, [this, c] { this->finishLoad(c); });
}
 
QQmlApplicationEngine::QQmlApplicationEngine(QObject *parent)
: QQmlEngine(*(new QQmlApplicationEnginePrivate(this)), parent)
{
    QJSEnginePrivate::addToDebugServer(this);
}
 
QQmlApplicationEngine::QQmlApplicationEngine(const QUrl &url, QObject *parent)
    : QQmlApplicationEngine(parent)
{
    load(url);
}
 
QQmlApplicationEngine::QQmlApplicationEngine(QAnyStringView uri, QAnyStringView typeName, QObject *parent)
    : QQmlApplicationEngine(parent)
{
    loadFromModule(uri, typeName);
}
 
QQmlApplicationEngine::QQmlApplicationEngine(const QString &filePath, QObject *parent)
    : QQmlApplicationEngine(QUrl::fromUserInput(filePath, QLatin1String("."), QUrl::AssumeLocalFile), parent)
{
}
 
QQmlApplicationEngine::~QQmlApplicationEngine()
{
    Q_D(QQmlApplicationEngine);
    QJSEnginePrivate::removeFromDebugServer(this);
    d->cleanUp();//Instantiated root objects must be deleted before the engine
}
 
void QQmlApplicationEngine::load(const QUrl &url)
{
    Q_D(QQmlApplicationEngine);
    d->startLoad(url);
}
 
void QQmlApplicationEngine::load(const QString &filePath)
{
    Q_D(QQmlApplicationEngine);
    d->startLoad(QUrl::fromUserInput(filePath, QLatin1String("."), QUrl::AssumeLocalFile));
}
 
void QQmlApplicationEngine::loadFromModule(QAnyStringView uri, QAnyStringView typeName)
{
    Q_D(QQmlApplicationEngine);
    d->startLoad(uri, typeName);
}
 
void QQmlApplicationEngine::setInitialProperties(const QVariantMap &initialProperties)
{
    Q_D(QQmlApplicationEngine);
    d->initialProperties = initialProperties;
}
 
void QQmlApplicationEngine::setExtraFileSelectors(const QStringList &extraFileSelectors)
{
    Q_D(QQmlApplicationEngine);
    if (d->isInitialized) {
        qWarning() << "QQmlApplicationEngine::setExtraFileSelectors()"
                   << "called after loading QML files. This has no effect.";
    } else {
        d->extraFileSelectors = extraFileSelectors;
    }
}
 
void QQmlApplicationEngine::loadData(const QByteArray &data, const QUrl &url)
{
    Q_D(QQmlApplicationEngine);
    d->startLoad(url, data, true);
}
 
QList<QObject *> QQmlApplicationEngine::rootObjects() const
{
    Q_D(const QQmlApplicationEngine);
    return d->objects;
}
 
QT_END_NAMESPACE
 
#include "moc_qqmlapplicationengine.cpp"