/// <summary> /// Expands the nodeInfo. /// </summary> /// <param name="nodeInfo">The nodeInfo.</param> /// <returns>false to cancel</returns> public bool ExpandNode(TreeNode node) { // get rid of the dummy TreeNode[] removeNodes = node.Nodes.Cast<TreeNode>().ToArray(); NodeInfo nodeInfo = node.GetInfo(); return this.AddSubNodes(nodeInfo, () => { // remove the original nodeInfo when finished foreach (TreeNode n in removeNodes) { this.Nodes.Remove(n); } }); }
/// <summary> /// Returns all the exceptions that a tree nodeInfo and it's child nodeInfo point to. /// </summary> /// <param name="nodeInfo">The nodeInfo.</param> /// <returns> /// The exceptions that a nodeInfo and it's child nodeInfo point to. /// </returns> private IEnumerable<ThrownException> AddList(TreeNode node) { Class cls = node.GetInfo().GetAnalysisObject<Class>(); IEnumerable<ThrownException> l = null; if (cls != null) { Type type = cls.ClassType; l = this.ExceptionTree.ExceptionDictionary.GetList(type); } else { l = new ThrownException[] { }; } foreach (TreeNode child in node.Nodes) { l = l.Concat(this.AddList(child)); } node.GetInfo().ExtraData = l; return l; }
public static ReloadNode Create(TreeNode node) { AssemblyItem asm = node.GetInfo().GetAnalysisObject<AssemblyItem>(); if (asm == null) { return null; } return new ReloadNode() { Filename = asm.Assembly.Location, Expanded = node.IsExpanded }; }
private void UpdateNode(TreeNode node) { NodeInfo info = node.GetInfo(); if (info != null) { node.GetInfo().UpdateNode(); } foreach (TreeNode child in node.Nodes) { this.UpdateNode(child); } }
public void ShowCallStack(CallStack callStack, TreeNode startAt, CancellationToken cancelToken) { if (callStack.Count == 0) { return; } // start from the bottom of the stack CallStack stack = new CallStack(callStack.Reverse()); TreeNode lastExistingNode = null; TreeNode newNodesRoot = null; NodeInfo nodeInfo = startAt.GetInfo(); TreeNode node = nodeInfo.Node; TreeNode lastNode = node; bool first = nodeInfo.GetAnalysisObject<Method>() == stack.Peek(); while (stack.Count >= 0) { if ((node.Nodes.Count == 0) || (node.Nodes[0].Tag == null)) { // hasn't got the child nodeInfo yet. nodeInfo = node.GetInfo(); if (newNodesRoot == null) { lastExistingNode = node; node = newNodesRoot = new TreeNode(); } else { node.Nodes.Clear(); } TreeNode[] childNodes = this.CreateSubNodes(nodeInfo, cancelToken); node.Nodes.AddRange(childNodes); } lastNode = node; if (stack.Count == 0) { break; } Method method = stack.Pop(); if (!first) { node = this.FindNode(ni => ni.GetAnalysisObject<Method>() == method, node, 1); } first = false; } this.InvokeIfRequired(() => { if ((lastExistingNode.Nodes.Count == 0) || (lastExistingNode.Nodes[0].Tag == null)) { lastExistingNode.Nodes.Clear(); } lastExistingNode.Nodes.AddRange(newNodesRoot.Nodes.Cast<TreeNode>().ToArray()); lastNode.EnsureVisible(); this.SelectedNode = lastNode; }); }
public void ReloadClassNodes(TreeNode node) { NodeInfo info = node.GetInfo(); if ((info != null) && info.Type.HasFlag(NodeType.Class)) { node.Collapse(true); node.Nodes.Clear(); node.Nodes.Add(this.CreateLazyDummyNode()); return; } foreach (TreeNode n in node.Nodes) { this.ReloadClassNodes(n); } }