QPainter Class

Dokumentation der Mitgliedsfunktionen

QPainter::QPainter()

Konstruiert einen Maler.

Siehe auch begin() und end().

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

Konstruiert einen Maler, der sofort mit dem Malen der Farbe device beginnt.

Dieser Konstruktor ist praktisch für kurzlebige Painter, z.B. in einem QWidget::paintEvent() und sollte nur einmal verwendet werden. Der Konstruktor ruft begin() für Sie auf und der QPainter Destruktor 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 mit diesem Konstruktor:

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 malen.

Siehe auch begin() und end().

[noexcept] QPainter::~QPainter()

Zerstört 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 Malen der Farbe device und gibt bei Erfolg true zurück; andernfalls false.

Beachten Sie, dass alle Painter-Einstellungen (setPen(), setBrush() usw.) auf Standardwerte zurückgesetzt werden, wenn begin() aufgerufen wird.

Bei den Fehlern, die auftreten können, handelt es sich um schwerwiegende Probleme, wie z. B. diese:

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

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() automatisch bei der Zerstörung ausgeführt wird.

Siehe auch end() und QPainter().

void QPainter::beginNativePainting()

Leert die Malpipeline und bereitet sich 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 die zugrunde liegende Paint-Engine ändert, auf ihre jeweiligen Standardzustände zurückgesetzt werden. Die Zustände, die wir zurücksetzen, können sich von Release zu Release ändern. Die folgenden Zustände werden derzeit in der OpenGL 2-Engine zurückgesetzt:

• Blending ist deaktiviert
• die Tiefen-, Schablonen- und Scherentests sind deaktiviert
• die aktive Textureinheit wird auf 0 zurückgesetzt
• die Tiefenmaske, die Tiefenfunktion und die klare Tiefe werden auf ihre Standardwerte zurückgesetzt
• die Schablonenmaske, die Schablonenoperation und die Schablonenfunktion werden auf die Standardwerte zurückgesetzt
• die aktuelle Farbe wird auf einfarbig weiß zurückgesetzt

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

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 begrenzende Rechteck des text zurück, wie es erscheint, wenn es innerhalb des angegebenen rectangle mit dem angegebenen flags unter Verwendung des aktuell eingestellten font() gezeichnet wird; d.h. die Funktion sagt Ihnen, wo die Funktion drawText() zeichnen wird, wenn sie die gleichen Argumente erhält.

Wenn text nicht in das angegebene rectangle mit dem angegebenen flags passt, gibt die Funktion das gewünschte 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

Wenn mehrere der horizontalen oder mehrere der vertikalen Ausrichtungsflags gesetzt sind, ist die resultierende Ausrichtung undefiniert.

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

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

Dies ist eine überladene Funktion.

Gibt das Begrenzungsrechteck von text zurück, wie es erscheint, wenn es innerhalb des angegebenen rectangle mit dem angegebenen flags unter Verwendung des aktuell eingestellten font() gezeichnet wird.

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

Dies ist eine überladene Funktion.

Anstatt die Flags als bitweises ODER von Qt::AlignmentFlag und Qt::TextFlag anzugeben, nimmt diese überladene Funktion ein option Argument. Die Klasse QTextOption bietet eine Beschreibung der allgemeinen Rich-Text-Eigenschaften.

Siehe auch QTextOption.

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

Dies ist eine überladene Funktion.

Gibt das begrenzende Rechteck des angegebenen text zurück, wie es erscheint, wenn es innerhalb des Rechtecks gezeichnet wird, das an dem Punkt (x, y) mit der Breite w und der Höhe h beginnt.

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 aktuell eingestellten Pinselursprung zurück.

Siehe auch setBrushOrigin() und Settings.

QRectF QPainter::clipBoundingRect() const

Gibt das Begrenzungsrechteck des aktuellen Clips zurück, wenn es einen Clip gibt; andernfalls wird ein leeres Rechteck zurückgegeben. Beachten Sie, dass der Ausschnittbereich in logischen Koordinaten angegeben wird.

Es ist nicht garantiert, dass das begrenzende Rechteck eng ist.

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 die aktuell eingestellte Clip-Region zurück. Beachten Sie, dass die Clip-Region in logischen Koordinaten angegeben wird.

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

QTransform QPainter::combinedTransform() const

Gibt die Transformationsmatrix zurück, die die aktuelle Fenster-/Viewport- und 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 Malgerät zurück, auf dem dieser Maler gerade malt, oder nullptr, wenn der Maler nicht aktiv ist.

Siehe auch isActive().

const QTransform &QPainter::deviceTransform() const

Gibt die Matrix zurück, die von logischen Koordinaten in Gerätekoordinaten des plattformabhängigen Malgeräts transformiert.

