logic: correctly undoing graph interactions by replaying actions since last active token change

This change introdoces a classification of commands by order in the undo stack. Undoing the last action will resend the
message of the last active token change and all messages changing the ui after that.

src/lib/component/controller/CodeController.cpp

@@ -25,6 +25,11 @@ const uint CodeController::s_lineRadius = 2;
 
 void CodeController::handleMessage(MessageActivateTokens* message)
 {
+	if (message->isIgnorable())
+	{
+		return;
+	}
+
 	std::vector<Id> activeTokenIds = message->tokenIds;
 	Id declarationId = 0; // 0 means that no token is found.
 

src/lib/component/controller/FeatureController.cpp

@@ -29,18 +29,23 @@ void FeatureController::handleMessage(MessageActivateEdge* message)
 
 	if (message->type == Edge::EDGE_AGGREGATION)
 	{
-		MessageActivateTokens(m_storageAccess->getTokenIdsForAggregationEdge(edgeId)).dispatch();
+		MessageActivateTokens m(m_storageAccess->getTokenIdsForAggregationEdge(edgeId));
+		m.undoRedoType = message->undoRedoType;
+		m.dispatch();
 		return;
 	}
 
 	MessageActivateTokens msg(std::vector<Id>(1, edgeId));
 	msg.isEdge = true;
-	msg.dispatch();
+	msg.undoRedoType = message->undoRedoType;
+	msg.dispatchImmediately();
 }
 
 void FeatureController::handleMessage(MessageActivateFile* message)
 {
-	MessageActivateTokens(std::vector<Id>(1, m_storageAccess->getTokenIdForFileNode(message->filePath))).dispatch();
+	MessageActivateTokens m(std::vector<Id>(1, m_storageAccess->getTokenIdForFileNode(message->filePath)));
+	m.undoRedoType = message->undoRedoType;
+	m.dispatchImmediately();
 }
 
 void FeatureController::handleMessage(MessageActivateNode* message)
@@ -54,9 +59,10 @@ void FeatureController::handleMessage(MessageActivateNode* message)
 
 	if (nodeId)
 	{
-		MessageActivateTokens msg(nodeId);
-		msg.isFromSystem = message->isFromSystem;
-		msg.dispatch();
+		MessageActivateTokens m(nodeId);
+		m.isFromSystem = message->isFromSystem;
+		m.undoRedoType = message->undoRedoType;
+		m.dispatchImmediately();
 	}
 }
 
@@ -69,11 +75,13 @@ void FeatureController::handleMessage(MessageActivateTokenLocation* message)
 			nodeId,
 			m_storageAccess->getNodeTypeForNodeWithId(nodeId),
 			m_storageAccess->getNameForNodeWithId(nodeId)
-		).dispatch();
+		).dispatchImmediately();
 	}
 }
 
 void FeatureController::handleMessage(MessageSearch* message)
 {
-	MessageActivateTokens(m_storageAccess->getTokenIdsForQuery(message->getQuery())).dispatch();
+	MessageActivateTokens m(m_storageAccess->getTokenIdsForQuery(message->getQuery()));
+	m.undoRedoType = message->undoRedoType;
+	m.dispatchImmediately();
 }

src/lib/component/controller/GraphController.cpp

@@ -15,6 +15,8 @@
 
 GraphController::GraphController(StorageAccess* storageAccess)
 	: m_storageAccess(storageAccess)
+	, m_rebuild(true)
+	, m_restore(false)
 {
 }
 
