blame: src/imagemodel.cpp

/*

MIT License

Copyright (c) 2026 Poul Sander

Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the "Software"), to deal

in the Software without restriction, including without limitation the rights

to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

copies of the Software, and to permit persons to whom the Software is

furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all

copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

SOFTWARE.

*/

#include "imagemodel.h"

#include "thumbnailworker.h"

#include <QImageReader>

#include <QFileIconProvider>

#include <algorithm>

#include <filesystem>

#include <vector>

ImageModel::ImageModel(QObject *parent)

    : QAbstractListModel(parent)

{

    // Limit 1 thread for thumbnail loading to avoid excessive disk I/O on harddrives. SSDs are so fast the extra threads don't help much anyway.

    m_threadPool.setMaxThreadCount(1);  //QThread::idealThreadCount()

    m_placeholder = QPixmap(128, 128);

    m_placeholder.fill(Qt::lightGray);

    QFileIconProvider iconProvider;

    m_folderIcon = iconProvider.icon(QFileIconProvider::Folder);

}

ImageModel::~ImageModel()

{

    m_cancelFlag = true;

    m_threadPool.waitForDone();

}

void ImageModel::setCacheMaxSize(int n)

{

    m_cacheMaxSize = std::max(0, n);

    while (m_cacheOrder.size() > m_cacheMaxSize)

        m_folderThumbnailCache.remove(m_cacheOrder.takeFirst());

}

void ImageModel::setThumbnailSize(ThumbnailCache::Size size)

{

    if (size == m_thumbnailSize)

        return;

    m_thumbnailSize = size;

    // Cancel any in-flight workers (they were started with the previous size).

    m_cancelFlag = true;

    m_threadPool.waitForDone();

    m_cancelFlag = false;

    m_pendingRows.clear();

    // The folder cache is keyed by directory and size-agnostic; drop it so the

    // user actually sees the new size.

    m_folderThumbnailCache.clear();

    m_cacheOrder.clear();

    // Mark existing image entries unloaded so they get re-fetched at the new size.

    if (!m_items.isEmpty())

    {

        for (int row = 0; row < m_items.size(); ++row)

        {

            Item &item = m_items[row];

            if (item.isFolder)

                continue;

            item.thumbnail = m_placeholder;

            item.loaded = false;

        }

        emit dataChanged(index(0), index(m_items.size() - 1),

                         {Qt::DecorationRole});

    }

}

void ImageModel::setDirectory(const QString &path)

{

    setDirectory(QFile::encodeName(path));

}

void ImageModel::setDirectory(const QByteArray &path)

{

    m_cancelFlag = true;

    m_threadPool.waitForDone();

    m_cancelFlag = false;

    // Save current folder's thumbnails to cache before discarding them

    if (!m_currentDir.isEmpty()) {

        ThumbnailMap map;

        for (const Item &item : m_items)

            if (item.loaded && !item.isFolder)

                map[item.path] = item.thumbnail;

        if (!map.isEmpty()) {

            if (!m_cacheOrder.contains(m_currentDir)) {

                m_cacheOrder.append(m_currentDir);

                if (m_cacheOrder.size() > m_cacheMaxSize)

                    m_folderThumbnailCache.remove(m_cacheOrder.takeFirst());

            }

            m_folderThumbnailCache[m_currentDir] = std::move(map);

        }

    }

    beginResetModel();

    m_items.clear();

    m_pendingRows.clear();

    m_currentDir = path;

    // Build set of supported image extensions (lower-case, without dot)

    QSet<QByteArray> imageExts;

    for (const QByteArray &fmt : QImageReader::supportedImageFormats())

        imageExts.insert(fmt.toLower());

    // Use std::filesystem::directory_iterator so that directory entries with

    // non-UTF-8 filenames (e.g. Latin-1 encoded names) are not silently

    // skipped or mangled as they would be with QDir::entryInfoList().

    namespace fs = std::filesystem;

    std::vector<std::string> dirs;

    std::vector<std::string> imageFiles;

    try {

        fs::path dirPath(path.toStdString());

        // Add ".." parent entry directly with the literal display name ".."

        // (mirrors QDir::NoDot behaviour)

        fs::path parentPath = dirPath.parent_path();

        if (!parentPath.empty() && parentPath != dirPath) {

            QPixmap folderPixmap = m_folderIcon.pixmap(128, 128);

            m_items.append({QByteArray::fromStdString(parentPath.native()),

                            QStringLiteral(".."), folderPixmap, true, true});

        }

        for (const fs::directory_entry &entry :

             fs::directory_iterator(dirPath,

                 fs::directory_options::skip_permission_denied))

        {

            std::error_code ec;

            const std::string fname = entry.path().filename().native();

            if (fname.empty() || fname[0] == '.')

                continue;   // skip hidden entries

            if (entry.is_directory(ec)) {

                dirs.push_back(entry.path().native());

            } else if (entry.is_regular_file(ec)) {

                // Filter by image extension

                const std::string &nativeExt = entry.path().extension().native();

                if (nativeExt.empty())

                    continue;

                // extension() includes the dot; strip it and lower-case

                QByteArray ext = QByteArray(nativeExt.c_str() + 1,

                                           static_cast<qsizetype>(nativeExt.size()) - 1).toLower();

                if (imageExts.contains(ext))

                    imageFiles.push_back(entry.path().native());

            }

        }

    } catch (const fs::filesystem_error &) {

        // Directory unreadable — show empty listing

    }

    // Sort subdirectories by filename

    std::sort(dirs.begin(), dirs.end(),

              [](const auto &a, const auto &b) {

                  return fs::path(a).filename() < fs::path(b).filename();

              });

    std::sort(imageFiles.begin(), imageFiles.end(),

              [](const auto &a, const auto &b) {

                  return fs::path(a).filename() < fs::path(b).filename();

              });

    QPixmap folderPixmap = m_folderIcon.pixmap(128, 128);

    for (const std::string &nativePath : dirs)

    {

        QByteArray entryPath = QByteArray::fromStdString(nativePath);

        std::string fname = fs::path(nativePath).filename().native();

        QString displayName = QString::fromLocal8Bit(fname.c_str(),

                                                     static_cast<qsizetype>(fname.size()));

        m_items.append({entryPath, displayName, folderPixmap, true, true});

    }

    // Restore cached thumbnails for this folder if available

    const ThumbnailMap *cached = m_folderThumbnailCache.contains(path)

        ? &m_folderThumbnailCache[path]

        : nullptr;

    for (const std::string &nativePath : imageFiles)

    {

        QByteArray entryPath = QByteArray::fromStdString(nativePath);

        std::string fname = fs::path(nativePath).filename().native();

        QString displayName = QString::fromLocal8Bit(fname.c_str(),

                                                     static_cast<qsizetype>(fname.size()));

        QPixmap thumb = m_placeholder;

        bool loaded = false;

        if (cached) {

            auto it = cached->find(entryPath);

            if (it != cached->end()) {

                thumb = it.value();

                loaded = true;

            }

        }

        m_items.append({entryPath, displayName, thumb, loaded, false});

    }

    endResetModel();

}

