QCanvasPath Class

QCanvasPath ist das native Pfadformat von QCanvasPainter. Mehr...

Überschrift:	`#include <QCanvasPath>`

CMake:	`find_package(Qt6 REQUIRED COMPONENTS CanvasPainter)` `target_link_libraries(mytarget PRIVATE Qt6::CanvasPainter)`
Seit:	Qt 6.11

Liste aller Mitglieder, einschließlich geerbter Mitglieder

Öffentliche Funktionen

	QCanvasPath()
	QCanvasPath(qsizetype commandsSize, qsizetype commandsDataSize = -1)
	QCanvasPath(const QCanvasPath &path)
	QCanvasPath(QCanvasPath &&other)
	~QCanvasPath()
`(since 6.12)` void	addPath(QStringView svgPath, const QTransform &transform = QTransform())
void	addPath(const QCanvasPath &path, const QTransform &transform = QTransform())
void	addPath(const QCanvasPath &path, qsizetype start, qsizetype count, const QTransform &transform = QTransform())
void	arc(qreal centerX, qreal centerY, qreal radius, qreal a0, qreal a1, QCanvasPainter::PathWinding direction = QCanvasPainter::PathWinding::ClockWise, QCanvasPainter::PathConnection connection = QCanvasPainter::PathConnection::Connected)
void	arc(QPointF centerPoint, qreal radius, qreal a0, qreal a1, QCanvasPainter::PathWinding direction = QCanvasPainter::PathWinding::ClockWise, QCanvasPainter::PathConnection connection = QCanvasPainter::PathConnection::Connected)
void	arcTo(qreal x1, qreal y1, qreal x2, qreal y2, qreal radius)
void	arcTo(QPointF point1, QPointF point2, qreal radius)
void	beginHoleSubPath()
void	beginSolidSubPath()
void	bezierCurveTo(qreal cp1X, qreal cp1Y, qreal cp2X, qreal cp2Y, qreal x, qreal y)
void	bezierCurveTo(QPointF controlPoint1, QPointF controlPoint2, QPointF endPoint)
void	circle(qreal x, qreal y, qreal radius)
void	circle(QPointF centerPoint, qreal radius)
void	clear()
void	closePath()
qsizetype	commandsCapacity() const
qsizetype	commandsDataCapacity() const
qsizetype	commandsDataSize() const
qsizetype	commandsSize() const
QPointF	currentPosition() const
void	ellipse(qreal x, qreal y, qreal radiusX, qreal radiusY)
void	ellipse(const QRectF &rect)
bool	isEmpty() const
void	lineTo(QPointF point)
void	lineTo(qreal x, qreal y)
void	moveTo(QPointF point)
void	moveTo(qreal x, qreal y)
QPointF	positionAt(qsizetype index) const
void	quadraticCurveTo(qreal cpX, qreal cpY, qreal x, qreal y)
void	quadraticCurveTo(QPointF controlPoint, QPointF endPoint)
void	rect(qreal x, qreal y, qreal width, qreal height)
void	rect(const QRectF &rect)
void	reserve(qsizetype commandsSize, qsizetype commandsDataSize = -1)
void	roundRect(qreal x, qreal y, qreal width, qreal height, qreal radius)
void	roundRect(qreal x, qreal y, qreal width, qreal height, qreal radiusTopLeft, qreal radiusTopRight, qreal radiusBottomRight, qreal radiusBottomLeft)
void	roundRect(const QRectF &rect, qreal radius)
void	roundRect(const QRectF &rect, qreal radiusTopLeft, qreal radiusTopRight, qreal radiusBottomRight, qreal radiusBottomLeft)
void	setPathWinding(QCanvasPainter::PathWinding winding)
QCanvasPath	sliced(qsizetype start, qsizetype count, const QTransform &transform = QTransform()) const
void	squeeze()
void	swap(QCanvasPath &other)
	operator QVariant() const
QCanvasPath &	operator=(QCanvasPath &&other)
QCanvasPath &	operator=(const QCanvasPath &path)

bool	operator!=(const QCanvasPath &lhs, const QCanvasPath &rhs)
bool	operator==(const QCanvasPath &lhs, const QCanvasPath &rhs)

