QCanvasPainter Class

QRectF rect(40, 70, 120, 60);
QRectF shadowRect = rect.translated(2, 4);
// Paint shadow
QCanvasBoxShadow shadow(shadowRect);
shadow.setRadius(30);
shadow.setBlur(15);
shadow.setColor("#60373F26");
p->drawBoxShadow(shadow);
// Paint rounded rect
p->beginPath();
p->roundRect(rect, 30);
p->setFillStyle("#DBEB00");
p->fill();
// Paint text
p->setTextAlign(QCanvasPainter::TextAlign::Center);
p->setTextBaseline(QCanvasPainter::TextBaseline::Middle);
QFont font("Titillium Web", 18);
p->setFont(font);
p->setFillStyle("#373F26");
p->fillText("CLICK!", rect);

// Paint grid
QCanvasGridPattern grid(0, 0, 10, 10);
grid.setLineColor("#404040");
grid.setBackgroundColor("#202020");
p->setFillStyle(grid);
p->fillRect(0, 0, width(), height());
// Paint axis
p->setFillStyle(QColorConstants::White);
p->fillRect(0, 0.5 * height() - 1, width(), 2);
p->fillRect(0.5 * width() - 1, 0, 2, height());
// Paint shadowed graph
p->beginPath();
p->moveTo(20, height() * 0.8);
p->bezierCurveTo(width() * 0.2, height() * 0.4,
                 width() * 0.5, height() * 0.8,
                 width() - 20, height() * 0.2);
p->setAntialias(10);
p->setLineWidth(12);
p->setStrokeStyle("#D0000000");
p->stroke();
p->setAntialias(1);
p->setLineWidth(6);
QCanvasLinearGradient lg(0, 0, 0, height());
lg.setStartColor(QColorConstants::Red);
lg.setEndColor(QColorConstants::Green);
p->setStrokeStyle(lg);
p->stroke();

p->setWindingEnforce(false);
p->beginPath();
// Outer shape, counterclockwise
p->moveTo(20, 20);
p->lineTo(100, 180);
p->lineTo(180, 20);
p->closePath();
// Inner shape, clockwise
p->moveTo(100, 40);
p->lineTo(125, 90);
p->lineTo(75, 90);
p->closePath();
p->fill();
p->stroke();

p->beginPath();
p->roundRect(20, 20, 160, 160, 30);
// Start painting holes
p->beginHoleSubPath();
p->roundRect(40, 40, 120, 120, 10);
// Start painting solid
p->beginSolidSubPath();
p->rect(60, 60, 80, 20);
p->circle(100, 120, 20);
p->fill();
p->stroke();

Documentation des fonctions membres

QCanvasPainter::QCanvasPainter()

Crée un « painter ».

[noexcept] QCanvasPainter::~QCanvasPainter()

Il détruit le peintre.

qsizetype QCanvasPainter::activeImageCount() const

Renvoie le nombre d'objets « QCanvasImage » actifs enregistrés auprès de cette instance de ` QCanvasPainter`. Ce nombre inclut également les images créées en interne pour ` gradients`.

QCanvasImage Les objets créés par l'enregistrement d'instances de ` QCanvasOffscreenCanvas ` ou les textures gérées en externe ne sont pas pris en compte par cette fonction.

Voir également activeImageMemoryUsage(), addImage() et removeImage().

qsizetype QCanvasPainter::activeImageMemoryUsage() const

Renvoie une estimation, en kilo-octets, de la mémoire utilisée par les données d’image (pixels) de toutes les instances actives de ` QCanvasImage ` pour ce « peintre », qui ont été créées par la surcharge de la méthode ` addImage()` prenant un ` QImage`. Cela inclut également les données provenant des images créées en interne pour ` gradients`.

QCanvasPainter ne conserve pas de copies des données d’ QImage s côté CPU une fois que addImage() a renvoyé une valeur. Par conséquent, le résultat de cette fonction est une approximation de la mémoire GPU utilisée pour les textures.

Les canevas hors écran et les textures gérées en externe enregistrées via les autres surcharges de la fonction ` addImage()` ne sont pas pris en compte par cette fonction.

Pour chaque ` QCanvasImage` valide, la taille individuelle en octets peut toujours être interrogée en appelant ` sizeInBytes()`. Cette fonction renvoie des résultats valides même lorsque l’` QCanvasImage ` a été créé à partir d’un ` QCanvasOffscreenCanvas ` ou d’un ` QRhiTexture`, mais elle ne prend pas en compte les données de mipmap ni de multisample.

Voir également activeImageCount(), addImage() et removeImage().

QCanvasImage QCanvasPainter::addImage(const QImage &image, QCanvasPainter::ImageFlags flags = {})

