Introduce new Undo/Redo system (#1817)

* Implement ability to switch between old and new backup system * Remove anything but the most essential logic * Make it more obvious that we're calling the legacy system * Make sure we always update the save counter * Change feature dialog text * Add another dialog when re-enabling the old system * Apply more cleanup before restructuring * Refactor backupManager * Introduce the new backup system to stroke tools and polyline. Also add a guard to make sure that saveStates doesn't do anything while we use the old system. * Add backup for smudge tool * Remove commented code * Update license snips * Fix tests crashing * Add missing MOC for backupmanager for Qt 6 compatibility Also removed an unused reference * Change argument type for layer bitmap/vector * Calling backupmanager backup should be noop for when not activated * Fix vector selection not being painted immediately during undo/redo * Simplify CanvasPainter::paintCurrentFrame logic Since we're always drawing the backbuffer, the logic gates are redundant. * Fix rotation would jump when using undo/redo and trying to modify again * Re-enable selection backups * Do some spring cleaning in BackupManager * Remove use of ptr's, so we don't have to deal with memory freeing. * Remove redundant member variables Since the keyframe already contains the frame pos, there's no reason to keep a second value which could lead to bugs in the future. * Replace replaceLastFoo in favour of a generic replaceKeyFrame method * Fix some issues and housekeeping etc. * Attempt to fix CI-only build failure * Fix legacy undo/redo actions being enabled following startup * Remove superfluous delete * Fix undo/redo system being broken Caused by a brainfart in the evening... * Remove redundant methods in backupelement * Remove id in backupelement Used for compressing backup events, which is currently not implemented. * Add unreachable check to TransformElement * Use QUndoStack clean instead if checking the backupElement ptr * Refactor replaceKeyFrame, should use getXAtFrame instead of getLast * Prevent use of a saved undo state more than once Also fixed memory leak situation with clone not being cleaned up later. * Rename BackupElements -> old/new to undo/redo * Refactor Backup terminology to UndoCommand terminology * Remove undo/redo prefix when using new undo/redo system * TransformCommand: split undo/redo keyframe resolving * Fix old backupmanager references * Implement ability to set undo/redo steps And set default to 100 steps. * Change QUndoStack from ptr to object * Update core_lib/src/managers/undoredomanager.cpp Co-authored-by: Jakob <[email protected]> * Update app/src/generalpage.cpp Co-authored-by: Jakob <[email protected]> * Update app/ui/generalpage.ui Co-authored-by: Jakob <[email protected]> * Fix changes individual undo/redo setting would disable buttons. * Add newline for easier readability * Rework how undo save state should be used It's no longer possible to call add without having a valid save state. This makes it easier to see where the state comes from as well as allowing you to keep multiple save states at the same time. * Simplify UndoRedoManager::add * Update core_lib/src/managers/undoredomanager.cpp Co-authored-by: Jakob <[email protected]> * Fix transform command children would not be called the first time Which resulted in isFirstRedo being ignored * Rename Undo commands to be more specific * Rewrite how state is recorded and saved temporarily. * Rename saveStates -> state * Use layerType from save state rather than current layer * UndoRedoManager: Improve assert description --------- Co-authored-by: Jakob Gahde <[email protected]> Co-authored-by: Matt Chia-wen Chang <[email protected]>
pencil2d · Sep 6, 2024 · 3d0a148 · 3d0a148
1 parent 09ef787
commit 3d0a148
Show file tree

Hide file tree

Showing 40 changed files with 1,600 additions and 487 deletions.
diff --git a/app/src/generalpage.cpp b/app/src/generalpage.cpp
@@ -100,6 +100,9 @@ GeneralPage::GeneralPage() : ui(new Ui::GeneralPage)
     ui->backgroundButtons->setId(ui->dotsBackgroundButton, 4);
     ui->backgroundButtons->setId(ui->weaveBackgroundButton, 5);
 
+    ui->undoRedoGroupApplyButton->setDisabled(true);
+    ui->undoRedoGroupCancelButton->setDisabled(true);
+
     auto buttonClicked = static_cast<void (QButtonGroup::*)(QAbstractButton*)>(&QButtonGroup::buttonClicked);
     auto curIndexChanged = static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged);
     auto spinValueChanged = static_cast<void(QSpinBox::*)(int)>(&QSpinBox::valueChanged);
