QCanvasPainter Class

QRectF rect(40, 70, 120, 60);
QRectF shadowRect = rect.translated(2, 4);
// Paint shadow
QCanvasBoxShadow shadow(shadowRect, 30, 15, "#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, "#404040", "#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->setRenderHint(QCanvasPainter::RenderHint::DisableWindingEnforce);
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()

Construit un peintre.

[noexcept] QCanvasPainter::~QCanvasPainter()

Détruit le peintre.

qsizetype QCanvasPainter::activeImageCount() const

Renvoie le nombre d'objets QCanvasImage actifs enregistrés sur ce site QCanvasPainter. Cela inclut également les images créées en interne pour gradients.

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

Voir aussi activeImageMemoryUsage(), addImage() et removeImage().

qsizetype QCanvasPainter::activeImageMemoryUsage() const

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

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

Les toiles hors écran et les textures gérées en externe et enregistrées via les autres surcharges addImage() ne sont pas prises en compte par cette fonction.

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

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

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

Ajoute image avec flags disponible pour le peintre en tant que texture. Retourne QCanvasImage avec l'identifiant de la texture et d'autres informations sur l'image. L'image retournée QCanvasImage peut être utilisée avec drawImage et QCanvasImagePattern. Après l'appel de cette méthode, image QImage n'a pas besoin d'être conservé en mémoire.

L'appel à la même image est une opération peu coûteuse, puisqu'on s'attend à une réponse du cache.

Lors de l'optimisation, il faut veiller à n'appeler addImage() qu'une seule fois. Cela n'est pas toujours suffisant, en fonction de la conception de l'application. Par exemple, si les ressources graphiques sous-jacentes sont perdues, par exemple parce que le peintre est associé à un nouveau QRhi sous le capot en raison du déplacement d'un widget vers un nouveau niveau supérieur, l'appel à 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'indicateur NativeTexture est défini implicitement. Le fichier QCanvasImage retourné peut être utilisé avec drawImage et QCanvasImagePattern.

Voir aussi drawImage() et removeImage().

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

Enregistre canvas avec flags auprès du peintre afin qu'il soit disponible en tant qu'image. L'image QCanvasImage renvoyée peut être utilisée avec drawImage et QCanvasImagePattern.

Voir également drawImage() et removeImage().

void QCanvasPainter::addPath(const QPainterPath &path)

Ajoute path au chemin 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 d'une matrice d'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 commençant par la commande start et en incluant le nombre de commandes count. Il est possible d'utiliser transform pour modifier les points du chemin. La plage de start et count est vérifiée, de sorte que les commandes ne sont pas accédées plus que QCanvasPath::commandsSize(). Si le chemin ne doit pas continuer à partir de la position actuelle du chemin, appeler d'abord moveTo(), par exemple avec path.positionAt(start - 1).

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

Crée un nouveau sous-chemin en forme d'arc de cercle. Le centre de l'arc est situé à centerX, centerY, avec radius, et l'arc est dessiné de l'angle a0 à a1, et balayé à direction (ClockWise ou CounterClockWise). Lorsque connection est NotConnected, l'arc n'ajoute pas de ligne entre la position du chemin précédent et le début de l'arc. Les angles sont spécifiés en radians.

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

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

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

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

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

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

void QCanvasPainter::beginHoleSubPath()

Commencer un sous-chemin de trou. Ceci est équivalent à setPathWinding(QCanvasPainter::PathWinding::ClockWise))

Voir aussi beginSolidSubPath().

void QCanvasPainter::beginPath()

Commence à dessiner une nouvelle trajectoire tout en effaçant la trajectoire actuelle.

void QCanvasPainter::beginSolidSubPath()

Commencer un sous-chemin solide. Ceci est équivalent à setPathWinding(QCanvasPainter::PathWinding::CounterClockWise))

Voir aussi beginHoleSubPath().

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

Ajoute un segment de bézier cubique à partir du dernier point de la trajectoire via deux points de contrôle (cp1X, cp1Y et cp2X, cp2Y) jusqu'au point spécifié (x, y).

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

