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

Dokumentation der Member-Funktionen

[noexcept] QPainterPath::QPainterPath()

Erstellt ein leeres QPainterPath-Objekt.

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

Erstellt ein QPainterPath-Objekt, dessen aktuelle Position dem angegebenen „ startPoint “ entspricht.

QPainterPath::QPainterPath(const QPainterPath &path)

Erstellt ein QPainterPath-Objekt, das eine Kopie des angegebenen path ist.

Siehe auch ` operator=()`.

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

Erstellt mithilfe von „Move“ einen neuen Malerpfad aus other.

Das Objekt „ other “, aus dem die Konstruktion erfolgt, wird in den Zustand der Standardkonstruktion versetzt.

Diese Funktion wurde in Qt 6.10 eingeführt.

[noexcept] QPainterPath::~QPainterPath()

Löscht dieses „ QPainterPath “-Objekt.

void QPainterPath::addEllipse(const QRectF &boundingRectangle)

Erzeugt eine Ellipse innerhalb des angegebenen Bereichs „ boundingRectangle “ und fügt sie dem Malpfad als geschlossenen Teilpfad hinzu.

Die Ellipse besteht aus einer im Uhrzeigersinn verlaufenden Kurve, die bei null Grad (der 3-Uhr-Position) beginnt und endet. Die Kurve ist eine kubische Bézier-Näherung der Ellipse und keine exakte Darstellung derselben, wie in Arcs and Ellipses beschrieben.

Siehe auch arcTo(), QPainter::drawEllipse() und Composing a QPainterPath.

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

Erzeugt eine Ellipse mit den Koordinaten center und den Radien rx und ry und fügt sie dem Malpfad als geschlossenen Teilpfad hinzu.

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

Erzeugt eine Ellipse innerhalb des Begrenzungsrechtecks, das durch die obere linke Ecke bei (x, y), width und height definiert ist, und fügt sie dem Malpfad als geschlossenen Teilpfad hinzu.

void QPainterPath::addPath(const QPainterPath &path)

Fügt den angegebenen path als geschlossenen Teilpfad zu diesem Pfad hinzu.

Siehe auch „ connectPath()“ und „ Composing a QPainterPath “.

void QPainterPath::addPolygon(const QPolygonF &polygon)

Fügt das angegebene „ polygon “ als (nicht geschlossenen) Teilpfad zum Pfad hinzu.

Beachten Sie, dass die aktuelle Position nach dem Hinzufügen des Polygons dem letzten Punkt in ` polygon` entspricht. Um eine Linie zurück zum ersten Punkt zu zeichnen, verwenden Sie die Funktion ` closeSubpath()`.

Siehe auch „ lineTo()“ und „ Composing a QPainterPath “.

void QPainterPath::addRect(const QRectF &rectangle)

Fügt den angegebenen „ rectangle “ diesem Pfad als geschlossenen Teilpfad hinzu.

Der „ rectangle “ wird als im Uhrzeigersinn verlaufende Liniengruppe hinzugefügt. Die aktuelle Position des Zeichenpfads nach dem Hinzufügen des „ rectangle “ befindet sich in der oberen linken Ecke des Rechtecks.

Siehe auch addRegion(), lineTo() und Composing a QPainterPath.

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

Fügt an der Position (x, y) ein Rechteck mit den angegebenen Werten width und height als geschlossenen Teilpfad hinzu.

void QPainterPath::addRegion(const QRegion &region)

Fügt die angegebene Region „ region “ zum Pfad hinzu, indem jedes Rechteck in der Region als separater geschlossener Teilpfad hinzugefügt wird.

Siehe auch „ addRect()“ und „ Composing a QPainterPath “.

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

Fügt dem Pfad das angegebene Rechteck „ rect “ mit abgerundeten Ecken hinzu.

