QPMCache Class Reference

Inheritance diagram for QPMCache:

Public Functions
QList< QPair< QString, QPixmap > >	allPixmaps () const
void	clear ()
QPixmapCache::Key	createKey ()
bool	flushDetachedPixmaps (bool nt)
bool	insert (const QString &key, const QPixmap &pixmap, int cost)
QPixmapCache::Key	insert (const QPixmap &pixmap, int cost)
QPixmap *	object (const QString &key) const
QPixmap *	object (const QPixmapCache::Key &key) const
	QPMCache ()
void	releaseKey (const QPixmapCache::Key &key)
bool	remove (const QString &key)
bool	remove (const QPixmapCache::Key &key)
bool	replace (const QPixmapCache::Key &key, const QPixmap &pixmap, int cost)
void	resizeKeyArray (int size)
void	timerEvent (QTimerEvent *)
	This event handler can be reimplemented in a subclass to receive timer events for the object. More...
	~QPMCache ()
Public Functions inherited from QObject
bool	blockSignals (bool b)
	If block is true, signals emitted by this object are blocked (i.e., emitting a signal will not invoke anything connected to it). More...
const QObjectList &	children () const
	Returns a list of child objects. More...
bool	connect (const QObject *sender, const char *signal, const char *member, Qt::ConnectionType type=Qt::AutoConnection) const
bool	disconnect (const char *signal=0, const QObject *receiver=0, const char *member=0)
bool	disconnect (const QObject *receiver, const char *member=0)
void	dumpObjectInfo ()
	Dumps information about signal connections, etc. More...
void	dumpObjectTree ()
	Dumps a tree of children to the debug output. More...
QList< QByteArray >	dynamicPropertyNames () const
	Returns the names of all properties that were dynamically added to the object using setProperty(). More...
virtual bool	event (QEvent *)
	This virtual function receives events to an object and should return true if the event e was recognized and processed. More...
virtual bool	eventFilter (QObject *, QEvent *)
	Filters events if this object has been installed as an event filter for the watched object. More...
template<typename T >
T	findChild (const QString &aName=QString()) const
	Returns the child of this object that can be cast into type T and that is called name, or 0 if there is no such object. More...
template<typename T >
QList< T >	findChildren (const QString &aName=QString()) const
	Returns all children of this object with the given name that can be cast to type T, or an empty list if there are no such objects. More...
template<typename T >
QList< T >	findChildren (const QRegExp &re) const
bool	inherits (const char *classname) const
	Returns true if this object is an instance of a class that inherits className or a QObject subclass that inherits className; otherwise returns false. More...
void	installEventFilter (QObject *)
	Installs an event filter filterObj on this object. More...
bool	isWidgetType () const
	Returns true if the object is a widget; otherwise returns false. More...
void	killTimer (int id)
	Kills the timer with timer identifier, id. More...
virtual const QMetaObject *	metaObject () const
	Returns a pointer to the meta-object of this object. More...
void	moveToThread (QThread *thread)
	Changes the thread affinity for this object and its children. More...
QString	objectName () const
QObject *	parent () const
	Returns a pointer to the parent object. More...
QVariant	property (const char *name) const
	Returns the value of the object's name property. More...
Q_INVOKABLE	QObject (QObject *parent=0)
	Constructs an object with parent object parent. More...
void	removeEventFilter (QObject *)
	Removes an event filter object obj from this object. More...
void	setObjectName (const QString &name)
void	setParent (QObject *)
	Makes the object a child of parent. More...
bool	setProperty (const char *name, const QVariant &value)
	Sets the value of the object's name property to value. More...
void	setUserData (uint id, QObjectUserData *data)
bool	signalsBlocked () const
	Returns true if signals are blocked; otherwise returns false. More...
int	startTimer (int interval)
	Starts a timer and returns a timer identifier, or returns zero if it could not start a timer. More...
QThread *	thread () const
	Returns the thread in which the object lives. More...
QObjectUserData *	userData (uint id) const
virtual	~QObject ()
	Destroys the object, deleting all its child objects. More...
Public Functions inherited from QCache< QPixmapCache::Key, QPixmapCacheEntry >
void	clear ()
bool	contains (const QPixmapCache::Key &key) const
int	count () const
bool	insert (const QPixmapCache::Key &key, QPixmapCacheEntry *object, int cost=1)
bool	isEmpty () const
QList< QPixmapCache::Key >	keys () const
int	maxCost () const
QPixmapCacheEntry *	object (const QPixmapCache::Key &key) const
QPixmapCacheEntry *	operator[] (const QPixmapCache::Key &key) const
	QCache (int maxCost=100)
bool	remove (const QPixmapCache::Key &key)
void	setMaxCost (int m)
int	size () const
QPixmapCacheEntry *	take (const QPixmapCache::Key &key)
int	totalCost () const
	~QCache ()

