Présentation de Qt Literacy-Qt Paint System

I. Aperçu

Le système de peinture de Qt peut utiliser la même API pour dessiner sur l'écran et sur le périphérique d'impression. Il est principalement basé sur les classes QPainter, QPaintDevice et QPaintEnengine.

QPainter est utilisé pour effectuer des opérations de dessin. QPaintDevice est une abstraction d'un espace bidimensionnel sur lequel QPainter peut être utilisé pour dessiner. QPaintEngine fournit une interface permettant à QPainter de dessiner sur différents types d'appareils. La classe QPaintEngine est utilisée en interne par QPainter et QPaintDevice et nous est cachée en tant que programmeurs d'applications, sauf si nous créons nos propres types de périphériques de dessin.

Le principal avantage de cette approche est que tous les dessins suivent le même canal de dessin, ce qui facilite l'ajout de la prise en charge de nouvelles fonctionnalités et fournit des implémentations par défaut pour les fonctionnalités non prises en charge. En d'autres termes, il est très évolutif.

2. Dispositif de dessin et backend

La classe QPaintDevice est la classe de base des objets dessinables, c'est-à-dire que QPainter peut dessiner sur n'importe quelle sous-classe de QPaintDevice. La fonction de dessin de QPaintDevice est réalisée par QWidget, QImage, QPixmap, QPicture, QPrinter et QOpenGLPaintDevice.

Les classes mentionnées ci-dessous héritent toutes de QPaintDevice donc elles ont la fonction de dessiner

1. Gadget

La classe QWidget est la classe de base pour les éléments d'interface utilisateur dans le module Qt Widgets. Il reçoit la souris, le clavier et d'autres événements du système de fenêtres et s'affiche à l'écran. C'est une partie importante du système de fenêtre

2. Image

La classe QImage fournit une représentation d'image indépendante du matériel, conçue et optimisée pour les E/S et l'accès et la manipulation directs des pixels. QImage prend en charge une variété de formats d'image, y compris les images monochromes, 8 bits, 32 bits et alpha mélangées.

Il y a deux avantages à utiliser QImage comme périphérique de dessin :

1. La précision des pixels de toute opération de dessin peut être garantie de manière indépendante de la plate-forme.
2. Le dessin peut être effectué dans un autre thread que le thread actuel de l'interface graphique.

3. Plan de pixels

La classe QPixmap est une représentation d'image hors écran conçue et optimisée pour afficher des images à l'écran. Contrairement à QImage, les données de pixels dans pixmap sont internes et gérées par le système de fenêtres sous-jacent, c'est-à-dire que les pixels ne sont accessibles que par les fonctions QPainter ou en convertissant QPixmap en QImage.

Pour optimiser le dessin avec QPixmap, Qt fournit la classe QPixmapCache, qui peut être utilisée pour stocker des pixmaps temporaires coûteux à générer sans utiliser d'espace de stockage dépassant la limite du cache.

Qt fournit également la classe de commodité QBitmap, qui hérite de QPixmap. QBitmap garantit une carte de pixels monochrome (profondeur de 1 bit), principalement utilisée pour créer des objets QCursor et QBrush personnalisés, et pour construire des objets QRegion.

4. Dispositif de dessin OpenGL

Comme mentionné précédemment, Qt fournit des classes qui facilitent l'utilisation d'OpenGL dans les applications Qt. Par exemple, QOpenGLPaintDevice active l'API OpenGL pour le rendu QPainter.

5. Image

La classe QPicture est un périphérique de dessin qui enregistre et lit les commandes QPainter. L'image sérialise les commandes Painter vers les périphériques IO dans un format indépendant de la plate-forme. QPicture est également indépendant de la résolution, c'est-à-dire qu'une QPicture peut être affichée sur différents appareils (tels que svg, pdf, ps, imprimante et écran) et se ressembler.