Ajoute l'image, dont l'flags est accessible au peintre en tant que texture. Renvoie l'QCanvasImage contenant l'identifiant de la texture et d'autres informations sur l'image. L'QCanvasImage renvoyé peut ensuite être utilisé avec les méthodes drawImage et QCanvasImagePattern. Après l'appel de cette méthode, il n'est pas nécessaire de conserver en mémoire l'image QImage .

L'appel avec le même image est une opération peu coûteuse, car on s'attend à un accès au cache.

Lors de l’optimisation, il faut veiller à n’appeler addImage() qu’une seule fois. Cela n’est pas toujours suffisant, selon la conception de l’application. Par exemple, si les ressources graphiques sous-jacentes sont perdues, par exemple parce que le « painter » est associé en arrière-plan à une nouvelle QRhi suite au déplacement d’un widget vers un nouveau niveau supérieur, alors l’appel de cette fonction est essentiel pour recréer les textures graphiques natives à partir de image.

Voir également drawImage() et removeImage().

QCanvasImage QCanvasPainter::addImage(QRhiTexture *texture, QCanvasPainter::ImageFlags flags = {})

Ajoute texture avec flags, disponible pour le peintre en tant que texture. L'QCanvasImage renvoyé peut être utilisé avec drawImage et QCanvasImagePattern.

Voir également drawImage() et removeImage().

QCanvasImage QCanvasPainter::addImage(const QCanvasOffscreenCanvas &canvas, QCanvasPainter::ImageFlags flags = {})

Enregistre canvas auprès de flags auprès du « painter » afin qu’il soit disponible en tant qu’image. L’objet QCanvasImage renvoyé peut être utilisé avec drawImage et QCanvasImagePattern.

Voir également drawImage() et removeImage().

void QCanvasPainter::addPath(const QPainterPath &path)

Ajoute path au chemin d'accès actuel.

void QCanvasPainter::addPath(const QCanvasPath &path, const QTransform &transform = QTransform())

Ajoute path au chemin actuel, en utilisant éventuellement transform pour modifier les points du chemin. Lorsque transform n'est pas fourni (ou qu'il s'agit de la matrice identité), cette opération est très rapide car elle réutilise les données du chemin.

void QCanvasPainter::addPath(const QCanvasPath &path, qsizetype start, qsizetype count, const QTransform &transform = QTransform())

Ajoute path au chemin actuel, en partant de la commande située à l'adresse start et en incluant count nombre de commandes. Il est possible d'utiliser transform pour modifier les points du chemin. La plage comprise entre start et count est vérifiée, afin que les commandes ne soient pas consultées au-delà de QCanvasPath::commandsSize(). Si le chemin ne doit pas se poursuivre à partir de la position actuelle, appelez d'abord moveTo(), par exemple avec path.positionAt(start - 1).

void QCanvasPainter::arc(qreal centerX, qreal centerY, qreal radius, qreal a0, qreal a1, QCanvasPainter::PathWinding direction = PathWinding::ClockWise, QCanvasPainter::PathConnection connection = PathConnection::Connected)

Crée un nouveau sous-trajet en forme d’arc de cercle. Le centre de l’arc se trouve à l’adresse centerX, centerY, avec radius, et l’arc est tracé à partir de l’angle a0 jusqu’à a1, et balayé selon direction (ClockWise ou CounterClockWise). Lorsque connection vaut NotConnected, l’arc n’ajoute pas de ligne reliant la position du trajet précédent au début de l’arc. Les angles sont spécifiés en radians.

void QCanvasPainter::arc(QPointF centerPoint, qreal radius, qreal a0, qreal a1, QCanvasPainter::PathWinding direction = PathWinding::ClockWise, QCanvasPainter::PathConnection connection = PathConnection::Connected)

Crée un nouveau sous-trajet en forme d’arc de cercle. Le centre de l’arc se trouve à l’adresse centerPoint, avec radius, et l’arc est tracé de l’angle a0 à a1, et balayé selon direction (ClockWise ou CounterClockWise). Lorsque connection vaut NotConnected, l’arc n’ajoute pas de ligne entre la position du tracé précédent et le début de l’arc. Les angles sont spécifiés en radians.

void QCanvasPainter::arcTo(qreal x1, qreal y1, qreal x2, qreal y2, qreal radius)

Ajoute un segment d'arc au niveau du coin défini par le dernier point du tracé, ainsi que deux points spécifiés (x1, y1 et x2, y2) avec radius. L'arc est automatiquement relié au dernier point du tracé par une ligne droite si nécessaire.

void QCanvasPainter::arcTo(QPointF controlPoint1, QPointF controlPoint2, qreal radius)

