blame: src/mainwindow.cpp

#include "mainwindow.h"

#include "imagemodel.h"

#include "imageviewwidget.h"

#include "preferencesdialog.h"

#include "shortcutmanager.h"

#include "thumbnailcache.h"

#include "exifreader.h"

#include "fsdirmodel.h"

#include "pathcompletermodel.h"

#include "thumbnaildelegate.h"

#include <QTreeView>

#include <QLabel>

#include <QStackedWidget>

#include <QDir>

#include <QListWidget>

#include <QStandardPaths>

#include <QImageReader>

#include <QHeaderView>

#include <QScrollBar>

#include <QTimer>

#include <QEvent>

#include <QItemSelectionModel>

#include <QDockWidget>

#include <QMenuBar>

#include <QMenu>

#include <QAction>

#include <QSettings>

#include <QTableWidget>

#include <QDialog>

#include <QHBoxLayout>

#include <QPlainTextEdit>

#include <QMessageBox>

#include <QLineEdit>

#include <QPushButton>

#include <QCompleter>

#include <QClipboard>

#include <QDialogButtonBox>

#include <QFile>

#include <QFileInfo>

#include <QGuiApplication>

#include <QVBoxLayout>

#include <iostream>

#include <fcntl.h>

#include <filesystem>

#include <sys/stat.h>

#include <unistd.h>

namespace

{

ThumbnailCache::Size thumbnailSizeFromString(const QString &s)

{

    return (s == "large") ? ThumbnailCache::Size::Large

                          : ThumbnailCache::Size::Normal;

}

QString displayPath(const QByteArray &path)

{

    return QString::fromLocal8Bit(path.constData(), path.size());

}

QString filenameFromPath(const QByteArray &path)

{

    const std::filesystem::path fsPath(path.toStdString());

    const std::string nativeName = fsPath.filename().native();

    return QString::fromLocal8Bit(nativeName.data(),

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

}

} // namespace

MainWindow::MainWindow(QWidget *parent)

    : QMainWindow(parent)

{

    setupUi();

    setupMenuBar();

    setupConnections();

    loadPreferences();

}

void MainWindow::setupUi()

{

    // Folder model (left pane) — backed by std::filesystem so directories with

    // non-UTF-8 filenames are listed correctly.

    m_dirModel = new FsDirModel(this);

    m_dirModel->setRootPath(QDir::homePath());

    // Root chooser list

    m_rootList = new QListWidget;

    m_rootList->setSelectionMode(QAbstractItemView::SingleSelection);

    auto addRootItem = [this](const QString &label, const QString &path) {

        QListWidgetItem *item = new QListWidgetItem(label, m_rootList);

        item->setData(Qt::UserRole, path);

    };

    addRootItem(tr("Home"), QDir::homePath());

    addRootItem(tr("Pictures"), QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));

    addRootItem(tr("File System"), QDir::rootPath());

    m_rootList->setCurrentRow(0);

    m_treeView = new QTreeView;

    m_treeView->setModel(m_dirModel);

    m_treeView->setRootIndex(m_dirModel->rootIndex());

    m_treeView->header()->hide();

    m_treeView->setColumnHidden(1, true);

    m_treeView->setColumnHidden(2, true);

    m_treeView->setColumnHidden(3, true);

    // Thumbnail model (center pane)

    m_imageModel = new ImageModel(this);

    m_listView = new QListView;

    m_listView->setModel(m_imageModel);

    m_listView->setViewMode(QListView::IconMode);

    m_listView->setIconSize(QSize(128, 128));

    m_listView->setGridSize(QSize(148, 168));

    m_listView->setResizeMode(QListView::Adjust);

    m_listView->setSelectionMode(QAbstractItemView::SingleSelection);

    m_listView->setSpacing(4);

    m_listView->setWordWrap(true);

    m_listView->setTextElideMode(Qt::ElideRight);

    m_listView->setItemDelegate(new ThumbnailDelegate(this));

