Developpez.com - Qt
X

Choisissez d'abord la catégorieensuite la rubrique :

Viadeo Twitter Google Bookmarks ! Facebook Digg del.icio.us MySpace Yahoo MyWeb Blinklist Netvouz Reddit Simpy StumbleUpon Bookmarks Windows Live Favorites 
Logo Documentation Qt ·  Page d'accueil  ·  Toutes les classes  ·  Toutes les fonctions  ·  Vues d'ensemble  · 

QPainter

La classe QPainter réalise des dessins de bas niveau sur les widgets et les autres surfaces de dessin. Plus d'informations...

#include <QPainter>

Voir la position dans l'arbre des classes.

Héritage

Hérité par Q3Painter et QStylePainter.

Note : toutes les fonctions de cette classe sont ré-entrantes.

Description détaillée

La classe QPainter réalise des dessins de bas niveau sur les widgets et les autres surfaces de dessin.

QPainter fournit des fonctions optimisées pour la réalisation de tous les dessins demandés par des applications graphiques. Il peut dessiner diverses formes, depuis des lignes simples jusqu'à des formes complexes comme des cordes ou des secteurs. Il peut aussi dessiner du texte aligné et des pixmaps. Normalement, il dessine dans un système de coordonnées « naturel », mais il peut aussi effectuer des transformations. QPainter peut opérer sur tout objet héritant de la classe QPaintDevice.

L'usage courant de QPainter est à l'intérieur de l'événement de peinture d'un widget : construisez et personnalisez (par exemple en changeant le pinceau ou la brosse) le QPainter, puis dessinez. N'oubliez par de détruire le QPainter après le dessin. Par exemple :

 void SimpleExampleWidget::paintEvent(QPaintEvent *)
 {
     QPainter painter(this);
     painter.setPen(Qt::blue);
     painter.setFont(QFont("Arial", 30));
     painter.drawText(rect(), Qt::AlignCenter, "Qt");
 }

La fonctionnalité centrale de QPainter est le dessin, mais la classe fournit également plusieurs fonctions permettant de personnaliser les paramètres de QPainter et sa qualité de rendu, et d'autres activant le masquage. De plus vous pouvez contrôler la façon dont différentes formes sont fusionnées en spécifiant le mode de composition du QPainter.

La fonction isActive() indique si le QPainter est activé. Un QPainter est activé par la fonction begin() et par le constructeur prenant un argument QPaintDevice. La fonction end() et le destructeur le désactivent.

Avec les classes QPaintDevice et QPaintEngine, QPainter forme la base du système de dessin de Qt. QPainter est la classe utilisée pour réaliser les opérations de dessin. QPaintDevice représente un périphérique sur lequel un QPainter peut dessiner. QPaintEngine fournit l'interface que le QPainter utilise pour dessiner sur différents types de périphériques. Si le QPainter est activé, device() renvoie le périphérique sur lequel le QPainter dessine et paintEngine() renvoie le moteur de dessin sur lequel le QPainter opère actuellement. Pour plus d'informations, voir le système de dessin.

Pour effectuer un rendu sur un QPaintDevice sans passer par un QPainter, utilisez la fonction render() de QWidget. Cette fonction remplace la fonction obsolète setRedirected() de QPainter .

Attention : si le dessin se fait sur un widget, QPainter peut seulement être utilisé dans une fonction paintEvent() ou une fonction appelée par paintEvent(), sauf si l'attribut Qt::WA_PaintOutsidePaintEvent du widget est activé. Sur Mac OS X et Windows, le dessin ne peut se faire que dans la fonction paintEvent() indépendamment de la valeur de l'attribut.

Paramètres

Il existe plusieurs paramètres que vous pouvez utiliser pour que QPainter dessine suivant vos préférences :

Notez que certains de ces paramètres reprennent des paramètres de certaines surfaces de dessin, par exemple QWidget::font(). La fonction QPainter::begin() (ou le constructeur de QPainter) copie ces attributs depuis la surface de dessin.

Vous pouvez à tout moment sauvegarder l'état du QPainter en appelant la fonction save(), qui sauvegarde tous les paramètres dans une pile interne. La fonction restore() les restaure.

Dessin

QPainter fournit des fonctions de dessin pour la plupart des primitives : drawPoint(), drawPoints(), drawLine(), drawRect(), drawRoundedRect(), drawEllipse(), drawArc(), drawPie(), drawChord(), drawPolyline(), drawPolygon(), drawConvexPolygon() et drawCubicBezier(). Les deux fonctions utilitaires drawRects() et drawLines() dessinent le nombre de rectangles ou de lignes donné dans le tableau de QRect ou de QLine donné en utilisant le pinceau ou la brosse courants.

La classe QPainter fournit également la fonction fillRect() qui remplit le QRect donné avec la QBrush donnée et la fonction eraseRect() qui efface la zone à l'intérieur du rectangle donné.

Toutes ces fonctions ont à la fois des versions entières et en virgule flottante.

image Exemple de dessins L'exemple Dessins de base montre comment afficher des primitives graphiques de base dans des styles variés en utilisant la classe QPainter.

Si vous devez dessiner une forme complexe, en particulier si vous devez le faire de façon répétée, vous pouvez créer un QPainterPath et le dessiner avec drawPath().

Exemple de chemins de peinture La classe QPainterPath fournit un contenant pour les opérations de peinture, permettant la construction et la réutilisation de formes graphiques. L'exemple de chemins de peinture montre la façon dont les chemins de peinture peuvent être utilisés pour construire des formes complexes. image

QPainter fournit aussi la fonction fillPath() qui remplit le QPainterPath donné avec la QBrush donné et la fonction strokePath() qui dessine le contour du chemin donné (c'est-à-dire trace le chemin).

Voir aussi la démo de déformation vectorielle qui montre comment utiliser des techniques vectorielles avancées pour dessiner du texte en utilisant un QPainterPath, la démo gradients qui présente les différents types de gradients disponibles dans Qt et la démo de tracé de chemin qui présente les motifs de pointillés intégrés à Qt et la façon dont des motifs personnalisés peuvent étendre les motifs existants.

image image image
Vector Deformation Gradients Path Stroking

Il existe des fonctions pour dessiner des pixmap ou des images, ce sont drawPixmap(), drawImage() et drawTiledPixmap(). Les fonctions drawPixmap() et drawImage() produisent le même résultat, à part que drawPixmap() est plus rapide sur écran et drawImage() peut être plus rapide sur un QPrinter ou d'autres périphériques.

Le dessin de texte est fait en utilisant drawText(). Lorsque vous avez besoin d'un positionnement fin, boundingRect() vous précise où une commande drawText() donnée va dessiner.

Il existe une fonction drawPicture() qui dessine le contenu d'un QPicture entier. La fonction drawPicture() est la seule fonction qui ignore les paramètres du QPainter car QPicture possède ses propres paramètres.

Qualité du rendu

Pour obtenir un rendu optimal avec QPainter, vous devez utiliser un QImage indépendant de la plateforme comme surface de dessin ; c'est-à-dire que l'utilisation de QImage garantira que le résultat aura une représentation des pixels identique sur toutes les plateformes.

La classe QPainter fournit aussi un moyen de contrôler la qualité de rendu avec son énumération RenderHint et la gestion de la précision en virgule flottante : toutes les fonctions de dessin de primitives ont une version en virgule flottante. Elles sont souvent utilisées en combinaison avec l'indication de rendu QPainter::Antialiasing.

image

Exemples de cercles concentriques L'exemple Cercles concentriques montre l'amélioration de la qualité du rendu qui peut être obtenue par l'utilisation de la précision en virgule flottante et de l'anticrénelage lors du dessin de widgets personnalisés. La fenêtre principale de l'application affiche plusieurs widgets qui sont dessinés en utilisant diverses combinaisons de précision et d'anticrénelage. |

L'énumération RenderHint spécifie des options à QPainter qui peuvent être respectées ou non par un moteur de rendu donné. QPainter::Antialiasing indique que le moteur doit si possible effectuer un anticrénelage sur les bords des primitives, QPainter::TextAntialiasing indique que le moteur doit si possible effectuer un anticrénelage sur les textes et QPainter::SmoothPixmapTransform indique que le moteur doit utiliser un algorithme de transformation de pixmap avec lissage. HighQualityAntialiasing est une indication de rendu spécifique à OpenGL indiquant que le moteur doit utiliser des programmes de fragments et un rendu hors écran pour l'anticrénelage.

La fonction renderHints() renvoie un drapeau spécifiant les indications de rendu actives pour ce QPainter. Utilisez la fonction setRenderHint() pour activer ou désactiver les RenderHints courantes.

Transformations de coordonnées

Normalement, le QPainter opère dans le système de coordonnées du périphérique (en général des pixels), mais QPainter sait également gérer les transformations de coordonnées.

image image image image
nop rotate() scale() translate()

Les transformations les plus fréquemment utilisées sont le redimensionnement, la rotation, la translation et l'inclinaison. Utilisez la fonction scale() pour redimensionner le système de coordonnées, la fonction rotate() pour une rotation horaire, translate() pour une translation (c'est-à-dire ajouter le décalage donné aux points). Vous pouvez aussi déformer le système de coordonnées autour de l'origine en utilisant la fonction shear(). Voir la démo Transformations affines pour visualiser un système de coordonnées incliné.

Voir aussi l'exemple Transformations qui montre comment les transformations influencent la façon dont QPainter effectue le rendu des primitives graphiques. En particulier il montre la façon dont l'ordre des transformations affecte le résultat.

Démo de transformations affines La démonstration Transformations affines montre la capacité de Qt à effectuer des transformations affines sur les opérations de dessin. La démo permet aussi à l'utilisateur d'expérimenter avec les opérations de transformation et de voir les résultats immédiatement. image

Toutes les opérations de transformation opèrent sur la transformation worldTransform(). Une matrice transforme un point du plan en un autre point. Pour plus d'informations sur la matrice de transformation, voir le système de coordonnées et la documentation QTransform.

La fonction setWorldTransform() peut remplacer ou augmenter la worldTransform() courante. La fonction resetTransform() réinitialise les transformations faites avec translate(), scale(), shear(), rotate(), setWorldTransform(), setViewport() et setWindow(). La fonction deviceTransform() renvoie la matrice de transformation depuis les coordonnées logiques vers les coordonnées de destination du périphérique de peinture dépendant de la plateforme. Cette dernière fonction n'est nécessaire que dans le cas de l'utilisation de commandes de dessin de la plateforme et si la plateforme ne gère pas nativement les transformations.

En dessinant avec QPainter, nous spécifions les points en utilisant des coordonnées logiques qui sont ensuite converties vers les coordonnées physiques du périphérique de dessin. La conversion des coordonnées logiques vers les coordonnées physiques est gérée par la fonction combinedTransform() de QPainter, une combinaison de viewport(), window() et worldTransform(). Le viewport() représente les coordonnées physiques spécifiant un rectangle quelconque, window() décrit le même rectangle en coordonnées logiques et worldTransform() est identique à la matrice de transformation.

Voir aussi le système de coordonnées.

Masquage

QPainter peut restreindre (par masquage) toute opération de dessin à un rectangle, une région ou un chemin vectoriel. Cette zone de dessin est accessible à travers les fonctions clipRegion() et clipPath(). Le choix entre chemins et régions (pour les meilleures performances) se fait en fonction du paintEngine() sous-jacent. Par exemple, le moteur de dessin de QImage préfère les chemins alors que le moteur de dessin de X11 préfère les régions. La spécification de la zone de dessin se fait dans les coordonnées logiques du QPainter.

