AddEntry() public method

Add an entry, for which the application will provide a stream containing the entry data, on a just-in-time basis.

In cases where the application wishes to open the stream that holds the content for the ZipEntry, on a just-in-time basis, the application can use this method. The application provides an opener delegate that will be called by the DotNetZip library to obtain a readable stream that can be read to get the bytes for the given entry. Typically, this delegate opens a stream. Optionally, the application can provide a closer delegate as well, which will be called by DotNetZip when all bytes have been read from the entry.

These delegates are called from within the scope of the call to ZipFile.Save().

For ZipFile properties including Encryption, , SetCompression, , ExtractExistingFile, ZipErrorAction, and CompressionLevel, their respective values at the time of this call will be applied to the ZipEntry added.

public AddEntry ( string entryName, OpenDelegate opener, CloseDelegate closer ) : ZipEntry
entryName string the name of the entry to add
opener OpenDelegate /// the delegate that will be invoked by ZipFile.Save() to get the /// readable stream for the given entry. ZipFile.Save() will call /// read on this stream to obtain the data for the entry. This data /// will then be compressed and written to the newly created zip /// file. ///
closer CloseDelegate /// the delegate that will be invoked to close the stream. This may /// be null (Nothing in VB), in which case no call is makde to close /// the stream. ///
return ZipEntry
コード例 #1
1
ファイル: Util.cs プロジェクト: jbtule/PclUnit
        public static string CompileNewXAP(HashSet<string> fullsetOfDlls, string shared)
        {
            var tempPath = Path.Combine(shared, Guid.NewGuid() + ".xap");
            using (
                var stream = Assembly.GetExecutingAssembly()
                                     .GetManifestResourceStream("sl_runner.xap.sl-50-xap.xap"))
            using (var baseZip = ZipFile.Read(stream))
            {
                var set = new HashSet<string>();
                var item = baseZip["AppManifest.xaml"];
                var xml = XDocument.Parse(new StreamReader(item.OpenReader()).ReadToEnd());
                using (
                    var zip = new ZipFile()
                    {
                        CompressionLevel = CompressionLevel.Default,
                        CompressionMethod = CompressionMethod.Deflate
                    })
                {
                    zip.AddEntry("AppManifest.xaml", new byte[] { });
                    foreach (var entry in baseZip.Entries)
                    {
                        if (entry.FileName.Contains(".dll"))
                        {
                            using (var memstream = new MemoryStream())
                            {
                                entry.OpenReader().CopyTo(memstream);
                                memstream.Seek(0, SeekOrigin.Begin);
                                zip.AddEntry(entry.FileName, memstream.ToArray());
                                set.Add(Path.GetFileName(entry.FileName));
                            }
                        }
                    }
                    var desc = xml.DescendantNodes().OfType<XElement>();

                    var parts = desc.Single(it => it.Name.LocalName.Contains("Deployment.Parts"));

                    foreach (var dll in fullsetOfDlls)
                    {
                        if (set.Contains(Path.GetFileName(dll)))
                            continue;
                        set.Add(Path.GetFileName(dll));
                        zip.AddFile(dll, "");
                        parts.Add(new XElement(XName.Get("AssemblyPart", "http://schemas.microsoft.com/client/2007/deployment"),
                                               new XAttribute(
                                                   XName.Get("Name", "http://schemas.microsoft.com/winfx/2006/xaml"),
                                                   Path.GetFileNameWithoutExtension(dll)),
                                               new XAttribute("Source", Path.GetFileName(dll))));
                    }
                    using (var memstream = new MemoryStream())
                    {
                        xml.Save(memstream, SaveOptions.OmitDuplicateNamespaces);
                        zip.UpdateEntry("AppManifest.xaml", memstream.ToArray());
                    }
                    zip.Save(tempPath);
                }
            }
            return tempPath;
        }
コード例 #2
0
// --------------------------------------------------------------------------- 
    public void Write(Stream stream) {    
      using (ZipFile zip = new ZipFile()) {
        byte[] circledata = { 
          (byte) 0x3c, (byte) 0x7e, (byte) 0xff, (byte) 0xff, 
          (byte) 0xff, (byte) 0xff, (byte) 0x7e, (byte) 0x3c 
        };
        Image mask = Image.GetInstance(8, 8, 1, 1, circledata);
        mask.MakeMask();
        mask.Inverted = true;
        
        ImageMask im = new ImageMask();
        zip.AddEntry(RESULT1, im.CreatePdf(mask));
        
        byte[] gradient = new byte[256];
        for (int i = 0; i < 256; i++) {
          gradient[i] = (byte) i;
        }
        mask = Image.GetInstance(256, 1, 1, 8, gradient);
        mask.MakeMask();
        im = new ImageMask();
        zip.AddEntry(RESULT2, im.CreatePdf(mask));

        zip.AddFile(RESOURCE, "");
        zip.Save(stream);             
      }
    }
コード例 #3
0
ファイル: Book.cs プロジェクト: karino2/wikipediaconv
        /// <summary>
        /// Create a TOC from the chapters and create the file
        /// </summary>
        /// <param name="filename"></param>
        public void Save(string filename)
        {
            using (ZipFile zippedBook = new ZipFile())
            {
                zippedBook.ForceNoCompression = true;
                ZipEntry mimetype = zippedBook.AddEntry("mimetype", "", "application/epub+zip");

                zippedBook.ForceNoCompression = false;

                zippedBook.AddEntry("container.xml", "META-INF", GetResource("EPubLib.Files.META_INF.container.xml"));
                zippedBook.AddEntry("content.opf", "OEBPS", GetContentOpf(), Encoding.UTF8);
                zippedBook.AddEntry("toc.ncx", "OEBPS", GetToc(), Encoding.UTF8);

                foreach (Chapter chapter in GetChapters())
                {
                    zippedBook.AddEntry("chapter" + chapter.Number.ToString("000") + ".xhtml", "OEBPS", chapter.Content, Encoding.UTF8);
                }
                foreach (FileItem image in GetImages())
                {
                    zippedBook.AddEntry(image.Name, "OEBPS/images", image.Data);
                }

                zippedBook.Save(filename);
            }
        }
コード例 #4
0
        public void ImportActionShouldAddTestsToProblemIfZipFileIsCorrect()
        {
            var zipFile = new ZipFile();

            var inputTest = "input";
            var outputTest = "output";

            zipFile.AddEntry("test.001.in.txt", inputTest);
            zipFile.AddEntry("test.001.out.txt", outputTest);

            var zipStream = new MemoryStream();
            zipFile.Save(zipStream);
            zipStream = new MemoryStream(zipStream.ToArray());

            this.File.Setup(x => x.ContentLength).Returns(1);
            this.File.Setup(x => x.FileName).Returns("file.zip");
            this.File.Setup(x => x.InputStream).Returns(zipStream);

            var redirectResult = this.TestsController.Import("1", this.File.Object, false, false) as RedirectToRouteResult;
            Assert.IsNotNull(redirectResult);

            Assert.AreEqual("Problem", redirectResult.RouteValues["action"]);
            Assert.AreEqual(1, redirectResult.RouteValues["id"]);

            var tests = this.Data.Problems.All().First(pr => pr.Id == 1).Tests.Count;
            Assert.AreEqual(14, tests);

            var tempDataHasKey = this.TestsController.TempData.ContainsKey(GlobalConstants.InfoMessage);
            Assert.IsTrue(tempDataHasKey);

            var tempDataMessage = this.TestsController.TempData[GlobalConstants.InfoMessage];
            Assert.AreEqual("Тестовете са добавени към задачата", tempDataMessage);
        }
コード例 #5
0
        public override void ExportImpl(System.Windows.Window parentWindow, Data.DataMatrix matrix, string datasetName, object options)
        {
            var opts = options as DarwinCoreExporterOptions;

            var columnNames = new List<String>();

            matrix.Columns.ForEach(col => {
                if (!col.IsHidden) {
                    columnNames.Add(col.Name);
                }
            });

            datasetName = SystemUtils.StripIllegalFilenameChars(datasetName);

            using (ZipFile archive = new ZipFile(opts.Filename)) {

                archive.AddEntry(String.Format("{0}\\occurrence.txt", datasetName), (String name, Stream stream) => {
                    ExportToCSV(matrix, stream, opts, true);
                });

                archive.AddEntry(String.Format("{0}\\meta.xml", datasetName), (String name, Stream stream) => {
                    WriteMetaXml(stream, opts, columnNames);
                });

                archive.Save();
            }
        }