Die Argumente „ xRadius “ und „ yRadius “ geben die Radien der Ellipsen an, die die Ecken des abgerundeten Rechtecks definieren. Wenn „ mode “ auf „ Qt::RelativeSize “ gesetzt ist, werden „ xRadius “ und „ yRadius “ in Prozent der halben Breite bzw. Höhe des Rechtecks angegeben und sollten im Bereich von 0,0 bis 100,0 liegen.

Siehe auch addRect().

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

Fügt dem Pfad das angegebene Rechteck x, y, w, h mit abgerundeten Ecken hinzu.

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

Fügt den angegebenen Text „ text “ diesem Pfad als eine Reihe geschlossener Teilpfade hinzu, die aus den übergebenen „ font “ erstellt werden. Die Teilpfade werden so positioniert, dass das linke Ende der Grundlinie des Textes auf dem angegebenen „ point “ liegt.

Bei einigen Schriftarten kann es zu überlappenden Teilpfaden kommen, sodass für eine korrekte Darstellung die Füllregel „ Qt::WindingFill “ erforderlich ist.

Siehe auch QPainter::drawText(), Composing a QPainterPath und setFillRule().

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

Fügt den angegebenen „ text “ diesem Pfad als eine Menge geschlossener Teilpfade hinzu, die aus dem angegebenen „ font “ erstellt werden. Die Teilpfade werden so positioniert, dass das linke Ende der Grundlinie des Textes an dem durch (x, y) angegebenen Punkt liegt.

qreal QPainterPath::angleAtPercent(qreal t) const

Gibt den Winkel der Tangente am Pfad am Prozent t zurück. Das Argument t muss zwischen 0 und 1 liegen.

Positive Werte für die Winkel bedeuten eine Drehung gegen den Uhrzeigersinn, während negative Werte eine Drehung im Uhrzeigersinn bedeuten. Null Grad entspricht der 3-Uhr-Position.

Beachten Sie, dass – ähnlich wie bei den anderen Prozent-Methoden – die Prozentangabe in Bezug auf die Länge nicht linear ist, wenn der Pfad Kurven enthält. Bei Vorhandensein von Kurven wird das Prozent-Argument auf den Parameter t der Bézier-Gleichungen abgebildet.

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

Erzeugt einen Zug, der auf dem Bogen liegt, der die angegebene Koordinate „ rectangle “ bei „ angle “ einnimmt.

Winkel werden in Grad angegeben. Bögen im Uhrzeigersinn können mit negativen Winkeln angegeben werden. Wenn „ rectangle “ kein Quadrat ist, ist „ angle “ ein exzentrischer Winkel und misst nicht die Richtung vom Mittelpunkt des Rechtecks aus, wie unter Arcs and Ellipses beschrieben.

Siehe auch moveTo(), arcTo() und Arcs and Ellipses.

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

Erzeugt einen Zug, der auf dem Bogen liegt, der die Koordinaten QRectF(x, y, width, height) am Punkt angle einnimmt.

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

Erzeugt einen Bogen, der den angegebenen Bereich rectangle einnimmt, beginnend am angegebenen startAngle und sich um sweepLength Grad gegen den Uhrzeigersinn erstreckend.

Winkel werden in Grad angegeben. Bögen im Uhrzeigersinn können durch negative Winkel angegeben werden. Wenn rectangle kein Rechteck ist, handelt es sich um exzentrische Winkel, die nicht die Richtung vom Mittelpunkt des Rechtecks aus messen, wie unter Arcs and Ellipses beschrieben.

Beachten Sie, dass diese Funktion den Startpunkt des Bogens mit der aktuellen Position verbindet, sofern diese noch nicht miteinander verbunden sind. Nach dem Hinzufügen des Bogens ist die aktuelle Position der letzte Punkt des Bogens. Um eine Linie zurück zum ersten Punkt zu zeichnen, verwenden Sie die Funktion „ closeSubpath()“.

Siehe auch arcMoveTo(), addEllipse(), QPainter::drawArc(), QPainter::drawPie() und Composing a QPainterPath.

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

