Retrouvez cet article dans : Linux Magazine 78

Voilà bientôt trois ans, votre serviteur entamait une longue série d’articles consacrés à la bibliothèque Qt alors fraîchement disponible en version 3.x. Depuis, bien des progrès ont été accomplis par les développeurs de TrollTech, notablement aidés par de nombreux représentants du Logiciel libre, venant principalement du projet KDE. Découvrons avec un œil neuf la version 4 de Qt.

Cette toute dernière version sera à la base de la prochaine évolution majeure de l’environnement graphique KDE, attendue pour l’année prochaine. Par rapport à la version 3, Qt4 a été sensiblement optimisée et améliorée, offrant des possibilités jusqu’ici difficilement réalisables. Voyons comment tout cela s’organise.

Architecture

Pour commencer, reprenons le verbiage (marketing) de TrollTech [1] : Qt s’organise autour de cinq ensembles fondamentaux, auxquels s’ajoutent un certain nombre de modules pour des tâches non spécifiques d’une interface graphique comme l’accès aux bases de données ou des protocoles réseau. Voici ces cinq ensembles :

• Tulip est un ensemble de classes et conteneurs génériques, comparable à la bibliothèque standard STL du langage C++, mais avec une orientation d’inspiration plutôt Java ;
• Arthur est destiné au dessin graphique, tirant partie des capacités et spécificités du système sous-jacent (comme OpenGL) ;
• Scribe réalise l’affichage de textes Unicode et permet un agencement précis et « bas niveau » de ceux-ci ;
• Interview est une simplification du design pattern modèle/vue/contrôleur en modèle/vue, destinée à faciliter grandement l’exposition d’un même ensemble de données selon différentes présentations ;
• Enfin, Mainwindow offre une architecture souple et sophistiquée pour la réalisation de grandes fenêtres d’application.

Tout cela fait un peu slogan publicitaire. Après tout, TrollTech est une entreprise à vocation commerciale ! Plus intéressante est sans doute l’organisation binaire : Qt est désormais décomposée en plusieurs bibliothèques plus petites (alors qu’auparavant elle était en un seul bloc). Il est ainsi plus aisé de limiter les liens à ce qui est réellement nécessaire à l’application. On trouve nommément :

• QtCore, le cœur de la bibliothèque, qui contient ce qui ne dépend pas de l’interface graphique ; on y trouvera les classes de chaînes de caractères, les conteneurs génériques, les outils de manipulation des fichiers, etc. ;
• QtGui rassemble les fonctionnalités d’interfaces graphiques de base, des outils de dessin aux fenêtres principales en passant par les widgets (boutons, menus, etc.) ;
• QtOpenGL offre des services pour l’intégration d’un contexte OpenGL au sein d’une application Qt ;
• QtNetwork est destiné à contenir les classes liées aux protocoles réseau ;
• QtSql permet la manipulation de bases de données, comme SQLite, MySQL, PostgreSQL et d’autres ;
• QtXml propose les interfaces DOM et SAX2 pour les données au format XML ;
• Qt3Support a pour vocation de faciliter la migration depuis la version 3 de Qt.

Il en existe quelques autres, mais il y a là déjà de quoi faire.

Installation

Disons-le dès maintenant, la compilation et l’installation de Qt version 4 ne sont pas destinées aux machines (trop) modestes. L’espace nécessaire à la fin de la compilation est de près de 1.2 giga-octets, la bibliothèque installée (accompagnée des exemples et de la documentation) occupant près de 550 mégaoctets.
Et ne soyez pas pressés non plus, la compilation peut représenter plusieurs heures, même sur un Pentium IV à 3Ghz. Vous voilà prévenus !
Pour commencer, récupérez le code source par le lien [2], un fichier d’environ 20Mo. Décompactez-le quelque part, puis placez-vous dedans pour configurer la bibliothèque.
Cette opération est effectuée par un programme configure. Exécutez configure -help pour avoir la liste complète des options. La plus importante est sans doute -prefix, qui détermine l’endroit où Qt sera installée. Recommandation : surtout ne tentez pas d’installer la version 4 « sur » une version 3.
Elles sont parfaitement incompatibles, bien qu’il existe des outils pour faciliter la migration. Utilisez de préférence un endroit dans votre répertoire personnel. Voici la configuration que j’ai utilisée :

