QCanvasPainter Class

QRectF rect(40, 70, 120, 60);
QRectF shadowRect = rect.translated(2, 4);
// Paint shadow
QCanvasBoxShadow shadow(shadowRect, 30, 15, "#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, "#404040", "#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->setRenderHint(QCanvasPainter::RenderHint::DisableWindingEnforce);
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()

Konstruiert einen Maler.

[noexcept] QCanvasPainter::~QCanvasPainter()

Zerstört 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 extern verwalteten 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 Speichers zurück, der von den Bild-(Pixel-)Daten für alle aktiven QCanvasImage -Instanzen für diesen Painter verwendet wird, die durch die addImage()-Überladung unter Verwendung eines QImage erstellt wurden. Sie umfasst auch die Daten von intern erstellten Bildern für gradients.

QCanvasPainter behält keine Kopien der CPU-seitigen QImage Daten, sobald addImage() zurückgekehrt ist. Daher ist das Ergebnis dieser Funktion ein Näherungswert für den GPU-Speicher, der für Texturen verwendet wird.

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

Für jede gültige QCanvasImage kann die individuelle Größe in Bytes immer 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 aber 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 als Textur für den Maler hinzu. Gibt QCanvasImage mit der Textur-ID und anderen Informationen über das Bild zurück. Die zurückgegebene QCanvasImage kann dann mit drawImage und QCanvasImagePattern verwendet werden. Nach dem Aufruf dieser Methode muss image QImage nicht im Speicher gehalten werden.

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

Bei der Optimierung muss darauf geachtet werden, addImage() nur einmal aufzurufen. Je nach Anwendungsdesign ist dies nicht immer ausreichend. Wenn zum Beispiel die zugrundeliegenden Grafikressourcen verloren gehen, z.B. weil der Painter mit einem neuen QRhi unter der Haube verbunden ist, weil ein Widget auf eine neue Top-Ebene verschoben wurde, dann ist der Aufruf dieser Funktion unerlässlich, um die nativen Grafiktexturen von image neu zu erstellen.

Siehe auch drawImage() und removeImage().

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

Fügt texture mit flags als Textur für den Maler hinzu. Das Flag NativeTexture wird implizit gesetzt. Die 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, so dass 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 in den aktuellen Pfad ein.

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

Fügt path in den aktuellen Pfad ein und verwendet optional transform, um die Pfadpunkte zu ändern. Wenn transform nicht angegeben ist (oder es sich um eine Identitätsmatrix handelt), ist dieser Vorgang sehr schnell, da er die Pfaddaten wiederverwendet.

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

Fügt path in den aktuellen Pfad ein, beginnend mit dem Befehl unter start und einschließlich der Anzahl der Befehle unter count. Optional kann transform verwendet werden, um die Pfadpunkte zu ändern. Der Bereich von start und count wird überprüft, so dass nicht mehr Befehle als QCanvasPath::commandsSize() aufgerufen werden. Falls der Pfad nicht von der aktuellen Pfadposition aus fortgesetzt werden soll, rufen Sie zuerst moveTo() auf, z. B. mit path.positionAt(start - 1).

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

Erzeugt einen neuen kreisbogenförmigen Unterpfad. 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) gekehrt. Wenn connection gleich NotConnected ist, fügt arc keine Linie von der vorherigen Pfadposition zum Beginn des Bogens hinzu. Winkel werden in Radiant angegeben.

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

Erzeugt einen neuen kreisbogenförmigen Unterpfad. Der Mittelpunkt des Bogens liegt bei centerPoint, mit radius, und der Bogen wird vom Winkel a0 bis a1 gezeichnet und in direction (ClockWise oder CounterClockWise) gekehrt. Wenn connection gleich NotConnected ist, fügt arc keine Linie von der vorherigen Pfadposition zum Beginn des Bogens hinzu. Winkel werden in Radiant angegeben.

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

Fügt ein Bogensegment an der durch den letzten Pfadpunkt definierten Ecke und zwei angegebenen Punkten (x1, y1 und x2, y2) mit radius hinzu. Der Bogen wird automatisch mit dem letzten Punkt des Pfades durch eine gerade Linie verbunden, falls erforderlich.

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

Fügt ein Bogensegment an der durch den letzten Pfadpunkt definierten Ecke und zwei angegebenen Punkten (controlPoint1 und controlPoint2) mit radius hinzu. Der Bogen wird automatisch mit dem letzten Punkt des Pfades durch eine gerade Linie verbunden, falls erforderlich.

