qiconengine.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qiconengine.h"
#include "qiconengine_p.h"
#include "qpainter.h"
 
QT_BEGIN_NAMESPACE
 
QSize QIconEngine::actualSize(const QSize &size, QIcon::Mode /*mode*/, QIcon::State /*state*/)
{
    return size;
}
 
QIconEngine::QIconEngine()
{
}
 
QIconEngine::QIconEngine(const QIconEngine &)
{
}
 
QIconEngine::~QIconEngine()
{
}
 
 
QPixmap QIconEngine::pixmap(const QSize &size, QIcon::Mode mode, QIcon::State state)
{
    QPixmap pm(size);
    {
        QPainter p(&pm);
        paint(&p, QRect(QPoint(0,0),size), mode, state);
    }
    return pm;
}
 
void QIconEngine::addPixmap(const QPixmap &/*pixmap*/, QIcon::Mode /*mode*/, QIcon::State /*state*/)
{
}
 
 
void QIconEngine::addFile(const QString &/*fileName*/, const QSize &/*size*/, QIcon::Mode /*mode*/, QIcon::State /*state*/)
{
}
 
 
QString QIconEngine::key() const
{
    return QString();
}
 
bool QIconEngine::read(QDataStream &)
{
    return false;
}
 
bool QIconEngine::write(QDataStream &) const
{
    return false;
}
 
void QIconEngine::virtual_hook(int id, void *data)
{
    switch (id) {
    case QIconEngine::ScaledPixmapHook: {
        // We don't have any notion of scale besides "@nx", so just call pixmap() here.
        QIconEngine::ScaledPixmapArgument &arg =
            *reinterpret_cast<QIconEngine::ScaledPixmapArgument*>(data);
        arg.pixmap = pixmap(arg.size, arg.mode, arg.state);
        break;
    }
    default:
        break;
    }
}
 
QList<QSize> QIconEngine::availableSizes(QIcon::Mode /*mode*/, QIcon::State /*state*/)
{
    return {};
}
 
QString QIconEngine::iconName()
{
    return QString();
}
 
bool QIconEngine::isNull()
{
    bool isNull = false;
    virtual_hook(QIconEngine::IsNullHook, &isNull);
    return isNull;
}
 
QPixmap QIconEngine::scaledPixmap(const QSize &size, QIcon::Mode mode, QIcon::State state, qreal scale)
{
    ScaledPixmapArgument arg;
    arg.size = size;
    arg.mode = mode;
    arg.state = state;
    arg.scale = scale;
    const_cast<QIconEngine *>(this)->virtual_hook(QIconEngine::ScaledPixmapHook, reinterpret_cast<void*>(&arg));
    return arg.pixmap;
}
 
 
// ------- QProxyIconEngine -----
 
void QProxyIconEngine::paint(QPainter *painter, const QRect &rect, QIcon::Mode mode, QIcon::State state)
{
    proxiedEngine()->paint(painter, rect, mode, state);
}
 
QSize QProxyIconEngine::actualSize(const QSize &size, QIcon::Mode mode, QIcon::State state)
{
    return proxiedEngine()->actualSize(size, mode, state);
}
 
QPixmap QProxyIconEngine::pixmap(const QSize &size, QIcon::Mode mode, QIcon::State state)
{
    return proxiedEngine()->pixmap(size, mode, state);
}
 
void QProxyIconEngine::addPixmap(const QPixmap &pixmap, QIcon::Mode mode, QIcon::State state)
{
    proxiedEngine()->addPixmap(pixmap, mode, state);
}
 
void QProxyIconEngine::addFile(const QString &fileName, const QSize &size, QIcon::Mode mode, QIcon::State state)
{
    proxiedEngine()->addFile(fileName, size, mode, state);
}
 
QString QProxyIconEngine::key() const
{
    return proxiedEngine()->key();
}
 
QIconEngine *QProxyIconEngine::clone() const
{
    return proxiedEngine()->clone();
}
 
bool QProxyIconEngine::read(QDataStream &in)
{
    return proxiedEngine()->read(in);
}
 
bool QProxyIconEngine::write(QDataStream &out) const
{
    return proxiedEngine()->write(out);
}
 
QList<QSize> QProxyIconEngine::availableSizes(QIcon::Mode mode, QIcon::State state)
{
    return proxiedEngine()->availableSizes(mode, state);
}
 
QString QProxyIconEngine::iconName()
{
    return proxiedEngine()->iconName();
}
 
bool QProxyIconEngine::isNull()
{
    return proxiedEngine()->isNull();
}
 
QPixmap QProxyIconEngine::scaledPixmap(const QSize &size, QIcon::Mode mode, QIcon::State state, qreal scale)
{
    return proxiedEngine()->scaledPixmap(size, mode, state, scale);
}
 
void QProxyIconEngine::virtual_hook(int id, void *data)
{
    proxiedEngine()->virtual_hook(id, data);
}
 
 
QT_END_NAMESPACE