Static Public Functions
static QPixmapCache::KeyData *	get (const QPixmapCache::Key &key)
static QPixmapCache::KeyData *	getKeyData (QPixmapCache::Key *key)
Static Public Functions inherited from QObject
static bool	connect (const QObject *sender, const char *signal, const QObject *receiver, const char *member, Qt::ConnectionType=Qt::AutoConnection)
	Creates a connection of the given type from the signal in the sender object to the method in the receiver object. More...
static bool	connect (const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &method, Qt::ConnectionType type=Qt::AutoConnection)
static bool	disconnect (const QObject *sender, const char *signal, const QObject *receiver, const char *member)
	Disconnects signal in object sender from method in object receiver. More...
static bool	disconnect (const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &member)
static uint	registerUserData ()
static QString	tr (const char *sourceText, const char *comment=0, int n=-1)
static QString	trUtf8 (const char *sourceText, const char *comment=0, int n=-1)

Private Types
enum	{ soon_time = 10000, flush_time = 30000 }

Properties
QHash< QString, QPixmapCache::Key >	cacheKeys
int	freeKey
int *	keyArray
int	keyArraySize
int	ps
bool	t
int	theid

Additional Inherited Members
Public Slots inherited from QObject
void	deleteLater ()
	Schedules this object for deletion. More...
Signals inherited from QObject
void	destroyed (QObject *=0)
	This signal is emitted immediately before the object obj is destroyed, and can not be blocked. More...
Static Public Variables inherited from QObject
static const QMetaObject	staticMetaObject
	This variable stores the meta-object for the class. More...
Protected Functions inherited from QObject
virtual void	childEvent (QChildEvent *)
	This event handler can be reimplemented in a subclass to receive child events. More...
virtual void	connectNotify (const char *signal)
	This virtual function is called when something has been connected to signal in this object. More...
virtual void	customEvent (QEvent *)
	This event handler can be reimplemented in a subclass to receive custom events. More...
virtual void	disconnectNotify (const char *signal)
	This virtual function is called when something has been disconnected from signal in this object. More...
	QObject (QObjectPrivate &dd, QObject *parent=0)
int	receivers (const char *signal) const
	Returns the number of receivers connected to the signal. More...
QObject *	sender () const
	Returns a pointer to the object that sent the signal, if called in a slot activated by a signal; otherwise it returns 0. More...
int	senderSignalIndex () const
Protected Variables inherited from QObject
QScopedPointer< QObjectData >	d_ptr
Static Protected Variables inherited from QObject
static const QMetaObject	staticQtMetaObject
Related Functions inherited from QObject
T	qFindChildqFindChildren (const QObject *obj, const QString &name)()
QList< T >	qFindChildrenqFindChildren (const QObject *obj, const QString &name)()
QList< T >	qFindChildrenqFindChildren (const QObject *obj, const QRegExp &regExp)()
T *	qobject_cast (QObject *object)
	QObjectList
void *	qt_find_obj_child (QObject *parent, const char *type, const QString &name)
	Returns a pointer to the object named name that inherits type and with a given parent. More...

Detailed Description

Definition at line 180 of file qpixmapcache.cpp.

Enumerations

anonymous enum

anonymous enum

private

Enumerator
soon_time
flush_time

Definition at line 211 of file qpixmapcache.cpp.

{ soon_time = 10000, flush_time = 30000 };

Constructors and Destructors

QPMCache()

QPMCache::QPMCache

(

)

Definition at line 230 of file qpixmapcache.cpp.

    : QObject(0),
      QCache<QPixmapCache::Key, QPixmapCacheEntry>(cache_limit * 1024),
      keyArray(0), theid(0), ps(0), keyArraySize(0), freeKey(0), t(false)
{
}

~QPMCache()

QPMCache::~QPMCache

(

)

Definition at line 236 of file qpixmapcache.cpp.

{
    clear();
    free(keyArray);
}

Functions

allPixmaps()

QList< QPair< QString, QPixmap > > QPMCache::allPixmaps

(

)

const

Definition at line 451 of file qpixmapcache.cpp.

{
    QList< QPair<QString,QPixmap> > r;
    QHash<QString, QPixmapCache::Key>::const_iterator it = cacheKeys.begin();
    while (it != cacheKeys.end()) {
        QPixmap *ptr = QCache<QPixmapCache::Key, QPixmapCacheEntry>::object(it.value());
        if (ptr)
            r.append(QPair<QString,QPixmap>(it.key(),*ptr));
        ++it;
    }
    return r;
}

clear()

void QPMCache::clear

(

)

Definition at line 431 of file qpixmapcache.cpp.

Referenced by ~QPMCache().

