QPainterPath

La classe QPainterPath fournit un container pour réaliser des opérations de peinture, permettant de construire et réutiliser des formes géométriques. Plus d'informations...

#include <QPainterPath>

Voir la position dans l'arbre des classes.

Description détaillée

La classe QPainterPath fournit un container pour réaliser des opérations de peinture, permettant de construire et réutiliser des formes géométriques.

Un QPainterPath est un objet composé d'un certain nombre de formes géométriques comme des rectangles, des ellipses, des lignes et des courbes. Les différentes formes géométriques peuvent être assemblées dans des sous-formes fermées, par exemple pour un rectangle ou un cercle. Un chemin fermé possède un même point de départ et d'arrivée. Ils peuvent aussi exister indépendamment via des sous-chemins non fermés, comme les lignes et les courbes.

Un QPainterPath peut être utilisé pour créer un plan, le remplir et le couper. Pour générer un plan remplissable pour un chemin de peinture donné, utiliser la classe QPainterPathStroker. Le principal avantage des chemins de peinture par rapport aux opérations de dessin normales est que les formes complexes ont seulement besoin d'être créées une seule fois ; ensuite elles peuvent être réutilisées infiniment en appelant uniquement la fonction QPainter::drawPath();

QPainterPath fournit une collection de fonctions qui peuvent être utilisées pour obtenir des informations sur la forme et ses éléments. De plus il est possible d'inverser l'ordre des éléments en utilisant la fonction toReversed(). Il y a aussi plusieurs fonctions afin de convertir l'objet QPainterPath en une représentation polygonale.

Composition d'un QPainterPath

Un objet QPainterPath peut être construit comme un chemin vide, avec un point de départ donné ou comme une copie d'un autre objet QPainterPath. Une fois créé, des lignes et des courbes peuvent être ajoutées au chemin en utilisant les fonctions lineTo(), arcTo(), cubicTo() et quadTo(). Les lignes et courbes s'étendent de la position en cours currentPosition() à la position passée en argument.

La position renvoyée par currentPosition() de l'objet QPainterPath est toujours la position de fin du dernier sous-chemin ajouté (ou le point de départ initial). Utilisez la fonction moveTo() pour changer la currentPosition() sans ajouter de nouveaux composants. La fonction moveTo() crée implicitement un nouveau sous-chemin et ferme le précédent. Une autre façon de commencer un nouveau sous-chemin est d'appeler la fonction closeSubpath() qui ferme le chemin en cours en ajoutant une ligne depuis currentPosition() jusqu'au point de départ initial du chemin. Notez que currentPosition() aura alors pour valeur (0, 0).

La classe QPainterPath propose aussi plusieurs fonctions pour ajouter des sous-chemins fermés à une classe QPainterPath : addEllipse(), addPath(), addRect(), addRegion() et addText(). La fonction addPolygon() ajoute un sous-chemin non fermé. À vrai dire, ces fonctions sont des collections d'opérations de type moveTo(), lineTo() et cubicTo().

De plus, un chemin peut être ajouté au chemin en cours en utilisant la fonction connectPath(). Mais notez que cette fonction va connecter le dernier élément du chemin en cours au premier élément du chemin donné en ajoutant une ligne.

Le code ci-dessous est un petit exemple qui montre comment utiliser un objet QPainterPath :

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

La classe QPainterPath est initialement vide lorsqu'elle est construite. Premièrement, nous ajoutons un rect, qui est un sous-chemin fermé. Puis nous ajoutons deux courbes de Bézier qui forment ensemble un sous-chemin fermé bien qu'elles ne soient pas fermées individuellement. Enfin, nous dessinons le chemin entier. Le chemin est rempli en utilisant la règle de remplissage par défaut, Qt::OddEvenFill. Qt fournit deux méthodes pour remplir les chemins :

Qt::OddEvenFill	Qt::WindingFill

Voir Qt::FillRule pour la documentation concernant la définition des règles. La règle de remplissage en cours d'utilisation d'un chemin de peinture peut être retrouvée en utilisant la fonction fillRule() et peut être modifiée en utilisant la fonction setFillRule().

