logic: rewrote messages handling token activation for correct restoring on undo

* saving search query to undo stack with MessageSearch
* saving node and edge with name to undo stack with MessageActivateNode and MessageActivateEdge
* added FeatureController that handels distribution of MessageActivateTokens
* clearing views when refreshing or changing project
* clearing undo stack when changing project
* added StorageCache derived from StorageAccessProxy

src/lib/component/controller/CodeController.cpp

@@ -23,20 +23,6 @@ CodeController::~CodeController()
 
 const uint CodeController::s_lineRadius = 2;
 
-void CodeController::handleMessage(MessageActivateFile* message)
-{
-	MessageActivateTokens(std::vector<Id>(1, m_storageAccess->getTokenIdForFileNode(message->filePath))).dispatch();
-}
-
-void CodeController::handleMessage(MessageActivateTokenLocation* message)
-{
-	if (message->locationId)
-	{
-		std::vector<Id> activeTokenIds = m_storageAccess->getActiveTokenIdsForLocationId(message->locationId);
-		MessageActivateTokens(activeTokenIds).dispatch();
-	}
-}
-
 void CodeController::handleMessage(MessageActivateTokens* message)
 {
 	std::vector<Id> activeTokenIds = message->tokenIds;

src/lib/component/controller/CodeController.h

@@ -5,8 +5,6 @@
 #include <string>
 
 #include "utility/messaging/MessageListener.h"
-#include "utility/messaging/type/MessageActivateFile.h"
-#include "utility/messaging/type/MessageActivateTokenLocation.h"
 #include "utility/messaging/type/MessageActivateTokens.h"
 #include "utility/messaging/type/MessageFinishedParsing.h"
 #include "utility/messaging/type/MessageFocusIn.h"
@@ -24,8 +22,6 @@ class TokenLocationFile;
 
 class CodeController
 	: public Controller
-	, public MessageListener<MessageActivateFile>
-	, public MessageListener<MessageActivateTokenLocation>
 	, public MessageListener<MessageActivateTokens>
 	, public MessageListener<MessageFinishedParsing>
 	, public MessageListener<MessageFocusIn>
@@ -39,8 +35,6 @@ public:
 private:
 	static const uint s_lineRadius;
 
-	virtual void handleMessage(MessageActivateFile* message);
-	virtual void handleMessage(MessageActivateTokenLocation* message);
 	virtual void handleMessage(MessageActivateTokens* message);
 	virtual void handleMessage(MessageFinishedParsing* message);
 	virtual void handleMessage(MessageFocusIn* message);

src/lib/component/controller/FeatureController.cpp

@@ -0,0 +1,79 @@
+#include "component/controller/FeatureController.h"
+
+#include "utility/messaging/type/MessageActivateTokens.h"
+
+#include "data/access/StorageAccess.h"
+
+FeatureController::FeatureController(StorageAccess* storageAccess)
+	: m_storageAccess(storageAccess)
+{
+}
+
+FeatureController::~FeatureController()
+{
+}
+
+void FeatureController::handleMessage(MessageActivateEdge* message)
+{
+	Id edgeId = message->tokenId;
+
+	if (!message->isFresh())
+	{
+		edgeId = m_storageAccess->getIdForEdgeWithName(message->name);
+	}
+
+	if (!edgeId)
+	{
+		return;
+	}
+
+	if (message->type == Edge::EDGE_AGGREGATION)
+	{
+		MessageActivateTokens(m_storageAccess->getTokenIdsForAggregationEdge(edgeId)).dispatch();
+		return;
+	}
+
+	MessageActivateTokens msg(std::vector<Id>(1, edgeId));
+	msg.isEdge = true;
+	msg.dispatch();
+}
+
+void FeatureController::handleMessage(MessageActivateFile* message)
+{
+	MessageActivateTokens(std::vector<Id>(1, m_storageAccess->getTokenIdForFileNode(message->filePath))).dispatch();
+}
+
+void FeatureController::handleMessage(MessageActivateNode* message)
+{
+	Id nodeId = message->tokenId;
+
+	if (!message->isFresh())
+	{
+		nodeId = m_storageAccess->getIdForNodeWithName(message->name);
+	}
+
+	if (nodeId)
+	{
+		MessageActivateTokens msg(nodeId);
+		msg.isFromSystem = message->isFromSystem;
+		msg.dispatch();
+	}
+}
+
+void FeatureController::handleMessage(MessageActivateTokenLocation* message)
+{
+	if (message->locationId)
+	{
+		Id nodeId = m_storageAccess->getActiveNodeIdForLocationId(message->locationId);
+		MessageActivateNode(
+			nodeId,
+			m_storageAccess->getNodeTypeForNodeWithId(nodeId),
+			m_storageAccess->getNameForNodeWithId(nodeId)
+		).dispatch();
+	}
+}
+
+void FeatureController::handleMessage(MessageSearch* message)
+{
+	MessageActivateTokens(m_storageAccess->getTokenIdsForQuery(message->getQuery())).dispatch();
+}

src/lib/component/controller/FeatureController.h

@@ -0,0 +1,37 @@
+#ifndef FEATURE_CONTROLLER_H
+#define FEATURE_CONTROLLER_H
+
+#include "utility/messaging/MessageListener.h"
+#include "utility/messaging/type/MessageActivateEdge.h"
+#include "utility/messaging/type/MessageActivateFile.h"
+#include "utility/messaging/type/MessageActivateNode.h"
+#include "utility/messaging/type/MessageActivateTokenLocation.h"
+#include "utility/messaging/type/MessageSearch.h"
+
+#include "component/controller/Controller.h"
+
+class StorageAccess;
+
+class FeatureController
+	: public Controller
+	, public MessageListener<MessageActivateEdge>
+	, public MessageListener<MessageActivateFile>
+	, public MessageListener<MessageActivateNode>
+	, public MessageListener<MessageActivateTokenLocation>
+	, public MessageListener<MessageSearch>
+{
+public:
+	FeatureController(StorageAccess* storageAccess);
+	~FeatureController();
+
+private:
+	virtual void handleMessage(MessageActivateEdge* message);
+	virtual void handleMessage(MessageActivateFile* message);
+	virtual void handleMessage(MessageActivateNode* message);
+	virtual void handleMessage(MessageActivateTokenLocation* message);
+	virtual void handleMessage(MessageSearch* message);
+
+	StorageAccess* m_storageAccess;
+};
+
+#endif // FEATURE_CONTROLLER_H

src/lib/component/controller/SearchController.cpp

@@ -5,7 +5,6 @@
 
 SearchController::SearchController(StorageAccess* storageAccess)
 	: m_storageAccess(storageAccess)
-	, m_ignoreNextMessageActivateTokens(false)
 {
 }
 
@@ -13,21 +12,37 @@ SearchController::~SearchController()
 {
 }
 
-void SearchController::handleMessage(MessageActivateTokens* message)
+void SearchController::handleMessage(MessageActivateEdge* message)
 {
-	if (!m_ignoreNextMessageActivateTokens && message->tokenIds.size())
-	{
-		SearchMatch match;
-		match.fullName = m_storageAccess->getNameForNodeWithId(message->tokenIds[0]);
-		match.nodeType = m_storageAccess->getNodeTypeForNodeWithId(message->tokenIds[0]);
-		match.tokenIds.insert(message->tokenIds[0]);
-		match.queryNodeType = QueryNode::QUERYNODETYPE_TOKEN;
+	SearchMatch match;
+	match.fullName = message->name;
+	match.nodeType = Node::NODE_CLASS;
+	match.tokenIds.insert(message->tokenId);
+	match.queryNodeType = QueryNode::QUERYNODETYPE_TOKEN;
 
+	getView()->setMatches(std::deque<SearchMatch>(1, match));
+}
 
-		getView()->setMatch(match);
-	}
+void SearchController::handleMessage(MessageActivateFile* message)
+{
+	SearchMatch match;
+	match.fullName = message->filePath.fileName();
+	match.nodeType = Node::NODE_FILE;
+	match.tokenIds.insert(m_storageAccess->getTokenIdForFileNode(message->filePath));
+	match.queryNodeType = QueryNode::QUERYNODETYPE_TOKEN;
 
-	m_ignoreNextMessageActivateTokens = false;
+	getView()->setMatches(std::deque<SearchMatch>(1, match));
+}
+
+void SearchController::handleMessage(MessageActivateNode* message)
+{
+	SearchMatch match;
+	match.fullName = message->name;
+	match.nodeType = message->type;
+	match.tokenIds.insert(message->tokenId);
+	match.queryNodeType = QueryNode::QUERYNODETYPE_TOKEN;
+
+	getView()->setMatches(std::deque<SearchMatch>(1, match));
 }
 
 void SearchController::handleMessage(MessageFind* message)
@@ -37,28 +52,12 @@ void SearchController::handleMessage(MessageFind* message)
 
 void SearchController::handleMessage(MessageFinishedParsing* message)
 {
-	getView()->setText("");
+	getView()->setMatches(std::deque<SearchMatch>());
 }
 
 void SearchController::handleMessage(MessageSearch* message)
 {
-	const std::string& query = message->query;
-
-	LOG_INFO("search string: \"" + query + "\"");
-
-	m_ignoreNextMessageActivateTokens = true;
-
-	std::vector<Id> ids = m_storageAccess->getTokenIdsForQuery(query);
-	if (!ids.size())
-	{
-		Id id = m_storageAccess->getIdForNodeWithName(query);
-		if (id > 0)
-		{
-			ids.push_back(id);
-		}
-	}
-
-	MessageActivateTokens(ids).dispatch();
+	getView()->setMatches(message->getMatches());
 }
 
 void SearchController::handleMessage(MessageSearchAutocomplete* message)

src/lib/component/controller/SearchController.h

@@ -5,7 +5,9 @@
 
 #include "component/controller/Controller.h"
 #include "utility/messaging/MessageListener.h"
-#include "utility/messaging/type/MessageActivateTokens.h"
+#include "utility/messaging/type/MessageActivateEdge.h"
+#include "utility/messaging/type/MessageActivateFile.h"
+#include "utility/messaging/type/MessageActivateNode.h"
 #include "utility/messaging/type/MessageFind.h"
 #include "utility/messaging/type/MessageFinishedParsing.h"
 #include "utility/messaging/type/MessageSearch.h"
@@ -16,7 +18,9 @@ class SearchView;
 
 class SearchController
 	: public Controller
-	, public MessageListener<MessageActivateTokens>
+	, public MessageListener<MessageActivateEdge>
+	, public MessageListener<MessageActivateFile>
+	, public MessageListener<MessageActivateNode>
 	, public MessageListener<MessageFind>
 	, public MessageListener<MessageFinishedParsing>
 	, public MessageListener<MessageSearch>
@@ -27,7 +31,9 @@ public:
 	~SearchController();
 
 private:
-	virtual void handleMessage(MessageActivateTokens* message);
+	virtual void handleMessage(MessageActivateEdge* message);
+	virtual void handleMessage(MessageActivateFile* message);
+	virtual void handleMessage(MessageActivateNode* message);
 	virtual void handleMessage(MessageFind* message);
 	virtual void handleMessage(MessageFinishedParsing* message);
 	virtual void handleMessage(MessageSearch* message);
@@ -36,8 +42,6 @@ private:
 	SearchView* getView();
 
 	StorageAccess* m_storageAccess;
-
-	bool m_ignoreNextMessageActivateTokens;
 };
 
 #endif // SEARCH_CONTROLLER_H

