/****************************************************************************

**

** Copyright (C) 2016 The Qt Company Ltd.

** Contact: https://www.qt.io/licensing/

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** Commercial License Usage

** Licensees holding valid commercial Qt licenses may use this file in

** accordance with the commercial license agreement provided with the

** Software or, alternatively, in accordance with the terms contained in

** a written agreement between you and The Qt Company. For licensing terms

** and conditions see https://www.qt.io/terms-conditions. For further

** information use the contact form at https://www.qt.io/contact-us.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 3 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL3 included in the

** packaging of this file. Please review the following information to

** ensure the GNU Lesser General Public License version 3 requirements

** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.

**

** GNU General Public License Usage

** Alternatively, this file may be used under the terms of the GNU

** General Public License version 2.0 or (at your option) the GNU General

** Public license version 3 or any later version approved by the KDE Free

** Qt Foundation. The licenses are as published by the Free Software

** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3

** included in the packaging of this file. Please review the following

** information to ensure the GNU General Public License requirements will

** be met: https://www.gnu.org/licenses/gpl-2.0.html and

** https://www.gnu.org/licenses/gpl-3.0.html.

**

** $QT_END_LICENSE$

**

****************************************************************************/

#ifndef QT_NO_ICON

#include <private/qiconloader_p.h>

#include <private/qguiapplication_p.h>

#include <private/qicon_p.h>

#include <QtGui/QIconEnginePlugin>

#include <QtGui/QPixmapCache>

#include <qpa/qplatformtheme.h>

#include <QtGui/QIconEngine>

#include <QtGui/QPalette>

#include <QtCore/qmath.h>

#include <QtCore/QList>

#include <QtCore/QDir>

#if QT_CONFIG(settings)

#include <QtCore/QSettings>

#endif

#include <QtGui/QPainter>

#include <private/qhexstring_p.h>

QT_BEGIN_NAMESPACE

Q_GLOBAL_STATIC(QIconLoader, iconLoaderInstance)

/* Theme to use in last resort, if the theme does not have the icon, neither the parents  */

static QString systemFallbackThemeName()

{

    if (const QPlatformTheme *theme = QGuiApplicationPrivate::platformTheme()) {

        const QVariant themeHint = theme->themeHint(QPlatformTheme::SystemIconFallbackThemeName);

        if (themeHint.isValid())

            return themeHint.toString();

    }

    return QString();

}

QIconLoader::QIconLoader() :

        m_themeKey(1), m_supportsSvg(false), m_initialized(false)

{

}

static inline QString systemThemeName()

{

    const auto override = qgetenv("QT_QPA_SYSTEM_ICON_THEME");

    if (!override.isEmpty())

        return QString::fromLocal8Bit(override);

    if (const QPlatformTheme *theme = QGuiApplicationPrivate::platformTheme()) {

        const QVariant themeHint = theme->themeHint(QPlatformTheme::SystemIconThemeName);

        if (themeHint.isValid())

            return themeHint.toString();

    }

    return QString();

}

static inline QStringList systemIconSearchPaths()

{

    if (const QPlatformTheme *theme = QGuiApplicationPrivate::platformTheme()) {

        const QVariant themeHint = theme->themeHint(QPlatformTheme::IconThemeSearchPaths);

        if (themeHint.isValid())

            return themeHint.toStringList();

    }

    return QStringList();

}

static inline QStringList systemFallbackSearchPaths()

{

    if (const QPlatformTheme *theme = QGuiApplicationPrivate::platformTheme()) {

        const QVariant themeHint = theme->themeHint(QPlatformTheme::IconFallbackSearchPaths);

        if (themeHint.isValid())

            return themeHint.toStringList();

    }

    return QStringList();

}

extern QFactoryLoader *qt_iconEngineFactoryLoader(); // qicon.cpp

void QIconLoader::ensureInitialized()

{

    if (!m_initialized) {

        if (!QGuiApplicationPrivate::platformTheme())

            return; // it's too early: try again later (QTBUG-74252)

        m_initialized = true;

        m_systemTheme = systemThemeName();

        if (m_systemTheme.isEmpty())

            m_systemTheme = systemFallbackThemeName();

        if (qt_iconEngineFactoryLoader()->keyMap().key(QLatin1String("svg"), -1) != -1)

            m_supportsSvg = true;

    }

}

