Selon ses développeurs, la version finale de Qt Creator 4.0 ne tardera plus : la RC 1, sortie aujourd’hui, s’occupe de corriger un bon nombre de défauts détectés depuis la sortie de Beta, il y a à peu près un mois.

Les principaux changements depuis la dernière préversion concernent l’interface, avec un thème plat lustré : il est maintenant le thème par défaut de Qt Creator, les utilisateurs n’ayant jamais changé de thème le verront par défaut lors de la mise à jour. L’ancien thème est bien sûr toujours disponible, dans le menu Outils, Options, Environnement, Interface (option Classique).

Les binaires de cette nouvelle préversion sont disponibles sur la page des téléchargements de Qt.

Source : Qt Creator 4.0 RC1 released.

Qt est un framework C++ complet, parti des interfaces graphiques dans les années 1990 (avant la normalisation de C++) et maintenant extrêmement généraliste. L’un de ses points forts est probablement la connexion entre signaux et slots pour écrire des applications interactives : lorsqu’il se passe quelque chose dans l’application (l’utilisateur appuie sur un bouton, un paquet arrive du réseau, etc.), un signal est émis ; ensuite, le programmeur peut connecter un slot à ce signal : ce bout de code sera exécuté chaque fois que le signal sera émis. Pour implémenter cette fonctionnalité, dans les années 1990, vu l’état disparate des compilateurs, utiliser les templates C++ était impossible : les développeurs de Qt ont alors utilisé un générateur de code, nommé moc (metaobject compiler), qui sert d’autres objectifs (l’introspection et la réflexion, notamment). Avec les années, le système a été conservé, malgré le bon nombre de critiques : son importance a encore un peu grandi lors de l’arrivée de Qt Quick. Olivier Goffart, actuel mainteneur de l’outil, tente de remettre les pendules à l’heure.

Quelques mythes

moc ne réécrit pas le code qui lui est passé, il ne le réécrit pas : il l’analyse et génère de nouveaux fichiers C++, qui sont ensuite compilés de manière totalement indépendante. Sans l’outil, pour utiliser l’architecture actuelle de Qt, il serait nécessaire d’écrire de grandes quantités de code pour les tables d’introspection et d’autres détails nécessaires pour le fonctionnement des signaux et slots.

Il se concentre sur une série de macros définies par Qt pour générer son code : Qt ne définit pas de « nouveaux mots clés » C++. Pour définir une classe héritant de QObject, la macro Q_OBJECT évite au programmeur d’écrire une série de déclarations de fonctions (dont le code est généré par moc). Les signaux sont définis dans un bloc signals:, qui n’est autre qu’une macro qui correspond à public:. Bon nombre d’autres macros utilisées par le moc ne génèrent aucun code. Globalement, le code Qt reste du code C++, ce qui fait que tous les outils C++ traditionnels restent utilisables.

Son utilisation ne complique pas la compilation ou le débogage : la plupart des systèmes de compilation traitent de manière native moc ; de toute façon, il s’agit simplement d’une commande supplémentaire à appliquer sur les fichiers d’en-tête. En cas d’erreur à la compilation (ce qui est très rare), le code généré est plus facile à comprendre que l’embrouillamini généré par les templates C++.

Certains ont tenté de supprimer moc, comme CopperSpice, en promettant notamment une amélioration de performance. Cependant, cette affirmation n’est pas sous-tendue par des chiffres : le graphique ci-dessous indique que la taille des exécutables générés est bien plus grande avec CopperSpice (sans moc) que Qt (4 ou 5, avec moc). De manière générale, le code généré par moc est très efficace : il est entièrement statique et évite toute allocation dynamique de mémoire, ses données sont stockées dans les segments de données en lecture seule — là où CopperSpice génère ces mêmes données à l’exécution.

Finalement, moc évolue : depuis Qt 5, il gère complètement les macros, ce qui permet de les utiliser pour définir des signaux, des slots, des classes de base, etc. Q_PROPERTY n’autorisait pas, jusqu’il y a peu, les virgules dans ses arguments (par exemple, en lui passant un QMap), ce qui a été réglé en un rien de temps.

Des fonctionnalités absentes

Finalement, la plus grande critique de moc est probablement qu’il ne gère pas les classes avec des templates, des classes imbriquées ou l’héritage multiple. Cependant, si elles ne sont pas implémentées, c’est principalement parce qu’elles ne sont pas jugées importantes. Par exemple, une implémentation des templates a été rejetée il y a trois ans ; moc-ng, une implémentation de moc sous la forme d’extension du compilateur Clang, gère sans problème les templates et les classes imbriquées. L’héritage multiple reste possible à condition que QObject soit la première classe de base — ce qui permet bon nombre d’optimisations, de telle sorte que qobject_cast est bien plus rapide que la version standard dynamic_cast.