void QCanvasPainter::beginHoleSubPath()

Starten Sie einen Loch-Unterpfad. Dies ist gleichbedeutend mit setPathWinding(QCanvasPainter::PathWinding::ClockWise))

Siehe auch beginSolidSubPath().

void QCanvasPainter::beginPath()

Beginnt mit dem Zeichnen eines neuen Pfades, während der aktuelle Pfad gelöscht wird.

void QCanvasPainter::beginSolidSubPath()

Starten Sie einen festen Unterpfad. Dies ist äquivalent zu setPathWinding(QCanvasPainter::PathWinding::CounterClockWise))

Siehe auch beginHoleSubPath().

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

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

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

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

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

Erzeugt einen neuen kreisförmigen Unterpfad in ( centerX, centerY) mit radius.

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

Erzeugt einen neuen kreisförmigen Unterpfad in centerPoint mit radius.

void QCanvasPainter::cleanupResources()

Plant das Löschen von unbenutzten Texturen aus dem Cache.

Zusätzlich können andere Caches und Pools beim Aufruf dieser Funktion verkleinert werden, um den Speicherverbrauch zu minimieren. Dies kann möglicherweise zu teureren Zeichenaufrufen im Nachhinein führen.

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

Löscht die Pixel in einem rechteckigen Bereich, indem das durch x, y, width, 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. Dies ist eine überladene Methode mit QRectF.

void QCanvasPainter::closePath()

Schließt den aktuellen Unterpfad mit einem Liniensegment ab. Dies ist äquivalent zu lineTo([Startpunkt]) als letztes Pfadelement.

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

Gibt eine neue Offscreen-Leinwand mit den angegebenen pixelSize, sampleCount und flags zurück.

Die Größe der Leinwand wird in Pixeln angegeben. Die Eigenschaften pixelSize, sampleCount und flags sind danach unveränderlich. Um eine Leinwand mit einer anderen Größe, Anzahl der Samples oder Flaggen zu erhalten, erstellen Sie eine neue Leinwand.

Um einen Offscreen-Canvas mit Zeichenbefehlen anzusteuern, rufen Sie die entsprechende Überladung QCanvasRhiPaintDriver::beginPaint() auf, wenn Sie mit der API auf niedrigerer Ebene arbeiten, oder QCanvasPainterWidget::beginCanvasPainting() oder QCanvasPainterItemRenderer::beginCanvasPainting(), wenn Sie die Convenience-Widget- oder Qt Quick Item-Klassen verwenden.

Normalerweise wird der Inhalt des Canvas geleert, wenn darauf gemalt wird. Um dies zu deaktivieren, übergeben Sie PreserveContents in flags.

Um Multisample-Rendering auf dem Canvas anzufordern (Multisample-Antialiasing, MSAA), setzen Sie eine Sampleanzahl größer als 1, z. B. 4 oder 8. Die Beibehaltung des Canvas-Inhalts zwischen den Rendering-Durchgängen 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 canvas unterstützen. canvas wird dann zu null canvas.

Der Painter tut dies automatisch bei seiner Zerstörung. Daher ist der Aufruf dieser Funktion nur notwendig, wenn die Freigabe der zugehörigen Ressourcen sofort gewünscht ist.

float QCanvasPainter::devicePixelRatio() const

Gibt das Verhältnis zwischen physischen Pixeln und geräteunabhängigen Pixeln zurück. Der Standardwert ist 1.0.

void QCanvasPainter::drawBoxShadow(const QCanvasBoxShadow &shadow)

Zeichnet einen Rahmen shadow. Der Schatten wird mit der Position, Größe, Farbe, Unschärfe usw. gezeichnet, die in shadow festgelegt sind. Der Aufruf von beginPath() vor dieser Methode ist nicht erforderlich.

Siehe auch QCanvasBoxShadow.

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

Zeichnet image in x, y, in seiner Standardgröße.

Siehe auch addImage().

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

Zeichnet image in Position und Größe von destinationRect.

Siehe auch addImage().

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

Zeichnet image in Position und Größe von destinationRect, aus dem Bereich sourceRect des Bildes.

Siehe auch addImage().

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

Zeichnet image in x, y, bei gegebenem width und height.

Siehe auch addImage().

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

