QPixmap Class

Dokumentation zu den Member-Funktionen

QPixmap::QPixmap()

Erstellt eine Null-Pixmap.

Siehe auch ` isNull()`.

[explicit] QPixmap::QPixmap(const char *const[] xpm)

Erstellt eine Pixmap aus den angegebenen „ xpm “-Daten, bei denen es sich um ein gültiges XPM-Bild handeln muss.

Fehler werden stillschweigend ignoriert.

Beachten Sie, dass es möglich ist, die XPM-Variable durch eine ungewöhnliche Deklaration etwas zu verkleinern:

static const char * const start_xpm[] = {
    "16 15 8 1",
    "a c #cec6bd",
    // etc.
};

Das zusätzliche ` const ` macht die gesamte Definition schreibgeschützt, was etwas effizienter ist (beispielsweise, wenn sich der Code in einer gemeinsam genutzten Bibliothek befindet) und ROM-fähig, wenn die Anwendung im ROM gespeichert werden soll.

QPixmap::QPixmap(int width, int height)

Erstellt eine Pixmap mit den angegebenen Werten für ` width ` und ` height`. Ist entweder ` width ` oder ` height ` gleich Null, wird eine leere Pixmap erstellt.

Siehe auch ` isNull()`.

QPixmap::QPixmap(const QString &fileName, const char *format = nullptr, Qt::ImageConversionFlags flags = Qt::AutoColor)

Erstellt eine Pixmap aus der Datei mit dem angegebenen ` fileName`. Wenn die Datei nicht existiert oder ein unbekanntes Format hat, wird die Pixmap zu einer Null-Pixmap.

Der Loader versucht, die Pixmap unter Verwendung der angegebenen „ format “ zu lesen. Wenn die „ format “ nicht angegeben ist (was der Standard ist), durchsucht der Loader die Datei nach einem Header, um das Dateiformat zu ermitteln.

Der Dateiname kann sich entweder auf eine tatsächliche Datei auf der Festplatte oder auf eine der in die Anwendung eingebetteten Ressourcen beziehen. Weitere Informationen zum Einbetten von Bildern und anderen Ressourcendateien in die ausführbare Datei der Anwendung finden Sie in der Übersicht zum Ressourcensystem.

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 Eigenschaft „ flags “, um die Konvertierung zu steuern.

Die Parameter „ fileName “, „ format “ und „ flags “ werden an die Funktion „ load()“ übergeben. Das bedeutet, dass die Daten in „ fileName “ nicht in die Binärdatei kompiliert werden. Wenn „ fileName “ einen relativen Pfad enthält (z. B. nur den Dateinamen), muss die entsprechende Datei relativ zum Arbeitsverzeichnis der Laufzeitumgebung gefunden werden.

Siehe auch Reading and Writing Image Files.

[explicit] QPixmap::QPixmap(const QSize &size)

Erstellt eine Pixmap aus dem angegebenen ` size`.

QPixmap::QPixmap(const QPixmap &pixmap)

Erstellt eine Pixmap, die eine Kopie der angegebenen „ pixmap “ ist.

Siehe auch ` copy()`.

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

Erstellt eine QPixmap-Instanz aus „ other “ mittels „Move-Konstruktion“.

Siehe auch swap() und operator=(QPixmap&&).

[virtual noexcept] QPixmap::~QPixmap()

Löscht die Pixmap.

qint64 QPixmap::cacheKey() const

Gibt eine Zahl zurück, die diese ` QPixmap` identifiziert. Verschiedene ` QPixmap `-Objekte können nur dann denselben Cache-Schlüssel haben, wenn sie sich auf denselben Inhalt beziehen.

Der cacheKey() ändert sich, wenn das Pixmap-Objekt verändert wird.

bool QPixmap::convertFromImage(const QImage &image, Qt::ImageConversionFlags flags = Qt::AutoColor)

