QPainter Class

Documentation des fonctions membres

QPainter::QPainter()

Crée un « painter ».

Voir également begin() et end().

[explicit] QPainter::QPainter(QPaintDevice *device)

Crée un « painter » qui commence immédiatement à peindre l'device.

Ce constructeur est pratique pour les peintres à courte durée de vie, par exemple dans une fonction ` QWidget::paintEvent()`, et ne doit être utilisé qu'une seule fois. Le constructeur appelle ` begin()` à votre place 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(drawingCode);        // drawing code
    p.end();
}

Le même exemple utilisant ce constructeur :

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

Étant donné que le constructeur ne peut pas fournir de retour d'information en cas d'échec de l'initialisation du peintre, il est préférable d'utiliser begin() et end() pour dessiner sur des périphériques externes, par exemple des imprimantes.

Voir également begin() et end().

[noexcept] QPainter::~QPainter()

Il anéantit le peintre.

const QBrush &QPainter::background() const

Renvoie le pinceau d'arrière-plan actuel.

Voir également setBackground() et Settings.

Qt::BGMode QPainter::backgroundMode() const

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

Voir également setBackgroundMode() et Settings.

bool QPainter::begin(QPaintDevice *device)

Lance l'opération de peinture « device » et renvoie « true » en cas de réussite ; sinon, renvoie « false ».

Notez que tous les paramètres du peintre (setPen(), setBrush() etc.) sont réinitialisés à leurs valeurs par défaut lorsque la fonction begin() est appelée.

Les erreurs pouvant survenir constituent des problèmes graves, tels que ceux-ci :

painter->begin(nullptr); // impossible - paint device cannot be null

QPixmap image(0, 0);
painter->begin(&image); // impossible - image.isNull() == true;

painter->begin(myWidget);
painter2->begin(myWidget); // impossible - only one painter at a time

Notez que, la plupart du temps, vous pouvez utiliser l’un des constructeurs à la place de `begin()`, et que ` end()` est automatiquement exécutée lors de la destruction.

Voir également ` end()` et ` QPainter()`.

void QPainter::beginNativePainting()

Vide le pipeline de rendu et prépare le système à l’exécution de commandes directement adressées par l’utilisateur au contexte graphique sous-jacent. Doit être suivi d’un appel à la fonction ` endNativePainting()`.

Notez que seuls les états modifiés par le moteur de dessin sous-jacent seront réinitialisés à leurs états par défaut respectifs. Les états réinitialisés peuvent varier d'une version à l'autre. Les états suivants sont actuellement réinitialisés dans le moteur OpenGL 2 :

• le mélange 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, la fonction de profondeur et la profondeur de nettoyage sont réinitialisés à leurs valeurs par défaut
• le masque de stencil, l'opération de stencil et la fonction de stencil sont réinitialisés à leurs valeurs par défaut
• la couleur actuelle est réinitialisée en blanc uni

Si, par exemple, le mode polygone OpenGL est modifié par l’utilisateur à l’intérieur d’un bloc `beginNativePaint()`/`endNativePainting()`, il ne sera pas réinitialisé à son état par défaut par ` endNativePainting()`. Voici un exemple illustrant l’intermêlement de commandes de peinture 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();

Voir également endNativePainting().

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

Renvoie le rectangle englobant de l’ text, tel qu’il apparaîtra lorsqu’il sera dessiné à l’intérieur de l’ rectangle donné, avec l’ flags spécifié, en utilisant l’ font() actuellement défini ; en d’autres termes, cette fonction indique où la fonction drawText() dessinera si on lui fournit les mêmes arguments.

Si l’ text ne tient pas dans l’ rectangle donné en utilisant l’ flags spécifié, la fonction renvoie le rectangle requis.

L’argument ` flags ` est un OU binaire des indicateurs suivants :

• Qt::AlignLeft
• Qt::AlignRight
• Qt::AlignHCenter
• Qt::AlignTop
• Qt::AlignBottom
• Qt::AlignVCenter
• Qt::AlignCenter
• Qt::TextSingleLine
• Qt::TextExpandTabs
• Qt::TextShowMnemonic
• Qt::TextWordWrap
• Qt::TextIncludeTrailingSpaces

Si plusieurs indicateurs d’alignement horizontal ou plusieurs indicateurs d’alignement vertical sont activés, l’alignement résultant n’est pas défini.

Voir également drawText(), Qt::Alignment et Qt::TextFlag.

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

Renvoie le rectangle englobant de l’ text, tel qu’il apparaîtra lorsqu’il sera dessiné à l’intérieur de l’ rectangle donnée, avec l’ flags spécifiée, en utilisant le font() actuellement défini.

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

Au lieu de spécifier les indicateurs sous la forme d'un OU binaire entre les valeurs « Qt::AlignmentFlag » et « Qt::TextFlag », cette fonction surchargée prend un argument de type « option ». La classe « QTextOption » fournit une description des propriétés générales du texte enrichi.

Voir également QTextOption.

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

Renvoie le rectangle englobant de l'text donné, tel qu'il apparaîtra lorsqu'il sera dessiné à l'intérieur du rectangle dont les coordonnées de départ sont (x, y), avec une largeur de w et une hauteur de h.

const QBrush &QPainter::brush() const

Renvoie le pinceau actuellement utilisé par le peintre.

Voir également QPainter::setBrush() et Settings.

QPoint QPainter::brushOrigin() const

Renvoie l'origine actuelle du pinceau. Il est préférable d'utiliser QPainter::brushOriginF() pour obtenir l'origine exacte.

Voir également setBrushOrigin() et Settings.

[since 6.11] QPointF QPainter::brushOriginF() const

Renvoie l'origine actuelle du pinceau.

Cette fonction a été introduite dans Qt 6.11.

Voir également setBrushOrigin() et Settings.

QRectF QPainter::clipBoundingRect() const

Renvoie le rectangle englobant du clip actuel s'il existe un clip ; sinon, renvoie un rectangle vide. Notez que la région du clip est exprimée en coordonnées logiques.