Informations sur le QPainterPath

La classe QPainterPath fournit une collection de fonctions qui donnent des informations sur le chemin et ses éléments.

La fonction currentPosition() retourne le point final du dernier sous-chemin ajouté (ou le point de départ initial). La fonction elementAt() peut être utilisée pour retrouver les différents sous-chemins, le nombre d'éléments peut être retrouvé en utilisant la fonction elementCount() et la fonction isEmpty() indique si l'objet QPainterPath contient des éléments ou non.

La fonction controlPointRect() retourne le rectangle qui contient tous les points et points de contrôles dans ce chemin. Cette fonction est plus rapide que la fonction exacte boundingRect() qui retourne le rectangle englobant ce chemin de peinture avec une précision flottante.

Enfin, QPainterPath fournit la fonction contains() qui peut être utilisée pour déterminer si un point ou un rectangle donné est contenu à l'intérieur ou non du chemin. La fonction intersects() détermine quels points d'un rectangle donné sont dans ce chemin.

Conversion d'un QPainterPath

Pour des raisons de compatibilité, il peut être requis de simplifier la représentation d'un chemin de peinture : QPainterPath fournit les fonctions toFillPolygon(), toFillPolygons() et toSubpathPolygons() qui convertissent le chemin de peinture en un polygone. La fonction toFillPolygon() retourne le chemin de peinture dans un seul polygone, alors que les deux autres fonctions retournent une liste de polygones.