{
    free(keyArray);
    keyArray = 0;
    freeKey = 0;
    keyArraySize = 0;
    //Mark all keys as invalid
    QList<QPixmapCache::Key> keys = QCache<QPixmapCache::Key, QPixmapCacheEntry>::keys();
    for (int i = 0; i < keys.size(); ++i)
        keys.at(i).d->isValid = false;
    QCache<QPixmapCache::Key, QPixmapCacheEntry>::clear();
}

createKey()

QPixmapCache::Key QPMCache::createKey

(

)

Definition at line 408 of file qpixmapcache.cpp.

Referenced by insert(), and replace().

{
    if (freeKey == keyArraySize)
        resizeKeyArray(keyArraySize ? keyArraySize << 1 : 2);
    int id = freeKey;
    freeKey = keyArray[id];
    QPixmapCache::Key key;
    QPixmapCache::KeyData *d = QPMCache::getKeyData(&key);
    d->key = ++id;
    return key;
}

flushDetachedPixmaps()

bool QPMCache::flushDetachedPixmaps

(

bool

nt

)

Definition at line 256 of file qpixmapcache.cpp.

Referenced by timerEvent().

{
    int mc = maxCost();
    setMaxCost(nt ? totalCost() * 3 / 4 : totalCost() -1);
    setMaxCost(mc);
    ps = totalCost();

    bool any = false;
    QHash<QString, QPixmapCache::Key>::iterator it = cacheKeys.begin();
    while (it != cacheKeys.end()) {
        if (!contains(it.value())) {
            releaseKey(it.value());
            it = cacheKeys.erase(it);
            any = true;
        } else {
            ++it;
        }
    }

    return any;
}

get()

static QPixmapCache::KeyData* QPMCache::get ( const QPixmapCache::Key &  key )

inlinestatic

Definition at line 202 of file qpixmapcache.cpp.

Referenced by qHash().

    {return key.d;}

getKeyData()

QPixmapCache::KeyData * QPMCache::getKeyData ( QPixmapCache::Key *  key )

static

Definition at line 444 of file qpixmapcache.cpp.

Referenced by createKey().

{
    if (!key->d)
        key->d = new QPixmapCache::KeyData;
    return key->d;
}

insert() [1/2]

bool QPMCache::insert	(	const QString &	key,
		const QPixmap &	pixmap,
		int	cost
	)

Definition at line 317 of file qpixmapcache.cpp.

{
    QPixmapCache::Key cacheKey;
    QPixmapCache::Key oldCacheKey = cacheKeys.value(key);
    //If for the same key we add already a pixmap we should delete it
    if (oldCacheKey.d) {
        QCache<QPixmapCache::Key, QPixmapCacheEntry>::remove(oldCacheKey);
        cacheKeys.remove(key);
    }

    //we create a new key the old one has been removed
    cacheKey = createKey();

    bool success = QCache<QPixmapCache::Key, QPixmapCacheEntry>::insert(cacheKey, new QPixmapCacheEntry(cacheKey, pixmap), cost);
    if (success) {
        cacheKeys.insert(key, cacheKey);
        if (!theid) {
            theid = startTimer(flush_time);
            t = false;
        }
    } else {
        //Insertion failed we released the new allocated key
        releaseKey(cacheKey);
    }
    return success;
}

insert() [2/2]

QPixmapCache::Key QPMCache::insert	(	const QPixmap &	pixmap,
		int	cost
	)

Definition at line 344 of file qpixmapcache.cpp.

{
    QPixmapCache::Key cacheKey = createKey();
    bool success = QCache<QPixmapCache::Key, QPixmapCacheEntry>::insert(cacheKey, new QPixmapCacheEntry(cacheKey, pixmap), cost);
    if (success) {
        if (!theid) {
            theid = startTimer(flush_time);
            t = false;
        }
    } else {
        //Insertion failed we released the key and return an invalid one
        releaseKey(cacheKey);
    }
    return cacheKey;
}

object() [1/2]

QPixmap * QPMCache::object

(

const QString &

key

)

const

Definition at line 292 of file qpixmapcache.cpp.

{
    QPixmapCache::Key cacheKey = cacheKeys.value(key);
    if (!cacheKey.d || !cacheKey.d->isValid) {
        const_cast<QPMCache *>(this)->cacheKeys.remove(key);
        return 0;
    }
    QPixmap *ptr = QCache<QPixmapCache::Key, QPixmapCacheEntry>::object(cacheKey);
     //We didn't find the pixmap in the cache, the key is not valid anymore
    if (!ptr) {
        const_cast<QPMCache *>(this)->cacheKeys.remove(key);
    }
    return ptr;
}

object() [2/2]

QPixmap * QPMCache::object

(

const QPixmapCache::Key &

key

)

const

Definition at line 307 of file qpixmapcache.cpp.

{
    Q_ASSERT(key.d->isValid);
    QPixmap *ptr = QCache<QPixmapCache::Key, QPixmapCacheEntry>::object(key);
    //We didn't find the pixmap in the cache, the key is not valid anymore
    if (!ptr)
        const_cast<QPMCache *>(this)->releaseKey(key);
    return ptr;
}

