void DecompileNode(IDecompileNodeContext context, DocumentTreeNodeData node) { foreach (var d in decompileNodes) { if (d.Decompile(context, node)) return; } Debug.Fail("Missing decompiler"); }
public DerivedTypesFinder(DocumentTreeNodeData targetNode, TypeDef type) : base(targetNode) { msgNodeGroup = targetNode.Context.DocumentTreeView.DocumentTreeNodeGroups.GetGroup(DocumentTreeNodeGroupType.MessageTreeNodeGroupDerivedTypes); derivedTypesGroup = targetNode.Context.DocumentTreeView.DocumentTreeNodeGroups.GetGroup(DocumentTreeNodeGroupType.DerivedTypeTreeNodeGroupDerivedTypes); weakModules = targetNode.Context.DocumentTreeView.DocumentService.GetDocuments().Where(a => a.ModuleDef != null).SelectMany(a => a.AssemblyDef != null ? (IEnumerable<ModuleDef>)a.AssemblyDef.Modules : new[] { a.ModuleDef }).Select(a => new WeakReference(a)).ToArray(); this.type = type; Start(); }
NodeTabSaver(IMessageBoxService messageBoxService, IDocumentTab tab, IDocumentTreeNodeDecompiler documentTreeNodeDecompiler, IDecompiler decompiler, IDocumentViewer documentViewer, DocumentTreeNodeData[] nodes) { this.messageBoxService = messageBoxService; this.tab = tab; this.documentTreeNodeDecompiler = documentTreeNodeDecompiler; this.decompiler = decompiler; this.documentViewer = documentViewer; this.nodes = nodes; }
public DocumentTabContent CreateTabContent(DocumentTreeNodeData[] nodes) { var context = new DocumentTabContentFactoryContext(nodes); foreach (var factory in tabContentFactories) { var tabContent = factory.Value.Create(context); if (tabContent != null) return tabContent; } return null; }
public DocumentTabContent Deserialize(Guid guid, ISettingsSection section, DocumentTreeNodeData[] nodes) { var context = new DocumentTabContentFactoryContext(nodes); foreach (var factory in tabContentFactories) { var content = factory.Value.Deserialize(guid, section, context); if (content != null) return content; } return null; }
public void Decompile(IDecompileNodeContext decompileNodeContext, DocumentTreeNodeData[] nodes) { foreach (var dc in decompileNodeCollections) { if (dc.Decompile(decompileNodeContext, nodes)) return; } if (nodes.Length == 1) { var ds = nodes[0] as IDecompileSelf; if (ds?.Decompile(decompileNodeContext) == true) return; } for (int i = 0; i < nodes.Length; i++) { decompileNodeContext.DecompilationContext.CancellationToken.ThrowIfCancellationRequested(); if (i > 0) decompileNodeContext.Output.WriteLine(); DecompileNode(decompileNodeContext, nodes[i]); } }
static void Filter(DocumentTreeNodeData node) { if (node == null) { return; } var res = node.GetFilterType(node.Context.Filter); switch (res) { case FilterType.Default: case FilterType.Visible: node.FilterVersion = node.Context.FilterVersion; node.TreeNode.IsHidden = false; var fnode = node as DocumentTreeNodeData; if (fnode != null && fnode.refilter && node.TreeNode.Children.Count > 0) { node.OnEnsureChildrenLoaded(); } break; case FilterType.Hide: node.TreeNode.IsHidden = true; break; case FilterType.CheckChildren: node.FilterVersion = node.Context.FilterVersion; node.TreeNode.EnsureChildrenLoaded(); node.TreeNode.IsHidden = node.TreeNode.Children.All(a => a.IsHidden); break; default: Debug.Fail($"Invalid type: {res}"); goto case FilterType.Default; } }
static bool CanExecute(DocumentTreeNodeData[] nodes) => nodes.Length == 1 && (nodes[0] is TypeNode || (nodes[0].TreeNode.Parent != null && nodes[0].TreeNode.Parent.Data is TypeNode));
static void Execute(Lazy<IUndoCommandService> undoCommandService, IAppService appService, DocumentTreeNodeData[] nodes) { if (!CanExecute(nodes)) return; var ownerNode = nodes[0]; if (!(ownerNode is TypeNode)) ownerNode = (DocumentTreeNodeData)ownerNode.TreeNode.Parent.Data; var typeNode = ownerNode as TypeNode; Debug.Assert(typeNode != null); if (typeNode == null) throw new InvalidOperationException(); var module = typeNode.GetModule(); Debug.Assert(module != null); if (module == null) throw new InvalidOperationException(); var options = EventDefOptions.Create("MyEvent", module.CorLibTypes.GetTypeRef("System", "EventHandler")); var data = new EventOptionsVM(options, module, appService.DecompilerService, typeNode.TypeDef); var win = new EventOptionsDlg(); win.Title = dnSpy_AsmEditor_Resources.CreateEventCommand2; win.DataContext = data; win.Owner = appService.MainWindow; if (win.ShowDialog() != true) return; var cmd = new CreateEventDefCommand(typeNode, data.CreateEventDefOptions()); undoCommandService.Value.Add(cmd); appService.DocumentTabService.FollowReference(cmd.eventNode); }
public virtual DocumentTreeNodeFilterResult GetResultOther(DocumentTreeNodeData node) => new DocumentTreeNodeFilterResult();
static bool CanExecute(DocumentTreeNodeData[] nodes) => nodes != null && (nodes.Length == 0 || nodes[0] is DsDocumentNode);
/// <summary> /// Constructor /// </summary> /// <param name="node">Node</param> public DocumentTreeNodeActivatedEventArgs(DocumentTreeNodeData node) => Node = node ?? throw new ArgumentNullException(nameof(node));
internal static void Execute(Lazy<IMethodAnnotations> methodAnnotations, Lazy<IUndoCommandService> undoCommandService, IAppService appService, DocumentTreeNodeData[] nodes, uint[] offsets = null) { if (!CanExecute(nodes)) return; var methodNode = (MethodNode)nodes[0]; var module = nodes[0].GetModule(); Debug.Assert(module != null); if (module == null) throw new InvalidOperationException(); var data = new MethodBodyVM(new MethodBodyOptions(methodNode.MethodDef), module, appService.DecompilerService, methodNode.MethodDef.DeclaringType, methodNode.MethodDef); var win = new MethodBodyDlg(); win.DataContext = data; win.Owner = appService.MainWindow; win.Title = string.Format("{0} - {1}", win.Title, methodNode.ToString()); if (data.IsCilBody && offsets != null) data.CilBodyVM.Select(offsets); if (win.ShowDialog() != true) return; undoCommandService.Value.Add(new EditMethodBodyILCommand(methodAnnotations.Value, methodNode, data.CreateMethodBodyOptions())); }
static void Execute(Lazy<IUndoCommandService> undoCommandService, IAppService appService, DocumentTreeNodeData[] nodes) { if (!CanExecute(nodes)) return; var ownerNode = nodes[0]; if (!(ownerNode is TypeNode)) ownerNode = (DocumentTreeNodeData)ownerNode.TreeNode.Parent.Data; var typeNode = ownerNode as TypeNode; Debug.Assert(typeNode != null); if (typeNode == null) throw new InvalidOperationException(); var module = typeNode.GetModule(); Debug.Assert(module != null); if (module == null) throw new InvalidOperationException(); bool isInstance = !(typeNode.TypeDef.IsAbstract && typeNode.TypeDef.IsSealed); var sig = isInstance ? MethodSig.CreateInstance(module.CorLibTypes.Void) : MethodSig.CreateStatic(module.CorLibTypes.Void); var options = MethodDefOptions.Create("MyMethod", sig); if (typeNode.TypeDef.IsInterface) options.Attributes |= MethodAttributes.Abstract | MethodAttributes.Virtual | MethodAttributes.NewSlot; var data = new MethodOptionsVM(options, module, appService.DecompilerService, typeNode.TypeDef, null); var win = new MethodOptionsDlg(); win.Title = dnSpy_AsmEditor_Resources.CreateMethodCommand2; win.DataContext = data; win.Owner = appService.MainWindow; if (win.ShowDialog() != true) return; var cmd = new CreateMethodDefCommand(typeNode, data.CreateMethodDefOptions()); undoCommandService.Value.Add(cmd); appService.DocumentTabService.FollowReference(cmd.methodNode); }
static string GetHeader(DocumentTreeNodeData[] nodes) { if (nodes.Length == 1) return string.Format(dnSpy_AsmEditor_Resources.DeleteX, UIUtilities.EscapeMenuItemHeader(nodes[0].ToString())); return string.Format(dnSpy_AsmEditor_Resources.DeleteEvents, nodes.Length); }
HashSet<object> GetDocuments(DocumentTreeNodeData[] nodes) { var hash = new HashSet<object>(); foreach (var node in nodes) { var fileNode = node.GetDocumentNode(); if (fileNode == null) continue; // Removed nodes could still be used, don't use them. var topNode = fileNode.GetTopNode(); if (topNode == null || topNode.TreeNode.Parent == null) continue; bool added = false; if (fileNode.Document.ModuleDef != null) { var file = fileNode.Document; var uo = undoCommandService.Value.GetUndoObject(file); if (undoCommandService.Value.IsModified(uo)) { hash.Add(file); added = true; } } var doc = hexBufferService.Value.TryGet(fileNode.Document.Filename); if (doc != null) { var uo = undoCommandService.Value.GetUndoObject(doc); if (undoCommandService.Value.IsModified(uo)) { hash.Add(doc); added = true; } } // If nothing was modified, just include the selected module if (!added && fileNode.Document.ModuleDef != null) hash.Add(fileNode.Document); } return new HashSet<object>(undoCommandService.Value.GetUniqueDocuments(hash)); }
static void Execute(Lazy<IUndoCommandService> undoCommandService, DocumentTreeNodeData[] nodes) { if (!CanExecute(nodes)) return; if (!AskDeleteDef(dnSpy_AsmEditor_Resources.AskDeleteMethod)) return; var methodNodes = nodes.Cast<MethodNode>().ToArray(); undoCommandService.Value.Add(new DeleteMethodDefCommand(methodNodes)); }
/// <summary> /// Constructor /// </summary> /// <param name="node">Node</param> public DocumentTreeNodeActivatedEventArgs(DocumentTreeNodeData node) { if (node == null) throw new ArgumentNullException(nameof(node)); Node = node; }
static bool CanExecute(EditCodeVMCreator editCodeVMCreator, DocumentTreeNodeData[] nodes) => editCodeVMCreator.CanCreate(CompilationKind.AddClass) && nodes.Length == 1;
static void Execute(EditCodeVMCreator editCodeVMCreator, Lazy<IAddUpdatedNodesHelperProvider> addUpdatedNodesHelperProvider, Lazy<IUndoCommandService> undoCommandService, IAppService appService, DocumentTreeNodeData[] nodes) { if (!CanExecute(editCodeVMCreator, nodes)) return; var asmNode = nodes[0] as AssemblyDocumentNode; ModuleDocumentNode modNode; if (asmNode != null) { asmNode.TreeNode.EnsureChildrenLoaded(); modNode = asmNode.TreeNode.DataChildren.FirstOrDefault() as ModuleDocumentNode; } else modNode = nodes[0].GetModuleNode(); Debug.Assert(modNode != null); if (modNode == null) return; var module = modNode.Document.ModuleDef; Debug.Assert(module != null); if (module == null) throw new InvalidOperationException(); if (module.IsManifestModule) asmNode = modNode.TreeNode.Parent?.Data as AssemblyDocumentNode; else asmNode = null; var vm = editCodeVMCreator.CreateAddClass(module); var win = new EditCodeDlg(); win.DataContext = vm; win.Owner = appService.MainWindow; win.Title = string.Format("{0} - {1}", dnSpy_AsmEditor_Resources.EditCodeAddClass, asmNode?.ToString() ?? modNode.ToString()); if (win.ShowDialog() != true) { vm.Dispose(); return; } Debug.Assert(vm.Result != null); undoCommandService.Value.Add(new AddClassCommand(addUpdatedNodesHelperProvider, modNode, vm.Result)); vm.Dispose(); }
static void Execute(Lazy<IUndoCommandService> undoCommandService, IAppService appService, DocumentTreeNodeData[] nodes) { if (!CanExecute(nodes)) return; var eventNode = (EventNode)nodes[0]; var module = nodes[0].GetModule(); Debug.Assert(module != null); if (module == null) throw new InvalidOperationException(); var data = new EventOptionsVM(new EventDefOptions(eventNode.EventDef), module, appService.DecompilerService, eventNode.EventDef.DeclaringType); var win = new EventOptionsDlg(); win.DataContext = data; win.Owner = appService.MainWindow; if (win.ShowDialog() != true) return; undoCommandService.Value.Add(new EventDefSettingsCommand(eventNode, data.CreateEventDefOptions())); }
MethodDefSettingsCommand(MethodNode methodNode, MethodDefOptions options) { this.methodNode = methodNode; newOptions = options; origOptions = new MethodDefOptions(methodNode.MethodDef); origParentNode = (DocumentTreeNodeData)methodNode.TreeNode.Parent.Data; origParentChildIndex = origParentNode.TreeNode.Children.IndexOf(methodNode.TreeNode); Debug.Assert(origParentChildIndex >= 0); if (origParentChildIndex < 0) throw new InvalidOperationException(); nameChanged = origOptions.Name != newOptions.Name; if (nameChanged) memberRefInfos = RefFinder.FindMemberRefsToThisModule(methodNode.GetModule()).Where(a => RefFinder.MethodEqualityComparerInstance.Equals(a, methodNode.MethodDef)).Select(a => new Field.MemberRefInfo(a)).ToArray(); }
EventDefSettingsCommand(EventNode eventNode, EventDefOptions options) { this.eventNode = eventNode; newOptions = options; origOptions = new EventDefOptions(eventNode.EventDef); origParentNode = (DocumentTreeNodeData)eventNode.TreeNode.Parent.Data; origParentChildIndex = origParentNode.TreeNode.Children.IndexOf(eventNode.TreeNode); Debug.Assert(origParentChildIndex >= 0); if (origParentChildIndex < 0) throw new InvalidOperationException(); nameChanged = origOptions.Name != newOptions.Name; }
static void Execute(Lazy<IUndoCommandService> undoCommandService, IAppService appService, DocumentTreeNodeData[] nodes) { if (!CanExecute(nodes)) return; var asmNode = (AssemblyDocumentNode)nodes[0]; var module = asmNode.Document.ModuleDef; var data = new AssemblyOptionsVM(new AssemblyOptions(asmNode.Document.AssemblyDef), module, appService.DecompilerService); var win = new AssemblyOptionsDlg(); win.DataContext = data; win.Owner = appService.MainWindow; if (win.ShowDialog() != true) return; undoCommandService.Value.Add(new AssemblySettingsCommand(asmNode, data.CreateAssemblyOptions())); }
static bool CanExecute(DocumentTreeNodeData[] nodes) => nodes.Length > 0 && nodes.All(n => n is EventNode);
public AsmEditorContext(DocumentTreeNodeData[] nodes) { Nodes = nodes; }
static bool CanExecute(DocumentTreeNodeData[] nodes) => nodes.Length == 1 && nodes[0] is MethodNode;
public virtual DocumentTreeNodeFilterResult GetResultOther(DocumentTreeNodeData node) => filter.GetResultOther(node);
public DocumentTabContentFactoryContext(DocumentTreeNodeData[] nodes) { if (nodes == null) throw new InvalidOperationException(); Nodes = nodes; }
static void Execute(Lazy<IUndoCommandService> undoCommandService, DocumentTreeNodeData[] nodes) { if (!CanExecute(nodes)) return; var eventNodes = nodes.Cast<EventNode>().ToArray(); undoCommandService.Value.Add(new DeleteEventDefCommand(eventNodes)); }
public override DocumentTreeNodeFilterResult GetResultOther(DocumentTreeNodeData node) { bool isMatch = (flags & VisibleMembersFlags.Other) != 0; if (!isMatch) return new DocumentTreeNodeFilterResult(FilterType.Hide, isMatch); return new DocumentTreeNodeFilterResult(FilterType.Visible, isMatch); }
static void Execute(Lazy<IUndoCommandService> undoCommandService, IAppService appService, DocumentTreeNodeData[] nodes) { if (!CanExecute(nodes)) return; var newModule = new ModuleDefUser(); var data = new AssemblyOptionsVM(AssemblyOptions.Create("MyAssembly"), newModule, appService.DecompilerService); data.CanShowClrVersion = true; var win = new AssemblyOptionsDlg(); win.Title = dnSpy_AsmEditor_Resources.CreateAssemblyCommand2; win.DataContext = data; win.Owner = appService.MainWindow; if (win.ShowDialog() != true) return; var cmd = new CreateAssemblyCommand(undoCommandService.Value, appService.DocumentTreeView, newModule, data.CreateAssemblyOptions()); undoCommandService.Value.Add(cmd); appService.DocumentTabService.FollowReference(cmd.fileNodeCreator.DocumentNode); }