Ersetzt die Daten dieser Pixmap durch die angegebene „ image “ unter Verwendung der angegebenen „ flags “ zur Steuerung der Konvertierung. Das Argument „ flags “ ist ein bitweises ODER aus „ Qt::ImageConversionFlags “. Wird für „ flags “ der Wert 0 übergeben, werden alle Standardoptionen gesetzt. Gibt „ true “ zurück, wenn das Ergebnis eine von Null verschiedene Pixmap ist.

Siehe auch „ fromImage()“.

QPixmap QPixmap::copy(const QRect &rectangle = QRect()) const

Gibt eine tiefe Kopie des Teils der Pixmap zurück, der durch den angegebenen „ rectangle “ festgelegt ist. Weitere Informationen zu tiefen Kopien finden Sie in der Dokumentation zu impliziter Datenfreigabe.

Ist der angegebene ` rectangle ` leer, wird das gesamte Bild kopiert.

Siehe auch „ operator=()“, „ QPixmap()“ und „ Pixmap Transformations “.

QPixmap QPixmap::copy(int x, int y, int width, int height) const

Gibt eine Deep-Copy der Teilmenge der Pixmap zurück, die durch das Rechteck QRect( x, y, width, height) festgelegt ist.

QBitmap QPixmap::createHeuristicMask(bool clipTight = true) const

Erstellt eine heuristische Maske für diese Pixmap und gibt sie zurück.

Die Funktion wählt eine Farbe aus einer der Ecken aus und entfernt dann Pixel dieser Farbe, beginnend an allen Rändern. Ist „ clipTight “ wahr (Standardeinstellung), ist die Maske gerade groß genug, um die Pixel abzudecken; andernfalls ist die Maske größer als die Datenpixel.

Die Maske ist zwar möglicherweise nicht perfekt, sollte aber plausibel sein, sodass Sie beispielsweise Folgendes tun können:

QPixmap myPixmap;
myPixmap.setMask(myPixmap.createHeuristicMask());

Diese Funktion ist langsam, da sie die Konvertierung in/aus einem „ QImage “ sowie nicht triviale Berechnungen beinhaltet.

Siehe auch „ QImage::createHeuristicMask()“ und „ createMaskFromColor()“.

QBitmap QPixmap::createMaskFromColor(const QColor &maskColor, Qt::MaskMode mode = Qt::MaskInColor) const

Erstellt und gibt eine Maske für diese Pixmap basierend auf dem angegebenen ` maskColor` zurück. Wenn der ` mode ` der Wert ` Qt::MaskInColor` ist, werden alle Pixel, die der `maskColor` entsprechen, transparent. Wenn der ` mode ` der Wert ` Qt::MaskOutColor` ist, werden alle Pixel, die der `maskColor` entsprechen, undurchsichtig.

Diese Funktion ist langsam, da sie die Konvertierung in ein bzw. aus einem „ QImage “ beinhaltet.

Siehe auch „ createHeuristicMask()“ und „ QImage::createMaskFromColor()“.

[static] int QPixmap::defaultDepth()

Gibt die von der Anwendung verwendete Standard-Pixmap-Tiefe zurück.

Auf allen Plattformen wird die Tiefe des primären Bildschirms zurückgegeben.

Siehe auch „ depth()“ und „ Pixmap Information “.

int QPixmap::depth() const

Gibt die Tiefe der Pixmap zurück.

Die Pixmap-Tiefe wird auch als „Bits pro Pixel“ (bpp) oder „Bit-Ebenen“ einer Pixmap bezeichnet. Eine leere Pixmap hat die Tiefe 0.

Siehe auch „ defaultDepth()“ und „ Pixmap Information “.

void QPixmap::detach()

Trennt die Pixmap von den gemeinsam genutzten Pixmap-Daten.

Eine Pixmap wird von Qt automatisch getrennt, sobald sich ihr Inhalt ändern soll. Dies geschieht in fast allen ` QPixmap `-Memberfunktionen, die die Pixmap ändern (fill(), fromImage(), load() usw.), sowie bei der Funktion ` QPainter::begin()` für eine Pixmap.