Ajoute un segment d'arc à l'angle défini par le dernier point du tracé et deux points spécifiés (controlPoint1 et controlPoint2) avec radius. L'arc est automatiquement relié au dernier point du tracé par une ligne droite si nécessaire.

void QCanvasPainter::beginHoleSubPath()

Créer un sous-chemin « hole ». Cela revient à utiliser la commande setPathWinding(QCanvasPainter::PathWinding::ClockWise))

Voir également beginSolidSubPath().

void QCanvasPainter::beginPath()

Commence à tracer un nouveau chemin tout en effaçant le chemin actuel.

void QCanvasPainter::beginSolidSubPath()

Lancer un sous-chemin solide. Cela revient à setPathWinding(QCanvasPainter::PathWinding::CounterClockWise))

Voir également beginHoleSubPath().

void QCanvasPainter::bezierCurveTo(qreal cp1X, qreal cp1Y, qreal cp2X, qreal cp2Y, qreal x, qreal y)

Ajoute un segment de Bézier cubique partant du dernier point du tracé, passant par deux points de contrôle (cp1X, cp1Y et cp2X, cp2Y) et aboutissant au point spécifié (x, y).

void QCanvasPainter::bezierCurveTo(QPointF controlPoint1, QPointF controlPoint2, QPointF endPoint)

Ajoute un segment de Bézier cubique partant du dernier point du tracé, passant par deux points de contrôle (controlPoint1 et controlPoint2) et aboutissant au point spécifié endPoint.

void QCanvasPainter::circle(qreal centerX, qreal centerY, qreal radius)

Crée un nouveau sous-tracé circulaire centré en ( centerX, centerY) et d'un radius.

void QCanvasPainter::circle(QPointF centerPoint, qreal radius)

Crée un nouveau sous-trajet circulaire centré sur centerPoint avec radius.

void QCanvasPainter::cleanupResources()

Programme la suppression des textures inutilisées du cache.

De plus, d'autres caches et pools peuvent être réduits lors de l'appel de cette fonction, afin de minimiser l'utilisation de la mémoire. Cela peut potentiellement entraîner des appels de dessin plus coûteux par la suite.

void QCanvasPainter::clearRect(qreal x, qreal y, qreal width, qreal height)

Efface les pixels d'une zone rectangulaire en remplissant de noir transparent le rectangle défini par x, y, width, height. Comme l'effacement ne nécessite pas de fusion, il peut s'avérer plus rapide que fillRect().

void QCanvasPainter::clearRect(const QRectF &rect)

Efface les pixels d'une zone rectangulaire en remplissant le rectangle spécifié par ` rect ` avec du noir transparent. Il s'agit d'une méthode surchargée utilisant ` QRectF`.

void QCanvasPainter::closePath()

Ferme le sous-trajet actuel à l'aide d'un segment de droite. Cela revient à utiliser « lineTo([point de départ]) » comme dernier élément du trajet.

QCanvasOffscreenCanvas QCanvasPainter::createCanvas(QSize pixelSize, int sampleCount = 1, QCanvasOffscreenCanvas::Flags flags = {})

Renvoie un nouveau canevas hors écran avec les paramètres pixelSize, sampleCount et flags fournis.

La taille du canevas est spécifiée en pixels. Les propriétés pixelSize, sampleCount et flags sont ensuite immuables. Pour obtenir un canevas avec une taille, un nombre d’échantillons ou des indicateurs différents, créez-en un nouveau.

Pour cibler un canevas hors écran avec des commandes de dessin, appelez la surcharge appropriée de ` QCanvasRhiPaintDriver::beginPaint()` lorsque vous utilisez l’API de bas niveau, ou ` QCanvasPainterWidget::beginCanvasPainting()` ou ` QCanvasPainterItemRenderer::beginCanvasPainting()` lorsque vous utilisez les classes de widgets de commodité ou d’éléments ` Qt Quick `.

Normalement, le contenu du canevas est effacé lors du dessin. Pour désactiver cette fonction, passez PreserveContents dans flags.

Pour demander un rendu multi-échantillonnage sur le canevas (anticrénelage multi-échantillonnage, MSAA), définissez un nombre d’échantillons supérieur à 1, par exemple 4 ou 8. La conservation du contenu du canevas entre les passes de rendu n’est toutefois pas prise en charge lorsque le multi-échantillonnage est activé, et l’indicateur ` PreserveContents ` ne fonctionnera pas dans ce cas.

void QCanvasPainter::destroyCanvas(QCanvasOffscreenCanvas &canvas)

Détruit les ressources associées à canvas. canvas devient alors null canvas.

