ui: added color_scheme_test command displaying all graph node types and states

implementations for other views comming.

src/lib/CMakeLists.txt

@@ -234,6 +234,7 @@ add_files(
 	utility/messaging/type/MessageAutoRefreshChanged.h
 	utility/messaging/type/MessageChangeFileView.h
 	utility/messaging/type/MessageClearErrorCount.h
+	utility/messaging/type/MessageColorSchemeTest.h
 	utility/messaging/type/MessageDeactivateEdge.h
 	utility/messaging/type/MessageDispatchWhenLicenseValid.h
 	utility/messaging/type/MessageEnteredLicense.h

src/lib/component/controller/FeatureController.cpp

@@ -6,6 +6,7 @@
 #include "utility/messaging/type/MessageActivateAll.h"
 #include "utility/messaging/type/MessageActivateTokens.h"
 #include "utility/messaging/type/MessageChangeFileView.h"
+#include "utility/messaging/type/MessageColorSchemeTest.h"
 #include "utility/messaging/type/MessageRefresh.h"
 #include "utility/messaging/type/MessageShowErrors.h"
 #include "utility/messaging/type/MessageStatus.h"
@@ -114,21 +115,34 @@ void FeatureController::handleMessage(MessageSearch* message)
 
 	for (const SearchMatch& match : matches)
 	{
-		if (match.searchType == SearchMatch::SEARCH_COMMAND &&
+		if (match.searchType == SearchMatch::SEARCH_COMMAND)
-			match.getFullName() == SearchMatch::getCommandName(SearchMatch::COMMAND_ALL))
 		{
-			MessageActivateAll msg;
+			SearchMatch::CommandType type = SearchMatch::getCommandType(match.getFullName());
-			msg.setIsReplayed(message->isReplayed());
+
-			msg.dispatchImmediately();
+			switch (type)
-			return;
+			{
-		}
+				case SearchMatch::COMMAND_ALL:
-		else if (match.searchType == SearchMatch::SEARCH_COMMAND &&
+				{
-			match.getFullName() == SearchMatch::getCommandName(SearchMatch::COMMAND_ERROR))
+					MessageActivateAll msg;
-		{
+					msg.setIsReplayed(message->isReplayed());
-			MessageShowErrors msg(ErrorCountInfo(-1, 0));
+					msg.dispatchImmediately();
-			msg.setIsReplayed(message->isReplayed());
+					return;
-			msg.dispatchImmediately();
+				}
-			return;
+
+				case SearchMatch::COMMAND_ERROR:
+				{
+					MessageShowErrors msg(ErrorCountInfo(-1, 0));
+					msg.setIsReplayed(message->isReplayed());
+					msg.dispatchImmediately();
+					return;
+				}
+
+				case SearchMatch::COMMAND_COLOR_SCHEME_TEST:
+				{
+					MessageColorSchemeTest().dispatchImmediately();
+					return;
+				}
+			}
 		}
 	}
 

src/lib/component/controller/GraphController.cpp

@@ -29,7 +29,7 @@ void GraphController::handleMessage(MessageActivateAll* message)
 	m_activeNodeIds.clear();
 	m_activeEdgeIds.clear();
 
-	createDummyGraphForTokenIds(std::vector<Id>(), m_storageAccess->getGraphForAll());
+	createDummyGraphForTokenIdsAndSetActiveAndVisibility(std::vector<Id>(), m_storageAccess->getGraphForAll());
 
 	bundleNodesByType();
 
@@ -71,7 +71,7 @@ void GraphController::handleMessage(MessageActivateTokens* message)
 
 	std::shared_ptr<Graph> graph = m_storageAccess->getGraphForActiveTokenIds(tokenIds);
 
-	createDummyGraphForTokenIds(tokenIds, graph);
+	createDummyGraphForTokenIdsAndSetActiveAndVisibility(tokenIds, graph);
 
 	if (m_activeNodeIds.size() == 1)
 	{
@@ -206,8 +206,6 @@ void GraphController::createDummyGraphForTokenIds(const std::vector<Id>& tokenId
 		return;
 	}
 
-	std::vector<Id> expandedNodeIds = getExpandedNodeIds();
-
 	m_dummyEdges.clear();
 	m_dummyGraphNodes.clear();
 
@@ -249,14 +247,22 @@ void GraphController::createDummyGraphForTokenIds(const std::vector<Id>& tokenId
 
 	m_dummyNodes = dummyNodes;
 
+	m_graph = graph;
+}
+
+void GraphController::createDummyGraphForTokenIdsAndSetActiveAndVisibility(
+	const std::vector<Id>& tokenIds, const std::shared_ptr<Graph> graph
+){
+	std::vector<Id> expandedNodeIds = getExpandedNodeIds();
+
+	createDummyGraphForTokenIds(tokenIds, graph);
+
 	bool noActive = setActive(tokenIds);
 
 	autoExpandActiveNode(tokenIds);
 	setExpandedNodeIds(expandedNodeIds);
 
 	setVisibility(noActive);
-
-	m_graph = graph;
 }
 
 std::shared_ptr<DummyNode> GraphController::createDummyNodeTopDown(Node* node, Id parentId)
@@ -729,7 +735,9 @@ void GraphController::bundleNodesAndEdgesMatching(
 	}
 
 	DummyNode* firstNode = bundleNode->bundledNodes[0].get();
-	bundleNode->tokenId = firstNode->data->getId();
+
+	// Use token Id of first node and make first bit 1
+	bundleNode->tokenId = ~(~size_t(0) >> 1) + firstNode->data->getId();
 	bundleNode->bundleInfo.layoutVertical = firstNode->bundleInfo.layoutVertical;
 	bundleNode->bundleInfo.isReferenced = firstNode->bundleInfo.isReferenced;
 	bundleNode->bundleInfo.isReferencing = firstNode->bundleInfo.isReferencing;
@@ -816,7 +824,8 @@ void GraphController::bundleNodesMatching(
 		nodes.erase(matchedNodes[i]);
 	}
 
-	bundleNode->tokenId = bundleNode->bundledNodes[0]->data->getId();
+	// Use token Id of first node and make first bit 1
+	bundleNode->tokenId = ~(~size_t(0) >> 1) + bundleNode->bundledNodes[0]->data->getId();
 	m_dummyNodes.push_back(bundleNode);
 }
 
@@ -1139,10 +1148,295 @@ DummyNode* GraphController::getDummyGraphNodeById(Id tokenId) const
 	return nullptr;
 }
 
