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