Et donc ?

moc n’est pas vraiment un problème, ses plus grands pourfendeurs sont généralement ceux qui le connaissent le moins. L’API et notamment le système de métaobjets et la connexion entre signaux et slots sont à la base du succès de Qt. Les avantages des autres solutions sont loin d’être clairs et moc n’est pas une limitation pour les développeurs.

Source : Moc myths debunked.

Qt est principalement prévu pour le développement d’interfaces graphiques, il n’empêche que ses fonctionnalités sont suffisamment générales et découplées les unes par rapport aux autres pour implémenter une couche de développement Web complète comme Cutelyst. Ainsi, il devient très facile de partager du code métier entre une application mobile, une application traditionnelle de bureau et un site Web, le tout dans la sphère Qt.

Au niveau des améliorations principales, les classes d’envoi de courriels View::Email peuvent s’enchaîner avec d’autres vues, notamment avec Grantlee, ce qui permet d’utiliser les mêmes outils que pour les pages affichées. Au niveau de Utils::Sql, la compatibilité avec les classes du module Qt SQL est améliorée, avec des fonctions pour sérialiser des QSqlQuery en QVariantList, ainsi que la gestion des requêtes préparées.

De manière générale, la version de Qt minimale est maintenant la 5.5, ce qui permet de nettoyer une partie du code, notamment pour la lecture de fichiers JSON. Cette nouvelle version de Cutelyst n’apporte cependant pas d’amélioration notable au niveau de la performance pour les tests exécutés par rapport aux résultats de Cutelyst 0.10, même si les changements du côté de QString dans Qt 5.6 auraient pu apporter beaucoup. Les conclusions devraient être différentes pour des applications bien plus lourdes que celles essayées (notamment avec Grantlee et des requêtes SQL).

Source : Cutelyst 0.11.0 released!

Finalement, Qt 5.6 est sorti en version finale, prête pour le grand public, avec un certain retard — Qt 5.7 est d’ores et déjà bien sur les rails. Ces délais sont dus à une nouvelle infrastructure mise en place pour garantir la faisabilité de la promesse première de Qt 5.6 : une assistance technique à long terme (LTS). Ainsi, pendant les trois années à venir, de nouvelles versions seront publiées avec des correctifs pour tous les défauts qui seront découverts dans cette version, au niveau des fonctionnalités et de la sécurité.

Infrastructure

Le travail d’infrastructure a principalement porté sur un système d’intégration continue, nommé COIN, après une année de travail. Il remplace le système précédent, déjà enfanté dans la douleur, qui exploitait Jerkins. COIN a le principal avantage d’être incrémental, ce qui accélère fortement le test des modifications apportées au code source de Qt. Ce système utilise notamment les mêmes configurations que celles des paquets binaires fournis à chaque nouvelle version, ce qui limitera aussi fortement le temps requis pour la génération des paquets. En conséquence, grâce à COIN, les développeurs pourront tester leur code sur un plus grand nombre de configurations, pour s’assurer d’une très haute qualité.

Windows 10

Dès Qt 5.5, la compatibilité avec Windows 10 est assurée. Avec cette nouvelle version, elle est encore améliorée, avec notamment l’utilisation des API Win32 (classiques) et WinRT (modernes, pour les applications distribuées par le Windows Store). Ainsi, pour déployer son application dans le Windows Store, la principale modification à effectuer sera une recompilation avec la version adaptée de Qt.

Les binaires de Qt sont maintenant aussi disponibles pour Visual C++ 2015. par contre, pour l’intégration à Visual Studio 2015, il faudra encore attendre un peu : l’extension utilise des mécanismes de Visual Studio désapprouvées depuis quelques années et maintenant supprimés. Elle est actuellement en cours de réécriture complète, ce qui aura aussi pour avantage de la rendre compatible avec l’édition Community (gratuite) de Visual Studio (précédemment, l’extension Qt n’était disponible que pour les éditions payantes de Visual Studio).

Écrans à haute résolution

