How to create custom icons for QFileSystemModel in

Question

I am making a file browser in qt for some custom design-files. I want to load their preview as their thumbnail and for that reason I am using QIconProvider to return the Icon to my QFileSystemModel.

The problem is that the algorithm that creates the QIcon needs some resources and as a result my application is not responsive until it finishes loading all the thumbnails.

I am wondering if there is any way to put my QIconProvider in a background thread, so that I have my application responsive.

Answer 1

The accepted answer is fantastic - introduced me to some of the more advanced Qt concepts.

For anyone trying this in the future, here's some changes I had to make to get this working smoothly:

• Limit threads: Pass a QThreadPool to QConcurrent::run, with max threads set to 1 or 2. Using the default killed the app, as all threads get burned building image previews. Bottleneck will be disk, so doesn't make sense to have more than 1 or 2 threads on this task.
• Avoid re-entry: Need to handle the case where the icon for the same path is queried multiple times before icon generation is complete. Current code would spawn multiple threads generating the same icon. Simple solution is to add a placeholder entry to the m_icons map before the QConcurrent::run call. I just called to the default QIdentityProxyModel::data(index, QFileSystemModel::FileIconRole), so the icon gets a decent default before loading is complete
• Task cancellation: If you destroy your model (or want to switch view folders, etc.), you'll want a way to cancel the active tasks. Unfortunately, there's no built-in way to cancel a pending QConcurrent::run task. I used a std::atomic_bool to signal cancellation, which the tasks check before executing. And a std::condition_variable to wait on until all tasks are cancelled/complete.

Tip: My use case for this was to load thumbnail previews from images on disk (likely the common use case). After some experimentation, I found that the fastest way to generate previews is to use QImageReader, passing your thumbnail size to setScaledSize. Note that if you have non-square images, you'll want to pass a size with the appropriate aspect ratio like this:

    const QSize originalSize = reader.size(); // Note: Doesn't load the file contents
    QSize scaledSize = originalSize;
    scaledSize.scale(MaximumIconSize, Qt::KeepAspectRatio);
    reader.setScaledSize(scaledSize);

Answer 2

Unfortunately, there's an impedance mismatch between the QFileIconProvider API and the model api: the QFileSystemModel provides asynchronous notifications to the view when things change, but the icon provider can't asynchronously notify the model when icons change or become known.

You can install an identity proxy between the file system model and the view(s). That proxy's data method would then query the icons asynchronously. The model's synchronous icon provider is then unused and unnecessary.

// https://github.com/KubaO/stackoverflown/tree/master/questions/icon-proxy-39144638
#include <QtWidgets>
#include <QtConcurrent>

/// A thread-safe function that returns an icon for an item with a given path.
/// If the icon is not known, a null icon is returned.
QIcon getIcon(const QString & path);

class IconProxy : public QIdentityProxyModel {
    Q_OBJECT
    QMap<QString, QIcon> m_icons;
    Q_SIGNAL void hasIcon(const QString&, const QIcon&, const QPersistentModelIndex& index) const;
    void onIcon(const QString& path, const QIcon& icon, const QPersistentModelIndex& index) {
        m_icons.insert(path, icon);
        emit dataChanged(index, index, QVector<int>{QFileSystemModel::FileIconRole});
    }
public:
    QVariant data(const QModelIndex & index, int role = Qt::DisplayRole) const override {
        if (role == QFileSystemModel::FileIconRole) {
            auto path = index.data(QFileSystemModel::FilePathRole).toString();
            auto it = m_icons.find(path);
            if (it != m_icons.end()) {
                if (! it->isNull()) return *it;
                return QIdentityProxyModel::data(index, role);
            }
            QPersistentModelIndex pIndex{index};
            QtConcurrent::run([this,path,pIndex]{
                emit hasIcon(path, getIcon(path), pIndex);
            });
            return QVariant{};
        }
        return QIdentityProxyModel::data(index, role);
    }
    IconProxy(QObject * parent = nullptr) : QIdentityProxyModel{parent} {
        connect(this, &IconProxy::hasIcon, this, &IconProxy::onIcon);
    }
};