-void GraphController::buildGraph(MessageBase* message)
+void GraphController::buildGraph(MessageBase* message, bool animated)
 {
 	if (!message->isReplayed())
 	{
-		getView()->rebuildGraph(m_graph, m_dummyNodes, m_dummyEdges);
+		getView()->rebuildGraph(m_graph, m_dummyNodes, m_dummyEdges, animated);
 	}
 }
+
+void GraphController::forEachDummyNodeRecursive(std::function<void(DummyNode*)> func)
+{
+	for (std::shared_ptr<DummyNode> node : m_dummyNodes)
+	{
+		node->forEachDummyNodeRecursive(func);
+	}
+}
+
+void GraphController::forEachDummyEdge(std::function<void(DummyEdge*)> func)
+{
+	for (std::shared_ptr<DummyEdge> edge : m_dummyEdges)
+	{
+		func(edge.get());
+	}
+}
+
+void GraphController::handleMessage(MessageColorSchemeTest* message)
+{
+	clear();
+
+	std::shared_ptr<Graph> graph = std::make_shared<Graph>();
+
+	std::function<void(Id, Node::NodeType)> createNodes(
+		[&](Id id, Node::NodeType type)
+		{
+			std::string name = Node::getTypeString(type);
+			graph->createNode(id + 1, type, NameHierarchy(name), true);
+			graph->createNode(id + 2, type, NameHierarchy("focused " + name), true);
+			graph->createNode(id + 3, type, NameHierarchy("active " + name), true);
+
+			graph->createNode(id + 4, type, NameHierarchy("undefined " + name), true);
+			graph->createNode(id + 5, type, NameHierarchy("undefined focused " + name), true);
+			graph->createNode(id + 6, type, NameHierarchy("undefined active " + name), true);
+		}
+	);
+
+	createNodes( 0, Node::NODE_FUNCTION);
+	createNodes(10, Node::NODE_GLOBAL_VARIABLE);
+	createNodes(20, Node::NODE_UNDEFINED);
+	createNodes(30, Node::NODE_TYPE);
+	createNodes(40, Node::NODE_TYPEDEF);
+	createNodes(50, Node::NODE_NAMESPACE);
+	createNodes(60, Node::NODE_FILE);
+	createNodes(70, Node::NODE_MACRO);
+
+	std::function<Node*(Node*, Id, Node::NodeType, std::string, TokenComponentAccess::AccessType)> createChild(
+		[&](Node* parent, Id id, Node::NodeType type, std::string name, TokenComponentAccess::AccessType access)
+		{
+			Node* node = graph->createNode(id + 1000, type, NameHierarchy(name), true);
+			Edge* edge = graph->createEdge(id + 10000, Edge::EDGE_MEMBER, parent, node);
+
+			if (access != TokenComponentAccess::ACCESS_NONE)
+			{
+				edge->addComponentAccess(std::make_shared<TokenComponentAccess>(access));
+			}
+
+			return node;
+		}
+	);
+
+	std::function<void(Id, std::string)> createEnum(
+		[&](Id id, std::string name)
+		{
+			Node* enumNode = graph->createNode(id, Node::NODE_ENUM,
+				NameHierarchy(name + Node::getTypeString(Node::NODE_ENUM)), true);
+			createChild(enumNode, id + 10, Node::NODE_ENUM_CONSTANT, name + Node::getTypeString(Node::NODE_ENUM_CONSTANT),
+				TokenComponentAccess::ACCESS_NONE);
+		}
+	);
+
+	createEnum(101, "");
+	createEnum(102, "focused ");
+	createEnum(103, "active ");
+
+	createEnum(104, "undefined ");
+	createEnum(105, "undefined focused ");
+	createEnum(106, "undefined active ");
+
+	std::function<void(Id, Node::NodeType, std::string)> createClass(
+		[&](Id id, Node::NodeType type, std::string name)
+		{
+			Node* classNode = graph->createNode(id, type, NameHierarchy(name + Node::getTypeString(type)), true);
+
+			if (type == Node::NODE_CLASS)
+			{
+				createChild(classNode, id, Node::NODE_TEMPLATE_PARAMETER_TYPE, name + "temp_param",
+					TokenComponentAccess::ACCESS_TEMPLATE);
+			}
+
+			createChild(classNode, id + 10, Node::NODE_METHOD, name + "method", TokenComponentAccess::ACCESS_PUBLIC);
+			if (type == Node::NODE_CLASS)
+			{
+				createChild(classNode, id + 30, Node::NODE_METHOD, name + "method",
+					TokenComponentAccess::ACCESS_PROTECTED);
+			}
+			createChild(classNode, id + 60, Node::NODE_FIELD, name + "field", TokenComponentAccess::ACCESS_PRIVATE);
+		}
+	);
+
+	std::function<void(Id, Node::NodeType)> createClasses(
+		[&](Id id, Node::NodeType type)
+		{
+			createClass(id + 1, type, "");
+			createClass(id + 2, type, "focused ");
+			createClass(id + 3, type, "active ");
+
+			createClass(id + 4, type, "undefined ");
+			createClass(id + 5, type, "undefined focused ");
+			createClass(id + 6, type, "undefined active ");
+		}
+	);
+
+	createClasses(200, Node::NODE_STRUCT);
+	createClasses(300, Node::NODE_CLASS);
+
+
+	std::function<void(Id, Edge::EdgeType, Node::NodeType, Node::NodeType, std::string)> createEdge(
+		[&](Id id, Edge::EdgeType type, Node::NodeType origin, Node::NodeType target, std::string name)
+		{
+			Node* originNode;
+			if (origin == Node::NODE_METHOD)
+			{
+				Node* classNode = graph->createNode(id + 101, Node::NODE_CLASS,
+					NameHierarchy(name + Node::getTypeString(Node::NODE_CLASS)), true);
+				originNode = createChild(classNode, id + 111, Node::NODE_METHOD, name + Edge::getTypeString(type),
+					TokenComponentAccess::ACCESS_PUBLIC);
+			}
+			else
+			{
+				originNode = graph->createNode(id + 1, origin, NameHierarchy(name + Edge::getTypeString(type)), true);
+			}
+
+			Node* targetNode;
+			if (target == Node::NODE_METHOD)
+			{
+				Node* classNode = graph->createNode(id + 201, Node::NODE_CLASS,
+					NameHierarchy(name + Node::getTypeString(Node::NODE_CLASS)), true);
+				targetNode = createChild(classNode, id + 211, Node::NODE_METHOD, name + Edge::getTypeString(type),
+					TokenComponentAccess::ACCESS_PUBLIC);
+			}
+			else
+			{
+				targetNode = graph->createNode(id + 11, target, NameHierarchy(name + Edge::getTypeString(type)), true);
+			}
+
+			Edge* edge = graph->createEdge(id, type, originNode, targetNode);
+
+			if (type == Edge::EDGE_AGGREGATION)
+			{
+				std::shared_ptr<TokenComponentAggregation> agg = std::make_shared<TokenComponentAggregation>();
+				for (Id i = 1; i < 11; i++)
+				{
+					agg->addAggregationId(i, true);
+				}
+				edge->addComponentAggregation(agg);
+			}
+		}
+	);
+
+	std::function<void(Id, Edge::EdgeType, Node::NodeType, Node::NodeType)> createEdges(
+		[&](Id id, Edge::EdgeType type, Node::NodeType origin, Node::NodeType target)
+		{
+			createEdge(id, type, origin, target, "");
+			createEdge(id + 1000, type, origin, target, "focused ");
+			createEdge(id + 2000, type, origin, target, "active ");
+		}
+	);
+
+	createEdges( 100000, Edge::EDGE_CALL, Node::NODE_FUNCTION, Node::NODE_FUNCTION);
+	createEdges( 200000, Edge::EDGE_USAGE, Node::NODE_GLOBAL_VARIABLE, Node::NODE_GLOBAL_VARIABLE);
+	createEdges( 300000, Edge::EDGE_TYPE_USAGE, Node::NODE_FUNCTION, Node::NODE_TYPE);
+	createEdges( 400000, Edge::EDGE_TYPE_OF, Node::NODE_GLOBAL_VARIABLE, Node::NODE_TYPE);
+
+	createEdges( 500000, Edge::EDGE_TYPEDEF_OF, Node::NODE_TYPEDEF, Node::NODE_TYPE);
+	createEdges( 600000, Edge::EDGE_AGGREGATION, Node::NODE_TYPE, Node::NODE_TYPE);
+	createEdges( 700000, Edge::EDGE_INCLUDE, Node::NODE_FILE, Node::NODE_FILE);
+	createEdges( 800000, Edge::EDGE_MACRO_USAGE, Node::NODE_MACRO, Node::NODE_MACRO);
+
+	createEdges( 900000, Edge::EDGE_INHERITANCE, Node::NODE_CLASS, Node::NODE_CLASS);
+	createEdges(1000000, Edge::EDGE_OVERRIDE, Node::NODE_METHOD, Node::NODE_METHOD);
+
+	createEdges(1100000, Edge::EDGE_TEMPLATE_ARGUMENT, Node::NODE_TYPE, Node::NODE_TYPE);
+	createEdges(1200000, Edge::EDGE_TEMPLATE_DEFAULT_ARGUMENT, Node::NODE_TYPE, Node::NODE_TYPE);
+	createEdges(1300000, Edge::EDGE_TEMPLATE_SPECIALIZATION_OF, Node::NODE_TYPE, Node::NODE_TYPE);
+	createEdges(1400000, Edge::EDGE_TEMPLATE_MEMBER_SPECIALIZATION_OF, Node::NODE_METHOD, Node::NODE_METHOD);
+
+	std::vector<Id> focusedTokenIds;
+	std::vector<Id> activeTokenIds;
+
+	graph->forEachNode(
+		[&](Node* node)
+		{
+			Id id = node->getId();
+			if (id % 10 < 4)
+			{
+				node->setExplicit(true);
+			}
+
+			if (id % 10 == 2 || id % 10 == 5)
+			{
+				focusedTokenIds.push_back(id);
+			}
+			else if (id % 10 == 3 || id % 10 == 6)
+			{
+				activeTokenIds.push_back(id);
+			}
+		}
+	);
+
+	graph->forEachEdge(
+		[&](Edge* edge)
+		{
+			Id id = edge->getId();
+			if (id % 10000 == 1000)
+			{
+				focusedTokenIds.push_back(id);
+			}
+			else if (id % 10000 == 2000)
+			{
+				activeTokenIds.push_back(id);
+			}
+		}
+	);
+
+	createDummyGraphForTokenIds(std::vector<Id>(), graph);
+
+	for (size_t i = 0; i < 2; i++)
+	{
+		std::shared_ptr<DummyNode> bundleNode = std::make_shared<DummyNode>();
+		bundleNode->tokenId = 10000001 + i;
+		bundleNode->name = "bundle";
+
+		if (i == 1)
+		{
+			bundleNode->name = "focused bundle";
+			focusedTokenIds.push_back(bundleNode->tokenId);
+		}
+
+		bundleNode->bundledNodes.push_back(std::make_shared<DummyNode>());
+		bundleNode->bundledNodeCount = 123;
+		m_dummyNodes.push_back(bundleNode);
+	}
+
+	forEachDummyNodeRecursive(
+		[](DummyNode* node)
+		{
+			node->visible = true;
+
+			if (node->subNodes.size())
+			{
+				node->expanded = true;
+				node->childVisible = true;
+			}
+		}
+	);
+
+	forEachDummyEdge(
+		[](DummyEdge* edge)
+		{
+			edge->visible = true;
+			edge->active = true;
+		}
+	);
+
+	setActive(activeTokenIds);
+
+	layoutNesting();
+
+	for (size_t i = 0; i < m_dummyNodes.size(); i++)
+	{
+		DummyNode* node = m_dummyNodes[i].get();
+
+		node->layoutBucket.x = i % 6 + 1;
+		node->layoutBucket.y = (i / 6) + 1;
+	}
+
+	BucketGrid grid(Vec2i(0, 0));
+	grid.createBuckets(m_dummyNodes, std::vector<std::shared_ptr<DummyEdge>>());
+	grid.layoutBuckets();
+
+	buildGraph(message, false);
+
+	getView()->focusTokenIds(focusedTokenIds);
+}

