Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

Qt 6 : une vision technique proposée par Lars Knoll
C++17 au programme, Qt Quick pourrait se passer de JavaScript

Le , par dourouc05

26PARTAGES

17  0 
Qt 5 est sorti en 2012, déjà, il y a un peu moins de sept ans. L’énorme apport de cette version a été un fort découplage des fonctionnalités en modules bien plus indépendants qu’auparavant. Les widgets ont été déclassés, avec la séparation en Qt GUI (éléments absolument nécessaires pour l’intégration avec un système de fenêtrage) et Qt Widgets (les widgets classiques qui ont fait la renommée de Qt depuis ses débuts). La transition de Qt 4 à Qt 5 a pu se faire de manière assez simple (surtout en comparaison du passage de Qt 3 à Qt 4) : bon nombre d’API sont restées intactes, les fonctionnalités désapprouvées étaient signalées en amont avant leur suppression de Qt 5.

Qt 6 est attendu pour la fin 2020 (sauf retard, plus ou moins inéluctable quand on parle de Qt) et devrait poursuivre la même voie de Qt 5 : limiter les changements par rapport aux versions existantes, mais tout de même se préparer aux futures évolutions du framework et des besoins du marché. Une bonne partie des nouvelles fonctionnalités de Qt 6 sera disponible dans Qt 5.14 et 5.15, afin de faciliter la transition.

Qt 6 s’oriente vers les nouvelles utilisations de Qt. Les interfaces lourdes n’ont plus tellement la cote, mais elles ont permis à Qt de s’imposer, avec force animations et autres complexités (intégration d’éléments 2D et 3D, apparition de la réalité virtuelle et augmentée). Le matériel embarqué est la source de croissance la plus importante pour Qt : les utilisateurs veulent des interfaces intuitives, esthétiques, fonctionnant sur des écrans tactiles, sur du matériel (très) bon marché — heureusement qu’il ne faut pas y intégrer trop de fonctionnalités ! Sauf quand on parle d’intelligence artificielle…

[h=2]Qt Quick[/h]

Arrivé avec Qt 4 et peaufiné avec Qt 5, Qt Quick, l’environnement de création d’interfaces graphiques de manière déclarative, continuera à prendre une place importante dans Qt. Cet environnement est assez compliqué : les interfaces sont décrites en QML, l’interaction en JavaScript (du code inclus dans les fichiers QML ou externe) ou en C++, le moteur d’exécution est entièrement codé en C++… et il est même possible d’utiliser Qt Quick exclusivement en C++ ! Plusieurs changements d’envergure sont prévus, comme l’ajout d’un système de typage statique, afin de faciliter le travail d’utilitaires pour vérifier la correction du code, par exemple, mais aussi pour augmenter les possibilités d’optimisation du code.
En termes de performance, l’inclusion d’ECMAScript de manière forcée dans Qt Quick est parfois une limite, surtout sur des appareils très peu puissants — mais est extrêmement utile pour le prototypage d’une interface. JavaScript deviendra une composante optionnelle de Qt Quick, les interactions étant remplacées par du code C++. Aussi, le code QML deviendra compilable en C++ natif, notamment grâce au typage statique.

Tous les composants de Qt Quick disposent d’une version, ce qui facilite l’écriture d’une application qui dure dans le temps (on peut rester sur une version plus ancienne d’un composant à cause d’un changement de comportement ou d’interface dans une version plus récente). Cependant, le moteur d’exécution est rendu très compliqué à cause de cette possibilité de versionnage au niveau de QML : elle devrait disparaître (probablement aussi pour les extensions écrites en C++).

Qt Quick est prévu comme un environnement beaucoup plus dynamique que le code Qt en C++ habituel : bon nombre de structures de données sont générées au démarrage de l’application, ce qui prend un certain temps. Elles devraient être générées au moment de la compilation de l’application. De plus, ces structures sont parfois redondantes avec l’infrastructure QObject, ce qui génère des surcoûts en termes de temps de démarrage et de consommation de mémoire.

[h=2]Infrastructure graphique[/h]

Qt 5 révolutionnait déjà la manière d’afficher les interfaces graphiques, puisqu’une bonne partie du rendu était effectuée en OpenGL (quitte à livrer ANGLE, une implémentation d’OpenGL par-dessus DirectX, ce dernier étant généralement mieux géré sous Windows en l’absence de pilotes). Cependant, depuis ce choix, le monde de l’infographie 3D a beaucoup évolué : Vulkan est le successeur désigné d’OpenGL, Microsoft a lancé Direct3D 12 et Apple Metal (des API très similaires à Vulkan dans leurs principes, mais de bien plus bas niveau par rapport à OpenGL et les versions précédentes de Direct3D). Qt devra travailler de manière transparente avec toutes ces API de rendu pour bénéficier d’un maximum de performance sur le matériel actuel et futur — sans oublier que tout le matériel que Qt devra gérer ne sera pas forcément compatible avec ces dernières API.