Il n'est pas garanti que le rectangle de délimitation soit serré.

Voir également setClipRect(), setClipPath() et setClipRegion().

QPainterPath QPainter::clipPath() const

Renvoie le tracé de découpe actuel en coordonnées logiques.

Voir également setClipPath(), clipRegion() et setClipping().

QRegion QPainter::clipRegion() const

Renvoie la région de clip actuellement définie. Notez que la région de clip est exprimée en coordonnées logiques.

Voir également setClipRegion(), clipPath() et setClipping().

QTransform QPainter::combinedTransform() const

Renvoie la matrice de transformation combinant la transformation de la fenêtre/fenêtre d'affichage actuelle et la transformation mondiale.

Voir également setWorldTransform(), setWindow() et setViewport().

QPainter::CompositionMode QPainter::compositionMode() const

Renvoie le mode de composition actuel.

Voir également CompositionMode et setCompositionMode().

QPaintDevice *QPainter::device() const

Renvoie le périphérique de dessin sur lequel ce « painter » est en train de dessiner, ou « nullptr » si le « painter » n'est pas actif.

Voir également isActive().

const QTransform &QPainter::deviceTransform() const

Renvoie la matrice permettant de transformer les coordonnées logiques en coordonnées du périphérique de dessin propre à la plateforme.

Cette fonction n' est nécessaire que lorsque l'on utilise des commandes de dessin spécifiques à la plate-forme sur le descripteur dépendant de la plate-forme (Qt::HANDLE) et que la plate-forme n'effectue pas ces transformations de manière native.

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

Voir également worldTransform() et QPaintEngine::hasFeature().

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

Dessine l'arc défini par les coordonnées données : rectangle, startAngle et spanAngle.

Les paramètres startAngle et spanAngle doivent être spécifiés en 1/16e de degré, c'est-à-dire qu'un cercle complet équivaut à 5 760 (16 * 360). Les valeurs positives des angles correspondent à un sens antihoraire, tandis que les valeurs négatives correspondent à un sens horaire. Zéro degré correspond à la position 3 heures. Si l'rectangle e n'est pas carré, les angles sont des angles excentriques et ne mesurent pas la direction à partir du centre de l' e, comme décrit dans Arcs and Ellipses.

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 également drawPie(), drawChord() et Système de coordonnées.

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

Dessine l'arc défini par les coordonnées données : rectangle, startAngle et spanAngle.

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

Dessine l'arc défini par le rectangle dont les sommets sont (x, y), avec les paramètres spécifiés width et height, ainsi que les valeurs données startAngle et spanAngle.

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

Dessine la corde définie par les paramètres ` rectangle`, ` startAngle ` et ` spanAngle`. La corde est remplie avec la couleur actuelle définie par ` brush()`.

Les paramètres startAngle et spanAngle doivent être spécifiés en 1/16e de degré, c'est-à-dire qu'un cercle complet équivaut à 5 760 (16 * 360). Les valeurs positives des angles correspondent à un sens antihoraire, tandis que les valeurs négatives correspondent à un sens horaire. Zéro degré correspond à la position 3 heures. Si rectangle n’est pas carré, les angles sont des angles excentriques et ne mesurent pas la direction à partir du centre du rectangle, comme décrit dans Arcs and Ellipses.

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 également drawArc(), drawPie() et Système de coordonnées.

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

Dessine la corde définie par les coordonnées données rectangle, startAngle et spanAngle.

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

Dessine la corde définie par le rectangle dont les sommets sont (x, y), avec les paramètres spécifiés width et height, ainsi que les valeurs données startAngle et spanAngle.

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

Dessine le polygone convexe défini par les premiers points de l'pointCount s du tableau points à l'aide du stylo actuel.

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 relié au dernier, et le polygone est rempli avec l'brush() actuel. Si le polygone fourni n'est pas convexe, c'est-à-dire s'il contient au moins un angle supérieur à 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 également drawPolygon(), drawPolyline() et Système de coordonnées.

void QPainter::drawConvexPolygon(const QPolygon &polygon)

Dessine le polygone convexe défini par polygon à l'aide du stylo et du pinceau actuels.

void QPainter::drawConvexPolygon(const QPolygonF &polygon)

Dessine le polygone convexe défini par polygon à l'aide du stylo et du pinceau actuels.

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

Dessine le polygone convexe défini par les points de la première pointCount s du tableau « points » à l'aide du stylo actuel.

void QPainter::drawEllipse(const QRectF &rectangle)

Dessine l'ellipse définie par les coordonnées données rectangle.

Une ellipse remplie a une taille de rectangle.size(). Une ellipse avec contour a une taille de rectangle.size() plus la largeur du stylo.

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

Voir également drawPie() et Système de coordonnées.

void QPainter::drawEllipse(const QRect &rectangle)

Dessine l'ellipse définie par l'rectangle s fournies.

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

Dessine l'ellipse située aux coordonnées center, dont les rayons sont rx et ry.

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

Dessine l'ellipse située à l'center, dont les rayons sont rx et ry.

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

Dessine l'ellipse définie par le rectangle dont les sommets sont (x, y), avec les paramètres width et height fournis.

void QPainter::drawGlyphRun(const QPointF &position, const QGlyphRun &glyphs)

Affiche les glyphes représentés par glyphs à l'adresse position. Le paramètre « position » indique le bord de la ligne de base de la chaîne de glyphes. Les glyphes seront extraits de la police sélectionnée sur glyphs et aux décalages indiqués par les positions figurant dans glyphs.

Voir également QGlyphRun::setRawFont(), QGlyphRun::setPositions() et QGlyphRun::setGlyphIndexes().

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

Dessine la partie rectangulaire source de l'image donné dans le rectangle target du périphérique de dessin.