Le « painter » effectue cette opération automatiquement lors de sa destruction. Par conséquent, l'appel de cette fonction n'est nécessaire que si l'on souhaite libérer immédiatement les ressources associées.

void QCanvasPainter::drawBoxShadow(const QCanvasBoxShadow &shadow)

Dessine une boîte shadow. L'ombre sera dessinée selon la position, la taille, la couleur, le flou, etc. définis par shadow. Il n'est pas nécessaire d'appeler beginPath() avant cette méthode.

Voir également QCanvasBoxShadow.

void QCanvasPainter::drawImage(const QCanvasImage &image, qreal x, qreal y)

Afficher image sur x, y, à sa taille par défaut.

Voir également addImage().

void QCanvasPainter::drawImage(const QCanvasImage &image, const QRectF &destinationRect)

Affichez image en respectant la position et la taille de destinationRect.

Voir également addImage().

void QCanvasPainter::drawImage(const QCanvasImage &image, const QRectF &sourceRect, const QRectF &destinationRect)

Dessiner image avec la position et la taille de destinationRect, à partir de la zone sourceRect de l'image.

Voir également addImage().

void QCanvasPainter::drawImage(const QCanvasImage &image, qreal x, qreal y, qreal width, qreal height)

Afficher image sur x, y, ainsi que sur les pages width et height.

Voir également addImage().

void QCanvasPainter::ellipse(qreal centerX, qreal centerY, qreal radiusX, qreal radiusY)

Crée un nouveau sous-trajet en forme d'ellipse centré en ( centerX, centerY) avec radiusX et radiusY.

void QCanvasPainter::ellipse(const QRectF &rect)

Crée un nouveau sous-tracé en forme d'ellipse dans « rect ». Cette ellipse recouvrira la zone « rect ».

void QCanvasPainter::ellipse(QPointF centerPoint, qreal radiusX, qreal radiusY)

Crée un nouveau sous-trajet en forme d'ellipse centré à l'centerPoint, avec les coordonnées radiusX et radiusY.

void QCanvasPainter::fill()

Remplit le tracé actuel avec le style de remplissage et la règle de remplissage actuels.

Voir également setFillStyle() et setFillRule().

[since 6.12] void QCanvasPainter::fill(QCanvasPainter::FillRule fillRule)

Remplit le tracé actuel avec le style de remplissage actuel et la règle de remplissage fillRule.

Cette fonction a été introduite dans Qt 6.12.

Voir également setFillStyle() et setFillRule().

void QCanvasPainter::fill(const QCanvasPath &path, int pathGroup = -1)

Remplit l'objet « path » avec le style et la règle de remplissage actuels, et l'intègre à l'objet « pathGroup ». Le remplissage via « QCanvasPath » est optimal lorsque le tracé contient davantage de commandes et est essentiellement statique.

Lorsque pathGroup est défini sur -1, le tracé ne sera pas mis en cache côté GPU. Il s’agit du comportement par défaut. Pour demander la mise en cache des données de tracé, transmettez une valeur égale ou supérieure à 0. Vous trouverez plus d’informations sur l’utilisation des groupes de cache de tracés dans la documentation QCanvasPath.

Il n’est pas nécessaire d’appeler ` beginPath()` avant cette méthode.

Voir également setFillStyle(), setFillRule() et removePathGroup().

[since 6.12] void QCanvasPainter::fill(const QCanvasPath &path, QCanvasPainter::FillRule fillRule, int pathGroup = -1)

Remplit l'path e avec le style et la règle de remplissage actuels fillRule

Cette fonction a été introduite dans Qt 6.12.

void QCanvasPainter::fillRect(qreal x, qreal y, qreal width, qreal height)

Dessine un rectangle rempli à l'emplacement spécifié ( x, y) avec les dimensions width, height.

void QCanvasPainter::fillRect(const QRectF &rect)

Dessine un rectangle rempli dans ` rect`. Il s'agit d'une méthode surchargée utilisant ` QRectF`.

void QCanvasPainter::fillText(const QString &text, qreal x, qreal y, qreal maxWidth = 0)

Dessine une chaîne de caractères de type « text » à l'emplacement spécifié ( x, y), en utilisant les valeurs actuelles de textAlign et textBaseline. Pour que le texte s'affiche sur plusieurs lignes, définissez le mode de retour à la ligne à l'aide de la fonction setTextWrapMode() en choisissant une valeur autre que la valeur par défaut NoWrap. Le paramètre facultatif maxWidth prend par défaut la valeur 0. Cela signifie que lorsque, par exemple, WordWrap a été défini, le texte est renvoyé à la ligne à chaque mot. Définissez le paramètre maxWidth sur la largeur de ligne souhaitée en pixels.

