/// <summary>
/// Combines all the students into a single PDF with each page a seperate report.
/// </summary>\
void ExportToSinglePDF()
{
string savePath = System.IO.Path.Combine(System.IO.Path.GetFullPath(textSavePath.Text), string.Format("{0}.pdf", textFileName.Text));
string templatePath = System.IO.Path.GetFullPath(textTempLocation.Text);
int finishedReports = 0;
using (Document doc = new Document())
{
using (PdfSmartCopy copy = new PdfSmartCopy(doc, new FileStream(savePath, FileMode.Create)))
{
doc.Open();
foreach (var student in StudentList)
{
PdfReader reader = new PdfReader(templatePath);
using (MemoryStream ms = new MemoryStream())
{
using (PdfStamper stamper = new PdfStamper(reader, ms))
{
var form = stamper.AcroFields;
//Setting the text of the template to the stored info
form.SetField("Street", student.Address);
form.SetField("CityZipState", student.CityZipState);
form.SetField("ClassName", student.ClassName);
form.SetField("Comments", student.Comments);
form.SetField("Grade", student.Grade.ToString());
form.SetField("Critique", student.Critique);
form.SetField("HighSchool", student.HighSchool);
form.SetField("Session", student.Session);
form.SetField("Absences", student.SemesterTotalAbs.ToString());
form.SetField("Tardies", student.SemesterTotalTdy.ToString());
form.SetField("NetAbsences", student.SemesterNetAbs.ToString());
form.SetField("StuNameReversed", student.NameReversed);
form.SetField("Date", DateTime.Now.ToShortDateString());
form.RenameField("Comments", string.Format("Comments{0}", finishedReports));
form.RenameField("Date", string.Format("Date{0}", finishedReports));
//Flatten the fields that we do not want editable
stamper.FormFlattening = true;
stamper.PartialFormFlattening("StuNameReversed");
stamper.PartialFormFlattening("Street");
stamper.PartialFormFlattening("CityZipState");
stamper.PartialFormFlattening("HighSchool");
stamper.PartialFormFlattening("ClassName");
stamper.PartialFormFlattening("Session");
stamper.PartialFormFlattening("Absences");
stamper.PartialFormFlattening("Tardies");
stamper.PartialFormFlattening("NetAbsences");
stamper.PartialFormFlattening("Grade");
stamper.PartialFormFlattening("Critique");
stamper.PartialFormFlattening("Date");
}
reader = new PdfReader(ms.ToArray());
//Adds page to the output pdf
copy.AddPage(copy.GetImportedPage(reader, 1));
//Report progress to update status text
bgProgressThread.ReportProgress(++finishedReports);
}
}// Student Foreach end
}
}
}
// ---------------------------------------------------------------------------
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);
}
}
public void OptimizePDFFile(Stream outputStream, Stream inputStream)
{
using (var doc = new Document())
{
using (var reader = new PdfReader(inputStream))
{
using (var copi = new PdfSmartCopy(doc, outputStream))
{
doc.Open();
var p = copi.GetImportedPage(reader, 1);
copi.AddPage(p);
}
}
}
}
public static Stream JoinPdfs(bool InsertBlankPages, List<Stream> Pdfs)
{
if (Pdfs.Count == 0)
throw new System.ArgumentNullException(nameof(Pdfs));
// Only One PDF - Possible Reference Bug v's Memory/Speed (Returning Param Memory Stream)
if (Pdfs.Count == 1)
return Pdfs[0];
// Join Pdfs
var msBuilder = new MemoryStream();
var pdfLastPageSize = PageSize.A4;
var pdfDoc = new Document();
var pdfCopy = new PdfSmartCopy(pdfDoc, msBuilder);
pdfDoc.Open();
pdfCopy.CloseStream = false;
for (int i = 0; i < Pdfs.Count; i++)
{
var pdf = Pdfs[i];
var pdfReader = new PdfReader(pdf);
if (InsertBlankPages && (pdfCopy.CurrentPageNumber % 2) == 0)
{
pdfCopy.AddPage(pdfLastPageSize, 0);
}
for (int indexPage = 1; indexPage <= pdfReader.NumberOfPages; indexPage++)
{
pdfLastPageSize = pdfReader.GetPageSizeWithRotation(indexPage);
var page = pdfCopy.GetImportedPage(pdfReader, indexPage);
pdfDoc.SetPageSize(pdfLastPageSize);
pdfCopy.AddPage(page);
}
pdfReader.Close();
}
pdfDoc.Close();
pdfCopy.Close();
msBuilder.Position = 0;
return msBuilder;
}
// ---------------------------------------------------------------------------
public override void Write(Stream stream) {
using (ZipFile zip = new ZipFile()) {
using (MemoryStream ms = new MemoryStream()) {
// step 1
using (Document document = new Document()) {
// step 2
using (PdfSmartCopy copy = new PdfSmartCopy(document, ms)) {
// step 3
document.Open();
// step 4
AddDataSheets(copy);
}
}
zip.AddEntry(RESULT, ms.ToArray());
}
zip.AddFile(DATASHEET_PATH, "");
zip.Save(stream);
}
}
public byte[] MergePdfForms(System.Collections.Generic.List <byte[]> files)
{
if (files.Count > 1)
{
using (System.IO.MemoryStream msOutput = new System.IO.MemoryStream())
{
iTextSharp.text.Document doc = new iTextSharp.text.Document();
using (iTextSharp.text.pdf.PdfSmartCopy pCopy = new iTextSharp.text.pdf.PdfSmartCopy(doc, msOutput)
{
PdfVersion = iTextSharp.text.pdf.PdfWriter.VERSION_1_7
})
{
doc.Open();
foreach (byte[] oFile in files)
{
using (iTextSharp.text.pdf.PdfReader pdfFile = new iTextSharp.text.pdf.PdfReader(oFile))
{
for (int i = 1; i <= pdfFile.NumberOfPages; i++)
{
pCopy.AddPage(pCopy.GetImportedPage(pdfFile, i));
pCopy.FreeReader(pdfFile);
}
}
}
}
return(msOutput.ToArray());
}
}
else if (files.Count == 1)
{
return(new System.IO.MemoryStream(files[0]).ToArray());
}
return(null);
}
/// <summary>
/// Merges pdf files from a byte list
/// </summary>
/// <param name="files">list of files to merge</param>
/// <returns>memory stream containing combined pdf</returns>
public static string MergePdfForms(List<string> file_names, string output) {
if (file_names.Count > 1) {
List<byte[]> files = new List<byte[]>();
foreach (string file_name in file_names) {
var file = File.ReadAllBytes(file_name);
files.Add(file);
}
string[] names;
PdfStamper stamper;
MemoryStream msTemp = null;
PdfReader pdfTemplate = null;
PdfReader pdfFile;
Document doc;
PdfWriter pCopy;
MemoryStream msOutput = new MemoryStream();
pdfFile = new PdfReader(files[0]);
doc = new Document();
pCopy = new PdfSmartCopy(doc, msOutput);
pCopy.PdfVersion = PdfWriter.VERSION_1_7;
doc.Open();
for (int k = 0; k < files.Count; k++) {
for (int i = 1; i < pdfFile.NumberOfPages + 1; i++) {
msTemp = new MemoryStream();
pdfTemplate = new PdfReader(files[k]);
stamper = new PdfStamper(pdfTemplate, msTemp);
names = new string[stamper.AcroFields.Fields.Keys.Count];
stamper.AcroFields.Fields.Keys.CopyTo(names, 0);
foreach (string name in names) {
stamper.AcroFields.RenameField(name, name + "_file" + k.ToString());
}
stamper.Close();
pdfFile = new PdfReader(msTemp.ToArray());
((PdfSmartCopy)pCopy).AddPage(pCopy.GetImportedPage(pdfFile, i));
pCopy.FreeReader(pdfFile);
}
}
FileStream f = new FileStream(output, FileMode.Create);
msOutput.WriteTo(f);
msOutput.Flush();
f.Flush();
pdfFile.Close();
pCopy.Close();
doc.Close();
msOutput.Close();
f.Close();
return output;
}
else if (file_names.Count == 1) {
File.Copy(file_names.First(), output);
return output;
}
return null;
}
virtual public void MergeAndStampPdf(bool resetStampEachPage, String[] input, String output, String stamp)
{
PdfReader stampReader = new PdfReader(pdfContent[stamp]);
List<PdfReader> readersToClose = new List<PdfReader>();
readersToClose.Add(stampReader);
MemoryStream baos = new MemoryStream();
try
{
Document document = new Document();
PdfCopy writer = new PdfSmartCopy(document, baos);
try
{
document.Open();
int stampPageNum = 1;
foreach (string element in input)
{
// create a reader for the input document
PdfReader documentReader = new PdfReader(
new RandomAccessFileOrArray(
new RandomAccessSourceFactory().CreateSource(pdfContent[element])
)
, null);
for (int pageNum = 1; pageNum <= documentReader.NumberOfPages; pageNum++)
{
// import a page from the main file
PdfImportedPage mainPage = writer.GetImportedPage(documentReader, pageNum);
// make a stamp from the page and get under content...
PdfCopy.PageStamp pageStamp = writer.CreatePageStamp(mainPage);
// import a page from a file with the stamp...
if (resetStampEachPage)
{
stampReader = new PdfReader(pdfContent[stamp]);
readersToClose.Add(stampReader);
}
PdfImportedPage stampPage = writer.GetImportedPage(stampReader, stampPageNum++);
// add the stamp template, update stamp, and add the page
pageStamp.GetOverContent().AddTemplate(stampPage, 0, 0);
pageStamp.AlterContents();
writer.AddPage(mainPage);
if (stampPageNum > stampReader.NumberOfPages)
stampPageNum = 1;
}
}
}
finally
{
writer.Close();
document.Close();
}
}
finally
{
foreach (PdfReader stampReaderToClose in readersToClose)
{
stampReaderToClose.Close();
}
}
pdfContent[output] = baos.ToArray();
}
virtual public void XmpEncodingTest() {
String fileName = "xmp_UTF-16BE-encoding";
Document document = new Document();
PdfSmartCopy copy = new PdfSmartCopy(document, new FileStream(OUT_FOLDER + fileName, FileMode.Create));
document.Open();
PdfReader reader = new PdfReader(CMP_FOLDER + "pdf_metadata.pdf");
int pageCount = reader.NumberOfPages;
for (int currentPage = 1; currentPage <= pageCount; currentPage++) {
PdfImportedPage page = copy.GetImportedPage(reader, currentPage);
copy.AddPage(page);
}
MemoryStream os = new MemoryStream();
XmpWriter xmp = new XmpWriter(os, XmpWriter.UTF16, 2000);
DublinCoreProperties.AddSubject(xmp.XmpMeta, "Hello World");
DublinCoreProperties.AddSubject(xmp.XmpMeta, "XMP & Metadata");
DublinCoreProperties.AddSubject(xmp.XmpMeta, "Metadata");
xmp.Close();
copy.XmpMetadata = os.ToArray();
string metadataXml = System.Text.Encoding.GetEncoding("UTF-16BE").GetString(copy.XmpMetadata);
XmlDocument doc = new XmlDocument();
doc.LoadXml(metadataXml); //<-- This is where the exception is thrown
document.Close();
copy.Close();
reader.Close();
}
virtual public void XmpEncodingTest() {
String fileName = "xmp_utf-8_encoding";
Document document = new Document();
PdfSmartCopy copy = new PdfSmartCopy(document, new FileStream(OUT_FOLDER + fileName, FileMode.Create));
document.Open();
PdfReader reader = new PdfReader(CMP_FOLDER + "pdf_metadata.pdf");
int pageCount = reader.NumberOfPages;
for (int currentPage = 1; currentPage <= pageCount; currentPage++) {
PdfImportedPage page = copy.GetImportedPage(reader, currentPage);
copy.AddPage(page);
}
PdfAConformanceLevel pdfaLevel = PdfAConformanceLevel.PDF_A_1B;
MemoryStream os = new MemoryStream();
PdfAXmpWriter xmp = new PdfAXmpWriter(os, copy.Info, pdfaLevel, copy);
xmp.Close();
copy.XmpMetadata = os.ToArray();
string metadataXml = System.Text.Encoding.GetEncoding("UTF-8").GetString(copy.XmpMetadata);
XmlDocument doc = new XmlDocument();
doc.LoadXml(metadataXml); //<-- This is where the exception is thrown
document.Close();
copy.Close();
reader.Close();
}
private void init()
{
_document = new Document();
_writer = new PdfSmartCopy(_document, OutputFileStream);
_writer.SetFullCompression();
_document.Open();
}
/**
* Test to make sure that the following issue is fixed: http://sourceforge.net/mailarchive/message.php?msg_id=30891213
*/
public void TestDecodeParmsArrayWithNullItems() {
Document document = new Document();
MemoryStream byteStream = new MemoryStream();
PdfSmartCopy pdfSmartCopy = new PdfSmartCopy(document, byteStream);
document.Open();
PdfReader reader = TestResourceUtils.GetResourceAsPdfReader(RESOURCES, "imgWithDecodeParms.pdf");
pdfSmartCopy.AddPage(pdfSmartCopy.GetImportedPage(reader, 1));
document.Close();
reader.Close();
reader = new PdfReader(byteStream.ToArray());
PdfDictionary page = reader.GetPageN(1);
PdfDictionary resources = page.GetAsDict(PdfName.RESOURCES);
PdfDictionary xObject = resources.GetAsDict(PdfName.XOBJECT);
PdfStream img = xObject.GetAsStream(new PdfName("Im0"));
PdfArray decodeParms = img.GetAsArray(PdfName.DECODEPARMS);
Assert.AreEqual(2, decodeParms.Size);
Assert.IsTrue(decodeParms[0] is PdfNull);
reader.Close();
}
public static byte[] Merge(string[] documentPaths) {
byte[] mergedDocument;
using (MemoryStream memoryStream = new MemoryStream())
using (Document document = new Document())
{
PdfSmartCopy pdfSmartCopy = new PdfSmartCopy(document, memoryStream);
document.Open();
foreach (string docPath in documentPaths)
{
PdfReader reader = new PdfReader(docPath);
try
{
reader.ConsolidateNamedDestinations();
int numberOfPages = reader.NumberOfPages;
for (int page = 0; page < numberOfPages; )
{
PdfImportedPage pdfImportedPage = pdfSmartCopy.GetImportedPage(reader, ++page);
pdfSmartCopy.AddPage(pdfImportedPage);
}
}
finally
{
reader.Close();
}
}
document.Close();
mergedDocument = memoryStream.ToArray();
}
return mergedDocument;
}
private static MemoryStream MergePdfs(List<byte[]> files)
{
MemoryStream msOutput = new MemoryStream();
try
{
if (files.Count > 1)
{
PdfReader pdfFile;
Document doc;
PdfWriter pCopy;
pdfFile = new PdfReader(files[0]);
doc = new Document();
pCopy = new PdfSmartCopy(doc, msOutput);
doc.Open();
for (int k = 0; k < files.Count; k++)
{
pdfFile = new PdfReader(files[k]);
for (int i = 1; i < pdfFile.NumberOfPages + 1; i++)
{
((PdfSmartCopy)pCopy).AddPage(pCopy.GetImportedPage(pdfFile, i));
}
pCopy.FreeReader(pdfFile);
}
pdfFile.Close();
pCopy.Close();
doc.Close();
return msOutput;
}
else if (files.Count == 1)
{
return new MemoryStream(files[0]);
}
}
catch
{
}
finally
{
msOutput.Close();
msOutput.Dispose();
}
return null;
}