Diese Funktion wird nur benötigt, wenn plattformabhängige Painting-Befehle für das plattformabhängige Handle (Qt::HANDLE) verwendet werden und die Plattform die Transformationen nicht von Haus aus durchführt.

Das QPaintEngine::PaintEngineFeature enum kann abgefragt werden, um festzustellen, 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 rectangle, startAngle und spanAngle definiert ist.

Die 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 gegen den Uhrzeigersinn, während negative Werte den Uhrzeigersinn bedeuten. Der Nullpunkt liegt auf der 3-Uhr-Position.

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)

Dies ist eine überladene Funktion.

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

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

Dies ist eine überladene Funktion.

Zeichnet den Bogen, der durch das bei (x, y) beginnende Rechteck mit den angegebenen width und height und den angegebenen startAngle und spanAngle definiert ist.

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

Zeichnet die Sehne, die durch die angegebenen rectangle, startAngle und spanAngle definiert ist. Die Sehne wird mit dem aktuellen brush() gefüllt.

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 gegen den Uhrzeigersinn, während negative Werte den Uhrzeigersinn bedeuten. Der Nullpunkt liegt auf der 3-Uhr-Position.

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)

Dies ist eine überladene Funktion.

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

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

Dies ist eine überladene Funktion.

Zeichnet die Sehne, die durch das Rechteck definiert ist, das bei (x, y) beginnt, mit den angegebenen width und height, und den angegebenen 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, unter Verwendung des aktuellen Stifts.

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 ist implizit mit dem letzten Punkt verbunden, und das Polygon wird mit dem aktuellen brush() gefüllt. Wenn das gelieferte Polygon nicht konvex ist, d.h. es enthält 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)

Dies ist eine überladene Funktion.

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

void QPainter::drawConvexPolygon(const QPolygonF &polygon)

Dies ist eine überladene Funktion.

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

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

Dies ist eine überladene Funktion.

Zeichnet das konvexe Polygon, das durch die ersten pointCount Punkte im Array points definiert ist, unter Verwendung des aktuellen Stifts.

void QPainter::drawEllipse(const QRectF &rectangle)

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

Eine gefüllte Ellipse hat eine Größe von rectangle.size(). Eine gestrichelte Ellipse hat eine Größe von rectangle.size() plus 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)

Dies ist eine überladene Funktion.

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

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

Dies ist eine überladene Funktion.

Zeichnet die Ellipse an der Position center mit den Radien rx und ry.

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

Dies ist eine überladene Funktion.

Zeichnet die Ellipse an der Position center mit den Radien rx und ry.

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

Dies ist eine überladene Funktion.

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

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

Zeichnet die durch glyphs dargestellten Glyphen an position. position gibt den Rand der Grundlinie für die Glyphenkette an. Die Glyphen werden aus der auf glyphs ausgewählten Schriftart und an den durch die Positionen in glyphs angegebenen Offsets abgerufen.

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 Teil source der angegebenen image in das Rechteck target im Malgerät.

Wenn das Bild geändert werden muss, um in ein Ergebnis mit geringerer Auflösung zu passen (z. B. Konvertierung von 32-Bit in 8-Bit), verwenden Sie flags, um anzugeben, wie Sie dies wünschen.

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)

Dies ist eine überladene Funktion.

Zeichnet die angegebene image unter der angegebenen point.

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

Dies ist eine überladene Funktion.

Zeichnet die angegebene image unter der angegebenen point.

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

Dies ist eine überladene Funktion.

Zeichnet das angegebene image in das angegebene rectangle.

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

Dies ist eine überladene Funktion.

Zeichnet das angegebene image in das angegebene rectangle.

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

Dies ist eine überladene Funktion.

Zeichnet den rechteckigen Teil source des 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)

Dies ist eine überladene Funktion.

Zeichnet den rechteckigen Teil source des 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)

Dies ist eine überladene Funktion.

Zeichnet den rechteckigen Teil source der 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)

Dies ist eine überladene Funktion.

Zeichnet ein Bild bei (x, y) durch Kopieren eines Teils von image in das Malgerät.

(x, y) gibt den Punkt oben links im Malgerät an, auf den gezeichnet werden soll. (sx, sy) gibt den oberen linken Punkt in image an, der gezeichnet werden soll. Die Vorgabe ist (0, 0).

(sw, sh) gibt die Größe des Bildes an, das gezeichnet werden soll. Die Vorgabe (0, 0) (und negativ) bedeutet, dass das Bild bis zum rechten unteren Rand reicht.

void QPainter::drawLine(const QLineF &line)

Zeichnet eine durch line definierte Linie.

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)