Après le masquage effectué par QPainter, le périphérique de dessin peut également effectuer un masquage. Par exemple, la plupart des widgets limitent les widgets enfants à leur propre périmètre et la plupart des imprimantes empêchent les dessins dans une zone proche des bords du papier. Ce masquage supplémentaire n'est pas pris en compte par les valeurs de retour de clipRegion() ou hasClipping().

Modes de composition

QPainter fournit l'énumération CompositionMode qui définit des règles de Porter-Duff pour la composition d'images numériques ; il décrit un modèle de combinaison des pixels d'une image, la source, avec les pixels d'une autre image, la destination.

Les deux formes les plus communes de composition sont Source et SourceOver. Source est utilisée pour dessiner des objets opaques. Dans ce mode, chaque pixel dans la source remplace le pixel correspondant de la destination. Dans le mode de composition SourceOver, l'objet source est transparent et est dessiné au-dessus de l'objet destination.

Notez que la transformation de composition opère pixel par pixel. Pour cette raison, il y a une différence entre l'utilisation de la primitive graphique elle-même et l'utilisation de son rectangle frontière : le rectangle contient des pixels avec alpha == 0 (les pixels entourant la primitive). Ces pixels vont remplacer les pixels de l'autre image, et les effacer, alors que la primitive ne remplace que ses propres pixels.

image Démo modes de composition La démo Modes de composition, disponible dans le répertoire de démo de Qt, vous permet d'expérimenter les différents modes de composition et de voir les résultats immédiatement.

Limitations

Si vous utilisez des coordonnées avec le système de dessin raster de Qt, il est important de noter, bien que des coordonnées plus grandes que +/- 215 puissent être utilisées, que tout dessin effectué avec des coordonnées en dehors de cette plage risque de ne pas être visible ; le dessin peut être coupé à cette frontière. Ceci est dû à l'usage de short int dans l'implémentation.

Les contours générés par le traceur de Qt ne sont que des approximations dans le cas de formes courbes. Il est dans la plupart des cas impossible de représenter la bordure d'un segment d'une courbe de Bézier en utilisant un autre segment de courbe de Bézier et donc Qt trace une approximation en utilisant plusieurs courbes plus petites. Pour des raisons de performances le nombre de courbes que Qt utilise pour ces contours est limité, et pour de grandes largeurs de pinceau ou des agrandissements importants l'erreur augmente. Pour générer des contours avec des erreurs plus faibles il est possible d'utiliser la classe QPainterPathStroker, qui possède la fonction membre setCurveThreshold permettant à l'utilisateur de spécifier la tolérance d'erreur. Une autre solution est de convertir d'abord le chemin en polygones et d'ensuite dessiner les polygones.

Performances

QPainter est un framework riche permettant aux développeurs d'effectuer une grande variété d'opérations graphiques, comme des gradients, des modes de composition et des graphismes vectoriels. Ces opérations peuvent être réalisées par QPainter sur une grande variété de plateformes matérielles et logicielles. Naturellement la combinaison sous-jacente de matériel et de logiciel a des implications sur les performances et il est quasiment impossible d'assurer que chaque opération est rapide à cause du nombre de permutations pour les différentes combinaisons de modes de composition, brosses, transformations, etc. Le compromis que nous avons choisi est de sélectionner un sous-ensemble de l'API de QPainter et des moteurs de rendu pour lesquels nous garantissons que les performances seront aussi bonnes que raisonnablement possible pour la combinaison de matériel et de logiciel donnée.

Les moteurs de rendu sur lesquels nous garantissons les performances sur certaines opérations sont :

  • Raster - Ce moteur implémente les rendus de façon purement logicielle et est systématiquement utilisé pour le rendu dans des QImages. Pour des performances optimales, n'utilisez que les types de format QImage::Format_ARGB32_Premultiplied, QImage::Format_RGB32 ou QImage::Format_RGB16. Tous les autres formats, y compris QImage::Format_ARGB32, ont des performances significativement moins bonnes. Ce moteur est aussi utilisé par défaut sur Windows et sur QWS. Il peut être utilisé comme système graphique par défaut sur toute combinaison OS/matériel/logiciel en passant -graphicssystem raster en ligne de commande ;
  • OpenGL 2.0 (ES) - Ce moteur est le moteur principal pour l'accélération matérielle des graphismes. Il peut fonctionner sur des machines de bureau ou des appareils embarqués compatibles avec la spécification OpenGL 2.0 ou OpenGL/ES 2.0. Ceci inclut la plupart des composants graphiques produits dans les deux dernières années. Le moteur peut être activé en utilisant QPainter sur un QGLWidget ou en passant -graphicssystem opengl en ligne de commande, si le système sous-jacent est compatible ;
  • OpenVG - Ce moteur implémente le standard Khronos pour les graphismes 2D et vectoriels. Il est principalement destiné aux appareils embarqués avec une gestion matérielle de OpenVG. Le moteur peut être activé en passant -graphicssystem openvg en ligne de commande, si le système sous-jacent est compatible.