    m_listView->setContextMenuPolicy(Qt::CustomContextMenu);

    // Preview pane (right)

    m_previewLabel = new QLabel;

    m_previewLabel->setAlignment(Qt::AlignCenter);

    m_previewLabel->setMinimumWidth(200);

    // Single image view

    m_imageView = new ImageViewWidget;

    m_imageView->setContextMenuPolicy(Qt::CustomContextMenu);

    // Path bar: editable absolute path with ajax-style folder completion and a Go button

    m_pathEdit = new QLineEdit;

    m_goButton = new QPushButton(tr("Go"));

    m_prevFolderButton = new QPushButton(tr("Prev"));

    m_nextFolderButton = new QPushButton(tr("Next"));

    m_pathCompleterModel = new PathCompleterModel(this);

    m_pathCompleter = new QCompleter(m_pathCompleterModel, this);

    m_pathCompleter->setCaseSensitivity(Qt::CaseSensitive);

    m_pathCompleter->setCompletionMode(QCompleter::PopupCompletion);

    m_pathCompleter->setFilterMode(Qt::MatchStartsWith);

    m_pathEdit->setCompleter(m_pathCompleter);

    auto *pathRow = new QHBoxLayout;

    pathRow->setContentsMargins(4, 4, 4, 0);

    pathRow->addWidget(m_pathEdit, 1);

    pathRow->addWidget(m_goButton);

    pathRow->addWidget(m_prevFolderButton);

    pathRow->addWidget(m_nextFolderButton);

    auto *browserPage = new QWidget;

    auto *vbox = new QVBoxLayout(browserPage);

    vbox->setContentsMargins(0, 0, 0, 0);

    vbox->setSpacing(0);

    vbox->addLayout(pathRow);

    vbox->addWidget(m_listView, 1);

    // Stack to switch between browser and single image

    m_stack = new QStackedWidget;

    m_stack->addWidget(browserPage);

    m_stack->addWidget(m_imageView);

    m_browserPage = browserPage;

    setCentralWidget(m_stack);

    updatePathField(QFile::encodeName(QDir::homePath()));

    // Dock widgets — can be dragged, floated and stacked by the user

    m_rootDock = new QDockWidget(tr("Roots"), this);

    m_rootDock->setObjectName("RootDock");

    m_rootDock->setWidget(m_rootList);

    addDockWidget(Qt::LeftDockWidgetArea, m_rootDock);

    m_folderDock = new QDockWidget(tr("Folders"), this);

    m_folderDock->setObjectName("FolderDock");

    m_folderDock->setWidget(m_treeView);

    addDockWidget(Qt::LeftDockWidgetArea, m_folderDock);

    splitDockWidget(m_rootDock, m_folderDock, Qt::Vertical);

    m_previewDock = new QDockWidget(tr("Preview"), this);

    m_previewDock->setObjectName("PreviewDock");

    m_previewDock->setWidget(m_previewLabel);

    addDockWidget(Qt::RightDockWidgetArea, m_previewDock);

    // EXIF info dock — placed below the preview dock by default

    m_exifTable = new QTableWidget(0, 2);

    m_exifTable->setHorizontalHeaderLabels({tr("Field"), tr("Value")});

    m_exifTable->horizontalHeader()->setStretchLastSection(true);

    m_exifTable->verticalHeader()->hide();

    m_exifTable->setEditTriggers(QAbstractItemView::NoEditTriggers);

    m_exifTable->setSelectionMode(QAbstractItemView::NoSelection);

    m_exifTable->setShowGrid(false);

    m_exifTable->setAlternatingRowColors(true);

    m_exifTable->setMinimumWidth(200);

    m_exifDock = new QDockWidget(tr("EXIF Info"), this);

    m_exifDock->setObjectName("ExifDock");

    m_exifDock->setWidget(m_exifTable);

    addDockWidget(Qt::RightDockWidgetArea, m_exifDock);

    splitDockWidget(m_previewDock, m_exifDock, Qt::Vertical);

}

