Example #1
0
		public static void WriteOffsetComment(this ITextOutput output, IResourceNode node) {
			if (!DecompilerSettingsPanel.CurrentDecompilerSettings.ShowTokenAndRvaComments)
				return;

			ulong fo = node.FileOffset;
			if (fo == 0)
				return;

			var mod = ILSpyTreeNode.GetModule((SharpTreeNode)node);
			var filename = mod == null ? null : mod.Location;
			output.WriteReference(string.Format("0x{0:X8}", fo), new AddressReference(filename, false, fo, node.Length), TextTokenType.Comment);
			output.Write(": ", TextTokenType.Comment);
		}
        private GridResourceNode(IResourceNode node)
        {
            if (node == null) throw new ArgumentNullException("node");

            this.Source = node;
            this.Offense = node.Offense;
            this.Defense = node.Defense;
            this.Exchange = node.Exchange;

            Id = new UniqueIdentifier(IdentityType.ResourceNode, new[] { this.Offense, this.Defense, this.Exchange });

            this.RenewableResources = new List<Resource>();
            this.RenewableResources.AddRange(node.RenewableResources);

            this.Reservoir = new List<Resource>();
            this.RefreshReservoir();
        }
Example #3
0
		public static void Save(IResourceNode[] nodes, bool useSubDirs, ResourceDataType resourceDataType) {
			if (nodes == null)
				return;

			var files = GetFiles(GetResourceData(nodes, resourceDataType), useSubDirs).ToArray();
			if (files.Length == 0)
				return;

			var data = new ProgressVM(MainWindow.Instance.Dispatcher, new ResourceSaver(files));
			var win = new ProgressDlg();
			win.DataContext = data;
			win.Owner = MainWindow.Instance;
			win.Title = files.Length == 1 ? "Save Resource" : "Save Resources";
			var res = win.ShowDialog();
			if (res != true)
				return;
			if (!data.WasError)
				return;
			MainWindow.Instance.ShowMessageBox(string.Format("An error occurred:\n\n{0}", data.ErrorMessage));
		}
Example #4
0
        public static void Save(IResourceNode[] nodes, bool useSubDirs, ResourceDataType resourceDataType)
        {
            if (nodes == null)
                return;

            var infos = GetResourceData(nodes, resourceDataType);
            if (infos.Length == 1) {
                var info = infos[0];
                var name = ResourceUtils.FixFileNamePart(ResourceUtils.GetFileName(info.Name));
                var dlg = new WF.SaveFileDialog {
                    RestoreDirectory = true,
                    ValidateNames = true,
                    FileName = name,
                };
                var ext = Path.GetExtension(name);
                dlg.DefaultExt = string.IsNullOrEmpty(ext) ? string.Empty : ext.Substring(1);
                if (dlg.ShowDialog() != WF.DialogResult.OK)
                    return;
                var ex = ResourceUtils.SaveFile(dlg.FileName, info.GetStream());
                if (ex != null)
                    MainWindow.Instance.ShowMessageBox(string.Format("Could not save '{0}'\nERROR: {1}", dlg.FileName, ex.Message));
            }
            else {
                var dlg = new WF.FolderBrowserDialog();
                if (dlg.ShowDialog() != WF.DialogResult.OK)
                    return;
                string baseDir = dlg.SelectedPath;
                foreach (var info in infos) {
                    var name = ResourceUtils.GetCleanedPath(info.Name, useSubDirs);
                    var pathName = Path.Combine(baseDir, name);
                    var ex = ResourceUtils.SaveFile(pathName, info.GetStream());
                    if (ex != null) {
                        MainWindow.Instance.ShowMessageBox(string.Format("Could not save '{0}'\nERROR: {1}", pathName, ex.Message));
                        break;
                    }
                }
            }
        }
Example #5
0
 protected ResourceData[] GetResourceData(IResourceNode[] nodes)
 {
     return SaveResources.GetResourceData(nodes, resourceDataType);
 }
Example #6
0
		protected CreateResourceTreeNodeCommand(IResourcesFolderNode rsrcListNode, IResourceNode resTreeNode) {
			this.module = rsrcListNode.GetModule();
			Debug.Assert(this.module != null);
			this.rsrcListNode = rsrcListNode;
			this.resTreeNode = resTreeNode;
		}
Example #7
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]);
		}