/*!

    \internal

    Gets an instance.

    \l QIcon::setFallbackThemeName() should be called before QGuiApplication is

    created, to avoid a race condition (QTBUG-74252). When this function is

    called from there, ensureInitialized() does not succeed because there

    is no QPlatformTheme yet, so systemThemeName() is empty, and we don't want

    m_systemTheme to get intialized to the fallback theme instead of the normal one.

*/

QIconLoader *QIconLoader::instance()

{

   iconLoaderInstance()->ensureInitialized();

   return iconLoaderInstance();

}

// Queries the system theme and invalidates existing

// icons if the theme has changed.

void QIconLoader::updateSystemTheme()

{

    // Only change if this is not explicitly set by the user

    if (m_userTheme.isEmpty()) {

        QString theme = systemThemeName();

        if (theme.isEmpty())

            theme = fallbackThemeName();

        if (theme != m_systemTheme) {

            m_systemTheme = theme;

            invalidateKey();

        }

    }

}

void QIconLoader::setThemeName(const QString &themeName)

{

    m_userTheme = themeName;

    invalidateKey();

}

QString QIconLoader::fallbackThemeName() const

{

    return m_userFallbackTheme.isEmpty() ? systemFallbackThemeName() : m_userFallbackTheme;

}

void QIconLoader::setFallbackThemeName(const QString &themeName)

{

    m_userFallbackTheme = themeName;

}

void QIconLoader::setThemeSearchPath(const QStringList &searchPaths)

{

    m_iconDirs = searchPaths;

    themeList.clear();

    invalidateKey();

}

QStringList QIconLoader::themeSearchPaths() const

{

    if (m_iconDirs.isEmpty()) {

        m_iconDirs = systemIconSearchPaths();

        // Always add resource directory as search path

        m_iconDirs.append(QLatin1String(":/icons"));

    }

    return m_iconDirs;

}

void QIconLoader::setFallbackSearchPaths(const QStringList &searchPaths)

{

    m_fallbackDirs = searchPaths;

    invalidateKey();

}

QStringList QIconLoader::fallbackSearchPaths() const

{

    if (m_fallbackDirs.isEmpty()) {

        m_fallbackDirs = systemFallbackSearchPaths();

    }

    return m_fallbackDirs;

}

/*!

    \internal

    Helper class that reads and looks up into the icon-theme.cache generated with

    gtk-update-icon-cache. If at any point we detect a corruption in the file

    (because the offsets point at wrong locations for example), the reader

    is marked as invalid.

*/

class QIconCacheGtkReader

{

public:

    explicit QIconCacheGtkReader(const QString &themeDir);

    QVector<const char *> lookup(const QStringRef &);

    bool isValid() const { return m_isValid; }

private:

    QFile m_file;

    const unsigned char *m_data;

    quint64 m_size;

    bool m_isValid;

    quint16 read16(uint offset)

    {

        if (offset > m_size - 2 || (offset & 0x1)) {

            m_isValid = false;

            return 0;

        }

        return m_data[offset+1] | m_data[offset] << 8;

    }

    quint32 read32(uint offset)

    {

        if (offset > m_size - 4 || (offset & 0x3)) {

            m_isValid = false;

            return 0;

        }

        return m_data[offset+3] | m_data[offset+2] << 8

            | m_data[offset+1] << 16 | m_data[offset] << 24;

    }

};

QIconCacheGtkReader::QIconCacheGtkReader(const QString &dirName)

    : m_isValid(false)

{

    QFileInfo info(dirName + QLatin1String("/icon-theme.cache"));

    if (!info.exists() || info.lastModified() < QFileInfo(dirName).lastModified())

        return;

    m_file.setFileName(info.absoluteFilePath());

    if (!m_file.open(QFile::ReadOnly))

        return;

    m_size = m_file.size();

    m_data = m_file.map(0, m_size);

    if (!m_data)

        return;

    if (read16(0) != 1) // VERSION_MAJOR

        return;

    m_isValid = true;

    // Check that all the directories are older than the cache

    auto lastModified = info.lastModified();

    quint32 dirListOffset = read32(8);

    quint32 dirListLen = read32(dirListOffset);

    for (uint i = 0; i < dirListLen; ++i) {

        quint32 offset = read32(dirListOffset + 4 + 4 * i);

        if (!m_isValid || offset >= m_size || lastModified < QFileInfo(dirName + QLatin1Char('/')

                + QString::fromUtf8(reinterpret_cast<const char*>(m_data + offset))).lastModified()) {

            m_isValid = false;

            return;

        }

    }

}