void MainWindow::setupMenuBar()

{

    m_menuBar = menuBar();

    m_menuBar->setStyleSheet(

        "QMenuBar { padding: 1px 2px; }"

        "QMenuBar::item { padding: 2px 6px; }"

    );

    QMenu *viewMenu = m_menuBar->addMenu(tr("&View"));

    viewMenu->addAction(m_rootDock->toggleViewAction());

    viewMenu->addAction(m_folderDock->toggleViewAction());

    viewMenu->addAction(m_previewDock->toggleViewAction());

    viewMenu->addAction(m_exifDock->toggleViewAction());

    QMenu *editMenu = m_menuBar->addMenu(tr("&Edit"));

    QAction *preferencesAction = editMenu->addAction(tr("&Preferences"));

    connect(preferencesAction, &QAction::triggered, this, &MainWindow::onPreferencesTriggered);

}

void MainWindow::navigateToFolder(const QString &path)

{

    navigateToFolder(QFile::encodeName(path));

}

QByteArray MainWindow::siblingFolder(int delta) const

{

    QByteArray currentDir = m_imageModel->currentDirectory();

    if (currentDir.isEmpty())

        return {};

    namespace fs = std::filesystem;

    fs::path current(currentDir.toStdString());

    fs::path parent = current.parent_path();

    if (parent.empty() || parent == current)

        return {};

    QByteArray parentPath = QByteArray::fromStdString(parent.native());

    QModelIndex parentIdx = m_dirModel->indexForPath(parentPath);

    if (!parentIdx.isValid())

        return {};

    int count = m_dirModel->rowCount(parentIdx);

    int currentRow = -1;

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

        QModelIndex idx = m_dirModel->index(i, 0, parentIdx);

        if (m_dirModel->filePath(idx) == currentDir) {

            currentRow = i;

            break;

        }

    }

    if (currentRow < 0)

        return {};

    int targetRow = currentRow + delta;

    if (targetRow < 0 || targetRow >= count)

        return {};

    QModelIndex targetIdx = m_dirModel->index(targetRow, 0, parentIdx);

    return m_dirModel->filePath(targetIdx);

}

void MainWindow::navigateToPrevFolder()

{

    QByteArray path = siblingFolder(-1);

    if (!path.isEmpty())

        navigateToFolder(path);

}

void MainWindow::navigateToNextFolder()

{

    QByteArray path = siblingFolder(+1);

    if (!path.isEmpty())

        navigateToFolder(path);

}

void MainWindow::navigateToFolder(const QByteArray &path)

{

    m_previousFolderPath = m_imageModel->currentDirectory();

    m_imageModel->setDirectory(path);

    QModelIndex dirIdx = m_dirModel->indexForPath(path);

    if (dirIdx.isValid())

        m_treeView->setCurrentIndex(dirIdx);

    updatePathField(path);

    QTimer::singleShot(0, this, [this]() {

        selectPreviousFolderIfExists();

        loadVisibleThumbnails();

    });

}

void MainWindow::updatePathField(const QByteArray &path)

{

    if (!m_pathEdit)

        return;

    const QString text = QFile::decodeName(path);

    if (m_pathEdit->text() != text)

        m_pathEdit->setText(text);

}

void MainWindow::onPathEntered()

{

    const QString text = m_pathEdit->text().trimmed();

    if (text.isEmpty())

        return;

    openPath(text);

}

void MainWindow::openPath(const QString &path)

{

    QFileInfo info(path);

    if (!info.exists())

        return;

    if (info.isDir()) {

        navigateToFolder(QFile::encodeName(info.absoluteFilePath()));

    } else if (info.isFile()) {

        navigateToFolder(QFile::encodeName(info.absolutePath()));

        // ImageModel::setDirectory is synchronous, so items are ready now.

        // Find the file in the model and open it.

        QByteArray target = QFile::encodeName(info.absoluteFilePath());

        for (int i = 0; i < m_imageModel->rowCount(); ++i) {

            QModelIndex idx = m_imageModel->index(i);

            if (m_imageModel->filePath(idx) == target) {

                m_listView->setCurrentIndex(idx);

                m_listView->scrollTo(idx);

                showPreview(idx);

                if (!m_imageModel->isFolder(idx))

                    enterSingleImageMode(idx);

                break;

            }

        }

    }

}

