public void LoadArchive(string path)
{
if (_Archive != null)
{
_Archive.Dispose();
_Archive = null;
}
#if DEBUG
using (var input = File.OpenRead(path))
{
_Archive = new ArchiveFile();
_Archive.Deserialize(input);
}
#else
Thread thread = new Thread(() => ArchiveThreadLoad(path));
thread.Start();
while (thread.IsAlive)
{
Application.DoEvents();
}
#endif
if (_Archive == null)
{
return;
}
Program.FilePath = path;
_Descr = LoadDescriptions(_Archive.ResourceInfoXml);
BuildEntryTree();
}
public void CloseArchive()
{
if (_archive != null)
{
_archive.Dispose();
_archive = null;
}
}
public Stream GetStream()
{
ArchiveFile archiveFile = new ArchiveFile(_archiveFullname);
var filtered = archiveFile.Entries.Where(entry => entry.FileName.Equals(Name)).ToList();
if (filtered.Count > 0)
{
MemoryStream memoryStream = new MemoryStream();
filtered[0].Extract(memoryStream);
memoryStream.Position = 0;
archiveFile.Dispose();
return(memoryStream);
}
else
{
archiveFile.Dispose();
return(null);
}
}
static void GetProductInfos(Stream inputStream, List <ProductInfo> productInfos)
{
ArchiveFile extractor = null;
try {
extractor = new ArchiveFile(inputStream);
GetProductInfos(extractor, productInfos);
} catch (SevenZipException) {
} finally {
extractor?.Dispose();
}
}
static void GetProductInfos(string file, List <ProductInfo> productInfos)
{
ArchiveFile extractor = null;
try {
extractor = new ArchiveFile(file);
GetProductInfos(extractor, productInfos);
} catch (SevenZipException) {
} finally {
extractor?.Dispose();
}
}
private void CloseArchiveFile()
{
if ((object)m_archiveFile != null)
{
m_archiveFile.DataReadException -= file_DataReadException;
m_archiveFile.HistoricFileListBuildComplete -= file_HistoricFileListBuildComplete;
m_archiveFile.HistoricFileListBuildException -= file_HistoricFileListBuildException;
m_archiveFile.HistoricFileListBuildStart -= file_HistoricFileListBuildStart;
m_archiveFile.HistoricFileListUpdated -= file_HistoricFileListUpdated;
m_archiveFile.RolloverComplete -= file_RolloverComplete;
m_archiveFile.RolloverStart -= file_RolloverStart;
m_archiveFile.Dispose();
}
m_archiveFile = null;
}
public static void DownloadAndInstall()
{
string thisDir = Path.Combine(Directory.GetCurrentDirectory());
try
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(Build.DownloadLink);
request.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
string update = "";
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
var fn = response.Headers["Content-Disposition"].Split(new string[] { "=" }, StringSplitOptions.None)[1].Replace("\"", "");
if (fn.Contains("?"))
{
fn = fn.Replace("?", "");
}
var responseStream = response.GetResponseStream();
string name = fn;
Write("Downloading update...");
// Otherwise do download.
using (var fileStream = File.Open(Path.Combine(thisDir, fn), FileMode.Create))
{
responseStream.CopyTo(fileStream);
}
update = Path.Combine(thisDir, fn);
Write("Download done. Extracting...");
ArchiveFile file = new ArchiveFile(update);
file.Extract(thisDir, true);
file.Dispose();
File.Delete(update);
Write("Update installed successfully!");
Thread.Sleep(1300);
Launch();
}
}
catch (SevenZipException e)
{
Write("Archieve error: {0}", e.Message);
}
}
protected override void Dispose(bool disposing)
{
if (!m_disposed)
{
try
{
if (disposing)
{
if ((object)m_file != null)
{
m_file.Dispose();
}
}
}
finally
{
m_disposed = true;
base.Dispose(disposing);
}
}
}
public async Task <Dictionary <RelativePath, T> > Extract()
{
var source = new TaskCompletionSource <bool>();
var th = new Thread(() =>
{
try
{
_archive = ArchiveFile.Open(_stream, _sig).Result;
ulong checkPos = 1024 * 32;
_archive._archive.Open(_archive._archiveStream, ref checkPos, null);
_itemsCount = _archive._archive.GetNumberOfItems();
_archive._archive.Extract(null, 0xFFFFFFFF, 0, this);
_archive.Dispose();
if (_killException != null)
{
source.SetException(_killException);
}
else
{
source.SetResult(true);
}
}
catch (Exception ex)
{
source.SetException(ex);
}
})
{
Priority = ThreadPriority.BelowNormal, Name = "7Zip Extraction Worker Thread"
};
th.Start();
await source.Task;
return(_results);
}
private void OnExtractFileSavePathSelected(ArchiveFile archive, string fileName, string destPath)
{
interactable = true;
try
{
if (Path.GetExtension(fileName).ToLowerInvariant() == ".bmp")
{
// Special processing to convert tileset to a standard bmp format
BitmapFile bitmapFile = TilesetLoader.ReadTileset(archive.ExtractFileToMemory(fileName));
bitmapFile.Serialize(destPath);
}
else
{
archive.ExtractFile(fileName, destPath);
}
}
finally
{
archive.Dispose();
}
Debug.Log(Path.GetFileName(destPath) + " extracted successfully.");
}
/// <summary>
/// Returns all images found in an archive file
/// </summary>
/// <param name="archiveFileFullName">Path to the archive file</param>
/// <returns>A list of ArchiveEntry objects containing all suspected image files</returns>
public static List <ArchiveEntry> GetImageFiles(string archiveFileFullName)
{
ArchiveFile arc = new ArchiveFile(archiveFileFullName);
List <ArchiveEntry> imagesFiles = new List <ArchiveEntry>();
var files = arc.Entries.Where(file => Config.ExtensionFilter.Any(x => file.FileName.EndsWith(x, StringComparison.OrdinalIgnoreCase))).ToList();
if (files.Count > 0)
{
foreach (Entry archiveEntry in files)
{
//check that we are not adding a folder named HELLO.JPG
if (!archiveEntry.IsFolder)
{
var e = new ArchiveEntry(archiveEntry, archiveFileFullName);
imagesFiles.Add(e);
}
}
}
arc.Dispose();
return(imagesFiles);
}
private void OnExtractFileCanceled(ArchiveFile archive)
{
interactable = true;
archive.Dispose();
}
public void Close()
{
archiveFile.Dispose();
}