コード例 #6
0
 // --------------------------------------------------------------------------- 
 public void Write(Stream stream)
 {
     using (ZipFile zip = new ZipFile())
     {
         Stationery s = new Stationery();
         StampStationery ss = new StampStationery();
         byte[] stationery = s.CreateStationary();
         byte[] sStationery = ss.ManipulatePdf(
           ss.CreatePdf(), stationery
         );
         byte[] insertPages = ManipulatePdf(sStationery, stationery);
         zip.AddEntry(RESULT1, insertPages);
         // reorder the pages in the PDF
         PdfReader reader = new PdfReader(insertPages);
         reader.SelectPages("3-41,1-2");
         using (MemoryStream ms = new MemoryStream())
         {
             using (PdfStamper stamper = new PdfStamper(reader, ms))
             {
             }
             zip.AddEntry(RESULT2, ms.ToArray());
         }
         zip.AddEntry(Utility.ResultFileName(s.ToString() + ".pdf"), stationery);
         zip.AddEntry(Utility.ResultFileName(ss.ToString() + ".pdf"), sStationery);
         zip.Save(stream);
     }
 }
コード例 #7
0
ファイル: Epub.cs プロジェクト: 13xforever/DeDRM
 public byte[] Strip(ZipFile zip, Dictionary<string, Tuple<Cipher, byte[]>> sessionKeys)
 {
     IEnumerable<ZipEntry> entriesToDecrypt = zip.Entries.Where(e => !META_NAMES.Contains(e.FileName));
     using (var output = new ZipFile(Encoding.UTF8))
     {
         output.UseZip64WhenSaving = Zip64Option.Never;
         output.CompressionLevel = CompressionLevel.None;
         using (var s = new MemoryStream())
         {
             zip["mimetype"].Extract(s);
             output.AddEntry("mimetype", s.ToArray());
         }
         foreach (var file in entriesToDecrypt)
         {
             byte[] data;
             using (var s = new MemoryStream())
             {
                 file.Extract(s);
                 data = s.ToArray();
             }
             if (sessionKeys.ContainsKey(file.FileName))
                 data = Decryptor.Decrypt(data, sessionKeys[file.FileName].Item1, sessionKeys[file.FileName].Item2);
             var ext = Path.GetExtension(file.FileName);
             output.CompressionLevel = UncompressibleExts.Contains(ext) ? CompressionLevel.None : CompressionLevel.BestCompression;
             output.AddEntry(file.FileName, data);
         }
         using (var result = new MemoryStream())
         {
             output.Save(result);
             return result.ToArray();
         }
     }
 }
コード例 #8
0
// ---------------------------------------------------------------------------
    public void Write(Stream stream) {
      MovieLinks1 ml = new MovieLinks1();
      MovieHistory mh = new MovieHistory();
      List<byte[]> pdf = new List<byte[]>() {
        Utility.PdfBytes(ml),
        Utility.PdfBytes(mh)
      };
      string[] names = {ml.ToString(), mh.ToString()};
      using (ZipFile zip = new ZipFile()) { 
        using (MemoryStream ms = new MemoryStream()) {
          // step 1
          using (Document document = new Document()) {
            // step 2
            using (PdfCopy copy = new PdfCopy(document, ms)) {
              // step 3
              document.Open();
              // step 4
              for (int i = 0; i < pdf.Count; ++i) {
                zip.AddEntry(Utility.ResultFileName(names[i] + ".pdf"), pdf[i]);
                PdfReader reader = new PdfReader(pdf[i]);
                // loop over the pages in that document
                int n = reader.NumberOfPages;
                for (int page = 0; page < n; ) {
                  copy.AddPage(copy.GetImportedPage(reader, ++page));
                }
              }
            }
          }
          zip.AddEntry(RESULT, ms.ToArray());
        }
        zip.Save(stream);    
      }
    }
コード例 #9
0
        public void OutputZip(HttpResponseBase response, 
            FileHandle dataFile,
            IEnumerable<FileHandle> photoFiles,
            IEnumerable<StreamHandle> docmentStreams,
            string downloadTokenValue,
            string zipFilename)
        {
            using (var zip = new ZipFile())
            {
                zip.UseZip64WhenSaving = Zip64Option.AsNecessary;

                var pdfList = new List<FileHandle>();
                if (dataFile != null) pdfList.Add(dataFile);
                pdfList.AddRange(photoFiles);

                PrepareResponse(response, downloadTokenValue, zipFilename);

                foreach (var pdfHolder in pdfList)
                {
                    zip.AddEntry(pdfHolder.FileName, pdfHolder.Content);
                }

                foreach (var document in docmentStreams)
                {
                    if (document.ContentStream != null)
                    {
                        zip.AddEntry(document.FileName, document.ContentStream);
                    }
                }

                zip.Save(response.OutputStream);

            }
        }
コード例 #10
0
 // ---------------------------------------------------------------------------
 public void Write(Stream stream)
 {
     // Use old example to create PDF
     MovieTemplates mt = new MovieTemplates();
     byte[] pdf = Utility.PdfBytes(mt);
     using (ZipFile zip = new ZipFile())
     {
         using (MemoryStream ms = new MemoryStream())
         {
             // step 1
             using (Document document = new Document())
             {
                 // step 2
                 PdfWriter writer = PdfWriter.GetInstance(document, ms);
                 // step 3
                 document.Open();
                 // step 4
                 PdfPTable table = new PdfPTable(2);
                 PdfReader reader = new PdfReader(pdf);
                 int n = reader.NumberOfPages;
                 PdfImportedPage page;
                 for (int i = 1; i <= n; i++)
                 {
                     page = writer.GetImportedPage(reader, i);
                     table.AddCell(Image.GetInstance(page));
                 }
                 document.Add(table);
             }
             zip.AddEntry(RESULT, ms.ToArray());
         }
         zip.AddEntry(Utility.ResultFileName(mt.ToString() + ".pdf"), pdf);
         zip.Save(stream);
     }
 }
コード例 #11
0
// ---------------------------------------------------------------------------
    public void Write(Stream stream) {
      // use one of the previous examples to create a PDF
      MovieTemplates mt = new MovieTemplates();
      // Create a reader
      byte[] pdf = Utility.PdfBytes(mt);
      PdfReader reader = new PdfReader(pdf);
      // loop over all the pages in the original PDF
      int n = reader.NumberOfPages;      
      using (ZipFile zip = new ZipFile()) {
        for (int i = 0; i < n; ) {
          string dest = string.Format(RESULT, ++i);
          using (MemoryStream ms = new MemoryStream()) {
// We'll create as many new PDFs as there are pages
            // step 1
            using (Document document = new Document()) {
              // step 2
              using (PdfCopy copy = new PdfCopy(document, ms)) {
                // step 3
                document.Open();
                // step 4
                copy.AddPage(copy.GetImportedPage(reader, i));
              }
            }
            zip.AddEntry(dest, ms.ToArray());
          }
        }
        zip.AddEntry(Utility.ResultFileName(mt.ToString() + ".pdf"), pdf);
        zip.Save(stream);       
      }
    }
コード例 #12
0
// ---------------------------------------------------------------------------        
    public void Write(Stream stream) {
      using (ZipFile zip = new ZipFile()) { 
        byte[] pdf = new Superimposing().CreatePdf();
        // Create a reader
        PdfReader reader = new PdfReader(pdf);
        using (MemoryStream ms = new MemoryStream()) {     
          // step 1
          using (Document document = new Document(PageSize.POSTCARD)) {
            // step 2
            PdfWriter writer = PdfWriter.GetInstance(document, ms);
            // step 3
            document.Open();
            // step 4
            PdfContentByte canvas = writer.DirectContent;
            PdfImportedPage page;
            for (int i = 1; i <= reader.NumberOfPages; i++) {
              page = writer.GetImportedPage(reader, i);
              canvas.AddTemplate(page, 1f, 0, 0, 1, 0, 0);
            }
          } 
          zip.AddEntry(RESULT, ms.ToArray());
        }
        zip.AddEntry(SOURCE, pdf);
        zip.Save(stream);            
      }        
    }
