QPainter Class

Dokumentation zu den Mitgliedsfunktionen

QPainter::QPainter()

Erstellt einen „Painter“.

Siehe auch begin() und end().

[explicit] QPainter::QPainter(QPaintDevice *device)

Erstellt einen Painter, der sofort mit dem Zeichnen des Paint- device s beginnt.

Dieser Konstruktor eignet sich für kurzlebige Painter, z. B. in einer ` QWidget::paintEvent()`-Funktion, und sollte nur einmal verwendet werden. Der Konstruktor ruft für Sie ` begin()` auf, und der Destruktor von `QPainter` ruft automatisch ` end()` auf.

Hier ist ein Beispiel mit ` begin()` und ` end()`:

void MyWidget::paintEvent(QPaintEvent *)
{
    QPainter p;
    p.begin(this);
    p.drawLine(drawingCode);        // drawing code
    p.end();
}

Das gleiche Beispiel unter Verwendung dieses Konstruktors:

void MyWidget::paintEvent(QPaintEvent *)
{
    QPainter p(this);
    p.drawLine(drawingCode);        // drawing code
}

Da der Konstruktor keine Rückmeldung geben kann, wenn die Initialisierung des Painters fehlgeschlagen ist, sollten Sie lieber begin() und end() verwenden, um auf externen Geräten, z. B. Druckern, zu zeichnen.

Siehe auch begin() und end().

[noexcept] QPainter::~QPainter()

Vernichtet den Maler.

const QBrush &QPainter::background() const

Gibt den aktuellen Hintergrundpinsel zurück.

Siehe auch setBackground() und Settings.

Qt::BGMode QPainter::backgroundMode() const

Gibt den aktuellen Hintergrundmodus zurück.

Siehe auch setBackgroundMode() und Settings.

bool QPainter::begin(QPaintDevice *device)

Beginnt mit dem Zeichnen des Farb device s und gibt bei Erfolg true zurück; andernfalls wird false zurückgegeben.

Beachten Sie, dass alle Einstellungen des Painters (setPen(), setBrush() usw.) beim Aufruf von begin() auf die Standardwerte zurückgesetzt werden.

Die Fehler, die auftreten können, sind schwerwiegende Probleme, wie zum Beispiel diese:

painter->begin(nullptr); // impossible - paint device cannot be null

QPixmap image(0, 0);
painter->begin(&image); // impossible - image.isNull() == true;

painter->begin(myWidget);
painter2->begin(myWidget); // impossible - only one painter at a time

Beachten Sie, dass Sie in den meisten Fällen einen der Konstruktoren anstelle von `begin()` verwenden können und dass ` end()` bei der Zerstörung automatisch ausgeführt wird.

Siehe auch ` end()` und ` QPainter()`.

void QPainter::beginNativePainting()

Leert die Zeichenpipeline und bereitet die Umgebung darauf vor, dass der Benutzer Befehle direkt an den zugrunde liegenden Grafikkontext sendet. Muss von einem Aufruf von ` endNativePainting()` gefolgt werden.

Beachten Sie, dass nur die Zustände, die von der zugrunde liegenden Zeichen-Engine geändert werden, auf ihre jeweiligen Standardzustände zurückgesetzt werden. Welche Zustände zurückgesetzt werden, kann sich von Version zu Version ändern. In der OpenGL-2-Engine werden derzeit die folgenden Zustände zurückgesetzt:

• Das Blending ist deaktiviert
• Die Tiefen-, Stencil- und Scherenprüfungen sind deaktiviert
• die aktive Textur-Einheit wird auf 0 zurückgesetzt
• Die Tiefenmaske, die Tiefenfunktion und die Clear-Tiefe werden auf ihre Standardwerte zurückgesetzt
• Die Stencil-Maske, die Stencil-Operation und die Stencil-Funktion werden auf ihre Standardwerte zurückgesetzt
• Die aktuelle Farbe wird auf reines Weiß zurückgesetzt

Wenn beispielsweise der OpenGL-Polygonmodus vom Benutzer innerhalb eines „beginNativePaint()“- bzw. „endNativePainting()“-Blocks geändert wird, wird er durch „ endNativePainting()“ nicht auf den Standardzustand zurückgesetzt. Hier ist ein Beispiel, das die Vermischung von Painter-Befehlen und reinen OpenGL-Befehlen veranschaulicht:

QPainter painter(this);
painter.fillRect(0, 0, 128, 128, Qt::green);
painter.beginNativePainting();

glEnable(GL_SCISSOR_TEST);
glScissor(0, 0, 64, 64);

glClearColor(1, 0, 0, 1);
glClear(GL_COLOR_BUFFER_BIT);

glDisable(GL_SCISSOR_TEST);

painter.endNativePainting();

Siehe auch ` endNativePainting()`.

QRectF QPainter::boundingRect(const QRectF &rectangle, int flags, const QString &text)

Gibt das Begrenzungsrechteck des „ text “ zurück, wie es erscheinen wird, wenn es innerhalb des angegebenen „ rectangle “ mit dem angegebenen „ flags “ unter Verwendung des aktuell festgelegten „ font()“ gezeichnet wird; d. h., die Funktion gibt an, wo die Funktion „ drawText()“ bei Verwendung derselben Argumente zeichnen wird.

Wenn das „ text “ nicht in das angegebene „ rectangle “ unter Verwendung des angegebenen „ flags “ passt, gibt die Funktion das erforderliche Rechteck zurück.

Das Argument „ flags “ ist ein bitweises ODER der folgenden Flags:

• Qt::AlignLeft
• Qt::AlignRight
• Qt::AlignHCenter
• Qt::AlignTop
• Qt::AlignBottom
• Qt::AlignVCenter
• Qt::AlignCenter
• Qt::TextSingleLine
• Qt::TextExpandTabs
• Qt::TextShowMnemonic
• Qt::TextWordWrap
• Qt::TextIncludeTrailingSpaces

Sind mehrere der Flags für die horizontale oder mehrere der Flags für die vertikale Ausrichtung gesetzt, ist die resultierende Ausrichtung undefiniert.

Siehe auch drawText(), Qt::Alignment und Qt::TextFlag.

QRect QPainter::boundingRect(const QRect &rectangle, int flags, const QString &text)

Gibt das Begrenzungsrechteck des „ text “ zurück, wie es erscheinen wird, wenn es innerhalb des angegebenen „ rectangle “ mit dem angegebenen „ flags “ unter Verwendung des aktuell festgelegten „ font()“ gezeichnet wird.

QRectF QPainter::boundingRect(const QRectF &rectangle, const QString &text, const QTextOption &option = QTextOption())

Anstatt Flags als bitweises ODER aus „ Qt::AlignmentFlag “ und „ Qt::TextFlag “ anzugeben, nimmt diese überladene Funktion ein Argument vom Typ „ option “ entgegen. Die Klasse „ QTextOption “ enthält eine Beschreibung allgemeiner Rich-Text-Eigenschaften.

Siehe auch „ QTextOption “.

QRect QPainter::boundingRect(int x, int y, int w, int h, int flags, const QString &text)

Gibt das Begrenzungsrechteck des angegebenen text zurück, wie es erscheinen würde, wenn es innerhalb des Rechtecks gezeichnet würde, das am Punkt (x, y) beginnt und die Breite w sowie die Höhe h hat.

const QBrush &QPainter::brush() const

Gibt den aktuellen Pinsel des Malers zurück.

Siehe auch QPainter::setBrush() und Settings.

QPoint QPainter::brushOrigin() const

Gibt den aktuellen Pinselursprung zurück. Verwenden Sie vorzugsweise QPainter::brushOriginF(), um den genauen Ursprung zu ermitteln.

Siehe auch ` setBrushOrigin()` und ` Settings`.

[since 6.11] QPointF QPainter::brushOriginF() const

Gibt den aktuellen Pinselursprung zurück.

Diese Funktion wurde in Qt 6.11 eingeführt.

Siehe auch „ setBrushOrigin()“ und „ Settings “.

QRectF QPainter::clipBoundingRect() const

Gibt das Begrenzungsrechteck des aktuellen Clips zurück, sofern ein Clip vorhanden ist; andernfalls wird ein leeres Rechteck zurückgegeben. Beachten Sie, dass der Clip-Bereich in logischen Koordinaten angegeben wird.

Es kann nicht garantiert werden, dass das Begrenzungsrechteck eng anliegt.

Siehe auch setClipRect(), setClipPath() und setClipRegion().

QPainterPath QPainter::clipPath() const

Gibt den aktuellen Clip-Pfad in logischen Koordinaten zurück.

Siehe auch „ setClipPath()“, „ clipRegion()“ und „ setClipping()“.

QRegion QPainter::clipRegion() const

Gibt den aktuell festgelegten Clip-Bereich zurück. Beachten Sie, dass der Clip-Bereich in logischen Koordinaten angegeben wird.

Siehe auch ` setClipRegion()`, ` clipPath()` und ` setClipping()`.

