QPixmapCache Class
La classe QPixmapCache fournit un cache de pixmaps à l'échelle de l'application. En savoir plus...
| 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 permettant d’optimiser le dessin avec QPixmap. Vous pouvez l’utiliser pour stocker des pixmaps temporaires dont la génération est coûteuse, sans utiliser plus d’espace de stockage qu’ cacheLimit(). Utilisez insert() pour insérer des pixmaps, find() pour les rechercher et clear() pour vider le cache.
QPixmapCache ne contient aucune donnée de membre, seulement des fonctions statiques permettant d’accéder au cache global de pixmaps. Il crée un objet interne de type ` QCache ` pour mettre en cache les pixmaps.
Le cache associe une image bitmap à une chaîne fournie par l’utilisateur en tant que clé, ou à un objet ` QPixmapCache::Key ` généré par le cache. L’utilisation d’objets ` QPixmapCache::Key ` comme clés est plus rapide que l’utilisation de chaînes. L’API de chaînes de caractères est très pratique pour les clés complexes, mais l’API d’ QPixmapCache::Key s s’avère très efficace et pratique pour un mappage un-à-un entre objets et pixmaps — 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 dans le cache. Ce comportement est conforme à celui des classes ` QHash ` et ` QCache `.
Le cache est plein lorsque la taille totale de toutes les images de type pixmap qu’il contient dépasse la valeur définie par ` cacheLimit()`. La limite initiale du cache est de 10 240 Ko (10 Mo) ; vous pouvez la modifier en appelant la fonction ` setCacheLimit()` avec la valeur souhaitée. Une image de type pixmap occupe environ (largeur * hauteur * profondeur)/8 octets de mémoire.
L’article du Qt Quarterly intitulé « Optimizing with QPixmapCache » explique comment utiliser QPixmapCache pour accélérer les applications en mettant en cache les résultats du traçage.
Remarque : QPixmapCache n'est utilisable qu'à partir du thread principal de l'application. Tout accès depuis d'autres threads sera ignoré et renverra un échec.
Voir également QCache et QPixmap.
Documentation sur les fonctions membres
[static] int QPixmapCache::cacheLimit()
Renvoie la limite du cache (en kilo-octets).
La limite par défaut du cache est de 10 240 Ko.
Voir aussi setCacheLimit().
[static] void QPixmapCache::clear()
Supprime toutes les images de la mémoire cache.
[static] bool QPixmapCache::find(const QPixmapCache::Key &key, QPixmap *pixmap)
Recherche dans le cache une image pixmap mise en cache associée à l'key. Si l'image pixmap est trouvée, la fonction attribue pixmap à cette image et renvoie true; dans le cas contraire, elle laisse pixmap inchangé et renvoie false. Si l'image pixmap n'est pas trouvée, cela signifie que l'key n'est plus valide ; elle sera donc libérée pour permettre une nouvelle insertion.
[static] bool QPixmapCache::find(const QString &key, QPixmap *pixmap)
Recherche dans le cache une image (pixmap) mise en cache associée à l'key. Si l'image est trouvée, la fonction attribue pixmap à cette image et renvoie true; dans le cas contraire, elle ne modifie pas pixmap 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'pixmap on fournie dans le cache et renvoie une clé permettant de la récupérer.
Lorsqu’un pixmap est inséré et que le cache est sur le point d’atteindre sa limite, celui-ci supprime des pixmaps jusqu’à ce qu’il y ait suffisamment d’espace pour insérer le pixmap.
Les pixmaps les plus anciens (ceux qui n’ont pas été consultés récemment dans le cache) sont supprimés lorsque davantage d’espace est nécessaire.
Voir aussi setCacheLimit().
[static] bool QPixmapCache::insert(const QString &key, const QPixmap &pixmap)
Insère dans le cache une copie de l'image bitmap pixmap associée à l'key.
Toutes les images pixmap insérées par la bibliothèque Qt ont une clé commençant par « $qt » ; vos propres clés d'images pixmap ne doivent donc jamais commencer par « $qt ».
Lorsqu'une image bitmap est insérée et que le cache est sur le point d'atteindre sa limite, celui-ci supprime des images bitmap jusqu'à ce qu'il y ait suffisamment d'espace pour l'insertion de la nouvelle image.
Les pixmaps les plus anciens (ceux auxquels on a accédé le moins récemment dans le cache) sont supprimés lorsque davantage d’espace est nécessaire.
La fonction renvoie ` true ` si l'objet a été inséré dans le cache ; sinon, elle renvoie ` false`.
Voir également setCacheLimit().
[static] void QPixmapCache::remove(const QPixmapCache::Key &key)
Supprime de la mémoire cache la carte d'images associée à key et libère la clé en vue d'une insertion ultérieure.
[static] void QPixmapCache::remove(const QString &key)
Supprime du cache la carte de pixels associée à key.
[static] void QPixmapCache::setCacheLimit(int n)
Définit la limite du cache à n k.
La valeur par défaut est 10240 Ko.
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.
