QCanvasPainter Class

QRectF rect(40, 70, 120, 60);
QRectF shadowRect = rect.translated(2, 4);
// Paint shadow
QCanvasBoxShadow shadow(shadowRect);
shadow.setRadius(30);
shadow.setBlur(15);
shadow.setColor("#60373F26");
p->drawBoxShadow(shadow);
// Paint rounded rect
p->beginPath();
p->roundRect(rect, 30);
p->setFillStyle("#DBEB00");
p->fill();
// Paint text
p->setTextAlign(QCanvasPainter::TextAlign::Center);
p->setTextBaseline(QCanvasPainter::TextBaseline::Middle);
QFont font("Titillium Web", 18);
p->setFont(font);
p->setFillStyle("#373F26");
p->fillText("CLICK!", rect);

// Paint grid
QCanvasGridPattern grid(0, 0, 10, 10);
grid.setLineColor("#404040");
grid.setBackgroundColor("#202020");
p->setFillStyle(grid);
p->fillRect(0, 0, width(), height());
// Paint axis
p->setFillStyle(QColorConstants::White);
p->fillRect(0, 0.5 * height() - 1, width(), 2);
p->fillRect(0.5 * width() - 1, 0, 2, height());
// Paint shadowed graph
p->beginPath();
p->moveTo(20, height() * 0.8);
p->bezierCurveTo(width() * 0.2, height() * 0.4,
                 width() * 0.5, height() * 0.8,
                 width() - 20, height() * 0.2);
p->setAntialias(10);
p->setLineWidth(12);
p->setStrokeStyle("#D0000000");
p->stroke();
p->setAntialias(1);
p->setLineWidth(6);
QCanvasLinearGradient lg(0, 0, 0, height());
lg.setStartColor(QColorConstants::Red);
lg.setEndColor(QColorConstants::Green);
p->setStrokeStyle(lg);
p->stroke();

p->setWindingEnforce(false);
p->beginPath();
// Outer shape, counterclockwise
p->moveTo(20, 20);
p->lineTo(100, 180);
p->lineTo(180, 20);
p->closePath();
// Inner shape, clockwise
p->moveTo(100, 40);
p->lineTo(125, 90);
p->lineTo(75, 90);
p->closePath();
p->fill();
p->stroke();

p->beginPath();
p->roundRect(20, 20, 160, 160, 30);
// Start painting holes
p->beginHoleSubPath();
p->roundRect(40, 40, 120, 120, 10);
// Start painting solid
p->beginSolidSubPath();
p->rect(60, 60, 80, 20);
p->circle(100, 120, 20);
p->fill();
p->stroke();

Dokumentation der Mitgliedsfunktionen

QCanvasPainter::QCanvasPainter()

Erstellt einen „Painter“.

[noexcept] QCanvasPainter::~QCanvasPainter()

Vernichtet den Maler.

qsizetype QCanvasPainter::activeImageCount() const

Gibt die Anzahl der aktiven „ QCanvasImage “-Objekte zurück, die bei diesem „ QCanvasPainter “ registriert sind. Dazu gehören auch die intern erstellten Bilder für „ gradients “.

QCanvasImage Objekte, die durch die Registrierung von „ QCanvasOffscreenCanvas “-Instanzen oder durch extern verwaltete Texturen erstellt wurden, werden von dieser Funktion nicht berücksichtigt.

Siehe auch activeImageMemoryUsage(), addImage() und removeImage().

qsizetype QCanvasPainter::activeImageMemoryUsage() const

Gibt eine Schätzung in Kilobyte des Speicherbedarfs der Bilddaten (Pixel) für alle aktiven „ QCanvasImage “-Instanzen dieses „painter“ zurück, die durch die Überladung von „ addImage()“ unter Verwendung von „ QImage “ erstellt wurden. Dies umfasst auch die Daten von intern erstellten Bildern für „ gradients “.

QCanvasPainter Es werden keine Kopien der CPU-seitigen „ QImage “-Daten aufbewahrt, sobald „ addImage()“ zurückgekehrt ist. Daher ist das Ergebnis dieser Funktion eine Annäherung an den GPU-Speicher, der für Texturen verwendet wird.

Offscreen-Canvases und extern verwaltete Texturen, die über die anderen Überladungen von ` addImage()` registriert wurden, werden von dieser Funktion nicht berücksichtigt.

Für jede gültige ` QCanvasImage` kann die jeweilige Größe in Byte jederzeit durch Aufruf von ` sizeInBytes()` abgefragt werden. Diese Funktion liefert auch dann gültige Ergebnisse, wenn die ` QCanvasImage ` aus einer ` QCanvasOffscreenCanvas ` oder ` QRhiTexture` erstellt wurde, berücksichtigt jedoch keine Mipmap- oder Multisample-Daten.

Siehe auch activeImageCount(), addImage() und removeImage().

QCanvasImage QCanvasPainter::addImage(const QImage &image, QCanvasPainter::ImageFlags flags = {})

