QPainter Class

Documentation des fonctions membres

QPainter::QPainter()

Construit un peintre.

Voir aussi begin() et end().

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

Construit un peintre qui commence immédiatement à peindre la peinture device.

Ce constructeur est pratique pour les peintres de courte durée, par exemple dans un QWidget::paintEvent() et ne doit être utilisé qu'une seule 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(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 lorsque l'initialisation du peintre a échoué, vous devriez plutôt utiliser begin() et end() pour peindre sur des périphériques externes, par exemple des imprimantes.

Voir également begin() et end().

[noexcept] QPainter::~QPainter()

Détruit le peintre.

const QBrush &QPainter::background() const

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

Voir aussi setBackground() et Settings.

Qt::BGMode QPainter::backgroundMode() const

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

Voir aussi setBackgroundMode() et Settings.

bool QPainter::begin(QPaintDevice *device)

Commence à peindre la peinture device et renvoie true en cas de succès ; sinon, renvoie false.

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

Les erreurs qui peuvent se produire sont des problèmes graves, comme 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 au lieu de begin(), et que end() est automatiquement exécuté lors de la destruction.

Voir aussi end() et QPainter().

void QPainter::beginNativePainting()

Rince le pipeline de peinture et prépare l'utilisateur à émettre des commandes directement au contexte graphique sous-jacent. Doit être suivi d'un appel à endNativePainting().

Notez que seuls les états modifiés par le moteur de peinture sous-jacent seront réinitialisés à leurs états par défaut respectifs. Les états que nous réinitialisons peuvent changer 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 pochoir 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 claire sont réinitialisés à leurs valeurs par défaut
• le masque de pochoir, l'opération de pochoir et la fonction de pochoir sont réinitialisés à leurs valeurs par défaut
• la couleur actuelle est réinitialisée au 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é à l'état par défaut par endNativePainting(). Voici un exemple qui montre le mélange des commandes de peinture et des 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 aussi endNativePainting().

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

Renvoie le rectangle de délimitation de text tel qu'il apparaîtra lorsqu'il sera dessiné à l'intérieur de rectangle avec flags à l'aide de font() ; c'est-à-dire que la fonction vous indique où la fonction drawText() dessinera lorsqu'elle recevra les mêmes arguments.

Si l'adresse text ne tient pas dans l'adresse rectangle avec l'adresse flags, la fonction renvoie le rectangle requis.

L'argument flags est un OU binaire des drapeaux 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 drapeaux d'alignement horizontal ou plusieurs drapeaux d'alignement vertical 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)

Renvoie le rectangle de délimitation de text tel qu'il apparaîtra lorsqu'il sera dessiné à l'intérieur de rectangle avec flags en utilisant font().

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

Au lieu de spécifier les drapeaux comme un OU bit à bit de Qt::AlignmentFlag et Qt::TextFlag, cette fonction surchargée prend un argument option. La classe QTextOption fournit une description des propriétés générales du texte riche.

Voir aussi QTextOption.

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

Renvoie le rectangle de délimitation de text tel qu'il apparaîtra lorsqu'il sera dessiné à l'intérieur du rectangle commençant au point (x, y) avec la largeur w et la hauteur h.

const QBrush &QPainter::brush() const

Renvoie la brosse actuelle du peintre.

Voir aussi QPainter::setBrush() et Settings.

QPoint QPainter::brushOrigin() const

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

Voir aussi setBrushOrigin() et Settings.

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

Renvoie l'origine actuelle de la brosse.

Cette fonction a été introduite dans Qt 6.11.

Voir aussi setBrushOrigin() et Settings.

QRectF QPainter::clipBoundingRect() const

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

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

Voir aussi setClipRect(), setClipPath(), et setClipRegion().

QPainterPath QPainter::clipPath() const

Renvoie le chemin du clip actuel en coordonnées logiques.

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

QRegion QPainter::clipRegion() const

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

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

QTransform QPainter::combinedTransform() const

Renvoie la matrice de transformation combinant la fenêtre/port de vue actuelle et la transformation du monde.

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

QPainter::CompositionMode QPainter::compositionMode() const

Renvoie le mode de composition actuel.

Voir aussi CompositionMode et setCompositionMode().

