private void SortChildNodes(VisualizationNode visualizationNode, RelationType relationType)
{
visualizationNode.SetRelations(visualizationNode.GetRelations(relationType, true, true).OrderBy(p =>
{
return(p.VNode.GetSortingKey(relationType));
}).ToList(), relationType);
}
public void CreateNodeHierarchyRec(HashSet <string> addedVisualizationNodes, Stack <VisualizationNode> visualizationNodeStack, VisualizationNode visualizationNode, Connection connection, int depth, RelationType relationType, NodeDisplayOptions nodeDisplayOptions, ref int iterations)
{
// prevent the tree from becoming too big
if (iterations >= 0xFFFF)
{
return;
}
iterations++;
visualizationNode.Key = NodeDependencyLookupUtility.GetNodeKey(connection.Node.Id, connection.Node.Type);
bool containedNode = addedVisualizationNodes.Contains(visualizationNode.Key);
if (depth == nodeDisplayOptions.MaxDepth || (containedNode && nodeDisplayOptions.ShowHierarchyOnce))
{
return;
}
if (!nodeDisplayOptions.ConnectionTypesToDisplay.Contains(connection.Type) && connection.Type != "Root")
{
return;
}
addedVisualizationNodes.Add(visualizationNode.Key);
visualizationNodeStack.Push(visualizationNode);
List <MergedNode> mergedNodes = GetMergedNodes(connection.Node.GetRelations(relationType));
foreach (MergedNode mergedNode in mergedNodes)
{
Node childNode = mergedNode.Target.Node;
string childNodeKey = NodeDependencyLookupUtility.GetNodeKey(childNode.Id, childNode.Type);
if (addedVisualizationNodes.Contains(childNodeKey) && _nodeDisplayOptions.ShowNodesOnce)
{
continue;
}
VisualizationNode recursionNode = HasRecursion(childNodeKey, visualizationNodeStack);
bool isRecursion = recursionNode != null;
VisualizationNode visualizationChildNode = isRecursion ? recursionNode : GetVisualizationNode(childNode.Id, childNode.Type);
visualizationChildNode.IsFiltered = IsNodeFiltered(childNode.Id, childNode.Type);
if (!isRecursion)
{
CreateNodeHierarchyRec(addedVisualizationNodes, visualizationNodeStack, visualizationChildNode, mergedNode.Target, depth + 1, relationType, nodeDisplayOptions, ref iterations);
}
if (!nodeDisplayOptions.HideFilteredNodes || HasNoneFilteredChildren(visualizationChildNode, relationType))
{
visualizationChildNode.HasNoneFilteredChildren = true;
AddBidirConnection(relationType, visualizationNode, visualizationChildNode, mergedNode.Datas, isRecursion);
}
}
SortChildNodes(visualizationNode, relationType);
visualizationNodeStack.Pop();
}
private bool HasNoneFilteredChildren(VisualizationNode node, RelationType relationType)
{
foreach (VisualizationConnection connection in node.GetRelations(relationType))
{
if (connection.VNode.HasNoneFilteredChildren || !connection.VNode.IsFiltered)
{
return(true);
}
}
return(!node.IsFiltered);
}
public void UpdateAreaSize(VisualizationNode node, Rect _windowData)
{
EnclosedBounds oldArea = new EnclosedBounds();
Bounds.CopyTo(oldArea);
EnclosedBounds bounds = node.TreeBounds;
int edge = 1000;
Bounds.Set(bounds.MinX - edge, bounds.MinY - edge, bounds.MaxX + edge, bounds.MaxY + edge);
Bounds.Enclose(new EnclosedBounds(-(int)_windowData.width / 2, -(int)_windowData.height / 2, (int)_windowData.width / 2, (int)_windowData.height / 2));
if (!oldArea.IsInvalid)
{
ScrollPosition.x += (Bounds.Width - oldArea.Width) / 2;
ScrollPosition.y += (Bounds.Height - oldArea.Height) / 2;
}
}
private void BuildNodeStructure(Node node)
{
Connection rootConnection = new Connection(node, "Root", new PathSegment[0]);
_nodeStructure = GetVisualizationNode(rootConnection.Node.Id, rootConnection.Node.Type);
int iterations = 0;
CreateNodeHierarchyRec(new HashSet <string>(), new Stack <VisualizationNode>(), _nodeStructure, rootConnection, 0, RelationType.DEPENDENCY, _nodeDisplayOptions, ref iterations);
if (_nodeDisplayOptions.DrawReferencerNodes)
{
iterations = 0;
CreateNodeHierarchyRec(new HashSet <string>(), new Stack <VisualizationNode>(), _nodeStructure, rootConnection, 0, RelationType.REFERENCER, _nodeDisplayOptions, ref iterations);
}
_nodeStructureDirty = false;
}