Si l’image doit être modifiée pour s’adapter à un résultat de résolution inférieure (par exemple, conversion de 32 bits à 8 bits), utilisez la fonction flags pour spécifier la manière dont vous souhaitez que cette opération soit effectuée.

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 également drawPixmap() et QImage::devicePixelRatio().

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

Affiche l'image e indiquée à l'point indiquée.

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

Affiche l'image on indiquée à l'point indiquée.

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

Affiche l'image on fournie dans l'rectangle on fournie.

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

Affiche l'image on fournie dans l'rectangle on fournie.

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

Dessine la partie rectangulaire source de l'image donnée, dont l'origine se trouve au point point.

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

Dessine la partie rectangulaire source de l'image donnée, dont l'origine se trouve à l'point indiquée.

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

Dessine la partie rectangulaire source de l'image donné dans le rectangle target du périphérique de dessin.

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)

Dessine une image aux coordonnées (x, y) en copiant une partie de image dans le périphérique de dessin.

(x, y) spécifie le point d'angle supérieur gauche dans le périmètre de dessin sur lequel l'image doit être dessinée. (sx, sy) spécifie le point d'angle supérieur gauche dans image qui doit être dessiné. La valeur par défaut est (0, 0).

(sw, sh) spécifie la taille de l’image à dessiner. La valeur par défaut, (0, 0) (et les valeurs négatives), correspond à la zone allant jusqu’au coin inférieur droit de l’image.

void QPainter::drawLine(const QLineF &line)

Trace une ligne définie par line.

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

Voir également drawLines(), drawPolyline() et Système de coordonnées.

void QPainter::drawLine(const QLine &line)

Dessine une ligne définie par line.

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

Trace une ligne reliant p1 à p2.

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

Trace une ligne reliant p1 à p2.

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

Trace une droite reliant les points (x1, y1) à (x2, y2).

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

Dessine les premières lignes de type « lineCount » du tableau « lines » à l'aide du stylo actuel.

Voir également drawLine() et drawPolyline().

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

Dessine l'ensemble des lignes définies par la liste lines à l'aide du stylo et du pinceau actuels.

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

Dessine l'ensemble des lignes définies par la liste lines à l'aide du stylo et du pinceau actuels.

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

Dessine une ligne pour chaque paire de points du vecteur pointPairs à l'aide du stylo actuel.

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

Dessine une ligne pour chaque paire de points du vecteur ` pointPairs ` à l'aide du stylo actuel. Si le tableau contient un nombre impair de points, le dernier point sera ignoré.

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

Dessine les lineCount premières lignes du tableau lines à l'aide du stylo actuel.

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

Dessine les lineCount premières lignes du tableau « pointPairs » à l'aide du stylo actuel.

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

Dessine les lineCount premières lignes du tableau pointPairs à l'aide du stylo actuel. Les lignes sont spécifiées sous forme de paires de points ; le nombre d'entrées dans pointPairs doit donc être au moins égal à lineCount * 2.

void QPainter::drawPath(const QPainterPath &path)

Dessine l'path « painter » spécifiée en utilisant le stylo actuel pour le contour et le pinceau actuel pour le remplissage.

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 également l'exemple «Painter Paths » et l'exemple « Vector Deformation ».

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

Relance l'picture spécifiée à l'adresse point.

La classe ` QPicture ` est un périphérique de dessin qui enregistre et relance les commandes ` QPainter `. Une image sérialise les commandes de dessin vers un périphérique d’E/S dans un format indépendant de la plate-forme. Tout ce qui peut être dessiné sur un widget ou une image bitmap peut également être stocké dans une image.

