QCanvasPath Class

// m_path is QCanvasPath with lots of commands in it
const int pathGroup = 5;

// in every frame:
  painter->stroke(m_path, pathGroup);
  // ... other draw commands
  painter->translate(100, 0);
  painter->stroke(m_path, pathGroup);
  // ... other draw commands

// m_path is QCanvasPath with lots of commands in it
const int pathGroup = 5;

// in every frame:
  painter->setStrokeWidth(4);
  painter->stroke(m_path, pathGroup);
  // ... other draw commands
  painter->translate(100, 0);
  painter->setStrokeWidth(8);
  painter->stroke(m_path, pathGroup);
  // ... other draw commands

Documentation des fonctions membres

QCanvasPath::QCanvasPath()

Crée un chemin vide.

[explicit] QCanvasPath::QCanvasPath(qsizetype commandsSize, qsizetype commandsDataSize = -1)

Crée un chemin vide, en allouant de l'espace pour un nombre de commandes défini par ` commandsSize ` et, éventuellement, pour un volume de données défini par ` commandsDataSize `. Si le paramètre ` commandsDataSize ` n'est pas fourni, de l'espace est automatiquement réservé pour le volume de données défini par ` 2 * commandsSize `, ce qui correspond à la quantité optimale lorsque les commandes du chemin sont des lignes droites (moveTo(), lineTo(), rect()).

La réservation d'un espace adéquat constitue une optimisation pour la création du chemin et l'utilisation de la mémoire. Elle n'est pas obligatoire, car un espace suffisant sera automatiquement garanti lors de l'ajout de commandes au chemin.

Voir également reserve().

QCanvasPath::QCanvasPath(const QCanvasPath &path)

Crée un chemin qui est une copie du chemin path.

[noexcept] QCanvasPath::QCanvasPath(QCanvasPath &&other)

Crée par « move » un nouvel objet `QCanvasPath` à partir de ` other`.

[noexcept] QCanvasPath::~QCanvasPath()

Supprime le chemin.

[since 6.12] void QCanvasPath::addPath(QStringView svgPath, const QTransform &transform = QTransform())

Ajoute un chemin de type « svgPath » à ce tracé, en utilisant éventuellement « transform » pour modifier les points du tracé. Si la taille estimée du tracé est connue, pensez à appeler « reserve() » au préalable.

Consultez la documentation W3C SVG Path Data pour plus de détails sur ce format.

Cette fonction a été introduite dans Qt 6.12.

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

Ajoute path à ce chemin, 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 QCanvasPath::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. Les plages start et count sont vérifiées, afin que les commandes ne soient pas accessibles au-delà de QCanvasPath::commandsSize(). Si le chemin ne doit pas se poursuivre à partir de la position actuelle, appelez d'abord moveTo() avec path.positionAt(start - 1).

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

Crée un arc centré sur QPointF(centerX, centerY) avec l'radius donné, commençant à un angle de a0 radians et se terminant à a1 radians. L'arc s'étend sur la direction donnée. Lorsque connection vaut NotConnected, le chemin précédent est fermé et un nouveau sous-chemin est créé.

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

Crée un arc centré sur centerPoint avec l'radius donné, commençant à un angle de a0 radians et se terminant à a1 radians. L'arc s'étend sur la direction donnée. Lorsque connection est égal à NotConnected, le chemin précédent est fermé et un nouveau sous-chemin est créé.

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

Crée un arc à partir des points QPointF(x1, y1) et QPointF(x2, y2) avec l'radius.

void QCanvasPath::arcTo(QPointF point1, QPointF point2, qreal radius)

Crée un arc à partir des points point1 et point2, avec l'radius donnée.

void QCanvasPath::beginHoleSubPath()

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

Voir également beginSolidSubPath().

void QCanvasPath::beginSolidSubPath()

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

Voir également beginHoleSubPath().

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

Ajoute une courbe de Bézier cubique entre la position actuelle et le point final spécifié par x et y, en utilisant les points de contrôle spécifiés par cp1X, cp1Y, cp2X et cp2Y.