Ausführliche Beschreibung

Ein Malpfad ist ein Objekt, das aus einer Reihe grafischer Bausteine wie Rechtecken, Ellipsen, Linien und Kurven besteht. Die QCanvasPath-API entspricht der Pfadmalfunktion „ QCanvasPainter “, wodurch sich der Code leicht anpassen lässt, je nachdem, ob direkt gemalt oder in einen Pfad gemalt wird. Der Hauptgrund für die Verwendung von QCanvasPath besteht darin, die erneute Erstellung statischer Pfade zu vermeiden, die in jedem Frame der Darstellung verwendet werden, und möglicherweise das Zwischenspeichern der pfadbezogenen Darstellungsdaten (wie z. B. der daraus generierten Scheitelpunkt- und Indexdaten) zu ermöglichen, anstatt diese bei jeder Füllung oder Umrandung des Pfades neu zu generieren.

Im Vergleich zu „ QPainterPath “ ist „QCanvasPath“ stärker auf das Rendern optimiert und verfügt über weniger Funktionen zum Vergleichen oder Anpassen der Pfade. Insbesondere:

Es gibt keine Methoden zum Schnitt oder zur Subtraktion zwischen zwei Pfaden.
Es gibt keine Methode zum Verschieben des Pfades.
Es gibt keine Methode zum Hinzufügen von Text.

Aus funktionaler Sicht ähnelt QCanvasPath eher dem HTML-Canvas -Path2D, mit einigen Ergänzungen und einer API, die an QCanvasPainter angelehnt ist.

Pfadgruppen und Zwischenspeicherung

Das Zeichnen von Pfaden über QCanvasPath ermöglicht es der Engine, die Pfadgeometrie (Knoten) zwischenzuspeichern. Dies verbessert die Leistung statischer Pfade, erhöht jedoch möglicherweise den CPU- und GPU-Speicherverbrauch.

Beim Zeichnen von Pfaden mit „ fill()“ oder „ stroke()“, die „ QCanvasPath “ als Parameter verwenden, ist es möglich, als zweiten Parameter „ pathGroup “ festzulegen.

Standardmäßig ist pathGroup auf -1 gesetzt, was bedeutet, dass nicht versucht wird, die Pfaddaten zwischenzuspeichern, und das Rendern daher weitgehend identisch abläuft wie beim direkten Zeichnen mit beginPath(), gefolgt von Befehlen zur Pfaddfinition und schließlich einer Füllung oder einem Strich.

Wird ` pathGroup ` auf den Wert ` 0 ` oder eine höhere Zahl gesetzt, werden das Zwischenspeichern und die Wiederverwendung der generierten Geometrie des Pfades aktiviert. Das Anordnen von Pfaden in Pfadgruppen ermöglicht eine effiziente Optimierung der Darstellungsleistung und des Speicherverbrauchs. Pfade, die zusammengehören und sich oft gleichzeitig ändern, sollten für optimale Ergebnisse in derselben Gruppe liegen.

Wenn sich der Pfad ändert, werden seine Daten – selbst wenn sie zwischengespeichert waren – automatisch aktualisiert. Folgende Vorgänge führen zu einer Geometrieaktualisierung der Pfadgruppe:

Das Löschen von Pfadelementen oder das Hinzufügen neuer Elemente.
Änderung der Strichbreite (QCanvasPainter::setLineWidth(), relevant für Striche).
Anpassen des Antialiasing-Grades (QCanvasPainter::setAntialias(), relevant sowohl für Füllungen als auch für Konturen).
Ändern des Linienabschluss- oder Verbindungsstyps (QCanvasPainter::setLineCap(), QCanvasPainter::setLineJoin(), relevant für Konturen).
Ändern von „ winding enforce “ (gilt sowohl für Füllungen als auch für Konturen).
Ändern von high quality stroking (gilt sowohl für Füllungen als auch für Konturen).

Beachten Sie, dass das Ändern der Zustandstransformation (QCanvasPainter::transform(), QCanvasPainter::rotate() usw.) den Pfad nicht ungültig macht, sodass das Verschieben, Skalieren oder Drehen eines zwischengespeicherten Pfads sehr effizient ist.

