LibGUI: Add GUndoStack and GCommand classes

This patch converts the undo stack from GTextDocument into GUndoStack,
and GTextDocumentUndoCommand now inherits from GCommand.

Let's turn this into a generic mechanism that can be used to implement
undo/redo in any application. :^)

Libraries/LibGUI/GCommand.cpp

@@ -0,0 +1,5 @@
+#include <LibGUI/GCommand.h>
+
+GCommand::~GCommand()
+{
+}

Libraries/LibGUI/GCommand.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <AK/String.h>
+
+class GCommand {
+public:
+    virtual ~GCommand();
+
+    virtual void undo() {}
+    virtual void redo() {}
+
+    String action_text() const { return m_action_text; }
+
+protected:
+    GCommand() {}
+    void set_action_text(const String& text) { m_action_text = text; }
+
+private:
+    String m_action_text;
+};

Libraries/LibGUI/GTextDocument.cpp

@@ -366,23 +366,7 @@ void GTextDocument::undo()
 {
     if (!can_undo())
         return;
-
+    m_undo_stack.undo();
-    auto& undo_container = m_undo_stack[m_undo_stack_index];
-    auto& undo_vector = undo_container.m_undo_vector;
-
-    //If we try to undo a empty vector, delete it and skip over.
-    if (undo_vector.is_empty()) {
-        m_undo_stack.remove(m_undo_stack_index);
-        undo();
-        return;
-    }
-
-    for (int i = 0; i < undo_vector.size(); i++) {
-        auto& undo_command = undo_vector[i];
-        undo_command.undo();
-    }
-
-    m_undo_stack_index++;
     notify_did_change();
 }
 
@@ -390,36 +374,13 @@ void GTextDocument::redo()
 {
     if (!can_redo())
         return;
-
+    m_undo_stack.redo();
-    auto& undo_container = m_undo_stack[m_undo_stack_index - 1];
-    auto& redo_vector = undo_container.m_undo_vector;
-
-    for (int i = redo_vector.size() - 1; i >= 0; i--) {
-        auto& undo_command = redo_vector[i];
-        undo_command.redo();
-    }
-
-    m_undo_stack_index--;
     notify_did_change();
 }
 
 void GTextDocument::add_to_undo_stack(NonnullOwnPtr<GTextDocumentUndoCommand> undo_command)
 {
-    if (m_undo_stack.is_empty()) {
+    m_undo_stack.push(move(undo_command));
-        auto undo_commands_container = make<UndoCommandsContainer>();
-        m_undo_stack.prepend(move(undo_commands_container));
-    }
-
-    // Clear the elements of the stack before the m_undo_stack_index (Excluding our new element)
-    for (int i = 1; i < m_undo_stack_index; i++)
-        m_undo_stack.remove(1);
-
-    if (m_undo_stack_index > 0 && !m_undo_stack.is_empty())
-        m_undo_stack[0].m_undo_vector.clear();
-
-    m_undo_stack_index = 0;
-
-    m_undo_stack[0].m_undo_vector.prepend(move(undo_command));
 }
 
 GTextDocumentUndoCommand::GTextDocumentUndoCommand(GTextDocument& document)
@@ -536,21 +497,5 @@ void CreateLineCommand::redo()
 
 void GTextDocument::update_undo_timer()
 {
-    if (m_undo_stack.is_empty())
+    m_undo_stack.finalize_current_combo();
-        return;
-
-    auto& undo_vector = m_undo_stack[0].m_undo_vector;
-
-    if (undo_vector.size() == m_last_updated_undo_vector_size && !undo_vector.is_empty()) {
-        auto undo_commands_container = make<UndoCommandsContainer>();
-        m_undo_stack.prepend(move(undo_commands_container));
-        // Note: Remove dbg() if we're 100% sure there are no bugs left.
-        dbg() << "Undo stack increased to " << m_undo_stack.size();
-
-        // Shift the index to the left since we're adding an empty container.
-        if (m_undo_stack_index > 0)
-            m_undo_stack_index++;
-    }
-
-    m_last_updated_undo_vector_size = undo_vector.size();
 }

Libraries/LibGUI/GTextDocument.h

@@ -9,6 +9,7 @@
 #include <LibDraw/Color.h>
 #include <LibDraw/Font.h>
 #include <LibGUI/GTextRange.h>
+#include <LibGUI/GUndoStack.h>
 
 class GTextEditor;
 class GTextDocument;
@@ -23,12 +24,10 @@ struct GTextDocumentSpan {
     void* data { nullptr };
 };
 