src/lib/component/controller/GraphController.h

@@ -7,6 +7,7 @@
 #include "utility/messaging/MessageListener.h"
 #include "utility/messaging/type/MessageActivateAll.h"
 #include "utility/messaging/type/MessageActivateTokens.h"
+#include "utility/messaging/type/MessageColorSchemeTest.h"
 #include "utility/messaging/type/MessageFlushUpdates.h"
 #include "utility/messaging/type/MessageFocusIn.h"
 #include "utility/messaging/type/MessageFocusOut.h"
@@ -31,6 +32,7 @@ class GraphController
 	: public Controller
 	, public MessageListener<MessageActivateAll>
 	, public MessageListener<MessageActivateTokens>
+	, public MessageListener<MessageColorSchemeTest>
 	, public MessageListener<MessageFlushUpdates>
 	, public MessageListener<MessageFocusIn>
 	, public MessageListener<MessageFocusOut>
@@ -61,6 +63,8 @@ private:
 	virtual void clear();
 
 	void createDummyGraphForTokenIds(const std::vector<Id>& tokenIds, const std::shared_ptr<Graph> graph);
+	void createDummyGraphForTokenIdsAndSetActiveAndVisibility(
+		const std::vector<Id>& tokenIds, const std::shared_ptr<Graph> graph);
 	std::shared_ptr<DummyNode> createDummyNodeTopDown(Node* node, Id parentId);
 
 	std::vector<Id> getExpandedNodeIds() const;