Dies ist eine überladene Funktion.

Zeichnet eine durch line definierte Linie.

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

Dies ist eine überladene Funktion.

Zeichnet eine Linie von p1 nach p2.

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

Dies ist eine überladene Funktion.

Zeichnet eine Linie von p1 nach p2.

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

Dies ist eine überladene Funktion.

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 unter Verwendung des aktuellen Stifts.

Siehe auch drawLine() und drawPolyline().

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

Dies ist eine überladene Funktion.

Zeichnet den durch die Liste lines definierten Satz von Linien mit dem aktuellen Stift und Pinsel.

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

Dies ist eine überladene Funktion.

Zeichnet den durch die Liste lines definierten Satz von Linien mit dem aktuellen Stift und Pinsel.

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

Dies ist eine überladene Funktion.

Zeichnet eine Linie für jedes Paar von Punkten im Vektor pointPairs unter Verwendung des aktuellen Stifts.

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

Dies ist eine überladene Funktion.

Zeichnet eine Linie für jedes Paar von Punkten im Vektor pointPairs unter Verwendung des aktuellen Stifts. Wenn das Array eine ungerade Anzahl von Punkten enthält, wird der letzte Punkt ignoriert.

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

Dies ist eine überladene Funktion.

Zeichnet die ersten lineCount Zeilen in das Array lines unter Verwendung des aktuellen Stifts.

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

Dies ist eine überladene Funktion.

Zeichnet die ersten lineCount Zeilen in das Array pointPairs unter Verwendung des aktuellen Stifts.

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

Dies ist eine überladene Funktion.

Zeichnet die ersten lineCount Linien im Array pointPairs unter Verwendung des aktuellen Stifts. Die Linien 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 mit dem aktuellen Stift für die Kontur und dem aktuellen Pinsel für die Füllung.

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 Pfade des Malers und das Beispiel Vektordeformation.

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

Gibt die angegebene picture unter der angegebenen point wieder.

Die Klasse QPicture ist ein Malgerät, das QPainter Befehle aufzeichnet und wiedergibt. Ein Bild serialisiert die Malbefehle an ein IO-Gerät in einem plattformunabhängigen Format. Alles, was auf ein Widget oder eine Pixmap gemalt werden kann, kann auch in einem Bild gespeichert werden.

Diese Funktion tut genau dasselbe 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)

Dies ist eine überladene Funktion.

Gibt die angegebene picture unter der angegebenen point wieder.

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

Dies ist eine überladene Funktion.

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

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

Zeichnet einen Kuchen, der durch die angegebenen rectangle, startAngle und spanAngle definiert ist.

Der Kreis wird mit dem aktuellen brush() gefüllt.

startAngle und spanAngle müssen in 1/16tel Grad angegeben werden, d.h. ein Vollkreis entspricht 5760 (16 * 360). Positive Werte für die Winkel bedeuten gegen den Uhrzeigersinn, während negative Werte den Uhrzeigersinn bedeuten. Der Nullpunkt liegt auf der 3-Uhr-Position.

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)

Dies ist eine überladene Funktion.

Zeichnet einen Kuchen, der durch die angegebenen rectangle, startAngle und und spanAngle definiert ist.

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

Dies ist eine überladene Funktion.

Zeichnet die Torte, die durch das Rechteck definiert ist, das bei (x, y) beginnt, mit den angegebenen width und height, und den angegebenen startAngle und spanAngle.

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

Zeichnet den rechteckigen Teil source der angegebenen pixmap in die angegebene target im Malgerät.

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

Wenn pixmap ein QBitmap ist, wird es mit den Bits gezeichnet, die mit der Stiftfarbe "gesetzt" sind. Wenn backgroundMode gleich Qt::OpaqueMode ist, werden die "nicht gesetzten" Bits mit der Farbe des Hintergrundpinsels gezeichnet; wenn backgroundMode gleich Qt::TransparentMode ist, sind die "nicht gesetzten" Bits transparent. Das Zeichnen von Bitmaps mit Farbverläufen oder Texturen wird nicht unterstützt.

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

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

Dies ist eine überladene Funktion.

Zeichnet das angegebene pixmap mit dem Ursprung am angegebenen point.

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

Dies ist eine überladene Funktion.

Zeichnet das angegebene pixmap mit dem Ursprung am angegebenen point.

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

Dies ist eine überladene Funktion.

Zeichnet das angegebene pixmap in das angegebene rectangle.

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

Dies ist eine überladene Funktion.

Zeichnet den rechteckigen Teil source des angegebenen pixmap mit dem Ursprung am angegebenen point.

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

Dies ist eine überladene Funktion.

Zeichnet den rechteckigen Teil source des angegebenen pixmap mit dem Ursprung am angegebenen point.

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

