Qt 5 QtWidgets QtMultimedia QtGui QtNetwork QtSql Qt 5 · Maîtrisez Qt 5 Guide de développement...

Maîtrisez Qt 5 Guide de développement d’applications professionnellesCe 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 et mobiles, pour amé-liorer les performances des applications et satisfaire au mieux les exigences des utilisateurs. A ce titre, l’auteur présente les différents aspects de Qt 5, à la fois bibliothèque et framework, depuis ses fondations jusqu’aux éléments d’interface graphique multiplateformes. Pour tirer pleinement parti de ce livre, les lecteurs devront posséder des connaissances suffisantes en C++.Étape par étape vous comprendrez la structure de la bibliothèque, le modèle objet de Qt et la program-mation é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 mo-dules graphiques 2D et 3D (QtGui), les modules de composants d’interface graphique et multimédia (QtWidgets et QtMultimedia). Cette seconde édition a également été enrichie pour intégrer les nom-breuses évolutions de Qt comme le développement rapide d’applications avec le module QtQuick et le langage déclaratif QML, ou les API dédiées aux plateformes mobiles (capteurs, positionnement, cartographie, Bluetooth, NFC et achats in-app).Les derniers chapitres vous permettront de rendre concret cet ensemble en l’appliquant au travail quo-tidien 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.

ISSN : 1960-3444ISBN : 978-2-409-01176-4

54 €

Tristan ISRAËLIngénieur et titulaire d’un MBA (Master in Busi-ness Administration), Tristan ISRAËL est déve-loppeur professionnel C et C++ depuis 1997 et spécialisé sur Qt depuis 2005. Aujourd’hui, il apporte son expertise du développement Qt à des grands comptes industriels pour le dévelop-pement d’applications spécifiques et complexes. Titulaire de trois certifications Qt, il partage ses connaissances au travers d’ateliers de formation en entreprise. Dans les pages de ce livre, il trans-met sa passion pour cette plateforme qui lui per-met de concilier le plaisir d’utiliser les technolo-gies C avec le respect de la qualité fonctionnelle et ergonomique des applications qu’il crée.

Avant-propos • Introduction • L’environnement de développement • Les fondations de Qt • Anatomie d’une application • Développement rapide d’applica-tions • QtCore et fondations • QtNetwork • QtSql • QtGui • QtWidgets • QtMultimedia • Les modules graphiques et web • API pour les plateformes mo-biles • QtTest - qualité du code • Traduction d’une ap-plication • Publication d’une application • Techniques d’optimisation

Les chapitres du livre

Téléchargementwww.editions-eni.fr.fr

sur www.editions-eni.fr : b Code source d’exemples autour

des différents modules Qt.

Pour plus d’informations :

Maî

tris

ez Q

t 5G

uide

de

déve

lopp

emen

t d’a

pplic

atio

ns p

rofe

ssio

nnel

les

MaîtrisezQt 5

Guide de développementd’applications professionnelles

Tristan ISRAËL

2e édition

Nouvelle édition

1Table des matières

Avant-propos

Chapitre 1

Introduction

1. Objectifs et méthode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

2. Glossaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

3. Qt, qu'est-ce ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233.1 Histoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243.2 Compatibilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263.3 Notoriété . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263.4 Bibliothèque ou framework ?. . . . . . . . . . . . . . . . . . . . . . . . . . . . 263.5 Documentation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

4. Connaissances requises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284.1 UML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284.2 Patrons de conception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284.3 C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294.4 Contrôler ses connaissances. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

5. Que peut-on faire avec Qt ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305.1 Applications pour PC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325.2 Applications mobiles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325.3 Applications serveur et web services . . . . . . . . . . . . . . . . . . . . . . 32

6. Contrôle des connaissances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

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 EP25QT dans la zone de recherche et validez. Cliquez sur le titre du livre puis sur le bouton de téléchargement.

lcroise

Tampon

2Guide de développement d’applications professionnelles

Maîtrisez Qt 5

Chapitre 2

L'environnement de développement

1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

2. Licence commerciale ou libre ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352.1 Propriété intellectuelle et GPL . . . . . . . . . . . . . . . . . . . . . . . . . . . 362.2 Diffusion de l'application. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

3. Choisir judicieusement son compilateur. . . . . . . . . . . . . . . . . . . . . . . 373.1 Monoplateforme ou multiplateforme ? . . . . . . . . . . . . . . . . . . . 373.2 Maintenabilité du code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

4. Installer l'environnement de développement . . . . . . . . . . . . . . . . . . . 414.1 Le compilateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414.2 Plug-ins Qt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424.3 Première installation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434.4 Intégrer un autre environnement de compilation . . . . . . . . . . . 49