Example #8
0
			public void Restore(IResourceNode[] nodes) {
				Debug.Assert(infos != null);
				if (infos == null)
					throw new InvalidOperationException();
				Debug.Assert(infos.Length == nodes.Length);
				if (infos.Length != nodes.Length)
					throw new InvalidOperationException();

				for (int i = infos.Length - 1; i >= 0; i--) {
					var node = nodes[i];
					var info = infos[i];
					info.OwnerModule.Resources.Insert(info.Index, node.Resource);
				}

				infos = null;
			}
Example #9
0
		ResourceSettingsCommand(IResourceNode rsrcNode, ResourceOptions options) {
			this.rsrcNode = rsrcNode;
			this.newOptions = options;
			this.origOptions = new ResourceOptions(rsrcNode.Resource);

			this.origParentNode = (IFileTreeNodeData)rsrcNode.TreeNode.Parent.Data;
			this.origParentChildIndex = this.origParentNode.TreeNode.Children.IndexOf(rsrcNode.TreeNode);
			Debug.Assert(this.origParentChildIndex >= 0);
			if (this.origParentChildIndex < 0)
				throw new InvalidOperationException();

			this.nameChanged = origOptions.Name != newOptions.Name;
		}
 public virtual FileTreeNodeFilterResult GetResult(IResourceNode node)
 {
     return new FileTreeNodeFilterResult();
 }
 private ColorViewModel GetColorResource(IResourceNode node, string key)
 {
     return(((Color)node.FindResource(key)).FromColor());
 }
Example #12
0
    /// <summary>
    /// 确认修改
    /// </summary>
    /// <param name="_rModelNode"></param>
    /// <param name="_rImgNode"></param>
    /// <param name="_strTag"></param>
    /// <param name="_strShowName"></param>
    public void OnAffirm(IResourceNode _rModelNode, IResourceNode _rImgNode,
                         string _strTag,
                         string _strShowName)
    {
        m_bNeedUpdate = true;

        string   strData   = m_infoJson.ReadString("data", JsonUtils.EmptyJsonArray.ToJson());
        JsonData jdData    = JsonMapper.ToObject(strData);
        JsonData dataJD    = jdData;
        JsonData jdNewData = JsonUtils.EmptyJsonArray;

        if (dataJD.Count < 1)
        {
            JsonData jd = JsonUtils.EmptyJsonObject;
            dataJD.Add(jd);
        }

        JsonData jdFbx = dataJD[0];

        if (_rImgNode != null)
        {
            m_infoJson["picName"] = _rImgNode.GetName();
            m_infoJson["picCrc"]  = _rImgNode.GetCrc();

            m_strImg    = _rImgNode.GetName();
            m_strImgCrc = _rImgNode.GetCrc();

            m_rNewImg = _rImgNode;
        }
        if (_rModelNode != null)
        {
            jdFbx["fileName"] = _rModelNode.GetName();
            jdFbx["fileCrc"]  = _rModelNode.GetCrc();
            jdFbx["type"]     = _rModelNode.GetResType().ToString();

            m_strModelCrc  = _rModelNode.GetCrc();
            m_strModelName = _rModelNode.GetName();
            m_strModelType = _rModelNode.GetResType().ToString();

            m_rNewModel = _rModelNode;

            if (m_bIsNew)
            {
                m_strCode                = Utils.GetFilePrefix(m_strModelName);
                m_infoJson["code"]       = m_strCode;
                m_infoJson["wallLength"] = "0";
            }
        }
        if (!_strShowName.Equals(m_strShowName))
        {
            m_infoJson["name"] = _strShowName;
            m_strShowName      = _strShowName;
        }
        if (!_strTag.Equals(m_strTag))
        {
            m_infoJson["tag"] = _strTag;
            m_strTag          = _strTag;
        }

        jdFbx["children"] = JsonUtils.EmptyJsonArray;
        jdNewData.Add(jdFbx);
        m_infoJson["data"] = jdNewData.ToJson();
        Debug.LogWarning("NewComp:" + m_infoJson.ToJson());
    }
 public virtual DocumentTreeNodeFilterResult GetResult(IResourceNode node) => new DocumentTreeNodeFilterResult(FilterType.Hide, false);
 public virtual FileTreeNodeFilterResult GetResult(IResourceNode node)
 {
     return this.filter.GetResult(node);
 }
 /// <summary>
 /// Create the first layer after the root layer (based on the root node)
 /// </summary>
 /// <returns>The next layer.</returns>
 /// <param name="rootNode">Root node.</param>
 public NodeLayer CreateNextLayer(IResourceNode rootNode)
 {
     return(CreateNextLayer(new[] { rootNode }));
 }