Dies ist eine überladene Funktion.

Zeichnet den rechteckigen Teil source der angegebenen pixmap in die angegebene target im Malgerät.

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

Dies ist eine überladene Funktion.

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

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

Dies ist eine überladene Funktion.

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

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

Dies ist eine überladene Funktion.

Zeichnet eine Pixmap auf (x, y), indem sie einen Teil des angegebenen pixmap in das Malgerät kopiert.

(x, y) gibt den oberen linken Punkt im Malgerät an, auf den gezeichnet werden soll. (sx, sy) gibt den oberen linken Punkt in pixmap an, der gezeichnet werden soll. Die Vorgabe ist (0, 0).

(sw, sh) gibt die Größe der Pixmap an, die gezeichnet werden soll. Die Vorgabe (0, 0) (und negativ) bedeutet, dass die Pixmap bis zum unteren rechten Rand reicht.

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

Dies ist eine überladene Funktion.

Zeichnet den rechteckigen Teil mit dem Ursprung (sx, sy), der Breite sw und der Höhe sh, des gegebenen pixmap, am Punkt (x, y), mit einer Breite von w und einer Höhe von h. Wenn sw oder sh gleich Null sind, wird die Breite/Höhe der Pixmap verwendet und um den Offset sx/sy angepasst;

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

Diese Funktion wird verwendet, um pixmap oder ein Unterrechteck von pixmap an mehreren Positionen mit unterschiedlicher Skalierung, Drehung und Deckkraft zu zeichnen. fragments ist ein Array von fragmentCount Elementen, die die Parameter angeben, die zum Zeichnen jedes Pixmap-Fragments verwendet werden. Der Parameter hints kann zur Übergabe von Zeichenhinweisen verwendet werden.

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 Adresse position unter Verwendung der aktuellen Stiftfarbe.

Siehe auch Koordinatensystem.

void QPainter::drawPoint(const QPoint &position)

Dies ist eine überladene Funktion.

Zeichnet einen einzelnen Punkt an der angegebenen Adresse position unter Verwendung der aktuellen Stiftfarbe.

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

Dies ist eine überladene Funktion.

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

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

Zeichnet die ersten pointCount Punkte in das Array points unter Verwendung der aktuellen Stiftfarbe.

Siehe auch Koordinatensystem.

void QPainter::drawPoints(const QPolygon &points)

Dies ist eine überladene Funktion.

Zeichnet die Punkte des Vektors points.

void QPainter::drawPoints(const QPolygonF &points)

Dies ist eine überladene Funktion.

Zeichnet die Punkte des Vektors points.

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

Dies ist eine überladene Funktion.

Zeichnet die ersten pointCount Punkte im Array points unter Verwendung der aktuellen Stiftfarbe.

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

Zeichnet das Polygon, das durch die ersten pointCount Punkte 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 ist implizit mit dem letzten Punkt verbunden, und das Polygon wird mit dem aktuellen brush() gefüllt.

Wenn fillRule gleich Qt::WindingFill ist, wird das Polygon mit dem gewundenen Füllalgorithmus gefüllt. Wenn fillRule gleich Qt::OddEvenFill ist, wird das Polygon mit dem Algorithmus für ungerade und gerade Füllungen gefüllt. Unter Qt::FillRule finden Sie eine ausführlichere Beschreibung dieser Füllregeln.

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

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

Dies ist eine überladene Funktion.

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

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

Dies ist eine überladene Funktion.

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

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

Dies ist eine überladene Funktion.

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

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

Zeichnet die Polylinie, die durch die ersten pointCount Punkte in points definiert ist, unter Verwendung des aktuellen Stifts.

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

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)

Dies ist eine überladene Funktion.

Zeichnet die durch die angegebene points definierte Polylinie unter Verwendung des aktuellen Stifts.

void QPainter::drawPolyline(const QPolygonF &points)

Dies ist eine überladene Funktion.

Zeichnet die durch die angegebene points definierte Polylinie unter Verwendung des aktuellen Stifts.

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

Dies ist eine überladene Funktion.

Zeichnet die Polylinie, die durch die ersten pointCount Punkte in points definiert ist, unter Verwendung des aktuellen Stifts.

void QPainter::drawRect(const QRectF &rectangle)

Zeichnet das aktuelle rectangle mit dem aktuellen Stift und Pinsel.

Ein gefülltes Rechteck hat eine Größe von rectangle.size(). Ein gestrichenes Rechteck hat eine Größe von rectangle.size() plus der 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)

Dies ist eine überladene Funktion.

Zeichnet die aktuelle rectangle mit dem aktuellen Stift und Pinsel.

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