Betrachten wir als Beispiel einen QCanvasPath- p, der eine sehr große Anzahl von Befehlen enthält. Das Zeichnen von Konturen oder das Füllen dieses Pfades p kann aufgrund des hohen Arbeitsaufwands auf der CPU-Seite eine rechenintensive Operation sein. Die Scheitelpunktdaten müssen möglicherweise bei jedem dieser Strich- oder Füllvorgänge in jedem Frame neu generiert und in die GPU-Puffer geladen werden. Das ist nicht ideal, wenn der Pfad statisch ist und wir ihn lediglich in jedem Frame so effizient wie möglich immer wieder zeichnen möchten.

Wenn eine Pfadgruppe angegeben wird, beispielsweise durch Ersetzen von stroke(p) durch stroke(p, 5), hat der Renderer die Möglichkeit, dedizierte Scheitelpunkt- und Indexpuffer für den Pfad p sowie für jeden anderen Pfad zu verwalten, für den in einem Strich- oder Füllbefehl dieselbe Gruppe (5) angegeben ist.

Unter der Annahme, dass sich der Pfad p (die Befehle im QCanvasPath) nicht ändern, wird das wiederholte Füllen oder Zeichnen dieses Pfads zu einer kostengünstigen Operation, da alle Daten bereits in den für die Pfadgruppe 5 vorgesehenen GPU-Puffern vorhanden sind. Auch die Transformation ist kostengünstig, da bei zwischengespeicherten Pfadgruppen die Transformationen im Vertex-Shader erfolgen und nicht an der Geometrie selbst.

Im folgenden Codeausschnitt gilt: Wenn „ m_path “ komplex genug ist, sich seine Befehle nicht ändern und er in jedem Frame mit derselben Strichbreite, Antialiasing-Stärke usw. umrandet wird, kann das Folgende deutlich effizienter sein als der Verzicht auf Pfadgruppen:

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

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

Beim zweiten, dritten und allen weiteren Malen, in denen „ m_path “ gezeichnet wird, ist das Rendern im Vergleich zur Nichtverwendung von Pfadgruppen sehr ressourcenschonend, da auf der CPU-Seite keine Verarbeitung der Pfadgeometrie erforderlich ist. Das Ändern der Transformation durch Anwenden einer Translation macht die zwischengespeicherten Pfadgruppendaten nicht ungültig, daher ist der verschobene „stroke()“-Aufruf genauso schnell.

Was passiert, wenn sich einer der oben aufgeführten relevanten Zustände ändert? Zum Beispiel, wenn der Pfad mit zwei unterschiedlichen Strichbreiten gezeichnet wird:

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

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

Dies ist nach wie vor sehr effizient, da die Pfadknotendaten zwischengespeichert und sowohl für die Strichbreite 4 als auch für 8 wiederverwendet werden; allerdings steigt der Ressourcenverbrauch leicht an, da der GPU-Puffer für die Pfadgruppen 5 nun sowohl die Version der Pfadgeometrie mit Strichbreite 4 als auch die mit Strichbreite 8 enthält.

Man kann sich Pfadgruppen als einen Caching-Mechanismus vorstellen, bei dem der Pfadgruppenwert als Cache-Schlüssel der ersten Ebene behandelt wird, während das QCanvasPath-Objekt, der Antialiasing-Grad, die Render-Hinweise und – im Falle einer Konturierung – die Strichbreite, die Linienendform und die Linienverbindungsform den Cache-Schlüssel der zweiten Ebene bilden (innerhalb der Pfadgruppe).

Das Ändern der Pfadbefehle (der Elemente im `QCanvasPath`) ist immer rechenintensiv, da dies stets dazu führt, dass die zugehörigen Daten auf der CPU- und GPU-Seite neu aufgebaut werden müssen. Als etwas extremes Beispiel: Wenn ein QCanvasPath seine Befehle in jedem Frame ändert, macht es für diesen bestimmten Pfad keinen Sinn, Pfadgruppen (und sogar QCanvasPath) zu verwenden, da es im Vergleich zum direkten Zeichnen des Pfads über die Funktionen „ QCanvasPainter “ keine Vorteile gibt.