QTransform QPainter::combinedTransform() const

Gibt die Transformationsmatrix zurück, die die aktuelle Fenster-/Ansichtsbereichstransformation und die Welttransformation kombiniert.

Siehe auch setWorldTransform(), setWindow() und setViewport().

QPainter::CompositionMode QPainter::compositionMode() const

Gibt den aktuellen Kompositionsmodus zurück.

Siehe auch „ CompositionMode “ und „ setCompositionMode()“.

QPaintDevice *QPainter::device() const

Gibt das Zeichenobjekt zurück, auf dem dieser „Painter“ gerade zeichnet, oder „ nullptr “, falls der „Painter“ nicht aktiv ist.

Siehe auch isActive().

const QTransform &QPainter::deviceTransform() const

Gibt die Matrix zurück, die eine Transformation von logischen Koordinaten in Gerätekordinaten des plattformabhängigen Zeichen-Geräts durchführt.

Diese Funktion wird nur benötigt, wenn plattformabhängige Zeichenbefehle auf dem plattformabhängigen Handle (Qt::HANDLE) verwendet werden und die Plattform die Transformationen nicht nativ durchführt.

Anhand der Enumeration ` QPaintEngine::PaintEngineFeature ` lässt sich abfragen, ob die Plattform die Transformationen durchführt oder nicht.

Siehe auch ` worldTransform()` und ` QPaintEngine::hasFeature()`.

void QPainter::drawArc(const QRectF &rectangle, int startAngle, int spanAngle)

Zeichnet den Bogen, der durch die angegebenen Werte rectangle, startAngle und spanAngle definiert ist.

Die Werte „ startAngle “ und „ spanAngle “ müssen in 1/16 Grad angegeben werden, d. h. ein Vollkreis entspricht 5760 (16 × 360). Positive Winkelwerte bedeuten eine Drehung gegen den Uhrzeigersinn, negative Winkelwerte eine Drehung im Uhrzeigersinn. Null Grad entspricht der 3-Uhr-Position. Wenn rectangle nicht quadratisch ist, handelt es sich um exzentrische Winkel, die nicht die Richtung vom Mittelpunkt des Rechtecks aus messen, wie unter Arcs and Ellipses beschrieben.

QRectF rectangle(10.0, 20.0, 80.0, 60.0); int startAngle = 30 * 16; int spanAngle = 120 * 16; QPainter painter(this); painter.drawArc(rectangle, startAngle, spanAngle);

Siehe auch drawPie(), drawChord() und Koordinatensystem.

void QPainter::drawArc(const QRect &rectangle, int startAngle, int spanAngle)

Zeichnet den Bogen, der durch die angegebenen Werte rectangle, startAngle und spanAngle definiert ist.

void QPainter::drawArc(int x, int y, int width, int height, int startAngle, int spanAngle)

Zeichnet den durch das Rechteck definierten Bogen, das bei (x, y) beginnt, mit den angegebenen Werten für „ width “ und „ height “ sowie den vorgegebenen Werten für „ startAngle “ und „ spanAngle “.

void QPainter::drawChord(const QRectF &rectangle, int startAngle, int spanAngle)

Zeichnet die Sehne, die durch die angegebenen Werte „ rectangle “, „ startAngle “ und „ spanAngle “ definiert ist. Die Sehne wird mit der aktuellen Füllfarbe „ brush()“ ausgefüllt.

Die Winkel „startAngle“ und „spanAngle“ müssen in 1/16 Grad angegeben werden, d. h. ein Vollkreis entspricht 5760 (16 * 360). Positive Werte für die Winkel bedeuten eine Drehung gegen den Uhrzeigersinn, während negative Werte eine Drehung im Uhrzeigersinn bedeuten. Null Grad entspricht der 3-Uhr-Position. Wenn rectangle nicht quadratisch ist, handelt es sich um exzentrische Winkel, die nicht die Richtung vom Mittelpunkt des Rechtecks aus messen, wie unter Arcs and Ellipses beschrieben.

QRectF rectangle(10.0, 20.0, 80.0, 60.0); int startAngle = 30 * 16; int spanAngle = 120 * 16; QPainter painter(this); painter.drawChord(rect, startAngle, spanAngle);

Siehe auch „ drawArc()“, „ drawPie()“ und „Koordinatensystem“.

void QPainter::drawChord(const QRect &rectangle, int startAngle, int spanAngle)

Zeichnet die Chord, die durch die angegebenen Werte rectangle, startAngle und spanAngle definiert ist.

void QPainter::drawChord(int x, int y, int width, int height, int startAngle, int spanAngle)

Zeichnet die Sehne, die durch das Rechteck mit den Eckpunkten (x, y) definiert ist, unter Verwendung der angegebenen Werte für „ width “ und „ height “ sowie der vorgegebenen Werte für „ startAngle “ und „ spanAngle “.

void QPainter::drawConvexPolygon(const QPointF *points, int pointCount)

Zeichnet das konvexe Polygon, das durch die ersten pointCount Punkte im Array points definiert ist, mit dem aktuellen Stift.

static const QPointF points[4] = { QPointF(10.0, 80.0), QPointF(20.0, 10.0), QPointF(80.0, 30.0), QPointF(90.0, 70.0) }; QPainter painter(this); painter.drawConvexPolygon(points, 4);

Der erste Punkt wird implizit mit dem letzten Punkt verbunden, und das Polygon wird mit der aktuellen Füllfarbe brush() ausgefüllt. Ist das übergebene Polygon nicht konvex, d. h. enthält es mindestens einen Winkel größer als 180 Grad, sind die Ergebnisse undefiniert.

Auf einigen Plattformen (z. B. X11) kann die Funktion `drawConvexPolygon()` schneller sein als die Funktion ` drawPolygon()`.

Siehe auch „ drawPolygon()“, „ drawPolyline()“ und „Koordinatensystem“.

void QPainter::drawConvexPolygon(const QPolygon &polygon)

Zeichnet das durch polygon definierte konvexe Polygon mit dem aktuellen Stift und Pinsel.

void QPainter::drawConvexPolygon(const QPolygonF &polygon)

Zeichnet das durch polygon definierte konvexe Polygon mit dem aktuellen Stift und Pinsel.

void QPainter::drawConvexPolygon(const QPoint *points, int pointCount)

Zeichnet das konvexe Polygon, das durch die ersten pointCount Punkte im Array points definiert ist, mit dem aktuellen Stift.

void QPainter::drawEllipse(const QRectF &rectangle)

Zeichnet die Ellipse, die durch die angegebene „ rectangle “ definiert ist.

Eine gefüllte Ellipse hat die Größe von ` rectangle`. `size()`. Eine umrandete Ellipse hat die Größe von ` rectangle`. `size()` zuzüglich der Stiftbreite.

QRectF rectangle(10.0, 20.0, 80.0, 60.0); QPainter painter(this); painter.drawEllipse(rectangle);

Siehe auch „ drawPie“ () und „Koordinatensystem“.

void QPainter::drawEllipse(const QRect &rectangle)

Zeichnet die Ellipse, die durch die angegebenen Koordinaten rectangle definiert ist.

void QPainter::drawEllipse(const QPoint &center, int rx, int ry)

Zeichnet die Ellipse, die an der Position center liegt und die Radien rx und ry hat.

void QPainter::drawEllipse(const QPointF &center, qreal rx, qreal ry)

Zeichnet die Ellipse, die bei Koordinaten center positioniert ist und die Radien rx und ry aufweist.

void QPainter::drawEllipse(int x, int y, int width, int height)

Zeichnet die Ellipse, die durch das Rechteck mit den Eckpunkten (x, y) und den angegebenen Werten width und height definiert ist.

void QPainter::drawGlyphRun(const QPointF &position, const QGlyphRun &glyphs)

Zeichnet die Glyphen, die unter glyphs auf position dargestellt sind. Die „ position “ gibt die Kante der Grundlinie für die Glyphenfolge an. Die Glyphen werden aus der unter glyphs ausgewählten Schriftart und an den Offsets abgerufen, die durch die Positionen in glyphs angegeben sind.

Siehe auch QGlyphRun::setRawFont(), QGlyphRun::setPositions() und QGlyphRun::setGlyphIndexes().

void QPainter::drawImage(const QRectF &target, const QImage &image, const QRectF &source, Qt::ImageConversionFlags flags = Qt::AutoColor)

Zeichnet den rechteckigen Ausschnitt source des angegebenen Bildes image in das Rechteck target im Zeichenobjekt.

Wenn das Bild angepasst werden muss, um in ein Ergebnis mit niedrigerer Auflösung zu passen (z. B. Konvertierung von 32-Bit auf 8-Bit), verwenden Sie die Funktion „ flags “, um festzulegen, wie dies erfolgen soll.

QRectF target(10.0, 20.0, 80.0, 60.0);
QRectF source(0.0, 0.0, 70.0, 40.0);
QImage image(":/images/myImage.png");

QPainter painter(this);
painter.drawImage(target, image, source);