Erzeugt einen Bogen, der das Rechteck QRectF(x, y, width, height) einnimmt, beginnend bei der angegebenen startAngle und sich sweepLength Grad gegen den Uhrzeigersinn erstreckend.

QRectF QPainterPath::boundingRect() const

Gibt das Begrenzungsrechteck dieses Malpfads als Rechteck mit Gleitkommagenauigkeit zurück.

Siehe auch „ controlPointRect()“.

int QPainterPath::capacity() const

Gibt die Anzahl der Elemente zurück, die von der Funktion „ QPainterPath “ zugewiesen wurden.

Siehe auch „ clear()“ und „ reserve()“.

void QPainterPath::clear()

Löscht die gespeicherten Pfadelemente.

Dadurch kann der Pfad zuvor zugewiesene Speicherbereiche wiederverwenden.

Siehe auch reserve() und capacity().

void QPainterPath::closeSubpath()

Schließt den aktuellen Teilpfad, indem eine Linie zum Anfang des Teilpfads gezeichnet wird, wodurch automatisch ein neuer Pfad begonnen wird. Der aktuelle Punkt des neuen Pfads ist (0, 0).

Wenn der Teilpfad keine Elemente enthält, führt diese Funktion keine Aktion aus.

Siehe auch moveTo() und Composing a QPainterPath.

void QPainterPath::connectPath(const QPainterPath &path)

Verbindet den angegebenen Pfad „ path “ mit diesem Pfad, indem eine Linie vom letzten Element dieses Pfads zum ersten Element des angegebenen Pfads hinzugefügt wird.

Siehe auch „ addPath()“ und „ Composing a QPainterPath “.

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

Gibt „ true “ zurück, wenn der angegebene Pfad „ p “ im aktuellen Pfad enthalten ist. Gibt „ false “ zurück, wenn sich Kanten des aktuellen Pfads und von „ p “ schneiden.

Bei Mengenoperationen auf Pfaden werden die Pfade als Flächen behandelt. Nicht geschlossene Pfade werden implizit als geschlossen behandelt.

Siehe auch „ intersects()“.

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

Gibt „ true “ zurück, wenn die angegebene „ point “ im Pfad enthalten ist, andernfalls „ false “.

Siehe auch intersects().

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

Gibt „ true “ zurück, wenn die angegebene „ rectangle “ im Pfad enthalten ist, andernfalls „ false “.

QRectF QPainterPath::controlPointRect() const

Gibt das Rechteck zurück, das alle Punkte und Kontrollpunkte dieses Pfades enthält.

Diese Funktion ist deutlich schneller zu berechnen als die exakte Funktion ` boundingRect()` und das zurückgegebene Rechteck ist immer eine Obermenge des von ` boundingRect()` zurückgegebenen Rechtecks.

Siehe auch ` boundingRect()`.

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

Fügt eine kubische Bézier-Kurve zwischen der aktuellen Position und der angegebenen Koordinate ` endPoint ` hinzu, wobei die durch ` c1` und ` c2` angegebenen Kontrollpunkte verwendet werden.

Nachdem die Kurve hinzugefügt wurde, wird die aktuelle Position auf den Endpunkt der Kurve aktualisiert.

Siehe auch quadTo() und Composing a QPainterPath.

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

Fügt eine kubische Bézier-Kurve zwischen der aktuellen Position und dem Endpunkt (endPointX, endPointY) ein, deren Kontrollpunkte durch (c1X, c1Y) und (c2X, c2Y) angegeben werden.

QPointF QPainterPath::currentPosition() const

Gibt die aktuelle Position des Pfades zurück.

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

Gibt das Element an der angegebenen Position „ index “ im Painter-Pfad zurück.

Siehe auch „ ElementType“ , „ elementCount()“ und „ isEmpty()“.

int QPainterPath::elementCount() const

Gibt die Anzahl der Pfadelemente im Painter-Pfad zurück.

Siehe auch „ ElementType“ , „ elementAt()“ und „ isEmpty()“.