Ces opérations sont :

  • les transformations simples, à savoir les translations, les redimensionnements, ainsi que les rotations de 0, 90, 180, et 270 degrés ;
  • drawPixmap() combinée avec les transformations simples et une opacité avec un mode de transformation non lissé (c'est-à-dire que l'indication de rendu QPainter::SmoothPixmapTransform n'est pas activée ;
  • les remplissages de rectangles avec des couleurs pleines, les gradients linéaires à deux couleurs et les transformations simples ;
  • le masquage (clipping) rectangulaire avec des transformations simples ;
  • les modes de composition QPainter::CompositionMode_Source et QPainter::CompositionMode_SourceOver ;
  • le remplissage de rectangles arrondis utilisant des couleurs pleines et des gradients linéaires à deux couleurs ;
  • les pixmaps 3 × 3 juxtaposées, via qDrawBorderPixmap.

Cette liste indique les opérations utilisables sans risque dans une application pour laquelle les performances sont critiques. Dans certains cas, d'autres opérations peuvent être elles aussi rapides, mais avant de les utiliser intensivement, il est recommandé de mesurer leurs performances sur le système sur lequel le logiciel est destiné à fonctionner. Il existe aussi des cas où il est possible d'utiliser des opérations coûteuses, par exemple lorsque le résultat est mis en cache dans une QPixmap.

Voir aussi QPaintDevice, QPaintEngine, me module QtSvg, l'exemple simple de dessin et les fonctions utilitaires pour le dessin.

Type

enum QPainter::CompositionMode

Définit les modes possibles pour la composition des images. Les modes de composition sont utilisés pour spécifier la façon dont les pixels d'une image, la source, sont fusionnés avec les pixels d'une autre image, la destination.

Veuillez remarquer que les modes opératoires raster bit à bit, notés avec un préfixe RasterOp, ne sont gérés nativement que dans les moteurs de dessin X11 et raster. Ceci signifie que la seule façon d'utiliser ces modes sur Mac OS est d'utiliser une QImage. Les modes de mélange notés RasterOp ne sont pas gérés pour les pinceaux et les brosses avec des composantes alpha. De plus, l'activation de l'indication de rendu QPainter::Antialiasing désactivera les modes RasterOp.

image image Le type le plus courant est SourceOver (souvent désigné comme alpha blending) où le pixel source est mélangé au pixel destination de façon à ce que la composante alpha de la source définisse la transparence du pixel.

Lorsque la surface de dessin est une QImage, le format d'image doit être fixé à Format_ARGB32Premultiplied ou Format_ARGB32 pour que les modes de composition aient un effet. Pour les performances, la version prémultipliée est le meilleur format.

Lorsqu'un mode de composition est défini, il s'applique à tous les opérateurs de dessin, pinceaux, brosses, gradients et dessins de pixmap/images.

Constante Valeur Description
QPainter::CompositionMode_SourceOver   C'est le mode par défaut. La source est au-dessus, et la valeur alpha de la source est utilisée pour le mélange du pixel avec la destination.
QPainter::CompositionMode_DestinationOver 1 La destination est au-dessus, et la valeur alpha de la destination est utilisée pour le mélange avec les pixels source. Ce mode est l'inverse de CompositionMode_SourceOver.
QPainter::CompositionMode_Clear 2 Les pixels de la destination sont effacés (rendus transparents) indépendamment de la source.
QPainter::CompositionMode_Source 3 Le résultat est le pixel source, ce qui correspond à une simple opération de copie et est identique à SourceOver si le pixel source est opaque.
QPainter::CompositionMode_Destination 4 Le résultat est le pixel destination, ce qui signifie que le mélange n'a pas d'effet. Ce mode est l'inverse de CompositionMode_Source.
QPainter::CompositionMode_SourceIn 5 Le résultat est la source, avec l'alpha réduit par celui de la destination.
QPainter::CompositionMode_DestinationIn 6 Le résultat est la destination, avec l'alpha réduit par celui de la source. Ce mode est l'inverse de CompositionMode_SourceIn.
QPainter::CompositionMode_SourceOut 7 Le résultat est la source, avec l'alpha réduit par l'inverse de la destination.
QPainter::CompositionMode_DestinationOut 8 Le résultat est la destination, avec l'alpha réduit par l'inverse de la source. Ce mode est l'inverse de CompositionMode_SourceOut.
QPainter::CompositionMode_SourceAtop 9 Le pixel source est mélangé sur la destination, avec l'alpha du pixel source réduit de l'alpha du pixel destination.
QPainter::CompositionMode_DestinationAtop 10 Le pixel destination est mélangé sur la source, avec l'alpha du pixel destination réduit de l'alpha du pixel source. Ce mode est l'inverse de CompositionMode_SourceAtop.
QPainter::CompositionMode_Xor 11 La source, dont l'alpha est réduit par l'inverse de l'alpha de la destination, est mélangée avec la destination, dont l'alpha est réduit par l'inverse de l'alpha source. CompositionMode_Xor est différent du Xor (ou exclusif) bit à bit.
QPainter::CompositionMode_Plus 12 Les couleurs et alpha des pixels source et destination sont additionnés.
QPainter::CompositionMode_Multiply 13 Le résultat est la couleur source color multipliée par la destination. La multiplication d'une couleur par du blanc laisse la couleur inchangée, alors que la multiplication d'une couleur avec du noir produit du noir.
QPainter::CompositionMode_Screen 14 Les couleurs source et destination sont inversées puis multipliées. Si une des couleurs est blanche le résultat est blanc, alors que si une des couleurs est noire le résultat est l'autre couleur.
QPainter::CompositionMode_Overlay 15 Utilise un des modes de composition CompositionMode_Multiply ou CompositionMode_Screen en fonction de la couleur destination. La couleur destination est mélangée avec la couleur source pour correspondre au caractère sombre ou clair de la destination.
QPainter::CompositionMode_Darken 16 Sélectionne la couleur la plus sombre entre la source et la destination.
QPainter::CompositionMode_Lighten 17 Sélectionne la couleur la plus claire entre la source et la destination.
QPainter::CompositionMode_ColorDodge 18 La couleur destination est éclaircie par la couleur source. Une couleur source noire laisse la couleur destination inchangée.
QPainter::CompositionMode_ColorBurn 19 La couleur destination est assombrie par la couleur source. Une couleur source blanche laisse la couleur destination inchangée.
QPainter::CompositionMode_HardLight 20  
QPainter::CompositionMode_SoftLight 21 Assombrit ou éclaircit les couleurs en fonction de la source. Similaire à CompositionMode_HardLight.
QPainter::CompositionMode_Difference 22 Soustrait la couleur la plus sombre à la couleur la plus claire. Dessiner en blanc inverse la couleur destination, alors que dessiner en noir laisse la couleur destination inchangée.
QPainter::CompositionMode_Exclusion 23 Similaire à CompositionMode_Difference mais avec un contraste plus faible. Dessiner en blanc inverse la couleur destination, alors que dessiner en noir laisse la couleur destination inchangée.
QPainter::RasterOp_SourceOrDestination 24 Effectue une opération bit à bit OR sur les pixels source et destination (src OR dst).
QPainter::RasterOp_SourceAndDestination 25 Effectue une opération bit à bit AND sur les pixels source et destination (src AND dst).
QPainter::RasterOp_SourceXorDestination 26 Effectue une opération bit à bit XOR sur les pixels source et destination (src XOR dst).
QPainter::RasterOp_NotSourceAndNotDestination 27 Effectue une opération bit à bit NOR sur les pixels source et destination ((NOT src) AND (NOT dst)).
QPainter::RasterOp_NotSourceOrNotDestination 28 Effectue une opération bit à bit NAND sur les pixels source et destination ((NOT src) OR (NOT dst)).
QPainter::RasterOp_NotSourceXorDestination 29 Effectue une opération bit à bit où une inversion des pixels source est suivie d'un XOR avec la destination ((NOT src) XOR dst).
QPainter::RasterOp_NotSource 30 Effectue une opération bit à bit où les pixels source sont inversés (NOT src).
QPainter::RasterOp_NotSourceAndDestination 31 Effectue une opération bit à bit où la source est inversée puis additionnée bit à bit avec la destination ((NOT src) AND dst).
QPainter::RasterOp_SourceAndNotDestination 32 Effectue une opération bit à bit où la source est additionnée bit à bit avec les pixels destination inversés (src AND (NOT dst)).

Voir aussi compositionMode(), setCompositionMode(), Composition Modes et l'exemple de composition d'image.

enum QPainter::PixmapFragmentHintflags QPainter::PixmapFragmentHints

Constante Valeur Description
QPainter::OpaqueHint 0x01 Indique que les fragments de pixmap à dessiner sont opaques. Les fragments sont potentiellement plus rapides à dessiner.

Cette énumération a été introduite ou modifiée dans Qt 4.7.

Le type PixmapFragmentHints est un typedef pour QFlags<PixmapFragmentHint>. Il enregistre une combinaison OU de valeurs PixmapFragmentHint.

Voir aussi QPainter::drawPixmapFragments() et QPainter::PixmapFragment.

enum QPainter::RenderHintflags QPainter::RenderHints

Les Renderhints (indications de rendu) sont utilisés pour spécifier des drapeaux à QPainter, qui peuvent être respectés ou non par les moteurs de rendu.

Constante Valeur Description
QPainter::Antialiasing 0x01 Indique que le moteur doit si possible effectuer un anticrénelage sur les bordures des primitives.
QPainter::TextAntialiasing 0x02 Indique que le moteur doit si possible effectuer un anticrénelage sur les textes. Pour forcer la désactivation de l'anticrénelage du texte, n'utilisez pas cette indication. Utilisez à la place QFont::NoAntialias sur votre stratégie de style de police.
QPainter::SmoothPixmapTransform 0x04 Demande au moteur d'utiliser un algorithme de transformation de pixmap lissé (bilinéaire par exemple) plutôt que du plus proche voisin.
QPainter::HighQualityAntialiasing 0x08 Indication de rendu spécifique à OpenGL demandant au moteur d'utiliser les programmes de fragmentation et du rendu hors écran pour l'antialiasing.
QPainter::NonCosmeticDefaultPen 0x10 Le moteur doit interpréter les pinceaux de largeur 0 (qui sinon activent QPen::isCosmetic()) comme des pinceaux non cosmétiques avec une largeur de 1.

Le type RenderHints est un typedef pour QFlags<RenderHints >. Il enregistre une combinaison OU de valeurs RenderHints.

Voir aussi renderHints(), setRenderHint(), Qualité de rendu et l'exemple de cercles concentriques.

Fonctions membres

QPainter::QPainter ()

Construit un QPainter.

Voir aussi begin() et end().

QPainter::QPainter ( QPaintDevice * device )

Construit un QPainter qui commence immédiatement à dessiner sur device.

Ce constructeur est pratique pour les QPainter à courte durée de vie, par exemple dans un QWidget::paintEvent(), et ne doit être utilisé qu'une fois. Le constructeur appelle begin() pour vous et le destructeur de QPainter appelle automatiquement end().

Voici un exemple utilisant begin() et end() :

 void MyWidget::paintEvent(QPaintEvent *)
 {
     QPainter p;
     p.begin(this);
     p.drawLine(...);        // code de dessin
     p.end();
 }

Et le même exemple avec ce constructeur :

 void MyWidget::paintEvent(QPaintEvent *)
 {
     QPainter p(this);
     p.drawLine(...);        // code de dessin
 }

Étant donné que le constructeur ne peut pas informer de l'échec de l'initialisation du QPainter, il est préférable d'utiliser begin() et end() pour les périphériques externes, par exemple les imprimantes.

Voir aussi begin() et end().

QPainter::~QPainter ()

Détruit le QPainter.

const QBrush & QPainter::background () const

Renvoie la brosse d'arrière-plan courante.

Voir aussi setBackground() et Settings.

Qt::BGMode QPainter::backgroundMode () const

Renvoie le mode d'arrière-plan courant.

Voir aussi setBackgroundMode() et Settings.

bool QPainter::begin ( QPaintDevice * device )

Commence à dessiner sur device et renvoie true en cas de succès ; sinon renvoie false.

Notez que tous les paramètres du QPainter (setPen(), setBrush() etc.) sont réinitialisés à leur valeur par défaut lorsque begin() est appelé.

Les erreurs pouvant se produire sont des problèmes sérieux, comme :

 painter->begin(0); // impossible - la surface de dessin ne peut être 0
 
 QPixmap image(0, 0);
 painter->begin(&image); // impossible - image.isNull() == true;
 
 painter->begin(myWidget);
 painter2->begin(myWidget); // impossible - un seul QPainter à la fois

Notez que la plupart du temps, vous pouvez utiliser un des constructeurs à la place de begin() et que end() est automatiquement appelé à la destruction.

Attention : plusieurs QPainter ne peuvent pas dessiner simultanément sur la même surface.

Attention : il est impossible de dessiner sur une QImage avec le format QImage::Format_Indexed8.

Voir aussi end() et QPainter().

void QPainter::beginNativePainting ()

Purge le flux d'impression et se prépare à l'envoi par l'utilisateur de commandes directes au contexte graphique sous-jacent. Doit être suivi par un appel à endNativePainting().

Notez que seuls les changements dans les états du moteur de dessin sous-jacent seront réinitialisés à leur état par défaut respectif. La liste des états réinitialisés peut changer de version en version. Les états suivants sont actuellement réinitialisés dans le moteur OpenGL 2 :

  • le mélange (blending) est désactivé ;
  • les tests de profondeur, de stencil et de ciseaux sont désactivés ;
  • l'unité de texture active est réinitialisée à 0 ;
  • le masque de profondeur et la fonction de profondeur sont réinitialisés à leur valeur par défaut ;
  • le masque de stencil, les opérations et fonctions de stencil sont réinitialisés à leur valeur par défaut ;
  • la couleur courante est réinitialisée au blanc plein.

Si, par exemple, le polygone OpenGL est modifié par l'utilisateur dans un bloc beginNativePaint()/endNativePainting(), il ne sera pas réinitialisé à l'état par défaut par endNativePainting(). Voici un exemple montrant le mélange de commandes de dessin et de commandes OpenGL brutes :

 QPainter painter(this);
 painter.fillRect(0, 0, 128, 128, Qt::green);
 painter.beginNativePainting();
 
 glEnable(GL_SCISSOR_TEST);
 glScissor(0, 0, 64, 64);
 
 glClearColor(1, 0, 0, 1);
 glClear(GL_COLOR_BUFFER_BIT);
 
 glDisable(GL_SCISSOR_TEST);
 
 painter.endNativePainting();

Cette fonction a été introduite dans Qt 4.6.

Voir aussi endNativePainting().

QRectF QPainter::boundingRect ( const QRectF & rectangle, int flags, const QString & text )

Renvoie le rectangle frontière de text comme il apparaîtra lorsqu'il sera dessiné dans le rectangle donné, avec les drapeaux flags spécifiés, et la police courante ; c'est-à-dire que cette fonction vous dit où la fonction drawText() dessinera si on lui passe les mêmes arguments.

Si text déborde du rectangle donné avec les flags spécifiés, la fonction renvoie le rectangle requis.

Les arguments flags sont un OU bit à bit des drapeaux suivants :

Si plusieurs des drapeaux horizontaux ou plusieurs des drapeaux verticaux sont activés, l'alignement résultant est indéfini.

Voir aussi drawText(), Qt::Alignment et Qt::TextFlag.

QRect QPainter::boundingRect ( const QRect & rectangle, int flags, const QString & text )

Il s'agit d'une fonction surchargée.

Renvoie le rectangle frontière de text comme il apparaîtra lorsqu'il sera dessiné dans le rectangle donné, avec les drapeaux flags spécifiés, et la police courante.

QRect QPainter::boundingRect ( int x, int y, int w, int h, int flags, const QString & text )

Il s'agit d'une fonction surchargée.

Renvoie le rectangle frontière de text comme il apparaîtra lorsqu'il sera dessiné dans le rectangle commençant au point (x, y) avec la largeur w et la hauteur h.

QRectF QPainter::boundingRect ( const QRectF & rectangle, const QString & text, const QTextOption & option = QTextOption() )

Il s'agit d'une fonction surchargée.

Au lieu de spécifier les drapeaux sous forme d'un OU bit à bit de Qt::AlignmentFlag et de Qt::TextFlag, cette fonction surchargée prend un argument option. La classe QTextOption fournit une description de propriétés générales de textes enrichis.

Voir aussi QTextOption.

const QBrush & QPainter::brush () const

Renvoie la brosse courante du QPainter.

Voir aussi QPainter::setBrush() et Settings.

QPoint QPainter::brushOrigin () const

Renvoie l'origine de la brosse courante du QPainter.

Voir aussi setBrushOrigin() et Settings.

QPainterPath QPainter::clipPath () const

Renvoie le masquage courant sous forme d'un chemin. Notez que le chemin est donné en coordonnées logiques.

Attention : QPainter ne stocke pas cette valeur car elle est gérée par le QPaintEngine sous-jacent, donc le chemin est recréé à la demande et converti dans le système de coordonnées logiques courant. Ceci est une opération potentiellement coûteuse.

Voir aussi setClipPath(), clipRegion() et setClipping().

QRegion QPainter::clipRegion () const

Renvoie la région de masquage courante. Notez que la région est donnée en coordonnées logiques.

Attention : QPainter ne stocke pas cette valeur car elle est gérée par le QPaintEngine sous-jacent, donc le chemin est recréé à la demande et converti dans le système de coordonnées logiques courant. Ceci est une opération potentiellement coûteuse.

Voir aussi setClipRegion(), clipPath() et setClipping().

QTransform QPainter::combinedTransform () const

Renvoie la matrice de transformation combinant les transformations de monde et de vue/fenêtre courantes.

Voir aussi setWorldTransform(), setWindow() et setViewport().

CompositionMode QPainter::compositionMode () const

Renvoie le mode de composition courant.

Voir aussi CompositionMode and setCompositionMode().

QPaintDevice * QPainter::device () const

Renvoie le QPaintDevice sur lequel le QPainter dessine actuellement ou 0 si le QPainter n'est pas actif.

Voir aussi isActive().

const QTransform & QPainter::deviceTransform () const

Renvoie la matrice de transformation depuis les coordonnées logiques vers les coordonnées de la surface de peinture dépendant de la plateforme.

Cette fonction est nécessaire seulement pour l'usage de commandes de dessin de la plateforme sur les Qt::HANDLE dépendant de la plateforme, et que la plateforme n'effectue pas nativement les transformations.

L'énumération QPaintEngine::PaintEngineFeature peut être consultée pour déterminer si la plateforme effectue ou non les transformations.

Voir aussi worldTransform() et QPaintEngine::hasFeature().

void QPainter::drawArc ( const QRectF & rectangle, int startAngle, int spanAngle )

Dessine l'arc défini par les rectangle, startAngle (angle de départ) et spanAngle (angle couvert) donnés.

Les startAngle et spanAngle doivent être spécifiés en seizièmes de degré, c'est-à-dire qu'un cercle complet correspond à 5760 (16 * 360). Les valeurs positives pour les angles signifient une direction antihoraire et les valeurs négatives une direction horaire. Zéro degré est à la position trois heures.

image
 QRectF rectangle(10.0, 20.0, 80.0, 60.0);
 int startAngle = 30 * 16;
 int spanAngle = 120 * 16;
 
 QPainter painter(this);
 painter.drawArc(rectangle, startAngle, spanAngle);

Voir aussi drawPie(), drawChord() et le système de coordonnées.

void QPainter::drawArc ( const QRect & rectangle, int startAngle, int spanAngle )

Il s'agit d'une fonction surchargée.

Dessine l'arc défini par les rectangle, startAngle (angle de départ) et spanAngle (angle couvert) donnés.

void QPainter::drawArc ( int x, int y, int width, int height, int startAngle, int spanAngle )

Il s'agit d'une fonction surchargée.

Dessine l'arc défini par le rectangle commençant à (x, y) avec les width (largeur) et height (hauteur) données, et les startAngle (angle de départ) et spanAngle (angle couvert) donnés.

void QPainter::drawChord ( const QRectF & rectangle, int startAngle, int spanAngle )

Dessine la corde définie par les rectangle, startAngle (angle de départ) et spanAngle (angle couvert) donnés. La corde est remplie avec la brosse courante.

Les startAngle et spanAngle doivent être spécifiés en seizièmes de degré, c'est-à-dire qu'un cercle complet correspond à 5760 (16 * 360). Les valeurs positives pour les angles signifient une direction antihoraire et les valeurs négatives une direction horaire. Zéro degré est à la position trois heures.

image
 QRectF rectangle(10.0, 20.0, 80.0, 60.0);
 int startAngle = 30 * 16;
 int spanAngle = 120 * 16;
 
 QPainter painter(this);
 painter.drawChord(rect, startAngle, spanAngle);

Voir aussi drawArc(), drawPie() et le système de coordonnées.

void QPainter::drawChord ( const QRect & rectangle, int startAngle, int spanAngle )

Il s'agit d'une fonction surchargée.

Dessine la corde définie par les rectangle, startAngle (angle de départ) et spanAngle (angle couvert) donnés.

void QPainter::drawChord ( int x, int y, int width, int height, int startAngle, int spanAngle )

Il s'agit d'une fonction surchargée.

Dessine la corde définie par le rectangle commençant à (x, y) avec les width (largeur) et height (hauteur) données, et les startAngle (angle de départ) et spanAngle (angle couvert) donnés.

void QPainter::drawConvexPolygon ( const QPointF * points, int pointCount )

Dessine le polygone convexe défini par les premiers pointCount points dans le tableau points en utilisant le pinceau courant.

image
 static const QPointF points[4] = {
     QPointF(10.0, 80.0),
     QPointF(20.0, 10.0),
     QPointF(80.0, 30.0),
     QPointF(90.0, 70.0)
 };
 
 QPainter painter(this);
 painter.drawConvexPolygon(points, 4);

Le premier point est implicitement connecté au dernier point et le polygone est rempli avec la brosse courante . Si le polygone fourni n'est pas convexe, c'est-à-dire s'il contient au moins un angle de plus de 180 degrés, le résultat est indéfini.

Sur certaines plateformes (par exemple X11), la fonction drawConvexPolygon() peut être plus rapide que la fonction drawPolygon().

Voir aussi drawPolygon(), drawPolyline() et le système de coordonnées.

void QPainter::drawConvexPolygon ( const QPoint * points, int pointCount )

Il s'agit d'une fonction surchargée.

Dessine le polygone convexe défini par les premiers pointCount points dans le tableau points en utilisant le pinceau courant.

void QPainter::drawConvexPolygon ( const QPolygonF & polygon )

Il s'agit d'une fonction surchargée.

Dessine le polygone convexe défini par polygon en utilisant le pinceau et la brosse courants.

void QPainter::drawConvexPolygon ( const QPolygon & polygon )

Il s'agit d'une fonction surchargée.

Dessine le polygone convexe défini par polygon en utilisant le pinceau et la brosse courants.

void QPainter::drawEllipse ( const QRectF & rectangle )

Dessine l'ellipse définie par le rectangle donné.

Une ellipse pleine a une taille égale à rectangle.size(). Une ellipse dessinée par un trait a une taille égale à rectangle.size() plus la largeur du pinceau.

image
 QRectF rectangle(10.0, 20.0, 80.0, 60.0);
 
 QPainter painter(this);
 painter.drawEllipse(rectangle);

Voir aussi drawPie() et le système de coordonnées.

void QPainter::drawEllipse ( const QRect & rectangle )

Il s'agit d'une fonction surchargée.

Dessine l'ellipse définie par le rectangle donné.

void QPainter::drawEllipse ( int x, int y, int width, int height )

Il s'agit d'une fonction surchargée.

Dessine l'ellipse définie par le rectangle commençant à (x, y) avec les width (largeur) et height (hauteur) données.

void QPainter::drawEllipse ( const QPointF & center, qreal rx, qreal ry )

Il s'agit d'une fonction surchargée.

Dessine l'ellipse avec comme centre center et avec les rayons rx et ry.

Cette fonction a été introduite dans Qt 4.4.

void QPainter::drawEllipse ( const QPoint & center, int rx, int ry )

Il s'agit d'une fonction surchargée.

Dessine l'ellipse avec comme centre center et avec les rayons rx et ry.

Cette fonction a été introduite dans Qt 4.4.

void QPainter::drawImage ( const QRectF & target, const QImage & image, const QRectF & source, Qt::ImageConversionFlags flags = Qt::AutoColor )

Dessine la portion rectangulaire source de l'image donnée dans le rectangle target de la surface de dessin.

Note : l'image est redimensionnée pour s'adapter au rectangle si l'image et le rectangle n'ont pas la même taille.

Si l'image doit être modifiée pour s'adapter à un résultat de plus basse résolution (par exemple une conversion de 32 bits vers 8 bits), utilisez flags pour spécifier la façon dont la conversion doit être faite.

 QRectF target(10.0, 20.0, 80.0, 60.0);
 QRectF source(0.0, 0.0, 70.0, 40.0);
 QImage image(":/images/myImage.png");
 
 QPainter painter(this);
 painter.drawImage(target, image, source);

Voir aussi drawPixmap().

void QPainter::drawImage ( const QRect & target, const QImage & image, const QRect & source, Qt::ImageConversionFlags flags = Qt::AutoColor )

Il s'agit d'une fonction surchargée.

Dessine la portion rectangulaire source de l'image donnée dans le rectangle target de la surface de dessin.

Note : l'image est redimensionnée pour s'adapter au rectangle si l'image et le rectangle n'ont pas la même taille.

void QPainter::drawImage ( const QPointF & point, const QImage & image )

Il s'agit d'une fonction surchargée.

Dessine l'image donnée au point donné.

void QPainter::drawImage ( const QPoint & point, const QImage & image )

Il s'agit d'une fonction surchargée.

Dessine l'image donnée au point donné.

void QPainter::drawImage ( const QPointF & point, const QImage & image, const QRectF & source, Qt::ImageConversionFlags flags = Qt::AutoColor )

Il s'agit d'une fonction surchargée.

Dessine la portion rectangulaire source de l'image donnée avec comme origine le point donné.

void QPainter::drawImage ( const QPoint & point, const QImage & image, const QRect & source, Qt::ImageConversionFlags flags = Qt::AutoColor )

Il s'agit d'une fonction surchargée.

Dessine la portion rectangulaire source de l'image donnée avec comme origine le point donné.

void QPainter::drawImage ( const QRectF & rectangle, const QImage & image )

Il s'agit d'une fonction surchargée.

Dessine l'image donnée dans le rectangle donné.

Note : l'image est redimensionnée pour s'adapter au rectangle si l'image et le rectangle n'ont pas la même taille.

void QPainter::drawImage ( const QRect & rectangle, const QImage & image )

Il s'agit d'une fonction surchargée.

Dessine l'image donnée dans le rectangle donné.

Note : l'image est redimensionnée pour s'adapter au rectangle si l'image et le rectangle n'ont pas la même taille.

void QPainter::drawImage ( int x, int y, const QImage & image, int sx = 0, int sy = 0, int sw = -1, int sh = -1, Qt::ImageConversionFlags flags = Qt::AutoColor )

Il s'agit d'une fonction surchargée.

Dessine une image au point (x, y) en copiant une partie de image sur la surface de dessin.

(x, y) spécifie le point supérieur gauche du dessin sur la surface destination. (sx, sy) spécifie le point supérieur gauche à dessiner dans image. La valeur par défaut est (0, 0).

(sw, sh) spécifie la taille de l'image à dessiner. La valeur par défaut est (0, 0) (et les valeurs négatives) signifie la totalité de l'image.

void QPainter::drawLine ( const QLineF & line )

Dessine une ligne définie par line.

image
 QLineF line(10.0, 80.0, 90.0, 20.0);
 
 QPainter(this);
 painter.drawLine(line);

Voir aussi drawLines(), drawPolyline() et le système de coordonnées.

void QPainter::drawLine ( const QLine & line )

Il s'agit d'une fonction surchargée.

Dessine une ligne définie par line.

void QPainter::drawLine ( const QPoint & p1, const QPoint & p2 )

Il s'agit d'une fonction surchargée.

Dessine une ligne de p1 à p2.

void QPainter::drawLine ( const QPointF & p1, const QPointF & p2 )

Il s'agit d'une fonction surchargée.

Dessine une ligne de p1 à p2.

void QPainter::drawLine ( int x1, int y1, int x2, int y2 )

Il s'agit d'une fonction surchargée.

Dessine une ligne de (x1, y1) à (x2, y2) et fixe la position courante du pinceau à (x2, y2).

void QPainter::drawLines ( const QLineF * lines, int lineCount )

Dessine les lineCount premières lignes du tableau lines en utilisant le pinceau courant.

Voir aussi drawLine() et drawPolyline().

void QPainter::drawLines ( const QLine * lines, int lineCount )

Il s'agit d'une fonction surchargée.

Dessine les lineCount premières lignes du tableau lines en utilisant le pinceau courant.

void QPainter::drawLines ( const QPointF * pointPairs, int lineCount )

Il s'agit d'une fonction surchargée.

Dessine les lineCount premières lignes du tableau pointPairs en utilisant le pinceau courant. Les lignes sont spécifiées sous forme de paires de points donc le nombre d'entrées de pointPairs doit être au moins égal à lineCount * 2.

void QPainter::drawLines ( const QPoint * pointPairs, int lineCount )

Il s'agit d'une fonction surchargée.

Dessine les lineCount premières lignes du tableau pointPairs en utilisant le pinceau courant.

void QPainter::drawLines ( const QVector<QPointF> & pointPairs )

Il s'agit d'une fonction surchargée.

Dessine une ligne pour chaque paire de points du vecteur pointPairs en utilisant le pinceau courant. Si le tableau contient un nombre impair de points, le dernier point sera ignoré.

void QPainter::drawLines ( const QVector<QPoint> & pointPairs )

Il s'agit d'une fonction surchargée.

Dessine une ligne pour chaque paire de points du vecteur pointPairs en utilisant le pinceau courant.

void QPainter::drawLines ( const QVector<QLineF> & lines )

Il s'agit d'une fonction surchargée.

Dessine l'ensemble de lignes défini par la liste lines en utilisant le pinceau et la brosse courants.

void QPainter::drawLines ( const QVector<QLine> & lines )

Il s'agit d'une fonction surchargée.

Dessine l'ensemble de lignes défini par la liste lines en utilisant le pinceau et la brosse courants.

void QPainter::drawPath ( const QPainterPath & path )

Dessine le chemin path donné en utilisant le pinceau courant pour le tracé et la brosse courante pour le remplissage.

image
 QPainterPath path;
 path.moveTo(20, 80);
 path.lineTo(20, 30);
 path.cubicTo(80, 0, 50, 50, 80, 80);
 
 QPainter painter(this);
 painter.drawPath(path);

Voir aussi the Painter Paths example et la démo Vector Deformation.

void QPainter::drawPicture ( const QPointF & point, const QPicture & picture )

Rejoue la picture donnée au point donné.

La classe QPicture est un QPaintDevice qui enregistre et rejoue des commandes de QPainter. Un QPicture sérialise les commandes du QPainter vers un périphérique d'E/S dans un format indépendant de la plateforme. Tout ce qui peut être dessiné sur un widget ou une pixmap peut être aussi stocké dans un QPicture.

Cette fonction fait exactement la même chose que QPicture::play() appelée avec point = QPoint(0, 0).

 QPicture picture;
 QPointF point(10.0, 20.0)
 picture.load("drawing.pic");
 
 QPainter painter(this);
 painter.drawPicture(0, 0, picture);

Voir aussi QPicture::play().

void QPainter::drawPicture ( const QPoint & point, const QPicture & picture )

Il s'agit d'une fonction surchargée.

Rejoue la picture donnée au point donné.

void QPainter::drawPicture ( int x, int y, const QPicture & picture )

Il s'agit d'une fonction surchargée.

Rejoue la picture donnée au point (x, y).

void QPainter::drawPie ( const QRectF & rectangle, int startAngle, int spanAngle )

Dessine une portion d'ellipse définie par les rectangle, startAngle (angle de départ) et spanAngle (angle couvert) donnés.

La portion est remplie avec la brosse courante.

Les startAngle et spanAngle doivent être spécifiés en seizièmes de degré, c'est-à-dire qu'un cercle complet correspond à 5760 (16 * 360). Les valeurs positives pour les angles signifient une direction antihoraire et les valeurs négatives une direction horaire. Zéro degré est à la position trois heures.

image
 QRectF rectangle(10.0, 20.0, 80.0, 60.0);
 int startAngle = 30 * 16;
 int spanAngle = 120 * 16;
 
 QPainter painter(this);
 painter.drawPie(rectangle, startAngle, spanAngle);

Voir aussi drawEllipse(), drawChord() et le système de coordonnées.

void QPainter::drawPie ( const QRect & rectangle, int startAngle, int spanAngle )

Il s'agit d'une fonction surchargée.

Dessine une portion d'ellipse définie par les rectangle, startAngle (angle de départ) et spanAngle (angle couvert) donnés.

void QPainter::drawPie ( int x, int y, int width, int height, int startAngle, int spanAngle )

Il s'agit d'une fonction surchargée.

Dessine la portion d'ellipse définie par le rectangle commençant à (x, y) avec les width (largeur) et height (hauteur) données, et les startAngle (angle de départ) et spanAngle (angle couvert) donnés.

void QPainter::drawPixmap ( const QRectF & target, const QPixmap & pixmap, const QRectF & source )

Dessine la portion rectangulaire source de la pixmap donnée dans le rectangle cible target de la surface de dessin.

Note : l?image est redimensionnée pour s?adapter au rectangle si l?image et le rectangle n?ont pas la même taille.

 QRectF target(10.0, 20.0, 80.0, 60.0);
 QRectF source(0.0, 0.0, 70.0, 40.0);
 QPixmap pixmap(":myPixmap.png");
 
 QPainter(this);
 painter.drawPixmap(target, image, source);

Si pixmap est une QBitmap, elle est dessinée avec la couleur du pinceau pour les bits à 1. Si backgroundMode est Qt::OpaqueMode, les bits à 0 sont dessinés avec la couleur de la brosse d'arrière-plan ; si backgroundMode est Qt::TransparentMode, les bits à 0 sont transparents. Le dessin de bitmaps avec des gradients ou des textures n'est pas géré.

Voir aussi drawImage().

void QPainter::drawPixmap ( const QRect & target, const QPixmap & pixmap, const QRect & source )

Il s'agit d'une fonction surchargée.

Dessine la portion rectangulaire source de la pixmap donnée dans le rectangle cible target de la surface de dessin.

Note : l?image est redimensionnée pour s?adapter au rectangle si l?image et le rectangle n?ont pas la même taille.

void QPainter::drawPixmap ( const QPointF & point, const QPixmap & pixmap, const QRectF & source )

Il s'agit d'une fonction surchargée.

Dessine la portion rectangulaire source de la pixmap donnée avec comme origine le point donné.

void QPainter::drawPixmap ( const QPoint & point, const QPixmap & pixmap, const QRect & source )

Il s'agit d'une fonction surchargée.

Dessine la portion rectangulaire source de la pixmap donnée avec comme origine le point donné.

void QPainter::drawPixmap ( const QPointF & point, const QPixmap & pixmap )

Il s'agit d'une fonction surchargée.

Dessine la pixmap donnée avec comme origine le point donné.

void QPainter::drawPixmap ( const QPoint & point, const QPixmap & pixmap )

Il s'agit d'une fonction surchargée.

Dessine la pixmap donnée avec comme origine le point donné.

void QPainter::drawPixmap ( int x, int y, const QPixmap & pixmap )

Il s'agit d'une fonction surchargée.

Dessine la pixmap donnée à la position (x, y).

void QPainter::drawPixmap ( const QRect & rectangle, const QPixmap & pixmap )

Il s'agit d'une fonction surchargée.

Dessine la pixmap donnée dans le rectangle donné.

Note : la pixmap est redimensionnée pour s'adapter au rectangle si les tailles de la pixmap et du rectangle sont différentes.

void QPainter::drawPixmap ( int x, int y, int width, int height, const QPixmap & pixmap )

Il s'agit d'une fonction surchargée.

Dessine la pixmap dans le rectangle à la position (x, y) avec les width (largeur) et height (hauteur) données.

void QPainter::drawPixmap ( int x, int y, int w, int h, const QPixmap & pixmap, int sx, int sy, int sw, int sh )

Il s'agit d'une fonction surchargée.

Dessine la portion rectangulaire d'origine (sx, sy), de largeur sw, et de hauteur height sh, de la pixmap donnée, au point (x, y), avec une largeur de w et une hauteur de h. Si sw ou sh sont égales à zéro la largeur/hauteur de la pixmap est utilisée et ajustée par l'offset sx/sy.

void QPainter::drawPixmap ( int x, int y, const QPixmap & pixmap, int sx, int sy, int sw, int sh )

Il s'agit d'une fonction surchargée.

Dessine une pixmap à la position (x, y) en copiant une partie de la pixmap sur la surface de dessin.

(x, y) spécifie le point supérieur gauche de la surface de dessin sur laquelle on va dessiner. (sx, sy) spécifie le point supérieur gauche dans la pixmap à dessiner. La valeur par défaut est (0, 0).

(sw, sh) spécifie la taille de la pixmap à dessiner. La valeur par défaut (0, 0) et les valeurs négatives signifient que la pixmap entière sera dessinée.

void QPainter::drawPixmapFragments ( const PixmapFragment * fragments, int fragmentCount, const QPixmap & pixmap, PixmapFragmentHints hints = 0 )

Cette fonction permet de dessiner pixmap ou un sous-rectangle de pixmap, à de multiples positions et avec différentes échelles, rotations et opacités. fragments est un tableau de fragmentCount éléments spécifiant les paramètres utilisés pour dessiner chaque fragment de pixmap. Le paramètre hints peut être utilisé pour passer des indications de dessin.

Cette fonction est potentiellement plus rapide que des appels multiples de drawPixmap(), car le moteur peut optimiser les changements d'état.

Cette fonction a été introduite dans Qt 4.7.

Voir aussi QPainter::PixmapFragment et QPainter::PixmapFragmentHint.

void QPainter::drawPoint ( const QPointF & position )

Dessine un point unique à la position donnée en utilisant la couleur courante du pinceau.

Voir aussi le système de coordonnées.

void QPainter::drawPoint ( const QPoint & position )

Il s'agit d'une fonction surchargée.

Dessine un point unique à la position donnée en utilisant la couleur courante du pinceau.

void QPainter::drawPoint ( int x, int y )

Il s'agit d'une fonction surchargée.

Dessine un point unique à la position (x, y).

void QPainter::drawPoints ( const QPointF * points, int pointCount )

Dessine les pointCount premiers points dans le tableau points en utilisant la couleur courante du pinceau.

Voir aussi le système de coordonnées.

void QPainter::drawPoints ( const QPoint * points, int pointCount )

Il s'agit d'une fonction surchargée.

Dessine les pointCount premiers points dans le tableau points en utilisant la couleur courante du pinceau.

void QPainter::drawPoints ( const QPolygonF & points )

Il s'agit d'une fonction surchargée.

Dessine les points du vecteur points.

void QPainter::drawPoints ( const QPolygon & points )

Il s'agit d'une fonction surchargée.

Dessine les points du vecteur points.

void QPainter::drawPolygon ( const QPointF * points, int pointCount, Qt::FillRule fillRule = Qt::OddEvenFill )

Dessine le polygone défini par les premiers pointCount points du tableau points en utilisant le pinceau et la brosse courants.

image
 static const QPointF points[4] = {
     QPointF(10.0, 80.0),
     QPointF(20.0, 10.0),
     QPointF(80.0, 30.0),
     QPointF(90.0, 70.0)
 };
 
 QPainter painter(this);
 painter.drawPolygon(points, 4);

Le premier point est implicitement connecté au dernier point et le polygone est rempli avec la brosse courante.

Si fillRule est Qt::WindingFill, le polygone est rempli avec l'algorithme d'enroulement. Si fillRule est Qt::OddEvenFill, le polygone est rempli avec l'algorithme pair-impair. Voir Qt::FillRule pour une description détaillée de ces règles de remplissage.

Voir aussi drawConvexPolygon(), drawPolyline() et le système de coordonnées.

void QPainter::drawPolygon ( const QPoint * points, int pointCount, Qt::FillRule fillRule = Qt::OddEvenFill )

Il s'agit d'une fonction surchargée.

Dessine le polygone défini par les premiers pointCount points du tableau points.

void QPainter::drawPolygon ( const QPolygonF & points, Qt::FillRule fillRule = Qt::OddEvenFill )

Il s'agit d'une fonction surchargée.

Dessine le polygone défini par les points donnés en utilisant la règle de remplissage fillRule.

void QPainter::drawPolygon ( const QPolygon & points, Qt::FillRule fillRule = Qt::OddEvenFill )

Il s'agit d'une fonction surchargée.

Dessine le polygone défini par les points donnés en utilisant la règle de remplissage fillRule.

void QPainter::drawPolyline ( const QPointF * points, int pointCount )

Dessine la polyligne (ligne brisée) définie par les pointCount premiers points de points en utilisant le pinceau courant.

Notez que contrairement à la fonction drawPolygon() le dernier point n'est pas connecté au premier, et que la forme n'est pas remplie.

 static const QPointF points[3] = {
     QPointF(10.0, 80.0),
     QPointF(20.0, 10.0),
     QPointF(80.0, 30.0),
 };
 
 QPainter painter(this);
 painter.drawPolyline(points, 3);

Voir aussi drawLines(), drawPolygon() et le système de coordonnées.

void QPainter::drawPolyline ( const QPoint * points, int pointCount )

Il s'agit d'une fonction surchargée.

Dessine la polyligne définie par les pointCount premiers points de points en utilisant le pinceau courant.

void QPainter::drawPolyline ( const QPolygonF & points )

Il s'agit d'une fonction surchargée.

Dessine la polyligne définie par les points donnés en utilisant le pinceau courant.

void QPainter::drawPolyline ( const QPolygon & points )

Il s'agit d'une fonction surchargée.

Dessine la polyligne définie par les points donnés en utilisant le pinceau courant.

void QPainter::drawRect ( const QRectF & rectangle )

Dessine le rectangle donné avec le pinceau et la brosse courants.

Un rectangle plein a une taille égale à rectangle.size(). Un rectangle dessiné par un trait a une taille égale à rectangle.size() plus la largeur du pinceau.

image
 QRectF rectangle(10.0, 20.0, 80.0, 60.0);
 
 QPainter painter(this);
 painter.drawRect(rectangle);

Voir aussi drawRects(), drawPolygon() et le système de coordonnées.

void QPainter::drawRect ( const QRect & rectangle )

Il s'agit d'une fonction surchargée.

Dessine le rectangle donné avec le pinceau et la brosse courants.

void QPainter::drawRect ( int x, int y, int width, int height )

Il s'agit d'une fonction surchargée.

Dessine un rectangle avec le coin supérieur gauche au point (x, y) et avec les width (largeur) et height (hauteur) données.

void QPainter::drawRects ( const QRectF * rectangles, int rectCount )

Dessine les rectCount premiers rectangles donnés avec le pinceau et la brosse courants.

Voir aussi drawRect().

void QPainter::drawRects ( const QRect * rectangles, int rectCount )

Il s'agit d'une fonction surchargée.

Dessine les rectCount premiers rectangles donnés avec le pinceau et la brosse courants.

void QPainter::drawRects ( const QVector<QRectF> & rectangles )

Il s'agit d'une fonction surchargée.

Dessine les rectangles donnés avec le pinceau et la brosse courants.

void QPainter::drawRects ( const QVector<QRect> & rectangles )

Il s'agit d'une fonction surchargée.

Dessine les rectangles donnés avec le pinceau et la brosse courants.

void QPainter::drawRoundedRect ( const QRectF & rect, qreal xRadius, qreal yRadius, Qt::SizeMode mode = Qt::AbsoluteSize )

Dessine le rectangle rect donné avec des coins arrondis.

Les arguments xRadius and yRadius spécifient les rayons des ellipses définissant les coins du rectangle arrondi. Si mode est Qt::RelativeSize, xRadius and yRadius sont spécifiés en pourcentage de la moitié de respectivement la largeur et la hauteur du rectangle et doivent être dans la plage 0.0 à 100.0.

Un rectangle plein a une taille égale à rectangle.size(). Un rectangle dessiné par un trait a une taille égale à rectangle.size() plus la largeur du pinceau.

image
 QRectF rectangle(10.0, 20.0, 80.0, 60.0);
 
 QPainter painter(this);
 painter.drawRoundedRect(rectangle, 20.0, 15.0);

Cette fonction a été introduite dans Qt 4.4.

Voir aussi drawRect() et QPen.

void QPainter::drawRoundedRect ( const QRect & rect, qreal xRadius, qreal yRadius, Qt::SizeMode mode = Qt::AbsoluteSize )

Il s'agit d'une fonction surchargée.

Dessine le rectangle rect donné avec des coins arrondis.

Cette fonction a été introduite dans Qt 4.4.

void QPainter::drawRoundedRect ( int x, int y, int w, int h, qreal xRadius, qreal yRadius, Qt::SizeMode mode = Qt::AbsoluteSize )

Il s'agit d'une fonction surchargée.

Dessine le rectangle x, y, w, h donné avec des coins arrondis.

Cette fonction a été introduite dans Qt 4.4.

void QPainter::drawStaticText ( const QPointF & topLeftPosition, const QStaticText & staticText )

Dessine le texte staticText donné à la position topLeftPosition donnée.

Le texte sera dessiné en utilisant la police de caractères et la transformation du QPainter. Si la police et/ou la transformation du QPainter sont différentes de celles utilisées pour initialiser la disposition du QStaticText, la disposition sera recalculée. Utilisez QStaticText::prepare() pour initialiser staticText la police et la transformation avec lesquelles il sera dessiné.

Si topLeftPosition est différent de sa valeur au moment où staticText a été initialisé ou de lors de son dernier dessin, il y aura une légère charge de travail supplémentaire pour la translation du texte à sa nouvelle position.

Note : si la transformation du QPainter n'est pas affine, alors staticText sera dessiné avec des appels standard à drawText(), ce qui empêchera tout éventuel gain de performance.

Note : le Y de la position sera le haut de la police.

Cette fonction a été introduite dans Qt 4.7.

Voir aussi QStaticText.

void QPainter::drawStaticText ( const QPoint & topLeftPosition, const QStaticText & staticText )

Il s'agit d'une fonction surchargée.

Dessine le texte staticText à la position topLeftPosition.

Note : le Y de la position représente le haut de la police.

Cette fonction a été introduite dans Qt 4.7.

void QPainter::drawStaticText ( int left, int top, const QStaticText & staticText )

Il s'agit d'une fonction surchargée.

Dessine le texte staticText à la position topLeftPosition.

Note : le Y de la position représente le haut de la police.

Cette fonction a été introduite dans Qt 4.7.

void QPainter::drawText ( const QPointF & position, const QString & text )

Dessine le texte donné avec la direction de texte actuellement définie, en commençant à la position donnée.

Cette fonction ne gère pas le caractère de saut de ligne (\n), car elle ne peut pas séparer le texte en plusieurs lignes et ne peut pas afficher le caractère de saut de ligne. Utilisez la surcharge QPainter::drawText() prenant un rectangle si vous voulez afficher du texte contenant des caractères de saut de ligne sur plusieurs lignes, ou si vous voulez que le texte passe à la ligne automatiquement.

Par défaut, QPainter dessine le texte avec un anticrénelage.

Note : le Y de la position représente la ligne de base de la police.

void QPainter::drawText ( const QPoint & position, const QString & text )

Il s'agit d'une fonction surchargée.

Dessine le texte donné avec la direction de texte actuellement définie, en commençant à la position donnée.

Par défaut, QPainter dessine le texte avec un anticrénelage.

Note : le Y de la position représente la ligne de base de la police.

void QPainter::drawText ( const QRectF & rectangle, int flags, const QString & text, QRectF * boundingRect = 0 )

Il s'agit d'une fonction surchargée.

Dessine le texte donné à l'intérieur du rectangle fourni.

image
 QPainter painter(this);
 painter.drawText(rect, Qt::AlignCenter, tr("Qt by\nNokia"));

Le boundingRect (si non nul) reçoit la valeur représentant le plus petit rectangle contenant la totalité du texte. L'argument flags est un OU bit à bit des drapeaux suivants :

Par défaut, QPainter dessine le texte avec un anticrénelage.

Note : le Y de la position représente le haut de la police.

Voir aussi Qt::AlignmentFlag, Qt::TextFlag, boundingRect() et layoutDirection().

void QPainter::drawText ( const QRect & rectangle, int flags, const QString & text, QRect * boundingRect = 0 )

Il s'agit d'une fonction surchargée.

Dessine le texte donné dans le rectangle spécifié en suivant les indications des drapeaux flags spécifiés. Le boundingRect (si non nul) reçoit la valeur représentant le plus petit rectangle contenant la totalité du texte.

Par défaut, QPainter dessine le texte avec un anticrénelage.

Note : le Y de la position représente le haut de la police.

void QPainter::drawText ( int x, int y, const QString & text )

Il s'agit d'une fonction surchargée.

Dessine le texte donné à la position (x, y) avec la direction de texte actuellement définie.

Par défaut, QPainter dessine le texte avec un anticrénelage.

Note : le Y de la position représente le haut de la police.

void QPainter::drawText ( int x, int y, int width, int height, int flags, const QString & text, QRect * boundingRect = 0 )

Il s'agit d'une fonction surchargée.

Dessine le texte donné à l'intérieur du rectangle d'origine (x, y), de largeur width et de hauteur height.

Le boundingRect (si non nul) reçoit la valeur représentant le plus petit rectangle contenant la totalité du texte. L'argument flags est un OU bit à bit des drapeaux suivants :

Par défaut, QPainter dessine le texte avec un anticrénelage.

Note : le Y de la position représente le haut de la police

Voir aussi Qt::AlignmentFlag et Qt::TextFlag.

void QPainter::drawText ( const QRectF & rectangle, const QString & text, const QTextOption & option = QTextOption() )

Il s'agit d'une fonction surchargée.

Dessine le texte donné dans le rectangle spécifié en utilisant option pour contrôler son positionnement et son orientation.

Par défaut, QPainter dessine le texte avec un anticrénelage.

Note : le Y de la position représente le haut de la police

void QPainter::drawTiledPixmap ( const QRectF & rectangle, const QPixmap & pixmap, const QPointF & position = QPointF() )

Dessine une pixmap par pavage, à l'intérieur du rectangle donné, avec comme origine la position donnée.

L'appel de drawTiledPixmap() est similaire à des appels successifs de drawPixmap() pour remplir (paver) une zone avec une pixmap mais est potentiellement beaucoup plus efficace, en fonction du système de fenêtres sous-jacent.

Voir aussi drawPixmap().

void QPainter::drawTiledPixmap ( const QRect & rectangle, const QPixmap & pixmap, const QPoint & position = QPoint() )

Il s'agit d'une fonction surchargée.

Dessine une pixmap par pavage, à l'intérieur du rectangle donné, avec comme origine la position donnée.

void QPainter::drawTiledPixmap ( int x, int y, int width, int height, const QPixmap & pixmap, int sx = 0, int sy = 0 )

Il s'agit d'une fonction surchargée.

Dessine une pixmap par pavage à l'intérieur du rectangle spécifié.

(x, y) spécifie le point supérieur gauche de la surface sur laquelle le dessin se fait, width et height sont les largeur et hauteur dessinées. (sx, sy) spécifie un point supérieur gauche dans la pixmap à dessiner ; sa valeur par défaut est (0, 0).

bool QPainter::end ()

Termine le dessin. Toutes les ressources utilisées pendant le dessin sont libérées. Vous n'avez normalement pas besoin d'appeler cette fonction car elle est appelée par le destructeur.

Renvoie true si le QPainter n'est plus actif ; sinon renvoie false.

Voir aussi begin() et isActive().

void QPainter::endNativePainting ()

Restaure le QPainter après avoir utilisé manuellement des commandes de dessin natives.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi beginNativePainting().

void QPainter::eraseRect ( const QRectF & rectangle )

Efface la zone à l'intérieur du rectangle donné. Équivalent à l'appel de

 fillRect(rectangle, background()).

Voir aussi fillRect().

void QPainter::eraseRect ( const QRect & rectangle )

Il s'agit d'une fonction surchargée.

Efface la zone à l'intérieur du rectangle donné.

void QPainter::eraseRect ( int x, int y, int width, int height )

Il s'agit d'une fonction surchargée.

Efface la zone à l'intérieur du rectangle commençant en (x, y) avec les width (largeur) et height (hauteur) donnés.

void QPainter::fillPath ( const QPainterPath & path, const QBrush & brush )

Remplit le chemin path donné en utilisant la brosse brush. Le contour n'est pas dessiné.

Vous pouvez également spécifier une QColor à la place de la QBrush ; le constructeur de la QBrush (acceptant un argument QColor) créera automatiquement une brosse pleine.

Voir aussi drawPath().

void QPainter::fillRect ( const QRectF & rectangle, const QBrush & brush )

Remplit le chemin path donné en utilisant la brosse brush.

Vous pouvez également spécifier une QColor à la place de la QBrush ; le constructeur de la QBrush (acceptant un argument QColor) créera automatiquement une brosse pleine.

Voir aussi drawRect().

void QPainter::fillRect ( int x, int y, int width, int height, Qt::BrushStyle style )

Il s'agit d'une fonction surchargée.

Remplit le rectangle commençant en (x, y) avec les width (largeur) et height (hauteur) donnés, en utilisant le style de brosse spécifié.

Cette fonction a été introduite dans Qt 4.5.

void QPainter::fillRect ( const QRect & rectangle, Qt::BrushStyle style )

Il s'agit d'une fonction surchargée.

Remplit le rectangle donné en utilisant le style de brosse spécifié.

Cette fonction a été introduite dans Qt 4.5.

void QPainter::fillRect ( const QRectF & rectangle, Qt::BrushStyle style )

Il s'agit d'une fonction surchargée.

Remplit le rectangle donné en utilisant le style de brosse spécifié.

Cette fonction a été introduite dans Qt 4.5.

void QPainter::fillRect ( const QRect & rectangle, const QBrush & brush )

Il s'agit d'une fonction surchargée.

Remplit le rectangle donné avec la brosse spécifiée.

void QPainter::fillRect ( const QRect & rectangle, const QColor & color )

Il s'agit d'une fonction surchargée.

Remplit le rectangle donné avec la couleur color spécifiée.

Cette fonction a été introduite dans Qt 4.5.

void QPainter::fillRect ( const QRectF & rectangle, const QColor & color )

Il s'agit d'une fonction surchargée.

Remplit le rectangle donné avec la couleur color spécifiée.

Cette fonction a été introduite dans Qt 4.5.

void QPainter::fillRect ( int x, int y, int width, int height, const QBrush & brush )

Il s'agit d'une fonction surchargée.

Remplit le rectangle commençant en (x, y) avec les width (largeur) et height (hauteur) donnés, en utilisant la brosse spécifiée.

void QPainter::fillRect ( int x, int y, int width, int height, const QColor & color )

Il s'agit d'une fonction surchargée.

Remplit le rectangle commençant en (x, y) avec les width (largeur) et height (hauteur) donnés, en utilisant la couleur color spécifiée.

Cette fonction a été introduite dans Qt 4.5.

void QPainter::fillRect ( int x, int y, int width, int height, Qt::GlobalColor color )

Il s'agit d'une fonction surchargée. Remplit le rectangle commençant en (x, y) avec les width (largeur) et height (hauteur) donnés, en utilisant la couleur color spécifiée.

Cette fonction a été introduite dans Qt 4.5.

void QPainter::fillRect ( const QRect & rectangle, Qt::GlobalColor color )

Il s'agit d'une fonction surchargée.

Remplit le rectangle donné avec la couleur color spécifiée.

Cette fonction a été introduite dans Qt 4.5.

void QPainter::fillRect ( const QRectF & rectangle, Qt::GlobalColor color )

Il s'agit d'une fonction surchargée.

Remplit le rectangle donné avec la couleur color spécifiée.

Cette fonction a été introduite dans Qt 4.5.

const QFont & QPainter::font () const

Renvoie la police de caractères utilisée pour dessiner le texte.

Voir aussi setFont(), drawText() et Settings.

QFontInfo QPainter::fontInfo () const

Renvoie les informations sur la police de caractères du QPainter s'il est actif. Sinon la valeur de retour est indéfinie.

Voir aussi font(), isActive() et Settings.

QFontMetrics QPainter::fontMetrics () const

Renvoie les métriques de la police de caractères du QPainter s'il est actif. Sinon la valeur de retour est indéfinie.

Voir aussi font(), isActive() et Settings.

bool QPainter::hasClipping () const

Renvoie true si le masquage est activé ; sinon renvoie false.

Voir aussi setClipping() et Clipping.

void QPainter::initFrom ( const QWidget * widget )

Initialise les pinceaux, arrière-plan et polices aux valeurs du widget donné. Cette fonction est appelée automatiquement lorsque le QPainter est ouvert sur un QWidget.

Voir aussi begin() et Settings.

bool QPainter::isActive () const

Renvoie true si begin() a été appelé et end() n'a pas encore été appelé ; sinon renvoie false.

Voir aussi begin() et QPaintDevice::paintingActive().

Qt::LayoutDirection QPainter::layoutDirection () const

Renvoie la direction de la disposition utilisée par le QPainter pour le dessin du texte.

Voir aussi QTextOption::textDirection(), setLayoutDirection(), drawText() et Settings.

qreal QPainter::opacity () const

Renvoie l'opacité du QPainter. La valeur par défaut est 1.

Cette fonction a été introduite dans Qt 4.2.

Voir aussi setOpacity().

QPaintEngine * QPainter::paintEngine () const

Renvoie le moteur de rendu avec lequel le QPainter opère actuellement si le QPainter est actif ; sinon 0.

Voir aussi isActive().

const QPen & QPainter::pen () const

Renvoie le pinceau courant du QPainter.

Voir aussi setPen() et Settings.

RenderHints QPainter::renderHints () const

Renvoie les indications de rendu activées pour ce QPainter.

Voir aussi setRenderHints(), testRenderHint() et la qualité du rendu.

void QPainter::resetTransform ()

Réinitialise les transformations faites avec translate(), scale(), shear(), rotate(), setWorldTransform(), setViewport() et setWindow().

Voir aussi les transformations de coordonnées.

void QPainter::restore ()

Restaure l'état du QPainter (extrait l'état du haut de la pile).

