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()

Construit un objet QPainterPath vide.

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

Crée un objet QPainterPath avec l'adresse startPoint comme position actuelle.

QPainterPath::QPainterPath(const QPainterPath &path)

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

Voir aussi operator=().

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

Move-construit un nouveau chemin de peinture à partir de other.

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

Cette fonction a été introduite dans Qt 6.10.

[noexcept] QPainterPath::~QPainterPath()

Détruit cet objet QPainterPath.

void QPainterPath::addEllipse(const QRectF &boundingRectangle)

Crée une ellipse à l'intérieur du site boundingRectangle spécifié et l'ajoute au chemin du peintre en tant que sous-chemin fermé.

L'ellipse est composée d'une courbe dans le sens des aiguilles d'une montre, commençant et finissant à zéro degré (position 3 heures).

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 à center avec les rayons rx et ry, et l'ajoute au chemin du peintre en tant que sous-chemin fermé.

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

Crée une ellipse dans le rectangle délimité par son coin supérieur gauche à (x, y), width et height, et l'ajoute au chemin du peintre en tant que sous-chemin fermé.

void QPainterPath::addPath(const QPainterPath &path)

Ajoute le chemin path à ce chemin en tant que sous-chemin fermé.

Voir aussi connectPath() et Composing a QPainterPath.

void QPainterPath::addPolygon(const QPolygonF &polygon)

Ajoute le polygone polygon au chemin en tant que sous-chemin (non fermé).

Notez que la position actuelle après l'ajout du polygone est le dernier point de polygon. Pour tracer une ligne jusqu'au premier point, utilisez la fonction closeSubpath().

Voir également lineTo() et Composing a QPainterPath.

void QPainterPath::addRect(const QRectF &rectangle)

Ajoute l'adresse rectangle à ce chemin en tant que sous-chemin fermé.

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

Voir aussi 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 données width et height, en tant que sous-chemin fermé.

void QPainterPath::addRegion(const QRegion &region)

Ajoute le site region au chemin en ajoutant chaque rectangle de la région comme un sous-chemin fermé séparé.

Voir aussi addRect() et Composing a QPainterPath.

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

Ajoute au chemin le rectangle donné rect avec des coins arrondis.

Les arguments xRadius et yRadius spécifient les rayons des ellipses définissant les coins du rectangle arrondi. Lorsque mode est Qt::RelativeSize, xRadius et yRadius sont spécifiés en pourcentage de la moitié de la largeur et de la hauteur du rectangle respectivement, et doivent être compris entre 0,0 et 100,0.

Voir aussi addRect().

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

Ajoute au chemin le rectangle donné x, y, w, h avec des coins arrondis.

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

Ajoute l'adresse text à ce chemin sous la forme d'un ensemble de sous-chemins fermés créés à partir de l'adresse 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'endroit spécifié point.

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

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

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

Ajoute l'adresse text à ce chemin sous la forme d'un ensemble de sous-chemins fermés créés à partir de l'adresse 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 au point spécifié par (x, y).

qreal QPainterPath::angleAtPercent(qreal t) const

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

Les valeurs positives des angles correspondent au sens inverse des aiguilles d'une montre, tandis que les valeurs négatives correspondent au sens des aiguilles d'une montre. Le zéro degré se trouve à la position 3 heures.

Notez qu'à l'instar des autres méthodes de pourcentage, la mesure du pourcentage n'est pas linéaire en ce qui concerne la longueur si des courbes sont présentes sur la trajectoire. Lorsque des courbes sont présentes, l'argument du pourcentage est mis en correspondance avec le paramètre t des équations de Bézier.

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

Crée un déplacement vers qui se trouve sur l'arc qui occupe l'adresse rectangle donnée à 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 en utilisant des angles négatifs.

Voir aussi moveTo() et arcTo().

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

Crée un déplacement vers qui se trouve sur l'arc qui occupe le QRectF(x, y, width, height) à angle.

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

Crée un arc qui occupe le site rectangle, en commençant par le site startAngle et en s'étendant sur sweepLength degrés dans le sens inverse des aiguilles d'une montre.

Les angles sont spécifiés en degrés. Les arcs dans le sens des aiguilles d'une montre peuvent être spécifiés en utilisant des angles négatifs.

Notez que cette fonction relie le point de départ de l'arc à la position actuelle s'ils ne sont pas déjà connectés. Une fois l'arc ajouté, la position actuelle est le dernier point de l'arc. Pour tracer une ligne jusqu'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), commençant à l'endroit spécifié startAngle et s'étendant sur sweepLength degrés dans le sens inverse des aiguilles d'une montre.

QRectF QPainterPath::boundingRect() const

Renvoie le rectangle de délimitation de ce chemin de peintre 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 QPainterPath.

Voir aussi clear() et reserve().

void QPainterPath::clear()

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

Cela permet au chemin d'accès de réutiliser les allocations de mémoire précédentes.

Voir également reserve() et capacity().

void QPainterPath::closeSubpath()

