TypeDefSettingsCommand(ModuleDef module, ITypeNode typeNode, TypeDefOptions options) { this.module = module; this.typeNode = typeNode; this.newOptions = options; this.origOptions = new TypeDefOptions(typeNode.TypeDef); this.origParentNode = (IFileTreeNodeData)typeNode.TreeNode.Parent.Data; this.origParentChildIndex = this.origParentNode.TreeNode.Children.IndexOf(typeNode.TreeNode); Debug.Assert(this.origParentChildIndex >= 0); if (this.origParentChildIndex < 0) { throw new InvalidOperationException(); } this.nameChanged = origOptions.Name != newOptions.Name; if (this.origParentNode is INamespaceNode) { var modNode = (IModuleFileNode)this.origParentNode.TreeNode.Parent.Data; if (newOptions.Namespace != origOptions.Namespace) { this.nsNodeCreator = new NamespaceNodeCreator(newOptions.Namespace, modNode); } } if (this.nameChanged || origOptions.Namespace != newOptions.Namespace) { this.typeRefInfos = RefFinder.FindTypeRefsToThisModule(module).Where(a => RefFinder.TypeEqualityComparerInstance.Equals(a, typeNode.TypeDef)).Select(a => new TypeRefInfo(a)).ToArray(); } }
FileTabReferenceResult Create(IFileTreeNodeData node) { var content = fileTabContentFactoryManager.CreateTabContent(new IFileTreeNodeData[] { node }); if (content == null) return null; return new FileTabReferenceResult(content); }
RenameNamespaceCommand(string newName, INamespaceNode nsNode) { this.newName = newName; this.origName = nsNode.Name; this.nsNode = nsNode; this.existingNsNode = (INamespaceNode)nsNode.TreeNode.Parent.DataChildren.FirstOrDefault(a => a is INamespaceNode && newName == ((INamespaceNode)a).Name); var module = nsNode.GetModule(); Debug.Assert(module != null); if (module == null) { throw new InvalidOperationException(); } this.origParentNode = (IFileTreeNodeData)nsNode.TreeNode.Parent.Data; this.origParentChildIndex = this.origParentNode.TreeNode.Children.IndexOf(nsNode.TreeNode); Debug.Assert(this.origParentChildIndex >= 0); if (this.origParentChildIndex < 0) { throw new InvalidOperationException(); } // Make sure the exact same namespace names are restored if we undo. The names are UTF8 // strings, but not necessarily canonicalized if it's an obfuscated assembly. nsNode.TreeNode.EnsureChildrenLoaded(); this.origChildren = nsNode.TreeNode.DataChildren.Cast <ITypeNode>().ToArray(); this.typeNamespaces = new UTF8String[nsNode.TreeNode.Children.Count]; for (int i = 0; i < this.typeNamespaces.Length; i++) { this.typeNamespaces[i] = origChildren[i].TypeDef.Namespace; } this.typeRefInfos = GetTypeRefInfos(module, new[] { nsNode }); }
/// <summary> /// Constructor /// </summary> /// <param name="node">Node</param> public FileTreeNodeActivatedEventArgs(IFileTreeNodeData node) { if (node == null) { throw new ArgumentNullException(); } this.Node = node; }
IFileTreeNodeData[] GetChildren(IFileTreeNodeData node) { var n = node; return((IFileTreeNodeData[])execInThread(() => { n.TreeNode.EnsureChildrenLoaded(); return n.TreeNode.DataChildren.OfType <IFileTreeNodeData>().ToArray(); })); }
NodeTabSaver(IMessageBoxManager messageBoxManager, IFileTab tab, IFileTreeNodeDecompiler fileTreeNodeDecompiler, ILanguage language, ITextEditorUIContext uiContext, IFileTreeNodeData[] nodes) { this.messageBoxManager = messageBoxManager; this.tab = tab; this.fileTreeNodeDecompiler = fileTreeNodeDecompiler; this.language = language; this.uiContext = uiContext; this.nodes = nodes; }
public override FileTreeNodeFilterResult GetResult(IFileTreeNodeData node) { bool isMatch = (flags & VisibleMembersFlags.Other) != 0; if (!isMatch) { return(new FileTreeNodeFilterResult(FilterType.Hide, isMatch)); } return(new FileTreeNodeFilterResult(FilterType.Visible, isMatch)); }
public IFileTabContent CreateTabContent(IFileTreeNodeData[] nodes) { var context = new FileTabContentFactoryContext(nodes); foreach (var factory in tabContentFactories) { var tabContent = factory.Value.Create(context); if (tabContent != null) return tabContent; } return null; }
public IFileTabContent Deserialize(Guid guid, ISettingsSection section, IFileTreeNodeData[] nodes) { var context = new FileTabContentFactoryContext(nodes); foreach (var factory in tabContentFactories) { var content = factory.Value.Deserialize(guid, section, context); if (content != null) return content; } return null; }
FileTabReferenceResult Create(IFileTreeNodeData node) { var content = fileTabContentFactoryManager.CreateTabContent(new IFileTreeNodeData[] { node }); if (content == null) { return(null); } return(new FileTabReferenceResult(content)); }
void DecompileNode(IDecompileNodeContext context, IFileTreeNodeData node) { foreach (var d in decompileNodes) { if (d.Decompile(context, node)) { return; } } Debug.Fail("Missing decompiler"); }
public static SerializedPath Create(IFileTreeNodeData node) { var path = new SerializedPath(); while (node != null && node.TreeNode.Parent != null) { path.Names.Add(node.NodePathName); var parent = node.TreeNode.Parent; node = parent.Data as IFileTreeNodeData; } path.Names.Reverse(); return path; }
public bool Decompile(IDecompileNodeContext context, IFileTreeNodeData node) { var msgNode = node as SomeMessageNode; if (msgNode == null) { return(false); } context.Language.WriteCommentLine(context.Output, "The secret message has been decrypted."); context.Language.WriteCommentLine(context.Output, string.Format("The message is: {0}", msgNode.Message)); return(true); }
CreateTypeDefCommand(IList <TypeDef> ownerList, IFileTreeNodeData ownerNode, TypeDefOptions options) { this.ownerList = ownerList; var modNode = ownerNode.GetModuleNode(); Debug.Assert(modNode != null); if (modNode == null) { throw new InvalidOperationException(); } this.nsNodeCreator = new NamespaceNodeCreator(options.Namespace, modNode); this.typeNode = modNode.Context.FileTreeView.Create(options.CreateTypeDef(modNode.DnSpyFile.ModuleDef)); }
void DecompileUnknown(IFileTreeNodeData node) { var decompileSelf = node as IDecompileSelf; if (decompileSelf != null && decompileNodeContext != null) { if (decompileSelf.Decompile(decompileNodeContext)) { return; } } language.WriteCommentLine(output, NameUtils.CleanName(node.ToString(language))); }
public bool RaiseNodeActivated(IFileTreeNodeData node) { if (node == null) { throw new ArgumentNullException(nameof(node)); } if (NodeActivated == null) { return(false); } var e = new FileTreeNodeActivatedEventArgs(node); NodeActivated(this, e); return(e.Handled); }
PropertyDefSettingsCommand(IPropertyNode propNode, PropertyDefOptions options) { this.propNode = propNode; this.newOptions = options; this.origOptions = new PropertyDefOptions(propNode.PropertyDef); this.origParentNode = (IFileTreeNodeData)propNode.TreeNode.Parent.Data; this.origParentChildIndex = this.origParentNode.TreeNode.Children.IndexOf(propNode.TreeNode); Debug.Assert(this.origParentChildIndex >= 0); if (this.origParentChildIndex < 0) { throw new InvalidOperationException(); } this.nameChanged = origOptions.Name != newOptions.Name; }
EventDefSettingsCommand(IEventNode eventNode, EventDefOptions options) { this.eventNode = eventNode; this.newOptions = options; this.origOptions = new EventDefOptions(eventNode.EventDef); this.origParentNode = (IFileTreeNodeData)eventNode.TreeNode.Parent.Data; this.origParentChildIndex = this.origParentNode.TreeNode.Children.IndexOf(eventNode.TreeNode); Debug.Assert(this.origParentChildIndex >= 0); if (this.origParentChildIndex < 0) { throw new InvalidOperationException(); } this.nameChanged = origOptions.Name != newOptions.Name; }
static NodeType GetNodeType(IFileTreeNodeData node) { NodeType nodeType; var type = node.GetType(); lock (lockObj) { if (toNodeType.TryGetValue(type, out nodeType)) { return(nodeType); } nodeType = GetNodeTypeSlow(node); toNodeType.Add(type, nodeType); } return(nodeType); }
public void Decompile(IDecompileNodeContext decompileNodeContext, IFileTreeNodeData[] nodes) { foreach (var dc in decompileNodeCollections) { if (dc.Decompile(decompileNodeContext, nodes)) return; } if (nodes.Length == 1) { var ds = nodes[0] as IDecompileSelf; if (ds != null && ds.Decompile(decompileNodeContext)) return; } for (int i = 0; i < nodes.Length; i++) { decompileNodeContext.DecompilationContext.CancellationToken.ThrowIfCancellationRequested(); if (i > 0) decompileNodeContext.Output.WriteLine(); DecompileNode(decompileNodeContext, nodes[i]); } }
MethodDefSettingsCommand(IMethodNode methodNode, MethodDefOptions options) { this.methodNode = methodNode; this.newOptions = options; this.origOptions = new MethodDefOptions(methodNode.MethodDef); this.origParentNode = (IFileTreeNodeData)methodNode.TreeNode.Parent.Data; this.origParentChildIndex = this.origParentNode.TreeNode.Children.IndexOf(methodNode.TreeNode); Debug.Assert(this.origParentChildIndex >= 0); if (this.origParentChildIndex < 0) { throw new InvalidOperationException(); } this.nameChanged = origOptions.Name != newOptions.Name; if (this.nameChanged) { this.memberRefInfos = RefFinder.FindMemberRefsToThisModule(methodNode.GetModule()).Where(a => RefFinder.MethodEqualityComparerInstance.Equals(a, methodNode.MethodDef)).Select(a => new Field.MemberRefInfo(a)).ToArray(); } }
static void Filter(IFileTreeNodeData 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 FileTreeNodeData; 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 void Execute(Lazy<IUndoCommandManager> undoCommandManager, IAppWindow appWindow, IFileTreeNodeData[] nodes) { if (!CanExecute(nodes)) return; var fieldNode = (IFieldNode)nodes[0]; var module = nodes[0].GetModule(); Debug.Assert(module != null); if (module == null) throw new InvalidOperationException(); var data = new FieldOptionsVM(new FieldDefOptions(fieldNode.FieldDef), module, appWindow.LanguageManager, fieldNode.FieldDef.DeclaringType); var win = new FieldOptionsDlg(); win.DataContext = data; win.Owner = appWindow.MainWindow; if (win.ShowDialog() != true) return; undoCommandManager.Value.Add(new FieldDefSettingsCommand(fieldNode, data.CreateFieldDefOptions())); }
FieldDefSettingsCommand(IFieldNode fieldNode, FieldDefOptions options) { this.fieldNode = fieldNode; this.newOptions = options; this.origOptions = new FieldDefOptions(fieldNode.FieldDef); this.origParentNode = (IFileTreeNodeData)fieldNode.TreeNode.Parent.Data; this.origParentChildIndex = this.origParentNode.TreeNode.Children.IndexOf(fieldNode.TreeNode); Debug.Assert(this.origParentChildIndex >= 0); if (this.origParentChildIndex < 0) throw new InvalidOperationException(); this.nameChanged = origOptions.Name != newOptions.Name; if (this.nameChanged) this.memberRefInfos = RefFinder.FindMemberRefsToThisModule(fieldNode.GetModule()).Where(a => RefFinder.FieldEqualityComparerInstance.Equals(a, fieldNode.FieldDef)).Select(a => new MemberRefInfo(a)).ToArray(); }
static void Execute(Lazy<IUndoCommandManager> undoCommandManager, IAppWindow appWindow, IFileTreeNodeData[] nodes) { if (!CanExecute(nodes)) return; var imgRsrcElNode = (IImageResourceElementNode)nodes[0]; var options = new ResourceElementOptions(imgRsrcElNode.ResourceElement); var data = new ImageResourceElementVM(options); var win = new ImageResourceElementDlg(); win.Title = dnSpy_AsmEditor_Resources.EditResourceCommand2; win.DataContext = data; win.Owner = appWindow.MainWindow; if (win.ShowDialog() != true) return; var opts = data.CreateResourceElementOptions(); string error; try { error = imgRsrcElNode.CheckCanUpdateData(opts.Create()); } catch (Exception ex) { error = string.Format(dnSpy_AsmEditor_Resources.Error_NewResourceDataMustBeImage, ex.Message); } if (!string.IsNullOrEmpty(error)) { Shared.App.MsgBox.Instance.Show(error); return; } undoCommandManager.Value.Add(new ImageResourceElementSettingsCommand(imgRsrcElNode, opts)); }
static bool CanExecute(IFileTreeNodeData[] nodes) { return nodes.Length == 1 && nodes[0] is IFieldNode; }
static void Execute(Lazy<IUndoCommandManager> undoCommandManager, IFileTreeNodeData[] nodes) { if (!CanExecute(nodes)) return; var rsrcNodes = nodes.Cast<IResourceElementNode>().ToArray(); undoCommandManager.Value.Add(new DeleteResourceElementCommand(rsrcNodes)); }
public virtual FileTreeNodeFilterResult GetResult(IFileTreeNodeData node) => this.filter.GetResult(node);
public bool Decompile(IDecompileNodeContext context, IFileTreeNodeData node) { new NodeDecompiler(a => context.ExecuteInUIThread(() => a()), context.Output, context.Language, context.DecompilationContext, context).Decompile(node); return(true); }
public virtual FileTreeNodeFilterResult GetResult(IFileTreeNodeData node) => new FileTreeNodeFilterResult();
public virtual FileTreeNodeFilterResult GetResult(IFileTreeNodeData node) { return(this.filter.GetResult(node)); }
static bool CanExecute(IFileTreeNodeData[] nodes) { return nodes.Length == 1 && nodes[0] is ISerializedImageListStreamerResourceElementNode; }
public void Decompile(IFileTreeNodeData node) { var nodeType = GetNodeType(node); switch (nodeType) { case NodeType.Unknown: DecompileUnknown(node); break; case NodeType.Assembly: language.Decompile(((IAssemblyFileNode)node).DnSpyFile.AssemblyDef, output, decompilationContext); break; case NodeType.Module: language.Decompile(((IModuleFileNode)node).DnSpyFile.ModuleDef, output, decompilationContext); break; case NodeType.Type: language.Decompile(((ITypeNode)node).TypeDef, output, decompilationContext); break; case NodeType.Method: language.Decompile(((IMethodNode)node).MethodDef, output, decompilationContext); break; case NodeType.Field: language.Decompile(((IFieldNode)node).FieldDef, output, decompilationContext); break; case NodeType.Property: language.Decompile(((IPropertyNode)node).PropertyDef, output, decompilationContext); break; case NodeType.Event: language.Decompile(((IEventNode)node).EventDef, output, decompilationContext); break; case NodeType.AssemblyRef: Decompile((IAssemblyReferenceNode)node); break; case NodeType.BaseTypeFolder: Decompile((IBaseTypeFolderNode)node); break; case NodeType.BaseType: Decompile((IBaseTypeNode)node); break; case NodeType.DerivedType: Decompile((IDerivedTypeNode)node); break; case NodeType.DerivedTypesFolder: Decompile((IDerivedTypesFolderNode)node); break; case NodeType.ModuleRef: Decompile((IModuleReferenceNode)node); break; case NodeType.Namespace: Decompile((INamespaceNode)node); break; case NodeType.PEFile: Decompile((IPEFileNode)node); break; case NodeType.ReferencesFolder: Decompile((IReferencesFolderNode)node); break; case NodeType.ResourcesFolder: Decompile((IResourcesFolderNode)node); break; case NodeType.Resource: Decompile((IResourceNode)node); break; case NodeType.ResourceElement: Decompile((IResourceElementNode)node); break; case NodeType.ResourceElementSet: Decompile((IResourceElementSetNode)node); break; case NodeType.UnknownFile: Decompile((IUnknownFileNode)node); break; case NodeType.Message: Decompile((IMessageNode)node); break; default: Debug.Fail(string.Format("Unknown NodeType: {0}", nodeType)); goto case NodeType.Unknown; } }
static void Execute(Lazy<IUndoCommandManager> undoCommandManager, IAppWindow appWindow, IFileTreeNodeData[] nodes) { if (!CanExecute(nodes)) return; var imgNode = (ISerializedImageListStreamerResourceElementNode)nodes[0]; var options = new ImageListOptions(imgNode.ImageListOptions); var data = new ImageListVM(options); var win = new ImageListDlg(); win.Title = dnSpy_AsmEditor_Resources.EditResourceCommand2; win.DataContext = data; win.Owner = appWindow.MainWindow; if (win.ShowDialog() != true) return; var listOpts = data.CreateImageListOptions(); if (listOpts.ImageSources.Count == 0) { Shared.App.MsgBox.Instance.Show(dnSpy_AsmEditor_Resources.Error_EmptyImageList); return; } ResourceElementOptions opts = null; string error; try { opts = new ResourceElementOptions(SerializedImageListStreamerUtils.Serialize(listOpts)); error = imgNode.CheckCanUpdateData(opts.Create()); } catch (Exception ex) { error = string.Format(dnSpy_AsmEditor_Resources.Error_CouldNotSerializeImages, ex.Message); } if (!string.IsNullOrEmpty(error)) { Shared.App.MsgBox.Instance.Show(error); return; } undoCommandManager.Value.Add(new SerializedImageListStreamerResourceElementSettingsCommand(imgNode, opts)); }
public static bool CanExecuteResourceListCommand(IFileTreeNodeData[] nodes) { return GetResourceListTreeNode(nodes) != null; }
/// <summary> /// Constructor /// </summary> /// <param name="node">Node</param> public FileTreeNodeActivatedEventArgs(IFileTreeNodeData node) { if (node == null) throw new ArgumentNullException(); this.Node = node; }
static NodeType GetNodeTypeSlow(IFileTreeNodeData node) { if (node is IAssemblyFileNode) return NodeType.Assembly; if (node is IModuleFileNode) return NodeType.Module; if (node is ITypeNode) return NodeType.Type; if (node is IMethodNode) return NodeType.Method; if (node is IFieldNode) return NodeType.Field; if (node is IPropertyNode) return NodeType.Property; if (node is IEventNode) return NodeType.Event; if (node is IAssemblyReferenceNode) return NodeType.AssemblyRef; if (node is IBaseTypeFolderNode) return NodeType.BaseTypeFolder; if (node is IBaseTypeNode) return NodeType.BaseType; if (node is IDerivedTypeNode) return NodeType.DerivedType; if (node is IDerivedTypesFolderNode) return NodeType.DerivedTypesFolder; if (node is IModuleReferenceNode) return NodeType.ModuleRef; if (node is INamespaceNode) return NodeType.Namespace; if (node is IPEFileNode) return NodeType.PEFile; if (node is IReferencesFolderNode) return NodeType.ReferencesFolder; if (node is IResourcesFolderNode) return NodeType.ResourcesFolder; if (node is IResourceNode) return NodeType.Resource; if (node is IResourceElementNode) return NodeType.ResourceElement; if (node is IResourceElementSetNode) return NodeType.ResourceElementSet; if (node is IUnknownFileNode) return NodeType.UnknownFile; if (node is IMessageNode) return NodeType.Message; return NodeType.Unknown; }
static bool CanExecute(IFileTreeNodeData[] nodes) { return nodes.Length == 1 && nodes[0] is IImageResourceElementNode; }
IFileTreeNodeData[] GetChildren(IFileTreeNodeData node) { var n = node; return (IFileTreeNodeData[])execInThread(() => { n.TreeNode.EnsureChildrenLoaded(); return n.TreeNode.DataChildren.OfType<IFileTreeNodeData>().ToArray(); }); }
static void Execute(Lazy<IUndoCommandManager> undoCommandManager, IAppWindow appWindow, IResourceNodeFactory resourceNodeFactory, IFileTreeNodeData[] nodes) { if (!CanExecute(nodes)) return; var rsrcListNode = ResUtils.GetResourceListTreeNode(nodes); var module = nodes[0].GetModule(); Debug.Assert(module != null); if (module == null) throw new InvalidOperationException(); var options = new ResourceOptions { ResourceType = ResourceType.Embedded, Name = "my.resources", Attributes = ManifestResourceAttributes.Public, }; var data = new ResourceVM(options, module); var win = new ResourceDlg(); win.Title = dnSpy_AsmEditor_Resources.CreateMultiFileResourceCommand2; win.DataContext = data; win.Owner = appWindow.MainWindow; if (win.ShowDialog() != true) return; var outStream = new MemoryStream(); ResourceWriter.Write(module, outStream, new ResourceElementSet()); var er = new EmbeddedResource(data.Name, outStream.ToArray(), data.Attributes); var treeView = appWindow.FileTreeView.TreeView; var treeNodeGroup = appWindow.FileTreeView.FileTreeNodeGroups.GetGroup(FileTreeNodeGroupType.ResourceTreeNodeGroup); var node = (IResourceNode)treeView.Create(resourceNodeFactory.Create(module, er, treeNodeGroup)).Data; undoCommandManager.Value.Add(new CreateMultiFileResourceCommand(rsrcListNode, node)); appWindow.FileTabManager.FollowReference(node); }
static bool CanExecute(IFileTreeNodeData[] nodes) { return nodes.Length > 0 && nodes.All(n => n is IResourceElementNode); }
public virtual FileTreeNodeFilterResult GetResult(IFileTreeNodeData node) { return(new FileTreeNodeFilterResult()); }
static string GetHeader(IFileTreeNodeData[] nodes) { if (nodes.Length == 1) return string.Format(dnSpy_AsmEditor_Resources.DeleteX, UIUtils.EscapeMenuItemHeader(nodes[0].ToString())); return string.Format(dnSpy_AsmEditor_Resources.DeleteFieldsCommand, nodes.Length); }
static NodeType GetNodeType(IFileTreeNodeData node) { NodeType nodeType; var type = node.GetType(); lock (lockObj) { if (toNodeType.TryGetValue(type, out nodeType)) return nodeType; nodeType = GetNodeTypeSlow(node); toNodeType.Add(type, nodeType); } return nodeType; }
static bool CanExecute(IFileTreeNodeData[] nodes) { return nodes.Length > 0 && nodes.All(n => n is IFieldNode); }
void DecompileUnknown(IFileTreeNodeData node) { var decompileSelf = node as IDecompileSelf; if (decompileSelf != null && decompileNodeContext != null) { if (decompileSelf.Decompile(decompileNodeContext)) return; } language.WriteCommentLine(output, node.ToString(language)); }
static void Execute(Lazy<IUndoCommandManager> undoCommandManager, IFileTreeNodeData[] nodes) { if (!CanExecute(nodes)) return; if (!Method.DeleteMethodDefCommand.AskDeleteDef(dnSpy_AsmEditor_Resources.AskDeleteField)) return; var fieldNodes = nodes.Cast<IFieldNode>().ToArray(); undoCommandManager.Value.Add(new DeleteFieldDefCommand(fieldNodes)); }
static bool CanExecute(IFileTreeNodeData[] nodes) { return nodes.Length == 1 && (nodes[0] is ITypeNode || (nodes[0].TreeNode.Parent != null && nodes[0].TreeNode.Parent.Data is ITypeNode)); }
public static IResourcesFolderNode GetResourceListTreeNode(IFileTreeNodeData[] nodes) { if (nodes.Length != 1) return null; var rsrcListNode = nodes[0] as IResourcesFolderNode; if (rsrcListNode != null) return rsrcListNode; rsrcListNode = nodes[0].TreeNode.Parent == null ? null : nodes[0].TreeNode.Parent.Data as IResourcesFolderNode; if (rsrcListNode != null) return rsrcListNode; var modNode = nodes[0] as IModuleFileNode; if (modNode == null) return null; modNode.TreeNode.EnsureChildrenLoaded(); rsrcListNode = (IResourcesFolderNode)modNode.TreeNode.DataChildren.FirstOrDefault(a => a is IResourcesFolderNode); if (rsrcListNode == null) // If not a module node return null; rsrcListNode.TreeNode.EnsureChildrenLoaded(); if (rsrcListNode.TreeNode.Children.Count == 0) return rsrcListNode; return null; }
static void Execute(Lazy<IUndoCommandManager> undoCommandManager, IAppWindow appWindow, IFileTreeNodeData[] nodes) { if (!CanExecute(nodes)) return; var ownerNode = nodes[0]; if (!(ownerNode is ITypeNode)) ownerNode = (IFileTreeNodeData)ownerNode.TreeNode.Parent.Data; var typeNode = ownerNode as ITypeNode; Debug.Assert(typeNode != null); if (typeNode == null) throw new InvalidOperationException(); var module = typeNode.GetModule(); Debug.Assert(module != null); if (module == null) throw new InvalidOperationException(); FieldDefOptions options; var type = typeNode.TypeDef; if (type.IsEnum) { var ts = type.GetEnumUnderlyingType(); if (ts != null) { options = FieldDefOptions.Create("MyField", new FieldSig(new ValueTypeSig(typeNode.TypeDef))); options.Constant = module.UpdateRowId(new ConstantUser(ModelUtils.GetDefaultValue(ts), ts.RemovePinnedAndModifiers().GetElementType())); options.Attributes |= FieldAttributes.Literal | FieldAttributes.Static | FieldAttributes.HasDefault; } else { options = FieldDefOptions.Create("value__", new FieldSig(module.CorLibTypes.Int32)); options.Attributes |= FieldAttributes.SpecialName | FieldAttributes.RTSpecialName; } } else if (type.IsAbstract && type.IsSealed) { options = FieldDefOptions.Create("MyField", new FieldSig(module.CorLibTypes.Int32)); options.Attributes |= FieldAttributes.Static; } else options = FieldDefOptions.Create("MyField", new FieldSig(module.CorLibTypes.Int32)); var data = new FieldOptionsVM(options, module, appWindow.LanguageManager, type); var win = new FieldOptionsDlg(); win.Title = dnSpy_AsmEditor_Resources.CreateFieldCommand2; win.DataContext = data; win.Owner = appWindow.MainWindow; if (win.ShowDialog() != true) return; var cmd = new CreateFieldDefCommand(typeNode, data.CreateFieldDefOptions()); undoCommandManager.Value.Add(cmd); appWindow.FileTabManager.FollowReference(cmd.fieldNode); }
static NodeType GetNodeTypeSlow(IFileTreeNodeData node) { if (node is IAssemblyFileNode) { return(NodeType.Assembly); } if (node is IModuleFileNode) { return(NodeType.Module); } if (node is ITypeNode) { return(NodeType.Type); } if (node is IMethodNode) { return(NodeType.Method); } if (node is IFieldNode) { return(NodeType.Field); } if (node is IPropertyNode) { return(NodeType.Property); } if (node is IEventNode) { return(NodeType.Event); } if (node is IAssemblyReferenceNode) { return(NodeType.AssemblyRef); } if (node is IBaseTypeFolderNode) { return(NodeType.BaseTypeFolder); } if (node is IBaseTypeNode) { return(NodeType.BaseType); } if (node is IDerivedTypeNode) { return(NodeType.DerivedType); } if (node is IDerivedTypesFolderNode) { return(NodeType.DerivedTypesFolder); } if (node is IModuleReferenceNode) { return(NodeType.ModuleRef); } if (node is INamespaceNode) { return(NodeType.Namespace); } if (node is IPEFileNode) { return(NodeType.PEFile); } if (node is IReferencesFolderNode) { return(NodeType.ReferencesFolder); } if (node is IResourcesFolderNode) { return(NodeType.ResourcesFolder); } if (node is IResourceNode) { return(NodeType.Resource); } if (node is IResourceElementNode) { return(NodeType.ResourceElement); } if (node is IResourceElementSetNode) { return(NodeType.ResourceElementSet); } if (node is IUnknownFileNode) { return(NodeType.UnknownFile); } if (node is IMessageNode) { return(NodeType.Message); } return(NodeType.Unknown); }
static void Execute(Lazy<IUndoCommandManager> undoCommandManager, IAppWindow appWindow, IResourceNodeFactory resourceNodeFactory, IFileTreeNodeData[] nodes) { if (!CanExecute(nodes)) return; var rsrcListNode = ResUtils.GetResourceListTreeNode(nodes); var module = nodes[0].GetModule(); Debug.Assert(module != null); if (module == null) throw new InvalidOperationException(); var dlg = new WF.OpenFileDialog { RestoreDirectory = true, Multiselect = true, }; if (dlg.ShowDialog() != WF.DialogResult.OK) return; var fnames = dlg.FileNames; if (fnames.Length == 0) return; var newNodes = new IResourceNode[fnames.Length]; var treeView = appWindow.FileTreeView.TreeView; var treeNodeGroup = appWindow.FileTreeView.FileTreeNodeGroups.GetGroup(FileTreeNodeGroupType.ResourceTreeNodeGroup); for (int i = 0; i < fnames.Length; i++) { var fn = fnames[i]; try { var rsrc = new EmbeddedResource(Path.GetFileName(fn), File.ReadAllBytes(fn), ManifestResourceAttributes.Public); newNodes[i] = (IResourceNode)treeView.Create(resourceNodeFactory.Create(module, rsrc, treeNodeGroup)).Data; } catch (Exception ex) { Shared.App.MsgBox.Instance.Show(string.Format(dnSpy_AsmEditor_Resources.Error_ReadingFiles, ex.Message)); return; } } undoCommandManager.Value.Add(new CreateFileResourceCommand(rsrcListNode, newNodes)); appWindow.FileTabManager.FollowReference(newNodes[0]); }
public virtual FileTreeNodeFilterResult GetResult(IFileTreeNodeData node) => new FileTreeNodeFilterResult(FilterType.Hide, false);
static bool CanExecute(IFileTreeNodeData[] nodes) { return ResUtils.CanExecuteResourceListCommand(nodes); }