Voir aussi save().

void QPainter::rotate ( qreal angle )

Effectue une rotation horaire du système de coordonnées suivant l'angle donné.

Voir aussi setWorldTransform() et les transformations de coordonnées.

void QPainter::save ()

Sauvegarde l'état courant du QPainter (ajoute l'état sur une pile). Un save() doit être suivi du restore() correspondant ; la fonction end() vide la pile.

Voir aussi restore().

void QPainter::scale ( qreal sx, qreal sy )

Multiplie l'échelle du système de coordonnées par (sx, sy).

Voir aussi setWorldTransform() et les transformations de coordonnées.

void QPainter::setBackground ( const QBrush & brush )

Définit la brosse brush comme arrière-plan.

La brosse d'arrière-plan est la brosse de remplissage pour les textes opaques, les lignes pointillées et les bitmaps. La brosse d'arrière-plan n'a pas d'effet dans si l'arrière-plan est en mode transparent (la valeur par défaut).

Voir aussi background(), setBackgroundMode() et Settings.

void QPainter::setBackgroundMode ( Qt::BGMode mode )

Définit mode comme mode d'arrière-plan du QPainter.

Qt::TransparentMode (le mode par défaut) dessine les lignes pointillées et le texte sans remplir les pixels d'arrière-plan. Qt::OpaqueMode remplit ces espaces avec la couleur d'arrière-plan courante.