コード例 #13
0
 // ---------------------------------------------------------------------------
 public void Write(Stream stream)
 {
     using (ZipFile zip = new ZipFile())
     {
         HelloWorld h = new HelloWorld();
         byte[] pdf = Utility.PdfBytes(h);
         // Create a reader
         PdfReader reader = new PdfReader(pdf);
         string js = File.ReadAllText(
           Path.Combine(Utility.ResourceJavaScript, RESOURCE)
         );
         using (MemoryStream ms = new MemoryStream())
         {
             using (PdfStamper stamper = new PdfStamper(reader, ms))
             {
                 // Add some javascript
                 stamper.JavaScript = js;
             }
             zip.AddEntry(RESULT, ms.ToArray());
         }
         zip.AddEntry(RESOURCE, js);
         zip.AddEntry(Utility.ResultFileName(h.ToString() + ".pdf"), pdf);
         zip.Save(stream);
     }
 }
コード例 #14
0
// ---------------------------------------------------------------------------    
    public void Write(Stream stream) {
      using (ZipFile zip = new ZipFile()) {
        // Use previous examples to create PDF files
        MovieLinks1 m = new MovieLinks1(); 
        byte[] pdfM = Utility.PdfBytes(m);
        LinkActions l = new LinkActions();
        byte[] pdfL = l.CreatePdf();
        // Create readers.
        PdfReader[] readers = {
          new PdfReader(pdfL),
          new PdfReader(pdfM)
        };
        
        // step 1
        //Document document = new Document();
        // step 2
        using (var ms = new MemoryStream()) { 
          // step 1
          using (Document document = new Document()) {
            using (PdfCopy copy = new PdfCopy(document, ms)) {
              // step 3
              document.Open();
              // step 4
              int n;
              // copy the pages of the different PDFs into one document
              for (int i = 0; i < readers.Length; i++) {
                readers[i].ConsolidateNamedDestinations();
                n = readers[i].NumberOfPages;
                for (int page = 0; page < n; ) {
                  copy.AddPage(copy.GetImportedPage(readers[i], ++page));
                }
              }
              // Add named destination  
              copy.AddNamedDestinations(
                // from the second document
                SimpleNamedDestination.GetNamedDestination(readers[1], false),
                // using the page count of the first document as offset
                readers[0].NumberOfPages
              );
            }
            zip.AddEntry(RESULT1, ms.ToArray());
          }
          
          // Create a reader
          PdfReader reader = new PdfReader(ms.ToArray());
          // Convert the remote destinations into local destinations
          reader.MakeRemoteNamedDestinationsLocal();
          using (MemoryStream ms2 = new MemoryStream()) {
            // Create a new PDF containing the local destinations
            using (PdfStamper stamper = new PdfStamper(reader, ms2)) {
            }
            zip.AddEntry(RESULT2, ms2.ToArray());
          }
          
        }
        zip.AddEntry(Utility.ResultFileName(m.ToString() + ".pdf"), pdfM);
        zip.AddEntry(Utility.ResultFileName(l.ToString() + ".pdf"), pdfL);
        zip.Save(stream);             
      }   
   }
コード例 #15
0
// ---------------------------------------------------------------------------    
    public void Write(Stream stream) {   
      using (ZipFile zip = new ZipFile()) { 
        MovieLinks1 ml = new MovieLinks1();
        byte[] r1 = Utility.PdfBytes(ml);
        MovieHistory mh = new MovieHistory();
        byte[] r2 = Utility.PdfBytes(mh);
        using (MemoryStream ms = new MemoryStream()) {
          // step 1
          using (Document document = new Document()) {
            // step 2
            using (PdfCopy copy = new PdfCopy(document, ms)) {
              // step 3
              document.Open();
              // step 4
              // reader for document 1
              PdfReader reader1 = new PdfReader(r1);
              int n1 = reader1.NumberOfPages;
              // reader for document 2
              PdfReader reader2 = new PdfReader(r2);
              int n2 = reader2.NumberOfPages;
              // initializations
              PdfImportedPage page;
              PdfCopy.PageStamp stamp;
              // Loop over the pages of document 1
              for (int i = 0; i < n1; ) {
                page = copy.GetImportedPage(reader1, ++i);
                stamp = copy.CreatePageStamp(page);
                // add page numbers
                ColumnText.ShowTextAligned(
                  stamp.GetUnderContent(), Element.ALIGN_CENTER,
                  new Phrase(string.Format("page {0} of {1}", i, n1 + n2)),
                  297.5f, 28, 0
                );
                stamp.AlterContents();
                copy.AddPage(page);
              }

              // Loop over the pages of document 2
              for (int i = 0; i < n2; ) {
                page = copy.GetImportedPage(reader2, ++i);
                stamp = copy.CreatePageStamp(page);
                // add page numbers
                ColumnText.ShowTextAligned(
                  stamp.GetUnderContent(), Element.ALIGN_CENTER,
                  new Phrase(string.Format("page {0} of {1}", n1 + i, n1 + n2)),
                  297.5f, 28, 0
                );
                stamp.AlterContents();
                copy.AddPage(page);
              }   
            }   
          }
          zip.AddEntry(RESULT, ms.ToArray());          
          zip.AddEntry(Utility.ResultFileName(ml.ToString() + ".pdf"), r1);       
          zip.AddEntry(Utility.ResultFileName(mh.ToString()+ ".pdf"), r2); 
        }
        zip.Save(stream);
      }       
    }
コード例 #16
0
// --------------------------------------------------------------------------- 
    public void Write(Stream stream) {
      using (ZipFile zip = new ZipFile()) {
        PdfXPdfA example = new PdfXPdfA();
        zip.AddEntry(RESULT1, example.CreatePdfX());       
        zip.AddEntry(RESULT2, example.CreatePdfA());       
        zip.Save(stream);             
      }
    }    
コード例 #17
0
// ---------------------------------------------------------------------------    
    public void Write(Stream stream) {
      using (ZipFile zip = new ZipFile()) {
        PeekABoo peekaboo = new PeekABoo();
        zip.AddEntry(RESULT1, peekaboo.CreatePdf(true));       
        zip.AddEntry(RESULT2, peekaboo.CreatePdf(false));       
        zip.Save(stream);             
      }
    }    
コード例 #18
0
// ---------------------------------------------------------------------------
    public void Write(Stream stream) {
      using (ZipFile zip = new ZipFile()) {
        MovieAds movieAds = new MovieAds();
        byte[] pdf = movieAds.CreateTemplate();
        zip.AddEntry(TEMPLATE, pdf);       
        
        using (MemoryStream msDoc = new MemoryStream()) {
          using (Document document = new Document()) {
            using (PdfSmartCopy copy = new PdfSmartCopy(document, msDoc)) {
              document.Open();
              PdfReader reader;
              PdfStamper stamper = null;
              AcroFields form = null;
              int count = 0;
              MemoryStream ms = null;
              using (ms) {
                foreach (Movie movie in PojoFactory.GetMovies()) {
                  if (count == 0) {
                    ms = new MemoryStream();
                    reader = new PdfReader(RESOURCE);
                    stamper = new PdfStamper(reader, ms);
                    stamper.FormFlattening = true;
                    form = stamper.AcroFields;
                  }
                  count++;
                  PdfReader ad = new PdfReader(
                    movieAds.FillTemplate(pdf, movie)
                  );
                  PdfImportedPage page = stamper.GetImportedPage(ad, 1);
                  PushbuttonField bt = form.GetNewPushbuttonFromField(
                    "movie_" + count
                  );
                  bt.Layout = PushbuttonField.LAYOUT_ICON_ONLY;
                  bt.ProportionalIcon = true;
                  bt.Template = page;
                  form.ReplacePushbuttonField("movie_" + count, bt.Field);
                  if (count == 16) {
                    stamper.Close();
                    reader = new PdfReader(ms.ToArray());
                    copy.AddPage(copy.GetImportedPage(reader, 1));
                    count = 0;
                  }
                }
                if (count > 0) {
                  stamper.Close();
                  reader = new PdfReader(ms.ToArray());
                  copy.AddPage(copy.GetImportedPage(reader, 1));
                }
              }
            }
          }
          zip.AddEntry(RESULT, msDoc.ToArray());
        }

        zip.AddFile(RESOURCE, "");
        zip.Save(stream);             
      }
    }
コード例 #19
0
// --------------------------------------------------------------------------- 
    public void Write(Stream stream) {
      using (ZipFile zip = new ZipFile()) {
        TextFields example = new TextFields(0);
        byte[] pdf = example.CreatePdf();
        zip.AddEntry(RESULT1, pdf);       
        zip.AddEntry(RESULT2, example.ManipulatePdf(pdf));       
        zip.Save(stream);             
      }
    }