-class GTextDocumentUndoCommand {
+class GTextDocumentUndoCommand : public GCommand {
 public:
     GTextDocumentUndoCommand(GTextDocument&);
     virtual ~GTextDocumentUndoCommand();
-    virtual void undo() {}
-    virtual void redo() {}
 
 protected:
     GTextDocument& m_document;
@@ -143,15 +142,10 @@ public:
     Optional<GTextDocumentSpan> first_non_skippable_span_before(const GTextPosition&) const;
     Optional<GTextDocumentSpan> first_non_skippable_span_after(const GTextPosition&) const;
 
-    struct UndoCommandsContainer {
-        NonnullOwnPtrVector<GTextDocumentUndoCommand> m_undo_vector;
-    };
-
     void add_to_undo_stack(NonnullOwnPtr<GTextDocumentUndoCommand>);
 
-    bool can_undo() const { return m_undo_stack_index < m_undo_stack.size() && !m_undo_stack.is_empty(); }
+    bool can_undo() const { return m_undo_stack.can_undo(); }
-    bool can_redo() const { return m_undo_stack_index > 0 && m_undo_stack[m_undo_stack_index - 1].m_undo_vector.size() > 0 && !m_undo_stack.is_empty(); }
+    bool can_redo() const { return m_undo_stack.can_redo(); }
-
     void undo();
     void redo();
 
@@ -169,10 +163,7 @@ private:
     HashTable<Client*> m_clients;
     bool m_client_notifications_enabled { true };
 
-    NonnullOwnPtrVector<UndoCommandsContainer> m_undo_stack;
+    GUndoStack m_undo_stack;
-    int m_undo_stack_index { 0 };
-    int m_last_updated_undo_vector_size = 0;
-
     RefPtr<CTimer> m_undo_timer;
 };
 

Libraries/LibGUI/GUndoStack.cpp

@@ -0,0 +1,89 @@
+#include <LibGUI/GUndoStack.h>
+
+GUndoStack::GUndoStack()
+{
+}
+
+GUndoStack::~GUndoStack()
+{
+}
+
+void GUndoStack::undo()
+{
+    if (!can_undo())
+        return;
+
+    auto& undo_container = m_stack[m_stack_index];
+    auto& undo_vector = undo_container.m_undo_vector;
+
+    //If we try to undo a empty vector, delete it and skip over.
+    if (undo_vector.is_empty()) {
+        m_stack.remove(m_stack_index);
+        undo();
+        return;
+    }
+
+    for (int i = 0; i < undo_vector.size(); i++) {
+        auto& undo_command = undo_vector[i];
+        undo_command.undo();
+    }
+
+    m_stack_index++;
+}
+
+void GUndoStack::redo()
+{
+    if (!can_redo())
+        return;
+
+    auto& undo_container = m_stack[m_stack_index - 1];
+    auto& redo_vector = undo_container.m_undo_vector;
+
+    for (int i = redo_vector.size() - 1; i >= 0; i--) {
+        auto& undo_command = redo_vector[i];
+        undo_command.redo();
+    }
+
+    m_stack_index--;
+}
+
+void GUndoStack::push(NonnullOwnPtr<GCommand>&& command)
+{
+    if (m_stack.is_empty()) {
+        auto undo_commands_container = make<UndoCommandsContainer>();
+        m_stack.prepend(move(undo_commands_container));
+    }
+
+    // Clear the elements of the stack before the m_undo_stack_index (Excluding our new element)
+    for (int i = 1; i < m_stack_index; i++)
+        m_stack.remove(1);
+
+    if (m_stack_index > 0 && !m_stack.is_empty())
+        m_stack[0].m_undo_vector.clear();
+
+    m_stack_index = 0;
+
+    m_stack[0].m_undo_vector.prepend(move(command));
+}
+
+
+void GUndoStack::finalize_current_combo()
+{
+    if (m_stack.is_empty())
+        return;
+
+    auto& undo_vector = m_stack[0].m_undo_vector;
+
+    if (undo_vector.size() == m_last_updated_undo_vector_size && !undo_vector.is_empty()) {
+        auto undo_commands_container = make<UndoCommandsContainer>();
+        m_stack.prepend(move(undo_commands_container));
+        // Note: Remove dbg() if we're 100% sure there are no bugs left.
+        dbg() << "Undo stack increased to " << m_stack.size();
+
+        // Shift the index to the left since we're adding an empty container.
+        if (m_stack_index > 0)
+            m_stack_index++;
+    }
+
+    m_last_updated_undo_vector_size = undo_vector.size();
+}

Libraries/LibGUI/GUndoStack.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <AK/NonnullOwnPtrVector.h>
+#include <LibGUI/GCommand.h>
+
+class GCommand;
+
+class GUndoStack {
+public:
+    GUndoStack();
+    ~GUndoStack();
+
+    void push(NonnullOwnPtr<GCommand>&&);
+
+    bool can_undo() const { return m_stack_index < m_stack.size() && !m_stack.is_empty(); }
+    bool can_redo() const { return m_stack_index > 0 && m_stack[m_stack_index - 1].m_undo_vector.size() > 0 && !m_stack.is_empty(); }
+
+    void undo();
+    void redo();
+
+    void finalize_current_combo();
+
+private:
+    struct UndoCommandsContainer {
+        NonnullOwnPtrVector<GCommand> m_undo_vector;
+    };
+
+    NonnullOwnPtrVector<UndoCommandsContainer> m_stack;
+    int m_stack_index { 0 };
+    int m_last_updated_undo_vector_size { 0 };
+};

Libraries/LibGUI/Makefile

@@ -57,6 +57,8 @@ OBJS = \
     GAboutDialog.o \
     GModelSelection.o \
     GLazyWidget.o \
+    GCommand.o \
+    GUndoStack.o \
     GWindow.o
 
 LIBRARY = libgui.a