Erzeugt einen neuen ellipsenförmigen Unterpfad in ( centerX, centerY) mit radiusX und radiusY.

void QCanvasPainter::ellipse(const QRectF &rect)

Erzeugt einen neuen ellipsenförmigen Unterpfad in rect. Diese Ellipse wird den Bereich rect abdecken.

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

Erzeugt einen neuen ellipsenförmigen Unterpfad in centerPoint mit radiusX und radiusY.

void QCanvasPainter::fill()

Füllt den aktuellen Pfad mit dem aktuellen Füllstil.

Siehe auch setFillStyle().

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

Füllt die path mit dem aktuellen Füllstil und gehört in pathGroup. Das Malen durch QCanvasPath ist optimal, wenn der Pfad mehr Befehle enthält und überwiegend statisch ist. Standardmäßig ist pathGroup gleich 0, so dass die erste Gruppe verwendet wird. Wenn pathGroup zu -1 gehört, wird der Pfad nicht auf der GPU-Seite zwischengespeichert. Weitere Informationen zur Verwendung von Pfad-Cache-Gruppen finden Sie in der Dokumentation QCanvasPath. Der Aufruf von beginPath() vor dieser Methode ist nicht erforderlich.

Siehe auch setFillStyle().

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

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

void QCanvasPainter::fillRect(const QRectF &rect)

Zeichnet ein gefülltes Rechteck in rect. Dies ist eine überladene Methode, die QRectF verwendet.

void QCanvasPainter::fillText(const QString &text, float x, float y, float maxWidth = -1)

Zeichnet die Zeichenkette text an der angegebenen Position ( x, y), mit der aktuellen textAlign und textBaseline. Um den Text in mehrere Zeilen umbrechen zu lassen, setzen Sie den optionalen Parameter maxWidth auf die gewünschte Zeilenbreite in Pixel. Am Anfang der Zeilen werden Leerzeichen entfernt, der Text wird an Wortgrenzen oder beim Auftreten von Zeilenumbrüchen geteilt. Wörter, die länger als die maximale Breite sind, werden am nächsten Zeichen getrennt (d. h. keine Silbentrennung).

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

Zeichnet die Zeichenkette text innerhalb von rect, mit der aktuellen textAlign und textBaseline. Die Breite des Rect-Parameters wird als maxWidth verwendet.

Dies ist eine überladene Methode, die QRectF verwendet. Es ist oft nützlich, die Textgrundlinie auf TextBaseline::Top oder TextBaseline::Middle zu setzen, wenn Text mit dieser Methode gezeichnet wird.

void QCanvasPainter::fillText(const QString &text, QPointF point, float maxWidth = -1)

Zeichnet die Zeichenkette text an der angegebenen Position point, mit der aktuellen textAlign und textBaseline. Um den Text in mehrere Zeilen umbrechen zu lassen, setzen Sie den optionalen Parameter maxWidth auf die gewünschte Zeilenbreite in Pixel. Leerzeichen werden am Anfang der Zeilen entfernt, der Text wird an Wortgrenzen oder beim Auftreten von Zeilenumbrüchen geteilt. Wörter, die länger als die maximale Breite sind, werden am nächsten Zeichen getrennt (d. h. keine Silbentrennung).

Dies ist eine überladene Methode, die QPointF verwendet.

QTransform QCanvasPainter::getTransform() const

Gibt die aktuelle Transformation zurück.

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

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

void QCanvasPainter::lineTo(QPointF point)

Fügt ein Liniensegment vom letzten Punkt des Pfades zum point hinzu.

[static] float QCanvasPainter::mmToPx(float mm)

Statische Hilfsmethode zur Umwandlung von Millimetern mm in Pixel. Dies ermöglicht auflösungsunabhängiges Zeichnen. Zum Beispiel um die Linienbreite auf 2mm zu setzen:

painter->setLineWidth(QCanvasPainter::mmToPx(2));

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

Beginnt einen neuen Unterpfad mit ( x, y) als erstem Punkt.

void QCanvasPainter::moveTo(QPointF point)

Beginnt einen neuen Unterpfad mit point als erstem Punkt.

[static] float QCanvasPainter::ptToPx(float pt)

Statische Hilfsmethode zur Umwandlung von Punkten pt in Pixel.

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

Fügt ein quadratisches Bezier-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 eine controlPoint zum angegebenen endPoint hinzu.

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

