Le livre blanc Qt

Qt inclut une large panoplie de widgets (contrôles dans la terminologie Windows) qui assurent les fonctionnalités standard de l'interface graphique. Qt introduit une alternative innovante pour la communication interobjet, également connue sous le nom de « système de signaux et de slots », qui remplace l'ancienne fonction de rappel non sécurisée utilisée dans de nombreux frameworks historiques. Qt propose également un modèle d'événements conventionnels pour gérer les clics de souris, les pressions des touches du clavier et d'autres interactions avec l'utilisateur. Les applications multiplateformes d'interfaces graphiques avec Qt peuvent gérer toutes les fonctionnalités de l'interface utilisateur requises par une application moderne, comme les menus, les menus contextuels, le glisser-déposer et les barres d'outils de type dock. Les fonctions d'intégration au bureau fournies par Qt peuvent être utilisées pour étendre les applications dans l'environnement du bureau, tirant avantage de certains services disponibles sur chacune des plateformes.

Qt contient également Qt Designer, un outil pour dessiner graphiquement des interfaces utilisateur. Qt Designer reprend les puissantes fonctionnalités en termes de disposition de Qt en plus d'une traduction absolue. Qt Designer peut être utilisé simplement pour la conception des interfaces graphiques, ou pour créer des applications entières avec sa capacité à s'intégrer dans des environnements de développement intégrés (EDI) populaires.

Qt est une excellente aide pour le multimédia et les représentations 3D (voir plus loin). Qt est, de fait, le framework d'interfaces graphiques standard pour la programmation indépendamment de la plateforme OpenGL®. Le système de dessin de Qt offre un rendu de haute qualité à travers toutes les plateformes supportées. Un framework de canevas sophistiqué permet aux développeurs de créer des applications graphiques interactives qui tirent avantage des fonctionnalités avancées de dessin de Qt.

Qt rend possible la création d'applications basées sur des données indépendantes de la plateforme en utilisant des bases de données standard. Qt contient des pilotes natifs pour Oracle®, Microsoft®, SQL Server, Sybase® Adaptative Server, IBM DB2, PostgreSQL™, MySQL®, Borland® Interbase, SQLite et les bases de données accessibles par ODBC. Qt contient des widgets spécifiques aux bases de données et tous les widgets intégrés et personnalisés peuvent s'adapter aux données.

Les programmes Qt ont une ergonomie native sous toutes les plateformes supportées utilisant les styles et les thèmes acceptés par Qt. À partir d'une seule arborescence de sources, la recompilation est la seule chose requise pour produire des applications pour Windows® XP®, Windows Vista™ et Windows 7™, Mac OS X®, Linux®, Solaris™, HP-UX™ et bien d'autres versions d'Unix® avec X11. L'outil de compilation de Qt qmake produit des makefiles ou des fichiers .dsp selon la nature de la plateforme cible.

Comme l'architecture Qt tire avantage de la plateforme sous-jacente, de nombreux clients utilisent Qt pour un développement monoplateforme sous Windows, Mac OS X et Unix car ils préfèrent l'approche de Qt. Qt inclut une aide pour d'importantes fonctions spécifiques aux plateformes, comme ActiveX® sous Windows et Motif™ sous Unix. Voir la section pour plus d'information.

Qt utilise dans son ensemble l'Unicode™ et fournit un support considérable pour l'internationalisation. Qt contient Qt Linguist et d'autres outils pour aider les traducteurs. Les applications peuvent facilement utiliser et mélanger l'arabe, le chinois, l'anglais, l'hébreu, le japonais, le russe et d'autres langues définies par l'Unicode.

Qt contient une variété de classes dans des domaines spécifiques. Par exemple, Qt possède un module XML qui inclut des classes SAX et DOM pour lire et manipuler des données stockées en XML. Les objets peuvent être sauvegardés en mémoire en utilisant les classes de collections compatibles avec STL de Qt et manipulés en utilisant les styles d'itérateurs Java® ainsi que la bibliothèque standard C++ (STL). La manipulation des fichiers locaux et distants utilisant des protocoles standard est fournie par les classes Qt d'entrée/sortie et de réseau.

Les applications Qt peuvent voir leurs fonctionnalités étendues par des plug-ins et des bibliothèques dynamiques. Les plug-ins fournissent des codecs supplémentaires, des pilotes de bases de données, des formats d'images, des styles et des widgets. Les plug-ins et les bibliothèques peuvent être vendus en tant que produits indépendants.

Le module QtScript permet d'écrire des applications avec Qt Script, un langage de script basé sur ECMAScript, lié à JavaScript. Cette technologie permet aux développeurs de définir des restrictions d'accès pour les utilisateurs pour certaines parties de leurs applications en ce qui concerne l'écriture des scripts.

Qt est un framework mature pour C++ qui est largement utilisé de par le monde. En plus des nombreuses utilisations commerciales de Qt, l'édition Open Source de Qt constitue les fondations de KDE, l'environnement de bureau de Linux. Développer des applications devient un plaisir grâce à Qt, avec son système de construction multiplateforme, la conception graphique des pages et une API élégante.

Qt in Use.

Les images ci-dessus présentent une sélection de widgets. Ceci inclut des widgets standard de saisie de texte, des cases à cocher, des boutons radio, des curseurs et des boutons d'action, ainsi que des widgets plus spécialisés pour la saisie de dates ou d'horaires.

Les libellés, fenêtres de message, infobulles et autres widgets textuels ne sont pas limités à l'usage d'une seule couleur, police ou langue. Les widgets d'interprétation textuelle peuvent afficher du texte enrichi multilingue en utilisant un sous-ensemble de HTML.

