Add "Delete current comic" with library IPC support (Ctrl+Del)

When opened from YACReaderLibrary, sends an IPC delete request so the
library removes the comic from the DB and refreshes its view. In
standalone mode, deletes the file directly. Includes a confirmation
dialog with a "Don't ask again this session" checkbox, and navigates
to the next (or previous) comic after deletion.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: dragonpaw

YACReader/main_window_viewer.cpp

@@ -35,6 +35,10 @@
 #include <QImage>
 #include <QDate>
 #include <QMenuBar>
+#include <QCheckBox>
+#include <QFile>
+
+#include "QsLog.h"
 
 #ifdef use_unarr
 #include "unarr.h"
@@ -94,6 +98,7 @@ MainWindowViewer::~MainWindowViewer()
     delete adjustToFullSizeAction;
     delete fitToPageAction;
     delete showFlowAction;
+    delete deleteCurrentComicAction;
 }
 void MainWindowViewer::loadConfiguration()
 {
@@ -841,6 +846,7 @@ void MainWindowViewer::open(QString path, qint64 comicId, qint64 libraryId, YACR
 
     if (success) {
         isClient = true;
+        currentComicFilePath = path + currentComicDB.path;
         open(path + currentComicDB.path, currentComicDB, siblingComics);
     } else {
         isClient = false;
@@ -869,6 +875,7 @@ void MainWindowViewer::openComic(QString pathFile)
 {
     QFileInfo fi(pathFile);
     currentDirectory = fi.dir().absolutePath();
+    currentComicFilePath = fi.absoluteFilePath();
     getSiblingComics(fi.absolutePath(), fi.fileName());
 
     setWindowTitle("YACReader - " + fi.fileName());
@@ -1158,13 +1165,17 @@ void MainWindowViewer::setUpShortcutsManagement()
     // Get current theme for initial icons
     const auto &theme = ThemeManager::instance().getCurrentTheme();
 
+    deleteCurrentComicAction = addActionWithShortcut(tr("Delete current comic"), DELETE_CURRENT_COMIC_ACTION_Y);
+    connect(deleteCurrentComicAction, &QAction::triggered, this, &MainWindowViewer::deleteCurrentComic);
+
     editShortcutsDialog->addActionsGroup(tr("Comics"), theme.shortcutsIcons.comicsIcon,
                                          tmpList = { openAction,
                                                      openLatestComicAction,
                                                      openFolderAction,
                                                      saveImageAction,
                                                      openComicOnTheLeftAction,
-                                                     openComicOnTheRightAction });
+                                                     openComicOnTheRightAction,
+                                                     deleteCurrentComicAction });
 
     allActions << tmpList;
 
@@ -1325,6 +1336,126 @@ void MainWindowViewer::doubleMangaPageSwitch()
     }
 }
 
