Page suivante Page précédente Table des matières

### 3. Construction des Tutoriels Qt

### 3.1 Étape 1 : Hello World!

Comme l'explique le chapitre précédent, nous avons créé un projet appelé `MyWidget`> - si nous regardons à la première page du tutoriel de la documentation de Qt, nous voyons que la première application utilise uniquement la fonction `main()`>. Il nous suffit donc de modifier la fonction `main()`> de notre projet généré pour franchir la première étape du tutoriel.

Pour accéder à la fonction `main()`>, sélectionnez-la dans le dossier "Globals" du visualiseur de classes qui contient un sous-dossier "Fonctions" où sont listées les fonctions qui n'appartiennent pas à une classe. Cela ouvre le fichier `main.cpp`> dans la fenêtre des "Fichiers C/C++" et le curseur d'édition est directement positionné au début de la première ligne de `main()`.

#### Quoi modifier en premier

Nous pourrions commencer par modifier le code donné pour obtenir ce qui est listé dans le tutoriel mais il y a encore plus simple. Sélectionnez le contenu de la fonction `main()`> avec la souris ou en maintenant la touche Shift enfoncée pendant la sélection des lignes avec la touche flèche vers le bas. Sélectionnez ensuite "Couper" dans le menu "Edition" ou appuyez sur la touche Suppr. pour supprimer le code sélectionné. Cela effacera la fonction main et nous pourrons commencer à zéro la construction de notre tutoriel.

#### Saisie du code source

Pour insérer le code du tutoriel, vous pourriez le lire attentivement et essayer de vous souvenir de chaque ligne de code qu'il contient. Ensuite, après avoir lu ligne par ligne la description du tutoriel, vous pourriez l'utiliser comme exemple pour écrire le tutoriel vous-même.