Les widgets conteneurs comme les widgets d'onglets et les groupes de contrôles sont également disponibles et peuvent être utilisés pour regrouper les composants liés de l'interface utilisateur. Ces widgets sont gérés spécifiquement dans Qt Designer pour aider les concepteurs d'interfaces à créer de nouvelles interfaces utilisateur. Les widgets plus complexes, comme les vues déroulantes, sont souvent utilisés plutôt par les développeurs que par les concepteurs d'interfaces utilisateur, car ils sont utilisés pour afficher du contenu spécialisé ou dynamique.

Les développeurs peuvent créer leurs propres widgets et fenêtres de dialogue en héritant de la classe de base QWidget ou de l'une de ses sous-classes. Les widgets spécialisés de ce type peuvent être complètement personnalisés pour présenter leur propre contenu, répondre aux actions de l'utilisateur et produire leurs propres signaux et slots.

Qt fournit bien d'autres widgets qui s'additionnent à ceux présentés ici. La plupart des widgets disponibles se présentent avec des liens vers la documentation de leur classe dans la galerie des widgets de Qt en ligne.

Les Gestionnaires de disposition procurent une flexibilité et une réactivité aux interfaces utilisateur, leur permettant de s'adapter lors d'un changement de style, d'orientation ou de police de caractères.

Ils aident les développeurs à maintenir l'internationalisation de leurs applications. Avec des positions et des largeurs fixes, un texte traduit est souvent tronqué ; avec eux, les widgets enfants sont redimensionnés automatiquement. De plus, le placement d'un widget peut être inversé pour produire une apparence plus naturelle pour les utilisateurs qui travaillent avec un système d'écriture de droite à gauche.

Les dispositions peuvent également aller de droite à gauche et de bas en haut. Celles de droite à gauche sont commodes pour les applications internationalisées qui supportent les systèmes d'écriture de droite à gauche comme l'arabe ou l'hébreu. Elles sont intégrées complètement dans le système de style de Qt pour procurer une vision pratique et agréable sur les affichages inversés.

Qt Designer est capable d'utiliser les layouts pour les widgets de positionnement.

Les widgets émettent des signaux quand des événements ont lieu. Par exemple, un bouton émet le signal clicked lorsqu'il est cliqué. Un développeur peut choisir de connecter un signal en créant une fonction (un « slot ») et en appelant la fonction connect() pour rapprocher le signal du slot. Les mécanismes des signaux et des slots de Qt ne nécessitent pas que les classes aient connaissance les unes des autres, ce qui facilite le développement de classes hautement réutilisables. Puisque les signaux et les slots ont un typage sécurisé, les erreurs de type sont reportées en tant qu'avertissements et ne provoquent pas l'apparition de plantages.

Par exemple, si le signal clicked() d'un bouton de fermeture est connecté au slot quit() de l'application, le clic d'un utilisateur sur Quit termine l'application. En termes de code, cela s'écrit comme cela :

connect(button, SIGNAL(clicked()), qApp, SLOT(quit()));

Les connexions peuvent être ajoutées ou supprimées à n'importe quel moment pendant l'exécution d'une application Qt, elles peuvent être paramétrées pour s'exécuter lorsqu'un signal est émis ou mises en file d'attente pour une exécution future, elles peuvent aussi impliquer des objets de processus différents.

Le mécanisme des signaux et des slots est implémenté en C++ standard. L'implémentation utilise le préprocesseur C++ et moc, le compilateur de métaobjets, inclus dans Qt. La génération de code est effectuée automatiquement par le système de compilation de Qt. Les développeurs n'ont à aucun moment besoin d'éditer ou même de visualiser le code généré.

En plus de manipuler les signaux et les slots, le compilateur de métaobjets supporte les mécanismes de traduction de Qt, son système de propriétés et ses informations de type disponibles à l'exécution. Cela permet également une introspection des programmes C++ lors de l'exécution d'une manière qui fonctionne sur toutes les plateformes supportées. Le système sous-jacent qui procure ces capacités est connu sous le nom de système de métaobjets de Qt.

• Exemples.
• Les dispositions.
• Le modèle objet.
• Les signaux et slots.

La classe QMainWindow offre un framework pour les fenêtres principales des applications usuelles. Une fenêtre principale contient un ensemble de widgets standard. Le haut de la fenêtre principale est occupé par une barre de menu, sous laquelle les barres d'outils sont disposées dans des zones de barre d'outils autour du centre de la fenêtre. La zone de la fenêtre principale située sous la barre d'outils du bas est occupée par une barre d'état. Les messages « Qu'est-ce que c'est ? » et les infobulles constituent les éléments de l'aide dans l'interface utilisateur.

Le widget QMenu présente les objets du menu à l'utilisateur sous forme d'une liste verticale. Les menus peuvent être isolés (par exemple, un menu contextuel sous forme de pop-up), apparaître dans une barre de menu ou être des sous-menus d'un autre menu pop-up. Les menus peuvent avoir des poignées de redimensionnement.

Chaque objet de menu peut avoir une icône, une case à cocher et un accélérateur. Les objets de menu correspondent habituellement à des actions (comme « Sauvegarder ») et provoquent l'exécution des slots qui leur sont associés lorsqu'ils sont sélectionnés par l'utilisateur. Le gestionnaire de layout de Qt prend en considération chaque barre de menu. Sur Mac OS X, la barre de menu apparaît en haut de l'écran.

Les menus de Qt sont très flexibles et font partie d'un système d'actions intégré (voir Actions). Les actions peuvent être activées ou désactivées, ajoutées dynamiquement aux menus et supprimées à nouveau plus tard.