Les développeurs de Qt 5.6 ont beaucoup porté attention aux écrans à haute résolution (comme l’écran Retina des MacBook d’Apple), sur toutes les plateformes : le niveau de qualité autrefois disponible uniquement sur OS X est maintenant atteint pour Windows et Linux. Les applications écrites pour une résolution traditionnelle s’adapteront automatiquement aux densités de pixels bien plus importantes des écrans haut de gamme actuels — même lors du passage d’un écran à l’autre quand les densités varient. Ces modifications s’appliquent tant aux applications Qt Widgets que Qt Quick.

Qt WebEngine

Le nouveau moteur Web, Qt WebEngine, basé sur Chromium (le moteur de Google Chrome), a vu bon nombre d’améliorations depuis Qt 5.5. Une mise à jour de Chromium a été effectuée vers la version 45, ce qui apporte moult nouvelles fonctionnalités et corrections de défauts. De plus, les extensions Pepper (PPAPI) sont maintenant gérées : il est possible d’afficher des animations Flash, par exemple. La configuration des serveurs mandataires de Qt est aussi utilisée, au lieu des paramètres par défaut de Chromium. L’API WebActions est maintenant disponible, comme elle l’était pour Qt WebKit. Pour Linux, afin de contrer les griefs exprimés par certains mainteneurs de distribution, les bibliothèques système sont privilégiées par rapport à des versions non partagées.

Un autre module a fait son apparition : Qt WebEngineCore, qui n’expose que des API de bien plus bas niveau. Ainsi, il devient possible de définir de nouveaux protocoles pour les URL, par là d’intercepter ou de bloquer des requêtes qui passent sur le réseau, mais aussi de tracer et de bloquer les témoins de connexion.

Télécharger Qt 5.6.

Source : Qt 5.6 released

En simultané avec Qt 5.6.0, une nouvelle version de Qt Creator est disponible, numérotée 3.6.1.

Elle corrige principalement des défauts, comme des plantages inopinés, une intégration améliorée avec Clang et quelques régressions au niveau du débogage. Qt 5.6 est maintenant disponible dans les assistants de création de projet Qt Quick. Les Microsoft Visual C++ Build Tools sont maintenant détectés automatiquement comme kit de compilation.

Les paquets binaires sont maintenant compilés avec Qt 5.6.0.
Liste complète des modifications.
Télécharger Qt Creator 3.6.1.

La première préversion de Qt 5.7 pointe le bout de son nez, peu de temps après Qt 5.6 RC. À cause de retards du côté de Qt 5.6, les deux versions ont été développées en parallèle : quand Qt 5.6 se focalisait sur la stabilisation, Qt 5.7 s’enrichissait en fonctionnalités.

Parmi les nouveautés, la compatibilité avec C++98 ne sera plus nécessaire, ouvrant des perspectives avec C++11 ; les Qt Quick Controls verront leur deuxième version, plus optimisée pour les plateformes embarquées ; Qt 3D sera disponible en version finale ; Qt SerialBus gérera les communications par bus série. L’évolution se fera aussi au niveau des licences, allant de pair avec la libération d’une série de modules précédemment uniquement disponibles dans les éditions commerciales : Qt Chart, Qt Data Visualization, Qt Purchasing, Qt Virtual Keyboard et Qt Quick 2D Renderer.

Source : Qt 5.7 Alpha Released

Pour sa première version libre, Qt Virtual Keyboard vient avec un nouveau pan de fonctionnalités : la reconnaissance d’écriture. Jusqu’il y a peu entièrement commercial, ce composant est maintenant disponible sous licence GPLv3. Il ne sera pas disponible avec toutes les éditions de Qt 5.6 (il devra être téléchargé et compilé séparément), mais il sera bien intégré dès Qt 5.7 comme n’importe quel autre module d’extension.

Ce module contient un clavier virtuel, principalement à destination des écrans tactiles dans des applications dépourvues de clavier physique (comme sur téléphone ou bon nombre d’applications embarquées). Il est principalement prévu pour être utilisé en QML et peut être étendu à de nouvelles langues ou disposition facilement.

Reconnaissance d’écriture

Qt Virtual Keyboard peut utiliser deux moteurs pour ses nouvelles fonctionnalités de reconnaissance d’écriture : Lipi, un logiciel libre, ou T9 Write, son pendant commercial. Le premier a été intégré dans les sources du composant, il a également été optimisé, principalement à cause de sa performance inadéquate pour les plateformes embarquées (il a d’abord été prévu pour des téléphones Android). Les étapes de reconnaissance et de chargement des modèles ont été accélérées de dix à quarante pour cent, ce qui le rend plus compétitif par rapport à la concurrence commerciale.