Es gibt zwei Ausnahmen, in denen `detach()` explizit aufgerufen werden muss, nämlich beim Aufruf der Funktion `handle()` oder der Funktion `x11PictureHandle()` (nur unter X11 verfügbar). Andernfalls werden alle Änderungen, die über Systemaufrufe vorgenommen werden, an den gemeinsam genutzten Daten durchgeführt.

Die Funktion `detach()` kehrt sofort zurück, wenn nur eine einzige Referenz vorhanden ist oder wenn die Pixmap noch nicht initialisiert wurde.

[since 6.2] QSizeF QPixmap::deviceIndependentSize() const

Gibt die Größe der Pixmap in geräteunabhängigen Pixeln zurück.

Dieser Wert sollte verwendet werden, wenn die Größe der Pixmap bei Berechnungen der Benutzeroberflächengröße herangezogen wird.

Der Rückgabewert entspricht pixmap.size() / pixmap.devicePixelRatio().

Diese Funktion wurde in Qt 6.2 eingeführt.

qreal QPixmap::devicePixelRatio() const

Gibt das Gerätepixelverhältnis für die Pixmap zurück. Dabei handelt es sich um das Verhältnis zwischen Gerätepixeln und geräteunabhängigen Pixeln.

Verwenden Sie diese Funktion, wenn Sie die Layout-Geometrie basierend auf der Größe der Pixmap berechnen: ` QSize layoutSize = image.size() / image.devicePixelRatio()`

Der Standardwert ist 1,0.

Siehe auch ` setDevicePixelRatio()` und ` QImageReader`.

void QPixmap::fill(const QColor &color = Qt::white)

Füllt die Pixmap mit dem angegebenen „ color “.

Das Verhalten dieser Funktion ist undefiniert, wenn gerade auf die Pixmap gezeichnet wird.

Siehe auch ` Pixmap Transformations`.

[static] QPixmap QPixmap::fromImage(const QImage &image, Qt::ImageConversionFlags flags = Qt::AutoColor)

Konvertiert die angegebene „ image “ mithilfe der angegebenen „ flags “ in eine Pixmap, um die Konvertierung zu steuern. Das Argument „ flags “ ist ein bitweises ODER aus den „ Qt::ImageConversionFlags “. Wird für „ flags “ der Wert 0 übergeben, werden alle Standardoptionen gesetzt.

Bei monochromen und 8-Bit-Bildern wird das Bild zunächst in eine 32-Bit-Pixmap konvertiert und anschließend mit den Farben aus der Farbtabelle gefüllt. Sollte dieser Vorgang zu rechenintensiv sein, können Sie stattdessen QBitmap::fromImage() verwenden.

Siehe auch fromImageReader(), toImage() und Pixmap Conversion.

[static] QPixmap QPixmap::fromImage(QImage &&image, Qt::ImageConversionFlags flags = Qt::AutoColor)

Wandelt das angegebene ` image ` nach Möglichkeit ohne Kopieren in eine Pixmap um.

[static] QPixmap QPixmap::fromImageReader(QImageReader *imageReader, Qt::ImageConversionFlags flags = Qt::AutoColor)

Erstellen Sie ein „ QPixmap “ aus einem Bild, das direkt von einem „ imageReader “ eingelesen wurde. Das Argument „ flags “ ist ein bitweises ODER aus den „ Qt::ImageConversionFlags “. Wenn Sie für „ flags “ den Wert 0 übergeben, werden alle Standardoptionen gesetzt.

Auf einigen Systemen kann das direkte Einlesen eines Bildes in „ QPixmap “ weniger Speicher beanspruchen als das Einlesen eines „ QImage “, um es in „ QPixmap “ zu konvertieren.

Siehe auch fromImage(), toImage() und Pixmap Conversion.