5. Maintenir à jour son environnement . . . . . . . . . . . . . . . . . . . . . . . . . 535.1 Profiter des dernières nouveautés . . . . . . . . . . . . . . . . . . . . . . . . 555.2 Gérer le cycle de vie de son application. . . . . . . . . . . . . . . . . . . . 58

6. Utiliser Qt Creator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 596.1 Organisation des projets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 596.2 Fenêtre principale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

6.2.1 Boutons d'accès aux modules. . . . . . . . . . . . . . . . . . . . . . . 616.2.2 Boutons de compilation et d'exécution. . . . . . . . . . . . . . . 616.2.3 Onglets de journaux. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 636.2.4 Onglets de contenus additionnels . . . . . . . . . . . . . . . . . . . 656.2.5 Sessions récentes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 666.2.6 Projets récents. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

6.3 Module d'édition. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 666.4 Module de conception d'interfaces graphiques. . . . . . . . . . . . . . 676.5 Module de débogage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 676.6 Module de configuration de projet . . . . . . . . . . . . . . . . . . . . . . . 696.7 Module de profilage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 706.8 Paramétrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70


7. Créer une application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

8. Création et gestion des ressources . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74

9. Contrôle des connaissances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

Chapitre 3

Les fondations de Qt

1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

2. La classe QObject . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 832.1 Entité et identité. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 842.2 Modèle de threads. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 852.3 Affinité de thread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 862.4 Signaux et slots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88

2.4.1 Le signal. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 892.4.2 Le slot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 892.4.3 La connexion. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 902.4.4 Différents types de connexion. . . . . . . . . . . . . . . . . . . . . . 932.4.5 L'appel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 952.4.6 Éléments particuliers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98

2.5 Arbre d’objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1022.6 Timers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1052.7 Traduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1062.8 Propriétés dynamiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106

3. Héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1073.1 Généralités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1073.2 Prototype. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1083.3 Conversion de types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109

4. Copie à l’écriture. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1114.1 Comptage de références . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1114.2 Partage implicite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1154.3 Partage explicite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116

5. La classe QVariant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117


Maîtrisez Qt 5

6. Gestion des erreurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

6.1 bool *ok = 0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

6.2 error() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

7. Le modèle event-driven . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

7.1 Pourquoi Qt est-il orienté événements ?. . . . . . . . . . . . . . . . . . 122

7.2 La notion de flux. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

7.3 La run-loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128

7.4 La programmation asynchrone . . . . . . . . . . . . . . . . . . . . . . . . . 131

7.5 Appeler une fonction de manière asynchrone . . . . . . . . . . . . . 133

7.5.1 L'émission de signaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134

7.5.2 L'utilisation d'un timer. . . . . . . . . . . . . . . . . . . . . . . . . . . 135

7.5.3 La fonction invokeMethod . . . . . . . . . . . . . . . . . . . . . . . 136

7.6 Suppression explicite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

7.7 Avantages et inconvénients . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

7.8 Gestion des ressources et performances . . . . . . . . . . . . . . . . . . 139

7.9 Rendre ses algorithmes non bloquants . . . . . . . . . . . . . . . . . . . 140

7.9.1 Effectuer une boucle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140

7.9.2 Faire une pause dans le programme . . . . . . . . . . . . . . . . 143

7.10 Faire dialoguer des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144

8. Les ressources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149

9. Les propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150

10. Contrôle des connaissances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153

Chapitre 4

Anatomie d'une application

1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157

2. L'humain . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158

2.1 Les différents types d'applications. . . . . . . . . . . . . . . . . . . . . . . 158

2.2 Contenu d'un projet Qt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159


2.3 Création d'une application . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1592.3.1 En ligne de commande . . . . . . . . . . . . . . . . . . . . . . . . . . . 1592.3.2 Avec Qt Creator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163

2.4 Le fichier projet .pro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1642.4.1 Les directives de projet . . . . . . . . . . . . . . . . . . . . . . . . . . . 1642.4.2 Les directives de chemins . . . . . . . . . . . . . . . . . . . . . . . . . 1652.4.3 Les directives de précompilation . . . . . . . . . . . . . . . . . . . 166

3. La machine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1663.1 Les commandes externes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1663.2 La phase de compilation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167


Chapitre 5

Développement rapide d'applications

1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171

2. QtQuick et QML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1722.1 La programmation déclarative . . . . . . . . . . . . . . . . . . . . . . . . . . 1732.2 QML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1742.3 Les éléments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1772.4 MVC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1792.5 Limitations de QtQuick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181

