QPixmapIconEngine Class Reference

#include <qicon_p.h>

Inheritance diagram for QPixmapIconEngine:

Public Functions
QSize	actualSize (const QSize &size, QIcon::Mode mode, QIcon::State state)
	Returns the actual size of the icon the engine provides for the requested size, mode and state. More...
void	addFile (const QString &fileName, const QSize &size, QIcon::Mode mode, QIcon::State state)
	Called by QIcon::addFile(). More...
void	addPixmap (const QPixmap &pixmap, QIcon::Mode mode, QIcon::State state)
	Called by QIcon::addPixmap(). More...
QPixmapIconEngineEntry *	bestMatch (const QSize &size, QIcon::Mode mode, QIcon::State state, bool sizeOnly)
QIconEngineV2 *	clone () const
	Returns a clone of this icon engine. More...
QString	key () const
	Returns a key that identifies this icon engine. More...
void	paint (QPainter *painter, const QRect &rect, QIcon::Mode mode, QIcon::State state)
	Uses the given painter to paint the icon with the required mode and state into the rectangle rect. More...
QPixmap	pixmap (const QSize &size, QIcon::Mode mode, QIcon::State state)
	Returns the icon as a pixmap with the required size, mode, and state. More...
	QPixmapIconEngine ()
	QPixmapIconEngine (const QPixmapIconEngine &)
bool	read (QDataStream &in)
	Reads icon engine contents from the QDataStream in. More...
void	virtual_hook (int id, void *data)
	Additional method to allow extending QIconEngineV2 without adding new virtual methods (and without breaking binary compatibility). More...
bool	write (QDataStream &out) const
	Writes the contents of this engine to the QDataStream out. More...
	~QPixmapIconEngine ()
Public Functions inherited from QIconEngineV2
QList< QSize >	availableSizes (QIcon::Mode mode=QIcon::Normal, QIcon::State state=QIcon::Off)
	Returns sizes of all images that are contained in the engine for the specific mode and state. More...
QString	iconName ()
	Returns the name used to create the engine, if available. More...
Public Functions inherited from QIconEngine
virtual	~QIconEngine ()
	Destroys the icon engine. More...

Private Functions
QPixmapIconEngineEntry *	tryMatch (const QSize &size, QIcon::Mode mode, QIcon::State state)

Properties
QVector< QPixmapIconEngineEntry >	pixmaps

Friends
QDataStream &	operator<< (QDataStream &s, const QIcon &icon)
class	QIconThemeEngine

Additional Inherited Members
Public Types inherited from QIconEngineV2
enum	IconEngineHook { AvailableSizesHook = 1, IconNameHook }
	These enum values are used for virtual_hook() to allow additional queries to icon engine without breaking binary compatibility. More...

Detailed Description

Definition at line 110 of file qicon_p.h.

Constructors and Destructors

QPixmapIconEngine() [1/2]

QPixmapIconEngine::QPixmapIconEngine

(

)

Definition at line 133 of file qicon.cpp.

Referenced by clone().

{
}

QPixmapIconEngine() [2/2]

QPixmapIconEngine::QPixmapIconEngine

(

const QPixmapIconEngine &

other

)

Definition at line 137 of file qicon.cpp.

    : QIconEngineV2(other), pixmaps(other.pixmaps)
{
}

~QPixmapIconEngine()

QPixmapIconEngine::~QPixmapIconEngine

(

)

Definition at line 142 of file qicon.cpp.

{
}

Functions

actualSize()

QSize QPixmapIconEngine::actualSize ( const QSize &  size, QIcon::Mode  mode, QIcon::State  state  )

virtual

Returns the actual size of the icon the engine provides for the requested size, mode and state.

The default implementation returns the given size.

Reimplemented from QIconEngine.

Definition at line 306 of file qicon.cpp.

Referenced by pixmap().

{
    QSize actualSize;
    if (QPixmapIconEngineEntry *pe = bestMatch(size, mode, state, true))
        actualSize = pe->size;

    if (actualSize.isNull())
        return actualSize;

    if (!actualSize.isNull() && (actualSize.width() > size.width() || actualSize.height() > size.height()))
        actualSize.scale(size, Qt::KeepAspectRatio);
    return actualSize;
}

addFile()

void QPixmapIconEngine::addFile ( const QString &  fileName, const QSize &  size, QIcon::Mode  mode, QIcon::State  state  )

virtual

Called by QIcon::addFile().

Adds a specialized pixmap from the file with the given fileName, size, mode and state. The default pixmap-based engine stores any supplied file names, and it loads the pixmaps on demand instead of using scaled pixmaps if the size of a pixmap matches the size of icon requested. Custom icon engines that implement scalable vector formats are free to ignores any extra files.