void MainWindow::selectPreviousFolderIfExists()

{

    if (m_previousFolderPath.isEmpty())

        return;

    // Find the previous folder in the current directory's contents

    for (int i = 0; i < m_imageModel->rowCount(); ++i) {

        QModelIndex idx = m_imageModel->index(i);

        if (m_imageModel->isFolder(idx)) {

            QByteArray folderPath = m_imageModel->filePath(idx);

            if (folderPath == m_previousFolderPath) {

                m_listView->setCurrentIndex(idx);

                m_listView->scrollTo(idx);

                return;

            }

        }

    }

}

void MainWindow::setupConnections()

{

    connect(m_pathEdit, &QLineEdit::returnPressed,

            this, &MainWindow::onPathEntered);

    connect(m_goButton, &QPushButton::clicked,

            this, &MainWindow::onPathEntered);

    connect(m_prevFolderButton, &QPushButton::clicked,

            this, &MainWindow::navigateToPrevFolder);

    connect(m_nextFolderButton, &QPushButton::clicked,

            this, &MainWindow::navigateToNextFolder);

    connect(m_pathEdit, &QLineEdit::textEdited,

            m_pathCompleterModel, &PathCompleterModel::setPrefix);

    connect(m_rootList, &QListWidget::currentItemChanged, this,

            [this](QListWidgetItem *current, QListWidgetItem *) {

                if (current == nullptr)

                    return;

                QString rootPath = current->data(Qt::UserRole).toString();

                m_dirModel->setRootPath(rootPath);

                m_treeView->setRootIndex(m_dirModel->rootIndex());

            });

    connect(m_treeView, &QTreeView::clicked, this,

            [this](const QModelIndex &index)

            {

                QByteArray path = m_dirModel->filePath(index);

                navigateToFolder(path);

            });

    connect(m_listView, &QListView::clicked, this,

            [this](const QModelIndex &index) { showPreview(index); });

    connect(m_listView->selectionModel(), &QItemSelectionModel::currentChanged,

            this, [this](const QModelIndex &current) { showPreview(current); });

    connect(m_listView, &QListView::doubleClicked, this,

            [this](const QModelIndex &index) {

                if (m_imageModel->isFolder(index)) {

                    QByteArray path = m_imageModel->filePath(index);

                    navigateToFolder(path);

                } else {

                    enterSingleImageMode(index);

                }

            });

    connect(m_listView, &QListView::customContextMenuRequested,

            this, &MainWindow::showImageContextMenu);

    connect(m_imageView, &ImageViewWidget::customContextMenuRequested,

            this, &MainWindow::showImageViewContextMenu);

    connect(m_imageView, &ImageViewWidget::closeRequested,

            this, &MainWindow::leaveSingleImageMode);

    connect(m_imageView, &ImageViewWidget::editCaptionRequested,

        this, &MainWindow::onEditCaption);

    connect(m_imageView, &ImageViewWidget::nextRequested, this, [this]() {

        QModelIndex cur = m_listView->currentIndex();

        int next = cur.isValid() ? cur.row() + 1 : 0;

        while (next < m_imageModel->rowCount() && m_imageModel->isFolder(m_imageModel->index(next)))

            ++next;

        if (next < m_imageModel->rowCount())

        {

            QModelIndex idx = m_imageModel->index(next);

            m_listView->setCurrentIndex(idx);

            enterSingleImageMode(idx);

        }

    });

    connect(m_imageView, &ImageViewWidget::previousRequested, this, [this]() {

        QModelIndex cur = m_listView->currentIndex();

        int prev = cur.isValid() ? cur.row() - 1 : 0;

        while (prev >= 0 && m_imageModel->isFolder(m_imageModel->index(prev)))

            --prev;

        if (prev >= 0)

        {

            QModelIndex idx = m_imageModel->index(prev);

            m_listView->setCurrentIndex(idx);

            enterSingleImageMode(idx);

        }

    });

    connect(m_listView->verticalScrollBar(), &QScrollBar::valueChanged,

            this, [this]()

            { loadVisibleThumbnails(); });

    // Also catch resize — visible range changes when the viewport is resized

    m_listView->viewport()->installEventFilter(this);

    // The folder list and tree views consume Ctrl+Left/Ctrl+Right for their own

    // item navigation, so those keys never reach MainWindow::keyPressEvent.

    // Filter them here so PrevFolder/NextFolder shortcuts work while a view has focus.

    m_listView->installEventFilter(this);

    m_treeView->installEventFilter(this);

}