+void MainWindowViewer::deleteCurrentComic()
+{
+    if (currentComicFilePath.isEmpty()) {
+        return;
+    }
+
+    // Confirmation dialog
+    if (!skipDeleteConfirmation) {
+        QMessageBox msgBox(this);
+        msgBox.setWindowTitle(tr("Delete Comic"));
+        msgBox.setText(tr("Are you sure you want to delete the current comic?"));
+        msgBox.setInformativeText(QFileInfo(currentComicFilePath).fileName());
+        msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::Cancel);
+        msgBox.setDefaultButton(QMessageBox::Cancel);
+        msgBox.setIcon(QMessageBox::Warning);
+
+        auto *checkBox = new QCheckBox(tr("Don't ask again this session"), &msgBox);
+        msgBox.setCheckBox(checkBox);
+
+        if (msgBox.exec() != QMessageBox::Yes) {
+            return;
+        }
+
+        if (checkBox->isChecked()) {
+            skipDeleteConfirmation = true;
+        }
+    }
+
+    // Determine navigation before deleting
+    bool hasNext = false;
+    bool hasPrevious = false;
+
+    if (isClient && !siblingComics.isEmpty()) {
+        int currentIndex = siblingComics.indexOf(currentComicDB);
+        hasNext = (currentIndex + 1 < siblingComics.count());
+        hasPrevious = (currentIndex - 1 >= 0);
+    } else {
+        hasNext = !nextComicPath.isEmpty();
+        hasPrevious = !previousComicPath.isEmpty();
+    }
+
+    if (isClient) {
+        int currentIndex = siblingComics.indexOf(currentComicDB);
+
+        // Close the comic to release the file handle
+        viewer->closeCurrentComic();
+
+        // Send delete request via IPC
+        YACReaderLocalClient client;
+        bool success = client.sendDeleteComic(libraryId, currentComicDB);
+
+        if (!success) {
+            QMessageBox::warning(this, tr("Delete Comic"), tr("Unable to delete the comic file."));
+            currentComicFilePath.clear();
+            return;
+        }
+
+        // Remove the comic from siblingComics
+        if (currentIndex >= 0 && currentIndex < siblingComics.count()) {
+            siblingComics.removeAt(currentIndex);
+        }
+
+        currentComicFilePath.clear();
+
+        // Navigate to next/previous comic
+        if (hasNext && currentIndex < siblingComics.count()) {
+            currentComicDB = siblingComics.at(currentIndex);
+            currentComicFilePath = currentDirectory + currentComicDB.path;
+            open(currentDirectory + currentComicDB.path, currentComicDB, siblingComics);
+        } else if (hasPrevious && currentIndex - 1 >= 0) {
+            currentComicDB = siblingComics.at(currentIndex - 1);
+            currentComicFilePath = currentDirectory + currentComicDB.path;
+            open(currentDirectory + currentComicDB.path, currentComicDB, siblingComics);
+        }
+    } else {
+        // Standalone mode
+        QString pathToDelete = currentComicFilePath;
+        QString savedNextComicPath = nextComicPath;
+        QString savedPreviousComicPath = previousComicPath;
+
+        viewer->closeCurrentComic();
+        currentComicFilePath.clear();
+
+        QFileInfo fileCheck(pathToDelete);
+        bool fileDeleted = false;
+        QString errorDetail;
+
+        if (!fileCheck.exists()) {
+            errorDetail = tr("File not found: %1").arg(pathToDelete);
+        } else if (!fileCheck.isWritable()) {
+            errorDetail = tr("File is not writable: %1").arg(pathToDelete);
+        } else {
+            fileDeleted = QFile::moveToTrash(pathToDelete);
+            if (fileDeleted) {
+                QLOG_INFO() << "Comic recycled:" << pathToDelete;
+            } else {
+                QFile f(pathToDelete);
+                fileDeleted = f.remove();
+                if (fileDeleted) {
+                    QLOG_INFO() << "Comic permanently deleted:" << pathToDelete;
+                } else {
+                    errorDetail = tr("Could not delete: %1\n%2").arg(pathToDelete, f.errorString());
+                    QLOG_ERROR() << "Failed to delete comic:" << pathToDelete << f.errorString();
+                }
+            }
+        }
+
+        if (!fileDeleted) {
+            QMessageBox::warning(this, tr("Delete Comic"), errorDetail);
+            return;
+        }
+
+        if (hasNext && !savedNextComicPath.isEmpty()) {
+            openSiblingComic(savedNextComicPath);
+        } else if (hasPrevious && !savedPreviousComicPath.isEmpty()) {
+            openSiblingComic(savedPreviousComicPath);
+        }
+    }
+}
+
 void MainWindowViewer::toggleFitToWidthSlider()
 {
     int y;

YACReader/main_window_viewer.h

@@ -77,6 +77,7 @@ public slots:
     void processReset();
     void setUpShortcutsManagement();
     void doubleMangaPageSwitch();
+    void deleteCurrentComic();
 
     void toggleFitToWidthSlider();
 
@@ -152,6 +153,7 @@ public slots:
     QAction *showFlowAction;
 
     QAction *showEditShortcutsAction;
+    QAction *deleteCurrentComicAction;
 
     QList<QAction *> mglassActions;
     QList<QAction *> loadedComicActions;
@@ -186,6 +188,8 @@ public slots:
     ComicDB currentComicDB;
     QList<ComicDB> siblingComics;
     bool isClient;
+    QString currentComicFilePath;
+    bool skipDeleteConfirmation = false;
     QString startComicPath;
     quint64 libraryId;
     OpenComicSource source;

YACReader/render.cpp

@@ -702,6 +702,22 @@ void Render::load(const QString &path, const ComicDB &comicDB)
     }
 }
 
+void Render::releaseComic()
+{
+    if (comic != nullptr) {
+        comic->invalidate();
+        comic->disconnect();
+        auto *comicThread = comic->thread();
+        if (comicThread != QThread::currentThread() && comicThread->isRunning()) {
+            comicThread->quit();
+            comicThread->wait();
+        }
+        comic->moveToThread(QThread::currentThread());
+        delete comic;
+        comic = nullptr;
+    }
+}
+
 void Render::createComic(const QString &path)
 {
     previousIndex = currentIndex = 0;

YACReader/render.h

@@ -176,6 +176,7 @@ public slots:
     void setBookmark();
     void removeBookmark();
     void save();
+    void releaseComic();
     void reset();
     void reload();
     void updateFilters(int brightness, int contrast, int gamma);

YACReader/viewer.cpp

@@ -1199,6 +1199,12 @@ void Viewer::resetContent()
     emit reset();
 }
 