src/lib/component/controller/UndoRedoController.cpp

@@ -1,8 +1,9 @@
 #include "component/controller/UndoRedoController.h"
 
-#include "component/view/UndoRedoView.h"
 #include "utility/logging/logging.h"
 
+#include "component/view/UndoRedoView.h"
+
 UndoRedoController::UndoRedoController()
 	: m_lastCommand(nullptr)
 {
@@ -17,108 +18,153 @@ UndoRedoView* UndoRedoController::getView()
 	return Controller::getView<UndoRedoView>();
 }
 
-void UndoRedoController::handleMessage(MessageActivateTokens* message)
+void UndoRedoController::handleMessage(MessageActivateEdge* message)
 {
-    if(m_lastCommand && m_lastCommand->getType() == "MessageActivateTokens")
-    {
-        if(static_cast<MessageActivateTokens*>(m_lastCommand.get())->tokenIds == message->tokenIds)
-        {
-            return;
-        }
-    }
-    std::shared_ptr<MessageActivateTokens> m = std::shared_ptr<MessageActivateTokens>(new MessageActivateTokens(*message));
-    std::shared_ptr<MessageBase> msg = m;
-    processMessage(msg);
+	if (m_lastCommand && m_lastCommand->getType() == message->getType() &&
+		static_cast<MessageActivateEdge*>(m_lastCommand.get())->name == message->name)
+	{
+		return;
+	}
+
+	processMessage(std::make_shared<MessageActivateEdge>(*message));
+}
+
+void UndoRedoController::handleMessage(MessageActivateFile* message)
+{
+	if (m_lastCommand && m_lastCommand->getType() == message->getType() &&
+		static_cast<MessageActivateFile*>(m_lastCommand.get())->filePath == message->filePath)
+	{
+		return;
+	}
+
+	processMessage(std::make_shared<MessageActivateFile>(*message));
+}
+
+void UndoRedoController::handleMessage(MessageActivateNode* message)
+{
+	if (m_lastCommand && m_lastCommand->getType() == message->getType() &&
+		static_cast<MessageActivateNode*>(m_lastCommand.get())->name == message->name)
+	{
+		return;
+	}
+
+	processMessage(std::make_shared<MessageActivateNode>(*message));
 }
 
 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(MessageLoadProject* message)