Les barres d'outils contiennent des ensembles de boutons ainsi que d'autres widgets auxquels l'utilisateur peut accéder pour effectuer des actions. Elles peuvent être déplacées au choix entre le haut, la gauche, la droite et le bas de la zone centrale de la fenêtre principale. Chaque barre d'outils peut être glissée hors de sa zone de barre d'outils et flotter comme une palette d'outils indépendante.

La classe QToolButton implémente un bouton de barre d'outils avec une icône, un cadre stylisé et un libellé optionnel. Les boutons de basculement de la barre d'outils activent les fonctionnalités ou les désactivent. D'autres boutons de la barre d'outils exécutent des commandes. Différentes icônes peuvent être fournies pour les modes actif, valide et invalide et les états démarré et arrêté. Si une seule icône est fournie, Qt distingue automatiquement l'état en utilisant des artifices visuels (par exemple, griser les boutons inactifs). Les boutons de la barre d'outils peuvent également déclencher des menus pop-up.

Les fenêtres dock sont des fenêtres que l'utilisateur peut déplacer à l'intérieur d'une même zone de barre d'outils ou d'une zone de barre d'outils à une autre. L'utilisateur peut détacher une fenêtre dock et la rendre flottante en haut de l'application ou la réduire. Des animations sont utilisées pour glisser doucement les fenêtres dock dans et hors des zones dock.

Les zones dock peuvent également s'emboîter pour empiler les fenêtres dock en plusieurs lignes ou colonnes, les fenêtres dock peuvent être empilées dans des zones partagées - lorsque c'est le cas, les widgets dock sont contenus dans des onglets.

La personnalisation des fenêtres dock est possible également. Elles peuvent être affichées avec une barre de titre verticale et des barres de titres et des contrôles de fenêtres avec un style particulier donné.

Certaines applications, comme Qt Designer et Qt Linguist, utilisant des fenêtres dock de manière intensive, offrent des opérateurs de sauvegarde et restituent la position des fenêtres dock et des barres d'outils, pour que les applications puissent restituer facilement l'environnement de travail préféré de l'utilisateur.

Les applications offrent habituellement à l'utilisateur la possibilité d'effectuer une action particulière de plusieurs façons bien différentes. Par exemple, la plupart des applications mettent traditionnellement une action « sauvegarder » à disposition via le menu, la barre d'outils (un bouton dans la barre d'outils avec une icône appropriée) et un accélérateur. La classe QAction encapsule ce concept. Il permet aux programmeurs de définir une action à un emplacement.

Tout en évitant de faire le même travail plusieurs fois, l'utilisation d'une QAction assure que l'état des objets de menu reste en phase avec les boutons de la barre d'outils correspondants et que l'aide interactive soit bien affichée quand cela est nécessaire. Désactiver une action va désactiver tous les objets de menu correspondants et les boutons de la barre d'outils. De même, si l'utilisateur clique sur un bouton de basculement dans la barre d'outils, l'objet de menu correspondant sera basculé lui aussi.

La plupart des applications GUI utilisent des boîtes de dialogue pour interagir avec l'utilisateur pour certaines opérations. Qt inclut des classes de boîtes de dialogue prêtes à l'emploi offrant des fonctions commodes pour les tâches les plus communes. Des captures d'écran de certaines boîtes de dialogue standard de Qt sont présentées ci-dessous. Qt propose également des boîtes de dialogue standard pour la sélection de couleur, l'impression, les indicateurs de progression et les messages d'information.

Les programmeurs peuvent créer leurs propres boîtes de dialogue par héritage de la classe QDialog. Qt Designer inclut également des modèles de boîtes pour aider les développeurs à démarrer avec la conception.

Les assistants sont utilisés pour guider les utilisateurs à travers les tâches et les procédures communes, les emmenant étape par étape à travers les options disponibles tout en leur proposant de l'aide si nécessaire. Qt offre une API flexible et intuitive pour construire des assistants possédant l'aspect natif approprié et une utilisation conforme aux environnements des plateformes supportées.

La classe QWizard offre des fonctionnalités pour personnaliser l'apparence de l'assistant au-delà de l'aspect visuel et ergonomique basique, spécifiquement à la plateforme. Les instances de cette classe contrôlent également l'ordre de présentation des pages à l'utilisateur. QWizardPage est un widget standard qui offre des fonctionnalités pour sauvegarder et valider les saisies de l'utilisateur.

Les applications utilisent souvent des formes variées d'aide interactive pour expliquer le propos d'un élément d'interface et assister l'utilisateur. Qt offre deux mécanismes pour donner des messages d'erreur brefs : les infobulles pour une aide courte liée au contexte et des aides pop-up du style « Qu'est-ce que c'est ? » contenant des messages plus longs et plus informels. Tous deux sont intégrés dans le système d'action Qt.

Les développeurs peuvent déployer l'assistant Qt comme un navigateur d'aide pour leurs propres applications ainsi que l'ensemble de la documentation en utilisant les classes du module d'aide de Qt. Ce module offre également une API que les développeurs peuvent utiliser pour accéder à la documentation dans le but d'obtenir des affichages personnalisés, peut-être en utilisant les classes infobulles et « Qu'est-ce que c'est ? » pour montrer de petites, mais pertinentes, parties d'information à l'utilisateur.

Les paramètres de l'utilisateur et les paramètres d'autres applications peuvent être sauvegardés facilement en utilisant la classe QSettings. Sur les plateformes Windows, Mac OS X et Linux, les paramètres sont sauvegardés dans un système standard de localisation ; pour les autres plateformes, ils sont sauvegardés dans des fichiers texte.

Une variété de types de données Qt peut être utilisée de façon cohérente avec QSettings. Ce type est sérialisé pour être stocké et rendu disponible par la suite pour les applications. Voir la gestion des fichiers pour plus d'information à propos de la sérialisation des types de données de Qt.