Qt::FillRule QPainterPath::fillRule() const

Gibt die aktuell festgelegte Füllregel des Malpfads zurück.

Siehe auch ` setFillRule()`.

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

Gibt einen Pfad zurück, der die Schnittmenge zwischen dem Füllbereich dieses Pfads und dem Füllbereich von p darstellt. Bézier-Kurven können aufgrund numerischer Instabilitäten bei der Berechnung von Schnittpunkten von Bézier-Kurven zu Liniensegmenten vereinfacht werden.

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

Gibt „ true “ zurück, wenn sich der aktuelle Pfad an irgendeiner Stelle mit dem angegebenen Pfad „ p “ schneidet. Gibt außerdem „ true “ zurück, wenn der aktuelle Pfad einen Teil von „ p “ enthält oder von diesem Teil enthalten ist.

Bei Mengenoperationen auf Pfaden werden die Pfade als Flächen behandelt. Nicht geschlossene Pfade werden implizit als geschlossen behandelt.

Siehe auch contains().

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

Gibt „ true “ zurück, wenn ein beliebiger Punkt im angegebenen „ rectangle “ den Pfad schneidet; andernfalls wird „ false “ zurückgegeben.

Eine Schnittstelle liegt vor, wenn eine der Linien, aus denen das Rechteck besteht, einen Teil des Pfades kreuzt oder wenn sich ein Teil des Rechtecks mit einem vom Pfad umschlossenen Bereich überschneidet. Diese Funktion berücksichtigt die aktuelle „ fillRule “, um zu bestimmen, was als innerhalb des Pfades liegend gilt.

Siehe auch „ contains()“.

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

Gibt „true“ zurück, wenn das Caching aktiviert ist; andernfalls „false“.

Diese Funktion wurde in Qt 6.10 eingeführt.

Siehe auch ` setCachingEnabled()`.

bool QPainterPath::isEmpty() const

Gibt „ true “ zurück, wenn dieser Pfad entweder keine Elemente enthält oder wenn das einzige Element ein „ MoveToElement “ ist; andernfalls wird „ false “ zurückgegeben.

Siehe auch elementCount().

qreal QPainterPath::length() const

Gibt die Länge des aktuellen Pfads zurück.

void QPainterPath::lineTo(const QPointF &endPoint)

Fügt eine gerade Linie von der aktuellen Position zum angegebenen Koordinatenpaar ` endPoint` hinzu. Nachdem die Linie gezeichnet wurde, wird die aktuelle Position auf den Endpunkt der Linie aktualisiert.

Siehe auch addPolygon(), addRect() und Composing a QPainterPath.

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

Zeichnet eine Linie von der aktuellen Position zu dem Punkt (x, y).

void QPainterPath::moveTo(const QPointF &point)

Verschiebt den aktuellen Punkt an die angegebene Koordinaten point, wobei implizit ein neuer Teilpfad begonnen und der vorherige geschlossen wird.

Siehe auch „ closeSubpath()“ und „ Composing a QPainterPath “.

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

Verschiebt die aktuelle Position zu (x, y) und beginnt einen neuen Teilpfad, wobei der vorherige Pfad implizit geschlossen wird.

qreal QPainterPath::percentAtLength(qreal len) const

Gibt den prozentualen Anteil der gesamten Strecke bei der angegebenen Länge zurück len.

Beachten Sie, dass – ähnlich wie bei anderen Prozent-Methoden – die Prozentangabe in Bezug auf die Länge nicht linear ist, wenn der Pfad Kurven enthält. Bei Vorhandensein von Kurven wird das Prozent-Argument auf den Parameter t der Bézier-Gleichungen abgebildet.

QPointF QPainterPath::pointAtPercent(qreal t) const

Gibt den Punkt am prozentualen t en des aktuellen Pfades zurück. Das Argument „ t “ muss zwischen 0 und 1 liegen.