+{
+	clear();
+}
+
+void UndoRedoController::handleMessage(MessageLoadSource* message)
+{
+	clear();
 }
 
 void UndoRedoController::handleMessage(MessageRedo* message)
 {
-    if(!m_redo.empty())
-    {
-        std::shared_ptr<MessageBase> m = m_redo.back();
-        m_redo.pop_back();
-        m->UndoRedoType = MessageBase::UndoType_Redo;
-        m->dispatch();
-    }
+	if (!m_redo.empty())
+	{
+		std::shared_ptr<MessageBase> m = m_redo.back();
+		m_redo.pop_back();
+		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())
+	{
+		return;
+	}
+
+	processMessage(std::make_shared<MessageSearch>(*message));
 }
 
 void UndoRedoController::handleMessage(MessageUndo* message)
 {
-    if(!m_undo.empty())
-    {
-    	std::shared_ptr<MessageBase> m = m_undo.back();
-        m_undo.pop_back();
-    	m->UndoRedoType = MessageBase::UndoType_Undo;
-    	m->dispatch();
-    }
+	if (!m_undo.empty())
+	{
+		std::shared_ptr<MessageBase> m = m_undo.back();
+		m_undo.pop_back();
+		m->undoRedoType = MessageBase::UndoType_Undo;
+		m->dispatch();
+	}
 }
 
 void UndoRedoController::processMessage(std::shared_ptr<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;
-    }
+	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(std::shared_ptr<MessageBase> message)
 {
-    if(m_lastCommand != nullptr)
-    {
-        m_undo.push_back(m_lastCommand);
-        getView()->setUndoButtonEnabled(true);
-    }
-    m_lastCommand = message;
-    while(!m_redo.empty())
-    {
-        std::shared_ptr<MessageBase> m = m_redo.back();
-        m_redo.pop_back();
-    }
-    getView()->setRedoButtonEnabled(false);
+	if (m_lastCommand)
+	{
+		m_undo.push_back(m_lastCommand);
+		getView()->setUndoButtonEnabled(true);
+	}
+
+	m_lastCommand = message;
+
+	m_redo.clear();
+	getView()->setRedoButtonEnabled(false);
 }
 
 void UndoRedoController::processRedoMessage(std::shared_ptr<MessageBase> message)
 {
-    m_undo.push_back(m_lastCommand);
-    getView()->setUndoButtonEnabled(true);
-    m_lastCommand = message;
-    if(m_redo.empty())
-    {
-        getView()->setRedoButtonEnabled(false);
-    }
+	m_undo.push_back(m_lastCommand);
+	m_lastCommand = message;
+
+	getView()->setUndoButtonEnabled(true);
+
+	if (m_redo.empty())
+	{
+		getView()->setRedoButtonEnabled(false);
+	}
 }
 
 void UndoRedoController::processUndoMessage(std::shared_ptr<MessageBase> message)
 {
-    m_redo.push_back(m_lastCommand);
-    getView()->setRedoButtonEnabled(true);
-    m_lastCommand = message;
-    if(m_undo.empty())
-    {
-        getView()->setUndoButtonEnabled(false);
-    }
+	m_redo.push_back(m_lastCommand);
+	m_lastCommand = message;
+
+	getView()->setRedoButtonEnabled(true);
+
+	if (m_undo.empty())
+	{
+		getView()->setUndoButtonEnabled(false);
+	}
 }
 