Les applications Qt peuvent utiliser de multiples processus : un processus pour garder l'interface utilisateur active et un ou plus pour s'occuper des activités consommatrices de temps, comme la lecture de gros fichiers ou des calculs complexes. Qt propose des classes pour représenter les processus, les exclusions mutuelles, les sémaphores, les stockages de processus globaux et les primitives de verrouillage.

Des facilités pour la programmation concurrente sont également fournies, incluant des implémentations des algorithmes bien connus de map-reduce et filter-reduce. Ils sont intégrés dans le modèle objet de Qt, utilisant des classes conteneurs standard pour rendre plus commode l'utilisation des techniques concurrentes dans les applications Qt.

Le système de métaobjets de Qt active des objets dans les différents processus pour communiquer en utilisant les signaux et les slots, permettant aux développeurs de créer des applications monoprocessus qui pourront plus tard être adaptées pour le multiprocessus, sans pour autant revoir massivement la conception.

Les applications peuvent être étendues pour interagir avec des services fournis par l'environnement du bureau de l'utilisateur en utilisant les classes d'intégration du bureau de Qt. Cela va de QSystemTrayIcon, qui est souvent utilisée par des applications avec un temps d'exécution long pour garder un indicateur persistant dans la barre de notification, à QDesktopServices, qui permet aux ressources comme des URL mailto: et http:// d'être traitée par les applications les plus appropriées sur chaque plateforme.

Les classes de Qt pour la fenêtre principaleLes classes de Qt pour la fenêtre principale.

Les développeurs peuvent créer à la fois des applications du style « boîte de dialogue » ou des applications du style « fenêtre principale » avec des menus, des barres d'outils, des infobulles et d'autres fonctionnalités standard. Plusieurs modèles de formulaires sont proposés et les développeurs peuvent créer leurs propres modèles pour assurer la cohérence dans une même application ou dans une famille d'applications. Les programmeurs peuvent créer leurs propres widgets personnalisés qui peuvent être intégrés simplement avec Qt Designer.

Qt Designer propose une approche basée sur les formulaires pour le développement d'applications. Un formulaire est représenté par un fichier d'interface utilisateur (.ui) qui peut soit être converti en C++ et compilé dans l'application, soit être traité au moment de l'exécution pour produire des interfaces utilisateur générées dynamiquement. Le système de compilation de Qt est capable d'automatiser la préparation de l'étape de compilation des interfaces utilisateur pour faciliter le processus de conception.

Les outils utilisés pour créer et éditer le code source des applications créées avec Qt Designer vont dépendre des préférences personnelles de chaque développeur ; certains voudront tirer avantage des fonctionnalités d'intégration offertes avec Qt Designer pour développer à partir de Microsoft Visual Studio ou l'environnement Eclipse.

L'architecture basée sur les composants utilisée comme fondements de Qt Designer a été spécialement conçue pour permettre aux développeurs d'étendre son interface utilisateur et les outils d'édition avec des composants personnalisés. En plus, la nature modulaire de l'application permet de rendre accessibles les fonctionnalités de conception d'interface graphique de Qt Designer à partir des environnements de développement intégrés comme Microsoft Visual Studio et KDevelop.

En tout, le module Qt Designer offre plus de vingt classes pour travailler avec les fichiers .ui et pour étendre Qt Designer. Beaucoup d'entre elles permettent à des tiers de personnaliser l'interface utilisateur de l'application elle-même.

Les tiers et les widgets personnalisés pour un travail interne sont facilement intégrés dans Qt Designer. Adapter un widget existant pour l'utiliser dans Qt Designer nécessite uniquement de compiler le widget en tant que plug-in, en utilisant une classe d'interface pour supporter les propriétés par défaut du widget et construire de nouvelles instances du widget. L'interface du plug-in est exportée vers Qt Designer en utilisant une macro similaire à celle décrite dans la partie Plug-ins.

• Le manuel de Qt Designer.
• Outils pour développeurs.
• Qt Designer.
• Exemples.

Qt fournit une API indépendante de la plateforme pour dessiner sur des widgets et d'autres périphériques de dessin. Il fournit des primitives de dessin comme des fonctionnalités avancées (notamment, les transformations). Tous les widgets de Qt se dessinent à l'aide de QPainter et les programmeurs utilisent cette même classe pour implémenter leurs widgets personnalisés.

QPainter fournit des fonctions standard pour dessiner des points, des lignes, des ellipses, des arcs, des courbes de Bézier et d'autres primitives. Des opérations de dessin plus complexes incluent le support des polygones et des chemins vectoriels, permettant la préparation des dessins détaillés (dessinables alors avec un simple appel de fonction). Le texte peut aussi être affiché directement avec un dessinateur ou incorporé dans un chemin pour utilisation future.

Le système de dessin de Qt fournit aussi un certain nombre de fonctionnalités pour améliorer la qualité globale du rendu, dont des fondus alpha, des modes de composition Porter-Duff, l'anti-aliasing, des remplissages avec des dégradés linéaires, radiaux et coniques.

Qt supporte l'entrée, la sortie et la manipulation d'images dans divers formats, dont BMP, GIF, JPEG, MNG, PNG, PNM, TIFF, XBM et XPM. Les deux classes (QImage et QPixmap) peuvent être utilisées comme périphériques de dessin et utilisées dans des applications graphiques interactives ou pour préparer les images pour utilisation future dans des composants de l'interface.

QImage est utilisée pour la manipulation d'images et peut effectuer des conversions entre diverses profondeurs de couleur et formats de pixel. Les programmeurs peuvent manipuler les pixels et les données de la palette, appliquer des transformations comme des rotations et réduire la profondeur de couleur avec tramage si désiré. Le support des canaux alpha permet d'utiliser la transparence et les fusions alpha pour la composition d'images et à d'autres fins.