@@ -24,12 +26,14 @@ GraphController::~GraphController()
 
 void GraphController::handleMessage(MessageActivateTokens* message)
 {
+	setRebuildState(message);
+
 	m_activeTokenIds = message->tokenIds;
 
 	if (message->isEdge && message->tokenIds.size() == 1)
 	{
 		setActiveAndVisibility(message->tokenIds);
-		getView()->rebuildGraph(nullptr, m_dummyNodes, m_dummyEdges);
+		rebuildGraph();
 		return;
 	}
 
@@ -53,6 +57,8 @@ void GraphController::handleMessage(MessageFocusOut *message)
 
 void GraphController::handleMessage(MessageGraphNodeBundleSplit* message)
 {
+	setRebuildState(message);
+
 	for (size_t i = 0; i < m_dummyNodes.size(); i++)
 	{
 		DummyNode& node = m_dummyNodes[i];
@@ -80,40 +86,44 @@ void GraphController::handleMessage(MessageGraphNodeBundleSplit* message)
 	GraphLayouter::layoutSpectralPrototype(m_dummyNodes, m_dummyEdges);
 	GraphPostprocessor::doPostprocessing(m_dummyNodes);
 
-	getView()->rebuildGraph(nullptr, m_dummyNodes, m_dummyEdges);
+	rebuildGraph();
 }
 
 void GraphController::handleMessage(MessageGraphNodeExpand* message)
 {
+	setRebuildState(message);
+
 	DummyNode* node = findDummyNodeRecursive(m_dummyNodes, message->tokenId);
 	if (node)
 	{
-		if (node->autoExpanded)
-		{
-			node->autoExpanded = false;
-			node->expanded = false;
-		}
-		else
-		{
-			node->expanded = !node->expanded;
-		}
+		node->expanded = message->expand;
 
 		setActiveAndVisibility(m_activeTokenIds);
 		layoutNesting();
 
 		GraphPostprocessor::doPostprocessing(m_dummyNodes);
 
-		getView()->rebuildGraph(nullptr, m_dummyNodes, m_dummyEdges);
+		rebuildGraph();
 	}
 }
 
 void GraphController::handleMessage(MessageGraphNodeMove* message)
 {
+	setRebuildState(message);
+
 	DummyNode* node = findDummyNodeRecursive(m_dummyNodes, message->tokenId);
 	if (node)
 	{
 		node->position += message->delta;
-		getView()->resizeView();
+
+		if (message->isFresh())
+		{
+			getView()->resizeView();
+		}
+		else
+		{
+			rebuildGraph();
+		}
 	}
 }
 
@@ -164,7 +174,8 @@ void GraphController::createDummyGraphForTokenIds(const std::vector<Id>& tokenId
 	GraphLayouter::layoutSpectralPrototype(m_dummyNodes, m_dummyEdges);
 	GraphPostprocessor::doPostprocessing(m_dummyNodes);
 
-	view->rebuildGraph(graph, m_dummyNodes, m_dummyEdges);
+	m_graph = graph;
+	rebuildGraph();
 }
 
 DummyNode GraphController::createDummyNodeTopDown(Node* node)
@@ -186,7 +197,7 @@ DummyNode GraphController::createDummyNodeTopDown(Node* node)
 	}
 
 	DummyNode* oldNode = findDummyNodeRecursive(m_dummyNodes, node->getId());
-	if (oldNode)
+	if (oldNode && !m_restore)
 	{
 		result.expanded = oldNode->isExpanded();
 	}
@@ -269,7 +280,7 @@ void GraphController::autoExpandActiveNode(const std::vector<Id>& activeTokenIds
 
 	if (node && node->data->isType(Node::NODE_CLASS | Node::NODE_STRUCT))
 	{
-		node->autoExpanded = true;
+		node->expanded = true;
 	}
 }
 
@@ -762,7 +773,6 @@ void GraphController::addExpandToggleNode(DummyNode& node) const
 	DummyNode expandNode;
 	expandNode.visible = true;
 	expandNode.expanded = node.expanded;
-	expandNode.autoExpanded = node.autoExpanded;
 
 	for (size_t i = 0; i < node.subNodes.size(); i++)
 	{
@@ -871,3 +881,31 @@ DummyNode* GraphController::findDummyNodeAccessRecursive(
 	}
 	return nullptr;
 }
+
+void GraphController::setRebuildState(MessageBase* message)
+{
+	m_restore = false;
+
+	switch (message->undoRedoType)
+	{
+	case MessageBase::UNDOTYPE_UNDO:
+		m_restore = true;
+	case MessageBase::UNDOTYPE_NORMAL:
+	case MessageBase::UNDOTYPE_REDO:
+		m_rebuild = true;
+		break;
+	case MessageBase::UNDOTYPE_IGNORE:
+		m_restore = true;
+		m_rebuild = false;
+		break;
+	}
+}
+
+void GraphController::rebuildGraph()
+{
+	if (m_rebuild)
+	{
+		getView()->rebuildGraph(m_graph, m_dummyNodes, m_dummyEdges);
+		m_graph.reset();
+	}
+}

src/lib/component/controller/GraphController.h

@@ -72,12 +72,19 @@ private:
 	DummyNode* findDummyNodeRecursive(std::vector<DummyNode>& nodes, Id tokenId) const;
 	DummyNode* findDummyNodeAccessRecursive(std::vector<DummyNode>& nodes, Id parentId, TokenComponentAccess::AccessType type) const;
 
+	void setRebuildState(MessageBase* message);
+	void rebuildGraph();
+
 	StorageAccess* m_storageAccess;
 
 	std::vector<DummyNode> m_dummyNodes;
 	std::vector<DummyEdge> m_dummyEdges;
 
 	std::vector<Id> m_activeTokenIds;
+
+	std::shared_ptr<Graph> m_graph;
+	bool m_rebuild;
+	bool m_restore;
 };
 
 #endif // GRAPH_CONTROLLER_H

