IEnumerable <AnalyzerTreeNodeData> FindReferencesInType(TypeDef type) { AnalyzerTreeNodeData newNode = null; try { if (!TypesHierarchyHelpers.IsBaseType(analyzedMethod.DeclaringType, type, resolveTypeArguments: false)) { yield break; } foreach (MethodDef method in type.Methods) { if (TypesHierarchyHelpers.IsBaseMethod(analyzedMethod, method)) { bool hidesParent = !method.IsVirtual ^ method.IsNewSlot; newNode = new MethodNode(method, hidesParent) { Context = Context }; } } } catch (ResolveException) { // ignore this type definition. maybe add a notification about such cases. } if (newNode != null) { yield return(newNode); } }
internal static void DeleteNodes(ITreeNodeData[] nodes) { if (nodes != null) { foreach (var node in nodes) { AnalyzerTreeNodeData.CancelSelfAndChildren(node); node.TreeNode.Parent.Children.Remove(node.TreeNode); } } }
protected override IEnumerable <AnalyzerTreeNodeData> FetchChildren(CancellationToken ct) { //note: only goes up 1 level AnalyzerTreeNodeData newNode = null; try { //get base type (if any) if (analyzedMethod.DeclaringType.BaseType == null) { yield break; } ITypeDefOrRef baseType = analyzedMethod.DeclaringType.BaseType; while (baseType != null) { //only typedef has a Methods property if (baseType is TypeDef) { TypeDef def = (TypeDef)baseType; foreach (var method in def.Methods) { if (TypesHierarchyHelpers.IsBaseMethod(method, analyzedMethod)) { newNode = new MethodNode(method) { Context = Context }; break; //there can be only one } } //escape from the while loop if we have a match (cannot yield return in try/catch) if (newNode != null) { break; } baseType = def.BaseType; } else { //try to resolve the TypeRef //will be null if resolving failed baseType = baseType.Resolve(); } } } catch (ResolveException) { //ignored } if (newNode != null) { yield return(newNode); } }
public static void HandleModelUpdated(ITreeNode node, IDsDocument[] documents) { var children = node.DataChildren.ToArray(); for (int i = children.Length - 1; i >= 0; i--) { var c = children[i]; var n = c as AnalyzerTreeNodeData; if (n is null || !n.HandleModelUpdated(documents)) { AnalyzerTreeNodeData.CancelSelfAndChildren(c); node.Children.RemoveAt(i); } } }
public static void HandleAssemblyListChanged(ITreeNode node, IDsDocument[] removedAssemblies, IDsDocument[] addedAssemblies) { var children = node.DataChildren.ToArray(); for (int i = children.Length - 1; i >= 0; i--) { var c = children[i]; var n = c as AnalyzerTreeNodeData; if (n is null || !n.HandleAssemblyListChanged(removedAssemblies, addedAssemblies)) { AnalyzerTreeNodeData.CancelSelfAndChildren(c); node.Children.RemoveAt(i); } } }
public static void HandleModelUpdated(ITreeNode node, IDnSpyFile[] files) { var children = node.DataChildren.ToArray(); for (int i = children.Length - 1; i >= 0; i--) { var c = children[i]; var n = c as IAnalyzerTreeNodeData; if (n == null || !n.HandleModelUpdated(files)) { AnalyzerTreeNodeData.CancelSelfAndChildren(c); node.Children.RemoveAt(i); } } }
void CancelAndClearChildren() { AnalyzerTreeNodeData.CancelSelfAndChildren(this); TreeNode.Children.Clear(); TreeNode.LazyLoading = true; }
public void OnActivated(AnalyzerTreeNodeData node) { if (node == null) throw new ArgumentNullException(nameof(node)); bool newTab = Keyboard.Modifiers == ModifierKeys.Control || Keyboard.Modifiers == ModifierKeys.Shift; FollowNode(node, newTab, null); }
public void Add(AnalyzerTreeNodeData node) { if (node is EntityNode) { var an = node as EntityNode; var found = TreeView.Root.DataChildren.OfType<EntityNode>().FirstOrDefault(n => n.Member == an.Member); if (found != null) { found.TreeNode.IsExpanded = true; TreeView.SelectItems(new TreeNodeData[] { found }); TreeView.Focus(); return; } } TreeView.Root.Children.Add(TreeView.Create(node)); node.TreeNode.IsExpanded = true; TreeView.SelectItems(new TreeNodeData[] { node }); TreeView.Focus(); }