Reimplemented from QIconEngine.

Definition at line 333 of file qicon.cpp.

Referenced by read().

{
    if (!fileName.isEmpty()) {
        QSize size = _size;
        QPixmap pixmap;

        QString abs = fileName;
        if (fileName.at(0) != QLatin1Char(':'))
            abs = QFileInfo(fileName).absoluteFilePath();

        for (int i = 0; i < pixmaps.count(); ++i) {
            if (pixmaps.at(i).mode == mode && pixmaps.at(i).state == state) {
                QPixmapIconEngineEntry *pe = &pixmaps[i];
                if(size == QSize()) {
                    pixmap = QPixmap(abs);
                    size = pixmap.size();
                }
                if (pe->size == QSize() && pe->pixmap.isNull()) {
                    pe->pixmap = QPixmap(pe->fileName);
                    pe->size = pe->pixmap.size();
                }
                if(pe->size == size) {
                    pe->pixmap = pixmap;
                    pe->fileName = abs;
                    return;
                }
            }
        }
        QPixmapIconEngineEntry e(abs, size, mode, state);
        e.pixmap = pixmap;
        pixmaps += e;
    }
}

addPixmap()

void QPixmapIconEngine::addPixmap ( const QPixmap &  pixmap, QIcon::Mode  mode, QIcon::State  state  )

virtual

Called by QIcon::addPixmap().

Adds a specialized pixmap for the given mode and state. The default pixmap-based engine stores any supplied pixmaps, and it uses them instead of scaled pixmaps if the size of a pixmap matches the size of icon requested. Custom icon engines that implement scalable vector formats are free to ignores any extra pixmaps.

Reimplemented from QIconEngine.

Definition at line 320 of file qicon.cpp.

{
    if (!pixmap.isNull()) {
        QPixmapIconEngineEntry *pe = tryMatch(pixmap.size(), mode, state);
        if(pe && pe->size == pixmap.size()) {
            pe->pixmap = pixmap;
            pe->fileName.clear();
        } else {
            pixmaps += QPixmapIconEngineEntry(pixmap, mode, state);
        }
    }
}

bestMatch()

QPixmapIconEngineEntry * QPixmapIconEngine::bestMatch	(	const QSize &	size,
		QIcon::Mode	mode,
		QIcon::State	state,
		bool	sizeOnly
	)

Definition at line 195 of file qicon.cpp.

Referenced by actualSize(), and pixmap().

{
    QPixmapIconEngineEntry *pe = tryMatch(size, mode, state);
    while (!pe){
        QIcon::State oppositeState = (state == QIcon::On) ? QIcon::Off : QIcon::On;
        if (mode == QIcon::Disabled || mode == QIcon::Selected) {
            QIcon::Mode oppositeMode = (mode == QIcon::Disabled) ? QIcon::Selected : QIcon::Disabled;
            if ((pe = tryMatch(size, QIcon::Normal, state)))
                break;
            if ((pe = tryMatch(size, QIcon::Active, state)))
                break;
            if ((pe = tryMatch(size, mode, oppositeState)))
                break;
            if ((pe = tryMatch(size, QIcon::Normal, oppositeState)))
                break;
            if ((pe = tryMatch(size, QIcon::Active, oppositeState)))
                break;
            if ((pe = tryMatch(size, oppositeMode, state)))
                break;
            if ((pe = tryMatch(size, oppositeMode, oppositeState)))
                break;
        } else {
            QIcon::Mode oppositeMode = (mode == QIcon::Normal) ? QIcon::Active : QIcon::Normal;
            if ((pe = tryMatch(size, oppositeMode, state)))
                break;
            if ((pe = tryMatch(size, mode, oppositeState)))
                break;
            if ((pe = tryMatch(size, oppositeMode, oppositeState)))
                break;
            if ((pe = tryMatch(size, QIcon::Disabled, state)))
                break;
            if ((pe = tryMatch(size, QIcon::Selected, state)))
                break;
            if ((pe = tryMatch(size, QIcon::Disabled, oppositeState)))
                break;
            if ((pe = tryMatch(size, QIcon::Selected, oppositeState)))
                break;
        }

        if (!pe)
            return pe;
    }

    if (sizeOnly ? (pe->size.isNull() || !pe->size.isValid()) : pe->pixmap.isNull()) {
        pe->pixmap = QPixmap(pe->fileName);
        if (!pe->pixmap.isNull())
            pe->size = pe->pixmap.size();
    }

    return pe;
}

clone()