Voir également setTextAlign(), setTextBaseline() et setTextWrapMode().

void QCanvasPainter::fillText(const QString &text, const QRectF &rect)

Dessine la chaîne text à l'intérieur de rect, en utilisant les valeurs actuelles de textAlign et textBaseline. La largeur du paramètre rect est utilisée comme maxWidth.

Il s’agit d’une méthode surchargée utilisant ` QRectF`. Il est souvent utile de définir la ligne de base du texte sur ` TextBaseline::Top ` ou ` TextBaseline::Middle ` lors du tracé de texte avec cette méthode.

Voir également setTextAlign(), setTextBaseline() et setTextWrapMode().

void QCanvasPainter::fillText(const QString &text, QPointF point, qreal maxWidth = 0)

Affiche la chaîne « text » à l’ point spécifiée, en utilisant les paramètres actuels textAlign et textBaseline. Pour que le texte s’affiche sur plusieurs lignes, définissez le mode de retour à la ligne à l’aide de la fonction setTextWrapMode() en choisissant une valeur différente de la valeur par défaut « NoWrap ». Le paramètre facultatif « maxWidth » prend par défaut la valeur « 0 ». Cela signifie que lorsque, par exemple, la valeur « WordWrap » a été définie, le texte passe à la ligne à chaque mot. Définissez le paramètre ` maxWidth ` sur la largeur de ligne souhaitée en pixels.

Il s’agit d’une méthode surchargée utilisant QPointF.

Voir également setTextAlign(), setTextBaseline() et setTextWrapMode().

QTransform QCanvasPainter::getTransform() const

Renvoie la transformation actuelle.

void QCanvasPainter::lineTo(qreal x, qreal y)

Ajoute un segment de droite reliant le dernier point du tracé au point ( x, y).

void QCanvasPainter::lineTo(QPointF point)

Ajoute un segment de droite reliant le dernier point du tracé à l'point.

void QCanvasPainter::moveTo(qreal x, qreal y)

Crée un nouveau sous-chemin dont le premier point est ( x, y).

void QCanvasPainter::moveTo(QPointF point)

Lance un nouveau sous-chemin dont le premier point est point.

void QCanvasPainter::quadraticCurveTo(qreal cpX, qreal cpY, qreal x, qreal y)

Ajoute un segment de Bézier quadratique partant du dernier point du tracé, passant par un point de contrôle (cpX, cpY) et aboutissant au point spécifié (x, y).

void QCanvasPainter::quadraticCurveTo(QPointF controlPoint, QPointF endPoint)

Ajoute un segment de Bézier quadratique reliant le dernier point du tracé, en passant par un point de transition ( controlPoint ), au point de destination ( endPoint) spécifié.

void QCanvasPainter::rect(qreal x, qreal y, qreal width, qreal height)

Crée un nouveau sous-trajet de forme rectangulaire à la position x, y, de taille width, height.

void QCanvasPainter::rect(const QRectF &rect)

Crée un nouveau sous-trajet de forme rectangulaire à l'adresse rect. Il s'agit d'une méthode surchargée utilisant QRectF.

void QCanvasPainter::removeImage(const QCanvasImage &image)

Libère les ressources associées à ` image ` et supprime l'image du « painter ».

Voir également ` addImage()`.

void QCanvasPainter::removePathGroup(int pathGroup)

Supprime l'pathGroup du cache du peintre. L'appel de ` fill()` ou ` stroke()` pour ` pathGroup ` après cette opération régénérera le chemin dans le cache du groupe.

Voir également fill() et stroke().

void QCanvasPainter::reset()

Réinitialise l'état actuel du peintre aux valeurs par défaut.

Cela inclut les styles de trait et de remplissage ainsi que les propriétés associées, la matrice de transformation, la zone de découpe, les paramètres liés au texte, les propriétés de composition, la pile d'états de dessin et les paramètres d'anticrénelage.

Voir également save() et restore().

void QCanvasPainter::resetClipping()

Réinitialise et désactive l'écrêtage.

Voir aussi setClipRect().

void QCanvasPainter::resetTransform()

Réinitialise la transformation actuelle pour qu'elle corresponde à une matrice identité.

void QCanvasPainter::restore()

Affiche et restaure l'état de rendu actuel. L'état précédemment enregistré sera donc restauré. Si la fonction save() n'a pas été appelée et que la pile d'états est vide, l'appel de cette fonction n'a aucun effet.

Voir également save().

void QCanvasPainter::rotate(qreal angle)

Fait pivoter le système de coordonnées actuel dans le sens des aiguilles d'une montre d'un angle de angle.

L'angle est exprimé en radians. Utilisez la fonction qDegreesToRadians() pour convertir les degrés en radians.