La gamme de formats de fichiers supportés qui peuvent être utilisés avec ces classes peut être étendue avec des plug-ins d'extension.

QPainter peut être utilisé sur n'importe quel périphérique de dessin. Le code requis pour dessiner sur n'importe quel périphérique supporté est le même, peu importe le périphérique.

Tous les widgets sont des périphériques de dessin. Les fenêtres transparentes avec une forme spécifique peuvent être créées sur des systèmes correctement configurés.

Les surfaces OpenGL utilisées avec QGLWidget sont aussi des périphériques de dessin qui convertissent les appels standard à QPainter en appels OpenGL, ce qui fait que des opérations 2D sont accélérées sur des périphériques avec un matériel supporté.

Des images peuvent aussi être créées en dessinant sur des QImage (indépendants du matériel) et des objets QPixmap, optimisés pour l'affichage. Les formats de fichier standard peuvent être créés en effectuant un rendu dans une image avec la profondeur de couleur et le format de pixels désirés. Les images peuvent être créées avec support de différents niveaux de transparence et dessinées sur des widgets personnalisés pour obtenir certains effets.

Les fichiers vectoriels et les métafichiers sont aussi supportés par le système de dessin. QSvgGenerator crée des images SVG en traduisant les commandes de dessin par les structures correspondantes du format SVG. QPicture est utilisé pour contenir une série de commandes de dessin qui peuvent être rejouées pour dessiner sur un autre périphérique ou pour stockage dans un fichier.

L'impression est effectuée avec un rendu dans un QPrinter, qui représente une imprimante physique. Sur Windows, les commandes de dessin sont envoyées au moteur d'impression de Windows, qui utilise les pilotes installés. Sur UNIX, les données PostScript ou PDF sont envoyées au démon d'impression - ceci est géré par CUPS (Common Unix Printing System) sur des systèmes récents.

En utilisant l'API de dessin générique de Qt, des applications peuvent créer des fichiers PDF et PS qui peuvent être générés sur toutes les plateformes, donc créer des documents de haute qualité qui peuvent être visualisés par des applications de lecture appropriées.

Qt contient un nouveau mais très puissant framework pour les applications graphiques interactives, utilisé pour gérer et afficher un grand nombre d'items dans une scène 2D. La vue graphique fournit une API orientée objet pour ajouter de nouveaux items à une scène et une API plus traditionnelle, semblable à celle du canevas, contenant des fonctions auxiliaires pour créer des items prédéfinis.

Une fois créés, les items peuvent être placés avec les position, orientation et échelle requises dans une scène. Les fonctionnalités d'affichage et de gestion des items sont implémentées séparément dans les classes QGraphicsView et QGraphicsScene, ce qui facilite des fonctionnalités comme les multiples vues sur la même scène et le support de moteurs de rendu échangeables.

Une sélection de types d'item standard est fournie, ceux-ci peuvent être étendus par le biais de sous-classes pour fournir des types d'item personnalisés. Ils peuvent être groupés pour un contrôle de plus haut niveau de la scène. Chaque scène, vue et item fournit un ensemble complet de fonctions pour transformer les coordonnées entre les différents systèmes. Les items standard et personnalisés peuvent être rendus sélectionnables et déplaçables, avec un niveau basique d'interactivité et un minimum de code.

La vue graphique a été pensée avec les animations en tête : les items peuvent être utilisés pour créer des objets animés qui sont transformés en fonction d'une série de transformations définies à certains points sur une ligne du temps.

Certains items standard apportent des fonctionnalités trouvables à d'autres endroits de Qt au framework, dont des éditeurs de texte riche, la navigation sur le Web, l'affichage de dessins SVG et l'utilisation de formes, chemins et images. Les items d'une scène peuvent être rendus indépendamment de la vue attachée, les scènes peuvent donc être rendues dans des images et imprimées dans des fichiers PDF.

Un modèle événementiel complet permet une gestion efficace des événements en les distribuant aux items qui en ont besoin. Puisque la gestion basique des items est effectuée par le framework, les items doivent seulement répondre aux événements s'ils ont besoin d'une information particulière sur leur environnement.

Les applications qui doivent mélanger des éléments d'interface utilisateur classique avec du contenu interactif peuvent embarquer des widgets directement dans une scène en utilisant QGraphicsProxyWidget ou créer - en partant de rien avec QGraphicsWidget - des éléments ressemblant à des items. Comme pour les interfaces conventionnelles, les gestionnaires de disposition peuvent être utilisés pour disposer les widgets et les items dans une scène.

Scalable Vector Graphics est un format de fichier basé sur XML et un langage pour décrire des applications graphiques, habituellement associé aux graphismes 2D du Web. Le support SVG dans Qt est basé sur le standard SVG 1.1, une recommandation du W3C (World Wide Web Consortium). Il fournit des fonctionnalités additionnelles pour le support des profils Tiny de SVG 1.1 et 1.2.

Qt peut rendre des dessins SVG sur n'importe quel périphérique de dessin, dont ceux pour les images et les widgets OpenGL. Cette flexibilité laisse les développeurs échanger la qualité pour la rapidité quand cela est nécessaire. Les dessins SVG peuvent aussi être utilisés pour des icônes dans des contrôles d'interface, enlevant ainsi le besoin de générer des bitmaps dans une série de tailles prédéfinies.

Les développeurs peuvent aussi générer des dessins SVG en utilisant les fonctions de QPainter pour dessiner sur un périphérique de dessin spécialisé SVG, les graphiques utilisés dans des applications peuvent donc être exportés comme dessins SVG avec peu d'effort supplémentaire.

