private void DownloadAndInstall(string url, string filename, string mod_name = null)
{
var src = Path.Combine(DOWNLOAD_FOLDER, filename);
if (!File.Exists(src))
{
var state = DownloadDispatcher.ResolveArchive(url);
state.Download(new Archive()
{
Name = "Unknown"
}, src);
}
if (!Directory.Exists(utils.DownloadsFolder))
{
Directory.CreateDirectory(utils.DownloadsFolder);
}
File.Copy(src, Path.Combine(utils.DownloadsFolder, filename));
if (mod_name == null)
{
FileExtractor.ExtractAll(src, utils.MO2Folder);
}
else
{
FileExtractor.ExtractAll(src, Path.Combine(utils.ModsFolder, mod_name));
}
}
private void DownloadAndInstall(Game game, int modid, string mod_name)
{
utils.AddMod(mod_name);
var client = new NexusApiClient();
var file = client.GetModFiles(game, modid).First(f => f.is_primary);
var src = Path.Combine(DOWNLOAD_FOLDER, file.file_name);
var ini = string.Join("\n",
new List <string>
{
"[General]",
$"gameName={GameRegistry.Games[game].MO2ArchiveName}",
$"modID={modid}",
$"fileID={file.file_id}"
});
if (!File.Exists(file.file_name))
{
var state = DownloadDispatcher.ResolveArchive(ini.LoadIniString());
state.Download(src);
}
if (!Directory.Exists(utils.DownloadsFolder))
{
Directory.CreateDirectory(utils.DownloadsFolder);
}
var dest = Path.Combine(utils.DownloadsFolder, file.file_name);
File.Copy(src, dest);
FileExtractor.ExtractAll(src, Path.Combine(utils.ModsFolder, mod_name));
File.WriteAllText(dest + ".meta", ini);
}
private void ClearExplorerSource()
{
this.ExplorerViewModel?.ClearFileSystemTree();
FileExtractor.CleanUpExtractedTemporaryFiles();
NotifyExplorerSourceCleared();
}
/// <summary>
/// Add a path to a url file to parse.
/// </summary>
public void AddUrlFile(string path)
{
_lock.Take();
// has the extractor been setup?
if (_fileExtractor == null)
{
// no, create an extractor of urls
Extract extract = new ExtractUrl(
new ActionSet <string, Crawler>(ParseControl.OnUrl),
new ArrayRig <Protocol>(ParseControl.Protocols));
// start a file extractor for the files with the url extractor
_fileExtractor = new FileExtractor(new ArrayRig <string>(new [] { path }), extract);
_fileExtractor.OnFile = new ActionSet <string>(OnCompleteUrlFile);
_fileExtractor.Run();
}
else
{
// yes, add the file to the extractor
_fileExtractor.AddFile(path);
}
_lock.Release();
}
public Action Stage(IEnumerable <VirtualFile> files)
{
var grouped = files.SelectMany(f => f.FilesInPath)
.Distinct()
.Where(f => f.ParentArchive != null)
.GroupBy(f => f.ParentArchive)
.OrderBy(f => f.Key == null ? 0 : f.Key.Paths.Length)
.ToList();
List <string> Paths = new List <string>();
foreach (var group in grouped)
{
var tmp_path = Path.Combine(_stagedRoot, Guid.NewGuid().ToString());
FileExtractor.ExtractAll(group.Key.StagedPath, tmp_path);
Paths.Add(tmp_path);
foreach (var file in group)
{
file._stagedPath = Path.Combine(tmp_path, file.Paths[group.Key.Paths.Length]);
}
}
return(() =>
{
Paths.Do(p =>
{
if (Directory.Exists(p))
{
DeleteDirectory(p);
}
});
});
}
public async Task <bool> transferFiles(string d3path, string bfgpath, int scaling)
{
await Task.Run(() => {
exporter = new FileExtractorImpl(d3path + "/pak000.pk4");
foreach (string key in Paths.paths.Keys)
{
string currentPath = bfgpath + "/" + key;
Directory.CreateDirectory(currentPath);
Directory.SetCurrentDirectory(currentPath);
if (key.Equals("maps/game"))
{
File.WriteAllText(currentPath + "/erebus3.map", Resources.erebus3);
File.WriteAllText(currentPath + "/erebus4.map", Resources.erebus4);
File.WriteAllText(currentPath + "/phobos2.map", Resources.phobos2);
continue;
}
if (Paths.paths[key][0].EndsWith(".gui"))
{
exporter.extractFiles(Paths.paths[key][0], "guis", currentPath, scaling);
continue;
}
foreach (string path in Paths.paths[key])
{
exporter.extractFiles(path, key, currentPath, scaling);
}
}
});
return(true);
}
void Client_DownloadFileCompleted(object sender, AsyncCompletedEventArgs e)
{
if (e.Cancelled)
{
this.toolStripStatusLabel1.Text = Properties.Resources.Downloadcanceled;
resetUI();
}
else if (e.Error != null)
{
this.toolStripProgressBar1.Visible = false;
this.toolStripStatusLabel1.Text = e.Error.Message;
resetUI();
}
else
{
string fileName = e.UserState.ToString();
if (fileName.StartsWith(DICTIONARY_FOLDER))
{
FileExtractor.ExtractCompressedFile(fileName.Substring(DICTIONARY_FOLDER.Length), Path.Combine(baseDir, DICTIONARY_FOLDER));
}
else
{
FileExtractor.ExtractCompressedFile(fileName.Substring(TESS_DATA.Length), Path.Combine(baseDir, TESS_DATA));
numberOfDownloads++;
}
if (--numOfConcurrentTasks <= 0)
{
this.toolStripStatusLabel1.Text = Properties.Resources.Downloadcompleted;
this.toolStripProgressBar1.Visible = false;
resetUI();
}
}
}
public static void ExportBinary(PackedFile CurrentPackedFile, string _exportDirectory)
{
string extractTo = null;
// TODO: Add support for ModManager
//extractTo = ModManager.Instance.CurrentModSet ? ModManager.Instance.CurrentModDirectory : null;
if (extractTo == null)
{
DirectoryDialog dialog = new DirectoryDialog
{
Description = "Please point to folder to extract to",
SelectedPath = String.IsNullOrEmpty(_exportDirectory)
? System.IO.Path.GetDirectoryName(System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName)
: _exportDirectory
};
extractTo = dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK ? dialog.SelectedPath : null;
_exportDirectory = dialog.SelectedPath;
}
if (!string.IsNullOrEmpty(extractTo))
{
List <PackedFile> files = new List <PackedFile>();
files.Add(CurrentPackedFile);
FileExtractor extractor = new FileExtractor(extractTo);
extractor.ExtractFiles(files);
MessageBox.Show(string.Format("File exported as binary."));
}
}
public void Extract()
{
const string targetPath = "e:\\temp\\gitlab";
const string filePath = "e:\\temp\\gitlab\\temp.zip";
FileExtractor.Extract(filePath, targetPath);
}
private async Task Setup()
{
Console.WriteLine(Program.Configuration.serverCorePath);
var download = await _artifactsService.Download(_artifactsService.artifacts.First().Value,
Program.Configuration.serverCorePath);
Console.WriteLine("UnZip - Citizen");
FileExtractor.Zip(download, Program.Configuration.serverCorePath);
Console.WriteLine("Finish !");
}
private void UpdateArchive(VirtualFile f)
{
if (!f.IsStaged)
{
throw new InvalidDataException("Can't analyze an unstaged file");
}
var tmp_dir = Path.Combine(_stagedRoot, Guid.NewGuid().ToString());
Utils.Status($"Extracting Archive {Path.GetFileName(f.StagedPath)}");
FileExtractor.ExtractAll(f.StagedPath, tmp_dir);
Utils.Status($"Updating Archive {Path.GetFileName(f.StagedPath)}");
var entries = Directory.EnumerateFiles(tmp_dir, "*", SearchOption.AllDirectories)
.Select(path => path.RelativeTo(tmp_dir));
var new_files = entries.Select(e =>
{
var new_path = new string[f.Paths.Length + 1];
f.Paths.CopyTo(new_path, 0);
new_path[f.Paths.Length] = e;
var nf = new VirtualFile
{
Paths = new_path
};
nf._stagedPath = Path.Combine(tmp_dir, e);
Add(nf);
return(nf);
}).ToList();
// Analyze them
new_files.PMap(file =>
{
Utils.Status($"Analyzing {Path.GetFileName(file.StagedPath)}");
file.Analyze();
});
// Recurse into any archives in this archive
new_files.Where(file => file.IsArchive).Do(file => UpdateArchive(file));
f.FinishedIndexing = true;
if (!_isSyncing)
{
SyncToDisk();
}
Utils.Status("Cleaning Directory");
DeleteDirectory(tmp_dir);
}
public static async Task Unpack(UnpackerConfig config)
{
using (var initialUnpack = new InitialUnpack(config.InputUnityFile, config.WorkingDir, config.Logger))
{
await initialUnpack.StartAsync();
var fileScanner = new FileScanner(config.WorkingDir, config.OutputDir, config.Logger);
var scannedFiles = await fileScanner.StartAsync();
using (var fileExtractor = new FileExtractor(config.WorkingDir, scannedFiles, config.Logger))
{
await fileExtractor.StartAsync();
}
}
}
/// <summary>
/// We bundle the cef libs inside the .exe, we need to extract them before loading any wpf code that requires them
/// </summary>
private static async Task ExtractLibs()
{
if (File.Exists("cefglue.7z") && File.Exists("libcef.dll"))
{
return;
}
using (var fs = File.OpenWrite("cefglue.7z"))
using (var rs = Assembly.GetExecutingAssembly().GetManifestResourceStream("Wabbajack.Lib.LibCefHelpers.cefglue.7z"))
{
rs.CopyTo(fs);
Utils.Log("Extracting libCef files");
}
using (var wq = new WorkQueue(1))
{
await FileExtractor.ExtractAll(wq, "cefglue.7z", ".");
}
}
/// <summary>
/// We bundle the cef libs inside the .exe, we need to extract them before loading any wpf code that requires them
/// </summary>
private static void ExtractLibs()
{
if (File.Exists("cefsharp.7z") && File.Exists("libcef.dll"))
{
return;
}
using (var fs = File.Open("cefsharp.7z", System.IO.FileMode.Create))
using (var rs = Assembly.GetExecutingAssembly().GetManifestResourceStream("Wabbajack.Lib.LibCefHelpers.cefsharp.7z"))
{
rs.CopyTo(fs);
Utils.Log("Extracting libCef files");
}
using (var wq = new WorkQueue(1))
{
FileExtractor.ExtractAll(wq, "cefsharp.7z", ".").Wait();
}
}
private void btnBegin_Click(object sender, EventArgs e)
{
if (btnBegin.Text == "Cancel")
{
Log("User cancelled process...stopping as soon as possible");
FileExtractor.CancelAsync();
btnBegin.Enabled = false;
return;
}
if (!inputFiles.Any())
{
return;
}
EnableDisable(false);
btnConverter.Visible = false;
btnBegin.Text = "Cancel";
toolTip1.SetToolTip(btnBegin, "Click to cancel extracting process");
FileExtractor.RunWorkerAsync();
}
public async Task ExtractFiles_WithManifestItemsInContentDirectory_ReturnsFiles()
{
var zip = new Mock <IZip>();
var content = Encoding.ASCII.GetBytes("test");
var manifestItems = new[]
{
new ManifestItem(string.Empty, "chapter1.xml", string.Empty, ContentType.Unknown),
};
var opf = await XmlStructureFile.LoadFromTextAsync("content/opf.opf", "<Doc />");
zip.Setup(x => x.GetFileContent("content/chapter1.xml")).Returns(content);
var testee = new FileExtractor();
var result = (await testee.ExtractFiles(opf, manifestItems, zip.Object)).Single();
Assert.AreEqual(content, result.Content);
Assert.AreEqual("chapter1.xml", result.Name);
Assert.AreEqual("content/chapter1.xml", result.Path);
}
private IFileSystemItemModel CreateFileSystemTreeItemModel(IFileSystemItemModel parentFileSystemItem, FileSystemInfo pathInfo)
{
IFileSystemItemModel fileSystemTreeElement = parentFileSystemItem.CreateModel();
fileSystemTreeElement.ParentFileSystemItem = parentFileSystemItem;
fileSystemTreeElement.Info = pathInfo;
fileSystemTreeElement.DisplayName = pathInfo.Name;
fileSystemTreeElement.IsDirectory = pathInfo is DirectoryInfo;
fileSystemTreeElement.IsArchive = !fileSystemTreeElement.IsDirectory &&
FileExtractor.FileIsArchive(fileSystemTreeElement.Info as FileInfo);
fileSystemTreeElement.IsSystem = pathInfo.Attributes.HasFlag(FileAttributes.System);
fileSystemTreeElement.IsHidden = pathInfo.Attributes.HasFlag(FileAttributes.Hidden);
fileSystemTreeElement.IsDrive = pathInfo is DirectoryInfo directoryInfo && directoryInfo.Root.FullName.Equals(
directoryInfo.FullName,
StringComparison.OrdinalIgnoreCase);
return(fileSystemTreeElement);
}
private async Task DownloadAndInstall(string url, string filename, string mod_name = null)
{
var src = Path.Combine(DOWNLOAD_FOLDER, filename);
if (!File.Exists(src))
{
var state = DownloadDispatcher.ResolveArchive(url);
await state.Download(new Archive { Name = "Unknown" }, src);
}
if (!Directory.Exists(utils.DownloadsFolder))
{
Directory.CreateDirectory(utils.DownloadsFolder);
}
await Utils.CopyFileAsync(src, Path.Combine(utils.DownloadsFolder, filename));
await FileExtractor.ExtractAll(Queue, src,
mod_name == null?utils.MO2Folder : Path.Combine(utils.ModsFolder, mod_name));
}
private async Task <(string Download, string ModFolder)> DownloadAndInstall(Game game, int modid, string mod_name)
{
utils.AddMod(mod_name);
var client = await NexusApiClient.Get();
var resp = await client.GetModFiles(game, modid);
var file = resp.files.FirstOrDefault(f => f.is_primary) ?? resp.files.FirstOrDefault(f => !string.IsNullOrEmpty(f.category_name));
var src = Path.Combine(DOWNLOAD_FOLDER, file.file_name);
var ini = string.Join("\n",
new List <string>
{
"[General]",
$"gameName={game.MetaData().MO2ArchiveName}",
$"modID={modid}",
$"fileID={file.file_id}"
});
if (!File.Exists(src))
{
var state = (AbstractDownloadState)await DownloadDispatcher.ResolveArchive(ini.LoadIniString());
await state.Download(src);
}
if (!Directory.Exists(utils.DownloadsFolder))
{
Directory.CreateDirectory(utils.DownloadsFolder);
}
var dest = Path.Combine(utils.DownloadsFolder, file.file_name);
await Utils.CopyFileAsync(src, dest);
var modFolder = Path.Combine(utils.ModsFolder, mod_name);
await FileExtractor.ExtractAll(Queue, src, modFolder);
File.WriteAllText(dest + Consts.MetaFileExtension, ini);
return(dest, modFolder);
}
private void CreateChildItems(int remainingFileSystemTreeEnumerationLevelCount, ref List <FileSystemTreeElement> lazyChildren)
{
foreach (FileSystemInfo fileSystemTreeChildInfo in (this.ElementInfo as DirectoryInfo).EnumerateFileSystemInfos(
"*",
SearchOption.TopDirectoryOnly))
{
if (fileSystemTreeChildInfo is DirectoryInfo subdirectoryInfo)
{
var childDirectoryElement = new FileSystemTreeElement(this.RootFileSystemTreeElement, this, subdirectoryInfo)
{
HasLazyChildren = remainingFileSystemTreeEnumerationLevelCount.Equals(0)
};
Application.Current.Dispatcher.Invoke(
() => this.ChildFileSystemTreeElements.Add(childDirectoryElement),
DispatcherPriority.Send);
if (childDirectoryElement.HasLazyChildren)
{
lazyChildren.Add(childDirectoryElement);
}
else
{
childDirectoryElement.ReadFolderStructure(remainingFileSystemTreeEnumerationLevelCount, ref lazyChildren);
}
}
else if (fileSystemTreeChildInfo is FileInfo fileInfo)
{
var fileIsArchive = FileExtractor.FileIsArchive(fileInfo);
var childFileElement = new FileSystemTreeElement(this.RootFileSystemTreeElement, this, fileInfo)
{
IsArchive = fileIsArchive
};
Application.Current.Dispatcher.Invoke(
() => this.ChildFileSystemTreeElements.Add(childFileElement),
DispatcherPriority.Send);
}
}
}
static void Main(string[] args)
{
Console.WriteLine("Hello.");
var extractor = new FileExtractor(new FileSystem());
var weather = new WeatherData();
var manager = new WeatherDataManager(extractor, weather);
Console.WriteLine($"Processing the file '{AppConstants.FullFileName}'.");
try
{
var result = manager.GetDayWithLeastChange(AppConstants.FullFileName);
Console.WriteLine($"The result is: {result}.");
}
catch (Exception exception)
{
Console.WriteLine($"The application threw the following exception: {exception.Message}.");
}
Console.WriteLine("I hoped you enjoyed it!");
}
private void ExecuteViewFile(object sender, ExecutedRoutedEventArgs e)
{
if (!(e.OriginalSource is FrameworkElement frameworkElement))
{
return;
}
if (!(frameworkElement.DataContext is FileSystemTreeElement fileSystemTreeElement) || fileSystemTreeElement.IsDirectory)
{
return;
}
// If file is a compressed archive, then try to extract to temp folder and open the destination folder ...
if (FileExtractor.FileIsArchive(fileSystemTreeElement.ElementInfo as FileInfo))
{
this.ExplorerViewModel.ExtractArchive(fileSystemTreeElement).ConfigureAwait(true);
return;
}
// ... or just open the document if it's no archive but file
throw new NotImplementedException();
}
private void AddFilePathInfoToExplorerTree([NotNull] FileSystemInfo pathInfo, bool isRootFolderExpanded)
{
var fileSystemTreeElement = new FileSystemTreeElement(
this.VirtualExplorerRootDirectory,
this.VirtualExplorerRootDirectory,
pathInfo);
fileSystemTreeElement.IsArchive = !fileSystemTreeElement.IsDirectory &&
FileExtractor.FileIsArchive(fileSystemTreeElement.ElementInfo as FileInfo);
fileSystemTreeElement.IsSystemDirectory = DriveInfo.GetDrives().Any((driveInfo) => driveInfo.RootDirectory.FullName.Equals(fileSystemTreeElement.ElementInfo.FullName, StringComparison.OrdinalIgnoreCase));
if (fileSystemTreeElement.IsDirectory || fileSystemTreeElement.IsArchive)
{
List <FileSystemTreeElement> lazyFileSystemElements = fileSystemTreeElement.InitializeWithLazyTreeStructure();
// Observe top level tree directories 'IsExpanded' to show/ hide drag drop hint accordingly
ObserveTopLevelDirectoryIsExpanded(fileSystemTreeElement);
// Observe lazy children
if (fileSystemTreeElement.IsLazyLoading)
{
ObserveVirtualDirectories(lazyFileSystemElements);
fileSystemTreeElement.IsExpanded = isRootFolderExpanded && !fileSystemTreeElement.IsArchive;
}
}
// Validate state including the new item that to this point is still not added to the tree
UpdateFileSystemElementTreeState(fileSystemTreeElement);
Application.Current.Dispatcher.Invoke(
() =>
{
FilterFileSystemTree(fileSystemTreeElement);
this.VirtualExplorerRootDirectory.ChildFileSystemTreeElements.Add(fileSystemTreeElement);
},
DispatcherPriority.Send);
}
private void ExportData(object sender, EventArgs e)
{
string extractTo = ModManager.Instance.CurrentModSet ? ModManager.Instance.CurrentModDirectory : null;
if (extractTo == null)
{
DirectoryDialog dialog = new DirectoryDialog {
Description = "Please point to folder to extract to",
SelectedPath = Settings.Default.LastPackDirectory
};
extractTo = dialog.ShowDialog() == DialogResult.OK ? dialog.SelectedPath : null;
}
if (!string.IsNullOrEmpty(extractTo))
{
List <PackedFile> files = new List <PackedFile>();
files.Add(CurrentPackedFile);
FileExtractor extractor = new FileExtractor(null, null, extractTo)
{
Preprocessor = new TsvExtractionPreprocessor()
};
extractor.ExtractFiles(files);
MessageBox.Show(string.Format("File exported to TSV."));
}
}
public FileExtractorTests()
{
_fileSystem = Substitute.For <IFileSystem>();
_fileExtractor = new FileExtractor(_fileSystem);
}
public async Task ExtractModlist()
{
ExtractedModListFiles = await FileExtractor.ExtractAll(Queue, ModListArchive);
}
[InlineData(Game.Fallout4, 43474)] // EM 2 Rifle
public async Task BSACompressionRecompression(Game game, int modid)
{
var filename = await DownloadMod(game, modid);
var folder = _bsaFolder.Combine(game.ToString(), modid.ToString());
await folder.DeleteDirectory();
folder.CreateDirectory();
await using var files = await FileExtractor.ExtractAll(Queue, filename);
await files.MoveAllTo(folder);
foreach (var bsa in folder.EnumerateFiles().Where(f => Consts.SupportedBSAs.Contains(f.Extension)))
{
TestContext.WriteLine($"From {bsa}");
TestContext.WriteLine("Cleaning Output Dir");
await _tempDir.DeleteDirectory();
_tempDir.CreateDirectory();
TestContext.WriteLine($"Reading {bsa}");
var tempFile = ((RelativePath)"tmp.bsa").RelativeToEntryPoint();
var size = bsa.Size;
await using var a = BSADispatch.OpenRead(bsa);
await a.Files.PMap(Queue, file =>
{
var absName = _tempDir.Combine(file.Path);
ViaJson(file.State);
absName.Parent.CreateDirectory();
using (var fs = absName.Create())
{
file.CopyDataTo(fs);
}
Assert.Equal(file.Size, absName.Size);
});
// Check Files should be case insensitive
Assert.Equal(a.Files.Count(), a.Files.Select(f => f.Path).ToHashSet().Count);
Assert.Equal(a.Files.Count(), a.Files.Select(f => f.Path.ToString().ToLowerInvariant()).ToHashSet().Count);
TestContext.WriteLine($"Building {bsa}");
await using (var w = ViaJson(a.State).MakeBuilder(size))
{
var streams = await a.Files.PMap(Queue, async file =>
{
var absPath = _tempDir.Combine(file.Path);
var str = absPath.OpenRead();
await w.AddFile(ViaJson(file.State), str);
return(str);
});
await w.Build(tempFile);
streams.Do(s => s.Dispose());
}
TestContext.WriteLine($"Verifying {bsa}");
await using var b = BSADispatch.OpenRead(tempFile);
TestContext.WriteLine($"Performing A/B tests on {bsa}");
Assert.Equal(a.State.ToJson(), b.State.ToJson());
// Check same number of files
Assert.Equal(a.Files.Count(), b.Files.Count());
await a.Files.Zip(b.Files, (ai, bi) => (ai, bi))
.PMap(Queue, pair =>
{
Assert.Equal(pair.ai.State.ToJson(), pair.bi.State.ToJson());
//Console.WriteLine($" - {pair.ai.Path}");
Assert.Equal(pair.ai.Path, pair.bi.Path);
//Equal(pair.ai.Compressed, pair.bi.Compressed);
Assert.Equal(pair.ai.Size, pair.bi.Size);
Assert.Equal(GetData(pair.ai), GetData(pair.bi));
});
}
}
private void Init()
{
context.InstInfo.InstallPath = context.ConvertPath(context.InstInfo.InstallPath);
context.Files.ForEach(x => x.Path = context.ConvertPath(x.Key));
context.UninstallData = new UninstallData()
{
UninstallKey = context.AppInfo.AppName,
InstallPath = context.InstInfo.InstallPath,
AppName = context.AppInfo.FullName,
Shortcuts = new List <string>()
};
var index = 0;
var fileExtractor = new FileExtractor();
fileExtractor.SetContext(context, process);
commands.Add(new Cmd()
{
Index = index++, Command = fileExtractor
});
var shortcutCreator = new ShortcutCreator();
shortcutCreator.SetContext(context, process);
commands.Add(new Cmd()
{
Index = index++, Command = shortcutCreator
});
foreach (var cmdInfo in context.Commands)
{
cmdInfo.ArgList = cmdInfo.ArgList?.Select(x => context.ConvertPath(context.ConvertVars(x))).ToArray() ?? new string[0];
var cmd = BaseCommand.GetCommand(cmdInfo.Target);
if (cmd != null)
{
cmd.SetContext(context, process, cmdInfo.Name, cmdInfo.ArgList);
commands.Add(new Cmd()
{
Index = index++, Command = cmd
});
}
else
{
commands.Add(new Cmd()
{
Index = index++, CmdInfo = cmdInfo
});
}
}
var uninsCreator = new UninsCreator();
uninsCreator.SetContext(context, process);
commands.Add(new Cmd()
{
Index = index++, Command = uninsCreator
});
var registerEditor = new RegisterEditor();
registerEditor.SetContext(context, process);
commands.Add(new Cmd()
{
Index = index++, Command = registerEditor
});
process?.SetMaxValue(GetProcessValue(), ValueMin);
}