Dies ist eine überladene Funktion.

Zeichnet ein Rechteck mit der linken oberen Ecke bei (x, y) und mit den angegebenen width und height.

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

Zeichnet die erste rectCount der angegebenen rectangles mit dem aktuellen Stift und Pinsel.

Siehe auch drawRect().

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

Dies ist eine überladene Funktion.

Zeichnet die angegebene rectangles mit dem aktuellen Stift und Pinsel.

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

Dies ist eine überladene Funktion.

Zeichnet die angegebene rectangles mit dem aktuellen Stift und Pinsel.

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

Dies ist eine überladene Funktion.

Zeichnet die erste rectCount der 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 Qt::RelativeSize ist, werden xRadius und yRadius in Prozent der halben Rechteckbreite bzw. -höhe angegeben und sollten im Bereich von 0,0 bis 100,0 liegen.

Ein gefülltes Rechteck hat eine Größe von rect.size(). Ein gestrichenes Rechteck hat eine Größe von rect.size() plus 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)

Dies ist eine überladene Funktion.

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)

Dies ist eine überladene Funktion.

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

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

Zeichnet die angegebene staticText unter der angegebenen topLeftPosition.

Der Text wird unter Verwendung der im Painter eingestellten Schriftart und Transformation gezeichnet. Wenn die Schriftart und/oder die Transformation, die auf dem Painter eingestellt sind, sich von denen unterscheiden, die verwendet werden, um das Layout von QStaticText zu initialisieren, dann muss das Layout neu berechnet werden. Verwenden Sie QStaticText::prepare(), um staticText mit der Schriftart und der Transformation zu initialisieren, mit der es später gezeichnet werden soll.

Wenn topLeftPosition nicht derselbe ist, wie bei der Initialisierung von staticText oder beim letzten Zeichnen, dann wird es einen leichten Overhead geben, wenn der Text an seine neue Position übersetzt wird.

Siehe auch QStaticText.

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

Dies ist eine überladene Funktion.

Zeichnet die staticText an der topLeftPosition.

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

Dies ist eine überladene Funktion.

Zeichnet die staticText an den Koordinaten left und top.

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

Zeichnet die angegebene text mit der aktuell definierten Textrichtung, beginnend mit der angegebenen position.

Diese Funktion kann das Zeilenumbruchzeichen (\n) nicht verarbeiten, da sie Text nicht in mehrere Zeilen umbrechen und das Zeilenumbruchzeichen nicht anzeigen kann. Verwenden Sie stattdessen die QPainter::drawText()-Überladung, die ein Rechteck annimmt, wenn Sie mehrere Textzeilen mit dem Zeilenumbruchzeichen zeichnen wollen oder wenn Sie den Text umbrechen wollen.

Standardmäßig zeichnet QPainter den Text anti-aliased.

Siehe auch setFont() und setPen().

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

Dies ist eine überladene Funktion.

Zeichnet die angegebene text mit der aktuell definierten Textrichtung, beginnend mit der angegebenen position.

Standardmäßig zeichnet QPainter den Text anti-aliased.

Siehe auch setFont() und setPen().

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

Dies ist eine überladene Funktion.

Zeichnet das angegebene text in der angegebenen rectangle unter Verwendung der option, um seine Positionierung, Richtung und Ausrichtung zu steuern. Die Optionen, die in option angegeben werden, überschreiben die Optionen, die für das QPainter Objekt selbst festgelegt wurden.

Standardmäßig zeichnet QPainter den Text anti-aliased.

Siehe auch setFont() und setPen().

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

Dies ist eine überladene Funktion.

Zeichnet die angegebene text an der Position (x, y), unter Verwendung der aktuell definierten Textrichtung des Malers.

Standardmäßig zeichnet QPainter den Text anti-aliased.

Siehe auch setFont() und setPen().

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

Dies ist eine überladene Funktion.

Zeichnet den angegebenen text innerhalb des angegebenen rectangle entsprechend dem angegebenen flags.

boundingRect (falls nicht null) wird auf den Wert gesetzt, den das Begrenzungsrechteck haben sollte, um den gesamten Text zu umschließen. In der folgenden Abbildung stellt die gepunktete Linie beispielsweise boundingRect dar, wie sie von der Funktion berechnet wurde, und die gestrichelte Linie stellt rectangle dar:

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)

Dies ist eine überladene Funktion.

Zeichnet die angegebene text innerhalb der angegebenen rectangle. Die rectangle zusammen mit der Ausrichtung flags definiert die Anker für die text.

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

Der Wert boundingRect (falls nicht null) wird auf den Wert des Begrenzungsrechtecks gesetzt, das den gesamten Text umschließen soll. In der folgenden Abbildung stellt die gepunktete Linie beispielsweise boundingRect dar, wie von der Funktion berechnet, und die gestrichelte Linie rectangle:

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