bool QPixmap::hasAlpha() const

Gibt „ true “ zurück, wenn diese Pixmap über einen Alphakanal oder eine Maske verfügt; andernfalls wird „ false “ zurückgegeben.

Siehe auch hasAlphaChannel() und mask().

bool QPixmap::hasAlphaChannel() const

Gibt „ true “ zurück, wenn das Pixmap-Format den Alphakanal berücksichtigt; andernfalls wird „ false “ zurückgegeben.

Siehe auch hasAlpha().

int QPixmap::height() const

Gibt die Höhe der Pixmap zurück.

Siehe auch size() und Pixmap Information.

bool QPixmap::isNull() const

Gibt „ true “ zurück, wenn es sich um eine Null-Pixmap handelt; andernfalls wird „ false “ zurückgegeben.

Eine Null-Pixmap hat die Breite Null, die Höhe Null und keinen Inhalt. In eine Null-Pixmap kann nicht gezeichnet werden.

bool QPixmap::isQBitmap() const

Gibt „ true “ zurück, wenn es sich um eine „ QBitmap “ handelt; andernfalls wird „ false “ zurückgegeben.

bool QPixmap::load(const QString &fileName, const char *format = nullptr, Qt::ImageConversionFlags flags = Qt::AutoColor)

Lädt eine Pixmap aus der Datei mit dem angegebenen „ fileName “ . Gibt „true“ zurück, wenn die Pixmap erfolgreich geladen wurde; andernfalls wird die Pixmap ungültig gemacht und „ false “ zurückgegeben.

Der Loader versucht, die Pixmap unter Verwendung des angegebenen „ format “ zu lesen. Wenn der „ format “ nicht angegeben ist (was der Standard ist), durchsucht der Loader die Datei nach einem Header, um das Dateiformat zu ermitteln.

Der Dateiname kann sich entweder auf eine tatsächliche Datei auf der Festplatte oder auf eine der in die Anwendung eingebetteten Ressourcen beziehen. Weitere Informationen zum Einbetten von Pixmaps und anderen Ressourcendateien in die ausführbare Datei der Anwendung finden Sie in der Übersicht zum Ressourcensystem.

Wenn die Daten angepasst werden müssen, um in ein Ergebnis mit niedrigerer Auflösung zu passen (z. B. Konvertierung von 32-Bit auf 8-Bit), verwenden Sie den Parameter „ flags “, um die Konvertierung zu steuern.

Beachten Sie, dass QPixmaps automatisch zum ` QPixmapCache ` hinzugefügt werden, wenn sie aus einer Datei im Hauptthread geladen werden; der verwendete Schlüssel ist intern und kann nicht abgerufen werden.

Siehe auch „ loadFromData()“ und „ Reading and Writing Image Files “.

bool QPixmap::loadFromData(const uchar *data, uint len, const char *format = nullptr, Qt::ImageConversionFlags flags = Qt::AutoColor)

Lädt eine Pixmap aus den ersten Bytes der angegebenen Binärdatei „ len “ data. Gibt „ true “ zurück, wenn die Pixmap erfolgreich geladen wurde; andernfalls wird die Pixmap ungültig gemacht und „ false “ zurückgegeben.

Der Loader versucht, die Pixmap unter Verwendung der angegebenen „ format “ zu lesen. Wenn die „ format “ nicht angegeben ist (was der Standard ist), durchsucht der Loader die Datei nach einem Header, um das Dateiformat zu ermitteln.

Wenn die Daten angepasst werden müssen, um in ein Ergebnis mit niedrigerer Auflösung zu passen (z. B. Konvertierung von 32-Bit auf 8-Bit), verwenden Sie den Parameter ` flags `, um die Konvertierung zu steuern.

Siehe auch „ load()“ und „ Reading and Writing Image Files “.

bool QPixmap::loadFromData(const QByteArray &data, const char *format = nullptr, Qt::ImageConversionFlags flags = Qt::AutoColor)