3. Création de l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1833.1 Création d’une application . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1833.2 La scène . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187

3.2.1 Les éléments invisibles . . . . . . . . . . . . . . . . . . . . . . . . . . . 1943.3 Les données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1953.4 Le contrôleur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196

3.4.1 Initialisation de l’application . . . . . . . . . . . . . . . . . . . . . . 1973.4.2 Réaction aux événements . . . . . . . . . . . . . . . . . . . . . . . . 1983.4.3 Déclenchement des actions . . . . . . . . . . . . . . . . . . . . . . . 199


Maîtrisez Qt 5

3.5 Les états et transitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2003.5.1 États. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2003.5.2 Transitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204


Chapitre 6

QtCore

1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207

2. Intégration et interactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207

3. Découverte de QtCore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2083.1 Le méta-objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2083.2 Introspection. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2093.3 Le méta-type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2103.4 Instanciation dynamique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211

4. Créer et piloter des threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2114.1 Paralléliser des tâches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212

4.1.1 Les threads pilotés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2124.1.2 Un exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2154.1.3 Les tâches simples. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2184.1.4 Lancer une tâche asynchrone. . . . . . . . . . . . . . . . . . . . . . 220

4.2 Synchronisation par blocage et protection . . . . . . . . . . . . . . . . 2224.3 Synchronisation par notification. . . . . . . . . . . . . . . . . . . . . . . . 224

5. Les structures de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2265.1 Structures unidimensionnelles . . . . . . . . . . . . . . . . . . . . . . . . . 2265.2 Structures multidimensionnelles. . . . . . . . . . . . . . . . . . . . . . . . 2315.3 Rechercher les performances . . . . . . . . . . . . . . . . . . . . . . . . . . . 233

6. QByteArray. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2346.1 Instanciation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2356.2 Utilisation d’un pointeur existant. . . . . . . . . . . . . . . . . . . . . . . 2356.3 Rechercher des sous-ensembles . . . . . . . . . . . . . . . . . . . . . . . . . 2366.4 Convertir un QByteArray . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237


7. QBuffer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238

8. QString . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2398.1 Les chaînes C et les langues accentuées . . . . . . . . . . . . . . . . . . 2408.2 Les normes ISO, Unicode, UCS . . . . . . . . . . . . . . . . . . . . . . . . . 2408.3 Échanger des données. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2438.4 Composer des chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2458.5 Listes de chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . 2468.6 Découper des chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . 2478.7 Extraire une sous-chaîne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2478.8 Rechercher une sous-chaîne . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2488.9 Construire une chaîne à partir d’un nombre . . . . . . . . . . . . . . 2488.10 Convertir une chaîne en nombre . . . . . . . . . . . . . . . . . . . . . . . . 2498.11 Connaître la taille de la chaîne. . . . . . . . . . . . . . . . . . . . . . . . . . 249

9. Interactions avec le système d'exploitation . . . . . . . . . . . . . . . . . . . 2509.1 Exécuter une commande externe . . . . . . . . . . . . . . . . . . . . . . . 2509.2 Les fichiers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252

10. La gestion des paramètres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25410.1 QSettings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25410.2 Une classe propriétaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256

11. La sérialisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25711.1 Mécanismes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25711.2 Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260

12. Les fichiers XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26112.1 Écrire dans un fichier XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26112.2 Lire un fichier XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263

13. Les fichiers JSON . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26513.1 Lire un fichier JSON . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26513.2 Écrire dans un fichier JSON . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268

14. Automate à états . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26914.1 Automate simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26914.2 Collaboration entre automates . . . . . . . . . . . . . . . . . . . . . . . . . 271


Maîtrisez Qt 5

14.3 Automate fini . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27314.4 Animer les changements de propriétés . . . . . . . . . . . . . . . . . . . 274

15. Fonctions et types globaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27515.1 Conversion d’endianisme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27515.2 Types universels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27715.3 Fonctions globales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277

15.3.1Mathématiques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27715.3.2Utilitaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278

15.4 Macros. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27815.5 Fonctions mathématiques avancées . . . . . . . . . . . . . . . . . . . . . 280


Chapitre 7

QtNetwork

1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283


3. Accéder au réseau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2843.1 Portée de QtNetwork . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2843.2 Appel bloquant vs non bloquant . . . . . . . . . . . . . . . . . . . . . . . . 285

4. Sockets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2874.1 Client TCP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287

