KisRecentFileIconCache Class Reference

#include <KisRecentFileIconCache.h>

Inheritance diagram for KisRecentFileIconCache:

Classes
struct	CacheItem

Signals
void	fileIconChanged (const QUrl &url, const QIcon &icon)

Public Member Functions
QIcon	getOrQueueFileIcon (const QUrl &url)
void	invalidateFileIcon (const QUrl &url)
	KisRecentFileIconCache ()
void	reloadFileIcon (const QUrl &url)
	~KisRecentFileIconCache ()

Static Public Member Functions
static KisRecentFileIconCache *	instance ()

Private Slots
void	cleanupOnQuit ()
void	futureCanceled ()
void	iconFetched ()

Private Attributes
float	m_devicePixelRatioF {1.0}
QMap< QUrl, CacheItem >	m_iconCacheMap
QThreadPool	m_iconFetchThreadPool

Detailed Description

Definition at line 16 of file KisRecentFileIconCache.h.

Constructor & Destructor Documentation

KisRecentFileIconCache()

KisRecentFileIconCache::KisRecentFileIconCache

(

)

DO NOT USE! Use instance() instead. This constructor is public only because it is needed by Q_GLOBAL_STATIC.

Definition at line 67 of file KisRecentFileIconCache.cpp.

{
    // Limit the number of threads used for icon fetching to prevent it from
    // impacting normal usage too much, and to prevent it from consuming too
    // much memory by loading too many large files.
    if (QThread::idealThreadCount() > 2) {
        m_iconFetchThreadPool.setMaxThreadCount(2);
    }
    if (qApp) {
        m_devicePixelRatioF = qMax(qApp->devicePixelRatio(), 1.0);
    }
    connect(qApp, SIGNAL(aboutToQuit()), SLOT(cleanupOnQuit()));
}

References cleanupOnQuit(), m_devicePixelRatioF, and m_iconFetchThreadPool.

~KisRecentFileIconCache()

KisRecentFileIconCache::~KisRecentFileIconCache

(

)

Definition at line 81 of file KisRecentFileIconCache.cpp.

{}

Member Function Documentation

cleanupOnQuit

void KisRecentFileIconCache::cleanupOnQuit ( )

privateslot

Definition at line 142 of file KisRecentFileIconCache.cpp.

{
    // We need to wait for the icon fetching to finish before letting qApp
    // be deleted, because the icon generation relies on qApp.
    m_iconFetchThreadPool.clear();
    m_iconFetchThreadPool.waitForDone();
}

References m_iconFetchThreadPool.

fileIconChanged

void KisRecentFileIconCache::fileIconChanged ( const QUrl & url, const QIcon & icon )

signal

futureCanceled

void KisRecentFileIconCache::futureCanceled ( )

privateslot

Definition at line 178 of file KisRecentFileIconCache.cpp.

{
    auto *watcher = dynamic_cast<QFutureWatcher<IconFetchResult> *>(QObject::sender());
    if (!watcher) {
        qWarning() << "KisRecentFileIconCache::futureCanceled() called but sender is not a QFutureWatcher";
        return;
    }
    watcher->deleteLater();
}

getOrQueueFileIcon()

QIcon KisRecentFileIconCache::getOrQueueFileIcon

(

const QUrl &

url

)

Get a cached icon or queue fetching of the icon.

If the icon is cached and available, the cached icon is returned. Otherwise, a null default-constructed QIcon will be returned, and the fetching of the icon may be queued in a background thread.

Definition at line 94 of file KisRecentFileIconCache.cpp.

{
    const QMap<QUrl, CacheItem>::const_iterator findItem = m_iconCacheMap.constFind(url);
    if (findItem != m_iconCacheMap.constEnd()) {
        // If the icon is still being fetched, this returns `QIcon()`.
        return findItem.value().cachedIcon;
    } else {
        if (!url.isLocalFile()) {
            // We don't fetch thumbnails for non-local files.
            return QIcon();
        }
        constexpr QSize iconSize(KisRecentDocumentsModelWrapper::ICON_SIZE_LENGTH, KisRecentDocumentsModelWrapper::ICON_SIZE_LENGTH);
        const GetFileIconParameters param = {
            url, // m_documentUrl
            iconSize, // m_iconSize
            m_devicePixelRatioF, // m_devicePixelRatioF
        };
        QFuture<IconFetchResult> future = QtConcurrent::run(&m_iconFetchThreadPool, getFileIcon, param);
        auto *watcher = new QFutureWatcher<IconFetchResult>(this);
        watcher->setFuture(future);
        connect(watcher, SIGNAL(finished()), SLOT(iconFetched()));
        connect(watcher, SIGNAL(canceled()), SLOT(futureCanceled()));
        const CacheItem cacheItem = { url, future, QIcon() };
        m_iconCacheMap.insert(url, cacheItem);
        return QIcon();
    }
}