Une fois la courbe ajoutée, la position actuelle est mise à jour pour se situer au point d'extrémité de la courbe.

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

Ajoute une courbe de Bézier cubique entre la position actuelle et l'endPoint e indiquée, en utilisant les points de contrôle spécifiés par controlPoint1 et controlPoint2.

Une fois la courbe ajoutée, la position actuelle est mise à jour pour se situer au point d'extrémité de la courbe.

void QCanvasPath::circle(qreal x, qreal y, qreal radius)

Ajoute au tracé un cercle dont le centre est situé à l'adresse QPointF(x, y) et dont le diamètre est spécifié par radius.

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

Ajoute au tracé un cercle dont le centre est situé à l'adresse centerPoint et dont le rayon est celui indiqué par ` radius `.

void QCanvasPath::clear()

Efface les commandes et les données du chemin.

Appelez cette fonction lorsque les commandes du chemin changent afin de recréer le chemin. Cela n'affecte pas l'utilisation de la mémoire ; utilisez plutôt reserve() et squeeze() à cette fin.

Voir également reserve() et squeeze().

void QCanvasPath::closePath()

Ferme le sous-trajet actuel en traçant une ligne jusqu'au début de celui-ci, ce qui lance automatiquement un nouveau trajet.

qsizetype QCanvasPath::commandsCapacity() const

Renvoie la capacité des commandes situées dans le chemin d'accès.

Voir également commandsDataCapacity() et reserve().

qsizetype QCanvasPath::commandsDataCapacity() const

Renvoie la taille des données de commandes présentes dans le chemin.

Voir également commandsCapacity() et reserve().

qsizetype QCanvasPath::commandsDataSize() const

Renvoie la quantité de données de commandes présentes dans le chemin.

Les données de commande correspondent essentiellement aux points requis par les commandes.

qsizetype QCanvasPath::commandsSize() const

Renvoie le nombre de commandes présentes dans le chemin.

QPointF QCanvasPath::currentPosition() const

Renvoie la position actuelle du chemin. Il s'agit de la position à laquelle la commande de chemin précédente (moveTo, lineTo, bezierCurveTo, etc.) s'est terminée. Lorsque le chemin est vide, renvoie (0,0, 0,0).

void QCanvasPath::ellipse(qreal x, qreal y, qreal radiusX, qreal radiusY)

Crée une ellipse centrée sur (x, y), dont les rayons sont définis par radiusX et radiusY, et l'ajoute au tracé en tant que sous-tracé fermé.

void QCanvasPath::ellipse(const QRectF &rect)

Crée une ellipse à l'intérieur du rectangle rect et l'ajoute au tracé en tant que sous-tracé fermé.

bool QCanvasPath::isEmpty() const

Renvoie « true » lorsque le chemin est vide.

Voir aussi clear.

void QCanvasPath::lineTo(QPointF point)

Ajoute une ligne droite reliant la position actuelle à l'point e indiquée. Une fois la ligne tracée, la position actuelle est mise à jour pour correspondre au point d'arrivée de la ligne.

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

Trace une ligne entre la position actuelle et le point (x, y).

void QCanvasPath::moveTo(QPointF point)

Déplace le point courant vers l'point indiquée, en créant implicitement un nouveau sous-trajet et en fermant le précédent.

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

Déplace la position courante vers (x, y) et lance un nouveau sous-trajet, en fermant implicitement le trajet précédent.

QPointF QCanvasPath::positionAt(qsizetype index) const

Renvoie la position du chemin dans index. Il s'agit de la position à laquelle se trouve la commande « path » (moveTo, lineTo, bezierCurveTo, etc.) dans index. L'indice doit être compris entre 0 et commandsSize() - 1. Si le chemin est vide, la fonction renvoie (0,0, 0,0).

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

Ajoute une courbe de Bézier quadratique entre le point actuel et le point d'arrivée (x, y), avec le point de contrôle spécifié par (cpX, cpY).

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