Fügt „ image “ mit „ flags “ hinzu, das dem Painter als Textur zur Verfügung steht. Gibt „ QCanvasImage “ mit der Textur-ID und weiteren Informationen zum Bild zurück. Die zurückgegebene „ QCanvasImage “ kann anschließend mit „ drawImage “ und „ QCanvasImagePattern “ verwendet werden. Nach dem Aufruf dieser Methode muss das „ image “ „ QImage “ nicht mehr im Speicher gehalten werden.

Der Aufruf mit demselben ` image ` ist eine ressourcenschonende Operation, da ein Cache-Treffer erwartet wird.

Bei der Optimierung ist darauf zu achten, dass addImage() nur einmal aufgerufen wird. Je nach Anwendungsdesign reicht dies jedoch nicht immer aus. Wenn beispielsweise die zugrunde liegenden Grafikressourcen verloren gehen – z. B. weil der „Painter“ intern mit einem neuen ` QRhi ` verknüpft wird, da ein Widget auf eine neue oberste Ebene verschoben wurde –, ist der Aufruf dieser Funktion unerlässlich, um die nativen Grafiktexturen aus ` image` neu zu erstellen.

Siehe auch drawImage() und removeImage().

QCanvasImage QCanvasPainter::addImage(QRhiTexture *texture, QCanvasPainter::ImageFlags flags = {})

Fügt „ texture “ mit „ flags “ hinzu, das dem Painter als Textur zur Verfügung steht. Das zurückgegebene „ QCanvasImage “ kann mit „ drawImage “ und „ QCanvasImagePattern “ verwendet werden.

Siehe auch „ drawImage()“ und „ removeImage()“.

QCanvasImage QCanvasPainter::addImage(const QCanvasOffscreenCanvas &canvas, QCanvasPainter::ImageFlags flags = {})

Registriert „ canvas “ mit „ flags “ beim Painter, sodass es als Bild verfügbar ist. Das zurückgegebene „ QCanvasImage “ kann mit „ drawImage “ und „ QCanvasImagePattern “ verwendet werden.

Siehe auch drawImage() und removeImage().

void QCanvasPainter::addPath(const QPainterPath &path)

Fügt „ path “ zum aktuellen Pfad hinzu.

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

Fügt „ path “ in den aktuellen 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 QCanvasPainter::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() auf, z. B. mit path.positionAt(start - 1).

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

Erstellt einen neuen Teilpfad in Form eines Kreisbogens. Der Mittelpunkt des Bogens liegt bei centerX, centerY, mit radius, und der Bogen wird vom Winkel a0 bis a1 gezeichnet und in direction (ClockWise oder CounterClockWise) geschwenkt. Wenn connection gleich NotConnected ist, fügt der Bogen keine Linie von der vorherigen Pfadposition zum Anfang des Bogens hinzu. Winkel werden in Radianten angegeben.

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

Erstellt einen neuen Teilpfad in Form eines Kreisbogens. Der Mittelpunkt des Bogens liegt bei centerPoint, der Radius beträgt radius, und der Bogen wird vom Winkel a0 bis zum Winkel a1 gezeichnet und in direction (ClockWise oder CounterClockWise) gezeichnet. Wenn connection den Wert NotConnected hat, fügt der Bogen keine Linie von der vorherigen Pfadposition zum Startpunkt des Bogens hinzu. Winkel werden in Radianten angegeben.

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

Fügt an der Ecke, die durch den letzten Pfadpunkt und zwei angegebene Punkte (x1, y1 und x2, y2) definiert ist, ein Bogensegment mit der Koordinaten radius hinzu. Der Bogen wird bei Bedarf automatisch durch eine Gerade mit dem letzten Punkt des Pfades verbunden.

void QCanvasPainter::arcTo(QPointF controlPoint1, QPointF controlPoint2, qreal radius)

Fügt an der Ecke, die durch den letzten Pfadpunkt und zwei angegebene Punkte (controlPoint1 und controlPoint2) definiert ist, ein Bogensegment hinzu, wobei radius gilt. Der Bogen wird bei Bedarf automatisch mit einer geraden Linie an den letzten Punkt des Pfades angeschlossen.

void QCanvasPainter::beginHoleSubPath()

Einen Teilpfad „hole“ starten. Dies entspricht setPathWinding(QCanvasPainter::PathWinding::ClockWise))

Siehe auch beginSolidSubPath().

void QCanvasPainter::beginPath()

Beginnt mit dem Zeichnen eines neuen Pfades und löscht dabei den aktuellen Pfad.

void QCanvasPainter::beginSolidSubPath()

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

Siehe auch beginHoleSubPath().

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

Fügt ein kubisches Bézier-Segment vom letzten Punkt des Pfades über zwei Kontrollpunkte (cp1X, cp1Y und cp2X, cp2Y) bis zum angegebenen Punkt (x, y) hinzu.

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

