I. Les fondamentaux

I-A. Sujets couverts

  • Comparaison des frameworks multiplateformes.
  • Création d'une application simple avec Qt.
  • Étapes de développement de base, inclusion, modification, construction et utilisation de Qt dans des EDI.
  • Connecter l'interface utilisateur à la logique métier d'une application.
  • Un aperçu des modules Qt et de leurs fonctionnalités clés.

I-B. Objectifs

I-B-1. Interface utilisateur et bibliothèques multiplateformes

  • Apprendre la différence entre une API native et une API multiplateforme.
  • Connaître la différence entre les boîtes à outils (toolkits) et les frameworks.
  • Comprendre le raisonnement de la portabilité d'applications.


I-B-2. Premières étapes de développement

I-B-3. Modification et création

  • Être capable de créer un projet Qt.
  • Connaître les points clés concernant le processus de construction Qt et les outils utilisés.
  • Apprendre à utiliser Qt avec un EDI.
  • Être capable de compiler et d'exécuter un programme à partir d'un EDI.
  • Être capable d'utiliser un designer à l'intérieur d'un EDI.
  • Être capable de déboguer du code dans un EDI.
  • Être capable de trouver de l'aide à travers un EDI.


I-B-4. Signaux et slots

  • Apprendre les avantages des signaux/slots.
  • Comprendre le concept des signaux/slots.
  • Apprendre comment connecter des signaux à des slots.
  • Être capable d'utiliser et de définir ses propres signaux/slots.


I-B-5. Aperçu des modules et des classes

  • Être capable de lister les modules majeurs de Qt.
  • Comprendre le concept et la fonctionnalité d'un module Qt.
  • Comprendre les API majeures fournies par les différents modules de Qt.


II. Développement d'une application

II-A. Sujets couverts

  • Le concept d'événements dans Qt et la différence avec les signaux/slots.
  • Manipulation des événements basiques.
  • Comment dessiner avec Qt.
  • Utilisation de QMainWindow.
  • Utilisation des Actions.
  • Entrée/Sortie générique, accès aux fichiers.
  • Encodage du texte.
  • Comment afficher des images.
  • Utilisation de QPrinter.

II-B. Objectifs

II-B-1. Manipulation d'événements

  • Comprendre le concept d'événements.
  • Comprendre la différence entre les événements et les signaux/slots.
  • Être capable d'implémenter la manipulation d'événements.
  • Comprendre le rôle des événements dans le dessin.


II-B-2. Dessin de base

  • Apprendre à dessiner sur des widgets.
  • Comprendre la différence entre QPixmap, QImage et QPicture.
  • Être capable de charger une image à partir d'un fichier.


II-B-3. Fenêtre principale et actions

  • Comment utiliser QMainWindow.
  • Savoir comment implémenter un menu.
  • Être capable d'utiliser une barre d'outils et une barre de statut.
  • Comprendre le concept des Actions.
  • Savoir comment utiliser QVariant pour stocker des données dans des actions.
  • Être capable de créer sa propre application.
  • Comprendre l'utilisation des zones de défilement.


II-B-4. Entrée/sortie générique, fichiers et impression

  • Comprendre l'utilisation de QFile.
  • Être capable d'identifier la différence entre QDataStream et QTextStream.
  • Connaître les classes utilisables pour l'accès à des fichiers et des répertoires.
  • Être capable de lire/d'écrire à partir de/ dans des fichiers en utilisant Qt.
  • Comprendre la question de l'encodage du texte et des fichiers.
  • Comprendre quand il est mieux d'utiliser QDataStream à la place de QTextStream.
  • Être capable d'imprimer un widget ou un document texte au format PDF en utilisant QPrinter.


III. Utilisation des boîtes de dialogue et manipulation des dispositions de l'interface graphique

III-A. Sujets couverts

  • Géométrie dans Qt.
  • Widgets de haut niveau et boîtes de dialogue.
  • Gestion de disposition.
  • Création de boîtes de dialogue.
  • Création de widgets personnalisés.
  • Fonctionnalités standards des boîtes de dialogue.
  • Utilisation de l'assistant (API).
  • Utilisation des outils de Qt Designer.

III-B. Objectifs

III-B-1. Gestion de la géométrie

  • Apprendre à manipuler la géométrie d'un widget.
  • Comprendre le concept derrière la gestion de disposition dans Qt.
  • Connaître et comprendre les différents gestionnaires de disposition.
  • Apprendre à utiliser les widgets avec la gestion de disposition.
  • Être capable de développer votre propre boîte de dialogue avec une gestion de disposition.


III-B-2. Boîtes de dialogue standards

  • Connaître les divers types de boîtes de dialogue standards.
  • Comprendre l'utilisation des boîtes de dialogue standards.
  • Être capable de les utiliser.
  • Comprendre comment le traitement des événements fonctionne avec QProgressDialog.
  • Comprendre la structure de l'assistant.
  • Être capable de créer vos propres assistants avec des pages.


III-B-3. Créer vos propres boîtes de dialogue (personnalisées)

  • Apprendre à dériver une QDialog.
  • Comprendre l'utilisation de boutons dans une boîte de dialogue.
  • Être capable de lancer des boîtes de dialogue (non) modales.
  • Connaître les options de suppression des boîtes de dialogue.
  • Être capable de créer vos propres boîtes de dialogue avec des interactions utilisateurs.


