Vue d’ensemble

Avant de commencer, une remarque sur Windows. À priori, il est possible de travailler sur Windows. Cependant, les binaires Qt pour Android ne sont disponibles que pour Linux. Comme la compilation de Qt pour Windows est pénible et que je ne l’ai pas faite depuis longtemps, je présente seulement l’utilisation de Linux. Pour ceux qui aimeraient pouvoir utiliser Windows… tant pis pour vous

Je n’avais pas testé Qt sur Android depuis quelques temps, en fait depuis Qt 4.8 et Necessitas. Du coup, j’ai découvert le portage Android dans Qt 5.1 en même temps que je prenais des notes pour cet article. Comme base de travail, je suis parti des pages des pages de documentation de Qt : Qt – Android support.

L’utilisation de Qt sur Android nécessite l’installation de plusieurs outils :

• la version de Qt 5.1 pour Android : ok, on s’y attendait un peu. Contient la bibliothèque complète et Qt Creator ;
• le kit de développement (SDK) pour Android : permet de créer des applications Java pour Android et un simulateur pour tester ses applications ;
• le kit de développement natif (NDK) pour Android : permet de créer des applications C++ pour Android ;
• l’environnement d’exécution de Java (JRE) : nécessaire pour le SDK Android ;
• Apache Ant : pour faire beau. (bon ok, ce n’est pas que pour faire beau, ça sert au déploiement. Mais comme c’est un outil Java, je ne connais pas du tout).

Dans ce tutoriel, je vais montrer l’utilisation de Qt Creator, mais il doit être possible d’utiliser d’autres outils.

Installations

Installation de OpenJDK 7

Pour commencer, il faut installer l’environnement d’exécution de Java. Il est fort possible qu’il soit déjà installé. Dans la documentation, il est indiqué qu’il faut par exemple OpenJDK en version 6 ou plus récente.

Personnellement, j’avais la version 7. Cependant, j’ai eu des problème avec Apache Ant, qui me retournait une erreur. J’ai donc dû installer la version 6 en plus. Comme j’ai pas mal bidouillé, je ne suis pas sûr de la procédure. Si des personnes testent et remarquent des problèmes, n’hésitez pas à me le signaler.

Merci à rotoOm qui m’a indiqué l’origine du problème. Il suffit en fait d’installer le JDK en plus du JRE. Merci à lui pour l’information.

Vous pouvez tester si Java est installé avec la ligne de commande suivante :

Pour l’installation, j’ai donc utilisé les paquets fournis par Ubuntu. Il faut donc juste taper ces lignes de commande :

Pour les autres systèmes Linux, vous pouvez consulter la page de documentation d’OpenJDK : How to download and install prebuilt OpenJDK packages.

Installation d’Apache Ant

Pour l’installation d’Apache Ant, même méthode, j’utilise les paquets Ubuntu :

Pour tester l’installation d’Apache Ant, vous pouvez taper la ligne de commande suivante :

Installation du SDK Android

Pourquoi installer le kit de développement Java ?

Pour commencer, on ne peut se poser une question : pourquoi installer le kit de développement Java et le kit de développement natif et pas simplement ce dernier ? La réponse est simple : parce qu’on ne peut développer que en Java pour Android !

Ok…

Donc cela veut dire qu’il faudra utiliser le binding Java de Qt ? On parlait pas de développement C++ dans ce tutoriel ?

Oui, pas d’inquiétude En fait, il y a un point à savoir sur les applications natives C++ sur Android. C’est une application Java qui appelle un « module » écrit en C++ (on utilise le terme « activité » en Java). Avec Qt, on va donc simplement créer notre code C++/Qt et Qt Creator va s’occuper de créer l’application Java qui appelle notre code.

Ouf !

Installation