Fügt ein kubisches Bézier-Segment vom letzten Punkt des Pfades über zwei Kontrollpunkte (controlPoint1 und controlPoint2) bis zum angegebenen Punkt endPoint hinzu.

void QCanvasPainter::circle(qreal centerX, qreal centerY, qreal radius)

Erstellt einen neuen kreisförmigen Teilpfad, der auf den Punkten ( centerX, centerY) zentriert ist und einen Radius von radius hat.

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

Erstellt einen neuen kreisförmigen Teilpfad, dessen Mittelpunkt bei „ centerPoint “ liegt und dessen Radius „ radius “ beträgt.

void QCanvasPainter::cleanupResources()

Entfernt nicht verwendete Texturen aus dem Cache.

Zudem können beim Aufruf dieser Funktion andere Caches und Pools verkleinert werden, um den Speicherverbrauch zu minimieren. Dies kann möglicherweise zu aufwändigeren Zeichenaufrufen im Anschluss führen.

void QCanvasPainter::clearRect(qreal x, qreal y, qreal width, qreal height)

Löscht die Pixel in einem rechteckigen Bereich, indem das durch x, y, width und height angegebene Rechteck mit transparentem Schwarz gefüllt wird. Da das Löschen keine Überblendung erfordert, kann es schneller sein als fillRect().

void QCanvasPainter::clearRect(const QRectF &rect)

Löscht die Pixel in einem rechteckigen Bereich, indem das durch ` rect ` angegebene Rechteck mit transparentem Schwarz gefüllt wird. Hierbei handelt es sich um eine überladene Methode, die ` QRectF` verwendet.

void QCanvasPainter::closePath()

Schließt den aktuellen Teilpfad mit einem Liniensegment ab. Dies entspricht dem Befehl „ lineTo “ ([Startpunkt]) als letztes Pfadelement.

QCanvasOffscreenCanvas QCanvasPainter::createCanvas(QSize pixelSize, int sampleCount = 1, QCanvasOffscreenCanvas::Flags flags = {})

Gibt eine neue Offscreen-Leinwand mit den angegebenen Werten für „ pixelSize “, „ sampleCount “ und „ flags “ zurück.

Die Größe des Canvas wird in Pixeln angegeben. Die Eigenschaften ` pixelSize`, ` sampleCount` und ` flags ` sind danach unveränderlich. Um einen Canvas mit einer anderen Größe, einer anderen Sample-Anzahl oder anderen Flags zu erhalten, erstellen Sie einen neuen.

Um eine Offscreen-Canvas mit Zeichenbefehlen anzusteuern, rufen Sie bei der Arbeit mit der Low-Level-API die entsprechende Überladung von ` QCanvasRhiPaintDriver::beginPaint()` auf, oder bei Verwendung der Komfort-Widget- oder „ Qt Quick “-Elementklassen die Methoden ` QCanvasPainterWidget::beginCanvasPainting()` oder ` QCanvasPainterItemRenderer::beginCanvasPainting()`.

Normalerweise wird der Inhalt der Leinwand beim Zeichnen gelöscht. Um dies zu deaktivieren, übergeben Sie ` PreserveContents ` in ` flags`.

Um Multisample-Rendering auf die Leinwand anzufordern (Multisample-Antialiasing, MSAA), legen Sie eine Sample-Anzahl größer als 1 fest, beispielsweise 4 oder 8. Das Beibehalten des Leinwandinhalts zwischen den Render-Durchläufen wird jedoch nicht unterstützt, wenn Multisampling aktiviert ist, und das Flag ` PreserveContents ` funktioniert in diesem Fall nicht.

void QCanvasPainter::destroyCanvas(QCanvasOffscreenCanvas &canvas)

Zerstört die Ressourcen, die hinter „ canvas “ stehen. „ canvas “ wird dann zu „ null canvas “.

Der „Painter“ führt dies automatisch bei seiner Zerstörung durch. Daher ist der Aufruf dieser Funktion nur dann erforderlich, wenn die zugehörigen Ressourcen sofort freigegeben werden sollen.

void QCanvasPainter::drawBoxShadow(const QCanvasBoxShadow &shadow)

Zeichnet ein Rechteck mit der Funktion „ shadow “. Der Schatten wird mit den durch „ shadow “ definierten Parametern für Position, Größe, Farbe, Unschärfe usw. gezeichnet. Der Aufruf von „ beginPath()“ vor dieser Methode ist nicht erforderlich.

Siehe auch QCanvasBoxShadow.

void QCanvasPainter::drawImage(const QCanvasImage &image, qreal x, qreal y)

Zeichne „ image “ in „ x “, „ y “, in der Standardgröße.

Siehe auch addImage().

void QCanvasPainter::drawImage(const QCanvasImage &image, const QRectF &destinationRect)

Zeichne image in der Position und Größe von destinationRect.

Siehe auch addImage().

void QCanvasPainter::drawImage(const QCanvasImage &image, const QRectF &sourceRect, const QRectF &destinationRect)