QPaintDevice *QPainter::device() const

Renvoie le dispositif de peinture sur lequel ce peintre est en train de peindre, ou nullptr si le peintre n'est pas actif.

Voir aussi isActive().

const QTransform &QPainter::deviceTransform() const

Renvoie la matrice qui transforme les coordonnées logiques en coordonnées du périphérique de peinture dépendant de la plate-forme.

Cette fonction n' est nécessaire que lorsque l'on utilise les commandes de peinture de la plate-forme sur la poignée dépendante de la plate-forme (Qt::HANDLE), et que la plate-forme n'effectue pas les transformations de manière native.

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

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

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

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

Les angles startAngle et spanAngle doivent être spécifiés en 1/16e de degré, c'est-à-dire qu'un cercle complet équivaut à 5760 (16 * 360). Les valeurs positives des angles signifient le sens inverse des aiguilles d'une montre, tandis que les valeurs négatives signifient le sens des aiguilles d'une montre. Le zéro degré se trouve à la position 3 heures.

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 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 commençant à (x, y) avec les éléments spécifiés width et height, et les éléments donnés startAngle et spanAngle.

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

Dessine la corde définie par les données rectangle, startAngle et spanAngle. La corde est remplie avec la valeur actuelle de brush().

Les angles startAngle et spanAngle doivent être spécifiés en 1/16e de degré, c'est-à-dire qu'un cercle complet équivaut à 5760 (16 * 360). Des valeurs positives pour les angles signifient un sens contraire aux aiguilles d'une montre, tandis que des valeurs négatives signifient le sens des aiguilles d'une montre. Le zéro degré se trouve à la position 3 heures.

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 l'accord défini par les données rectangle, startAngle et spanAngle.

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

Dessine l'accord défini par le rectangle commençant à (x, y) avec les éléments spécifiés width et height, et les éléments donnés startAngle et spanAngle.

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

Dessine le polygone convexe défini par les premiers pointCount points du tableau points en utilisant le 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 connecté au dernier point, et le polygone est rempli avec le 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, les résultats sont indéfinis.

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

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

void QPainter::drawConvexPolygon(const QPolygon &polygon)

Dessine le polygone convexe défini par polygon en utilisant le stylo et le pinceau actuels.

void QPainter::drawConvexPolygon(const QPolygonF &polygon)

Dessine le polygone convexe défini par polygon en utilisant le stylo et le pinceau actuels.

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

Dessine le polygone convexe défini par les premiers pointCount points du tableau points en utilisant le stylo actuel.

void QPainter::drawEllipse(const QRectF &rectangle)

Dessine l'ellipse définie par la donnée rectangle.

Une ellipse remplie a une taille de rectangle.size(). Une ellipse tracée 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'adresse rectangle.

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

Dessine l'ellipse positionnée à center avec les rayons rx et ry.

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

Dessine l'ellipse positionnée à center avec les rayons rx et ry.

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

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

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

Dessine les glyphes représentés par glyphs à position. Le site position indique le bord de la ligne de base pour la chaîne de glyphes. Les glyphes seront extraits de la police sélectionnée sur glyphs et à des décalages donnés par les positions dans glyphs.

Voir aussi 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ée image dans le rectangle target du dispositif de peinture.

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 flags pour spécifier comment vous préférez que cela se produise.

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)

Dessine l'image donnée image à l'endroit donné point.

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

Dessine l'image donnée image à l'endroit donné point.

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

Dessine l'image image dans l'image rectangle.

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

Dessine l'image image dans l'image rectangle.

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

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

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

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

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ée image dans le rectangle target du dispositif de peinture.

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 à (x, y) en copiant une partie de image dans le dispositif de peinture.

(x, y) indique le point supérieur gauche du dispositif de peinture sur lequel le dessin doit être effectué. (sx, sy) indique le point supérieur gauche de 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 négative), signifie que l'image doit être dessinée jusqu'en bas à droite.

void QPainter::drawLine(const QLineF &line)

Dessine une ligne définie par line.

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

Voir aussi 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 de p1 à p2.

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

Trace une ligne de p1 à p2.

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

Dessine une ligne de (x1, y1) à (x2, y2).

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

Dessine les premières lignes de lineCount dans le tableau lines en utilisant le stylo actuel.