@@ -89,7 +93,12 @@ private:
 
 	DummyNode* getDummyGraphNodeById(Id tokenId) const;
 
-	void buildGraph(MessageBase* message);
+	void buildGraph(MessageBase* message, bool animated = true);
+
+	void forEachDummyNodeRecursive(std::function<void(DummyNode*)> func);
+	void forEachDummyEdge(std::function<void(DummyEdge*)> func);
+
+	virtual void handleMessage(MessageColorSchemeTest* message);
 
 	StorageAccess* m_storageAccess;
 

src/lib/component/controller/SearchController.cpp

@@ -13,12 +13,6 @@ 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->isFromSearch)
@@ -58,6 +52,21 @@ void SearchController::handleMessage(MessageFind* message)
 	}
 }
 
+void SearchController::handleMessage(MessageSearch* message)
+{
+	const std::vector<SearchMatch>& matches = message->getMatches();
+
+	for (const SearchMatch& match : matches)
+	{
+		if (match.searchType == SearchMatch::SEARCH_COMMAND)
+		{
+			SearchMatch m = SearchMatch::createCommand(SearchMatch::getCommandType(match.getFullName()));
+			getView()->setMatches(std::vector<SearchMatch>(1, m));
+			return;
+		}
+	}
+}
+
 void SearchController::handleMessage(MessageSearchAutocomplete* message)
 {
 	TRACE("search autocomplete");

src/lib/component/controller/SearchController.h

@@ -3,9 +3,9 @@
 
 #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/MessageSearch.h"
 #include "utility/messaging/type/MessageSearchAutocomplete.h"
 #include "utility/messaging/type/MessageSearchFullText.h"
 #include "utility/messaging/type/MessageShowErrors.h"
@@ -15,9 +15,9 @@ class SearchView;
 
 class SearchController
 	: public Controller
-	, public MessageListener<MessageActivateAll>
 	, public MessageListener<MessageActivateTokens>
 	, public MessageListener<MessageFind>
+	, public MessageListener<MessageSearch>
 	, public MessageListener<MessageSearchAutocomplete>
 	, public MessageListener<MessageSearchFullText>
 	, public MessageListener<MessageShowErrors>
@@ -27,9 +27,9 @@ public:
 	~SearchController();
 
 private:
-	virtual void handleMessage(MessageActivateAll* message);
 	virtual void handleMessage(MessageActivateTokens* message);
 	virtual void handleMessage(MessageFind* message);
+	virtual void handleMessage(MessageSearch* message);
 	virtual void handleMessage(MessageSearchAutocomplete* message);
 	virtual void handleMessage(MessageSearchFullText* message);
 	virtual void handleMessage(MessageShowErrors* message);

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

@@ -76,7 +76,7 @@ void Bucket::sort()
 
 void Bucket::preLayout(Vec2i viewSize)
 {
-	int cols = m_height / viewSize.y + 1;
+	int cols = (viewSize.y > 0 ? (m_height / viewSize.y) : 0) + 1;
 
 	int x = 0;
 	int y = 0;
@@ -299,7 +299,7 @@ DummyNode* BucketGrid::findTopMostDummyNodeRecursive(
 
 void BucketGrid::addNode(DummyNode* node)
 {
-	Bucket* bucket = getBucket(0, 0);
+	Bucket* bucket = getBucket(node->layoutBucket.x, node->layoutBucket.y);
 	bucket->addNode(node);
 }
 
@@ -310,7 +310,8 @@ bool BucketGrid::addNode(DummyNode* owner, DummyNode* target, bool horizontal)
 
 	if (!ownerBucket && !targetBucket)
 	{
-		return false;
+		ownerBucket = getBucket(0, 0);
+		ownerBucket->addNode(owner);
 	}
 	else if (ownerBucket && targetBucket)
 	{

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

@@ -42,6 +42,7 @@ public:
 		, hasParent(true)
 		, accessType(TokenComponentAccess::ACCESS_NONE)
 		, invisibleSubNodeCount(0)
+		, layoutBucket(0, 0)
 		, bundledNodeCount(0)
 	{
 	}
@@ -191,6 +192,16 @@ public:
 		return bundledNodes.size();
 	}
 
+	void forEachDummyNodeRecursive(std::function<void(DummyNode*)> func)
+	{
+		func(this);
+
+		for (std::shared_ptr<DummyNode> node : subNodes)
+		{
+			node->forEachDummyNodeRecursive(func);
+		}
+	}
+
 	Vec2i position;
 	Vec2i size;
 
@@ -220,6 +231,9 @@ public:
 	// Bundling
 	BundleInfo bundleInfo;
 
+	// Layout
+	Vec2i layoutBucket;
+
 	// BundleNode
 	std::vector<std::shared_ptr<DummyNode>> bundledNodes;
 	size_t bundledNodeCount;

src/lib/component/view/GraphView.h

@@ -20,7 +20,8 @@ public:
 	virtual void rebuildGraph(
 		std::shared_ptr<Graph> graph,
 		const std::vector<std::shared_ptr<DummyNode>>& nodes,
-		const std::vector<std::shared_ptr<DummyEdge>>& edges) = 0;
+		const std::vector<std::shared_ptr<DummyEdge>>& edges,
+		bool animated) = 0;
 	virtual void clear() = 0;
 
 	virtual void focusTokenIds(const std::vector<Id>& focusedTokenIds) = 0;

src/lib/data/PersistentStorage.cpp

@@ -32,6 +32,7 @@ PersistentStorage::PersistentStorage(const FilePath& dbPath)
 {
 	m_commandIndex.addNode(0, NameHierarchy(SearchMatch::getCommandName(SearchMatch::COMMAND_ALL)));
 	m_commandIndex.addNode(0, NameHierarchy(SearchMatch::getCommandName(SearchMatch::COMMAND_ERROR)));
+	m_commandIndex.addNode(0, NameHierarchy(SearchMatch::getCommandName(SearchMatch::COMMAND_COLOR_SCHEME_TEST)));
 	m_commandIndex.finishSetup();
 }
 

src/lib/data/name/NameHierarchy.cpp

@@ -21,7 +21,7 @@ std::string NameHierarchy::serialize(NameHierarchy nameHierarchy)
 NameHierarchy NameHierarchy::deserialize(const std::string& serializedName)
 {
 	NameHierarchy nameHierarchy;
-	
+
 	std::vector<std::string> serializedNameElements = utility::splitToVector(serializedName, "\n");
 	for (size_t i = 0; i < serializedNameElements.size(); i++)
 	{
@@ -46,6 +46,14 @@ NameHierarchy::NameHierarchy(const std::string& name)
 	push(std::make_shared<NameElement>(name));
 }
 
+NameHierarchy::NameHierarchy(const std::vector<std::string>& names)
+{
+	for (const std::string& name : names)
+	{
+		push(std::make_shared<NameElement>(name));
+	}
+}
+
 NameHierarchy::~NameHierarchy()
 {
 }

src/lib/data/name/NameHierarchy.h

@@ -15,6 +15,7 @@ public:
 
 	NameHierarchy();
 	NameHierarchy(const std::string& name);
+	NameHierarchy(const std::vector<std::string>& names);
 	~NameHierarchy();
 
 	void push(std::shared_ptr<NameElement> element);

src/lib/data/search/SearchMatch.cpp

@@ -32,7 +32,6 @@ std::string SearchMatch::getSearchTypeName(SearchType type)
 	case SEARCH_FULLTEXT:
 		return "fulltext";
 	}
-
 }
 
 std::string SearchMatch::searchMatchesToString(const std::vector<SearchMatch>& matches)
@@ -64,11 +63,31 @@ std::string SearchMatch::getCommandName(CommandType type)
 		return "overview";
 	case COMMAND_ERROR:
 		return "error";
+	case COMMAND_COLOR_SCHEME_TEST:
+		return "color_scheme_test";
 	}
 
 	return "none";
 }
 