Siehe auch drawPixmap() und QImage::devicePixelRatio().

void QPainter::drawImage(const QPoint &point, const QImage &image)

Zeichnet die angegebene Funktion „ image “ an der angegebenen Stelle „ point “.

void QPainter::drawImage(const QPointF &point, const QImage &image)

Zeichnet die angegebene „ image “ an der angegebenen Position „ point “.

void QPainter::drawImage(const QRect &rectangle, const QImage &image)

Zeichnet das angegebene Bild „ image “ in das angegebene Rechteck „ rectangle “.

void QPainter::drawImage(const QRectF &rectangle, const QImage &image)

Zeichnet das angegebene Bild „ image “ in das angegebene Rechteck „ rectangle “.

void QPainter::drawImage(const QPoint &point, const QImage &image, const QRect &source, Qt::ImageConversionFlags flags = Qt::AutoColor)

Zeichnet den rechteckigen Ausschnitt source der angegebenen image mit dem Ursprung am angegebenen point.

void QPainter::drawImage(const QPointF &point, const QImage &image, const QRectF &source, Qt::ImageConversionFlags flags = Qt::AutoColor)

Zeichnet den rechteckigen Ausschnitt source der angegebenen image mit dem Ursprung am angegebenen point.

void QPainter::drawImage(const QRect &target, const QImage &image, const QRect &source, Qt::ImageConversionFlags flags = Qt::AutoColor)

Zeichnet den rechteckigen Ausschnitt source des angegebenen image in das Rechteck target im Malgerät.

void QPainter::drawImage(int x, int y, const QImage &image, int sx = 0, int sy = 0, int sw = -1, int sh = -1, Qt::ImageConversionFlags flags = Qt::AutoColor)

Zeichnet ein Bild an der Position (x, y), indem ein Teil von image in das Zeichenobjekt kopiert wird.

(x, y) gibt den Punkt links oben im Zeichenbereich an, auf den gezeichnet werden soll. (sx, sy) gibt den Punkt links oben in image an, der gezeichnet werden soll. Der Standardwert ist (0, 0).

(sw, sh) gibt die Größe des zu zeichnenden Bildes an. Der Standardwert (0, 0) (sowie negative Werte) bedeutet, dass bis zur unteren rechten Ecke des Bildes gezeichnet wird.

void QPainter::drawLine(const QLineF &line)

Zeichnet eine Linie, die durch line definiert ist.

QLineF line(10.0, 80.0, 90.0, 20.0); QPainter painter(this); painter.drawLine(line);

Siehe auch drawLines(), drawPolyline() und Koordinatensystem.

void QPainter::drawLine(const QLine &line)

Zeichnet eine Linie, die durch ` line` definiert ist.

void QPainter::drawLine(const QPoint &p1, const QPoint &p2)

Zeichnet eine Linie von p1 nach p2.

void QPainter::drawLine(const QPointF &p1, const QPointF &p2)

Zeichnet eine Linie von p1 nach p2.

void QPainter::drawLine(int x1, int y1, int x2, int y2)

Zeichnet eine Linie von (x1, y1) nach (x2, y2).

void QPainter::drawLines(const QLineF *lines, int lineCount)

Zeichnet die ersten lineCount Zeilen im Array lines mit dem aktuellen Stift.

Siehe auch „ drawLine()“ und „ drawPolyline()“.

void QPainter::drawLines(const QList<QLine> &lines)

Zeichnet die durch die Liste „ lines “ definierten Linien mit dem aktuellen Stift und Pinsel.

void QPainter::drawLines(const QList<QLineF> &lines)

Zeichnet die durch die Liste „ lines “ definierten Linien mit dem aktuellen Stift und Pinsel.

void QPainter::drawLines(const QList<QPoint> &pointPairs)

Zeichnet mit dem aktuellen Stift für jedes Punktpaar im Vektor „ pointPairs “ eine Linie.

void QPainter::drawLines(const QList<QPointF> &pointPairs)

Zeichnet für jedes Punktpaar im Vektor „ pointPairs “ mit dem aktuellen Stift eine Linie. Enthält das Array eine ungerade Anzahl von Punkten, wird der letzte Punkt ignoriert.

void QPainter::drawLines(const QLine *lines, int lineCount)

Zeichnet die ersten lineCount Zeilen im Array lines mit dem aktuellen Stift.

void QPainter::drawLines(const QPoint *pointPairs, int lineCount)

Zeichnet die ersten lineCount Zeilen im Array pointPairs mit dem aktuellen Stift.

void QPainter::drawLines(const QPointF *pointPairs, int lineCount)

Zeichnet die ersten lineCount Zeilen im Array pointPairs mit dem aktuellen Stift. Die Zeilen werden als Punktpaare angegeben, daher muss die Anzahl der Einträge in pointPairs mindestens lineCount * 2 betragen.

void QPainter::drawPath(const QPainterPath &path)

Zeichnet den angegebenen Painter- path, wobei der aktuelle Stift für die Kontur und der aktuelle Pinsel für die Füllung verwendet werden.

QPainterPath path; path.moveTo(20, 80); path.lineTo(20, 30); path.cubicTo(80, 0, 50, 50, 80, 80); QPainter painter(this); painter.drawPath(path);

Siehe auch das Beispiel „Painter Paths “ und das Beispiel „Vector Deformation“.

void QPainter::drawPicture(const QPointF &point, const QPicture &picture)

Gibt die angegebene „ picture “ unter der angegebenen „ point “ wieder.

Die Klasse „ QPicture “ ist ein Zeichen-Gerät, das „ QPainter “-Befehle aufzeichnet und wiederabspielt. Ein „Picture“ serialisiert die Zeichenbefehle in einem plattformunabhängigen Format auf ein E/A-Gerät. Alles, was auf ein Widget oder eine Pixmap gezeichnet werden kann, kann auch in einem „Picture“ gespeichert werden.

Diese Funktion verhält sich genau wie „ QPicture::play()“, wenn sie mit „ point = QPointF(0, 0)“ aufgerufen wird.

QPicture picture;
QPointF point(10.0, 20.0);
picture.load("drawing.pic");

QPainter painter(this);
painter.drawPicture(0, 0, picture);

Siehe auch ` QPicture::play()`.

void QPainter::drawPicture(const QPoint &point, const QPicture &picture)

Spielt die angegebene Datei „ picture “ unter der angegebenen Adresse „ point “ ab.

void QPainter::drawPicture(int x, int y, const QPicture &picture)

Zeichnet die angegebene Funktion „ picture “ am Punkt (x, y).

void QPainter::drawPie(const QRectF &rectangle, int startAngle, int spanAngle)

Zeichnet ein Kreisdiagramm, das durch die angegebenen Werte rectangle, startAngle und spanAngle definiert ist.

Das Kreisdiagramm wird mit dem aktuellen brush() gefüllt.

Die Werte für `startAngle` und `spanAngle` müssen in 1/16 Grad angegeben werden, d. h. ein voller Kreis entspricht 5760 (16 * 360). Positive Winkelwerte bedeuten eine Drehung gegen den Uhrzeigersinn, negative Werte eine Drehung im Uhrzeigersinn. Null Grad entspricht der 3-Uhr-Position. Wenn „ rectangle “ nicht quadratisch ist, handelt es sich um exzentrische Winkel, die nicht die Richtung vom Mittelpunkt des Rechtecks aus messen, wie unter Arcs and Ellipses beschrieben.

QRectF rectangle(10.0, 20.0, 80.0, 60.0); int startAngle = 30 * 16; int spanAngle = 120 * 16; QPainter painter(this); painter.drawPie(rectangle, startAngle, spanAngle);

Siehe auch „ drawEllipse()“, „ drawChord()“ und „Koordinatensystem“.

void QPainter::drawPie(const QRect &rectangle, int startAngle, int spanAngle)

Zeichnet ein Kreisdiagramm, das durch die angegebenen Werte rectangle, startAngle und spanAngle definiert ist.

void QPainter::drawPie(int x, int y, int width, int height, int startAngle, int spanAngle)

Zeichnet den Kreisausschnitt, der durch das Rechteck mit den Eckpunkten (x, y) definiert ist, mit den angegebenen Werten für „ width “ und „ height “ sowie den vorgegebenen Werten für „ startAngle “ und „ spanAngle “.

void QPainter::drawPixmap(const QRectF &target, const QPixmap &pixmap, const QRectF &source)

Zeichnet den rechteckigen Ausschnitt source des angegebenen Bildes pixmap in das angegebene target im Zeichen-Device.

QRectF target(10.0, 20.0, 80.0, 60.0);
QRectF source(0.0, 0.0, 70.0, 40.0);
QPixmap pixmap(":myPixmap.png");

QPainter painter(this);
painter.drawPixmap(target, pixmap, source);