@@ -122,6 +125,10 @@ GeneralPage::GeneralPage() : ui(new Ui::GeneralPage)
     connect(ui->gridCheckBox, &QCheckBox::stateChanged, this, &GeneralPage::gridCheckBoxStateChanged);
     connect(ui->framePoolSizeSpin, spinValueChanged, this, &GeneralPage::frameCacheNumberChanged);
     connect(ui->invertScrollDirectionBox, &QCheckBox::stateChanged, this, &GeneralPage::invertScrollDirectionBoxStateChanged);
+    connect(ui->newUndoRedoCheckBox, &QCheckBox::stateChanged, this, &GeneralPage::newUndoRedoCheckBoxStateChanged);
+    connect(ui->undoStepsBox, spinValueChanged, this, &GeneralPage::undoRedoMaxStepsChanged);
+    connect(ui->undoRedoGroupApplyButton, &QPushButton::clicked, this, &GeneralPage::undoRedoApplyButtonPressed);
+    connect(ui->undoRedoGroupCancelButton, &QPushButton::clicked, this, &GeneralPage::undoRedoCancelButtonPressed);
 }
 
 GeneralPage::~GeneralPage()
@@ -181,6 +188,12 @@ void GeneralPage::updateValues()
     QSignalBlocker b12(ui->framePoolSizeSpin);
     ui->framePoolSizeSpin->setValue(mManager->getInt(SETTING::FRAME_POOL_SIZE));
 
+    QSignalBlocker bNewUndoRedoCheckBox(ui->newUndoRedoCheckBox);
+    ui->newUndoRedoCheckBox->setChecked(mManager->isOn(SETTING::NEW_UNDO_REDO_SYSTEM_ON));
+
+    QSignalBlocker bUndoRedoLimitSpinBox(ui->undoStepsBox);
+    ui->undoStepsBox->setValue(mManager->getInt(SETTING::UNDO_REDO_MAX_STEPS));
+
     int buttonIdx = 1;
     if (bgName == "checkerboard") buttonIdx = 1;
     else if (bgName == "white")   buttonIdx = 2;
@@ -318,3 +331,80 @@ void GeneralPage::invertScrollDirectionBoxStateChanged(int b)
 {
     mManager->set(SETTING::INVERT_SCROLL_ZOOM_DIRECTION, b != Qt::Unchecked);
 }