src/lib/component/controller/SearchController.cpp

@@ -14,6 +14,11 @@ SearchController::~SearchController()
 
 void SearchController::handleMessage(MessageActivateEdge* message)
 {
+	if (message->isIgnorable())
+	{
+		return;
+	}
+
 	SearchMatch match;
 	match.fullName = message->name;
 	match.nodeType = Node::NODE_CLASS;
@@ -25,6 +30,11 @@ void SearchController::handleMessage(MessageActivateEdge* message)
 
 void SearchController::handleMessage(MessageActivateFile* message)
 {
+	if (message->isIgnorable())
+	{
+		return;
+	}
+
 	SearchMatch match;
 	match.fullName = message->filePath.fileName();
 	match.nodeType = Node::NODE_FILE;
@@ -36,6 +46,11 @@ void SearchController::handleMessage(MessageActivateFile* message)
 
 void SearchController::handleMessage(MessageActivateNode* message)
 {
+	if (message->isIgnorable())
+	{
+		return;
+	}
+
 	SearchMatch match;
 	match.fullName = message->name;
 	match.nodeType = message->type;
@@ -57,6 +72,11 @@ void SearchController::handleMessage(MessageFinishedParsing* message)
 
 void SearchController::handleMessage(MessageSearch* message)
 {
+	if (message->isIgnorable())
+	{
+		return;
+	}
+
 	getView()->setMatches(message->getMatches());
 }
 

src/lib/component/controller/UndoRedoController.cpp

@@ -5,7 +5,7 @@
 #include "component/view/UndoRedoView.h"
 
 UndoRedoController::UndoRedoController()
-	: m_lastCommand(nullptr)
+	: m_lastCommand(nullptr, 0)
 {
 }
 
@@ -18,45 +18,64 @@ UndoRedoView* UndoRedoController::getView()
 	return Controller::getView<UndoRedoView>();
 }
 
+UndoRedoController::Command::Command(std::shared_ptr<MessageBase> message, size_t order)
+	: message(message)
+	, order(order)
+{
+}
+
 void UndoRedoController::handleMessage(MessageActivateEdge* message)
 {
-	if (m_lastCommand && m_lastCommand->getType() == message->getType() &&
-		static_cast<MessageActivateEdge*>(m_lastCommand.get())->name == message->name)
+	if (m_lastCommand.message && m_lastCommand.message->getType() == message->getType() &&
+		static_cast<MessageActivateEdge*>(m_lastCommand.message.get())->name == message->name)
 	{
 		return;
 	}
 
-	processMessage(std::make_shared<MessageActivateEdge>(*message));
+	Command command(std::make_shared<MessageActivateEdge>(*message), (message->type == Edge::EDGE_AGGREGATION ? 0 : 1));
+	processCommand(command);
 }
 
 void UndoRedoController::handleMessage(MessageActivateFile* message)
 {
-	if (m_lastCommand && m_lastCommand->getType() == message->getType() &&
-		static_cast<MessageActivateFile*>(m_lastCommand.get())->filePath == message->filePath)
+	if (m_lastCommand.message && m_lastCommand.message->getType() == message->getType() &&
+		static_cast<MessageActivateFile*>(m_lastCommand.message.get())->filePath == message->filePath)
 	{
 		return;
 	}
 
-	processMessage(std::make_shared<MessageActivateFile>(*message));
+	Command command(std::make_shared<MessageActivateFile>(*message), 0);
+	processCommand(command);
 }
 
 void UndoRedoController::handleMessage(MessageActivateNode* message)
 {
-	if (m_lastCommand && m_lastCommand->getType() == message->getType() &&
-		static_cast<MessageActivateNode*>(m_lastCommand.get())->name == message->name)
+	if (m_lastCommand.message && m_lastCommand.message->getType() == message->getType() &&
+		static_cast<MessageActivateNode*>(m_lastCommand.message.get())->name == message->name)
 	{
 		return;
 	}
 
-	processMessage(std::make_shared<MessageActivateNode>(*message));
+	Command command(std::make_shared<MessageActivateNode>(*message), 0);
+	processCommand(command);
+}
+
+void UndoRedoController::handleMessage(MessageGraphNodeBundleSplit* message)
+{
+	Command command(std::make_shared<MessageGraphNodeBundleSplit>(*message), 1);
+	processCommand(command);
 }
 
 void UndoRedoController::handleMessage(MessageGraphNodeExpand* message)
 {
+	Command command(std::make_shared<MessageGraphNodeExpand>(*message), 1);
+	processCommand(command);
 }
 
 void UndoRedoController::handleMessage(MessageGraphNodeMove* message)
 {
+	Command command(std::make_shared<MessageGraphNodeMove>(*message), 1);
+	processCommand(command);
 }
 
 void UndoRedoController::handleMessage(MessageLoadProject* message)
@@ -73,69 +92,87 @@ void UndoRedoController::handleMessage(MessageRedo* message)
 {
 	if (!m_redo.empty())
 	{
-		std::shared_ptr<MessageBase> m = m_redo.back();
+		std::shared_ptr<MessageBase> m = m_redo.back().message;
 		m_redo.pop_back();
-		m->undoRedoType = MessageBase::UndoType_Redo;
+		m->undoRedoType = MessageBase::UNDOTYPE_REDO;
 		m->dispatch();
 	}
 }
 
 void UndoRedoController::handleMessage(MessageSearch* message)
 {
-	if (m_lastCommand && m_lastCommand->getType() == message->getType() &&
-		static_cast<MessageSearch*>(m_lastCommand.get())->getQuery() == message->getQuery())
+	if (m_lastCommand.message && m_lastCommand.message->getType() == message->getType() &&
+		static_cast<MessageSearch*>(m_lastCommand.message.get())->getQuery() == message->getQuery())
 	{
 		return;
 	}
 
-	processMessage(std::make_shared<MessageSearch>(*message));
+	Command command(std::make_shared<MessageSearch>(*message), 0);
+	processCommand(command);
 }
 
 void UndoRedoController::handleMessage(MessageUndo* message)
 {
 	if (!m_undo.empty())
 	{
-		std::shared_ptr<MessageBase> m = m_undo.back();
+		int i = m_undo.size() - 1;
+		while (i >= 1 && m_undo[i].order > 0)
+		{
+			i--;
+		}
+
+		std::shared_ptr<MessageBase> m;
+		while (i < int(m_undo.size() - 1))
+		{
+			m = m_undo[i].message;
+			m->undoRedoType = MessageBase::UNDOTYPE_IGNORE;
+			m->dispatch();
+			i++;
+		}
+
+		m = m_undo.back().message;
 		m_undo.pop_back();
-		m->undoRedoType = MessageBase::UndoType_Undo;
+		m->undoRedoType = MessageBase::UNDOTYPE_UNDO;
 		m->dispatch();
 	}
 }
 
-void UndoRedoController::processMessage(std::shared_ptr<MessageBase> message)
+void UndoRedoController::processCommand(const Command& command)
 {
-	switch (message->undoRedoType)
+	switch (command.message->undoRedoType)
 	{
-	case MessageBase::UndoType_Normal:
-		processNormalMessage(message);;
+	case MessageBase::UNDOTYPE_NORMAL:
+		processNormalCommand(command);
 		break;
-	case MessageBase::UndoType_Redo:
-		processRedoMessage(message);
+	case MessageBase::UNDOTYPE_REDO:
+		processRedoCommand(command);
 		break;
-	case MessageBase::UndoType_Undo:
-		processUndoMessage(message);
+	case MessageBase::UNDOTYPE_UNDO:
+		processUndoCommand(command);
+		break;
+	case MessageBase::UNDOTYPE_IGNORE:
 		break;
 	}
 }
 
-void UndoRedoController::processNormalMessage(std::shared_ptr<MessageBase> message)
+void UndoRedoController::processNormalCommand(const Command& command)
 {
-	if (m_lastCommand)
+	if (m_lastCommand.message)
 	{
 		m_undo.push_back(m_lastCommand);
 		getView()->setUndoButtonEnabled(true);
 	}
 
-	m_lastCommand = message;
+	m_lastCommand = command;
 
 	m_redo.clear();
 	getView()->setRedoButtonEnabled(false);
 }
 
-void UndoRedoController::processRedoMessage(std::shared_ptr<MessageBase> message)
+void UndoRedoController::processRedoCommand(const Command& command)
 {
 	m_undo.push_back(m_lastCommand);
-	m_lastCommand = message;
+	m_lastCommand = command;
 
 	getView()->setUndoButtonEnabled(true);
 
@@ -145,10 +182,10 @@ void UndoRedoController::processRedoMessage(std::shared_ptr<MessageBase> message
 	}
 }
 
-void UndoRedoController::processUndoMessage(std::shared_ptr<MessageBase> message)
+void UndoRedoController::processUndoCommand(const Command& command)
 {
 	m_redo.push_back(m_lastCommand);
-	m_lastCommand = message;
+	m_lastCommand = command;
 
 	getView()->setRedoButtonEnabled(true);
 
@@ -160,7 +197,7 @@ void UndoRedoController::processUndoMessage(std::shared_ptr<MessageBase> message
 
 void UndoRedoController::clear()
 {
-	m_lastCommand = nullptr;
+	m_lastCommand = Command(nullptr, 0);
 
 	m_undo.clear();
 	m_redo.clear();

src/lib/component/controller/UndoRedoController.h

@@ -8,6 +8,7 @@
 #include "utility/messaging/type/MessageActivateEdge.h"
 #include "utility/messaging/type/MessageActivateFile.h"
 #include "utility/messaging/type/MessageActivateNode.h"
+#include "utility/messaging/type/MessageGraphNodeBundleSplit.h"
 #include "utility/messaging/type/MessageGraphNodeExpand.h"
 #include "utility/messaging/type/MessageGraphNodeMove.h"
 #include "utility/messaging/type/MessageLoadProject.h"
@@ -25,6 +26,7 @@ class UndoRedoController
 	, public MessageListener<MessageActivateEdge>
 	, public MessageListener<MessageActivateFile>
 	, public MessageListener<MessageActivateNode>
+	, public MessageListener<MessageGraphNodeBundleSplit>
 	, public MessageListener<MessageGraphNodeExpand>
 	, public MessageListener<MessageGraphNodeMove>
 	, public MessageListener<MessageLoadProject>
@@ -40,9 +42,18 @@ public:
 	UndoRedoView* getView();
 
 private:
+	struct Command
+	{
+		Command(std::shared_ptr<MessageBase> message, size_t order);
+
+		std::shared_ptr<MessageBase> message;
+		size_t order;
+	};
+
 	virtual void handleMessage(MessageActivateEdge* message);
 	virtual void handleMessage(MessageActivateFile* message);
 	virtual void handleMessage(MessageActivateNode* message);
+	virtual void handleMessage(MessageGraphNodeBundleSplit* message);
 	virtual void handleMessage(MessageGraphNodeExpand* message);
 	virtual void handleMessage(MessageGraphNodeMove* message);
 	virtual void handleMessage(MessageLoadProject* message);
@@ -51,17 +62,17 @@ private:
 	virtual void handleMessage(MessageSearch* message);
 	virtual void handleMessage(MessageUndo* message);
 
-	void processMessage(std::shared_ptr<MessageBase> message);
-	void processNormalMessage(std::shared_ptr<MessageBase> message);
-	void processRedoMessage(std::shared_ptr<MessageBase> message);
-	void processUndoMessage(std::shared_ptr<MessageBase> message);
+	void processCommand(const Command& command);
+	void processNormalCommand(const Command& command);
+	void processRedoCommand(const Command& command);
+	void processUndoCommand(const Command& command);
 
 	void clear();
 
-	std::shared_ptr<MessageBase> m_lastCommand;
+	Command m_lastCommand;
 
-	std::deque<std::shared_ptr<MessageBase>> m_undo;
-	std::deque<std::shared_ptr<MessageBase>> m_redo;
+	std::deque<Command> m_undo;
+	std::deque<Command> m_redo;
 };
 
 #endif // UNDO_REDO_CONTROLLER_H

src/lib/component/controller/helper/DummyNode.h

@@ -22,7 +22,6 @@ public:
 		, connected(false)
 		, aggregated(false)
 		, expanded(false)
-		, autoExpanded(false)
 		, accessType(TokenComponentAccess::ACCESS_NONE)
 		, invisibleSubNodeCount(0)
 	{
@@ -50,7 +49,7 @@ public:
 
 	bool isExpanded() const
 	{
-		return expanded || autoExpanded;
+		return expanded;
 	}
 
 	bool hasVisibleSubNode() const
@@ -119,7 +118,6 @@ public:
 	bool connected;
 	bool aggregated;
 	bool expanded;
-	bool autoExpanded;
 
 	// AccessNode
 	TokenComponentAccess::AccessType accessType;