Ist „ pixmap “ ein „ QBitmap “, wird die Pixmap mit den „gesetzten“ Bits in der Farbe des Stifts gezeichnet. Ist „ backgroundMode “ ein „ Qt::OpaqueMode “, werden die „nicht gesetzten“ Bits in der Farbe des Hintergrundpinsels gezeichnet; ist „ backgroundMode “ ein „ Qt::TransparentMode “, sind die „nicht gesetzten“ Bits transparent. Das Zeichnen von Bitmaps mit Farbverläufen oder Texturfarben wird nicht unterstützt.

Siehe auch „ drawImage “ () und „ QPixmap::devicePixelRatio “ ().

void QPainter::drawPixmap(const QPoint &point, const QPixmap &pixmap)

Zeichnet die angegebene Funktion pixmap mit ihrem Ursprung am angegebenen Punkt point.

void QPainter::drawPixmap(const QPointF &point, const QPixmap &pixmap)

Zeichnet die angegebene Funktion pixmap mit ihrem Ursprung am angegebenen Punkt point.

void QPainter::drawPixmap(const QRect &rectangle, const QPixmap &pixmap)

Zeichnet die angegebene Bilddatei „ pixmap “ in das angegebene Rechteck „ rectangle “.

void QPainter::drawPixmap(const QPoint &point, const QPixmap &pixmap, const QRect &source)

Zeichnet den rechteckigen Ausschnitt source der angegebenen pixmap mit dem Ursprung am angegebenen point.

void QPainter::drawPixmap(const QPointF &point, const QPixmap &pixmap, const QRectF &source)

Zeichnet den rechteckigen Ausschnitt source der angegebenen pixmap mit dem Ursprung am angegebenen point.

void QPainter::drawPixmap(const QRect &target, const QPixmap &pixmap, const QRect &source)

Zeichnet den rechteckigen Ausschnitt source des angegebenen Bildes pixmap in das angegebene Rechteck target im Zeichen-Device.

void QPainter::drawPixmap(int x, int y, const QPixmap &pixmap)

Zeichnet das angegebene „ pixmap “ an der Position (x, y).

void QPainter::drawPixmap(int x, int y, int width, int height, const QPixmap &pixmap)

Zeichnet die „ pixmap “ in das Rechteck an der Position (x, y) mit den angegebenen Werten „ width “ und „ height “.

void QPainter::drawPixmap(int x, int y, const QPixmap &pixmap, int sx, int sy, int sw, int sh)

Zeichnet eine Pixmap an den Koordinaten (x, y), indem ein Teil der angegebenen „ pixmap “ in das Zeichen-Device kopiert wird.

(x, y) gibt den Punkt links oben im Zeichenbereich an, auf den gezeichnet werden soll. (sx, sy) gibt den Punkt links oben in der „ pixmap “ an, die gezeichnet werden soll. Der Standardwert ist (0, 0).

(sw, sh) gibt die Größe der Pixmap an, die gezeichnet werden soll. Der Standardwert (0, 0) (sowie negative Werte) bedeutet, dass bis zur unteren rechten Ecke der Pixmap gezeichnet wird.

void QPainter::drawPixmap(int x, int y, int w, int h, const QPixmap &pixmap, int sx, int sy, int sw, int sh)

Zeichnet den rechteckigen Ausschnitt mit dem Ursprung (sx, sy), der Breite sw und der Höhe sh des angegebenen pixmap am Punkt (x, y) mit einer Breite von w und einer Höhe von h. Sind sw oder sh gleich Null, werden die Breite bzw. Höhe der Pixmap verwendet und um den Versatz sx/sy angepasst;

void QPainter::drawPixmapFragments(const QPainter::PixmapFragment *fragments, int fragmentCount, const QPixmap &pixmap, QPainter::PixmapFragmentHints hints = PixmapFragmentHints())

Diese Funktion dient dazu, pixmap oder ein Teilrechteck von pixmap an mehreren Positionen mit unterschiedlichem Maßstab, unterschiedlicher Drehung und unterschiedlicher Deckkraft zu zeichnen. fragments ist ein Array aus fragmentCount Elementen, die die Parameter für das Zeichnen der einzelnen Pixmap-Fragmente festlegen. Der Parameter hints kann verwendet werden, um Zeichnungshinweise zu übergeben.

Diese Funktion ist potenziell schneller als mehrere Aufrufe von ` drawPixmap()`, da das Backend Zustandsänderungen optimieren kann.

Siehe auch „ QPainter::PixmapFragment “ und „ QPainter::PixmapFragmentHint “.

void QPainter::drawPoint(const QPointF &position)

Zeichnet einen einzelnen Punkt an der angegebenen Koordinaten position, wobei die Farbe des aktuellen Stifts verwendet wird.

Siehe auch Koordinatensystem.

void QPainter::drawPoint(const QPoint &position)

Zeichnet einen einzelnen Punkt an der angegebenen Koordinaten position, wobei die Farbe des aktuellen Stifts verwendet wird.

void QPainter::drawPoint(int x, int y)

Zeichnet einen einzelnen Punkt an der Position (x, y).

void QPainter::drawPoints(const QPointF *points, int pointCount)

Zeichnet die ersten pointCount Punkte im Array points mit der Farbe des aktuellen Stifts.

Siehe auch Koordinatensystem.

void QPainter::drawPoints(const QPolygon &points)

Zeichnet die Punkte des Vektors „ points “.

void QPainter::drawPoints(const QPolygonF &points)

Zeichnet die Punkte des Vektors points.

void QPainter::drawPoints(const QPoint *points, int pointCount)

Zeichnet die ersten pointCount Punkte im Array points mit der Farbe des aktuellen Stifts.

void QPainter::drawPolygon(const QPointF *points, int pointCount, Qt::FillRule fillRule = Qt::OddEvenFill)

Zeichnet das Polygon, das durch die ersten Punkte ` pointCount ` im Array ` points ` definiert ist, mit dem aktuellen Stift und Pinsel.

static const QPointF points[4] = { QPointF(10.0, 80.0), QPointF(20.0, 10.0), QPointF(80.0, 30.0), QPointF(90.0, 70.0) }; QPainter painter(this); painter.drawPolygon(points, 4);

Der erste Punkt wird implizit mit dem letzten Punkt verbunden, und das Polygon wird mit dem aktuellen „ brush()“ ausgefüllt.

Ist ` fillRule ` gleich ` Qt::WindingFill`, wird das Polygon mit dem „Winding“-Füllalgorithmus gefüllt. Ist ` fillRule ` gleich ` Qt::OddEvenFill`, wird das Polygon mit dem „Odd-Even“-Füllalgorithmus gefüllt. Eine ausführlichere Beschreibung dieser Füllregeln finden Sie unter Qt::FillRule.

Siehe auch „ drawConvexPolygon()“, „ drawPolyline()“ und „Koordinatensystem“.

void QPainter::drawPolygon(const QPolygon &points, Qt::FillRule fillRule = Qt::OddEvenFill)

Zeichnet das durch die angegebene Koordinatenliste ` points ` definierte Polygon unter Verwendung der Füllregel ` fillRule`.

void QPainter::drawPolygon(const QPolygonF &points, Qt::FillRule fillRule = Qt::OddEvenFill)

Zeichnet das durch die angegebene Koordinaten points definierte Polygon unter Verwendung der Füllregel „ fillRule “.

void QPainter::drawPolygon(const QPoint *points, int pointCount, Qt::FillRule fillRule = Qt::OddEvenFill)

Zeichnet das Polygon, das durch die ersten pointCount Punkte im Array points definiert ist.

void QPainter::drawPolyline(const QPointF *points, int pointCount)

Zeichnet die durch die ersten Punkte von ` pointCount ` in ` points ` definierte Polylinie mit dem aktuellen Stift.

Beachten Sie, dass im Gegensatz zur Funktion „ drawPolygon()“ der letzte Punkt nicht mit dem ersten verbunden wird und die Polylinie auch nicht ausgefüllt wird.

static const QPointF points[3] = {
    QPointF(10.0, 80.0),
    QPointF(20.0, 10.0),
    QPointF(80.0, 30.0),
};

QPainter painter(this);
painter.drawPolyline(points, 3);

Siehe auch „ drawLines()“, „ drawPolygon()“ und „Koordinatensystem“.

void QPainter::drawPolyline(const QPolygon &points)

Zeichnet die durch die angegebene „ points “ definierte Polylinie mit dem aktuellen Stift.

void QPainter::drawPolyline(const QPolygonF &points)

Zeichnet die durch die angegebene „ points “ definierte Polylinie mit dem aktuellen Stift.

void QPainter::drawPolyline(const QPoint *points, int pointCount)

Zeichnet die durch die ersten pointCount Punkte in points definierte Polylinie mit dem aktuellen Stift.

void QPainter::drawRect(const QRectF &rectangle)

Zeichnet das aktuelle rectangle mit dem aktuellen Stift und Pinsel.

Ein gefülltes Rechteck hat die Größe von ` rectangle`. `size()`. Ein umrandetes Rechteck hat die Größe von ` rectangle`. `size() ` plus die Stiftbreite.

QRectF rectangle(10.0, 20.0, 80.0, 60.0); QPainter painter(this); painter.drawRect(rectangle);