Zeichne „ image “ in der Position und Größe von „ destinationRect “ aus dem Bildbereich „ sourceRect “ ein.

Siehe auch addImage().

void QCanvasPainter::drawImage(const QCanvasImage &image, qreal x, qreal y, qreal width, qreal height)

Zeichne „ image “ in „ x “, „ y “ an den angegebenen Koordinaten „ width “ und „ height “.

Siehe auch addImage().

void QCanvasPainter::ellipse(qreal centerX, qreal centerY, qreal radiusX, qreal radiusY)

Erstellt einen neuen ellipsenförmigen Teilpfad, dessen Mittelpunkt bei ( centerX, centerY) liegt, mit den Werten radiusX und radiusY.

void QCanvasPainter::ellipse(const QRectF &rect)

Erstellt einen neuen ellipsenförmigen Teilpfad in „ rect “. Diese Ellipse deckt den Bereich „ rect “ ab.

void QCanvasPainter::ellipse(QPointF centerPoint, qreal radiusX, qreal radiusY)

Erstellt einen neuen ellipsenförmigen Teilpfad, dessen Mittelpunkt bei centerPoint liegt und dessen Achsen bei radiusX und radiusY liegen.

void QCanvasPainter::fill()

Füllt den aktuellen Pfad mit dem aktuellen Füllstil und der aktuellen Füllregel.

Siehe auch setFillStyle() und setFillRule().

[since 6.12] void QCanvasPainter::fill(QCanvasPainter::FillRule fillRule)

Füllt den aktuellen Pfad mit dem aktuellen Füllstil und der Füllregel „ fillRule “.

Diese Funktion wurde in Qt 6.12 eingeführt.

Siehe auch „ setFillStyle()“ und „ setFillRule()“.

void QCanvasPainter::fill(const QCanvasPath &path, int pathGroup = -1)

Füllt den „ path “ mit dem aktuellen Füllstil und der aktuellen Füllregel und ordnet ihn dem „ pathGroup “ zu. Das Zeichnen über den „ QCanvasPath “ ist optimal, wenn der Pfad mehr Befehle enthält und größtenteils statisch ist.

Wenn „ pathGroup “ den Wert „ -1 “ hat, wird der Pfad auf der GPU-Seite nicht zwischengespeichert. Dies ist die Standardeinstellung. Um die Zwischenspeicherung von Pfaddaten anzufordern, übergeben Sie einen Wert, der gleich oder größer als „ 0 “ ist. Weitere Informationen zur Verwendung von Pfad-Cache-Gruppen finden Sie in der Dokumentation unter „ QCanvasPath “.

Der Aufruf von ` beginPath()` vor dieser Methode ist nicht erforderlich.

Siehe auch ` setFillStyle()`, ` setFillRule()` und ` removePathGroup()`.

[since 6.12] void QCanvasPainter::fill(const QCanvasPath &path, QCanvasPainter::FillRule fillRule, int pathGroup = -1)

Füllt den „ path “ mit dem aktuellen Füllstil und der aktuellen Füllregel fillRule

Diese Funktion wurde in Qt 6.12 eingeführt.

void QCanvasPainter::fillRect(qreal x, qreal y, qreal width, qreal height)

Zeichnet ein gefülltes Rechteck an der angegebenen Position ( x, y) mit der Größe width, height.

void QCanvasPainter::fillRect(const QRectF &rect)

Zeichnet ein gefülltes Rechteck in ` rect`. Hierbei handelt es sich um eine überladene Methode, die ` QRectF` verwendet.

void QCanvasPainter::fillText(const QString &text, qreal x, qreal y, qreal maxWidth = 0)

Zeichnet eine „ text “-Zeichenkette an der angegebenen Position ( x, y) mit den aktuellen Werten für „textAlign“ und „textBaseline“. Um den Text mehrzeilig umbrechen zu lassen, setzen Sie den Zeilenumbruchmodus mithilfe von setTextWrapMode() auf einen anderen Wert als den Standardwert „ NoWrap “. Der optionale Parameter „ maxWidth “ ist standardmäßig auf „ 0 “ gesetzt. Das bedeutet, dass der Text beispielsweise bei der Einstellung „ WordWrap “ nach jedem Wort umgebrochen wird. Setzen Sie den Parameter „ maxWidth “ auf die gewünschte Zeilenbreite in Pixeln.

Siehe auch setTextAlign(), setTextBaseline() und setTextWrapMode().

void QCanvasPainter::fillText(const QString &text, const QRectF &rect)

Zeichnet die Zeichenkette „ text “ innerhalb des Bereichs „ rect “ mit den aktuellen Werten für „textAlign“ und „textBaseline“. Die Breite des Parameters „rect“ wird als „maxWidth“ verwendet.