References futureCanceled(), KisRecentDocumentsModelWrapper::ICON_SIZE_LENGTH, iconFetched(), iconSize(), m_devicePixelRatioF, m_iconCacheMap, and m_iconFetchThreadPool.

iconFetched

void KisRecentFileIconCache::iconFetched ( )

privateslot

Definition at line 150 of file KisRecentFileIconCache.cpp.

{
    auto *watcher = dynamic_cast<QFutureWatcher<IconFetchResult> *>(QObject::sender());
    if (!watcher) {
        qWarning() << "KisRecentFileIconCache::iconFetched() called but sender is not a QFutureWatcher";
        return;
    }
    QFuture<IconFetchResult> future = watcher->future();
    watcher->deleteLater();
    IconFetchResult result = future.result();
    auto findItem = m_iconCacheMap.find(result.m_documentUrl);
    if (findItem == m_iconCacheMap.end()) {
        qWarning() << "KisRecentFileIconCache item not found!";
        return;
    }
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
    if (findItem.value().fetchingFuture != future) {
        qWarning() << "KisRecentFileIconCache item has a different QFuture";
        return;
    }
#endif
    findItem.value().fetchingFuture = QFuture<IconFetchResult>();
    if (result.m_iconWasFetchedOk) {
        findItem.value().cachedIcon = result.m_icon;
        Q_EMIT fileIconChanged(result.m_documentUrl, result.m_icon);
    }
}

References fileIconChanged(), and m_iconCacheMap.

instance()

KisRecentFileIconCache * KisRecentFileIconCache::instance ( )

static

Definition at line 85 of file KisRecentFileIconCache.cpp.

{
    if (QThread::currentThread() != qApp->thread()) {
        qWarning() << "KisRecentFileIconCache::instance() called from non-GUI thread!";
        return nullptr;
    }
    return s_instance;
}

invalidateFileIcon()

void KisRecentFileIconCache::invalidateFileIcon

(

const QUrl &

url

)

Invalidate (remove) a cached file icon. If the file icon is still in the process of being loaded, its result will be discarded.

Definition at line 122 of file KisRecentFileIconCache.cpp.

{
    QMap<QUrl, CacheItem>::iterator findItem = m_iconCacheMap.find(url);
    if (findItem == m_iconCacheMap.end()) {
        return;
    }
    // Note: Futures returned by `QtConcurrent::run` does not support
    // cancellation, but we try anyway.
    if (!findItem.value().fetchingFuture.isCanceled()) {
        findItem.value().fetchingFuture.cancel();
    }
    m_iconCacheMap.erase(findItem);
}

References m_iconCacheMap.

reloadFileIcon()

void KisRecentFileIconCache::reloadFileIcon

(

const QUrl &

url

)

Invalidate a cached file icon and trigger a reload of it.

Definition at line 136 of file KisRecentFileIconCache.cpp.

{
    invalidateFileIcon(url);
    getOrQueueFileIcon(url);
}

References getOrQueueFileIcon(), and invalidateFileIcon().

Member Data Documentation

m_devicePixelRatioF

float KisRecentFileIconCache::m_devicePixelRatioF {1.0}

private

Definition at line 24 of file KisRecentFileIconCache.h.

{1.0};

m_iconCacheMap

QMap<QUrl, CacheItem> KisRecentFileIconCache::m_iconCacheMap

private

Definition at line 22 of file KisRecentFileIconCache.h.

m_iconFetchThreadPool

QThreadPool KisRecentFileIconCache::m_iconFetchThreadPool

private

Definition at line 23 of file KisRecentFileIconCache.h.

---

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

• libs/ui/utils/KisRecentFileIconCache.h
• libs/ui/utils/KisRecentFileIconCache.cpp