static quint32 icon_name_hash(const char *p)

{

    quint32 h = static_cast<signed char>(*p);

    for (p += 1; *p != '\0'; p++)

        h = (h << 5) - h + *p;

    return h;

}

/*! \internal

    lookup the icon name and return the list of subdirectories in which an icon

    with this name is present. The char* are pointers to the mapped data.

    For example, this would return { "32x32/apps", "24x24/apps" , ... }

 */

QVector<const char *> QIconCacheGtkReader::lookup(const QStringRef &name)

{

    QVector<const char *> ret;

    if (!isValid() || name.isEmpty())

        return ret;

    QByteArray nameUtf8 = name.toUtf8();

    quint32 hash = icon_name_hash(nameUtf8);

    quint32 hashOffset = read32(4);

    quint32 hashBucketCount = read32(hashOffset);

    if (!isValid() || hashBucketCount == 0) {

        m_isValid = false;

        return ret;

    }

    quint32 bucketIndex = hash % hashBucketCount;

    quint32 bucketOffset = read32(hashOffset + 4 + bucketIndex * 4);

    while (bucketOffset > 0 && bucketOffset <= m_size - 12) {

        quint32 nameOff = read32(bucketOffset + 4);

        if (nameOff < m_size && strcmp(reinterpret_cast<const char*>(m_data + nameOff), nameUtf8) == 0) {

            quint32 dirListOffset = read32(8);

            quint32 dirListLen = read32(dirListOffset);

            quint32 listOffset = read32(bucketOffset+8);

            quint32 listLen = read32(listOffset);

            if (!m_isValid || listOffset + 4 + 8 * listLen > m_size) {

                m_isValid = false;

                return ret;

            }

            ret.reserve(listLen);

            for (uint j = 0; j < listLen && m_isValid; ++j) {

                quint32 dirIndex = read16(listOffset + 4 + 8 * j);

                quint32 o = read32(dirListOffset + 4 + dirIndex*4);

                if (!m_isValid || dirIndex >= dirListLen || o >= m_size) {

                    m_isValid = false;

                    return ret;

                }

                ret.append(reinterpret_cast<const char*>(m_data) + o);

            }

            return ret;

        }

        bucketOffset = read32(bucketOffset);

    }

    return ret;

}

QIconTheme::QIconTheme(const QString &themeName)

        : m_valid(false)

{

    QFile themeIndex;

    const QStringList iconDirs = QIcon::themeSearchPaths();

    for ( int i = 0 ; i < iconDirs.size() ; ++i) {

        QDir iconDir(iconDirs[i]);

        QString themeDir = iconDir.path() + QLatin1Char('/') + themeName;

        QFileInfo themeDirInfo(themeDir);

        if (themeDirInfo.isDir()) {

            m_contentDirs << themeDir;

            m_gtkCaches << QSharedPointer<QIconCacheGtkReader>::create(themeDir);

        }

        if (!m_valid) {

            themeIndex.setFileName(themeDir + QLatin1String("/index.theme"));

            if (themeIndex.exists())

                m_valid = true;

        }

    }

#if QT_CONFIG(settings)

    if (themeIndex.exists()) {

        const QSettings indexReader(themeIndex.fileName(), QSettings::IniFormat);

        const QStringList keys = indexReader.allKeys();

        for (const QString &key : keys) {

            if (key.endsWith(QLatin1String("/Size"))) {

                // Note the QSettings ini-format does not accept

                // slashes in key names, hence we have to cheat

                if (int size = indexReader.value(key).toInt()) {

                    QString directoryKey = key.left(key.size() - 5);

                    QIconDirInfo dirInfo(directoryKey);

                    dirInfo.size = size;

                    QString type = indexReader.value(directoryKey +

                                                     QLatin1String("/Type")

                                                     ).toString();

                    if (type == QLatin1String("Fixed"))

                        dirInfo.type = QIconDirInfo::Fixed;

                    else if (type == QLatin1String("Scalable"))

                        dirInfo.type = QIconDirInfo::Scalable;

                    else

                        dirInfo.type = QIconDirInfo::Threshold;

                    dirInfo.threshold = indexReader.value(directoryKey +

                                                        QLatin1String("/Threshold"),

                                                        2).toInt();

                    dirInfo.minSize = indexReader.value(directoryKey +

                                                         QLatin1String("/MinSize"),

                                                         size).toInt();

                    dirInfo.maxSize = indexReader.value(directoryKey +

                                                        QLatin1String("/MaxSize"),

                                                        size).toInt();

                    dirInfo.scale = indexReader.value(directoryKey +

                                                      QLatin1String("/Scale"),

                                                      1).toInt();

                    m_keyList.append(dirInfo);

                }

            }

        }

        // Parent themes provide fallbacks for missing icons

        m_parents = indexReader.value(

                QLatin1String("Icon Theme/Inherits")).toStringList();

        m_parents.removeAll(QString());

        // Ensure a default platform fallback for all themes

        if (m_parents.isEmpty()) {

            const QString fallback = QIconLoader::instance()->fallbackThemeName();

            if (!fallback.isEmpty())

                m_parents.append(fallback);

        }

        // Ensure that all themes fall back to hicolor

        if (!m_parents.contains(QLatin1String("hicolor")))

            m_parents.append(QLatin1String("hicolor"));

    }

#endif // settings

}