Beachten Sie, dass – ähnlich wie bei anderen Prozent-Methoden – die Prozentangabe in Bezug auf die Länge nicht linear ist, wenn der Pfad Kurven enthält. Sind Kurven vorhanden, wird das Prozentargument auf den Parameter t der Bézier-Gleichungen abgebildet.

void QPainterPath::quadTo(const QPointF &c, const QPointF &endPoint)

Fügt eine quadratische Bézier-Kurve zwischen der aktuellen Position und dem angegebenen Koordinatenpaar ` endPoint ` ein, wobei der Kontrollpunkt durch ` c` festgelegt wird.

Nachdem die Kurve hinzugefügt wurde, wird der aktuelle Punkt auf den Endpunkt der Kurve aktualisiert.

Siehe auch cubicTo() und Composing a QPainterPath.

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

Fügt eine quadratische Bézier-Kurve zwischen dem aktuellen Punkt und dem Endpunkt (endPointX, endPointY) ein, wobei der Kontrollpunkt durch (cx, cy) angegeben wird.

void QPainterPath::reserve(int size)

Reserviert eine bestimmte Anzahl von Elementen im internen Speicher von QPainterPath.

Versucht, Speicherplatz für mindestens size Elemente zuzuweisen.

Siehe auch clear(), capacity() und QList::reserve().

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

Aktiviert oder deaktiviert das Längen-Caching entsprechend dem Wert von „ enabled “.

Das Aktivieren des Caching beschleunigt wiederholte Aufrufe von Member-Funktionen, die Pfadlängen und Prozentwerte beinhalten, wie z. B. ` length()`, ` percentAtLength()`, ` pointAtPercent()` usw., geht jedoch mit einem zusätzlichen Speicherbedarf für die Speicherung von Zwischenberechnungen einher. Standardmäßig ist es deaktiviert.

Durch das Deaktivieren des Caching wird der gesamte zugewiesene Cache-Speicher freigegeben.

Diese Funktion wurde in Qt 6.10 eingeführt.

Siehe auch isCachingEnabled(), length(), percentAtLength(), pointAtPercent() und trimmed().

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

Setzt die x- und y-Koordinaten des Elements am Index „ index “ auf „ x “ bzw. „ y “.

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

Legt die Füllregel für den Malpfad auf die angegebene „ fillRule “ fest. Qt bietet zwei Methoden zum Füllen von Pfaden:

Siehe auch ` fillRule()`.

QPainterPath QPainterPath::simplified() const

Gibt eine vereinfachte Version dieses Pfades zurück. Dabei werden alle sich schneidenden Teilpfade zusammengeführt und ein Pfad zurückgegeben, der keine sich schneidenden Kanten enthält. Auch aufeinanderfolgende parallele Linien werden zusammengeführt. Der vereinfachte Pfad verwendet stets die Standard-Füllregel „ Qt::OddEvenFill “. Bézier-Kurven können aufgrund numerischer Instabilitäten bei der Berechnung von Schnittpunkten von Bézier-Kurven zu Liniensegmenten vereinfacht werden.

qreal QPainterPath::slopeAtPercent(qreal t) const

Gibt die Steigung des Pfades am Prozent t zurück. Das Argument „ t “ muss zwischen 0 und 1 liegen.

Beachten Sie, dass ähnlich wie bei anderen Prozent-Methoden die Prozentangabe in Bezug auf die Länge nicht linear ist, wenn der Pfad Kurven enthält. Bei Vorhandensein von Kurven wird das Prozentargument auf den Parameter t der Bézier-Gleichungen abgebildet.

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

Gibt einen Pfad zurück, der der Füllfläche von p abzüglich der Füllfläche dieses Pfads entspricht.

Bei Mengenoperationen auf Pfaden werden die Pfade als Flächen behandelt. Nicht geschlossene Pfade werden implizit als geschlossen behandelt. Bézier-Kurven können aufgrund numerischer Instabilitäten bei der Berechnung von Schnittpunkten von Bézier-Kurven zu Liniensegmenten vereinfacht werden.

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