Lädt eine Pixmap aus der Binärdatei „ data “ unter Verwendung der angegebenen „ format “ und der Konvertierungsfunktion „ flags “.

QBitmap QPixmap::mask() const

Extrahiert eine Bitmap-Maske aus dem Alphakanal der Pixmap.

Siehe auch setMask() und Pixmap Information.

QRect QPixmap::rect() const

Gibt das umschließende Rechteck der Pixmap zurück.

Siehe auch „ Pixmap Information “.

bool QPixmap::save(const QString &fileName, const char *format = nullptr, int quality = -1) const

Speichert die Pixmap in der Datei mit dem angegebenen „ fileName “ unter Verwendung des angegebenen Bilddatei- format s und des „ quality “-Faktors. Gibt bei Erfolg „ true “ zurück; andernfalls wird „ false “ zurückgegeben.

Der Faktor „ quality “ muss im Bereich [0,100] oder -1 liegen. Geben Sie 0 an, um kleine komprimierte Dateien zu erhalten, 100 für große unkomprimierte Dateien und -1, um die Standardeinstellungen zu verwenden.

Wenn „ format “ auf „ nullptr “ gesetzt ist, wird ein Bildformat anhand der Endung von „ fileName “ ausgewählt.

Siehe auch Reading and Writing Image Files.

bool QPixmap::save(QIODevice *device, const char *format = nullptr, int quality = -1) const

Diese Funktion schreibt eine „ QPixmap “ unter Verwendung des angegebenen Bilddatei- format s und des „ quality “-Faktors in die angegebene „ device “. Dies kann beispielsweise verwendet werden, um eine „pixmap“ direkt in eine „ QByteArray “ zu speichern:

QPixmap pixmap;
QByteArray bytes;
QBuffer buffer(&bytes);
buffer.open(QIODevice::WriteOnly);
pixmap.save(&buffer, "PNG"); // writes pixmap into bytes in PNG format

QPixmap QPixmap::scaled(const QSize &size, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio, Qt::TransformationMode transformMode = Qt::FastTransformation) const

Skaliert die Pixmap auf die angegebene Größe ` size`, wobei das Seitenverhältnis und die Transformationsmodi verwendet werden, die durch ` aspectRatioMode ` und ` transformMode` festgelegt sind.

• Wenn aspectRatioMode gleich Qt::IgnoreAspectRatio ist, wird die Pixmap auf size skaliert.
• Ist aspectRatioMode gleich Qt::KeepAspectRatio, wird die Pixmap unter Beibehaltung des Seitenverhältnisses auf ein möglichst großes Rechteck innerhalb von size skaliert.
• Ist ` aspectRatioMode ` gleich ` Qt::KeepAspectRatioByExpanding`, wird die Pixmap unter Beibehaltung des Seitenverhältnisses auf ein möglichst kleines Rechteck außerhalb von ` size` skaliert.

Ist das angegebene ` size ` leer, gibt diese Funktion eine Null-Pixmap zurück.

In manchen Fällen kann es vorteilhafter sein, die Pixmap mit einem festgelegten Skalierungsfaktor auf einen Painter zu zeichnen, anstatt die Pixmap zu skalieren. Dies ist beispielsweise der Fall, wenn der Painter auf OpenGL basiert oder wenn sich der Skalierungsfaktor schnell ändert.

Siehe auch ` isNull()` und ` Pixmap Transformations`.

QPixmap QPixmap::scaled(int width, int height, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio, Qt::TransformationMode transformMode = Qt::FastTransformation) const

Gibt eine Kopie der Pixmap zurück, die gemäß den angegebenen Werten für „ aspectRatioMode “ und „ transformMode “ auf ein Rechteck mit den angegebenen Werten für „ width “ und „ height “ skaliert wurde.

Ist entweder die Breite ( width ) oder die Höhe ( height ) gleich Null oder negativ, gibt diese Funktion eine leere Pixmap zurück.