Siehe auch drawRects(), drawPolygon() und Koordinatensystem.

void QPainter::drawRect(const QRect &rectangle)

Zeichnet das aktuelle rectangle mit dem aktuellen Stift und Pinsel.

void QPainter::drawRect(int x, int y, int width, int height)

Zeichnet ein Rechteck, dessen linke obere Ecke bei (x, y) liegt und dessen Breite und Höhe durch die angegebenen Werte width und height definiert sind.

void QPainter::drawRects(const QRectF *rectangles, int rectCount)

Zeichnet den ersten „ rectCount “ des angegebenen „ rectangles “ mit dem aktuellen Stift und Pinsel.

Siehe auch drawRect().

void QPainter::drawRects(const QList<QRect> &rectangles)

Zeichnet das angegebene „ rectangles “ mit dem aktuellen Stift und Pinsel.

void QPainter::drawRects(const QList<QRectF> &rectangles)

Zeichnet das angegebene „ rectangles “ mit dem aktuellen Stift und Pinsel.

void QPainter::drawRects(const QRect *rectangles, int rectCount)

Zeichnet das erste „ rectCount “ des angegebenen „ rectangles “ mit dem aktuellen Stift und Pinsel.

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

Zeichnet das angegebene Rechteck „ rect “ mit abgerundeten Ecken.

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

Ein gefülltes Rechteck hat die Größe von rect.size(). Ein umrandetes Rechteck hat die Größe von rect.size() zuzüglich der Stiftbreite.

QRectF rectangle(10.0, 20.0, 80.0, 60.0); QPainter painter(this); painter.drawRoundedRect(rectangle, 20.0, 15.0);

Siehe auch „ drawRect()“ und „ QPen “.

void QPainter::drawRoundedRect(const QRect &rect, qreal xRadius, qreal yRadius, Qt::SizeMode mode = Qt::AbsoluteSize)

Zeichnet das angegebene Rechteck „ rect “ mit abgerundeten Ecken.

void QPainter::drawRoundedRect(int x, int y, int w, int h, qreal xRadius, qreal yRadius, Qt::SizeMode mode = Qt::AbsoluteSize)

Zeichnet das angegebene Rechteck x, y, w, h mit abgerundeten Ecken.

void QPainter::drawStaticText(const QPointF &topLeftPosition, const QStaticText &staticText)

Zeichnet die angegebene „ staticText “ an der angegebenen „ topLeftPosition “.

Der Text wird unter Verwendung der Schriftart und der Transformation gezeichnet, die für den „Painter“ festgelegt wurden. Wenn sich die für den „Painter“ festgelegte Schriftart und/oder Transformation von denen unterscheiden, die zur Initialisierung des Layouts von „ QStaticText “ verwendet wurden, muss das Layout neu berechnet werden. Verwenden Sie „ QStaticText::prepare()“, um „ staticText “ mit der Schriftart und der Transformation zu initialisieren, mit denen es später gezeichnet wird.

Wenn „ topLeftPosition “ nicht mehr dem Wert zum Zeitpunkt der Initialisierung von „ staticText “ oder zum Zeitpunkt der letzten Darstellung entspricht, entsteht ein geringer Mehraufwand beim Verschieben des Textes an seine neue Position.

Siehe auch „ QStaticText “.

void QPainter::drawStaticText(const QPoint &topLeftPosition, const QStaticText &staticText)

Zeichnet die Schriftart „ staticText “ an der Position „ topLeftPosition “.

void QPainter::drawStaticText(int left, int top, const QStaticText &staticText)

Zeichnet die Schriftart „ staticText “ an den Koordinaten left und top.

void QPainter::drawText(const QPointF &position, const QString &text)

Zeichnet das angegebene ` text ` mit der aktuell definierten Textrichtung, beginnend bei der angegebenen ` position`.

Diese Funktion verarbeitet das Zeilenumbruchzeichen (\n) nicht, da sie den Text nicht in mehrere Zeilen aufteilen und das Zeilenumbruchzeichen nicht anzeigen kann. Verwenden Sie stattdessen die Überladung von QPainter::drawText(), die ein Rechteck als Argument akzeptiert, wenn Sie mehrere Textzeilen mit dem Zeilenumbruchzeichen zeichnen möchten oder wenn der Text umgebrochen werden soll.

Standardmäßig zeichnet QPainter Text mit Kantenglättung.

Siehe auch ` setFont()` und ` setPen()`.

void QPainter::drawText(const QPoint &position, const QString &text)

Zeichnet den angegebenen Text „ text “ mit der aktuell definierten Textrichtung, beginnend an der angegebenen Position „ position “.

Standardmäßig zeichnet „ QPainter “ den Text mit Kantenglättung.

Siehe auch setFont() und setPen().

void QPainter::drawText(const QRectF &rectangle, const QString &text, const QTextOption &option = QTextOption())

Zeichnet das angegebene „ text “ in das „ rectangle “, das mithilfe von „ option “ festgelegt wurde, um dessen Position, Richtung und Ausrichtung zu steuern. Die in „ option “ angegebenen Optionen überschreiben diejenigen, die für das „ QPainter “-Objekt selbst festgelegt wurden.

Standardmäßig zeichnet „ QPainter “ Text mit Kantenglättung.

Siehe auch „ setFont()“ und „ setPen()“.

void QPainter::drawText(int x, int y, const QString &text)

Zeichnet den angegebenen Text „ text “ an der Position (x, y) unter Verwendung der aktuell definierten Textrichtung des Zeichners.

Standardmäßig zeichnet „ QPainter “ den Text mit Kantenglättung.

Siehe auch setFont() und setPen().

void QPainter::drawText(const QRect &rectangle, int flags, const QString &text, QRect *boundingRect = nullptr)

Zeichnet das angegebene „ text “ innerhalb des angegebenen „ rectangle “ gemäß dem festgelegten „ flags “.

Die „ boundingRect “ (sofern nicht null) wird so festgelegt, dass das Begrenzungsrechteck den gesamten Text umschließt. In der folgenden Abbildung stellt die gepunktete Linie beispielsweise den von der Funktion berechneten „ boundingRect “ dar, während die gestrichelte Linie den „ rectangle “ darstellt:

QPainter painter(this); QFont font = painter.font(); font.setPixelSize(48); painter.setFont(font); const QRect rectangle = QRect(0, 0, 100, 50); QRect boundingRect; painter.drawText(rectangle, 0, tr("Hello"), &boundingRect); QPen pen = painter.pen(); pen.setStyle(Qt::DotLine); painter.setPen(pen); painter.drawRect(boundingRect.adjusted(0, 0, -pen.width(), -pen.width())); pen.setStyle(Qt::DashLine); painter.setPen(pen); painter.drawRect(rectangle.adjusted(0, 0, -pen.width(), -pen.width()));

Standardmäßig zeichnet „ QPainter “ den Text mit Anti-Aliasing.

Siehe auch „ setFont()“ und „ setPen()“.

void QPainter::drawText(const QRectF &rectangle, int flags, const QString &text, QRectF *boundingRect = nullptr)

Zeichnet das angegebene „ text “ innerhalb des angegebenen „ rectangle “. Die „ rectangle “ definieren zusammen mit der Ausrichtung „ flags “ die Anker für das „ text “.

QPainter painter(this); painter.drawText(rect, Qt::AlignCenter, tr("Qt\nProject"));

Das Argument ` boundingRect ` (sofern nicht null) legt fest, wie das Begrenzungsrechteck aussehen soll, um den gesamten Text zu umfassen. In der folgenden Abbildung stellt beispielsweise die gepunktete Linie den von der Funktion berechneten ` boundingRect ` dar, während die gestrichelte Linie den ` rectangle` darstellt:

QPainter painter(this); QFont font = painter.font(); font.setPixelSize(48); painter.setFont(font); const QRect rectangle = QRect(0, 0, 100, 50); QRect boundingRect; painter.drawText(rectangle, 0, tr("Hello"), &boundingRect); QPen pen = painter.pen(); pen.setStyle(Qt::DotLine); painter.setPen(pen); painter.drawRect(boundingRect.adjusted(0, 0, -pen.width(), -pen.width())); pen.setStyle(Qt::DashLine); painter.setPen(pen); painter.drawRect(rectangle.adjusted(0, 0, -pen.width(), -pen.width()));

Das Argument „ flags “ ist ein bitweises ODER aus den folgenden Flags:

• Qt::AlignLeft
• Qt::AlignRight
• Qt::AlignHCenter
• Qt::AlignJustify
• Qt::AlignTop
• Qt::AlignBottom
• Qt::AlignVCenter
• Qt::AlignCenter
• Qt::TextDontClip
• Qt::TextSingleLine
• Qt::TextExpandTabs
• Qt::TextShowMnemonic
• Qt::TextWordWrap
• Qt::TextIncludeTrailingSpaces

Standardmäßig zeichnet „ QPainter “ den Text mit Anti-Aliasing.