Erzeugt einen neuen rechteckigen Unterpfad an der Position x, y mit der Größe width, height.

void QCanvasPainter::rect(const QRectF &rect)

Erzeugt einen neuen rechteckigen Unterpfad auf rect. Dies ist eine überladene Methode mit QRectF.

void QCanvasPainter::removeImage(const QCanvasImage &image)

Gibt die mit image verbundenen Ressourcen frei und entfernt das Bild aus dem Painter.

Siehe auch addImage().

void QCanvasPainter::removePathGroup(int pathGroup)

Entfernt pathGroup aus dem Maler-Cache. Wenn Sie danach fill() oder stroke() für pathGroup aufrufen, wird der Pfad wieder in den Gruppen-Cache aufgenommen.

Siehe auch fill() und stroke().

QCanvasPainter::RenderHints QCanvasPainter::renderHints() const

Gibt ein Flag zurück, das die Rendering-Hinweise angibt, die für diesen Painter gesetzt sind.

Siehe auch setRenderHints() und setRenderHint().

void QCanvasPainter::reset()

Setzt den aktuellen Malerstatus auf die Standardwerte zurück.

Siehe auch save() und restore().

void QCanvasPainter::resetClipping()

Setzt das Clipping zurück und deaktiviert es.

Siehe auch setClipRect().

void QCanvasPainter::resetTransform()

Setzt die aktuelle Transformation auf eine Identitätsmatrix zurück.

void QCanvasPainter::restore()

Löscht und stellt den aktuellen Renderstatus wieder her. Der zuvor gespeicherte Zustand wird also wiederhergestellt. Wenn save() nicht aufgerufen wurde und der Zustandsstapel leer ist, bewirkt der Aufruf dieser Funktion nichts.

Siehe auch save().

void QCanvasPainter::rotate(float angle)

Dreht das aktuelle Koordinatensystem im Uhrzeigersinn um angle.

Der Winkel wird in Bogenmaß angegeben. Verwenden Sie qDegreesToRadians(), um von Grad in Bogenmaß umzurechnen.

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

Erzeugt einen neuen abgerundeten rechteckigen Unterpfad an der Position x, y mit der Größe width, height. Die Abrundung der Ecken wird radius sein.

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

Erzeugt einen neuen abgerundeten, rechteckigen Unterpfad auf rect mit radius Ecken. Dies ist eine überladene Methode mit QRectF.

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

Erzeugt einen neuen abgerundeten rechteckigen Unterpfad bei rect. Die Abrundung der Ecken kann pro Ecke variiert werden, mit radiusTopLeft, radiusTopRight, radiusBottomRight, radiusBottomLeft.

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

Erzeugt einen neuen abgerundeten rechteckigen Unterpfad an der Position x, y mit der Größe width, height. Die Abrundung der Ecken kann pro Ecke variiert werden, mit radiusTopLeft, radiusTopRight, radiusBottomRight, radiusBottomLeft.

void QCanvasPainter::save()

Verschiebt und speichert den aktuellen Renderzustand in einen Zustandsstapel. Um den Zustand wiederherzustellen, muss eine passende restore() verwendet werden.

Siehe auch restore().

void QCanvasPainter::scale(float scale)

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

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

Skaliert das aktuelle Koordinatensystem mit scaleX und scaleY.

void QCanvasPainter::setAntialias(float antialias)

Setzen Sie den aktuellen Antialiasing-Wert auf antialias in Pixel. Mehr Antialias bedeutet glatteres Malen. Dies wirkt sich nur auf Füll- und Strichzeichnungen aus, nicht auf Bilder oder Texte. Der Standardwert ist 1.0 und der Höchstwert ist 10.0.

Das Antialiasing kann pfadweise geändert werden, so dass es vor jedem Strich/Füllung eingestellt werden kann. Um Antialiasing für den gesamten Canvas-Painter zu deaktivieren, verwenden Sie QCanvasPainter::RenderHint::Antialiasing render hint.

Siehe auch setRenderHints() und setTextAntialias().

void QCanvasPainter::setBrushTransform(const QTransform &transform)

Setzt die aktuelle Pinseltransformation auf transform. Diese Transformation wird sowohl auf Strich- als auch auf Füllpinsel angewendet.

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

Setzt das aktuelle Scherenrechteck auf (x, y, width, height). Das Scherenrechteck wird mit der aktuellen 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().

