QPixmap Class

Dokumentation der Mitgliedsfunktionen

QPixmap::QPixmap()

Konstruiert eine Null-Pixmap.

Siehe auch isNull().

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

Konstruiert eine Pixmap aus den angegebenen xpm Daten, die ein gültiges XPM-Bild sein müssen.

Fehler werden stillschweigend ignoriert.

Beachten Sie, dass es möglich ist, die XPM-Variable durch eine ungewöhnliche Deklaration ein wenig 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 (z. B. 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)

Konstruiert eine Pixmap mit den angegebenen Werten width und height. Ist entweder width oder height gleich Null, wird eine Null-Pixmap konstruiert.

Siehe auch isNull().

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

Konstruiert eine Pixmap aus der Datei mit dem angegebenen fileName. Existiert die Datei nicht oder hat sie ein unbekanntes Format, wird die Pixmap zu einer Null-Pixmap.

Der Lader versucht, die Pixmap unter Verwendung der angegebenen format zu lesen. Wenn format nicht angegeben ist (was der Standard ist), sucht der Lader in der Datei nach einem Header, um das Dateiformat zu erraten.

Der Dateiname kann entweder auf eine tatsächliche Datei auf der Festplatte oder auf eine der eingebetteten Ressourcen der Anwendung verweisen. Im Überblick über das Ressourcensystem finden Sie Einzelheiten zum Einbetten von Bildern und anderen Ressourcendateien in die ausführbare Datei der Anwendung.

Wenn das Bild modifiziert werden muss, um in ein Ergebnis mit geringerer Auflösung zu passen (z. B. Konvertierung von 32-Bit in 8-Bit), verwenden Sie die flags, um die Konvertierung zu steuern.

Die Parameter fileName, format und flags werden an load() weitergegeben. Dies 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 Laufzeit gefunden werden.

Siehe auch Reading and Writing Image Files.

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

Dies ist eine überladene Funktion.

Erzeugt eine Pixmap mit der angegebenen size.

QPixmap::QPixmap(const QPixmap &pixmap)

Konstruiert eine Pixmap, die eine Kopie der angegebenen pixmap ist.

Siehe auch copy().

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

Move-konstruiert eine QPixmap-Instanz aus other.

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

[virtual noexcept] QPixmap::~QPixmap()

Zerstört die Pixmap.

qint64 QPixmap::cacheKey() const

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

Der cacheKey() ändert sich, wenn die Pixmap geä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 eine bitweise ODER-Verknüpfung des Arguments Qt::ImageConversionFlags. Die Übergabe von 0 für flags setzt alle Standardoptionen. Gibt true zurück, wenn das Ergebnis ist, dass diese Pixmap nicht null ist.

Siehe auch fromImage().

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

Gibt eine tiefe Kopie der Teilmenge der Pixmap zurück, die durch die angegebene rectangle angegeben ist. Weitere Informationen zu tiefen Kopien finden Sie in der Dokumentation Implizite Datenfreigabe.

Wenn die angegebene rectangle leer ist, wird das gesamte Bild kopiert.

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

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

Dies ist eine überladene Funktion.

Gibt eine tiefe Kopie der Teilmenge der Pixmap zurück, die durch das Rechteck QRect( x, y, width, height) angegeben ist.

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

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

Die Funktion arbeitet, indem sie eine Farbe aus einer der Ecken auswählt und dann Pixel dieser Farbe abschneidet, beginnend an allen Rändern. Wenn clipTight wahr ist (Standardeinstellung), ist die Maske gerade groß genug, um die Pixel abzudecken; andernfalls ist die Maske größer als die Datenpixel.

Die Maske muss nicht perfekt sein, aber sie sollte vernünftig sein, so dass Sie Dinge wie das Folgende tun können:

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

Diese Funktion ist langsam, da sie eine Konvertierung in/aus QImage und nicht-triviale Berechnungen beinhaltet.

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

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

Erzeugt eine Maske für diese Pixmap auf der Grundlage der angegebenen maskColor und gibt sie zurück. Wenn mode Qt::MaskInColor ist, sind alle Pixel, die der maskColor entsprechen, transparent. Wenn mode gleich Qt::MaskOutColor ist, werden alle Pixel, die der maskColor entsprechen, undurchsichtig sein.

Diese Funktion ist langsam, da sie eine Konvertierung nach/von QImage erfordert.

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(), QColormap::depth(), und Pixmap Information.

int QPixmap::depth() const

Gibt die Tiefe der Pixmap zurück.

Die Pixmap-Tiefe wird auch Bits pro Pixel (bpp) oder Bitebenen einer Pixmap genannt. Eine Null-Pixmap hat die Tiefe 0.

Siehe auch defaultDepth() und Pixmap Information.

void QPixmap::detach()

Löst die Pixmap von den gemeinsamen Pixmap-Daten.