Notez que pour dessiner une bitmap ou une pixmap transparente, vous devez utiliser QPixmap::setMask().

Voir aussi backgroundMode(), setBackground() et Settings.

void QPainter::setBrush ( const QBrush & brush )

Définit la brosse brush comme brosse du QPainter.

Cette brosse détermine le remplissage des formes.

Voir aussi brush() et Settings.

void QPainter::setBrush ( Qt::BrushStyle style )

Il s'agit d'une fonction surchargée.

Définit une brosse noire du style spécifié comme brosse du QPainter.

void QPainter::setBrushOrigin ( const QPointF & position )

Définit position comme origine de la brosse.

L'origine de la brosse spécifie la coordonnée (0, 0) du painter de la brosse.

Notez qu'alors que brushOrigin() était nécessaire pour adopter l'arrière-plan du parent pour un widget avec Qt 3, ce n'est plus le cas étant donné que le QPainter de Qt 4 ne dessine pas l'arrière-plan sauf si vous le demandez explicitement en activant la propriété autoFillBackground du widget.

Voir aussi brushOrigin() et Settings.

void QPainter::setBrushOrigin ( const QPoint & position )

Il s'agit d'une fonction surchargée.

Définit position comme origine de la brosse.

void QPainter::setBrushOrigin ( int x, int y )