L’installation du SDK Android est simple aussi… puisqu’il n’y a pas d’installation à faire. Vous devez simplement télécharger le kit de développement pour Android et décompresser l’archive. Ce SDK contient les outils de développement Android, des plateformes de compilation, l’éditeur Eclipse ADT (Android Developer Tools, configuré spécialement pour Android), un simulateur Android pour tester ses applications.

Pour installer d’autres outils, par exemple d’autres versions de plateforme, vous pouvez utiliser le SDK Manager. Dans Eclipse ADT, allez dans le menu Windows puis Android SDK Manager.

Tester Eclipse

Comme je suis curieux et que j’ai envie de voir un peu comment fonctionne une application Java sur Android, j’ai testé un peu Eclipse et Java. Ceux qui ne sont pas intéressés, vous pouvez passer directement à l’installation du NDK.

Pour cela, j’ai simplement suivi le tutoriel : Building Your First App (il faut reconnaître que la documentation est très claire et simple à suivre, même pour un développeur C++ comme moi).

Allez dans le répertoire d’installation du SDK Android puis dans le répertoire eclipse/. Celui-ci contient un binaire eclipse, que vous lancez. Si c’est la première utilisation d’Eclipse, il va falloir faire quelques réglages de configuration. En premier le Workspace (l’espace de travail d’Eclipse, dans lequel il range les fichiers). Personnellement, j’ai accepté toutes les valeurs par défaut.

Une fois qu’Eclipse est lancé, créez un nouveau projet de type « Android Application Project » dans Fichier puis Créer un projet. Un dialogue permet de donner un nom à votre application (c’est le nom qui apparaîtra sur le téléphone), la version minimale d’Android à prendre en charge et la version Android de destination. J’ai laissé par défaut. Vous pouvez ensuite choisir l’icône de l’application et le type d’activité. Choisissez BlanckActivity, qui va créer une activité « hello world ».

Après quelques minutes (je vais rien dire que la lenteur d’Eclipse…), un projet est créé, qui contient quelques fichiers et répertoires. Les plus importants sont :

• le fichier AndroidManifest.xml : contient les informations sur l’application, en particulier les versions minimale et ciblée de la plateforme ;
• le répertoire res/layout/ : contient les interfaces de l’application, décrites dans des fichiers XML ;
• le répertoire src/ : contient les sources Java du projet. Dans ce projet par défaut, il lance simplement une activité, qui affiche l’interface décrite dans le fichier XML de layouts/ ;
• les répertoires res/drawable-xxx/ : contient les images de l’application.

Comme c’est une application Android, vous ne pouvez pas simplement la lancer comme une application de Bureau classique. Il existe deux méthodes pour la lancer : utiliser un simulateur ou déployer sur un téléphone.

Tester l’application sur simulateur

Pour cela, il faut dans un premier temps créer un simulateur. Le SDK Android est fournit avec un gestionnaire, permettant de créer différentes configurations pour le simulateur, permettant ainsi de tester l’application sur plusieurs types de téléphone.

Allez dans le menu Windows puis Android Virtual Device Manager. Dans le dialogue, créez un nouveau périphérique en cliquant sur « New », puis configurez selon le type de téléphone que vous voulez tester. Par exemple, comme j’ai un téléphone Samsung Galaxy S1, j’ai choisit un écran 4″ en 480*800. Après la création du périphérique, lancez-le.

Lancez ensuite l’application en ouvrant le fichier java (dans src/) puis en cliquant sur le bouton Run. Un dialogue « Run As… » s’ouvre pour choisir comment exécuter l’application. Choisissez Android Application. Normalement, l’application devrait se lancer.

Tester l’application sur téléphone

Bon, un simulateur, c’est bien, mais on aimerait avoir l’application sur un vrai téléphone pour tester. Ce n’est pas très compliqué non plus, mais il va falloir faire une manipulation sur le téléphone. Celle-ci permet d’activer les fonctionnalités de développement du téléphone, en particulier le Debug Mode USB, qui permet de déployer des applications via un cable USB.

