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 intégrer le fichier QML dans un module. Pour plus d'informations, consultez la section Déploiement d'applications QML.

qml peut instancier n’importe quel type QML que vous fournissez, tel quel, même s’il n’y a rien à afficher. Pour afficher du contenu QML dont l’objet racine n’est pas Window, qml encapsule ce contenu dans un 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’ Item racine. En attendant, vous pouvez charger et tester des parties de votre prototype séparément à l’aide de l’outil qml.

Pour charger un fichier .qml, indiquez le chemin d’accès au fichier dans l’invite de commande :

$ qml myqmlfile.qml

Pour afficher les options de configuration, exécutez ` qml ` avec l’argument ` --help `.

Lorsque l’objet racine du fichier QML que vous chargez est un Item plutôt qu’une Window, il doit être encapsulé dans un Window pour pouvoir s’afficher. En attendant que cette fonctionnalité soit implémentée, l’objet de niveau supérieur déjà chargé est représenté par un objet PartialScene. L’outil qml charge ensuite des fichiers QML supplémentaires pour déterminer la suite des opérations : l’un d’eux est un fichier de configuration qui spécifie dans quel type de conteneur encapsuler l’ PartialScene. La propriété PartialScene.container fournit une URL pointant vers le code source QML du composant conteneur, qui doit normalement déclarer un Window dans lequel encapsuler l’ Item chargé en premier. Ainsi, le processus d’encapsulation d’un `Item` dans une `Window` est programmable ; par défaut, ces deux fichiers QML supplémentaires sont chargés à partir des ressources contenues dans l’exécutable `qml`. Vous pouvez répertorier les 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 d’encapsulation au démarrage, ainsi que lorsque l’utilisateur redimensionne la fenêtre. La configuration alternative « resizeToItem » fonctionne à l’inverse : l’élément « Item » peut définir sa propre taille par programmation (par exemple en créant des liaisons vers ses propres propriétés « width » et « height »), et la fenêtre d’encapsulation sera redimensionnée pour s’y adapter (sous réserve des limites éventuellement imposées par le système de fenêtrage). Vous pouvez choisir l’une ou l’autre de ces options à l’aide de l’option « -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 contenant deux fichiers QML : un fichier de configuration nommé ` configuration.qml` et un fichier QML déclarant le conteneur `Item`, qui peut porter n’importe quel nom. Une fois cette opération effectuée, la commande ` qml --list-conf ` affichera également ces configurations supplémentaires, tandis que l’option ` --verbose ` les développera pour fournir les chemins d’accès complets vers ces configurations, ainsi que les emplacements supplémentaires qui ont été parcourus :

$ 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 l’ 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 indiquant 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 d’ qml définira directement la propriété ` containedObject `, qui doit obligatoirement porter ce nom ; une fois cette propriété définie, la fenêtre ` Item ` sera rattachée à l’objet ` Window ` et s’affichera. Comme cette fenêtre est déclarée en QML, lorsque vous écrivez votre propre fenêtre « wrapper », vous êtes libre d’y ajouter toutes les fonctionnalités supplémentaires de votre choix : pour gérer le redimensionnement de manière personnalisée, ou pour ajouter des fonctionnalités qui pourraient vous être utiles lors du prototypage.

Indépendamment de ce qui a été trouvé dans AppConfigLocation, vous pouvez également utiliser l’option qml -c en indiquant le chemin d’accès complet au fichier configuration.qml, qui peut à son tour spécifier le chemin d’accès complet à l’objet conteneur ; ces fichiers peuvent donc se trouver n’importe où.

Outre les fonctionnalités pouvant être déclarées dans les fichiers de configuration, l’outil qml propose également quelques fonctionnalités supplémentaires via des options de ligne de commande. Utilisez l’option --help pour obtenir une liste à jour.