Support recovery files

Author: CrSjimo

src/libs/3rdparty/dspxmodel

@@ -25,6 +25,7 @@ namespace Core::Internal {
         QString proxyUsername{};
         QString proxyPassword{};
         BehaviorPreference::FileOption fileOption{};
+        bool documentLogEnabled{};
         bool useCustomFont{};
         QString fontFamily{};
         QString fontStyle{};
@@ -87,6 +88,8 @@ namespace Core::Internal {
         emit proxyPasswordChanged();
         d->fileOption = settings->value("fileOption", QVariant::fromValue(FO_LockOpenedFiles | FO_CheckForExternalChangedOnSave)).value<FileOption>();
         emit fileOptionChanged();
+        d->documentLogEnabled = settings->value("documentLogEnabled", true).toBool();
+        emit documentLogEnabledChanged();
         d->useCustomFont = settings->value("useCustomFont", false).toBool();
         emit useCustomFontChanged();
         d->fontFamily = settings->value("fontFamily", QApplication::font().family()).toString();
@@ -143,6 +146,7 @@ namespace Core::Internal {
         settings->setValue("proxyUsername", d->proxyUsername);
         settings->setValue("proxyPassword", d->proxyPassword);
         settings->setValue("fileOption", static_cast<int>(d->fileOption));
+        settings->setValue("documentLogEnabled", d->documentLogEnabled);
         settings->setValue("useCustomFont", d->useCustomFont);
         settings->setValue("fontFamily", d->fontFamily);
         settings->setValue("fontStyle", d->fontStyle);
@@ -320,6 +324,17 @@ namespace Core::Internal {
         d->fileOption = fileOption;
         emit m_instance->fileOptionChanged();
     }
+    bool BehaviorPreference::documentLogEnabled() {
+        M_INSTANCE_D;
+        return d->documentLogEnabled;
+    }
+    void BehaviorPreference::setDocumentLogEnabled(bool documentLogEnabled) {
+        M_INSTANCE_D;
+        if (d->documentLogEnabled == documentLogEnabled)
+            return;
+        d->documentLogEnabled = documentLogEnabled;
+        emit m_instance->documentLogEnabledChanged();
+    }
     bool BehaviorPreference::useCustomFont() {
         M_INSTANCE_D;
         return d->useCustomFont;

src/plugins/coreplugin/internal/BehaviorPreference.cpp

@@ -33,6 +33,7 @@ namespace Core::Internal {
         Q_PROPERTY(QString proxyUsername READ proxyUsername WRITE setProxyUsername NOTIFY proxyUsernameChanged)
         Q_PROPERTY(QString proxyPassword READ proxyPassword WRITE setProxyPassword NOTIFY proxyPasswordChanged)
         Q_PROPERTY(BehaviorPreference::FileOption fileOption READ fileOption WRITE setFileOption NOTIFY fileOptionChanged)
+        Q_PROPERTY(bool documentLogEnabled READ documentLogEnabled WRITE setDocumentLogEnabled NOTIFY documentLogEnabledChanged)
         Q_PROPERTY(bool useCustomFont READ useCustomFont WRITE setUseCustomFont NOTIFY useCustomFontChanged)
         Q_PROPERTY(QString fontFamily READ fontFamily WRITE setFontFamily NOTIFY fontFamilyChanged)
         Q_PROPERTY(QString fontStyle READ fontStyle WRITE setFontStyle NOTIFY fontStyleChanged)
@@ -130,6 +131,9 @@ namespace Core::Internal {
         static FileOption fileOption();
         static void setFileOption(FileOption fileOption);
 
+        static bool documentLogEnabled();
+        static void setDocumentLogEnabled(bool documentLogEnabled);
+
         static bool useCustomFont();
         static void setUseCustomFont(bool useCustomFont);
 
@@ -217,6 +221,7 @@ namespace Core::Internal {
         void proxyUsernameChanged();
         void proxyPasswordChanged();
         void fileOptionChanged();
+        void documentLogEnabledChanged();
         void useCustomFontChanged();
         void fontFamilyChanged();
         void fontStyleChanged();

src/plugins/coreplugin/internal/BehaviorPreference.h

@@ -67,7 +67,7 @@ namespace Core::Internal {
         }
         if (button == SVS::SVSCraft::No) {
             QDir runtimeDataDir(ApplicationInfo::applicationLocation(ApplicationInfo::RuntimeData));
-            auto tempPath = runtimeDataDir.filePath(QStringLiteral("latest_unsaved_project.dspx"));
+            auto tempPath = runtimeDataDir.filePath(QStringLiteral("recovery/latest_unsaved_project.dspx"));
             return projectContext->saveCopy(tempPath);
         }
 

src/plugins/coreplugin/internal/addon/CloseSaveCheckAddOn.cpp

@@ -1,23 +1,44 @@
 #include "RecentFileAddOn.h"
 
+#include <memory>
+
 #include <QDir>
+#include <QFile>
 #include <QFileInfo>
+#include <QLockFile>
+#include <QLoggingCategory>
 #include <QQmlComponent>
 #include <QStandardItemModel>
 
+#include <CoreApi/applicationinfo.h>
 #include <CoreApi/recentfilecollection.h>
 #include <CoreApi/runtimeinterface.h>
 
+#include <dspxmodelCore/Document.h>
+#include <dspxmodelORM/Model.h>
+#include <opendspx/model.h>
+
 #include <QAKQuick/quickactioncontext.h>
 
 #include <uishell/USDef.h>
 
 #include <coreplugin/CoreInterface.h>
 #include <coreplugin/HomeWindowInterface.h>
+#include <coreplugin/ProjectDocumentContext.h>
 #include <coreplugin/ProjectWindowInterface.h>
 
 namespace Core::Internal {
 
+    Q_STATIC_LOGGING_CATEGORY(lcRecentFileAddOn, "diffscope.core.recentfileaddon")
+
+    enum RecoveryFileKind {
+        RFK_LatestUnsavedProject,
+        RFK_DocumentLogDirectory,
+    };
+
+    constexpr int RecoveryFileKindRole = Qt::UserRole + 100;
+    constexpr int RecoveryFileStoragePathRole = Qt::UserRole + 101;
+
     class RecentFilesModel : public QStandardItemModel {
     public:
         using QStandardItemModel::QStandardItemModel;
@@ -26,24 +47,19 @@ namespace Core::Internal {
             static const QHash<int, QByteArray> m{
                 {UIShell::USDef::RF_NameRole, "name"},
                 {UIShell::USDef::RF_PathRole, "path"},
+                {UIShell::USDef::RF_LastModifiedTextRole, "lastModifiedText"},
+                {UIShell::USDef::RF_ThumbnailRole, "thumbnail"},
+                {UIShell::USDef::RF_IconRole, "icon"},
+                {UIShell::USDef::RF_ColorizeRole, "colorize"},
             };
             return m;
         }
     };
 
-    RecentFileAddOn::RecentFileAddOn(QObject *parent) : WindowInterfaceAddOn(parent), m_recentFilesModel(new RecentFilesModel(this)), m_recoveryFilesModel(new QStandardItemModel(this)) {
+    RecentFileAddOn::RecentFileAddOn(QObject *parent) : WindowInterfaceAddOn(parent), m_recentFilesModel(new RecentFilesModel(this)), m_recoveryFilesModel(new RecentFilesModel(this)) {
         connect(CoreInterface::recentFileCollection(), &RecentFileCollection::recentFilesChanged, this, &RecentFileAddOn::updateRecentFilesModel);
         updateRecentFilesModel();
-        // TODO mock data
-        {
-            auto item = new QStandardItem;
-            item->setData("mock_recovery_file.dspx", UIShell::USDef::RF_NameRole);
-            item->setData("/path/to/mock_recovery_file.dspx", UIShell::USDef::RF_PathRole);
-            item->setData(QLocale().toString(QDateTime::fromString("1919-08-10T11:45:14", Qt::ISODate), QLocale::ShortFormat), UIShell::USDef::RF_LastModifiedTextRole);
-            item->setData(QUrl(), UIShell::USDef::RF_ThumbnailRole);
-            item->setData(QUrl("image://appicon/dspx"), UIShell::USDef::RF_IconRole);
-            m_recoveryFilesModel->appendRow(item);
-        }
+        updateRecoveryFilesModel();
     }
 
     RecentFileAddOn::~RecentFileAddOn() = default;
@@ -105,6 +121,10 @@ namespace Core::Internal {
         return m_recoveryFilesModel;
     }
 
+    int RecentFileAddOn::recoveryFileCount() const {
+        return m_recoveryFileCount;
+    }
+
     bool RecentFileAddOn::isHomeWindow() const {
         return static_cast<bool>(qobject_cast<HomeWindowInterface *>(windowHandle()));
     }
@@ -126,6 +146,99 @@ namespace Core::Internal {
         }
     }
 
+    static QString recoveryRootPath() {
+        return QDir(ApplicationInfo::applicationLocation(ApplicationInfo::RuntimeData)).filePath(QStringLiteral("recovery"));
+    }
+
+    static QString latestUnsavedProjectPath() {
+        return QDir(recoveryRootPath()).filePath(QStringLiteral("latest_unsaved_project.dspx"));
+    }
+
+    static bool recoveryDirectoryInUse(const QDir &directory) {
+        QLockFile lock(directory.filePath(QStringLiteral("active.lock")));
+        if (lock.tryLock(0)) {
+            lock.unlock();
+            return false;
+        }
+        return true;
+    }
+
+    static QString formatLastModified(const QFileInfo &fileInfo) {
+        if (!fileInfo.exists()) {
+            return {};
+        }
+        return QLocale().toString(fileInfo.lastModified(), QLocale::ShortFormat);
+    }
+
+    static QString recoveryDirectoryDisplayName(const QDir &directory) {
+        QFile nameFile(directory.filePath(QStringLiteral("name")));
+        if (nameFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
+            auto name = QString::fromUtf8(nameFile.readAll()).trimmed();
+            if (!name.isEmpty()) {
+                return name;
+            }
+        }
+        return directory.dirName();
+    }
+
+    static QString defaultDocumentNameFromRecoveryName(const QString &name) {
+        if (QFileInfo(name).suffix().compare(QStringLiteral("dspx"), Qt::CaseInsensitive) == 0) {
+            return name;
+        }
+        return name + QStringLiteral(".dspx");
+    }
+
+    void RecentFileAddOn::updateRecoveryFilesModel() {
+        static const QUrl dspxIconUrl{"image://appicon/dspx"};
+        m_recoveryFilesModel->clear();
+        int recoveryFileCount = 0;
+
+        const auto latestPath = latestUnsavedProjectPath();
+        QFileInfo latestFileInfo(latestPath);
+        if (latestFileInfo.exists() && latestFileInfo.isFile()) {
+            auto item = new QStandardItem;
+            item->setData(tr("Unsaved project from last close"), UIShell::USDef::RF_NameRole);
+            item->setData(QString(), UIShell::USDef::RF_PathRole);
+            item->setData(formatLastModified(latestFileInfo), UIShell::USDef::RF_LastModifiedTextRole);
+            item->setData(QUrl(), UIShell::USDef::RF_ThumbnailRole);
+            item->setData(dspxIconUrl, UIShell::USDef::RF_IconRole);
+            item->setData(false, UIShell::USDef::RF_ColorizeRole);
+            item->setData(RFK_LatestUnsavedProject, RecoveryFileKindRole);
+            item->setData(QDir::toNativeSeparators(latestFileInfo.absoluteFilePath()), RecoveryFileStoragePathRole);
+            m_recoveryFilesModel->appendRow(item);
+        }
+
+        QDir recoveryRoot(recoveryRootPath());
+        for (const auto &directoryInfo : recoveryRoot.entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot, QDir::Time)) {
+            QDir directory(directoryInfo.absoluteFilePath());
+            if (recoveryDirectoryInUse(directory)) {
+                continue;
+            }
+            const QFileInfo logsFileInfo(directory.filePath(QStringLiteral("logs")));
+            const QFileInfo snapshotFileInfo(directory.filePath(QStringLiteral("snapshot")));
+            const auto modifiedText = logsFileInfo.exists()
+                ? formatLastModified(logsFileInfo)
+                : formatLastModified(snapshotFileInfo);
+
+            auto item = new QStandardItem;
+            item->setData(recoveryDirectoryDisplayName(directory), UIShell::USDef::RF_NameRole);
+            item->setData(QString(), UIShell::USDef::RF_PathRole);
+            item->setData(modifiedText, UIShell::USDef::RF_LastModifiedTextRole);
+            item->setData(QUrl(), UIShell::USDef::RF_ThumbnailRole);
+            item->setData(dspxIconUrl, UIShell::USDef::RF_IconRole);
+            item->setData(false, UIShell::USDef::RF_ColorizeRole);
+            item->setData(RFK_DocumentLogDirectory, RecoveryFileKindRole);
+            item->setData(QDir::toNativeSeparators(directoryInfo.absoluteFilePath()), RecoveryFileStoragePathRole);
+            m_recoveryFilesModel->appendRow(item);
+            ++recoveryFileCount;
+        }
+
+        if (m_recoveryFileCount != recoveryFileCount) {
+            m_recoveryFileCount = recoveryFileCount;
+            Q_EMIT recoveryFileCountChanged();
+        }
+    }
+
     void RecentFileAddOn::openRecentFile(int index) {
         auto filePath = CoreInterface::recentFileCollection()->recentFiles().at(index);
         CoreInterface::openFile(filePath);
@@ -134,4 +247,84 @@ namespace Core::Internal {
     void RecentFileAddOn::removeRecentFile(int index) {
         CoreInterface::recentFileCollection()->removeRecentFile(CoreInterface::recentFileCollection()->recentFiles().at(index));
     }
+
+    void RecentFileAddOn::openRecoveryFile(int index) {
+        if (index < 0 || index >= m_recoveryFilesModel->rowCount()) {
+            return;
+        }
+        auto item = m_recoveryFilesModel->item(index);
+        const auto path = item->data(RecoveryFileStoragePathRole).toString();
+        const auto kind = item->data(RecoveryFileKindRole).toInt();
+
+        if (kind == RFK_LatestUnsavedProject) {
+            CoreInterface::newFileFromTemplate(path);
+            return;
+        }
+
+        QDir recoveryDirectory(path);
+        QFile snapshotFile(recoveryDirectory.filePath(QStringLiteral("snapshot")));
+        if (!snapshotFile.open(QIODevice::ReadOnly)) {
+            qCWarning(lcRecentFileAddOn) << "Failed to open recovery snapshot:" << snapshotFile.fileName() << snapshotFile.errorString();
+            return;
+        }
+
+        QFile logsFile(recoveryDirectory.filePath(QStringLiteral("logs")));
+        QIODevice *logsDevice = nullptr;
+        if (logsFile.exists()) {
+            if (!logsFile.open(QIODevice::ReadOnly)) {
+                qCWarning(lcRecentFileAddOn) << "Failed to open recovery log:" << logsFile.fileName() << logsFile.errorString();
+                return;
+            }
+            logsDevice = &logsFile;
+        }
+
+        std::unique_ptr<dspx::Document> restoredDocument;
+        try {
+            restoredDocument.reset(dspx::Document::restore(&snapshotFile, logsDevice));
+        } catch (...) {
+            qCWarning(lcRecentFileAddOn) << "Failed to restore document log:" << recoveryDirectory.absolutePath();
+            return;
+        }
+
+        dspx::Model restoredModel(restoredDocument.get());
+        auto openDspxModel = restoredModel.toOpenDSPX();
+        auto defaultDocumentName = defaultDocumentNameFromRecoveryName(item->data(UIShell::USDef::RF_NameRole).toString());
+        auto projectDocumentContext = std::make_unique<ProjectDocumentContext>();
+        if (!projectDocumentContext->newFile(openDspxModel, defaultDocumentName, false)) {
+            qCWarning(lcRecentFileAddOn) << "Failed to create project context from recovery directory:" << recoveryDirectory.absolutePath();
+            return;
+        }
+        CoreInterface::createProjectWindow(projectDocumentContext.release());
+    }
+
+    void RecentFileAddOn::removeRecoveryFile(int index) {
+        if (index < 0 || index >= m_recoveryFilesModel->rowCount()) {
+            return;
+        }
+        auto item = m_recoveryFilesModel->item(index);
+        const auto path = item->data(RecoveryFileStoragePathRole).toString();
+        const auto kind = item->data(RecoveryFileKindRole).toInt();
+        if (kind == RFK_LatestUnsavedProject) {
+            QFile::remove(path);
+        } else {
+            QDir(path).removeRecursively();
+        }
+        updateRecoveryFilesModel();
+    }
+
+    void RecentFileAddOn::clearRecoveryFiles() {
+        auto root = QDir(recoveryRootPath());
+        QFile::remove(latestUnsavedProjectPath());
+        for (const auto &directoryInfo : root.entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot)) {
+            QDir directory(directoryInfo.absoluteFilePath());
+            if (!recoveryDirectoryInUse(directory)) {
+                directory.removeRecursively();
+            }
+        }
+        updateRecoveryFilesModel();
+    }
+
+    void RecentFileAddOn::refreshRecoveryFiles() {
+        updateRecoveryFilesModel();
+    }
 }

src/plugins/coreplugin/internal/addon/RecentFileAddOn.cpp

@@ -16,6 +16,7 @@ namespace Core::Internal {
         QML_UNCREATABLE("")
         Q_PROPERTY(QAbstractItemModel *recentFilesModel READ recentFilesModel CONSTANT)
         Q_PROPERTY(QAbstractItemModel *recoveryFilesModel READ recoveryFilesModel CONSTANT)
+        Q_PROPERTY(int recoveryFileCount READ recoveryFileCount NOTIFY recoveryFileCountChanged)
         Q_PROPERTY(bool isHomeWindow READ isHomeWindow CONSTANT)
     public:
         explicit RecentFileAddOn(QObject *parent = nullptr);
@@ -27,18 +28,28 @@ namespace Core::Internal {
 
         QAbstractItemModel *recentFilesModel() const;
         QAbstractItemModel *recoveryFilesModel() const;
+        int recoveryFileCount() const;
 
         bool isHomeWindow() const;
 
     public Q_SLOTS:
         static void openRecentFile(int index);
         static void removeRecentFile(int index);
+        Q_INVOKABLE void openRecoveryFile(int index);
+        Q_INVOKABLE void removeRecoveryFile(int index);
+        Q_INVOKABLE void clearRecoveryFiles();
+        Q_INVOKABLE void refreshRecoveryFiles();
+
+    Q_SIGNALS:
+        void recoveryFileCountChanged();
 
     private:
         QStandardItemModel *m_recentFilesModel;
         QStandardItemModel *m_recoveryFilesModel;
+        int m_recoveryFileCount{};
 
         void updateRecentFilesModel() const;
+        void updateRecoveryFilesModel();
 
     };