Dies ist eine überladene Methode, die „ QRectF “ verwendet. Oft ist es sinnvoll, die Textgrundlinie auf „ TextBaseline::Top “ oder „ TextBaseline::Middle “ zu setzen, wenn Text mit dieser Methode gezeichnet wird.

Siehe auch „ setTextAlign()“, „ setTextBaseline()“ und „ setTextWrapMode()“.

void QCanvasPainter::fillText(const QString &text, QPointF point, qreal maxWidth = 0)

Zeichnet die Zeichenkette „ text “ an der angegebenen Position „ point “ mit den aktuellen Werten für „textAlign“ und „textBaseline“ ein. Um den Text in mehrere Zeilen umbrechen zu lassen, setzen Sie den Zeilenumbruchmodus mithilfe von „ setTextWrapMode()“ auf einen anderen Wert als den Standardwert „ NoWrap “. Der optionale Parameter „ maxWidth “ ist standardmäßig auf „ 0 “ gesetzt. Das bedeutet, dass beispielsweise bei der Einstellung „ WordWrap “ der Text nach jedem Wort umgebrochen wird. Setzen Sie den Parameter ` maxWidth ` auf die gewünschte Zeilenbreite in Pixeln.

Dies ist eine überladene Methode, die „ QPointF “ verwendet.

Siehe auch „ setTextAlign()“, „ setTextBaseline()“ und „ setTextWrapMode()“.

QTransform QCanvasPainter::getTransform() const

Gibt die aktuelle Transformation zurück.

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

Fügt eine Liniensegment vom letzten Punkt des Pfades zum Punkt ( x, y) hinzu.

void QCanvasPainter::lineTo(QPointF point)

Fügt eine Liniensegment vom letzten Punkt des Pfades bis zum „ point “ hinzu.

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

Startet einen neuen Teilpfad mit ( x, y) als erstem Punkt.

void QCanvasPainter::moveTo(QPointF point)

Startet einen neuen Teilpfad mit „ point “ als erstem Punkt.

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

Fügt ein quadratisches Bézier-Segment vom letzten Punkt des Pfades über einen Kontrollpunkt (cpX, cpY) zum angegebenen Punkt (x, y) hinzu.

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

Fügt ein quadratisches Bézier-Segment vom letzten Punkt des Pfades über einen „ controlPoint “ zum angegebenen „ endPoint “ hinzu.

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

Erstellt einen neuen rechteckigen Teilpfad an der Position x, y mit den Abmessungen width, height.

void QCanvasPainter::rect(const QRectF &rect)

Erstellt einen neuen rechteckigen Teilpfad an der Position „ rect “. Hierbei handelt es sich um eine überladene Methode, die „ QRectF “ verwendet.

void QCanvasPainter::removeImage(const QCanvasImage &image)

Gibt die mit ` image ` verknüpften Ressourcen frei und entfernt das Bild aus dem Painter.

Siehe auch ` addImage()`.

void QCanvasPainter::removePathGroup(int pathGroup)

Entfernt „ pathGroup “ aus dem Painter-Cache. Wenn anschließend „ fill()“ oder „ stroke()“ für „ pathGroup “ aufgerufen wird, wird der Pfad im Gruppen-Cache neu generiert.

Siehe auch „ fill()“ und „ stroke()“.

void QCanvasPainter::reset()

Setzt den aktuellen Malzustand auf die Standardwerte zurück.

Dazu gehören die Strich- und Füllstile sowie die zugehörigen Eigenschaften, die Transformationsmatrix, der Ausschnittbereich, die textbezogenen Einstellungen, die Compositing-Eigenschaften, der Zeichnungszustandsstapel und die Antialiasing-Einstellungen.

Siehe auch „ save()“ und „ restore()“.

void QCanvasPainter::resetClipping()

Setzt die Clipping-Einstellung zurück und deaktiviert sie.

Siehe auch „ setClipRect()“.

void QCanvasPainter::resetTransform()

Setzt die aktuelle Transformation auf eine Einheitsmatrix zurück.

void QCanvasPainter::restore()

Ruft den aktuellen Render-Zustand ab und stellt ihn wieder her. Der zuvor gespeicherte Zustand wird somit wiederhergestellt. Wenn save() nicht aufgerufen wurde und der Zustandsstapel leer ist, hat der Aufruf dieser Funktion keine Auswirkung.

Siehe auch ` save()`.

void QCanvasPainter::rotate(qreal angle)

Dreht das aktuelle Koordinatensystem um angle im Uhrzeigersinn.

Der Winkel wird in Radianten angegeben. Verwenden Sie qDegreesToRadians(), um Grad in Radianten umzurechnen.

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

Erstellt einen neuen Unterpfad in Form eines abgerundeten Rechtecks an der Position x, y mit den Abmessungen width, height. Die Ecken werden wie folgt abgerundet: radius.

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

Erstellt einen neuen, abgerundeten Rechteck-Teilpfad an der Position „ rect “ mit den Ecken „ radius “. Hierbei handelt es sich um eine überladene Methode, die „ QRectF “ verwendet.

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

