private async void Refresh()
{
images.Clear();
lblStatus.UpdateText("Retreiving Mounted Images");
await Task.Factory.StartNew(() =>
{
try
{
images = Wim.GetMounted();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
});
if (!string.IsNullOrWhiteSpace(lastImage) && !images.Any(w => w.WimPath.EqualsIgnoreCase(lastImage)))
{
lblStatus.UpdateText("Loading previous image...");
await LoadWIM(lastImage);
}
DefineGroup();
dgImages.Items.Refresh();
lblStatus.UpdateText("Idle.");
}
public void ApplyProgress_Template(string fileName)
{
string destDir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
try
{
CallbackTested tested = new CallbackTested(false);
string wimFile = Path.Combine(TestSetup.BaseDir, "Samples", fileName);
using (Wim wim = Wim.OpenWim(wimFile, WimLibOpenFlags.DEFAULT, ApplyProgress_Callback, tested))
{
wim.ExtractImage(1, destDir, WimLibExtractFlags.DEFAULT);
}
Assert.IsTrue(tested.Value);
TestHelper.CheckSample01(destDir);
}
finally
{
if (Directory.Exists(destDir))
{
Directory.Delete(destDir, true);
}
}
}
public void SetWimInfo_Template(string wimFileName, uint bootIndex)
{
string srcWim = Path.Combine(TestSetup.SampleDir, wimFileName);
string destWim = Path.GetTempFileName();
try
{
File.Copy(srcWim, destWim, true);
using (Wim wim = Wim.OpenWim(destWim, OpenFlags.WRITE_ACCESS))
{
WimInfo info = new WimInfo
{
BootIndex = bootIndex,
};
wim.SetWimInfo(info, ChangeFlags.BOOT_INDEX);
wim.Overwrite(WriteFlags.DEFAULT, Wim.DefaultThreads);
}
using (Wim wim = Wim.OpenWim(destWim, OpenFlags.DEFAULT))
{
WimInfo info = wim.GetWimInfo();
Assert.IsTrue(info.BootIndex == bootIndex);
}
}
finally
{
if (File.Exists(destWim))
{
File.Delete(destWim);
}
}
}
private async Task <ObservableCollection <_WimImage> > LoadWIM(string wimPath)
{
ObservableCollection <_WimImage> result = new ObservableCollection <_WimImage>();
try
{
await Task.Factory.StartNew(() =>
{
result = Wim.GetWIM(wimPath);
});
if (result.Count > 0)
{
images = new ObservableCollection <_WimImage>(images.Concat(result).Distinct());
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
return(result);
// DefineGroup();
// dgImages.Items.Refresh();
sbProgress.Visibility = sbTime.Visibility = Visibility.Collapsed;
lblStatus.UpdateText("Idle.");
}
public static void CheckWimPath(SampleSet set, string wimFile)
{
switch (set)
{
case SampleSet.Src01:
using (Wim wim = Wim.OpenWim(wimFile, OpenFlags.None))
{
Assert.IsTrue(wim.DirExists(1, Path.Combine(@"\", "ABCD")));
Assert.IsTrue(wim.DirExists(1, Path.Combine(@"\", "ABCD", "Z")));
Assert.IsTrue(wim.DirExists(1, Path.Combine(@"\", "ABDE")));
Assert.IsTrue(wim.DirExists(1, Path.Combine(@"\", "ABDE", "Z")));
Assert.IsTrue(wim.FileExists(1, Path.Combine(@"\", "ACDE.txt")));
Assert.IsTrue(wim.FileExists(1, Path.Combine(@"\", "ABCD", "A.txt")));
Assert.IsTrue(wim.FileExists(1, Path.Combine(@"\", "ABCD", "B.txt")));
Assert.IsTrue(wim.FileExists(1, Path.Combine(@"\", "ABCD", "C.txt")));
Assert.IsTrue(wim.FileExists(1, Path.Combine(@"\", "ABCD", "D.ini")));
Assert.IsTrue(wim.FileExists(1, Path.Combine(@"\", "ABCD", "Z", "X.txt")));
Assert.IsTrue(wim.FileExists(1, Path.Combine(@"\", "ABCD", "Z", "Y.ini")));
Assert.IsTrue(wim.FileExists(1, Path.Combine(@"\", "ABDE", "A.txt")));
Assert.IsTrue(wim.FileExists(1, Path.Combine(@"\", "ABDE", "Z", "X.txt")));
Assert.IsTrue(wim.FileExists(1, Path.Combine(@"\", "ABDE", "Z", "Y.ini")));
}
break;
case SampleSet.Src02:
using (Wim wim = Wim.OpenWim(wimFile, OpenFlags.None))
{
Assert.IsTrue(wim.DirExists(1, Path.Combine(@"\", "B")));
Assert.IsTrue(wim.FileExists(1, Path.Combine(@"\", "A.txt")));
Assert.IsTrue(wim.FileExists(1, Path.Combine(@"\", "B", "C.txt")));
Assert.IsTrue(wim.FileExists(1, Path.Combine(@"\", "B", "D.ini")));
Assert.IsTrue(wim.DirExists(2, Path.Combine(@"\", "B")));
Assert.IsTrue(wim.FileExists(2, Path.Combine(@"\", "Z.txt")));
Assert.IsTrue(wim.FileExists(2, Path.Combine(@"\", "B", "C.txt")));
Assert.IsTrue(wim.FileExists(2, Path.Combine(@"\", "B", "D.ini")));
Assert.IsTrue(wim.DirExists(3, Path.Combine(@"\", "B")));
Assert.IsTrue(wim.FileExists(3, Path.Combine(@"\", "Y.txt")));
Assert.IsTrue(wim.FileExists(3, Path.Combine(@"\", "Z.txt")));
Assert.IsTrue(wim.FileExists(3, Path.Combine(@"\", "B", "C.txt")));
Assert.IsTrue(wim.FileExists(3, Path.Combine(@"\", "B", "D.ini")));
}
break;
case SampleSet.Src03:
break;
default:
throw new NotImplementedException();
}
}
public bool CaptureImage(string wimFile, string imageName, string imageDescription, string InputDirectory, CompressionType compressionType = CompressionType.LZX, AddFlags addFlags = AddFlags.DEFAULT, ProgressCallback progressCallback = null)
{
string title = $"Creating {wimFile.Split('\\').Last()}";
try
{
CallbackStatus ProgressCallback(ProgressMsg msg, object info, object progctx)
{
switch (msg)
{
case ProgressMsg.SCAN_BEGIN:
{
ProgressInfo_Scan m = (ProgressInfo_Scan)info;
progressCallback?.Invoke($"Scanning files ({m.NumBytesScanned} bytes scanned, Current directory: {m.CurPath})", 0, true);
}
break;
case ProgressMsg.SCAN_END:
{
ProgressInfo_Scan m = (ProgressInfo_Scan)info;
progressCallback?.Invoke($"Scanning files ({m.NumBytesScanned} bytes scanned, Current directory: {m.CurPath})", 0, true);
}
break;
case ProgressMsg.WRITE_METADATA_BEGIN:
break;
case ProgressMsg.WRITE_STREAMS:
{
ProgressInfo_WriteStreams m = (ProgressInfo_WriteStreams)info;
progressCallback?.Invoke(title, (int)Math.Round((double)m.CompletedBytes / m.TotalBytes * 100), false);
}
break;
case ProgressMsg.WRITE_METADATA_END:
break;
}
return(CallbackStatus.CONTINUE);
}
using (Wim wim = Wim.CreateNewWim((ManagedWimLib.CompressionType)compressionType))
{
wim.RegisterCallback(ProgressCallback);
wim.AddImage(InputDirectory, imageName, null, (ManagedWimLib.AddFlags)addFlags);
if (!string.IsNullOrEmpty(imageDescription))
{
wim.SetImageDescription(1, imageDescription);
}
wim.Write(wimFile, Wim.AllImages, WriteFlags.DEFAULT, Wim.DefaultThreads);
}
}
catch
{
return(false);
}
return(true);
}
public void JoinProgressTemplate(string[] splitWimNames)
{
string[] splitWims = splitWimNames.Select(x => Path.Combine(TestSetup.SampleDir, x)).ToArray();
string destDir = TestHelper.GetTempDir();
string destWim = Path.Combine(destDir, "Dest.wim");
try
{
Directory.CreateDirectory(destDir);
bool[] _checked = new bool[3];
for (int i = 0; i < _checked.Length; i++)
{
_checked[i] = false;
}
CallbackStatus ProgressCallback(ProgressMsg msg, object info, object progctx)
{
switch (msg)
{
case ProgressMsg.WriteMetadataBegin:
Assert.IsNull(info);
_checked[0] = true;
break;
case ProgressMsg.WriteMetadataEnd:
Assert.IsNull(info);
_checked[1] = true;
break;
case ProgressMsg.WriteStreams:
{
WriteStreamsProgress m = (WriteStreamsProgress)info;
Assert.IsNotNull(m);
Assert.AreEqual(m.CompressionType, CompressionType.LZX);
_checked[2] = true;
}
break;
}
return(CallbackStatus.Continue);
}
Wim.Join(splitWims, destWim, OpenFlags.None, WriteFlags.None, ProgressCallback);
Assert.IsTrue(_checked.All(x => x));
TestHelper.CheckWimPath(SampleSet.Src03, destWim);
}
finally
{
if (Directory.Exists(destDir))
{
Directory.Delete(destDir, true);
}
}
}
public void RenamePath_Template(string wimFileName, string srcPath)
{
string srcWim = Path.Combine(TestSetup.SampleDir, wimFileName);
string destDir = TestHelper.GetTempDir();
string destWim = Path.Combine(destDir, wimFileName);
try
{
Directory.CreateDirectory(destDir);
File.Copy(srcWim, destWim, true);
bool[] _checked = new bool[2];
for (int i = 0; i < _checked.Length; i++)
{
_checked[i] = false;
}
CallbackStatus ProgressCallback(ProgressMsg msg, object info, object progctx)
{
switch (msg)
{
case ProgressMsg.WRITE_METADATA_BEGIN:
Assert.IsNull(info);
_checked[0] = true;
break;
case ProgressMsg.WRITE_METADATA_END:
Assert.IsNull(info);
_checked[1] = true;
break;
}
return(CallbackStatus.CONTINUE);
}
using (Wim wim = Wim.OpenWim(destWim, OpenFlags.WRITE_ACCESS))
{
wim.RegisterCallback(ProgressCallback);
Assert.IsTrue(wim.PathExists(1, srcPath));
wim.RenamePath(1, srcPath, "REN");
wim.Overwrite(WriteFlags.DEFAULT, Wim.DefaultThreads);
Assert.IsTrue(_checked.All(x => x));
Assert.IsFalse(wim.PathExists(1, srcPath));
Assert.IsTrue(wim.PathExists(1, "REN"));
}
}
finally
{
if (Directory.Exists(destDir))
{
Directory.Delete(destDir, true);
}
}
}
public void JoinProgress_Template(string[] splitWimNames)
{
string[] splitWims = splitWimNames.Select(x => Path.Combine(TestSetup.SampleDir, x)).ToArray();
string destDir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
string destWim = Path.Combine(TestSetup.SampleDir, "Dest.wim");
try
{
Directory.CreateDirectory(destDir);
bool[] _checked = new bool[3];
for (int i = 0; i < _checked.Length; i++)
{
_checked[i] = false;
}
CallbackStatus ProgressCallback(ProgressMsg msg, object info, object progctx)
{
switch (msg)
{
case ProgressMsg.WRITE_METADATA_BEGIN:
Assert.IsNull(info);
_checked[0] = true;
break;
case ProgressMsg.WRITE_METADATA_END:
Assert.IsNull(info);
_checked[1] = true;
break;
case ProgressMsg.WRITE_STREAMS:
{
ProgressInfo_WriteStreams m = (ProgressInfo_WriteStreams)info;
Assert.IsNotNull(m);
Assert.AreEqual(m.CompressionType, CompressionType.LZX);
_checked[2] = true;
}
break;
}
return(CallbackStatus.CONTINUE);
}
Wim.Join(splitWims, destWim, OpenFlags.DEFAULT, WriteFlags.DEFAULT, ProgressCallback);
Assert.IsTrue(_checked.All(x => x));
TestHelper.CheckWimPath(SampleSet.Src03, destWim);
}
finally
{
if (Directory.Exists(destDir))
{
Directory.Delete(destDir, true);
}
}
}
public void ResolveImageTemplate(string fileName, string imageNameOrNum, int expected)
{
string wimFile = Path.Combine(TestSetup.SampleDir, fileName);
using (Wim wim = Wim.OpenWim(wimFile, OpenFlags.None))
{
int imageIndex = wim.ResolveImage(imageNameOrNum);
Assert.AreEqual(expected, imageIndex);
}
}
public void ResolveImage_Template(string fileName, string imageNameOrNum, int comp)
{
string wimFile = Path.Combine(TestSetup.SampleDir, fileName);
using (Wim wim = Wim.OpenWim(wimFile, OpenFlags.DEFAULT))
{
int imageIndex = wim.ResolveImage(imageNameOrNum);
Assert.AreEqual(imageIndex, comp);
}
}
public void IsImageNameInUse_Template(string fileName, string imageName, bool comp)
{
string wimFile = Path.Combine(TestSetup.SampleDir, fileName);
using (Wim wim = Wim.OpenWim(wimFile, OpenFlags.DEFAULT))
{
bool ret = wim.IsImageNameInUse(imageName);
Assert.AreEqual(ret, comp);
}
}
public static void IsImageNameInUseTemplate(string fileName, string imageName, bool expected)
{
string wimFile = Path.Combine(TestSetup.SampleDir, fileName);
using (Wim wim = Wim.OpenWim(wimFile, OpenFlags.None))
{
bool ret = wim.IsImageNameInUse(imageName);
Assert.AreEqual(expected, ret);
}
}
public void AddEmptyImage_Template(CompressionType compType, string wimFileName, AddFlags addFlags = AddFlags.DEFAULT)
{
string destDir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
try
{
Directory.CreateDirectory(destDir);
bool[] _checked = new bool[2];
for (int i = 0; i < _checked.Length; i++)
{
_checked[i] = false;
}
CallbackStatus ProgressCallback(ProgressMsg msg, object info, object progctx)
{
switch (msg)
{
case ProgressMsg.WRITE_METADATA_BEGIN:
Assert.IsNull(info);
_checked[0] = true;
break;
case ProgressMsg.WRITE_METADATA_END:
Assert.IsNull(info);
_checked[1] = true;
break;
}
return(CallbackStatus.CONTINUE);
}
// Capture Wim
string wimFile = Path.Combine(destDir, wimFileName);
using (Wim wim = Wim.CreateNewWim(compType))
{
wim.RegisterCallback(ProgressCallback);
wim.AddEmptyImage("UnitTest");
wim.Write(wimFile, Wim.AllImages, WriteFlags.DEFAULT, Wim.DefaultThreads);
WimInfo wi = wim.GetWimInfo();
Assert.IsTrue(wi.ImageCount == 1);
}
for (int i = 0; i < _checked.Length; i++)
{
Assert.IsTrue(_checked[i]);
}
}
finally
{
if (Directory.Exists(destDir))
{
Directory.Delete(destDir, true);
}
}
}
public void DeletePathTemplate(string wimFileName, string deletePath)
{
string srcWim = Path.Combine(TestSetup.SampleDir, wimFileName);
string destDir = TestHelper.GetTempDir();
string destWim = Path.Combine(destDir, wimFileName);
try
{
Directory.CreateDirectory(destDir);
File.Copy(srcWim, destWim, true);
bool[] _checked = new bool[2];
for (int i = 0; i < _checked.Length; i++)
{
_checked[i] = false;
}
CallbackStatus ProgressCallback(ProgressMsg msg, object info, object progctx)
{
switch (msg)
{
case ProgressMsg.WriteMetadataBegin:
Assert.IsNull(info);
_checked[0] = true;
break;
case ProgressMsg.WriteMetadataEnd:
Assert.IsNull(info);
_checked[1] = true;
break;
}
return(CallbackStatus.Continue);
}
using (Wim wim = Wim.OpenWim(destWim, OpenFlags.WriteAccess))
{
wim.RegisterCallback(ProgressCallback);
Assert.IsTrue(wim.PathExists(1, deletePath));
wim.DeletePath(1, deletePath, DeleteFlags.Recursive);
wim.Overwrite(WriteFlags.None, Wim.DefaultThreads);
Assert.IsTrue(_checked.All(x => x));
Assert.IsFalse(wim.PathExists(1, deletePath));
}
}
finally
{
if (Directory.Exists(destDir))
{
Directory.Delete(destDir, true);
}
}
}
public static void GetXmlDataTemplate(string fileName, string compXml)
{
string wimFile = Path.Combine(TestSetup.SampleDir, fileName);
using (Wim wim = Wim.OpenWim(wimFile, OpenFlags.None))
{
string wimXml = wim.GetXmlData();
Assert.IsTrue(wimXml.Equals(compXml, StringComparison.InvariantCulture));
}
}
private static void InitWimLib()
{
if (Environment.Is64BitProcess)
{
Wim.GlobalInit(Path.Combine("x64", "libwim-15.dll"));
}
else
{
Wim.GlobalInit(Path.Combine("x86", "libwim-15.dll"));
}
}
private static void InitNativeLibrary()
{
string arch = null;
switch (RuntimeInformation.OSArchitecture)
{
case Architecture.X86:
arch = "x86";
break;
case Architecture.X64:
arch = "x64";
break;
case Architecture.Arm:
arch = "armhf";
break;
case Architecture.Arm64:
arch = "arm64";
break;
}
var runningDirectory = Process.GetCurrentProcess().MainModule.FileName.Contains("\\") ? string.Join("\\", Process.GetCurrentProcess().MainModule.FileName.Split('\\').Reverse().Skip(1).Reverse()) : "";
string libPath = null;
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
libPath = Path.Combine(runningDirectory, arch, "libwim-15.dll");
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
libPath = Path.Combine(runningDirectory, arch, "libwim.so");
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
libPath = Path.Combine(runningDirectory, arch, "libwim.dylib");
}
if (libPath == null || !File.Exists(libPath))
{
throw new PlatformNotSupportedException();
}
try
{
Wim.GlobalInit(libPath);
}
catch (InvalidOperationException)
{
// Lib already initialized
}
}
public static void GetImageInfoTemplate(string wimFileName, int imageIndex, string imageName, string imageDesc)
{
string wimFile = Path.Combine(TestSetup.SampleDir, wimFileName);
using (Wim wim = Wim.OpenWim(wimFile, OpenFlags.None))
{
Assert.IsTrue(imageName.Equals(wim.GetImageName(imageIndex), StringComparison.Ordinal));
Assert.IsNull(wim.GetImageDescription(imageIndex));
Assert.IsNull(wim.GetImageProperty(imageIndex, "DESCRIPTION"));
}
}
public void ReferenceTemplateImage_Template(string wimFileName, string captureDir, SampleSet set)
{
string destDir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
try
{
Directory.CreateDirectory(destDir);
string srcDir = Path.Combine(TestSetup.SampleDir, captureDir);
string srcWimFile = Path.Combine(TestSetup.SampleDir, wimFileName);
string destWimFile = Path.Combine(destDir, wimFileName);
File.Copy(srcWimFile, destWimFile, true);
int imageCount;
using (Wim wim = Wim.OpenWim(destWimFile, OpenFlags.WRITE_ACCESS))
{
WimInfo wi = wim.GetWimInfo();
imageCount = (int)wi.ImageCount;
wim.AddImage(srcDir, "UnitTest", null, AddFlags.DEFAULT);
wim.ReferenceTemplateImage(imageCount + 1, 1);
wim.Overwrite(WriteFlags.DEFAULT, Wim.DefaultThreads);
}
List <Tuple <string, bool> > entries = new List <Tuple <string, bool> >();
CallbackStatus IterateCallback(DirEntry dentry, object userData)
{
string path = dentry.FullPath;
bool isDir = (dentry.Attributes & FileAttribute.DIRECTORY) != 0;
entries.Add(new Tuple <string, bool>(path, isDir));
return(CallbackStatus.CONTINUE);
}
string wimFile = Path.Combine(TestSetup.SampleDir, wimFileName);
using (Wim wim = Wim.OpenWim(destWimFile, OpenFlags.DEFAULT))
{
wim.IterateDirTree(imageCount + 1, Wim.RootPath, IterateFlags.RECURSIVE, IterateCallback);
}
TestHelper.CheckPathList(set, entries);
}
finally
{
if (Directory.Exists(destDir))
{
Directory.Delete(destDir, true);
}
}
}
public void AddEmptyImageTemplate(CompressionType compType, string wimFileName)
{
string destDir = TestHelper.GetTempDir();
try
{
bool[] _checked = new bool[2];
for (int i = 0; i < _checked.Length; i++)
{
_checked[i] = false;
}
CallbackStatus ProgressCallback(ProgressMsg msg, object info, object progctx)
{
switch (msg)
{
case ProgressMsg.WriteMetadataBegin:
Assert.IsNull(info);
_checked[0] = true;
break;
case ProgressMsg.WriteMetadataEnd:
Assert.IsNull(info);
_checked[1] = true;
break;
}
return(CallbackStatus.Continue);
}
// Capture Wim
string wimFile = Path.Combine(destDir, wimFileName);
using (Wim wim = Wim.CreateNewWim(compType))
{
wim.RegisterCallback(ProgressCallback);
wim.AddEmptyImage("UnitTest");
wim.Write(wimFile, Wim.AllImages, WriteFlags.None, Wim.DefaultThreads);
WimInfo wi = wim.GetWimInfo();
Assert.IsTrue(wi.ImageCount == 1);
}
for (int i = 0; i < _checked.Length; i++)
{
Assert.IsTrue(_checked[i]);
}
}
finally
{
if (Directory.Exists(destDir))
{
Directory.Delete(destDir, true);
}
}
}
public override async Task ApplyImage(Volume volume, string imagePath, int imageIndex = 1, IObserver <double> progressObserver = null)
{
EnsureValidParameters(volume, imagePath, imageIndex);
await Task.Run(() =>
{
using (var wim = Wim.OpenWim(imagePath, OpenFlags.DEFAULT, (msg, info, callback) => UpdatedStatusCallback(msg, info, callback, progressObserver)))
{
wim.ExtractImage(imageIndex, volume.RootDir.Name, ExtractFlags.DEFAULT);
}
});
}
public void GetLastError()
{
string[] paths = new string[] { @"\NOTEXIST.bin", @"NOTGLOB?.cue" };
// Default is Wim.SetPrintErrors(true);
CheckErrorTemplate("XPRESS.wim", paths, true);
Wim.SetPrintErrors(false);
CheckErrorTemplate("LZX.wim", paths, false);
Wim.SetPrintErrors(true);
CheckErrorTemplate("LZMS.wim", paths, true);
}
public static void Init(TestContext context)
{
_ = context;
string absPath = TestHelper.GetProgramAbsolutePath();
BaseDir = Path.GetFullPath(Path.Combine(absPath, "..", "..", ".."));
SampleDir = Path.Combine(BaseDir, "Samples");
string libPath = GetNativeLibPath();
Wim.GlobalInit(libPath);
}
public void GetImageInfo()
{
Version ver = Wim.GetVersion();
Assert.AreEqual(new Version(1, 13, 1), ver);
Tuple <ushort, ushort, ushort> tuple = Wim.GetVersionTuple();
Assert.AreEqual(new Tuple <ushort, ushort, ushort>(1, 13, 1), tuple);
string str = Wim.GetVersionString();
Assert.IsTrue(str.Equals("1.13.1", StringComparison.Ordinal));
}
public static void Init(TestContext context)
{
BaseDir = Path.GetFullPath(Path.Combine(TestHelper.GetProgramAbsolutePath(), "..", "..", ".."));
SampleDir = Path.Combine(BaseDir, "Samples");
const string x64 = "x64";
const string x86 = "x86";
const string armhf = "armhf";
const string arm64 = "arm64";
const string dllName = "libwim-15.dll";
const string soName = "libwim.so";
string libPath = null;
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
switch (RuntimeInformation.ProcessArchitecture)
{
case Architecture.X86:
libPath = Path.Combine(x86, dllName);
break;
case Architecture.X64:
libPath = Path.Combine(x64, dllName);
break;
}
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
switch (RuntimeInformation.ProcessArchitecture)
{
case Architecture.X64:
libPath = Path.Combine(x64, soName);
break;
case Architecture.Arm:
libPath = Path.Combine(armhf, soName);
break;
case Architecture.Arm64:
libPath = Path.Combine(arm64, soName);
break;
}
}
if (libPath == null)
throw new PlatformNotSupportedException();
Wim.GlobalInit(libPath);
}
public bool ExportImage(string wimFile, int imageIndex, string outputWIMFile, CompressionType compressionType = CompressionType.LZX, ExportFlags exportFlags = ExportFlags.DEFAULT, ProgressCallback progressCallback = null)
{
string title = $"Exporting {wimFile.Split('\\').Last()} - Index {imageIndex}";
try
{
CallbackStatus ProgressCallback(ProgressMsg msg, object info, object progctx)
{
switch (msg)
{
case ProgressMsg.WRITE_STREAMS:
{
ProgressInfo_WriteStreams m = (ProgressInfo_WriteStreams)info;
progressCallback?.Invoke(title, (int)Math.Round((double)m.CompletedBytes / m.TotalBytes * 100), false);
}
break;
case ProgressMsg.WRITE_METADATA_BEGIN:
break;
case ProgressMsg.WRITE_METADATA_END:
break;
}
return(CallbackStatus.CONTINUE);
}
using (Wim srcWim = Wim.OpenWim(wimFile, OpenFlags.DEFAULT))
{
string imageName = srcWim.GetImageName(imageIndex);
using (Wim destWim = Wim.CreateNewWim((ManagedWimLib.CompressionType)compressionType))
{
destWim.RegisterCallback(ProgressCallback);
srcWim.ExportImage(imageIndex, destWim, imageName, null, (ManagedWimLib.ExportFlags)exportFlags);
destWim.Write(outputWIMFile, Wim.AllImages, WriteFlags.DEFAULT, Wim.DefaultThreads);
}
}
}
catch
{
return(false);
}
return(true);
}
public bool MarkImageAsBootable(string wimFile, int imageIndex)
{
try
{
using (Wim wim = Wim.OpenWim(wimFile, OpenFlags.None))
{
wim.SetWimInfo(new ManagedWimLib.WimInfo()
{
BootIndex = (uint)imageIndex
}, ChangeFlags.BootIndex);
wim.Overwrite(WriteFlags.None, Wim.DefaultThreads);
}
}
catch
{
return(false);
}
return(true);
}
private void Export_image(string loc1, string loc2, int index, int compression)
{
if (Tools_location.Conversion.convert_path_type == "Folder")
{
}
if (Tools_location.Conversion.convert_path_type == "ISO")
{
}
else
{
Wim.GlobalInit("libwim-15.dll");
Wim x = Wim.OpenWim(loc1, 0);
if (Tools_location.Conversion.to_convert_part_type == "SWM")
{
ulong partSize = (ulong)(Tools_location.Conversion.swm_partition_type * 1024);
x.Split(Tools_location.Conversion.to_convert_path, partSize, WriteFlags.DEFAULT);
}
switch (compression)
{
case 0:
y = Wim.CreateNewWim(CompressionType.NONE);
break;
case 1:
y = Wim.CreateNewWim(CompressionType.XPRESS);
break;
case 2:
y = Wim.CreateNewWim(CompressionType.LZMS);
break;
case 3:
y = Wim.CreateNewWim(CompressionType.LZX);
break;
default:
y = Wim.CreateNewWim(CompressionType.NONE);
break;
}
x.ExportImage(index, y, null, null, ExportFlags.DEFAULT);
y.Write(loc2, Wim.AllImages, WriteFlags.DEFAULT, Wim.DefaultThreads);
}
}
public static void Init(TestContext context)
{
BaseDir = Path.GetFullPath(Path.Combine(TestHelper.GetProgramAbsolutePath(), "..", ".."));
SampleDir = Path.Combine(BaseDir, "Samples");
switch (IntPtr.Size)
{
case 8:
Wim.GlobalInit(Path.Combine("x64", "libwim-15.dll"));
break;
case 4:
Wim.GlobalInit(Path.Combine("x86", "libwim-15.dll"));
break;
default:
throw new PlatformNotSupportedException();
}
}