In Fällen, in denen die Pfadgruppe beim Zeichnen nicht mehr verwendet wird oder die Anwendung so viel Speicher wie möglich freigeben möchte, kann der Cache durch den Aufruf von ` QCanvasPainter::removePathGroup()` freigegeben werden. Dies ist in der Regel nicht erforderlich, da die zwischengespeicherten Pfade automatisch während des Destruktors des Painters freigegeben werden.

Siehe auch „ QCanvasPainter::addPath()“ und „ QCanvasPainter::removePathGroup()“.

Dokumentation zu den Member-Funktionen

QCanvasPath::QCanvasPath()

Erstellt einen leeren Pfad.

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

Erstellt einen leeren Pfad und reserviert Speicherplatz für die Anzahl der Befehle „ commandsSize “ sowie optional für die Datenmenge „ commandsDataSize “. Wenn der Parameter „ commandsDataSize “ nicht angegeben wird, wird automatisch Speicherplatz für die Datenmenge „ 2 * commandsSize “ reserviert. Dies ist die optimale Datenmenge, wenn es sich bei den Pfadbefehlen um gerade Linien handelt (moveTo(), lineTo(), rect()).

Die Reservierung des richtigen Speicherplatzes ist eine Optimierung für die Pfaderstellung und die Speichernutzung. Sie ist nicht zwingend erforderlich, da beim Hinzufügen von Befehlen zum Pfad automatisch ausreichend Speicherplatz bereitgestellt wird.

Siehe auch reserve().

QCanvasPath::QCanvasPath(const QCanvasPath &path)

Erstellt einen Pfad, der eine Kopie des angegebenen „ path “ ist.

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

Erstellt ein neues `QCanvasPath`-Objekt aus ` other`.

`[noexcept]` QCanvasPath::~QCanvasPath()

Löscht den Pfad.

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

Fügt „ svgPath “ in diesen Pfad ein und verwendet optional „ transform “, um die Pfadpunkte zu ändern. Wenn die geschätzte Größe des Pfads bekannt ist, sollten Sie zuvor den Aufruf von „ reserve()“ in Betracht ziehen.

Zwei identische grüne, geschwungene Formen aus einem SVG-Pfad, wobei die zweite eine verschobene Kopie ist

// m_path is QCanvasPath
if (m_path.isEmpty()) {
    QString path("M 20 20 C 40 120, 80 120, 100 20 Z");
    m_path.addPath(path);
    m_path.addPath(path, QTransform::fromTranslate(80, 80));
}
p->fill(m_path);
p->stroke(m_path);

Weitere Informationen zu diesem Format finden Sie unter „W3C SVG Path Data “.

Diese Funktion wurde in Qt 6.12 eingeführt.

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

Fügt „ path “ in diesen Pfad ein und verwendet dabei optional „ transform “, um die Pfadpunkte zu ändern. Wenn „ transform “ nicht angegeben wird (oder es sich um die Einheitsmatrix handelt), ist dieser Vorgang sehr schnell, da die Pfaddaten wiederverwendet werden.

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

Fügt „ path “ zum aktuellen Pfad hinzu, beginnend mit dem Befehl unter start und einschließlich count Befehlen. Optional kann transform verwendet werden, um die Pfadpunkte zu ändern. Der Bereich von start und count wird überprüft, damit nicht mehr als QCanvasPath::commandsSize() Befehle aufgerufen werden. Falls der Pfad nicht von der aktuellen Pfadposition aus fortgesetzt werden soll, rufen Sie zunächst moveTo() mit path.positionAt(start - 1) auf.

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

Erzeugt einen Bogen mit dem Mittelpunkt QPointF(centerX, centerY) und dem angegebenen radius, der bei einem Winkel von a0 Radiant beginnt und bei a1 Radiant endet. Der Bogen erstreckt sich über die angegebene direction. Wenn connection gleich NotConnected ist, wird der vorherige Pfad geschlossen und ein neuer Teilpfad begonnen.

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