4.1.1 Connexion avec un hôte . . . . . . . . . . . . . . . . . . . . . . . . . 2884.1.2 Envoi d'une requête . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2894.1.3 Lecture d'une réponse. . . . . . . . . . . . . . . . . . . . . . . . . . . . 2894.1.4 Fermeture et nettoyage . . . . . . . . . . . . . . . . . . . . . . . . . . 290

4.2 Serveur TCP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2924.3 Client UDP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294

4.3.1 Connexion à un hôte . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2944.3.2 Envoi de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2954.3.3 Lecture des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2964.3.4 Fermeture de la connexion. . . . . . . . . . . . . . . . . . . . . . . . 297


5. Internet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2975.1 Résolution DNS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297

5.1.1 Résoudre un nom de machine . . . . . . . . . . . . . . . . . . . . . 2985.1.2 Obtenir les enregistrements d'un nom de domaine . . . . 299

5.2 Échange de fichiers avec FTP . . . . . . . . . . . . . . . . . . . . . . . . . . . 3015.2.1 Client simple. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3025.2.2 Client évolué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304

5.3 Connexion à un serveur HTTP . . . . . . . . . . . . . . . . . . . . . . . . . 3065.3.1 Création d'une requête . . . . . . . . . . . . . . . . . . . . . . . . . . . 3075.3.2 Exécution de la requête . . . . . . . . . . . . . . . . . . . . . . . . . . 3085.3.3 Lecture du résultat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3085.3.4 Authentification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311

5.4 Le chiffrement avec SSL et TLS . . . . . . . . . . . . . . . . . . . . . . . . . 313

6. Les interfaces réseau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315


Chapitre 8

QtSql

1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319


3. Persistance des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3203.1 Utilisation d'un serveur de données . . . . . . . . . . . . . . . . . . . . . 3203.2 Ce que QtSql permet et ne permet pas . . . . . . . . . . . . . . . . . . . 3213.3 Le modèle de conception approprié . . . . . . . . . . . . . . . . . . . . . . 321

4. Connexion au serveur de données . . . . . . . . . . . . . . . . . . . . . . . . . . . 324

5. Effectuer une requête . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3255.1 La requête . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3265.2 Le résultat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3275.3 Le mode transactionnel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3285.4 Obtenir les métadonnées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329


Maîtrisez Qt 5

5.5 Rechercher les performances . . . . . . . . . . . . . . . . . . . . . . . . . . . 3305.5.1 Préparation de la requête . . . . . . . . . . . . . . . . . . . . . . . . . 3325.5.2 Exécution de la requête . . . . . . . . . . . . . . . . . . . . . . . . . . 3335.5.3 Stratégie d'instanciation. . . . . . . . . . . . . . . . . . . . . . . . . . 334


Chapitre 9

QtGui

1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337


3. QGuiApplication et QWindow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3383.1 QGuiApplication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3383.2 QWindow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339

4. Rendu 2D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3404.1 Géométrie et positionnement . . . . . . . . . . . . . . . . . . . . . . . . . . 3414.2 Images . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342

4.2.1 QImage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3424.2.2 QPixmap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344

4.3 Dessin 2D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3454.3.1 Dessiner des formes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3464.3.2 Dessiner du texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348

5. Rendu 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349


Chapitre 10

QtWidgets

1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351


3. Flux d'application et de GUI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353


4. Modèle objet et Vue-Modèle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3554.1 Vue-Modèle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3564.2 Architecture du code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364

5. Créer avec Qt Designer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3655.1 Organisation du designer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3685.2 Mise en page . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369

5.2.1 Ergonomie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3695.2.2 Redimensionnement automatique . . . . . . . . . . . . . . . . . 3705.2.3 Une mise en page plus complexe. . . . . . . . . . . . . . . . . . . 3825.2.4 Modèle objet et relations . . . . . . . . . . . . . . . . . . . . . . . . . 389

6. Créer « à la main » . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389

7. Modes SDI et MDI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391

8. Créer un menu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396

9. Réagir aux événements. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399

10. Intégrer et afficher les dialogues créés . . . . . . . . . . . . . . . . . . . . . . . . 401

11. Feuilles de style . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403

12. Gestion des événements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407

13. Ressources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41113.1 Créer un fichier de ressources . . . . . . . . . . . . . . . . . . . . . . . . . . 41113.2 Utiliser une ressource dans le designer . . . . . . . . . . . . . . . . . . . 41213.3 Accéder à une ressource depuis le code . . . . . . . . . . . . . . . . . . . 414

14. Widgets personnalisés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414

15. Icône de notification (Tray icon). . . . . . . . . . . . . . . . . . . . . . . . . . . . 418

