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);
}
