Prototypage avec l'outil QML Runtime

L'utilitaire qml est principalement destiné à tester vos applications et composants QML. Pour lancer une application QML dans un environnement de production, vous devez souvent développer une application C++ personnalisée ou regrouper le fichier QML dans un module. Pour plus d'informations, voir Déploiement d'applications QML.

qml peut instancier n'importe quel type QML que vous lui fournissez, tel quel, même s'il n'y a rien à afficher. Pour afficher un contenu QML dont l'objet racine n'est pas Window, qml enveloppe ce contenu dans une page Window.

Par conséquent, lorsque vous passez d'un prototype développé avec qml à une application C++, vous devez soit vous assurer que l'élément racine est un Window, soit créer un QQuickView en C++ pour contenir l'objet racine Item. Mais en attendant, vous pouvez charger et tester des parties de votre prototype séparément avec l'outil qml.

Pour charger un fichier .qml, indiquez le chemin d'accès à l'invite de commande :

$ qml myqmlfile.qml

Pour voir les options de configuration, exécutez qml avec l'argument --help.

Lorsque l'objet racine du fichier QML que vous chargez est un élément plutôt qu'une fenêtre, il doit être enveloppé dans une page Window pour être affiché. Pendant que ce travail est en cours, l'objet de premier niveau déjà chargé est représenté par un objet PartialScene. L'outil qml charge ensuite d'autres fichiers QML pour décider de la marche à suivre : l'un d'eux est un fichier de configuration qui spécifie dans quel type de conteneur envelopper l'objet PartialScene. La propriété PartialScene.container donne une URL pointant vers le code source QML pour le composant conteneur, qui devrait normalement déclarer un Window dans lequel envelopper l'objet Item qui a été chargé en premier. Ainsi, le processus d'encapsulation d'un élément dans une fenêtre est programmable ; et par défaut, ces deux fichiers QML supplémentaires sont chargés à partir de ressources à l'intérieur de l'exécutable qml. Vous pouvez dresser la liste des configurations disponibles à l'aide de la commande --list-conf:

$ qml --list-conf
Built-in configurations:
  default
  resizeToItem

La configuration default fournit le comportement par défaut : l'élément racine sera redimensionné pour remplir la fenêtre enveloppante au démarrage, ainsi que lorsque l'utilisateur redimensionne la fenêtre. La configuration alternative resizeToItem fonctionne dans l'autre sens : l'élément peut définir sa propre taille par programme (par exemple en créant des liens vers ses propres propriétés width et height ), et la fenêtre enveloppante sera redimensionnée pour s'adapter (sous réserve des limites éventuellement imposées par le système de fenêtres). Vous pouvez choisir l'une ou l'autre de ces options en utilisant les options -c ou --config:

$ qml -c resizeToItem selfResizingItem.qml

Des configurations supplémentaires peuvent être ajoutées en créant des répertoires de configuration dans QStandardPaths::AppConfigLocation, chacun avec deux fichiers QML à l'intérieur : un fichier de configuration nommé configuration.qml, et un fichier QML qui déclare le wrapper Item, qui peut avoir n'importe quel nom. Si cela a été fait, la commande qml --list-conf listera également ces configurations supplémentaires, tandis que l'option --verbose les développera pour donner les chemins d'accès complets à ces configurations et les emplacements supplémentaires qui ont été recherchés :

$ qml --list-conf --verbose
Built-in configurations:
  default
  resizeToItem
Other configurations:
  /home/myuser/.config/QtProject/Qml Runtime/simplest
Checked in:
  /home/myuser/.config/QtProject/Qml Runtime
  /etc/xdg/QtProject/Qml Runtime

Voici un exemple de fichier configuration.qml:

import QmlRuntime.Config

Configuration {
    PartialScene {
        itemType: "QQuickItem"
        container: Qt.resolvedUrl("ItemWrapper.qml")
    }
}

Et voici le fichier ItemWrapper.qml le plus simple possible vers lequel la propriété container pourrait pointer :

import QtQuick

Window {
    required property Item containedObject: null
    onContainedObjectChanged: {
        if (containedObject == undefined || containedObject == null) {
            visible = false;
        } else {
            containedObject.parent = contentItem;
            visible = true;
        }
    }
}

Une fois ces fichiers créés, vous pouvez utiliser l'option qml -c en donnant le nom du répertoire contenant le fichier configuration.qml, qui spécifie le chemin d'accès à l'objet conteneur :

$ qml -c simplest mycomponent.qml

Le moteur d'exécution qml définira directement la propriété containedObject, qui doit porter ce nom ; lorsqu'elle sera définie, l'objet Item sera réparti sur l'objet Window et affiché. Étant donné que cette fenêtre est déclarée en QML, lorsque vous écrivez votre propre fenêtre enveloppante, vous êtes libre d'ajouter toutes les fonctionnalités supplémentaires que vous souhaitez : pour gérer le redimensionnement d'une manière personnalisée, ou pour ajouter des capacités que vous pouvez trouver utiles pendant le prototypage.

Indépendamment de ce qui a été trouvé dans AppConfigLocation, vous pouvez également utiliser l'option qml -c en donnant le chemin complet vers le fichier configuration.qml, qui peut à son tour spécifier le chemin complet vers l'objet conteneur ; ces fichiers peuvent donc être situés n'importe où.

Outre les fonctionnalités qui peuvent être déclarées dans les fichiers de configuration, l'outil qml fournit également quelques autres fonctionnalités via les options de la ligne de commande. Utilisez l'option --help pour obtenir une liste à jour.