QPixmapCache Class
La classe QPixmapCache fournit un cache pour les pixmaps à l'échelle de l'application. Plus d'informations...
| En-tête : | #include <QPixmapCache> |
| CMake : | find_package(Qt6 REQUIRED COMPONENTS Gui)target_link_libraries(mytarget PRIVATE Qt6::Gui) |
| qmake : | QT += gui |
Types publics
| class | Key |
Membres publics statiques
| 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) |
Description détaillée
Cette classe est un outil pour optimiser le dessin avec QPixmap. Vous pouvez l'utiliser pour stocker des pixmaps temporaires qui sont coûteux à générer sans utiliser plus d'espace de stockage que cacheLimit(). Utilisez insert() pour insérer des pixmaps, find() pour les retrouver et clear() pour vider le cache.
QPixmapCache ne contient aucune donnée membre, mais uniquement des fonctions statiques permettant d'accéder au cache global de pixmaps. Il crée un objet interne QCache pour la mise en cache des images.
Le cache associe une pixmap à une chaîne de caractères fournie par l'utilisateur comme clé, ou à une adresse QPixmapCache::Key générée par le cache. L'utilisation de QPixmapCache::Key pour les clés est plus rapide que l'utilisation de chaînes de caractères. L'API des chaînes est très pratique pour les clés complexes, mais l'API QPixmapCache::Key sera très efficace et pratique pour une correspondance objet-pixmap univoque - dans ce cas, vous pouvez stocker les clés en tant que membres d'un objet.
Si deux pixmaps sont insérés dans le cache avec des clés identiques, le dernier pixmap remplacera le premier pixmap dans le cache. Ceci suit le comportement des classes QHash et QCache.
Le cache est plein lorsque la taille totale de toutes les images dans le cache dépasse cacheLimit(). La limite initiale du cache est de 10240 Ko (10 Mo) ; vous pouvez la modifier en appelant setCacheLimit() avec la valeur requise. Une pixmap occupe environ(largeur * hauteur * profondeur)/8 octets de mémoire.
L'article de Qt Quarterly Optimizing with QPixmapCache explique comment utiliser QPixmapCache pour accélérer les applications en mettant en cache les résultats de la peinture.
Remarque : QPixmapCache n'est utilisable qu'à partir du thread principal de l'application. L'accès à partir d'autres threads sera ignoré et retournera un échec.
Voir également QCache et QPixmap.
Documentation des fonctions membres
[static] int QPixmapCache::cacheLimit()
Renvoie la limite du cache (en kilo-octets).
La limite de cache par défaut est de 10240 Ko.
Voir aussi setCacheLimit().
[static] void QPixmapCache::clear()
Supprime toutes les pixmaps du cache.
[static] bool QPixmapCache::find(const QPixmapCache::Key &key, QPixmap *pixmap)
Recherche dans le cache un pixmap associé à l'adresse key. Si la pixmap est trouvée, la fonction affecte pixmap à cette pixmap et renvoie true; sinon, elle laisse pixmap en l'état et renvoie false. Si la pixmap n'est pas trouvée, cela signifie que le site key n'est plus valide et qu'il sera libéré pour la prochaine insertion.
[static] bool QPixmapCache::find(const QString &key, QPixmap *pixmap)
Recherche dans le cache un pixmap associé à l'adresse key. Si la pixmap est trouvée, la fonction attribue la valeur pixmap à cette pixmap et renvoie true; sinon, elle laisse pixmap tranquille et renvoie false.
Exemple :
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)
Insère une copie de l'image donnée pixmap dans le cache et renvoie une clé qui peut être utilisée pour la récupérer.
Lorsqu'une pixmap est insérée et que le cache est sur le point de dépasser sa limite, il supprime des pixmaps jusqu'à ce qu'il y ait suffisamment de place pour insérer la pixmap.
Les pixmaps les plus anciennes (les moins récemment accédées dans le cache) sont supprimées lorsqu'il y a besoin de plus d'espace.
Voir aussi setCacheLimit().
[static] bool QPixmapCache::insert(const QString &key, const QPixmap &pixmap)
Insère une copie de la pixmap pixmap associée à key dans le cache.
Toutes les pixmaps insérées par la bibliothèque Qt ont une clé commençant par "$qt", donc vos propres clés de pixmap ne doivent jamais commencer par "$qt".
Lorsqu'une pixmap est insérée et que le cache est sur le point de dépasser sa limite, il supprime des pixmaps jusqu'à ce qu'il y ait suffisamment de place pour insérer la pixmap.
Les pixmaps les plus anciennes (les moins récemment accédées dans le cache) sont supprimées lorsqu'il y a besoin de plus d'espace.
La fonction renvoie true si l'objet a été inséré dans le cache ; sinon, elle renvoie false.
Voir aussi setCacheLimit().
[static] void QPixmapCache::remove(const QPixmapCache::Key &key)
Supprime du cache la pixmap associée à key et libère la clé pour une insertion ultérieure.
[static] void QPixmapCache::remove(const QString &key)
Supprime du cache la pixmap associée à key.
[static] void QPixmapCache::setCacheLimit(int n)
Fixe la limite du cache à n kilo-octets.
La valeur par défaut est de 10240 KB.
Voir aussi cacheLimit().
© 2026 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.
