Transcript NUMERO DE CARTE:

Epsilon_GT_v8_Mise en page 1 06/05/2014 10:24 Page 20
Maîtrisez Qt 5
Le livre a été conçu pour entrer progressivement dans les profondeurs de Qt. Étape par
étape vous comprendrez le modèle objet de Qt et la programmation événementielle pour
structurer vos applications et atteindre très vite des objectifs complexes. Lorsque vous
maîtriserez ces fondamentaux vous approfondirez les bibliothèques de composants en
parcourant tous les modules de Qt : le module réseau (QtNetwork), le module SQL
(QtSql), les modules graphiques 2D et 3D (QtGui), les modules de composants d'interface
graphique et multimédia (QtWidgets et QtMultimedia).
Les derniers chapitres vous permettront de rendre concret cet ensemble en l'appliquant au
travail quotidien d'un développeur sérieux : la testabilité du code, qui est une réelle problématique d'entreprise, et le packaging des applications, pour leur diffusion sur tous les systèmes d'exploitation.
Les concepts présentés dans cet ouvrage sont illustrés par des exemples dont le code source
est téléchargeable sur le site www.editions-eni.fr.
Les chapitres du livre
Introduction • L’environnement de développement • Le modèle « event-driven » • Anatomie
d’une application • QtCore et fondations •
QtNetwork • QtSql • QtGui • QtWidgets •
QtMultimedia • Les modules graphiques et
web • QtTest : qualité du code • Traduction
d’une application • Publication d’une application • Techniques d’optimisation
ISSN 1960-3444
ISBN 978-2-7460-8921-1
9 782746
089211
54 €
Plus
d’informations :
Tristan ISRAËL est développeur (Java, C, C++,
Objective-C) depuis de nombreuses années et
spécialisé sur Qt depuis l’année 2007.
Aujourd’hui il développe également en Qt dans
le cadre de ses missions de consulting ou pour
des produits commercialisés sur les différents
Stores. Titulaire des trois certifications Qt
(Essentials, Widget UI et Core C++), il partage
dans les pages de ce livre sa passion pour Qt qui
lui permet de concilier le plaisir d'utiliser les technologies C avec le respect de la qualité fonctionnelle et ergonomique des applications qu’il crée.
Sur www.editions-eni.fr :
b Code source d’exemples
autour des différents modules Qt.
Maîtrisez Qt 5
Ce livre sur Qt 5 s’adresse aux professionnels de l’informatique, développeurs débutants
ou plus avancés, souhaitant maîtriser cet outil pour écrire du code de qualité et le tester,
pour packager des applications et les distribuer sur les différents systèmes d’exploitation
pour PC, pour améliorer les performances des applications et satisfaire au mieux les exigences des utilisateurs. Pour tirer pleinement parti de ce livre, les lecteurs devront posséder des connaissances suffisantes en C++.
Guide de développement d’applications professionnelles
Guide de développement d’applications professionnelles
Maîtrisez
Qt 5
Guide de développement
d’applications professionnelles
Téléchargement
www.editions-eni.fr
.fr
Tristan ISRAËL
Table des matières
Les éléments à télécharger sont disponibles à l'adresse suivante :
http://www.editions-eni.fr
Saisissez la référence ENI de l'ouvrage EP5QT dans la zone de recherche et
validez. Cliquez sur le titre du livre puis sur le bouton de téléchargement.
Chapitre 1
Introduction
1. Objectifs et méthode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2. Glossaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3. Qt, qu'est-ce ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.1 Histoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.2 Compatibilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.3 Notoriété . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.4 Bibliothèque ou framework ?. . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.5 Documentation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.6 Que peut-on faire avec Qt ?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.7 Modèles de conception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.8 Modèle objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.9 Plugins Qt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
4. Retour sur C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
4.1 Pointeurs et références . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
4.1.1 Pointeurs C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
4.1.2 Références . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
4.2 Copie d'objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4.2.1 Copie superficielle (shallow copy). . . . . . . . . . . . . . . . . . . 30
4.2.2 Copie en profondeur (deep copy) . . . . . . . . . . . . . . . . . . . 32
4.2.3 Copie paresseuse (lazy copy) . . . . . . . . . . . . . . . . . . . . . . . 34
4.2.4 Partage implicite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.3 Types primitifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
1
Maîtrisez Qt 5
2
Guide de développement d’applications professionnelles
4.4 Gestion de la mémoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
4.4.1 Cycle de vie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
4.4.2 Structures de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
4.5 STL, Boost et Qt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
4.6 Réentrance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
4.7 Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
Chapitre 2
L'environnement de développement
1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
2. Licence commerciale ou libre ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
2.1 Propriété intellectuelle et GPL . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
2.2 Diffusion de l'application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3. Choisir judicieusement son compilateur. . . . . . . . . . . . . . . . . . . . . . . 49
3.1 Monoplateforme ou multiplateforme ? . . . . . . . . . . . . . . . . . . . 49
3.2 Maintenabilité du code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
4. Installer l'environnement de développement . . . . . . . . . . . . . . . . . . . 53
4.1 Le compilateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
4.2 Qt Creator. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
4.3 Intégrer un autre environnement de compilation . . . . . . . . . . . 57
5. Maintenir à jour son environnement . . . . . . . . . . . . . . . . . . . . . . . . . 61
5.1 Profiter des dernières nouveautés . . . . . . . . . . . . . . . . . . . . . . . . 63
5.2 Gérer le cycle de vie de son application. . . . . . . . . . . . . . . . . . . . 65
6. Utiliser Qt Creator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
6.1 Organisation des projets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
6.2 Fenêtre principale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
6.2.1 Boutons d'accès aux modules. . . . . . . . . . . . . . . . . . . . . . . 68
6.2.2 Boutons de compilation et d'exécution. . . . . . . . . . . . . . . 68
6.2.3 Onglets de journaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
Table des matières
6.3
6.4
6.5
6.6
6.7
6.8
6.2.4 Onglets de contenus additionnels . . . . . . . . . . . . . . . . . . . 72
6.2.5 Sessions récentes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
6.2.6 Projets récents. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
Module d'édition. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
Module de conception d'interfaces graphiques. . . . . . . . . . . . . . 73
Module de débogage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
Module de configuration de projet . . . . . . . . . . . . . . . . . . . . . . . 76
Module de profilage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
Paramétrage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
Chapitre 3
Le modèle « event-driven »
1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
2. Pourquoi Qt est-il orienté événements ?. . . . . . . . . . . . . . . . . . . . . . . 79
3. La notion de flux. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
4. La run-loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
5. La programmation asynchrone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
6. Avantages et inconvénients . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
7. Gestion des ressources et performances . . . . . . . . . . . . . . . . . . . . . . . 91
Chapitre 4
Anatomie d'une application
1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
2. L'humain . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
2.1 Les différents types d'applications. . . . . . . . . . . . . . . . . . . . . . . . 94
2.2 Contenu d'un projet Qt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
2.3 Création d'une application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
2.3.1 En ligne de commande . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
2.3.2 Avec Qt Creator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
3
Maîtrisez Qt 5
4
Guide de développement d’applications professionnelles
2.4 Le fichier projet .pro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
2.4.1 Les directives de projet . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
2.4.2 Les directives de chemins . . . . . . . . . . . . . . . . . . . . . . . . . 103
2.4.3 Les directives de précompilation . . . . . . . . . . . . . . . . . . . 104
3. La machine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
3.1 Les commandes externes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
3.2 La phase de compilation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
Chapitre 5
QtCore et fondations
1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
2. Intégration et interactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
3. Découverte de QtCore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
3.1 Principes de conception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
3.2 La classe QObject . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
3.2.1 Prototype. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
3.2.2 Copie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
3.2.3 Internationalisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
3.3 Métaclasses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
3.4 La classe QVariant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
3.5 Propriétés Qt. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
3.6 Instanciation d'objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
3.7 Votre modèle objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
3.8 Signaux et slots. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
3.8.1 Le signal. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
3.8.2 Le slot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
3.8.3 La connexion. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
3.8.4 Différents types de connexion. . . . . . . . . . . . . . . . . . . . . 127
3.8.5 L'appel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
3.8.6 Éléments particuliers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
Table des matières
3.9 Appel asynchrone d'une fonction . . . . . . . . . . . . . . . . . . . . . . . 135
3.9.1 L'émission de signaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
3.9.2 L'utilisation d'un timer . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
3.9.3 La fonction invokeMethod . . . . . . . . . . . . . . . . . . . . . . . 137
4. Rendre ses algorithmes asynchrones . . . . . . . . . . . . . . . . . . . . . . . . . 137
4.1 Effectuer une boucle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
4.2 Faire une pause dans le programme. . . . . . . . . . . . . . . . . . . . . . 141
4.3 Synchroniser des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
5. Créer et piloter des threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
5.1 Paralléliser des tâches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
5.1.1 Les threads pilotés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
5.1.2 Un exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
5.1.3 Les tâches simples. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
5.1.4 Lancer une tâche asynchrone. . . . . . . . . . . . . . . . . . . . . . 155
5.2 Synchronisation par blocage et protection . . . . . . . . . . . . . . . . 156
5.3 Synchronisation par notification. . . . . . . . . . . . . . . . . . . . . . . . 158
6. Les pointeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
6.1 Pointeurs intelligents . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
6.2 Comptage de références vs héritage . . . . . . . . . . . . . . . . . . . . . 164
6.3 Faire le bon choix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
7. Les structures de données. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
7.1 Structures unidimensionnelles . . . . . . . . . . . . . . . . . . . . . . . . . 166
7.2 Structures multidimensionnelles. . . . . . . . . . . . . . . . . . . . . . . . 169
7.3 Parcourir les structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
7.4 Rechercher les performances . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
8. Choisir sa classe String . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
8.1 Les chaînes C et les langues accentuées . . . . . . . . . . . . . . . . . . 171
8.2 Les normes ISO, Unicode, UCS . . . . . . . . . . . . . . . . . . . . . . . . . 172
8.3 Adopter une solution universelle. . . . . . . . . . . . . . . . . . . . . . . . 175
8.4 Construire des tableaux de chaînes . . . . . . . . . . . . . . . . . . . . . . 176
5
Maîtrisez Qt 5
6
Guide de développement d’applications professionnelles
9. Interactions avec le système d'exploitation . . . . . . . . . . . . . . . . . . . 178
9.1 Exécuter une commande externe . . . . . . . . . . . . . . . . . . . . . . . 178
9.2 Les fichiers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
10. La gestion des paramètres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
10.1 QSettings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
10.2 Une classe propriétaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
11. La sérialisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
11.1 Mécanismes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
11.2 Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
12. Les fichiers XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
12.1 Écrire dans un fichier XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
12.2 Lire un fichier XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
Chapitre 6
QtNetwork
1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
2. Intégration et interactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
3. Accéder au réseau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
3.1 Portée de QtNetwork . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
3.2 Appel bloquant vs non bloquant . . . . . . . . . . . . . . . . . . . . . . . . 195
4. Sockets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
4.1 Client TCP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
4.1.1 Connexion avec un hôte . . . . . . . . . . . . . . . . . . . . . . . . . 198
4.1.2 Envoi d'une requête . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
4.1.3 Lecture d'une réponse . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
4.1.4 Fermeture et nettoyage . . . . . . . . . . . . . . . . . . . . . . . . . . 200
4.2 Serveur TCP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
4.3 Client UDP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
4.3.1 Connexion à un hôte . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
4.3.2 Envoi de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
4.3.3 Lecture des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
Table des matières
4.3.4 Fermeture de la connexion. . . . . . . . . . . . . . . . . . . . . . . . 207
5. Internet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
5.1 Résolution DNS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
5.1.1 Résoudre un nom de machine . . . . . . . . . . . . . . . . . . . . . 208
5.1.2 Obtenir les enregistrements d'un nom de domaine . . . . 209
5.2 Échange de fichiers avec FTP . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
5.2.1 Client simple. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
5.2.2 Client évolué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
5.3 Connexion à un serveur HTTP . . . . . . . . . . . . . . . . . . . . . . . . . 216
5.3.1 Création d'une requête . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
5.3.2 Exécution de la requête . . . . . . . . . . . . . . . . . . . . . . . . . . 218
5.3.3 Lecture du résultat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
5.3.4 Authentification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
5.4 Le chiffrement avec SSL et TLS . . . . . . . . . . . . . . . . . . . . . . . . . 223
6. Les interfaces réseau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
Chapitre 7
QtSql
1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
2. Intégration et interactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
3. Persistance des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
3.1 Utilisation d'un serveur de données . . . . . . . . . . . . . . . . . . . . . 228
3.2 Ce que QtSql permet et ne permet pas . . . . . . . . . . . . . . . . . . . 229
3.3 Le modèle de conception approprié . . . . . . . . . . . . . . . . . . . . . . 229
4. Connexion au serveur de données . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
5. Effectuer une requête . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
5.1 La requête . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234
5.2 Le résultat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
5.3 Le mode transactionnel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
5.4 Obtenir les métadonnées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
5.5 Rechercher les performances . . . . . . . . . . . . . . . . . . . . . . . . . . . 238
7
Maîtrisez Qt 5
8
Guide de développement d’applications professionnelles
5.5.1 Préparation de la requête . . . . . . . . . . . . . . . . . . . . . . . . . 240
5.5.2 Exécution de la requête . . . . . . . . . . . . . . . . . . . . . . . . . . 241
5.5.3 Stratégie d'instanciation. . . . . . . . . . . . . . . . . . . . . . . . . . 242
Chapitre 8
QtGui
1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
2. Intégration et interactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
3. QGuiApplication et QWindow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
3.1 QGuiApplication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
3.2 QWindow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
4. Rendu 2D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
4.1 Géométrie et positionnement . . . . . . . . . . . . . . . . . . . . . . . . . . 247
4.2 Images . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248
4.2.1 QImage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248
4.2.2 QPixmap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250
4.3 Dessin 2D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
4.3.1 Dessiner des formes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252
4.3.2 Dessiner du texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254
5. Rendu 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
Chapitre 9
QtWidgets
1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257
2. Intégration et interactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258
3. Flux d'application et de GUI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
4. Modèle objet et modèle-vue. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
4.1 Modèle-vue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
4.2 Architecture du code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270
Table des matières
5. Créer avec Qt Designer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271
5.1 Organisation du designer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
5.2 Mise en page . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
5.2.1 Ergonomie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
5.2.2 Redimensionnement automatique . . . . . . . . . . . . . . . . . 276
5.2.3 Une mise en page plus complexe. . . . . . . . . . . . . . . . . . . 289
5.2.4 Modèle objet et relations . . . . . . . . . . . . . . . . . . . . . . . . . 297
6. Créer « à la main » . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297
7. Modes SDI et MDI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299
8. Créer un menu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304
9. Réagir aux événements. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307
10. Intégrer et afficher les dialogues créés . . . . . . . . . . . . . . . . . . . . . . . . 310
11. Feuilles de style . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312
12. Gestion des événements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316
13. Ressources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320
13.1 Créer un fichier de ressources . . . . . . . . . . . . . . . . . . . . . . . . . . 320
13.2 Utiliser une ressource dans le designer . . . . . . . . . . . . . . . . . . . 321
13.3 Accéder à une ressource depuis le code . . . . . . . . . . . . . . . . . . . 323
14. Widgets personnalisés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323
15. Icône de notification (Tray icon). . . . . . . . . . . . . . . . . . . . . . . . . . . . 327
16. Composants graphiques 2D. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
17. Drag and Drop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334
17.1 Initialisation des widgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335
17.2 Mise en place du drag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336
17.3 Mise en place du drop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338
18. Copier-coller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
19. Ouvrir et enregistrer des fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 340
20. Généraliser les styles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342
9
10
Maîtrisez Qt 5
Guide de développement d’applications professionnelles
Chapitre 10
QtMultimedia
1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
2. Intégration et interactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344
3. Audio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344
3.1 Lister les périphériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344
3.2 Enregistrer du son. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345
3.3 Lire un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347
4. Vidéo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349
4.1 Enregistrer une vidéo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349
4.2 Lire une vidéo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350
5. Caméra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351
5.1 Afficher en direct . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351
5.2 Enregistrer en direct . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352
6. Radio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353
6.1 Lire un flux radio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354
6.2 Enregistrer un flux radio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356
Chapitre 11
Les modules graphiques et web
1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357
2. QtSvg. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357
2.1 Intégration et interactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357
2.2 Rendu et affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358
2.3 Exporter au format SVG . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358
3. QtPrintSupport. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360
3.1 Intégration et interactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360
3.2 Choisir l'imprimante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360
3.3 Imprimer un dessin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361
3.4 Imprimer un widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363
Table des matières
3.5 Imprimer du texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363
4. QtWebkitWidgets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364
4.1 Intégration et interactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364
4.2 Afficher une page web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364
4.3 Accéder au DOM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366
4.4 Bases de données HTML 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369
Chapitre 12
QtTest - qualité du code
1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371
2. Intégration et interactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372
3. Scénario de tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372
4. Tests unitaires et couverture de code . . . . . . . . . . . . . . . . . . . . . . . . 375
4.1 Les assertions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376
4.2 Exécution des test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377
4.3 Diversifier les données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379
4.4 Événements GUI. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381
4.5 Tester les performances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
5. Non-régression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384
Chapitre 13
Traduction d’une application
1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385
2. Cycle de traduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385
3. Rendre traduisible son application . . . . . . . . . . . . . . . . . . . . . . . . . . 387
3.1 Code source . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387
3.2 Vues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
11
12
Maîtrisez Qt 5
Guide de développement d’applications professionnelles
4. Traduire son application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390
4.1 Langue et région . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390
4.2 Traduction de l'application . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391
4.2.1 Exportation des textes . . . . . . . . . . . . . . . . . . . . . . . . . . . 391
4.2.2 Traduction des textes. . . . . . . . . . . . . . . . . . . . . . . . . . . . 391
4.2.3 Compilation des traductions . . . . . . . . . . . . . . . . . . . . . . 394
4.3 Intégration des traductions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394
5. Contexte de traduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396
Chapitre 14
Publication d'une application
1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397
2. Comprendre les licences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398
3. Les dépendances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400
4. Créer un installeur universel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401
5. Créer un installeur pour Windows . . . . . . . . . . . . . . . . . . . . . . . . . . 402
5.1 Programme compilé avec Microsoft Visual C++ . . . . . . . . . . 402
5.2 Programme compilé avec mingw. . . . . . . . . . . . . . . . . . . . . . . . 403
6. Créer un installeur pour OS X . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404
6.1 Bundle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404
6.1.1 Création . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405
6.1.2 Signature . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406
6.2 Fichier DMG . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407
6.3 Paquet d'installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
7. Créer un paquet pour Debian/Ubuntu . . . . . . . . . . . . . . . . . . . . . . . 409
7.1 Arborescence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
7.2 Fichier de contrôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411
7.3 Création du paquet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412
Table des matières
8. Inclure les plugins de Qt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412
8.1 Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412
8.2 OS X . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413
8.3 GNU/Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413
9. Tester son application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414
Chapitre 15
Techniques d'optimisation
1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
2. Langages et mode de pensée. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416
3. Optimisations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 419
3.1 Le modèle objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420
3.2 Le cycle de vie des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 422
3.3 Les classes optimisées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425
3.3.1 QByteArray . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425
3.3.2 QStringRef . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427
3.4 Optimiser le processeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429
4. Lectures complémentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 431
Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433
13
Chapitre 5
QtCore et fondations
1. Objectifs
QtCore et fondations
Dans ce chapitre nous vous présenterons le module principal, le plus important de Qt : le module QtCore. Celui-ci contient un certain nombre de classes
indispensables pour la création d'applications comme QString pour les
chaînes de caractères, QTimer pour la programmation d'événements, QFile
et QDir pour la gestion des fichiers et encore bien d'autres.
La présentation de ce module est aussi, et avant toute chose, l'occasion
d'introduire les concepts fondamentaux de Qt et la manière dont ce framework
facilitera grandement vos travaux de conception et de développement. Parmi
ceux-ci nous étudierons particulièrement le modèle objet et la façon d'interagir avec la run-loop en utilisant les signaux et les slots, deux notions propres au
framework Qt.
2. Intégration et interactions
Le module QtCore est intégré à votre projet grâce à l'ajout du mot clé core
dans la déclaration QT de votre fichier .pro.
QT += core
Maîtrisez Qt 5
108
Guide de développement d’applications professionnelles
Remarque
Il est pratiquement impossible de s'en passer, sauf si vous faites de la programmation purement C++ sans utiliser aucune des fonctionnalités de Qt.
N'importe quel autre module de Qt aura besoin de celui-ci.
3. Découverte de QtCore
QtCore est un ensemble d'API qui fournit essentiellement des types de base
comme les chaînes de caractères Unicode, les type fichier et répertoire pour
l'accès aux disques, des interfaces pour les entrées-sorties et des mécanismes
de gestion des événements. Cet ensemble de classes est nommé, dans l'univers
Qt, un module. Il contient notamment la classe QObject, la mère des classes
contenues dans les autres modules de Qt et de vos futures classes. En outre, la
plupart des classes de QtCore sont utilisées par les autres API de Qt.
3.1 Principes de conception
Comme nous l'avons évoqué précédemment, la conception de votre application suppose que vous ayez une idée des objets que vous allez créer et de la
manière dont ils vont interagir. Dans certains cas, vos objets pourront
interagir de manière synchrone et dans d'autres l'interaction sera nécessairement asynchrone, pour être non bloquante.
Pour vous aider à simplifier votre conception, nous vous proposons un découpage de vos objets en catégories et le type d'approche que vous devez avoir
pour les appels de fonctions sur ces objets.
Type d'appel
Objet du modèle
Synchrone
Helper
Généralement synchrone
DAO
Synchrone
Factory
Synchrone
Contrôleur
Généralement asynchrone
Widget graphique
Asynchrone
© Editions ENI - All rights reserved
Type d'objet
QtCore et fondations
Chapitre 5
Pour vous simplifier la vie, vous ferez hériter tous vos objets directement ou
indirectement de la classe QObject. Cela aura l'avantage de vous faire bénéficier de la fonction tr(), membre de la classe QObject et qui vous permettra de traduire facilement vos chaînes de caractères dans différentes langues,
ainsi que des mécanismes d'émission et de réception de signaux.
Remarque
Il vous suffit d'hériter publiquement de QObject pour que les classes enfants
bénéficient elles aussi des fonctionnalités de QObject, inutile donc de vous
lancer dans un double héritage. Si votre classe parente n'hérite pas de
QObject, faites-la hériter de QObject car vous risquez d'être rapidement
bloqué.
3.2 La classe QObject
Cette classe est au centre de tous les mécanismes complexes de Qt comme
l'émission de signaux, la traduction d'interfaces, la hiérarchie d'objets et
l'autodestruction des instances, le nommage et les timers.
Toutes les classes de Qt en héritent, et toutes vos classes devraient faire de
même. Peu importe si elles utilisent les mécanismes cités ci-dessus selon votre
idée initiale de la conception de votre application, il est plus que probable que
vous en aurez besoin tôt ou tard. Alors autant gagner du temps en faisant
hériter vos classes de QObject.
3.2.1 Prototype
Voici le prototype classique d'une classe héritant de QObject :
class MaClasse : public QObject
{
Q_OBJECT
public :
explicit MaClasse(QObject* parent = 0) ;
signals :
void signalOk(void) ;
109
Maîtrisez Qt 5
110
Guide de développement d’applications professionnelles
public slots :
void onSignalOk(void) ;
private slots :
void onSignalKo(void) ;
}
Votre classe doit donc obligatoirement :
– hériter publiquement de QObject.
– utiliser la macro Q_OBJECT avant toute autre déclaration.
– avoir un ou plusieurs constructeurs possédant au moins un argument
QObject* parent initialisé à 0.
La macro Q_OBJECT apportera à votre classe les mécanismes de gestion des
signaux et des slots.
Remarque
Notez que toutes les classes qui héritent d'une classe héritant de QObject doivent utiliser la macro Q_OBJECT.
Votre classe peut, optionnellement déclarer les sections suivantes :
– signals : indique que votre classe émettra un ou plusieurs signaux et publie leurs signatures. Un signal peut avoir un ou plusieurs arguments.
– slots : peut être public, protected ou private. Indique que votre
classe peut recevoir des signaux. Les slots peuvent avoir un ou plusieurs
arguments.
La classe QObject possède un constructeur de copie et un opérateur d'assignation privés. Elle n'est donc pas copiable. Cela signifie en outre que les
classes héritant de QObject ne seront copiables qu'à condition que vous implémentiez vous-même ces fonctions.
Vous devez donc ajouter ces deux fonctions à votre classe :
MaClasse(const MaClasse& orig) ;
MaClasse& operator =(const MaClasse& orig) ;
© Editions ENI - All rights reserved
3.2.2 Copie
QtCore et fondations
Chapitre 5
Les objets Qt doivent être considérés comme des identités et non des valeurs,
à ce propos nous démontrerons qu'il est contre-productif et même risqué de
les instancier statiquement. Si un objet héritant de QObject et créé par vous
doit être copié, vous devez implémenter les constructeurs par copie et/ou les
opérateurs de copie pour procéder vous même à la copie des membres. Ainsi la
copie sera un nouvel élément doté de membres dont les emplacements
mémoire lui seront propres. Ce sera donc pour vous l'occasion de décider quel
type de copie vous ferez de vos objets.
Cette notion est d'autant plus importante que de très nombreuses classes de
Qt utilisent le lazy-copy et le partage implicite. Les données ne sont copiées que
si elles doivent être modifiées, c'est ainsi que Qt tire au maximum profit des
qualités de C++ et offre des performances étonnantes.
3.2.3 Internationalisation
Aussi connu sous le nom de i18n, ce mécanisme de traduction est accessible
grâce à la fonction tr() membre de QObject. Nous aborderons en détail le
mécanisme de traduction de votre application dans le chapitre Traduction
d’une application.
3.3 Métaclasses
Qt utilise un système de méta-objets pour faciliter le travail des programmeurs dans la gestion des signaux et l'appel asynchrone des fonctions. Cette
métaclasse est directement issue de l'héritage de la classe QObject et de la
macro Q_OBJECT. L'utilitaire moc exécuté dans la première partie de la compilation de votre projet générera automatiquement la métaclasse associée à
votre classe.
111
Maîtrisez Qt 5
Guide de développement d’applications professionnelles
La métaclasse sert en quelque sorte d'intermédiaire entre le modèle objet de
votre application et celui de Qt, en particulier la run-loop. Contrairement à
votre modèle objet les classes du méta-modèle savent comment émettre et
recevoir des signaux. La fonction emit() ou l'opérateur emit ainsi que les
fonctions déclarées dans les sections signals et slots ne sont jamais appelés directement par vos classes mais redirigés par et vers les méta-objets.
Remarque
Une métaclasse ajoute des fonctionnalités et des attributs à votre classe et lui
permet de s'intégrer parfaitement dans le système de gestion des signaux et
slots.
Ce mécanisme est totalement transparent pour vous, les classes sont générées
automatiquement et leur contenu dépend à la fois du contexte de votre
programme et de la manière dont vous faites dépendre vos objets les uns des
autres, c'est-à-dire la manière dont vous émettez vos signaux ou faites vos
appels asynchrones.
En outre, ce mécanisme permet d'effectuer des appels asynchrones sur les
fonctions de vos classes grâce à des fonctions comme QMetaObjet::invokeMethod(), ce que C++ ne permet pas naturellement.
© Editions ENI - All rights reserved
112