QThemeIconInfo QIconLoader::findIconHelper(const QString &themeName,

                                           const QString &iconName,

                                           QStringList &visited) const

{

    QThemeIconInfo info;

    Q_ASSERT(!themeName.isEmpty());

    // Used to protect against potential recursions

    visited << themeName;

    QIconTheme &theme = themeList[themeName];

    if (!theme.isValid()) {

        theme = QIconTheme(themeName);

        if (!theme.isValid())

            theme = QIconTheme(fallbackThemeName());

    }

    const QStringList contentDirs = theme.contentDirs();

    QStringRef iconNameFallback(&iconName);

    // Iterate through all icon's fallbacks in current theme

    while (info.entries.isEmpty()) {

        const QString svgIconName = iconNameFallback + QLatin1String(".svg");

        const QString pngIconName = iconNameFallback + QLatin1String(".png");

        // Add all relevant files

        for (int i = 0; i < contentDirs.size(); ++i) {

            QVector<QIconDirInfo> subDirs = theme.keyList();

            // Try to reduce the amount of subDirs by looking in the GTK+ cache in order to save

            // a massive amount of file stat (especially if the icon is not there)

            auto cache = theme.m_gtkCaches.at(i);

            if (cache->isValid()) {

                const auto result = cache->lookup(iconNameFallback);

                if (cache->isValid()) {

                    const QVector<QIconDirInfo> subDirsCopy = subDirs;

                    subDirs.clear();

                    subDirs.reserve(result.count());

                    for (const char *s : result) {

                        QString path = QString::fromUtf8(s);

                        auto it = std::find_if(subDirsCopy.cbegin(), subDirsCopy.cend(),

                                               [&](const QIconDirInfo &info) {

                                                   return info.path == path; } );

                        if (it != subDirsCopy.cend()) {

                            subDirs.append(*it);

                        }

                    }

                }

            }

            QString contentDir = contentDirs.at(i) + QLatin1Char('/');

            for (int j = 0; j < subDirs.size() ; ++j) {

                const QIconDirInfo &dirInfo = subDirs.at(j);

                const QString subDir = contentDir + dirInfo.path + QLatin1Char('/');

                const QString pngPath = subDir + pngIconName;

                if (QFile::exists(pngPath)) {

                    PixmapEntry *iconEntry = new PixmapEntry;

                    iconEntry->dir = dirInfo;

                    iconEntry->filename = pngPath;

                    // Notice we ensure that pixmap entries always come before

                    // scalable to preserve search order afterwards

                    info.entries.prepend(iconEntry);

                } else if (m_supportsSvg) {

                    const QString svgPath = subDir + svgIconName;

                    if (QFile::exists(svgPath)) {

                        ScalableEntry *iconEntry = new ScalableEntry;

                        iconEntry->dir = dirInfo;

                        iconEntry->filename = svgPath;

                        info.entries.append(iconEntry);

                    }

                }

            }

        }

        if (!info.entries.isEmpty()) {

            info.iconName = iconNameFallback.toString();

            break;

        }

        // If it's possible - find next fallback for the icon

        const int indexOfDash = iconNameFallback.lastIndexOf(QLatin1Char('-'));

        if (indexOfDash == -1)

            break;

        iconNameFallback.truncate(indexOfDash);

    }

    if (info.entries.isEmpty()) {

        const QStringList parents = theme.parents();

        // Search recursively through inherited themes

        for (int i = 0 ; i < parents.size() ; ++i) {

            const QString parentTheme = parents.at(i).trimmed();

            if (!visited.contains(parentTheme)) // guard against recursion

                info = findIconHelper(parentTheme, iconName, visited);

            if (!info.entries.isEmpty()) // success

                break;

        }

    }

    return info;

}