Qt fournit les fonctions QPicture::load() et QPicture::save() et les opérateurs de flux pour charger et enregistrer des images.

6. Backend de dessin personnalisé

La prise en charge de nouveaux backends peut être obtenue en dérivant de la classe QPaintDevice et en réimplémentant la fonction factice QPaintDevice::paintEngine() pour indiquer à QPainter quel moteur de dessin il doit utiliser pour dessiner sur ce périphérique particulier.

Pour pouvoir dessiner sur le périphérique, ce moteur de dessin doit être un moteur de dessin personnalisé créé en dérivant la classe QPaintDevice.

3. Dessiner et remplir

1. Dessin

QPainter fournit des fonctions hautement optimisées pour faire le dessin requis par la plupart des programmes GUI. Il peut dessiner n'importe quoi, des primitives graphiques simples (représentées par les classes QPoint, QLine, QRect, QRegion et QPolygon) aux formes complexes telles que les chemins vectoriels. Dans Qt, les chemins vectoriels sont représentés par la classe QPainterPath. QPainterPath fournit un conteneur pour les opérations de dessin, permettant de construire et de réutiliser des formes graphiques.

1. QPainterPath
QPainterPath est un objet composé de lignes et de courbes. Par exemple, les rectangles sont constitués de lignes droites et les ellipses sont constituées de lignes courbes.

Le principal avantage des chemins de peinture par rapport aux opérations de dessin normales est que les formes complexes n'ont besoin d'être créées qu'une seule fois ; elles peuvent ensuite être dessinées plusieurs fois en appelant simplement la fonction QPainter::drawPath().

Les objets QPainterPath peuvent être utilisés pour le remplissage, le contour et le découpage. Pour générer un contour remplissable pour un chemin de peinture donné, utilisez la classe QPainterPathStroker.

Les lignes et les contours sont dessinés à l'aide de la classe QPen. Un stylo est défini par son style (c'est-à-dire son type de ligne), sa largeur, son pinceau, la façon dont les majuscules sont dessinées (style majuscule) et la façon dont deux lignes connectées se connectent (style jointure). Le pinceau du stylo est un objet QBrush, qui est utilisé pour remplir les traits générés par le stylo, c'est-à-dire que la classe QBrush définit le mode de remplissage.

QPainter peut également dessiner du texte aligné et des cartes de pixels.

Lors du dessin de texte, la police est spécifiée à l'aide de la classe QFont. Qt utilisera la police avec les propriétés spécifiées, si aucune police correspondante n'existe, Qt utilisera la police installée la plus proche. Les propriétés de police réelles utilisées peuvent être obtenues à l'aide de la classe QFontInfo. De plus, la classe QFontMetrics fournit des métriques de police et la classe QFontDatabase fournit des informations sur les polices disponibles dans le système de fenêtres sous-jacent.

Normalement, QPainter dessine dans un système de coordonnées "naturel", mais il peut utiliser la classe QTransform pour effectuer des transformations entre les systèmes de coordonnées de la vue et du monde. Pour plus d'informations, consultez Systèmes de coordonnées, qui décrit également le processus de rendu, la relation entre les représentations logiques et les pixels rendus, et les avantages du dessin anticrénelé.

2. Dessin anticrénelé
Lors du dessin, le rendu des pixels est contrôlé par l'indicateur de rendu QPainter::Antialiasing. L'énumération QPainter::RenderHint est utilisée pour spécifier des drapeaux à QPainter qui peuvent ou non être utilisés par un moteur donné.

La valeur QPainter::Antialiasing indique que le moteur doit éliminer les bords de la primitive si possible, c'est-à-dire lisser les bords en utilisant différentes intensités de couleur.

2. Remplissage