Dies ist eine überladene Funktion.

Zeichnet den angegebenen text innerhalb des Rechtecks mit Ursprung (x, y), width und height.

boundingRect (falls nicht null) wird auf den Wert gesetzt, den das begrenzende Rechteck haben sollte, um den gesamten Text zu umschließen. In der folgenden Abbildung stellt zum Beispiel die gepunktete Linie boundingRect dar, wie sie von der Funktion berechnet wurde, und die gestrichelte Linie stellt das Rechteck dar, 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 ein bitweises ODER 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 den Text anti-aliased.

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() ähnelt dem mehrmaligen Aufruf von drawPixmap(), um einen Bereich mit einer Pixmap zu füllen (zu kacheln), ist aber je nach dem zugrunde liegenden Fenstersystem potenziell viel effizienter.

drawTiledPixmap() erzeugt auf Bildschirmen mit hoher Auflösung (mit devicePixelRatio > 1) das gleiche visuelle Kachelmuster wie auf Bildschirmen mit normaler Auflösung. Stellen Sie das devicePixelRatio auf pixmap ein, um die Kachelgröße zu steuern. Eine Einstellung von 2 halbiert beispielsweise die Kachelbreite und -höhe (sowohl auf 1x- als auch auf 2x-Displays) und erzeugt eine hochauflösende Ausgabe auf 2x-Displays.

Der position Offset ist immer im Maler-Koordinatensystem, unabhängig von der Anzeige devicePixelRatio.

Siehe auch drawPixmap().

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

Dies ist eine überladene Funktion.

Zeichnet ein gekacheltes 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)

Dies ist eine überladene Funktion.

Zeichnet ein gekacheltes pixmap in das angegebene Rechteck.

(x, y) gibt den oberen linken Punkt im Malgerät an, auf den gezeichnet werden soll; mit den gegebenen width und height. (sx, sy) gibt den oberen linken Punkt im pixmap an, der gezeichnet werden soll; der Standardwert ist (0, 0).

bool QPainter::end()

Beendet das Malen. Alle beim Malen verwendeten Ressourcen werden freigegeben. Normalerweise müssen Sie dies nicht aufrufen, da es durch den Destruktor aufgerufen wird.

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

Siehe auch begin() und isActive().

void QPainter::endNativePainting()

Stellt den Painter nach der manuellen Ausgabe von nativen Malbefehlen wieder her. Lässt den Painter jeden nativen Zustand wiederherstellen, auf den er sich verlässt, bevor er andere Painter-Befehle aufruft.

Siehe auch beginNativePainting().

void QPainter::eraseRect(const QRectF &rectangle)

Löscht den Bereich innerhalb des angegebenen rectangle. Äquivalent zum Aufruf von

fillRect(rectangle, background());

Siehe auch fillRect().

void QPainter::eraseRect(const QRect &rectangle)

Dies ist eine überladene Funktion.

Löscht den Bereich innerhalb des angegebenen rectangle.

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

Dies ist eine überladene Funktion.

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

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

Füllt die angegebene path unter Verwendung der angegebenen brush. Der Umriss wird nicht gezeichnet.

Alternativ können Sie anstelle von QBrush auch QColor angeben; der Konstruktor QBrush (mit dem Argument QColor ) erzeugt automatisch einen einfarbigen Musterpinsel.

Siehe auch drawPath().

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

Füllt den angegebenen rectangle mit dem angegebenen brush.

Alternativ können Sie ein QColor anstelle eines QBrush angeben; der QBrush Konstruktor (mit einem QColor Argument) wird automatisch einen einfarbigen Musterpinsel erzeugen.

Siehe auch drawRect().

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

Dies ist eine überladene Funktion.

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

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

Dies ist eine überladene Funktion.

Füllt die angegebene rectangle mit dem angegebenen Pinsel style.

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

Dies ist eine überladene Funktion.

Füllt die angegebene rectangle mit der angegebenen color.

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

Dies ist eine überladene Funktion.

Füllt die angegebene rectangle mit der angegebenen brush.

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

Dies ist eine überladene Funktion.

Füllt die angegebene rectangle mit der angegebenen color.

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

Dies ist eine überladene Funktion.

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

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

Dies ist eine überladene Funktion.

Füllt die angegebene rectangle mit dem angegebenen Pinsel style.

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

Dies ist eine überladene Funktion.

Füllt die angegebene rectangle mit der angegebenen color.

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

Dies ist eine überladene Funktion.

Füllt die angegebene rectangle mit der angegebenen color.

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