Ajoute une courbe de Bézier quadratique entre la position actuelle et l'endPoint e indiquée, avec le point de contrôle spécifié par controlPoint.

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

Crée un rectangle positionné aux coordonnées QPointF(x, y) avec les paramètres width et height.

void QCanvasPath::rect(const QRectF &rect)

Crée un rectangle défini par rect

void QCanvasPath::reserve(qsizetype commandsSize, qsizetype commandsDataSize = -1)

Réserve un certain espace dans la mémoire interne d'QCanvasPath.

Tente d'allouer de la mémoire pour au moins commandsSize commandes et commandsDataSize points de données. Certains éléments de chemin nécessitent plusieurs commandes, voir commandsSize() et commandsDataSize().

Si commandsDataSize n’est pas spécifié, de l’espace est alors automatiquement réservé pour 2 * commandsSize quantité de données, ce qui correspond à la quantité optimale lorsque les commandes du tracé sont des lignes droites (moveTo(), lineTo(), rect()).

La réservation d'un espace adéquat constitue une optimisation pour la création du chemin et l'utilisation de la mémoire. Elle n'est pas obligatoire, car un espace suffisant sera automatiquement garanti lors de l'ajout de commandes dans le chemin.

Voir également squeeze(), commandsCapacity() et commandsDataCapacity().

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

Ajoute au tracé le rectangle spécifié x, y, width, height avec des coins arrondis. Les coins sont des quarts de cercle définis par radius.

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

Ajoute au tracé les rectangles x, y, width et height, dont les coins sont arrondis. Les coins sont des quarts de cercle dont les rayons sont respectivement radiusTopLeft, radiusTopRight, radiusBottomRight et radiusBottomLeft.

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

Ajoute au tracé le rectangle spécifié rect avec des coins arrondis. Les coins sont des quarts de cercle dont les coordonnées sont spécifiées radius.

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

Ajoute au tracé le rectangle rect avec des coins arrondis. Les coins sont des quarts de cercle dont les rayons sont respectivement radiusTopLeft, radiusTopRight radiusBottomRight et radiusBottomLeft.

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

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

QCanvasPath QCanvasPath::sliced(qsizetype start, qsizetype count, const QTransform &transform = QTransform()) const

Renvoie un nouveau chemin contenant les commandes de ce chemin, à partir de la commande située à l'adresse start et comprenant count nombre de commandes, en utilisant éventuellement transform pour modifier les points du chemin.

La plage comprise entre start et count est vérifiée, afin que l'on n'accède pas à plus de commandsSize(). Si la commande située à l'adresse start n'est pas MoveTo, la première commande sera remplacée par MoveTo afin que cette tranche constitue un chemin distinct.

void QCanvasPath::squeeze()

Libère toute la mémoire qui n'est pas nécessaire au stockage des commandes et des données du chemin d'accès. Cette fonction peut être utilisée pour réduire l'utilisation de la mémoire après l'appel de la fonction ` reserve()`.

Normalement, cette fonction n’est pas nécessaire, mais elle peut s’avérer utile lorsque la taille du chemin est importante en raison de la réservation ou de l’ajout de nombreux éléments (lineTo, bezierCurveTo, etc.) et que l’on s’attend à ce qu’elle soit nettement réduite par la suite. Dans ce cas, appeler d’abord reserve() puis squeeze() permettra de libérer de la mémoire.

Voir également reserve().

[noexcept] void QCanvasPath::swap(QCanvasPath &other)

Permute ce chemin avec other. Cette opération est très rapide et ne rencontre jamais d'échec.

QCanvasPath::operator QVariant() const

Renvoie le chemin sous la forme « QVariant ».

[noexcept] QCanvasPath &QCanvasPath::operator=(QCanvasPath &&other)

Cette opération attribue l'other à cette instance QCanvasPath.

QCanvasPath &QCanvasPath::operator=(const QCanvasPath &path)

Attribue l'path on spécifiée à ce chemin et renvoie une référence à ce chemin.