logic: Show overview of analyzed symbols after launch

* show analysed nodes as bundles in graph
* ellide node names longer than 50 chars
* sort nodes alphabetic in these bundles
* show stats of analysis in code
* error are displayed as well in overview
* added keywords overview and error
* project description can be set in .coatiproject file
* description can include links to symbols using [symbol] syntax
* updated documentation
* increased toc nesting in documentation

src/lib/component/controller/CodeController.cpp

@@ -5,6 +5,7 @@
 #include "utility/messaging/type/MessageStatus.h"
 #include "utility/text/TextAccess.h"
 #include "utility/utility.h"
+#include "utility/utilityString.h"
 
 #include "data/access/StorageAccess.h"
 #include "data/location/TokenLocation.h"
@@ -12,6 +13,7 @@
 #include "data/location/TokenLocationFile.h"
 #include "data/location/TokenLocationLine.h"
 #include "settings/ApplicationSettings.h"
+#include "settings/ProjectSettings.h"
 
 CodeController::CodeController(StorageAccess* storageAccess)
 	: m_storageAccess(storageAccess)
@@ -24,6 +26,63 @@ CodeController::~CodeController()
 
 const uint CodeController::s_lineRadius = 2;
 
+void CodeController::handleMessage(MessageActivateAll* message)
+{
+	std::vector<std::string> errorMessages;
+	std::vector<CodeView::CodeSnippetParams> snippets = getSnippetsForErrorLocations(&errorMessages);
+
+	StorageStats stats = m_storageAccess->getStorageStats();
+	CodeView::CodeSnippetParams statsSnippet;
+
+	statsSnippet.startLineNumber = 1;
+	statsSnippet.endLineNumber = 1;
+
+	statsSnippet.locationFile = std::make_shared<TokenLocationFile>(FilePath());
+	statsSnippet.locationFile->isWholeCopy = true;
+
+	std::vector<std::string> description = getProjectDescription(statsSnippet.locationFile.get());
+
+	std::stringstream ss;
+
+	ss << "\n";
+	ss << "\t" + ProjectSettings::getInstance()->getFilePath().withoutExtension().fileName() + "\n";
+
+	if (description.size())
+	{
+		ss << "\n";
+		for (const std::string& line : description)
+		{
+			ss << line + "\n";
+		}
+	}
+
+	ss << "\n";
+	ss << "\t" + std::to_string(stats.fileCount) + " files\n";
+	ss << "\t" + std::to_string(stats.fileLOCCount) + " lines of code\n";
+	ss << "\n";
+	ss << "\t" + std::to_string(stats.nodeCount) + " symbols\n";
+	ss << "\t" + std::to_string(stats.edgeCount) + " relations\n";
+	ss << "\n";
+	ss << "\t" + std::to_string(stats.errorCount) + " errors\n";
+	ss << "\n";
+
+	if (stats.errorCount > 0)
+	{
+		ss << "\tWarning: The analysis may be incomplete as long as it yields errors.\n";
+		ss << "\tTry resolving them and refresh the project.\n";
+		ss << "\n";
+	}
+
+	statsSnippet.code = ss.str();
+
+	snippets.insert(snippets.begin(), statsSnippet);
+
+	CodeView* view = getView();
+	view->setActiveTokenIds(std::vector<Id>());
+	view->setErrorMessages(errorMessages);
+	view->showCodeSnippets(snippets);
+}
+
 void CodeController::handleMessage(MessageActivateTokens* message)
 {
 	if (message->keepContent() && message->isIgnorable())
@@ -92,17 +151,7 @@ void CodeController::handleMessage(MessageFocusOut* message)
 void CodeController::handleMessage(MessageShowErrors* message)
 {
 	std::vector<std::string> errorMessages;
-	TokenLocationCollection errorCollection = m_storageAccess->getErrorTokenLocations(&errorMessages);
-
-	std::vector<CodeView::CodeSnippetParams> snippets;
-
-	errorCollection.forEachTokenLocationFile(
-		[&](std::shared_ptr<TokenLocationFile> file) -> void
-		{
-			std::vector<CodeView::CodeSnippetParams> fileSnippets = getSnippetsForFile(file);
-			snippets.insert(snippets.end(), fileSnippets.begin(), fileSnippets.end());
-		}
-	);
+	std::vector<CodeView::CodeSnippetParams> snippets = getSnippetsForErrorLocations(&errorMessages);
 
 	CodeView* view = getView();
 	view->setActiveTokenIds(std::vector<Id>());
@@ -357,3 +406,72 @@ std::shared_ptr<SnippetMerger> CodeController::buildMergerHierarchy(
 	nextMerger->addChild(currentMerger);
 	return currentMerger;
 }
+
+std::vector<CodeView::CodeSnippetParams> CodeController::getSnippetsForErrorLocations(
+	std::vector<std::string>* errorMessages)
+const {
+	TokenLocationCollection errorCollection = m_storageAccess->getErrorTokenLocations(errorMessages);
+
+	std::vector<CodeView::CodeSnippetParams> snippets;
+
+	errorCollection.forEachTokenLocationFile(
+		[&](std::shared_ptr<TokenLocationFile> file) -> void
+		{
+			std::vector<CodeView::CodeSnippetParams> fileSnippets = getSnippetsForFile(file);
+			snippets.insert(snippets.end(), fileSnippets.begin(), fileSnippets.end());
+		}
+	);
+
+	return snippets;
+}
+
+std::vector<std::string> CodeController::getProjectDescription(TokenLocationFile* locationFile) const
+{
+	std::string description = ProjectSettings::getInstance()->getDescription();
+
+	if (!description.size())
+	{
+		return std::vector<std::string>();
+	}
+
+	std::vector<std::string> lines = utility::splitToVector(description, "\\n");
+	size_t startLineNumber = 4;
+
+	for (size_t i = 0; i < lines.size(); i++)
+	{
+		std::string line = "\t" + lines[i];
+
+		size_t pos = 0;
+
+		while (pos != std::string::npos)
+		{
+			size_t posA = line.find('[', pos);
+			size_t posB = line.find(']', posA);
+
+			if (posA == std::string::npos || posB == std::string::npos)
+			{
+				break;
+			}
+
+			std::string tokenName = line.substr(posA + 1, posB - posA - 1);
+
+			Id tokenId = m_storageAccess->getIdForNodeWithSearchNameHierarchy(NameHierarchy(tokenName));
+
+			if (tokenId > 0)
+			{
+				line.replace(posA, posB - posA + 1, tokenName);
+				locationFile->addTokenLocation(
+					0, tokenId,
+					startLineNumber + i, posA + 1,
+					startLineNumber + i, posA + tokenName.size()
+				);
+			}
+
+			pos = posA + tokenName.size();
+		}
+
+		lines[i] = line;
+	}
+
+	return lines;
+}

src/lib/component/controller/CodeController.h

@@ -5,6 +5,7 @@
 #include <string>
 
 #include "utility/messaging/MessageListener.h"
+#include "utility/messaging/type/MessageActivateAll.h"
 #include "utility/messaging/type/MessageActivateTokens.h"
 #include "utility/messaging/type/MessageFocusIn.h"
 #include "utility/messaging/type/MessageFocusOut.h"
@@ -24,6 +25,7 @@ class TokenLocationFile;
 
 class CodeController
 	: public Controller
+	, public MessageListener<MessageActivateAll>
 	, public MessageListener<MessageActivateTokens>
 	, public MessageListener<MessageFocusIn>
 	, public MessageListener<MessageFocusOut>
@@ -39,6 +41,7 @@ public:
 private:
 	static const uint s_lineRadius;
 
+	virtual void handleMessage(MessageActivateAll* message);
 	virtual void handleMessage(MessageActivateTokens* message);
 	virtual void handleMessage(MessageFocusIn* message);
 	virtual void handleMessage(MessageFocusOut* message);
@@ -57,6 +60,10 @@ private:
 	std::shared_ptr<SnippetMerger> buildMergerHierarchy(
 		TokenLocation* location, SnippetMerger& fileScopedMerger, std::map<int, std::shared_ptr<SnippetMerger>>& mergers) const;
 
+	std::vector<CodeView::CodeSnippetParams> getSnippetsForErrorLocations(std::vector<std::string>* errorMessages) const;
+
+	std::vector<std::string> getProjectDescription(TokenLocationFile* locationFile) const;
+
 	StorageAccess* m_storageAccess;
 };
 

src/lib/component/controller/FeatureController.cpp

@@ -53,6 +53,15 @@ void FeatureController::handleMessage(MessageSearch* message)
 	}
 }
 