L’utilisateur peut dessiner ses caractères partout sur l’écran, pas seulement dans la zone réservée au clavier, à l’aide d’un double clic dans cette zone — ce qui a pour impact de cacher le clavier.

Chinois traditionnel

L’autre grande modification par rapport aux versions précédentes concerne l’entrée de texte en chinois traditionnel, un jeu d’idéogrammes utilisé dans certaines régions comme Hong Kong ou Taïwan, avec trois méthodes d’entrée : pinyin (qui correspond au chinois simplifié, utilisé en Chine continentale, avec une translittération dans l’alphabet latin), cangjie (qui exploite l’étymologie des idéogrammes) et zhuyin (qui utilise un alphabet phonétique).

Clavier pinyin

Clavier cangjie

Clavier zhuyin

Source (dont images) : Qt Virtual Keyboard Updated with Handwriting Recognition

L’année 2016 promet sa dose d’actualité Qt, avec trois versions qui devraient voir le jour : Qt 5.6 en mars, Qt 5.7 en mai et Qt 5.8 en octobre. De manière générale, Qt vise une haute qualité sur toutes les plateformes gérées (qu’elles soient plus ou moins mobiles) tout en limitant le temps de mise sur le marché pour ses utilisateurs. C’est pourquoi Qt 5.6 a été retardé : cette version aurait dû voir le jour en décembre dernier. Le cÅ“ur de Qt n’est pas très spécifique à un environnement ou l’autre, même si un bon nombre de fonctionnalités plus orientées vers l’une ou l’autre industrie en particulier : par exemple, les débats ont récemment tourné autour du protocole CAN, prévu pour la communication entre microcontrôleurs dans l’automobile ; l’implémentation a mené à un module Qt SerialBus, qui est bien plus général que le type de bus visé au départ, l’API pouvant alors être généralisée à d’autres types de bus en série, comme Modbus ou OPC-UA.

Qt 5.6 : première version avec support à long terme

Qt 4.8 est sorti en 2013, mais a été maintenu pendant plusieurs années, alors qu’une version de Qt normale ne l’est que pendant quelques mois. Il n’y avait pas encore eu de version avec un support à long terme dans la branche Qt 5 et cela arrivera avec Qt 5.6. Par rapport à Qt 4.8, les améliorations sont très nombreuses, avec notamment une accélération matérielle pour l’affichage, peu importe la technologie employée ; Qt Quick y voit sa deuxième version majeure, avec une plus grande maturité ; les plateformes mobiles sont mieux gérées.

Qt 5.6 aura droit à du support pendant trois ans à compter de sa date de sortie, c’est-à-dire jusqu’en 2019. Les nouveautés des versions de Qt qui suivront ne seront pas réintégrées, à l’exception des corrections de défauts, notamment de sécurité. Pour son développement, Qt 5.6 a vu les efforts converger vers une amélioration générale de la qualité du code et la parité entre plateformes au niveau des fonctionnalités. Cette version avec support à long terme permettra de limiter en partie la rétrocompatibilité pour les versions à venir : Qt se tournera vers C++11, sans plus chercher à être compatible avec les plus vieux compilateurs et la norme C++98.

La fonctionnalité phare de Qt 5.6 sera la gestion des écrans à haute résolution, un mouvement initié par Apple avec ses écrans Retina. Qt ajustera automatiquement son affichage à la résolution de l’écran : taille de police, icônes, graphiques, etc. Surtout, les applications s’ajusteront automatiquement lors du passage d’un écran à un autre possédant une résolution plus élevée, chose traditionnellement mal gérée par les applications.

Qt 5.7 : des modules en tout sens

Puisque Qt 5.6 sera là pour les compilateurs les plus anciens, Qt 5.7 pourra s’orienter définitivement vers C++11 : là où il n’était pas impossible d’utiliser certaines nouvelles fonctionnalités du langage dans Qt (comme la connexion de signaux à des fonctions anonymes), Qt 5.7 pourra utiliser C++11 directement dans l’implémentation de ses modules, nouveaux ou plus anciens, sans contrainte particulière. Le module Qt SerialBus sera le premier à profiter de ce traitement de faveur.

Qt 5.7 arrivera avec une pléthore de nouvelles fonctionnalités, changements qui viennent en parallèle avec une évolution des licences. Tout d’abord, trois modules quitteront le statut de préversion technologique (sans support officiel, donc) :

