/// <summary>Loads the file into the given project.</summary> /// <param name="path">Full pathname of the file.</param> /// <param name="project">[in,out] The project.</param> private static void LoadProjectFromPath(string path, ref ReClassNetProject project) { Contract.Requires(path != null); Contract.Requires(project != null); Contract.Ensures(Contract.ValueAtReturn(out project) != null); IReClassImport import; switch (Path.GetExtension(path)?.ToLower()) { case ReClassNetFile.FileExtension: import = new ReClassNetFile(project); break; case ReClassQtFile.FileExtension: import = new ReClassQtFile(project); break; case ReClassFile.FileExtension: import = new ReClassFile(project); break; default: Program.Logger.Log(LogLevel.Error, $"The file '{path}' has an unknown type."); return; } import.Load(path, Program.Logger); }
/// <summary>Loads the file into the given project.</summary> /// <param name="filePath">Full pathname of the file.</param> /// <param name="project">[in,out] The project.</param> private void LoadFileFromPath(string filePath, ref ReClassNetProject project) { Contract.Requires(filePath != null); Contract.Requires(project != null); Contract.Ensures(Contract.ValueAtReturn(out project) != null); IReClassImport import = null; switch (Path.GetExtension(filePath)) { case ReClassNetFile.FileExtension: import = new ReClassNetFile(project); break; case ReClassQtFile.FileExtension: import = new ReClassQtFile(project); break; case ReClassFile.FileExtension: import = new ReClassFile(project); break; case ReClass2007File.FileExtension: import = new ReClass2007File(project); break; default: Program.Logger.Log(LogLevel.Error, $"The file '{filePath}' has an unknown type."); break; } import?.Load(filePath, Program.Logger); }
private void MainForm_DragDrop(object sender, DragEventArgs e) { var files = e.Data.GetData(DataFormats.FileDrop) as string[]; if (files != null && files.Any()) { try { var path = files.First(); var project = new ReClassNetProject(); LoadFileFromPath(path, ref project); // If the file is a ReClass.NET file remember the path. if (Path.GetExtension(path) == ReClassNetFile.FileExtension) { project.Path = path; } SetProject(project); } catch (Exception ex) { Program.Logger.Log(ex); } } }
/// <summary>Sets the current project.</summary> /// <param name="newProject">The new project.</param> public void SetProject(ReClassNetProject newProject) { Contract.Requires(newProject != null); if (currentProject == newProject) { return; } if (currentProject != null) { ClassNode.ClassCreated -= currentProject.AddClass; } currentProject = newProject; ClassUtil.Classes = currentProject.Classes; ClassNode.ClassCreated += currentProject.AddClass; classesView.Project = currentProject; memoryViewControl.Project = currentProject; memoryViewControl.ClassNode = currentProject.Classes.FirstOrDefault(); }
public static Tuple <List <ClassNode>, List <BaseNode> > DeserializeNodesFromStream(Stream input, ReClassNetProject templateProject, ILogger logger) { Contract.Requires(input != null); Contract.Requires(logger != null); Contract.Ensures(Contract.Result <Tuple <List <ClassNode>, List <BaseNode> > >() != null); using (var project = new ReClassNetProject()) { templateProject?.Classes.ForEach(project.AddClass); var file = new ReClassNetFile(project); file.Load(input, logger); var classes = project.Classes .Where(c => c.Name != SerializationClassName); if (templateProject != null) { classes = classes.Where(c => !templateProject.ContainsClass(c.Uuid)); } var nodes = project.Classes .Where(c => c.Name == SerializationClassName) .SelectMany(c => c.Nodes); return(Tuple.Create(classes.ToList(), nodes.ToList())); } }
private void openProjectToolStripMenuItem_Click(object sender, EventArgs e) { try { var path = ShowOpenProjectFileDialog(); if (path != null) { var project = new ReClassNetProject(); LoadFileFromPath(path, ref project); // If the file is a ReClass.NET file remember the path. if (Path.GetExtension(path) == ReClassNetFile.FileExtension) { project.Path = path; } SetProject(project); } } catch (Exception ex) { Program.Logger.Log(ex); } }
/// <summary>Pastes nodes from the clipboard.</summary> /// <param name="templateProject">The project to resolve class references.</param> /// <param name="logger">The logger.</param> /// <returns>A list of <see cref="ClassNode"/> and <see cref="BaseNode"/>. If no data was present, both lists are empty.</returns> public static Tuple <List <ClassNode>, List <BaseNode> > Paste(ReClassNetProject templateProject, ILogger logger) { Contract.Requires(templateProject != null); Contract.Requires(logger != null); Contract.Ensures(Contract.Result <List <BaseNode> >() != null); var classes = new List <ClassNode>(); var nodes = new List <BaseNode>(); if (ContainsNodes) { var data = Clipboard.GetData(ClipboardFormat) as byte[]; if (data != null) { using (var ms = new MemoryStream(data)) { var result = ReClassNetFile.ReadNodes(ms, templateProject, logger); classes.AddRange(result.Item1); nodes.AddRange(result.Item2); } } } return(Tuple.Create(classes, nodes)); }
public static Tuple <List <ClassNode>, List <BaseNode> > ReadNodes(Stream input, ReClassNetProject templateProject, ILogger logger) { Contract.Requires(input != null); Contract.Requires(logger != null); Contract.Ensures(Contract.Result <Tuple <List <ClassNode>, List <BaseNode> > >() != null); using (var project = new ReClassNetProject()) { templateProject?.Classes.ForEach(project.AddClass); var file = new ReClassNetFile(project); file.Load(input, logger); var classes = new List <ClassNode>(); var nodes = new List <BaseNode>(); var serialisationClassNode = project.Classes.FirstOrDefault(c => c.Name == SerialisationClassName); if (serialisationClassNode != null) { if (templateProject != null) { classes.AddRange(project.Classes.Where(c => c != serialisationClassNode).Where(classNode => !templateProject.ContainsClass(classNode.Uuid))); } nodes.AddRange(serialisationClassNode.Nodes); project.Remove(serialisationClassNode); } return(Tuple.Create(classes, nodes)); } }
public EnumSelectionForm(ReClassNetProject project) { Contract.Requires(project != null); this.project = project; InitializeComponent(); ShowFilteredEnums(); }
public static void WriteNodes(Stream output, IEnumerable <BaseNode> nodes, ILogger logger) { Contract.Requires(output != null); Contract.Requires(nodes != null); Contract.Requires(Contract.ForAll(nodes, n => n != null)); Contract.Requires(logger != null); using (var project = new ReClassNetProject()) { Action <BaseReferenceNode> recursiveAddReferences = null; recursiveAddReferences = delegate(BaseReferenceNode referenceNode) { if (project.ContainsClass(referenceNode.InnerNode.Uuid)) { return; } project.AddClass(referenceNode.InnerNode); foreach (var reference in referenceNode.InnerNode.Nodes.OfType <BaseReferenceNode>()) { recursiveAddReferences(reference); } }; var serialisationClass = new ClassNode(false) { Name = SerialisationClassName }; project.AddClass(serialisationClass); foreach (var node in nodes) { var classNode = node as ClassNode; if (classNode != null) { project.AddClass(classNode); continue; } var referenceNode = node as BaseReferenceNode; if (referenceNode != null) { recursiveAddReferences(referenceNode); } serialisationClass.AddNode(node); } var file = new ReClassNetFile(project); file.Save(output, logger); } }
/// <summary>Pastes nodes from the clipboard.</summary> /// <param name="templateProject">The project to resolve class references.</param> /// <param name="logger">The logger.</param> /// <returns>A list of <see cref="ClassNode"/> and <see cref="BaseNode"/>. If no data was present, both lists are empty.</returns> public static Tuple <List <ClassNode>, List <BaseNode> > Paste(ReClassNetProject templateProject, ILogger logger) { Contract.Requires(templateProject != null); Contract.Requires(logger != null); Contract.Ensures(Contract.Result <Tuple <List <ClassNode>, List <BaseNode> > >() != null); if (ContainsNodes && Clipboard.GetData(ClipboardFormat) is byte[] data) { using var ms = new MemoryStream(data); return(ReClassNetFile.DeserializeNodesFromStream(ms, templateProject, logger)); } return(Tuple.Create(new List <ClassNode>(), new List <BaseNode>())); }
/// <summary>Loads the file as a new project.</summary> /// <param name="path">Full pathname of the file.</param> public void LoadProjectFromPath(string path) { Contract.Requires(path != null); var project = new ReClassNetProject(); LoadProjectFromPath(path, ref project); // If the file is a ReClass.NET file remember the path. if (Path.GetExtension(path) == ReClassNetFile.FileExtension) { project.Path = path; } SetProject(project); }
/// <summary>Sets the current project.</summary> /// <param name="newProject">The new project.</param> public void SetProject(ReClassNetProject newProject) { Contract.Requires(newProject != null); if (currentProject == newProject) { return; } if (currentProject != null) { ClassNode.ClassCreated -= currentProject.AddClass; } void UpdateClassNodes(BaseNode node) { projectView.UpdateClassNode((ClassNode)node); } currentProject = newProject; currentProject.ClassAdded += c => { projectView.AddClass(c); c.NodesChanged += UpdateClassNodes; c.NameChanged += UpdateClassNodes; }; currentProject.ClassRemoved += c => { projectView.RemoveClass(c); c.NodesChanged -= UpdateClassNodes; c.NameChanged -= UpdateClassNodes; }; currentProject.EnumAdded += e => { projectView.AddEnum(e); }; ClassNode.ClassCreated += currentProject.AddClass; projectView.Clear(); projectView.AddEnums(currentProject.Enums); projectView.AddClasses(currentProject.Classes); memoryViewControl.ClassNode = currentProject.Classes.FirstOrDefault(); }
public ReClassNetFile(ReClassNetProject project) { Contract.Requires(project != null); this.project = project; }
public static void SerializeNodesToStream(Stream output, IEnumerable <BaseNode> nodes, ILogger logger) { Contract.Requires(output != null); Contract.Requires(nodes != null); Contract.Requires(Contract.ForAll(nodes, n => n != null)); Contract.Requires(logger != null); using var project = new ReClassNetProject(); void RecursiveAddClasses(BaseNode node) { ClassNode classNode = null; switch (node) { case ClassNode c1: classNode = c1; break; case BaseWrapperNode wrapperNode when wrapperNode.ResolveMostInnerNode() is ClassNode c2: classNode = c2; break; } if (classNode == null || project.ContainsClass(classNode.Uuid)) { return; } project.AddClass(classNode); foreach (var wrapperNodeChild in classNode.Nodes.OfType <BaseWrapperNode>()) { RecursiveAddClasses(wrapperNodeChild); } } var serialisationClass = new ClassNode(false) { Name = SerializationClassName }; var needsSerialisationClass = true; foreach (var node in nodes) { RecursiveAddClasses(node); if (!(node is ClassNode)) { if (needsSerialisationClass) { needsSerialisationClass = false; project.AddClass(serialisationClass); } serialisationClass.AddNode(node); } } var file = new ReClassNetFile(project); file.Save(output, logger); }