bool MainWindow::eventFilter(QObject *obj, QEvent *event)

{

    if (obj == m_listView->viewport() && event->type() == QEvent::Resize)

        QTimer::singleShot(0, this, &MainWindow::loadVisibleThumbnails);

    if ((obj == m_listView || obj == m_treeView)

        && event->type() == QEvent::KeyPress

        && m_stack->currentWidget() == m_browserPage)

    {

        const ShortcutManager &sc = ShortcutManager::instance();

        QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);

        if (sc.matches(keyEvent, ShortcutManager::PrevFolder)) {

            navigateToPrevFolder();

            return true;

        }

        if (sc.matches(keyEvent, ShortcutManager::NextFolder)) {

            navigateToNextFolder();

            return true;

        }

        if (obj == m_listView

            && sc.matches(keyEvent, ShortcutManager::MoveToTrash)) {

            moveCurrentImageToTrash();

            return true;

        }

    }

    return QMainWindow::eventFilter(obj, event);

}

void MainWindow::loadVisibleThumbnails()

{

    QModelIndex topLeft = m_listView->indexAt(QPoint(0, 0));

    QModelIndex bottomRight = m_listView->indexAt(

        QPoint(m_listView->viewport()->width() - 1,

               m_listView->viewport()->height() - 1));

    int first = topLeft.isValid() ? topLeft.row() : 0;

    int last = bottomRight.isValid() ? bottomRight.row()

                                     : m_imageModel->rowCount() - 1;

    if (last < 0)

        return;

    std::cout << "loadVisibleThumbnails: " << first << " - " << last << "\n";

    m_imageModel->requestThumbnails(first, last);

}

void MainWindow::showPreview(const QModelIndex &index)

{

    if (!index.isValid())

        return;

    QByteArray path = m_imageModel->filePath(index);

    int fd = ::open(path.constData(), O_RDONLY | O_CLOEXEC);

    if (fd >= 0) {

        QFile file;

        if (file.open(fd, QIODevice::ReadOnly, QFileDevice::AutoCloseHandle)) {

            QImageReader reader(&file);

            reader.setAutoTransform(true);

            QSize fullSize = reader.size();

            if (fullSize.isValid()) {

                QSize target = fullSize.scaled(m_previewLabel->size(), Qt::KeepAspectRatio);

                reader.setScaledSize(target);

            }

            QImage image = reader.read();

            m_previewLabel->setPixmap(

                QPixmap::fromImage(image).scaled(

                    m_previewLabel->size(),

                    Qt::KeepAspectRatio,

                    Qt::SmoothTransformation));

        }

    }

    updateExifInfo(path);

}

void MainWindow::updateExifInfo(const QByteArray &path)

{

    // Check if this is a folder by attempting stat

    struct ::stat st{};

    if (::stat(path.constData(), &st) != 0 || S_ISDIR(st.st_mode)) {

        m_exifTable->setRowCount(0);

        return;

    }

    const ExifData data = ExifReader::read(path);

    const auto fields = data.toList();

    m_exifTable->setRowCount(fields.size());

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

        m_exifTable->setItem(i, 0, new QTableWidgetItem(fields[i].first));

        m_exifTable->setItem(i, 1, new QTableWidgetItem(fields[i].second));

    }

    m_exifTable->resizeColumnToContents(0);

}