void QCanvasPainter::roundRect(qreal x, qreal y, qreal width, qreal height, qreal radius)

Crée un nouveau sous-tracé en forme de rectangle arrondi à la position x, y avec les dimensions width, height. L'arrondi des coins sera de radius.

void QCanvasPainter::roundRect(const QRectF &rect, qreal radius)

Crée un nouveau sous-trajet en forme de rectangle arrondi à l'adresse rect avec des coins définis par radius. Il s'agit d'une méthode surchargée utilisant QRectF.

void QCanvasPainter::roundRect(const QRectF &rect, qreal radiusTopLeft, qreal radiusTopRight, qreal radiusBottomRight, qreal radiusBottomLeft)

Crée un nouveau sous-tracé en forme de rectangle arrondi à l'adresse rect. Le niveau d'arrondi des coins peut varier d'un coin à l'autre, avec les paramètres suivants : radiusTopLeft, radiusTopRight, radiusBottomRight, radiusBottomLeft.

void QCanvasPainter::roundRect(qreal x, qreal y, qreal width, qreal height, qreal radiusTopLeft, qreal radiusTopRight, qreal radiusBottomRight, qreal radiusBottomLeft)

Crée un nouveau sous-trajet en forme de rectangle arrondi à la position x, y avec les dimensions width, height. L'arrondi des coins peut varier d'un coin à l'autre, avec les valeurs radiusTopLeft, radiusTopRight, radiusBottomRight, radiusBottomLeft.

void QCanvasPainter::save()

Ajoute et enregistre l'état de rendu actuel dans une pile d'états. Il faut utiliser la méthode correspondante restore() pour restaurer cet état.

Voir également restore().

void QCanvasPainter::scale(qreal scale)

Mise à l'échelle du système de coordonnées actuel selon le rapport scale. Les coordonnées x et y sont mises à l'échelle de manière uniforme.

void QCanvasPainter::scale(qreal scaleX, qreal scaleY)

Redimensionne le système de coordonnées actuel selon les valeurs scaleX et scaleY.

void QCanvasPainter::setAntialias(qreal antialias)

Définit le niveau d'anticrénelage actuel à antialias en pixels. Un anticrénelage plus important permet un rendu plus lisse. Cela n'affecte que le remplissage et le tracé, et non les images ou les textes. La valeur par défaut est 1.0 et la valeur maximale est 10.0.

L'anticrénelage peut être modifié pour chaque tracé ; il peut donc être défini avant chaque trait ou remplissage. Pour désactiver l'anticrénelage et réduire le coût de rendu, définissez l'anticrénelage sur 0.

Voir également setTextAntialias().

void QCanvasPainter::setClipRect(qreal x, qreal y, qreal width, qreal height)

Définit le rectangle de découpe actuel sur (x, y, width, height). Le rectangle de découpe est transformé par la transformation actuelle.

Voir également resetClipping().

void QCanvasPainter::setClipRect(const QRectF &rect)

Définit le rectangle de découpe actuel sur rect. Le rectangle de découpe est transformé par la transformation actuelle.

Voir également resetClipping().

[since 6.12] void QCanvasPainter::setFillRule(QCanvasPainter::FillRule fillRule)

Définit la règle de remplissage des chemins sur « fillRule ». Cette valeur s'applique à tous les appels à la fonction fill() effectués après la définition de la règle. La règle de remplissage par défaut est QCanvasPainter::FillRule::NonZero

Cette fonction a été introduite dans Qt 6.12.

void QCanvasPainter::setFillStyle(QColor color)

Définit le style de remplissage sur une couleur unie color. Le style de remplissage par défaut est le noir uni (0, 0, 0, 1).

void QCanvasPainter::setFillStyle(const QCanvasBrush &brush)

Définit le style de remplissage sur « brush ». Le style de remplissage par défaut est le noir uni (0, 0, 0, 1).

void QCanvasPainter::setFont(const QFont &font)

Définit la police « font » comme police actuellement active.

void QCanvasPainter::setGlobalAlpha(qreal alpha)

Définit la valeur globale de l'alpha (transparence) sur alpha. Cette valeur d'alpha s'applique à toutes les formes affichées. Les tracés déjà transparents deviendront également proportionnellement plus transparents. La valeur de l'alpha doit être comprise entre 0,0 (entièrement transparent) et 1,0 (entièrement opaque). Par défaut, l'alpha est défini sur 1.0.

void QCanvasPainter::setGlobalBrightness(qreal value)

Définit la luminosité globale à value. Cette luminosité s'applique à toutes les formes affichées. Une valeur de 0 rendra l'affichage entièrement noir. La valeur peut également être supérieure à 1,0 pour augmenter la luminosité. Par défaut, la luminosité est de 1.0.