• Qt Quick Controls 2, un ensemble de composants Qt Quick réécrits et optimisés ;
• Qt 3D, un moteur 3D multifil pour Qt en C++ et Qt Quick ;
• Qt SerialBus, un système de communication par bus série depuis une application Qt, actuellement pour CAN et Modbus.

Ensuite, plusieurs modules seront libérés : ils étaient disponibles exclusivement sous licence commerciale, ils seront disponibles dans l’édition libre. Ces modules sont au nombre de cinq :

• Qt Charts, pour la visualisation en 2D de données ;
• Qt Data Visualization, pour la visualisation en 3D de données ;
• Qt Purchasing, une API multiplateforme pour gérer les achats depuis les différentes boutiques en ligne pour chaque plateforme ;
• Qt Virtual Keyboard, un clavier virtuel adaptable, gérant plusieurs langues et la reconnaissance d’écriture ;
• Qt Quick 2D Renderer, un moteur d’affichage pour les applications Qt Quick 2 sans accélération OpenGL.

Finalement, deux nouveaux modules feront leur apparition en qualité de préversion technologique : Qt Wayland Compositor et Qt SCXML, qui généralise les fonctionnalités de machines d’états.

Qt 5.8 : plus modulaire, plus optimisé, plus Vulkan

Qt 5.8 devrait arriver fin de cette année. Quand Qt 5.7 apportera bon nombre de fonctionnalités plus incrémentales, Qt 5.8 retournera au niveau des fondations pour préparer le futur, des changements qui continueront dans les versions futures et qui s’inscrivent dans la lignée de Qt 5.0 (une modularisation accrue, une utilisation d’OpenGL pour tout l’affichage). Un des points sera l’optimisation de l’utilisation de la mémoire, rapidement problématique dans l’embarqué.

Qt 5.0 est venu avec une architecture bien plus modulaire qu’auparavant, avec une série de modules formant le cÅ“ur de Qt et des ajouts : il n’est pas nécessaire d’inclure tous les modules dans une application (contrairement à Qt 3), avec une séparation plus claire que du temps de Qt 4. Par contre, les interdépendances entre modules sont toujours fortes : il est parfois nécessaire d’inclure un module pas très utile pour bénéficier de fonctionnalités dans un autre, ce qui est rapidement problématique dans les applications embarquées, par définition limitées, y compris au niveau du stockage. L’objectif est de créer une configuration minimale pour Qt Quick pour limiter le nombre de dépendances, ce qui impliquera des changements au moins dans les modules Qt Core, Qt GUI et Qt Declarative.

KDAB et la Qt Company sont membres de Khronos, le consortium qui se charge de la spécification de normes comme OpenGL ou Vulkan. Ce n’est pas un hasard : Qt 5.8 devrait retirer la dépendance directe envers OpenGL au niveau du graphe de scène, qui devrait être remplacée par une abstraction permettant de choisir entre différentes API. Les premiers pas devraient venir avec Qt 5.8, avec à terme l’utilisation des dernières API graphiques disponibles sur chaque plateforme — et la suppression d’ANGLE côté Windows (une implémentation d’OpenGL utilisant DirectX).

Finalement, une dernière technologie anciennement propriétaire devrait être libérée : le Qt Quick Compiler. Il ne sera plus disponible sous la forme de module séparé, mais bien directement dans Qt Declarative, pour compiler en code natif les interfaces Qt Quick. Les objectifs sont multiples : améliorer fortement la performance sur les plateformes qui ne peuvent pas bénéficier de technologies JIT (iOS et Windows RT), mais aussi diminuer les temps de démarrage des applications.

Qt Creator 4.0 : une apparence plus moderne, plus de Clang, plus de CMake

Une nouvelle version majeure de Qt Creator, l’EDI Qt, fera également son apparition, normalement en avril. Tout comme Qt, une série de fonctionnalités transitera de l’édition commerciale vers la version libre, comme un profilage avancé, un analyseur statique de code ou encore un éditeur visuel Qt Quick bien plus poussé. L’interface sera rafraîchie avec de nouvelles icônes, plus modernes. L’interface des extensions sera également revisitée ; Clang sera de plus en plus utilisé, lui qui arrive petit à petit dans l’éditeur depuis plusieurs versions. Également, CMake sera mieux géré dans l’éditeur.

Source : Qt Roadmap for 2016.