$ ./configure -prefix /home/yves/qt400 -qt-sql-sqlite -qt-zlib \ -qt-libpng -qt-libjpeg -no-pch
$ make
$ make install

À l’issu de l’installation, on obtient un répertoire qui contient la bibliothèque avec tout ce qui l’accompagne. Son contenu :

• bin contient les programmes et outils propres à Qt ; il est nécessaire d’ajouter ce répertoire (son chemin complet) dans la variable d’environnement PATH pour pouvoir utiliser Qt ;
• lib contient la bibliothèque en elle-même, décomposée en plusieurs modules comme évoqué plus haut ; remarquez que chacun existe en deux versions, l’une (beaucoup plus grosse) nantie du suffixe _debug : cela correspond à une version contenant les informations de débogage nécessaires à (par exemple) gdb ; à lui seul ce répertoire fait dans les 300Mo ;
• include contient les fichiers d’en-tête, répartis selon les modules ;
• doc/html/index.html est le point d’entrée de la documentation, aussi complète et détaillée qu’à l’accoutumé avec Qt ;
• demos et examples contiennent de nombreux programmes de démonstration et d’exemples, certains assez élémentaires, d’autres assez sophistiqués ;
• mkspecs contient les informations nécessaires à l’utilitaire qmake, que nous découvrirons bientôt ;

• phrasebooks contient les traductions des différents éléments prédéfinis de la bibliothèque, Qt ayant son système de traduction propre ;
• Enfin, plugins regroupe diverses extensions comme des formats d’images.

Pour vérifier que l’installation s’est bien passée, vous pouvez lancer le programme qtdemo : il donne accès à la plupart des exemples.
Un outil fort pratique que vous pouvez exécuter également dès maintenant est assistant, dont la vocation est d’offrir un accès simple et efficace à l’intégralité de la documentation Qt. Toute ressemblance avec un navigateur web n’est probablement pas due au seul hasard.

Mais en voilà assez pour l’installation. Passons à la réalisation de notre premier programme avec Qt 4.

Premier programme

Placez dans un répertoire quelconque un fichier que nous nommerons hello.cpp et dont voici le contenu :

    1 #include <QApplication>
    2 #include <QWidget>
    3 #include <QLabel>
    4 #include <QPushButton>
    5 #include <QVBoxLayout>
    6 int main(int argc, char* argv[])
    7 {
    8    QApplication app(argc, argv) ;
    9    QWidget w ;
   10    QVBoxLayout vbox(&w) ;
   11    QLabel l(«<b>Bonjour</b> <i>Monde</i> !», &w) ;
   12    QPushButton quit(“&Quitter”, &w) ;
   13    vbox.addWidget(&l) ;
   14    vbox.addWidget(&quit) ;
   15    app.connect(&quit, SIGNAL(clicked()), SLOT(quit())) ;
   16    w.show();
   17    return app.exec();
   18 }

Commençons par les cinq premières lignes. À partir de la version 4, Qt pose comme principe que pour obtenir la déclaration d’une classe utilisée dans le programme, il suffit de placer une directive #include du nom de la classe. Ainsi, comme nous utilisons ici la classe QApplication (ligne 8), pour obtenir sa déclaration, on utilise simplement une directive #include <QApplication>. Ce principe n’est pas sans rappeler celui de la bibliothèque standard STL du C++, qui suit une convention similaire.
On s’épargne ainsi pas mal d’interrogations sur quel en-tête inclure ou non.
Continuons. La création d’une instance de la classe QApplication (ligne 8) est le passage obligé pour tout programme utilisant Qt - en fait, cette instance doit être créée avant l’utilisation de pratiquement toute autre classe de Qt, notamment les classes concernant l’interface graphique. Ensuite, sans entrer dans les détails :