16. Composants graphiques 2D. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 422

17. Drag and Drop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42517.1 Initialisation des widgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42617.2 Mise en place du drag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42717.3 Mise en place du drop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429

18. Copier-coller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 430

19. Ouvrir et enregistrer des fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 431


Maîtrisez Qt 5

20. Généraliser les styles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433


Chapitre 11

QtMultimedia

1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437


3. Audio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4383.1 Lister les périphériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4383.2 Enregistrer du son. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4393.3 Lire un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441

4. Vidéo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4434.1 Enregistrer une vidéo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4434.2 Lire une vidéo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444

5. Caméra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4455.1 Afficher en direct . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4455.2 Enregistrer en direct . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446

6. Radio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4476.1 Lire un flux radio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4486.2 Enregistrer un flux radio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 450


Chapitre 12

Les modules graphiques et web

1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453

2. QtSvg. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4532.1 Intégration et interactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4532.2 Rendu et affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4542.3 Exporter au format SVG . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454


3. QtPrintSupport. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4563.1 Intégration et interactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4563.2 Choisir l'imprimante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4563.3 Imprimer un dessin. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4573.4 Imprimer un widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4593.5 Imprimer du texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 459

4. QtWebkitWidgets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4604.1 Intégration et interactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4604.2 Afficher une page web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4604.3 Accéder au DOM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4624.4 Bases de données HTML 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465

5. Qt Charts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4665.1 Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4665.2 Licences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4665.3 Intégration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4675.4 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4675.5 Principe général. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4675.6 Créer un diagramme en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . 4685.7 Créer un diagramme en QML . . . . . . . . . . . . . . . . . . . . . . . . . . 4695.8 Diagramme à barres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 470

5.8.1 C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4705.8.2 QML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4705.8.3 Variantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471

5.9 Diagramme circulaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4735.9.1 C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4735.9.2 QML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4745.9.3 Variantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474

5.10 Diagramme à lignes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4755.10.1C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4755.10.2QML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 476

5.11 Diagramme à surface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4765.11.1C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4775.11.2QML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 478


Maîtrisez Qt 5

5.12 Diagramme à points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4785.12.1C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4795.12.2QML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 479

5.13 Diagramme à chandelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4805.13.1C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4805.13.2QML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 481

5.14 Combiner les diagrammes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4825.15 Modifier la légende . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4835.16 Manipuler les axes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4845.17 Utiliser des thèmes de couleurs . . . . . . . . . . . . . . . . . . . . . . . . . 4855.18 Interagir avec un diagramme . . . . . . . . . . . . . . . . . . . . . . . . . . . 486


Chapitre 13

API pour les plateformes mobiles

1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 489


3. L’environnement de développement. . . . . . . . . . . . . . . . . . . . . . . . . 4903.1 Préparation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4903.2 Configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 491

4. Exécution d’une application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493

5. Capteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4995.1 Utilisation générique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5005.2 Obtenir la liste des capteurs disponibles . . . . . . . . . . . . . . . . . . 5015.3 Lire les valeurs d’un capteur. . . . . . . . . . . . . . . . . . . . . . . . . . . . 5025.4 Lecture asynchrone. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5035.5 Filtrer les données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503

6. Positionnement. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5046.1 Cas d’utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 505

6.1.1 Position courante en C++ . . . . . . . . . . . . . . . . . . . . . . . 5056.1.2 Position courante en QML. . . . . . . . . . . . . . . . . . . . . . . . 506


7. Cartographie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5077.1 Cartes et navigation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 508

7.1.1 Afficher un plan en QML. . . . . . . . . . . . . . . . . . . . . . . . . 5087.1.2 Changer le type de carte. . . . . . . . . . . . . . . . . . . . . . . . . . 511

7.2 Lieux et points d’intérêt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5137.2.1 Afficher la position courante . . . . . . . . . . . . . . . . . . . . . . 5137.2.2 Utiliser une adresse postale . . . . . . . . . . . . . . . . . . . . . . . 5137.2.3 Mettre en évidence un point d’intérêt . . . . . . . . . . . . . . 5157.2.4 Calculer un itinéraire . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517

8. Bluetooth. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5218.1 Cas d’utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 521

8.1.1 Obtenir des informations sur le périphérique Bluetooth. . . . . . . . . . . . . . . . . . . . . . 521

8.1.2 Rechercher des appareils distants . . . . . . . . . . . . . . . . . . 5228.1.3 Envoyer un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5228.1.4 Échanger en direct entre périphériques . . . . . . . . . . . . . . 5238.1.5 Envoyer des notifications par Bluetooth LE . . . . . . . . . . 526