Erzeugt einen Bogen mit Mittelpunkt centerPoint und der angegebenen radius, der bei einem Winkel von a0 Radiant beginnt und bei a1 Radiant endet. Der Bogen erstreckt sich über die angegebene direction. Wenn connection gleich NotConnected ist, wird der vorherige Pfad geschlossen und ein neuer Teilpfad begonnen.

Dies ist eine überladene Funktion.

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

Erzeugt einen Bogen unter Verwendung der Punkte QPointF(x1, y1) und QPointF(x2, y2) mit dem angegebenen radius.

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

Erzeugt einen Bogen unter Verwendung der Punkte point1 und point2 mit dem angegebenen radius.

Dies ist eine überladene Funktion.

void QCanvasPath::beginHoleSubPath()

Einen Loch-Teilpfad starten. Dies entspricht setPathWinding(QCanvasPainter::PathWinding::ClockWise))

Siehe auch beginSolidSubPath().

void QCanvasPath::beginSolidSubPath()

Starten Sie einen absoluten Teilpfad. Dies entspricht setPathWinding(QCanvasPainter::PathWinding::CounterClockWise))

Siehe auch beginHoleSubPath().

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

Fügt eine kubische Bézier-Kurve zwischen der aktuellen Position und dem durch x und y angegebenen Endpunkt ein, wobei die durch cp1X, cp1Y, cp2X und cp2Y angegebenen Kontrollpunkte verwendet werden.

Nachdem die Kurve hinzugefügt wurde, wird die aktuelle Position so aktualisiert, dass sie am Endpunkt der Kurve liegt.

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

Fügt eine kubische Bézier-Kurve zwischen der aktuellen Position und dem angegebenen endPoint hinzu, wobei die durch controlPoint1 und controlPoint2 angegebenen Kontrollpunkte verwendet werden.

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

Dies ist eine überladene Funktion.

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

Fügt dem Pfad einen Kreis hinzu, dessen Mittelpunkt bei QPointF(x, y) liegt und dessen Radius mit radius angegeben wird.

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

Fügt dem Pfad einen Kreis hinzu, dessen Mittelpunkt bei centerPoint liegt und dessen Radius mit radius angegeben wird.

Dies ist eine überladene Funktion.

void QCanvasPath::clear()

Löscht die Pfadbefehle und Daten.

Rufen Sie diese Funktion auf, wenn sich die Pfadbefehle ändern, um den Pfad neu zu erstellen. Dies hat keinen Einfluss auf den Speicherverbrauch; verwenden Sie hierfür reserve() und squeeze().

Siehe auch reserve() und squeeze().

void QCanvasPath::closePath()

Schließt den aktuellen Teilpfad, indem eine Linie zum Anfang des Teilpfads gezeichnet wird, und beginnt automatisch einen neuen Pfad.

qsizetype QCanvasPath::commandsCapacity() const

Gibt die Kapazität der Befehle im Pfad zurück.

Siehe auch commandsDataCapacity() und reserve().

qsizetype QCanvasPath::commandsDataCapacity() const

Gibt die Kapazität der Befehlsdaten im Pfad zurück.

Siehe auch commandsCapacity() und reserve().

qsizetype QCanvasPath::commandsDataSize() const

Gibt die Anzahl der Befehlsdaten im Pfad zurück.

Unter Befehlsdaten versteht man im Wesentlichen die von den Befehlen benötigten Punkte.

Hinweis: Einige Pfadelemente erfordern mehrere Datenpunkte. Beispielsweise benötigt „ closePath “ die Datenpunkte „ 0 “, „ moveTo “ und „ lineTo “ die Datenpunkte „ 2 “, „ bezierCurveTo “ benötigt 6 und „ roundRect “ benötigt die Datenpunkte „ 34 “.

qsizetype QCanvasPath::commandsSize() const

Gibt die Anzahl der Befehle im Pfad zurück.

Hinweis: Einige Pfadelemente erfordern mehrere Befehle. Beispielsweise erfordern „ moveTo “ und „ lineTo “ den Befehl „ 1 “, „ bezierCurveTo “ die Befehle „ 6 “ und „ roundRect “ die Befehle „ 10 “.