void MainWindow::enterSingleImageMode(const QModelIndex &index)

{

    if (!index.isValid())

        return;

    // Only save state and hide chrome when transitioning from browse mode

    if (m_stack->currentWidget() != m_imageView) {

        m_rootDockWasVisible = m_rootDock->isVisible();

        m_folderDockWasVisible = m_folderDock->isVisible();

        m_previewDockWasVisible = m_previewDock->isVisible();

        m_exifDockWasVisible = m_exifDock->isVisible();

        m_rootDock->hide();

        m_folderDock->hide();

        m_previewDock->hide();

        m_exifDock->hide();

        m_menuBar->hide();

    }

    m_imageView->setBackgroundColor(m_backgroundColorPreference);

    QByteArray path = m_imageModel->filePath(index);

    m_imageView->setNeighborPaths(computeNeighborPaths(index));

    m_imageView->setImage(path);

    m_imageView->setExifData(ExifReader::read(path));

    updateExifInfo(path);

    m_stack->setCurrentWidget(m_imageView);

    m_imageView->setFocus();

    if (m_imageViewWasFullScreen) {

        setFullScreenMode(true);

        m_imageViewWasFullScreen = false;

    }

}

void MainWindow::onEditCaption()

{

    QByteArray path;

    if (m_stack->currentWidget() == m_imageView) {

        path = m_imageView->currentPath();

    } else {

        const QModelIndex index = m_listView->currentIndex();

        if (index.isValid() && !m_imageModel->isFolder(index))

            path = m_imageModel->filePath(index);

    }

    if (path.isEmpty())

        return;

    if (::access(path.constData(), W_OK) != 0) {

        QMessageBox::warning(this, tr("Cannot Edit Caption"),

            tr("The file is write-protected and cannot be edited.\n\n%1")

                .arg(displayPath(path)));

        return;

    }

    ExifData data = ExifReader::read(path);

    QDialog dlg(this);

    dlg.setWindowTitle(tr("Edit Caption"));

    auto *layout = new QVBoxLayout(&dlg);

    layout->addWidget(new QLabel(tr("Caption-Abstract:"), &dlg));

    auto *edit = new QPlainTextEdit(&dlg);

    edit->setPlainText(data.captionAbstract);

    edit->setMinimumWidth(400);

    layout->addWidget(edit);

    auto *buttons = new QDialogButtonBox(

        QDialogButtonBox::Ok | QDialogButtonBox::Cancel, &dlg);

    layout->addWidget(buttons);

    connect(buttons, &QDialogButtonBox::accepted, &dlg, &QDialog::accept);

    connect(buttons, &QDialogButtonBox::rejected, &dlg, &QDialog::reject);

    if (dlg.exec() != QDialog::Accepted)

        return;

    const QString newCaption = edit->toPlainText();

    if (ExifReader::saveCaption(path, newCaption, data)) {

        ExifData updated = ExifReader::read(path);

        if (m_imageView->currentPath() == path)

            m_imageView->setExifData(updated);

        updateExifInfo(path);

    }

}

void MainWindow::showImageContextMenu(const QPoint &pos)

{

    const QModelIndex index = m_listView->indexAt(pos);

    if (!index.isValid() || m_imageModel->isFolder(index))

        return;

    m_listView->setCurrentIndex(index);

    showPreview(index);

    const QByteArray path = m_imageModel->filePath(index);

    executeContextMenu(m_listView->viewport()->mapToGlobal(pos), path, index);

}

void MainWindow::showImageViewContextMenu(const QPoint &pos)

{

    const QByteArray path = m_imageView->currentPath();

    if (path.isEmpty())

        return;

    const QModelIndex index = m_listView->currentIndex();

    executeContextMenu(m_imageView->mapToGlobal(pos), path, index);

}