Pour Android 4.2, allez dans les paramètres puis dans le menu À propos du téléphone. Cliquez plusieurs fois sur Numéro de build par activer le mode développeur. Vous allez avoir un message confirmant le passage en mode Debug. Revenez ensuite à l’écran précédent et allez dans les options de développeur. Activez le mode Debug USB. Pour les autres versions d’Android, vous pouvez consulter la page suivante : Run on a Real Device.

Pour terminer, il suffit de brancher le téléphone sur l’ordinateur avec un câble USB puis de lancer l’application comme précédemment. L’application devrait se lancer sur le téléphone.

Installation du NDK Android

Rien de compliqué ici non plus, il n’y a pas d’installation à faire, il faut simplement décompresser l’archive.

Installation de Qt Android

Le plus simple, comme indiqué au début de ce tutoriel, est d’utiliser les binaires fournis de Qt 5.1 pour Android. Si vous n’utilisez pas Ubuntu, il vous faudra compiler Qt vous-même. Bon courage

Lancez le binaire Qt pour Android. Le processus d’installation est classique, avec une particularité : le SDK propose par défaut l’installation de Qt Desktop, mais pour Android (versions ARM ou x86), il faut l’activer soi-même. Une fois l’installation finie, allez dans les répertoires Tools, QtCreator, bin puis lancez qtcreator.

La première étape va être de configurer Android. Pour cela, allez dans le menu Outils puis Options. Dans la liste de gauche, allez dans Android, puis configurez les répertoires du SDK et du NDK. Cochez la case pour laisser Qt Creator créer automatiquement les kits de compilation.

Il faut ensuite créer un périphérique pour le simulateur si ce n’est pas encore fait. Pour cela, cliquez sur le bouton Start Android AVD Manager.

Cliquez sur New pour créer un nouveau périphérique. Choisissez le type de Device (pour simuler mon Galaxy S, j’ai donc choisit un 4″ en 480*800). N’oubliez pas d’activer la prise en charge du GPU (Use Host GPU) pour que Qt puisse utiliser OpenGL ES.

Pour créer une application Qt, allez dans le menu Fichier puis Nouveau projet. Choisissez un projet compatible avec Android (par exemple Application Graphique Qt ou Application Qt Quick 2 (élément de base)).

Dans un premier temps, le simulateur se lance.

Puis l’application à la fin du déploiement.

Pour déployer sur un téléphone (préalablement passé en mode Debug USB, voir au début), il suffit simplement de le brancher, Qt Creator lancera alors l’application dessus.

Conclusion

Rien de très compliqué finalement. Le déploiement est relativement simple une fois que les outils sont configurés. Reste plus qu’à tester les performances.

Pour ceux qui sont intéressés par Qt Quick, je rappelle le livre auquel je participe : Créer des applications avec Qt 5 – Les essentiels. J’ai en particulier participé à la rédaction de Qt Quick. C’est encore une pré-version du livre final, mais il y a déjà pas mal de choses sur Qt Quick. Et n’hésitez pas à me dire s’il y a des points que vous souhaiteriez voir abordés dans ce livre.

Si vous êtes intéressé par Qt Quick sur mobile, je fais une présentation le 5 juin à Paris. Contactez-moi par MP pour plus d’informations.

Merci à prgasp77 et winjerome pour leur relecture orthographique.

N’hésitez pas à commenter cet article sur le forum.

Un problème que l’on revoit souvent sur le forum est l’installation de Qt 5. J’ai réalisé, dans le cadre du livre sur Qt auquel je participe (Créer des applications avec Qt 5 – Les essentiels), plusieurs vidéos pour expliquer comment installer et tester l’installation.

Il y a quatre vidéos pour le moment :

• installation sur Windows avec Microsoft Visual C++ 2010 ;
• installation sur Windows avec MinGW ;
• installation sur Linux en utilisant les binaires ;
• installation sur Ubuntu en utilisant les dépôts.