Erstellt einen neuen, abgerundeten, rechteckigen Teilpfad unter rect. Die Ecken können je nach Ecke unterschiedlich abgerundet werden, mit radiusTopLeft, radiusTopRight, radiusBottomRight und radiusBottomLeft.

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

Erstellt einen neuen, abgerundeten, rechteckigen Teilpfad an der Position x, y mit den Abmessungen width, height. Die Eckenrundung kann je nach Ecke variieren, mit den Werten radiusTopLeft, radiusTopRight, radiusBottomRight, radiusBottomLeft.

void QCanvasPainter::save()

Speichert den aktuellen Render-Zustand in einem Statusstapel. Zum Wiederherstellen des Zustands muss die entsprechende Funktion „ restore()“ aufgerufen werden.

Siehe auch ` restore()`.

void QCanvasPainter::scale(qreal scale)

Skaliert das aktuelle Koordinatensystem um den Faktor scale. Sowohl die x- als auch die y-Koordinaten werden gleichmäßig skaliert.

void QCanvasPainter::scale(qreal scaleX, qreal scaleY)

Skaliert das aktuelle Koordinatensystem um scaleX und scaleY.

void QCanvasPainter::setAntialias(qreal antialias)

Legt den aktuellen Antialiasing-Wert auf „ antialias “ in Pixeln fest. Ein höherer Antialiasing-Wert sorgt für eine glattere Darstellung. Dies wirkt sich nur auf das Zeichnen von Füllungen und Konturen aus, nicht auf Bilder oder Texte. Der Standardwert ist „ 1.0 “ und der Maximalwert ist „ 10.0 “.

Das Anti-Aliasing kann pro Pfad angepasst werden, sodass es vor jedem Strich bzw. jeder Füllung festgelegt werden kann. Um das Anti-Aliasing zu deaktivieren und den Rechenaufwand zu reduzieren, setzen Sie den Anti-Aliasing-Wert auf 0.

Siehe auch setTextAntialias().

void QCanvasPainter::setClipRect(qreal x, qreal y, qreal width, qreal height)

Setzt das aktuelle „Scissor“-Rechteck auf (x, y, width, height). Das „Scissor“-Rechteck wird durch die aktuelle Transformation transformiert.

Siehe auch resetClipping().

void QCanvasPainter::setClipRect(const QRectF &rect)

Setzt das aktuelle Scherenrechteck auf „ rect “. Das Scherenrechteck wird durch die aktuelle Transformation transformiert.

Siehe auch „ resetClipping()“.

[since 6.12] void QCanvasPainter::setFillRule(QCanvasPainter::FillRule fillRule)

Legt die Regel für die Pfadfüllung auf „ fillRule “ fest. Dieser Wert gilt für alle Aufrufe von „ fill()“, die nach dem Festlegen der Regel erfolgen. Die Standardregel für die Pfadfüllung lautet QCanvasPainter::FillRule::NonZero

Diese Funktion wurde in Qt 6.12 eingeführt.

void QCanvasPainter::setFillStyle(QColor color)

Legt den Füllstil auf ein durchgefärbtes „ color “ fest. Der Standard-Füllstil ist durchgefärbt schwarz (0, 0, 0, 1).

void QCanvasPainter::setFillStyle(const QCanvasBrush &brush)

Setzt den Füllstil auf „ brush “. Der Standard-Füllstil ist durchgehend schwarz (0, 0, 0, 1).

void QCanvasPainter::setFont(const QFont &font)

Legt „ font “ als aktuell aktive Schriftart fest.

void QCanvasPainter::setGlobalAlpha(qreal alpha)

Setzt den globalen Alpha-Wert (Transparenz) auf alpha. Dieser Alpha-Wert wird auf alle gerenderten Formen angewendet. Bereits transparente Pfade werden ebenfalls proportional transparenter. Der Alpha-Wert sollte zwischen 0,0 (vollständig transparent) und 1,0 (vollständig undurchsichtig) liegen. Standardmäßig beträgt der Alpha-Wert 1.0.

void QCanvasPainter::setGlobalBrightness(qreal value)

Legt die globale Helligkeit auf „ value “ fest. Diese Helligkeit wird auf alle gerenderten Formen angewendet. Bei einem Wert von 0 wird die Darstellung komplett schwarz. Der Wert kann auch größer als 1,0 sein, um die Helligkeit zu erhöhen. Standardmäßig beträgt die Helligkeit „ 1.0 “.

void QCanvasPainter::setGlobalCompositeOperation(QCanvasPainter::CompositeOperation operation)

Setzt den globalen Composite-Modus auf „ operation “. Dieser Modus wird auf alle Zeichenvorgänge angewendet. Der Standardmodus ist „ QCanvasPainter::CompositeOperation::SourceOver “.

void QCanvasPainter::setGlobalContrast(qreal value)

