Esempio n. 1
0
        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);
 }
Esempio n. 3
0
        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;
 }
Esempio n. 5
0
        IFileTreeNodeData[] GetChildren(IFileTreeNodeData node)
        {
            var n = node;

            return((IFileTreeNodeData[])execInThread(() => {
                n.TreeNode.EnsureChildrenLoaded();
                return n.TreeNode.DataChildren.OfType <IFileTreeNodeData>().ToArray();
            }));
        }
Esempio n. 6
0
 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;
 }
Esempio n. 7
0
        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));
        }
Esempio n. 11
0
 void DecompileNode(IDecompileNodeContext context, IFileTreeNodeData node)
 {
     foreach (var d in decompileNodes)
     {
         if (d.Decompile(context, node))
         {
             return;
         }
     }
     Debug.Fail("Missing decompiler");
 }
Esempio n. 12
0
		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;
		}
Esempio n. 13
0
        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);
        }
Esempio n. 14
0
        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));
        }
Esempio n. 15
0
        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)));
        }
Esempio n. 16
0
        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);
        }
Esempio n. 17
0
        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;
        }
Esempio n. 18
0
        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;
        }
Esempio n. 19
0
        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);
        }
Esempio n. 20
0
        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]);
            }
        }
Esempio n. 21
0
        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();
            }
        }
Esempio n. 22
0
        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;
            }
        }
Esempio n. 23
0
		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()));
		}
Esempio n. 24
0
		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();
		}
Esempio n. 25
0
		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));
		}
Esempio n. 26
0
		static bool CanExecute(IFileTreeNodeData[] nodes) {
			return nodes.Length == 1 &&
				nodes[0] is IFieldNode;
		}
Esempio n. 27
0
		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);
Esempio n. 29
0
 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();
Esempio n. 31
0
 public virtual FileTreeNodeFilterResult GetResult(IFileTreeNodeData node)
 {
     return(this.filter.GetResult(node));
 }
Esempio n. 32
0
		static bool CanExecute(IFileTreeNodeData[] nodes) {
			return nodes.Length == 1 &&
				nodes[0] is ISerializedImageListStreamerResourceElementNode;
		}
Esempio n. 33
0
        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;
            }
        }
Esempio n. 34
0
		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));
		}
Esempio n. 35
0
		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;
		}
Esempio n. 37
0
        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;
        }
Esempio n. 38
0
		static bool CanExecute(IFileTreeNodeData[] nodes) {
			return nodes.Length == 1 &&
				nodes[0] is IImageResourceElementNode;
		}
Esempio n. 39
0
 IFileTreeNodeData[] GetChildren(IFileTreeNodeData node)
 {
     var n = node;
     return (IFileTreeNodeData[])execInThread(() => {
         n.TreeNode.EnsureChildrenLoaded();
         return n.TreeNode.DataChildren.OfType<IFileTreeNodeData>().ToArray();
     });
 }
Esempio n. 40
0
		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);
		}
Esempio n. 41
0
		static bool CanExecute(IFileTreeNodeData[] nodes) {
			return nodes.Length > 0 &&
				nodes.All(n => n is IResourceElementNode);
		}
Esempio n. 42
0
 public virtual FileTreeNodeFilterResult GetResult(IFileTreeNodeData node)
 {
     return(new FileTreeNodeFilterResult());
 }
Esempio n. 43
0
		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);
		}
Esempio n. 44
0
        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;
        }
Esempio n. 45
0
		static bool CanExecute(IFileTreeNodeData[] nodes) {
			return nodes.Length > 0 &&
				nodes.All(n => n is IFieldNode);
		}
Esempio n. 46
0
 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));
 }
Esempio n. 47
0
		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));
		}
Esempio n. 48
0
        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;
            }
        }
Esempio n. 49
0
		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));
		}
Esempio n. 50
0
		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;
		}
Esempio n. 51
0
		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);
		}
Esempio n. 52
0
        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);
        }
Esempio n. 53
0
		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]);
		}
Esempio n. 54
0
 public virtual FileTreeNodeFilterResult GetResult(IFileTreeNodeData node) => new FileTreeNodeFilterResult(FilterType.Hide, false);
Esempio n. 55
0
		static bool CanExecute(IFileTreeNodeData[] nodes) {
			return ResUtils.CanExecuteResourceListCommand(nodes);
		}