QIconEngineV2 * QPixmapIconEngine::clone ( ) const

virtual

Returns a clone of this icon engine.

Reimplemented from QIconEngineV2.

Definition at line 372 of file qicon.cpp.

{
    return new QPixmapIconEngine(*this);
}

key()

QString QPixmapIconEngine::key ( ) const

virtual

Returns a key that identifies this icon engine.

Reimplemented from QIconEngineV2.

Definition at line 367 of file qicon.cpp.

Referenced by pixmap().

{
    return QLatin1String("QPixmapIconEngine");
}

paint()

void QPixmapIconEngine::paint ( QPainter *  painter, const QRect &  rect, QIcon::Mode  mode, QIcon::State  state  )

virtual

Uses the given painter to paint the icon with the required mode and state into the rectangle rect.

Implements QIconEngine.

Definition at line 146 of file qicon.cpp.

{
    QSize pixmapSize = rect.size();
#if defined(Q_WS_MAC)
    pixmapSize *= qt_mac_get_scalefactor();
#endif
    painter->drawPixmap(rect, pixmap(pixmapSize, mode, state));
}

pixmap()

QPixmap QPixmapIconEngine::pixmap ( const QSize &  size, QIcon::Mode  mode, QIcon::State  state  )

virtual

Returns the icon as a pixmap with the required size, mode, and state.

The default implementation creates a new pixmap and calls paint() to fill it.

Reimplemented from QIconEngine.

Definition at line 247 of file qicon.cpp.

Referenced by addFile(), addPixmap(), and paint().

