From bd0f3345a938b35ce6a12f6150373b0955b8dd12 Mon Sep 17 00:00:00 2001 From: Timothy Pearson Date: Sun, 10 Jul 2011 15:24:15 -0500 Subject: Add Qt3 development HEAD version --- doc/html/qpixmapcache.html | 191 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 191 insertions(+) create mode 100644 doc/html/qpixmapcache.html (limited to 'doc/html/qpixmapcache.html') diff --git a/doc/html/qpixmapcache.html b/doc/html/qpixmapcache.html new file mode 100644 index 0000000..190294e --- /dev/null +++ b/doc/html/qpixmapcache.html @@ -0,0 +1,191 @@ + + + + + +QPixmapCache Class + + + + + + + +
+ +Home + | +All Classes + | +Main Classes + | +Annotated + | +Grouped Classes + | +Functions +

QPixmapCache Class Reference

+ +

The QPixmapCache class provides an application-global cache for +pixmaps. +More... +

#include <qpixmapcache.h> +

List of all member functions. +

Static Public Members

+ +

Detailed Description

+ + +

The QPixmapCache class provides an application-global cache for +pixmaps. +

+ + +

This class is a tool for optimized drawing with QPixmap. You can +use it to store temporary pixmaps that are expensive to generate +without using more storage space than cacheLimit(). Use insert() +to insert pixmaps, find() to find them and clear() to empty the +cache. +

For example, QRadioButton has a non-trivial visual representation +so we don't want to regenerate a pixmap whenever a radio button is +displayed or changes state. In the function +QRadioButton::drawButton(), we do not draw the radio button +directly. Instead, we first check the global pixmap cache for a +pixmap with the key "$qt_radio_nnn_", where nnn is a numerical +value that specifies the the radio button state. If a pixmap is +found, we bitBlt() it onto the widget and return. Otherwise, we +create a new pixmap, draw the radio button in the pixmap, and +finally insert the pixmap in the global pixmap cache, using the +key above. The bitBlt() is ten times faster than drawing the +radio button. All radio buttons in the program share the cached +pixmap since QPixmapCache is application-global. +

QPixmapCache contains no member data, only static functions to +access the global pixmap cache. It creates an internal QCache for +caching the pixmaps. +

The cache associates a pixmap with a string (key). If two pixmaps +are inserted into the cache using equal keys, then the last pixmap +will hide the first pixmap. The QDict and QCache classes do +exactly the same. +

The cache becomes full when the total size of all pixmaps in the +cache exceeds cacheLimit(). The initial cache limit is 1024 KByte +(1 MByte); it is changed with setCacheLimit(). A pixmap takes +roughly width*height*depth/8 bytes of memory. +

See the QCache documentation for more details about the cache +mechanism. +

See also Environment Classes, Graphics Classes, and Image Processing Classes. + +

Member Function Documentation

+

int QPixmapCache::cacheLimit () [static] +

+Returns the cache limit (in kilobytes). +

The default setting is 1024 kilobytes. +

See also setCacheLimit(). + +

void QPixmapCache::clear () [static] +

+Removes all pixmaps from the cache. + +

QPixmap * QPixmapCache::find ( const QString & key ) [static] +

+Returns the pixmap associated with the key in the cache, or +null if there is no such pixmap. +

Warning: If valid, you should copy the pixmap immediately (this is +fast). Subsequent insertions into the cache could cause the +pointer to become invalid. For this reason, we recommend you use +find(const QString&, QPixmap&) instead. +

Example: +

+        QPixmap* pp;
+        QPixmap p;
+        if ( (pp=QPixmapCache::find("my_big_image", pm)) ) {
+            p = *pp;
+        } else {
+            p.load("bigimage.png");
+            QPixmapCache::insert("my_big_image", new QPixmap(p));
+        }
+        painter->drawPixmap(0, 0, p);
+
+ + +

bool QPixmapCache::find ( const QString & key, QPixmap & pm ) [static] +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Looks for a cached pixmap associated with the key in the cache. +If a pixmap is found, the function sets pm to that pixmap and +returns TRUE; otherwise leaves pm alone and returns FALSE. +

Example: +

+        QPixmap p;
+        if ( !QPixmapCache::find("my_big_image", pm) ) {
+            pm.load("bigimage.png");
+            QPixmapCache::insert("my_big_image", pm);
+        }
+        painter->drawPixmap(0, 0, p);
+
+ + +

bool QPixmapCache::insert ( const QString & key, const QPixmap & pm ) [static] +

+Inserts a copy of the pixmap pm associated with the key into +the cache. +

All pixmaps inserted by the Qt library have a key starting with +"$qt", so your own pixmap keys should never begin "$qt". +

When a pixmap is inserted and the cache is about to exceed its +limit, it removes pixmaps until there is enough room for the +pixmap to be inserted. +

The oldest pixmaps (least recently accessed in the cache) are +deleted when more space is needed. +

See also setCacheLimit(). + +

bool QPixmapCache::insert ( const QString & key, QPixmap * pm ) [static] +

+This function is obsolete. It is provided to keep old source working. We strongly advise against using it in new code. +

Inserts the pixmap pm associated with key into the cache. +Returns TRUE if successful, or FALSE if the pixmap is too big for the cache. +

+Note: pm must be allocated on the heap (using new). +

If this function returns FALSE, you must delete pm yourself. +

If this function returns TRUE, do not use pm afterwards or +keep references to it because any other insertions into the cache, +whether from anywhere in the application or within Qt itself, could cause +the pixmap to be discarded from the cache and the pointer to +become invalid. +

Due to these dangers, we strongly recommend that you use +insert(const QString&, const QPixmap&) instead. + + +

void QPixmapCache::remove ( const QString & key ) [static] +

+Removes the pixmap associated with key from the cache. + +

void QPixmapCache::setCacheLimit ( int n ) [static] +

+Sets the cache limit to n kilobytes. +

The default setting is 1024 kilobytes. +

See also cacheLimit(). + + +

+This file is part of the Qt toolkit. +Copyright © 1995-2007 +Trolltech. All Rights Reserved.

+ +
Copyright © 2007 +TrolltechTrademarks +
Qt 3.3.8
+
+ -- cgit v1.2.1