Voir aussi drawLine() et drawPolyline().

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

Dessine l'ensemble des lignes définies par la liste lines en utilisant le stylo et le pinceau actuels.

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

Dessine l'ensemble des lignes définies par la liste lines en utilisant le stylo et le pinceau actuels.

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

Dessine une ligne pour chaque paire de points dans le vecteur pointPairs en utilisant le stylo actuel.

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

Dessine une ligne pour chaque paire de points dans le vecteur pointPairs en utilisant le stylo actuel. S'il y a un nombre impair de points dans le tableau, le dernier point sera ignoré.

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

Dessine les premières lineCount lignes du tableau lines en utilisant le stylo actuel.

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

Dessine les premières lineCount lignes du tableau pointPairs en utilisant le stylo actuel.

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

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

void QPainter::drawPath(const QPainterPath &path)

Dessine le peintre donné path 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 aussi l'exemple Chemins de peinture et l'exemple Déformation vectorielle.

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

Rejoue la commande picture donnée à la commande point donnée.

La classe QPicture est un dispositif de peinture qui enregistre et reproduit les commandes QPainter. Une image sérialise les commandes du peintre vers un périphérique IO dans un format indépendant de la plateforme. Tout ce qui peut être peint sur un widget ou une pixmap 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)

Rejoue l'adresse picture donnée à l'adresse point donnée.

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

Dessine le site picture au point (x, y).

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

Dessine une tarte définie par les données rectangle, startAngle et spanAngle.

La tarte est remplie avec la valeur actuelle de brush().

Les angles startAngle et spanAngle doivent être spécifiés en 1/16e de degré, c'est-à-dire qu'un cercle complet équivaut à 5760 (16 * 360). Des valeurs positives pour les angles signifient un sens contraire aux aiguilles d'une montre, tandis que des valeurs négatives signifient le sens des aiguilles d'une montre. Le zéro degré se trouve à la position 3 heures.

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 une tarte définie par les données rectangle, startAngle et et spanAngle.

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

Dessine la tarte définie par le rectangle commençant à (x, y) avec les éléments spécifiés width et height, et les éléments donnés startAngle et spanAngle.

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

Dessine la partie rectangulaire source de l'adresse pixmap donnée dans l'adresse target donnée dans le dispositif de peinture.

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 qui sont "définis" à l'aide de la couleur du stylo. Si backgroundMode est Qt::OpaqueMode, les bits "non définis" sont dessinés en utilisant la couleur de la brosse d'arrière-plan ; si backgroundMode est Qt::TransparentMode, les bits "non définis" sont transparents. Le dessin de bitmaps avec des couleurs de dégradé ou de texture n'est pas pris en charge.

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

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

Dessine l'image pixmap avec son origine à l'adresse point.

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

Dessine l'image pixmap avec son origine à l'adresse point.

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

Dessine l'image pixmap dans l'image rectangle.

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

Dessine la portion rectangulaire source de l'image donnée pixmap avec son origine à l'image donnée point.

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

Dessine la portion rectangulaire source de l'image donnée pixmap avec son origine à l'image donnée point.

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

Dessine la partie rectangulaire source de l'adresse pixmap donnée dans l'adresse target donnée dans le dispositif de peinture.

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

Dessine le site pixmap à la position (x, y).

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

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

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

Dessine un pixmap à (x, y) en copiant une partie du fichier pixmap dans le périphérique de peinture.

(x, y) spécifie le point en haut à gauche du dispositif de peinture sur lequel le dessin doit être effectué. (sx, sy) indique le point supérieur gauche de pixmap qui doit être dessiné. La valeur par défaut est (0, 0).

(sw, sh) spécifie la taille de la pixmap qui doit être dessinée. La valeur par défaut, (0, 0) (et la valeur négative), signifie que le pixmap doit être dessiné jusqu'en bas à droite.

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 avec l'origine (sx, sy), la largeur sw et la hauteur sh, de l'image donnée pixmap, 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 est utilisée pour dessiner pixmap, ou un sous-rectangle de pixmap, à des positions multiples avec une échelle, une rotation et une opacité différentes. fragments est un tableau d'éléments fragmentCount spécifiant les paramètres utilisés pour dessiner chaque fragment de pixmap. Le paramètre hints peut être utilisé pour transmettre des indices de dessin.

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

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