Les vidéos sont disponibles sur le site de l’éditeur : D-booker.fr (YouTube).

Je n’ai pas fait de prise son, donc penser à activer les sous-titres pour avoir les explications. J’essaierais de proposer prochainement d’autres vidéos d’installation (sur Mac, sur Raspberry Pi) ou des démos.

Bonne visualisation (et bonne lecture à ceux qui liront le livre ;))

Les modules Essentials

Le module Qt Core

Ce module fournit les fonctionnalités de base de Qt, excepté ce qui concerne l’interface graphique. Tous les autres modules sont liés à ce module. Voici la liste de quelques ajouts dans Qt 5 :

• QStandardPaths : permet de récupérer les répertoires par défaut en fonction de la plateforme. C’est une évolution de QDesktopServices avec plus de fonctionnalités, sur le modèle de KStandardDirs de KDE. Cela permet par exemple de faire une recherche de toutes les occurrences d’un fichier dans les différents répertoires ;
• support de JSON : permet de créer ou de lire un fichier JSON à partir d’une représentation binaire en mémoire ;
• extension prise en charge MIME : permet de déterminer le type mime d’un fichier ou de données en mémoire, en fonction de l’extension et/ou du contenu. Ce module utilise une base de données des types MIME par QMimeDatabase fourni par freedesktop.org shared-mime-info project. Cette base de données est incluse par défaut dans le système sous Linux et fourni par Qt sur Windows et Mac OS X ;
• vérification des connexions signaux/slots à la compilation : vérifie l’existence du signal et du receveur et que les arguments sont compatibles. Cette fonctionnalité utilise les templates et est compatible avec C++11. Il est possible de connecter un signal à des fonctions lambda, des fonctions membres ou des fonctions statiques, sans avoir besoin de déclarer comme slots. Voir l’article détaillé sur le sujet : Les signaux et slots dans Qt 5 ;
• QRegularExpression : nouveau moteur d’expressions régulières compatible Perl, plus puissante et rapide que QRegExp, avec plus de fonctionnalités (lazy and possessive quantifiers, lookbehinds, named capturing groups and iteration of matches) ;
• amélioration des performances, en particulier pour les structures de données ;
• amélioration du support C++11 quand c’est possible (mais compatibilité avec C++98) ;
• support des boutons supplémentaires sur les souris (souris pour joueurs), jusque 27 boutons pour XCB, XLIB ou DirectFB, jusque 16 pour Wayland, Evdev ou OS-X, jusque 8 pour BlackBerry/QNX et 5 sur Windows (limitation due au système).

Le module Qt Gui

Ce module fournit les fonctionnalités de base pour créer une interface utilisateur. Les anciennes classes QWidget et dérivées sont séparées dans un module indépendant. Ce module contient de nouvelles classes comme QWindow, QScreen, QSurfaceFormat permettant le support de fonctionnalités de base et est surtout destiné à être utilisé par les autres modules (QWidget, QQuickView, Qt 3D View, etc.).
En particulier, ce module fournit les classes QOpenGLxxx (QOpenGLFramebufferObject, QOpenGLShaderProgram, QOpenGLFunctions, QOpenGLContext, etc.) permettant de fournir l’accélération matérielle pour tous les modules graphiques (widgets traditionnels, Qt Quick). La classe QOpenGLContext est plus générique que QGLContext et est découplée de QWindow, pour permettre d’utiliser un contexte commun pour plusieurs affichages. QOpenGLPaintDevice permet d’utiliser directement QPainter sur un contexte OpenGL sans devoir dériver de QWindow ou QOpenGLFramebufferObject.
Voir l’article OpenGL dans Qt 5 pour plus de détails.

Le module Qt QML

Ce module permet d’utiliser le langage de script déclaratif QML grâce au QML engine. Il présente des améliorations des performances et des ajouts de fonctionnalités par rapport celui inclus dans Qt 4.