QThemeIconInfo QIconLoader::lookupFallbackIcon(const QString &iconName) const

{

    QThemeIconInfo info;

    const QString pngIconName = iconName + QLatin1String(".png");

    const QString xpmIconName = iconName + QLatin1String(".xpm");

    const QString svgIconName = iconName + QLatin1String(".svg");

    const auto searchPaths = QIcon::fallbackSearchPaths();

    for (const QString &iconDir: searchPaths) {

        QDir currentDir(iconDir);

        if (currentDir.exists(pngIconName)) {

            PixmapEntry *iconEntry = new PixmapEntry;

            iconEntry->dir.type = QIconDirInfo::Fallback;

            iconEntry->filename = currentDir.filePath(pngIconName);

            info.entries.append(iconEntry);

            break;

        } else if (currentDir.exists(xpmIconName)) {

            PixmapEntry *iconEntry = new PixmapEntry;

            iconEntry->dir.type = QIconDirInfo::Fallback;

            iconEntry->filename = currentDir.filePath(xpmIconName);

            info.entries.append(iconEntry);

            break;

        } else if (m_supportsSvg &&

                   currentDir.exists(svgIconName)) {

            ScalableEntry *iconEntry = new ScalableEntry;

            iconEntry->dir.type = QIconDirInfo::Fallback;

            iconEntry->filename = currentDir.filePath(svgIconName);

            info.entries.append(iconEntry);

            break;

        }

    }

    if (!info.entries.isEmpty())

        info.iconName = iconName;

    return info;

}

QThemeIconInfo QIconLoader::loadIcon(const QString &name) const

{

    if (!themeName().isEmpty()) {

        QStringList visited;

        const QThemeIconInfo iconInfo = findIconHelper(themeName(), name, visited);

        if (!iconInfo.entries.isEmpty())

            return iconInfo;

        return lookupFallbackIcon(name);

    }

    return QThemeIconInfo();

}

// -------- Icon Loader Engine -------- //

QIconLoaderEngine::QIconLoaderEngine(const QString& iconName)

        : m_iconName(iconName), m_key(0)

{

}

QIconLoaderEngine::~QIconLoaderEngine()

{

    qDeleteAll(m_info.entries);

}

QIconLoaderEngine::QIconLoaderEngine(const QIconLoaderEngine &other)

        : QIconEngine(other),

        m_iconName(other.m_iconName),

        m_key(0)

{

}

QIconEngine *QIconLoaderEngine::clone() const

{

    return new QIconLoaderEngine(*this);

}

bool QIconLoaderEngine::read(QDataStream &in) {

    in >> m_iconName;

    return true;

}

bool QIconLoaderEngine::write(QDataStream &out) const

{

    out << m_iconName;

    return true;

}

bool QIconLoaderEngine::hasIcon() const

{

    return !(m_info.entries.isEmpty());

}

// Lazily load the icon

void QIconLoaderEngine::ensureLoaded()

{

    if (!(QIconLoader::instance()->themeKey() == m_key)) {

        qDeleteAll(m_info.entries);

        m_info.entries.clear();

        m_info.iconName.clear();

        Q_ASSERT(m_info.entries.size() == 0);

        m_info = QIconLoader::instance()->loadIcon(m_iconName);

        m_key = QIconLoader::instance()->themeKey();

    }

}

void QIconLoaderEngine::paint(QPainter *painter, const QRect &rect,

                             QIcon::Mode mode, QIcon::State state)