void MainWindow::executeContextMenu(const QPoint &globalPos, const QByteArray &path, const QModelIndex &index)

{

    QMenu menu(this);

    QAction *copyFilenameAction = menu.addAction(tr("Copy filename"));

    QAction *copyFullPathAction = menu.addAction(tr("Copy full path"));

    menu.addSeparator();

    QAction *rotateLeftAction = menu.addAction(tr("Rotate Left"));

    QAction *rotateRightAction = menu.addAction(tr("Rotate Right"));

    menu.addSeparator();

    QAction *editDescriptionAction = menu.addAction(tr("Edit description"));

    QAction *moveToTrashAction = menu.addAction(tr("Move to trash"));

    moveToTrashAction->setShortcut(

        ShortcutManager::instance().shortcut(ShortcutManager::MoveToTrash));

    QAction *chosen = menu.exec(globalPos);

    if (chosen == copyFilenameAction) {

        QGuiApplication::clipboard()->setText(filenameFromPath(path));

    } else if (chosen == copyFullPathAction) {

        QGuiApplication::clipboard()->setText(displayPath(path));

    } else if (chosen == rotateLeftAction) {

        rotateImage(index, false);

    } else if (chosen == rotateRightAction) {

        rotateImage(index, true);

    } else if (chosen == editDescriptionAction) {

        onEditCaption();

    } else if (chosen == moveToTrashAction) {

        moveImageToTrash(path);

    }

}

void MainWindow::rotateImage(const QModelIndex &index, bool clockwise)

{

    if (!index.isValid() || m_imageModel->isFolder(index))

        return;

    const QByteArray path = m_imageModel->filePath(index);

    if (::access(path.constData(), W_OK) != 0) {

        QMessageBox::warning(this, tr("Cannot Rotate Image"),

            tr("The file is write-protected and cannot be rotated.\n\n%1")

                .arg(displayPath(path)));

        return;

    }

    if (!ExifReader::rotate(path, clockwise)) {

        QMessageBox::warning(this, tr("Cannot Rotate Image"),

            tr("The image orientation could not be changed. The format may not "

               "support EXIF orientation.\n\n%1")

                .arg(displayPath(path)));

        return;

    }

    m_imageModel->refreshThumbnail(index);

    showPreview(index);

    if (m_imageView->currentPath() == path) {

        m_imageView->invalidateCache(path);

        m_imageView->setImage(path);

        m_imageView->setExifData(ExifReader::read(path));

    }

}

void MainWindow::moveImageToTrash(const QByteArray &path)

{

    if (path.isEmpty())

        return;

    const QString fileName = filenameFromPath(path);

    const QMessageBox::StandardButton answer = QMessageBox::question(

        this,

        tr("Move to Trash"),

        tr("Move \"%1\" to the trash?").arg(fileName),

        QMessageBox::Yes | QMessageBox::Cancel,

        QMessageBox::Cancel);

    if (answer != QMessageBox::Yes)

        return;

    if (!QFile::moveToTrash(displayPath(path))) {

        QMessageBox::warning(this, tr("Cannot Move to Trash"),

            tr("The file could not be moved to the trash.\n\n%1")

                .arg(displayPath(path)));

        return;

    }

    const QByteArray currentDir = m_imageModel->currentDirectory();

    m_previewLabel->clear();

    m_exifTable->setRowCount(0);

    m_imageModel->setDirectory(currentDir);

    QTimer::singleShot(0, this, &MainWindow::loadVisibleThumbnails);

}

void MainWindow::moveCurrentImageToTrash()

{

    const QModelIndex index = m_listView->currentIndex();

    if (!index.isValid() || m_imageModel->isFolder(index))

        return;

    moveImageToTrash(m_imageModel->filePath(index));

}

void MainWindow::leaveSingleImageMode()