+void FeatureController::handleMessage(MessageActivateTokenIds* message)
+{
+	std::shared_ptr<MessageActivateTokens> m = m_activationTranslator.translateMessage(message);
+	if (m)
+	{
+		m->dispatchImmediately();
+	}
+}
+
 void FeatureController::handleMessage(MessageActivateTokenLocations* message)
 {
 	std::vector<Id> nodeIds = m_storageAccess->getNodeIdsForLocationIds(message->locationIds);

src/lib/component/controller/FeatureController.h

@@ -10,6 +10,7 @@
 #include "utility/messaging/type/MessageActivateEdge.h"
 #include "utility/messaging/type/MessageActivateFile.h"
 #include "utility/messaging/type/MessageActivateNodes.h"
+#include "utility/messaging/type/MessageActivateTokenIds.h"
 #include "utility/messaging/type/MessageActivateTokenLocations.h"
 #include "utility/messaging/type/MessageResetZoom.h"
 #include "utility/messaging/type/MessageSearch.h"
@@ -23,6 +24,7 @@ class FeatureController
 	, public MessageListener<MessageActivateEdge>
 	, public MessageListener<MessageActivateFile>
 	, public MessageListener<MessageActivateNodes>
+	, public MessageListener<MessageActivateTokenIds>
 	, public MessageListener<MessageActivateTokenLocations>
 	, public MessageListener<MessageResetZoom>
 	, public MessageListener<MessageSearch>
@@ -38,6 +40,7 @@ private:
 	virtual void handleMessage(MessageActivateFile* message);
 	virtual void handleMessage(MessageActivateNodes* message);
 	virtual void handleMessage(MessageSearch* message);
+	virtual void handleMessage(MessageActivateTokenIds* message);
 	virtual void handleMessage(MessageActivateTokenLocations* message);
 	virtual void handleMessage(MessageResetZoom* message);
 	virtual void handleMessage(MessageSwitchColorScheme* message);

src/lib/component/controller/GraphController.cpp

@@ -4,6 +4,7 @@
 
 #include "utility/logging/logging.h"
 #include "utility/utility.h"
+#include "utility/utilityString.h"
 
 #include "component/controller/helper/DummyEdge.h"
 #include "component/controller/helper/DummyNode.h"
@@ -23,6 +24,21 @@ GraphController::~GraphController()
 {
 }
 
+void GraphController::handleMessage(MessageActivateAll* message)
+{
+	m_activeNodeIds.clear();
+	m_activeEdgeIds.clear();
+
+	createDummyGraphForTokenIds(std::vector<Id>(), m_storageAccess->getGraphForAll());
+
+	bundleNodesByType();
+
+	layoutNesting();
+	layoutGraph();
+
+	buildGraph(message);
+}
+
 void GraphController::handleMessage(MessageActivateTokens* message)
 {
 	if (message->isEdge || message->keepContent())
@@ -49,7 +65,16 @@ void GraphController::handleMessage(MessageActivateTokens* message)
 		return;
 	}
 
-	createDummyGraphForTokenIds(utility::concat(m_activeNodeIds, m_activeEdgeIds));
+	std::vector<Id> tokenIds = utility::concat(m_activeNodeIds, m_activeEdgeIds);
+
+	std::shared_ptr<Graph> graph = m_storageAccess->getGraphForActiveTokenIds(tokenIds);
+
+	createDummyGraphForTokenIds(tokenIds, graph);
+
+	bundleNodes();
+
+	layoutNesting();
+	layoutGraph();
 
 	buildGraph(message);
 }