QPointF QCanvasPath::currentPosition() const

Gibt die aktuelle Position des Pfades zurück. Damit ist die Position gemeint, an der der vorherige Pfadbefehl (moveTo, lineTo, bezierCurveTo usw.) endete. Ist der Pfad leer, wird (0,0; 0,0) zurückgegeben.

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

Erzeugt eine Ellipse mit dem Mittelpunkt (x, y) und den Radien radiusX und radiusY und fügt sie dem Pfad als geschlossenen Teilpfad hinzu.

void QCanvasPath::ellipse(const QRectF &rect)

Erstellt eine Ellipse innerhalb des Rechtecks „ rect “ und fügt sie dem Pfad als geschlossenen Teilpfad hinzu.

Dies ist eine überladene Funktion.

bool QCanvasPath::isEmpty() const

Gibt „true“ zurück, wenn der Pfad leer ist.

Siehe auch clear.

void QCanvasPath::lineTo(QPointF point)

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

Dies ist eine überladene Funktion.

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

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

Dies ist eine überladene Funktion.

void QCanvasPath::moveTo(QPointF point)

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

Dies ist eine überladene Funktion.

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

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

Dies ist eine überladene Funktion.

QPointF QCanvasPath::positionAt(qsizetype index) const

Gibt die Position des Pfades unter index zurück. Damit ist die Position gemeint, an der sich der Pfadbefehl (moveTo, lineTo, bezierCurveTo usw.) unter index befindet. Der Index muss zwischen 0 und commandsSize() - 1 liegen. Ist der Pfad leer, wird (0,0, 0,0) zurückgegeben.

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

Fügt eine quadratische Bézier-Kurve zwischen dem aktuellen Punkt und dem Endpunkt (x, y) ein, wobei der Kontrollpunkt durch (cpX, cpY) angegeben wird.

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

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

Dies ist eine überladene Funktion.

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

Erzeugt ein Rechteck, das an der Position QPointF(x, y) platziert wird, mit den angegebenen Werten für „ width “ und „ height “.

void QCanvasPath::rect(const QRectF &rect)

Erzeugt ein Rechteck, das durch rect

Dies ist eine überladene Funktion.

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

Reserviert eine bestimmte Menge an Speicherplatz im internen Speicher von „ QCanvasPath “.

Versucht, Speicherplatz für mindestens commandsSize Befehle und commandsDataSize Datenpunkte zuzuweisen. Einige Pfadelemente erfordern mehrere Befehle, siehe commandsSize() und commandsDataSize().

Wenn commandsDataSize nicht angegeben wird, wird automatisch Speicherplatz für die Datenmenge 2 * commandsSize reserviert; dies ist die optimale Menge, wenn es sich bei den Pfadbefehlen um gerade Linien handelt (moveTo(), lineTo(), rect()).

Die Reservierung des richtigen Speicherplatzes ist eine Optimierung für die Pfaderzeugung und die Speichernutzung. Sie ist nicht zwingend erforderlich, da beim Hinzufügen von Befehlen zum Pfad automatisch ausreichend Speicherplatz sichergestellt wird.

Siehe auch squeeze(), commandsCapacity() und commandsDataCapacity().

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

Fügt dem Pfad das angegebene Rechteck x, y, width, height mit abgerundeten Ecken hinzu. Die Ecken sind Viertelkreise mit den angegebenen Werten radius.

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

Fügt dem Pfad die Rechtecke x, y, width und height mit abgerundeten Ecken hinzu. Die Ecken sind Viertelkreise mit den Radien radiusTopLeft, radiusTopRight, radiusBottomRight bzw. radiusBottomLeft.

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

Fügt das angegebene Rechteck „ rect “ mit abgerundeten Ecken zum Pfad hinzu. Die Ecken sind Viertelkreise mit dem angegebenen „ radius “.

Dies ist eine überladene Funktion.

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

Fügt dem Pfad das Rechteck rect mit abgerundeten Ecken hinzu. Die Ecken sind Viertelkreise mit den Radien radiusTopLeft, radiusTopRight, radiusBottomRight und radiusBottomLeft.

Dies ist eine überladene Funktion.

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