+void UndoRedoController::clear()
+{
+	m_lastCommand = nullptr;
+
+	m_undo.clear();
+	m_redo.clear();
+
+	getView()->setUndoButtonEnabled(false);
+	getView()->setRedoButtonEnabled(false);
+}

src/lib/component/controller/UndoRedoController.h

@@ -2,46 +2,53 @@
 #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/MessageActivateEdge.h"
+#include "utility/messaging/type/MessageActivateFile.h"
+#include "utility/messaging/type/MessageActivateNode.h"
 #include "utility/messaging/type/MessageGraphNodeExpand.h"
 #include "utility/messaging/type/MessageGraphNodeMove.h"
+#include "utility/messaging/type/MessageLoadProject.h"
+#include "utility/messaging/type/MessageLoadSource.h"
 #include "utility/messaging/type/MessageRedo.h"
+#include "utility/messaging/type/MessageSearch.h"
 #include "utility/messaging/type/MessageUndo.h"
 
+#include "component/controller/Controller.h"
+
 class UndoRedoView;
 
 class UndoRedoController
 	: public Controller
-	, public MessageListener<MessageActivateTokens>
+	, public MessageListener<MessageActivateEdge>
+	, public MessageListener<MessageActivateFile>
+	, public MessageListener<MessageActivateNode>
 	, public MessageListener<MessageGraphNodeExpand>
 	, public MessageListener<MessageGraphNodeMove>