コード例 #20
0
// ---------------------------------------------------------------------------    
    public virtual void Write(Stream stream) {
      using (ZipFile zip = new ZipFile()) {
        HtmlMovies1 h = new HtmlMovies1();
        byte[] pdf = h.CreateHtmlAndPdf(stream);
        zip.AddEntry(HTML, h.Html.ToString());
        zip.AddEntry(PDF, pdf);
        zip.Save(stream);             
      }
    }
コード例 #21
0
// --------------------------------------------------------------------------- 
    public void Write(Stream stream) {
      using (ZipFile zip = new ZipFile()) {
// create first PDF        
        byte[] stationary  = CreateStationary();
        zip.AddEntry(STATIONERY, stationary);
        zip.AddEntry(RESULT, CreatePdf(stationary));
        zip.Save(stream);
      }
    }
コード例 #22
0
// ---------------------------------------------------------------------------    
    public void Write(Stream stream) {
      using (ZipFile zip = new ZipFile()) {
        SpecialId s = new SpecialId();
        byte[] pdf = s.CreatePdf();
        zip.AddEntry(Utility.ResultFileName(s.ToString() + ".pdf"), pdf);       
        zip.AddEntry(RESULT, new ResizeImage().ManipulatePdf(pdf));       
        zip.Save(stream);             
      }
    } 
コード例 #23
0
// --------------------------------------------------------------------------- 
    public void Write(Stream stream) {
      using (ZipFile zip = new ZipFile()) {
        ReplaceURL form = new ReplaceURL(); 
    	  byte[] pdf = form.CreatePdf();
  	    zip.AddEntry(RESULT1, pdf);
  	    zip.AddEntry(RESULT2, form.ManipulatePdf(pdf));         
        zip.Save(stream);             
      }
    }     
コード例 #24
0
// ---------------------------------------------------------------------------    
    public void Write(Stream stream) {
      using (ZipFile zip = new ZipFile()) {
        EmbedFontPostFacto example = new EmbedFontPostFacto();
        byte[] pdf = example.CreatePdf();
        zip.AddEntry(RESULT1, pdf);       
        zip.AddEntry(RESULT2, example.ManipulatePdf(pdf));       
        zip.Save(stream);             
      }
    }     
コード例 #25
0
// ---------------------------------------------------------------------------    
    public void Write(Stream stream) {
      using (ZipFile zip = new ZipFile()) {
        CreateOutlineTree example = new CreateOutlineTree();
        byte[] pdf = example.CreatePdf();
        zip.AddEntry(RESULT, pdf);
        zip.AddEntry(RESULTXML, example.CreateXml(pdf));
        zip.Save(stream);             
      }   
    }
コード例 #26
0
// --------------------------------------------------------------------------- 
    public void Write(Stream stream) {
      using (ZipFile zip = new ZipFile()) {
        CompressImage c = new CompressImage();
        zip.AddEntry(RESULT1, c.CreatePdf(false));
        zip.AddEntry(RESULT2, c.CreatePdf(true));
        zip.AddFile(Path.Combine(Utility.ResourceImage, RESOURCE), "");
        zip.Save(stream);             
      }
    }
コード例 #27
0
// ---------------------------------------------------------------------------    
    public void Write(Stream stream) {
      using (ZipFile zip = new ZipFile()) { 
        MovieTemplates m = new MovieTemplates();
        byte[] pdf = Utility.PdfBytes(m); 
        zip.AddEntry(RESULT, new NamedActions().ManipulatePdf(pdf)); 
        zip.AddEntry(Utility.ResultFileName(m.ToString() + ".pdf"), pdf);
        zip.Save(stream);             
      }
    }
コード例 #28
0
// ---------------------------------------------------------------------------
    public void Write(Stream stream) {
      using (ZipFile zip = new ZipFile()) {
        MetadataPdf metadata = new MetadataPdf();
        byte[] pdf = metadata.CreatePdf();
        zip.AddEntry(RESULT1, pdf);
        zip.AddEntry(RESULT2, metadata.ManipulatePdf(pdf));
        zip.Save(stream);
      }
    }
コード例 #29
0
// --------------------------------------------------------------------------- 
    public void Write(Stream stream) {
      using (ZipFile zip = new ZipFile()) {
        ChoiceFields fields = new ChoiceFields(0);
        byte[] pdf = fields.CreatePdf();
        zip.AddEntry(RESULT1, pdf);       
        zip.AddEntry(RESULT2, fields.ManipulatePdf(pdf));       
        zip.Save(stream);             
      }
    }
コード例 #30
0
        public void Save()
        {
            //archive.UpdateEntry(name, Document.ToString());
            //using (var stream = entry.Open())
            //{
            //    stream.Seek(0, SeekOrigin.End);
            //    using (var sw = new StreamWriter(stream))
            //    {
            //        sw.Write(Document.ToString());
            //        sw.Flush();
            //    }
            //}
            var path = AppDomain.CurrentDomain.BaseDirectory + "temp.xml";

            Document.Save(path);
            archive.RemoveEntry(entry);
            archive.AddEntry(name, new FileStream(path, FileMode.Open));
            archive.Save();
            //using (var s = new MemoryStream())
            //{
            //    using (var sw = new StreamWriter(s))
            //    {
            //        var xml = Document.ToString();
            //        sw.WriteLine("123");
            //        sw.Flush();
            //        archive.AddEntry("test.xml", s);
            //        archive.Save();
            //    }
            //    //Document.Save(s);

            //}
        }
コード例 #31
0
 /// <summary>
 /// Append the zip data to the file-entry specified.
 /// </summary>
 /// <param name="path"></param>
 /// <param name="entry"></param>
 /// <param name="data"></param>
 /// <returns></returns>
 public static bool ZipCreateAppendData(string path, string entry, string data)
 {
     try
     {
         if (File.Exists(path))
         {
             using (var zip = ZipFile.Read(path))
             {
                 zip.AddEntry(entry, data);
                 zip.Save();
             }
         }
         else
         {
             using (var zip = new ZipFile(path))
             {
                 zip.AddEntry(entry, data);
                 zip.Save();
             }
         }
     }
     catch (Exception err)
     {
         Log.Error(err);
         return(false);
     }
     return(true);
 }
コード例 #32
0
        /// <summary>
        /// compress the files
        /// </summary>
        /// <param name="FolderToZip"></param>
        /// <param name="s"></param>
        /// <param name="ParentFolderName"></param>
        private static bool ZipFileDictory(string FolderToZip, string ParentFolderName, Ionic.Zip.ZipFile zip)
        {
            bool res = true;

            string[]   folders, filenames;
            ZipEntry   entry = null;
            FileStream fs    = null;

            try
            {
                //create current folder
                using (Ionic.Zip.ZipFile izip = new Ionic.Zip.ZipFile(Path.Combine(ParentFolderName, Path.GetFileName(FolderToZip)), Encoding.UTF8))
                {
                    //first compress the file, then the folder
                    filenames = Directory.GetFiles(FolderToZip);
                    foreach (string file in filenames)
                    {
                        if (File.Exists(file))
                        {
                            using (FileStream innerfs = new FileStream(file, FileMode.Open, FileAccess.Read))
                            {
                                byte[] buffer = new byte[innerfs.Length];
                                innerfs.Read(buffer, 0, buffer.Length);
                                string fileName = file.Substring(file.LastIndexOf("\\") + 1);
                                izip.AddEntry(fileName, buffer);
                            }
                        }
                    }
                }
            }
            catch
            {
                res = false;
            }
            finally
            {
                if (fs != null)
                {
                    fs.Close();
                    fs = null;
                }
                if (entry != null)
                {
                    entry = null;
                }
                GC.Collect();
                GC.Collect(1);
            }
            folders = Directory.GetDirectories(FolderToZip);
            foreach (string folder in folders)
            {
                if (!ZipFileDictory(folder, Path.Combine(ParentFolderName, Path.GetFileName(FolderToZip)), zip))
                {
                    return(false);
                }
            }

            return(res);
        }
コード例 #33
0
ファイル: Entity.cs プロジェクト: Svetuf/FileManager
        public void CreateFile(string filename)
        {
            MemoryStream memory = new MemoryStream();
            var          bytes  = ReadBytes(filename);

            memory.Write(bytes, 0, bytes.Length);

            using (Ionic.Zip.ZipFile zip = new Ionic.Zip.ZipFile(path))

            {
                ZipEntry e = zip.AddEntry(filename, memory);
                // zip.AddFile(filename);

                zip.Save();
            }
        }