OpenGL est une API standard pour le rendu de graphismes 3D qui peut être utilisée par les développeurs Qt pour inclure des graphismes 3D dans leurs applications graphiques. Le module OpenGL de Qt est disponible sur Windows, X11 et Mac OS X et utilise la bibliothèque OpenGL de chaque système.

Pour utiliser OpenGL dans une application Qt, il suffit aux développeurs de sous-classer QGLWidget et de dessiner dessus avec les fonctions standard d'OpenGL. Qt fournit des fonctions pour convertir les valeurs des couleurs dans le format d'OpenGL pour fournir une interface constante pour les applications.

Qt supporte aussi des fonctionnalités et extensions d'OpenGL, avec une utilisation plus pratique à l'intérieur des applications Qt. Des fonctions auxiliaires permettent de créer des textures depuis des images et le support des tampons de pixels et de frames est fourni par des classes appropriées. Le support de fonctionnalités comme les tampons d'échantillons peut être activé si elles sont disponibles sur le système sous-jacent.

Les applications 2D peuvent utiliser des sous-classes de QGLWidget pour améliorer les performances de rendu sur du matériel approprié. Dans ce cas, les opérations standard de QPainter sont transformées en appels OpenGLCeci rendu aussi possible de recouvrir des contrôles sur des scènes 3D peintes avec seulement OpenGL. Sur des plateformes embarquées, où l'accélération matérielle est souvent limitée, ce moteur de rendu est restreint aux fonctionnalités d'OpenGL ES 2.0, ce qui permet de s'assurer qu'il fonctionne parfaitement sur un grand nombre de périphériques.

Sur du matériel approprié, le support du rendu anti-aliasé peut être activé pour améliorer la rapidité du rendu et la qualité des graphismes produits en utilisant le moteur OpenGL. Sur du matériel moins puissant, les développeurs peuvent donner le choix à l'utilisateur entre la qualité et la rapidité, en exposant ces options de rendu à l'utilisateur à l'exécution.

Qt utilise le framework multimédia Phonon, un projet open source de KDE, pour fournir des fonctionnalités de lecture de médias, à travers une API constante et multiplateforme. Qt s'assure que les applications sur Linux, Unix, Windows et Mac OS X utilisent de manière transparente le framework multimédia de chaque plateforme - ceci signifie que les applications peuvent aussi profiter du support spécifique à la plateforme pour les codecs et formats audio et vidéo.

Les fonctionnalités de Phonon peuvent être intégrées à d'autres technologies de Qt. Par exemple, des widgets de films peuvent être ajoutés à des pages Web affichées avec le moteur d'affichage WebKit et à des scènes rendues avec le framework de la vue graphique.

Des classes supplémentaires pour le multimédia sont incluses dans le module QtMultimedia. Ces classes sont orientées sur l'accès de bas niveau aux données audio et vidéo.

• QPainter.
• La vue graphique.
• QtOpenGL.
• QtMultimedia.
• QtSVG.
• Phonon.

Les implémentations standard des widgets de vue en liste, en arbre, en tableau et d'icônes sont fournies par Qt. Elles supportent les opérations de glisser-déposer dans la même vue et entre des vues différentes. Comme pour tous les widgets Qt, elles sont aussi complètement intégrées au système de ressources de Qt.

Les classes de vue sont utilisées pour afficher des données de diverses boîtes de dialogue dans Qt et sont utilisées de manière extensive dans Qt Designer, Qt Assistant et Qt Linguist.

Les vues classiques servent généralement à afficher et gérer quelques centaines d'items, en usant d'une architecture qui utilise des objets individuels pour encapsuler des données. Cette approche devrait être familière à des développeurs Qt et fournit une manière agréable de construire rapidement des interfaces riches pour gérer des quantités raisonnables de données.

Pour la cohérence et la fiabilité, les vues classiques se basent sur le framework modèle-vue de Qt, qui fournit une manière plus adaptée à de grands volumes de données et plus personnalisable pour gérer ces vues.

Le framework modèle-vue fourni par Qt est une variation du patron de conception MVC bien connu (Model-View-Controller, modèle-vue-contrôleur), spécifiquement adapté aux vues d'items de Qt. Dans cette approche, les modèles sont utilisés pour fournir des données à d'autres composants, des vues qui affichent des items à l'utilisateur et des délégués qui gèrent le rendu et l'édition.

Les modèles ne sont que de fins emballages autour des sources de données, écrites conformément à une interface standard fournie par QAbstractItemModel. Cette interface autorise les widgets dérivant de QAbstractItemView à accéder aux données fournies par le modèle, peu importe la nature de la source des données.

La séparation entre les données et leur représentation dans cette approche fournit un certain nombre d'avantages par rapport aux vues classiques :

• puisque les modèles fournissent une interface standard pour accéder aux données, ils peuvent être conçus et écrits séparément, même remplacés au besoin ;
• les données obtenues de modèles peuvent être partagées par les vues ; ainsi, des applications peuvent offrir plusieurs vues des mêmes données, potentiellement avec plusieurs représentations ;
• les sélections peuvent être partagées entre les vues ou gardées séparées, en fonction des attentes et demandes de l'utilisateur ;
• pour les listes, arbres et tableaux standard, le gros du rendu est effectué par les délégués, ce qui facilite la personnalisation des vues sans devoir réécrire beaucoup de code ;
• en utilisant des modèles proxy, les données fournies par des modèles peuvent être transformées avant d'être passées aux vues ; les applications peuvent donc fournir des fonctionnalités de tri et de filtrage que l'on peut partager entre les vues.

Le système modèle-vue est aussi utilisé par les modèles SQL de Qt pour rendre l'intégration d'une base de données plus simple pour les développeurs ne les maîtrisant pas.

• Programmation modèle-vue.
• Exemples.