+	, public MessageListener<MessageLoadProject>
+	, public MessageListener<MessageLoadSource>
 	, public MessageListener<MessageRedo>
+	, public MessageListener<MessageSearch>
 	, public MessageListener<MessageUndo>
 {
 public:
-	UndoRedoController(void);
-	virtual ~UndoRedoController(void);
-	UndoRedoView* getView();
-private:
-    enum UndoRedoType
-    {
-        UndoRedoType_Normal,
-        UndoRedoType_Undo,
-        UndoRedoType_Redo
-    };
+	UndoRedoController();
+	virtual ~UndoRedoController();
 
-	virtual void handleMessage(MessageActivateTokens* message);
+	UndoRedoView* getView();
+
+private:
+	virtual void handleMessage(MessageActivateEdge* message);
+	virtual void handleMessage(MessageActivateFile* message);
+	virtual void handleMessage(MessageActivateNode* message);
 	virtual void handleMessage(MessageGraphNodeExpand* message);
 	virtual void handleMessage(MessageGraphNodeMove* message);
+	virtual void handleMessage(MessageLoadProject* message);
+	virtual void handleMessage(MessageLoadSource* message);
 	virtual void handleMessage(MessageRedo* message);
+	virtual void handleMessage(MessageSearch* message);
 	virtual void handleMessage(MessageUndo* message);
 
 	void processMessage(std::shared_ptr<MessageBase> message);
@@ -49,6 +56,8 @@ private:
 	void processRedoMessage(std::shared_ptr<MessageBase> message);
 	void processUndoMessage(std::shared_ptr<MessageBase> message);
 
+	void clear();
+
 	std::shared_ptr<MessageBase> m_lastCommand;
 
 	std::deque<std::shared_ptr<MessageBase>> m_undo;