コード例 #34
0
 /// <summary>
 /// 压缩zip
 /// </summary>
 /// <param name="fileToZips">文件路径集合</param>
 /// <param name="zipedFile">想要压成zip的文件名</param>
 public static void Zip(string[] fileToZips, string zipedFile)
 {
     using (Ionic.Zip.ZipFile zip = new Ionic.Zip.ZipFile(zipedFile, Encoding.Default))
     {
         foreach (string fileToZip in fileToZips)
         {
             using (FileStream fs = new FileStream(fileToZip, FileMode.Open, FileAccess.ReadWrite))
             {
                 byte[] buffer = new byte[fs.Length];
                 fs.Read(buffer, 0, buffer.Length);
                 string fileName = fileToZip.Substring(fileToZip.LastIndexOf("\\") + 1);
                 zip.AddEntry(fileName, buffer);
             }
         }
         zip.Save();
     }
 }
コード例 #35
0
ファイル: FileTool.cs プロジェクト: WeboxChen/WxQuestion
 public static void Compress(string zipfile, Dictionary <string, string> entrys, Encoding encoding = default(Encoding))
 {
     if (encoding == default(Encoding))
     {
         encoding = Encoding.Default;
     }
     using (Ionic.Zip.ZipFile zip = new Ionic.Zip.ZipFile(encoding))
     {
         foreach (var key in entrys.Keys)
         {
             if (File.Exists(entrys[key]))
             {
                 zip.AddEntry(key, File.OpenRead(entrys[key]));
             }
         }
         zip.Save(zipfile);
     }
 }
コード例 #36
0
        private byte[] IncludeZip(string file, string fileName)
        {
            byte[] ziplenecekData = Encoding.UTF8.GetBytes(file);

            MemoryStream zipStream = new MemoryStream();

            using (ZipFile zip = new Ionic.Zip.ZipFile())
            {
                ZipEntry zipEleman = zip.AddEntry(fileName + ".txt", ziplenecekData);

                zip.Save(zipStream);
            }

            zipStream.Seek(0, SeekOrigin.Begin);
            zipStream.Flush();

            zipStream.Position = 0;
            return(zipStream.ToArray());
        }
コード例 #37
0
        /** Compressess given source string into a zip file formatted as base64 */
        public static string Compress(string source)
        {
                        #if ZIP_NONE
            return(System.Convert.ToBase64String(Encoding.UTF8.GetBytes(source)));
                        #endif
                        #if ZIP_IONIC
            using (var zip = new Ionic.Zip.ZipFile())
            {
                // compressed data, then converts back to a string again
                zip.AddEntry("x", source);
                var zipOutput = new MemoryStream();
                zip.Save(zipOutput);

                // Base 64 encoding (so that I can embed it in an XML file.
                return(System.Convert.ToBase64String(zipOutput.ToArray()));
            }
                        #endif
                        #if ZIP_SHARP
            using (MemoryStream fsOut = new MemoryStream())
            {
                using (var zipStream = new ZipOutputStream(fsOut))
                {
                    zipStream.SetLevel(3);

                    var newEntry = new ZipEntry("X");
                    zipStream.PutNextEntry(newEntry);

                    var sourceBytes = Encoding.UTF8.GetBytes(source);
                    Util.CopyStream(new MemoryStream(sourceBytes), zipStream);

                    zipStream.CloseEntry();
                    zipStream.IsStreamOwner = false;
                    zipStream.Close();
                }

                // Base 64 encoding (so that I can embed it in an XML file.
                return(Convert.ToBase64String(fsOut.ToArray()));
            }
                        #endif
        }
コード例 #38
0
ファイル: FileTool.cs プロジェクト: WeboxChen/WxQuestion
        /// <summary>
        /// 压缩文件
        /// </summary>
        /// <param name="entrys">新文件名,支持目录 => 原始文件名</param>
        /// <param name="encoding">编码</param>
        /// <returns></returns>
        public static Stream CompressOutStream(Dictionary <string, string> entrys, Encoding encoding = default(Encoding))
        {
            if (encoding == default(Encoding))
            {
                encoding = Encoding.Default;
            }
            MemoryStream stream = new MemoryStream();

            using (Ionic.Zip.ZipFile zip = new Ionic.Zip.ZipFile(encoding))
            {
                foreach (var key in entrys.Keys)
                {
                    if (File.Exists(entrys[key]))
                    {
                        zip.AddEntry(key, File.OpenRead(entrys[key]));
                    }
                }
                zip.Save(stream);
                stream.Position = 0;
            }
            return(stream);
        }
コード例 #39
0
        private static ZipOutputStream CreateNewStream(ArrayList htmlFile, string outPath, out long HTMLstreamlenght)
        {
            ZipOutputStream oZipStream = new ZipOutputStream(File.Create(outPath), false);// create zip stream

            // Compression level of zip file.

            oZipStream.CompressionLevel = 0;
            const int BufferSize = 4096;

            byte[] obuffer = new byte[BufferSize];
            HTMLstreamlenght = 0;
            //FileStream htmlstream = null;
            ZipEntry oHtmlEntry = new ZipEntry();

            using (Ionic.Zip.ZipFile htmlZip = new Ionic.Zip.ZipFile())
            {
                foreach (string htmlFil in htmlFile.ToArray()) // for each file, generate a zip entry
                {
                    oHtmlEntry = htmlZip.AddEntry(Path.GetFileName(htmlFil.ToString()), htmlFil);
                    oZipStream.PutNextEntry(oHtmlEntry.FileName);
                    using (FileStream htmlstream = File.OpenRead(htmlFil))
                    {
                        int read;
                        while ((read = htmlstream.Read(obuffer, 0, obuffer.Length)) > 0)
                        {
                            oZipStream.Write(obuffer, 0, read);
                        }
                    }
                }
                htmlZip.Dispose();
            }
            HTMLstreamlenght = oZipStream.Position;


            return(oZipStream);
        }