L'affichage interactif de texte riche et son édition sont gérés par Qt dans les widgets QTextBrowser et QTextEdit. Ils supportent complètement Unicode et sont construits sur une représentation de la structure du document fournie par QTextDocument, il n'y a pas besoin d'utiliser des langages de balisage intermédiaires pour créer du texte riche. QTextDocument fournit aussi un support de l'import et de l'export d'un sous-ensemble de HTML 4.0, des capacités d'undo-redo (dont les actions groupées) et la gestion des ressources.

Qt fournit une API orientée objet pour les documents qui aide le développeur à obtenir une vue globale de haut niveau sur les structures. Une API basée sur des curseurs est aussi fournie pour faciliter l'exploration, le traitement et la transformation des documents. En plus des classes correspondant à la structure et au contenu, il y a bon nombre d'autres classes pour contrôler l'apparence du texte et des éléments de document. Ceci fait que les styles de texte pour les tableaux, les listes, les cadres et les paragraphes ordinaires peuvent être personnalisés pour donner aux documents l'apparence désirée.

Les documents créés par le code restent éditables dans les widgets QTextEdit et conservent un historique complet d'undo-redo. Les développeurs peuvent ajouter de nouvelles fonctionnalités à l'éditeur, faisant en sorte que les utilisateurs puissent alors insérer des structures et du contenu personnalisés.

Les fonctionnalités de gestion du texte de Qt peuvent être utilisées pour fournir du formatage spécialisé du texte pour des widgets personnalisés et des documents riches. On peut les écrire avec des classes de bas niveau comme QTextLayout pour disposer le texte ligne par ligne, puis les intégrer dans le système de disposition extensible de texte fourni par QTextDocument pour utilisation avec QTextEdit.

Des règles de coloration syntaxique peuvent aussi être appliquées à des documents riches avec QSyntaxHighlighter. Un simple widget QTextEdit pourra être utilisé comme base d'un éditeur de code, cela peut aussi servir à des outils de recherche dans le document.

Les documents peuvent aussi être formatés selon les informations obtenues d'une boîte de dialogue QPrintDialog dans une série de pages que l'on peut passer à un QPrinter.

La classe QTextDocumentWriter fournit un support de l'export de documents en HTML, texte brut et fichiers OpenDocument Format (ODF). Cette classe expose ses fonctionnalités par le biais d'une API générique et est prévue pour être étendue à d'autres formats dans de futures versions.

• Les classes du framework Scribe.
• Traitement du texte riche.
• QTextDocumentWriter.

Le support de Qt pour WebKit dépasse l'affichage de HTML en exposant les fonctionnalités de WebKit aux applications en utilisant les paradigmes Qt. Par exemple, le mécanisme de signaux et de slots pour la communication facilite la connexion de composants Web à des widgets et à d'autres objets de l'application.

Inversement, l'intégration entre Qt et le moteur de rendu permet d'intégrer des contrôles Qt natifs dans les pages Web, ce qui rend possible de combiner du contenu Web avec des interfaces natives hautement dynamiques.

Les applications peuvent aussi profiter de WebKit pour utiliser le stockage natif pour les données persistantes, cette fonctionnalité étant supportée par Qt. Les développeurs peuvent activer le stockage natif pour des applications qui interagissent avec des services distants et prendre appui sur les options de configuration pour définir un endroit approprié et un quota sur le système utilisateur.

La manière standard de manipuler la structure de pages Web est d'utiliser l'API DOM (Document Object Model, modèle objet du document). QtWebKit inclut une implémentation de l'API des sélecteurs du W3C qui fournit un accès très simple à la structure des pages, ainsi que leur modification.

Cette API rend intuitif l'accès au DOM en laissant les développeurs réutiliser leurs connaissances sur les sélecteurs CSS, sans occasionner de surcharge ou de maintenance supplémentaire.

Les plug-ins se conformant à l'API Netscape, un standard de facto pour les composants tiers des navigateurs, peuvent être embarqués et affichés dans des pages Web rendues par QtWebKit. La configuration de cette fonctionnalité est effectuée dans une classe Qt qui est aussi utilisée pour configurer d'autres sortes de plug-ins, comme les plug-ins de widgets exposés par l'application à l'environnement Web.

• Le module QtWebKit.
• Démo : un navigateur Web.
• Intégrer des widgets avec QtWebKit.

La classe QSqlQuery est utilisée pour directement exécuter toute requête SQL et naviguer dans les résultats produits par les requêtes SELECT. Les requêtes INSERT, UPDATE et DELETE sont aussi faciles à utiliser.

Le module SQL de Qt supporte aussi le lien de valeurs et les requêtes préparées. On peut lier des valeurs en utilisant des liens nommés et des paramètres fictifs nommés ou avec un lien positionnel avec des paramètres fictifs nommés ou positionnels. La syntaxe de lien de Qt fonctionne aussi bien avec toutes les bases de données supportées, en utilisant soit le support de la part de la base de données sous-jacente, soit une couche d'émulation.

Qt fournit aussi un nombre de classes de modèle à utiliser avec d'autres composants du framework modèle-vue. Ainsi, les développeurs peuvent assembler des requêtes SQL et créer des vues en table automatiquement, les items provenant de la base.

Utiliser ces modèles avec d'autres composants du framework modèle-vue requiert un minimum de travail de la part des développeurs. Créer un modèle de requête est simplement l'affaire de spécifier une requête, choisir les en-têtes à examiner et définir une vue en table pour afficher les résultats de la requête.

Les modèles sont prévus pour accéder aux tables SQL de différentes manières, dont un modèle en lecture seule pour des ensembles de résultats SQL, un modèle aux données éditables pour une seule table et un modèle relationnel, avec lequel les colonnes peuvent être définies comme clés étrangères d'autres tables. La démo Qt Books, montrée dans la figure ci-dessous, utilise un modèle de base de données relationnelle pour trouver les informations sur chaque livre dans une table.