void QPainter::drawPoint(const QPointF &position)

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

Voir aussi Système de coordonnées.

void QPainter::drawPoint(const QPoint &position)

Dessine un point unique à l'adresse position 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 pointCount points du tableau points en utilisant la couleur du stylo actuel.

Voir aussi Système de coordonnées.

void QPainter::drawPoints(const QPolygon &points)

Dessine les points du vecteur points.

void QPainter::drawPoints(const QPolygonF &points)

Dessine les points du vecteur points.

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

Dessine les premiers pointCount 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 pointCount points du tableau points en utilisant le stylo et le 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 connecté au dernier point, et le polygone est rempli avec la valeur courante brush().

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

Voir aussi 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'adresse points 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'adresse points 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 pointCount points du tableau points.

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

Dessine la polyligne définie par les premiers points pointCount dans points en utilisant le stylo actuel.

Notez que contrairement à la fonction drawPolygon(), le dernier point n' est pas connecté 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'adresse points en utilisant le stylo actuel.

void QPainter::drawPolyline(const QPolygonF &points)

Dessine la polyligne définie par l'adresse points en utilisant le stylo actuel.

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

Dessine la polyligne définie par les premiers pointCount points dans points en utilisant le stylo actuel.

void QPainter::drawRect(const QRectF &rectangle)

Dessine le site rectangle avec le stylo et le pinceau actuels.

Un rectangle rempli a une taille de rectangle.size(). Un rectangle tracé 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 aussi drawRects(), drawPolygon() et Système de coordonnées.

void QPainter::drawRect(const QRect &rectangle)

Dessine le site rectangle avec le stylo et le pinceau actuels.

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

Dessine un rectangle dont le coin supérieur gauche est situé à (x, y) et dont les coordonnées sont width et height.

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

Dessine le premier rectCount de l'adresse rectangles donnée en utilisant le stylo et le pinceau actuels.

Voir aussi drawRect().

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

Dessine le site rectangles en utilisant le stylo et le pinceau actuels.

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

Dessine le site rectangles en utilisant le stylo et le pinceau actuels.

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

Dessine le premier rectCount de l'adresse rectangles donnée en utilisant le stylo et le pinceau actuels.

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

Dessine le rectangle donné rect avec des coins arrondis.

Les arguments xRadius et yRadius spécifient les rayons des ellipses définissant les coins du rectangle arrondi. Lorsque mode est 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 une taille de rect.size(). Un rectangle tracé a une taille de 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 donné x, y, w, h avec des coins arrondis.

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

Dessine le texte donné staticText à l'endroit donné topLeftPosition.

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 QStaticText, la mise en page devra être recalculée. Utilisez QStaticText::prepare() pour initialiser staticText avec la police et la transformation avec lesquelles il sera dessiné par la suite.

Si topLeftPosition n'est pas identique à la police utilisée lors de l'initialisation de staticText ou lors de son dernier dessin, il y aura un léger surcoût lors de la translation du texte vers sa nouvelle position.

Voir aussi QStaticText.

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

Dessine le site staticText à l'adresse topLeftPosition.

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

Dessine le site staticText aux coordonnées left et top.

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

Dessine la page text avec la direction du texte actuellement définie, en commençant par la page position.

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 le caractère de nouvelle ligne. Utilisez la surcharge QPainter::drawText() qui prend un rectangle à la place si vous voulez dessiner plusieurs lignes de texte avec le caractère de nouvelle ligne, ou si vous voulez que le texte soit enveloppé.

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

Voir aussi setFont() et setPen().

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

Dessine le site text avec la direction du texte actuellement définie, en commençant par le site position.

Par défaut, QPainter dessine le texte en anti-crénelage.

Voir aussi setFont() et setPen().

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

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

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

Voir aussi setFont() et setPen().

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

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

Par défaut, QPainter dessine le texte en anti-crénelage.

Voir aussi setFont() et setPen().

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

Dessine le texte text à l'intérieur du texte rectangle en fonction de flags.

