public static void AddToZip(BackgroundWorker worker, string zipfile, string FileToAdd, string AsFilename = "", bool showProgress = true, Ionic.Zlib.CompressionLevel complevel = Ionic.Zlib.CompressionLevel.Default)
{
if (!File.Exists(zipfile))
throw new FileNotFoundException("Zipfile " + zipfile + " does not exist");
bool exists = ExistsInZip(zipfile, AsFilename == "" ? FileToAdd : AsFilename);
using (ZipFile zip = new ZipFile(zipfile))
{
Utility.SetZipTempFolder(zip);
zip.CompressionLevel = complevel;
if (exists)
zip.RemoveEntry(AsFilename == "" ? FileToAdd : AsFilename);
ZipEntry ze = zip.AddFile(FileToAdd, "");
if (!string.IsNullOrEmpty(AsFilename))
ze.FileName = AsFilename;
if (showProgress)
zip.SaveProgress += (o, e) =>
{
if (e.EventType == ZipProgressEventType.Saving_EntryBytesRead && e.CurrentEntry.FileName == (AsFilename == "" ? FileToAdd : AsFilename))
worker.ReportProgress((int)((float)e.BytesTransferred / e.TotalBytesToTransfer * 100));
};
zip.Save();
}
}
public static void ZipFolder(string inputFolder, string outputFile, Ionic.Zlib.CompressionLevel level)
{
using (ZipFile zip = new ZipFile())
{
zip.CompressionLevel = level;
zip.AddDirectory(inputFolder, "");
//zip.AddFiles(GenerateFileList(inputFolder));
//zip.AddDirectory(inputFolder);
zip.Save(outputFile);
}
}
/// <summary>
/// Retrieve the ZipEntry items in the ZipFile that conform to the specified criteria.
/// </summary>
/// <remarks>
///
/// <para>
/// This method applies the criteria set in the FileSelector instance (as described in
/// the <see cref="FileSelector.SelectionCriteria"/>) to the specified ZipFile. Using this
/// method, for example, you can retrieve all entries from the given ZipFile that
/// have filenames ending in .txt.
/// </para>
///
/// <para>
/// Normally, applications would not call this method directly. This method is used
/// by the ZipFile class.
/// </para>
///
/// <para>
/// Using the appropriate SelectionCriteria, you can retrieve entries based on size,
/// time, and attributes. See <see cref="FileSelector.SelectionCriteria"/> for a
/// description of the syntax of the SelectionCriteria string.
/// </para>
///
/// </remarks>
///
/// <param name="zip">The ZipFile from which to retrieve entries.</param>
///
/// <returns>a collection of ZipEntry objects that conform to the criteria.</returns>
public ICollection<Ionic.Zip.ZipEntry> SelectEntries(Ionic.Zip.ZipFile zip)
{
var list = new List<Ionic.Zip.ZipEntry>();
foreach (Ionic.Zip.ZipEntry e in zip)
{
if (this.Evaluate(e))
list.Add(e);
}
return list;
}
public void FillKnowledge(CandidateViewModel candidate)
{
_driver.Manage().Timeouts().ImplicitWait = TimeSpan.FromSeconds(5);
Ionic.EnterText(candidate.Ionic.ToString());
Android.EnterText(candidate.Android.ToString());
Angular.EnterText(candidate.Angular.ToString());
Asp.EnterText(candidate.Asp.ToString());
Others.EnterText(candidate.Others);
Photoshop.EnterText(candidate.Photoshop.ToString());
Illustrator.EnterText(candidate.Illustrator.ToString());
Html.EnterText(candidate.Html.ToString());
Jquery.EnterText(candidate.Jquery.ToString());
}
public WorkItem(int size, Ionic.Zlib.CompressionLevel compressLevel, CompressionStrategy strategy)
{
buffer= new byte[size];
// alloc 5 bytes overhead for every block (margin of safety= 2)
int n = size + ((size / 32768)+1) * 5 * 2;
compressed= new byte[n];
status = (int)Status.None;
compressor = new ZlibCodec();
compressor.InitializeDeflate(compressLevel, false);
compressor.OutputBuffer = compressed;
compressor.InputBuffer = buffer;
}
internal void FinishOutputStream(Stream s,
CountingStream entryCounter,
Stream encryptor,
Stream compressor,
Ionic.Crc.CrcCalculatorStream output)
{
if (output == null) return;
output.Close();
// by calling Close() on the deflate stream, we write the footer bytes, as necessary.
if ((compressor as Ionic.Zlib.DeflateStream) != null)
compressor.Close();
#if BZIP
else if ((compressor as Ionic.BZip2.BZip2OutputStream) != null)
compressor.Close();
#if !NETCF
else if ((compressor as Ionic.BZip2.ParallelBZip2OutputStream) != null)
compressor.Close();
#endif
#endif
#if !NETCF
else if ((compressor as Ionic.Zlib.ParallelDeflateOutputStream) != null)
compressor.Close();
#endif
encryptor.Flush();
encryptor.Close();
_LengthOfTrailer = 0;
_UncompressedSize = output.TotalBytesSlurped;
#if AESCRYPTO
WinZipAesCipherStream wzacs = encryptor as WinZipAesCipherStream;
if (wzacs != null && _UncompressedSize > 0)
{
s.Write(wzacs.FinalAuthentication, 0, 10);
_LengthOfTrailer += 10;
}
#endif
_CompressedFileDataSize = entryCounter.BytesWritten;
_CompressedSize = _CompressedFileDataSize; // may be adjusted
_Crc32 = output.Crc;
// Set _RelativeOffsetOfLocalHeader now, to allow for re-streaming
StoreRelativeOffset();
}
public WorkItem(int size,
Ionic.Zlib.CompressionLevel compressLevel,
CompressionStrategy strategy,
int ix)
{
this.buffer= new byte[size];
// alloc 5 bytes overhead for every block (margin of safety= 2)
int n = size + ((size / 32768)+1) * 5 * 2;
this.compressed = new byte[n];
this.compressor = new ZlibCodec();
this.compressor.InitializeDeflate(compressLevel, false);
this.compressor.OutputBuffer = this.compressed;
this.compressor.InputBuffer = this.buffer;
this.index = ix;
}
private static void RecursiveArchivate(string path, Ionic.Zip.ZipFile zip, string relPath, ref DateTime dt)
{
foreach (var file in Directory.GetFiles(path))
{
//if (!CheckFile(file)) continue;
var fdt = File.GetLastWriteTime(file);
if (fdt > dt) dt = File.GetLastWriteTime(file);
zip.AddFile(file, relPath);
}
foreach (string directory in Directory.GetDirectories(path))
{
var dirName = new DirectoryInfo(directory).Name;
RecursiveArchivate(directory, zip, string.Format(@"{0}\{1}", relPath, dirName), ref dt);
}
}
internal override bool Evaluate(Ionic.Zip.ZipEntry entry)
{
bool result = Left.Evaluate(entry);
switch (Conjunction)
{
case LogicalConjunction.AND:
if (result)
result = Right.Evaluate(entry);
break;
case LogicalConjunction.OR:
if (!result)
result = Right.Evaluate(entry);
break;
case LogicalConjunction.XOR:
result ^= Right.Evaluate(entry);
break;
}
return result;
}
void LNSF_SaveProgress(object sender, Ionic.Zip.SaveProgressEventArgs e)
{
switch (e.EventType)
{
case ZipProgressEventType.Saving_Started:
_numEntriesSaved = 0;
_txrx.Send("status saving started...");
_pb1Set = false;
break;
case ZipProgressEventType.Saving_BeforeWriteEntry:
_numEntriesSaved++;
if (_numEntriesSaved % 64 == 0)
_txrx.Send(String.Format("status Compressing {0}", e.CurrentEntry.FileName));
if (!_pb1Set)
{
_txrx.Send(String.Format("pb 1 max {0}", e.EntriesTotal));
_pb1Set = true;
}
break;
case ZipProgressEventType.Saving_EntryBytesRead:
Assert.IsTrue(e.BytesTransferred <= e.TotalBytesToTransfer);
break;
case ZipProgressEventType.Saving_AfterWriteEntry:
_txrx.Send("pb 1 step");
break;
case ZipProgressEventType.Saving_Completed:
_txrx.Send("status Save completed");
_pb1Set = false;
_txrx.Send("pb 1 max 1");
_txrx.Send("pb 1 value 1");
break;
}
}
internal override bool Evaluate(Ionic.Zip.ZipEntry entry)
{
FileAttributes fileAttrs = entry.Attributes;
return _Evaluate(fileAttrs);
}
internal override bool Evaluate(Ionic.Zip.ZipEntry entry)
{
bool result = (ObjectType == 'D')
? entry.IsDirectory
: !entry.IsDirectory;
if (Operator != ComparisonOperator.EqualTo)
result = !result;
return result;
}
internal override bool Evaluate(Ionic.Zip.ZipEntry entry)
{
DateTime x;
switch (Which)
{
case WhichTime.atime:
x = entry.AccessedTime;
break;
case WhichTime.mtime:
x = entry.ModifiedTime;
break;
case WhichTime.ctime:
x = entry.CreationTime;
break;
default: throw new ArgumentException("??time");
}
return _Evaluate(x);
}
internal override bool Evaluate(Ionic.Zip.ZipEntry entry)
{
return _Evaluate(entry.UncompressedSize);
}
internal override bool Evaluate(Ionic.Zip.ZipEntry entry)
{
// swap forward slashes in the entry.FileName for backslashes
string transformedFileName = entry.FileName.Replace("/", "\\");
return _Evaluate(transformedFileName);
}
void _Zip64_Over65534Entries(Zip64Option z64option,
EncryptionAlgorithm encryption,
Ionic.Zlib.CompressionLevel compression)
{
// Emitting a zip file with > 65534 entries requires the use of ZIP64 in
// the central directory.
int numTotalEntries = _rnd.Next(4616)+65534;
//int numTotalEntries = _rnd.Next(461)+6534;
//int numTotalEntries = _rnd.Next(46)+653;
string enc = encryption.ToString();
if (enc.StartsWith("WinZip")) enc = enc.Substring(6);
else if (enc.StartsWith("Pkzip")) enc = enc.Substring(0,5);
string zipFileToCreate = String.Format("Zip64.ZF_Over65534.{0}.{1}.{2}.zip",
z64option.ToString(),
enc,
compression.ToString());
_testTitle = String.Format("ZipFile #{0} 64({1}) E({2}), C({3})",
numTotalEntries,
z64option.ToString(),
enc,
compression.ToString());
_txrx = TestUtilities.StartProgressMonitor(zipFileToCreate,
_testTitle,
"starting up...");
_txrx.Send("pb 0 max 4"); // 3 stages: AddEntry, Save, Verify
_txrx.Send("pb 0 value 0");
string password = Path.GetRandomFileName();
string statusString = String.Format("status Encrypt:{0} Compress:{1}...",
enc,
compression.ToString());
int numSaved = 0;
var saveProgress = new EventHandler<SaveProgressEventArgs>( (sender, e) => {
switch (e.EventType)
{
case ZipProgressEventType.Saving_Started:
_txrx.Send("status saving...");
_txrx.Send("pb 1 max " + numTotalEntries);
numSaved= 0;
break;
case ZipProgressEventType.Saving_AfterWriteEntry:
numSaved++;
if ((numSaved % 128) == 0)
{
_txrx.Send("pb 1 value " + numSaved);
_txrx.Send(String.Format("status Saving entry {0}/{1} ({2:N0}%)",
numSaved, numTotalEntries,
numSaved / (0.01 * numTotalEntries)
));
}
break;
case ZipProgressEventType.Saving_Completed:
_txrx.Send("status Save completed");
_txrx.Send("pb 1 max 1");
_txrx.Send("pb 1 value 1");
break;
}
});
string contentFormatString =
"This is the content for entry #{0}.\r\n\r\n" +
"AAAAAAA BBBBBB AAAAA BBBBB AAAAA BBBBB AAAAA\r\n"+
"AAAAAAA BBBBBB AAAAA BBBBB AAAAA BBBBB AAAAA\r\n";
_txrx.Send(statusString);
int dirCount= 0;
using (var zip = new ZipFile())
{
_txrx.Send(String.Format("pb 1 max {0}", numTotalEntries));
_txrx.Send("pb 1 value 0");
zip.Password = password;
zip.Encryption = encryption;
zip.CompressionLevel = compression;
zip.SaveProgress += saveProgress;
zip.UseZip64WhenSaving = z64option;
// save space when saving the file:
zip.EmitTimesInWindowsFormatWhenSaving = false;
zip.EmitTimesInUnixFormatWhenSaving = false;
// add files:
for (int m=0; m<numTotalEntries; m++)
{
if (_rnd.Next(7)==0)
{
string entryName = String.Format("{0:D5}", m);
zip.AddDirectoryByName(entryName);
dirCount++;
}
else
{
string entryName = String.Format("{0:D5}.txt", m);
if (_rnd.Next(12)==0)
{
string contentBuffer = String.Format(contentFormatString, m);
byte[] buffer = System.Text.Encoding.ASCII.GetBytes(contentBuffer);
zip.AddEntry(entryName, contentBuffer);
}
else
zip.AddEntry(entryName, Stream.Null);
}
if (m % 1024 == 0)
{
_txrx.Send("pb 1 value " + m);
string msg = String.Format("status adding entry {0}/{1} ({2:N0}%)",
m, numTotalEntries, (m/(0.01*numTotalEntries)));
_txrx.Send(msg);
}
}
_txrx.Send("pb 0 step");
_txrx.Send(statusString + " Saving...");
zip.Save(zipFileToCreate);
}
_txrx.Send("pb 0 step");
_txrx.Send("pb 1 value 0");
_txrx.Send("status Reading...");
// verify the zip by unpacking.
_numFilesToExtract = numTotalEntries;
_numExtracted= 1;
_pb1Set = false;
verb = "verify";
BasicVerifyZip(zipFileToCreate, password, false, Zip64ExtractProgress);
_txrx.Send("pb 0 step");
_txrx.Send("status successful extract, now doing final count...");
_txrx.Send("pb 1 value 0");
Assert.AreEqual<int>(numTotalEntries-dirCount,
TestUtilities.CountEntries(zipFileToCreate));
_txrx.Send("pb 0 step");
}
public static void SetZipTempFolder(Ionic.Zip.ZipFile zf)
{
if (!string.IsNullOrEmpty(Settings.templocation))
zf.TempFileFolder = Settings.templocation;
}
public override void PackResources(Ionic.Zip.ZipFile zip, String archiveTargetPath, IPath sourcePath)
{
RelativePath path = new RelativePath(this.Source, sourcePath);
zip.AddFile(path.AbsolutePath, archiveTargetPath);
}
private bool Evaluate(Ionic.Zip.ZipEntry entry)
{
bool result = _Criterion.Evaluate(entry);
return result;
}
/// <summary>
/// Prepare the given stream for output - wrap it in a CountingStream, and
/// then in a CRC stream, and an encryptor and deflator as appropriate.
/// </summary>
/// <remarks>
/// <para>
/// Previously this was used in ZipEntry.Write(), but in an effort to
/// introduce some efficiencies in that method I've refactored to put the
/// code inline. This method still gets called by ZipOutputStream.
/// </para>
/// </remarks>
internal void PrepOutputStream(Stream s,
long streamLength,
out CountingStream outputCounter,
out Stream encryptor,
out Stream compressor,
out Ionic.Crc.CrcCalculatorStream output)
{
TraceWriteLine("PrepOutputStream: e({0}) comp({1}) crypto({2}) zf({3})",
FileName,
CompressionLevel,
Encryption,
_container.Name);
// Wrap a counting stream around the raw output stream:
// This is the last thing that happens before the bits go to the
// application-provided stream.
outputCounter = new CountingStream(s);
// Sometimes the incoming "raw" output stream is already a CountingStream.
// Doesn't matter. Wrap it with a counter anyway. We need to count at both
// levels.
if (streamLength != 0L)
{
// Maybe wrap an encrypting stream around that:
// This will happen BEFORE output counting, and AFTER deflation, if encryption
// is used.
encryptor = MaybeApplyEncryption(outputCounter);
// Maybe wrap a compressing Stream around that.
// This will happen BEFORE encryption (if any) as we write data out.
compressor = MaybeApplyCompression(encryptor, streamLength);
}
else
{
encryptor = compressor = outputCounter;
}
// Wrap a CrcCalculatorStream around that.
// This will happen BEFORE compression (if any) as we write data out.
output = new Ionic.Crc.CrcCalculatorStream(compressor, true);
}
private void Transaction_ProgressChanged(object sender, Ionic.Zip.SaveProgressEventArgs e)
{
try
{
if (prbMaster == null || prbSlave == null ||
prbMaster.IsDisposed || prbSlave.IsDisposed ||
!prbMaster.IsHandleCreated || !prbSlave.IsHandleCreated ||
!prbMaster.Created || !prbSlave.Created)
return;
if (e.TotalBytesToTransfer > 0)
{
if (this.prbSlave.InvokeRequired)
{
this.prbSlave.Invoke(new Action(delegate
{
this.prbSlave.Value = unchecked((int)(e.BytesTransferred * 100 / e.TotalBytesToTransfer));
}));
}
}
if (e.EntriesSaved > 0 && e.EntriesTotal > 0)
{
if (this.prbMaster.InvokeRequired)
{
this.prbMaster.Invoke(new Action(delegate
{
this.prbMaster.Value = unchecked((int)((double)e.EntriesSaved * 100 / (double)e.EntriesTotal));
}));
}
}
}
catch (Exception ex) { EventReflector.CallReport.Post(new ReportEventArgs("GUI.TransferToDisk_ProgressChanged", ex)); }
}
/// <summary>
/// Retrieve the ZipEntry items in the ZipFile that conform to the specified criteria.
/// </summary>
/// <remarks>
///
/// <para>
/// This method applies the criteria set in the FileSelector instance (as described in
/// the <see cref="FileSelector.SelectionCriteria"/>) to the specified ZipFile. Using this
/// method, for example, you can retrieve all entries from the given ZipFile that
/// have filenames ending in .txt.
/// </para>
///
/// <para>
/// Normally, applications would not call this method directly. This method is used
/// by the ZipFile class.
/// </para>
///
/// <para>
/// This overload allows the selection of ZipEntry instances from the ZipFile to be restricted
/// to entries contained within a particular directory in the ZipFile.
/// </para>
///
/// <para>
/// Using the appropriate SelectionCriteria, you can retrieve entries based on size,
/// time, and attributes. See <see cref="FileSelector.SelectionCriteria"/> for a
/// description of the syntax of the SelectionCriteria string.
/// </para>
///
/// </remarks>
///
/// <param name="zip">The ZipFile from which to retrieve entries.</param>
///
/// <param name="directoryPathInArchive">
/// the directory in the archive from which to select entries. If null, then
/// all directories in the archive are used.
/// </param>
///
/// <returns>a collection of ZipEntry objects that conform to the criteria.</returns>
public ICollection<Ionic.Zip.ZipEntry> SelectEntries(Ionic.Zip.ZipFile zip, string directoryPathInArchive)
{
var list = new List<Ionic.Zip.ZipEntry>();
// workitem 8559
string slashSwapped = (directoryPathInArchive==null) ? null : directoryPathInArchive.Replace("/","\\");
// workitem 9174
if (slashSwapped != null)
{
while (slashSwapped.EndsWith("\\"))
slashSwapped= slashSwapped.Substring(0, slashSwapped.Length-1);
}
foreach (Ionic.Zip.ZipEntry e in zip)
{
if (directoryPathInArchive == null || (Path.GetDirectoryName(e.FileName) == directoryPathInArchive)
|| (Path.GetDirectoryName(e.FileName) == slashSwapped)) // workitem 8559
if (this.Evaluate(e))
list.Add(e);
}
return list;
}
public override void PackResources(Ionic.Zip.ZipFile zip, String archiveTargetPath, ScriptCenter.Utils.IPath sourcePath)
{
//No resources to pack for this action.
}
public void SetCompression(Ionic.Zlib.CompressionLevel Level)
{
Zip.CompressionLevel = Level;
}
internal override bool Evaluate(Ionic.Zip.ZipEntry entry)
{
// swap slashes in reference to local configuration
string transformedFileName = entry.FileName.Replace(Path.DirectorySeparatorChar == '/' ? '\\' : '/', Path.DirectorySeparatorChar);
return _Evaluate(transformedFileName);
}
private void _ZOS_z64Over65534Entries
(Zip64Option z64option,
EncryptionAlgorithm encryption,
Ionic.Zlib.CompressionLevel compression)
{
TestContext.WriteLine("_ZOS_z64Over65534Entries hello: {0}",
DateTime.Now.ToString("G"));
int fileCount = _rnd.Next(14616) + 65536;
//int fileCount = _rnd.Next(146) + 5536;
TestContext.WriteLine("entries: {0}", fileCount);
var txrxLabel =
String.Format("ZOS #{0} 64({3}) E({1}) C({2})",
fileCount,
encryption.ToString(),
compression.ToString(),
z64option.ToString());
TestContext.WriteLine("label: {0}", txrxLabel);
string zipFileToCreate =
String.Format("ZOS.Zip64.over65534.{0}.{1}.{2}.zip",
z64option.ToString(), encryption.ToString(),
compression.ToString());
TestContext.WriteLine("zipFileToCreate: {0}", zipFileToCreate);
_txrx = TestUtilities.StartProgressMonitor(zipFileToCreate,
txrxLabel, "starting up...");
TestContext.WriteLine("generating {0} entries ", fileCount);
_txrx.Send("pb 0 max 3"); // 2 stages: Write, Count, Verify
_txrx.Send("pb 0 value 0");
string password = Path.GetRandomFileName();
string statusString = String.Format("status Encryption:{0} Compression:{1}",
encryption.ToString(),
compression.ToString());
_txrx.Send(statusString);
int dirCount = 0;
using (FileStream fs = File.Create(zipFileToCreate))
{
using (var output = new ZipOutputStream(fs))
{
_txrx.Send("test " + txrxLabel);
System.Threading.Thread.Sleep(400);
_txrx.Send("pb 1 max " + fileCount);
_txrx.Send("pb 1 value 0");
output.Password = password;
output.Encryption = encryption;
output.CompressionLevel = compression;
output.EnableZip64 = z64option;
for (int k = 0; k < fileCount; k++)
{
if (_rnd.Next(7) == 0)
{
// make it a directory
string entryName = String.Format("{0:D4}/", k);
output.PutNextEntry(entryName);
dirCount++;
}
else
{
string entryName = String.Format("{0:D4}.txt", k);
output.PutNextEntry(entryName);
// only a few entries are non-empty
if (_rnd.Next(18) == 0)
{
var block = TestUtilities.GenerateRandomAsciiString();
string content = String.Format("This is the content for entry #{0}.\n", k);
int n = _rnd.Next(4) + 1;
for (int j=0; j < n; j++)
content+= block;
byte[] buffer = System.Text.Encoding.ASCII.GetBytes(content);
output.Write(buffer, 0, buffer.Length);
}
}
if (k % 1024 == 0)
_txrx.Send(String.Format("status saving ({0}/{1}) {2:N0}%",
k, fileCount,
((double)k) / (0.01 * fileCount)));
else if (k % 256 == 0)
_txrx.Send("pb 1 value " + k);
}
}
}
_txrx.Send("pb 1 max 1");
_txrx.Send("pb 1 value 1");
_txrx.Send("pb 0 step");
System.Threading.Thread.Sleep(400);
TestContext.WriteLine("Counting entries ... " + DateTime.Now.ToString("G"));
_txrx.Send("status Counting entries...");
Assert.AreEqual<int>
(fileCount - dirCount,
TestUtilities.CountEntries(zipFileToCreate),
"{0}: The zip file created has the wrong number of entries.",
zipFileToCreate);
_txrx.Send("pb 0 step");
System.Threading.Thread.Sleep(140);
// basic verify. The output is really large, so we pass emitOutput=false .
_txrx.Send("status Verifying...");
TestContext.WriteLine("Verifying ... " + DateTime.Now.ToString("G"));
_numExtracted = 0;
_numFilesToExtract = fileCount;
_txrx.Send("pb 1 max " + fileCount);
System.Threading.Thread.Sleep(200);
_txrx.Send("pb 1 value 0");
BasicVerifyZip(zipFileToCreate, password, false, Streams_ExtractProgress);
_txrx.Send("pb 0 step");
System.Threading.Thread.Sleep(800);
TestContext.WriteLine("Done ... " + DateTime.Now.ToString("G"));
}
/// <summary>
/// Retrieve the ZipEntry items in the ZipFile that conform to the specified criteria.
/// </summary>
/// <remarks>
///
/// <para>
/// This method applies the criteria set in the FileSelector instance (as described in
/// the <see cref="FileSelector.SelectionCriteria"/>) to the specified ZipFile. Using this
/// method, for example, you can retrieve all entries from the given ZipFile that
/// have filenames ending in .txt.
/// </para>
///
/// <para>
/// Normally, applications would not call this method directly. This method is used
/// by the ZipFile class.
/// </para>
///
/// <para>
/// Using the appropriate SelectionCriteria, you can retrieve entries based on size,
/// time, and attributes. See <see cref="FileSelector.SelectionCriteria"/> for a
/// description of the syntax of the SelectionCriteria string.
/// </para>
///
/// </remarks>
///
/// <param name="zip">The ZipFile from which to retrieve entries.</param>
///
/// <returns>a collection of ZipEntry objects that conform to the criteria.</returns>
public ICollection<Ionic.Zip.ZipEntry> SelectEntries(Ionic.Zip.ZipFile zip)
{
if (zip == null)
throw new ArgumentNullException("zip");
var list = new List<Ionic.Zip.ZipEntry>();
foreach (Ionic.Zip.ZipEntry e in zip)
{
if (this.Evaluate(e))
list.Add(e);
}
return list;
}
void ReadZip(Ionic.Zip.ZipFile archive, DirectoryInfo dinfo)
{
foreach (Ionic.Zip.ZipEntry entry in archive)
entry.Extract(dinfo.FullName);
}
private static int GetFileFormatByZip(Ionic.Zip.ZipFile oZipFile)
{
if (oZipFile.ContainsEntry("[Content_Types].xml"))
{
Ionic.Zip.ZipEntry oEntry = oZipFile["[Content_Types].xml"];
using (MemoryStream oMemoryStream = new MemoryStream((int)oEntry.UncompressedSize))
{
oEntry.Extract(oMemoryStream);
oMemoryStream.Position = 0;
string sContent = System.Text.UTF8Encoding.UTF8.GetString(oMemoryStream.GetBuffer(), 0, (int)oMemoryStream.Length);
if (-1 != sContent.IndexOf("application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml") ||
-1 != sContent.IndexOf("application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml") ||
-1 != sContent.IndexOf("application/vnd.ms-word.document.macroEnabled.main+xml") ||
-1 != sContent.IndexOf("application/vnd.ms-word.template.macroEnabledTemplate.main+xml"))
return FileFormats.AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCX;
else if (-1 != sContent.IndexOf("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml") ||
-1 != sContent.IndexOf("application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml") ||
-1 != sContent.IndexOf("application/vnd.ms-excel.sheet.macroEnabled.main+xml") ||
-1 != sContent.IndexOf("application/vnd.ms-excel.template.macroEnabled.main+xml"))
return FileFormats.AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX;
else if (-1 != sContent.IndexOf("application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml") ||
-1 != sContent.IndexOf("application/vnd.openxmlformats-officedocument.presentationml.template.main+xml") ||
-1 != sContent.IndexOf("application/vnd.ms-powerpoint.presentation.macroEnabled.main+xml") ||
-1 != sContent.IndexOf("application/vnd.ms-powerpoint.slideshow.macroEnabled.main+xml") ||
-1 != sContent.IndexOf("application/vnd.ms-powerpoint.template.macroEnabled.main+xml"))
return FileFormats.AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTX;
else if (-1 != sContent.IndexOf("application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml"))
return FileFormats.AVS_OFFICESTUDIO_FILE_PRESENTATION_PPSX;
}
}
if (oZipFile.ContainsEntry("mimetype"))
{
Ionic.Zip.ZipEntry oEntry = oZipFile["mimetype"];
using (MemoryStream oMemoryStream = new MemoryStream((int)oEntry.UncompressedSize))
{
oEntry.Extract(oMemoryStream);
oMemoryStream.Position = 0;
string sContent = System.Text.ASCIIEncoding.ASCII.GetString(oMemoryStream.GetBuffer(), 0, (int)oMemoryStream.Length);
if (-1 != sContent.IndexOf("application/vnd.oasis.opendocument.text"))
return FileFormats.AVS_OFFICESTUDIO_FILE_DOCUMENT_ODT;
else if (-1 != sContent.IndexOf("application/vnd.oasis.opendocument.spreadsheet"))
return FileFormats.AVS_OFFICESTUDIO_FILE_SPREADSHEET_ODS;
else if (-1 != sContent.IndexOf("application/vnd.oasis.opendocument.presentation"))
return FileFormats.AVS_OFFICESTUDIO_FILE_PRESENTATION_ODP;
else if (-1 != sContent.IndexOf("application/epub+zip"))
return FileFormats.AVS_OFFICESTUDIO_FILE_DOCUMENT_EPUB;
}
}
if (oZipFile.ContainsEntry("_rels/.rels"))
{
Ionic.Zip.ZipEntry oEntry = oZipFile["_rels/.rels"];
using (MemoryStream oMemoryStream = new MemoryStream((int)oEntry.UncompressedSize))
{
oEntry.Extract(oMemoryStream);
oMemoryStream.Position = 0;
string sContent = System.Text.ASCIIEncoding.ASCII.GetString(oMemoryStream.GetBuffer(), 0, (int)oMemoryStream.Length);
if (-1 != sContent.IndexOf("http://schemas.microsoft.com/xps/2005/06/fixedrepresentation"))
return FileFormats.AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_XPS;
}
}
if (oZipFile.ContainsEntry("_rels/.rels/[0].piece"))
return FileFormats.AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_XPS;
if (oZipFile.ContainsEntry("Editor.bin"))
{
Ionic.Zip.ZipEntry oEntry = oZipFile["Editor.bin"];
int nFormat = FileFormats.AVS_OFFICESTUDIO_FILE_UNKNOWN;
using (MemoryStream oMemoryStream = new MemoryStream((int)oEntry.UncompressedSize))
{
oEntry.Extract(oMemoryStream);
oMemoryStream.Position = 0;
int nSignatureLength = 4;
if (oMemoryStream.Length >= nSignatureLength)
{
byte[] aSignature = new byte[nSignatureLength];
oMemoryStream.Read(aSignature, 0, nSignatureLength);
string sSignature = System.Text.ASCIIEncoding.ASCII.GetString(aSignature);
switch (sSignature)
{
case "DOCY": nFormat = FileFormats.AVS_OFFICESTUDIO_FILE_TEAMLAB_DOCY; break;
case "XLSY": nFormat = FileFormats.AVS_OFFICESTUDIO_FILE_TEAMLAB_XLSY; break;
case "PPTY": nFormat = FileFormats.AVS_OFFICESTUDIO_FILE_TEAMLAB_PPTY; break;
}
}
}
if(FileFormats.AVS_OFFICESTUDIO_FILE_UNKNOWN != nFormat)
return nFormat;
}
else if (oZipFile.ContainsEntry("Editor.xml"))
{
return FileFormats.AVS_OFFICESTUDIO_FILE_OTHER_OLD_PRESENTATION;
}
else if (oZipFile.ContainsEntry("Editor.svg"))
{
return FileFormats.AVS_OFFICESTUDIO_FILE_OTHER_OLD_DRAWING;
}
else if (oZipFile.ContainsEntry("Editor.html.arch"))
{
return FileFormats.AVS_OFFICESTUDIO_FILE_OTHER_OLD_DOCUMENT;
}
return FileFormats.AVS_OFFICESTUDIO_FILE_UNKNOWN;
}
private static IEnumerable<string> ReadZipEntry(Ionic.Zip.ZipEntry entry)
{
using (var entryReader = new StreamReader(entry.OpenReader()))
{
while (!entryReader.EndOfStream)
{
yield return entryReader.ReadLine();
}
}
}
internal abstract bool Evaluate(Ionic.Zip.ZipEntry entry);