void QCanvasPainter::setGlobalCompositeOperation(QCanvasPainter::CompositeOperation operation)

Définit le mode d'opération composite global sur « operation ». Ce mode s'applique à toutes les opérations de dessin. Le mode par défaut est « QCanvasPainter::CompositeOperation::SourceOver ».

void QCanvasPainter::setGlobalContrast(qreal value)

Définit le contraste global à value. Ce contraste s'applique à toutes les formes affichées. Une valeur de 0 rendra l'affichage entièrement gris (0,5, 0,5, 0,5). La valeur peut également être supérieure à 1,0 pour augmenter le contraste. Par défaut, le contraste est de 1.0.

void QCanvasPainter::setGlobalSaturation(qreal value)

Définit la saturation globale à value. Cette saturation s'applique à toutes les formes affichées. Une valeur de 0 désactive la saturation et rend l'affichage entièrement en niveaux de gris. La valeur peut également être supérieure à 1,0 pour augmenter la saturation. Par défaut, la saturation est de 1.0.

void QCanvasPainter::setHighQualityStroking(bool enabled)

Définit le tracé de haute qualité sur « enabled ». Le réglage sur « true » permet un rendu plus correct dans certains cas peu courants où les tracés se chevauchent et ne présentent pas une opacité totale. L’activation de cette option entraîne une augmentation du coût de rendu. La valeur par défaut est « false ».

void QCanvasPainter::setLineCap(QCanvasPainter::LineCap cap)

Définit la fin de trait sur « cap ». La fin de trait par défaut est « QCanvasPainter::LineCap::Butt ».

void QCanvasPainter::setLineJoin(QCanvasPainter::LineJoin join)

Définit le type de jonction des traits sur « join ». La jonction par défaut est « QCanvasPainter::LineJoin::Miter ».

Voir également setMiterLimit().

void QCanvasPainter::setLineWidth(qreal width)

Définit la largeur des traits à width en pixels. La largeur par défaut est 1.0. Lorsque l'anticrénelage est activé, les largeurs inférieures à un pixel entraînent automatiquement une diminution progressive de l'opacité, ce qui permet d'obtenir un rendu lisse.

Voir aussi stroke().

void QCanvasPainter::setMiterLimit(qreal limit)

Définit la limite de coupe en onglet à limit. La limite de coupe en onglet détermine à quel moment un angle aigu est biseauté. Lorsque la longueur de l'angle dépasse cette limite, une coupe en onglet ( QCanvasPainter::LineJoin::Bevel ) est alors appliquée entre les lignes. Ce paramètre n'a d'effet qu'avec le type de jonction « QCanvasPainter::LineJoin::Miter ». La limite par défaut est 10.0.

Voir également setLineJoin().

void QCanvasPainter::setPathWinding(QCanvasPainter::PathWinding winding)

Définit le sous-trajet actuel « winding » sur « CounterClockWise » (par défaut) ou « ClockWise ». L'option « CounterClockWise » permet de tracer des sous-trajets pleins, tandis que l'option « ClockWise » permet de tracer des trous.

Voir également beginHoleSubPath() et beginSolidSubPath().

void QCanvasPainter::setStrokeStyle(QColor color)

Définit le style de trait sur « color » (couleur unie). Le style de trait par défaut est une couleur noire unie (0, 0, 0, 1).

void QCanvasPainter::setStrokeStyle(const QCanvasBrush &brush)

Définit le style de trait sur « brush ». Le style de trait par défaut est un trait noir continu (0, 0, 0, 1).

void QCanvasPainter::setTextAlign(QCanvasPainter::TextAlign align)

Définit l'alignement horizontal du texte sur « align ». L'alignement par défaut est « QCanvasPainter::TextAlign::Start ».

Voir également setTextBaseline().

void QCanvasPainter::setTextAntialias(qreal antialias)

Définit le niveau actuel d'anticrénelage du texte. La valeur « antialias » correspond à un multiplicateur de l'anticrénelage normal : ainsi, « 0.0 » désactive l'anticrénelage et « 2.0 » le double. La valeur par défaut est 1.0.

void QCanvasPainter::setTextBaseline(QCanvasPainter::TextBaseline baseline)

Définit l'alignement vertical (ligne de base) du texte sur « baseline ». L'alignement par défaut est « QCanvasPainter::TextBaseline::Alphabetic ».

Voir aussi setTextAlign().

void QCanvasPainter::setTextDirection(QCanvasPainter::TextDirection direction)

Définit le sens d'écriture du texte sur « direction ». Le sens par défaut est « QCanvasPainter::TextDirection::Inherit ».

