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