Ferme le sous-chemin actuel en traçant une ligne jusqu'au début du sous-chemin, démarrant ainsi automatiquement un nouveau chemin. Le point actuel du nouveau chemin est (0, 0).

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

Voir aussi moveTo() et Composing a QPainterPath.

void QPainterPath::connectPath(const QPainterPath &path)

Connecte le site path à ce chemin en ajoutant une ligne entre le dernier élément de ce chemin et le premier élément du chemin donné.

Voir aussi 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 l'une des arêtes du chemin actuel et p se croisent.

Les opérations Set sur les chemins traiteront les chemins comme des zones. Les chemins non fermés seront traités comme implicitement fermés.

Voir aussi intersects().

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

Renvoie true si l'adresse point se trouve à l'intérieur du chemin, sinon renvoie false.

Voir aussi intersects().

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

Renvoie true si l'adresse rectangle se trouve à l'intérieur du chemin, sinon renvoie false.

QRectF QPainterPath::controlPointRect() const

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

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

Voir aussi 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'adresse endPoint à l'aide des points de contrôle spécifiés par c1, et c2.

Après l'ajout de la courbe, la position actuelle est mise à jour pour se trouver au point final 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 les points de contrôle spécifiés 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'adresse index dans le chemin du peintre.

Voir aussi ElementType, elementCount(), et isEmpty().

int QPainterPath::elementCount() const

Renvoie le nombre d'éléments du chemin dans le chemin du peintre.

Voir aussi ElementType, elementAt(), et isEmpty().

Qt::FillRule QPainterPath::fillRule() const

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

Voir également setFillRule().

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

Renvoie un chemin qui est l'intersection de l'aire de remplissage de ce chemin et de l'aire de remplissage de p. Les courbes de Bézier peuvent être aplaties en segments de ligne en raison de l'instabilité numérique des intersections de courbes de Bézier.

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

Renvoie true si le chemin actuel croise en tout point 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 traiteront les chemins comme des zones. Les chemins non fermés seront traités comme implicitement fermés.

Voir aussi contains().

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

Renvoie true si un point de la zone rectangle donnée coupe le chemin ; sinon, renvoie false.

Il y a intersection si l'une des lignes composant le rectangle traverse une partie du chemin ou si une partie du rectangle chevauche une zone délimitée par le chemin. Cette fonction respecte l'adresse fillRule actuelle pour déterminer ce qui est considéré comme étant à l'intérieur du chemin.

Voir également contains().

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

Retourne true si la mise en cache est activée, sinon retourne 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 aussi elementCount().

qreal QPainterPath::length() const

Renvoie la longueur du chemin actuel.

void QPainterPath::lineTo(const QPointF &endPoint)

Ajoute une ligne droite entre la position actuelle et la position donnée endPoint. Une fois la ligne tracée, la position actuelle est mise à jour pour correspondre au point final de la ligne.

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

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

Dessine une ligne depuis la position actuelle jusqu'au point (x, y).

void QPainterPath::moveTo(const QPointF &point)

Déplace le point courant sur le site point, en commençant implicitement un nouveau sous-chemin et en fermant le précédent.

Voir aussi closeSubpath() et Composing a QPainterPath.

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

Déplace la position actuelle à (x, y) et démarre un nouveau sous-chemin, fermant implicitement le chemin précédent.

qreal QPainterPath::percentAtLength(qreal len) const

Renvoie le pourcentage de l'ensemble du chemin à la longueur spécifiée len.

Notez que, comme pour les autres méthodes de pourcentage, la mesure du pourcentage n'est pas linéaire par rapport à la longueur, si des courbes sont présentes dans le chemin. Lorsque des courbes sont présentes, l'argument du pourcentage est mis en correspondance avec le paramètre t des équations de Bézier.

QPointF QPainterPath::pointAtPercent(qreal t) const

Renvoie le point au pourcentage t 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 du pourcentage n'est pas linéaire par rapport à la longueur, si des courbes sont présentes dans le chemin. Lorsque des courbes sont présentes, l'argument du pourcentage est mis en correspondance avec 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 le site endPoint donné, avec le point de contrôle spécifié par c.

Après l'ajout de la courbe, le point courant est mis à jour pour être au point final de la courbe.

Voir aussi 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 final (endPointX, endPointY) avec le point de contrôle spécifié par (cx, cy).

void QPainterPath::reserve(int size)

Réserve une quantité donnée d'éléments dans la mémoire interne de QPainterPath.

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

Voir aussi clear(), capacity() et QList::reserve().

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

Active ou désactive la mise en cache de la longueur 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 la longueur du chemin et les valeurs de pourcentage, telles que length(), percentAtLength(), pointAtPercent(), etc., au prix d'une utilisation supplémentaire de la mémoire pour le stockage des calculs intermédiaires. Par défaut, la mise en cache est désactivée.

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

Cette fonction a été introduite dans Qt 6.10.

Voir aussi 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 à l'index index à x et y.

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

Définit la règle de remplissage du chemin du peintre à l'adresse fillRule. Qt propose deux méthodes pour remplir les chemins :

Voir aussi fillRule().

QPainterPath QPainterPath::simplified() const

