From d796c9dd933ab96ec83b9a634feedd5d32e1ba3f Mon Sep 17 00:00:00 2001 From: Timothy Pearson Date: Tue, 8 Nov 2011 12:31:36 -0600 Subject: Test conversion to TQt3 from Qt3 8c6fc1f8e35fd264dd01c582ca5e7549b32ab731 --- 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 000000000..d3a56da02 --- /dev/null +++ b/doc/html/qpixmapcache.html @@ -0,0 +1,191 @@ + + + + + +TQPixmapCache Class + + + + + + + +
+ +Home + | +All Classes + | +Main Classes + | +Annotated + | +Grouped Classes + | +Functions +

TQPixmapCache Class Reference

+ +

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

#include <qpixmapcache.h> +

List of all member functions. +

Static Public Members

+ +

Detailed Description

+ + +

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

+ + +

This class is a tool for optimized drawing with TQPixmap. 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, TQRadioButton 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 +TQRadioButton::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 TQPixmapCache is application-global. +

TQPixmapCache contains no member data, only static functions to +access the global pixmap cache. It creates an internal TQCache 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 TQDict and TQCache 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 TQCache documentation for more details about the cache +mechanism. +

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

Member Function Documentation

+

int TQPixmapCache::cacheLimit () [static] +

+Returns the cache limit (in kilobytes). +

The default setting is 1024 kilobytes. +

See also setCacheLimit(). + +

void TQPixmapCache::clear () [static] +

+Removes all pixmaps from the cache. + +

TQPixmap * TQPixmapCache::find ( const TQString & 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 TQString&, TQPixmap&) instead. +

Example: +

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

bool TQPixmapCache::find ( const TQString & key, TQPixmap & 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: +

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

bool TQPixmapCache::insert ( const TQString & key, const TQPixmap & pm ) [static] +

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

All pixmaps inserted by the TQt 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 TQPixmapCache::insert ( const TQString & key, TQPixmap * 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 TQt 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 TQString&, const TQPixmap&) instead. + + +

void TQPixmapCache::remove ( const TQString & key ) [static] +

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

void TQPixmapCache::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 TQt toolkit. +Copyright © 1995-2007 +Trolltech. All Rights Reserved.

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