Les fonctions toFillPolygons() et toSubpathPolygons() sont fournies car il est généralement plus rapide de dessiner plusieurs petits polygones qu'un grand polygone, même si le nombre total de points est le même. La différence entre les deux est le nombre de polygones qu'elles retournent : la fonction toSubpathPolygons() crée un polygone pour chaque sous-chemin sans tenir compte des chemins qui se croisent (c'est-à-dire : des rectangles se superposant), alors que la fonction toFillPolygons() crée un polygone pour les sous-chemins se croisant.

Les fonctions toFillPolygon() et toFillPolygons() convertissent premièrement tous les sous-chemins en polygones, puis utilisent une technique de rewinding pour s'assurer que les sous-chemins se croisant sont correctement remplis en utilisant la règle de remplissage adéquate. Notez que le rewinding ajoute des lignes dans le polygone, donc le contour du polygone rempli ne correspond pas au contour du chemin.

Exemples

Qt fournit l'exemple des chemins de peinture et la démo de déformation des vecteurs qui sont situés dans le répertoire d'exemples et démos de Qt, respectivement.

L'exemple des chemins de peinture montre comment les chemins de peinture peuvent être utilisés pour construire des formes complexes pour le dessin et laisse l'utilisateur expérimenter avec le remplissage et le stroking. La démo de déformation des vecteurs montre comment utiliser QPainterPath pour dessiner du texte.

Exemple des chemins de peinture	Démo de déformation des vecteurs

Voir aussi QPainterPathStroker, QPainter, QRegion et l'exemple des chemins de peinture.

Type

enum QPainterPath::ElementType

Cette enum décrit le type des éléments utilisés pour connecter les vecteurs dans les sous-chemins.

Notez que les éléments ajoutés comme sous-chemins fermés en utilisant les fonctions de commodités addEllipse(), addPath(), addPolygon(), addRect(), addRegion() et addText(), sont actuellement ajoutés au chemin en utilisant une liste d'éléments distincts en utilisant les fonctions moveTo(), lineTo() et cubicTo().

Voir aussi elementAt() et elementCount().

Fonctions membres

QPainterPath::QPainterPath ()

Construit un objet QPainterPath vide.

QPainterPath::QPainterPath ( const QPointF & startPoint )

Crée un objet QPainterPath avec le point de départ startPoint donné comme position courante.

QPainterPath::QPainterPath ( const QPainterPath & path )

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

Voir aussi operator=().

QPainterPath::~QPainterPath ()

Détruit cet objet QPainterPath.

void QPainterPath::addEllipse ( const QRectF & boundingRectangle )

Crée une ellipse contenue dans le rectangle boundingRectangle spécifié et l'ajoute au chemin de peinture comme un sous-chemin fermé.

L'ellipse est composée d'une courbe, démarrant et se terminant au degré 0 (la position à trois heures sur une horloge), dans le sens des aiguilles d'une montre.

 QLinearGradient myGradient;
 QPen myPen;
 QRectF boundingRectangle;
 
 QPainterPath myPath;
 myPath.addEllipse(boundingRectangle);
 
 QPainter painter(this);
 painter.setBrush(myGradient);
 painter.setPen(myPen);
 painter.drawPath(myPath);

Voir aussi arcTo(), QPainter::drawEllipse() et Composition d'un QPainterPath.

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

Il s'agit d'une fonction surchargée.

Crée une ellipse contenue dans le rectangle défini par son coin supérieur gauche à (x, y), avec la largeur width et hauteur height. Une fois créée, elle est ajoutée au chemin de peinture comme un sous-chemin fermé.

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

Il s'agit d'une fonction surchargée.

Crée une ellipse positionnée au centre center avec pour rayons rx et ry et l'ajoute au chemin de peinture comme un sous-chemin fermé.

Cette fonction a été introduite dans Qt 4.4.

void QPainterPath::addPath ( const QPainterPath & path )

Ajoute le chemin path donné au chemin this comme un sous-chemin fermé.

Voir aussi connectPath() et Composition d'un QPainterPath.

void QPainterPath::addPolygon ( const QPolygonF & polygon )

Ajoute le polygone polygon donné au chemin comme un sous-chemin (non fermé).

Notez que la position courante après l'ajout du polygone est le dernier point dans le polygone polygon. Pour dessiner une ligne entre ce point et le premier point, utilisez la fonction closeSubpath().

 QLinearGradient myGradient;
 QPen myPen;
 QPolygonF myPolygon;
 
 QPainterPath myPath;
 myPath.addPolygon(myPolygon);
 
 QPainter painter(this);
 painter.setBrush(myGradient);
 painter.setPen(myPen);
 painter.drawPath(myPath);

Voir aussi lineTo() et Composition d'un QPainterPath.

void QPainterPath::addRect ( const QRectF & rectangle )

Ajoute le rectangle donné au chemin comme un sous-chemin fermé.

Le rectangle est ajouté comme un ensemble de lignes dans le sens des aiguilles d'une montre. La position courante du chemin de peinture après l'ajout du rectangle est au coin supérieur gauche du rectangle.

 QLinearGradient myGradient;
 QPen myPen;
 QRectF myRectangle;
 
 QPainterPath myPath;
 myPath.addRect(myRectangle);
 
 QPainter painter(this);
 painter.setBrush(myGradient);
 painter.setPen(myPen);
 painter.drawPath(myPath);

Voir aussi addRegion(), lineTo() et Composition d'un QPainterPath.

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

Il s'agit d'une fonction surchargée.

Ajoute un rectangle à la position (x, y), avec la largeur width et hauteur height données, comme un sous-chemin fermé.

void QPainterPath::addRegion ( const QRegion & region )

Ajoute la région region donnée au chemin en ajoutant chaque rectangle dans la région comme des sous-chemins fermés différents.

Voir aussi addRect() et Composition d'un QPainterPath.

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

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

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

Cette fonction a été introduite dans Qt 4.4.

Voir aussi addRect().

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

Il s'agit d'une fonction surchargée.

Ajoute le rectangle arrondi donné x, y, w, h au chemin.

Cette fonction a été introduite dans Qt 4.4.

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

Ajoute le texte text donné, au chemin, comme un ensemble de sous-chemins créés à partir de la police font fournie. Les sous-chemins sont positionnés afin que la partie gauche de la ligne guide du texte corresponde au point spécifié.

 QLinearGradient myGradient;
 QPen myPen;
 QFont myFont;
 QPointF baseline(x, y);
 
 QPainterPath myPath;
 myPath.addText(baseline, myFont, tr("Qt"));
 
 QPainter painter(this);
 painter.setBrush(myGradient);
 painter.setPen(myPen);
 painter.drawPath(myPath);

Voir aussi QPainter::drawText() et Composition d'un QPainterPath.

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

Il s'agit d'une fonction surchargée.

Ajoute le texte text donné, au chemin, comme un ensemble de sous-chemins fermés créés à partir de la police font fournie. Les sous-chemins sont positionnés afin que la partie gauche de la ligne guide du texte corresponde au point spécifié par (x, y).

qreal QPainterPath::angleAtPercent ( qreal t ) const

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

Les valeurs positives pour les angles signifient une direction contre le sens des aiguilles d'une montre, alors que des valeurs négatives signifient une direction dans le sens des aiguilles d'une montre. Le degré 0 se situe à la position de trois heures.

Notez que similairement aux autres méthodes utilisant les pourcentages, la mesure du pourcentage n'est pas linéaire selon la longueur si des courbes sont présentes dans le chemin. Lorsque des courbes sont présentes l'argument de pourcentage est appliqué au paramètre t des équations de Bézier.

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

Crée un mouvement qui correspond à l'arc qui occupe le rectangle donné à l'angle.

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

Cette fonction a été introduite dans Qt 4.2.

Voir aussi moveTo() et arcTo().

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

Il s'agit d'une fonction surchargée.

Crée un mouvement qui correspond à l'arc qui occupe le QRectF(x, y, width, height) à l‹angle.

Cette fonction a été introduite dans Qt 4.2.

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

Crée un arc qui occupe le rectangle rectangle donné, démarrant de l'angle startAngle et s'étendant de sweepLength degrés dans le sens inverse des aiguilles d'une montre.

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

Notez que cette fonction connecte le point de départ de l'arc à la position courante s'ils ne sont pas déjà connectés. Après l'ajout de l'arc, la position courante est le dernier point de l'arc. Pour dessiner une ligne allant entre le premier et le dernier point, utilisez la fonction closeSubpath().

 QLinearGradient myGradient;
 QPen myPen;
 
 QPointF center, startPoint;
 
 QPainterPath myPath;
 myPath.moveTo(center);
 myPath.arcTo(boundingRect, startAngle,
              sweepLength);
 
 QPainter painter(this);
 painter.setBrush(myGradient);
 painter.setPen(myPen);
 painter.drawPath(myPath);

Voir aussi arcMoveTo(), addEllipse(), QPainter::drawArc(), QPainter::drawPie() et Composition d'un QPainterPath.

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

Il s'agit d'une fonction surchargée.

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

QRectF QPainterPath::boundingRect () const

Retourne le rectangle limitant ce chemin de peinture en tant que rectangle de précision à virgule flottante.

Voir aussi controlPointRect().

void QPainterPath::closeSubpath ()

Ferme le sous-chemin actuel en dessinant une ligne joignant le départ du sous-chemin et en démarrant automatiquement un nouveau sous-chemin. Le point actuel du nouveau chemin est (0, 0).

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

Voir aussi moveTo() et Composition d'un QPainterPath.

void QPainterPath::connectPath ( const QPainterPath & path )

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

Voir aussi addPath() et Composition d'un QPainterPath.

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

Retourne true si le point donné est dans le chemin, sinon retourne false.

Voir aussi intersects().

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

Retourne true si le rectangle donné est à ‹intérieur de path, sinon retourne false.

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

Retourne true si le chemin p donné est contenu dans le chemin courant. Retourne false si une des bordures du chemin courant croise p.

Un ensemble d'opérations sur les chemins vont interpréter le chemin comme zones. Les chemins non fermés sont interprétés comme implicitement fermés.

Cette fonction a été introduite dans Qt 4.3.

Voir aussi intersects().

QRectF QPainterPath::controlPointRect () const

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

Cette fonction est sensiblement plus rapide à exécuter que l'exacte boundingRect() et le rectangle retourné est toujours plus grand que le rectangle retourné 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 courante et le point final endPoint donné en utilisant les points de contrôles spécifiés par c1 et c2.

Après l'ajout de la courbe, la position courante est mise à jour pour correspondre au point final de la courbe.

 QLinearGradient myGradient;
 QPen myPen;
 
 QPainterPath myPath;
 myPath.cubicTo(c1, c2, endPoint);
 
 QPainter painter(this);
 painter.setBrush(myGradient);
 painter.setPen(myPen);
 painter.drawPath(myPath);

Voir aussi quadTo() et Composition d'un QPainterPath.

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

Il s'agit d'une fonction surchargée.

Ajoute une courbe de Bézier cubique entre la position courante et le point final (endPointX, endPointY) avec les points de contrôles spécifiés par (c1X, c1Y) et (c2X, c2Y).

QPointF QPainterPath::currentPosition () const

Retourne la position courante du chemin.

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

Retourne l'élément à l'index donné du chemin de peinture.

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

int QPainterPath::elementCount () const

Retourne le nombre d'éléments chemin dans le chemin de peinture.

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

Qt::FillRule QPainterPath::fillRule () const

Retourne la règle de remplissage actuelle du chemin de peinture.

Voir aussi setFillRule().

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

Retourne un chemin qui est l'intersection de la zone de remplissage de ce chemin et la zone de remplissage de p. Les courbes de Bézier peuvent être aplaties en segments linéaires à cause d'instabilités numériques lors du calcul des intersections avec les courbes de Bézier.

Cette fonction a été introduite dans Qt 4.3.

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

Retourne true si un des points du rectangle donné croise le chemin ; sinon retourne false.

Il y a intersection si l'une des lignes du rectangle croise une partie du chemin ou si une partie du rectangle se superpose à une zone comprise dans le chemin. Cette fonction respecte la règle de remplissage courante pour déterminer ce qui est considéré compris dans le chemin.

Voir aussi contains().

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

Retourne true si le chemin courant croise à n'importe quel endroit le chemin p donné. Retourne aussi true si le chemin courant contient ou est contenu par une partie de p.

Un ensemble d'opérations sur les chemins vont interpréter le chemin comme zones. Les chemins non fermés sont interprétés comme implicitement fermés.

Cette fonction a été introduite dans Qt 4.3.

Voir aussi contains().

bool QPainterPath::isEmpty () const

Retourne true s'il n'y a pas d'élément dans ce chemin ou si le seul élément est un MoveToElement ; sinon retourne false.

Voir aussi elementCount().

qreal QPainterPath::length () const

Retourne la longueur du chemin courant.

void QPainterPath::lineTo ( const QPointF & endPoint )

Ajoute une ligne droite de la position actuelle au point final endPoint donné. Après le dessin de la ligne, la position courante est mise à jour pour correspondre au point final de la ligne.

Voir aussi addPolygon(), addRect() et Composition d'un QPainterPath.

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

Il s'agit d'une fonction surchargée.

Dessine une ligne de la position courante jusqu'au point (x, y).

void QPainterPath::moveTo ( const QPointF & point )

Déplace le point actuel au point donné, démarrant implicitement un nouveau sous-chemin et fermant le précédent.

Voir aussi closeSubpath() et Composition d'un QPainterPath.

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

Il s'agit d'une fonction surchargée.

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

qreal QPainterPath::percentAtLength ( qreal len ) const

Retourne un pourcentage du chemin complet pour la position len donnée.

Notez que similairement aux autres méthodes utilisant les pourcentages, la mesure du pourcentage n'est pas linéaire selon la longueur si des courbes sont présentes dans le chemin. Lorsque des courbes sont présentes l'argument de pourcentage est appliqué au paramètre t des équations de Bézier.

QPointF QPainterPath::pointAtPercent ( qreal t ) const

Retourne le point au pourcentage t du chemin courant. L'argument t doit être compris entre 0 et 1.

Notez que similairement aux autres méthodes utilisant les pourcentages, la mesure du pourcentage n'est pas linéaire selon la longueur si des courbes sont présentes dans le chemin. Lorsque des courbes sont présentes l'argument de pourcentage est appliqué au 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 courante et la position finale endPoint donnée en utilisant le point de contrôle spécifié par c.

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

Voir aussi cubicTo() et Composition d'un QPainterPath.

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

Il s'agit d'une fonction surchargée.

Ajoute une courbe de Bézier quadratique entre le point courant et le point final (endPointX, endPointY) en utilisant comme point de contrôle (cx, cy).

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

Définit les coordonnées x et y de l'élément à l'index aux valeurs x et y.

Cette fonction a été introduite dans Qt 4.2.

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

Définit la règle de remplissage du chemin de peinture à la règle fillRule donnée. Qt fournit deux méthodes pour le remplissage des chemins :

Qt::OddEvenFill (défaut)	Qt::WindingFill

Voir aussi fillRule().

QPainterPath QPainterPath::simplified () const

Retourne une version simplifiée du chemin. Cela implique la fusion de tous les sous-chemins qui se croisent et retourne un chemin ne contenant aucune bordure se croisant. Les lignes parallèles consécutives vont aussi être fusionnées. Le chemin simplifié va toujours utiliser la règle de remplissage par défaut, Qt::OddEvenFill. Les courbes de Bézier peuvent être aplaties en segments linéaires à cause des instabilités numériques lors du calcul des intersections des courbes de Bézier.

Cette fonction a été introduite dans Qt 4.4.

qreal QPainterPath::slopeAtPercent ( qreal t ) const

Retourne l'inclinaison du chemin au pourcentage t. L'argument t doit être compris entre 0 et 1.

Notez que similairement aux autres méthodes utilisant les pourcentages, la mesure du pourcentage n'est pas linéaire selon la longueur si des courbes sont présentes dans le chemin. Lorsque des courbes sont présentes l'argument de pourcentage est appliqué au paramètre t des équations de Bézier.

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

Retourne un chemin qui est la zone de remplissage de p soustraite de la zone de remplissage du chemin.

Un ensemble d'opérations sur les chemins vont interpréter le chemin comme zones. Les chemins non fermés sont interprétés comme implicitement fermés. Les courbes de Bézier peuvent être aplaties en segments linéaires à cause des instabilités numériques lors du calcul des intersections des courbes de Bézier.

Cette fonction a été introduite dans Qt 4.3.

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

Convertit le chemin en un polygone en utilisant la matrice QTransform matrix et retourne le polygone.

Le polygone est créé en convertissant d'abord tous les sous-chemins en polygones, puis en utilisant une technique de rewinding pour s'assurer que les sous-chemins se recouvrant peuvent être remplis en utilisant la règle de remplissage adéquate.

Notez que le rewinding ajoute des lignes dans le polygone, il est donc possible que le contour du polygone rempli ne corresponde pas au contour du chemin.

Voir aussi toSubpathPolygons(), toFillPolygons() et QPainterPath Conversion.

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

Il s'agit d'une fonction surchargée.

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

Convertit le chemin dans une liste de polygones en utilisant la matrice QTransform matrix et retourne la liste.

Cette fonction diffère de la fonction toFillPolygon() car elle crée plusieurs polygones. Elle est fournie car il est habituellement plus rapide de dessiner plusieurs petits polygones qu'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() car elle crée seulement des polygones pour les sous-chemins qui ont des rectangles qui se superposent.

Comme la fonction toFillPolygon(), cette fonction utilise la technique de rewinding pour s'assurer que les sous-chemins se recouvrant peuvent être remplis en utilisant la règle de remplissage adéquate. Notez que le rewinding ajoute des lignes dans le polygone, il est donc possible que le contour du polygone rempli ne corresponde pas au contour du chemin.

Voir aussi toSubpathPolygons(), toFillPolygon() et QPainterPath Conversion.

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

Il s'agit d'une fonction surchargée.

QPainterPath QPainterPath::toReversed () const

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

C'est l'ordre des éléments qui est inversé : si un QPainterPath est composé en appelant les fonctions moveTo(), lineTo() et cubicTo() dans cet ordre, la copie inverse est composée en appelant cubicTo(), lineTo() et moveTo().

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

Convertit le chemin dans une liste de polygones en utilisant la matrice QTransform matrix et retourne la liste.

La fonction crée un polygone pour chaque sous-chemin sans prendre en compte les intersections des sous-chemins (c'est-à-dire : des rectangles se superposant). Pour s'assurer que ces sous-chemins se superposant sont remplis correctement, utilisez la fonction toFillPolygons() à la place.

Voir aussi toFillPolygons(), toFillPolygon() et QPainterPath Conversion.

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

Il s'agit d'une fonction surchargée.

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

Déplace tous les éléments du chemin de (dx, dy).

Cette fonction a été introduite dans Qt 4.6.

Voir aussi translated().

void QPainterPath::translate ( const QPointF & offset )

Il s'agit d'une fonction surchargée.

Déplace tous les éléments du chemin d'un décalage offset donné.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi translated().

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

Retourne une copie du chemin après déplacement de (dx, dy).

Cette fonction a été introduite dans Qt 4.6.

Voir aussi translate().

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

Il s'agit d'une fonction surchargée.

Retourne une copie du chemin après déplacement d'un décalage offset donné.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi translate().

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

Retourne un chemin qui est l'union de la zone de remplissage de ce chemin avec la zone de remplissage de p.

Un ensemble d'opérations sur les chemins vont interpréter le chemin comme zones. Les chemins non fermés sont interprétés comme implicitement fermés. Les courbes de Bézier peuvent être aplaties en segments linéaires à cause des instabilités numériques lors du calcul des intersections des courbes de Bézier.

Cette fonction a été introduite dans Qt 4.3.

Voir aussi intersected() et subtracted().

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

Retourne true si ce chemin de peinture diffère du chemin path donné.

Notez que la comparaison de chemin peut utiliser une comparaison par éléments ce qui peut être lent pour les chemins complexes.

Voir aussi operator==().

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

Retourne l'intersection de ce chemin avec le chemin other.

Cette fonction a été introduite dans Qt 4.5.

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

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

Intersecte le chemin avec other et retourne une référence de ce chemin.

Cette fonction a été introduite dans Qt 4.5.

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

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

Retourne l'union de ce chemin avec le chemin other. Cette fonction équivaut à operator|().

Cette fonction a été introduite dans Qt 4.5.

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

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

Unit ce chemin avec other et retourne une référence sur ce chemin. Cette fonction équivaut à operator|=().

Cette fonction a été introduite dans Qt 4.5.

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

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

Soustrait le chemin other de la copie de ce chemin et retourne la copie.

Cette fonction a été introduite dans Qt 4.5.

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

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

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

Cette fonction a été introduite dans Qt 4.5.

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

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

Définit le chemin path donné à ce chemin.

Voir aussi QPainterPath().

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

Retourne true si le chemin de peinture équivaut au chemin path donné.

Notez que la comparaison peut utiliser une comparaison par élément qui peut être lente pour les chemins complexes.

Voir aussi operator!=().

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

Retourne l'union de ce chemin avec le chemin other.

Cette fonction a été introduite dans Qt 4.5.

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

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

Unit ce chemin avec other et retourne une référence sur ce chemin.

Cette fonction a été introduite dans Qt 4.5.

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

En relation mais non membre de la classe

QDataStream & operator<< ( QDataStream & stream, const QPainterPath & path )

Écrit le chemin path sur le flux stream donné et retourne une référence sur le flux stream.

Voir aussi Serializing Qt Data Types.

QDataStream & operator>> ( QDataStream & stream, QPainterPath & path )

Lit un chemin de peinture à partir du flux stream dans le chemin spécifié path et retourne une référence sur le flux stream.

Voir aussi Serializing Qt Data Types.

Remerciements

Merci à feda12 et Alexandre Laurent pour la traduction ainsi qu'à Jonathan Courtois et Claude Leloup pour leur relecture !