QPainterPath Class

QPainterPath path;
path.addRect(20, 20, 60, 60);

path.moveTo(0, 0);
path.cubicTo(99, 0,  50, 50,  99, 99);
path.cubicTo(0, 99,  50, 50,  0, 0);

QPainter painter(this);
painter.fillRect(0, 0, 100, 100, Qt::white);
painter.setPen(QPen(QColor(79, 106, 25), 1, Qt::SolidLine,
                    Qt::FlatCap, Qt::MiterJoin));
painter.setBrush(QColor(122, 163, 39));

painter.drawPath(path);

Documentation des fonctions membres

[noexcept] QPainterPath::QPainterPath()

Crée un objet QPainterPath vide.

[explicit] QPainterPath::QPainterPath(const QPointF &startPoint)

Crée un objet `QPainterPath` dont la position actuelle correspond à l'startPoint e indiquée.

QPainterPath::QPainterPath(const QPainterPath &path)

Crée un objet `QPainterPath` qui est une copie de l'objet ` path` fourni.

Voir aussi operator=().

[noexcept, since 6.10] QPainterPath::QPainterPath(QPainterPath &&other)

La fonction `Move` construit un nouveau chemin de peinture à partir de ` other`.

L'objet d'origine other est placé dans l'état de construction par défaut.

Cette fonction a été introduite dans Qt 6.10.

[noexcept] QPainterPath::~QPainterPath()

Supprime cet objet « QPainterPath ».

void QPainterPath::addEllipse(const QRectF &boundingRectangle)

Crée une ellipse dans l'boundingRectangle spécifiée et l'ajoute au tracé du peintre en tant que sous-tracé fermé.

L'ellipse est composée d'une courbe dans le sens des aiguilles d'une montre, commençant et se terminant à zéro degré (position 3 heures). La courbe est une approximation cubique de Bézier de l'ellipse, et non une représentation exacte de celle-ci, comme décrit dans Arcs and Ellipses.

Voir également arcTo(), QPainter::drawEllipse() et Composing a QPainterPath.

void QPainterPath::addEllipse(const QPointF &center, qreal rx, qreal ry)

Crée une ellipse positionnée à l'center, avec des rayons rx et ry, et l'ajoute au tracé du peintre en tant que sous-tracé fermé.

void QPainterPath::addEllipse(qreal x, qreal y, qreal width, qreal height)

Crée une ellipse à l'intérieur du rectangle englobant défini par son coin supérieur gauche situé en (x, y), width et height, et l'ajoute au tracé du peintre en tant que sous-tracé fermé.

void QPainterPath::addPath(const QPainterPath &path)

Ajoute l'path on indiquée à ce chemin en tant que sous-chemin fermé.

Voir également connectPath() et Composing a QPainterPath.

void QPainterPath::addPolygon(const QPolygonF &polygon)

Ajoute l'polygon on indiquée au chemin en tant que sous-chemin (non fermé).

Notez qu’après l’ajout du polygone, la position courante correspond au dernier point de ` polygon`. Pour tracer une ligne revenant au premier point, utilisez la fonction ` closeSubpath()`.

Voir également lineTo() et Composing a QPainterPath.

void QPainterPath::addRect(const QRectF &rectangle)

Ajoute l'rectangle on indiquée à ce chemin sous forme de sous-chemin fermé.

L'rectangle est ajoutée sous la forme d'un ensemble de lignes dans le sens des aiguilles d'une montre. La position actuelle du chemin de dessin après l'ajout de l'rectangle se trouve dans le coin supérieur gauche du rectangle.

Voir également addRegion(), lineTo() et Composing a QPainterPath.

void QPainterPath::addRect(qreal x, qreal y, qreal width, qreal height)

Ajoute un rectangle à la position (x, y), avec les paramètres width et height fournis, sous la forme d'un sous-trajet fermé.

void QPainterPath::addRegion(const QRegion &region)

Ajoute la région « region » indiquée au tracé en intégrant chaque rectangle de cette région sous forme de sous-tracé fermé distinct.

Voir également ` addRect()` et ` Composing a QPainterPath`.

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

Ajoute au tracé le rectangle rect spécifié, dont les coins sont arrondis.