+
+void GeneralPage::newUndoRedoCheckBoxStateChanged()
+{
+    ui->undoRedoGroupApplyButton->setEnabled(canApplyOrCancelUndoRedoChanges());
+    ui->undoRedoGroupCancelButton->setEnabled(canApplyOrCancelUndoRedoChanges());
+}
+
+void GeneralPage::undoRedoMaxStepsChanged()
+{
+    ui->undoRedoGroupApplyButton->setEnabled(canApplyOrCancelUndoRedoChanges());
+    ui->undoRedoGroupCancelButton->setEnabled(canApplyOrCancelUndoRedoChanges());
+}
+
+bool GeneralPage::canApplyOrCancelUndoRedoChanges() const
+{
+    const bool newSystemIsOnCurrent = mManager->isOn(SETTING::NEW_UNDO_REDO_SYSTEM_ON);
+    const int maxUndoRedoStepNumCurrent = mManager->getInt(SETTING::UNDO_REDO_MAX_STEPS);
+
+    if (newSystemIsOnCurrent != ui->newUndoRedoCheckBox->isChecked()
+            || maxUndoRedoStepNumCurrent != ui->undoStepsBox->value()) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+void GeneralPage::undoRedoApplyButtonPressed()
+{
+    if (ui->undoStepsBox->value() != mManager->getInt(SETTING::UNDO_REDO_MAX_STEPS)) {
+        QMessageBox messageBox(this);
+        messageBox.setIcon(QMessageBox::Warning);
+        messageBox.setText(tr("Resets your current undo history"));
+        messageBox.setInformativeText(tr("Changing the maximum number of undo/redo steps resets your current undo/redo history. \n\nAre you sure you want to proceed?"));
+        messageBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
+
+        if (messageBox.exec() == QMessageBox::Yes) {
+            mManager->set(SETTING::UNDO_REDO_MAX_STEPS, ui->undoStepsBox->value());
+        } else {
+            ui->undoStepsBox->setValue(mManager->getInt(SETTING::UNDO_REDO_MAX_STEPS));
+        }
+    }
+
+    const bool systemIsOn = mManager->isOn(SETTING::NEW_UNDO_REDO_SYSTEM_ON);
+    if (ui->newUndoRedoCheckBox->isChecked() != systemIsOn) {
+        if (ui->newUndoRedoCheckBox->isChecked()) {
+            QMessageBox messageBox(this);
+            messageBox.setIcon(QMessageBox::Warning);
+            messageBox.setText(tr("Experimental feature!"));
+            messageBox.setInformativeText(tr("This feature is work in progress and may not currently allow for the same features as the current undo/redo system. Once enabled, you'll need to restart the application to start using it. \n\nDo you still want to try?"));
+            messageBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
+
+            if (messageBox.exec() == QMessageBox::Yes) {
+                mManager->set(SETTING::NEW_UNDO_REDO_SYSTEM_ON, true);
+            } else {
+                ui->newUndoRedoCheckBox->setCheckState(Qt::Unchecked);
+                mManager->set(SETTING::NEW_UNDO_REDO_SYSTEM_ON, false);
+            }
+        } else {
+            QMessageBox messageBox(this);
+            messageBox.setIcon(QMessageBox::Information);
+            messageBox.setText(tr("The undo/redo system will be changed on the next launch of the application"));
+            messageBox.exec();
+            mManager->set(SETTING::NEW_UNDO_REDO_SYSTEM_ON, false);
+        }
+    }
+
+    ui->undoRedoGroupCancelButton->setDisabled(true);
+    ui->undoRedoGroupApplyButton->setDisabled(true);
+}
+
+void GeneralPage::undoRedoCancelButtonPressed()
+{
+    ui->undoStepsBox->setValue(mManager->getInt(SETTING::UNDO_REDO_MAX_STEPS));
+    ui->newUndoRedoCheckBox->setCheckState(mManager->isOn(SETTING::NEW_UNDO_REDO_SYSTEM_ON) ? Qt::Checked : Qt::Unchecked);
+    ui->undoRedoGroupCancelButton->setDisabled(true);
+    ui->undoRedoGroupApplyButton->setDisabled(true);
+}
diff --git a/app/src/generalpage.h b/app/src/generalpage.h
@@ -58,9 +58,15 @@ private slots:
     void backgroundChanged(QAbstractButton* button);
     void frameCacheNumberChanged(int value);
     void invertScrollDirectionBoxStateChanged(int b);
+    void newUndoRedoCheckBoxStateChanged();
+    void undoRedoMaxStepsChanged();
+
+    void undoRedoApplyButtonPressed();
+    void undoRedoCancelButtonPressed();
 
 private:
 
+    bool canApplyOrCancelUndoRedoChanges() const;
     void updateSafeHelperTextEnabledState();
 
     Ui::GeneralPage* ui = nullptr;

diff --git a/app/src/mainwindow2.cpp b/app/src/mainwindow2.cpp
@@ -51,11 +51,12 @@ GNU General Public License for more details.
 #include "soundmanager.h"
 #include "viewmanager.h"
 #include "selectionmanager.h"
+#include "undoredomanager.h"
 
 #include "actioncommands.h"
 #include "fileformat.h"     //contains constants used by Pencil File Format
 #include "util.h"
-#include "backupelement.h"
+#include "undoredocommand.h"
 
 // app headers
 #include "colorbox.h"
@@ -263,10 +264,8 @@ void MainWindow2::createMenus()
     connect(ui->actionImport_Replace_Palette, &QAction::triggered, this, &MainWindow2::openPalette);
 
     //--- Edit Menu ---
-    connect(mEditor, &Editor::updateBackup, this, &MainWindow2::undoActSetText);
-    connect(ui->actionUndo, &QAction::triggered, mEditor, &Editor::undo);
+    replaceUndoRedoActions();
     connect(ui->actionRemoveLastPolylineSegment, &QAction::triggered, static_cast<PolylineTool*>(mEditor->tools()->getTool(POLYLINE)), &PolylineTool::removeLastPolylineSegment);
-    connect(ui->actionRedo, &QAction::triggered, mEditor, &Editor::redo);
     connect(ui->actionCut, &QAction::triggered, mEditor, &Editor::copyAndCut);
     connect(ui->actionCopy, &QAction::triggered, mEditor, &Editor::copy);
     connect(ui->actionPaste_Previous, &QAction::triggered, mEditor, &Editor::pasteFromPreviousFrame);
@@ -465,6 +464,16 @@ void MainWindow2::createMenus()
     connect(mRecentFileMenu, &RecentFileMenu::loadRecentFile, this, &MainWindow2::openFile);
 }
 