{

    const qreal dpr = !qApp->testAttribute(Qt::AA_UseHighDpiPixmaps) ?

                qreal(1.0) : painter->device()->devicePixelRatioF();

    QSize pixmapSize = rect.size() * dpr;

    painter->drawPixmap(rect, pixmap(pixmapSize, mode, state));

}

/*

 * This algorithm is defined by the freedesktop spec:

 * http://standards.freedesktop.org/icon-theme-spec/icon-theme-spec-latest.html

 */

static bool directoryMatchesSize(const QIconDirInfo &dir, int iconsize, int iconscale)

{

    if (dir.scale != iconscale)

        return false;

    if (dir.type == QIconDirInfo::Fixed) {

        return dir.size == iconsize;

    } else if (dir.type == QIconDirInfo::Scalable) {

        return iconsize <= dir.maxSize &&

                iconsize >= dir.minSize;

    } else if (dir.type == QIconDirInfo::Threshold) {

        return iconsize >= dir.size - dir.threshold &&

                iconsize <= dir.size + dir.threshold;

    } else if (dir.type == QIconDirInfo::Fallback) {

        return true;

    }

    Q_ASSERT(1); // Not a valid value

    return false;

}

/*

 * This algorithm is defined by the freedesktop spec:

 * http://standards.freedesktop.org/icon-theme-spec/icon-theme-spec-latest.html

 */

static int directorySizeDistance(const QIconDirInfo &dir, int iconsize, int iconscale)

{

    const int scaledIconSize = iconsize * iconscale;

    if (dir.type == QIconDirInfo::Fixed) {

        return qAbs(dir.size * dir.scale - scaledIconSize);

    } else if (dir.type == QIconDirInfo::Scalable) {

        if (scaledIconSize < dir.minSize * dir.scale)

            return dir.minSize * dir.scale - scaledIconSize;

        else if (scaledIconSize > dir.maxSize * dir.scale)

            return scaledIconSize - dir.maxSize * dir.scale;

        else

            return 0;

    } else if (dir.type == QIconDirInfo::Threshold) {

        if (scaledIconSize < (dir.size - dir.threshold) * dir.scale)

            return dir.minSize * dir.scale - scaledIconSize;

        else if (scaledIconSize > (dir.size + dir.threshold) * dir.scale)

            return scaledIconSize - dir.maxSize * dir.scale;

        else return 0;

    } else if (dir.type == QIconDirInfo::Fallback) {

        return 0;

    }

    Q_ASSERT(1); // Not a valid value

    return INT_MAX;

}

QIconLoaderEngineEntry *QIconLoaderEngine::entryForSize(const QThemeIconInfo &info, const QSize &size, int scale)

{

    int iconsize = qMin(size.width(), size.height());

    // Note that m_info.entries are sorted so that png-files

    // come first

    const int numEntries = info.entries.size();

    // Search for exact matches first

    for (int i = 0; i < numEntries; ++i) {

        QIconLoaderEngineEntry *entry = info.entries.at(i);

        if (directoryMatchesSize(entry->dir, iconsize, scale)) {

            return entry;

        }

    }

    // Find the minimum distance icon

    int minimalSize = INT_MAX;

    QIconLoaderEngineEntry *closestMatch = nullptr;

    for (int i = 0; i < numEntries; ++i) {

        QIconLoaderEngineEntry *entry = info.entries.at(i);

        int distance = directorySizeDistance(entry->dir, iconsize, scale);

        if (distance < minimalSize) {

            minimalSize  = distance;

            closestMatch = entry;

        }

    }

    return closestMatch;

}

/*

 * Returns the actual icon size. For scalable svg's this is equivalent

 * to the requested size. Otherwise the closest match is returned but

 * we can never return a bigger size than the requested size.

 *

 */

QSize QIconLoaderEngine::actualSize(const QSize &size, QIcon::Mode mode,

                                   QIcon::State state)

{

    Q_UNUSED(mode);

    Q_UNUSED(state);

    ensureLoaded();

    QIconLoaderEngineEntry *entry = entryForSize(m_info, size);

    if (entry) {

        const QIconDirInfo &dir = entry->dir;

        if (dir.type == QIconDirInfo::Scalable) {

            return size;

        } else if (dir.type == QIconDirInfo::Fallback) {

            return QIcon(entry->filename).actualSize(size, mode, state);

        } else {

            int result = qMin<int>(dir.size, qMin(size.width(), size.height()));

            return QSize(result, result);

        }

    }

    return QSize(0, 0);

}

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