Les arguments ` xRadius ` et ` yRadius ` spécifient les rayons des ellipses définissant les coins du rectangle arrondi. Lorsque ` mode ` est défini sur ` 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.

Voir également addRect().

void QPainterPath::addRoundedRect(qreal x, qreal y, qreal w, qreal h, qreal xRadius, qreal yRadius, Qt::SizeMode mode = Qt::AbsoluteSize)

Ajoute au tracé le rectangle spécifié x, y, w, h avec des coins arrondis.

void QPainterPath::addText(const QPointF &point, const QFont &font, const QString &text)

Ajoute l'text donné à ce chemin sous la forme d'un ensemble de sous-chemins fermés créés à partir de l'font fournie. Les sous-chemins sont positionnés de manière à ce que l'extrémité gauche de la ligne de base du texte se trouve à l'point spécifiée.

Certaines polices peuvent générer des sous-chemins qui se chevauchent et nécessiteront la règle de remplissage Qt::WindingFill pour un rendu correct.

Voir également QPainter::drawText(), Composing a QPainterPath et setFillRule().

void QPainterPath::addText(qreal x, qreal y, const QFont &font, const QString &text)

Ajoute l'text on fournie à ce chemin sous la forme d'un ensemble de sous-chemins fermés créés à partir de l'font on fournie. Les sous-chemins sont positionnés de manière à ce que l'extrémité gauche de la ligne de base du texte se trouve au point spécifié par (x, y).

qreal QPainterPath::angleAtPercent(qreal t) const

Renvoie l'angle de la tangente au tracé au pourcentage t. L'argument t doit être compris entre 0 et 1.

Les valeurs positives de l'angle correspondent à un sens antihoraire, tandis que les valeurs négatives correspondent à un sens horaire. Zéro degré correspond à la position 3 heures.

Notez que, comme pour les autres méthodes de pourcentage, la mesure en pourcentage n'est pas linéaire par rapport à la longueur si le tracé comporte des courbes. En présence de courbes, l'argument de pourcentage est mappé sur le paramètre t des équations de Bézier.

void QPainterPath::arcMoveTo(const QRectF &rectangle, qreal angle)

Crée un mouvement situé sur l'arc correspondant à l'rectangle donnée à l'adresse angle.

Les angles sont spécifiés en degrés. Les arcs dans le sens des aiguilles d’une montre peuvent être spécifiés à l’aide d’angles négatifs. Si rectangle n’est pas un carré, angle est un angle excentrique et ne mesure pas la direction à partir du centre du rectangle, comme décrit dans Arcs and Ellipses.

Voir également moveTo(), arcTo() et Arcs and Ellipses.

void QPainterPath::arcMoveTo(qreal x, qreal y, qreal width, qreal height, qreal angle)

Crée un mouvement situé sur l'arc qui relie les points QRectF(x, y, width, height) sur angle.

void QPainterPath::arcTo(const QRectF &rectangle, qreal startAngle, qreal sweepLength)

Crée un arc qui occupe l'rectangle donnée, en partant de l'startAngle spécifiée et s'étendant de sweepLength degrés dans le sens antihoraire.

Les angles sont exprimés en degrés. Les arcs dans le sens des aiguilles d’une montre peuvent être spécifiés à l’aide d’angles négatifs. Si rectangle n’est pas un rectangle, les angles sont des angles excentriques et ne mesurent pas la direction à partir du centre du rectangle, comme décrit dans Arcs and Ellipses.

Notez que cette fonction relie le point de départ de l’arc à la position courante s’ils ne sont pas déjà reliés. Une fois l’arc ajouté, la position courante correspond au dernier point de l’arc. Pour tracer une ligne revenant au premier point, utilisez la fonction closeSubpath().

Voir également arcMoveTo(), addEllipse(), QPainter::drawArc(), QPainter::drawPie() et Composing a QPainterPath.

void QPainterPath::arcTo(qreal x, qreal y, qreal width, qreal height, qreal startAngle, qreal sweepLength)

Crée un arc qui occupe le rectangle QRectF(x, y, width, height), partant de l'startAngle e spécifiée et s'étendant sur sweepLength degrés dans le sens inverse des aiguilles d'une montre.

QRectF QPainterPath::boundingRect() const

Renvoie le rectangle englobant de ce tracé de dessin sous la forme d'un rectangle avec une précision en virgule flottante.

Voir également controlPointRect().

int QPainterPath::capacity() const

Renvoie le nombre d'éléments alloués par la fonction ` QPainterPath`.

Voir également clear() et reserve().

void QPainterPath::clear()

Efface les éléments du chemin enregistrés.

Cela permet au chemin de réutiliser les allocations de mémoire précédentes.

Voir également reserve() et capacity().

void QPainterPath::closeSubpath()

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

Si le sous-trajet ne contient aucun élément, cette fonction ne fait rien.

Voir également moveTo() et Composing a QPainterPath.

void QPainterPath::connectPath(const QPainterPath &path)

Relie le chemin « path » à ce chemin en ajoutant une ligne reliant le dernier élément de ce dernier au premier élément du chemin spécifié.

Voir également addPath() et Composing a QPainterPath.

bool QPainterPath::contains(const QPainterPath &p) const

Renvoie « true » si le chemin donné p est contenu dans le chemin actuel. Renvoie « false » si des arêtes du chemin actuel et de p se croisent.

Les opérations d’ensemble sur les chemins traitent ces derniers comme des zones. Les chemins non fermés sont traités comme implicitement fermés.

Voir également intersects().

bool QPainterPath::contains(const QPointF &point) const

Renvoie « true » si l'point on fournie se trouve dans le chemin d'accès, sinon renvoie « false ».

Voir aussi intersects().

bool QPainterPath::contains(const QRectF &rectangle) const

Renvoie « true » si l'rectangle on fournie se trouve dans le chemin d'accès, sinon renvoie « false ».

QRectF QPainterPath::controlPointRect() const

Renvoie le rectangle contenant tous les points et points de contrôle de ce tracé.

Cette fonction est nettement plus rapide à calculer que la fonction exacte ` boundingRect()`, et le rectangle renvoyé est toujours un sur-ensemble du rectangle renvoyé par ` boundingRect()`.

Voir également boundingRect().

void QPainterPath::cubicTo(const QPointF &c1, const QPointF &c2, const QPointF &endPoint)

Ajoute une courbe de Bézier cubique entre la position actuelle et l'endPoint e indiquée, à l'aide des points de contrôle spécifiés par c1 et c2.

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

Voir également quadTo() et Composing a QPainterPath.

void QPainterPath::cubicTo(qreal c1X, qreal c1Y, qreal c2X, qreal c2Y, qreal endPointX, qreal endPointY)

Ajoute une courbe de Bézier cubique entre la position actuelle et le point final (endPointX, endPointY) avec des points de contrôle définis par (c1X, c1Y) et (c2X, c2Y).

QPointF QPainterPath::currentPosition() const

Renvoie la position actuelle du chemin.

QPainterPath::Element QPainterPath::elementAt(int index) const

Renvoie l'élément situé à l'index indiquée dans le chemin du peintre.

Voir également ElementType, elementCount() et isEmpty().

int QPainterPath::elementCount() const

Renvoie le nombre d'éléments du chemin de dessin.

Voir également ElementType, elementAt() et isEmpty().

Qt::FillRule QPainterPath::fillRule() const

Renvoie la règle de remplissage actuellement définie pour le chemin de dessin.

Voir aussi setFillRule().

QPainterPath QPainterPath::intersected(const QPainterPath &p) const

Renvoie un chemin correspondant à l'intersection entre la zone de remplissage de ce chemin et celle de p. Les courbes de Bézier peuvent être aplaties en segments de droite en raison de l'instabilité numérique liée au calcul des intersections de courbes de Bézier.

bool QPainterPath::intersects(const QPainterPath &p) const

Renvoie « true » si le chemin actuel croise en un point quelconque le chemin donné « p ». Renvoie également « true » si le chemin actuel contient ou est contenu par une partie quelconque de « p ».

Les opérations d’ensemble sur les chemins traitent ces derniers comme des zones. Les chemins non fermés sont traités comme étant implicitement fermés.

Voir également contains().

bool QPainterPath::intersects(const QRectF &rectangle) const

Renvoie « true » si un point quelconque de l'rectangle e donné coupe le chemin ; sinon, renvoie « false ».

Il y a intersection si l’une des lignes constituant le rectangle croise une partie du tracé ou si une partie du rectangle chevauche une zone délimitée par le tracé. Cette fonction tient compte de l’ fillRule actuelle pour déterminer ce qui est considéré comme étant à l’intérieur du tracé.

Voir également contains().

[since 6.10] bool QPainterPath::isCachingEnabled() const

Renvoie « true » si la mise en cache est activée ; sinon, renvoie « false ».

Cette fonction a été introduite dans Qt 6.10.

Voir aussi setCachingEnabled().

bool QPainterPath::isEmpty() const

Renvoie « true » s'il n'y a aucun élément dans ce chemin ou si le seul élément est un « MoveToElement » ; sinon, renvoie « false ».

Voir également elementCount().

qreal QPainterPath::length() const

Renvoie la longueur du chemin actuel.

void QPainterPath::lineTo(const QPointF &endPoint)

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

Voir également addPolygon(), addRect() et Composing a QPainterPath.

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

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

void QPainterPath::moveTo(const QPointF &point)

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

Voir également closeSubpath() et Composing a QPainterPath.

void QPainterPath::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.

qreal QPainterPath::percentAtLength(qreal len) const

Renvoie le pourcentage de la longueur totale du tracé correspondant à la longueur spécifiée len.

Notez que, comme pour les autres méthodes de type « % », la mesure du pourcentage n'est pas linéaire par rapport à la longueur si le tracé comporte des courbes. En présence de courbes, l'argument « % » est mappé sur le paramètre t des équations de Bézier.

QPointF QPainterPath::pointAtPercent(qreal t) const

Renvoie le point situé à l't, exprimée en pourcentage, du chemin actuel. L'argument t doit être compris entre 0 et 1.

Notez que, comme pour les autres méthodes de pourcentage, la mesure en pourcentage n'est pas linéaire par rapport à la longueur si le tracé comporte des courbes. En présence de courbes, l'argument de pourcentage est mappé sur le paramètre t des équations de Bézier.

void QPainterPath::quadTo(const QPointF &c, const 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 c.

Une fois la courbe ajoutée, le point actuel est mis à jour pour se situer à l'extrémité de la courbe.

Voir également cubicTo() et Composing a QPainterPath.

void QPainterPath::quadTo(qreal cx, qreal cy, qreal endPointX, qreal endPointY)

Ajoute une courbe de Bézier quadratique entre le point actuel et le point d'arrivée (endPointX, endPointY) avec le point de contrôle spécifié par (cx, cy).

void QPainterPath::reserve(int size)

Réserve un nombre donné d'éléments dans la mémoire interne d'QPainterPath.

Tente d'allouer de la mémoire pour au moins size éléments.

Voir également clear(), capacity() et QList::reserve().

[since 6.10] void QPainterPath::setCachingEnabled(bool enabled)

Active ou désactive la mise en cache des longueurs en fonction de la valeur de ` enabled`.

L'activation de la mise en cache accélère les appels répétés aux fonctions membres impliquant des valeurs de longueur de chemin et de pourcentage, telles que ` length()`, ` percentAtLength()`, ` pointAtPercent()` etc., au prix d'une utilisation supplémentaire de mémoire pour le stockage des calculs intermédiaires. Par défaut, cette fonctionnalité est désactivée.

La désactivation de la mise en cache libère toute la mémoire allouée au cache.

Cette fonction a été introduite dans Qt 6.10.

Voir également isCachingEnabled(), length(), percentAtLength(), pointAtPercent() et trimmed().

void QPainterPath::setElementPositionAt(int index, qreal x, qreal y)

Définit les coordonnées x et y de l'élément situé à l'index index sur x et y respectivement.

void QPainterPath::setFillRule(Qt::FillRule fillRule)

Définit la règle de remplissage du tracé du peintre selon l'fillRule spécifiée. Qt propose deux méthodes pour remplir les tracés :

Voir également fillRule().

QPainterPath QPainterPath::simplified() const

Renvoie une version simplifiée de ce tracé. Cela implique de fusionner tous les sous-tracés qui se croisent et de renvoyer un tracé ne contenant aucune arête qui se croise. Les lignes parallèles consécutives seront également fusionnées. Le tracé simplifié utilisera toujours la règle de remplissage par défaut, Qt::OddEvenFill. Les courbes de Bézier peuvent être aplaties en segments de droite en raison de l'instabilité numérique liée au calcul des intersections de courbes de Bézier.

qreal QPainterPath::slopeAtPercent(qreal t) const

Renvoie la pente du tracé au pourcentage t. L'argument t doit être compris entre 0 et 1.

Notez que, comme pour les autres méthodes de pourcentage, la mesure en pourcentage n'est pas linéaire par rapport à la longueur si le chemin comporte des courbes. En présence de courbes, l'argument de pourcentage est mappé sur le paramètre t des équations de Bézier.

QPainterPath QPainterPath::subtracted(const QPainterPath &p) const

Renvoie un tracé correspondant à la différence entre la surface de remplissage de p et celle de ce tracé.

Les opérations d'union sur les chemins traitent ces derniers comme des zones. Les chemins non fermés sont traités comme implicitement fermés. Les courbes de Bézier peuvent être aplaties en segments de droite en raison de l'instabilité numérique liée au calcul des intersections de courbes de Bézier.

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

Remplace ce chemin d'accès par other. Cette opération est très rapide et ne pose jamais de problème.

QPolygonF QPainterPath::toFillPolygon(const QTransform &matrix = QTransform()) const

Convertit le tracé en polygone à l’aide de la fonction « QTransform » matrix, puis renvoie le polygone.

Le polygone est créé en convertissant d'abord tous les sous-trajets en polygones, puis en utilisant une technique de « rewinding » pour s'assurer que les sous-trajets qui se chevauchent puissent être remplis selon la règle de remplissage appropriée.

Notez que le « rewinding » insère des lignes supplémentaires dans le polygone ; par conséquent, le contour du polygone de remplissage ne correspond pas au contour du tracé.

Voir également toSubpathPolygons(), toFillPolygons() et QPainterPath Conversion.

QList<QPolygonF> QPainterPath::toFillPolygons(const QTransform &matrix = QTransform()) const

Convertit le chemin en une liste de polygones à l'aide de la fonction QTransform matrix , puis renvoie cette liste.

Cette fonction diffère de la fonction toFillPolygon() en ce qu’elle crée plusieurs polygones. Elle est fournie car il est généralement plus rapide de tracer plusieurs petits polygones que de tracer un seul grand polygone, même si le nombre total de points tracés est identique.

La fonction `toFillPolygons()` diffère de la fonction ` toSubpathPolygons()` en ce qu’elle ne crée un polygone que pour les sous-trajets dont les rectangles de délimitation se chevauchent.

À l’instar de la fonction toFillPolygon(), cette fonction utilise une technique de « rewinding » pour garantir que les sous-chemins qui se chevauchent puissent être remplis selon la règle de remplissage appropriée. Notez que le « rewinding » insère des lignes supplémentaires dans les polygones, de sorte que le contour du polygone de remplissage ne correspond pas au contour du chemin.

Voir également toSubpathPolygons(), toFillPolygon() et QPainterPath Conversion.

QPainterPath QPainterPath::toReversed() const

Crée et renvoie une copie inversée du chemin.

C'est l'ordre des éléments qui est inversé : si une « QPainterPath » est constituée en appelant les fonctions « moveTo()», « lineTo()» et « cubicTo()» dans l'ordre spécifié, la copie inversée est constituée en appelant « cubicTo()», « lineTo()» et « moveTo()».

QList<QPolygonF> QPainterPath::toSubpathPolygons(const QTransform &matrix = QTransform()) const

Convertit le chemin en une liste de polygones à l'aide de la fonction QTransform matrix , puis renvoie cette liste.

Cette fonction crée un polygone pour chaque sous-chemin, indépendamment des intersections entre sous-chemins (c'est-à-dire des rectangles de délimitation qui se chevauchent). Pour vous assurer que ces sous-chemins qui se chevauchent soient correctement remplis, utilisez plutôt la fonction toFillPolygons().

Voir également toFillPolygons(), toFillPolygon() et QPainterPath Conversion.

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

Transforme tous les éléments du chemin selon (dx, dy).

Voir également translated().

void QPainterPath::translate(const QPointF &offset)

Transforme tous les éléments du chemin selon l'offset ion indiquée.

Voir également translated().

QPainterPath QPainterPath::translated(qreal dx, qreal dy) const

Renvoie une copie du chemin traduit par (dx, dy).

Voir également translate().

QPainterPath QPainterPath::translated(const QPointF &offset) const

Renvoie une copie du chemin traduit à l'aide de l'offset on fournie.

Voir aussi translate().

[since 6.10] QPainterPath QPainterPath::trimmed(qreal fromFraction, qreal toFraction, qreal offset = 0) const

Renvoie la section du chemin comprise entre les fractions de longueur fromFraction et toFraction. L'intervalle effectif de ces fractions va de 0, qui correspond au point de départ du chemin, à 1, qui correspond à son point d'arrivée. Ces fractions sont linéaires par rapport à la longueur du chemin, contrairement aux valeurs en pourcentage t.

La valeur de offset sera ajoutée aux valeurs des fractions. Si cela entraîne un dépassement supérieur ou inférieur de l'intervalle [0, 1], les valeurs seront bouclées, tout comme le chemin résultant. L'intervalle effectif du décalage est compris entre -1 et 1.

Les appels répétés à cette fonction peuvent être optimisés en {activant la mise en cache}{setCachingEnabled()}.

Cette fonction a été introduite dans Qt 6.10.

Voir également length(), percentAtLength() et setCachingEnabled().

QPainterPath QPainterPath::united(const QPainterPath &p) const

Renvoie un chemin qui correspond à l'union de la zone de remplissage de ce chemin et de celle de p.

Les opérations d'ensemble sur les chemins traiteront ces derniers comme des zones. Les chemins non fermés seront traités comme implicitement fermés. Les courbes de Bézier peuvent être aplaties en segments de droite en raison de l'instabilité numérique liée au calcul des intersections de courbes de Bézier.

Voir également ` intersected()` et ` subtracted()`.

bool QPainterPath::operator!=(const QPainterPath &path) const

Renvoie « true » si ce chemin de dessin diffère de celui indiqué par « path ».

Notez que la comparaison des chemins peut impliquer une comparaison élément par élément, ce qui peut être lent pour des chemins complexes.

Voir également operator==().

QPainterPath QPainterPath::operator&(const QPainterPath &other) const

Renvoie l'intersection entre ce chemin et le chemin other.

Voir également intersected(), operator&=(), united() et operator|().

QPainterPath &QPainterPath::operator&=(const QPainterPath &other)

Croise ce chemin avec other et renvoie une référence à ce chemin.

Voir également intersected(), operator&() et operator|=().

QPainterPath QPainterPath::operator+(const QPainterPath &other) const

Renvoie l'union de ce chemin et du chemin other. Cette fonction est équivalente à l'opérateur |().

Voir également united(), operator+=() et operator-().

QPainterPath &QPainterPath::operator+=(const QPainterPath &other)

Réunit ce chemin avec other et renvoie une référence à ce chemin. Cela équivaut à l'opérateur |=().

Voir également united(), operator+() et operator-=().

QPainterPath QPainterPath::operator-(const QPainterPath &other) const

Soustrait le chemin other d'une copie de ce chemin, puis renvoie cette copie.

Voir également subtracted(), operator-=() et operator+().

QPainterPath &QPainterPath::operator-=(const QPainterPath &other)

Soustrait other de ce chemin d'accès et renvoie une référence à ce chemin.

Voir également subtracted(), operator-() et operator+=().

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

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

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

Assigne l'path on indiquée à ce chemin de peinture.

Voir aussi QPainterPath().

bool QPainterPath::operator==(const QPainterPath &path) const

Renvoie ` true ` si ce `painterpath` est égal à l'path` fournie.

Notez que la comparaison des chemins peut impliquer une comparaison élément par élément, ce qui peut être lent pour les chemins complexes.

Voir également operator!=().

QPainterPath QPainterPath::operator|(const QPainterPath &other) const

Renvoie l'union de ce chemin et du chemin other.

Voir également united(), operator|=(), intersected() et operator&().

QPainterPath &QPainterPath::operator|=(const QPainterPath &other)

Associe ce chemin à other et renvoie une référence à ce chemin.

Voir également united(), operator|() et operator&=().