Il s'agit d'une fonction surchargée.

Définit le point (x, y) comme origine de la brosse.

void QPainter::setClipPath ( const QPainterPath & path, Qt::ClipOperation operation = Qt::ReplaceClip )

Active le masquage (clipping) et définit path comme chemin de masquage du QPainter, avec l'opération de masquage operation.

Notez que le chemin de masquage est spécifié en coordonnées logiques du QPainter.

Voir aussi clipPath(), clipRegion() et Masquage.

void QPainter::setClipRect ( const QRectF & rectangle, Qt::ClipOperation operation = Qt::ReplaceClip )

Active le masquage (clipping) et définit rectangle comme région de masquage du QPainter, avec l'opération de masquage operation. L'opération par défaut remplace le rectangle de masquage courant.

Notez que le chemin de masquage est spécifié en coordonnées logiques du QPainter.

Voir aussi clipRegion(), setClipping() et Clipping.

void QPainter::setClipRect ( int x, int y, int width, int height, Qt::ClipOperation operation = Qt::ReplaceClip )

Active le masquage (clipping) et définit comme région de masquage le rectangle commençant en (x, y) , de largeur width et de hauteur height.

void QPainter::setClipRect ( const QRect & rectangle, Qt::ClipOperation operation = Qt::ReplaceClip )