コード例 #40
0
        /// <summary>
        /// This method generate the package as per the <c>PackageSize</c> declare.
        /// Currently <c>PackageSize</c> is 2 GB.
        /// </summary>
        /// <param name="inputFolderPath">Input folder Path.</param>
        /// <param name="outputFolderandFile">Output folder Path.</param>

        static void SplitZipFolder(string inputFolderPath, string outputFolderandFile, string threadId)
        {
            #region otherApproach

            #endregion

            int cnt = 1;
            m_packageSize = m_packageSize * 20;
            ArrayList htmlFile = new ArrayList();
            ArrayList ar       = GenerateFileList(inputFolderPath, out htmlFile); // generate file list



            // Output Zip file name.
            string outPath          = Path.Combine(outputFolderandFile, threadId + "-" + cnt + ".zip");
            long   HTMLstreamlenght = 0;

            using (ZipOutputStream oZipStream = CreateNewStream(htmlFile, outPath, out HTMLstreamlenght))
            {
                // Initialize the zip entry object.
                ZipEntry oZipEntry = new ZipEntry();

                // numbers of files in file list.
                var counter = ar.Count;
                try
                {
                    using (Ionic.Zip.ZipFile zip = new Ionic.Zip.ZipFile())
                    {
                        Array.Sort(ar.ToArray());            // Sort the file list array.
                        foreach (string Fil in ar.ToArray()) // for each file, generate a zip entry
                        {
                            if (!Fil.EndsWith(@"/"))         // if a file ends with '/' its a directory
                            {
                                if (!zip.ContainsEntry(Path.GetFileName(Fil.ToString())))
                                {
                                    oZipEntry = zip.AddEntry("Attachments/" + Path.GetFileName(Fil.ToString()), Fil);
                                    counter--;
                                    try
                                    {
                                        if (counter >= 0)
                                        {
                                            long      streamlenght = HTMLstreamlenght;
                                            const int BufferSize   = 4096;
                                            byte[]    obuffer      = new byte[BufferSize];
                                            if (oZipStream.Position + streamlenght < m_packageSize)
                                            {
                                                using (FileStream ostream = File.OpenRead(Fil))
                                                {
                                                    //ostream = File.OpenRead(Fil);
                                                    using (ZipOutputStream tempZStream = new ZipOutputStream(File.Create(Directory.GetCurrentDirectory() + "\\test.zip"), false))
                                                    {
                                                        tempZStream.PutNextEntry(oZipEntry.FileName);
                                                        int tempread;
                                                        while ((tempread = ostream.Read(obuffer, 0, obuffer.Length)) > 0)
                                                        {
                                                            tempZStream.Write(obuffer, 0, tempread);
                                                        }
                                                        streamlenght = tempZStream.Position;
                                                        tempZStream.Dispose();
                                                        tempZStream.Flush();
                                                        tempZStream.Close(); // close the zip stream.
                                                                             // ostream.Dispose();
                                                    }

                                                    File.Delete(Directory.GetCurrentDirectory() + "\\test.zip");
                                                }
                                            }

                                            if (oZipStream.Position + streamlenght > m_packageSize)
                                            {
                                                zip.RemoveEntry(oZipEntry);
                                                zip.Dispose();
                                                oZipStream.Dispose();
                                                oZipStream.Flush();
                                                oZipStream.Close();                                                                    // close the zip stream.
                                                cnt     = cnt + 1;
                                                outPath = Path.Combine(outputFolderandFile, threadId + "-" + cnt.ToString() + ".zip"); // create new output zip file when package size.
                                                using (ZipOutputStream oZipStream2 = CreateNewStream(htmlFile, outPath, out HTMLstreamlenght))
                                                {
                                                    oZipStream2.PutNextEntry(oZipEntry.FileName);
                                                    using (FileStream ostream = File.OpenRead(Fil))
                                                    {
                                                        int read;
                                                        while ((read = ostream.Read(obuffer, 0, obuffer.Length)) > 0)
                                                        {
                                                            oZipStream2.Write(obuffer, 0, read);
                                                        }
                                                    }
                                                }
                                            }
                                            else
                                            {
                                                oZipStream.PutNextEntry(oZipEntry.FileName);
                                                using (FileStream ostream = File.OpenRead(Fil))
                                                {
                                                    int read;
                                                    while ((read = ostream.Read(obuffer, 0, obuffer.Length)) > 0)
                                                    {
                                                        oZipStream.Write(obuffer, 0, read);
                                                    }
                                                }
                                            }
                                        }
                                        else
                                        {
                                            Console.WriteLine("No more file existed in directory");
                                        }
                                    }
                                    catch (Exception ex)
                                    {
                                        Console.WriteLine(ex.ToString());
                                        zip.RemoveEntry(oZipEntry.FileName);
                                    }
                                }
                                else
                                {
                                    Console.WriteLine("File Existed {0} in Zip {1}", Path.GetFullPath(Fil.ToString()), outPath);
                                }
                            }
                        }
                        zip.Dispose();
                    }
                    oZipStream.Dispose();
                    oZipStream.Flush();
                    oZipStream.Close();// close stream
                }

                catch (Exception ex)
                {
                    Console.WriteLine(ex.ToString());
                }
                finally
                {
                    oZipStream.Dispose();
                    oZipStream.Flush();
                    oZipStream.Close();// close stream

                    Console.WriteLine("Remain Files{0}", counter);
                }
            }
        }
コード例 #41
0
 public IZipEntry AddFile(string path, Stream stream)
 {
     return(new MZipEntry(zip.AddEntry(path, stream)));
 }
コード例 #42
0
    void Publish()
    {
        string webplayer = PlayerPrefs.GetString("Course_Export");
        string tempdir   = System.IO.Path.GetTempPath() + System.IO.Path.GetRandomFileName();

        System.IO.Directory.CreateDirectory(tempdir);
        CopyFilesRecursively(new System.IO.DirectoryInfo(webplayer), new System.IO.DirectoryInfo(tempdir));
        string zipfile = EditorUtility.SaveFilePanel("Choose Output File", webplayer, PlayerPrefs.GetString("Course_Title"), "zip");

        if (zipfile != "")
        {
            if (File.Exists(zipfile))
            {
                File.Delete(zipfile);
            }

            Ionic.Zip.ZipFile zip = new Ionic.Zip.ZipFile(zipfile);
            zip.AddDirectory(tempdir);

            if (PlayerPrefs.GetInt("SCORM_Version") < 3)
            {
                zip.AddItem(Application.dataPath + "/ADL SCORM/Plugins/2004");
                string manifest =
                    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
                    "<!-- exported by Unity-SCORM Integration Toolkit Version 1.4 Beta-->" +
                    "<manifest xmlns=\"http://www.imsglobal.org/xsd/imscp_v1p1\" xmlns:imsmd=\"http://www.imsglobal.org/xsd/imsmd_v1p2\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:adlcp=\"http://www.adlnet.org/xsd/adlcp_v1p3\" xmlns:imsss=\"http://www.imsglobal.org/xsd/imsss\" xmlns:adlseq=\"http://www.adlnet.org/xsd/adlseq_v1p3\" xmlns:adlnav=\"http://www.adlnet.org/xsd/adlnav_v1p3\" identifier=\"MANIFEST-AECEF15E-06B8-1FAB-5289-73A0B058E2DD\" xsi:schemaLocation=\"http://www.imsglobal.org/xsd/imscp_v1p1 imscp_v1p1.xsd http://www.imsglobal.org/xsd/imsmd_v1p2 imsmd_v1p2p2.xsd http://www.adlnet.org/xsd/adlcp_v1p3 adlcp_v1p3.xsd http://www.imsglobal.org/xsd/imsss imsss_v1p0.xsd http://www.adlnet.org/xsd/adlseq_v1p3 adlseq_v1p3.xsd http://www.adlnet.org/xsd/adlnav_v1p3 adlnav_v1p3.xsd\" version=\"1.3\">" +
                    "  <metadata>" +
                    "    <schema>ADL SCORM</schema>"
                    + ((PlayerPrefs.GetInt("SCORM_Version") == 0)?"    <schemaversion>2004 4th Edition</schemaversion>":"")
                    + ((PlayerPrefs.GetInt("SCORM_Version") == 1)?"    <schemaversion>2004 3rd Edition</schemaversion>":"")
                    + ((PlayerPrefs.GetInt("SCORM_Version") == 2)?"    <schemaversion>2004 CAM 1.3</schemaversion>":"")
                    +
                    "  </metadata>" +
                    "  <organizations default=\"ORG-8770D9D9-AD66-06BB-9A3D-E87784C697FF\">" +
                    "    <organization identifier=\"ORG-8770D9D9-AD66-06BB-9A3D-E87784C697FF\">" +
                    "      <title>" + PlayerPrefs.GetString("Course_Title") + "</title>" +
                    "      <item identifier=\"ITEM-79701DB3-F0AD-9426-8C43-819F3CB0EE6E\" identifierref=\"RES-4F17946A-9286-D5F0-7B6A-04E980C04F46\" parameters=\"" + GetParameterString() + "\">" +
                    "			<title>"+ PlayerPrefs.GetString("SCO_Title") + "</title>" +
                    "			 <adlcp:dataFromLMS>"+ PlayerPrefs.GetString("Data_From_Lms") + "</adlcp:dataFromLMS>" +
                    "			 <adlcp:completionThreshold completedByMeasure = \""+ (System.Convert.ToBoolean(PlayerPrefs.GetInt("completedByMeasure"))).ToString().ToLower() + "\" minProgressMeasure= \"" + PlayerPrefs.GetFloat("minProgressMeasure") + "\" />";
                if (PlayerPrefs.GetInt("satisfiedByMeasure") == 1)
                {
                    manifest += "				<imsss:sequencing>"+
                                "			      <imsss:objectives>"+
                                "			        <imsss:primaryObjective objectiveID = \"PRIMARYOBJ\""+
                                "			               satisfiedByMeasure = \""+ (System.Convert.ToBoolean(PlayerPrefs.GetInt("satisfiedByMeasure"))).ToString().ToLower() + "\">" +
                                "			          <imsss:minNormalizedMeasure>"+ PlayerPrefs.GetFloat("minNormalizedMeasure") + "</imsss:minNormalizedMeasure>" +
                                "			        </imsss:primaryObjective>"+
                                "			      </imsss:objectives>"+
                                "			    </imsss:sequencing>";
                }
                manifest +=
                    "      </item>" +
                    "    </organization>" +
                    "  </organizations>" +
                    "  <resources>" +
                    "    <resource identifier=\"RES-4F17946A-9286-D5F0-7B6A-04E980C04F46\" type=\"webcontent\" href=\"WebPlayer/WebPlayer.html\" adlcp:scormType=\"sco\">" +
                    "      <file href=\"WebPlayer/WebPlayer.html\" />" +
                    "      <file href=\"WebPlayer/scripts/scorm.js\" />" +
                    "		<file href=\"WebPlayer/scripts/ScormSimulator.js\" />"+
                    "		<file href=\"WebPlayer/UnityObject.js\" />"+
                    "		<file href=\"WebPlayer/Webplayer.unity3d\" />"+
                    "		<file href=\"WebPlayer/images/scorm_progres_bar.png\" />"+
                    "		<file href=\"WebPlayer/images/thumbnail.png\" />"+
                    "    </resource>" +
                    "  </resources>" +
                    "</manifest>";

                zip.AddEntry("imsmanifest.xml", ".", System.Text.ASCIIEncoding.ASCII.GetBytes(manifest));
            }
            else
            {
                zip.AddItem(Application.dataPath + "/ADL SCORM/Plugins/1.2");
                string manifest =
                    "<?xml version=\"1.0\"?>" +
                    "<!-- exported by Unity-SCORM Integration Toolkit Version 1.4 Beta-->" +
                    "<manifest identifier=\"SingleCourseManifest\" version=\"1.1\"" +
                    "          xmlns=\"http://www.imsproject.org/xsd/imscp_rootv1p1p2\"" +
                    "          xmlns:adlcp=\"http://www.adlnet.org/xsd/adlcp_rootv1p2\"" +
                    "          xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"" +
                    "          xsi:schemaLocation=\"http://www.imsproject.org/xsd/imscp_rootv1p1p2 imscp_rootv1p1p2.xsd" +
                    "                              http://www.imsglobal.org/xsd/imsmd_rootv1p2p1 imsmd_rootv1p2p1.xsd" +
                    "                              http://www.adlnet.org/xsd/adlcp_rootv1p2 adlcp_rootv1p2.xsd\">" +
                    "   <organizations default=\"B0\">" +
                    "      <organization identifier=\"B0\">" +
                    "         <title>" + PlayerPrefs.GetString("Course_Title") + "</title>" +
                    "			   <item identifier=\"IS12\" identifierref=\"RS12\" parameters=\""+ GetParameterString() + "\">" +
                    "				  <title>"+ PlayerPrefs.GetString("SCO_Title") + "</title>" +
                    "				  <adlcp:dataFromLMS>"+ PlayerPrefs.GetString("Data_From_Lms") + "</adlcp:dataFromLMS>" +
                    "				  <adlcp:masteryscore>"+ PlayerPrefs.GetFloat("masteryscore") + "</adlcp:masteryscore>" +
                    "			   </item>"+
                    "	      </organization>"+
                    "	   </organizations>"+
                    "	   <resources>"+
                    "	      <resource identifier=\"RS12\" type=\"webcontent\""+
                    "	                adlcp:scormtype=\"sco\" href=\"WebPlayer/WebPlayer.html\">"+
                    "	      </resource>"+
                    "	   </resources>"+
                    "	</manifest>";


                zip.AddEntry("imsmanifest.xml", ".", System.Text.ASCIIEncoding.ASCII.GetBytes(manifest));
            }
            zip.Save();
        }
    }