Le module Qt Js backend (JavaScript)

Ce module fournit un interpréteur JavaScript, permettant de scripter les applications écrites en C++ et en QML. Il utilise un nouveau moteur JS v8 plus rapide. Il inclut de nouvelles classes (QJSEngine, QJSValue), le support de nouveaux types (QColor avec les propriétés r, g, b et a, QVector4D constructible avec Qt.vector4d()). Il est possible d’ajouter des fonctionnalités dans un namespace avec la fonction qmlRegisterModuleApi et d’importer du QML et du JS directement dans un fichier JS.

Le module Qt Quick

Ce module permet de créer des interfaces dynamiques riches, en utilisant les modules QML et le JS. Cette nouvelle version de Qt Quick correspond au module « qtquick2″ alors que l’ancienne version correspond au module « qtquick1″. L’interface graphique de Qt Quick 2 se base maintenant sur scenegraph et permet l’accélération matérielle en utilisant les classes QOpenGLxxx de Qt Gui.
On trouve de nouvelles classes (QQuickView, QQuickCanvas, QQuickItem et QQuickPaintedItem qui remplacent les classes équivalentes de QDeclarative), de nouveaux items (Canvas permet le support de l’API Context2D de HTML 5, le rendu est réalisé dans Canvas.Image et Canvas.FramebufferObject, avec support multithread en arrière-plan). Le moteur de particules 2D Qt Quick.Particles 2.0 et la collection d’effets de shaders qui étaient avant des projets séparés dans Qt Labs sont maintenant inclus dans Qt.

Le module Qt 3D

Le module Qt 3D est également un ancien projet provenant de Qt Labs et est inclus dans Qt 5. Il a permis dans Qt 4 l’ajout de nombreuses fonctionnalités de calculs 3D comme les classes QMatrix4×4, QGLShaderProgram et QVector3D. Il utilise en interne le module Qt QML et le support OpenGL de Qt Gui. Ce module contient deux bibliothèques : Qt 3D (pour utiliser directement la 3D en C++) et Qt 3D Quick (pour l’utilisation dans Qt Quick).

Plusieurs fonctionnalités sont ajoutées :

• gestion de scènes 3D, avec rendu en OpenGL ;
• lecture de fichiers 3D (par exemple .obj et .3ds) ;
• gestion des lumières, des meshs, des textures, des matériaux, des animations, des caméras, des vues ;
• ajout de shader directement ou par fichier dans les propriétés QML ;

Le module Qt Location

Ce module est un ajout dans Qt 5, mais il existait déjà depuis des années comme sous-ensemble de Qt Mobility. Il fournit les services nécessaires pour la localisation : GPS, cartographie, etc.
Il inclut une fonctionnalité permettant d’afficher des cartes avec MapQuickItem. L’affichage se base sur une approche modèle/vue et bénéficie de l’accélération OpenGL dans scenegraph. Les gestuelles pour les zooms et les panoramas dynamiques, le routage et le géocodage, l’ajout de repères sur les cartes sont pris en charge.

Le module Qt Network

Ce module fournit une interface portable pour utiliser les réseaux. Parmi les évolutions :

• amélioration du support IPv6 et des réseaux utilisant les types d’adresse IP, de manière transparente par défaut. En réception, QTcpServer et QUdpSocket lancés avec QHostAddress::Any permet de recevoir dans les deux modes ; avec QHostAddress::AnyIPv4 et QHostAddress::AnyIPv6 permet de travailler sur un mode uniquement. En émission, QNetworkAccessManager tente d’utiliser les deux modes et garde le premier qui réussit ;
• QTcpSocket peut maintenant être attaché à un socket existant avant de lancer une connexion, pour limiter les connexions dans un environnement multihôte ;
• QDnsLookup permet de rechercher des enregistrements DNS. Il ne remplace pas QHostInfo, qui permet de résoudre les noms en adresse IP, mais permet principalement d’utiliser les autres types d’enregistrements DNS : SRV, TXT et MX ;
• les classes QFtp et QHttp ne sont pas conservées dans ce module, mais restent disponibles dans un module indépendant pour la compatibilité. Elles sont remplacées par QNetworkAccessManager.
• extensions et vérifications des certificats SSL : prise en charge des extensions des certificats. La vérification des certificats ne se fait plus uniquement lors de la connexion à un serveur ;
• support des clés privées masquées : permet de lire une clé privée à partir d’un périphérique, par exemple un dongle PKCS#11.