Eine Pixmap wird von Qt automatisch abgetrennt, wenn ihr Inhalt geändert werden soll. Dies geschieht in fast allen QPixmap Mitgliedsfunktionen, die die Pixmap verändern (fill(), fromImage(), load(), usw.), und in QPainter::begin() auf einer Pixmap.

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

Die Funktion detach() kehrt sofort zurück, wenn nur ein einziger Verweis 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 Pixmap-Größe für die Berechnung der Größe der Benutzeroberfläche verwendet wird.

Der Rückgabewert ist äquivalent zu 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. Dies ist das Verhältnis zwischen Gerätepixeln und geräteunabhängigen Pixeln.

Verwenden Sie diese Funktion bei der Berechnung der Layout-Geometrie auf der Grundlage der Pixmap-Größe: 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 der angegebenen color.

Die Wirkung dieser Funktion ist undefiniert, wenn die Pixmap gerade bemalt wird.

Siehe auch Pixmap Transformations.

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

Konvertiert die angegebene image in eine Pixmap unter Verwendung der angegebenen flags zur Steuerung der Konvertierung. Das Argument flags ist ein bitweises ODER des Arguments Qt::ImageConversionFlags. Die Übergabe von 0 für flags setzt alle Standardoptionen.

Bei monochromen und 8-Bit-Bildern wird das Bild zunächst in eine 32-Bit-Pixmap umgewandelt und dann mit den Farben aus der Farbtabelle gefüllt. Wenn dieser Vorgang zu teuer ist, 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)

Dies ist eine überladene Funktion.

Konvertiert die angegebene image in eine Pixmap, wenn möglich ohne Kopieren.

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

Erstellt ein QPixmap aus einem Bild, das direkt von einem imageReader gelesen wurde. Das Argument flags ist ein bitweises ODER des Qt::ImageConversionFlags. Die Übergabe von 0 für flags setzt alle Standardoptionen.

Auf einigen Systemen kann das direkte Einlesen eines Bildes in QPixmap weniger Speicher verbrauchen 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 einen Alphakanal oder eine Maske hat, andernfalls false.

Siehe auch hasAlphaChannel() und mask().

bool QPixmap::hasAlphaChannel() const

Gibt true zurück, wenn das Pixmap ein Format hat, das den Alphakanal respektiert, andernfalls false.

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 null Breite, null Höhe und keinen Inhalt. Sie können in einer Null-Pixmap nicht zeichnen.

bool QPixmap::isQBitmap() const

Gibt true zurück, wenn es sich um 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 der angegebenen fileName. Gibt true zurück, wenn die Pixmap erfolgreich geladen wurde; andernfalls wird die Pixmap ungültig und false zurückgegeben.

Der Lader versucht, die Pixmap unter Verwendung der angegebenen format zu lesen. Wenn format nicht angegeben ist (was die Voreinstellung ist), sucht der Lader in der Datei nach einem Header, um das Dateiformat zu erraten.

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

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

Beachten Sie, dass QPixmaps automatisch zu QPixmapCache hinzugefügt werden, wenn sie im Haupt-Thread aus einer Datei geladen werden; der verwendete Schlüssel ist intern und kann nicht erworben 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 len ersten Bytes der angegebenen Binärdatei data. Gibt true zurück, wenn die Pixmap erfolgreich geladen wurde; andernfalls wird die Pixmap ungültig und false zurückgegeben.

Der Lader versucht, die Pixmap unter Verwendung der angegebenen format zu lesen. Wenn format nicht angegeben ist (was der Standard ist), sucht der Lader in der Datei nach einem Header, um das Dateiformat zu erraten.

Wenn die Daten modifiziert werden müssen, um in ein Ergebnis mit geringerer Auflösung zu passen (z. B. Konvertierung von 32-Bit in 8-Bit), verwenden Sie 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)

Dies ist eine überladene Funktion.

Lädt eine Pixmap aus der Binärdatei data unter Verwendung der angegebenen format und der Konvertierung 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 der angegebenen Bilddatei format und des Faktors quality. Gibt bei Erfolg true zurück, andernfalls false.

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 gleich nullptr ist, wird ein Bildformat aus dem Suffix von fileName gewählt.

Siehe auch Reading and Writing Image Files.

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

Dies ist eine überladene Funktion.

Diese Funktion schreibt ein QPixmap in die angegebene device unter Verwendung der angegebenen Bilddatei format und des Faktors quality. Dies kann z.B. 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 size unter Verwendung des Seitenverhältnisses und der Transformationsmodi, die durch aspectRatioMode und transformMode festgelegt sind.

• Wenn aspectRatioMode gleich Qt::IgnoreAspectRatio ist, wird die Pixmap auf size skaliert.
• Wenn aspectRatioMode gleich Qt::KeepAspectRatio ist, wird die Pixmap auf ein möglichst großes Rechteck innerhalb von size skaliert, wobei das Seitenverhältnis beibehalten wird.
• Wenn aspectRatioMode gleich Qt::KeepAspectRatioByExpanding ist, wird die Pixmap auf ein Rechteck skaliert, das so klein wie möglich außerhalb von size ist, wobei das Seitenverhältnis beibehalten wird.