9. NFC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5279.1 Cas d’utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527

9.1.1 Recevoir des tags NFC . . . . . . . . . . . . . . . . . . . . . . . . . . . 5279.1.2 Envoyer un message . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 529

10. Achats in-app . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53010.1 Cas d’utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 530

10.1.1Enregistrer des achats in-app . . . . . . . . . . . . . . . . . . . . . . 53010.1.2Effectuer un achat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53310.1.3Restaurer les achats précédents . . . . . . . . . . . . . . . . . . . . 534



Maîtrisez Qt 5

Chapitre 14

QtTest - qualité du code

1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 537


3. Scénario de tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 538

4. Tests unitaires et couverture de code . . . . . . . . . . . . . . . . . . . . . . . . 5414.1 Les assertions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5424.2 Exécution des tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5434.3 Diversifier les données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5454.4 Événements GUI. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5474.5 Tester les performances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 549

5. Non-régression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 550


Chapitre 15

Traduction d’une application

1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553

2. Cycle de traduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553

3. Rendre traduisible son application . . . . . . . . . . . . . . . . . . . . . . . . . . 5553.1 Code source. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5553.2 Vues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 557

4. Traduire son application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5584.1 Langue et région . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5584.2 Traduction de l'application . . . . . . . . . . . . . . . . . . . . . . . . . . . . 559

4.2.1 Exportation des textes . . . . . . . . . . . . . . . . . . . . . . . . . . . 5594.2.2 Traduction des textes. . . . . . . . . . . . . . . . . . . . . . . . . . . . 5594.2.3 Compilation des traductions . . . . . . . . . . . . . . . . . . . . . . 562

4.3 Intégration des traductions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 562

5. Contexte de traduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 564



Chapitre 16

Publication d'une application

1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 567

2. Comprendre les licences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 568

3. Les dépendances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 570

4. Créer un installeur universel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 571

5. Créer un installeur pour Windows . . . . . . . . . . . . . . . . . . . . . . . . . . 5725.1 Programme compilé avec Microsoft Visual C++ . . . . . . . . . . 5725.2 Programme compilé avec mingw. . . . . . . . . . . . . . . . . . . . . . . . 573

6. Créer un installeur pour OS X . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5746.1 Bundle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 574

6.1.1 Création. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5756.1.2 Signature . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 576

6.2 Fichier DMG . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5776.3 Paquet d'installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 579

7. Créer un paquet pour Debian/Ubuntu . . . . . . . . . . . . . . . . . . . . . . . 5797.1 Arborescence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5797.2 Fichier de contrôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5817.3 Création du paquet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 582

8. Inclure les plug-ins de Qt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5828.1 Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5828.2 OS X . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5838.3 GNU/Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 583

9. Tester son application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 584


Chapitre 17

Techniques d'optimisation

1. Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 587

2. Langages et mode de pensée. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 588


Maîtrisez Qt 5

3. Notions de C++ indispensables . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5913.1 Pointeurs et références . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 591

3.1.1 Pointeurs C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5923.1.2 Références . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594

3.2 Copie d'objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5963.2.1 Copie superficielle (shallow copy). . . . . . . . . . . . . . . . . . 5963.2.2 Copie en profondeur (deep copy) . . . . . . . . . . . . . . . . . . 5983.2.3 Copie paresseuse (lazy copy) . . . . . . . . . . . . . . . . . . . . . . 6003.2.4 Partage implicite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 603

4. Optimisations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6054.1 Le modèle objet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6064.2 Le cycle de vie des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6084.3 Les classes optimisées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 611

4.3.1 QByteArray. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6114.3.2 QStringRef . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 613

4.4 Optimiser l’utilisation du processeur . . . . . . . . . . . . . . . . . . . . 615

5. Quelques particularités de Qt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6175.1 Types primitifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6175.2 Gestion de la mémoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 618

5.2.1 Cycle de vie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6185.2.2 Structures de données . . . . . . . . . . . . . . . . . . . . . . . . . . . 619

5.3 STL, Boost et Qt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6205.4 Réentrance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6215.5 Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 622

6. Lectures complémentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 624

Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 627

Chapitre 6

QtCore

QtCore

1. Objectifs

Dans ce chapitre nous vous présenterons le module principal, le plus impor-tant de Qt : le module QtCore. Celui-ci contient un certain nombre de classesindispensables pour la création d'applications, telles que QString pour leschaînes de caractères, QTimer pour la programmation d'événements, QFileet QDir pour la gestion des fichiers et encore bien d'autres.