Pour ce faire, il faudra une couche d’abstraction de l’API de rendu, tout comme QPA (Qt platform abstraction) fournit une couche d’abstraction de la plateforme sous-jacente (gestion des polices, des fenêtres, des curseurs, du presse-papiers, du thème, etc.). RHI (rendering hardware interface) remplira ce rôle : tout le code de rendu de QPainter, du graphe de scène derrière Qt Quick, de Qt 3D n’utilisera plus directement OpenGL, mais bien RHI.

RHI ne sera pas la seule solution en place : en effet, chaque API de rendu nécessite d’utiliser son propre langage pour écrire des nuanceurs, utilisés pour le rendu (GLSL pour OpenGL, HLSL pour Direct3D, SPIR-V pour Vulkan, MSL pour Metal — sans oublier les différentes versions de chacun de ces langages). Les développeurs de Qt ont en tête de développer le module Qt Shader Tools pour automatiser la transpilation des nuanceurs d’un langage à l’autre (juste avant l’exécution ou en amont).

Cette solution a été préférée à l’utilisation de bibliothèques de traduction, comme Zink (une implémentation d’OpenGL par-dessus Vulkan pour le pilote libre Mesa Gallium), MoltenGL (OpenGL par-dessus Metal) ou ANGLE. En effet, il s’agirait d’introduire d’énormes dépendances externes dans Qt (Zink est un pilote, MoltenGL un produit commercial). Toute dépendance externe nécessite un certain niveau de maintenance de la part des développeurs de Qt (ils en ont eu l’expérience avec ANGLE dans Qt 5).

Toujours dans l’infrastructure nécessaire au niveau graphique, il faudra un moyen de compresser les textures à envoyer au processeur graphique : celui-ci n’apprécie que moyennement des formats comme PNG, qui n’offrent pas un bon rapport entre la consommation de bande passante et le temps de décompression. Qt disposera de l’infrastructure nécessaire pour ce faire, au moment de la compilation de l’application, en fonction de la cible matérielle visée.

[h=2]Interfaces graphiques[/h]

La 3D dans Qt a pas mal évolué depuis Qt 5, notamment avec l’ajout du moteur 3D Qt 3D, mais aussi d’un environnement de développement d’interfaces graphiques entièrement 3D, Qt 3D Studio. Cependant, l’intégration de parties 3D dans une interface graphique n’est pas toujours naturelle ; il est actuellement impossible de synchroniser image par image deux animations, l’une 2D, l’autre 3D.

Pour ce faire, Qt Quick et QML évolueront : il n’y aura plus qu’un seul moteur de rendu, qui se chargera des parties 2D et 3D simultanément, peu importe le niveau d’imbrication des deux. QML deviendra le langage de déclaration des interfaces 3D, en remplacement d’UIP. Les développements en ce sens sont déjà bien avancés, puisqu’une première version de ce “Qt Quick 3.0” sera disponible avec Qt 5.14.

La gestion des styles entre les widgets et Qt Quick laisse franchement à désirer : Qt Quick n’a pas de notion de style de la plateforme, le développeur doit donc adapter ses composants pour qu’ils ne détonnent pas parmi d’autres applications au look vraiment natif. Bien sûr, une solution a été proposée : Qt Quick Controls, mais seulement la première version. La deuxième a abandonné le rendu proche du natif pour des raisons de performance. Pour les widgets, QPA se charge de faire le lien avec les composants natifs. Qt 6 apportera un moteur de style uniformisé, adapté tant aux applications lourdes qu’aux mobiles, utilisable tant par des widgets que Qt Quick.

[h=2]Outillage[/h]

De nouveaux outils pour le développement d’interfaces graphiques ont récemment fait leur apparition. Qt Designer facilite la conception d’interfaces à base de widgets (il est aussi intégré à Qt Creator). Pour Qt Quick, au début fut Qt Creator et son éditeur graphique ; ensuite, pour la 3D, on a eu Qt 3D Studio ; finalement, pour la 2D, Qt Design Studio. De quoi y perdre son latin, surtout que ces outils partagent certains morceaux de code — même s’ils sont dupliqués dans chaque projet. À terme, l’outil de conception d’interfaces graphiques Qt Quick sera Qt Design Studio, dont le code est déjà très proche de celui de Qt Creator. Il sera principalement prévu pour les concepteurs d’interface, plus ou moins sans code.