Setzt den globalen Kontrast auf „ value “. Dieser Kontrast wird auf alle gerenderten Formen angewendet. Bei einem Wert von 0 wird die Darstellung vollständig grau (0,5; 0,5; 0,5). Der Wert kann auch größer als 1,0 sein, um den Kontrast zu erhöhen. Standardmäßig beträgt der Kontrast „ 1.0 “.

void QCanvasPainter::setGlobalSaturation(qreal value)

Legt die globale Sättigung auf „ value “ fest. Diese Sättigung wird auf alle gerenderten Formen angewendet. Bei einem Wert von 0 wird die Sättigung deaktiviert, sodass die Darstellung vollständig in Graustufen erfolgt. Der Wert kann auch größer als 1,0 sein, um die Sättigung zu erhöhen. Standardmäßig beträgt die Sättigung „ 1.0 “.

void QCanvasPainter::setHighQualityStroking(bool enabled)

Legt die hochwertige Konturierung auf „ enabled “ fest. Die Einstellung „ true “ sorgt in einigen selteneren Fällen, in denen sich Konturen überlappen und keine volle Deckkraft aufweisen, für eine korrektere Darstellung. Die Aktivierung dieser Option führt zu einem höheren Rendering-Aufwand. Der Standardwert ist „ false “.

void QCanvasPainter::setLineCap(QCanvasPainter::LineCap cap)

Legt das Linienende für Striche auf „ cap “ fest. Die Standard-Linienendform ist „ QCanvasPainter::LineCap::Butt “.

void QCanvasPainter::setLineJoin(QCanvasPainter::LineJoin join)

Legt den Linienanschluss der Striche auf „ join “ fest. Der Standard-Linienanschluss ist „ QCanvasPainter::LineJoin::Miter “.

Siehe auch setMiterLimit().

void QCanvasPainter::setLineWidth(qreal width)

Legt die Linienbreite der Striche auf width in Pixeln fest. Die Standard-Linienbreite beträgt 1.0. Wenn die Kantenglättung aktiviert ist, wird bei Breiten, die dünner als ein einzelnes Pixel sind, die Deckkraft automatisch ausgeblendet, wodurch eine glatte Darstellung entsteht.

Siehe auch stroke().

void QCanvasPainter::setMiterLimit(qreal limit)

Legt den Gehrungsgrenzwert auf „ limit “ fest. Der Gehrungsgrenzwert bestimmt, wann eine scharfe Ecke abgeschrägt wird. Wenn die Ecklänge diesen Grenzwert überschreiten würde, wird stattdessen zwischen den Linien eine „ QCanvasPainter::LineJoin::Bevel “ angewendet. Dies wirkt sich nur bei der Linienverbindung „ QCanvasPainter::LineJoin::Miter “ aus. Der Standardgrenzwert ist „ 10.0 “.

Siehe auch „ setLineJoin()“.

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

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

Siehe auch beginHoleSubPath() und beginSolidSubPath().

void QCanvasPainter::setStrokeStyle(QColor color)

Legt den Strichstil auf „ color “ fest. Der Standard-Strichstil ist ein durchgezogener schwarzer Strich (0, 0, 0, 1).

void QCanvasPainter::setStrokeStyle(const QCanvasBrush &brush)

Setzt den Strichstil auf „ brush “. Der Standard-Strichstil ist durchgehend schwarz (0, 0, 0, 1).

void QCanvasPainter::setTextAlign(QCanvasPainter::TextAlign align)

Legt die horizontale Ausrichtung des Textes auf „ align “ fest. Die Standardausrichtung ist „ QCanvasPainter::TextAlign::Start “.

Siehe auch setTextBaseline().

void QCanvasPainter::setTextAntialias(qreal antialias)

Legt den aktuellen Grad der Textglättung fest. Der Wert „ antialias “ ist ein Multiplikator für die normale Textglättung, d. h., „ 0.0 “ deaktiviert die Textglättung und „2,0“ verdoppelt sie. Der Standardwert ist 1,0.

void QCanvasPainter::setTextBaseline(QCanvasPainter::TextBaseline baseline)

Legt die vertikale Ausrichtung (Grundlinie) des Textes auf „ baseline “ fest. Die Standardausrichtung ist „ QCanvasPainter::TextBaseline::Alphabetic “.

Siehe auch ` setTextAlign()`.

void QCanvasPainter::setTextDirection(QCanvasPainter::TextDirection direction)

Legt die Textrichtung auf „ direction “ fest. Die Standardrichtung ist „ QCanvasPainter::TextDirection::Inherit “.

void QCanvasPainter::setTextLineHeight(qreal height)

Legt die Zeilenhöhe für umgebrochenen Text in Pixeln auf „ height “ fest. Die Standard-Zeilenhöhe beträgt „ 0 “.

void QCanvasPainter::setTextWrapMode(QCanvasPainter::WrapMode wrapMode)

Stellt den Textumbruchmodus auf „ wrapMode “ ein. Der Standard-Umbruchmodus ist „ QCanvasPainter::WrapMode::NoWrap “.