Les autres modules

• Qt Multimedia : fournit les fonctionnalités de base pour lire l’audio, la vidéo, la radio et gérer les caméras ;
• Qt SQL : fournit une prise en charge portable des bases de données SQL ;
• Qt Test : fournit les outils nécessaires pour implémenter des tests unitaires ;
• Qt WebKit : basé sur WebKit 2, mais sans changement de l’API C++. Ce module continue l’amélioration de prise en charge HTML 5 et des performances.

Les modules Add-ons

Le module Qt Widget

Ce module fournit l’ensemble des classes QWidget et dérivées pour la compatibilité avec Qt 4. Il utilise la nouvelle architecture Qt Platform Abstraction (QPA).

Le module Qt Quick 1

Ce module permet d’utiliser la version de Qt Quick disponible dans Qt 4, pour compatibilité. Pour utiliser ce module, il suffit d’ajouter dans le .pro :

Et d’inclure les fichiers d’en-têtes :

Les autres modules

• Qt Script : permet de rendre les applications scriptables, compatibilité avec Qt 4. Il utilise les classes QJSxxx du module Qt Js ;
• Qt Bluetooth : prise en charge du Bluetooth ;
• Qt D-Bus : interprocessus communication avec D-Bus ;
• Qt Graphical Effects : collection d’effets graphiques ;
• Qt Image Formats : prise en charge de formats d’images supplémentaires (TIFF, MNG, TGA, WBMP) ;
• Qt OpenGL : module 3D OpenGL compatible avec Qt 4 ;
• Qt Print Support : support pour l’impression ;
• Qt Publish and Subscribe ;
• Qt Script Tools : outils supplémentaires pour scripter ;
• Qt Sensor : gestion des capteurs (accéléromètre, détecteur de lumière ambiante, compas, etc.) ;
• Qt Service Framework : permet de fournir des services en ligne ;
• Qt SVG : prise en charge du format d’image SVG (image vectorielle) ;
• Qt System Info : informations sur le système (profile utilisateur, batterie, stockage, etc.) ;
• Qt Tools : outils divers (Qt Designer, Qt Help, etc.) ;
• Qt Pim : contacts, organiseur, vCard, etc. ;
• Qt WebKit Widgets : version de wekbit 1, pour compatibilité avec Qt 4 ;
• Qt XML : fichier XML avec SAX et DOM. Ce module est déprécié, il faut maintenant utiliser QXmlStreamReader/Writer ;
• Qt XML Patterns : support pour XPath, XQuery, XSLT et XML Schema validation.

Les modules accessoires

Le support de ces modules n’est pas encore déterminé.

• Active Qt : support des ActiveX et Com (Windows) ;
• Qt Feedback ;
• Qt JSON DB ;
• Phonon : support du framework phonon pour la vidéo et audio ;
• Qt QA : auto test, pour gestion automatique des tests ;
• Qt QLALR : interpréteur LALR.

Commentaires et remerciements

Vous pouvez commenter cet article sur le forum.
Merci à ClaudeLELOUP pour sa relecture orthographique.

Dans Qt4, les fonctionnalités d’OpenGL sont implémentées dans un module spécifique, QtOpenGL. Ce module était utilisé par différentes classes pour bénéficier de l’accélération matérielle. Il existe plusieurs méthodes pour activer l’accélération matérielle :