Pour ceux qui veulent se simplifier la vie : sélectionnez dans le navigateur le contenu de la fonction `main()`> listée et cliquez sur l'icône "Copier" dans la barre d'outils. Autrement, vous pouvez utiliser le menu contextuel ou l'entrée appropriée dans le menu "Edit". Cela copiera la sélection dans le presse-papiers et, après être revenu dans la fenêtre du code source, vous pourrez l'insérer avec "Coller" (en utilisant le menu contextuel, l'icône de la barre d'outils ou l'entrée adéquate du menu "Edition").

Enfin, ajoutez hors de la fonction `main()`> les fichiers d'en-tête suivants :

> `

>     #include <qapplication.h>
>     #include <qpushbutton.h>

> `

C'est tout ! Le code source de votre première application de tutoriel est terminé.

#### Construction de Hello World!

Pour construire le premier tutoriel, sélectionnez "Construire" dans le menu "Build" ou cliquez sur l'icône correspondante dans la barre d'outils. Vous pourriez aussi bien choisir "Exécuter" qui provoque l'exécution après une construction correcte.

Si la construction s'arrête à cause d'une erreur, vous pouvez être sûr que la faute vient du programmeur et non du tutoriel ! Ca serait dommage de chercher une erreur alors que vous avez décidé de programmer pour KDE et/ou Qt mais vous pouvez utiliser cette occasion pour vous entraîner à utiliser KDevelop. Pour chercher une erreur, vous avez deux possibilités : soit en sélectionnant le message d'erreur correspondant dans la fênetre des messages, ce qui vous placera sur la ligne où l'erreur s'est produite, soit en appuyant sur la touche F4. Vous pourriez aussi utiliser l'entrée "Erreur suivante" du menu "Affichage".

#### Exercices

Vous pourriez vous dire "Exercices ? C'était si simple que je n'ai pas besoin de m'exercer !" mais rassurez-vous, les choses vont devenir plus compliquées. Ceci était l'exemple le plus simple qui soit mais plus ce sera compliqué et plus cela demandera de réflexions de votre part pour assimiler et suivre les étapes du tutoriel.

Les exercices vous permettront aussi d'apprendre comment utiliser KDevelop et ses fonctionnalités.

Pour apprendre par vous-même plus de choses avec le premier tutoriel, vous pouvez essayer d'effectuer les modifications suivantes dans le code et voir l'influence sur le comportement de l'application :

1. changez le bouton (pushbutton) en QLabel
2. utilisez `setText()`> au lieu de définir directement le texte dans le constructeur du bouton (pushbutton)
3. utilisez `QPushButton::resize ( const QSize & s )`> au lieu de définir directement la taille par sa largeur et sa hauteur. Créez d'abord une instance de `QSize`> qui contiendra la taille
4. jouez avec les tailles pour voir laquelle est la largeur et laquelle est la hauteur

### 3.2 Étapes 2 et 3 : Extensions

Les étapes 2 et 3 du tutoriel étendent les fonctionnalités du premier tutorial. Vous y découvrirez le mécanisme signal/slot ainsi que les relations parent-enfant entre les widgets.

À propos, pourquoi est-il important d'apprendre cela ? Eh bien, le mécanisme signal/slot est à la base de la technologie qui fait la différence entre la bibliothèque Qt et les autres bibliothèques de widgets. Lorsque vous rencontrerez un problème d'implantation où vous voulez communiquer entre objets, cela réduira considérablement vos efforts et rien de grave n'arrivera si quelque chose se passe mal, même les mauvaises connexions ne conduisent pas à des fautes de segmentation (NdT : segmentation fault). C'est la force de la bibliothèque Qt et beaucoup de développeurs KDE/Qt ne peuvent plus se passer de sa flexibilité. Comprendre le mécanisme signal/slot est donc essentiel pour créer des applications KDE/Qt.

Une autre chose à remarquer est le fait que le bouton termine l'instance de `QApplication`> en appelant `quit()`>. Vous rencontrerez `quit()`> à nouveau en travaillant avec `KApplication`>, l'équivalent de `QApplication`> pour KDE.

### 3.3 Écrire vos propres widgets

Après avoir réussi à modifier et à étendre la fonction `main()`>, vous allez créer un nouveau widget - un widget particulier qui peut seulement être construit avec la classe que vous allez écrire à l'étape 4. En fait, la classe a été créée pour vous par l'assistant d'application donc il n'y a pas grand chose à ajouter - vous devez juste insérer le code que la leçon 4 place dans les fichiers d'en-tête et d'implantation de la classe `MyWidget`> du fichier `main.cpp`>. Par chance, il suffit d'ajouter l'implantation au code du constructeur.

Pour accéder au constructeur, sélectionnez-le dans le visualiseur de classes. Vous serez automatiquement placé dans l'implantation où vous pourrez ajouter le code.

Ici, vous devez uniquement faire attention à l'inclusion de `qfont.h`> - `QFont`> est uniquement utilisé dans le code du constructeur de `MyWidget`>. Ajoutez donc `#include> <qfont.h>` en haut du fichier `mywidget.cpp`>.

Pour exécuter la nouvelle application, cliquez juste sur "Exécuter". Après un enregistrement automatique, toutes les modifications seront compilées.

### 3.4 Étendre la classe Widget

Dans la leçon 5, le but va maintenant être d'étendre la classe widget. Vous allez donc apprendre les fonctions virtuelles. Ici, l'événement `resizeEvent()`> est réimplanté. Ce qu'il est important d'apprendre ici (au-delà de l'extension de classe), c'est que Qt utilise des fonctions virtuelles ayant un événement en paramètre pour gérer les événements utilisateurs. Vous devriez donc vous familiariser avec les classes suivantes de la bibliothèque Qt :

- QEvent
- QChildEvent
- QCloseEvent
- QFocusEvent
- QKeyEvent
- QMouseEvent
- QMoveEvent
- QPaintEvent
- QResizeEvent
- QTimerEvent

Lorsque vous voulez écrire des widgets personnalisés, spécialement les zones d'affichage des applications, vous devez surcharger l'implantation par défaut des méthodes-événements du widget par les vôtres pour certains événements à traiter. Par exemple, cela peut être

`virtual> void mousePressEvent ( QMouseEvent * )` afin de traiter un événement de la souris pour afficher un menu contextuel. Dans l'implantation, vous devrez insérer un paramètre formel dans l'en-tête de la fonction, la plupart des développeurs utilise `event`> ou juste `e`> comme nom du paramètre.

Ensuite, vous pouvez traiter les paramètres de l'événement. Pour un `QMouseEvent`>, vous devez demander si c'est le bouton gauche, droit ou du milieu de la souris qui a provoqué cet événement.

### 3.5 Ajouter une nouvelle Classe

Avec la leçon 6, vous allez devoir ajouter une classe à l'application du tutoriel. Logiquement, vous devriez penser "Je vais juste créer un fichier d'en-tête et un fichier d'implantation, et c'est tout" mais KDevelop va vous rendre cela encore plus simple. Pour ajouter une classe, vous devriez toujours utiliser le Générateur de classes. Il fera tout le boulot pour vous et vous aurez uniquement à rajouter le code spécifique.

Pour ajouter une classe avec le Générateur de classes, choisissez "Projet" - "Nouvelle Classe" qui ouvrira une boîte de dialogue afin de saisir toutes les valeurs nécessaires à la classe que vous voulez ajouter. La première chose à insérer est le nom de la classe. Le tutoriel la nomme `LCDRange`> donc ceci doit être inséré en premier. Ensuite, passons à la classe de base. La classe de base est celle dont hérite la nouvelle classe. D'après le tutoriel (Qt 1.42), il s'agit de `QWidget`>. Maintenant, comme la plupart des classes du GUI (Interface Graphique Utilisateur) à ajouter dérivent de QWidget, le Générateur de classes rend cela encore plus simple. Laissez vide la classe de base et cochez plutôt "Classe fille de QWidget" dans la section "Options supplémentaires". Cela ajoutera automatiquement dans le fichier d'en-tête la macro `Q_OBJECT`> qui est nécessaire pour ajouter des signal/slot (requis pour le chapitre 7).

Comme les noms de fichiers sont automatiquement insérés, vous n'avez pas à vous en préoccuper. La seule chose que nous vous suggérons d'ajouter est la documentation. Il est toujours plus élégant d'ajouter une documentation descriptive à la classe, spécialement lorsque le nom de classe `LCDRange`> n'est pas très clair sur le but du widget.

### 3.6 Étapes 7-14

Pour les dernières étapes du tutoriel, vous êtes prêt et vous savez tout ce que vous avez à savoir - ajouter les classes nécessaires et effectuer les modifications.

Après chaque modification, vous devriez reconstruire l'application et vérifier que votre code ne contient pas d'erreur. Lancez la et suivez son exécution ; vous pouvez aussi jouer avec les options de "Construction" de KDevelop, exécuter l'application avec une ligne de commande contenant des arguments tels que --geometry et la déboguer avec KDbg dans la fenêtre des Outils. Ensuite, vous devriez être capable de traiter les exemples de Qt qui seront présentés dans le chapitre suivant.

Page suivante Page précédente Table des matières