Côté développeur, PySide a refait son apparition il y a peu : on peut utiliser Qt en Python avec une interface officielle, avec une licence LGPL. Pourtant, Qt Creator rattrape lentement son retard pour le code Python. À terme, Qt Creator sera l’outil de choix pour les développeurs.

Un dernier sujet dans les outils a déjà fait couler beaucoup d’encre : l’abandon de qmake (et de Qbs, au passage) pour la gestion de la compilation des projets Qt. Qt 6 n’utilisera pas d’outil spécifique à Qt, mais bien CMake, l’outil le plus répandu dans le monde C++. Cela signifie que Qt ne sera plus compilé avec qmake, mais bien uniquement CMake. A priori, qmake pourrait rester distribué avec Qt 6 pour faciliter la transition des projets.

[h=2]Langages[/h]

Lorsque Qt 5 est sorti, le langage C++ était dans une phase de renouveau : C++11 venait de sortir, le comité s’était mis en tête de faire avancer le langage et sa bibliothèque standard plus rapidement. Les compilateurs n’avaient pas vraiment eu le temps de suivre : Qt 5 a dû se cantonner à C++03, par manque de compilateurs C++11 suffisamment stables depuis un certain temps pour toutes les plateformes. En effet, Qt ne peut pas se permettre d’obliger ses utilisateurs à utiliser les toutes dernières versions des compilateurs, pour des raisons de rétrocompatibilité.

Pour Qt 6, la situation a bien changé : entre temps, les normes C++14, C++17 et, très bientôt, C++20 sont sorties. On dispose de trois compilateurs majeurs qui respectent relativement bien les dernières nouveautés de la norme (GCC, Clang et Visual C++). Cela signifie que Qt 6 nécessitera au moins un compilateur C++17. Cela permettra d’utiliser les nouvelles constructions pour coder Qt, mais aussi de faciliter l’intégration avec la bibliothèque standard de C++.

Parmi les dernières API apportées à Qt, certaines ne sont utilisables qu’en QML, pas en C++. La raison principale est la flexibilité apportée par l’environnement d’exécution de Qt Quick par rapport à QObject : on peut lier des propriétés entre elles pour effectuer des mises à jour automatiques quand la valeur de la première change. Ce système est implémenté par les signaux et slots de Qt, mais est bien plus compliqué à mettre en œuvre en C++. Surtout, faire le lien entre Qt Quick et C++ impose une surcharge importante (occupation de mémoire, mais aussi en temps de calcul).

Ce point ne devrait pas être sous-évalué : QObject aura droit à de grandes évolutions avec Qt 6, avec un nouveau système de propriétés et l’implémentation des liaisons de Qt Quick. Cela facilitera l’interaction entre les deux univers, Qt Quick n’ayant plus grand-chose de particulier par rapport à QObject.

[h=2]Compatibilité ascendante[/h]

La compatibilité entre versions de Qt est un sujet important, tant au niveau des binaires que des sources : tout changement dans Qt peut casser des milliards de lignes de code écrites par ses utilisateurs. Aussi, si la migration est trop difficile, beaucoup d’utilisateurs préféreront rester sur Qt 5, qui devra être maintenu plus longtemps.

Par conséquent, le principe de base pour la transition entre Qt 5 et Qt 6 sera de préférer des erreurs nettes à la compilation, plutôt que des changements de comportement non explicités auprès de l’utilisateur, ces derniers étant bien plus difficiles à remarquer. La plupart des changements n’impliquera cependant qu’une incompatibilité binaire (il faudra recompiler les applications avec Qt 6, sans modifier le code source) : les ruptures de compatibilité des sources seront mineures, la plupart du nettoyage de code prévu pouvant se faire en cassant simplement la compatibilité binaire.

Certaines parties de Qt ont été désapprouvées avec le temps, étant remplacées par de nouvelles approches. Néanmoins, même si les widgets sont près de cette situation, ils resteront disponibles avec Qt 6 : ils sont trop utilisés pour que Qt puisse s’en passer. (Il n’est toutefois pas impossible que le système de widgets ait droit à un peu de modernisation, mais sans aucune certitude.)

Source : Technical vision for Qt 6.

Une erreur dans cette actualité ? Signalez-le nous !

Responsable bénévole de la rubrique Qt : Thibaut Cuvelier -

Partenaire : Hébergement Web