{

    if (isFullScreen()) {

        m_imageViewWasFullScreen = true;

        setFullScreenMode(false);

    }

    m_imageView->clearCache();

    m_stack->setCurrentWidget(m_browserPage);

    m_menuBar->show();

    if (m_rootDockWasVisible)

        m_rootDock->show();

    if (m_folderDockWasVisible)

        m_folderDock->show();

    if (m_previewDockWasVisible)

        m_previewDock->show();

    if (m_exifDockWasVisible)

        m_exifDock->show();

    m_listView->setFocus();

}

QList<QByteArray> MainWindow::computeNeighborPaths(const QModelIndex &index) const

{

    QList<QByteArray> paths;

    int row = index.row();

    // Collect up to CacheKeepBehind non-folder images before current

    int count = 0;

    for (int i = row - 1; i >= 0 && count < ImageViewWidget::CacheKeepBehind; --i) {

        QModelIndex idx = m_imageModel->index(i);

        if (!m_imageModel->isFolder(idx)) {

            paths.prepend(m_imageModel->filePath(idx));

            ++count;

        }

    }

    // Collect up to CacheReadAhead non-folder images after current

    count = 0;

    for (int i = row + 1; i < m_imageModel->rowCount() && count < ImageViewWidget::CacheReadAhead; ++i) {

        QModelIndex idx = m_imageModel->index(i);

        if (!m_imageModel->isFolder(idx)) {

            paths.append(m_imageModel->filePath(idx));

            ++count;

        }

    }

    return paths;

}

void MainWindow::setFullScreenMode(bool fullScreen)

{

    if (fullScreen == isFullScreen())

        return;

    if (fullScreen) {

        m_wasMaximized = isMaximized();

        m_menuBar->hide();

        showFullScreen();

    } else {

        // Only restore menu bar when returning to browse mode

        if (m_stack->currentWidget() != m_imageView)

            m_menuBar->show();

        if (m_wasMaximized)

            showMaximized();

        else

            showNormal();

    }

}

void MainWindow::keyPressEvent(QKeyEvent *event)

{

    // THREADING: No race condition with F11 fullscreen toggle.  All cross-thread

    // signal deliveries (thumbnailReady via explicit QueuedConnection,

    // onImageLoaded via AutoConnection resolving to QueuedConnection) execute on

    // the main thread's event loop.  The event loop processes events one at a

    // time, so this handler and any signal slot can never interleave.  All widget

    // state (m_wasMaximized, m_stack, fullscreen flag) is only accessed from the

    // main thread.

    const ShortcutManager &sc = ShortcutManager::instance();

    if (sc.matches(event, ShortcutManager::ToggleFullscreen)

        && m_stack->currentWidget() == m_imageView)

    {

        setFullScreenMode(!isFullScreen());

        event->accept();

        return;

    }

    if (sc.matches(event, ShortcutManager::ActivateEntry)

        && m_stack->currentWidget() == m_browserPage)

    {

        QModelIndex current = m_listView->currentIndex();

        if (current.isValid())

        {

            if (m_imageModel->isFolder(current)) {

                QByteArray path = m_imageModel->filePath(current);

                navigateToFolder(path);

            } else {

                enterSingleImageMode(current);

            }

            event->accept();

            return;

        }

    }

    if (sc.matches(event, ShortcutManager::PrevFolder)

        && m_stack->currentWidget() == m_browserPage)

    {

        navigateToPrevFolder();

        event->accept();

        return;

    }

    if (sc.matches(event, ShortcutManager::NextFolder)

        && m_stack->currentWidget() == m_browserPage)

    {

        navigateToNextFolder();

        event->accept();

        return;

    }

    if (sc.matches(event, ShortcutManager::MoveToTrash)

        && m_stack->currentWidget() == m_browserPage)

    {

        moveCurrentImageToTrash();

        event->accept();

        return;

    }

    QMainWindow::keyPressEvent(event);

}

void MainWindow::closeEvent(QCloseEvent *event)

{

    if (m_stack->currentWidget() == m_imageView)