コード例 #43
0
ファイル: BatchResizeWorker.cs プロジェクト: timgaunt/resizer
        /// <summary>
        /// Not for external use. Assumes 'state' is a BatchResizeSettings instance, and stores it in a class member.
        /// Next, it completes (or fails at) the job. Throws exceptions only if (a) state is not a BatchResizeSettings instance, or (b) an exception is thrown by and handler of the JobEvent (Failed) event.
        /// </summary>
        /// <param name="state"></param>
        protected internal void Work(object state)
        {
            s = (BatchResizeSettings)state;
            try
            {
                //Time the job.
                jobTimer = new Stopwatch();
                jobTimer.Start();

                //1) Eliminate duplicate target filenames, sanitize, and add appropriate extensions, then mark all items as immutable
                s.FixDuplicateFilenames();
                s.AppendFinalExtensions();
                s.MarkItemsImmutable();

                //2) Build dictionary based on target filenames.
                items = BuildDict(s.files);

                //3) Verify destination folder exists, otherwise create it. (early detection of security failures)
                CreateDestinationFolder();

                //4) Open zip file (writes to a temporary location, then moves the file when it is done)
                using (Ionic.Zip.ZipFile z = new Ionic.Zip.ZipFile(s.destinationFile))
                {
                    //Compress for speed.
                    z.CompressionLevel = Ionic.Zlib.CompressionLevel.BestSpeed;
                    //Fire events instead of throwing exceptions
                    z.ZipErrorAction = ZipErrorAction.InvokeErrorEvent;
                    z.ZipError      += new EventHandler <ZipErrorEventArgs>(z_ZipError);
                    z.SaveProgress  += new EventHandler <SaveProgressEventArgs>(z_SaveProgress);
                    //5) Create a list to store item resize/compression results
                    results = new List <ItemResult>();


                    //6) Queue the files that will be included in the archive, specifying a callback for items
                    foreach (BatchResizeItem i in s.files)
                    {
                        try{
                            ZipEntry ze = z.AddEntry(i.TargetFilename, new WriteDelegate(WriteItemCallback));
                            //Don't try to compress files we have already resized, it won't help, just slow things down and possibly use more space.
                            if (wouldResize(i))
                            {
                                ze.CompressionMethod = CompressionMethod.None;
                            }
                            else
                            {
                                //Set the times
                                //ze.SetEntryTimes(System.IO.File.GetLastWriteTimeUtc(i.PhysicalPath),
                                //    System.IO.File.GetLastAccessTimeUtc(i.PhysicalPath),
                                //    System.IO.File.GetCreationTimeUtc(i.PhysicalPath));
                                //Never mind, not desired behavior.
                            }
                        }catch (Exception ex) {
                            ItemFailed(i, ex);
                        }
                    }
                    //7) Begin processing the queue.
                    //As each file is written to the archive, a callback is invoked which actually provides the resized stream.
                    z.Save();
                } //8) Close zip file

                jobTimer.Stop();

                //9) Fire the event that says "We're done!"
                JobCompleted(s);
            }
            catch (Exception ex)
            {
                //Admit we failed to whoever is listening.
                JobFailed(s, ex);
            }
        }
コード例 #44
0
        /// <summary>
        /// zip when has special file
        /// </summary>
        /// <param name="fileToZips"></param>
        /// <param name="zipedFile"></param>
        /// <param name="basePath"></param>
        public static void ZipAdvanced(string[] fileToZips, string zipedFile, string basePath)
        {
            using (Ionic.Zip.ZipFile zip = new Ionic.Zip.ZipFile(zipedFile, Encoding.GetEncoding(932)))
            {
                zip.UseZip64WhenSaving = Ionic.Zip.Zip64Option.Always;
                zip.CompressionLevel   = Ionic.Zlib.CompressionLevel.BestSpeed;
                zip.BufferSize         = 65536 * 8; // Set the buffersize to 512k for better efficiency with large files

                foreach (string fileToZip in fileToZips)
                {
                    if (LongPath.IsFileExists(fileToZip))
                    {
                        FileStream fs = LongPath.OpenForOnlyRead(fileToZip);
                        zip.AddEntry(fileToZip.Substring(basePath.Length), fs);

                        continue;
                    }

                    else //文件夹
                    {
                        if (Directory.Exists(fileToZip))
                        {
                            foreach (var e in Directory.EnumerateFiles(fileToZip, "*", SearchOption.AllDirectories))
                            {
                                try
                                {
                                    //判断文件名是否以空格结尾
                                    bool   spaceEnd = false;
                                    string name     = e.Substring(e.LastIndexOf('\\') + 1);
                                    if (name.TrimEnd().Length < name.Length)
                                    {
                                        spaceEnd = true;
                                    }
                                    if (!spaceEnd && File.Exists(e))
                                    {
                                        zip.AddFile(e, e.Substring(basePath.Length, e.LastIndexOf('\\') - basePath.Length));
                                    }
                                    else
                                    {
                                        string entryName = e.Substring(basePath.Length);

                                        /*
                                         * 末尾添加全角空格,(ps:如果同一目录下有个 文件a 又有一个文件 a空格 则解压时会同名冲突,故添加全角空格以区分
                                         */
                                        if (spaceEnd)
                                        {
                                            entryName += " ";
                                        }
                                        FileStream fs = LongPath.OpenForOnlyRead(e);
                                        zip.AddEntry(entryName, fs);
                                    }
                                }
                                catch (Exception ex)
                                {
                                    logger.Error("path:" + e + Environment.NewLine + ex.Message);
                                }
                            }
                        }
                        else
                        {
                            foreach (String path in FilesystemHelper.EnumFilesYield(fileToZip))
                            {
                                try
                                {
                                    FileStream fs = LongPath.OpenForOnlyRead(path);
                                    zip.AddEntry(path.Substring(basePath.Length), fs);
                                }
                                catch (Exception ex)
                                {
                                    logger.Error("path:" + path + Environment.NewLine + ex.Message);
                                }
                            }
                        }
                    }
                }
                zip.Save();
            }
        }