Legt den aktuellen Teilpfad „ winding “ entweder auf „ QCanvasPainter::CounterClockWise “ (Standard) oder „ QCanvasPainter::ClockWise “ fest. „CounterClockWise“ zeichnet geschlossene Teilpfade, während „ClockWise“ Löcher zeichnet.

Hinweis: Dies ist ein Befehl, ähnlich wie „ lineTo “, „ moveTo “ usw., daher sollte die Einstellung der Windungsrichtung vor den übrigen Befehlen erfolgen, auf die die geänderte Windungsrichtung angewendet werden soll.

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

Gibt einen neuen Pfad zurück, der die Befehle aus diesem Pfad enthält, beginnend mit dem Befehl unter start und einschließlich count Anzahl an Befehlen, wobei optional transform verwendet werden kann, um die Pfadpunkte zu ändern.

Der Bereich von start bis count wird überprüft, damit nicht auf mehr als commandsSize() Befehle zugegriffen wird. Falls der Befehl unter start nicht MoveTo lautet, wird der erste Befehl durch MoveTo ersetzt, damit dieser Ausschnitt einen eigenständigen Pfad bildet.

void QCanvasPath::squeeze()

Gibt den Speicher frei, der nicht zur Speicherung der Pfadbefehle und Daten benötigt wird. Dies kann genutzt werden, um den Speicherverbrauch nach dem Aufruf von ` reserve()` zu reduzieren.

Normalerweise ist die Verwendung dieser Funktion nicht erforderlich, sie kann jedoch nützlich sein, wenn die Pfadgröße aufgrund der Reservierung oder des Hinzufügens vieler Elemente (lineTo, bezierCurveTo usw.) groß geworden ist und erwartet wird, dass die Größe in Zukunft deutlich kleiner sein wird. In diesem Fall wird durch den Aufruf von zunächst reserve() und anschließend squeeze() etwas Speicher freigegeben.

Siehe auch reserve().

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

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

QCanvasPath::operator QVariant() const

Gibt den Pfad als ` QVariant` zurück.

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

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

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

Weist dem angegebenen „ path “ diesen Pfad zu und gibt eine Referenz auf diesen Pfad zurück.

QCanvasPath Class

Öffentliche Funktionen

Verwandte Nicht-Mitglieder

Ausführliche Beschreibung

Pfadgruppen und Zwischenspeicherung

Dokumentation zu den Member-Funktionen

QCanvasPath::QCanvasPath()

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

QCanvasPath::QCanvasPath(const QCanvasPath &path)

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

[noexcept] QCanvasPath::~QCanvasPath()

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

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

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

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

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

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

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

void QCanvasPath::beginHoleSubPath()

void QCanvasPath::beginSolidSubPath()

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

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

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

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

void QCanvasPath::clear()

void QCanvasPath::closePath()

qsizetype QCanvasPath::commandsCapacity() const

qsizetype QCanvasPath::commandsDataCapacity() const

qsizetype QCanvasPath::commandsDataSize() const

qsizetype QCanvasPath::commandsSize() const

QPointF QCanvasPath::currentPosition() const

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

void QCanvasPath::ellipse(const QRectF &rect)

bool QCanvasPath::isEmpty() const

void QCanvasPath::lineTo(QPointF point)

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

void QCanvasPath::moveTo(QPointF point)

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

QPointF QCanvasPath::positionAt(qsizetype index) const

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

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

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

void QCanvasPath::rect(const QRectF &rect)

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

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

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

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

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

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

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

void QCanvasPath::squeeze()

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

QCanvasPath::operator QVariant() const

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

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

Verwandte Nicht-Mitglieder

[noexcept] bool operator!=(const QCanvasPath &lhs, const QCanvasPath &rhs)

[noexcept] bool operator==(const QCanvasPath &lhs, const QCanvasPath &rhs)

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

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

`[noexcept]` QCanvasPath::~QCanvasPath()

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

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

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

`[noexcept]` bool operator!=(const QCanvasPath &lhs, const QCanvasPath &rhs)

`[noexcept]` bool operator==(const QCanvasPath &lhs, const QCanvasPath &rhs)