Siehe auch „ Qt::AlignmentFlag“ , „ Qt::TextFlag “, „ boundingRect()“ und „ layoutDirection()“.

void QPainter::drawText(int x, int y, int width, int height, int flags, const QString &text, QRect *boundingRect = nullptr)

Zeichnet das angegebene „ text “ innerhalb des Rechtecks mit den Koordinaten (x, y), width und height.

Das Argument „ boundingRect “ (sofern nicht null) legt fest, wie das Begrenzungsrechteck aussehen soll, um den gesamten Text zu umfassen. In der folgenden Abbildung stellt die gepunktete Linie beispielsweise den von der Funktion berechneten Wert für „ boundingRect “ dar, während die gestrichelte Linie das Rechteck darstellt, das durch „ x “, „ y “, „ width “ und „ height “ definiert ist:

QPainter painter(this); QFont font = painter.font(); font.setPixelSize(48); painter.setFont(font); const QRect rectangle = QRect(0, 0, 100, 50); QRect boundingRect; painter.drawText(rectangle, 0, tr("Hello"), &boundingRect); QPen pen = painter.pen(); pen.setStyle(Qt::DotLine); painter.setPen(pen); painter.drawRect(boundingRect.adjusted(0, 0, -pen.width(), -pen.width())); pen.setStyle(Qt::DashLine); painter.setPen(pen); painter.drawRect(rectangle.adjusted(0, 0, -pen.width(), -pen.width()));

Das Argument ` flags ` ist eine bitweise ODER-Verknüpfung der folgenden Flags:

• Qt::AlignLeft
• Qt::AlignRight
• Qt::AlignHCenter
• Qt::AlignJustify
• Qt::AlignTop
• Qt::AlignBottom
• Qt::AlignVCenter
• Qt::AlignCenter
• Qt::TextSingleLine
• Qt::TextExpandTabs
• Qt::TextShowMnemonic
• Qt::TextWordWrap

Standardmäßig zeichnet ` QPainter ` Text mit Kantenglättung.

Siehe auch „ Qt::AlignmentFlag“ , „ Qt::TextFlag “, „ setFont()“ und „ setPen()“.

void QPainter::drawTiledPixmap(const QRectF &rectangle, const QPixmap &pixmap, const QPointF &position = QPointF())

Zeichnet ein gekacheltes „ pixmap “ innerhalb des angegebenen „ rectangle “ mit dem Ursprung am angegebenen „ position “.

Der Aufruf von `drawTiledPixmap()` entspricht in etwa dem mehrmaligen Aufruf von ` drawPixmap()`, um einen Bereich mit einer Pixmap zu füllen (kacheln), ist jedoch je nach zugrunde liegendem Fenstersystem potenziell wesentlich effizienter.

drawTiledPixmap() erzeugt auf Displays mit hoher dpi-Auflösung (mit devicePixelRatio > 1) dasselbe visuelle Kachelmuster wie auf Displays mit normaler dpi-Auflösung. Stellen Sie den Parameter `devicePixelRatio` bei ` pixmap ` ein, um die Kachelgröße zu steuern. Wenn Sie ihn beispielsweise auf 2 setzen, werden Breite und Höhe der Kacheln halbiert (sowohl auf 1x- als auch auf 2x-Displays), und auf 2x-Displays wird eine hochauflösende Ausgabe erzeugt.

Der Versatz des „ position “ wird in geräteunabhängigen Pixeln relativ zur oberen linken Ecke des „ rectangle “ angegeben. Mit dem „ position “ lässt sich das sich wiederholende Muster innerhalb des „ rectangle “ ausrichten.

Siehe auch „ drawPixmap()“.

void QPainter::drawTiledPixmap(const QRect &rectangle, const QPixmap &pixmap, const QPoint &position = QPoint())

Zeichnet einen gekachelten „ pixmap “ innerhalb des angegebenen „ rectangle “ mit dem Ursprung am angegebenen „ position “.

void QPainter::drawTiledPixmap(int x, int y, int width, int height, const QPixmap &pixmap, int sx = 0, int sy = 0)

Zeichnet einen gekachelten „ pixmap “ in das angegebene Rechteck.

(x, y) gibt den Punkt in der oberen linken Ecke des Zeichenbereichs an, auf den gezeichnet werden soll; mit den angegebenen Werten für width und height.

(sx, sy) gibt den Ursprung innerhalb des angegebenen Rechtecks an, in dem die Pixmap gezeichnet werden soll. Die Ursprungsposition wird in geräteunabhängigen Pixeln relativ zu (x, y) angegeben. Der Standardwert ist (0, 0).

bool QPainter::end()

Beendet den Malvorgang. Alle während des Malvorgangs verwendeten Ressourcen werden freigegeben. Normalerweise müssen Sie diese Funktion nicht aufrufen, da sie vom Destruktor aufgerufen wird.

Gibt ` true ` zurück, wenn der Painter nicht mehr aktiv ist; andernfalls gibt er ` false` zurück.

Siehe auch „ begin()“ und „ isActive()“.

void QPainter::endNativePainting()

Stellt den Painter nach der manuellen Ausgabe nativer Malbefehle wieder her. Ermöglicht es dem Painter, jeden nativen Zustand wiederherzustellen, auf den er angewiesen ist, bevor er weitere Painter-Befehle aufruft.

Siehe auch ` beginNativePainting()`.

void QPainter::eraseRect(const QRectF &rectangle)

Löscht den Bereich innerhalb der angegebenen rectangle. Entspricht dem Aufruf von

fillRect(rectangle, background());

Siehe auch fillRect().

void QPainter::eraseRect(const QRect &rectangle)

Löscht den Bereich innerhalb der angegebenen Koordinaten rectangle.

void QPainter::eraseRect(int x, int y, int width, int height)

Löscht den Bereich innerhalb des Rechtecks, beginnend bei (x, y), mit den angegebenen Werten width und height.

void QPainter::fillPath(const QPainterPath &path, const QBrush &brush)

Füllt die angegebene „ path “ mit dem angegebenen „ brush “. Der Umriss wird nicht gezeichnet.

Alternativ können Sie anstelle eines „ QBrush “ einen „ QColor “ angeben; der Konstruktor „ QBrush “ (der ein „ QColor “-Argument erwartet) erstellt automatisch einen „Solid Pattern Brush“.

Siehe auch „ drawPath()“.

void QPainter::fillRect(const QRectF &rectangle, const QBrush &brush)

Füllt die angegebene „ rectangle “ mit der angegebenen „ brush “ auf.

Alternativ können Sie anstelle eines „ QBrush “ einen „ QColor “ angeben; der Konstruktor „ QBrush “ (der ein „ QColor “-Argument erwartet) erstellt automatisch einen Pinsel mit durchgehendem Muster.

Siehe auch „ drawRect()“.

void QPainter::fillRect(const QRect &rectangle, QGradient::Preset preset)

Füllt den angegebenen Bereich „ rectangle “ mit dem festgelegten Farbverlauf „ preset “.

void QPainter::fillRect(const QRect &rectangle, Qt::BrushStyle style)

Füllt den angegebenen Bereich „ rectangle “ mit dem angegebenen Pinsel „ style “.

void QPainter::fillRect(const QRect &rectangle, Qt::GlobalColor color)

Füllt das angegebene „ rectangle “ mit dem angegebenen „ color “ auf.

void QPainter::fillRect(const QRect &rectangle, const QBrush &brush)

Füllt die angegebene ` rectangle ` mit dem angegebenen ` brush`.

void QPainter::fillRect(const QRect &rectangle, const QColor &color)

Füllt das angegebene „ rectangle “ mit dem angegebenen „ color “.

void QPainter::fillRect(const QRectF &rectangle, QGradient::Preset preset)

Füllt die angegebene Funktion „ rectangle “ mit dem angegebenen Gradienten „ preset “.

void QPainter::fillRect(const QRectF &rectangle, Qt::BrushStyle style)

Füllt den angegebenen Bereich „ rectangle “ mit dem angegebenen Pinsel „ style “.

void QPainter::fillRect(const QRectF &rectangle, Qt::GlobalColor color)

Füllt das angegebene ` rectangle ` mit dem angegebenen ` color`.

void QPainter::fillRect(const QRectF &rectangle, const QColor &color)

Füllt die angegebene „ rectangle “ mit dem angegebenen „ color “ auf.

void QPainter::fillRect(int x, int y, int width, int height, QGradient::Preset preset)

Füllt das Rechteck, das bei (x, y) beginnt, mit den angegebenen Werten width und height unter Verwendung des angegebenen Farbverlaufs preset.

void QPainter::fillRect(int x, int y, int width, int height, Qt::BrushStyle style)

Füllt das Rechteck, das bei (x, y) beginnt, mit den angegebenen Werten „ width “ und „ height “ unter Verwendung des angegebenen Pinsels „ style “.

void QPainter::fillRect(int x, int y, int width, int height, Qt::GlobalColor color)