void ImageModel::requestThumbnails(int firstRow, int lastRow)

{

    if (m_items.isEmpty())

        return;

    firstRow = std::max(0, firstRow);

    lastRow = std::min(lastRow, static_cast<int>(m_items.size()) - 1);

    for (int row = firstRow; row <= lastRow; ++row)

    {

        if (!m_items[row].loaded && !m_items[row].isFolder)

            queueRow(row);

    }

    // Optional: preload nearby rows

    int buffer = 20;

    for (int row = firstRow - buffer; row < firstRow; ++row)

        if (row >= 0 && !m_items[row].loaded && !m_items[row].isFolder)

            queueRow(row);

    for (int row = lastRow + 1; row <= lastRow + buffer; ++row)

        if (row < m_items.size() && !m_items[row].loaded && !m_items[row].isFolder)

            queueRow(row);

}

void ImageModel::refreshThumbnail(const QModelIndex &index)

{

    if (!index.isValid())

        return;

    const int row = index.row();

    if (row < 0 || row >= m_items.size() || m_items[row].isFolder)

        return;

    // The on-disk thumbnail cache is keyed by source mtime, so it invalidates

    // itself once the file is rewritten. Drop the in-memory copy and re-decode.

    m_items[row].thumbnail = m_placeholder;

    m_items[row].loaded = false;

    emit dataChanged(index, index, {Qt::DecorationRole});

    queueRow(row);

}

void ImageModel::queueRow(int row)

{

    if (m_pendingRows.contains(row))

        return;

    m_pendingRows.insert(row);

    auto *worker = new ThumbnailWorker(

        m_items[row].path,

        row,

        m_thumbnailSize,

        &m_cancelFlag);

    // THREADING: Explicit QueuedConnection ensures thumbnailReady() is invoked

    // on the main thread even though the signal is emitted from a pool thread.

    // This means all m_items[] mutations happen on the main thread only.

    connect(worker, &ThumbnailWorker::finished,

            this, &ImageModel::thumbnailReady,

            Qt::QueuedConnection);

    m_threadPool.start(worker);

}

QByteArray ImageModel::filePath(const QModelIndex &index) const

{

    if (!index.isValid())

        return {};

    return m_items[index.row()].path;

}

bool ImageModel::isFolder(const QModelIndex &index) const

{

    if (!index.isValid() || index.row() >= m_items.size())

        return false;

    return m_items[index.row()].isFolder;

}

QByteArray ImageModel::currentDirectory() const

{

    return m_currentDir;

}

int ImageModel::rowCount(const QModelIndex &) const

{

    return m_items.size();

}

QVariant ImageModel::data(const QModelIndex &index, int role) const

{

    if (!index.isValid())

        return {};

    const Item &item = m_items[index.row()];

    if (role == Qt::DecorationRole)

        return item.thumbnail;

    if (role == Qt::DisplayRole)

        return item.displayName;

    if (role == Qt::UserRole)

        return item.isFolder;

    return {};

}

void ImageModel::thumbnailReady(int row, const QImage &image)

{

    if (m_cancelFlag)

        return;

    if (row < 0 || row >= m_items.size())

        return;

    m_items[row].thumbnail = QPixmap::fromImage(image);

    m_items[row].loaded = true;

    m_pendingRows.remove(row);

    QModelIndex idx = index(row);

    emit dataChanged(idx, idx, {Qt::DecorationRole});

}