+SearchMatch::CommandType SearchMatch::getCommandType(const std::string& name)
+{
+	if (name == "overview")
+	{
+		return COMMAND_ALL;
+	}
+	else if (name == "error")
+	{
+		return COMMAND_ERROR;
+	}
+	else if (name == "color_scheme_test")
+	{
+		return COMMAND_COLOR_SCHEME_TEST;
+	}
+
+	return COMMAND_ALL;
+}
+
 SearchMatch::SearchMatch()
 	: typeName("")
 	, searchType(SEARCH_NONE)

src/lib/data/search/SearchMatch.h

@@ -23,7 +23,8 @@ struct SearchMatch
 	enum CommandType
 	{
 		COMMAND_ALL,
-		COMMAND_ERROR
+		COMMAND_ERROR,
+		COMMAND_COLOR_SCHEME_TEST
 	};
 
 	static void log(const std::vector<SearchMatch>& matches, const std::string& query);
@@ -33,6 +34,7 @@ struct SearchMatch
 
 	static SearchMatch createCommand(CommandType type);
 	static std::string getCommandName(CommandType type);
+	static CommandType getCommandType(const std::string& name);
 
 	static const char FULLTEXT_SEARCH_CHARACTER = '?';
 

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

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

src/lib_gui/qt/view/QtGraphView.cpp