Example #16
0
        void SearchResourceElementTreeNode(IDnSpyFile module, IResourceNode resTreeNode, IResourceElementNode resElNode)
        {
            var res = options.Filter.GetResult(resElNode);
            if (res.FilterType == FilterType.Hide)
                return;

            if (res.IsMatch) {
                bool m = IsMatch(resElNode.Name, resElNode);
                if (!m) {
                    var builtin = resElNode.ResourceElement.ResourceData as BuiltInResourceData;
                    if (builtin != null) {
                        var val = builtin.Data;
                        if (builtin.Code == ResourceTypeCode.TimeSpan)
                            val = ((TimeSpan)val).Ticks;
                        m = IsMatch(val as string, val);
                    }
                }
                if (!m)
                    m = IsMatch(ToString(resElNode), null);
                if (m) {
                    options.OnMatch(new SearchResult {
                        Context = options.Context,
                        Object = resElNode,
                        NameObject = resElNode,
                        ObjectImageReference = resElNode.Icon,
                        LocationObject = resTreeNode,
                        LocationImageReference = resTreeNode.Icon,
                        DnSpyFile = module,
                    });
                }
            }
        }
 private ThicknessViewModel GetThicknessResource(IResourceNode node, string key)
 {
     return(((Thickness)node.FindResource(key)).FromThickness());
 }
 public ResourceObservable(IResourceNode target, object key)
 {
     _target = target;
     _key    = key;
 }
 private double GetDoubleResource(IResourceNode node, string key)
 {
     return((double)node.FindResource(key));
 }
Example #20
0
 public static ResourceData[] GetResourceData(IResourceNode[] nodes, ResourceDataType resourceDataType)
 {
     return nodes.SelectMany(a => a.GetResourceData(resourceDataType)).ToArray();
 }
 public virtual DocumentTreeNodeFilterResult GetResult(IResourceNode node) => new DocumentTreeNodeFilterResult();
Example #22
0
		CreateFileLinkedResourceCommand(IResourcesFolderNode rsrcListNode, IResourceNode resTreeNode)
			: base(rsrcListNode, resTreeNode) {
		}
Example #23
0
 public void addResourceNode(IResourceNode newNode, Vector2Int pos)
 {
     this.resourceMap.addNode(newNode, pos);
 }
Example #24
0
			public void Delete(IResourceNode[] nodes, IFileTreeNodeData[] parents) {
				Debug.Assert(infos == null);
				if (infos != null)
					throw new InvalidOperationException();

				infos = new ModelInfo[nodes.Length];

				for (int i = 0; i < infos.Length; i++) {
					var node = nodes[i];

					var module = parents[i].GetModule();
					Debug.Assert(module != null);
					if (module == null)
						throw new InvalidOperationException();
					var info = new ModelInfo(module, node.Resource);
					infos[i] = info;
					info.OwnerModule.Resources.RemoveAt(info.Index);
				}
			}
Example #25
0
 public Styles(IResourceNode parent)
     : this()
 {
     _parent = parent;
 }
Example #26
0
		DeleteResourceCommand(IResourceNode[] rsrcNodes) {
			this.nodes = new DeletableNodes<IResourceNode>(rsrcNodes);
		}
