|
public AddPage ( |
||
| iPage | ||
| return | void | |
/// <summary>
/// Extract a single page from PDF file.
/// </summary>
/// <param name="sourceFile">The source file.</param>
/// <param name="outputFile">The output file.</param>
/// <param name="pageNumber">The specific page number.</param>
public static void ExtractPage(string sourceFile, string outputFile, int pageNumber)
{
try
{
PdfReader reader = new PdfReader(sourceFile);
if (pageNumber > reader.NumberOfPages)
{
Console.WriteLine("This page number is out of reach.");
return;
}
Document document = new Document();
PdfCopy pdfCopy = new PdfCopy(document, new FileStream(outputFile, FileMode.Create));
document.Open();
PdfImportedPage importedPage = pdfCopy.GetImportedPage(reader, pageNumber);
pdfCopy.AddPage(importedPage);
document.Close();
reader.Close();
}
catch (Exception ex)
{
throw ex;
}
}
public static bool Collate(string frontSide, string backSide, string saveAs, bool backSideIsInReverseOrder = true)
{
try
{
bool backSideIsAscending = !backSideIsInReverseOrder;
using (FileStream stream = new FileStream(saveAs, FileMode.Create))
using (Document doc = new Document())
using (PdfCopy pdf = new PdfCopy(doc, stream))
{
doc.Open();
int b = 0;
using (PdfReader front = new PdfReader(frontSide))
{
using (PdfReader back = new PdfReader(backSide))
{
for (int p = 1; p <= front.NumberOfPages; p++)
{
pdf.AddPage(pdf.GetImportedPage(front, p));
pdf.FreeReader(front);
if (p <= back.NumberOfPages)
{
if (backSideIsAscending)
b = p;
else
b = back.NumberOfPages - p + 1;
pdf.AddPage(pdf.GetImportedPage(back, b));
pdf.FreeReader(back);
}
}
}
}
}
}
catch(Exception ex)
{
Console.WriteLine(ex.Message);
return false;
}
return true;
}
// ---------------------------------------------------------------------------
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);
}
}
// ---------------------------------------------------------------------------
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);
}
}
// ---------------------------------------------------------------------------
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);
}
}
public void ExtractPage(string sourcePdfPath, string outputPdfPath,
int pageNumber, string password = "")
{
PdfReader reader = null;
Document document = null;
PdfCopy pdfCopyProvider = null;
PdfImportedPage importedPage = null;
try
{
// Intialize a new PdfReader instance with the contents of the source Pdf file:
reader = new PdfReader(sourcePdfPath, Encoding.UTF8.GetBytes(password));
// Capture the correct size and orientation for the page:
document = new Document(reader.GetPageSizeWithRotation(pageNumber));
// Initialize an instance of the PdfCopyClass with the source
// document and an output file stream:
pdfCopyProvider = new PdfCopy(document,
new System.IO.FileStream(outputPdfPath, System.IO.FileMode.Create));
document.Open();
// Extract the desired page number:
importedPage = pdfCopyProvider.GetImportedPage(reader, pageNumber);
pdfCopyProvider.AddPage(importedPage);
document.Close();
reader.Close();
}
catch (Exception ex)
{
throw ex;
}
}
public void ConvertToImage(string _rutaPDF, int width, int height)
{
iTextSharp.text.pdf.PdfReader reader = null;
int currentPage = 1;
int pageCount = 0;
System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding();
reader = new iTextSharp.text.pdf.PdfReader(_rutaPDF);
reader.RemoveUnusedObjects();
pageCount = reader.NumberOfPages;
string ext = System.IO.Path.GetExtension(_rutaPDF);
for (int i = 1; i <= 1; i++)
{
iTextSharp.text.pdf.PdfReader reader1 = new iTextSharp.text.pdf.PdfReader(_rutaPDF);
string outfile = _rutaPDF.Replace((System.IO.Path.GetFileName(_rutaPDF)), (System.IO.Path.GetFileName(_rutaPDF).Replace(".pdf", "") + "_" + i.ToString()) + ext);
reader1.RemoveUnusedObjects();
iTextSharp.text.Document doc = new iTextSharp.text.Document(reader.GetPageSizeWithRotation(currentPage));
iTextSharp.text.pdf.PdfCopy pdfCpy = new iTextSharp.text.pdf.PdfCopy(doc, new System.IO.FileStream(outfile, System.IO.FileMode.Create));
doc.Open();
for (int j = 1; j <= 1; j++)
{
iTextSharp.text.pdf.PdfImportedPage page = pdfCpy.GetImportedPage(reader1, currentPage);
pdfCpy.SetFullCompression();
pdfCpy.AddPage(page);
currentPage += 1;
}
doc.Close();
pdfCpy.Close();
reader1.Close();
reader.Close();
}
}
// ---------------------------------------------------------------------------
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);
}
}
public void TestExtraXObjects()
{
#if DRAWING
PdfReader sourceR = new PdfReader(CreateImagePdf());
try
{
int sourceXRefCount = sourceR.XrefSize;
Document document = new Document();
MemoryStream outStream = new MemoryStream();
PdfCopy copy = new PdfCopy(document, outStream);
document.Open();
PdfImportedPage importedPage = copy.GetImportedPage(sourceR, 1);
copy.AddPage(importedPage);
document.Close();
PdfReader targetR = new PdfReader(outStream.ToArray());
int destinationXRefCount = targetR.XrefSize;
// TestResourceUtils.saveBytesToFile(createImagePdf(), new File("./source.pdf"));
// TestResourceUtils.saveBytesToFile(out.toByteArray(), new File("./result.pdf"));
Assert.AreEqual(sourceXRefCount, destinationXRefCount);
}
finally
{
sourceR.Close();
}
#endif// DRAWING
}
public void Combine(string saveFileName, IEnumerable<string> files)
{
byte[] mergedPdf = null;
using (MemoryStream ms = new MemoryStream())
{
using (Document document = new Document())
{
using (PdfCopy copy = new PdfCopy(document, ms))
{
document.Open();
foreach (var item in files.OrderBy(x=> x))
{
PdfReader reader = new PdfReader(item);
// loop over the pages in that document
int n = reader.NumberOfPages;
for (int page = 0; page < n; )
{
copy.AddPage(copy.GetImportedPage(reader, ++page));
}
reader.Close();
}
}
}
mergedPdf = ms.ToArray();
}
File.WriteAllBytes(String.Concat(saveFileName, ".pdf"), mergedPdf);
}
/// <summary>
/// Merges multiple pdf files into 1 pdf file.
/// </summary>
/// <param name="FilesToMerge">Files to merger (Byte array for each file)</param>
/// <returns>1 file with all the files passed in</returns>
public static byte[] MergeFiles(IEnumerable<byte[]> FilesToMerge)
{
//Declare the memory stream to use
using (var MemoryStreamToWritePdfWith = new MemoryStream())
{
//declare the new document which we will merge all the files into
using (var NewFileToMergeIntoWith = new Document())
{
//holds the byte array which we will return
byte[] ByteArrayToReturn;
//declare the pdf copy to write the data with
using (var PdfCopyWriter = new PdfCopy(NewFileToMergeIntoWith, MemoryStreamToWritePdfWith))
{
//set the page size of the new file
//NewFileToMergeIntoWith.SetPageSize(PageSize.GetRectangle("Letter").Rotate().Rotate());
//go open the new file that we are writing into
NewFileToMergeIntoWith.Open();
//now loop through all the files we want to merge
foreach (var FileToMerge in FilesToMerge)
{
//declare the pdf reader so we can copy it
using (var PdfFileReader = new PdfReader(FileToMerge))
{
//figure out how many pages are in this pdf, so we can add each of the pdf's
int PdfFilePageCount = PdfFileReader.NumberOfPages;
// loop over document pages (start with page 1...not a 0 based index)
for (int i = 1; i <= PdfFilePageCount; i++)
{
//set the file size for this page
NewFileToMergeIntoWith.SetPageSize(PdfFileReader.GetPageSize(i));
//add a new page for the next page
NewFileToMergeIntoWith.NewPage();
//now import the page
PdfCopyWriter.AddPage(PdfCopyWriter.GetImportedPage(PdfFileReader, i));
}
}
}
//now close the new file which we merged everyting into
NewFileToMergeIntoWith.Close();
//grab the buffer and throw it into a byte array to return
ByteArrayToReturn = MemoryStreamToWritePdfWith.GetBuffer();
//flush out the memory stream
MemoryStreamToWritePdfWith.Flush();
}
//now return the byte array
return ByteArrayToReturn;
}
}
}
/// <summary>
/// Concatenates two or more PDF files into one file.
/// </summary>
/// <param name="inputFiles">A string array containing the names of the pdf files to concatenate</param>
/// <param name="outputFile">Name of the concatenated file.</param>
public void ConcatenatePDFFiles(String[] inputFiles, String outputFile)
{
if (inputFiles != null && inputFiles.Length > 0)
{
if (!String.IsNullOrEmpty(outputFile) && !String.IsNullOrWhiteSpace(outputFile))
{
var concatDocument = new iTextSharpText.Document();
var outputCopy = new iTextSharpPDF.PdfCopy(concatDocument, new FileStream(outputFile, FileMode.Create, FileAccess.ReadWrite));
concatDocument.Open();
try
{
for (int loop = 0; loop <= inputFiles.GetUpperBound(0); loop++)
{
var inputDocument = new iTextSharpPDF.PdfReader(inputFiles[loop]);
for (int pageLoop = 1; pageLoop <= inputDocument.NumberOfPages; pageLoop++)
{
concatDocument.SetPageSize(inputDocument.GetPageSizeWithRotation(pageLoop));
outputCopy.AddPage(outputCopy.GetImportedPage(inputDocument, pageLoop));
}
inputDocument.Close();
outputCopy.FreeReader(inputDocument);
inputDocument = null;
}
concatDocument.Close();
outputCopy.Close();
}
catch
{
if (concatDocument != null && concatDocument.IsOpen())
{
concatDocument.Close();
}
if (outputCopy != null)
{
outputCopy.Close();
}
if (File.Exists(outputFile))
{
try
{
File.Delete(outputFile);
}
catch { }
}
throw;
}
}
else
{
throw new ArgumentNullException("outputFile", exceptionArgumentNullOrEmptyString);
}
}
else
{
throw new ArgumentNullException("inputFiles", exceptionArgumentNullOrEmptyString);
}
}
/**
* Adds the pages from an existing PDF document.
* @param reader the reader for the existing PDF document
* @return the number of pages that were added
* @throws DocumentException
* @throws IOException
*/
public int AddPages(PdfReader reader)
{
Open();
int n = reader.NumberOfPages;
for (int i = 1; i <= n; i++)
{
copy.AddPage(copy.GetImportedPage(reader, i));
}
copy.FreeReader(reader);
return(n);
}
/**
* Creates a new PDF based on the one in the reader
* @param reader a reader with a PDF file
* @throws IOException
* @throws DocumentException
*/
private void ManipulateWithCopy(PdfReader reader)
{
int n = reader.NumberOfPages;
Document document = new Document();
PdfCopy copy = new PdfCopy(document, new MemoryStream());
document.Open();
for (int i = 0; i < n; )
{
copy.AddPage(copy.GetImportedPage(reader, ++i));
}
document.Close();
}
public static byte[] MergeFiles(List<byte[]> sourceFiles)
{
Document document = new Document();
using (MemoryStream ms = new MemoryStream())
{
PdfCopy copy = new PdfCopy(document, ms);
document.Open();
int documentPageCounter = 0;
// Iterate through all pdf documents
for (int fileCounter = 0; fileCounter < sourceFiles.Count; fileCounter++)
{
// Create pdf reader
PdfReader reader = new PdfReader(sourceFiles[fileCounter]);
int numberOfPages = reader.NumberOfPages;
// Iterate through all pages
for (int currentPageIndex = 1; currentPageIndex <= numberOfPages; currentPageIndex++)
{
PdfImportedPage importedPage = copy.GetImportedPage(reader, currentPageIndex);
//***************************************
// Uncomment and alter for watermarking.
//***************************************
//
//documentPageCounter++;
//PdfCopy.PageStamp pageStamp = copy.CreatePageStamp(importedPage);
//
//// Write header
//ColumnText.ShowTextAligned(pageStamp.GetOverContent(), Element.ALIGN_CENTER,
// new Phrase("PDF Merged with me.AxeyWorks PDFMerge"), importedPage.Width / 2, importedPage.Height - 30,
// importedPage.Width < importedPage.Height ? 0 : 1);
//
//// Write footer
//ColumnText.ShowTextAligned(pageStamp.GetOverContent(), Element.ALIGN_CENTER,
// new Phrase($"Page {documentPageCounter}"), importedPage.Width / 2, 30,
// importedPage.Width < importedPage.Height ? 0 : 1);
//
//pageStamp.AlterContents();
copy.AddPage(importedPage);
}
copy.FreeReader(reader);
reader.Close();
}
document.Close();
return ms.GetBuffer();
}
}
// ---------------------------------------------------------------------------
/**
* Creates a new PDF based on the one in the reader
* @param reader a reader with a PDF file
*/
private byte[] ManipulateWithCopy(PdfReader reader) {
using (MemoryStream ms = new MemoryStream()) {
int n = reader.NumberOfPages;
using (Document document = new Document()) {
using (PdfCopy copy = new PdfCopy(document, ms)) {
document.Open();
for (int i = 0; i < n;) {
copy.AddPage(copy.GetImportedPage(reader, ++i));
}
}
}
return ms.ToArray();
}
}
private void StartThread()
{
List <String> filePaths = new List <string>();
// create one-page pdfs first
iTextSharp.text.pdf.PdfReader reader = null;
int currentPage = 1;
int pageCount = 0;
String filepath = textBox_file.Text;
System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding();
reader = new iTextSharp.text.pdf.PdfReader(filepath);
reader.RemoveUnusedObjects();
pageCount = reader.NumberOfPages;
string ext = System.IO.Path.GetExtension(filepath);
for (int i = 1; i <= pageCount; i++)
{
iTextSharp.text.pdf.PdfReader reader1 = new iTextSharp.text.pdf.PdfReader(filepath);
string outfile = filepath.Replace((System.IO.Path.GetFileName(filepath)), (System.IO.Path.GetFileName(filepath).Replace(".pdf", "") + "_" + i.ToString()) + ext);
reader1.RemoveUnusedObjects();
iTextSharp.text.Document doc = new iTextSharp.text.Document(reader.GetPageSizeWithRotation(currentPage));
iTextSharp.text.pdf.PdfCopy pdfCpy = new iTextSharp.text.pdf.PdfCopy(doc, new System.IO.FileStream(outfile, System.IO.FileMode.Create));
doc.Open();
for (int j = 1; j <= 1; j++)
{
iTextSharp.text.pdf.PdfImportedPage page = pdfCpy.GetImportedPage(reader1, currentPage);
pdfCpy.AddPage(page);
currentPage += 1;
}
doc.Close();
pdfCpy.Close();
reader1.Close();
reader.Close();
filePaths.Add(outfile);
}
DecomposeData decompose = new DecomposeData
{
filePathsPdf = filePaths,
folder = textBox_destFolder.Text
};
backgroundWorker1.RunWorkerAsync(decompose);
label_status.Text = localization.GetValueForItem(LocalizedItem.TextSearchStarted).Replace("%i", filePaths.Count.ToString());
label_status.ForeColor = Color.Blue;
}
// ---------------------------------------------------------------------------
/**
* Fills out a data sheet, flattens it, and adds it to a combined PDF.
* @param copy the PdfCopy instance (can also be PdfSmartCopy)
*/
public void AddDataSheets(PdfCopy copy) {
IEnumerable<Movie> movies = PojoFactory.GetMovies();
// Loop over all the movies and fill out the data sheet
foreach (Movie movie in movies) {
PdfReader reader = new PdfReader(DATASHEET_PATH);
using (var ms = new MemoryStream()) {
using (PdfStamper stamper = new PdfStamper(reader, ms)) {
Fill(stamper.AcroFields, movie);
stamper.FormFlattening = true;
}
reader = new PdfReader(ms.ToArray());
copy.AddPage(copy.GetImportedPage(reader, 1));
}
}
}
public void Create(Album album, string outputPdfPath)
{
Document document = new Document();
PdfCopy pdfCopyProvider = new PdfCopy(document,
new FileStream(outputPdfPath, FileMode.Create));
document.Open();
foreach (Page page in album.Pages)
{
AddTextForPage(pdfCopyProvider, page.Image, page.TextForPage);
pdfCopyProvider.AddPage(page.Image);
}
document.Close();
}
/// <summary>
/// Splits the PDF file
/// </summary>
/// <param name="filepath">The file to split</param>
private void Split(string filepath)
{
this.statut.Text = "Début de la division";
this.statut.Refresh();
this.document.Text = Path.GetFileName(filepath);
this.document.Refresh();
PdfReader reader = null;
int currentPage = 1;
int pageCount = 0;
string dirPath = Path.GetDirectoryName(filepath);
System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding();
reader = new iTextSharp.text.pdf.PdfReader(filepath);
reader.RemoveUnusedObjects();
pageCount = reader.NumberOfPages;
string ext = System.IO.Path.GetExtension(filepath);
for (int i = 1; i <= pageCount; i++)
{
this.statut.Text = "En cours de division " + i + " / " + pageCount;
this.statut.Refresh();
iTextSharp.text.pdf.PdfReader reader1 = new iTextSharp.text.pdf.PdfReader(filepath);
string outfile = filepath.Replace(System.IO.Path.GetFileName(filepath), (System.IO.Path.GetFileName(filepath).Replace(FileExtension.PDF, string.Empty) + "_" + i.ToString()) + ext);
outfile = outfile.Substring(0, dirPath.Length).Insert(dirPath.Length, string.Empty) + "\\" + Path.GetFileName(filepath).Replace(FileExtension.PDF, string.Empty) + "_" + i.ToString() + ext;
reader1.RemoveUnusedObjects();
iTextSharp.text.Document doc = new iTextSharp.text.Document(reader.GetPageSizeWithRotation(currentPage));
iTextSharp.text.pdf.PdfCopy pdfCpy = new iTextSharp.text.pdf.PdfCopy(doc, new System.IO.FileStream(outfile, System.IO.FileMode.OpenOrCreate));
doc.Open();
for (int j = 1; j <= 1; j++)
{
iTextSharp.text.pdf.PdfImportedPage page = pdfCpy.GetImportedPage(reader1, currentPage);
pdfCpy.AddPage(page);
currentPage += 1;
}
this.progressBar1.PerformStep();
this.progressPages = this.progressPages + 1;
this.label1.Text = this.progressPages + " / " + this.nbpages;
this.label1.Refresh();
this.statut.Text = "Fin de la division " + i + " / " + pageCount;
this.statut.Refresh();
doc.Close();
pdfCpy.Close();
reader1.Close();
reader.Close();
}
}
public static void Merge(string file, string OutFile, ref SetupStationaryFields.addresscollection aic)
{
using (FileStream stream = new FileStream(OutFile, FileMode.Create))
{
using (Document doc = new Document())
{
using (PdfCopy pdf = new PdfCopy(doc, stream))
{
doc.Open();
PdfReader reader = null;
PdfImportedPage page = null;
//fixed typo
int ii = 0;
int count = 0;
foreach (SetupStationaryFields.addressitem ai in aic)
{
if ((!ai.ommitted))
{
reader = new PdfReader(file);
PdfReader.unethicalreading = true;
count = reader.NumberOfPages;
for (int i = 0; i <= reader.NumberOfPages - 1; i++)
{
page = pdf.GetImportedPage(reader, i + 1);
pdf.AddPage(page);
}
pdf.FreeReader(reader);
reader.Close();
ai.startpage = ((ii) * count) + 1;
ai.endpage = (ii * count) + count;
ii = ii + 1;
}
}
}
}
stream.Close();
}
}
protected override void Convert(ConversionOptions options)
{
if (m_sourceFiles != null)
{
if (m_sourceFiles.Count == 1 && !m_forceConversion)
{
this.OutputFile = m_sourceFiles[0];
}
else
{
try
{
using (MemoryStream ms = new MemoryStream())
{
using (Document doc = new Document(options.Orientation == PageOrientation.Portrait ? PageSize.LETTER : PageSize.LETTER_LANDSCAPE))
{
PdfCopy copy = new PdfCopy(doc, ms);
PdfReader reader;
doc.Open();
int n;
foreach (byte[] file in m_sourceFiles)
{
if (file != null)
{
reader = new PdfReader(file);
n = reader.NumberOfPages;
for (int page = 1; page <= n; page++)
{
copy.AddPage(copy.GetImportedPage(reader, page));
}
copy.FreeReader(reader);
}
}
}
this.OutputFile = ms.ToArray();
}
}
catch (Exception ex)
{
throw new ConversionEngineException("Error when merging Pdf files.", null, "pdf", this, ex);
}
}
}
}
public static void BreakApart()
{
var reader = new iTextSharp.text.pdf.PdfReader(@"C:\Projects\31g\trunk\temp\20140208110036.pdf");
for (var i = 1; i < reader.NumberOfPages; i++)
{
var document = new iTextSharp.text.Document(reader.GetPageSizeWithRotation(i));
var pdfCopyProvider = new iTextSharp.text.pdf.PdfCopy(document,
new System.IO.FileStream(string.Format(@"C:\Projects\31g\trunk\temp\pdf\20140208110036_{0}.pdf", i), System.IO.FileMode.Create));
document.Open();
var importedPage = pdfCopyProvider.GetImportedPage(reader, i);
pdfCopyProvider.AddPage(importedPage);
document.Close();
}
reader.Close();
}
private void CombineMultiplePDFsCer(string[] fileNames, string outFile, bool deleteSource)
{
// step 1: creation of a document-object
Document document = new Document();
//create newFileStream object which will be disposed at the end
using (FileStream newFileStream = new FileStream(outFile, FileMode.Create))
{
// step 2: we create a writer that listens to the document
PdfCopy writer = new iTextSharp.text.pdf.PdfCopy(document, newFileStream);
if (writer == null)
{
return;
}
// step 3: we open the document
document.Open();
foreach (string fileName in fileNames)
{
// we create a reader for a certain document
PdfReader reader = new PdfReader(fileName);
reader.ConsolidateNamedDestinations();
// step 4: we add content
for (int i = 1; i <= reader.NumberOfPages; i++)
{
PdfImportedPage page = writer.GetImportedPage(reader, i);
writer.AddPage(page);
}
PRAcroForm form = reader.AcroForm;
if (form != null)
{
writer.CopyAcroForm(reader);
}
reader.Close();
if (deleteSource)
{
File.Delete(fileName);
}
}
// step 5: we close the document and writer
writer.Close();
document.Close();
}//disposes the newFileStream object
}
// ---------------------------------------------------------------------------
/**
* Manipulates a PDF file src with the file dest as result
* @param src the original PDF
*/
public byte[] ManipulatePdf(List<byte[]> src)
{
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
int page_offset = 0;
// Create a list for the bookmarks
List<Dictionary<String, Object>> bookmarks =
new List<Dictionary<String, Object>>();
for (int i = 0; i < src.Count; i++)
{
PdfReader reader = new PdfReader(src[i]);
// merge the bookmarks
IList<Dictionary<String, Object>> tmp =
SimpleBookmark.GetBookmark(reader);
SimpleBookmark.ShiftPageNumbers(tmp, page_offset, null);
foreach (var d in tmp) bookmarks.Add(d);
// add the pages
int n = reader.NumberOfPages;
page_offset += n;
for (int page = 0; page < n; )
{
copy.AddPage(copy.GetImportedPage(reader, ++page));
}
}
// Add the merged bookmarks
copy.Outlines = bookmarks;
}
}
return ms.ToArray();
}
}
public void CombineMultiplePDFs(string[] fileNames, string outFile)
{
// step 1: creation of a document-object
Document document = new Document();
// step 2: we create a writer that listens to the document
PdfCopy writer = new PdfCopy(document, new FileStream(outFile, FileMode.Create));
if (writer == null)
{
return;
}
// step 3: we open the document
document.Open();
foreach (string fileName in fileNames)
{
// we create a reader for a certain document
PdfReader reader = new PdfReader(fileName);
reader.ConsolidateNamedDestinations();
// step 4: we add content
for (int i = 1; i <= reader.NumberOfPages; i++)
{
PdfImportedPage page = writer.GetImportedPage(reader, i);
writer.AddPage(page);
}
PRAcroForm form = reader.AcroForm;
if (form != null)
{
writer.CopyAcroForm(reader);
}
reader.Close();
}
// step 5: we close the document and writer
writer.Close();
document.Close();
}
/// <summary> iTextSharp_PNG 无法正常进行展出操作
///
/// </summary>
/// <param name="filepath"></param>
/// <param name="outputPath"></param>
/// <returns></returns>
List <PPTPage> SplitePDF(string filepath, string outputPath)
{
List <PPTPage> pages = new List <PPTPage>();
iTextSharp.text.pdf.PdfReader reader = null;
int currentPage = 1;
int pageCount = 0;
System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding();
reader = new iTextSharp.text.pdf.PdfReader(filepath);
reader.RemoveUnusedObjects();
pageCount = reader.NumberOfPages;
for (int i = 1; i <= pageCount;)
{
string outfile = System.IO.Path.Combine(outputPath, i + ".png");
iTextSharp.text.Document doc = new iTextSharp.text.Document(reader.GetPageSizeWithRotation(currentPage));
iTextSharp.text.pdf.PdfCopy pdfCpy = new iTextSharp.text.pdf.PdfCopy(doc, new System.IO.FileStream(outfile, System.IO.FileMode.Create));
doc.Open();
for (int j = 1; j <= 1; j++)
{
iTextSharp.text.pdf.PdfImportedPage page = pdfCpy.GetImportedPage(reader, currentPage);
pdfCpy.SetFullCompression();
pdfCpy.AddPage(page);
currentPage += 1;
}
Console.WriteLine("PDF TO IMAGES - {0}/{1}", ++i, pageCount);
pages.Add(new PPTPage()
{
Cover = outfile
});
pdfCpy.Flush();
doc.Close();
pdfCpy.Close();
reader.Close();
}
return(pages);
}
public void ExtractPages(string sourcePdfPath, string outputPdfPath,
int startPage, int endPage, string password = "")
{
PdfReader reader = null;
Document sourceDocument = null;
PdfCopy pdfCopyProvider = null;
PdfImportedPage importedPage = null;
try
{
// Intialize a new PdfReader instance with the contents of the source Pdf file:
reader = new PdfReader(sourcePdfPath, Encoding.UTF8.GetBytes(password));
// For simplicity, I am assuming all the pages share the same size
// and rotation as the first page:
sourceDocument = new Document(reader.GetPageSizeWithRotation(startPage));
// Initialize an instance of the PdfCopyClass with the source
// document and an output file stream:
pdfCopyProvider = new PdfCopy(sourceDocument,
new System.IO.FileStream(outputPdfPath, System.IO.FileMode.Create));
sourceDocument.Open();
// Walk the specified range and add the page copies to the output file:
for (int i = startPage; i <= endPage; i++)
{
importedPage = pdfCopyProvider.GetImportedPage(reader, i);
pdfCopyProvider.AddPage(importedPage);
}
sourceDocument.Close();
reader.Close();
}
catch (Exception ex)
{
throw ex;
}
}
public void ExtractPages(string sourcePdfPath,
string outputPdfPath, int[] extractThesePages)
{
PdfReader reader = null;
Document sourceDocument = null;
PdfCopy pdfCopyProvider = null;
PdfImportedPage importedPage = null;
try
{
// Intialize a new PdfReader instance with the
// contents of the source Pdf file:
reader = new PdfReader(sourcePdfPath);
// For simplicity, I am assuming all the pages share the same size
// and rotation as the first page:
sourceDocument = new Document(reader.GetPageSizeWithRotation(extractThesePages[0]));
// Initialize an instance of the PdfCopyClass with the source
// document and an output file stream:
pdfCopyProvider = new PdfCopy(sourceDocument,
new System.IO.FileStream(outputPdfPath, System.IO.FileMode.Create));
sourceDocument.Open();
// Walk the array and add the page copies to the output file:
foreach (int pageNumber in extractThesePages)
{
importedPage = pdfCopyProvider.GetImportedPage(reader, pageNumber);
pdfCopyProvider.AddPage(importedPage);
}
sourceDocument.Close();
reader.Close();
}
catch (Exception ex)
{
throw ex;
}
}
private Byte[] CombineMultiplePDFs(List <Byte[]> fileNames)
{
Byte[] _Byte = null;
Document document = new Document();
MemoryStream _PageAll = new MemoryStream();
PdfCopy writer = new iTextSharp.text.pdf.PdfCopy(document, _PageAll);
if (writer == null)
{
return(_Byte);
}
// step 3: we open the document
document.Open();
foreach (Byte[] fileName in fileNames.ToArray())
{
// we create a reader for a certain document
PdfReader reader = new PdfReader(fileName);
reader.ConsolidateNamedDestinations();
// step 4: we add content
for (int i = 1; i <= reader.NumberOfPages; i++)
{
PdfImportedPage page = writer.GetImportedPage(reader, i);
writer.AddPage(page);
}
PRAcroForm form = reader.AcroForm;
if (form != null)
{
writer.CopyAcroForm(reader);
}
reader.Close();
}
// step 5: we close the document and writer
writer.Close();
document.Close();
return(_PageAll.ToArray());
}
//99% of credit goes to this person: http://stackoverflow.com/a/20491695
public static bool Merge(List<string> fullFilePaths, string saveAs)
{
try
{
using (FileStream stream = new FileStream(saveAs, FileMode.Create))
using (Document doc = new Document())
using (PdfCopy pdf = new PdfCopy(doc, stream))
{
doc.Open();
PdfReader reader = null;
PdfImportedPage page = null;
fullFilePaths.ForEach(file =>
{
using (reader = new PdfReader(file))
{
for (int i = 0; i < reader.NumberOfPages; i++)
{
page = pdf.GetImportedPage(reader, i + 1);
pdf.AddPage(page);
}
pdf.FreeReader(reader);
}
});
}
}
catch(Exception ex)
{
Console.WriteLine(ex.Message);
return false;
}
return true;
}
/// <summary>
/// Create a PDF from a subset of source PDF pages specified in a page range.
/// </summary>
/// <param name="FirstPage">first source page</param>
/// <param name="LastPage">last source page</param>
/// <param name="srcPath">the source file</param>
/// <param name="outputPath">New PDF with the specefied pages.</param>
/// <returns>True if all goes well</returns>
public static bool RipPdf(int FirstPage, int LastPage, string srcPath, string outputPath)
{
bool result = true;
PdfReader reader = null;
Document document = null;
PdfCopy pdfCopyProvider = null;
PdfImportedPage importedPage = null;
// Intialize a new PdfReader instance with the contents of the source Pdf file:
using (reader = new PdfReader(srcPath))
{
// For simplicity, I am assuming all the pages share the same size
// and rotation as the first page:
using (document = new Document(reader.GetPageSizeWithRotation(FirstPage)))
{
// Initialize an instance of the PdfCopyClass with the source
// document and an output file stream:
pdfCopyProvider = new PdfCopy(document,
new System.IO.FileStream(outputPath, System.IO.FileMode.Create));
document.Open();
// Walk the specified range and add the page copies to the output file:
for (int i = FirstPage; i <= LastPage; i++)
{
importedPage = pdfCopyProvider.GetImportedPage(reader, i);
pdfCopyProvider.AddPage(importedPage);
}
}//Dispose of document
}//Dispose of reader
return result;
}
public static void SplitePDF(string filepath)
{
iTextSharp.text.pdf.PdfReader reader = null;
int currentPage = 1;
int pageCount = 0;
//string filepath_New = filepath + "\\PDFDestination\\";
System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding();
//byte[] arrayofPassword = encoding.GetBytes(ExistingFilePassword);
reader = new iTextSharp.text.pdf.PdfReader(filepath);
reader.RemoveUnusedObjects();
pageCount = reader.NumberOfPages;
string ext = System.IO.Path.GetExtension(filepath);
for (int i = 1; i <= pageCount; i++)
{
iTextSharp.text.pdf.PdfReader reader1 = new iTextSharp.text.pdf.PdfReader(filepath);
string outfile = filepath.Replace((System.IO.Path.GetFileName(filepath)), (System.IO.Path.GetFileName(filepath).Replace(".pdf", "") + "_" + i.ToString()) + ext);
reader1.RemoveUnusedObjects();
iTextSharp.text.Document doc = new iTextSharp.text.Document(reader.GetPageSizeWithRotation(currentPage));
iTextSharp.text.pdf.PdfCopy pdfCpy = new iTextSharp.text.pdf.PdfCopy(doc, new System.IO.FileStream(outfile, System.IO.FileMode.Create));
pdfCpy.SetFullCompression();
doc.Open();
for (int j = 1; j <= 1; j++)
{
iTextSharp.text.pdf.PdfImportedPage page = pdfCpy.GetImportedPage(reader1, currentPage);
pdfCpy.AddPage(page);
currentPage += 1;
}
doc.Close();
pdfCpy.Close();
reader1.Close();
reader.Close();
}
}
/// <summary>
/// Extract pages from a pdf file.
/// </summary>
/// <param name="source">The source file.</param>
/// <param name="output">The output file.</param>
/// <param name="startPage">The start page.</param>
/// <param name="endPage">The last page.</param>
public static void ExtractPages(string source, string output, int startPage, int endPage)
{
try
{
PdfReader reader = new PdfReader(source);
Document document = new Document();
PdfCopy pdfCopy = new PdfCopy(document, new FileStream(output, FileMode.Create));
document.Open();
for (int i = startPage; i <= endPage; i++)
{
PdfImportedPage importedPage = pdfCopy.GetImportedPage(reader, i);
pdfCopy.AddPage(importedPage);
}
document.Close();
reader.Close();
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
///
/// </summary>
/// <param name="inputFile">The PDF file to split</param>
/// <param name="splitStartPages"></param>
public void SplitPDF(String inputFile, SortedList <int, String> splitStartPages)
{
if (!String.IsNullOrEmpty(inputFile) &&
!String.IsNullOrWhiteSpace(inputFile) &&
splitStartPages != null &&
splitStartPages.Count >= 2)
{
var inputDocument = new iTextSharpPDF.PdfReader(inputFile);
// First split must begin with page 1
// Last split must not be higher than last page
if (splitStartPages.Keys[0] == 1 &&
splitStartPages.Keys[splitStartPages.Count - 1] <= inputDocument.NumberOfPages)
{
int currentPage = 1;
int firstPageOfSplit;
int lastPageOfSplit;
try
{
for (int splitPoint = 0; splitPoint <= (splitStartPages.Count - 1); splitPoint++)
{
firstPageOfSplit = currentPage;
if (splitPoint < (splitStartPages.Count - 1))
{
lastPageOfSplit = splitStartPages.Keys[splitPoint + 1] - 1;
}
else
{
lastPageOfSplit = inputDocument.NumberOfPages;
}
iTextSharpText.Document splitDocument = null;
iTextSharpPDF.PdfCopy splitOutputFile = null;
try
{
splitDocument = new iTextSharpText.Document();
splitOutputFile = new iTextSharpPDF.PdfCopy(splitDocument, new FileStream(splitStartPages.Values[splitPoint], FileMode.Create, FileAccess.ReadWrite));
splitDocument.Open();
for (int outputPage = firstPageOfSplit; outputPage <= lastPageOfSplit; outputPage++)
{
splitDocument.SetPageSize(inputDocument.GetPageSizeWithRotation(currentPage));
splitOutputFile.AddPage(splitOutputFile.GetImportedPage(inputDocument, currentPage));
currentPage++;
}
}
finally
{
if (splitDocument != null && splitDocument.IsOpen())
{
splitDocument.Close();
}
if (splitOutputFile != null)
{
splitOutputFile.Close();
splitOutputFile.FreeReader(inputDocument);
}
splitDocument = null;
splitOutputFile = null;
}
}
}
catch
{
// Cleanup any files that may have
// been written
foreach (KeyValuePair <int, String> split in splitStartPages)
{
try
{
File.Delete(split.Value);
}
catch { }
}
throw;
}
finally
{
if (inputDocument != null)
{
inputDocument.Close();
}
}
}
else
{
if (splitStartPages.Keys[splitStartPages.Count - 1] > inputDocument.NumberOfPages)
{
throw new ArgumentOutOfRangeException("splitStartPages", String.Format("Final page number must be less than the number of pages ({0}). Passed value is {1}.", inputDocument.NumberOfPages, splitStartPages.Keys[splitStartPages.Count - 1]));
}
throw new ArgumentOutOfRangeException("splitStartPages", "First page number must be 1.");
}
}
else
{
if (inputFile == null)
{
throw new ArgumentNullException("inputFile", exceptionArgumentNullOrEmptyString);
}
if (splitStartPages == null)
{
throw new ArgumentNullException("splitStartPages", exceptionArgumentNullOrEmptyString);
}
throw new ArgumentOutOfRangeException("splitStartPages", "Must contain at least two KeyValue pairs.");
}
}
/// <summary>
/// Extracts a range of pages from a PDF file,
/// and writes them to a new file.
/// </summary>
/// <param name="inputFile">The PDF to extract pages from.</param>
/// <param name="outputFile">The new file to write the extracted pages to.</param>
/// <param name="firstPage">The first page to extract.</param>
/// <param name="lastPage">The last page to extract.</param>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="ArgumentOutOfRangeException"></exception>
/// <remarks><see cref="FileStream"/> constructor exceptions may also be thrown.</remarks>
public void ExtractPDFPages(String inputFile, String outputFile, int firstPage, int lastPage)
{
if (!String.IsNullOrEmpty(inputFile) && !String.IsNullOrWhiteSpace(inputFile) &&
!String.IsNullOrEmpty(outputFile) && !String.IsNullOrWhiteSpace(outputFile) &&
firstPage > 0 && lastPage > 0 &&
lastPage >= firstPage)
{
var inputDocument = new iTextSharpPDF.PdfReader(inputFile);
try
{
// Page numbers specified must not be greater
// than the number of pages in the document
if (firstPage <= inputDocument.NumberOfPages &&
lastPage <= inputDocument.NumberOfPages)
{
iTextSharpText.Document extractOutputDocument = null;
iTextSharpPDF.PdfCopy extractOutputFile = null;
try
{
extractOutputDocument = new iTextSharpText.Document();
extractOutputFile = new iTextSharpPDF.PdfCopy(extractOutputDocument, new FileStream(outputFile, FileMode.Create, FileAccess.ReadWrite));
extractOutputDocument.Open();
for (int loop = firstPage; loop <= lastPage; loop++)
{
extractOutputDocument.SetPageSize(inputDocument.GetPageSizeWithRotation(loop));
extractOutputFile.AddPage(extractOutputFile.GetImportedPage(inputDocument, loop));
}
}
finally
{
if (extractOutputDocument != null && extractOutputDocument.IsOpen())
{
extractOutputDocument.Close();
}
if (extractOutputFile != null)
{
extractOutputFile.Close();
extractOutputFile.FreeReader(inputDocument);
}
}
}
else
{
if (firstPage > inputDocument.NumberOfPages)
{
throw new ArgumentOutOfRangeException("firstPage", String.Format(exceptionParameterCannotBeGreaterThan, "firstPage", "the number of pages in the document."));
}
throw new ArgumentOutOfRangeException("lastPage", String.Format(exceptionParameterCannotBeGreaterThan, "firstPage", "the number of pages in the document."));
}
}
catch
{
try
{
File.Delete(outputFile);
}
catch { }
throw;
}
finally
{
if (inputDocument != null)
{
inputDocument.Close();
}
inputDocument = null;
}
}
else
{
if (String.IsNullOrEmpty(inputFile) || String.IsNullOrWhiteSpace(inputFile))
{
throw new ArgumentNullException("inputFile", exceptionArgumentNullOrEmptyString);
}
if (String.IsNullOrEmpty(outputFile) || String.IsNullOrWhiteSpace(outputFile))
{
throw new ArgumentNullException("outputFile", exceptionArgumentNullOrEmptyString);
}
if (firstPage < 1)
{
throw new ArgumentOutOfRangeException("firstPage", exceptionArgumentZeroOrNegative);
}
if (lastPage < 1)
{
throw new ArgumentOutOfRangeException("lastPage", exceptionArgumentZeroOrNegative);
}
if (lastPage < firstPage)
{
throw new ArgumentOutOfRangeException("lastPage", String.Format(exceptionParameterCannotBeLessThan, "lastPage", "firstPage"));
}
}
}
private void button1_Click(object sender, EventArgs e)
{
if (openFile1.SafeFileName == "" || openFile2.SafeFileName == "")
{
MessageBox.Show("No haz seleccionado ningún PDF", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
MessageBox.Show("Se unira \"" + openFile1.SafeFileName + "\" con \"" + openFile2.SafeFileName + "\"");
saveFile.Filter = "Adobe Acrobat Document PDF (*.pdf)|*.pdf";
saveFile.FilterIndex = 1;
if (saveFile.ShowDialog() == DialogResult.OK)
{
MessageBox.Show("Se guardara en la siguiente ruta:\n" + saveFile.FileName);
FileStream myStream = new FileStream(saveFile.FileName,FileMode.OpenOrCreate);
PdfReader reader = new PdfReader(openFile1.FileName);
PdfReader reader2 = new PdfReader(openFile2.FileName);
Document document = new Document(reader.GetPageSizeWithRotation(1));
PdfCopy writer = new PdfCopy(document, myStream);
document.Open();
document.AddCreationDate();
if (txtAutor.Text != null)
{
document.AddAuthor(txtAutor.Text);
}
if (txtHeader.Text != null)
{
document.AddHeader(txtHeader.Text, "Document");
}
if (txtKeywords.Text != null)
{
document.AddKeywords(txtKeywords.Text);
}
document.AddProducer();
if (txtTitulo.Text != null)
{
document.AddTitle(txtTitulo.Text);
}
// Calculando incremento
progressBar.Refresh();
int incremento = (int)(100 / (reader.NumberOfPages + reader2.NumberOfPages));
MessageBox.Show("Incremento es: " + incremento);
for (int i = 1; i <= reader.NumberOfPages; i++)
{
writer.AddPage(writer.GetImportedPage(reader, i));
progressBar.PerformStep();
progressBar.Increment(++incremento);
}
progressBar.Increment(50);
for (int i = 1; i <= reader2.NumberOfPages; i++)
{
writer.AddPage(writer.GetImportedPage(reader2, i));
progressBar.PerformStep();
}
progressBar.Increment(100);
document.Close();
}
}
/// <summary>
/// Merge multiple pdf files into one pdf file.
/// </summary>
/// <param name="sources">The source files.</param>
/// <param name="outputFile">The output file.</param>
public static void Merge(string[] sources, string outputFile)
{
try
{
Document document = new Document();
PdfCopy pdfCopy = new PdfCopy(document, new FileStream(outputFile, FileMode.Create));
document.Open();
foreach (var source in sources)
{
PdfReader reader = new PdfReader(source);
for (int i = 1; i <= reader.NumberOfPages; i++)
{
PdfImportedPage page = pdfCopy.GetImportedPage(reader, i);
pdfCopy.AddPage(page);
}
reader.Close();
}
pdfCopy.Close();
document.Close();
}
catch (Exception ex)
{
throw ex;
}
}
static void test01(string file)
{
var db = RedisWrite.Db;
if (!File.Exists(file))
{
return;
}
var reader = new iTextSharpPdf.PdfReader(file);
reader.RemoveUnusedObjects();
long fileSize = reader.FileLength;
int currentPage = 1;
var readerCopy = new iTextSharpPdf.PdfReader(file);
readerCopy.RemoveUnusedObjects();
readerCopy.RemoveAnnotations();
readerCopy.RemoveFields();
readerCopy.RemoveUsageRights();
string CreationDate = "";
foreach (KeyValuePair <string, string> KV in readerCopy.Info)
{
if (KV.Key == "CreationDate")
{
CreationDate = KV.Value;
}
//readerCopy.Info.Remove(KV.Key);
}
//int headerSize = readerCopy.Metadata.Length;
//string mt = Encoding.UTF8.GetString(readerCopy.Metadata);
int max = reader.NumberOfPages;
if (max > 5)
{
max = 2;
}
string key = DocumentStatic.buildId(max, fileSize);
var obj = new Dictionary <string, object>()
{
{ "id", long.Parse(key) },
{ "file_name", Path.GetFileNameWithoutExtension(file) },
{ "file_type", "pdf" },
{ "file_size", fileSize },
{ "file_created", CreationDate },
{ "page", max }
};
string jsonInfo = JsonConvert.SerializeObject(obj);
var bufInfo = ASCIIEncoding.UTF8.GetBytes(jsonInfo);
var lsEntry = new List <NameValueEntry>()
{
new NameValueEntry(0, LZ4.LZ4Codec.Encode(bufInfo, 0, bufInfo.Length))
};
for (int i = 1; i <= max; i++)
{
////using (FileStream fs = new FileStream(@"C:\temp\" + i + "-.pdf", FileMode.Create, FileAccess.Write, FileShare.None))
////{
//// using (var d = new iTextSharpText.Document())
//// {
//// using (var w = new iTextSharpPdf.PdfCopy(d, fs))
//// {
//// d.Open();
//// w.AddPage(w.GetImportedPage(reader, i));
//// d.Close();
//// }
//// }
////}
using (var ms = new MemoryStream())
{
var docCopy = new iTextSharpText.Document(reader.GetPageSizeWithRotation(currentPage));
//var pdfCopy = new iTextSharpPdf.PdfCopy(docCopy, new FileStream(@"C:\temp\" + i + "-.pdf", FileMode.Create));
var pdfCopy = new iTextSharpPdf.PdfCopy(docCopy, ms);
docCopy.Open();
var page = pdfCopy.GetImportedPage(readerCopy, currentPage);
pdfCopy.SetFullCompression();
pdfCopy.AddPage(page);
currentPage += 1;
//long len = ms.Length;
docCopy.Close();
pdfCopy.Close();
//m_app.RedisUpdate(key, i.ToString(), ms.ToArray());
lsEntry.Add(new NameValueEntry(i, ms.ToArray()));
}
}
readerCopy.Close();
reader.Close();
string did = db.StreamAdd("BUF", lsEntry.ToArray(), key + "-0");
}
public static void CombineMultiplePDFs(string[] fileNames, string outFile)
{
try
{
iTextSharp.text.Document document = new iTextSharp.text.Document();
PdfCopy writer = new PdfCopy(document, new FileStream(outFile, FileMode.Create));
if (writer == null)
{
return;
}
document.Open();
foreach (string fileName in fileNames)
{
if (System.IO.File.Exists(fileName))
{
PdfReader reader = new PdfReader(fileName);
reader.ConsolidateNamedDestinations();
for (int i = 1; i <= reader.NumberOfPages; i++)
{
PdfImportedPage page = writer.GetImportedPage(reader, i);
writer.AddPage(page);
}
PRAcroForm form = reader.AcroForm;
if (form != null)
{
writer.CopyDocumentFields(reader);
}
reader.Close();
}
}
writer.Close();
document.Close();
}
catch
{
MessageBox.Show("Close the pdf file and try again.");
}
}
private void bCreatePDF_Click(Object sender, EventArgs e)
{
Match match = Regex.Match(tb_pages.Text, @"^(\d+|\d+-\d+)(,(\d+|\d+-\d+))*$");
if (match.Success)
{
// Grab pages from text box
List<int> pages = getNums(tb_pages.Text);
PdfReader pdfReader = new PdfReader(openPDF_Dialog.FileName);
int numberOfPages = pdfReader.NumberOfPages;
bool page_validates = true;
foreach (int p in pages)
{
if (p > numberOfPages)
{
page_validates = false;
}
}
if (pages.Any() && page_validates)
{
SaveFileDialog savePDF_Dialog = new SaveFileDialog();
savePDF_Dialog.Filter = "pdf files (*.pdf)|*.pdf";
savePDF_Dialog.FilterIndex = 2;
savePDF_Dialog.RestoreDirectory = false;
string save_path = "";
if (savePDF_Dialog.ShowDialog() == DialogResult.OK)
{
save_path = savePDF_Dialog.FileName;
}
pages.Sort();
PdfReader reader = null;
Document document = null;
PdfCopy pdfCopyProvider = null;
PdfImportedPage importedPage = null;
try
{
reader = new PdfReader(openPDF_Dialog.FileName);
string extracted_pdf_name = "";
if (String.IsNullOrEmpty(save_path))
{
// User willfully canceled saving... do nothing
}
else
{
extracted_pdf_name = save_path;
Console.Out.WriteLine(extracted_pdf_name);
document = new Document(reader.GetPageSizeWithRotation(pages[0]));
pdfCopyProvider = new PdfCopy(document, new FileStream(extracted_pdf_name, FileMode.Create));
document.Open();
foreach (int p in pages)
{
importedPage = pdfCopyProvider.GetImportedPage(reader, p);
pdfCopyProvider.AddPage(importedPage);
}
document.Close();
reader.Close();
tb_pages.Clear();
tb_pages.Enabled = false;
bCreatePDF.Enabled = false;
lPathPDF.Text = "No PDF File Selected...";
MessageBox.Show($"PDF Created at: {extracted_pdf_name}");
pdfViewer.LoadFile("meh.pdf");
selectedPages.Clear();
cbPageSelected.Checked = false;
bPrevPage.Enabled = false;
bNextPage.Enabled = false;
cbPageSelected.Enabled = false;
}
}
catch (Exception ex)
{
Console.Out.WriteLine(ex.Message);
}
}
else
{
MessageBox.Show("ERROR: Invalid format in Pages entry.\n\nOnly numbers, dashes, and commas are accepted.\nCheck your date ranges to make sure they're correct.\nMake sure pages entered fall within source PDF page range.");
}
}
else
{
MessageBox.Show("ERROR: Invalid format in Pages entry.\n\nOnly numbers, dashes, and commas are accepted.\nCheck your date ranges to make sure they're correct.\nMake sure pages entered fall within source PDF page range.");
}
}
private void InsertDestinationsIntoDocument(string document, IEnumerable<INamedDestination> nameddests)
{
if (!File.Exists(document))
throw new FileNotFoundException("Document not found.", document);
var extensionIndex = document.IndexOf(".pdf");
var tempDoc = document.Substring(0, extensionIndex) + "-2.pdf";
var doc = new Document();
var copy = new PdfCopy(doc, new FileStream(tempDoc, FileMode.Create));
doc.Open();
var reader = new PdfReader(document);
copy.Outlines = GetBookmarksFromDocument(document).ToList();
for (int page = 0; page < reader.NumberOfPages; )
{
copy.AddPage(copy.GetImportedPage(reader, ++page));
}
foreach (var destination in nameddests)
{
copy.AddNamedDestination(destination.Name, destination.Page, destination.Destination);
}
copy.FreeReader(reader);
reader.Close();
doc.Close();
// TODO: Uniqueness tests?
}
/// <summary>
/// Takes pages from two pdf files, and produces an output file
/// whose odd pages are the contents of the first, and
/// even pages are the contents of the second. Useful for
/// merging front/back output from single sided scanners.
/// </summary>
/// <param name="oddPageFile">The file supplying odd numbered pages</param>
/// <param name="evenPageFile">The file supplying even numbered pages</param>
/// <param name="outputFile">The output file containing the merged pages</param>
/// <param name="skipExtraPages">Set to true to skip any extra pages if
/// one file is longer than the other</param>
public void EvenOddMerge(String oddPageFile, String evenPageFile,
String outputFile, bool skipExtraPages)
{
if (!String.IsNullOrEmpty(oddPageFile) && !String.IsNullOrWhiteSpace(oddPageFile) &&
!String.IsNullOrEmpty(evenPageFile) && !String.IsNullOrWhiteSpace(evenPageFile) &&
!String.IsNullOrEmpty(outputFile) && !String.IsNullOrWhiteSpace(outputFile))
{
var oddPageDocument = new iTextSharpPDF.PdfReader(oddPageFile);
var evenPageDocument = new iTextSharpPDF.PdfReader(evenPageFile);
try
{
iTextSharpText.Document mergedOutputDocument = null;
iTextSharpPDF.PdfCopy mergedOutputFile = null;
int lastPage = 0;
switch (skipExtraPages)
{
case (false):
lastPage = oddPageDocument.NumberOfPages;
if (evenPageDocument.NumberOfPages > oddPageDocument.NumberOfPages)
{
lastPage = evenPageDocument.NumberOfPages;
}
else
{
lastPage = oddPageDocument.NumberOfPages;
}
break;
case (true):
if (evenPageDocument.NumberOfPages < oddPageDocument.NumberOfPages)
{
lastPage = evenPageDocument.NumberOfPages;
}
else
{
lastPage = oddPageDocument.NumberOfPages;
}
break;
}
try
{
mergedOutputDocument = new iTextSharpText.Document();
mergedOutputFile = new iTextSharpPDF.PdfCopy(mergedOutputDocument, new FileStream(outputFile, FileMode.Create, FileAccess.ReadWrite));
mergedOutputDocument.Open();
for (int loop = 1; loop <= lastPage; loop++)
{
// Extract and merge odd page
if (loop <= oddPageDocument.NumberOfPages)
{
mergedOutputDocument.SetPageSize(oddPageDocument.GetPageSizeWithRotation(loop));
mergedOutputFile.AddPage(mergedOutputFile.GetImportedPage(oddPageDocument, loop));
}
// Extract and merge even page
if (loop <= evenPageDocument.NumberOfPages)
{
mergedOutputDocument.SetPageSize(evenPageDocument.GetPageSizeWithRotation(loop));
mergedOutputFile.AddPage(mergedOutputFile.GetImportedPage(evenPageDocument, loop));
}
}
}
finally
{
if (mergedOutputDocument != null && mergedOutputDocument.IsOpen())
{
mergedOutputDocument.Close();
}
if (mergedOutputFile != null)
{
mergedOutputFile.Close();
mergedOutputFile.FreeReader(oddPageDocument);
mergedOutputFile.FreeReader(evenPageDocument);
}
}
}
catch
{
try
{
File.Delete(outputFile);
}
catch { }
throw;
}
finally
{
try
{
if (oddPageDocument != null)
{
oddPageDocument.Close();
}
oddPageDocument = null;
}
catch { }
try
{
if (evenPageDocument != null)
{
evenPageDocument.Close();
}
evenPageDocument = null;
}
catch { }
}
}
else
{
if (String.IsNullOrEmpty(oddPageFile) || String.IsNullOrWhiteSpace(oddPageFile))
{
throw new ArgumentNullException("oddPageFile", exceptionArgumentNullOrEmptyString);
}
if (String.IsNullOrEmpty(evenPageFile) || String.IsNullOrWhiteSpace(evenPageFile))
{
throw new ArgumentNullException("evenPageFile", exceptionArgumentNullOrEmptyString);
}
if (String.IsNullOrEmpty(outputFile) || String.IsNullOrWhiteSpace(outputFile))
{
throw new ArgumentNullException("outputFile", exceptionArgumentNullOrEmptyString);
}
}
}
/// <summary>
/// Concatenates two or more PDF files into one file.
/// </summary>
/// <param name="inputFiles">A string array containing the names of the pdf files to concatenate</param>
/// <param name="outputFile">Name of the concatenated file.</param>
public void ConcatenatePDFFiles(String[] inputFiles, String outputFile)
{
if (inputFiles != null && inputFiles.Length > 0)
{
if (!String.IsNullOrEmpty(outputFile) && !String.IsNullOrWhiteSpace(outputFile))
{
var concatDocument = new iTextSharpText.Document();
var outputCopy = new iTextSharpPDF.PdfCopy(concatDocument, new FileStream(outputFile, FileMode.Create, FileAccess.ReadWrite));
concatDocument.Open();
try
{
for (int loop = 0; loop <= inputFiles.GetUpperBound(0); loop++)
{
var inputDocument = new iTextSharpPDF.PdfReader(inputFiles[loop]);
for (int pageLoop = 1; pageLoop <= inputDocument.NumberOfPages; pageLoop++)
{
concatDocument.SetPageSize(inputDocument.GetPageSizeWithRotation(pageLoop));
outputCopy.AddPage(outputCopy.GetImportedPage(inputDocument, pageLoop));
}
inputDocument.Close();
outputCopy.FreeReader(inputDocument);
inputDocument = null;
}
concatDocument.Close();
outputCopy.Close();
}
catch
{
if (concatDocument != null && concatDocument.IsOpen()) concatDocument.Close();
if (outputCopy != null) outputCopy.Close();
if (File.Exists(outputFile))
{
try
{
File.Delete(outputFile);
}
catch { }
}
throw;
}
}
else
{
throw new ArgumentNullException("outputFile", exceptionArgumentNullOrEmptyString);
}
}
else
{
throw new ArgumentNullException("inputFiles", exceptionArgumentNullOrEmptyString);
}
}