Wenn die angegebene size leer ist, gibt diese Funktion eine Null-Pixmap zurück.

In manchen Fällen kann es vorteilhafter sein, die Pixmap in einen Maler mit einer eingestellten Skalierung zu zeichnen, anstatt die Pixmap zu skalieren. Dies ist der Fall, wenn der Painter zum Beispiel 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

Dies ist eine überladene Funktion.

Gibt eine Kopie der Pixmap zurück, die auf ein Rechteck mit den angegebenen width und height entsprechend den angegebenen aspectRatioMode und transformMode skaliert ist.

Wenn entweder width oder height Null oder negativ ist, gibt diese Funktion eine Null-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 unter Verwendung der angegebenen Transformation mode auf das angegebene height skaliert. Die Breite der Pixmap wird automatisch berechnet, so dass das Seitenverhältnis der Pixmap erhalten bleibt.

Wenn height 0 oder negativ ist, wird eine Null-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 unter Verwendung der angegebenen Transformation mode auf das angegebene width skaliert. Die Höhe der Pixmap wird automatisch berechnet, so dass das Seitenverhältnis der Pixmap erhalten bleibt.

Wenn width 0 oder negativ ist, wird eine Null-Pixmap zurückgegeben.

Siehe auch isNull() und Pixmap Transformations.

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

Scrollt den Bereich rect dieser Pixmap um (dx, dy). Der freigelegte Bereich bleibt unverändert. Sie können optional einen Zeiger auf ein leeres QRegion übergeben, um den Bereich zu erhalten, der durch den Bildlaufvorgang exposed wird.

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

Solange ein Maler auf der Pixmap aktiv ist, können Sie nicht scrollen.

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. Dies ist das Verhältnis zwischen Bildpixeln und geräteunabhängigen Pixeln.

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

QPainter, die auf der Pixmap geöffnet werden, werden skaliert. Zum Beispiel wird das Malen auf einem 200x200 Bild mit einem Verhältnis von 2.0 zu einer effektiven (geräteunabhängigen) Malfläche von 100x100 führen.

Code-Pfade in Qt, die die Layout-Geometrie basierend auf der Pixmap-Größe berechnen, berücksichtigen das Verhältnis: QSize layoutSize = pixmap.size() / pixmap.devicePixelRatio() Der Nettoeffekt davon ist, dass die Pixmap als High-DPI-Pixmap 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)

Setzt eine Bitmap-Maske.

Diese Funktion verschmilzt die mask mit dem Alphakanal der Pixmap. Ein Pixelwert von 1 in der Maske bedeutet, dass das Pixel der Pixmap unverändert ist; ein Wert von 0 bedeutet, dass das Pixel transparent ist. Die Maske muss die gleiche Größe wie die Pixelkarte haben.

Das Setzen einer Null-Maske setzt die Maske zurück und lässt die zuvor transparenten Pixel schwarz. Die Wirkung dieser Funktion ist undefiniert, wenn die Pixmap aufgemalt 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 mit other aus. Dieser Vorgang ist sehr schnell und schlägt nie fehl.

QImage QPixmap::toImage() const

Konvertiert die Pixmap in ein QImage. Schlägt die Konvertierung fehl, wird ein Null-Bild zurückgegeben.

Wenn die Pixmap eine Tiefe von 1 Bit hat, ist das zurückgegebene Bild auch nur 1 Bit tief. Bilder mit mehr Bits werden in einem Format zurückgegeben, das dem zugrunde liegenden System am nächsten kommt. Normalerweise ist dies QImage::Format_ARGB32_Premultiplied für Pixmaps mit Alpha und QImage::Format_RGB32 oder QImage::Format_RGB16 für Pixmaps ohne Alpha.

Beachten Sie, dass Alphamasken auf monochromen Bildern im Moment noch 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 unter Verwendung der angegebenen Transformation transform und Transformation mode transformiert wurde. Die ursprüngliche Pixmap wird nicht verändert.

Die Transformation transform wird intern angepasst, um ungewollte Verschiebungen zu kompensieren; 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ächliche Matrix abzurufen, die für die Transformation der Pixmap verwendet wird.

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 aktuelle Matrix zurück, die für die Transformation einer Pixmap mit den angegebenen width, height und matrix verwendet wird.

Bei der Transformation einer Pixmap mit der Funktion transformed() wird die Transformationsmatrix intern angepasst, um unerwünschte Verschiebungen zu kompensieren, d. h. transformed() gibt die kleinste Pixmap zurück, die alle transformierten Punkte der ursprünglichen Pixmap enthält. Diese Funktion gibt die geänderte Matrix zurück, die Punkte aus der ursprünglichen Pixmap korrekt auf 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.

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

Verschieben - weist other dieser QPixmap Instanz zu.

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

Weist die angegebene pixmap dieser Pixmap zu und gibt einen Verweis auf diese Pixmap zurück.

Siehe auch copy() und QPixmap().