Cette fonction fait exactement la même chose que ` QPicture::play()` lorsqu’elle est appelée avec ` point = QPointF(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)

Lance la rediffusion de l’ picture on indiquée à l’adresse point.

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

Dessine l'picture e indiquée au point (x, y).

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

Affiche un diagramme circulaire défini par les coordonnées fournies : rectangle, startAngle et spanAngle.

Le cercle est rempli avec la couleur actuelle brush().

Les paramètres startAngle et spanAngle doivent être spécifiés en 1/16e de degré, c’est-à-dire qu’un cercle complet équivaut à 5 760 (16 × 360). Les valeurs positives des angles correspondent à un sens antihoraire, tandis que les valeurs négatives correspondent à un sens horaire. Zéro degré correspond à la position 3 heures. Si rectangle n’est pas un carré, les angles sont des angles excentriques et ne mesurent pas la direction à partir du centre du rectangle, comme décrit dans Arcs and Ellipses.

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 également drawEllipse(), drawChord() et Système de coordonnées.

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

Dessine un diagramme circulaire défini par les coordonnées rectangle, startAngle et spanAngle.

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

Dessine le secteur défini par le rectangle dont les coins sont situés respectivement en (x, y), avec les paramètres width et height spécifiés, ainsi que les coordonnées startAngle et spanAngle fournies.

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

Dessine la partie rectangulaire source de l'image donnée pixmap dans la zone donnée target du périphérique de dessin.

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 painter(this);
painter.drawPixmap(target, pixmap, source);

Si pixmap est un QBitmap, il est dessiné avec les bits « activés » en utilisant la couleur des stylos. Si backgroundMode est Qt::OpaqueMode, les bits « désactivés » sont dessinés en utilisant la couleur du pinceau d’arrière-plan ; si backgroundMode est Qt::TransparentMode, les bits « désactivés » sont transparents. Le dessin de bitmaps avec des couleurs en dégradé ou en texture n’est pas pris en charge.

Voir également drawImage() et QPixmap::devicePixelRatio().

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

Dessine l'pixmap donnée dont l'origine se trouve à l'point indiquée.

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

Dessine l'pixmap donnée dont l'origine se trouve à l'point indiquée.

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

Dessine l'pixmap on fournie dans l'rectangle on fournie.

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

Dessine la partie rectangulaire source de la surface donnée pixmap, dont l'origine se trouve au point donné point.

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

Dessine la partie rectangulaire source de l'pixmap donnée, dont l'origine se trouve au point point.

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

Dessine la partie rectangulaire source de l'pixmap donné dans la zone target spécifiée du périphérique de dessin.

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

Affiche l'pixmap on indiquée à la position (x, y).

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

Dessine l'pixmap e dans le rectangle situé à la position (x, y) avec les paramètres width et height fournis.

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

Dessine une image pixelisée à l'emplacement (x, y) en copiant une partie de l'pixmap fournie dans le périphérique de dessin.

(x, y) spécifie le point d'angle supérieur gauche du périphérique de dessin sur lequel le dessin doit être effectué. (sx, sy) spécifie le point d'angle supérieur gauche de l'image pixmap à dessiner. La valeur par défaut est (0, 0).

(sw, sh) spécifie la taille de la carte de pixels sur laquelle le dessin doit être effectué. La valeur par défaut, (0, 0) (et les valeurs négatives), correspond à la zone allant jusqu’au coin inférieur droit de la carte de pixels.

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

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

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

Cette fonction sert à dessiner pixmap, ou un sous-rectangle de pixmap, à plusieurs emplacements avec des échelles, des rotations et des opacités différentes. 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 transmettre des indications de dessin.

Cette fonction est potentiellement plus rapide que plusieurs appels à ` drawPixmap()`, car le moteur peut optimiser les changements d’état.

Voir également QPainter::PixmapFragment et QPainter::PixmapFragmentHint.

void QPainter::drawPoint(const QPointF &position)

Trace un point unique aux coordonnées position, en utilisant la couleur actuelle du stylo.

Voir aussi Système de coordonnées.

void QPainter::drawPoint(const QPoint &position)

Dessine un point unique à l'position indiquée en utilisant la couleur du stylo actuel.

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

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

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

Dessine les premiers points de l'pointCount s du tableau points en utilisant la couleur du stylo actuel.

Voir aussi Système de coordonnées.

void QPainter::drawPoints(const QPolygon &points)

Trace les points du vecteur points.

void QPainter::drawPoints(const QPolygonF &points)

Trace les points du vecteur points.

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

Dessine les pointCount premiers points du tableau points en utilisant la couleur du stylo actuel.

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

Dessine le polygone défini par les premiers points d'pointCount s du tableau points à l'aide du stylo et du pinceau actuels.

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 relié au dernier point, et le polygone est rempli avec l'brush() actuel.

Si fillRule est Qt::WindingFill, le polygone est rempli à l’aide de l’algorithme de remplissage « winding ». Si fillRule est Qt::OddEvenFill, le polygone est rempli à l’aide de l’algorithme de remplissage « odd-even ». Voir Qt::FillRule pour une description plus détaillée de ces règles de remplissage.

Voir également drawConvexPolygon(), drawPolyline() et Système de coordonnées.

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

Dessine le polygone défini par l'points ion fournie en utilisant la règle de remplissage « fillRule ».

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

Dessine le polygone défini par l'points donnée en utilisant la règle de remplissage « fillRule ».

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

Dessine le polygone défini par les premiers points de l'pointCount s du tableau points.

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

Dessine la polyligne définie par les premiers points de la fonction « pointCount » dans « points » à l'aide du stylo actuel.

Notez que, contrairement à la fonction drawPolygon(), le dernier point n' est pas relié au premier, et la polyligne 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 également drawLines(), drawPolygon() et Système de coordonnées.

void QPainter::drawPolyline(const QPolygon &points)

Dessine la polyligne définie par l'points on fournie à l'aide du stylo actuel.

void QPainter::drawPolyline(const QPolygonF &points)

Dessine la polyligne définie par l'points on fournie à l'aide du stylo actuel.

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

Dessine la polyligne définie par les premiers points d'pointCount s dans « points » à l'aide du stylo actuel.

void QPainter::drawRect(const QRectF &rectangle)

Dessine l'rectangle e actuel avec le stylo et le pinceau actuels.

Un rectangle rempli a une taille de rectangle.size(). Un rectangle avec contour a une taille de rectangle.size() plus la largeur du stylo.

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

Voir également drawRects(), drawPolygon() et Système de coordonnées.

void QPainter::drawRect(const QRect &rectangle)

Dessine l'rectangle e actuelle avec le stylo et le pinceau sélectionnés.

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

Dessine un rectangle dont le coin supérieur gauche est situé aux coordonnées (x, y) et dont les paramètres « width » et « height » sont fournis.

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

Dessine la première rectCount de l'rectangles donné à l'aide du stylo et du pinceau actuels.

Voir aussi drawRect().

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

Dessine l'rectangles on fournie à l'aide du stylo et du pinceau actuels.

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

Dessine l'rectangles on indiquée à l'aide du stylo et du pinceau actuels.

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

Dessine le premier élément « rectCount » de l’ rectangles donné à l’aide du stylo et du pinceau actuels.

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

Dessine le rectangle rect spécifié avec des coins arrondis.

Les arguments xRadius et yRadius spécifient les rayons des ellipses définissant les coins du rectangle arrondi. Lorsque mode vaut Qt::RelativeSize, xRadius et yRadius sont spécifiés en pourcentage de la moitié de la largeur et de la hauteur du rectangle respectivement, et doivent être compris entre 0,0 et 100,0.

Un rectangle rempli a pour taille rect.size(). Un rectangle avec contour a pour taille rect.size() plus la largeur du stylo.

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

Voir également drawRect() et QPen.

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

Dessine le rectangle donné rect avec des coins arrondis.

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

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

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

Affiche l'staticText on fournie à l'topLeftPosition on indiquée.

Le texte sera dessiné en utilisant la police et la transformation définies sur le peintre. Si la police et/ou la transformation définies sur le peintre sont différentes de celles utilisées pour initialiser la mise en page de l'QStaticText, celle-ci devra alors être recalculée. Utilisez QStaticText::prepare() pour initialiser staticText avec la police et la transformation avec lesquelles il sera dessiné ultérieurement.

Si ` topLeftPosition ` n’est pas identique à ce qu’il était lors de l’initialisation de ` staticText ` ou lors de son dernier tracé, il y aura un léger surcoût lors du déplacement du texte vers sa nouvelle position.

Voir également QStaticText.

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

Affiche l'staticText à l'adresse topLeftPosition.

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

Dessine l'staticText e aux coordonnées left et top.

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

Dessine l'text on fournie selon le sens d'écriture actuellement défini, en commençant à l'position ion indiquée.

Cette fonction ne gère pas le caractère de nouvelle ligne (\n), car elle ne peut pas diviser le texte en plusieurs lignes et ne peut pas afficher ce caractère. Utilisez plutôt la surcharge de QPainter::drawText() qui prend un rectangle si vous souhaitez dessiner plusieurs lignes de texte avec le caractère de nouvelle ligne, ou si vous souhaitez que le texte soit renvoyé à la ligne.

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

Voir également setFont() et setPen().

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

Dessine l'text on fournie selon le sens d'écriture actuellement défini, en commençant à l'position ion indiquée.

Par défaut, la fonction ` QPainter ` affiche le texte avec lissage.

Voir également setFont() et setPen().

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

Dessine l'text spécifié dans l'rectangle, en utilisant l'option pour contrôler son positionnement, sa direction et son orientation. Les options fournies dans option remplacent celles définies sur l'objet QPainter lui-même.

Par défaut, QPainter affiche le texte avec lissage des contours.

Voir également setFont() et setPen().

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

Dessine l'text on fournie à la position (x, y), en utilisant la direction du texte actuellement définie par le peintre.

Par défaut, la fonction ` QPainter ` affiche le texte avec lissage.

Voir également setFont() et setPen().

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

Dessine l'text donné à l'intérieur de l'rectangle fournie, conformément à l'flags spécifiée.

L'boundingRect (si elle n'est pas nulle) définit les dimensions que doit avoir le rectangle de délimitation pour englober l'intégralité du texte. Par exemple, dans l'image suivante, la ligne pointillée représente l'boundingRect telle que calculée par la fonction, et la ligne en pointillés représente l'rectangle:

QPainter painter(this); QFont font = painter.font(); font.setPixelSize(48); painter.setFont(font); const QRect rectangle = QRect(0, 0, 100, 50); QRect boundingRect; painter.drawText(rectangle, 0, tr("Hello"), &boundingRect); QPen pen = painter.pen(); pen.setStyle(Qt::DotLine); painter.setPen(pen); painter.drawRect(boundingRect.adjusted(0, 0, -pen.width(), -pen.width())); pen.setStyle(Qt::DashLine); painter.setPen(pen); painter.drawRect(rectangle.adjusted(0, 0, -pen.width(), -pen.width()));

Par défaut, QPainter affiche le texte avec lissage.

Voir également setFont() et setPen().

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

Dessine l'text donné à l'intérieur de l'rectangle fourni. L'rectangle, associé à l'alignement flags, définit les ancrages de l'text.

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

L’ boundingRect (s’il n’est pas nul) définit les limites du rectangle de délimitation nécessaire pour englober l’intégralité du texte. Par exemple, dans l’image suivante, la ligne pointillée représente l’ boundingRect telle qu’elle est calculée par la fonction, et la ligne en pointillés représente l’ rectangle:

QPainter painter(this); QFont font = painter.font(); font.setPixelSize(48); painter.setFont(font); const QRect rectangle = QRect(0, 0, 100, 50); QRect boundingRect; painter.drawText(rectangle, 0, tr("Hello"), &boundingRect); QPen pen = painter.pen(); pen.setStyle(Qt::DotLine); painter.setPen(pen); painter.drawRect(boundingRect.adjusted(0, 0, -pen.width(), -pen.width())); pen.setStyle(Qt::DashLine); painter.setPen(pen); painter.drawRect(rectangle.adjusted(0, 0, -pen.width(), -pen.width()));

L’argument ` flags ` est un OU binaire des indicateurs suivants :

• Qt::AlignLeft
• Qt::AlignRight
• Qt::AlignHCenter
• Qt::AlignJustify
• Qt::AlignTop
• Qt::AlignBottom
• Qt::AlignVCenter
• Qt::AlignCenter
• Qt::TextDontClip
• Qt::TextSingleLine
• Qt::TextExpandTabs
• Qt::TextShowMnemonic
• Qt::TextWordWrap
• Qt::TextIncludeTrailingSpaces

Par défaut, QPainter affiche le texte avec lissage des contours.

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

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

Dessine l'text donné à l'intérieur du rectangle dont les coordonnées d'origine sont (x, y), width et height.

L’ boundingRect (s’il n’est pas nul) définit les dimensions que doit avoir le rectangle de délimitation pour englober l’intégralité du texte. Par exemple, dans l’image suivante, la ligne pointillée représente boundingRect tel qu’il est calculé par la fonction, et la ligne en pointillés représente le rectangle défini par x, y, width et height:

QPainter painter(this); QFont font = painter.font(); font.setPixelSize(48); painter.setFont(font); const QRect rectangle = QRect(0, 0, 100, 50); QRect boundingRect; painter.drawText(rectangle, 0, tr("Hello"), &boundingRect); QPen pen = painter.pen(); pen.setStyle(Qt::DotLine); painter.setPen(pen); painter.drawRect(boundingRect.adjusted(0, 0, -pen.width(), -pen.width())); pen.setStyle(Qt::DashLine); painter.setPen(pen); painter.drawRect(rectangle.adjusted(0, 0, -pen.width(), -pen.width()));

L'argument ` flags ` est un OU binaire des indicateurs suivants :

• Qt::AlignLeft
• Qt::AlignRight
• Qt::AlignHCenter
• Qt::AlignJustify
• Qt::AlignTop
• Qt::AlignBottom
• Qt::AlignVCenter
• Qt::AlignCenter
• Qt::TextSingleLine
• Qt::TextExpandTabs
• Qt::TextShowMnemonic
• Qt::TextWordWrap

Par défaut, QPainter dessine le texte avec lissage.

Voir également Qt::AlignmentFlag, Qt::TextFlag, setFont() et setPen().

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

Dessine une image en mosaïque ( pixmap) à l'intérieur de l'rectangle spécifiée, dont l'origine se trouve au point position indiqué.

L'appel à drawTiledPixmap() revient à appeler plusieurs fois drawPixmap() pour remplir (mosaïquer) une zone avec une image pixmap, mais peut s'avérer bien plus efficace selon le système de fenêtrage sous-jacent.

La fonction drawTiledPixmap() produira le même motif de mosaïque sur les écrans à haute résolution (avec devicePixelRatio > 1) que sur les écrans à résolution normale. Définissez la valeur devicePixelRatio de la fonction pixmap pour contrôler la taille des tuiles. Par exemple, en la définissant sur 2, vous divisez par deux la largeur et la hauteur des tuiles (sur les écrans 1x et 2x), et obtenez un rendu haute résolution sur les écrans 2x.

Le décalage de l’ position est exprimé en pixels indépendants du périphérique par rapport au coin supérieur gauche de l’ rectangle. La propriété position peut être utilisée pour aligner le motif répétitif à l’intérieur de l’ rectangle.

Voir également drawPixmap().

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

Dessine un pixmap en mosaïque, à l'intérieur de l'rectangle donné, dont l'origine est située au position donné.

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

Dessine une pixmap en mosaïque dans le rectangle spécifié.

(x, y) spécifie le point supérieur gauche du périphérique de dessin sur lequel l'image doit être dessinée ; avec les paramètres width et height.

(sx, sy) spécifie l’origine à l’intérieur du rectangle spécifié où la carte de pixels sera dessinée. La position de l’origine est spécifiée en pixels indépendants du périphérique par rapport à (x, y). La valeur par défaut est (0, 0).

bool QPainter::end()

Mette fin au processus de dessin. Toutes les ressources utilisées pendant le dessin sont libérées. Vous n'avez normalement pas besoin d'appeler cette méthode, car elle est appelée par le destructeur.

Renvoie ` true ` si le peintre n'est plus actif ; sinon, renvoie ` false`.

Voir également begin() et isActive().

void QPainter::endNativePainting()

Rétablit l'état du « painter » après l'exécution manuelle de commandes de dessin natives. Permet au « painter » de rétablir tout état natif dont il dépend avant d'appeler d'autres commandes de dessin.

Voir aussi beginNativePainting().

void QPainter::eraseRect(const QRectF &rectangle)

Efface la zone située à l'intérieur de l'rectangle. Équivaut à l'appel de

fillRect(rectangle, background());

Voir aussi fillRect().

void QPainter::eraseRect(const QRect &rectangle)

Efface la zone située à l'intérieur de l'rectangle.

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

Efface la zone située à l'intérieur du rectangle dont les coins sont les points (x, y), en utilisant les paramètres width et height fournis.

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

Remplit l'path spécifiée à l'aide de l'brush fournie. Le contour n'est pas tracé.

Vous pouvez également spécifier un QColor à la place d’un QBrush; le constructeur QBrush (qui prend un argument QColor ) créera automatiquement un pinceau à motif plein.

Voir également drawPath().

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

Remplit l'rectangle on fournie avec l'brush on spécifiée.

Vous pouvez également spécifier un « QColor » à la place d’un « QBrush » ; le constructeur « QBrush » (qui prend un argument « QColor ») créera automatiquement un pinceau à motif uni.

Voir également drawRect().

void QPainter::fillRect(const QRect &rectangle, QGradient::Preset preset)

Remplit l'rectangle on fournie avec le dégradé spécifié preset.

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

Remplit l'rectangle on indiquée avec le pinceau style spécifié.

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

Remplit l'rectangle on fournie avec l'color on spécifiée.

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

Remplit l'rectangle on fournie avec l'brush on spécifiée.

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

Remplit l'rectangle on fournie avec l'color on spécifiée.

void QPainter::fillRect(const QRectF &rectangle, QGradient::Preset preset)

Remplit l’ rectangle on fournie avec le dégradé spécifié preset.

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

Remplit l'rectangle on indiquée avec le pinceau style spécifié.

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

Remplit l'rectangle on fournie avec l'color on spécifiée.

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

Remplit l'rectangle on fournie avec l'color on spécifiée.

void QPainter::fillRect(int x, int y, int width, int height, QGradient::Preset preset)

Remplit le rectangle dont les coins de départ sont (x, y) avec les valeurs données width et height, en utilisant le dégradé donné preset.

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

Remplit le rectangle dont les coins de départ sont (x, y) avec les valeurs width et height fournies, en utilisant le pinceau style spécifié.

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

Remplit le rectangle dont les coins sont situés en (x, y) avec les valeurs données width et height, en utilisant la fonction donnée color.

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

Remplit le rectangle dont les coins sont situés en (x, y) avec les valeurs données width et height, en utilisant la fonction donnée brush.

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

Remplit le rectangle dont les coins sont situés aux coordonnées (x, y) avec les valeurs width et height, en utilisant la fonction color.

const QFont &QPainter::font() const

Renvoie la police actuellement définie pour l'affichage du texte.

Voir également setFont(), drawText() et Settings.

QFontInfo QPainter::fontInfo() const

Renvoie les informations relatives à la police du « painter » si celui-ci est actif. Dans le cas contraire, la valeur renvoyée n'est pas définie.

Voir également font(), isActive() et Settings.

QFontMetrics QPainter::fontMetrics() const

Renvoie les métriques de police pour le peintre si celui-ci est actif. Sinon, la valeur renvoyée n'est pas définie.

Voir également font(), isActive() et Settings.

bool QPainter::hasClipping() const

Renvoie « true » si le découpage a été activé ; sinon, renvoie « false ».

Voir également setClipping() et Clipping.

bool QPainter::isActive() const

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

Voir également ` begin()` et ` QPaintDevice::paintingActive()`.

Qt::LayoutDirection QPainter::layoutDirection() const

Renvoie le sens de mise en page utilisé par le moteur de rendu lors de l'affichage du texte.

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

qreal QPainter::opacity() const

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

Voir aussi setOpacity().

QPaintEngine *QPainter::paintEngine() const

Renvoie le moteur de peinture sur lequel le « painter » opère actuellement si celui-ci est actif ; sinon, renvoie 0.

Voir également isActive().

const QPen &QPainter::pen() const

Renvoie le stylo actuellement utilisé par le peintre.

Voir également setPen() et Settings.

QPainter::RenderHints QPainter::renderHints() const

Renvoie un indicateur précisant les consignes de rendu définies pour ce « painter ».

Voir également setRenderHints(), testRenderHint() et Rendering Quality.

void QPainter::resetTransform()

Réinitialise toutes les transformations effectuées à l'aide des fonctions translate(), scale(), shear(), rotate(), setWorldTransform(), setViewport() et setWindow().

Voir également Coordinate Transformations.

void QPainter::restore()

Restaure l'état actuel du « painter » (retire un état enregistré de la pile).

Voir aussi save().

void QPainter::rotate(qreal angle)

Fait pivoter le système de coordonnées dans le sens des aiguilles d'une montre. Le paramètre « angle » est exprimé en degrés.

Voir également setWorldTransform() et Coordinate Transformations.

void QPainter::save()

Enregistre l'état actuel du « painter » (place l'état dans une pile). Un appel à save() doit être suivi d'un appel correspondant à restore(); la fonction end() désemballe la pile.

Voir également restore().

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

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

Voir également setWorldTransform() et Coordinate Transformations.

void QPainter::setBackground(const QBrush &brush)

Définit le pinceau d'arrière-plan de l'outil « peintre » sur l'brush spécifiée.

Le pinceau d’arrière-plan est celui qui est utilisé pour remplir les zones lors du tracé de texte opaque, de lignes pointillées et d’images bitmap. Le pinceau d’arrière-plan n’a aucun effet en mode d’arrière-plan transparent (qui est le mode par défaut).

Voir également background(), setBackgroundMode() et Settings.

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

Définit le mode d'arrière-plan de l'outil de dessin sur la valeur indiquée mode

Qt::TransparentMode (valeur par défaut) dessine des lignes pointillées et du texte sans définir les pixels d'arrière-plan. La fonction Qt::OpaqueMode remplit ces espaces avec la couleur d'arrière-plan actuelle.

Notez que pour dessiner un bitmap ou un pixmap de manière transparente, vous devez utiliser ` QPixmap::setMask()`.

Voir également backgroundMode(), setBackground() et Settings.

void QPainter::setBrush(const QBrush &brush)

Définit le pinceau du peintre selon l'brush on indiquée.

Le pinceau du peintre définit la manière dont les formes sont remplies.

Voir également brush() et Settings.

[since 6.11] void QPainter::setBrush(QBrush &&brush)

Cette fonction a été introduite dans Qt 6.11.

[since 6.9] void QPainter::setBrush(QColor color)

Définit le pinceau du peintre comme un pinceau plein avec l'color spécifiée.

Cette fonction a été introduite dans Qt 6.9.

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

Définit la couleur du pinceau du peintre sur le noir et l'style spécifiée.

[since 6.9] void QPainter::setBrush(Qt::GlobalColor color)

Définit le pinceau du peintre comme un pinceau plein avec l'color spécifiée.

Cette fonction a été introduite dans Qt 6.9.

void QPainter::setBrushOrigin(const QPointF &position)

Définit l'origine du pinceau sur position.

L'origine du pinceau spécifie la coordonnée (0, 0) du pinceau du peintre.

Notez que si la fonction brushOrigin() était nécessaire pour adopter l’arrière-plan du parent d’un widget dans Qt 3, ce n’est plus le cas depuis Qt 4, car le peintre de Qt 4 ne dessine pas l’arrière-plan à moins que vous ne le lui demandiez explicitement en définissant la propriété autoFillBackground du widget sur true.

Voir également brushOrigin() et Settings.

void QPainter::setBrushOrigin(const QPoint &position)

Définit l'origine du pinceau à l'position indiquée.

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

Définit l'origine du pinceau sur le point (x, y).

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

Active le découpage et définit le chemin de découpage pour l'outil de peinture sur l'path, avec l'operation de découpage.

Notez que le tracé de découpe est spécifié en coordonnées logiques (du peintre).

Voir également clipPath(), clipRegion() et Clipping.

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

Active le découpage et définit la zone de découpage selon l'rectangle s fournies, en utilisant l'operation de découpage indiquée. Par défaut, cette opération remplace le rectangle de découpage actuel.

Notez que le rectangle de découpe est spécifié en coordonnées logiques (du peintre).

Voir également clipRegion(), setClipping() et Clipping.

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

Active le découpage et définit la zone de découpage comme étant le rectangle dont les coordonnées de départ sont (x, y), avec les paramètres width et height spécifiés.

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

Active le clipping et définit la zone de clipping sur l'rectangle spécifiée à l'aide de l'operation de clipping indiquée.

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

Définit la région de découpage selon l'region donnée à l'aide de l'operation de découpage spécifiée. Par défaut, l'opération de découpage consiste à remplacer la région de découpage actuelle.

Notez que la région de découpage est exprimée en coordonnées logiques.

Voir également clipRegion(), setClipRect() et Clipping.

void QPainter::setClipping(bool enable)

Active le clipping si enable a la valeur « true », ou le désactive si enable a la valeur « false ».

Voir également hasClipping() et Clipping.

void QPainter::setCompositionMode(QPainter::CompositionMode mode)

Définit le mode de composition sur l'mode spécifiée.

Voir également compositionMode().

void QPainter::setFont(const QFont &font)

Définit la police du peintre sur la valeur indiquée par ` font`.

Cette police est utilisée par les fonctions drawText() suivantes. La couleur du texte est identique à celle du stylo.

Si vous définissez une police qui n’est pas disponible, Qt trouve une police similaire. La fonction ` font()` renvoie la police que vous avez définie à l’aide de `setFont()`, tandis que ` fontInfo()` renvoie la police effectivement utilisée (qui peut être la même).

Voir également font(), drawText() et Settings.

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

Définit la direction de mise en page utilisée par le moteur de dessin lors de l'affichage du texte, en indiquant l'direction.

La valeur par défaut est ` Qt::LayoutDirectionAuto`, ce qui déterminera implicitement la direction à partir du texte dessiné.

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

void QPainter::setOpacity(qreal opacity)

Définit l'opacité de l'outil de dessin sur opacity. La valeur doit être comprise entre 0,0 et 1,0, où 0,0 correspond à une transparence totale et 1,0 à une opacité totale.

L'opacité définie pour l'outil de dessin s'applique séparément à chaque opération de dessin. Le remplissage d'une forme et le tracé de son contour sont considérés comme des opérations de dessin distinctes.

Voir également opacity().

void QPainter::setPen(const QPen &pen)

Définit le stylo du peintre sur l'pen spécifiée.

L'pen définit la manière de dessiner les lignes et les contours, ainsi que la couleur du texte.

Voir aussi pen() et Settings.

[since 6.11] void QPainter::setPen(QPen &&pen)

Cette fonction a été introduite dans Qt 6.11.

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

Définit le stylo du peintre avec l'style, une largeur de 1 et la couleur noire.

void QPainter::setPen(const QColor &color)

Définit le stylo du peintre avec le style « Qt::SolidLine », une largeur de 1 et la couleur spécifiée « color ».

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

Définit l'hint de rendu indiquée sur le « painter » si la valeur de « on » est « true » ; sinon, efface cette .

Voir également setRenderHints(), renderHints() et Rendering Quality.

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

Définit l'hints de rendu spécifiée sur le « painter » si la valeur de « on » est « true » ; sinon, efface les indications de rendu.

Voir également setRenderHint(), renderHints() et Rendering Quality.

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

Définit la matrice de transformation globale. Si la valeur de combine est « true », l'transform spécifiée est combinée avec la matrice actuelle ; dans le cas contraire, elle remplace la matrice actuelle.

Voir également transform() et setWorldTransform().

void QPainter::setViewTransformEnabled(bool enable)

Active les transformations de vue si la valeur de ` enable ` est `true`, ou désactive les transformations de vue si la valeur de ` enable ` est `false`.

Voir également viewTransformEnabled() et Conversion fenêtre-fenêtre de visualisation.

void QPainter::setViewport(const QRect &rectangle)

Définit le rectangle de la fenêtre d'affichage du peintre sur l'rectangle donné et active les transformations de vue.

Le rectangle de la fenêtre d'affichage fait partie de la transformation de la vue. La fenêtre d'affichage définit le système de coordonnées de l'appareil. Son équivalent, la fonction ` window()` (), définit le système de coordonnées logiques.

Le rectangle de la fenêtre d’affichage par défaut est identique à celui du périphérique.

Voir également ` viewport()`, ` viewTransformEnabled()` et Conversion fenêtre-fenêtre de visualisation.

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

Définit le rectangle de la fenêtre d'affichage du peintre comme étant le rectangle dont les coordonnées de départ sont (x, y), avec les paramètres width et height fournis.

void QPainter::setWindow(const QRect &rectangle)

Définit la fenêtre du peintre sur l'rectangle spécifiée et active les transformations de vue.

Le rectangle de la fenêtre fait partie de la transformation de la vue. La fenêtre définit le système de coordonnées logique. Sa fonction jumelle, ` viewport()`, définit le système de coordonnées du périphérique.

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

Voir également ` window()`, ` viewTransformEnabled()` et Conversion fenêtre-fenêtre de visualisation.

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

Définit la fenêtre du peintre sur le rectangle dont les coordonnées de départ sont (x, y) et dont les coordonnées de fin sont width et height.

void QPainter::setWorldMatrixEnabled(bool enable)

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

Voir également worldMatrixEnabled(), worldTransform() et Coordinate Transformations.

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

Définit la matrice de transformation globale. Si la valeur de « combine » est « true », l'matrix e spécifiée est combinée avec la matrice actuelle ; dans le cas contraire, elle remplace la matrice actuelle.

Voir également worldTransform(), transform() et setTransform().

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

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

Voir également setWorldTransform() et Coordinate Transformations.

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

Dessine le contour (tracés) du chemin path à l'aide du stylo spécifié par pen

Voir également fillPath() et Drawing.

bool QPainter::testRenderHint(QPainter::RenderHint hint) const

Renvoie « true » si « hint » est défini ; sinon, renvoie « false ».

Voir également renderHints() et setRenderHint().

const QTransform &QPainter::transform() const

Alias de la fonction worldTransform(). Renvoie la matrice de transformation mondiale.

Voir également setTransform() et worldTransform().

void QPainter::translate(const QPointF &offset)

Translate le système de coordonnées selon l'offset e spécifiée ; c'est-à-dire que l'offset e spécifiée est ajoutée aux points.

Voir également setWorldTransform() et Coordinate Transformations.

void QPainter::translate(const QPoint &offset)

Translate le système de coordonnées selon l'offset e indiquée.

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

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

bool QPainter::viewTransformEnabled() const

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

Voir également setViewTransformEnabled() et worldTransform().

QRect QPainter::viewport() const

Renvoie le rectangle de la fenêtre d'affichage.

Voir également 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 transformation du monde est activée ; sinon, renvoie « false ».

Voir également setWorldMatrixEnabled(), worldTransform() et Système de coordonnées.

const QTransform &QPainter::worldTransform() const

Renvoie la matrice de transformation mondiale.

Voir aussi setWorldTransform().