Remplissez la forme en utilisant la classe QBrush. Un pinceau est défini par sa couleur et son style (c'est-à-dire son mode de remplissage).

Toute couleur dans Qt est représentée par la classe QColor, qui prend en charge les modèles de couleurs RVB, HSV et CMJN. QColor prend également en charge les contours et les remplissages alpha-mélangés (pour spécifier les effets de transparence), et la classe est indépendante de la plate-forme et du périphérique (utilisez la classe QColormap pour mapper les couleurs au matériel).

Les motifs de remplissage disponibles sont décrits par l'énumération Qt::BrushStyle. Ceux-ci incluent des motifs de base allant de couleurs uniformes à des motifs très clairsemés, diverses combinaisons de lignes, des remplissages dégradés et des textures. Qt fournit la classe QGradient pour définir un remplissage dégradé personnalisé et utilise la classe QPixmap pour spécifier le mode de texture.

1. QGradient
La classe QGradient est utilisée en conjonction avec la classe QBrush pour spécifier le remplissage en dégradé.

Qt prend actuellement en charge trois types de remplissages dégradés : les dégradés linéaires interpolent la couleur entre les points de début et de fin, les dégradés radiaux interpolent la couleur entre le point focal et le point final sur la circonférence, et les dégradés coniques interpolent la couleur autour du point central.

4. Système de coordonnées

Le système de coordonnées est contrôlé par la classe QPainter. Avec les classes QPaintDevice et QPaintEngine, QPainter forme la base du système de peinture de Qt. QPainter est utilisé pour effectuer des opérations de dessin. QPaintDevice est une abstraction d'un espace bidimensionnel sur lequel QPainter peut être utilisé pour dessiner. QPaintEngine fournit une interface permettant à QPainter de dessiner sur différents types d'appareils.

La classe QPaintDevice est la classe de base pour les objets dessinables : sa fonctionnalité de dessin est héritée par les classes QWidget, QImage, QPixmap, QPicture et QOpenGLPaintDevice. Le système de coordonnées par défaut pour les appareils de dessin provient du coin supérieur gauche. les valeurs x augmentent vers la droite et les valeurs y augmentent vers le bas. L'unité par défaut est un pixel sur les appareils à base de pixels et un point (1/72 de pouce) sur les imprimantes.

Le mappage des coordonnées logiques de QPainter aux coordonnées physiques de QPaintDevice est géré par la matrice de transformation, la fenêtre et la "fenêtre" de QPainter. Le système de coordonnées logiques et le système de coordonnées physiques coïncident par défaut. QPainter prend également en charge les transformations de coordonnées (telles que la rotation et la mise à l'échelle).

1. Rendu

1. Représentation logique
La taille (largeur et hauteur) d'une primitive graphique correspond toujours à son modèle mathématique, quelle que soit la largeur du stylo utilisé pour le rendu :

2. Peinture sans anticrénelage
Lors du dessin, le rendu des pixels est contrôlé par le paramètre de rendu QPainter::Antialiasing.

L'énumération RenderHint est utilisée pour spécifier des drapeaux à QPainter qui peuvent ou non être utilisés par un moteur donné. La valeur QPainter::Antialiasing indique que le moteur doit éliminer les bords de la primitive si possible, c'est-à-dire, lisser les bords en utilisant différentes intensités de couleur.

Mais par défaut, le peintre est rendu avec un crénelage et d'autres règles s'appliquent : lors du rendu avec un stylet d'un pixel de large, les pixels seront rendus à droite et en dessous d'un point défini mathématiquement. Par exemple:

Lors du rendu avec un stylet avec des pixels pairs, les pixels seront rendus symétriquement autour d'un point défini mathématiquement, tandis qu'avec un stylet avec des pixels impairs, les pixels libres seront rendus à droite et en dessous du point mathématique, tout comme un 1 pixel Idem situation. Pour un exemple spécifique, veuillez vous référer au diagramme QRectF ci-dessous.

Notez que, pour des raisons historiques, les valeurs de retour des fonctions QRect::right() et QRect::bottom() s'écartent du véritable coin inférieur droit du rectangle.

La fonction right() de QRect renvoie left() + width() - 1, tandis que la fonction bottom() renvoie top() + height() - 1. Les points verts dans l'image ci-dessus montrent les coordonnées de retour de ces fonctions.

Nous vous recommandons d'utiliser directement QRectF : la classe QRectF utilise des coordonnées en virgule flottante pour définir un rectangle dans le plan afin d'assurer la précision (QRect utilise des coordonnées entières), tandis que les fonctions QRectF::right() et QRectF::bottom() renvoient le vrai coin inférieur droit.

Alternativement, en utilisant un QRect, appliquez x() + width() et y() + height() pour trouver le coin inférieur droit, en évitant les fonctions right() et bottom().

3. Peinture anti-crénelée
Si vous définissez l'indicateur de rendu anti-crénelé de QPainter, les pixels seront rendus symétriquement des deux côtés du point défini mathématiquement :

4. Transformation

Par défaut, QPainter fonctionne sur le propre système de coordonnées du périphérique associé, mais il prend également entièrement en charge les transformations de coordonnées affines.

Nous pouvons mettre à l'échelle le système de coordonnées par un décalage donné en utilisant la fonction QPainter::scale(), nous pouvons le faire pivoter dans le sens des aiguilles d'une montre en utilisant la fonction QPainter::rotate(), et nous pouvons le traduire en utilisant la fonction QPainter::translate() ( c'est-à-dire ajoute le décalage donné au point).

Vous pouvez également faire pivoter le système de coordonnées autour de l'origine en utilisant la fonction QPainter::shear(). Toutes les opérations de transformation sont effectuées sur la matrice de transformation de QPainter, que vous pouvez obtenir en utilisant la fonction QPainter::worldTransform(). Une matrice transforme un point d'un plan en un autre.

Si vous avez besoin d'utiliser la même transformation à plusieurs reprises, vous pouvez également utiliser l'objet QTransform et les fonctions QPainter::worldTransform() et QPainter::setWorldTransform(). Vous pouvez enregistrer la matrice de transformation de QPainter à tout moment en appelant la fonction QPainter::save(), qui enregistre la matrice sur la pile interne. La fonction QPainter::restore() l'affiche.

Les matrices de transformation sont souvent nécessaires lors de la réutilisation du même code de dessin sur divers périphériques de dessin. Sans transformations, le résultat sera étroitement lié à la résolution de l'appareil de dessin. Les imprimantes ont des résolutions élevées, telles que 600 points par pouce, tandis que les écrans ont généralement entre 72 et 100 points par pouce.

L'exemple Analog Clock montre comment utiliser la matrice de transformation de QPainter pour peindre le contenu d'un contrôle personnalisé.
Nous vous recommandons de compiler et d'exécuter cet exemple avant d'aller plus loin. En particulier, essayez de redimensionner la fenêtre à une taille différente.

  void AnalogClockWindow::render(QPainter *p)
  {
    
    
      static const QPoint hourHand[3] = {
    
    
          QPoint(7, 8),
          QPoint(-7, 8),
          QPoint(0, -40)
      };
      static const QPoint minuteHand[3] = {
    
    
          QPoint(7, 8),
          QPoint(-7, 8),
          QPoint(0, -70)
      };

      QColor hourColor(127, 0, 127);
      QColor minuteColor(0, 127, 127, 191);

      p->setRenderHint(QPainter::Antialiasing);
      p->translate(width() / 2, height() / 2);

      int side = qMin(width(), height());
      p->scale(side / 200.0, side / 200.0);

Nous transformons le système de coordonnées afin que le point (0,0) soit au centre du contrôle, plutôt qu'au coin supérieur gauche. Nous mettons également à l'échelle le système par side/100, où side est la largeur ou la hauteur du contrôle, selon la valeur la plus courte. Nous voulons que l'horloge soit carrée, même si l'appareil ne l'est pas.

Cela nous donnera une zone carrée de 200 x 200 avec l'origine (0,0) au centre, sur laquelle nous pourrons dessiner. Ce que nous dessinons apparaîtra dans le plus grand carré possible qui tient dans le contrôle.

Voir aussi la section Conversion de fenêtre en fenêtre.

      QTime time = QTime::currentTime();

      p->save();
      p->rotate(30.0 * ((time.hour() + time.minute() / 60.0)));
      p->drawConvexPolygon(hourHand, 3);
      p->restore();

Nous dessinons l'aiguille des heures de l'horloge en faisant tourner le système de coordonnées et en appelant QPainter::drawConvexPolygon(). En raison de la rotation, il est dessiné dans le bon sens.
Le polygone est spécifié comme un tableau de valeurs x, y alternées, stockées dans la variable statique hourHand (définie au début de la fonction), qui correspond aux quatre points (2,0), (0,2), (- 2,0 ) et (0, -25).

Les appels à QPainter::save() et QPainter::restore() autour du code garantissent que le code derrière n'interfère pas avec les transformations que nous utilisons.

      p->save();
      p->rotate(6.0 * (time.minute() + time.second() / 60.0));
      p->drawConvexPolygon(minuteHand, 3);
      p->restore();

Nous faisons de même pour l'aiguille des minutes de l'horloge, qui est définie par les quatre points (1,0), (0,1), (-1,0) et (0,-40). Ces coordonnées spécifient un pointeur plus fin et plus long qu'une aiguille.

      p->setPen(minuteColor);

      for (int j = 0; j < 60; ++j) {
    
    
          if ((j % 5) != 0)
              p->drawLine(92, 0, 96, 0);
          p->rotate(6.0);
      }

Enfin, nous dessinons le cadran de l'horloge, composé de 12 lignes courtes espacées de 30 degrés.

Conversion fenêtre-fenêtre

Lorsque nous dessinons avec QPainter, nous spécifions des points à l'aide de coordonnées logiques, qui sont ensuite converties en coordonnées physiques du périphérique de dessin.

Le mappage des coordonnées logiques aux coordonnées physiques est géré par la transformation mondiale de QPainter worldTransform() (décrite dans la section Transformation) et les viewport() et window() de QPainter. La fenêtre représente des coordonnées physiques spécifiant un rectangle arbitraire. Une "fenêtre" décrit le même rectangle en coordonnées logiques. Par défaut, les systèmes de coordonnées logiques et physiques coïncident, équivalent au rectangle de dessin de l'appareil.

En utilisant la transformation fenêtre-fenêtre, nous pouvons faire en sorte que le système de coordonnées logique corresponde à nos préférences. Le peut également être utilisé pour rendre le code de dessin indépendant du QPaintDevice. Par exemple, vous pouvez étendre les coordonnées logiques de (-50,-50) à (50,50), avec (0,0) entre les deux, en appelant la fonction QPainter::setwinwindow() :

  QPainter painter(this);
  painter.setWindow(QRect(-50, -50, 100, 100));

Maintenant, les coordonnées logiques (-50, -50) correspondent aux coordonnées physiques (0,0) du dispositif de dessin. Indépendamment du périphérique de dessin, notre code de dessin fonctionnera toujours sur des coordonnées logiques spécifiées. Cela équivaut à ce que nous puissions définir manuellement cette relation de coordonnées. Une relation pratique pour définir vous-même ces coordonnées.

En définissant la "fenêtre" ou le rectangle de la fenêtre, une transformation linéaire des coordonnées peut être effectuée. Notez que chaque coin de la "fenêtre" est mappé sur un coin correspondant de la fenêtre et vice versa. Pour cette raison, c'est généralement une bonne idée de garder le viewport et la "fenêtre" au même rapport d'aspect pour éviter la distorsion :

  int side = qMin(width(), height())
  int x = (width() - side / 2);
  int y = (height() - side / 2);

  painter.setViewport(x, y, side, side);

Si nous définissons le système de coordonnées logiques comme étant carré, nous devons également définir la fenêtre comme carrée en utilisant la fonction QPainter::setViewport(). Dans l'exemple ci-dessus, nous l'avons défini sur le plus grand carré qui tient dans le rectangle de dessin de l'appareil. Vous pouvez garder votre code de dessin indépendant du périphérique de dessin en tenant compte de la taille du périphérique de dessin lors de la configuration de la fenêtre ou de la fenêtre d'affichage.

Notez que la transformation fenêtre en fenêtre n'est qu'une transformation linéaire, c'est-à-dire qu'elle n'effectue pas de découpage. Cela signifie que si vous dessinez en dehors de la "fenêtre" actuellement définie, votre dessin sera toujours converti dans la fenêtre en utilisant la même méthode d'algèbre linéaire.

La fenêtre, la "fenêtre" et les matrices de transformation déterminent comment les coordonnées logiques de QPainter correspondent aux coordonnées physiques du périphérique de dessin. Par défaut, la matrice de transformation du monde est la matrice d'identité, et les paramètres de "fenêtre" et de fenêtre sont équivalents à ceux du périphérique de dessin, c'est-à-dire que les systèmes de coordonnées du monde, de la "fenêtre" et du périphérique sont équivalents, mais comme nous l'avons vu , le système peut manipuler à l'aide d'opérations de transformation et de transformations fenêtre-fenêtre.

5. Lire et écrire des fichiers image

La façon la plus courante de lire une image est d'utiliser les constructeurs QImage et QPixmap, ou d'appeler les fonctions QImage::load() et QPixmap::load(). De plus, Qt fournit la classe QImageReader, qui offre plus de contrôle sur le processus. Selon la prise en charge sous-jacente du format d'image, la classe fournit des fonctions qui économisent de la mémoire et accélèrent le chargement de l'image.

De même, Qt fournit la classe QImageWriter, qui prend en charge la définition d'options spécifiques au format telles que le gamma, le niveau de compression et la qualité avant de stocker l'image. Si nous n'avons pas besoin de ces options, nous pouvons utiliser QImage::save() ou QPixmap::save() à la place.

1. QMovie

QMovie est une classe pratique pour afficher des animations, en utilisant en interne la classe QImageReader. Une fois créée, la classe QMovie fournit diverses fonctions pour exécuter et contrôler une animation donnée.

Les classes QImageReader et QImageWriter dépendent de la classe QImageIOHandler. La classe QImageIOHandler est une interface d'E/S d'image générale pour tous les formats d'image dans Qt. QImageReader et QImageWriter utilisent en interne l'objet QImageIOHandler pour ajouter la prise en charge de différents formats d'image pour Qt.
Les fonctions QImageReader::supportedImageFormats() et QImageWriter::supportedImageFormats() fournissent une liste des formats de fichiers supportés. Qt prend en charge plusieurs formats de fichiers par défaut, de plus de nouveaux formats peuvent être ajoutés via des plugins. Les formats actuellement pris en charge sont répertoriés dans la documentation des classes QImageReader et QImageWriter.
Le mécanisme de plug-in de Qt peut également être utilisé pour écrire des gestionnaires de format d'image personnalisés. Cela se fait en dérivant de la classe QImageIOHandler et en créant un objet QImageIOPlugin, qui est une usine pour créer des objets QImageIOHandler. Lorsque le plugin est installé, QImageReader et QImageWriter chargeront automatiquement le plugin et commenceront à l'utiliser.

6. Équipement lié au dessin

Liés à la peinture	Fonction
QBitmap	Pixelmap monochrome (profondeur de 1 bit)
QBrush	Définit le mode de remplissage pour les formes dessinées par QPainter
QCouleur	Couleurs basées sur les valeurs RVB, HSV ou CMJN
QColorSpace	abstraction de l'espace colorimétrique
QColorTransform	Conversion entre espaces colorimétriques
QColormap	Mappe les QColors indépendants de l'appareil aux valeurs de pixel dépendantes de l'appareil
QConicalGradient	Utilisé en combinaison avec QBrush pour spécifier un pinceau dégradé effilé
QFontComment	Spécifie les requêtes de police pour dessiner du texte
QFontMetrics	informations sur les métriques de police
QFontMetricsF	informations sur les métriques de police
QGenericMatrix	Une classe modèle représentant une matrice de transformation NxM avec N colonnes et M lignes
QGradient	Utilisé en combinaison avec QBrush pour spécifier des remplissages dégradés
QIcon	Icônes évolutives dans différents modes et états
QIconEngine	Classe de base abstraite pour les rendus QIcon
QImage	Une représentation d'image indépendante du matériel qui permet un accès direct aux données de pixels et peut être utilisée comme dispositif de dessin
QImageReaderComment	Interface indépendante du format pour la lecture d'images à partir de fichiers ou d'autres appareils
QImageWriterComment	Interface indépendante du format pour écrire des images dans des fichiers ou d'autres appareils
QLine	Vecteur 2D utilisant une précision entière
QLigneF	Les vecteurs 2D utilisent une précision en virgule flottante
QLinearGradient	Utilisé en combinaison avec QBrush pour spécifier un pinceau dégradé linéaire
QMarges	Définir les quatre marges du rectangle
QMargesF	Définir les quatre marges du rectangle
QPagedPaintDevice	Indique un périphérique de dessin prenant en charge plusieurs pages
QPaintDevice	Classe de base pour les objets pouvant être dessinés avec QPainter
QPaintEngine	Une définition abstraite de la façon dont QPainter dessine sur un appareil donné sur une plate-forme donnée
QPainterName	Effectuez un dessin de bas niveau sur des widgets et d'autres appareils de dessin
QPainterPath	Un conteneur pour les opérations de dessin, permettant de construire et de réutiliser des graphiques
QPainterPathStroker	Utilisé pour générer un contour remplissable pour un chemin de dessin donné
QPdfWriterName	classe pour générer des fichiers PDF pouvant être utilisés comme dispositifs de traçage
QPen	Définit comment un QPainter doit dessiner les contours des lignes et des formes
QPixmap	Une représentation d'image hors écran qui peut être utilisée comme dispositif de dessin
QPoint	définir un point dans le plan en utilisant une précision entière
QPointF	définir un point dans le plan en utilisant la précision en virgule flottante
QPolygon	Vecteur ponctuel utilisant la précision d'un entier
QPolygoneF	Vecteur ponctuel utilisant la précision en virgule flottante
QRadialGradient	Spécification d'un pinceau dégradé radial en combinaison avec QBrush
QRect	définir un rectangle dans le plan en utilisant une précision entière
QRectF	définit un rectangle dans le plan en utilisant une précision en virgule flottante
QRegion	Spécifie la zone de découpage pour le paintr
QRgba64	Structure contenant des couleurs RVB 64 bits
QTaille	Définir la taille d'un objet 2D à l'aide d'un nombre entier de précision
QTailleF	Définir la taille d'un objet 2D à l'aide de la précision en virgule flottante
QStylePainter	Classe de commodité pour dessiner des éléments QStyle dans des widgets
QSupportedWritingSystems	Lors de l'enregistrement de polices avec la base de données de polices Qt interne, utilisez
Générateur QSvg	Un appareil de dessin pour créer des dessins SVG
QSvgRenderer	Utilisé pour dessiner le contenu d'un fichier SVG sur un périphérique de dessin
QSvgWidget	Un contrôle pour afficher le contenu d'un fichier Scalable Vector Graphics (SVG)
QTransform	Transformation 2D du système de coordonnées spécifié
QVector2D	représenter des vecteurs ou des sommets dans un espace à deux dimensions