void QCanvasPainter::setTransform(const QTransform &transform)

Setzt die aktuelle Transformation zurück und verwendet stattdessen „ transform “.

Siehe auch transform().

void QCanvasPainter::setWindingEnforce(bool enabled)

Legt die Windungsrichtung auf „ enabled “ fest. Durch die Einstellung „ false “ wird die Erzwingung der Pfadwindung deaktiviert, sodass die Einstellung in „ setPathWinding()“ übernommen wird. Durch die Deaktivierung können beispielsweise Löcher in Pfade erstellt werden, indem die Punkte im Uhrzeigersinn hinzugefügt werden. Die Deaktivierung kann zudem die Leistung steigern. Der Standardwert ist „ true “.

void QCanvasPainter::skew(qreal angleX, qreal angleY = 0.0)

Verschiebt (verzerrt) das aktuelle Koordinatensystem entlang der X-Achse um angleX und entlang der Y-Achse um angleY. Die Winkel werden in Radianten angegeben.

void QCanvasPainter::stroke()

Zeichnet den aktuellen Pfad mit dem aktuellen Strichstil nach.

Siehe auch „ setStrokeStyle()“.

void QCanvasPainter::stroke(const QCanvasPath &path, int pathGroup = -1)

Zeichnet den Pfad „ path “ mit dem aktuellen Strichstil und ordnet ihn „ pathGroup “ zu. Das Zeichnen über „ QCanvasPath “ ist optimal, wenn der Pfad mehr Befehle enthält und weitgehend statisch ist.

Wenn „ pathGroup “ auf „ -1 “ gesetzt ist, werden die rendernbezogenen Daten des Pfades nicht zwischengespeichert. Dies ist die Standardeinstellung. Um die Zwischenspeicherung von Pfaddaten zu erzwingen, übergeben Sie einen Wert, der gleich oder größer als „ 0 “ ist. Weitere Informationen zur Verwendung von Pfad-Cache-Gruppen finden Sie in der Dokumentation unter „ QCanvasPath “.

Der Aufruf von ` beginPath()` vor dieser Methode ist nicht erforderlich.

Siehe auch „ setStrokeStyle()“ und „ removePathGroup()“.

void QCanvasPainter::strokeRect(qreal x, qreal y, qreal width, qreal height)

Zeichnet ein umrandetes Rechteck an der angegebenen Position ( x, y) mit der Größe width, height.

void QCanvasPainter::strokeRect(const QRectF &rect)

Zeichnet ein umrandetes Rechteck in „ rect “. Hierbei handelt es sich um eine überladene Methode, die „ QRectF “ verwendet.

QRectF QCanvasPainter::textBoundingBox(const QString &text, qreal x, qreal y, qreal maxWidth = 0) const

Misst die Begrenzungsbox einer Zeichenkette vom Typ „ text “ an den Koordinaten (x, y).

Um mehrzeiligen Text zu messen, setzen Sie den Zeilenumbruchmodus mit ` setTextWrapMode()` auf einen anderen Wert als den Standardwert ` NoWrap`. Setzen Sie außerdem den optionalen Parameter ` maxWidth ` auf die gewünschte Zeilenbreite in Pixeln.

Gibt ` QRectF ` mit den Werten [xmin, ymin, width, height] zurück. Die gemessenen Werte werden im lokalen Koordinatensystem zurückgegeben.

QRectF QCanvasPainter::textBoundingBox(const QString &text, const QRectF &rect) const

Misst den Begrenzungsrahmen einer Zeichenkette vom Typ „ text “ unter rect. Gibt „ QRectF “ mit den Werten [xmin, ymin, width, height] zurück. Die gemessenen Werte werden im lokalen Koordinatensystem zurückgegeben.

QRectF QCanvasPainter::textBoundingBox(const QString &text, QPointF point, qreal maxWidth = 0) const

Misst die Begrenzungsbox einer „ text “-Zeichenkette unter point.

Um mehrzeiligen Text zu messen, legen Sie den Zeilenumbruchmodus mit ` setTextWrapMode()` auf einen anderen Wert als den Standardwert ` NoWrap` fest. Setzen Sie außerdem den optionalen Parameter ` maxWidth ` auf die gewünschte Zeilenbreite in Pixeln.

Gibt ` QRectF ` mit den Werten [xmin, ymin, width, height] zurück. Die gemessenen Werte werden im lokalen Koordinatensystem zurückgegeben.

void QCanvasPainter::transform(const QTransform &transform)

Multipliziert das aktuelle Koordinatensystem mit dem angegebenen Skalierungsfaktor ` transform`.

Siehe auch ` setTransform()`.

void QCanvasPainter::translate(qreal x, qreal y)

Verschiebt das aktuelle Koordinatensystem um x und y.

void QCanvasPainter::translate(QPointF point)

Verschiebt das aktuelle Koordinatensystem um point.