Ajoute un segment de bézier cubique à partir du dernier point de la trajectoire via deux points de contrôle (controlPoint1 et controlPoint2) jusqu'au point spécifié endPoint.

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

Crée un nouveau sous-chemin en forme de cercle dans ( centerX, centerY) avec radius.

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

Crée un nouveau sous-chemin en forme de cercle dans centerPoint avec radius.

void QCanvasPainter::cleanupResources()

Planifie l'élimination des textures inutilisées du cache.

En outre, 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 conduire à des appels de dessin plus coûteux par la suite.

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

Efface les pixels d'une zone rectangulaire en remplissant le rectangle spécifié par x, y, width, height avec du noir transparent. Comme l'effacement ne nécessite pas de mélange, il peut être 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-chemin actuel avec un segment de ligne. Cela équivaut à lineTo([point de départ]) comme dernier élément du chemin.

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

Renvoie un nouveau canevas hors écran avec les données pixelSize, sampleCount, et flags.

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

Pour cibler un canevas hors écran avec des commandes de dessin, appelez la surcharge QCanvasRhiPaintDriver::beginPaint() appropriée si vous travaillez avec l'API de niveau inférieur, ou QCanvasPainterWidget::beginCanvasPainting() ou QCanvasPainterItemRenderer::beginCanvasPainting() si vous utilisez les classes de widget de commodité ou d'élément Qt Quick.

Normalement, le contenu du canevas est effacé lorsque l'on peint dessus. Pour désactiver cette fonction, passez PreserveContents dans flags.

Pour demander un rendu multi-échantillon sur le canevas (anti-crénelage multi-échantillon, MSAA), définissez un nombre d'échantillons supérieur à 1, par exemple 4 ou 8. La préservation du contenu du canevas entre les passes de rendu n'est cependant pas prise en charge lorsque le multi-échantillonnage est activé, et le drapeau PreserveContents ne fonctionnera pas dans ce cas.

void QCanvasPainter::destroyCanvas(QCanvasOffscreenCanvas &canvas)

Détruit les ressources qui soutiennent canvas. canvas devient alors null canvas.

Le peintre le fait automatiquement lors de sa destruction. Par conséquent, l'appel à cette fonction n'est nécessaire que lorsque la libération des ressources associées est souhaitée immédiatement.

float QCanvasPainter::devicePixelRatio() const

Renvoie le rapport entre les pixels physiques et les pixels indépendants du périphérique. La valeur par défaut est 1.0.

void QCanvasPainter::drawBoxShadow(const QCanvasBoxShadow &shadow)

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

Voir également QCanvasBoxShadow.

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

Dessine image dans x, y, à sa taille par défaut.

Voir aussi addImage().

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

Dessine image à la position et à la taille de destinationRect.

Voir aussi addImage().

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

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

Voir aussi addImage().

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

Dessine image en x, y, à width et height.

Voir aussi addImage().

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

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

void QCanvasPainter::ellipse(const QRectF &rect)

Crée un nouveau sous-chemin en forme d'ellipse dans rect. Cette ellipse couvrira la zone rect.

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

Crée un nouveau sous-chemin en forme d'ellipse dans centerPoint avec radiusX et radiusY.

void QCanvasPainter::fill()

Remplit le chemin actuel avec le style de remplissage actuel.

Voir également setFillStyle().

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

Remplit path avec le style de remplissage actuel et appartient à pathGroup. La peinture à travers QCanvasPath est optimale lorsque le chemin contient plus de commandes et qu'il est principalement statique. Par défaut, pathGroup est 0, ce qui permet d'utiliser le premier groupe. Lorsque pathGroup est -1, le chemin ne sera pas mis en cache du côté du GPU. Plus d'informations sur l'utilisation des groupes de cache de chemin dans la documentation de QCanvasPath. Il n'est pas nécessaire d'appeler beginPath() avant cette méthode.

Voir également setFillStyle().

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

Dessine un rectangle rempli à la position spécifiée ( x, y) à la taille 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, float x, float y, float maxWidth = -1)

