Ecrire sa première application avec Qt 4
II. Premiers pas
II-1. Premier code
II-2. Compilation et Exécution
II-3. Explications
II-4. En résumé
II. Premiers pas
II-1. Premier code
Nous allons pour commencer étudier un code assez simple. En effet, le code ci-dessous affiche simplement
un bouton. Pour quitter l'application, il suffira de cliquer sur la croix, comme pour n'importe quelle application logicielle.
#include <QApplication>
#include <QPushButton>
int main(int argc, char** argv)
{
QApplication app(argc, argv);
QPushButton pb("Hello, Qt!");
pb.resize(400,100);
pb.show();
return app.exec();
}
|
Cependant, pour motiver l'utilisation de Qt, je vais rajouter une
simple ligne qui fera qu'un clic sur le bouton entrainera la fermeture de l'application.
Voici le code "final" que nous allons étudier dans toute cette section.
#include <QApplication>
#include <QPushButton>
int main(int argc, char** argv)
{
QApplication app(argc, argv);
QPushButton pb("Hello, Qt!");
QObject::connect(&pb, SIGNAL(clicked()), &app, SLOT(quit()));
pb.resize(400,100);
pb.show();
return app.exec();
}
|
Il faut maintenant compiler puis exécuter cette petite application.
Je vais tout d'abord vous expliquer le procédé de compilation d'une application
Qt, et enfin vous pourrez exécuter l'application et la recompiler en changeant des valeurs
pour vous faire la main.
II-2. Compilation et Exécution
Pour compiler un projet avec Qt 4, il y a un outil fondamental : qmake.
Ce dernier est un outil faisant partie de Qt 4 (au même titre que les sources) qui vous permet de
gérer tout un ensemble de fichier d'un projet, ou même tout votre projet. Voici les différentes
commandes à taper dans un terminal (n'importe quel terminal sous un système Unix, Menu Démarrer > Exécuter : cmd sous Windows).
- qmake -project : cette commande crée un fichier .pro rassemblant des informations sur les fichiers qui composent votre projet, mais surtout leurs rôles (source, en-tête, fichier de Qt Designer, ...)
- qmake : cette commande se sert du fichier .pro créé précédemment pour générer tous les fichiers "finaux" (génère du code C++ à partir du fichier designer, ...) du projet. C'est la dernière étape avant la compilation car de plus cette commande génère le fichier contenant les règles de compilation de votre projet.
Il ne reste plus qu'à exécuter la commande de compilation que vous utilisez habituellement (nmake pour Visual C++, make pour GCC/MingW, ...) afin de compiler
votre application, dont l'exécutable est par défaut dans un sous-répertoire nommé release du répertoire courant.
Il vous sufit donc, pour n'importe quel projet, de taper qmake -project puis qmake et enfin make/nmake ou autre pour construire votre application.
N'oubliez pas que la compilation ne s'effectue qu'à l'exécution de la dernière commande. Les deux
commandes précédentes ne sont que des commandes permettant de gérer l'ensemble de votre projet, en préparant la compilation.
Enfin, il faut préciser que lorsque votre projet n'est composé que d'un seul fichier,
vous pouvez le compiler directement en précisant à votre compilateur les dossiers où chercher
les en-têtes de Qt, les dossiers où chercher les fichiers bibliothèques de Qt et enfin quels fichiers bibliothèques de Qt il faut
lier au programme (ce que gère automatiquement qmake).
Il existe sur developpez un tutoriel qui examine plus en profondeur ce que fait
qmake
et comment personnaliser son fichier de projet .pro, disponible ici :
Compilation de projets Qt 4.
En supposant que vous avez compilé votre projet dans le répertoire PremierPas/, alors votre exécutable
doit se situer dans le répertoire PremierPas/release/ et en principe porte le nom PremierPas (l'extension dépend de votre système d'exploitation, évidemment). Par défaut
qmake prépare pour une compilation en mode Release. Il est cependant possible de préparer
la compilation pour le mode Debug. Pour cela, je vous invite à consulter le tutoriel sur la compilation
des projets Qt 4 mentionné ci-dessus. En exécutant, vous devez obtenir quelque chose de similaire à l'une des images suivantes.
Maintenant que vous savez ce que donne le code précédent une fois compilé, il est temps
que vous compreniez chacune de ses lignes, afin de pouvoir ensuite écrire des codes plus complexes avec Qt 4.
II-3. Explications
Nous allons étudier morceau par morceau le code précédent pour en comprendre chaque ligne.
#include <QApplication>
#include <QPushButton>
|
Ces directives d'inclusions permettent d'utiliser dans notre code les classes QApplication
et QPushButton. La classe QApplication sert, comme son nom l'indique, à créer une application
Qt. On transmet à son constructeur les arguments donnés au programme car QApplication permet de
les gérer. Enfin, la classe QPushButton permet d'intégrer un bouton dans notre application.
Il faut savoir dès maintenant que lorsque vous utilisez une classe QXYZ, il faut inclure à un moment
ou un autre l'en-tête <QXYZ>.
int main(int argc, char** argv)
{
...
}
|
Il s'agit de la fonction main habituelle, qui tient le même rôle
que d'habitude même lorsqu'il s'agit d'une application Qt 4 : il faut y placer
le code qui sera exécuté dès le lancement de l'application.
QApplication app(argc, argv);
|
Comme il est dit plus haut, on crée une instance de la classe QApplication, nommée
app, avec comme arguments pour le constructeur ceux de la fonction main.
QPushButton pb("Hello, Qt !");
|
On crée ici un bouton, sur lequel sera écrit "Hello, Qt !". La chaîne de caractère
que l'on passe au constructeur de QPushButton est de type QString, dont l'utilisation est transparente,
grâce à la façon dont est conçue la bibliothèque.
QObject::connect(&pb, SIGNAL(clicked()), &app, SLOT(quit()));
|
La fameuse ligne qu'il a fallu rajouter précédemment. Elle sert à
connecter
le clic sur le bouton à la fermeture de l'application. Nous étudierons plus tard ce système de
connexion, dans la
section IV : Créer une fenêtre complexe.
pb.resize(400,100);
pb.show();
|
Le code redimensionne notre bouton (400 pixels en largeur, 100 pixels en hauteur), grâce à la méthode resize,
puis affiche notre bouton grâce à la méthode show.
 |
Par défaut, tous les composants visuels, dont fait partie QPushButton,
sont cachés. Il faut appeler la méthode show pour les afficher.
|
Comme mentionné plus haut, l'instance de QApplication
gère notre application et en particulier si un problème grave survient,
obligeant à fermer l'application, app.exec() retournera une valeur d'erreur adaptée,
ce qui nous permet de ne pas nous soucier de ce genre de choses et de nous concentrer pour le moment
sur la conception de notre interface graphique.
II-4. En résumé
Vous avez donc écrit votre premier code C++ utilisant Qt, puis vous avez
appris à compiler ce dernier, en voyant ensuite ce que donnait son exécution. La section
précédente vous a de plus normalement permis de comprendre ce code, ce qui va vous permettre
de vous atteler à une tâche qui se trouve un niveau au-dessus sur l'échelle de la difficulté : l'affichage
de plusieurs composants visuels. La section suivante va donc vous expliquer comme faire cela, mais aussi
comment ordonner ses composants sur la fenêtre grâce aux gestionnaires de dispositions (layouts, en anglais).
Un petit point de vocabulaire pour terminer cette section :
|
Dans la suite de ce tutoriel, le mot widget sera utilisé pour désigner
un composant visuel. Il s'agit d'un anglicisme très utilisé dans les documentations techniques
en rapport avec les interfaces graphiques. Par conséquent, il est bon de s'y habituer et de plus,
il est assez court à écrire ;-)
|
Copyright © 2007 Alp Mestan.
Aucune reproduction, même partielle, ne peut être faite
de ce site ni de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à
trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