@@ -32,7 +32,8 @@
 QtGraphView::QtGraphView(ViewLayout* viewLayout)
 	: GraphView(viewLayout)
 	, m_rebuildGraphFunctor(
-		std::bind(&QtGraphView::doRebuildGraph, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3))
+		std::bind(&QtGraphView::doRebuildGraph, this,
+			std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4))
 	, m_clearFunctor(std::bind(&QtGraphView::doClear, this))
 	, m_resizeFunctor(std::bind(&QtGraphView::doResize, this))
 	, m_refreshFunctor(std::bind(&QtGraphView::doRefreshView, this))
@@ -82,9 +83,10 @@ void QtGraphView::refreshView()
 void QtGraphView::rebuildGraph(
 	std::shared_ptr<Graph> graph,
 	const std::vector<std::shared_ptr<DummyNode>>& nodes,
-	const std::vector<std::shared_ptr<DummyEdge>>& edges
+	const std::vector<std::shared_ptr<DummyEdge>>& edges,
+	bool animated
 ){
-	m_rebuildGraphFunctor(graph, nodes, edges);
+	m_rebuildGraphFunctor(graph, nodes, edges, animated);
 }
 
 void QtGraphView::clear()
@@ -197,7 +199,8 @@ QtGraphicsView* QtGraphView::getView() const
 void QtGraphView::doRebuildGraph(
 	std::shared_ptr<Graph> graph,
 	const std::vector<std::shared_ptr<DummyNode>>& nodes,
-	const std::vector<std::shared_ptr<DummyEdge>>& edges
+	const std::vector<std::shared_ptr<DummyEdge>>& edges,
+	bool animated
 ){
 	if (m_transition && m_transition->currentTime() < m_transition->totalDuration())
 	{
@@ -248,7 +251,14 @@ void QtGraphView::doRebuildGraph(
 		m_graph = graph;
 	}
 
-	createTransition();
+	if (animated)
+	{
+		createTransition();
+	}
+	else
+	{
+		switchToNewGraphData();
+	}
 }
 
 void QtGraphView::doClear()
@@ -596,7 +606,7 @@ void QtGraphView::doFocusIn(const std::vector<Id>& tokenIds)
 	for (const Id& tokenId : tokenIds)
 	{
 		std::shared_ptr<QtGraphNode> node = findNodeRecursive(m_oldNodes, tokenId);
-		if (node && node->isDataNode())
+		if (node)
 		{
 			node->focusIn();
 			continue;

src/lib_gui/qt/view/QtGraphView.h

@@ -34,7 +34,8 @@ public:
 	virtual void rebuildGraph(
 		std::shared_ptr<Graph> graph,
 		const std::vector<std::shared_ptr<DummyNode>>& nodes,
-		const std::vector<std::shared_ptr<DummyEdge>>& edges);
+		const std::vector<std::shared_ptr<DummyEdge>>& edges,
+		bool animated);
 	virtual void clear();
 
 	virtual void focusTokenIds(const std::vector<Id>& focusedTokenIds);
@@ -57,7 +58,8 @@ private:
 	void doRebuildGraph(
 		std::shared_ptr<Graph> graph,
 		const std::vector<std::shared_ptr<DummyNode>>& nodes,
-		const std::vector<std::shared_ptr<DummyEdge>>& edges);
+		const std::vector<std::shared_ptr<DummyEdge>>& edges,
+		bool animated);
 	void doClear();
 	void doResize();
 	void doRefreshView();
@@ -86,7 +88,8 @@ private:
 	QtThreadedFunctor<
 		std::shared_ptr<Graph>,
 		const std::vector<std::shared_ptr<DummyNode>>&,
-		const std::vector<std::shared_ptr<DummyEdge>>&
+		const std::vector<std::shared_ptr<DummyEdge>>&,
+		bool
 	> m_rebuildGraphFunctor;
 	QtThreadedFunctor<void> m_clearFunctor;
 	QtThreadedFunctor<void> m_resizeFunctor;