コード例 #45
0
    /// <summary>
    /// Publish this SCORM package to a conformant zip file.
    /// </summary>
    void Publish()
    {
        string timeLimitAction = "";

        switch (PlayerPrefs.GetInt("Time_Limit_Action"))
        {
        case 0:
            timeLimitAction = "";
            break;

        case 1:
            timeLimitAction = "exit,message";
            break;

        case 2:
            timeLimitAction = "exit,no message";
            break;

        case 3:
            timeLimitAction = "continue,message";
            break;

        case 4:
            timeLimitAction = "continue,no message";
            break;
        }

        string timeLimit = SecondsToTimeInterval(ParseFloat(PlayerPrefs.GetString("Time_Limit_Secs")));

        string webplayer = PlayerPrefs.GetString("Course_Export");
        string tempdir   = System.IO.Path.GetTempPath() + System.IO.Path.GetRandomFileName();

        System.IO.Directory.CreateDirectory(tempdir);
        CopyFilesRecursively(new System.IO.DirectoryInfo(webplayer), new System.IO.DirectoryInfo(tempdir));
        string zipfile = EditorUtility.SaveFilePanel("Choose Output File", webplayer, PlayerPrefs.GetString("Course_Title"), "zip");

        if (zipfile != "")
        {
            if (File.Exists(zipfile))
            {
                File.Delete(zipfile);
            }

            Ionic.Zip.ZipFile zip = new Ionic.Zip.ZipFile(zipfile);
            zip.AddDirectory(tempdir);

            zip.AddItem(Application.dataPath + "/SCORM/Plugins/2004");

            string manifest = "<?xml version=\"1.0\" standalone=\"no\" ?>\n" +
                              "<manifest identifier=\"" + PlayerPrefs.GetString("Manifest_Identifier") + "\" version=\"1\"\n" +
                              "\t\txmlns = \"http://www.imsglobal.org/xsd/imscp_v1p1\"\n" +
                              "\t\txmlns:adlcp = \"http://www.adlnet.org/xsd/adlcp_v1p3\"\n" +
                              "\t\txmlns:adlseq = \"http://www.adlnet.org/xsd/adlseq_v1p3\"\n" +
                              "\t\txmlns:adlnav = \"http://www.adlnet.org/xsd/adlnav_v1p3\"\n" +
                              "\t\txmlns:imsss = \"http://www.imsglobal.org/xsd/imsss\"\n" +
                              "\t\txmlns:xsi = \"http://www.w3.org/2001/XMLSchema-instance\"\n" +
                              "\t\txmlns:lom=\"http://ltsc.ieee.org/xsd/LOM\"\n" +
                              "\t\txsi:schemaLocation = \"http://www.imsglobal.org/xsd/imscp_v1p1 imscp_v1p1.xsd\n" +
                              "\t\t\thttp://www.adlnet.org/xsd/adlcp_v1p3 adlcp_v1p3.xsd\n" +
                              "\t\t\thttp://www.adlnet.org/xsd/adlseq_v1p3 adlseq_v1p3.xsd\n" +
                              "\t\t\thttp://www.adlnet.org/xsd/adlnav_v1p3 adlnav_v1p3.xsd\n" +
                              "\t\t\thttp://www.imsglobal.org/xsd/imsss imsss_v1p0.xsd\n" +
                              "\t\t\thttp://ltsc.ieee.org/xsd/LOM lom.xsd\" >\n" +
                              "<metadata>\n" +
                              "\t<schema>ADL SCORM</schema>\n" +
                              "\t<schemaversion>2004 4th Edition</schemaversion>\n" +
                              "<lom:lom>\n" +
                              "\t<lom:general>\n" +
                              "\t\t<lom:description>\n" +
                              "\t\t\t<lom:string language=\"en-US\">" + PlayerPrefs.GetString("Course_Description") + "</lom:string>\n" +
                              "\t\t</lom:description>\n" +
                              "\t</lom:general>\n" +
                              "\t</lom:lom>\n" +
                              "</metadata>\n" +
                              "<organizations default=\"B0\">\n" +
                              "\t<organization identifier=\"B0\" adlseq:objectivesGlobalToSystem=\"false\">\n" +
                              "\t\t<title>" + PlayerPrefs.GetString("Course_Title") + "</title>\n" +
                              "\t\t<item identifier=\"i1\" identifierref=\"r1\" isvisible=\"true\">\n" +
                              "\t\t\t<title>" + PlayerPrefs.GetString("SCO_Title") + "</title>\n" +
                              "\t\t\t<adlcp:timeLimitAction>" + timeLimitAction + "</adlcp:timeLimitAction>\n" +
                              "\t\t\t<adlcp:dataFromLMS>" + PlayerPrefs.GetString("Data_From_Lms") + "</adlcp:dataFromLMS> \n" +
                              "\t\t\t<adlcp:completionThreshold completedByMeasure = \"" + (System.Convert.ToBoolean(PlayerPrefs.GetInt("completedByMeasure"))).ToString().ToLower() + "\" minProgressMeasure= \"" + PlayerPrefs.GetFloat("minProgressMeasure") + "\" />\n" +
                              "\t\t\t<imsss:sequencing>\n" +
                              "\t\t\t<imsss:limitConditions attemptAbsoluteDurationLimit=\"" + timeLimit + "\"/>\n" +
                              "\t\t\t</imsss:sequencing>\n" +
                              "\t\t</item>\n" +
                              "\t</organization>\n" +
                              "</organizations>\n" +
                              "<resources>\n" +
                              "\t<resource identifier=\"r1\" type=\"webcontent\" adlcp:scormType=\"sco\" href=\"" + PlayerPrefs.GetString("Course_Export_Name") + ".html\">\n" +
                              "\t\t<file href=\"" + PlayerPrefs.GetString("Course_Export_Name") + ".html\" />\n" +
                              "\t\t<file href=\"scripts/scorm.js\" />\n" +
                              "\t\t<file href=\"scripts/ScormSimulator.js\" />\n" +
                              "\t\t<file href=\"" + PlayerPrefs.GetString("Course_Export_Name") + ".unity3d\" />\n" +
                              "\t</resource>\n" +
                              "</resources>\n" +
                              "</manifest>";

            zip.AddEntry("imsmanifest.xml", ".", System.Text.ASCIIEncoding.ASCII.GetBytes(manifest));

            zip.Save();
            EditorUtility.DisplayDialog("SCORM Package Published", "The SCORM Package has been published to " + zipfile, "OK");
        }
    }
コード例 #46
-1
// ---------------------------------------------------------------------------    
    public override void Write(Stream stream) {
      using (ZipFile zip = new ZipFile()) {
        HtmlMovies2 movies = new HtmlMovies2();
        // create a StyleSheet
        StyleSheet styles = new StyleSheet();
        styles.LoadTagStyle("ul", "indent", "10");
        styles.LoadTagStyle("li", "leading", "14");
        styles.LoadStyle("country", "i", "");
        styles.LoadStyle("country", "color", "#008080");
        styles.LoadStyle("director", "b", "");
        styles.LoadStyle("director", "color", "midnightblue");
        movies.SetStyles(styles);
        // create extra properties
        Dictionary<String,Object> map = new Dictionary<String, Object>();
        map.Add(HTMLWorker.FONT_PROVIDER, new MyFontFactory());
        map.Add(HTMLWorker.IMG_PROVIDER, new MyImageFactory());
        movies.SetProviders(map);
        // creates HTML and PDF (reusing a method from the super class)
        byte[] pdf = movies.CreateHtmlAndPdf(stream);
        zip.AddEntry(HTML, movies.Html.ToString());
        zip.AddEntry(RESULT1, pdf);
        zip.AddEntry(RESULT2, movies.CreatePdf());
        // add the images so the static html file works
        foreach (Movie movie in PojoFactory.GetMovies()) {
          zip.AddFile(
            Path.Combine(
              Utility.ResourcePosters, 
              string.Format("{0}.jpg", movie.Imdb)
            ), 
            ""
          );
        }
        zip.Save(stream);             
      }
    }