Ce module est un des plus importants, car sur lui reposent tous les autresmodules. Il intègre une grande partie des fonctionnalités offertes par Qt et dé-crites dans le chapitre Les fondations de Qt, en particulier la classe QObject.

2. Intégration et interactions

Le module QtCore est intégré à votre projet grâce à l'ajout du mot-clé coredans la déclaration QT de votre fichier .pro.

QT += core

Remarque

Il est pratiquement impossible de s'en passer, sauf si vous faites de la program-mation purement C++ sans utiliser aucune des fonctionnalités de Qt.N'importe quel autre module de Qt aura besoin de celui-ci.

lcroise

Tampon

© E

dit

ions

EN

I -

All r

ights

rese

rved


Maîtrisez Qt 5

3. Découverte de QtCore

QtCore est un ensemble d'API qui fournit essentiellement des types de basecomme les chaînes de caractères Unicode, les types fichier et répertoire pourl'accès aux disques, des interfaces pour les entrées-sorties et des mécanismesde gestion des événements.

Cet ensemble de classes est nommé, dans l'univers Qt, un module. Il contientnotamment la classe QObject, la mère des classes contenues dans les autresmodules de Qt et de vos futures classes. En outre, la plupart des classes deQtCore sont utilisées par les autres API de Qt.

3.1 Le méta-objet

Comme expliqué dans le chapitre Anatomie d'une application, Qt utilise unsystème de méta-objets pour faciliter le travail du développeur dans la gestiondes signaux et l'appel asynchrone des fonctions.

La méta-classe correspondant au méta-objet est directement issue de l'héritagede la classe QObject et de l’usage de la macro Q_OBJECT.

Lorsque vous utilisez la macro Q_OBJECT, vous ajoutez plusieurs déclarationsde fonctions à votre classe. Ces fonctions seront utilisées par Qt pour réaliserles appels de slots et générer les signaux.

Comme vous n'implantez pas vous-même ces fonctions surnuméraires, c'estQt qui va le faire pendant la phase de construction du programme. L'utilitairemoc est chargé de générer le code de ces fonctions associées à votre classe.

209QtCoreChapitre 6

Les fonctions ajoutées par Qt permettent d'étendre les capacités de votre codesource afin de le rendre capable d'émettre des signaux et d'en recevoir.

La fonction emit() ou l'opérateur emit ainsi que les fonctions déclaréesdans les sections signals et slots ne sont jamais appelés directement parvos classes mais redirigés par et vers les méta-objets.

Remarque

Qt ajoute des fonctionnalités et des attributs à votre classe et lui permet des'intégrer parfaitement dans le système de gestion des signaux et slots.

Ce mécanisme est totalement transparent pour vous, les fonctions sontgénérées automatiquement et leur contenu dépend à la fois du contexte devotre programme et de la manière dont vous faites dépendre vos objets les unsdes autres, c'est-à-dire la manière dont vous émettez vos signaux ou faites vosappels asynchrones ainsi que l'affinité des objets (voir chapitre Les fondationsde Qt - La classe QObject - Affinité de thread).

3.2 Introspection

Chaque classe qui hérite de QObject a un méta-objet associé, une instance dela classe QMetaObject. Cette classe fournit des mécanismes d'introspectionpendant l'exécution :

QMetaObject::className() : const char* - retourne le nom de laclasse.

QMetaObject::superClass() : QMetaObject* - retourne uneinstance du méta-objet de la classe mère.

QMetaObject ::constructorCount() : int - retourne le nombre deconstructeurs de la classe.

QMetaObject::constructor(int index) : QMetaMethod -retourne les métadonnées d'un constructeur.

QMetaObject::methodCount() : int - retourne le nombre deméthodes de la classe.

© E

dit

ions

EN

I -

All r

ights

rese

rved


Maîtrisez Qt 5

QMetaObject::method(int index) : QMetaMethod - retourne lesmétadonnées d'une fonction particulière de la classe.

QMetaObject::propertyCount() : int - retourne le nombre de pro-priétés de la classe, incluant celles de la classe mère.

QMetaObject::property(int index) : QMetaProperty - retourneles métadonnées d'une propriété de la classe.

3.3 Le méta-type

Pour être en mesure de traiter vos classes dans les signaux et les appels asyn-chrones, Qt utilise les méta-types de la classe QMetaType.

Il s'agit d'un système générique qui traite chaque classe comme un type géné-rique et est capable, en quelque sorte, d'encapsuler un objet d'une classe incon-nue dans un signal ou un appel de fonction.

Ainsi, si vous avez besoin de transmettre une de vos classes dans un signalvous devez la déclarer comme un méta-type :