Füllt das Rechteck, das bei (x, y) beginnt, mit den angegebenen Werten width und height unter Verwendung der angegebenen Funktion color.

void QPainter::fillRect(int x, int y, int width, int height, const QBrush &brush)

Füllt das Rechteck, das bei (x, y) beginnt, mit den angegebenen Werten width und height unter Verwendung der angegebenen Funktion brush.

void QPainter::fillRect(int x, int y, int width, int height, const QColor &color)

Füllt das Rechteck, das bei (x, y) beginnt, mit den angegebenen Werten width und height unter Verwendung der angegebenen Funktion color.

const QFont &QPainter::font() const

Gibt die aktuell eingestellte Schriftart zurück, die zum Zeichnen von Text verwendet wird.

Siehe auch setFont(), drawText() und Settings.

QFontInfo QPainter::fontInfo() const

Gibt die Schriftartinformationen für den Painter zurück, sofern dieser aktiv ist. Andernfalls ist der Rückgabewert undefiniert.

Siehe auch font(), isActive() und Settings.

QFontMetrics QPainter::fontMetrics() const

Gibt die Schriftartenmetriken für den Painter zurück, sofern dieser aktiv ist. Andernfalls ist der Rückgabewert undefiniert.

Siehe auch font(), isActive() und Settings.

bool QPainter::hasClipping() const

Gibt „ true “ zurück, wenn Clipping festgelegt wurde; andernfalls wird „ false “ zurückgegeben.

Siehe auch „ setClipping()“ und „ Clipping “.

bool QPainter::isActive() const

Gibt „ true “ zurück, wenn „ begin()“ aufgerufen wurde und „ end()“ noch nicht aufgerufen wurde; andernfalls wird „ false “ zurückgegeben.

Siehe auch begin() und QPaintDevice::paintingActive().

Qt::LayoutDirection QPainter::layoutDirection() const

Gibt die vom Painter beim Zeichnen von Text verwendete Ausrichtungsrichtung zurück.

Siehe auch QTextOption::textDirection(), setLayoutDirection(), drawText() und Settings.

qreal QPainter::opacity() const

Gibt die Deckkraft des Malwerkzeugs zurück. Der Standardwert ist 1.

Siehe auch „ setOpacity()“.

QPaintEngine *QPainter::paintEngine() const

Gibt die Paint-Engine zurück, mit der der Painter derzeit arbeitet, sofern der Painter aktiv ist; andernfalls 0.

Siehe auch ` isActive()`.

const QPen &QPainter::pen() const

Gibt den aktuellen Stift des Painters zurück.

Siehe auch setPen() und Settings.

QPainter::RenderHints QPainter::renderHints() const

Gibt ein Flag zurück, das die für diesen Painter festgelegten Darstellungshinweise angibt.

Siehe auch setRenderHints(), testRenderHint() und Rendering Quality.

void QPainter::resetTransform()

Setzt alle Transformationen zurück, die mit den Funktionen „ translate()“, „ scale()“, „ shear()“, „ rotate()“, „ setWorldTransform()“, „ setViewport()“ und „ setWindow()“ vorgenommen wurden.

Siehe auch Coordinate Transformations.

void QPainter::restore()

Stellt den aktuellen Zustand des Painters wieder her (entnimmt einen gespeicherten Zustand vom Stapel).

Siehe auch ` save()`.

void QPainter::rotate(qreal angle)

Dreht das Koordinatensystem im Uhrzeigersinn. Der angegebene Parameter „ angle “ wird in Grad angegeben.

Siehe auch ` setWorldTransform()` und ` Coordinate Transformations`.

void QPainter::save()

Speichert den aktuellen Zustand des Painters (legt den Zustand auf einen Stapel). Auf einen Aufruf von `save()` muss ein entsprechender Aufruf von ` restore()` folgen; die Funktion ` end()` löst den Stapel wieder auf.

Siehe auch restore().

void QPainter::scale(qreal sx, qreal sy)

Skaliert das Koordinatensystem um (sx, sy).

Siehe auch setWorldTransform() und Coordinate Transformations.

void QPainter::setBackground(const QBrush &brush)

Setzt den Hintergrundpinsel des Malwerkzeugs auf den angegebenen „ brush “.

Der Hintergrundpinsel ist der Pinsel, mit dem beim Zeichnen von deckendem Text, gepunkteten Linien und Bitmaps ausgefüllt wird. Der Hintergrundpinsel hat im Modus „Transparenter Hintergrund“ (der Standardmodus) keine Auswirkung.

Siehe auch background(), setBackgroundMode() und Settings.

void QPainter::setBackgroundMode(Qt::BGMode mode)

Setzt den Hintergrundmodus des Malwerkzeugs auf den angegebenen mode

Qt::TransparentMode (Standard) zeichnet gepunktete Linien und Text, ohne die Hintergrundpixel zu setzen. ` Qt::OpaqueMode ` füllt diesen Bereich mit der aktuellen Hintergrundfarbe.

Beachten Sie, dass Sie QPixmap::setMask() verwenden müssen, um eine Bitmap oder Pixmap transparent zu zeichnen.

Siehe auch backgroundMode(), setBackground() und Settings.

void QPainter::setBrush(const QBrush &brush)

Setzt den Pinsel des Malers auf die angegebene „ brush “.

Der Pinsel des Malers legt fest, wie Formen gefüllt werden.

Siehe auch „ brush()“ und „ Settings “.

[since 6.11] void QPainter::setBrush(QBrush &&brush)

Diese Funktion wurde in Qt 6.11 eingeführt.

[since 6.9] void QPainter::setBrush(QColor color)

Stellt den Pinsel des Malers auf einen Vollpinsel mit dem angegebenen „ color “ ein.

Diese Funktion wurde in Qt 6.9 eingeführt.

void QPainter::setBrush(Qt::BrushStyle style)

Setzt den Pinsel des Malers auf die Farbe Schwarz und die angegebene „ style “.

[since 6.9] void QPainter::setBrush(Qt::GlobalColor color)

Stellt den Pinsel des Malers auf einen Vollpinsel mit dem angegebenen „ color “ ein.

Diese Funktion wurde in Qt 6.9 eingeführt.

void QPainter::setBrushOrigin(const QPointF &position)

Setzt den Pinselursprung auf position.

Der Pinselursprung gibt die Koordinate (0, 0) des Pinsels des Painters an.

Beachten Sie, dass die Funktion ` brushOrigin()` in Qt 3 zwar erforderlich war, um den Hintergrund des übergeordneten Elements für ein Widget zu übernehmen, dies jedoch in Qt 4 nicht mehr der Fall ist, da der Qt-4-Painter den Hintergrund nur dann zeichnet, wenn Sie dies explizit anweisen, indem Sie die Eigenschaft ` autoFillBackground ` des Widgets auf `true` setzen.

Siehe auch „ brushOrigin()“ und „ Settings “.

void QPainter::setBrushOrigin(const QPoint &position)

Setzt den Ursprung des Pinsels auf die angegebene Koordinaten position.

void QPainter::setBrushOrigin(int x, int y)

Setzt den Ursprung des Pinsels auf den Punkt (x, y).

void QPainter::setClipPath(const QPainterPath &path, Qt::ClipOperation operation = Qt::ReplaceClip)

Aktiviert das Clipping und legt den Clip-Pfad für den Painter auf den angegebenen „ path “ fest, mit dem Clip- operation.

Beachten Sie, dass der Ausschnittpfad in logischen (Maler-)Koordinaten angegeben wird.

Siehe auch clipPath(), clipRegion() und Clipping.

void QPainter::setClipRect(const QRectF &rectangle, Qt::ClipOperation operation = Qt::ReplaceClip)

rectangle Aktiviert das Clipping und legt den Clipping-Bereich mithilfe der angegebenen Clip-Koordinaten operation auf die angegebenen Werte fest. Standardmäßig wird das aktuelle Clip-Rechteck ersetzt.

Beachten Sie, dass das Ausschnittrechteck in logischen (Painter-)Koordinaten angegeben wird.

Siehe auch clipRegion(), setClipping() und Clipping.

void QPainter::setClipRect(int x, int y, int width, int height, Qt::ClipOperation operation = Qt::ReplaceClip)

Aktiviert das Clipping und legt den Clipping-Bereich auf das Rechteck fest, das an den Koordinaten (x, y) beginnt und die angegebenen Werte für „ width “ und „ height “ aufweist.

void QPainter::setClipRect(const QRect &rectangle, Qt::ClipOperation operation = Qt::ReplaceClip)

Aktiviert das Clipping und legt den Clip-Bereich mithilfe des angegebenen Clip- operation s auf den angegebenen rectangle fest.

void QPainter::setClipRegion(const QRegion &region, Qt::ClipOperation operation = Qt::ReplaceClip)

Legt den Clip-Bereich mithilfe der angegebenen Clip- operation auf die angegebene region fest. Standardmäßig wird der aktuelle Clip-Bereich durch den neuen ersetzt.