releaseKey()

void QPMCache::releaseKey

(

const QPixmapCache::Key &

key

)

Definition at line 420 of file qpixmapcache.cpp.

Referenced by flushDetachedPixmaps(), insert(), object(), and replace().

{
    if (key.d->key > keyArraySize || key.d->key <= 0)
        return;
    key.d->key--;
    keyArray[key.d->key] = freeKey;
    freeKey = key.d->key;
    key.d->isValid = false;
    key.d->key = 0;
}

remove() [1/2]

bool QPMCache::remove

(

const QString &

key

)

Definition at line 382 of file qpixmapcache.cpp.

{
    QPixmapCache::Key cacheKey = cacheKeys.value(key);
    //The key was not in the cache
    if (!cacheKey.d)
        return false;
    cacheKeys.remove(key);
    return QCache<QPixmapCache::Key, QPixmapCacheEntry>::remove(cacheKey);
}

remove() [2/2]

bool QPMCache::remove

(

const QPixmapCache::Key &

key

)

Definition at line 392 of file qpixmapcache.cpp.

{
    return QCache<QPixmapCache::Key, QPixmapCacheEntry>::remove(key);
}

replace()

bool QPMCache::replace	(	const QPixmapCache::Key &	key,
		const QPixmap &	pixmap,
		int	cost
	)

Definition at line 360 of file qpixmapcache.cpp.

{
    Q_ASSERT(key.d->isValid);
    //If for the same key we had already an entry so we should delete the pixmap and use the new one
    QCache<QPixmapCache::Key, QPixmapCacheEntry>::remove(key);

    QPixmapCache::Key cacheKey = createKey();

    bool success = QCache<QPixmapCache::Key, QPixmapCacheEntry>::insert(cacheKey, new QPixmapCacheEntry(cacheKey, pixmap), cost);
    if (success) {
        if(!theid) {
            theid = startTimer(flush_time);
            t = false;
        }
        const_cast<QPixmapCache::Key&>(key) = cacheKey;
    } else {
        //Insertion failed we released the key
        releaseKey(cacheKey);
    }
    return success;
}

resizeKeyArray()

void QPMCache::resizeKeyArray

(

int

size

)

Definition at line 397 of file qpixmapcache.cpp.

Referenced by createKey().

{
    if (size <= keyArraySize || size == 0)
        return;
    keyArray = q_check_ptr(reinterpret_cast<int *>(realloc(keyArray,
                    size * sizeof(int))));
    for (int i = keyArraySize; i != size; ++i)
        keyArray[i] = i + 1;
    keyArraySize = size;
}

timerEvent()

void QPMCache::timerEvent ( QTimerEvent *  event )

virtual

This event handler can be reimplemented in a subclass to receive timer events for the object.

QTimer provides a higher-level interface to the timer functionality, and also more general information about timers. The timer event is passed in the event parameter.

See also

startTimer(), killTimer(), event()

Reimplemented from QObject.

Definition at line 278 of file qpixmapcache.cpp.

{
    bool nt = totalCost() == ps;
    if (!flushDetachedPixmaps(nt)) {
        killTimer(theid);
        theid = 0;
    } else if (nt != t) {
        killTimer(theid);
        theid = startTimer(nt ? soon_time : flush_time);
        t = nt;
    }
}

Properties

cacheKeys

QHash<QString, QPixmapCache::Key> QPMCache::cacheKeys

private

Definition at line 217 of file qpixmapcache.cpp.

Referenced by allPixmaps(), flushDetachedPixmaps(), insert(), object(), and remove().

freeKey

int QPMCache::freeKey

private

Definition at line 216 of file qpixmapcache.cpp.

Referenced by clear(), createKey(), and releaseKey().

keyArray

int* QPMCache::keyArray

private

Definition at line 212 of file qpixmapcache.cpp.

Referenced by clear(), createKey(), releaseKey(), resizeKeyArray(), and ~QPMCache().

keyArraySize

int QPMCache::keyArraySize

private

Definition at line 215 of file qpixmapcache.cpp.

Referenced by clear(), createKey(), releaseKey(), and resizeKeyArray().

ps

int QPMCache::ps

private

Definition at line 214 of file qpixmapcache.cpp.

Referenced by flushDetachedPixmaps(), and timerEvent().

t

bool QPMCache::t

private

Definition at line 218 of file qpixmapcache.cpp.

Referenced by insert(), replace(), and timerEvent().

theid

int QPMCache::theid

private

Definition at line 213 of file qpixmapcache.cpp.

Referenced by insert(), replace(), and timerEvent().

---

The documentation for this class was generated from the following file:

• /src/gui/image/qpixmapcache.cpp