• pour activer par défaut l’utilisation de OpenGL, utiliser la ligne de commande « -graphicssystem opengl » ou la fonction QApplication::setGraphicsSystem(« opengl ») ;
• pour QGraphicsView (QtGraphics) ou QDeclarativeView (QtQuick), utiliser la fonction setViewport(new QGLWidget) ;
• on peut également utiliser QPainter directement sur un QGLWidget ;
• avec le QML Viewer, utilisez la commande « -opengl ».

L’organisation des modules
Dans Qt4, on a donc un problème dans l’organisation des modules. Beaucoup de classes de QtGui peuvent dépendre des classes appartenant à QtOpenGL alors que ce module dépend normalement de QtGui.
C’est pour cela que de nouvelles classes font leur apparition dans Qt5 et que les différents modules ont été réorganisés :

• les classes QOpenGL appartiennent au module QtGui et fournissent les fonctionnalités de base permettant l’accélération matérielle pour toute les classes de rendu de Qt ;
• la classe QWidget n’est plus le parent de toutes les classes de rendu. Cette classe et ses dérivées (QGraphicsView) sont transférées dans le module « widgets » ;
• QtQuick 2 utilise maintenant scenegraph à la place de QWidget et la classe QDeclarativeView devient QQuickView et OpenGL est utilisé par défaut ;
• QtOpenGL continue d’exister pour fournir la classe QGLWidget et ses dérivés. Le code OpenGL Qt4 est donc compatible avec Qt5 ;
• le module Qt3d fait son apparition pour fournir un moteur 3D plus avancé. Ce module est suffisamment important et fera donc l’objet d’un article spécifique.

Remarque : il faut faire attention de ne pas confondre le module QtOpenGL, contenant les classes commençant par QGL, et le module QtGui, contenant les classes commençant par QOpenGL (sans t).

Les classes de QtGui dans Qt5
Le module QtGui de Qt5 réutilise des classes existantes du module QtOpenGL de Qt4. Les noms sont explicites :

1. QOpenGLBuffer ;
2. QOpenGLContext ;
3. QOpenGLFramebufferObject ;
4. QOpenGLFramebufferObjectFormat ;
5. QOpenGLShader ;
6. QOpenGLShaderProgram.

Plusieurs nouvelles classes font leur apparition :

1. QOpenGLContextGroup : groupe de contextes OpenGL pouvant partager des ressources. Cette classe est gérée automatiquement par les objets QOpenGLContext ;
2. QOpenGLFunctions : fournit un accès indépendant de la plateforme aux fonctions d’OpenGL ;
3. QOpenGLPaintDevice : permet de dessiner dans un contexte OpenGL avec QPainter ;
4. QOpenGLStaticContext : manque de documentation ;
5. QOpenGLContextData : manque de documentation ;
6. QWindowsGLContext : manque de documentation.

Que faut-il modifier pour utiliser OpenGL dans Qt5
Tout d’abord, il faut Qt5. Le plus simple est d’utiliser les dépôts PPA sur Ubuntu : https://launchpad.net/~forumnokia/+archive/fn-ppa. Qt5 sera installé dans le répertoire /opt/qt5. Pour ajouter cette version de Qt dans QtCreator, il faut aller dans le menu « Outils » puis « Options… », allez dans « Compiler et exécuter… » puis l’onglet « Versions de Qt ». Cliquer sur « Ajouter » et aller chercher le fichier « /opt/qt5/bin/qmake ». Voilà, Qt5 est prêt à être utilisé.

Normalement, vous pouvez utiliser vos projets directement, mais il est préférable de prendre l’habitude d’ajouter le module « widgets » (remarque : l’ajout des modules core et gui n’est pas obligatoire puisqu’ils sont inclus par défaut) :

Amusez-vous bien !

Lorsque l’on souhaite faire communiquer des objets entre eux, il nécessaire en général que les objets se connaissent mutuellement. Par exemple

Ce code présente cependant plusieurs problèmes :