• La classe QWidget utilisée ligne 9 est la classe ancêtre de tous les éléments graphiques (widgets) affichables par une application ; l’instance ici créée ne sert que de contenant pour ce qui suit ;
• QVBoxLayout, instanciée ligne 10 et utilisée lignes 13 et 14, a pour fonction d’agencer verticalement et automatiquement les widgets qui lui ont été attachés (lignes 13 et 14) ;
• QLabel affiche simplement un texte statique ; remarquez l’utilisation de tags de type HTML dans la chaîne de caractères donnée en premier paramètre ; le deuxième paramètre est un pointeur vers le widget dans lequel ledit label doit être inclus ; ceci est valable pour tous les widgets : les éléments graphiques d’une application sont ainsi organisés dans une arborescence, les parents « contenant » les enfants ;
• QPushButton est un simple bouton ; le caractère ‘&’ indique que la lettre qui suit sera un raccourci permettant d’activer le bouton, donc ici par la combinaison [Alt]+[Q] ;
• La ligne 15 réalise l’association entre le bouton et la méthode de QApplication qui quitte l’application ;
• La ligne 16 requiert l’affichage du widget w créé ligne 9, ce qui impliquera l’affichage du label et du bouton dûment agencé par l’instance de QVBoxLayout ;
• Enfin, l’invocation de la méthode exec() de QApplication lance la boucle interne qui réagira aux différents événements venant du clavier, de la souris ou d’ailleurs.

Ce petit programme étant écrit, il faut le compiler. Il est vivement déconseillé de tenter de le faire « à la main », les instructions nécessaires pouvant être fort compliquées, même pour un aussi petit programme. Pour donner une idée, voici ce qu’il faudrait exécuter, en supposant que QTDIR est une variable d’environnement pointant vers le répertoire où vous avez installé Qt :

 $ g++ -c -pipe -g -Wall -W -D_REENTRANT -DQT_CORE_LIB -DQT_GUI_LIB -DQT_SHARED -I$QTDIR/mkspecs/linux-g++ -I$QTDIR/include/QtGui
-I$QTDIR/include/QtCore -I$QTDIR/include -I. -o hello.o hello.cpp
$ g++ -Wl,-rpath,$QTDIR/lib -o hello hello.o -L$QTDIR/lib
-lQtGui_debug -L/usr/X11R6/lib -lSM -lICE -lXi -lXrender -lXrandr -lXcursor -lXinerama -lfreetype -lfontconfig -lXext -lX11 -lm -lQtCore_debug -ldl -lpthread

C’est assez rebutant. Heureusement, il existe un outil facilitant la tâche : qmake. Dans le même répertoire qui contient hello.cpp, créez un fichier hello.pro contenant :

TEMPLATE = app
SOURCES = hello.cpp

L’objet de ce fichier est de décrire simplement le projet en cours de réalisation, un peu comme un Makefile ultra-simplifié. L’utilitaire qmake va transformer cette description (ici élémentaire) en un Makefile contenant tout ce qu’il faut... et même un peu plus. Exécutez les commandes :

$ qmake
$ make
$ ./hello

Ce qui est quand même beaucoup plus simple. Vous obtenez alors la petite fenêtre :

Voyez comment les tags HTML dans le label sont interprétés. Ce n’est pas nouveau dans Qt, mais c’est toujours aussi agréable. Seul petit regret, ils sont inopérants pour le texte affiché par le bouton.

Conclusion

Voilà pour cette brève introduction à la version 4 de la bibliothèque Qt. La prochaine fois, nous verrons quelques classes fondamentales de Qt à usage général, comme les chaînes de caractères et les classes conteneurs. Si les premières n’ont pas beaucoup évolué, les secondes ont par contre été profondément repensées – l’occasion d’effectuer un petit comparatif de performances.

Lien:
[1] Le site de TrollTech :
http://www.trolltech.com
[2] Sources de Qt :
ftp://ftp.trolltech.com/qt/source/qt-x11-opensource-src-4.0.1.tar.gz