void QCanvasPainter::setTextLineHeight(qreal height)

Définit l'ajustement de l'interligne en pixels sur height pour le texte en retour à la ligne. L'interligne par défaut est de 0.

void QCanvasPainter::setTextWrapMode(QCanvasPainter::WrapMode wrapMode)

Définit le mode de retour à la ligne sur « wrapMode ». Le mode de retour à la ligne par défaut est « QCanvasPainter::WrapMode::NoWrap ».

void QCanvasPainter::setTransform(const QTransform &transform)

Réinitialise la transformation actuelle et utilise à la place transform.

Voir aussi transform().

void QCanvasPainter::setWindingEnforce(bool enabled)

Définit le sens de défilement des chemins sur « enabled ». En définissant cette option sur « false », vous désactivez l'application du sens de défilement des chemins défini dans la fonction « setPathWinding() ». Cette désactivation permet, par exemple, de créer des trous dans les chemins en ajoutant les points dans le sens des aiguilles d'une montre. Elle peut également améliorer les performances. La valeur par défaut est « true ».

void QCanvasPainter::skew(qreal angleX, qreal angleY = 0.0)

Déforme (cisaille) le système de coordonnées actuel de angleX le long de l'axe X et de angleY le long de l'axe Y. Les angles sont exprimés en radians.

void QCanvasPainter::stroke()

Trace le tracé actuel avec le style de trait actuel.

Voir aussi setStrokeStyle().

void QCanvasPainter::stroke(const QCanvasPath &path, int pathGroup = -1)

Trace le chemin path avec le style de trait actuel et l'intègre dans pathGroup. Le tracé via QCanvasPath est optimal lorsque le chemin contient davantage de commandes et est essentiellement statique.

Lorsque pathGroup est défini sur -1, les données liées au rendu du chemin ne sont pas mises en cache. Il s’agit du comportement par défaut. Pour demander la mise en cache des données du chemin, transmettez une valeur égale ou supérieure à 0. Vous trouverez plus d’informations sur l’utilisation des groupes de cache de chemins dans la documentation relative à QCanvasPath.

Il n’est pas nécessaire d’appeler ` beginPath()` avant cette méthode.

Voir également setStrokeStyle() et removePathGroup().

void QCanvasPainter::strokeRect(qreal x, qreal y, qreal width, qreal height)

Dessine un rectangle avec contour à l'emplacement spécifié ( x, y) et de taille width, height.

void QCanvasPainter::strokeRect(const QRectF &rect)

Dessine un rectangle avec un contour dans ` rect`. Il s'agit d'une méthode surchargée utilisant ` QRectF`.

QRectF QCanvasPainter::textBoundingBox(const QString &text, qreal x, qreal y, qreal maxWidth = 0) const

Mesure le cadre de délimitation d'une chaîne « text » à l'adresse (x, y).

Pour mesurer un texte sur plusieurs lignes, définissez le mode de retour à la ligne à l’aide de la fonction setTextWrapMode() sur une valeur autre que la valeur par défaut NoWrap. Définissez également le paramètre facultatif maxWidth sur la largeur de ligne souhaitée en pixels.

Renvoie QRectF avec les valeurs [xmin, ymin, width, height]. Les valeurs mesurées sont renvoyées dans l'espace de coordonnées local.

QRectF QCanvasPainter::textBoundingBox(const QString &text, const QRectF &rect) const

Mesure le cadre de délimitation d'une chaîne de caractères de type « text » disponible à l'adresse rect. Renvoie un objet de type « QRectF » contenant les valeurs [xmin, ymin, width, height]. Les valeurs mesurées sont renvoyées dans l'espace de coordonnées local.

QRectF QCanvasPainter::textBoundingBox(const QString &text, QPointF point, qreal maxWidth = 0) const

Mesure le cadre de délimitation d'une chaîne « text » à l'adresse point.

Pour mesurer du texte sur plusieurs lignes, définissez le mode de retour à la ligne à l’aide de la fonction setTextWrapMode() sur une valeur autre que la valeur par défaut NoWrap. Définissez également le paramètre facultatif maxWidth sur la largeur de ligne souhaitée en pixels.

Renvoie QRectF avec les valeurs [xmin, ymin, width, height]. Les valeurs mesurées sont renvoyées dans l'espace de coordonnées local.

void QCanvasPainter::transform(const QTransform &transform)

Multiplie le système de coordonnées actuel par l'transform e spécifiée.

Voir aussi setTransform().

void QCanvasPainter::translate(qreal x, qreal y)

Transforme le système de coordonnées actuel selon les fonctions x et y.

void QCanvasPainter::translate(QPointF point)

Translate le système de coordonnées actuel d'point.