QPixmap QPixmap::scaledToHeight(int height, Qt::TransformationMode mode = Qt::FastTransformation) const

Gibt eine skalierte Kopie des Bildes zurück. Das zurückgegebene Bild wird mithilfe der angegebenen Transformation mode auf die angegebene Größe height skaliert. Die Breite der Pixmap wird automatisch so berechnet, dass das Seitenverhältnis der Pixmap erhalten bleibt.

Ist ` height ` gleich 0 oder negativ, wird eine leere Pixmap zurückgegeben.

Siehe auch isNull() und Pixmap Transformations.

QPixmap QPixmap::scaledToWidth(int width, Qt::TransformationMode mode = Qt::FastTransformation) const

Gibt eine skalierte Kopie des Bildes zurück. Das zurückgegebene Bild wird mithilfe der angegebenen Transformation mode auf die angegebene Größe width skaliert. Die Höhe der Pixmap wird automatisch so berechnet, dass das Seitenverhältnis der Pixmap beibehalten wird.

Ist ` width ` gleich 0 oder negativ, wird eine leere Pixmap zurückgegeben.

Siehe auch isNull() und Pixmap Transformations.

void QPixmap::scroll(int dx, int dy, const QRect &rect, QRegion *exposed = nullptr)

Blättert den Bereich „ rect “ dieser Pixmap um (dx, dy). Der sichtbare Bereich bleibt unverändert. Optional können Sie einen Zeiger auf eine leere „ QRegion “ übergeben, um den Bereich abzurufen, der durch den Blättevorgang „ exposed “ wurde.

QPixmap pixmap("background.png");
QRegion exposed;
pixmap.scroll(10, 10, pixmap.rect(), &exposed);

Sie können nicht scrollen, solange ein „Painter“ auf der Pixmap aktiv ist.

Siehe auch „ QWidget::scroll()“ und „ QGraphicsItem::scroll()“.

void QPixmap::scroll(int dx, int dy, int x, int y, int width, int height, QRegion *exposed = nullptr)

Diese Komfortfunktion entspricht dem Aufruf von QPixmap::scroll(dx, dy, QRect(x, y, width, height), exposed).

Siehe auch QWidget::scroll() und QGraphicsItem::scroll().

void QPixmap::setDevicePixelRatio(qreal scaleFactor)

Legt das Gerätepixelverhältnis für die Pixmap fest. Dabei handelt es sich um das Verhältnis zwischen Bildpixeln und geräteunabhängigen Pixeln.

Der Standard scaleFactor wert ist 1,0. Eine andere Einstellung hat zwei Auswirkungen:

QPainters, die auf der Pixmap geöffnet werden, werden skaliert. Wird beispielsweise auf einem 200x200-Bild mit einem Verhältnis von 2,0 gezeichnet, ergibt sich ein effektiver (geräteunabhängiger) Zeichenbereich von 100x100.

Codepfade in Qt, die die Layout-Geometrie basierend auf der Größe der Pixmap berechnen, berücksichtigen das Verhältnis: ` QSize layoutSize = pixmap.size() / pixmap.devicePixelRatio()`. Dies hat letztlich zur Folge, dass die Pixmap als Pixmap mit hoher DPI-Auflösung und nicht als große Pixmap angezeigt wird (siehe Drawing High Resolution Versions of Pixmaps and Images).

Siehe auch devicePixelRatio() und deviceIndependentSize().

void QPixmap::setMask(const QBitmap &mask)

Legt eine Masken-Bitmap fest.

Diese Funktion führt die „ mask “ mit dem Alphakanal der Pixmap zusammen. Ein Pixelwert von 1 in der Maske bedeutet, dass das entsprechende Pixel der Pixmap unverändert bleibt; ein Wert von 0 bedeutet, dass das Pixel transparent ist. Die Maske muss dieselbe Größe wie diese Pixmap haben.