• il faut que la classe Sender connaisse la classe Receiver et cela implique d’ajouter une dépendance (include) entre ces classes ;
• il est nécessaire de créer une fonction spécifique dans Sender pour chaque type de classe Receiver et pour chaque slot possible ;
• il ne permet pas de gérer des connexions vers plusieurs objets Receiver et il faut modifier le code pour gérer une liste de Receiver.

Ces contraintes s’accumulent dans un framework complexe comme Qt et cela alourdit fortement le code en ajoutant un nombre important de dépendances inutiles. Le code devient très vite ingérable (*).

Le système des signaux et slots permet de faire de s’affranchir de ces contraintes. Il est ainsi possible de faire communiquer des objets entre eux sans qu’il soit nécessaire que ces objets se connaissent mutuellement. On peut également choisir lors de la connexion le slot que l’on souhaite appeler lorsque le signal est émis. On passe ainsi d’un couplage fort (nécessité d’avoir une dépendance) à un couplage faible (plus de dépendance nécessaire) et l’on parle de découplage des classes.

(*) Il est possible d’utiliser d’autres approches que celle présentée ici. En particulier, on peut utiliser les pointeurs de fonctions ou équivalents (callback). Le lecteur intéressé par la question pourra par exemple étudier l’approche utilisée dans Boost.Signals

Le système des signaux et slots dans Qt

Le système de signaux et slots de Qt est relativement simple. Lorsqu’un événement se produit, un signal est émis. Tous les slots qui sont connectés à ce signal sont alors exécutés. La fonction QObject::connect permet de créer une telle connexion. La forme la plus classique de cette fonction prend en paramètres un pointeur vers l’objet émetteur, le nom du signal (ainsi que la liste des types des arguments du signal), un pointeur vers l’objet recepteur et pour terminer le nom du slot (ainsi que la liste des types des arguments du slot). Il est possible de connecter plusieurs signaux à un même slot, un signal à plusieurs slots ou un signal avec un signal. Le compatibilité entre les classes et les signaux et slots est vérifiés lors de la compilation.

Les classes de Qt fournissent de nombreux signaux et slots par défaut. Ces signaux et slots seront disponibles dans les classes créées par les utilisateurs et dérivant des classes de Qt. Il est également possible de créer ses propres signaux et slots et de les connecter aux signaux et slots par défaut de Qt :

Créer une connexion dans Qt 5

Dans Qt 4, il est possible de connecter uniquement les fonctions déclarées comme signaux et
slots dans la classes, comme indiqué dans le code d’exemple précédant. Dans Qt 5, il est
maintenant possible de connecter directement des pointeurs de fonctions ou d’utiliser des
fonctions lambdas.

La connexion de pointeurs de fonctions est similaire à une connexion classique, en donnant un pointeur sur les objets et sur les fonctions. Les classes émettrices et réceptrices doivent dériver de QObject mais il n’est pas nécessaire de déclarer les fonctions slots avec le mot clé « slots ».

L’avantage de cette écriture est que la compatibilité des paramètres est effectuée lors de la compilation et non lors de l’exécution.

Pour les fonctions lambdas :

Dans ce code, on capture le pointeur vers l’objet recepteur et on récupère le paramètre passé par la fonction send() puis on appelle dans le corps de la lambda le fonction receive(). Le résultat obtenu est identique au code précédant, mais il est possible de faire beaucoup d’autres choses dans la lambda (par exemple déconnecter tous le signaux ou parcourir tous les enfants de l’objet récepteur).

Si le compilateur utilisé ne support pas les variadic template, les signaux et slots doivent avoir moins de 6 paramètres.

Remarques
Vous pouvez télécharger un projet d’exemple montrant ces nouvelles fonctionnalités en action : la page de téléchargement.

Les images et codes d’exemple sont issus de la documentation de Qt5 disponible à cette page : Qt 5.0: Signals & Slots.