Example #27
0
        private void CreateChildren(GraphNode graphNode, object constraints)
        {
            string                     graphNodeKeyStr = PrintRKTag(graphNode.OriginalKey, graphNode.ExtensionTag);
            int                        i, j, k, count, foundIndex;
            GraphNode                  childNode;
            GraphConnectionRef         childConnection;
            IResourceConnection        child;
            IResourceKey               childKey;
            List <IResourceConnection> children = graphNode.Core.SlurpConnections(constraints);

            count = (children == null) ? 0 : children.Count;
            Diagnostics.Log("Resolving " + count + " RK Refs from " + graphNodeKeyStr);
            for (i = 0; i < count; i++)
            {
                child           = children[i];
                childKey        = child.OriginalChildKey;
                childConnection = new GraphConnectionRef(this, graphNode, child);
                childNode       = null;
                // Try to find an already existing child node in the lookup table.
                foundIndex = -1;
                for (j = 0; j < this.nodeLookupTable.Count && foundIndex < 0; j++)
                {
                    if (this.nodeLookupTable[j].OriginalKey.Equals(childKey))
                    {
                        foundIndex = j;
                    }
                }
                if (foundIndex >= 0 && !child.AlwaysCreateChild)
                {
                    childNode = this.nodeLookupTable[foundIndex];
                }
                else
                {
                    RFileType        fileType  = RFileType.Game;
                    SpecificResource sr        = null;
                    IResourceNode    childCore = null;
                    if (child.ChildDataActions < ResourceDataActions.Find)
                    {
                        childCore = child.CreateChild(null, constraints);
                    }
                    else
                    {
                        List <PathPackageTuple> searchList;// = child.IsChildDDS ? FileTable.DDSImages :
                        //child.IsChildThum ? FileTable.Thumbnails : FileTable.GameContent;
                        if (child.IsChildDDS)
                        {
                            fileType   = RFileType.DDS;
                            searchList = FileTable.DDSImages;
                        }
                        else if (child.IsChildThum)
                        {
                            fileType   = RFileType.Thum;
                            searchList = FileTable.Thumbnails;
                        }
                        else
                        {
                            fileType   = RFileType.Game;
                            searchList = FileTable.GameContent;
                        }
                        sr = new SpecificResource(searchList, child.OriginalChildKey);
                        if (sr.ResourceIndexEntry == null || sr.Resource == null)
                        {
                            Diagnostics.Log("Unresolved RK Ref:" + PrintRKRef(childKey, child.AbsolutePath)
                                            + ((sr.Exception == null) ? "" :
                                               string.Concat(" Error:\r\n", sr.Exception.ToString())));
                        }
                        else
                        {
                            childCore = child.CreateChild(sr.Resource, constraints);
                        }
                    }
                    if (childCore == null)
                    {
                        Diagnostics.Log("CreateChild Failed:" + PrintRKRef(childKey, child.AbsolutePath));
                    }
                    else
                    {
                        childNode = new GraphNode(this, childKey, childCore,
                                                  sr == null ? null : sr.PathPackage, child.ChildDataActions, fileType);
                        if (child.AlwaysCreateChild && foundIndex >= 0)
                        {
                            Diagnostics.Log("Dup Ref Node Added:" + PrintRKRef(childKey, child.AbsolutePath));
                            this.nodeDuplicates.Add(childNode);
                        }
                        else
                        {
                            Diagnostics.Log("New Ref Node Added:" + PrintRKRef(childKey, child.AbsolutePath));
                            this.nodeLookupTable.Add(childNode);
                        }
                        CreateChildren(childNode, constraints);
                    }
                }
                if (childNode != null)
                {
                    graphNode.ChildConnections.Add(childConnection);
                    childConnection.Child = childNode;
                    childNode.ParentConnections.Add(childConnection);
                }
            }
            IResourceIndexEntry       kinKey;
            GraphConnectionKin        kinConnection;
            IResourceKinHelper        kinHelper;
            List <SpecificResource>   kin;
            List <IResourceKinHelper> kinHelpers = graphNode.Core.CreateKinHelpers(constraints);

            count = (kinHelpers == null) ? 0 : kinHelpers.Count;
            Diagnostics.Log("Resolving " + count + " RK Kin types for " + graphNodeKeyStr);
            for (i = 0; i < kinHelpers.Count; i++)
            {
                kinHelper = kinHelpers[i];
                Diagnostics.Log("Slurping " + kinHelper.KinName + " Kin of " + graphNodeKeyStr);
                if (kinHelper is IResourceKinFinder)
                {
                    kin = (kinHelper as IResourceKinFinder).FindKindredResources(graphNode.OriginalKey);
                }
                else
                {
                    kin = SlurpKindredResources(graphNode.OriginalKey, kinHelper);
                }
                for (j = 0; j < kin.Count; j++)
                {
                    kinKey = kin[j].ResourceIndexEntry;
                    if (kinKey == null)
                    {
                        continue;
                    }
                    kinConnection = new GraphConnectionKin(this, graphNode, kinHelper);
                    childNode     = null;
                    // Try to find an already existing kindred node in the lookup table.
                    foundIndex = -1;
                    for (k = 0; k < this.nodeLookupTable.Count && foundIndex < 0; k++)
                    {
                        if (this.nodeLookupTable[k].OriginalKey.Equals(kinKey))
                        {
                            foundIndex = k;
                        }
                    }
                    if (foundIndex >= 0)
                    {
                        childNode = this.nodeLookupTable[foundIndex];
                        if (!childNode.IsKindred)
                        {
                            Diagnostics.Log("Non-Kindred Node "
                                            + PrintRKTag(kinKey, childNode.ExtensionTag)
                                            + " is " + kinHelper.KinName + " Kin of "
                                            + graphNodeKeyStr);
                        }
                        else
                        {
                            Diagnostics.Log("Existing Kindred Node "
                                            + PrintRKTag(kinKey, childNode.ExtensionTag)
                                            + " is " + kinHelper.KinName + " Kin of "
                                            + graphNodeKeyStr);
                        }
                    }
                    else
                    {
                        IResource kinResource = kin[j].Resource;
                        if (kinResource == null)
                        {
                            Diagnostics.Log("Unresolved RK Kin:" + PrintRK(kinKey)
                                            + ((kin[j].Exception == null) ? "" :
                                               string.Concat(" Error:\r\n", kin[j].Exception.ToString())));
                        }
                        else
                        {
                            IResourceNode kinCore = kinHelper.CreateKin(kinResource, kinKey, constraints);
                            if (kinCore == null)
                            {
                                Diagnostics.Log("CreateKin Failed:" + PrintRK(kinKey));
                            }
                            else
                            {
                                childNode = new GraphNode(this, kinKey, kinCore,
                                                          kin[j].PathPackage, ResourceDataActions.FindWrite);
                                this.nodeLookupTable.Add(childNode);
                                Diagnostics.Log("New Kin Node Added:" + PrintRKTag(kinKey, childNode.ExtensionTag));
                                CreateChildren(childNode, constraints);
                            }
                        }
                    }
                    if (childNode != null)
                    {
                        graphNode.KindredConnections.Add(kinConnection);
                        kinConnection.Child = childNode;
                        childNode.KinOwnerConnections.Add(kinConnection);
                    }
                }
            }
        }