Il s'agit d'une fonction surchargée.

Active le masquage (clipping) et définit rectangle comme région de masquage du QPainter, avec l'opération de masquage operation.

void QPainter::setClipRegion ( const QRegion & region, Qt::ClipOperation operation = Qt::ReplaceClip )

Active le clipping (masquage) et définit region comme région de masquage du QPainter, avec l'opération de masquage operation. L'opération par défaut remplace la région de masquage courant.

Notez que la région de masquage est spécifiée en coordonnées logiques.

Voir aussi clipRegion(), setClipRect() et Masquage.

void QPainter::setClipping ( bool enable )

Active le masquage (clipping) si enable est vrai, ou le désactive sinon.

Voir aussi hasClipping() et Masquage.

void QPainter::setCompositionMode ( CompositionMode mode )

Spécifie le mode donné comme mode de composition.

Attention : seul un QPainter opérant sur une QImage gère complètement tous les modes de composition. Les modes RasterOp sont gérés pour X11 comme décrit dans compositionMode().

Voir aussi compositionMode().

void QPainter::setFont ( const QFont & font )

Spécifie la police font donnée comme police de caractères.

Cette police sera utilisée par les fonctions drawText() appelées par la suite. La couleur de texte sera la couleur du pinceau.

Si vous spécifiez une police non disponible, Qt trouvera une police approchante. font() renvoie la valeur que vous avez spécifiée dans setFont() et fontInfo() renvoie la police réellement utilisée (qui peut être la même).