Dies ist eine überladene Funktion.

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

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

Dies ist eine überladene Funktion.

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

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

Dies ist eine überladene Funktion.

Füllt das Rechteck beginnend bei (x, y) mit den angegebenen width und height, unter Verwendung des angegebenen color.

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

Dies ist eine überladene Funktion.

Füllt das Rechteck beginnend bei (x, y) mit den angegebenen width und height, unter Verwendung des angegebenen brush.

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

Dies ist eine überladene Funktion.

Füllt das Rechteck beginnend bei (x, y) mit den angegebenen width und height, unter Verwendung des angegebenen 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, wenn der Painter aktiv ist. Andernfalls ist der Rückgabewert undefiniert.

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

QFontMetrics QPainter::fontMetrics() const

Gibt die Schriftmetrik für den Painter zurück, wenn der Painter aktiv ist. Andernfalls ist der Rückgabewert undefiniert.

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

bool QPainter::hasClipping() const

Gibt true zurück, wenn die Beschneidung eingestellt wurde; andernfalls false.

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 Layout-Richtung zurück.

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

qreal QPainter::opacity() const

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

Siehe auch setOpacity().

QPaintEngine *QPainter::paintEngine() const

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

Siehe auch isActive().

const QPen &QPainter::pen() const

Gibt den aktuellen Stift des Malers zurück.

Siehe auch setPen() und Settings.

QPainter::RenderHints QPainter::renderHints() const

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

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

void QPainter::resetTransform()

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

Siehe auch Coordinate Transformations.

void QPainter::restore()

Stellt den aktuellen Zustand des Malers wieder her (holt einen gespeicherten Zustand vom Stapel).

Siehe auch save().

void QPainter::rotate(qreal angle)

Dreht das Koordinatensystem im Uhrzeigersinn. Der angegebene Parameter angle ist in Grad.

Siehe auch setWorldTransform() und Coordinate Transformations.

void QPainter::save()

Speichert den aktuellen Zustand des Malers (schiebt den Zustand auf einen Stapel). Auf ein save() muss eine entsprechende restore() folgen; die Funktion end() baut den Stack wieder ab.

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 Malers auf den angegebenen brush.

Der Hintergrundpinsel ist der Pinsel, der beim Zeichnen von opakem Text, gestrichelten Linien und Bitmaps ausgefüllt wird. Im Modus "Transparenter Hintergrund" (Standardeinstellung) hat der Hintergrundpinsel keine Wirkung.

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

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

Setzt den Hintergrundmodus des Malers auf den angegebenen mode

Qt::TransparentMode (die Voreinstellung) zeichnet gepunktete Linien und Text, ohne die Hintergrundpixel zu setzen. Qt::OpaqueMode füllt diese Bereiche 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 den angegebenen brush.

Der Malerpinsel bestimmt, wie Formen gefüllt werden.

Siehe auch brush() und Settings.

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

Dies ist eine überladene Funktion.

Setzt den Pinsel des Malers auf schwarze Farbe und die angegebene style.

void QPainter::setBrushOrigin(const QPointF &position)

Setzt den Pinselursprung auf position.

Der Pinselursprung spezifiziert die (0, 0) Koordinate des Pinsels des Malers.

Beachten Sie, dass brushOrigin() in Qt 3 notwendig war, um den Hintergrund des Elternteils für ein Widget zu übernehmen. Dies ist nun nicht mehr der Fall, da der Qt 4 Painter den Hintergrund nicht malt, es sei denn, Sie weisen ihn explizit an, dies zu tun, indem Sie die Eigenschaft autoFillBackground des Widgets auf true setzen.

Siehe auch brushOrigin() und Settings.

void QPainter::setBrushOrigin(const QPoint &position)

Dies ist eine überladene Funktion.

Setzt den Ursprung des Pinsels auf den angegebenen position.

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

Dies ist eine überladene Funktion.

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 setzt den Clip-Pfad für den Painter auf den angegebenen path mit dem Clip operation.

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

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

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

Aktiviert das Clipping und setzt den Clip-Bereich auf die angegebene rectangle unter Verwendung des angegebenen Clips operation. In der Standardeinstellung wird das aktuelle Clip-Rechteck ersetzt.

Beachten Sie, dass das Clip-Rechteck in logischen (Maler-)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 setzt den Clip-Bereich auf das Rechteck beginnend bei (x, y) mit den angegebenen width und height.

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

Dies ist eine überladene Funktion.

Aktiviert das Clipping und setzt den Clip-Bereich auf die angegebene rectangle unter Verwendung des angegebenen Clips operation.

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