@@ -76,7 +101,7 @@ void GraphController::handleMessage(MessageGraphNodeBundleSplit* message)
 		DummyNode& node = m_dummyNodes[i];
 		if (node.isBundleNode() && node.tokenId == message->bundleId)
 		{
-			m_dummyNodes.insert(m_dummyNodes.end(), node.bundledNodes.begin(), node.bundledNodes.end());
+			m_dummyNodes.insert(m_dummyNodes.begin() + i + 1, node.bundledNodes.begin(), node.bundledNodes.end());
 			m_dummyNodes.erase(m_dummyNodes.begin() + i);
 			break;
 		}
@@ -156,7 +181,7 @@ void GraphController::clear()
 	getView()->clear();
 }
 
-void GraphController::createDummyGraphForTokenIds(const std::vector<Id>& tokenIds)
+void GraphController::createDummyGraphForTokenIds(const std::vector<Id>& tokenIds, const std::shared_ptr<Graph> graph)
 {
 	GraphView* view = getView();
 	if (!view)
@@ -165,8 +190,6 @@ void GraphController::createDummyGraphForTokenIds(const std::vector<Id>& tokenId
 		return;
 	}
 
-	std::shared_ptr<Graph> graph = m_storageAccess->getGraphForActiveTokenIds(tokenIds);
-
 	m_dummyEdges.clear();
 
 	std::set<Id> addedNodes;
@@ -190,6 +213,7 @@ void GraphController::createDummyGraphForTokenIds(const std::vector<Id>& tokenId
 	for (DummyNode& node : dummyNodes)
 	{
 		node.hasParent = false;
+		node.name = node.data->getFullName();
 	}
 
 	m_dummyNodes = dummyNodes;
@@ -197,11 +221,6 @@ void GraphController::createDummyGraphForTokenIds(const std::vector<Id>& tokenId
 	autoExpandActiveNode(tokenIds);
 	setActiveAndVisibility(tokenIds);
 
-	bundleNodes();
-
-	layoutNesting();
-	layoutGraph();
-
 	m_graph = graph;
 }
 
@@ -210,6 +229,7 @@ DummyNode GraphController::createDummyNodeTopDown(Node* node)
 	DummyNode result;
 	result.data = node;
 	result.tokenId = node->getId();
+	result.name = node->getName();
 
 	// there is a global root node with id 0 afaik, so here we actually want the one node below this global root
 	Node* parent = node;
@@ -314,6 +334,8 @@ void GraphController::autoExpandActiveNode(const std::vector<Id>& activeTokenIds
 
 void GraphController::setActiveAndVisibility(const std::vector<Id>& activeTokenIds)
 {
+	bool noActive = activeTokenIds.size() == 0;
+
 	for (DummyNode& node : m_dummyNodes)
 	{
 		setNodeActiveRecursive(node, activeTokenIds);
@@ -335,7 +357,7 @@ void GraphController::setActiveAndVisibility(const std::vector<Id>& activeTokenI
 		DummyNode* from = findDummyNodeRecursive(m_dummyNodes, edge.ownerId);
 		DummyNode* to = findDummyNodeRecursive(m_dummyNodes, edge.targetId);
 
-		if (from && to && (from->active || to->active || edge.active))
+		if (from && to && (noActive || from->active || to->active || edge.active))
 		{
 			edge.visible = true;
 			from->connected = true;
@@ -345,7 +367,7 @@ void GraphController::setActiveAndVisibility(const std::vector<Id>& activeTokenI
 
 	for (DummyNode& node : m_dummyNodes)
 	{
-		setNodeVisibilityRecursiveBottomUp(node);
+		setNodeVisibilityRecursiveBottomUp(node, noActive);
 	}
 }
 
@@ -364,7 +386,7 @@ void GraphController::setNodeActiveRecursive(DummyNode& node, const std::vector<
 	}
 }
 
-bool GraphController::setNodeVisibilityRecursiveBottomUp(DummyNode& node) const
+bool GraphController::setNodeVisibilityRecursiveBottomUp(DummyNode& node, bool noActive) const
 {
 	node.visible = false;
 	node.childVisible = false;
@@ -382,13 +404,13 @@ bool GraphController::setNodeVisibilityRecursiveBottomUp(DummyNode& node) const
 
 	for (DummyNode& subNode : node.subNodes)
 	{
-		if (setNodeVisibilityRecursiveBottomUp(subNode))
+		if (setNodeVisibilityRecursiveBottomUp(subNode, noActive))
 		{
 			node.childVisible = true;
 		}
 	}
 
-	if (node.active || node.connected || node.childVisible)
+	if (noActive || node.active || node.connected || node.childVisible)
 	{
 		setNodeVisibilityRecursiveTopDown(node, false);
 	}
@@ -617,6 +639,54 @@ bool GraphController::isTypeNodeWithSingleInheritance(const DummyNode& node, boo
 	return matches;
 }
 
+#define BUNDLE_BY_TYPE(__type__, __name__) \
+	bundleNodesMatching( \
+		[&](const DummyNode& node) \
+		{ \
+			return node.visible && node.isGraphNode() && node.data->isType(__type__); \
+		}, \
+		1, \
+		__name__ \
+	); \
+
+void GraphController::bundleNodesByType()
+{
+	BUNDLE_BY_TYPE(Node::NODE_CLASS, "Classes");
+	BUNDLE_BY_TYPE(Node::NODE_STRUCT, "Structs");
+
+	BUNDLE_BY_TYPE(Node::NODE_FUNCTION, "Functions");
+	BUNDLE_BY_TYPE(Node::NODE_GLOBAL_VARIABLE, "Global Variables");
+
+	BUNDLE_BY_TYPE(Node::NODE_TYPE, "Types");
+	BUNDLE_BY_TYPE(Node::NODE_TYPEDEF, "Typedefs");
+	BUNDLE_BY_TYPE(Node::NODE_ENUM, "Enums");
+
+	BUNDLE_BY_TYPE(Node::NODE_FILE, "Files");
+	BUNDLE_BY_TYPE(Node::NODE_MACRO, "Macros");
+
+	// should never be visible
+
+	BUNDLE_BY_TYPE(Node::NODE_METHOD, "Methods");
+	BUNDLE_BY_TYPE(Node::NODE_FIELD, "Fields");
+	BUNDLE_BY_TYPE(Node::NODE_ENUM_CONSTANT, "Enum Constants");
+	BUNDLE_BY_TYPE(Node::NODE_TEMPLATE_PARAMETER_TYPE, "Template Parameter Types");
+	BUNDLE_BY_TYPE(Node::NODE_UNDEFINED, "Undefined Symbols");
+	BUNDLE_BY_TYPE(Node::NODE_NAMESPACE, "Namespaces");
+
+	for (DummyNode& node : m_dummyNodes)
+	{
+		if (node.isBundleNode())
+		{
+			sort(node.bundledNodes.begin(), node.bundledNodes.end(),
+				[](const DummyNode& a, const DummyNode& b) -> bool
+				{
+					return utility::toLowerCase(a.name) < utility::toLowerCase(b.name);
+				}
+			);
+		}
+	}
+}
+
 void GraphController::layoutNesting()
 {
 	for (DummyNode& node : m_dummyNodes)
@@ -663,15 +733,14 @@ void GraphController::layoutNestingRecursive(DummyNode& node) const
 
 	if (node.isGraphNode())
 	{
-		if (!node.hasParent)
+		size_t maxNameSize = 50;
+		if (!node.active && node.name.size() > maxNameSize)
 		{
-			width = margins.charWidth * node.data->getFullName().size();
-		}
-		else
-		{
-			width = margins.charWidth * node.data->getName().size();
+			node.name = node.name.substr(0, maxNameSize - 3) + "...";
 		}
 
+		width = margins.charWidth * node.name.size();
+
 		if (node.data->isType(Node::NODE_TYPE | Node::NODE_CLASS | Node::NODE_STRUCT | Node::NODE_ENUM) && node.subNodes.size())
 		{
 			addExpandToggleNode(node);

src/lib/component/controller/GraphController.h

@@ -4,6 +4,7 @@
 #include <vector>
 
 #include "utility/messaging/MessageListener.h"
+#include "utility/messaging/type/MessageActivateAll.h"
 #include "utility/messaging/type/MessageActivateTokens.h"
 #include "utility/messaging/type/MessageFlushUpdates.h"
 #include "utility/messaging/type/MessageFocusIn.h"
@@ -26,6 +27,7 @@ class StorageAccess;
 
 class GraphController
 	: public Controller
+	, public MessageListener<MessageActivateAll>
 	, public MessageListener<MessageActivateTokens>
 	, public MessageListener<MessageFlushUpdates>
 	, public MessageListener<MessageFocusIn>
@@ -40,6 +42,7 @@ public:
 	~GraphController();
 
 private:
+	virtual void handleMessage(MessageActivateAll* message);
 	virtual void handleMessage(MessageActivateTokens* message);
 	virtual void handleMessage(MessageFlushUpdates* message);
 	virtual void handleMessage(MessageFocusIn* message);
@@ -53,20 +56,21 @@ private:
 
 	void clear();
 
-	void createDummyGraphForTokenIds(const std::vector<Id>& tokenIds);
+	void createDummyGraphForTokenIds(const std::vector<Id>& tokenIds, const std::shared_ptr<Graph> graph);
 	DummyNode createDummyNodeTopDown(Node* node);
 
 	void autoExpandActiveNode(const std::vector<Id>& activeTokenIds);
 
 	void setActiveAndVisibility(const std::vector<Id>& activeTokenIds);
 	void setNodeActiveRecursive(DummyNode& node, const std::vector<Id>& activeTokenIds) const;
-	bool setNodeVisibilityRecursiveBottomUp(DummyNode& node) const;
+	bool setNodeVisibilityRecursiveBottomUp(DummyNode& node, bool noActive) const;
 	void setNodeVisibilityRecursiveTopDown(DummyNode& node, bool parentExpanded) const;
 
 	void bundleNodes();
 	void bundleNodesMatching(std::function<bool(const DummyNode&)> matcher, size_t count, const std::string& name);
 	bool isTypeNodeWithSingleAggregation(const DummyNode& node, TokenComponentAggregation::Direction direction) const;
 	bool isTypeNodeWithSingleInheritance(const DummyNode& node, bool isBase) const;
+	void bundleNodesByType();
 
 	void layoutNesting();
 	void layoutNestingRecursive(DummyNode& node) const;

src/lib/component/controller/SearchController.cpp

@@ -12,6 +12,12 @@ SearchController::~SearchController()
 {
 }
 
+void SearchController::handleMessage(MessageActivateAll* message)
+{
+	SearchMatch match = SearchMatch::createCommand(SearchMatch::COMMAND_ALL);
+	getView()->setMatches(std::vector<SearchMatch>(1, match));
+}
+
 void SearchController::handleMessage(MessageActivateTokens* message)
 {
 	if (!message->keepContent() && !message->isFromSearch)
@@ -33,7 +39,8 @@ void SearchController::handleMessage(MessageSearchAutocomplete* message)
 
 void SearchController::handleMessage(MessageShowErrors* message)
 {
-	getView()->setMatches(std::vector<SearchMatch>());
+	SearchMatch match = SearchMatch::createCommand(SearchMatch::COMMAND_ERROR);
+	getView()->setMatches(std::vector<SearchMatch>(1, match));
 }
 
 SearchView* SearchController::getView()

src/lib/component/controller/SearchController.h

@@ -3,6 +3,7 @@
 
 #include "component/controller/Controller.h"
 #include "utility/messaging/MessageListener.h"
+#include "utility/messaging/type/MessageActivateAll.h"
 #include "utility/messaging/type/MessageActivateTokens.h"
 #include "utility/messaging/type/MessageFind.h"
 #include "utility/messaging/type/MessageSearchAutocomplete.h"
@@ -13,6 +14,7 @@ class SearchView;
 
 class SearchController
 	: public Controller
+	, public MessageListener<MessageActivateAll>
 	, public MessageListener<MessageActivateTokens>
 	, public MessageListener<MessageFind>
 	, public MessageListener<MessageSearchAutocomplete>
@@ -23,6 +25,7 @@ public:
 	~SearchController();
 
 private:
+	virtual void handleMessage(MessageActivateAll* message);
 	virtual void handleMessage(MessageActivateTokens* message);
 	virtual void handleMessage(MessageFind* message);
 	virtual void handleMessage(MessageSearchAutocomplete* message);

src/lib/component/controller/UndoRedoController.cpp

@@ -67,6 +67,18 @@ void UndoRedoController::handleMessage(MessageActivateNodes* message)
 	processCommand(command);
 }
 
+void UndoRedoController::handleMessage(MessageActivateTokenIds* message)
+{
+	if (m_lastCommand.message && m_lastCommand.message->getType() == message->getType() && message->tokenIds.size() &&
+		static_cast<MessageActivateTokenIds*>(m_lastCommand.message.get())->tokenIds == message->tokenIds)
+	{
+		return;
+	}
+
+	Command command(std::make_shared<MessageActivateTokenIds>(*message), 0);
+	processCommand(command);
+}
+
 void UndoRedoController::handleMessage(MessageDeactivateEdge* message)
 {
 	MessageBase* m = nullptr;
@@ -140,23 +152,9 @@ void UndoRedoController::handleMessage(MessageRefresh* message)
 
 	if (requiresActivateFallbackToken())
 	{
-		Id nodeId = m_storageAccess->getIdForNodeWithSearchNameHierarchy(NameHierarchy("main"));
-		if (!nodeId)
-		{
-			nodeId = m_storageAccess->getIdForFirstNode();
-		}
-
-		if (nodeId)
-		{
-			MessageActivateNodes m;
-			m.addNode(
-				nodeId,
-				m_storageAccess->getNodeTypeForNodeWithId(nodeId),
-				m_storageAccess->getNameHierarchyForNodeWithId(nodeId)
-				);
-			m.isFromSystem = true;
-			m.dispatch();
-		}
+		SearchMatch match = SearchMatch::createCommand(SearchMatch::COMMAND_ALL);
+		MessageSearch msg(std::vector<SearchMatch>(1, match));
+		msg.dispatch();
 	}
 	else
 	{

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/MessageActivateNodes.h"
+#include "utility/messaging/type/MessageActivateTokenIds.h"
 #include "utility/messaging/type/MessageDeactivateEdge.h"
 #include "utility/messaging/type/MessageGraphNodeBundleSplit.h"
 #include "utility/messaging/type/MessageGraphNodeExpand.h"
@@ -32,6 +33,7 @@ class UndoRedoController
 	, public MessageListener<MessageActivateEdge>
 	, public MessageListener<MessageActivateFile>
 	, public MessageListener<MessageActivateNodes>
+	, public MessageListener<MessageActivateTokenIds>
 	, public MessageListener<MessageDeactivateEdge>
 	, public MessageListener<MessageGraphNodeBundleSplit>
 	, public MessageListener<MessageGraphNodeExpand>
@@ -63,6 +65,7 @@ private:
 	virtual void handleMessage(MessageActivateEdge* message);
 	virtual void handleMessage(MessageActivateFile* message);
 	virtual void handleMessage(MessageActivateNodes* message);
+	virtual void handleMessage(MessageActivateTokenIds* message);
 	virtual void handleMessage(MessageDeactivateEdge* message);
 	virtual void handleMessage(MessageGraphNodeBundleSplit* message);
 	virtual void handleMessage(MessageGraphNodeExpand* message);

src/lib/component/controller/helper/ActivationTranslator.cpp

@@ -1,11 +1,14 @@
 #include "component/controller/helper/ActivationTranslator.h"
 
 #include "data/access/StorageAccess.h"
+#include "utility/messaging/type/MessageActivateAll.h"
 #include "utility/messaging/type/MessageActivateEdge.h"
 #include "utility/messaging/type/MessageActivateFile.h"
 #include "utility/messaging/type/MessageActivateNodes.h"
+#include "utility/messaging/type/MessageActivateTokenIds.h"
 #include "utility/messaging/type/MessageActivateTokens.h"
 #include "utility/messaging/type/MessageSearch.h"
+#include "utility/messaging/type/MessageShowErrors.h"
 #include "utility/messaging/type/MessageShowFile.h"
 
 ActivationTranslator::ActivationTranslator(StorageAccess* storageAccess)
@@ -99,9 +102,40 @@ std::shared_ptr<MessageActivateTokens> ActivationTranslator::translateMessage(co
 	return m;
 }
 
+std::shared_ptr<MessageActivateTokens> ActivationTranslator::translateMessage(const MessageActivateTokenIds* message) const
+{
+	std::shared_ptr<MessageActivateTokens> m;
+	m = std::make_shared<MessageActivateTokens>(message->tokenIds);
+	m->undoRedoType = message->undoRedoType;
+	m->setKeepContent(message->keepContent());
+	return m;
+}
+
 std::shared_ptr<MessageActivateTokens> ActivationTranslator::translateMessage(const MessageSearch* message) const
 {
-	std::vector<Id> tokenIds = m_storageAccess->getTokenIdsForMatches(message->getMatches());
+	const std::vector<SearchMatch>& matches = message->getMatches();
+
+	for (const SearchMatch& match : matches)
+	{
+		if (match.searchType == SearchMatch::SEARCH_COMMAND &&
+			match.getFullName() == SearchMatch::getCommandName(SearchMatch::COMMAND_ALL))
+		{
+			MessageActivateAll msg;
+			msg.undoRedoType = message->undoRedoType;
+			msg.dispatchImmediately();
+			return nullptr;
+		}
+		else if (match.searchType == SearchMatch::SEARCH_COMMAND &&
+			match.getFullName() == SearchMatch::getCommandName(SearchMatch::COMMAND_ERROR))
+		{
+			MessageShowErrors msg;
+			msg.undoRedoType = message->undoRedoType;
+			msg.dispatchImmediately();
+			return nullptr;
+		}
+	}
+
+	std::vector<Id> tokenIds = m_storageAccess->getTokenIdsForMatches(matches);
 	tokenIds = m_storageAccess->getActiveTokenIdsForTokenIds(tokenIds);
 
 	std::shared_ptr<MessageActivateTokens> m;

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

@@ -6,6 +6,7 @@
 class MessageActivateEdge;
 class MessageActivateFile;
 class MessageActivateNodes;
+class MessageActivateTokenIds;
 class MessageActivateTokens;
 class MessageSearch;
 class StorageAccess;
@@ -19,6 +20,7 @@ public:
 	std::shared_ptr<MessageActivateTokens> translateMessage(const MessageActivateEdge* message) const;
 	std::shared_ptr<MessageActivateTokens> translateMessage(const MessageActivateFile* message) const;
 	std::shared_ptr<MessageActivateTokens> translateMessage(const MessageActivateNodes* message) const;
+	std::shared_ptr<MessageActivateTokens> translateMessage(const MessageActivateTokenIds* message) const;
 	std::shared_ptr<MessageActivateTokens> translateMessage(const MessageSearch* message) const;
 
 private:

src/lib/component/controller/helper/BucketGrid.cpp

@@ -126,13 +126,18 @@ void BucketGrid::createBuckets(std::vector<DummyNode>& nodes, const std::vector<
 	bool activeNodeAdded = false;
 	for (DummyNode& node : nodes)
 	{
-		if (node.hasActiveSubNode())
+		if (node.hasActiveSubNode() || !edges.size())
 		{
 			addNode(&node);
 			activeNodeAdded = true;
 		}
 	}
 
+	if (!edges.size())
+	{
+		return;
+	}
+
 	if (!activeNodeAdded)
 	{
 		addNode(&nodes[0]);

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

@@ -114,6 +114,8 @@ public:
 
 	// GraphNode
 	const Node* data;
+	std::string name;
+
 	bool active;
 	bool connected;
 	bool expanded;
@@ -127,7 +129,6 @@ public:
 
 	// BundleNode
 	std::vector<DummyNode> bundledNodes;
-	std::string name;
 };
 
 #endif // DUMMY_NODE_H