Voir aussi font(), drawText() et Settings.

void QPainter::setLayoutDirection ( Qt::LayoutDirection direction )

Spécifie direction comme direction de la disposition utilisée par le QPainter pour dessiner du texte.

La valeur par défaut est Qt::LayoutDirectionAuto, qui va déterminer implicitement une direction en fonction du texte dessiné.

Voir aussi QTextOption::setTextDirection(), layoutDirection(), drawText() et Settings.

void QPainter::setOpacity ( qreal opacity )

Spécifie opacity comme opacité du QPainter. La valeur doit être dans la plage 0.0 à 1.0, où 0.0 est complètement transparent et 1.0 est complètement opaque.

L'opacité affectée au QPainter s'applique à toutes les opérations de dessin individuellement.

Cette fonction a été introduite dans Qt 4.2.

Voir aussi opacity().

void QPainter::setPen ( const QPen & pen )

Spécifie pen comme pinceau du QPainter.

Le pinceau définit la façon de dessiner les lignes et les contours et définit également la couleur de texte.

Voir aussi pen() et Settings.

void QPainter::setPen ( const QColor & color )

Il s'agit d'une fonction surchargée.

Donne le style Qt::SolidLine au le pinceau du QPainter, avec une largeur de 0 et la couleur color spécifiée.

void QPainter::setPen ( Qt::PenStyle style )

Il s'agit d'une fonction surchargée.

Affecte le style spécifié au pinceau du QPainter, avec une largeur de 0 et la couleur noire.

void QPainter::setRenderHint ( RenderHint hint, bool on = true )

Active l'indication de rendu hint sur le QPainter si on est vrai ; sinon désactive l'indication de rendu.

Voir aussi setRenderHints(), renderHints() et la qualité du rendu.

void QPainter::setRenderHints ( RenderHints hints, bool on = true )

Active les indications de rendu hints sur le QPainter si on est vrai ; sinon désactive les indications de rendu.

Cette fonction a été introduite dans Qt 4.2.

Voir aussi setRenderHint(), renderHints() et la qualité du rendu.

void QPainter::setTransform ( const QTransform & transform, bool combine = false )

Modifie la matrice de transformation du monde. Si combine est vrai, la transformation transform spécifiée est combinée avec la matrice courante ; sinon elle remplace la matrice courante.

Cette fonction a été introduite dans Qt 4.3.

Voir aussi transform() et setWorldTransform().

void QPainter::setViewTransformEnabled ( bool enable )

Active les transformations de vue si enable est vrai ou les désactive sinon.

Voir aussi viewTransformEnabled() et la conversion Fenêtre-Viewport.

void QPainter::setViewport ( const QRect & rectangle )

Spécifie rectangle comme afficheur (viewport) du QPainter et active les transformations de vue.

Le rectangle de l'afficheur fait partie de la transformation de vue. L'afficheur spécifie le système de coordonnées du périphérique de dessin. Sa s?ur, la fenêtre, spécifie le système de coordonnées logiques.

L'afficheur par défaut est le rectangle du périphérique de dessin.

Voir aussi viewport(), viewTransformEnabled() et la conversion Fenêtre-Viewport.

void QPainter::setViewport ( int x, int y, int width, int height )

Il s'agit d'une fonction surchargée.

Spécifie comme afficheur (viewport) du QPainter le rectangle commençant à (x, y) et avec les width (largeur) et height (hauteur) données.

void QPainter::setWindow ( const QRect & rectangle )

Spécifie rectangle comme fenêtre du QPainter et active les transformations de vue.

Le rectangle de fenêtre fait partie de la transformation de vue. La fenêtre spécifie le système de coordonnées logiques. Son frère, l'afficheur, spécifie le système de coordonnées du périphérique de dessin.

Le rectangle de fenêtre par défaut est le rectangle du périphérique de dessin.

Voir aussi window(), viewTransformEnabled() et la conversion Fenêtre-Viewport.

void QPainter::setWindow ( int x, int y, int width, int height )

Il s'agit d'une fonction surchargée.

Spécifie comme fenêtre du QPainter le rectangle commençant à (x, y) et avec les width (largeur) et height (hauteur) données.

void QPainter::setWorldMatrixEnabled ( bool enable )

Active les transformations si enable est vrai et les désactive sinon. La matrice de transformation du monde n'est pas modifiée.

Cette fonction a été introduite dans Qt 4.2.

Voir aussi worldMatrixEnabled(), worldTransform() et les transformations de coordonnées.

void QPainter::setWorldTransform ( const QTransform & matrix, bool combine = false )

Modifie la matrice de transformation du monde. Si combine est vrai, la matrice matrix spécifiée est combinée avec la matrice courante ; sinon elle remplace la matrice courante.

Voir aussi worldTransform(), transform() et setTransform().

void QPainter::shear ( qreal sh, qreal sv )

Incline le système de coordonnées de (sh, sv).

Voir aussi setWorldTransform() et les transformations de coordonnées.

void QPainter::strokePath ( const QPainterPath & path, const QPen & pen )

Dessine (trace) le contour du chemin path avec le pinceau spécifié par pen

Voir aussi fillPath() et Drawing.

bool QPainter::testRenderHint ( RenderHint hint ) const

Renvoie true si hint est activé ; sinon renvoie false.

Cette fonction a été introduite dans Qt 4.3.

Voir aussi renderHints() et setRenderHint().

const QTransform & QPainter::transform () const

Renvoie la matrice de transformation du monde.

Voir aussi setTransform() et worldTransform().

void QPainter::translate ( const QPointF & offset )

Translate le système de coordonnées par offset ; c'est-à-dire que offset est ajouté aux points.

Voir aussi setWorldTransform() et Transformations de coordonnées.

void QPainter::translate ( const QPoint & offset )

Il s'agit d'une fonction surchargée.

Translate le système de coordonnées par l'offset donné.

void QPainter::translate ( qreal dx, qreal dy )

Il s'agit d'une fonction surchargée.

Translate le système de coordonnées par le vecteur (dx, dy).

bool QPainter::viewTransformEnabled () const

Renvoie true si la transformation de vue est activée ; sinon renvoie false.

Voir aussi setViewTransformEnabled() et worldTransform().

QRect QPainter::viewport () const

Renvoie le rectangle de l'afficheur.

Voir aussi setViewport() et setViewTransformEnabled().

QRect QPainter::window () const

Renvoie le rectangle de la fenêtre.

Voir aussi setWindow() et setViewTransformEnabled().

bool QPainter::worldMatrixEnabled () const

Renvoie true si la matrice de transformation du monde est activée ; sinon renvoie false.

Cette fonction a été introduite dans Qt 4.2.

Voir aussi setWorldMatrixEnabled(), worldTransform() et le système de coordonnées.

const QTransform & QPainter::worldTransform () const

Renvoie la matrice de transformation du monde.

Voir aussi setWorldTransform().

Remerciements

Merci à Ilya Diallo pour la traduction ainsi qu'à Jonathan Courtois et Claude Leloup pour leur relecture !

Publicité

Best Of

Actualités les plus lues

Semaine
Mois
Année
  1. « Quelque chose ne va vraiment pas avec les développeurs "modernes" », un développeur à "l'ancienne" critique la multiplication des bibliothèques 44
  2. Microsoft ouvre aux autres compilateurs C++ AMP, la spécification pour la conception d'applications parallèles C++ utilisant le GPU 22
  3. Les développeurs ignorent-ils trop les failles découvertes dans leur code ? Prenez-vous en compte les remarques des autres ? 17
  4. RIM : « 13 % des développeurs ont gagné plus de 100 000 $ sur l'AppWord », Qt et open-source au menu du BlackBerry DevCon Europe 0
  5. BlackBerry 10 : premières images du prochain OS de RIM qui devrait intégrer des widgets et des tuiles inspirées de Windows Phone 0
  6. Quelles nouveautés de C++11 Visual C++ doit-il rapidement intégrer ? Donnez-nous votre avis 10
  7. Adieu qmake, bienvenue qbs : Qt Building Suite, un outil déclaratif et extensible pour la compilation de projets Qt 17
Page suivante

Le Qt Quarterly au hasard

Logo

XQuery et la météo

Qt Quarterly est la revue trimestrielle proposée par Nokia et à destination des développeurs Qt. Ces articles d'une grande qualité technique sont rédigés par des experts Qt. Lire l'article.

Communauté

Ressources

Liens utiles

Contact

  • Vous souhaitez rejoindre la rédaction ou proposer un tutoriel, une traduction, une question... ? Postez dans le forum Contribuez ou contactez-nous par MP ou par email (voir en bas de page).

Qt dans le magazine

Cette page est une traduction d'une page de la documentation de Qt, écrite par Nokia Corporation and/or its subsidiary(-ies). Les éventuels problèmes résultant d'une mauvaise traduction ne sont pas imputables à Nokia. Qt 4.7
Copyright © 2012 Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon, vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts. Cette page est déposée à la SACD.
Vous avez déniché une erreur ? Un bug ? Une redirection cassée ? Ou tout autre problème, quel qu'il soit ? Ou bien vous désirez participer à ce projet de traduction ? N'hésitez pas à nous contacter ou par MP !
 
 
 
 
Partenaires

Hébergement Web

Responsable bénévole de la rubrique Qt : Thibaut Cuvelier -