{
    QPixmap pm;
    QPixmapIconEngineEntry *pe = bestMatch(size, mode, state, false);
    if (pe)
        pm = pe->pixmap;

    if (pm.isNull()) {
        int idx = pixmaps.count();
        while (--idx >= 0) {
            if (pe == &pixmaps[idx]) {
                pixmaps.remove(idx);
                break;
            }
        }
        if (pixmaps.isEmpty())
            return pm;
        else
            return pixmap(size, mode, state);
    }

    QSize actualSize = pm.size();
    if (!actualSize.isNull() && (actualSize.width() > size.width() || actualSize.height() > size.height()))
        actualSize.scale(size, Qt::KeepAspectRatio);

    QString key = QLatin1Literal("qt_")
                  % HexString<quint64>(pm.cacheKey())
                  % HexString<uint>(pe->mode)
                  % HexString<quint64>(QApplication::palette().cacheKey())
                  % HexString<uint>(actualSize.width())
                  % HexString<uint>(actualSize.height());

    if (mode == QIcon::Active) {
        if (QPixmapCache::find(key % HexString<uint>(mode), pm))
            return pm; // horray
        if (QPixmapCache::find(key % HexString<uint>(QIcon::Normal), pm)) {
            QStyleOption opt(0);
            opt.palette = QApplication::palette();
            QPixmap active = QApplication::style()->generatedIconPixmap(QIcon::Active, pm, &opt);
            if (pm.cacheKey() == active.cacheKey())
                return pm;
        }
    }

    if (!QPixmapCache::find(key % HexString<uint>(mode), pm)) {
        if (pm.size() != actualSize)
            pm = pm.scaled(actualSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
        if (pe->mode != mode && mode != QIcon::Normal) {
            QStyleOption opt(0);
            opt.palette = QApplication::palette();
            QPixmap generated = QApplication::style()->generatedIconPixmap(mode, pm, &opt);
            if (!generated.isNull())
                pm = generated;
        }
        QPixmapCache::insert(key % HexString<uint>(mode), pm);
    }
    return pm;
}

read()

bool QPixmapIconEngine::read ( QDataStream &  in )

virtual

Reads icon engine contents from the QDataStream in.

Returns true if the contents were read; otherwise returns false.

QIconEngineV2's default implementation always return false.

Reimplemented from QIconEngineV2.

Definition at line 377 of file qicon.cpp.

{
    int num_entries;
    QPixmap pm;
    QString fileName;
    QSize sz;
    uint mode;
    uint state;

    in >> num_entries;
    for (int i=0; i < num_entries; ++i) {
        if (in.atEnd()) {
            pixmaps.clear();
            return false;
        }
        in >> pm;
        in >> fileName;
        in >> sz;
        in >> mode;
        in >> state;
        if (pm.isNull()) {
            addFile(fileName, sz, QIcon::Mode(mode), QIcon::State(state));
        } else {
            QPixmapIconEngineEntry pe(fileName, sz, QIcon::Mode(mode), QIcon::State(state));
            pe.pixmap = pm;
            pixmaps += pe;
        }
    }
    return true;
}

tryMatch()

QPixmapIconEngineEntry * QPixmapIconEngine::tryMatch ( const QSize &  size, QIcon::Mode  mode, QIcon::State  state  )

private

Definition at line 181 of file qicon.cpp.

Referenced by addPixmap(), and bestMatch().

{
    QPixmapIconEngineEntry *pe = 0;
    for (int i = 0; i < pixmaps.count(); ++i)
        if (pixmaps.at(i).mode == mode && pixmaps.at(i).state == state) {
            if (pe)
                pe = bestSizeMatch(size, &pixmaps[i], pe);
            else
                pe = &pixmaps[i];
        }
    return pe;
}

virtual_hook()

void QPixmapIconEngine::virtual_hook ( int  id, void *  data  )

virtual

Additional method to allow extending QIconEngineV2 without adding new virtual methods (and without breaking binary compatibility).

Since

4.5

The actual action and format of data depends on id argument which is in fact a constant from IconEngineHook enum.

See also

IconEngineHook

Reimplemented from QIconEngineV2.

Definition at line 425 of file qicon.cpp.

{
    switch (id) {
    case QIconEngineV2::AvailableSizesHook: {
        QIconEngineV2::AvailableSizesArgument &arg =
            *reinterpret_cast<QIconEngineV2::AvailableSizesArgument*>(data);
        arg.sizes.clear();
        for (int i = 0; i < pixmaps.size(); ++i) {
            QPixmapIconEngineEntry &pe = pixmaps[i];
            if (pe.size == QSize() && pe.pixmap.isNull()) {
                pe.pixmap = QPixmap(pe.fileName);
                pe.size = pe.pixmap.size();
            }
            if (pe.mode == arg.mode && pe.state == arg.state && !pe.size.isEmpty())
                arg.sizes.push_back(pe.size);
        }
        break;
    }
    default:
        QIconEngineV2::virtual_hook(id, data);
    }
}

write()

bool QPixmapIconEngine::write ( QDataStream &  out ) const

virtual

Writes the contents of this engine to the QDataStream out.

Returns true if the contents were written; otherwise returns false.

QIconEngineV2's default implementation always return false.

Reimplemented from QIconEngineV2.

Definition at line 408 of file qicon.cpp.

{
    int num_entries = pixmaps.size();
    out << num_entries;
    for (int i=0; i < num_entries; ++i) {
        if (pixmaps.at(i).pixmap.isNull())
            out << QPixmap(pixmaps.at(i).fileName);
        else
            out << pixmaps.at(i).pixmap;
        out << pixmaps.at(i).fileName;
        out << pixmaps.at(i).size;
        out << (uint) pixmaps.at(i).mode;
        out << (uint) pixmaps.at(i).state;
    }
    return true;
}

Friends and Related Functions

operator<<

QDataStream& operator<< ( QDataStream &  s, const QIcon &  icon  )

friend

Definition at line 1096 of file qicon.cpp.

{
    if (s.version() >= QDataStream::Qt_4_3) {
        if (icon.isNull()) {
            s << QString();
        } else {
            if (icon.d->engine_version > 1) {
                QIconEngineV2 *engine = static_cast<QIconEngineV2 *>(icon.d->engine);
                s << engine->key();
                engine->write(s);
            } else {
                // not really supported
                qWarning("QIcon: Cannot stream QIconEngine. Use QIconEngineV2 instead.");
            }
        }
    } else if (s.version() == QDataStream::Qt_4_2) {
        if (icon.isNull()) {
            s << 0;
        } else {
            QPixmapIconEngine *engine = static_cast<QPixmapIconEngine *>(icon.d->engine);
            int num_entries = engine->pixmaps.size();
            s << num_entries;
            for (int i=0; i < num_entries; ++i) {
                s << engine->pixmaps.at(i).pixmap;
                s << engine->pixmaps.at(i).fileName;
                s << engine->pixmaps.at(i).size;
                s << (uint) engine->pixmaps.at(i).mode;
                s << (uint) engine->pixmaps.at(i).state;
            }
        }
    } else {
        s << QPixmap(icon.pixmap(22,22));
    }
    return s;
}

QIconThemeEngine

friend class QIconThemeEngine

friend

Definition at line 134 of file qicon_p.h.

Properties

pixmaps

QVector<QPixmapIconEngineEntry> QPixmapIconEngine::pixmaps

private

Definition at line 131 of file qicon_p.h.

Referenced by addFile(), addPixmap(), operator<<(), pixmap(), read(), tryMatch(), virtual_hook(), and write().

---

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

• /src/gui/image/qicon_p.h
• /src/gui/image/qicon.cpp