QPixmapCache Class
Die Klasse QPixmapCache bietet einen anwendungsweiten Cache für Pixmaps. Mehr...
| Kopfzeile: | #include <QPixmapCache> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Gui)target_link_libraries(mytarget PRIVATE Qt6::Gui) |
| qmake: | QT += gui |
Öffentliche Typen
| class | Key |
Statische öffentliche Mitglieder
| int | cacheLimit() |
| void | clear() |
| bool | find(const QPixmapCache::Key &key, QPixmap *pixmap) |
| bool | find(const QString &key, QPixmap *pixmap) |
| QPixmapCache::Key | insert(const QPixmap &pixmap) |
| bool | insert(const QString &key, const QPixmap &pixmap) |
| void | remove(const QPixmapCache::Key &key) |
| void | remove(const QString &key) |
| void | setCacheLimit(int n) |
Detaillierte Beschreibung
Diese Klasse ist ein Werkzeug zum optimierten Zeichnen mit QPixmap. Sie können damit temporäre Pixmaps speichern, die teuer zu erzeugen sind, ohne mehr Speicherplatz als cacheLimit() zu benötigen. Verwenden Sie insert(), um Pixmaps einzufügen, find(), um sie zu finden, und clear(), um den Cache zu leeren.
QPixmapCache enthält keine Mitgliedsdaten, sondern nur statische Funktionen für den Zugriff auf den globalen Pixmap-Cache. Er erstellt ein internes QCache Objekt für den Cache der Pixmaps.
Der Cache verknüpft eine Pixmap mit einer vom Benutzer bereitgestellten Zeichenkette als Schlüssel oder mit einer QPixmapCache::Key, die der Cache erzeugt. Die Verwendung von QPixmapCache::Key als Schlüssel ist schneller als die Verwendung von Zeichenketten. Die String-API ist sehr praktisch für komplexe Schlüssel, aber die QPixmapCache::Key -API ist sehr effizient und praktisch für eine Eins-zu-Eins-Zuordnung von Objekt zu Pixelkarte - in diesem Fall können Sie die Schlüssel als Elemente eines Objekts speichern.
Wenn zwei Pixmaps mit gleichen Schlüsseln in den Cache eingefügt werden, ersetzt die letzte Pixmap die erste Pixmap im Cache. Dies entspricht dem Verhalten der Klassen QHash und QCache.
Der Cache wird voll, wenn die Gesamtgröße aller Pixmaps im Cache cacheLimit() überschreitet. Die anfängliche Cache-Grenze beträgt 10240 KB (10 MB); Sie können dies ändern, indem Sie setCacheLimit() mit dem gewünschten Wert aufrufen. Eine Pixmap benötigt ungefähr(Breite * Höhe * Tiefe)/8 Bytes Speicher.
Der Qt Quarterly-Artikel Optimizing with QPixmapCache erklärt, wie man QPixmapCache verwendet, um Anwendungen zu beschleunigen, indem man die Ergebnisse des Malens zwischenspeichert.
Hinweis: QPixmapCache ist nur vom Hauptthread der Anwendung aus nutzbar. Der Zugriff von anderen Threads wird ignoriert und führt zu einem Fehler.
Siehe auch QCache und QPixmap.
Dokumentation der Mitgliedsfunktionen
[static] int QPixmapCache::cacheLimit()
Gibt das Cache-Limit (in Kilobytes) zurück.
Das Standard-Cache-Limit beträgt 10240 KB.
Siehe auch setCacheLimit().
[static] void QPixmapCache::clear()
Entfernt alle Pixmaps aus dem Cache.
[static] bool QPixmapCache::find(const QPixmapCache::Key &key, QPixmap *pixmap)
Sucht im Cache nach einer zwischengespeicherten Pixmap, die mit der angegebenen key verknüpft ist. Wenn die Pixelkarte gefunden wird, setzt die Funktion pixmap auf diese Pixelkarte und gibt true zurück; andernfalls lässt sie pixmap in Ruhe und gibt false zurück. Wenn die Pixmap nicht gefunden wird, bedeutet dies, dass key nicht mehr gültig ist und für die nächste Einfügung freigegeben wird.
[static] bool QPixmapCache::find(const QString &key, QPixmap *pixmap)
Sucht im Cache nach einer zwischengespeicherten Pixmap, die mit der angegebenen key verknüpft ist. Wenn die Pixelkarte gefunden wird, setzt die Funktion pixmap auf diese Pixelkarte und gibt true zurück; andernfalls lässt sie pixmap unverändert und gibt false zurück.
Beispiel:
QPixmap pm; if (!QPixmapCache::find("my_big_image", &pm)) { pm.load("bigimage.png"); QPixmapCache::insert("my_big_image", pm); } painter->drawPixmap(0, 0, pm);
[static] QPixmapCache::Key QPixmapCache::insert(const QPixmap &pixmap)
Fügt eine Kopie des angegebenen pixmap in den Cache ein und gibt einen Schlüssel zurück, mit dem es abgerufen werden kann.
Wenn eine Pixelkarte eingefügt wird und der Zwischenspeicher kurz davor ist, sein Limit zu überschreiten, werden Pixelkarten entfernt, bis genügend Platz für die einzufügende Pixelkarte vorhanden ist.
Die ältesten Pixmaps (auf die zuletzt im Cache zugegriffen wurde) werden gelöscht, wenn mehr Platz benötigt wird.
Siehe auch setCacheLimit() und replace().
[static] bool QPixmapCache::insert(const QString &key, const QPixmap &pixmap)
Fügt eine Kopie der Pixmap pixmap, die mit key verknüpft ist, in den Cache ein.
Alle von der Qt-Bibliothek eingefügten Pixmaps haben einen Schlüssel, der mit "$qt" beginnt, daher sollten Ihre eigenen Pixmap-Schlüssel niemals mit "$qt" beginnen.
Wenn eine Pixelkarte eingefügt wird und der Cache sein Limit erreicht, werden Pixelkarten entfernt, bis genügend Platz für die einzufügende Pixelkarte vorhanden ist.
Die ältesten Pixmaps (auf die zuletzt im Cache zugegriffen wurde) werden gelöscht, wenn mehr Platz benötigt wird.
Die Funktion gibt true zurück, wenn das Objekt in den Cache eingefügt wurde; andernfalls gibt sie false zurück.
Siehe auch setCacheLimit().
[static] void QPixmapCache::remove(const QPixmapCache::Key &key)
Entfernt die mit key verknüpfte Pixmap aus dem Cache und gibt den Schlüssel für ein späteres Einfügen frei.
[static] void QPixmapCache::remove(const QString &key)
Entfernt die mit key verbundene Pixmap aus dem Cache.
[static] void QPixmapCache::setCacheLimit(int n)
Setzt das Cache-Limit auf n Kilobytes.
Die Standardeinstellung ist 10240 KB.
Siehe auch cacheLimit().
© 2025 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.