Le framework modèle-vue contient un bon nombre de fonctionnalités qui se chargent des bases de toute application fondée sur une base de données, dont le support des transactions et l'option d'autoriser ou non l'édition du tableau sur base des colonnes pour éviter des allers-retours inutiles en base.

Qt fournit des commodités aux données obtenues des modèles, comme de l'un des modèles SQL décrits ci-dessus : elles peuvent être liées à des widgets spécifiques dans une fenêtre, l'utilisateur peut alors avoir une coupe transversale des données disponibles depuis plusieurs endroits dans le magasin de données sous-jacent. Ceci rend plus facile la création d'applications d'entrées de données avec des interfaces utilisateur conventionnelles basées sur des formulaires.

La classe QDataWidgetMapper est utilisée pour créer la relation entre un modèle et une sélection de widgets. Dans la démo Books fournie avec Qt, une correspondance entre les données est construite et assignée à un modèle ; ensuite, chaque widget utilisé pour éditer les champs dans la base est lié à une colonne.

Cette correspondance de données peut être utilisée directement pour traverser les colonnes d'un modèle, en faisant correspondre l'item de chaque colonne à un widget spécifique et en l'utilisant pour afficher les données obtenues. Les fonctions de navigation simplifient la connexion des contrôles de navigation faciles à utiliser à la correspondance.

Puisque la classe fournit aussi une API similaire aux classes de vue d'items, les différentes sections transversales d'un modèle peuvent être obtenues en changeant la configuration de la correspondance. L'utilisation de l'API modèle-vue rend aussi possible pour cette correspondance la réponse aux changements dans le modèle sous-jacent. La démo Books met à jour cette correspondance à chaque fois que l'utilisateur sélectionne une colonne différente dans la vue en tableau ; ce comportement est défini avec une simple connexion d'un signal à un slot.

• Le module QtSql.
• La couche GUI-base de données.
• Exemples.

Les systèmes d'écriture d'Asie requièrent beaucoup plus de caractères que le nombre disponible sur un clavier. La conversion d'une séquence d'appuis de touche vers les caractères est effectuée au niveau du système de fenêtrage, par des logiciels appelés méthodes d'entrée. Qt supporte automatiquement les méthodes d'entrée installées sur le système de l'utilisateur.

Qt fournit un moteur de rendu de texte puissant pour tout le texte affiché à l'écran, supportant des fonctionnalités avancées comme des comportements spéciaux de césures, l'écriture bidirectionnelle, les marques diacritiques. Il est capable d'afficher la plupart des systèmes d'écriture existant de par le monde, dont l'arabe, le chinois, le cyrillique, l'anglais, le grec, l'hébreu, le japonais, le coréen, le latin et le vietnamien. Qt combine automatiquement les polices installées pour afficher un texte en plusieurs langues.

Qt fournit des outils et des fonctions pour faciliter le support de la traduction des applications. En lui-même, il contient plusieurs centaines de chaînes visibles à l'utilisateur, pour lesquelles des traductions sont fournies en français, allemand et chinois simplifié.

Pour rendre des chaînes traduisibles, il suffit de les entourer d'un appel à la fonction de traduction tr(), en spécifiant au besoin des informations supplémentaires pour les traducteurs dans des commentaires spéciaux.

//: Ce nom fait référence à un nom d'hôte. 
hostNameLabel->setText(tr("Name:"));

/*: Ce texte fait référence à un exemple de code C++. */
QString example = tr("Example");

Avec le contexte, ces informations aident le traducteur à mieux rendre les nuances dans les chaînes visibles par les utilisateurs. Des arguments optionnels peuvent également être utilisés pour aider la traduction des formes plurielles.

Qt fournit des outils pour extraire le texte des fichiers source, pour les conversions entre les différents formats fréquents de traduction et pour générer des fichiers de messages compressés à utiliser dans les applications. Le processus d'extraction des chaînes et de mise à jour des traductions partielles est totalement intégré dans le système de compilation de Qt et peut être modifié pour s'adapter à différents workflows.

À l'exécution, les applications utilisent des objets QTranslator pour charger les fichiers de traduction. Chacun contient les traductions pour une langue particulière, choisie à l'exécution selon les paramètres locaux ou les préférences utilisateur.

Les traducteurs peuvent éditer les fichiers de traduction aisément avec Qt Linguist, une application graphique pour effectuer le travail de traduction. Les contextes sont listés du côté droit de la fenêtre de l'application, tandis que la liste des textes source est affichée en haut à droite, à côté des traductions et de leur état (non finie, obsolète, effectuée). On peut naviguer dans l'interface utilisateur par le clavier ; ses fenêtres ancrables peuvent être réorganisées pour s'accorder aux préférences du traducteur.

Les applications utilisent souvent les mêmes expressions dans différents contextes. Qt Linguist affiche automatiquement des suggestions utilisant les chaînes déjà traduites et les traductions prédéfinies. Il s'agit généralement de bons points de départ pour de nouvelles traductions. Les traductions les plus fréquentes peuvent également être stockées dans des « manuels de conversation » pour rendre la traduction de futures applications plus efficace. Qt Linguist peut, optionnellement, valider les traductions pour s'assurer que les raccourcis et ponctuations de fin sont correctement traduits.

Le manuel complet de Qt Linguist fournit des informations pertinentes sur le processus de traduction pour les gestionnaires, traducteurs et programmeurs.

• Classes pour l'internationalisation.
• Unicode et Qt.
• Manuel de Qt Linguist.
• QTextCodec.