Setzt den Clip-Bereich auf die angegebene region unter Verwendung des angegebenen Clips operation. In der Standardeinstellung wird der aktuelle Clip-Bereich 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 true ist, oder deaktiviert das Clipping, wenn enable false ist.

Siehe auch hasClipping() und Clipping.

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

Setzt den Kompositionsmodus auf die angegebene mode.

Siehe auch compositionMode().

void QPainter::setFont(const QFont &font)

Setzt die Schriftart des Malers auf die angegebene font.

Diese Schriftart wird von den nachfolgenden Funktionen drawText() verwendet. Die Textfarbe ist die gleiche wie die Stiftfarbe.

Wenn Sie eine Schriftart einstellen, die nicht verfügbar ist, findet Qt eine naheliegende Übereinstimmung. font() gibt das zurück, was Sie mit setFont() eingestellt haben und fontInfo() gibt die tatsächlich verwendete Schriftart zurück (die dieselbe sein kann).

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

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

Setzt die Layout-Richtung, die der Painter beim Zeichnen von Text verwendet, auf die angegebene direction.

Der Standardwert ist Qt::LayoutDirectionAuto, der die Richtung implizit aus dem gezeichneten Text bestimmt.

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

void QPainter::setOpacity(qreal opacity)

Setzt die Deckkraft des Malers auf opacity. 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 Painter eingestellte Deckkraft gilt für alle Zeichenoperationen einzeln.

Siehe auch opacity().

void QPainter::setPen(const QPen &pen)

Setzt den Stift des Malers auf die angegebene pen.

pen legt fest, wie Linien und Umrisse gezeichnet werden sollen, und definiert auch die Textfarbe.

Siehe auch pen() und Settings.

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

Dies ist eine überladene Funktion.

Setzt den Stift des Malers auf die angegebene style, Breite 1 und schwarze Farbe.

void QPainter::setPen(const QColor &color)

Dies ist eine überladene Funktion.

Setzt den Stift des Malers auf den Stil Qt::SolidLine, die Breite 1 und den angegebenen color.

void QPainter::setRenderHint(QPainter::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(), renderHints(), und Rendering Quality.

void QPainter::setRenderHints(QPainter::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(), renderHints(), und Rendering Quality.

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

Setzt die Welttransformationsmatrix. Wenn combine wahr ist, 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 die Ansichtsumwandlung, wenn enable wahr ist, oder deaktiviert die Ansichtsumwandlung, wenn enable falsch ist.

Siehe auch viewTransformEnabled() und Window-Viewport Conversion.

void QPainter::setViewport(const QRect &rectangle)

Setzt das Viewport-Rechteck des Painters auf das angegebene rectangle und aktiviert View-Transformationen.

Das Ansichtsfenster-Rechteck ist Teil der Ansichtstransformation. Das Ansichtsfenster spezifiziert das Gerätekoordinatensystem. Seine Schwester, die window(), gibt das logische Koordinatensystem an.

Das Standard-Rechteck des Ansichtsfensters ist das gleiche wie das Rechteck des Geräts.

Siehe auch viewport(), viewTransformEnabled(), und Fenster-Ansichtsfenster-Konvertierung.

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

Dies ist eine überladene Funktion.

Setzt das Ansichtsfenster-Rechteck des Malers auf das Rechteck beginnend bei (x, y) mit den angegebenen width und height.

void QPainter::setWindow(const QRect &rectangle)

Setzt das Fenster des Malers auf die angegebene rectangle und aktiviert Ansichtstransformationen.

Das Fensterrechteck ist Teil der Ansichtstransformation. Das Fenster gibt das logische Koordinatensystem an. Seine Schwester, die viewport(), gibt das Gerätekoordinatensystem an.

Das Standard-Fensterrechteck ist das gleiche wie das Geräte-Rechteck.

Siehe auch window(), viewTransformEnabled(), und Fenster-Ansichtsfenster-Umwandlung.

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

Dies ist eine überladene Funktion.

Setzt das Fenster des Malers auf das Rechteck beginnend bei (x, y) und den angegebenen width und height.

void QPainter::setWorldMatrixEnabled(bool enable)

Aktiviert Transformationen, wenn enable wahr ist, oder deaktiviert Transformationen, wenn enable falsch ist. Die Welttransformationsmatrix wird nicht verändert.

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

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

Setzt die Welttransformationsmatrix. Wenn combine wahr 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 Stift, der 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 die angegebene offset; d.h. die angegebene offset wird zu Punkten hinzugefügt.

Siehe auch setWorldTransform() und Coordinate Transformations.

void QPainter::translate(const QPoint &offset)

Dies ist eine überladene Funktion.

Verschiebt das Koordinatensystem um die angegebene offset.

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

Dies ist eine überladene Funktion.

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 Ansichtsfenster-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().