qRegisterMetaType<MaClasse>("MaClasse") ;

Les conditions pour utiliser cette fonction sont que votre classe doit posséderun constructeur par défaut sans argument, un constructeur de copie et undéstructeur public.

De plus, si vous déclarez des typedef sur des types déjà enregistrés, vousdevez enregistrer ces typedef aussi :

typedef QString MaChaine ;qRegisterMetaType<MaChaine>("MaChaine") ;

Si vous souhaitez utiliser votre classe avec les conteneurs à template de Qt(QList<T>, QHash<T>, etc), vous devez effectuer une déclaration du méta-type en utilisant la macro Q_DECLARE_METATYPE() :

class MaClasse {...};Q_DECLARE_METATYPE(MaClasse);

QList<MaClasse> maListe;

211QtCoreChapitre 6

3.4 Instanciation dynamique

Le méta-type vous permet aussi d'instancier dynamiquement n'importe quelleclasse par son nom, sous la forme d'une chaîne de caractères.

Par exemple, vous pouvez avoir un fichier texte qui comprend une liste denoms de classes à instancier et à exécuter et effectuer ce travail pendant lefonctionnement de l'application.

La fonction QMetaType::type(const char*) : int retourne un iden-tifiant de méta-type instanciable, ou QMetaType ::UnknownType si leméta-type n'existe pas ou s’il n'est pas déclaré.

La fonction QMetaType::create(int) : void* retourne un pointeurvers une nouvelle instance du méta-type pour lequel vous avez fourni un iden-tifiant.

QStringList nomsDeClasse;

QFile fichier("lefichier.txt");

//Lecture du fichier et récupération des noms de classes à instancier

foreach(QString nomDeClasse, nomsDeClasse) {

qDebug() << "Instanciation du type " << nomDeClasse;

//Conversion du nom de classe en const char* ASCII

int id = QMetaType::type(nomDeClasse.toLatin1());

if(id != QMetaType::UnknownType) {

void *instance = QMetaType::create(id);

if(!instance) { //L'instanciation a échoué }

} else { // Le type n'existe pas }

}

4. Créer et piloter des threads

La gestion des threads est un point extrêmement délicat, surtout lorsque l'onsouhaite que notre application soit multiplateforme.

Il existe principalement deux types de gestion des threads très différents :POSIX et WIN32. Le premier est une implantation Unix et le second existeuniquement sous Windows.

© E

dit

ions

EN

I -

All r

ights

rese

rved


Maîtrisez Qt 5

Pour satisfaire l'interopérabilité des programmes, Qt propose une classe degestion des threads : QThread. Attention toutefois, il ne s'agit pas d'un threadà proprement parler, mais davantage d'un contrôleur pour un thread système.

4.1 Paralléliser des tâches

Il faut être très prudent lorsque l'on décide de créer des threads. La plupart dutemps, un développeur peu expérimenté créera un ou plusieurs threads pourrésoudre un problème de performances ou de blocage de l'interface graphique.C'est une mauvaise interprétation du problème et une solution inadaptée, leblocage de l'interface graphique est révélateur d'un problème conceptuel (voirchapitre Les fondations de Qt).

Avec Qt, il y a très peu besoin de créer des threads, et surtout pas pour résoudrece genre de problèmes. Les threads doivent être utilisés uniquement pourparalléliser des sous-processus. Par exemple, le parcours d'un arbre avec unalgorithme de graphes peut être parallélisé avec un ou plusieurs threads.

S'il s'agit simplement d'un long travail à effectuer, sans parallélisme, il faudrautiliser la run-loop du thread principal et les signaux/slots pour intégrer ce tra-vail de manière fluide dans le flux de l'application.

Il existe plusieurs façons de créer et de gérer des threads : les threads pilotésdont on souhaite connaître l'état et que l'on souhaite pouvoir démarrer etarrêter de manière maîtrisée ainsi que les tâches autonomes que l'on exécuteet qui se terminent « dans l'anonymat ».

4.1.1 Les threads pilotés

La classe QThread propose un mécanisme d'encapsulation d'une tâche à exé-cuter dans un thread.

Il s'agit d'un conteneur pour une tâche et non d'un thread au sens du système.Un QThread possède sa propre run-loop.

Qt 5 QtWidgets QtMultimedia QtGui QtNetwork QtSql Qt 5 · Maîtrisez Qt 5 Guide de développement...

Documents

Transcript of Qt 5 QtWidgets QtMultimedia QtGui QtNetwork QtSql Qt 5 · Maîtrisez Qt 5 Guide de développement...