Renvoie une version simplifiée de ce chemin. Cela implique la fusion de tous les sous-chemins qui se croisent, et le renvoi d'un chemin ne contenant pas d'arêtes qui se croisent. Les lignes parallèles consécutives seront également fusionnées. Le chemin simplifié utilisera toujours la règle de remplissage par défaut, Qt::OddEvenFill. Les courbes de Bézier peuvent être aplaties en segments de ligne en raison de l'instabilité numérique des intersections de courbes de Bézier.

qreal QPainterPath::slopeAtPercent(qreal t) const

Renvoie la pente du chemin 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 du pourcentage n'est pas linéaire par rapport à la longueur, si des courbes sont présentes dans le chemin. En présence de courbes, l'argument du pourcentage est mis en correspondance avec le paramètre t des équations de Bézier.

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

Renvoie un chemin qui est p's fill area subtracted from this path's fill area.

Les opérations Set sur les chemins traiteront les chemins 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 ligne en raison de l'instabilité numérique des intersections de courbes de Bézier.

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

Remplace ce chemin de peinture par other. Cette opération est très rapide et n'échoue jamais.

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

Convertit le chemin en polygone à l'aide de QTransform matrix , et renvoie le polygone.

Le polygone est créé en convertissant d'abord tous les sous-chemins en polygones, puis en utilisant une technique de rembobinage pour s'assurer que les sous-chemins qui se chevauchent peuvent être remplis à l'aide de la règle de remplissage correcte.

Notez que le rembobinage insère des lignes supplémentaires dans le polygone, de sorte que le contour du polygone de remplissage ne corresponde pas au contour du chemin.

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 , et renvoie la liste.

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

La fonction toFillPolygons() diffère de la fonction toSubpathPolygons() en ce sens qu'elle ne crée que des polygones pour les sous-chemins dont les rectangles de délimitation se chevauchent.

Comme la fonction toFillPolygon(), cette fonction utilise une technique de rembobinage pour s'assurer que les sous-chemins qui se chevauchent peuvent être remplis à l'aide de la règle de remplissage correcte. Notez que le rembobinage insère des lignes supplémentaires dans les polygones afin que le contour du polygone de remplissage ne corresponde 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 un chemin QPainterPath est composé en appelant les fonctions moveTo(), lineTo() et cubicTo() dans l'ordre spécifié, la copie inversée est composé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 QTransform matrix , et renvoie la liste.

Cette fonction crée un polygone pour chaque sous-chemin sans tenir compte des sous-chemins qui se croisent (c'est-à-dire des rectangles de délimitation qui se chevauchent). Pour s'assurer que les sous-chemins qui se chevauchent sont correctement remplis, utilisez plutôt la fonction toFillPolygons().

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

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

Traduit tous les éléments du chemin par (dx, dy).

Voir aussi translated().

void QPainterPath::translate(const QPointF &offset)

Traduit tous les éléments du chemin par la valeur donnée offset.

Voir aussi translated().

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

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

Voir aussi translate().

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

Renvoie une copie du chemin traduit par l'adresse offset.

Voir aussi translate().

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

Renvoie la section du chemin entre les fractions de longueur fromFraction et toFraction. La plage effective des fractions est comprise entre 0, indiquant le point de départ du chemin, et 1, indiquant son point d'arrivée. Les fractions sont linéaires par rapport à la longueur du chemin, contrairement aux valeurs de t en pourcentage.

La valeur de offset sera ajoutée aux valeurs des fractions. Si cela entraîne un dépassement ou un sous-dépassement de la plage [0, 1], les valeurs seront enveloppées, de même que le chemin résultant. La plage effective du décalage est comprise 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 aussi length(), percentAtLength(), et setCachingEnabled().

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

Renvoie un chemin qui est l'union de la zone de remplissage de ce chemin et de la zone de remplissage de p.

Les opérations de définition sur les chemins traiteront les chemins 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 ligne en raison de l'instabilité numérique des intersections de courbes de Bézier.

Voir aussi intersected() et subtracted().

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

Renvoie true si ce chemin de peintre diffère du chemin donné path.

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

Voir aussi operator==().

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

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

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

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

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

Voir aussi 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 à operator|().

Voir aussi united(), operator+=(), et operator-().

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

Unifie ce chemin avec other, et renvoie une référence à ce chemin. Ceci est équivalent à l'opérateur|=().

Voir aussi united(), operator+(), et operator-=().

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

Soustrait le chemin other d'une copie de ce chemin et renvoie la copie.

Voir aussi subtracted(), operator-=(), et operator+().

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

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

Voir aussi subtracted(), operator-() et operator+=().

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

Move-assigne other à cette instance QPainterPath.

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

Affecte l'adresse path à ce chemin d'accès au peintre.

Voir aussi QPainterPath().

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

Renvoie true si ce chemin de peinture est égal au chemin donné path.

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

Voir aussi operator!=().

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

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

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

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

Réunit ce chemin d'accès avec other et renvoie une référence à ce chemin d'accès.

Voir aussi united(), operator|(), et operator&=().