Sur cette page

QQmlApplicationEngine Class

QQmlApplicationEngine fournit un moyen pratique de charger une application à partir d'un seul fichier QML. Plus d'informations...

En-tête : #include <QQmlApplicationEngine>
CMake : find_package(Qt6 REQUIRED COMPONENTS Qml)
target_link_libraries(mytarget PRIVATE Qt6::Qml)
qmake : QT += qml
Héritages : QQmlEngine

Fonctions publiques

QQmlApplicationEngine(QObject *parent = nullptr)
QQmlApplicationEngine(const QString &filePath, QObject *parent = nullptr)
QQmlApplicationEngine(const QUrl &url, QObject *parent = nullptr)
(since 6.5) QQmlApplicationEngine(QAnyStringView uri, QAnyStringView typeName, QObject *parent = nullptr)
virtual ~QQmlApplicationEngine() override
QList<QObject *> rootObjects() const

Emplacements publics

void load(const QString &filePath)
void load(const QUrl &url)
void loadData(const QByteArray &data, const QUrl &url = QUrl())
(since 6.5) void loadFromModule(QAnyStringView uri, QAnyStringView typeName)
(since 6.0) void setExtraFileSelectors(const QStringList &extraFileSelectors)
void setInitialProperties(const QVariantMap &initialProperties)

Signaux

void objectCreated(QObject *object, const QUrl &url)
(since 6.4) void objectCreationFailed(const QUrl &url)

Description détaillée

Cette classe combine QQmlEngine et QQmlComponent pour fournir un moyen pratique de charger un seul fichier QML. Elle expose également certaines fonctionnalités centrales de l'application à QML, qu'une application hybride C++/QML contrôlerait normalement à partir de C++.

Il peut être utilisé de la manière suivante :

#include <QGuiApplication>
#include <QQmlApplicationEngine>

int main(int argc, char *argv[])
{
    QGuiApplication app(argc, argv);
    QQmlApplicationEngine engine("main.qml");
    return app.exec();
}

Remarque : contrairement à QQuickView, QQmlApplicationEngine ne crée pas automatiquement une fenêtre racine. Si vous utilisez des éléments visuels provenant de Qt Quick, vous devrez les placer à l'intérieur d'une fenêtre Window.

Vous pouvez également utiliser QCoreApplication avec QQmlApplicationEngine, si vous n'utilisez pas de modules QML nécessitant QGuiApplication (comme QtQuick).

Liste des changements de configuration par rapport à la configuration par défaut QQmlEngine:

  • Connexion de Qt.quit() à QCoreApplication::quit()
  • Charge automatiquement les fichiers de traduction à partir d'un répertoire i18n adjacent au fichier QML principal.
  • Les traductions sont rechargées lorsque la propriété QJSEngine::uiLanguage / Qt.uiLanguage est modifiée.
  • Définit automatiquement un contrôleur d'incubation si la scène contient un QQuickWindow.
  • Définit automatiquement un QQmlFileSelector comme intercepteur d'url, appliquant des sélecteurs de fichiers à tous les fichiers QML et assets.

Le comportement du moteur peut être modifié en utilisant les méthodes héritées de QQmlEngine.

Note : Les fichiers de traduction doivent avoir un préfixe qml_ pour être reconnus, par exemple qml_ja_JP.qm.

Note : Le placement des fichiers de traduction par rapport au fichier QML principal implique l'ajout d'un RESOURCE_PREFIX à l'appel qt_add_translations correspondant. Celui-ci doit inclure le préfixe de ressource du module QML du fichier principal(/qt/qml par défaut) et l'URI du module. Par exemple, pour fournir des fichiers de traduction pour un module appelé "Translated" :

qt_add_translations(App
    RESOURCE_PREFIX /qt/qml/Translated/i18n
    TS_FILE_BASE qml
    TS_FILE_DIR i18n
)

Documentation des fonctions membres

QQmlApplicationEngine::QQmlApplicationEngine(QObject *parent = nullptr)

Créez un nouveau QQmlApplicationEngine avec l'adresse parent. Vous devrez appeler load() ultérieurement pour charger un fichier QML.

QQmlApplicationEngine::QQmlApplicationEngine(const QString &filePath, QObject *parent = nullptr)

Crée un nouveau QQmlApplicationEngine et charge le fichier QML à l'adresse filePath, qui doit être un fichier local ou un chemin qrc. Si un chemin relatif est donné, il sera interprété comme étant relatif au répertoire de travail de l'application.

Ceci est fourni par commodité, et revient à utiliser le constructeur vide et à appeler load par la suite.

QQmlApplicationEngine::QQmlApplicationEngine(const QUrl &url, QObject *parent = nullptr)

Crée un nouveau QQmlApplicationEngine et charge le fichier QML à l'adresse url. Ceci est fourni à titre de commodité, et revient à utiliser le constructeur vide et à appeler load ensuite.

[explicit, since 6.5] QQmlApplicationEngine::QQmlApplicationEngine(QAnyStringView uri, QAnyStringView typeName, QObject *parent = nullptr)

Crée un nouveau QQmlApplicationEngine et charge le type QML spécifié par uri et typeName. Cette fonction est fournie par commodité et revient à utiliser le constructeur vide et à appeler loadFromModule par la suite.

Cette fonction a été introduite dans Qt 6.5.

[override virtual noexcept] QQmlApplicationEngine::~QQmlApplicationEngine()

Détruit le site QQmlApplicationEngine et tous les objets QML qu'il a chargés.

[slot] void QQmlApplicationEngine::load(const QString &filePath)

Charge le fichier QML racine situé à l'adresse filePath. filePath doit être un chemin d'accès à un fichier local ou un chemin d'accès à un fichier du système de fichiers de ressources. Si filePath est un chemin relatif, il est considéré comme relatif au répertoire de travail de l'application. L'arbre d'objets défini par le fichier est instancié immédiatement.