+void MainWindow2::replaceUndoRedoActions()
+{
+    ui->menuEdit->removeAction(ui->actionUndo);
+    ui->menuEdit->removeAction(ui->actionRedo);
+    ui->actionUndo = mEditor->undoRedo()->createUndoAction(this, ui->actionUndo->icon());
+    ui->actionRedo = mEditor->undoRedo()->createRedoAction(this, ui->actionRedo->icon());
+    ui->menuEdit->insertAction(ui->actionCut, ui->actionUndo);
+    ui->menuEdit->insertAction(ui->actionCut, ui->actionRedo);
+}
+
 void MainWindow2::setOpacity(int opacity)
 {
     mEditor->preference()->set(SETTING::WINDOW_OPACITY, 100 - opacity);
@@ -473,11 +482,17 @@ void MainWindow2::setOpacity(int opacity)
 
 void MainWindow2::updateSaveState()
 {
-    const bool hasUnsavedChanges = mEditor->currentBackup() != mBackupAtSave;
+    const bool hasUnsavedChanges = mEditor->undoRedo()->hasUnsavedChanges();
     setWindowModified(hasUnsavedChanges);
     ui->statusBar->updateModifiedStatus(hasUnsavedChanges);
 }
 
+void MainWindow2::updateBackupActionState()
+{
+    mEditor->undoRedo()->updateUndoAction(ui->actionUndo);
+    mEditor->undoRedo()->updateRedoAction(ui->actionRedo);
+}
+
 void MainWindow2::openPegAlignDialog()
 {
     if (mPegAlign != nullptr)
@@ -698,7 +713,7 @@ bool MainWindow2::openObject(const QString& strFilePath)
     progress.setValue(progress.maximum());
 
     updateSaveState();
-    undoActSetText();
+    updateBackupActionState();
 
     if (!QFileInfo(strFilePath).isWritable())
     {
@@ -779,7 +794,6 @@ bool MainWindow2::saveObject(QString strSavedFileName)
     mTimeLine->updateContent();
 
     setWindowTitle(strSavedFileName.prepend("[*]"));
-    mBackupAtSave = mEditor->currentBackup();
     updateSaveState();
 
     progress.setValue(progress.maximum());
@@ -799,7 +813,7 @@ bool MainWindow2::saveDocument()
 
 bool MainWindow2::maybeSave()
 {
-    if (mEditor->currentBackup() == mBackupAtSave)
+    if (!mEditor->undoRedo()->hasUnsavedChanges())
     {
         return true;
     }
@@ -1046,7 +1060,8 @@ void MainWindow2::newObject()
     closeDialogs();
 
     setWindowTitle(PENCIL_WINDOW_TITLE);
-    undoActSetText();
+
+    updateBackupActionState();
 }
 
 bool MainWindow2::newObjectFromPresets(int presetIndex)
@@ -1071,7 +1086,7 @@ bool MainWindow2::newObjectFromPresets(int presetIndex)
 
     setWindowTitle(PENCIL_WINDOW_TITLE);
     updateSaveState();
-    undoActSetText();
+    updateBackupActionState();
 
     return true;
 }
@@ -1322,35 +1337,6 @@ void MainWindow2::clearKeyboardShortcuts()
     }
 }
 