{

    Q_UNUSED(state);

    // Ensure that basePixmap is lazily initialized before generating the

    // key, otherwise the cache key is not unique

    if (basePixmap.isNull())

        basePixmap.load(filename);

    QSize actualSize = basePixmap.size();

    // If the size of the best match we have (basePixmap) is larger than the

    // requested size, we downscale it to match.

    if (!actualSize.isNull() && (actualSize.width() > size.width() || actualSize.height() > size.height()))

        actualSize.scale(size, Qt::KeepAspectRatio);

    QString key = QLatin1String("$qt_theme_")

                  % HexString<qint64>(basePixmap.cacheKey())

                  % HexString<int>(mode)

                  % HexString<qint64>(QGuiApplication::palette().cacheKey())

                  % HexString<int>(actualSize.width())

                  % HexString<int>(actualSize.height());

    QPixmap cachedPixmap;

    if (QPixmapCache::find(key, &cachedPixmap)) {

        return cachedPixmap;

    } else {

        if (basePixmap.size() != actualSize)

            cachedPixmap = basePixmap.scaled(actualSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);

        else

            cachedPixmap = basePixmap;

        if (QGuiApplication *guiApp = qobject_cast<QGuiApplication *>(qApp))

            cachedPixmap = static_cast<QGuiApplicationPrivate*>(QObjectPrivate::get(guiApp))->applyQIconStyleHelper(mode, cachedPixmap);

        QPixmapCache::insert(key, cachedPixmap);

    }

    return cachedPixmap;

}

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

{

    if (svgIcon.isNull())

        svgIcon = QIcon(filename);

    // Bypass QIcon API, as that will scale by device pixel ratio of the

    // highest DPR screen since we're not passing on any QWindow.

    if (QIconEngine *engine = svgIcon.data_ptr() ? svgIcon.data_ptr()->engine : nullptr)

        return engine->pixmap(size, mode, state);

    return QPixmap();

}

QPixmap QIconLoaderEngine::pixmap(const QSize &size, QIcon::Mode mode,

                                 QIcon::State state)

{

    ensureLoaded();

    QIconLoaderEngineEntry *entry = entryForSize(m_info, size);

    if (entry)

        return entry->pixmap(size, mode, state);

    return QPixmap();

}

QString QIconLoaderEngine::key() const

{

    return QLatin1String("QIconLoaderEngine");

}

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

{

    ensureLoaded();

    switch (id) {

    case QIconEngine::AvailableSizesHook:

        {

            QIconEngine::AvailableSizesArgument &arg

                    = *reinterpret_cast<QIconEngine::AvailableSizesArgument*>(data);

            const int N = m_info.entries.size();

            QList<QSize> sizes;

            sizes.reserve(N);

            // Gets all sizes from the DirectoryInfo entries

            for (int i = 0; i < N; ++i) {

                const QIconLoaderEngineEntry *entry = m_info.entries.at(i);

                if (entry->dir.type == QIconDirInfo::Fallback) {

                    sizes.append(QIcon(entry->filename).availableSizes());

                } else {

                    int size = entry->dir.size;

                    sizes.append(QSize(size, size));

                }

            }

            arg.sizes.swap(sizes); // commit

        }

        break;

    case QIconEngine::IconNameHook:

        {

            QString &name = *reinterpret_cast<QString*>(data);

            name = m_info.iconName;

        }

        break;

    case QIconEngine::IsNullHook:

        {

            *reinterpret_cast<bool*>(data) = m_info.entries.isEmpty();

        }

        break;

    case QIconEngine::ScaledPixmapHook:

        {

            QIconEngine::ScaledPixmapArgument &arg = *reinterpret_cast<QIconEngine::ScaledPixmapArgument*>(data);

            // QIcon::pixmap() multiplies size by the device pixel ratio.

            const int integerScale = qCeil(arg.scale);

            QIconLoaderEngineEntry *entry = entryForSize(m_info, arg.size / integerScale, integerScale);

            arg.pixmap = entry ? entry->pixmap(arg.size, arg.mode, arg.state) : QPixmap();

        }

        break;

    default:

        QIconEngine::virtual_hook(id, data);

    }

}

QT_END_NAMESPACE

#endif //QT_NO_ICON