En cas d'erreur, les messages d'erreur sont imprimés avec qWarning.

Note : Ce slot est surchargé. Pour se connecter à ce slot :

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        qmlApplicationEngine, qOverload(&QQmlApplicationEngine::load));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        qmlApplicationEngine, [receiver = qmlApplicationEngine](const QString &filePath) { receiver->load(filePath); });
Pour plus d'exemples et d'approches, voir se connecter à des slots surchargés.

[slot] void QQmlApplicationEngine::load(const QUrl &url)

Charge le fichier QML racine situé à l'adresse url. L'arbre d'objets défini par le fichier est créé immédiatement pour les urls de fichiers locaux. Les URL distantes sont chargées de manière asynchrone ; il convient d'écouter le signal objectCreated pour déterminer si l'arbre d'objets est prêt.

En cas d'erreur, le signal objectCreated est émis avec un pointeur nul comme paramètre et les messages d'erreur sont imprimés avec qWarning.

Note : Ce slot est surchargé. Pour se connecter à ce slot :

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        qmlApplicationEngine, qOverload(&QQmlApplicationEngine::load));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        qmlApplicationEngine, [receiver = qmlApplicationEngine](const QUrl &url) { receiver->load(url); });
Pour plus d'exemples et d'approches, voir se connecter à des slots surchargés.

[slot] void QQmlApplicationEngine::loadData(const QByteArray &data, const QUrl &url = QUrl())

Charge le QML donné dans data. L'arbre d'objets défini par data est instancié immédiatement.

Si un url est spécifié, il est utilisé comme url de base du composant. Cela affecte les chemins relatifs dans les données et les messages d'erreur.

En cas d'erreur, les messages d'erreur sont imprimés avec qWarning.

[slot, since 6.5] void QQmlApplicationEngine::loadFromModule(QAnyStringView uri, QAnyStringView typeName)

Charge le type QML typeName à partir du module spécifié par uri. Si le type provient d'un fichier QML situé dans une url distante, le type sera chargé de manière asynchrone. Écoutez le signal objectCreated pour déterminer si l'arbre d'objets est prêt.

En cas d'erreur, le signal objectCreated est émis avec un pointeur nul comme paramètre et les messages d'erreur sont imprimés avec qWarning.

QQmlApplicationEngine engine;
engine.loadFromModule("QtQuick", "Rectangle");

Remarque : le module identifié par uri est recherché dans le chemin d'importation, de la même manière que si vous faisiez import uri à l'intérieur d'un fichier QML. Si le module ne peut être localisé à cet endroit, cette fonction échouera.

Cette fonction a été introduite dans Qt 6.5.

Voir aussi QQmlComponent::loadFromModule.

[signal] void QQmlApplicationEngine::objectCreated(QObject *object, const QUrl &url)

Ce signal est émis lorsque le chargement d'un objet est terminé. Si le chargement a réussi, object contient un pointeur sur l'objet chargé, sinon le pointeur est NULL.

L'adresse url du composant d'où provient l'objet object est également fournie.

Remarque : si le chemin d'accès au composant a été fourni sous la forme d'un QString contenant un chemin d'accès relatif, le url contiendra un chemin d'accès entièrement résolu au fichier.

[signal, since 6.4] void QQmlApplicationEngine::objectCreationFailed(const QUrl &url)

Ce signal est émis lorsque le chargement se termine en raison d'une erreur.

L'adresse url du composant dont le chargement a échoué est fournie en argument.

QGuiApplication app(argc, argv);
QQmlApplicationEngine engine;

// exit on error
QObject::connect(&engine, &QQmlApplicationEngine::objectCreationFailed,
    &app, []() { QCoreApplication::exit(-1); }, Qt::QueuedConnection);
engine.load(QUrl());
return app.exec();

Remarque : si le chemin d'accès au composant a été fourni sous la forme d'un QString contenant un chemin d'accès relatif, le url contiendra un chemin d'accès entièrement résolu au fichier.

Voir également QQmlApplicationEngine::objectCreated, qui sera émis en plus de ce signal (même si la création a échoué).

Cette fonction a été introduite dans Qt 6.4.

QList<QObject *> QQmlApplicationEngine::rootObjects() const

Renvoie une liste de tous les objets racines instanciés par la fonction QQmlApplicationEngine. Cette liste ne contiendra que les objets chargés via load() ou un constructeur de commodité.

Note : Dans les versions de Qt antérieures à 5.9, cette fonction est marquée comme nonconst.

[slot, since 6.0] void QQmlApplicationEngine::setExtraFileSelectors(const QStringList &extraFileSelectors)

Définit l'adresse extraFileSelectors à transmettre à l'adresse interne QQmlFileSelector utilisée pour résoudre les URL des fichiers locaux. Les extraFileSelectors sont appliqués lors du chargement du premier fichier QML. Les définir par la suite n'a aucun effet.

Cette fonction a été introduite dans Qt 6.0.

Voir aussi QQmlFileSelector et QFileSelector::setExtraSelectors.

[slot] void QQmlApplicationEngine::setInitialProperties(const QVariantMap &initialProperties)

Définit le site initialProperties avec lequel le composant QML est initialisé après son chargement.

QQmlApplicationEngine engine;

EventDatabase eventDatabase;
EventMonitor eventMonitor;

engine.setInitialProperties({
    { "eventDatabase", QVariant::fromValue(&eventDatabase) },
    { "eventMonitor", QVariant::fromValue(&eventMonitor) }
});

Voir aussi QQmlComponent::setInitialProperties, QQmlApplicationEngine::load, et QQmlApplicationEngine::loadData.

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.