La valeur de boundingRect (si elle n'est pas nulle) correspond à ce que doit être le rectangle de délimitation pour englober l'ensemble du texte. Par exemple, dans l'image suivante, la ligne en pointillé représente boundingRect tel que calculé par la fonction, et la ligne en pointillé représente 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 dessine le texte en anti-crénelage.

Voir aussi setFont() et setPen().

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

Dessine l'image text à l'intérieur de l'image rectangle. L'adresse rectangle ainsi que l'alignement flags définissent les points d'ancrage de l'adresse text.

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

La valeur de boundingRect (si elle n'est pas nulle) correspond à ce que devrait être le rectangle de délimitation pour englober l'ensemble du texte. Par exemple, dans l'image suivante, la ligne en pointillé représente boundingRect tel que calculé par la fonction, et la ligne en pointillé représente 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 drapeaux 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 dessine le texte en anti-crénelage.

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 le texte text à l'intérieur du rectangle ayant pour origine (x, y), width et height.

La valeur de boundingRect (si elle n'est pas nulle) correspond à ce que devrait être le rectangle de délimitation pour englober l'ensemble du texte. Par exemple, dans l'image suivante, la ligne en pointillé représente boundingRect tel que calculé par la fonction, et la ligne en pointillé 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 bit à bit des drapeaux 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 anticrénelage.

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

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

Dessine une mosaïque pixmap, à l'intérieur de rectangle, avec son origine à position.

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

drawTiledPixmap() produira le même motif visuel de mosaïque sur les écrans à haute résolution (avec devicePixelRatio > 1), par rapport aux écrans à résolution normale. Définissez le devicePixelRatio sur le site pixmap pour contrôler la taille des tuiles. Par exemple, en le fixant à 2, vous divisez par deux la largeur et la hauteur de la tuile (sur les écrans 1x et 2x) et vous obtenez une sortie haute résolution sur les écrans 2x.

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

Voir aussi drawPixmap().

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

Dessine une tuile pixmap, à l'intérieur de la tuile rectangle, avec son origine à la tuile position.

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

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

(x, y) spécifie le point en haut à gauche du dispositif de peinture sur lequel le dessin doit être effectué ; avec les données width et height.

(sx, sy) spécifie l'origine à l'intérieur du rectangle spécifié où la pixmap sera dessinée. La position d'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()

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

Retourne true si le peintre n'est plus actif, sinon retourne false.

Voir aussi begin() et isActive().

void QPainter::endNativePainting()

Restaure le peintre après l'émission manuelle de commandes de peinture natives. Permet au peintre de restaurer tout état natif sur lequel il s'appuie avant d'appeler d'autres commandes de peinture.

Voir aussi beginNativePainting().

void QPainter::eraseRect(const QRectF &rectangle)

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

fillRect(rectangle, background());

Voir aussi fillRect().

void QPainter::eraseRect(const QRect &rectangle)

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

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

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

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

Remplit le site path en utilisant le site brush. Le contour n'est pas dessiné.

Vous pouvez également spécifier un QColor au lieu d'un QBrush; le constructeur QBrush (qui prend un argument QColor ) créera automatiquement une brosse à motif solide.

Voir aussi drawPath().

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

Remplit le site rectangle avec le site brush spécifié.

Vous pouvez également spécifier un QColor au lieu d'un QBrush; le constructeur QBrush (qui prend un argument QColor ) créera automatiquement une brosse à motif solide.

Voir aussi drawRect().

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

Remplit le site rectangle avec le gradient spécifié preset.

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

Remplit le site rectangle avec la brosse style spécifiée.

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

Remplit le site rectangle avec le site color spécifié.

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

Remplit le site rectangle avec le site brush spécifié.

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

Remplit le site rectangle avec le site color spécifié.

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

Remplit le site rectangle avec le gradient spécifié preset.

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

Remplit le site rectangle avec la brosse style spécifiée.

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

Remplit le site rectangle avec le site color spécifié.

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

Remplit le site rectangle avec le site color spécifié.

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

Remplit le rectangle commençant à (x, y) avec les données width et height, en utilisant le gradient donné preset.

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

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

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

Remplit le rectangle commençant à (x, y) avec les données width et height, en utilisant la donnée color.

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

Remplit le rectangle commençant à (x, y) avec les données width et height, en utilisant la donnée brush.

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

Remplit le rectangle commençant à (x, y) avec les données width et height, en utilisant la donnée color.

const QFont &QPainter::font() const

Renvoie la police actuellement utilisée pour dessiner le texte.

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

QFontInfo QPainter::fontInfo() const

Renvoie les informations de police pour le peintre si celui-ci 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 police pour le peintre si celui-ci est actif. Sinon, la valeur de retour est indéfinie.

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

bool QPainter::hasClipping() const

Renvoie true si l'écrêtage a été défini ; sinon, renvoie false.

Voir aussi setClipping() et Clipping.

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 mise en page utilisée par le peintre lorsqu'il dessine du texte.

Voir aussi 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 peintre est en train d'opérer si le peintre est actif, sinon 0.

Voir aussi isActive().

const QPen &QPainter::pen() const

Renvoie le stylo actuel du peintre.

Voir aussi setPen() et Settings.

QPainter::RenderHints QPainter::renderHints() const

Renvoie un drapeau qui spécifie les indices de rendu qui sont définis pour ce peintre.

Voir aussi setRenderHints(), testRenderHint(), et Rendering Quality.

void QPainter::resetTransform()

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

Voir aussi Coordinate Transformations.

void QPainter::restore()

Rétablit l'état actuel du peintre (retire un état sauvegardé 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()

Sauvegarde l'état actuel du peintre (pousse l'état sur une pile). Un save() doit être suivi d'un restore() correspondant ; la fonction end() déroule la pile.

Voir également restore().

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

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

Voir également setWorldTransform() et Coordinate Transformations.

void QPainter::setBackground(const QBrush &brush)

Définit la brosse d'arrière-plan du peintre à l'adresse brush.

La brosse d'arrière-plan est la brosse qui est remplie lorsque l'on dessine du texte opaque, des lignes pointillées et des images bitmap. La brosse 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 du peintre à la valeur donnée. mode

Qt::TransparentMode (par défaut) dessine des lignes et du texte en pointillés sans définir les pixels d'arrière-plan. 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 la brosse du peintre à l'adresse brush.

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 la brosse du peintre comme une brosse solide avec la valeur spécifiée color.

Cette fonction a été introduite dans Qt 6.9.

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

Fixe le pinceau du peintre à la couleur noire et à la valeur spécifiée style.

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

Définit la brosse du peintre comme une brosse solide avec la valeur spécifiée color.

Cette fonction a été introduite dans Qt 6.9.

void QPainter::setBrushOrigin(const QPointF &position)

Fixe l'origine du pinceau à position.

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

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

Voir aussi brushOrigin() et Settings.

void QPainter::setBrushOrigin(const QPoint &position)

Fixe l'origine du pinceau à l'adresse position.

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

Fixe l'origine du pinceau au point (x, y).

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

Active l'écrêtage et définit le chemin d'écrêtage pour le peintre à l'adresse path, avec l'écrêtage operation.

Notez que le chemin du clip est spécifié en coordonnées logiques (peintre).

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

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

Active l'écrêtage et définit la région d'écrêtage à l'adresse rectangle en utilisant l'écrêtage operation. L'opération par défaut consiste à remplacer le rectangle d'écrêtage actuel.

Notez que le rectangle d'écrêtage est spécifié en coordonnées logiques (peintre).

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

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

Active l'écrêtage et définit la région d'écrêtage comme étant le rectangle commençant à (x, y) avec les données width et height.

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

Active l'écrêtage et définit la région d'écrêtage à l'adresse rectangle en utilisant l'écrêtage operation.

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

Définit la région du clip à l'adresse region donnée en utilisant le clip operation spécifié. L'opération de clip par défaut consiste à remplacer la région de clip actuelle.

Notez que la région du clip est donnée en coordonnées logiques.

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

void QPainter::setClipping(bool enable)

Active l'écrêtage si enable est vrai, ou le désactive si enable est faux.

Voir aussi hasClipping() et Clipping.

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

Définit le mode de composition à l'adresse mode.

Voir également compositionMode().

void QPainter::setFont(const QFont &font)

Fixe la police de caractères du peintre à la valeur donnée font.

Cette police est utilisée par les fonctions drawText() suivantes. La couleur du texte est la même que celle du stylo.

Si vous définissez une police qui n'est pas disponible, Qt trouve une police proche. font() renvoie ce que vous avez défini avec setFont() et fontInfo() renvoie la police utilisée (qui peut être la même).

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

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

Définit la direction de la mise en page utilisée par le peintre lorsqu'il dessine du texte, à la valeur spécifiée direction.

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

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

void QPainter::setOpacity(qreal opacity)

Définit l'opacité du peintre à opacity. La valeur doit être comprise entre 0,0 et 1,0, où 0,0 est totalement transparent et 1,0 est totalement opaque.

L'opacité définie sur le peintre s'applique à chaque opération de dessin séparément. Le remplissage d'une forme et le dessin de son contour sont traités comme des opérations de dessin distinctes.

Voir également opacity().

void QPainter::setPen(const QPen &pen)

Définit le stylo du peintre comme étant le stylo donné pen.

Le site 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 pour qu'il ait la valeur style, la largeur 1 et la couleur noire.

void QPainter::setPen(const QColor &color)

Définit le stylo du peintre comme ayant le style Qt::SolidLine, la largeur 1 et la valeur spécifiée color.

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

Définit le rendu donné hint sur le peintre si on est vrai ; sinon, efface l'indication de rendu.

Voir aussi setRenderHints(), renderHints(), et Rendering Quality.

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

Définit le rendu donné hints sur le peintre si on est vrai ; sinon, efface les indications de rendu.

Voir aussi setRenderHint(), renderHints(), et Rendering Quality.

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

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

Voir aussi transform() et setWorldTransform().

void QPainter::setViewTransformEnabled(bool enable)

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

Voir aussi viewTransformEnabled() et Window-Viewport Conversion.

void QPainter::setViewport(const QRect &rectangle)

Fixe le rectangle de visualisation du peintre à la valeur rectangle, et active les transformations de la vue.

Le rectangle de visualisation fait partie de la transformation de la vue. La fenêtre de visualisation spécifie le système de coordonnées du périphérique. Sa sœur, window(), spécifie le système de coordonnées logique.

Le rectangle d'affichage par défaut est le même que celui du périphérique.

Voir également viewport(), viewTransformEnabled() et Window-Viewport Conversion.

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

Définit le rectangle de visualisation du peintre comme étant le rectangle commençant à (x, y) avec les données width et height.

void QPainter::setWindow(const QRect &rectangle)

Définit la fenêtre du peintre à l'adresse rectangle, et active les transformations de vue.

Le rectangle de la fenêtre fait partie de la transformation de la vue. La fenêtre spécifie le système de coordonnées logique. Sa sœur, viewport(), spécifie le système de coordonnées du périphérique.

Le rectangle de la fenêtre par défaut est le même que celui du périphérique.

Voir également window(), viewTransformEnabled() et Window-Viewport Conversion.

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

Fixe la fenêtre du peintre au rectangle commençant à (x, y) et aux coordonnées width et height.

void QPainter::setWorldMatrixEnabled(bool enable)

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

Voir aussi worldMatrixEnabled(), worldTransform(), et Coordinate Transformations.

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

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

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

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

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

Voir également setWorldTransform() et Coordinate Transformations.

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

Dessine le contour (traits) du chemin path avec le 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 aussi renderHints() et setRenderHint().

const QTransform &QPainter::transform() const

Alias de worldTransform(). Renvoie la matrice de transformation du monde.

Voir aussi setTransform() et worldTransform().

void QPainter::translate(const QPointF &offset)

Traduit le système de coordonnées par la valeur donnée offset; c'est-à-dire que la valeur donnée offset est ajoutée aux points.

Voir aussi setWorldTransform() et Coordinate Transformations.

void QPainter::translate(const QPoint &offset)

Traduit le système de coordonnées en fonction de l'adresse offset.

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

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

bool QPainter::viewTransformEnabled() const

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

Voir aussi setViewTransformEnabled() et worldTransform().

QRect QPainter::viewport() const

Renvoie le rectangle de la fenêtre de visualisation.

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

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

const QTransform &QPainter::worldTransform() const

Renvoie la matrice de transformation du monde.

Voir aussi setWorldTransform().