Das Setzen einer Nullmaske setzt die Maske zurück, wobei die zuvor transparenten Pixel schwarz bleiben. Die Wirkung dieser Funktion ist undefiniert, wenn die Pixmap gerade gezeichnet wird.

Siehe auch ` mask()`, ` Pixmap Transformations` und ` QBitmap`.

QSize QPixmap::size() const

Gibt die Größe der Pixmap zurück.

Siehe auch width(), height() und Pixmap Information.

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

Tauscht diese Pixmap gegen „ other “ aus. Dieser Vorgang ist sehr schnell und schlägt niemals fehl.

QImage QPixmap::toImage() const

Wandelt die Pixmap in eine „ QImage “ um. Gibt ein Nullbild zurück, wenn die Konvertierung fehlschlägt.

Wenn die Pixmap eine Farbtiefe von 1 Bit hat, hat das zurückgegebene Bild ebenfalls eine Farbtiefe von 1 Bit. Bilder mit einer höheren Bitanzahl werden in einem Format zurückgegeben, das dem zugrunde liegenden System sehr nahe kommt. In der Regel ist dies „ QImage::Format_ARGB32_Premultiplied “ für Pixmaps mit Alpha-Kanal und „ QImage::Format_RGB32 “ oder „ QImage::Format_RGB16 “ für Pixmaps ohne Alpha-Kanal.

Beachten Sie, dass Alpha-Masken bei monochromen Bildern derzeit ignoriert werden.

Siehe auch fromImage() und Image Formats.

QPixmap QPixmap::transformed(const QTransform &transform, Qt::TransformationMode mode = Qt::FastTransformation) const

Gibt eine Kopie der Pixmap zurück, die mithilfe der angegebenen Transformation transform und der Transformation mode transformiert wurde. Die ursprüngliche Pixmap wird dabei nicht verändert.

Die Transformations transform wird intern angepasst, um unerwünschte Verschiebungen auszugleichen; d. h., die erzeugte Pixmap ist die kleinste Pixmap, die alle transformierten Punkte der ursprünglichen Pixmap enthält. Verwenden Sie die Funktion trueMatrix(), um die tatsächlich für die Transformation der Pixmap verwendete Matrix abzurufen.

Diese Funktion ist langsam, da sie eine Transformation in eine QImage, nicht-triviale Berechnungen und eine Rücktransformation in eine QPixmap beinhaltet.

Siehe auch ` trueMatrix()` und ` Pixmap Transformations`.

[static] QTransform QPixmap::trueMatrix(const QTransform &matrix, int width, int height)

Gibt die tatsächliche Matrix zurück, die zur Transformation einer Pixmap mit den angegebenen Werten für ` width`, ` height ` und ` matrix` verwendet wird.

Bei der Transformation einer Pixmap mit der Funktion ` transformed()` wird die Transformationsmatrix intern angepasst, um unerwünschte Verschiebungen auszugleichen, d. h. ` transformed()` gibt die kleinste Pixmap zurück, die alle transformierten Punkte der ursprünglichen Pixmap enthält. Diese Funktion gibt die modifizierte Matrix zurück, die Punkte korrekt von der ursprünglichen Pixmap in die neue Pixmap abbildet.

Siehe auch „ transformed()“ und „ Pixmap Transformations “.

int QPixmap::width() const

Gibt die Breite der Pixmap zurück.

Siehe auch size() und Pixmap Information.

QPixmap::operator QVariant() const

Gibt die Pixmap als „ QVariant “ zurück.

bool QPixmap::operator!() const

Gibt „ true “ zurück, wenn es sich um eine Null-Pixmap handelt; andernfalls wird „ false “ zurückgegeben.

Siehe auch isNull().

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

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

QPixmap &QPixmap::operator=(const QPixmap &pixmap)

Weist dieser Pixmap die angegebene „ pixmap “ zu und gibt eine Referenz auf diese Pixmap zurück.

Siehe auch „ copy()“ und „ QPixmap()“.