/// <summary>
/// Extracts the contents of the zip file to the working directory.
/// </summary>
public void ExtractToCurrentDirectory()
{
for (var index = 0; index < Entries.Length; index++)
{
var entry = Entries[index];
var fileName = Path.Combine(Directory.GetCurrentDirectory(), entry.Name);
// save file if it is not only a directory
if (!entry.IsDirectory)
{
Extract(entry.Name, fileName);
}
ExtractProgress?.Invoke(this, new FileProgressEventArgs(index + 1, Entries.Length, entry.Name));
}
}
/// <summary>
/// Extracts the contents of the zip file to the given directory.
/// </summary>
/// <param name="directoryName">Name of the directory.</param>
public void ExtractToDirectory(string directoryName)
{
for (var index = 0; index < Entries.Length; index++)
{
var entry = Entries[index];
// create target directory for the file
var fileName = Path.Combine(directoryName, entry.Name);
var dirName = Path.GetDirectoryName(fileName) ?? "";
Directory.CreateDirectory(dirName);
// save file if it is not only a directory
if (!entry.IsDirectory)
{
Extract(entry.Name, fileName);
}
ExtractProgress?.Invoke(this, new FileProgressEventArgs(index + 1, Entries.Length, entry.Name));
}
}
public void Extract(string selfExtractPath, string folderPathOutput, ExtractExistingFileAction extractExistingFile)
{
if (!ioOperation.FileExist(selfExtractPath))
{
throw new FileNotFoundException("SelfExtractor Executable path cannot be found");
}
if (!ioOperation.DirectoryExist(folderPathOutput))
{
throw new FileNotFoundException("The output path does not exist");
}
if (!ZipFile.IsZipFile(selfExtractPath))
{
throw new System.NotSupportedException("The provided SelfExtractor does not contain anything");
}
using (var zipFile = ZipFile.Read(selfExtractPath))
{
zipFile.ExtractProgress += (sender, arg) => ExtractProgress?.Invoke(sender, arg);
zipFile.ExtractAll(folderPathOutput, extractExistingFile);
}
}
public void ReferenceTemplateImageTemplate(string[] splitWimNames, RefFlags refFlags = RefFlags.None, bool failure = false)
{
string[] splitWims = splitWimNames.Select(x => Path.Combine(TestSetup.SampleDir, x)).ToArray();
string destDir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
try
{
Directory.CreateDirectory(destDir);
bool[] _checked = new bool[5];
for (int i = 0; i < _checked.Length; i++)
{
_checked[i] = false;
}
CallbackStatus ProgressCallback(ProgressMsg msg, object info, object progctx)
{
switch (msg)
{
case ProgressMsg.ExtractImageBegin:
{
ExtractProgress m = (ExtractProgress)info;
Assert.IsNotNull(m);
_checked[0] = true;
}
break;
case ProgressMsg.ExtractImageEnd:
{
ExtractProgress m = (ExtractProgress)info;
Assert.IsNotNull(m);
_checked[1] = true;
}
break;
case ProgressMsg.ExtractFileStructure:
{
ExtractProgress m = (ExtractProgress)info;
Assert.IsNotNull(m);
_checked[2] = true;
}
break;
case ProgressMsg.ExtractStreams:
{
ExtractProgress m = (ExtractProgress)info;
Assert.IsNotNull(m);
_checked[3] = true;
}
break;
case ProgressMsg.ExtractMetadata:
{
ExtractProgress m = (ExtractProgress)info;
Assert.IsNotNull(m);
_checked[4] = true;
}
break;
}
return(CallbackStatus.Continue);
}
try
{
using (Wim wim = Wim.OpenWim(splitWims[0], OpenFlags.None, ProgressCallback))
{
var leftSplitWims = splitWims.Skip(1);
wim.ReferenceResourceFiles(leftSplitWims, refFlags, OpenFlags.None);
wim.ExtractImage(1, destDir, ExtractFlags.NoAcls);
}
}
catch (WimLibException)
{
if (failure)
{
return;
}
else
{
Assert.Fail();
}
}
Assert.IsTrue(_checked.All(x => x));
TestHelper.CheckFileSystem(SampleSet.Src03, destDir);
}
finally
{
if (Directory.Exists(destDir))
{
Directory.Delete(destDir, true);
}
}
}
/// <summary>
/// Extract a node and all of its subnodes and children.
/// </summary>
/// <param name="RootPath">Path to which to extract node.</param>
/// <param name="TextureType">How textures are to be extracted.</param>
/// <param name="NodeType">Whether to recreate the full root path.</param>
/// <param name="OnlyTextures">Indicates whether only textures or to be
/// extracted or all files.</param>
/// <param name="Callback">Callback function to update the caller that a
/// leaf is about to be extracted.</param>
public void Extract(string RootPath, TextureExtractType TextureType,
NodeExtractType NodeType, bool OnlyTextures, ExtractProgress Callback)
{
// Create the path to extract the nodes.
string dir_path = RootPath;
switch (NodeType)
{
case NodeExtractType.Relative:
dir_path += Path.DirectorySeparatorChar + this.Name;
break;
case NodeExtractType.FullPath:
dir_path += Path.DirectorySeparatorChar + this.FullPath;
break;
default:
throw new NotSupportedException("NodeExtractType not supported.");
}
DirectoryInfo new_dir = Directory.CreateDirectory(dir_path);
// Extract all child nodes
foreach (PiggNode node in this.Subnodes)
{
node.Extract(dir_path, TextureType, NodeExtractType.Relative,
OnlyTextures, Callback);
}
// Extract all files
foreach (PiggLeaf leaf in this.Leafs)
{
if (Callback != null)
{
Callback(leaf);
}
int last = leaf.PiggReferences.Count - 1;
PiggLeafInfo leaf_info = leaf.PiggReferences[last];
if (Path.GetExtension(leaf.Name).ToLower() != ".texture" ||
TextureType == TextureExtractType.Texture)
{
// Check to see if we only want textures.
if (TextureType == TextureExtractType.Texture || !OnlyTextures)
{
// Extract the file as-is.
FileStream fs = new FileStream(dir_path +
Path.DirectorySeparatorChar + leaf.Name,
FileMode.Create, FileAccess.Write, FileShare.Write);
if (fs != null)
{
leaf_info.Extract(fs);
}
fs.Close();
}
}
else
{
PiggTexture tex = new PiggTexture(leaf_info);
string ext = "";
switch (TextureType)
{
case TextureExtractType.Bmp:
ext += ".bmp";
break;
case TextureExtractType.Gif:
ext += ".gif";
break;
case TextureExtractType.Jpeg:
ext += ".jpg";
break;
case TextureExtractType.Original:
ext += Path.GetExtension(tex.Filename).ToLower();
break;
case TextureExtractType.Png:
ext += ".png";
break;
case TextureExtractType.Tiff:
ext += ".tif";
break;
default:
throw new NotSupportedException();
}
FileStream fs = new FileStream(dir_path +
Path.DirectorySeparatorChar +
Path.GetFileNameWithoutExtension(leaf.Name) + ext,
FileMode.Create, FileAccess.Write, FileShare.Write);
tex.Extract(fs, TextureType);
fs.Close();
}
}
}
public HtsNotification(ExtractProgress progress)
{
Progress = progress;
}
public async Task ShowProgress(ExtractProgress progress)
{
await Clients.All.SendAsync("ShowMnchSendProgress", progress);
}
private void OnExtractProgress(string filename, long filelength)
{
var args = new ExtractProgressEventArgs(filename, filelength);
ExtractProgress?.Invoke(this, args);
}
public bool ApplyImage(string wimFile, int imageIndex, string OutputDirectory, IEnumerable <string> referenceWIMs = null, bool PreserveACL = true, IImaging.ProgressCallback progressCallback = null)
{
string title = $"Applying {wimFile.Split('\\').Last()} - Index {imageIndex}";
try
{
CallbackStatus ProgressCallback(ProgressMsg msg, object info, object progctx)
{
switch (msg)
{
case ProgressMsg.ExtractImageBegin:
{
ExtractProgress m = (ExtractProgress)info;
}
break;
case ProgressMsg.ExtractImageEnd:
{
ExtractProgress m = (ExtractProgress)info;
}
break;
case ProgressMsg.ExtractFileStructure:
{
ExtractProgress m = (ExtractProgress)info;
progressCallback?.Invoke($"Applying file structure ({(int)Math.Round((double)m.CurrentFileCount / m.EndFileCount * 100)}%)", 0, true);
}
break;
case ProgressMsg.ExtractStreams:
{
ExtractProgress m = (ExtractProgress)info;
progressCallback?.Invoke(title, (int)Math.Round((double)m.CompletedBytes / m.TotalBytes * 100), false);
}
break;
case ProgressMsg.ExtractMetadata:
{
ExtractProgress m = (ExtractProgress)info;
progressCallback?.Invoke($"Applying metadata ({(int)Math.Round((double)m.CompletedBytes / m.TotalBytes * 100)}%)", 0, true);
}
break;
}
return(CallbackStatus.Continue);
}
using (Wim wim = Wim.OpenWim(wimFile, OpenFlags.None))
{
wim.RegisterCallback(ProgressCallback);
if (referenceWIMs != null && referenceWIMs.Count() > 0)
{
wim.ReferenceResourceFiles(referenceWIMs, RefFlags.None, OpenFlags.None);
}
wim.ExtractImage(imageIndex, OutputDirectory, PreserveACL ? ExtractFlags.StrictAcls : ExtractFlags.NoAcls);
}
}
catch (Exception ex)
{
return(false);
}
return(true);
}
public void CheckErrorTemplate(string fileName, string[] paths, bool printError)
{
string destDir = TestHelper.GetTempDir();
try
{
Directory.CreateDirectory(destDir);
bool[] _checked = new bool[5];
for (int i = 0; i < _checked.Length; i++)
{
_checked[i] = false;
}
CallbackStatus ProgressCallback(ProgressMsg msg, object info, object progctx)
{
switch (msg)
{
case ProgressMsg.ExtractTreeBegin:
{
ExtractProgress m = (ExtractProgress)info;
Assert.IsNotNull(m);
_checked[0] = true;
}
break;
case ProgressMsg.ExtractTreeEnd:
{
ExtractProgress m = (ExtractProgress)info;
Assert.IsNotNull(m);
_checked[1] = true;
}
break;
case ProgressMsg.ExtractFileStructure:
{
ExtractProgress m = (ExtractProgress)info;
Assert.IsNotNull(m);
_checked[2] = true;
}
break;
case ProgressMsg.ExtractStreams:
{
ExtractProgress m = (ExtractProgress)info;
Assert.IsNotNull(m);
_checked[3] = true;
}
break;
case ProgressMsg.ExtractMetadata:
{
ExtractProgress m = (ExtractProgress)info;
Assert.IsNotNull(m);
_checked[4] = true;
}
break;
}
return(CallbackStatus.Continue);
}
string wimFile = Path.Combine(TestSetup.SampleDir, fileName);
using (Wim wim = Wim.OpenWim(wimFile, OpenFlags.None))
{
wim.RegisterCallback(ProgressCallback);
wim.ExtractPaths(1, destDir, paths, ExtractFlags.GlobPaths);
}
// The callback must not have been called
Assert.IsFalse(_checked.Any(x => x));
// The files must not exist
foreach (string path in paths.Select(x => TestHelper.NormalizePath(x.TrimStart('\\'))))
{
if (path.IndexOfAny(new char[] { '*', '?' }) == -1)
{ // No wlidcard
Assert.IsFalse(File.Exists(Path.Combine(destDir, path)));
}
else
{ // With wildcard
string destFullPath = Path.Combine(destDir, path);
string[] files = Directory.GetFiles(Path.GetDirectoryName(destFullPath), Path.GetFileName(destFullPath), SearchOption.AllDirectories);
Assert.IsFalse(0 < files.Length);
}
}
// Read error message
string[] errorMsgs = Wim.GetErrors();
ErrorPrintState printState = Wim.ErrorPrintState;
if (printError)
{
Assert.IsNotNull(errorMsgs);
Assert.AreEqual(ErrorPrintState.PrintOn, printState);
Assert.IsTrue(0 < errorMsgs.Length);
foreach (string errorMsg in errorMsgs)
{
Console.WriteLine(errorMsg);
}
}
else
{
Assert.IsNull(errorMsgs);
Assert.AreEqual(ErrorPrintState.PrintOff, printState);
}
}
finally
{
if (Directory.Exists(destDir))
{
Directory.Delete(destDir, true);
}
}
}
public void ExtractImageTemplate(string wimFileName)
{
string wimFile = Path.Combine(TestSetup.SampleDir, wimFileName);
string destDir = TestHelper.GetTempDir();
try
{
Directory.CreateDirectory(destDir);
bool[] _checked = new bool[5];
for (int i = 0; i < _checked.Length; i++)
{
_checked[i] = false;
}
CallbackStatus ProgressCallback(ProgressMsg msg, object info, object progctx)
{
switch (msg)
{
case ProgressMsg.ExtractImageBegin:
{
ExtractProgress m = (ExtractProgress)info;
Assert.IsNotNull(m);
Assert.IsTrue(m.ImageName.Equals("Sample", StringComparison.Ordinal));
_checked[0] = true;
}
break;
case ProgressMsg.ExtractImageEnd:
{
ExtractProgress m = (ExtractProgress)info;
Assert.IsNotNull(m);
Assert.IsTrue(m.ImageName.Equals("Sample", StringComparison.Ordinal));
_checked[1] = true;
}
break;
case ProgressMsg.ExtractFileStructure:
{
ExtractProgress m = (ExtractProgress)info;
Assert.IsNotNull(m);
Assert.IsTrue(m.ImageName.Equals("Sample", StringComparison.Ordinal));
_checked[2] = true;
}
break;
case ProgressMsg.ExtractStreams:
{
ExtractProgress m = (ExtractProgress)info;
Assert.IsNotNull(m);
Assert.IsTrue(m.ImageName.Equals("Sample", StringComparison.Ordinal));
_checked[3] = true;
}
break;
case ProgressMsg.ExtractMetadata:
{
ExtractProgress m = (ExtractProgress)info;
Assert.IsNotNull(m);
Assert.IsTrue(m.ImageName.Equals("Sample", StringComparison.Ordinal));
_checked[4] = true;
}
break;
}
return(CallbackStatus.Continue);
}
using (Wim wim = Wim.OpenWim(wimFile, OpenFlags.None))
{
wim.RegisterCallback(ProgressCallback);
WimInfo wi = wim.GetWimInfo();
Assert.IsTrue(wi.ImageCount == 1);
wim.ExtractImage(1, destDir, ExtractFlags.None);
}
Assert.IsTrue(_checked.All(x => x));
TestHelper.CheckFileSystem(SampleSet.Src01, destDir);
}
finally
{
if (Directory.Exists(destDir))
{
Directory.Delete(destDir, true);
}
}
}
public void ExtractListTemplate(string fileName, string[] paths)
{
string destDir = TestHelper.GetTempDir();
try
{
Directory.CreateDirectory(destDir);
bool[] _checked = new bool[5];
for (int i = 0; i < _checked.Length; i++)
{
_checked[i] = false;
}
CallbackStatus ProgressCallback(ProgressMsg msg, object info, object progctx)
{
switch (msg)
{
case ProgressMsg.ExtractTreeBegin:
{
ExtractProgress m = (ExtractProgress)info;
Assert.IsNotNull(m);
_checked[0] = true;
}
break;
case ProgressMsg.ExtractTreeEnd:
{
ExtractProgress m = (ExtractProgress)info;
Assert.IsNotNull(m);
_checked[1] = true;
}
break;
case ProgressMsg.ExtractFileStructure:
{
ExtractProgress m = (ExtractProgress)info;
Assert.IsNotNull(m);
_checked[2] = true;
}
break;
case ProgressMsg.ExtractStreams:
{
ExtractProgress m = (ExtractProgress)info;
Assert.IsNotNull(m);
_checked[3] = true;
}
break;
case ProgressMsg.ExtractMetadata:
{
ExtractProgress m = (ExtractProgress)info;
Assert.IsNotNull(m);
_checked[4] = true;
}
break;
}
return(CallbackStatus.Continue);
}
string listFile = Path.Combine(destDir, "ListFile.txt");
using (StreamWriter w = new StreamWriter(listFile, false, Encoding.Unicode))
{
foreach (string path in paths)
{
w.WriteLine(path);
}
}
string wimFile = Path.Combine(TestSetup.SampleDir, fileName);
using (Wim wim = Wim.OpenWim(wimFile, OpenFlags.None))
{
wim.RegisterCallback(ProgressCallback);
wim.ExtractPathList(1, destDir, listFile, ExtractFlags.GlobPaths);
}
Assert.IsTrue(_checked.All(x => x));
foreach (string path in paths.Select(x => TestHelper.NormalizePath(x.TrimStart('\\'))))
{
if (path.IndexOfAny(new char[] { '*', '?' }) == -1)
{ // No wlidcard
Assert.IsTrue(File.Exists(Path.Combine(destDir, path)));
}
else
{ // With wildcard
string destFullPath = Path.Combine(destDir, path);
string[] files = Directory.GetFiles(Path.GetDirectoryName(destFullPath), Path.GetFileName(destFullPath), SearchOption.AllDirectories);
Assert.IsTrue(0 < files.Length);
}
}
}
finally
{
if (Directory.Exists(destDir))
{
Directory.Delete(destDir, true);
}
}
}
/// <summary>
/// Convert a input file into a output file with a user specified format.
/// </summary>
/// </summary>
/// <param name="inFile"></param>
/// <param name="fileIdx"></param>
public void ConvertFile(string inFile, int fileIdx)
{
LogList.Clear();
ExtractProgress.Reset();
// check whether MsFileReaderLib is installed if the input file is a RAW file;
if (inFile.ToLower().EndsWith(".raw"))
{
//if (!Utils.verifyProgramInstalled())
//{
// Console.WriteLine("\nERROR: Not found the necessary program to read RAW files ! Please verify that the program is installed in your computer.\n");
// LogList.Add("ERROR: Not found the necessary program to read Raw files ! Please verify that the program is installed in your computer.\n");
// errorFiles = true;
// return;
//}
}
int totalFileNum = inputFiles.Count;
CurrentFileLabel = "File " + (fileIdx + 1) + " / " + totalFileNum;
Console.WriteLine(" Starting to convert file " + (fileIdx + 1) + " / " + totalFileNum + "...");
LogList.Add(" Starting to convert file " + (fileIdx + 1) + " / " + totalFileNum + "...");
if (inFile.EndsWith(".ms2", true, curCultInfo) && mgfConverter)
{
Console.WriteLine(" Parsing MS2 file: " + inFile + " . . . ");
LogList.Add(" Parsing MS2 file: " + inFile + " . . . ");
MS2Converter mc = new MS2Converter(inFile, OutFileFolder, outFileTypes, correctPrecMz);
mc.SetOptions(MzDecimalPlace, IntensityDecimalPlace);
mc.Convert(ExtractProgress);
mc.Close();
}
else if (inFile.EndsWith(".mgf", true, curCultInfo) && ms2Converter)
{
Console.WriteLine(" Parsing MGF file: " + inFile + " . . . ");
LogList.Add(" Parsing MGF file: " + inFile + " . . . ");
MgfConverter mc = new MgfConverter(inFile, OutFileFolder, outFileTypes[0]);
mc.SetOptions(MzDecimalPlace, IntensityDecimalPlace, DDADataChargeStates);
mc.Convert(ExtractProgress);
LogList.Add(" Conversion finished");
}
else if (inFile.EndsWith(".raw", true, curCultInfo))
{
Console.WriteLine(" Parsing RAW file: " + inFile + " . . . ");
LogList.Add(" Parsing RAW file: " + inFile + " . . . ");
ByPassThermoAlgorithm = true;
RawFileConverter rc = new RawFileConverter(inFile, OutFileFolder, outFileTypes, ExpType, exportChargeState);
rc.SetOptions(isCentroided, MzDecimalPlace, IntensityDecimalPlace, ExtractPrecursorByMz, ByPassThermoAlgorithm,
correctPrecMz, correctPrecZ, predictPrecursors, DDADataChargeStates, Ms2PrecZ,
showPeakChargeStates, showPeakResolution, exportChargeState);
rc.Convert(ExtractProgress);
rc.Close();
}
else if (inFile.EndsWith(".mzxml", true, curCultInfo))
{
Console.WriteLine(" Parsing mzXML file: " + inFile + " . . . ");
LogList.Add(" Parsing mzXML file: " + inFile + " . . . ");
MzXMLConverter mc = new MzXMLConverter(inFile, OutFileFolder, outFileTypes, ExpType);
mc.SetOptions(MzDecimalPlace, IntensityDecimalPlace);
mc.Convert(ExtractProgress);
mc.Close();
}
else if (inFile.EndsWith(".mzml", true, curCultInfo))
{
Console.WriteLine(" Parsing mzML file: " + inFile + " . . . ");
LogList.Add(" Parsing mzML file: " + inFile + " . . . ");
MzMLConverter mc = new MzMLConverter(inFile, OutFileFolder, outFileTypes);
mc.SetOptions(MzDecimalPlace, IntensityDecimalPlace, correctPrecMz);
mc.Convert(ExtractProgress);
mc.Close();
}
//ExtractProgress.CurrentProgress = 100;
LogList.Add(" \n");
}
public MnchNotification(ExtractProgress progress)
{
Progress = progress;
}
