logic: UndoRedo

UndoRedo working for ActiveTokensMessages

src/lib/CMakeLists.txt

@@ -36,6 +36,8 @@ add_files(
 	component/controller/SearchController.h
 	component/controller/StatusBarController.cpp
 	component/controller/StatusBarController.h
+	component/controller/UndoRedoController.cpp
+	component/controller/UndoRedoController.h
 
 	component/view/graphElements/GraphEdge.cpp
 	component/view/graphElements/GraphEdge.h
@@ -52,6 +54,8 @@ add_files(
 	component/view/SearchView.h
 	component/view/StatusBarView.cpp
 	component/view/StatusBarView.h
+	component/view/UndoRedoView.cpp
+	component/view/UndoRedoView.h
 	component/view/View.cpp
 	component/view/View.h
 	component/view/ViewFactory.cpp
@@ -213,6 +217,8 @@ add_files(
 	utility/messaging/type/MessageSearchAutocomplete.h
 	utility/messaging/type/MessageShowFile.h
 	utility/messaging/type/MessageStatus.h
+	utility/messaging/type/MessageRedo.h
+	utility/messaging/type/MessageUndo.h
 
 	utility/messaging/Message.h
 	utility/messaging/MessageBase.h

src/lib/component/ComponentFactory.cpp

@@ -5,10 +5,12 @@
 #include "component/controller/GraphController.h"
 #include "component/controller/SearchController.h"
 #include "component/controller/StatusBarController.h"
+#include "component/controller/UndoRedoController.h"
 #include "component/view/CodeView.h"
 #include "component/view/GraphView.h"
 #include "component/view/SearchView.h"
 #include "component/view/StatusBarView.h"
+#include "component/view/UndoRedoView.h"
 #include "component/view/ViewFactory.h"
 #include "component/view/ViewLayout.h"
 
@@ -54,6 +56,15 @@ std::shared_ptr<Component> ComponentFactory::createSearchComponent()
 	return component;
 }
 
+std::shared_ptr<Component> ComponentFactory::createUndoRedoComponent()
+{
+	std::shared_ptr<UndoRedoView> view = m_viewFactory->createUndoRedoView(m_viewLayout);
+	std::shared_ptr<UndoRedoController> controller = std::make_shared<UndoRedoController>();
+
+	std::shared_ptr<Component> component = std::make_shared<Component>(view, controller);
+	return component;
+}
+
 std::shared_ptr<Component> ComponentFactory::createStatusBarComponent()
 {
 	std::shared_ptr<StatusBarView> view = m_viewFactory->createStatusBarView(m_viewLayout);

src/lib/component/ComponentFactory.h

@@ -23,6 +23,7 @@ public:
 	std::shared_ptr<Component> createGraphComponent();
 	std::shared_ptr<Component> createSearchComponent();
 	std::shared_ptr<Component> createStatusBarComponent();
+	std::shared_ptr<Component> createUndoRedoComponent();
 
 private:
 	ComponentFactory();

src/lib/component/ComponentManager.cpp

@@ -29,6 +29,9 @@ void ComponentManager::setup()
 
 	std::shared_ptr<Component> statusBarComponent = m_componentFactory->createStatusBarComponent();
 	m_components.push_back(statusBarComponent);
+
+	std::shared_ptr<Component> undoRedoComponent = m_componentFactory->createUndoRedoComponent();
+	m_components.push_back(undoRedoComponent);
 }
 
 ComponentManager::ComponentManager()

src/lib/component/controller/UndoRedoController.cpp

@@ -0,0 +1,136 @@
+#include "component/controller/UndoRedoController.h"
+
+#include <iostream>
+
+#include "component/view/UndoRedoView.h"
+#include "utility/logging/logging.h"
+
+UndoRedoController::UndoRedoController()
+	: MessageListener<MessageActivateTokens>(true)
+	, MessageListener<MessageGraphNodeExpand>(true)
+	, MessageListener<MessageGraphNodeMove>(true)
+	, m_lastCommand(nullptr)
+{
+}
+
+UndoRedoController::~UndoRedoController()
+{
+	for(MessageBase* m : m_redo)
+	{
+		delete m;
+	}
+	for(MessageBase* m : m_undo)
+	{
+		delete m;
+	}
+}
+
+UndoRedoView* UndoRedoController::getView()
+{
+	return Controller::getView<UndoRedoView>();
+}
+
+void UndoRedoController::handleMessage(MessageActivateTokens* message)
+{
+    MessageActivateTokens* m = new MessageActivateTokens(message->tokenIds);
+    m->isAggregation = message->isAggregation;
+    m->isEdge = message->isEdge;
+    m->UndoRedoType = message->UndoRedoType;
+
+    processMessage(m);
+}
+
+void UndoRedoController::handleMessage(MessageGraphNodeExpand* message)
+{
+    /*MessageGraphNodeExpand* m = new MessageGraphNodeExpand(message->tokenId,message->access);
+    m->UndoRedoType = message->UndoRedoType;
+    processMessage(m);*/
+}
+
+void UndoRedoController::handleMessage(MessageGraphNodeMove* message)
+{
+    /*MessageGraphNodeMove* m = new MessageGraphNodeMove(message->tokenId,message->position);
+    m->UndoRedoType = message->UndoRedoType;
+    processMessage(m, true);*/
+}
+
+void UndoRedoController::handleMessage(MessageRedo* message)
+{
+    if(!m_redo.empty())
+    {
+        MessageBase* m = m_redo.back();
+        m_redo.pop_back();
+        m->UndoRedoType = MessageBase::UndoType_Redo;
+        m->dispatch();
+        delete m;
+    }
+}
+
+void UndoRedoController::handleMessage(MessageUndo* message)
+{
+    if(!m_undo.empty())
+    {
+    	MessageBase* m = m_undo.back();
+        m_undo.pop_back();
+    	m->UndoRedoType = MessageBase::UndoType_Undo;
+    	m->dispatch();
+        delete m;
+    }
+}
+
+void UndoRedoController::processMessage(MessageBase* message)
+{
+    switch(message->UndoRedoType)
+    {
+        case MessageBase::UndoType_Normal:
+            processNormalMessage(message);;
+            break;
+        case MessageBase::UndoType_Redo:
+            processRedoMessage(message);
+            break;
+        case MessageBase::UndoType_Undo:
+            processUndoMessage(message);
+            break;
+    }
+}
+
+
+void UndoRedoController::processNormalMessage(MessageBase* message)
+{
+    if(m_lastCommand != nullptr)
+    {
+        m_undo.push_back(m_lastCommand);
+        getView()->setUndoButtonEnabled(true);
+    }
+    m_lastCommand = message;
+    while(!m_redo.empty())
+    {
+        MessageBase* m = m_redo.back();
+        m_redo.pop_back();
+        delete m;
+    }
+    getView()->setRedoButtonEnabled(false);
+}
+
+void UndoRedoController::processRedoMessage(MessageBase* message)
+{
+    m_undo.push_back(m_lastCommand);
+    getView()->setUndoButtonEnabled(true);
+    m_lastCommand = message;
+    if(m_redo.empty())
+    {
+        getView()->setRedoButtonEnabled(false);
+    }
+}
+
+void UndoRedoController::processUndoMessage(MessageBase* message)
+{
+    m_redo.push_back(m_lastCommand);
+    getView()->setRedoButtonEnabled(true);
+    m_lastCommand = message;
+    if(m_undo.empty())
+    {
+        getView()->setUndoButtonEnabled(false);
+    }
+}
+

src/lib/component/controller/UndoRedoController.h

@@ -0,0 +1,64 @@
+#ifndef UNDO_REDO_CONTROLLER_H
+#define UNDO_REDO_CONTROLLER_H
+
+#include <deque>
+#include <memory>
+#include <stack>
+#include <string>
+
+#include "component/controller/Controller.h"
+
+#include "utility/messaging/MessageBase.h"
+#include "utility/messaging/MessageListener.h"
+#include "utility/messaging/type/MessageActivateTokens.h"
+#include "utility/messaging/type/MessageGraphNodeExpand.h"
+#include "utility/messaging/type/MessageGraphNodeMove.h"
+#include "utility/messaging/type/MessageRedo.h"
+#include "utility/messaging/type/MessageUndo.h"
+
+class UndoRedoView;
+
+struct UndoContainer
+{
+    MessageBase* message;
+    std::vector<MessageBase*> subMessages;
+};
+
+class UndoRedoController
+	: public Controller
+	, public MessageListener<MessageActivateTokens>
+	, public MessageListener<MessageGraphNodeExpand>
+	, public MessageListener<MessageGraphNodeMove>
+	, public MessageListener<MessageRedo>
+	, public MessageListener<MessageUndo>
+{
+public:
+	UndoRedoController(void);
+	virtual ~UndoRedoController(void);
+	UndoRedoView* getView();
+private:
+    enum UndoRedoType
+    {
+        UndoRedoType_Normal,
+        UndoRedoType_Undo,
+        UndoRedoType_Redo
+    };
+
+	virtual void handleMessage(MessageActivateTokens* message);
+	virtual void handleMessage(MessageGraphNodeExpand* message);
+	virtual void handleMessage(MessageGraphNodeMove* message);
+	virtual void handleMessage(MessageRedo* message);
+	virtual void handleMessage(MessageUndo* message);
+
+	void processMessage(MessageBase* message);
+	void processNormalMessage(MessageBase* message);
+	void processRedoMessage(MessageBase* message);
+	void processUndoMessage(MessageBase* message);
+
+	MessageBase* m_lastCommand;
+
+	std::deque<MessageBase*> m_undo;
+	std::deque<MessageBase*> m_redo;
+};
+
+#endif // UNDO_REDO_CONTROLLER_H

src/lib/component/view/UndoRedoView.cpp

@@ -0,0 +1,22 @@
+#include "component/view/UndoRedoView.h"
+
+#include "component/controller/UndoRedoController.h"
+
+UndoRedoView::UndoRedoView(ViewLayout* viewLayout)
+	: View(viewLayout, Vec2i(100,100))
+{
+}
+
+UndoRedoView::~UndoRedoView()
+{
+}
+
+std::string UndoRedoView::getName() const
+{
+	return "UndoRedoView";
+}
+
+UndoRedoController* UndoRedoView::getController()
+{
+	return View::getController<UndoRedoController>();
+}

src/lib/component/view/UndoRedoView.h

@@ -0,0 +1,22 @@
+#ifndef UNDO_REDO_VIEW_H
+#define UNDO_REDO_VIEW_H
+
+#include "component/view/View.h"
+
+class UndoRedoController;
+
+class UndoRedoView : public View
+{
+public:
+	UndoRedoView(ViewLayout* viewLayout);
+	~UndoRedoView(void);
+
+	virtual std::string getName() const;
+
+	virtual void setRedoButtonEnabled(bool enabled) = 0;
+	virtual void setUndoButtonEnabled(bool enabled) = 0;
+protected:
+	UndoRedoController* getController();
+};
+
+#endif //UNDO_REDO_VIEW_H

src/lib/component/view/ViewFactory.h

@@ -8,6 +8,7 @@ class GraphView;
 class MainView;
 class SearchView;
 class StatusBarView;
+class UndoRedoView;
 class ViewLayout;
 
 class ViewFactory
@@ -21,6 +22,7 @@ public:
 	virtual std::shared_ptr<GraphView> createGraphView(ViewLayout* viewLayout) const = 0;
 	virtual std::shared_ptr<SearchView> createSearchView(ViewLayout* viewLayout) const = 0;
 	virtual std::shared_ptr<StatusBarView> createStatusBarView(ViewLayout* viewLayout) const = 0;
+	virtual std::shared_ptr<UndoRedoView> createUndoRedoView(ViewLayout* viewLayout) const = 0;
 };
 
 #endif // VIEW_FACTORY_H

src/lib/utility/messaging/Message.h

@@ -11,6 +11,7 @@ template<typename MessageType>
 class Message: public MessageBase
 {
 public:
+
 	virtual ~Message()
 	{
 	}

src/lib/utility/messaging/MessageBase.h

@@ -6,11 +6,22 @@
 class MessageBase
 {
 public:
+	enum UndoType
+	{
+		UndoType_Normal,
+		UndoType_Redo,
+		UndoType_Undo,
+	};
+	MessageBase() : UndoRedoType(UndoType_Normal){};
 	virtual ~MessageBase()
 	{
 	}
 
 	virtual std::string getType() const = 0;
+	virtual void dispatch() = 0;
+
+	UndoType UndoRedoType;
+
 };
 
 #endif // MESSAGE_BASE_H

src/lib/utility/messaging/type/MessageRedo.h

@@ -0,0 +1,20 @@
+#ifndef MESSAGE_REDO_H
+#define MESSAGE_REDO_H
+
+#include "utility/messaging/Message.h"
+#include "utility/types.h"
+
+class MessageRedo: public Message<MessageRedo>
+{
+public:
+	MessageRedo()
+	{
+	}
+
+	static const std::string getStaticType()
+	{
+		return "MessageRedo";
+	}
+};
+
+#endif // MESSAGE_REDO_H

src/lib/utility/messaging/type/MessageUndo.h

@@ -0,0 +1,20 @@
+#ifndef MESSAGE_UNDO_H
+#define MESSAGE_UNDO_H
+
+#include "utility/messaging/Message.h"
+#include "utility/types.h"
+
+class MessageUndo: public Message<MessageUndo>
+{
+public:
+	MessageUndo()
+	{
+	}
+
+	static const std::string getStaticType()
+	{
+		return "MessageUndo";
+	}
+};
+
+#endif // MESSAGE_UNDO_H