III-B-4. Qt Designer

  • Comprendre comment le designer peut aider à la création de widgets.
  • Comprendre le concept des fichiers du designer.
  • Être capable d'ajouter du code du designer dans votre code.
  • Être capable de connecter des éléments du designer avec des fonctions métiers.
  • Savoir comment manager les widgets personnalisés dans le designer.
  • Être capable de charger des fichiers du designer.
  • Être capable de créer une boîte de dialogue en utilisant les outils du designer.


IV. Chaînes de caractères, ressources et aide

IV-A. Sujets couverts

  • Manipulation de chaîne de caractères.
  • Expressions régulières.
  • Validation des saisies utilisateurs.
  • Concept du système de ressources Qt.
  • Chargement des ressources.
  • Accéder aux éléments des ressources .
  • Ajouter une fonctionnalité d'aide à des widgets.
  • Aide dynamique.
  • QTextBrowser comme un visionneur d'aide.

IV-B. Objectifs

IV-B-1. Chaînes de caractères, URL et expressions régulières

  • Apprendre à créer une chaîne de caractères avec QString.
  • Savoir comment extraire des données de chaînes de caractères.
  • Savoir comment tester des chaînes de caractères.
  • Connaître les fonctions utiles de QString.
  • Connaître les bases de la traduction avec Qt des chaînes de caractères dans d'autres langues.
  • Comprendre QUrl et les composants d'une URL.
  • Apprendre à utiliser QRegExp pour une expression régulière.


IV-B-2. Validation des saisies

  • Être capable de définir un masque de saisie dans un champ texte.
  • Comprendre les formats des masques de saisie.
  • Savoir que QCompleter offre une fenêtre de complétion.


IV-B-3. Ressources

  • Comprendre les avantages des fichiers de ressources par rapport aux fichiers ordinaires.
  • Apprendre à ajouter des fichiers de ressources dans un projet.
  • Connaître la structure XML des fichiers de ressources.
  • Être capable d'accéder à des ressources dans une application.
  • Savoir que les fichiers de ressources peuvent être localisés.
  • Apprendre à charger un fichier de ressources dynamiquement.


IV-B-4. Système d'aide

  • Connaître les différentes possibilités fournies par l'aide.
  • Comprendre le concept du système des icônes de la barre d'état.
  • Apprendre à intégrer une aide dynamique.


V. Utilisation avancée des événements Qt

V-A. Sujets couverts

  • Affichage et envoi d'événements.
  • Événements personnalisés.
  • Invocation différée de méthode.
  • Traitement des événements au repos.
  • Filtres d'événements.

V-B. Objectifs

V-B-1. Événements synthétiques

  • Comprendre le concept de la propagation des événements.
  • Apprendre à afficher/envoyer des événements.
  • Être capable de créer/envoyer/manipuler des événements personnalisés.


V-B-2. Invocation différée

  • Comprendre le besoin de traitement au repos.
  • Être capable d'implémenter l'invocation d'une méthode différée.


V-B-3. Filtres d'évènements

  • Comprendre l'avantage de filtres d'événements.
  • Être capable d'installer vos propres filtres d'événements sur des objets.
  • Connaître la différence entre un objet et l'application de filtre d'événements.


VI. Classes outil pour les développeurs et API

VI-A. Sujets couverts

  • Types de conteneurs.
  • Itérateur de conteneur.
  • Mot clé foreach.
  • Classe partagée implicitement.
  • Messages de débogage.
  • Technique de débogage.
  • Réflexions sur la portabilité.
  • Pièges en portabilité.
  • Signal mapper.
  • Timers.
  • Widgets personnalisés.

VI-B. Objectifs

VI-B-1. Classes conteneurs

  • Comprendre le concept de conteneurs.
  • Connaître la différence entre Java et STL style API.
  • Connaître les différents types de conteneurs.
  • Être capable d'identifier le meilleur conteneur pour l'utilisation voulue.
  • Connaître les exigences d'un type de données afin d'être stockées dans un conteneur.
  • Être capable d'itérer des conteneurs.
  • Connaître les différents itérateurs standards et mutables.
  • Être capable d'utiliser le mot clé foreach dans un conteneur.
  • Connaître les algorithmes utiles de conteneurs disponibles dans Qt.
  • Comprendre le concept de classes implicites partagées.


VI-B-2. Débogage

  • Être capable d'écrire des messages de débogage.
  • Comprendre l'utilisation des assertions.
  • Être capable d'utiliser GDB avec Qt.
  • Comprendre pourquoi les filtres d'événements peuvent être utiles pour le débogage.


VI-B-3. Quelques réflexions sur la portabilité

  • Comprendre les avantages d'une application portable.
  • Connaître les concepts permettant de rendre vos applications plus portables.
  • Connaître les limitations de la portabilité Qt.
  • Comprendre comment réaliser un projet portable.


VI-B-4. QSignalMapper

VI-B-5. QTimer

  • Comprendre le concept du QTimer.
  • Être capable d'utiliser QTimer.
  • Comprendre les différents modes d'opération des timers.


VI-B-6. Écrire vos propres widgets

  • Savoir quand il est mieux d'utiliser un widget personnalisé.
  • Être capable de ré-implémenter les méthodes de manipulation d'événements.
  • Comprendre quand utiliser les signaux.
  • Être capable de décider quelles variables internes devraient être accessibles.
  • Comprendre l'importance d'une construction propre.