-void MainWindow2::undoActSetText()
-{
-    if (mEditor->mBackupIndex < 0)
-    {
-        ui->actionUndo->setText(tr("Undo", "Menu item text"));
-        ui->actionUndo->setEnabled(false);
-    }
-    else
-    {
-        ui->actionUndo->setText(QString("%1   %2 %3").arg(tr("Undo", "Menu item text"))
-                                .arg(mEditor->mBackupIndex + 1)
-                                .arg(mEditor->mBackupList.at(mEditor->mBackupIndex)->undoText));
-        ui->actionUndo->setEnabled(true);
-    }
-
-    if (mEditor->mBackupIndex + 2 < mEditor->mBackupList.size())
-    {
-        ui->actionRedo->setText(QString("%1   %2 %3").arg(tr("Redo", "Menu item text"))
-                                .arg(mEditor->mBackupIndex + 2)
-                                .arg(mEditor->mBackupList.at(mEditor->mBackupIndex + 1)->undoText));
-        ui->actionRedo->setEnabled(true);
-    }
-    else
-    {
-        ui->actionRedo->setText(tr("Redo", "Menu item text"));
-        ui->actionRedo->setEnabled(false);
-    }
-}
-
 void MainWindow2::exportPalette()
 {
     QString filePath = FileDialog::getSaveFileName(this, FileType::PALETTE);
@@ -1406,7 +1392,8 @@ void MainWindow2::openPalette()
 
 void MainWindow2::makeConnections(Editor* editor)
 {
-    connect(editor, &Editor::updateBackup, this, &MainWindow2::updateSaveState);
+    connect(editor->undoRedo(), &UndoRedoManager::didUpdateUndoStack, this, &MainWindow2::updateSaveState);
+    connect(editor->undoRedo(), &UndoRedoManager::didUpdateUndoStack, this, &MainWindow2::updateBackupActionState);
     connect(editor, &Editor::needDisplayInfo, this, &MainWindow2::displayMessageBox);
     connect(editor, &Editor::needDisplayInfoNoTitle, this, &MainWindow2::displayMessageBoxNoTitle);
     connect(editor->layers(), &LayerManager::currentLayerChanged, this, &MainWindow2::currentLayerChanged);
@@ -1634,7 +1621,7 @@ void MainWindow2::startProjectRecovery(int result)
     Q_ASSERT(o);
     mEditor->setObject(o);
     updateSaveState();
-    undoActSetText();
+    updateBackupActionState();
 
     const QString title = tr("Recovery Succeeded!");
     const QString text = tr("Please save your work immediately to prevent loss of data");
@@ -1682,7 +1669,7 @@ void MainWindow2::createToolbars()
     mOverlayToolbar->setIconSize(QSize(22,22));
     mViewToolbar->setIconSize(QSize(22,22));
     mMainToolbar->setIconSize(QSize(22,22));
-    
+
     QToolButton* perspectiveLinesAngleButton = new QToolButton(this);
     perspectiveLinesAngleButton->setDefaultAction(ui->menuPerspectiveLinesAngle->menuAction());
     perspectiveLinesAngleButton->setPopupMode(QToolButton::InstantPopup);

diff --git a/app/src/mainwindow2.h b/app/src/mainwindow2.h
@@ -41,7 +41,7 @@ class ColorInspector;
 class RecentFileMenu;
 class ActionCommands;
 class ImportImageSeqDialog;
-class BackupElement;
+class UndoRedoCommand;
 class LayerOpacityDialog;
 class PegBarAlignmentDialog;
 class RepositionFramesDialog;
@@ -65,7 +65,7 @@ class MainWindow2 : public QMainWindow
     Editor* mEditor = nullptr;
 
 public slots:
-    void undoActSetText();
+    void updateBackupActionState();
     void updateSaveState();
     void openPegAlignDialog();
     void openRepositionDialog();
@@ -124,6 +124,7 @@ private slots:
 
     void createDockWidgets();
     void createMenus();
+    void replaceUndoRedoActions();
     void setupKeyboardShortcuts();
     void clearKeyboardShortcuts();
     bool loadMostRecent();
@@ -167,9 +168,6 @@ private slots:
     QToolBar*             mViewToolbar = nullptr;
     QToolBar*             mOverlayToolbar = nullptr;
 
-    // backup
-    BackupElement* mBackupAtSave = nullptr;
-
     PegBarAlignmentDialog* mPegAlign = nullptr;
     RepositionFramesDialog* mReposDialog = nullptr;
     LayerOpacityDialog* mLayerOpacityDialog = nullptr;