Beachten Sie, dass der Ausschnittbereich in logischen Koordinaten angegeben wird.

Siehe auch „ clipRegion()“, „ setClipRect()“ und „ Clipping “.

void QPainter::setClipping(bool enable)

Aktiviert das Clipping, wenn „ enable “ auf „true“ gesetzt ist, oder deaktiviert es, wenn „ enable “ auf „false“ gesetzt ist.

Siehe auch hasClipping() und Clipping.

void QPainter::setCompositionMode(QPainter::CompositionMode mode)

Stellt den Kompositionsmodus auf den angegebenen mode ein.

Siehe auch compositionMode().

void QPainter::setFont(const QFont &font)

Setzt die Schriftart des Malers auf die angegebene „ font “.

Diese Schriftart wird von nachfolgenden drawText()-Funktionen verwendet. Die Textfarbe entspricht der Stiftfarbe.

Wenn Sie eine Schriftart festlegen, die nicht verfügbar ist, sucht Qt nach einer möglichst ähnlichen. „ font()“ gibt den mit „setFont()“ festgelegten Wert zurück, und „ fontInfo()“ gibt die tatsächlich verwendete Schriftart zurück (die möglicherweise identisch ist).

Siehe auch font(), drawText() und Settings.

void QPainter::setLayoutDirection(Qt::LayoutDirection direction)

Legt die vom „Painter“ beim Zeichnen von Text verwendete Ausrichtungsrichtung auf die angegebene „ direction “ fest.

Die Standardeinstellung ist ` Qt::LayoutDirectionAuto`, wodurch die Richtung implizit anhand des gezeichneten Textes ermittelt wird.

Siehe auch QTextOption::setTextDirection(), layoutDirection(), drawText() und Settings.

void QPainter::setOpacity(qreal opacity)

Stellt die Deckkraft des Malwerkzeugs auf „ opacity “ ein. Der Wert sollte im Bereich von 0,0 bis 1,0 liegen, wobei 0,0 vollständig transparent und 1,0 vollständig undurchsichtig ist.

Die für den Malwerkzeug festgelegte Deckkraft gilt für jeden Zeichenvorgang separat. Das Ausfüllen einer Form und das Zeichnen ihres Umrisses werden als separate Zeichenvorgänge behandelt.

Siehe auch ` opacity()`.

void QPainter::setPen(const QPen &pen)

Legt den Zeichenstift so fest, dass er dem angegebenen „ pen “ entspricht.

Die „ pen “ legt fest, wie Linien und Konturen gezeichnet werden, und bestimmt außerdem die Textfarbe.

Siehe auch „ pen()“ und „ Settings “.

[since 6.11] void QPainter::setPen(QPen &&pen)

Diese Funktion wurde in Qt 6.11 eingeführt.

void QPainter::setPen(Qt::PenStyle style)

Stellt den Zeichenstift so ein, dass er die angegebene style, die Breite 1 und die Farbe Schwarz hat.

void QPainter::setPen(const QColor &color)

Legt für den Zeichenstift den Stil „ Qt::SolidLine “, die Breite 1 und den angegebenen „ color “ fest.

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

Setzt den angegebenen Render hint us für den Painter, wenn „ on “ wahr ist; andernfalls wird der Render us gelöscht.

Siehe auch setRenderHints(), renderHints() und Rendering Quality.

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

Setzt die angegebenen Render hints en für den Painter, wenn „ on “ auf „true“ gesetzt ist; andernfalls werden die Render en gelöscht.

Siehe auch ` setRenderHint()`, ` renderHints()` und ` Rendering Quality`.

void QPainter::setTransform(const QTransform &transform, bool combine = false)

Legt die Welttransformationsmatrix fest. Ist „ combine “ auf „true“ gesetzt, wird die angegebene „ transform “ mit der aktuellen Matrix kombiniert; andernfalls ersetzt sie die aktuelle Matrix.

Siehe auch „ transform()“ und „ setWorldTransform()“.

void QPainter::setViewTransformEnabled(bool enable)

Aktiviert Ansichts-Transformationen, wenn „ enable “ auf „true“ gesetzt ist, oder deaktiviert sie, wenn „ enable “ auf „false“ gesetzt ist.

Siehe auch „ viewTransformEnabled()“ und „Fenster-Viewport-Konvertierung“.

void QPainter::setViewport(const QRect &rectangle)

Setzt das Viewport-Rechteck des Painters auf das angegebene „ rectangle “ und aktiviert Ansichtstransformationen.

Das Ansichtsfenster-Rechteck ist Teil der Ansichtstransformation. Das Ansichtsfenster definiert das Gerätekordinatensystem. Sein Gegenstück, die „ window()“, definiert das logische Koordinatensystem.

Das Standard-Ansichtsbereichsrechteck entspricht dem Rechteck des Geräts.

Siehe auch „ viewport()“, „ viewTransformEnabled()“ und „Fenster-Viewport-Konvertierung“.

void QPainter::setViewport(int x, int y, int width, int height)

Legt das Ansichtsfenster des Painters auf das Rechteck fest, das bei den Koordinaten (x, y) beginnt und die angegebenen Werte für „ width “ und „ height “ aufweist.

void QPainter::setWindow(const QRect &rectangle)

Setzt das Malerfenster auf das angegebene Fenster „ rectangle “ und aktiviert Ansichtstransformationen.

Das Fensterrechteck ist Teil der Ansichts-Transformation. Das Fenster definiert das logische Koordinatensystem. Sein Gegenstück, das „ viewport()“, definiert das Gerätekordinatensystem.

Das Standard-Fensterrechteck entspricht dem Rechteck des Geräts.

Siehe auch „ window()“, „ viewTransformEnabled()“ und „Umwandlung von Fenster zu Ansichtsbereich“.

void QPainter::setWindow(int x, int y, int width, int height)

Setzt das Fenster des Painters auf das Rechteck, das bei (x, y) beginnt, sowie auf die angegebenen Werte für „ width “ und „ height “.

void QPainter::setWorldMatrixEnabled(bool enable)

Aktiviert Transformationen, wenn „ enable “ auf „true“ gesetzt ist, oder deaktiviert sie, wenn „ enable “ auf „false“ gesetzt ist. Die Welt-Transformationsmatrix wird nicht verändert.

Siehe auch worldMatrixEnabled(), worldTransform() und Coordinate Transformations.

void QPainter::setWorldTransform(const QTransform &matrix, bool combine = false)

Legt die Welttransformationsmatrix fest. Wenn „ combine “ auf „true“ gesetzt ist, wird die angegebene „ matrix “ mit der aktuellen Matrix kombiniert; andernfalls ersetzt sie die aktuelle Matrix.

Siehe auch „ worldTransform()“, „ transform()“ und „ setTransform()“.

void QPainter::shear(qreal sh, qreal sv)

Schert das Koordinatensystem um (sh, sv).

Siehe auch setWorldTransform() und Coordinate Transformations.

void QPainter::strokePath(const QPainterPath &path, const QPen &pen)

Zeichnet die Kontur (Striche) des Pfades path mit dem durch pen

Siehe auch fillPath() und Drawing.

bool QPainter::testRenderHint(QPainter::RenderHint hint) const

Gibt „ true “ zurück, wenn „ hint “ gesetzt ist; andernfalls gibt es „ false “ zurück.

Siehe auch renderHints() und setRenderHint().

const QTransform &QPainter::transform() const

Alias für worldTransform(). Gibt die Welttransformationsmatrix zurück.

Siehe auch „ setTransform()“ und „ worldTransform()“.

void QPainter::translate(const QPointF &offset)

Verschiebt das Koordinatensystem um den angegebenen Wert „ offset “; d. h., der angegebene Wert „ offset “ wird zu den Punkten addiert.

Siehe auch setWorldTransform() und Coordinate Transformations.

void QPainter::translate(const QPoint &offset)

Verschiebt das Koordinatensystem um den angegebenen Wert ` offset`.

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

Verschiebt das Koordinatensystem um den Vektor (dx, dy).

bool QPainter::viewTransformEnabled() const

Gibt „ true “ zurück, wenn die Ansichtstransformation aktiviert ist; andernfalls wird „false“ zurückgegeben.

Siehe auch „ setViewTransformEnabled()“ und „ worldTransform()“.

QRect QPainter::viewport() const

Gibt das Viewport-Rechteck zurück.

Siehe auch „ setViewport()“ und „ setViewTransformEnabled()“.

QRect QPainter::window() const

Gibt das Fensterrechteck zurück.

Siehe auch „ setWindow()“ und „ setViewTransformEnabled()“.

bool QPainter::worldMatrixEnabled() const

Gibt „ true “ zurück, wenn die Welttransformation aktiviert ist; andernfalls wird „false“ zurückgegeben.

Siehe auch „ setWorldMatrixEnabled()“, „ worldTransform()“ und „Koordinatensystem“.

const QTransform &QPainter::worldTransform() const

Gibt die Welttransformationsmatrix zurück.

Siehe auch ` setWorldTransform()`.