void QCanvasPainter::setFillStyle(const QColor &color)

Setzt den Füllstil auf ein einfarbiges color. Der Standardfüllstil ist einfarbig schwarz (0, 0, 0, 1).

void QCanvasPainter::setFillStyle(const QCanvasBrush &brush)

Setzt den Füllstil auf brush. Der Standardfüllstil ist einfarbig schwarz (0, 0, 0, 1).

void QCanvasPainter::setFont(const QFont &font)

Legt die font als derzeit aktive Schriftart fest.

void QCanvasPainter::setGlobalAlpha(float 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. Alpha sollte zwischen 0.0 (vollständig transparent) und 1.0 (vollständig undurchsichtig) liegen. Standardmäßig ist Alpha auf 1.0 eingestellt.

void QCanvasPainter::setGlobalBrightness(float value)

Setzt die globale Helligkeit auf value. Diese Helligkeit wird auf alle gerenderten Formen angewendet. Ein Wert von 0 bewirkt, dass das Bild komplett schwarz ist. Der Wert kann auch größer als 1.0 sein, um die Helligkeit zu erhöhen. Standardmäßig ist die Helligkeit 1.0.

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

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

void QCanvasPainter::setGlobalContrast(float value)

Setzt den globalen Kontrast auf value. Dieser Kontrast wird auf alle gerenderten Formen angewendet. Ein Wert von 0 bewirkt, dass das Bild vollständig grau ist (0,5, 0,5, 0,5). Der Wert kann auch größer als 1.0 sein, um den Kontrast zu erhöhen. Der Standardwert für den Kontrast ist 1.0.

void QCanvasPainter::setGlobalSaturate(float value)

Setzt die globale Sättigung auf value. Diese Sättigung wird auf alle gerenderten Formen angewendet. Ein Wert von 0 deaktiviert die Sättigung und bewirkt, dass das Bild vollständig in Graustufen dargestellt wird. Der Wert kann auch größer als 1.0 sein, um die Sättigung zu erhöhen. Die Standardeinstellung für die Sättigung ist 1.0.

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

Setzt das Zeilenende von stoke auf cap. Die Standardzeilenkappe ist QCanvasPainter::LineCap::Butt.

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

Setzt die Linienverbindung von stroke auf join. Die Standardlinienverbindung ist QCanvasPainter::LineJoin::Miter.

Siehe auch setMiterLimit().

void QCanvasPainter::setLineWidth(float width)

Legt die Linienbreite der Kontur auf width in Pixeln fest. Die Standard-Linienbreite ist 1.0. Wenn das Antialiasing aktiviert ist, wird bei Linienbreiten unter einem Pixel automatisch die Deckkraft abgeblendet, wodurch eine glatte Ausgabe entsteht.

Siehe auch stroke().

void QCanvasPainter::setMiterLimit(float limit)

Setzt die Gehrungsgrenze auf limit. Die Gehrungsgrenze bestimmt, wann eine scharfe Ecke abgeschrägt wird. Wenn die Eckenlänge diesen Grenzwert überschreiten würde, wird stattdessen QCanvasPainter::LineJoin::Bevel zwischen den Linien angewendet. Dies hat nur Auswirkungen auf die Linienverbindung QCanvasPainter::LineJoin::Miter. Der Standardgrenzwert ist 10.0.

Siehe auch setLineJoin().

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

Setzt den aktuellen Unterpfad winding entweder auf CounterClockWise (Standard) oder ClockWise. CounterClockWise zeichnet solide Unterpfade, während ClockWise Löcher zeichnet.

Siehe auch beginHoleSubPath() und beginSolidSubPath().

void QCanvasPainter::setRenderHint(QCanvasPainter::RenderHint hint, bool on = true)

Setzt den angegebenen Render hint auf den Painter, wenn on wahr ist; andernfalls wird der Render-Hinweis gelöscht.

Siehe auch setRenderHints() und renderHints().

void QCanvasPainter::setRenderHints(QCanvasPainter::RenderHints hints, bool on = true)

Setzt den angegebenen Render hints auf den Painter, wenn on wahr ist; andernfalls werden die Render-Hinweise gelöscht.

Siehe auch setRenderHint() und renderHints().

void QCanvasPainter::setStrokeStyle(const QColor &color)

Setzt den Konturenstil auf einen einfarbigen color. Der Standardkonturenstil ist einfarbig schwarz (0, 0, 0, 1).

void QCanvasPainter::setStrokeStyle(const QCanvasBrush &brush)

Setzt den Strichstil auf brush. Der Standardstrichstil ist einfarbig schwarz (0, 0, 0, 1).

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

Setzt die horizontale Ausrichtung von Text auf align. Die Standardausrichtung ist QCanvasPainter::TextAlign::Start.

Siehe auch setTextBaseline().

void QCanvasPainter::setTextAntialias(float antialias)

Legt den aktuellen Antialiasing-Wert für Text fest. Der Wert antialias ist ein Multiplikator für das normale Antialiasing, d. h. 0.0 deaktiviert das Antialiasing und 2.0 verdoppelt es. Der Standardwert ist 1.0.

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

Setzt die vertikale Ausrichtung (Grundlinie) von Text auf baseline. Die Standardausrichtung ist QCanvasPainter::TextBaseline::Alphabetic.

Siehe auch setTextAlign().

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

Legt die Richtung des Textes auf direction fest. Die Standardrichtung ist QCanvasPainter::TextDirection::Inherit.

void QCanvasPainter::setTextLineHeight(float height)

Legt die Anpassung der Zeilenhöhe in Pixeln für umgebrochenen Text auf height fest. Die Standardzeilenhöhe ist 0.

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

Setzt den Textumbruchmodus auf wrapMode. Der Standardumbruchmodus 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::skew(float angleX, float angleY = 0.0f)

Verzerrt (schert) das aktuelle Koordinatensystem entlang der X-Achse um angleX und entlang der Y-Achse um angleY. Die Winkel werden in Radiant angegeben.

void QCanvasPainter::stroke()

Zeichnet den aktuellen Pfad mit dem aktuellen Zeichenstil.

Siehe auch setStrokeStyle().

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

Zeichnet die path mit dem aktuellen Zeichenstil und gehört in pathGroup. Das Malen durch QCanvasPath ist optimal, wenn der Pfad mehr Befehle enthält und überwiegend statisch ist. Standardmäßig ist pathGroup gleich 0, so dass die erste Gruppe verwendet wird. Wenn pathGroup -1 ist, wird der Pfad nicht auf der GPU-Seite zwischengespeichert. Weitere Informationen zur Verwendung von Pfad-Cache-Gruppen finden Sie in der Dokumentation QCanvasPath. Der Aufruf von beginPath() vor dieser Methode ist nicht erforderlich.

Siehe auch setStrokeStyle().

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

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

void QCanvasPainter::strokeRect(const QRectF &rect)

Zeichnet ein gestochenes Rechteck in rect. Dies ist eine überladene Methode, die QRectF verwendet.

QRectF QCanvasPainter::textBoundingBox(const QString &text, float x, float y, float maxWidth = -1)

Misst den Begrenzungsrahmen einer Zeichenkette text bei (x, y). Um mehrzeiligen Text zu messen, setzen Sie den optionalen Parameter maxWidth auf die bevorzugte Zeilenbreite in Pixel. Gibt QRectF mit den Werten [xmin, ymin, Breite, Höhe] zurück. Die gemessenen Werte werden im lokalen Koordinatenraum zurückgegeben.

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

Misst die Bounding Box eines text Strings auf rect. Gibt QRectF mit den Werten [xmin, ymin, Breite, Höhe] zurück. Die gemessenen Werte werden im lokalen Koordinatenraum zurückgegeben.

QRectF QCanvasPainter::textBoundingBox(const QString &text, QPointF point, float maxWidth = -1)

Misst den Begrenzungsrahmen einer Zeichenkette text unter point. Um mehrzeiligen Text zu messen, setzen Sie den optionalen Parameter maxWidth auf die bevorzugte Zeilenbreite in Pixeln. Gibt QRectF mit den Werten [xmin, ymin, Breite, Höhe] zurück. Die gemessenen Werte werden im lokalen Koordinatenraum zurückgegeben.

void QCanvasPainter::transform(const QTransform &transform)

Multipliziert das aktuelle Koordinatensystem mit dem angegebenen transform.

Siehe auch setTransform().

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

Verschiebt das aktuelle Koordinatensystem um x und y.

void QCanvasPainter::translate(QPointF point)

Verschiebt das aktuelle Koordinatensystem um point.