Example #28
0
		CreateFileResourceCommand(IResourcesFolderNode rsrcListNode, IResourceNode[] nodes) {
			this.module = rsrcListNode.GetModule();
			Debug.Assert(this.module != null);
			this.rsrcListNode = rsrcListNode;
			this.nodes = nodes;
		}
 public virtual FileTreeNodeFilterResult GetResult(IResourceNode node)
 {
     return new FileTreeNodeFilterResult(FilterType.Hide, false);
 }
Example #30
0
		CreateMultiFileResourceCommand(IResourcesFolderNode rsrcListNode, IResourceNode resTreeNode)
			: base(rsrcListNode, resTreeNode) {
		}
Example #31
0
 public virtual FileTreeNodeFilterResult GetResult(IResourceNode node)
 {
     return(new FileTreeNodeFilterResult(FilterType.Hide, false));
 }
Example #32
0
 void Decompile(IResourceNode node)
 {
     if (node is IResourceElementSetNode)
         Decompile((IResourceElementSetNode)node);
     else
         node.WriteShort(output, language, language.Settings.GetBoolean(DecompilerOptionConstants.ShowTokenAndRvaComments_GUID));
 }
 public override FileTreeNodeFilterResult GetResult(IResourceNode node)
 {
     var visibleFlags = VisibleMembersFlags.Resource | VisibleMembersFlags.ResourceElement |
                         VisibleMembersFlags.Attributes;
     bool isMatch = (flags & VisibleMembersFlags.Resource) != 0;
     if ((flags & visibleFlags) == 0)
         return new FileTreeNodeFilterResult(FilterType.Hide, isMatch);
     if (isMatch)
         return new FileTreeNodeFilterResult(FilterType.Visible, isMatch);
     return new FileTreeNodeFilterResult(FilterType.CheckChildren, isMatch);
 }
Example #34
0
        void SearchResourceTreeNodes(IDnSpyFile module, IResourceNode resTreeNode)
        {
            var res = options.Filter.GetResult(resTreeNode);
            if (res.FilterType == FilterType.Hide)
                return;

            if (res.IsMatch && (IsMatch(resTreeNode.Name, resTreeNode) || IsMatch(ToString(resTreeNode), null))) {
                options.OnMatch(new SearchResult {
                    Context = options.Context,
                    Object = resTreeNode,
                    NameObject = resTreeNode,
                    ObjectImageReference = resTreeNode.Icon,
                    LocationObject = module.ModuleDef,
                    LocationImageReference = options.DotNetImageManager.GetImageReference(module.ModuleDef),
                    DnSpyFile = module,
                });
            }

            res = options.Filter.GetResult((IResourceElementNode)null);
            if (res.FilterType == FilterType.Hide)
                return;

            var resNodes = new List<IResourceElementNode>();
            options.Dispatcher.Invoke(DispatcherPriority.Normal, new Action(() => {
                resTreeNode.TreeNode.EnsureChildrenLoaded();
                resNodes.AddRange(resTreeNode.TreeNode.DataChildren.OfType<IResourceElementNode>());
            }));

            foreach (var resElNode in resNodes)
                SearchResourceElementTreeNode(module, resTreeNode, resElNode);
        }
 public static IObservable <object> GetResourceObservable(this IResourceNode target, object key)
 {
     return(new ResourceObservable(target, key));
 }