public override void DeleteWithoutConfirmation(SharpTreeNode[] nodes) { foreach (var node in nodes) { if (node.Parent != null) node.Parent.Children.Remove(node); } }
protected override IDataObject GetDataObject(SharpTreeNode[] nodes) { var data = new DataObject(); var paths = nodes.OfType<FileSystemNode>().Select(n => n.FullPath).ToArray(); data.SetData(DataFormats.FileDrop, paths); return data; }
public void SelectNode(SharpTreeNode obj) { if (obj != null) { if (!obj.AncestorsAndSelf().Any(node => node.IsHidden)) { // Set both the selection and focus to ensure that keyboard navigation works as expected. treeView.FocusNode(obj); treeView.SelectedItem = obj; } else { MessageBox.Show("Navigation failed because the target is hidden or a compiler-generated class.\n" + "Please disable all filters that might hide the item (i.e. activate " + "\"View > Show internal types and members\") and try again.", "ILSpy", MessageBoxButton.OK, MessageBoxImage.Exclamation); } } }
public bool IsSatisfied(SharpTreeNode node) { var memberNode = node as IMemberTreeNode; if (memberNode == null) { return(false); } m_assemblyFullNames.Add(memberNode.Member.Module.Assembly.FullName); if (1 < m_assemblyFullNames.Count) { return(false); } return(memberNode.Member is MethodDefinition || memberNode.Member is PropertyDefinition || memberNode.Member is EventDefinition); }
private string GetAutoLoadedAssemblyNode(SharpTreeNode node) { if (node == null) { return(null); } while (!(node is TreeNodes.AssemblyTreeNode) && node.Parent != null) { node = node.Parent; } //this should be an assembly node var assyNode = node as TreeNodes.AssemblyTreeNode; var loadedAssy = assyNode.LoadedAssembly; if (!(loadedAssy.IsLoaded && loadedAssy.IsAutoLoaded)) { return(null); } return(loadedAssy.FileName); }
static LoadedAssembly GetLoadedAssembly(SharpTreeNode node) { var asmNode = ILSpyTreeNode.GetNode <AssemblyTreeNode>(node); if (asmNode == null) { return(null); } var module = asmNode.LoadedAssembly.ModuleDefinition as ModuleDefMD; if (module == null) { return(null); } if (!module.MetaData.PEImage.IsMemoryMappedIO) { return(null); } return(asmNode.LoadedAssembly); }
static DnSpyFile GetDnSpyFile(SharpTreeNode node) { var asmNode = node as AssemblyTreeNode; if (asmNode == null) { return(null); } var module = asmNode.DnSpyFile.ModuleDef as ModuleDefMD; if (module == null) { return(null); } if (!module.MetaData.PEImage.IsMemoryMappedIO) { return(null); } return(asmNode.DnSpyFile); }
IEnumerable <SharpTreeNode> FindReferences(LoadedAssembly asm, CancellationToken ct) { string asmName = asm.AssemblyDefinition.Name.Name; string name = analyzedProperty.Name; string declTypeName = analyzedProperty.DeclaringType.FullName; foreach (TypeDefinition type in TreeTraversal.PreOrder(asm.AssemblyDefinition.MainModule.Types, t => t.NestedTypes)) { ct.ThrowIfCancellationRequested(); SharpTreeNode newNode = null; try { if (!TypesHierarchyHelpers.IsBaseType(analyzedProperty.DeclaringType, type, resolveTypeArguments: false)) { continue; } foreach (PropertyDefinition property in type.Properties) { ct.ThrowIfCancellationRequested(); if (TypesHierarchyHelpers.IsBaseProperty(analyzedProperty, property)) { MethodDefinition anyAccessor = property.GetMethod ?? property.SetMethod; bool hidesParent = !anyAccessor.IsVirtual ^ anyAccessor.IsNewSlot; newNode = new AnalyzedPropertyTreeNode(property, hidesParent ? "(hides) " : ""); } } } catch (ReferenceResolvingException) { // ignore this type definition. } if (newNode != null) { yield return(newNode); } } }
void MainWindow_Loaded(object sender, RoutedEventArgs e) { ILSpySettings spySettings = this.spySettings; this.spySettings = null; // Load AssemblyList only in Loaded event so that WPF is initialized before we start the CPU-heavy stuff. // This makes the UI come up a bit faster. this.assemblyList = assemblyListManager.LoadList(spySettings, sessionSettings.ActiveAssemblyList); HandleCommandLineArguments(App.CommandLineArguments); if (assemblyList.GetAssemblies().Length == 0 && assemblyList.ListName == AssemblyListManager.DefaultListName) { LoadInitialAssemblies(); } ShowAssemblyList(this.assemblyList); HandleCommandLineArgumentsAfterShowList(App.CommandLineArguments); if (App.CommandLineArguments.NavigateTo == null) { SharpTreeNode node = FindNodeByPath(sessionSettings.ActiveTreeViewPath, true); if (node != null) { SelectNode(node); // only if not showing the about page, perform the update check: ShowMessageIfUpdatesAvailableAsync(spySettings); } else { AboutPage.Display(decompilerTextView); } } }
private SharpTreeNode NavigateFindPrevious(SharpTreeNode node) { var sibling = GetPreviousSibling(node); if (sibling != null) { return(GetLastGrandChild(sibling)); } if (node.Parent != null) { node = node.Parent; var item = node as ObjectViewModel; if (item?.IsChildrenLoadedBySearch == true) { item.UnloadChildren(); item.IsChildrenLoadedBySearch = false; } return(node); } return(GetLastGrandChild(node)); }
private IEnumerable <SharpTreeNode> FindReferences(LoadedAssembly asm, CancellationToken ct) { string asmName = asm.AssemblyDefinition.Name.Name; string name = analyzedMethod.Name; string declTypeName = analyzedMethod.DeclaringType.FullName; foreach (TypeDefinition type in TreeTraversal.PreOrder(asm.AssemblyDefinition.MainModule.Types, t => t.NestedTypes)) { ct.ThrowIfCancellationRequested(); SharpTreeNode newNode = null; try { if (!TypesHierarchyHelpers.IsBaseType(analyzedMethod.DeclaringType, type, resolveTypeArguments: false)) { continue; } foreach (MethodDefinition method in type.Methods) { ct.ThrowIfCancellationRequested(); if (TypesHierarchyHelpers.IsBaseMethod(analyzedMethod, method)) { bool hidesParent = !method.IsVirtual ^ method.IsNewSlot; newNode = new AnalyzedMethodTreeNode(method, hidesParent ? "(hides) " : ""); } } } catch (ReferenceResolvingException) { // ignore this type definition. maybe add a notification about such cases. } if (newNode != null) { yield return(newNode); } } }
protected override int GetNewChildIndex(SharpTreeNode node) { if (node is TypeTreeNode) { return(GetNewChildIndex(node, NestedTypeStringComparer, n => ((TypeTreeNode)n).TypeDefinition.Name)); } if (node is FieldTreeNode) { return(GetNewChildIndex(node, FieldStringComparer, n => ((FieldTreeNode)n).FieldDefinition.Name)); } if (node is PropertyTreeNode) { return(GetNewChildIndex(node, PropertyStringComparer, n => ((PropertyTreeNode)n).PropertyDefinition.Name)); } if (node is EventTreeNode) { return(GetNewChildIndex(node, EventStringComparer, n => ((EventTreeNode)n).EventDefinition.Name)); } if (node is MethodTreeNode) { return(GetNewChildIndex(node, MethodStringComparer, n => ((MethodTreeNode)n).MethodDefinition.Name)); } return(base.GetNewChildIndex(node)); }
void MainWindow_Loaded(object sender, RoutedEventArgs e) { ILSpySettings spySettings = this.spySettings; this.spySettings = null; // Load AssemblyList only in Loaded event so that WPF is initialized before we start the CPU-heavy stuff. // This makes the UI come up a bit faster. this.assemblyList = assemblyListManager.LoadList(spySettings, sessionSettings.ActiveAssemblyList); ShowAssemblyList(this.assemblyList); string[] args = Environment.GetCommandLineArgs(); for (int i = 1; i < args.Length; i++) { assemblyList.OpenAssembly(args[i]); } if (assemblyList.GetAssemblies().Length == 0) { LoadInitialAssemblies(); } SharpTreeNode node = FindNodeByPath(sessionSettings.ActiveTreeViewPath, true); if (node != null) { SelectNode(node); // only if not showing the about page, perform the update check: ShowMessageIfUpdatesAvailableAsync(spySettings); } else { AboutPage.Display(decompilerTextView); } }
protected override int GetNewChildIndex(SharpTreeNode node) { if (node is TypeTreeNode) { return(GetNewChildIndex(node, (a, b) => TypeDefComparer.Instance.Compare(((TypeTreeNode)a).TypeDefinition, ((TypeTreeNode)b).TypeDefinition))); } if (node is FieldTreeNode) { return(GetNewChildIndex(node, (a, b) => FieldDefComparer.Instance.Compare(((FieldTreeNode)a).FieldDefinition, ((FieldTreeNode)b).FieldDefinition))); } if (node is PropertyTreeNode) { return(GetNewChildIndex(node, (a, b) => PropertyDefComparer.Instance.Compare(((PropertyTreeNode)a).PropertyDefinition, ((PropertyTreeNode)b).PropertyDefinition))); } if (node is EventTreeNode) { return(GetNewChildIndex(node, (a, b) => EventDefComparer.Instance.Compare(((EventTreeNode)a).EventDefinition, ((EventTreeNode)b).EventDefinition))); } if (node is MethodTreeNode) { return(GetNewChildIndex(node, (a, b) => MethodDefComparer.Instance.Compare(((MethodTreeNode)a).MethodDefinition, ((MethodTreeNode)b).MethodDefinition))); } return(base.GetNewChildIndex(node)); }
public override void Delete(SharpTreeNode[] nodes) { if (MessageBox.Show("Are you sure you want to delete " + nodes.Length + " items?", "Delete", MessageBoxButton.OKCancel) == MessageBoxResult.OK) { DeleteWithoutConfirmation(nodes); } }
protected override void Execute(SharpTreeNode node) { ILSpyPackage.RenameItem(node, EventArgs.Empty); }
protected override void Execute(SharpTreeNode node) { ILSpyPackage.VerifyAssembly(node, EventArgs.Empty); }
protected override void Execute(SharpTreeNode node) { ILSpyPackage.UpdateHostObjectModel(this, EventArgs.Empty); }
protected override void Execute(SharpTreeNode node) { ILSpyPackage.Inject(InjectType.Constructor); }
internal void SelectNode(SharpTreeNode obj) { if (obj != null) { if (!obj.AncestorsAndSelf().Any(node => node.IsHidden)) { // Set both the selection and focus to ensure that keyboard navigation works as expected. treeView.FocusNode(obj); treeView.SelectedItem = obj; } else { MessageBox.Show("Navigation failed because the target is hidden or a compiler-generated class.\n" + "Please disable all filters that might hide the item (i.e. activate " + "\"View > Show internal types and members\") and try again.", "ILSpy", MessageBoxButton.OK, MessageBoxImage.Exclamation); } } }
void UpdateChildren(int maxDepth = 0) { if (FilesystemEntry.IsDirectory) { SharpDevelopFilesystemNode[] oldEntries; { SharpTreeNode[] sharpTreeNodes = new SharpTreeNode[Children.Count]; Children.CopyTo(sharpTreeNodes, 0); oldEntries = sharpTreeNodes.Cast <SharpDevelopFilesystemNode>().ToArray(); } // reuse exsting nodes var filesystemEntries = FilesystemEntry.Items; var filesystemEntriesCount = filesystemEntries.Count; bool requiresUpdate = false; // check for updates { requiresUpdate |= oldEntries.Length != filesystemEntriesCount; if (!requiresUpdate) { for (int i = 0; i < filesystemEntriesCount; i++) { if (oldEntries[i].FilesystemEntry != filesystemEntries[i]) { requiresUpdate = true; break; } } } } // perform update SharpDevelopFilesystemNode[] newEntries = oldEntries; if (requiresUpdate) { newEntries = new SharpDevelopFilesystemNode[filesystemEntriesCount]; for (var entryIndex = 0; entryIndex < filesystemEntriesCount; entryIndex++) { var currentFilesystemEntry = FilesystemEntry.Items[entryIndex]; // find existing entry var existingEntry = oldEntries.Where(entry => { return(entry.FilesystemEntry == currentFilesystemEntry); }).FirstOrDefault(); // use existing or create a new entry newEntries[entryIndex] = existingEntry ?? new SharpDevelopFilesystemNode(currentFilesystemEntry); } if (Children.Count > 0) { Children.Clear(); } Children.AddRange(newEntries); } if (maxDepth > 0) { maxDepth--; foreach (var entry in newEntries) { entry.Initialize(maxDepth); } } } }
protected override bool IsVisible(SharpTreeNode node) { return(node is TypeTreeNode); }
/// <summary> /// Gets the .ToString() representation of the node's ancestors. /// </summary> string[] GetPathForNode(SharpTreeNode node) { if (node == null) return null; List<string> path = new List<string>(); while (node.Parent != null) { path.Add(node.ToString()); node = node.Parent; } path.Reverse(); return path.ToArray(); }
protected override void Execute(SharpTreeNode node) { ILSpyPackage.SearchObfuscator(node, EventArgs.Empty); }
public bool GoToEntity(IEntity entity) { // Try to find assembly in workspace var entityAssembly = entity.ParentAssembly; if (entityAssembly != null) { ITypeDefinition entityType = null; if (entity is ITypeDefinition) { entityType = (ITypeDefinition)entity; } else { entityType = entity.DeclaringTypeDefinition; } SharpTreeNodeCollection namespaceChildren = null; var root = this.Root as WorkspaceTreeNode; // Try to find assembly of passed entity among open projects in solution var solutionTreeNode = this.Root.Children.OfType <SolutionTreeNode>().FirstOrDefault(); if (solutionTreeNode != null) { // Ensure that we have children solutionTreeNode.EnsureLazyChildren(); var projectTreeNode = solutionTreeNode.Children.FirstOrDefault( node => { if (node is ProjectTreeNode) { var treeNode = (ProjectTreeNode)node; if (node.Model is IProject) { var projectModel = (IProject)node.Model; return(projectModel.AssemblyModel.FullAssemblyName == entityAssembly.FullAssemblyName); } } return(false); }); if (projectTreeNode != null) { projectTreeNode.EnsureLazyChildren(); namespaceChildren = projectTreeNode.Children; } } if (namespaceChildren == null) { // Try to find assembly of passed entity among additional assemblies var assemblyTreeNode = FindAssemblyTreeNode(entityAssembly.FullAssemblyName); if (assemblyTreeNode != null) { assemblyTreeNode.EnsureLazyChildren(); namespaceChildren = assemblyTreeNode.Children; } } if (namespaceChildren == null) { // Add assembly to workspace (unpinned), if not available in ClassBrowser IAssemblyParserService assemblyParser = SD.GetService <IAssemblyParserService>(); IClassBrowser classBrowser = SD.GetService <IClassBrowser>(); if (assemblyParser != null && classBrowser != null) { IAssemblyModel unpinnedAssemblyModel = assemblyParser.GetAssemblyModel(new FileName(entityAssembly.UnresolvedAssembly.Location)); if (unpinnedAssemblyModel != null) { classBrowser.UnpinnedAssemblies.Assemblies.Add(unpinnedAssemblyModel); var assemblyTreeNode = FindAssemblyTreeNode(entityAssembly.FullAssemblyName); if (assemblyTreeNode != null) { assemblyTreeNode.EnsureLazyChildren(); namespaceChildren = assemblyTreeNode.Children; } } } } if (namespaceChildren != null) { var nsTreeNode = namespaceChildren.FirstOrDefault( node => (node is NamespaceTreeNode) && (((NamespaceTreeNode)node).Model is INamespaceModel) && (((INamespaceModel)((NamespaceTreeNode)node).Model).FullName == entityType.Namespace) ) as ModelCollectionTreeNode; if (nsTreeNode != null) { // Ensure that we have children nsTreeNode.EnsureLazyChildren(); SharpTreeNode entityTypeNode = null; // Search in namespace node recursively var foundEntityNode = nsTreeNode.FindChildNodeRecursively( node => { var treeNode = node as SharpTreeNode; if (treeNode != null) { var treeNodeTypeModel = treeNode.Model as ITypeDefinitionModel; if (treeNodeTypeModel != null) { var modelFullTypeName = treeNodeTypeModel.FullTypeName; if (modelFullTypeName == entityType.FullTypeName) { // This is the TypeDefinitionModel of searched entity (the type itself or its member) entityTypeNode = treeNode; if (entity is ITypeDefinition) { // We are looking for the type itself return(true); } } } if ((entity is IMember) && (treeNode.Model is IMemberModel)) { // Compare parent types and member names IMemberModel memberModel = (IMemberModel)treeNode.Model; IMember member = (IMember)entity; bool isSymbolOfTypeAndName = (member.DeclaringType.FullName == memberModel.UnresolvedMember.DeclaringTypeDefinition.FullName) && (member.Name == memberModel.Name) && (member.SymbolKind == memberModel.SymbolKind); if (isSymbolOfTypeAndName) { var parametrizedEntityMember = member as IParameterizedMember; var parametrizedTreeNodeMember = memberModel.UnresolvedMember as IUnresolvedParameterizedMember; if ((parametrizedEntityMember != null) && (parametrizedTreeNodeMember != null)) { // For methods and constructors additionally check the parameters and their types to handle overloading properly int treeNodeParamsCount = parametrizedTreeNodeMember.Parameters != null ? parametrizedTreeNodeMember.Parameters.Count : 0; int entityParamsCount = parametrizedEntityMember.Parameters != null ? parametrizedEntityMember.Parameters.Count : 0; if (treeNodeParamsCount == entityParamsCount) { for (int i = 0; i < entityParamsCount; i++) { // Compare full type names or at least only type names without namespace // This is not precise, but sufficient in most cases. var entityParamType = parametrizedEntityMember.Parameters[i].Type; var treeNodeParamType = parametrizedTreeNodeMember.Parameters[i].Type.Resolve( new SimpleTypeResolveContext(entityAssembly)); if ((entityParamType.FullName != treeNodeParamType.FullName) && (entityParamType.Name != treeNodeParamType.Name)) { return(false); } } // All parameters were equal return(true); } } else { return(true); } } } } return(false); }); // Special handling for default constructors: If not found, jump to type declaration instead if ((foundEntityNode == null) && (entity.SymbolKind == SymbolKind.Constructor)) { foundEntityNode = entityTypeNode; } if (foundEntityNode != null) { this.FocusNode(foundEntityNode); this.SelectedItem = foundEntityNode; return(true); } } } } return(false); }
protected override IMetadataTokenProvider ImportCore(MemberImportingOptions options, SharpTreeNode node) { //Checks that the task hasn't been canceled options.CancellationToken.ThrowIfCancellationRequested(); //Adds the field to the destination type ((TypeDefinition)Destination).Fields.Add(fieldClone); if (_createNode) { node.AddChildAndColorAncestors(new ILEditTreeNode(fieldClone, false)); } //Returns the new field return(fieldClone); }
public override bool CanDelete(SharpTreeNode[] nodes) { return nodes.All(n => n is FileSystemNode); }
protected override void Execute(SharpTreeNode node) { ILSpyPackage.Inject(InjectType.AssemblyReference); }
async void LoadAssemblies(IEnumerable <string> fileNames, List <LoadedAssembly> loadedAssemblies = null, bool focusNode = true) { SharpTreeNode lastNode = null; foreach (string file in fileNames) { switch (Path.GetExtension(file)) { case ".nupkg": LoadedNugetPackage package = new LoadedNugetPackage(file); var selectionDialog = new NugetPackageBrowserDialog(package); selectionDialog.Owner = this; if (await selectionDialog.ShowDialog <bool>() != true) { break; } foreach (var entry in selectionDialog.SelectedItems) { var nugetAsm = assemblyList.OpenAssembly("nupkg://" + file + ";" + entry.Name, entry.Stream, true); if (nugetAsm != null) { if (loadedAssemblies != null) { loadedAssemblies.Add(nugetAsm); } else { var node = assemblyListTreeNode.FindAssemblyNode(nugetAsm); if (node != null && focusNode) { treeView.SelectedItems.Add(node); lastNode = node; } } } } break; default: var asm = assemblyList.OpenAssembly(file); if (asm != null) { if (loadedAssemblies != null) { loadedAssemblies.Add(asm); } else { var node = assemblyListTreeNode.FindAssemblyNode(asm); if (node != null && focusNode) { treeView.SelectedItems.Add(node); lastNode = node; } } } break; } if (lastNode != null && focusNode) { treeView.FocusNode(lastNode); } } }
protected abstract bool IsVisible(SharpTreeNode node);
protected override bool IsVisible(SharpTreeNode node) { return(ILSpyPackage.ActiveHandler != null && ILSpyPackage.ActiveHandler.TargetObject != null && node != null && !(node.GetType().Name.Contains("AnalyzedTypeTreeNode"))); }
protected override IMetadataTokenProvider ImportCore(MemberImportingOptions options, SharpTreeNode node) { //Checks that the task hasn't been canceled options.CancellationToken.ThrowIfCancellationRequested(); //Checks if the destination is a module or a type if (Destination is ModuleDefinition) { //Destination var dest = (ModuleDefinition)Destination; dest.Types.Add(typeClone); //Finds the correct namespace var ns = typeClone.Namespace; var moduleNode = Helpers.Tree.GetModuleNode((ModuleDefinition)Destination); var nsNode = moduleNode.Children.EnsureLazyChildren().OfType <NamespaceTreeNode>().FirstOrDefault(x => x.Name == ns); if (nsNode != null) { nsNode.AddChildAndColorAncestors(new ILEditTreeNode(typeClone, false)); } else { nsNode = new NamespaceTreeNode(typeClone.Namespace) { Foreground = GlobalContainer.ModifiedNodesBrush }; nsNode.Children.Add(new ILEditTreeNode(typeClone, false)); moduleNode.AddChildAndColorAncestors(nsNode); } } else { //Destination var dest = (TypeDefinition)Destination; dest.NestedTypes.Add(typeClone); node.AddChildAndColorAncestors(new ILEditTreeNode(typeClone, false)); } //Return return(typeClone); }
async void NavigateOnLaunch(string navigateTo, string[] activeTreeViewPath, ILSpySettings spySettings, List <LoadedAssembly> relevantAssemblies) { var initialSelection = treeView.SelectedItem; if (navigateTo != null) { bool found = false; if (navigateTo.StartsWith("N:", StringComparison.Ordinal)) { string namespaceName = navigateTo.Substring(2); foreach (LoadedAssembly asm in relevantAssemblies) { AssemblyTreeNode asmNode = assemblyListTreeNode.FindAssemblyNode(asm); if (asmNode != null) { // FindNamespaceNode() blocks the UI if the assembly is not yet loaded, // so use an async wait instead. await asm.GetPEFileAsync().Catch <Exception>(ex => { }); NamespaceTreeNode nsNode = asmNode.FindNamespaceNode(namespaceName); if (nsNode != null) { found = true; if (treeView.SelectedItem == initialSelection) { SelectNode(nsNode); } break; } } } } else if (navigateTo == "none") { // Don't navigate anywhere; start empty. // Used by ILSpy VS addin, it'll send us the real location to navigate to via IPC. found = true; } else { IEntity mr = await Task.Run(() => FindEntityInRelevantAssemblies(navigateTo, relevantAssemblies)); if (mr != null && mr.ParentModule.PEFile != null) { found = true; if (treeView.SelectedItem == initialSelection) { JumpToReference(mr); } } } if (!found && treeView.SelectedItem == initialSelection) { AvalonEditTextOutput output = new AvalonEditTextOutput(); output.Write(string.Format("Cannot find '{0}' in command line specified assemblies.", navigateTo)); decompilerTextView.ShowText(output); } } else if (relevantAssemblies.Count == 1) { // NavigateTo == null and an assembly was given on the command-line: // Select the newly loaded assembly AssemblyTreeNode asmNode = assemblyListTreeNode.FindAssemblyNode(relevantAssemblies[0]); if (asmNode != null && treeView.SelectedItem == initialSelection) { SelectNode(asmNode); } } else if (spySettings != null) { SharpTreeNode node = null; if (activeTreeViewPath?.Length > 0) { foreach (var asm in assemblyList.GetAssemblies()) { if (asm.FileName == activeTreeViewPath[0]) { // FindNodeByPath() blocks the UI if the assembly is not yet loaded, // so use an async wait instead. await asm.GetPEFileAsync().Catch <Exception>(ex => { }); } } node = FindNodeByPath(activeTreeViewPath, true); } if (treeView.SelectedItem == initialSelection) { if (node != null) { SelectNode(node); // only if not showing the about page, perform the update check: await ShowMessageIfUpdatesAvailableAsync(spySettings); } else { AboutPage.Display(decompilerTextView); } } } }
protected override bool IsVisible(SharpTreeNode node) { return(ILSpyPackage.ActiveHandler != null && ILSpyPackage.ActiveHandler.TargetObject != null && !(node is AnalyzerTreeNode)); }
protected override void Execute(SharpTreeNode node) { ILSpyPackage.Inject(InjectType.Interface); }
protected override bool IsVisible(SharpTreeNode node) { return(node is AssemblyTreeNode); }