public static void SaveFileFormat(byte[] data, bool FileIsCompressed, ICompressionFormat CompressionFormat,
int Alignment, string FileName, bool EnableDialog = true, string DetailsLog = "")
{
uint DecompressedSize = (uint)data.Length;
Cursor.Current = Cursors.WaitCursor;
var compressedData = CompressFileFormat(CompressionFormat, new MemoryStream(data), FileIsCompressed, Alignment, FileName, EnableDialog);
string compressionLog = compressedData.Item2;
Stream FinalData = compressedData.Item1;
FinalData.ExportToFile(FileName);
uint CompressedSize = (uint)FinalData.Length;
DetailsLog += "\n" + SatisfyFileTables(null, FileName, new MemoryStream(data),
DecompressedSize,
CompressedSize,
FileIsCompressed);
FinalData.Flush();
FinalData.Close();
MessageBox.Show($"File has been saved to {FileName}", "Save Notification");
// STSaveLogDialog.Show($"File has been saved to {FileName}", "Save Notification", DetailsLog);
Cursor.Current = Cursors.Default;
}
private static IFileFormat SetFileFormat(IFileFormat fileFormat, string FileName, Stream stream, bool LeaveStreamOpen = false, bool InArchive = false,
bool Compressed = false, ICompressionFormat FileCompression = null)
{
fileFormat.IFileInfo.FileCompression = FileCompression;
fileFormat.IFileInfo.FileIsCompressed = Compressed;
fileFormat.FileName = Path.GetFileName(FileName);
fileFormat.FilePath = FileName;
fileFormat.IFileInfo.InArchive = InArchive;
fileFormat.IFileInfo.FileIsCompressed = Compressed;
fileFormat.Load(stream);
//After file has been loaded and read, we'll dispose unless left open
if (fileFormat is ILeaveOpenOnLoad)
{
LeaveStreamOpen = true;
}
if (!LeaveStreamOpen)
{
stream.Dispose();
GC.SuppressFinalize(stream);
}
return(fileFormat);
}
public void LoadFormat(ICompressionFormat fileFormat, System.IO.Stream stream, string fileName)
{
ObjectTreeNode dataNode = new ObjectTreeNode(System.IO.Path.GetFileName(fileName));
dataNode.Tag = stream;
ObjectHiearchy.Add(dataNode);
}
private void SaveFileForCompression(bool Compress, Stream data, ICompressionFormat compressionFormat)
{
SaveFileDialog sfd = new SaveFileDialog();
sfd.Filter = "All files(*.*)|*.*";
Cursor.Current = Cursors.Default;
if (sfd.ShowDialog() == DialogResult.OK)
{
Stream stream;
if (Compress)
{
stream = compressionFormat.Compress(data);
}
else
{
stream = compressionFormat.Decompress(data);
}
if (stream != null)
{
stream.ExportToFile(sfd.FileName);
stream.Flush();
stream.Close();
MessageBox.Show($"File has been saved to {sfd.FileName}", "Save Notification");
}
}
}
private static Tuple <Stream, string> CompressFileFormat(ICompressionFormat compressionFormat, Stream data, bool FileIsCompressed, int Alignment,
string FileName, bool EnableDialog = true)
{
string extension = Path.GetExtension(FileName);
if (extension == ".szs" || extension == ".sbfres")
{
FileIsCompressed = true;
compressionFormat = new Yaz0();
}
if (compressionFormat == null)
{
return(Tuple.Create(data, ""));
}
bool CompressFile = false;
if (EnableDialog && FileIsCompressed)
{
if (Runtime.AlwaysCompressOnSave)
{
CompressFile = true;
}
else
{
DialogResult save = MessageBox.Show($"Compress file with {compressionFormat}?", "File Save", MessageBoxButtons.YesNo);
CompressFile = (save == DialogResult.Yes);
}
}
else if (FileIsCompressed)
{
CompressFile = true;
}
Console.WriteLine($"FileIsCompressed {FileIsCompressed} CompressFile {CompressFile} CompressionType {compressionFormat}");
if (CompressFile)
{
if (compressionFormat is Yaz0)
{
((Yaz0)compressionFormat).Alignment = Alignment;
}
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
sw.Start();
var comp = compressionFormat.Compress(data);
sw.Stop();
TimeSpan ts = sw.Elapsed;
string message = string.Format("{0:D2}:{1:D2}:{2:D2}", ts.Minutes, ts.Seconds, ts.Milliseconds);
Console.WriteLine($"Compression Time : {message}");
return(Tuple.Create(comp, message));
}
return(Tuple.Create(data, ""));
}
/// <summary>
/// Gets the <see cref="IFileFormat"/> from a file or byte array.
/// </summary>
/// <param name="FileName">The name of the file</param>
/// <param name="data">The byte array of the data</param>
/// <param name="InArchive">If the file is in an archive so it can be saved back</param>
/// <param name="Compressed">If the file is being compressed or not</param>
/// <param name="CompressionFormat">The type of <see cref="ICompressionFormat"/> being used</param>
/// <returns></returns>
public static IFileFormat OpenFileFormat(Stream stream, string FileName, bool LeaveStreamOpen = false, bool InArchive = false,
bool Compressed = false, ICompressionFormat CompressionFormat = null, long DecompressedSize = 0, long CompressedSize = 0)
{
if (!Compressed)
{
DecompressedSize = stream.Length;
}
long streamStartPos = stream.Position;
if (stream.Length < 8)
{
return(null);
}
//Check all supported compression formats and decompress. Then loop back
if (!Compressed)
{
foreach (ICompressionFormat compressionFormat in FileManager.GetCompressionFormats())
{
stream.Position = streamStartPos;
if (compressionFormat.Identify(stream, FileName))
{
stream.Position = streamStartPos;
Stream decompStream = compressionFormat.Decompress(stream);
stream.Close();
CompressedSize = decompStream.Length;
return(OpenFileFormat(decompStream, FileName, LeaveStreamOpen, InArchive,
true, compressionFormat, DecompressedSize, CompressedSize));
}
}
}
stream.Position = streamStartPos;
foreach (IFileFormat fileFormat in FileManager.GetFileFormats())
{
//Set the file name so we can check it's extension in the identifier.
//Most is by magic but some can be extension or name.
fileFormat.FileName = Path.GetFileName(FileName);
if (fileFormat.Identify(stream))
{
fileFormat.IFileInfo = new IFileInfo();
fileFormat.IFileInfo.DecompressedSize = (uint)DecompressedSize;
fileFormat.IFileInfo.CompressedSize = (uint)CompressedSize;
return(SetFileFormat(fileFormat, FileName, stream, LeaveStreamOpen, InArchive, Compressed, CompressionFormat));
}
}
stream.Close();
return(null);
}
public CompressionMenuItem(ICompressionFormat format) : base(format.ToString())
{
Format = format;
Children.Add(new ToolMenuItem("Decompress", DecompressMenu));
Children.Add(new ToolMenuItem("Compress", CompressMenu)
{
Enabled = Format.CanCompress,
});
}
public void DecompressData(ICompressionFormat CompressionFormat, Stream data)
{
try
{
SaveFileForCompression(false, data, CompressionFormat);
}
catch (Exception ex)
{
MessageBox.Show($"File not compressed with {CompressionFormat} compression! {ex.ToString()}");
}
}
public void CompressData(ICompressionFormat CompressionFormat, Stream data)
{
try
{
SaveFileForCompression(true, data, CompressionFormat);
}
catch (Exception ex)
{
MessageBox.Show($"File failed to compress with {CompressionFormat} compression! {ex.ToString()}");
}
}
private void OpenFileForCompression(ICompressionFormat compressionFormat, bool Compress)
{
OpenFileDialog ofd = new OpenFileDialog();
ofd.Filter = "All files(*.*)|*.*";
ofd.Multiselect = true;
if (ofd.ShowDialog() == DialogResult.OK)
{
Cursor.Current = Cursors.WaitCursor;
SaveFileForCompression(Compress, ofd.FileNames, compressionFormat);
}
}
private static Stream CompressFileFormat(ICompressionFormat compressionFormat, Stream data, bool FileIsCompressed, int Alignment,
string FileName, bool EnableDialog = true)
{
string extension = Path.GetExtension(FileName);
if (extension == ".szs" || extension == ".sbfres")
{
FileIsCompressed = true;
compressionFormat = new Yaz0();
}
if (compressionFormat == null)
{
return(data);
}
bool CompressFile = false;
if (EnableDialog && FileIsCompressed)
{
if (Runtime.AlwaysCompressOnSave)
{
CompressFile = true;
}
else
{
DialogResult save = MessageBox.Show($"Compress file with {compressionFormat}?", "File Save", MessageBoxButtons.YesNo);
CompressFile = (save == DialogResult.Yes);
}
}
else if (FileIsCompressed)
{
CompressFile = true;
}
Console.WriteLine($"FileIsCompressed {FileIsCompressed} CompressFile {CompressFile} CompressionType {compressionFormat}");
if (CompressFile)
{
if (compressionFormat is Yaz0)
{
((Yaz0)compressionFormat).Alignment = Alignment;
}
return(compressionFormat.Compress(data));
}
return(data);
}
private void OpenFileForCompression(ICompressionFormat compressionFormat, bool Compress)
{
OpenFileDialog ofd = new OpenFileDialog();
ofd.Filter = "All files(*.*)|*.*";
ofd.Multiselect = true;
if (ofd.ShowDialog() == DialogResult.OK)
{
Cursor.Current = Cursors.WaitCursor;
foreach (string file in ofd.FileNames)
{
if (Compress)
{
CompressData(compressionFormat, File.OpenRead(ofd.FileName));
}
else
{
DecompressData(compressionFormat, File.OpenRead(ofd.FileName));
}
}
}
}
/// <summary>
/// Gets the <see cref="TreeNodeFile"/> from a file or byte array.
/// </summary>
/// <param name="FileName">The name of the file</param>
/// <param name="data">The byte array of the data</param>
/// <param name="InArchive">If the file is in an archive so it can be saved back</param>
/// <param name="archiveNode">The node being replaced from an archive</param>
/// <param name="ArchiveHash">The unique hash from an archive for saving</param>
/// <param name="Compressed">If the file is being compressed or not</param>
/// <param name="CompType">The type of <see cref="CompressionType"/> being used</param>
/// <returns></returns>
public static TreeNode GetNodeFileFormat(string FileName, bool InArchive = false,
bool LeaveStreamOpen = false, bool Compressed = false, ICompressionFormat CompressionFormat = null)
{
IFileFormat format = OpenFileFormat(FileName, LeaveStreamOpen, InArchive);
if (format is TreeNode)
{
return((TreeNode)format);
}
else
{
return(null);
}
}
/// <summary>
/// Gets the <see cref="IFileFormat"/> from a file or byte array.
/// </summary>
/// <param name="FileName">The name of the file</param>
/// <param name="data">The byte array of the data</param>
/// <param name="InArchive">If the file is in an archive so it can be saved back</param>
/// <param name="archiveNode">The node being replaced from an archive</param>
/// <param name="Compressed">If the file is being compressed or not</param>
/// <param name="CompType">The type of <see cref="CompressionType"/> being used</param>
/// <returns></returns>
public static IFileFormat OpenFileFormat(string FileName, bool LeaveStreamOpen = false, bool InArchive = false,
bool Compressed = false, ICompressionFormat CompressionFormat = null, uint DecompressedSize = 0, uint CompressedSize = 0)
{
return(OpenFileFormat(File.OpenRead(FileName), FileName, LeaveStreamOpen, InArchive,
Compressed, CompressionFormat, DecompressedSize, CompressedSize));
}
private void SaveFileForCompression(bool Compress, string[] fileNames, ICompressionFormat compressionFormat)
{
if (fileNames.Length == 0)
{
return;
}
string ext = Compress ? ".comp" : ".dec";
if (compressionFormat.Extension.Length > 0 && Compress)
{
ext = compressionFormat.Extension[0].Replace("*", string.Empty);
}
List <string> failedFiles = new List <string>();
if (fileNames.Length > 1)
{
FolderSelectDialog ofd = new FolderSelectDialog();
if (ofd.ShowDialog() == DialogResult.OK)
{
foreach (var file in fileNames)
{
string name = Path.GetFileName(file);
using (var data = new FileStream(file, FileMode.Open, FileAccess.Read))
{
try
{
Stream stream;
if (Compress)
{
stream = compressionFormat.Compress(data);
}
else
{
compressionFormat.Identify(data, file);
stream = compressionFormat.Decompress(data);
}
if (stream != null)
{
stream.ExportToFile($"{ofd.SelectedPath}/{name}{ext}");
stream.Flush();
stream.Close();
}
}
catch (Exception ex)
{
failedFiles.Add($"{file} \n\n {ex} \n\n");
}
}
}
if (failedFiles.Count > 0)
{
string action = Compress ? "compress" : "decompress";
STErrorDialog.Show($"Some files failed to {action}! See detail list of failed files.", "Switch Toolbox",
string.Join("\n", failedFiles.ToArray()));
}
else
{
MessageBox.Show("Files batched successfully!");
}
}
}
else
{
SaveFileDialog sfd = new SaveFileDialog();
string name = Path.GetFileName(fileNames[0]);
sfd.FileName = name + ext;
sfd.Filter = "All files(*.*)|*.*";
Cursor.Current = Cursors.Default;
if (sfd.ShowDialog() == DialogResult.OK)
{
try
{
using (var data = new FileStream(fileNames[0], FileMode.Open, FileAccess.Read))
{
Stream stream;
if (Compress)
{
stream = compressionFormat.Compress(data);
}
else
{
compressionFormat.Identify(data, sfd.FileName);
stream = compressionFormat.Decompress(data);
}
if (stream != null)
{
stream.ExportToFile(sfd.FileName);
stream.Flush();
stream.Close();
MessageBox.Show($"File has been saved to {sfd.FileName}", "Save Notification");
}
}
}
catch (Exception ex)
{
string action = Compress ? "compress" : "decompress";
STErrorDialog.Show($"Failed to {action}! See details for info.", "Switch Toolbox", ex.ToString());
}
}
}
}
public static ToolMenuItem CreateMenu(ICompressionFormat format)
{
var item = new CompressionMenuItem(format);
return(item);
}