Tauscht diesen Painer-Pfad gegen „ other “ aus. Dieser Vorgang ist sehr schnell und schlägt niemals fehl.

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

Wandelt den Pfad mithilfe der Funktion „ QTransform “ matrix in ein Polygon um und gibt das Polygon zurück.

Das Polygon wird erstellt, indem zunächst alle Teilpfade in Polygone umgewandelt werden und anschließend mithilfe einer „Rewinding“-Technik sichergestellt wird, dass sich überlappende Teilpfade gemäß der korrekten Füllregel gefüllt werden können.

Beachten Sie, dass beim „Rewinding“ zusätzliche Linien in das Polygon eingefügt werden, sodass der Umriss des Füllpolygons nicht mit dem Umriss des Pfades übereinstimmt.

Siehe auch toSubpathPolygons(), toFillPolygons() und QPainterPath Conversion.

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

Wandelt den Pfad mithilfe der Funktion „ QTransform “ matrix in eine Liste von Polygonen um und gibt diese Liste zurück.

Die Funktion unterscheidet sich von der Funktion „ toFillPolygon()“ dadurch, dass sie mehrere Polygone erstellt. Sie wird bereitgestellt, da das Zeichnen mehrerer kleiner Polygone in der Regel schneller ist als das Zeichnen eines großen Polygons, auch wenn die Gesamtzahl der gezeichneten Punkte gleich ist.

Die Funktion `toFillPolygons()` unterscheidet sich von der Funktion ` toSubpathPolygons()` dadurch, dass sie nur für Teilpfade, deren Begrenzungsrechtecke sich überlappen, ein Polygon erstellt.

Wie die Funktion „ toFillPolygon()“ verwendet auch diese Funktion eine Rückspultechnik, um sicherzustellen, dass sich überschneidende Teilpfade mit der richtigen Füllregel gefüllt werden können. Beachten Sie, dass durch das Zurückspulen zusätzliche Linien in die Polygone eingefügt werden, sodass der Umriss des Füllpolygons nicht mit dem Umriss des Pfades übereinstimmt.

Siehe auch „ toSubpathPolygons()“, „ toFillPolygon()“ und „ QPainterPath Conversion “.

QPainterPath QPainterPath::toReversed() const

Erzeugt eine umgekehrte Kopie des Pfads und gibt diese zurück.

Es ist die Reihenfolge der Elemente, die umgekehrt wird: Wenn ein „ QPainterPath “ durch Aufruf der Funktionen „ moveTo()“, „ lineTo()“ und „ cubicTo()“ in der angegebenen Reihenfolge zusammengesetzt wird, wird die umgekehrte Kopie durch Aufruf der Funktionen „ cubicTo()“, „ lineTo()“ und „ moveTo()“ zusammengesetzt.

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

Wandelt den Pfad mithilfe der Funktion „ QTransform “ ( matrix) in eine Liste von Polygonen um und gibt diese Liste zurück.

Diese Funktion erstellt für jeden Teilpfad ein Polygon, unabhängig davon, ob sich Teilpfade überschneiden (d. h. ob sich die umschließenden Rechtecke überlappen). Um sicherzustellen, dass solche überlappenden Teilpfade korrekt ausgefüllt werden, verwenden Sie stattdessen die Funktion „ toFillPolygons()“.

Siehe auch toFillPolygons(), toFillPolygon() und QPainterPath Conversion.

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

Verschiebt alle Elemente im Pfad um (dx, dy).

Siehe auch translated().

void QPainterPath::translate(const QPointF &offset)

Verschiebt alle Elemente im Pfad um den angegebenen Wert „ offset “.

Siehe auch ` translated()`.

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

Gibt eine Kopie des Pfads zurück, der mit (dx, dy) übersetzt wurde.

Siehe auch ` translate()`.

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

Gibt eine Kopie des Pfads zurück, der durch die angegebene Funktion ` offset` übersetzt wurde.