L’une des premières applications à utiliser Qt fut KDE, un environnement de bureau — plutôt que des ensembles d’application, comme c’était monnaie courante en 1996. Cependant, Qt n’était pas exactement un logiciel libre : sa licence n’était pas compatible avec la GPL selon la Free Software Foundation ; si la société devait être rachetée, le projet KDE courait le risque de ne plus pouvoir utiliser Qt dans ses versions à venir. Cette crainte a mené à la création de la KDE Free Qt Foundation, qui matérialise un accord avec les différentes sociétés derrière Qt et son exploitation commerciale : si jamais Qt n’était plus développé ou libre, alors la dernière version libre serait disponible sous une licence très permissive comme la BSD, automatiquement.

Cet accord avait déjà été mis à jour, la dernière fois en 2014 lors de l’ajout de la LGPLv3 dans les licences : le premier accord ne faisait pas état d’un grand nombre de plateformes concernées — seulement X11 —, alors que toutes les plateformes avec lesquelles Qt est compatible sont concernées ; de même, suite aux changements de gouvernance et la création du Qt Project, les contributions, intégrées ou non aux sources de Qt, sont comprises dans ce texte juridique. Avec ce nouvel accord, la compatibilité avec Linux et Android ne pourra pas être abandonnée (contrairement aux autres plateformes, où Digia reste libre), à moins d’une révision ; la fondation s’est aussi arrogée le droit d’y inclure les successeurs de X11, comme Wayland, sans négociation.

La principale nouveauté concerne cependant les licences de la version libre de Qt, pour les aligner avec la « philosophie du logiciel libre ». En 2014, la licence LGPLv3 a été ajoutée pour mieux respecter cette philosophie. Par rapport à la version précédente (2.1), elle garantit non seulement le droit de l’utilisateur à modifier les sources, mais aussi à les compiler et à les exécuter — ce qui empêche directement de bloquer complètement des appareils, afin de forcer la création d’un environnement libre. Un autre apport important concerne la protection par rapport aux brevets, très importante outre-Atlantique.

Ce nouvel accord sera d’application dès Qt 5.7 et supprime la LGPLv2.1 à cause de ces limitations et impose que le nouveau code soit disponible sous LGPLv3 et GPLv3 (le code existant doit aussi être disponible sous GPLv2 pour rester compatible par rapport à d’autres projets libres). Les différentes parties de Qt et de son environnement de base seront alors disponibles sous des régimes différents (tous seront toujours disponibles dans une édition commerciale, plus flexible mais non libre) :

• pour les modules essentiels (Qt Core, GUI, Quick, Network, etc.) : LGPLv3 et GPLv2 ;
• pour les modules d’extension (Qt Android Extras, Bluetooth, Concurrent, OpenGL, etc.) : LGPLv3 et GPLv2, à l’exception de Qt WebEngine (à cause de Chromium, le code est également disponible sous LGPLv2.1) ;
• pour les outils et applications (Qt Creator, moc, lupdate, etc.) : GPLv3, avec deux exceptions pour que le code généré n’ait aucune restriction et que les liens avec du code tiers soit toujours possible.

De manière générale : tout Qt est disponible sous la GPLv3 ou une licence compatible ; de larges pans sont aussi disponibles sous la LGPL et la GPLv2. Ces changements arriveront dès Qt 5.7 : la 5.6 étant une version avec support à long terme, les projets devraient avoir le temps de s’adapter à ces changements au besoin.

En même temps, de nouveaux modules, anciennement uniquement commerciaux, seront disponibles sous une licence libre (GPLv3) : dès Qt 5.7, Qt Charts, Qt Data Visualization, Qt Virtual Keyboard, Qt Test Integration, Qt Quick 2D Renderer, QML Profiler et l’analyseur statique pour Clang. L’objectif est d’inclure le compilateur Qt Quick dans le module Qt QML (LGPLv3 et GPLv2), qui devrait arriver avec Qt 5.8. Le code de la plupart des modules est déjà disponible, les autres devraient arriver sous peu. Par contre, l’offre spécifique à l’embarqué (Qt for Device Creation) reste entièrement commercial.

Cette annonce confirme la volonté d’uniformiser l’écosystème Qt, lancée avec le site qt.io, commun aux éditions libres et commerciales. La stratégie reste de fournir des fonctionnalités spécifiques sous licence commerciale pour garantir un flux de liquidités et assurer la suite du développement de Qt, tout en offrant beaucoup dans l’offre libre pour que Qt rayonne. Cependant, elle semble s’axer de plus en plus vers le monde de l’embarqué.

Sources : New agreement with the KDE Free Qt Foundation and changes for the open source version, Qt is Guaranteed to Stay Free and Open – Legal Update

Voir aussi : le contrat.