+void Viewer::closeCurrentComic()
+{
+    render->releaseComic();
+    resetContent();
+}
+
 void Viewer::setLoadingMessage()
 {
     if (magnifyingGlassShown) {

YACReader/viewer.h

@@ -88,6 +88,7 @@ public slots:
     void setMangaWithoutStoringSetting(bool manga);
     void doubleMangaPageSwitch();
     void resetContent();
+    void closeCurrentComic();
     void setLoadingMessage();
     void setPageUnavailableMessage();
     void configureContent(QString msg);

YACReader/yacreader_local_client.cpp

@@ -197,3 +197,87 @@ bool YACReaderLocalClient::sendComicInfo(quint64 libraryId, ComicDB &comic, qulo
     QLOG_ERROR() << "Sending Comic Info : unable to connect to the server";
     return false;
 }
+
+bool YACReaderLocalClient::sendDeleteComic(quint64 libraryId, ComicDB &comic)
+{
+    localSocket->connectToServer(YACREADERLIBRARY_GUID);
+    if (localSocket->isOpen()) {
+        QByteArray block;
+        QDataStream out(&block, QIODevice::WriteOnly);
+        out.setVersion(QDataStream::Qt_4_8);
+        out << (quint32)0;
+        out << (quint8)YACReader::DeleteComic;
+        out << libraryId;
+        out << comic;
+        out.device()->seek(0);
+        out << (quint32)(block.size() - sizeof(quint32));
+
+        int written = 0;
+        int previousWritten = 0;
+        quint16 tries = 0;
+        while (written != block.size() && tries < 200) {
+            written += localSocket->write(block);
+            localSocket->flush();
+            if (written == previousWritten)
+                tries++;
+            previousWritten = written;
+        }
+        if (tries == 200) {
+            localSocket->close();
+            QLOG_ERROR() << "Delete Comic : unable to send request";
+            return false;
+        }
+
+        localSocket->waitForBytesWritten(2000);
+
+        // Read response (bool success)
+        tries = 0;
+        int dataAvailable = 0;
+        QByteArray packageSize;
+        localSocket->waitForReadyRead(1000);
+        while (packageSize.size() < (int)sizeof(quint32) && tries < 20) {
+            packageSize.append(localSocket->read(sizeof(quint32) - packageSize.size()));
+            localSocket->waitForReadyRead(100);
+            if (dataAvailable == packageSize.size())
+                tries++;
+            dataAvailable = packageSize.size();
+        }
+        if (tries == 20) {
+            localSocket->close();
+            QLOG_ERROR() << "Delete Comic : unable to read package size";
+            return false;
+        }
+        QDataStream sizeStream(packageSize);
+        sizeStream.setVersion(QDataStream::Qt_4_8);
+        quint32 totalSize = 0;
+        sizeStream >> totalSize;
+
+        QByteArray data;
+        tries = 0;
+        int dataRead = 0;
+        localSocket->waitForReadyRead(1000);
+        while ((unsigned int)data.length() < totalSize && tries < 20) {
+            data.append(localSocket->readAll());
+            if ((unsigned int)data.length() < totalSize)
+                localSocket->waitForReadyRead(100);
+            if (data.length() == dataRead)
+                tries++;
+            dataRead = data.length();
+        }
+
+        if (tries == 20) {
+            localSocket->close();
+            QLOG_ERROR() << "Delete Comic : unable to read data (" << data.length() << "," << totalSize << ")";
+            return false;
+        }
+
+        QDataStream dataStream(data);
+        bool success = false;
+        dataStream >> success;
+        localSocket->close();
+        return success;
+    } else {
+        QLOG_ERROR() << "Delete Comic : unable to connect to the server";
+        return false;
+    }
+}

YACReader/yacreader_local_client.h

@@ -21,6 +21,7 @@ public slots:
     bool requestComicInfo(quint64 libraryId, ComicDB &comic, QList<ComicDB> &siblings, YACReader::OpenComicSource source);
     bool sendComicInfo(quint64 libraryId, ComicDB &comic);
     bool sendComicInfo(quint64 libraryId, ComicDB &comic, qulonglong nextComicId);
+    bool sendDeleteComic(quint64 libraryId, ComicDB &comic);
 
 private:
     QLocalSocket *localSocket;

YACReaderLibrary/library_window.cpp

@@ -2693,6 +2693,14 @@ void LibraryWindow::updateViewsOnComicUpdate(quint64 libraryId, const ComicDB &c
     }
 }
 
+void LibraryWindow::reloadAfterComicDeleted(quint64 libraryId, const ComicDB &comic)
+{
+    Q_UNUSED(comic);
+    if (libraryId == (quint64)libraries.getId(selectedLibrary->currentText())) {
+        navigationController->reselectCurrentFolder();
+    }
+}
+
 bool LibraryWindow::exitSearchMode()
 {
     if (status != LibraryWindow::Searching)

YACReaderLibrary/library_window.h

@@ -301,6 +301,7 @@ public slots:
     void updateViewsOnClientSync();
     void updateViewsOnComicUpdateWithId(quint64 libraryId, quint64 comicId);
     void updateViewsOnComicUpdate(quint64 libraryId, const ComicDB &comic);
+    void reloadAfterComicDeleted(quint64 libraryId, const ComicDB &comic);
     void showComicVineScraper();
     void setRemoveError();
     void checkRemoveError();