Dessine la chaîne text à l'emplacement spécifié ( x, y), avec les paramètres textAlign et textBaseline actuels. Pour que le texte s'étende sur plusieurs lignes, le paramètre facultatif maxWidth doit correspondre à la largeur de ligne souhaitée en pixels. Les espaces blancs sont supprimés au début des lignes, le texte est scindé aux limites des mots ou lorsque des caractères de nouvelle ligne sont rencontrés. Les mots plus longs que la largeur maximale sont coupés au caractère le plus proche (c'est-à-dire qu'il n'y a pas de césure).

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

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

Il s'agit d'une méthode surchargée qui utilise QRectF. Il est souvent utile de fixer la ligne de base du texte à TextBaseline::Top ou TextBaseline::Middle lorsque l'on peint du texte avec cette méthode.

void QCanvasPainter::fillText(const QString &text, QPointF point, float maxWidth = -1)

Dessine la chaîne text à l'emplacement spécifié point, avec les paramètres textAlign et textBaseline actuels. Pour que le texte s'étende sur plusieurs lignes, le paramètre facultatif maxWidth doit correspondre à la largeur de ligne souhaitée en pixels. Les espaces blancs sont supprimés au début des lignes, le texte est scindé aux limites des mots ou lorsque des caractères de nouvelle ligne sont rencontrés. Les mots plus longs que la largeur maximale sont coupés au caractère le plus proche (c'est-à-dire sans césure).

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

QTransform QCanvasPainter::getTransform() const

Renvoie la transformation actuelle.

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

Ajoute un segment de ligne à partir du dernier point du chemin jusqu'au point ( x, y).

void QCanvasPainter::lineTo(QPointF point)

Ajoute un segment de ligne depuis le dernier point du chemin jusqu'à point.

[static] float QCanvasPainter::mmToPx(float mm)

Méthode d'aide statique pour convertir les millimètres mm en pixels. Cela permet de réaliser des dessins indépendants de la résolution. Par exemple, pour définir la largeur de la ligne à 2 mm, utilisez :

painter->setLineWidth(QCanvasPainter::mmToPx(2)) ;

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

Commence un nouveau sous-chemin avec ( x, y) comme premier point.

void QCanvasPainter::moveTo(QPointF point)

Commence un nouveau sous-chemin avec point comme premier point.

[static] float QCanvasPainter::ptToPx(float pt)

Méthode d'aide statique pour convertir les points pt en pixels.

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

Ajoute un segment de bézier quadratique à partir du dernier point de la trajectoire via un point de contrôle (cpX, cpY) jusqu'au point spécifié (x, y).

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

Ajoute un segment de bézier quadratique à partir du dernier point de la trajectoire via une adresse controlPoint jusqu'à l'adresse endPoint spécifiée.

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

Crée un nouveau sous-chemin en forme de rectangle à la position x, y avec la taille width, height.

void QCanvasPainter::rect(const QRectF &rect)

Crée un nouveau sous-chemin en forme de rectangle à 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 peintre.

Voir également addImage().

void QCanvasPainter::removePathGroup(int pathGroup)

Supprime pathGroup du cache des peintres. L'appel à fill() ou stroke() pour pathGroup après ceci, régénérera le chemin dans le cache du groupe.

Voir aussi fill() et stroke().

QCanvasPainter::RenderHints QCanvasPainter::renderHints() const

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

Voir aussi setRenderHints() et setRenderHint().

void QCanvasPainter::reset()

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

Voir également save() et restore().

void QCanvasPainter::resetClipping()

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

Voir également setClipRect().

void QCanvasPainter::resetTransform()

Réinitialise la transformation actuelle à une matrice d'identité.

void QCanvasPainter::restore()

Supprime et restaure l'état actuel du rendu. L'état précédemment sauvegardé sera donc restauré. Si save() n'a pas été appelé et que la pile d'état est vide, cet appel ne fait rien.

Voir aussi save().

void QCanvasPainter::rotate(float angle)

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

L'angle est spécifié en radians. Utilisez qDegreesToRadians() pour convertir les degrés en radians.

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

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

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

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

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

Crée un nouveau sous-chemin en forme de rectangle arrondi à l'adresse rect. L'arrondi des coins peut varier d'un coin à l'autre, avec radiusTopLeft, radiusTopRight, radiusBottomRight, radiusBottomLeft.

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

Crée un nouveau sous-chemin en forme de rectangle arrondi à la position x, y avec la taille width, height. L'arrondi des coins peut varier selon les coins, avec radiusTopLeft, radiusTopRight, radiusBottomRight, radiusBottomLeft.

void QCanvasPainter::save()

Repousse et enregistre l'état de rendu actuel dans une pile d'états. Un restore() correspondant doit être utilisé pour restaurer l'état.

Voir aussi restore().

void QCanvasPainter::scale(float scale)

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

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

Met à l'échelle le système de coordonnées actuel en fonction de scaleX et scaleY.

void QCanvasPainter::setAntialias(float antialias)

Fixe la valeur actuelle de l'anticrénelage à antialias en pixels. Plus il y a d'anticrénelage, plus la peinture est lisse. Cela n'affecte que la peinture de remplissage et de trait, pas 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é par chemin, de sorte qu'il peut être défini avant chaque trait/remplissage. Pour désactiver l'anticrénelage sur l'ensemble de la toile, utilisez QCanvasPainter::RenderHint::Antialiasing render hint.

Voir également setRenderHints() et setTextAntialias().

void QCanvasPainter::setBrushTransform(const QTransform &transform)

Définit la transformation actuelle de la brosse à transform. Cette transformation s'applique aux brosses de trait et de remplissage.

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

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

Voir aussi resetClipping().

void QCanvasPainter::setClipRect(const QRectF &rect)

Définit le rectangle de ciseaux actuel à rect. Le rectangle de ciseaux est transformé par le transformateur actuel.

Voir également resetClipping().

void QCanvasPainter::setFillStyle(const QColor &color)

Définit le style de remplissage à un solide color. Le style de remplissage par défaut est un solide de couleur noire (0, 0, 0, 1).

void QCanvasPainter::setFillStyle(const QCanvasBrush &brush)

Définit le style de remplissage à brush. Le style de remplissage par défaut est la couleur noire unie (0, 0, 0, 1).

void QCanvasPainter::setFont(const QFont &font)

Définit la police font comme police active.

void QCanvasPainter::setGlobalAlpha(float alpha)

Fixe la valeur alpha globale (transparence) à alpha. Cette valeur alpha est appliquée à toutes les formes rendues. Les chemins déjà transparents deviendront proportionnellement plus transparents. La valeur alpha doit être comprise entre 0,0 (totalement transparent) et 1,0 (totalement opaque). Par défaut, la valeur alpha est 1.0.

void QCanvasPainter::setGlobalBrightness(float value)

Fixe la luminosité globale à value. Cette luminosité est appliquée à toutes les formes rendues. Une valeur de 0 rendra la peinture complètement noire. 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 est appliqué à toutes les opérations de peinture. Le mode par défaut est QCanvasPainter::CompositeOperation::SourceOver.

void QCanvasPainter::setGlobalContrast(float value)

Définit le contraste global à value. Ce contraste est appliqué à toutes les formes rendues. Une valeur de 0 rendra la peinture complètement grise (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::setGlobalSaturate(float value)

Définit la saturation globale à value. Cette saturation est appliquée à toutes les formes rendues. Une valeur de 0 désactivera la saturation et fera en sorte que la peinture soit 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::setLineCap(QCanvasPainter::LineCap cap)

Fixe la fin de la ligne de stoke à cap. La fin de ligne par défaut est QCanvasPainter::LineCap::Butt.

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

Définit la jointure de ligne du trait à join. La jointure de ligne par défaut est QCanvasPainter::LineJoin::Miter.

Voir également setMiterLimit().

void QCanvasPainter::setLineWidth(float width)

Définit la largeur de ligne du trait à width en pixels. La largeur de ligne par défaut est 1.0. Lorsque l'anticrénelage est activé, les largeurs de ligne inférieures à un pixel diminuent automatiquement l'opacité, créant ainsi une sortie lisse.

Voir également stroke().

void QCanvasPainter::setMiterLimit(float limit)

Règle la limite d'onglet sur limit. La limite d'onglet contrôle le moment où un angle aigu est biseauté. Lorsque la longueur de l'angle dépasse cette limite, QCanvasPainter::LineJoin::Bevel est appliqué entre les lignes. Cela n'a d'effet qu'avec la jonction de lignes QCanvasPainter::LineJoin::Miter. La limite par défaut est 10.0.

Voir aussi setLineJoin().

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

Définit le sous-chemin actuel winding en CounterClockWise (par défaut) ou ClockWise. CounterClockWise dessine des sous-chemins pleins tandis que ClockWise dessine des trous.

Voir aussi beginHoleSubPath() et beginSolidSubPath().

void QCanvasPainter::setRenderHint(QCanvasPainter::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() et renderHints().

void QCanvasPainter::setRenderHints(QCanvasPainter::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() et renderHints().

void QCanvasPainter::setStrokeStyle(const QColor &color)

Définit le style de trait à un solide color. Le style de trait par défaut est une couleur noire solide (0, 0, 0, 1).

void QCanvasPainter::setStrokeStyle(const QCanvasBrush &brush)

Définit le style de trait à brush. Le style de trait par défaut est une couleur noire unie (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 aussi setTextBaseline().

void QCanvasPainter::setTextAntialias(float antialias)

Définit la valeur actuelle de l'anti-crénelage du texte. La valeur antialias est un multiplicateur de l'anticrénelage normal, ce qui signifie que 0.0 désactive l'anticrénelage et que 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 la direction du texte à direction. La direction par défaut est QCanvasPainter::TextDirection::Inherit.

void QCanvasPainter::setTextLineHeight(float height)

Définit l'ajustement de la hauteur de ligne en pixels à height pour le texte enveloppé. La hauteur de ligne par défaut est 0.

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

Définit le mode d'habillage du texte à wrapMode. Le mode d'habillage par défaut est QCanvasPainter::WrapMode::NoWrap.

void QCanvasPainter::setTransform(const QTransform &transform)

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

Voir aussi transform().

void QCanvasPainter::skew(float angleX, float angleY = 0.0f)

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

void QCanvasPainter::stroke()

Trace le chemin actuel avec le style de trait actuel.

Voir également setStrokeStyle().

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

Trace le path avec le style de trait actuel et l'appartenance au pathGroup. Peindre à travers QCanvasPath est optimal lorsque le chemin contient plus de commandes et qu'il est principalement statique. Par défaut, pathGroup est 0, ce qui permet d'utiliser le premier groupe. Lorsque pathGroup est -1, le chemin ne sera pas mis en cache du côté du GPU. Plus d'informations sur l'utilisation des groupes de cache de chemin dans la documentation de QCanvasPath. Il n'est pas nécessaire d'appeler beginPath() avant cette méthode.

Voir également setStrokeStyle().

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

Dessine un rectangle stoked à la position spécifiée ( x, y) à la taille width, height.

void QCanvasPainter::strokeRect(const QRectF &rect)

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

QRectF QCanvasPainter::textBoundingBox(const QString &text, float x, float y, float maxWidth = -1)

Mesure le cadre d'une chaîne text à (x, y). Pour mesurer un texte sur plusieurs lignes, définissez le paramètre facultatif maxWidth sur la largeur de ligne souhaitée en pixels. Renvoie QRectF avec les valeurs [xmin, ymin, largeur, hauteur]. Les valeurs mesurées sont renvoyées dans l'espace de coordonnées locales.

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

Mesure la boîte de délimitation d'une chaîne text à rect. 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, QPointF point, float maxWidth = -1)

Mesure le cadre d'une chaîne de caractères text à l'adresse point. Pour mesurer un texte sur plusieurs lignes, définissez le paramètre facultatif maxWidth sur la largeur de ligne souhaitée en pixels. Retourne QRectF avec les valeurs [xmin, ymin, largeur, hauteur]. 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 la valeur spécifiée transform.

Voir également setTransform().

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

Traduit le système de coordonnées actuel par x et y.

void QCanvasPainter::translate(QPointF point)

Traduit le système de coordonnées actuel par point.