Siehe auch ` translate()`.

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

Gibt den Abschnitt des Pfades zwischen den Längenanteilen fromFraction und toFraction zurück. Der effektive Bereich der Anteile reicht von 0, was den Startpunkt des Pfades bezeichnet, bis 1, was dessen Endpunkt bezeichnet. Die Anteile verhalten sich linear zur Pfadlänge, im Gegensatz zu den prozentualen t-Werten.

Der Wert von offset wird zu den Bruchwerten addiert. Wenn dies zu einem Über- oder Unterlauf des Bereichs [0, 1] führt, werden die Werte umgebrochen, ebenso wie der resultierende Pfad. Der effektive Bereich des Offsets liegt zwischen -1 und 1.

Wiederholte Aufrufe dieser Funktion können durch {Aktivieren des Caching}{setCachingEnabled()} optimiert werden.

Diese Funktion wurde in Qt 6.10 eingeführt.

Siehe auch length(), percentAtLength() und setCachingEnabled().

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

Gibt einen Pfad zurück, der die Vereinigung aus dem Füllbereich dieses Pfads und dem Füllbereich von p darstellt.

Bei Verknüpfungsoperationen mit Pfaden werden die Pfade als Flächen behandelt. Nicht geschlossene Pfade werden implizit als geschlossen behandelt. Bézier-Kurven können aufgrund numerischer Instabilitäten bei der Berechnung von Schnittpunkten von Bézier-Kurven zu Liniensegmenten vereinfacht werden.

Siehe auch „ intersected()“ und „ subtracted()“.

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

Gibt „ true “ zurück, wenn sich dieser Painter-Pfad vom angegebenen „ path “ unterscheidet.

Beachten Sie, dass der Vergleich von Pfaden einen elementweisen Vergleich erfordern kann, was bei komplexen Pfaden langsam sein kann.

Siehe auch ` operator==()`.

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

Gibt die Schnittmenge dieses Pfads und des Pfads „ other “ zurück.

Siehe auch „ intersected()“, „ operator&=()“, „ united()“ und „ operator|()“.

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

Schneidet diesen Pfad mit other und gibt eine Referenz auf diesen Pfad zurück.

Siehe auch „ intersected()“, „ operator&()“ und „ operator|=()“.

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

Gibt die Vereinigung dieses Pfads und des Pfads „ other “ zurück. Diese Funktion entspricht dem Operator |().

Siehe auch „ united()“, „ operator+=()“ und „ operator-()“.

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

Vereint diesen Pfad mit other und gibt eine Referenz auf diesen Pfad zurück. Dies entspricht dem Operator |=().

Siehe auch united(), operator+() und operator-=().

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

Subtrahiert den Pfad „ other “ von einer Kopie dieses Pfads und gibt die Kopie zurück.

Siehe auch „ subtracted()“, „ operator-=()“ und „ operator+()“.

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

Subtrahiert „ other “ von diesem Pfad und gibt eine Referenz auf diesen Pfad zurück.

Siehe auch „ subtracted()“, „ operator-()“ und „ operator+=()“.

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

Weist „ other “ dieser „ QPainterPath “-Instanz zu.

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

Weist diesem Painter-Pfad die angegebene „ path “ zu.

Siehe auch QPainterPath().

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

Gibt „ true “ zurück, wenn dieser „painterpath“ mit dem angegebenen „ path “ übereinstimmt.

Beachten Sie, dass der Vergleich von Pfaden einen elementweisen Vergleich beinhalten kann, was bei komplexen Pfaden langsam sein kann.

Siehe auch ` operator!=()`.

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

Gibt die Vereinigung dieses Pfades und des Pfades „ other “ zurück.

Siehe auch „ united()“, „ operator|=()“, „ intersected()“ und „ operator&()“.

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

Verknüpft diesen Pfad mit other und gibt eine Referenz auf diesen Pfad zurück.

Siehe auch united(), operator|() und operator&=().