public static void MergeFiles(List <string> sourceFiles, string rutaPdfJoin, bool addCopy)
{
Document document = new Document();
using (MemoryStream ms = new MemoryStream())
{
FileStream fl = new FileStream(rutaPdfJoin, FileMode.Create, FileAccess.Write, FileShare.None);
PdfCopy copy = new PdfCopy(document, fl);
document.Open();
// Iterar pdfs
for (int fileCounter = 0; fileCounter < sourceFiles.Count; fileCounter++)
{
PdfReader reader = new PdfReader(sourceFiles[fileCounter]);
int numberOfPages = reader.NumberOfPages;
// Iterar paginas
for (int currentPageIndex = 1; currentPageIndex <= numberOfPages; currentPageIndex++)
{
PdfImportedPage importedPage = copy.GetImportedPage(reader, currentPageIndex);
PdfCopy.PageStamp pageStamp = copy.CreatePageStamp(importedPage);
pageStamp.AlterContents();
copy.AddPage(importedPage);
if (addCopy)
{
copy.AddPage(importedPage);
}
}
copy.FreeReader(reader);
reader.Close();
}
document.Close();
}
}
static void Main(string[] args)
{
Parameters parms = new Parameters();
if (!parms.ParseArgs(args))
{
return;
}
using (MemoryStream ms = new MemoryStream())
{
var newDoc = new Document();
var newWriter = new PdfCopy(newDoc, ms);
newDoc.Open();
PdfReader reader1 = new PdfReader(parms.File1);
PdfReader reader2 = new PdfReader(parms.File2);
int pageCount = Math.Max(reader1.NumberOfPages, reader2.NumberOfPages);
for (int f1PgNo = 1; f1PgNo <= pageCount; f1PgNo++)
{
newWriter.AddPage(newWriter.GetImportedPage(reader1, f1PgNo));
try
{
int f2PgNo = parms.Reverse ? reader2.NumberOfPages - (f1PgNo - 1) : f1PgNo;
newWriter.AddPage(newWriter.GetImportedPage(reader2, f2PgNo));
}
catch { }
}
newDoc.Close();
File.WriteAllBytes(parms.Output, ms.ToArray());
}
}
public void CopySignedDocuments()
{
string file = RESOURCES + "hello_signed1.pdf";
Directory.CreateDirectory("PdfCopyTest/");
Document pdfDocument = new Document();
PdfCopy copier = new PdfCopy(pdfDocument, new FileStream("PdfCopyTest/CopySignedDocuments.pdf", FileMode.Create));
pdfDocument.Open();
PdfReader reader1 = new PdfReader(file);
copier.AddPage(copier.GetImportedPage(reader1, 1));
copier.FreeReader(reader1);
reader1 = new PdfReader(file);
copier.AddPage(copier.GetImportedPage(reader1, 1));
copier.FreeReader(reader1);
pdfDocument.Close();
PdfReader reader = new PdfReader("PdfCopyTest/CopySignedDocuments.pdf");
PdfDictionary sig = (PdfDictionary)reader.GetPdfObject(9);
PdfDictionary sigRef = sig.GetAsArray(PdfName.REFERENCE).GetAsDict(0);
Assert.True(PdfName.SIGREF.Equals(sigRef.GetAsName(PdfName.TYPE)));
Assert.False(sigRef.Contains(PdfName.DATA));
sig = (PdfDictionary)reader.GetPdfObject(21);
sigRef = sig.GetAsArray(PdfName.REFERENCE).GetAsDict(0);
Assert.True(PdfName.SIGREF.Equals(sigRef.GetAsName(PdfName.TYPE)));
Assert.False(sigRef.Contains(PdfName.DATA));
}
private void buttonSplit_Click(object sender, EventArgs e)
{
progressBar1.Value = 0;
PdfReader reader = new PdfReader(textBoxSelectPDF.Text);
int number = reader.NumberOfPages;
int first = Convert.ToInt16(textBoxRange1.Text);
int last = Convert.ToInt16(textBoxRange2.Text);
Document document = new Document();
PdfCopy copy = new PdfCopy(document, new FileStream(textBoxLocation.Text + "//" + "Splitted PDF File " + first + " - " + last + ".pdf", FileMode.Create));
if (first == 0 && last == 0)
{
document.Open();
for (int i = 1; i <= number; i++)
{
copy.AddPage(copy.GetImportedPage(reader, i));
}
document.Close();
}
else
{
document.Open();
for (int i = first; i <= last; i++)
{
copy.AddPage(copy.GetImportedPage(reader, i));
}
document.Close();
}
Process.Start(textBoxLocation.Text);
progressBar1.Value = 100;
}
public void MergeArquivo(string pathRaizLote, string pathArquivo, string pathArquivoParaMerge, string cpfCnpj, LoteDTO lote)
{
var pathArquivoTemp = String.Format(@"{0}\{1}_TEMP{2}", pathRaizLote, cpfCnpj, ".pdf");
//Arquivo formatado -> Ex..: 00081876000100.pdf
//Arquivo para merger -> Ex..: 00081876000100_TASK1_1.pdf
using (var readerArquivoFormatado = new PdfReader(pathArquivo))
using (var readerArquivoParaMerge = new PdfReader(pathArquivoParaMerge))
{
int totalArqFormatado = readerArquivoFormatado.NumberOfPages;
int totalArqMerge = readerArquivoParaMerge.NumberOfPages;
var document = new Document(readerArquivoFormatado.GetPageSizeWithRotation(1));
var provider = new PdfCopy(document, new FileStream(pathArquivoTemp, FileMode.Create));
document.Open();
var conteudoPaginas = new List <string>();
string textoPag;
//Adiciona paginas ao arquivo temporario.
for (int pagina = 1; pagina <= totalArqFormatado; pagina++)
{
textoPag = PdfTextExtractor.GetTextFromPage(readerArquivoFormatado, pagina, new SimpleTextExtractionStrategy());
var imported = provider.GetImportedPage(readerArquivoFormatado, pagina);
provider.AddPage(imported);
conteudoPaginas.Add(textoPag);
}
//Adiciona paginas ao arquivo temporario se não houver duplicacao.
for (int pagina = 1; pagina <= totalArqMerge; pagina++)
{
textoPag = PdfTextExtractor.GetTextFromPage(readerArquivoParaMerge, pagina, new SimpleTextExtractionStrategy());
if (!string.IsNullOrWhiteSpace(textoPag) && !conteudoPaginas.Contains(textoPag))
{
var imported = provider.GetImportedPage(readerArquivoParaMerge, pagina);
provider.AddPage(imported);
}
}
document.Close();
provider.Close();
}
File.Delete(pathArquivo);
File.Delete(pathArquivoParaMerge);
File.Move(pathArquivoTemp, pathArquivo);
//throw new InvalidPdfException("Teste");
}
public void AddSheet(string pdfFile, string addSheetFile, int numberInSheetFile, int numberInPdfFile, string destFile)
{
var sheet = new PdfReader(addSheetFile);
var pdf = new PdfReader(pdfFile);
var doc = new Document();
var copier = new PdfCopy(doc, new FileStream(destFile, FileMode.Create));
doc.Open();
var pdfLabels = PdfPageLabels.GetPageLabels(pdf);
if (pdfLabels?.Length != pdf.NumberOfPages)
{
pdfLabels = null;
}
var sheetLabel = PdfPageLabels.GetPageLabels(sheet);
if (sheetLabel?.Length != sheet.NumberOfPages)
{
sheetLabel = null;
}
var labels = new PdfPageLabels();
for (var i = 1; i < numberInPdfFile; i++)
{
var page = copier.GetImportedPage(pdf, i);
copier.AddPage(page);
if (pdfLabels != null)
{
var label = pdfLabels[i - 1];
labels.AddPageLabel(i, PdfPageLabels.EMPTY, label);
}
}
copier.AddPage(copier.GetImportedPage(sheet, numberInSheetFile));
if (sheetLabel != null)
{
labels.AddPageLabel(numberInPdfFile, PdfPageLabels.EMPTY, sheetLabel[numberInSheetFile - 1]);
}
else
{
labels.AddPageLabel(numberInPdfFile, PdfPageLabels.EMPTY, "бланк");
}
for (var i = numberInPdfFile; i < pdf.NumberOfPages + 1; i++)
{
copier.AddPage(copier.GetImportedPage(pdf, i));
if (pdfLabels != null)
{
var label = pdfLabels[i - 1];
labels.AddPageLabel(i + 1, PdfPageLabels.EMPTY, label);
}
}
copier.PageLabels = labels;
doc.Close();
copier.Close();
pdf.Close();
sheet.Close();
}
public void MergeNamedDestinationsTest()
{
string outputFolder = "PdfCopyTest/";
string outputFile = "namedDestinations.pdf";
Directory.CreateDirectory(outputFolder);
// Create simple document
MemoryStream main = new MemoryStream();
Document doc = new Document(new Rectangle(612f, 792f), 54f, 54f, 36f, 36f);
PdfWriter pdfwrite = PdfWriter.GetInstance(doc, main);
doc.Open();
doc.Add(new Paragraph("Testing Page"));
doc.Close();
// Create TOC document
MemoryStream two = new MemoryStream();
Document doc2 = new Document(new Rectangle(612f, 792f), 54f, 54f, 36f, 36f);
PdfWriter pdfwrite2 = PdfWriter.GetInstance(doc2, two);
doc2.Open();
Chunk chn = new Chunk("<<-- Link To Testing Page -->>");
chn.SetRemoteGoto("DUMMY.PDF", "page-num-1");
doc2.Add(new Paragraph(chn));
doc2.Close();
// Merge documents
MemoryStream three = new MemoryStream();
PdfReader reader1 = new PdfReader(main.ToArray());
PdfReader reader2 = new PdfReader(two.ToArray());
Document doc3 = new Document();
PdfCopy DocCopy = new PdfCopy(doc3, three);
doc3.Open();
DocCopy.AddPage(DocCopy.GetImportedPage(reader2, 1));
DocCopy.AddPage(DocCopy.GetImportedPage(reader1, 1));
DocCopy.AddNamedDestination("page-num-1", 2, new PdfDestination(PdfDestination.FIT));
doc3.Close();
// Fix references and write to file
PdfReader finalReader = new PdfReader(three.ToArray());
finalReader.MakeRemoteNamedDestinationsLocal();
PdfStamper stamper = new PdfStamper(finalReader, new FileStream(outputFolder + outputFile, FileMode.Create));
stamper.Close();
CompareTool compareTool = new CompareTool();
String errorMessage = compareTool.CompareByContent(outputFolder + outputFile, RESOURCES + "cmp_" + outputFile, outputFolder, "diff");
if (errorMessage != null)
{
Assert.Fail(errorMessage);
}
}
public void zamjeni()
{
int o = Convert.ToInt32(odstr2.Text);
int d = Convert.ToInt32(dostr2.Text);
int oz = Convert.ToInt32(odstr3.Text);
int dz = Convert.ToInt32(dostr3.Text);
Document document = new Document();
string tempf = put2.Replace(".pdf", ".bak");
System.IO.File.Copy(put2, tempf, true);
//create PdfCopy object
PdfCopy copy = new PdfCopy(document, new FileStream(put2, FileMode.Create));
//open the document
document.Open();
//PdfReader variable putanjadod
PdfReader reader = new PdfReader(tempf);
PdfReader readerz = new PdfReader(put1);
List <int> ptd = new List <int>();
for (int i = o; i < d + 1; i++)
{
ptd.Add(i);
}
List <int> ptc = new List <int>();
for (int i = oz; i < dz + 1; i++)
{
ptc.Add(i);
}
//DeletePages(ref ptd, putanjaIDE, putanjaIDE);
;
for (int i = 1; i < d; i++)
{
copy.AddPage(copy.GetImportedPage(reader, i));
}
for (int i = oz; i < dz + 1; i++)
{
copy.AddPage(copy.GetImportedPage(readerz, i));
}
for (int i = d - 1; i <= reader.NumberOfPages; i++)
{
copy.AddPage(copy.GetImportedPage(reader, i));
}
reader.Close();
readerz.Close();
document.Close();
}
//Methode zum Zusammenführen/Mergen der gesammelten PDFs; Zusammengeführt wird, was in "SPListItemCollection" mitgegeben wird (vorherige Methode); Rückgabewert ist das Ergebnis als byteArray
public byte[] Merge(SPListItemCollection listItems, Boolean eab, string auftragsnummer)
{
//Initialiseren eines neuen Byte-Arrays; diesem wird später das erstellte PDf als MemoryStream übergeben.
byte[] result = new byte[0];
//"Öffnen" eines neuen Memorystreams; dieser bleibt solange offen, bis die geschweifte Klammer von "using" wieder geschlossen wird
using (MemoryStream ms = new MemoryStream())
{
//Initialisieren eines neuen itextsharp-Dokuments; auch dieses bleibt solange geöffnet, bis die geschweifte Klammer von using wieder geschlossen wird
using (Document document = new Document())
{
//Starten von PdfCopy (von itextsharp), es werden das zuvor erstellte Dokument und der geöffnete MemoryStream zugwiesen.
using (PdfCopy copy = new PdfCopy(document, ms))
{
document.Open();
//Mit eienr Foreach-Schleife wird durch alle SharePoint-Elemente innerhalb der mitgegeben "SPListItemCollection" durchgegangen
foreach (SPListItem li in listItems)
{
//Durch initialisieren eines PDF-Readers (itextsharp) wird jedes einzelne PDf zum Lesen geöffnet
using (PdfReader pdfreader = new PdfReader(li.File.OpenBinaryStream()))
{
//Dieser Befehl ist wichtig, da mit ihm passwortgeschützte PDFs, oder PDFs, die das Zusammenführen nicht erlauben, TROTZDEM zusammengeführt werden können
PdfReader.unethicalreading = true;
//Abspeichern der Seitenanzahl des gerade geöffneten PDFs
int n = pdfreader.NumberOfPages;
//Wenn die aktuelle Datei der Auftragszettel selbst ist UND wenn beim Aufruf der Methode für "eab" "false" mitgebgen wird, wird nur die erste Seite hinzugefügt.
//Somit bleiben die AEBs raus. Das wird für die ERstellung des PDfs für den Lieferanten verwendet. Beim Erstellen des Dokuments für die Verwaltung wird eab auf "true" gesetzt.
if ((li.File.Name == auftragsnummer + ".pdf") && (eab == false))
{
//Befehl zum importieren, der ersten Seite des Auftragszettels
copy.AddPage(copy.GetImportedPage(pdfreader, 1));
}
//Wenn es sich um jede andere Datei handelt UND eab == true ist, werden immer alle Seiten importiert.
else
{
//jede Seite wird importiert, der Zähler wird mit jeder Seite hochgezählt, bis keine Seite mehr vorhanden ist.
for (int page = 0; page < n;)
{
copy.AddPage(copy.GetImportedPage(pdfreader, ++page));
}
}
}
}
}
}
//Speichern des MemoryStreams in das ByteArray.
result = ms.ToArray();
}
//Rückgabe des erstellten PDFs als ByteArray zur Weiterverwendung
return(result);
}
private void Button8_Click(object sender, EventArgs e)
{
PdfReader reader = new PdfReader("COMPLETO.pdf");
Document document = new Document(reader.GetPageSize(1));
PdfCopy copier = new PdfCopy(document, new FileStream("2.pdf", FileMode.Create));
for (int pageCounter = 1; pageCounter < reader.NumberOfPages + 1; pageCounter++)
{
// get page
PdfImportedPage page = copier.GetImportedPage(reader, pageCounter);
/*// add content to imported page
* //PageStamp ps = pdfCopy.CreatePageStamp(page);
* PdfContentByte cb = page.GetOverContent();
* // set color
* cb.SetColorFill(BaseColor.BLACK);
* // get font
* BaseFont baseFont = BaseFont.CreateFont(string.Format("{0}\\Fonts\\arialuni.ttf", Environment.GetEnvironmentVariable("windir"), BaseFont.CP1252, BaseFont.NOT_EMBEDDED);
* cb.SetFontAndSize(baseFont, 12);
* cb.BeginText();
* cb.ShowTextAligned(PdfContentByte.ALIGN_CENTER, printLangString, 100f, 40f, 0f);
* cb.EndText();
* // Accept changes
* page.AlterContents();*/
// add page
copier.AddPage(page);
}
using (var ms = new MemoryStream())
{
Document doc = new Document(PageSize.A4);
PdfWriter writer = PdfWriter.GetInstance(doc, ms);
writer.CloseStream = false;
doc.Open();
doc.NewPage();
//doc.Add(new Paragraph(error, fontRed));
doc.Close();
writer.Close();
ms.Seek(0, SeekOrigin.Begin);
PdfReader rd = new PdfReader(ms);
for (int pageCounter = 1; pageCounter < reader.NumberOfPages + 1; pageCounter++)
{
copier.AddPage(copier.GetImportedPage(rd, pageCounter));
}
rd.Close();
}
document.Close();
reader.Close();
}
private void Form1_Load(object sender, EventArgs e)
{
String SecondPage = AppDomain.CurrentDomain.BaseDirectory + "TranscriptRequest.pdf";
String FirstPage = AppDomain.CurrentDomain.BaseDirectory + "FirstPage.pdf";
String Merged = AppDomain.CurrentDomain.BaseDirectory + "TranscriptMerged.pdf";
Document document = new Document();
using (FileStream newFileStream = new FileStream(Merged, FileMode.Create))
{
PdfCopy writer = new PdfCopy(document, newFileStream);
if (writer == null)
{
return;
}
document.Open();
PdfReader reader = new PdfReader(FirstPage);
reader.ConsolidateNamedDestinations();
for (int i = 1; i <= reader.NumberOfPages; i++)
{
PdfImportedPage page = writer.GetImportedPage(reader, i);
writer.AddPage(page);
}
reader.Close();
PdfReader readers = new PdfReader(SecondPage);
PdfReader.unethicalreading = true;
readers.ConsolidateNamedDestinations();
// step 4: we add content
for (int i = 1; i <= readers.NumberOfPages; i++)
{
PdfImportedPage page = writer.GetImportedPage(readers, i);
writer.AddPage(page);
}
readers.Close();
writer.Close();
document.Close();
}
}
/// <summary>
/// The SplitPdfFile
/// </summary>
/// <param name="v1">The <see cref="string"/></param>
/// <param name="v2">The <see cref="string"/></param>
/// <returns>The <see cref="Task"/></returns>
public async Task SplitFile(string filePath)
{
await Task.Factory.StartNew(() =>
{
var outputDirectoryPath = DirectoryDataFactory.CreateChildDirectory(filePath, $"pages{ DateTime.Now.ToString("ddHHmm")}");
PdfReader reader = new PdfReader(filePath);;
Document sourceDocument = null;
PdfCopy pdfCopyProvider = null;
PdfImportedPage importedPage = null;
var fileName = Path.GetFileName(filePath);
this.args.totalFiles = reader.NumberOfPages;
for (int i = 1; i < reader.NumberOfPages; i++)
{
var outPath = $"{outputDirectoryPath}\\{fileName.Replace(".pdf", "")}_{i}_page.pdf";
sourceDocument = new Document(reader.GetPageSizeWithRotation(i));
pdfCopyProvider = new PdfCopy(sourceDocument, new FileStream(outPath, FileMode.Create));
sourceDocument.Open();
importedPage = pdfCopyProvider.GetImportedPage(reader, i);
pdfCopyProvider.AddPage(importedPage);
sourceDocument.Close();
this.args.currentFile++;
this.eventHandler?.Invoke(this.args);
}
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);
}
}
private void MergeFile()
{
SaveFileDialog saveFileDialog = new SaveFileDialog();
saveFileDialog.FilterIndex = 1;
saveFileDialog.Filter = "Pdf file(.pdf)|*.pdf|All Files (*.*)|*.*";
bool?result = saveFileDialog.ShowDialog();
if (result == true)
{
PdfReader.unethicalreading = true;
Document document = new Document();
PdfCopy pdfCopy = new PdfCopy(document, new System.IO.FileStream(saveFileDialog.FileName, System.IO.FileMode.Create));
document.Open();
foreach (var file in MergeFiles)
{
using (PdfReader reader = new PdfReader(file.Path))
{
reader.ConsolidateNamedDestinations();
for (var i = 1; i <= reader.NumberOfPages; i++)
{
PdfImportedPage importedPage = pdfCopy.GetImportedPage(reader, i);
pdfCopy.AddPage(importedPage);
}
reader.Close();
}
}
document.Close();
}
}
private void SplitFile()
{
PdfReader.unethicalreading = true;
foreach (var file in SplitFiles)
{
using (PdfReader reader = new PdfReader(file.Path))
{
PdfReader.unethicalreading = true;
for (var i = 1; i <= reader.NumberOfPages; i++)
{
Document sourceDocument = new Document(reader.GetPageSizeWithRotation(i));
string outPath = System.IO.Path.Combine(
System.IO.Path.GetDirectoryName(file.Path),
System.IO.Path.GetFileNameWithoutExtension(file.Path) + "_" + i.ToString("000") + System.IO.Path.GetExtension(file.Path));
PdfCopy pdfCopyProvider = new PdfCopy(sourceDocument, new System.IO.FileStream(outPath, System.IO.FileMode.Create));
sourceDocument.Open();
PdfImportedPage importedPage = pdfCopyProvider.GetImportedPage(reader, i);
pdfCopyProvider.AddPage(importedPage);
sourceDocument.Close();
}
reader.Close();
}
}
}
/// <summary>
/// Extracts the pdf pages content to new pdf file.
/// </summary>
/// <param name="sourcePdf"></param>
/// <param name="targetPdf"></param>
/// <param name="extractPages"></param>
public static void ExtractPdf(FileInfo sourcePdf, FileInfo targetPdf, List <int> extractPages)
{
if (sourcePdf == null)
{
throw new ArgumentNullException(nameof(sourcePdf));
}
if (targetPdf == null)
{
throw new ArgumentNullException(nameof(targetPdf));
}
if (extractPages == null)
{
throw new ArgumentNullException(nameof(extractPages));
}
var reader = new PdfReader(sourcePdf.FullName);
var doc = new Document(reader.GetPageSizeWithRotation(extractPages[0]));
var copy = new PdfCopy(doc, new FileStream(targetPdf.FullName, FileMode.Create));
doc.Open();
foreach (var pageNumber in extractPages)
{
copy.AddPage(copy.GetImportedPage(reader, pageNumber));
}
doc.Close();
reader.Close();
}
public void ExtractPage(string sourcePdfPath, string outputPdfPath, int pageNumber)
{
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);
// Capture the correct size and orientation for the page:
document = new Document();
// 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 static string[] ExtractPages(string sourcePdfPath, string outputPdfDir)
{
PdfReader reader = null;
Document sourceDocument = null;
PdfCopy pdfCopyProvider = null;
PdfImportedPage importedPage = null;
List <string> filePaths = new List <string>();
try
{
reader = new PdfReader(sourcePdfPath);
int pageCount = reader.NumberOfPages;
for (int i = 1; i <= pageCount; i++)
{
sourceDocument = new Document(reader.GetPageSizeWithRotation(i));
string outputPdfPath = System.IO.Path.Combine(outputPdfDir, i.ToString() + ".pdf");
filePaths.Add(outputPdfPath);
pdfCopyProvider = new PdfCopy(sourceDocument, new System.IO.FileStream(outputPdfPath, System.IO.FileMode.Create));
sourceDocument.Open();
importedPage = pdfCopyProvider.GetImportedPage(reader, i);
pdfCopyProvider.AddPage(importedPage);
sourceDocument.Close();
}
reader.Close();
return(filePaths.ToArray());
}
catch (Exception ex)
{
throw ex;
}
}
virtual 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 PreguntasPDF(int page)
{
string sourcePdfPath = "CAMS/Programas.pdf";
string outputPdfPath = "pregunta.pdf";
if (File.Exists(outputPdfPath))
{
System.IO.File.Delete(outputPdfPath);
}
try {
reader = new PdfReader(sourcePdfPath);
// se conserva el mismo tamaño de la página
sourceDocument = new Document(reader.GetPageSizeWithRotation(page));
pdfCopyProvider = new PdfCopy(sourceDocument,
new System.IO.FileStream(outputPdfPath, System.IO.FileMode.Create));
sourceDocument.Open();
importedPage = pdfCopyProvider.GetImportedPage(reader, page);
pdfCopyProvider.AddPage(importedPage);
sourceDocument.Close();
reader.Close();
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Takes an ordered list of files and merges them into one output file.
/// </summary>
/// <param name="mergeList">An ordered list of file paths.</param>
/// <returns>The path to merged file created in this method.</returns>
private static string MergeOrderedList(List <string> mergeList)
{
int counter = 0;
string filename = Guid.NewGuid() + ".pdf";
string outfileFullPath = Path.Combine(Constants.inputDirectory.FullName, filename);
using (var stream = new FileStream(outfileFullPath, FileMode.Create))
using (var doc = new Document())
using (var pdf = new PdfCopy(doc, stream))
{
PdfReader reader = null;
PdfImportedPage page = null;
doc.Open();
foreach (string file in mergeList)
{
reader = new PdfReader(file);
for (int i = 0; i < reader.NumberOfPages; i++)
{
page = pdf.GetImportedPage(reader, i + 1);
pdf.AddPage(page);
}
counter++;
}
pdf.FreeReader(reader);
reader.Close();
}
return(outfileFullPath);
}
public byte[] AddAdditionalDocument(byte[] orginialDocument, List <AdditionalDocuments> additionalDocuments)
{
var additionalDocumentBytes = new List <byte[]>
{
orginialDocument
};
additionalDocumentBytes.AddRange(AttachImages(ImageList));
additionalDocumentBytes.AddRange(AttachPdfs(PdfList));
additionalDocumentBytes.AddRange(AttachHtml(HtmlList));
var memoryStreamPdf = new MemoryStream();
var documentPdf = new Document();
var pdfCopy = new PdfCopy(documentPdf, memoryStreamPdf);
documentPdf.Open();
foreach (var additionalDocumentByte in additionalDocumentBytes)
{
var pdfReader = new PdfReader(additionalDocumentByte);
var numberOfPages = pdfReader.NumberOfPages;
for (var page = 0; page < numberOfPages;)
{
pdfCopy.AddPage(pdfCopy.GetImportedPage(pdfReader, ++page));
}
}
documentPdf.Close();
var mergedPdfBytes = memoryStreamPdf.ToArray();
return(mergedPdfBytes);
}
public static void SplitPdfs(string OriginalPdf, List <string> PdfSheets, string workdir = "")
{
if (workdir == "")
{
workdir = System.IO.Path.GetTempPath() + DateTime.Now.Ticks.ToString();
}
Directory.CreateDirectory(workdir);
PdfReader sourcePdf = new PdfReader(OriginalPdf);
Document destinationPdfContainer = null;
PdfCopy pdfCopyProvider = null;
PdfImportedPage importedPage = null;
for (int numPage = 0; numPage < sourcePdf.NumberOfPages; numPage++)
{
destinationPdfContainer = new Document(sourcePdf.GetPageSizeWithRotation(1));
pdfCopyProvider = new PdfCopy(destinationPdfContainer, new FileStream(System.IO.Path.Combine(workdir, numPage + ".pdf"), FileMode.Create));
destinationPdfContainer.Open();
importedPage = pdfCopyProvider.GetImportedPage(sourcePdf, numPage + 1);
pdfCopyProvider.AddPage(importedPage);
PdfSheets.Add(System.IO.Path.Combine(workdir, numPage + ".pdf"));
destinationPdfContainer.Close();
}
}
/// <summary>
/// Extracts the pdf range content to new pdf file.
/// </summary>
/// <param name="sourcePdf"></param>
/// <param name="targetPdf"></param>
/// <param name="startPage"></param>
/// <param name="endPage"></param>
public static void ExtractPdf(FileInfo sourcePdf, FileInfo targetPdf, int startPage, int endPage)
{
if (sourcePdf == null)
{
throw new ArgumentNullException(nameof(sourcePdf));
}
if (targetPdf == null)
{
throw new ArgumentNullException(nameof(targetPdf));
}
var reader = new PdfReader(sourcePdf.FullName);
var doc = new Document(reader.GetPageSizeWithRotation(startPage));
var copy = new PdfCopy(doc, new FileStream(targetPdf.FullName, FileMode.Create));
doc.Open();
for (var i = startPage; i <= endPage; i++)
{
var importPage = copy.GetImportedPage(reader, i);
copy.AddPage(importPage);
}
doc.Close();
reader.Close();
}
public static Int32 SplitPDF(String str_src_path)
{
//variables
String str_dir_path = "";
String result = "";
PdfCopy copy;
str_dir_path = GetDirPath(str_src_path);
str_dir_path = str_dir_path + "result\\";
if (!Directory.Exists(str_dir_path))
{
Directory.CreateDirectory(str_dir_path);
}
//create PdfReader object
PdfReader reader = new PdfReader(str_src_path);
for (int i = 1; i <= reader.NumberOfPages; i++)
{
//create Document object
Document document = new Document();
copy = new PdfCopy(document, new FileStream(str_dir_path + i + ".pdf", FileMode.Create));
//open the document
document.Open();
//add page to PdfCopy
copy.AddPage(copy.GetImportedPage(reader, i));
//close the document object
document.Close();
}
return(reader.NumberOfPages);
}
public void RespuestasPDF(int startPage, int endPage)
{
string sourcePdfPath = "CAMS/Programas.pdf";
string outputPdfPath = "respuesta.pdf";
if (File.Exists(outputPdfPath))
{
System.IO.File.Delete(outputPdfPath);
}
try
{
reader = new PdfReader(sourcePdfPath);
sourceDocument = new Document(reader.GetPageSizeWithRotation(startPage));
pdfCopyProvider = new PdfCopy(sourceDocument,
new System.IO.FileStream(outputPdfPath, System.IO.FileMode.Create));
sourceDocument.Open();
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 static byte[] ExtractPages(string pdfDocument, int startPage, int endPage)
{
PdfReader reader = new PdfReader(pdfDocument);
int numberOfPages = reader.NumberOfPages;
int endPageResolved = endPage;
if (startPage > numberOfPages || endPageResolved > numberOfPages)
{
return(null);
}
byte[] outputDocument;
using (Document doc = new Document())
using (MemoryStream msOut = new MemoryStream())
{
PdfCopy pdfCopyProvider = new PdfCopy(doc, msOut);
doc.Open();
for (int i = startPage; i <= endPageResolved; i++)
{
PdfImportedPage page = pdfCopyProvider.GetImportedPage(reader, i);
pdfCopyProvider.AddPage(page);
}
doc.Close();
reader.Close();
outputDocument = msOut.ToArray();
}
return(outputDocument);
}
private void ExtractPages(string sourcePDFpath, string outputPDFpath, int startpage, int endpage)
{
Console.WriteLine("Extracting document " + DateTime.Now.Millisecond);
PdfReader reader = null;
iTextSharp.text.Document sourceDocument = null;
PdfCopy pdfCopyProvider = null;
PdfImportedPage importedPage = null;
PdfReader.unethicalreading = true;
reader = new PdfReader(sourcePDFpath);
sourceDocument = new iTextSharp.text.Document(reader.GetPageSizeWithRotation(startpage));
pdfCopyProvider = new PdfCopy(sourceDocument, new FileStream(outputPDFpath, FileMode.Create));
sourceDocument.Open();
for (int i = startpage; i < startpage + endpage; i++)
{
try
{
importedPage = pdfCopyProvider.GetImportedPage(reader, i);
pdfCopyProvider.AddPage(importedPage);
}
catch (System.ArgumentException ex)
{
throw ex;
}
}
sourceDocument.Close();
reader.Close();
}
public static void AddAllPages(this PdfCopy source, ref PdfReader reader)
{
foreach (var p in reader.PageNumbers())
{
source.AddPage(source.GetImportedPage(reader, p));
}
}
private void ExtractPages(string sourcePDFpath, string outputPDFpath, int startpage, int endpage)
{
PdfReader reader = null;
iTextSharp.text.Document sourceDocument = null;
PdfCopy pdfCopyProvider = null;
PdfImportedPage importedPage = null;
PdfReader.unethicalreading = true;
reader = new PdfReader(sourcePDFpath);
sourceDocument = new iTextSharp.text.Document(reader.GetPageSizeWithRotation(startpage));
pdfCopyProvider = new PdfCopy(sourceDocument, new FileStream(outputPDFpath, FileMode.Create));
sourceDocument.Open();
for (int i = startpage; i < startpage + endpage; i++)
{
Application.DoEvents();
try
{
importedPage = pdfCopyProvider.GetImportedPage(reader, i);
pdfCopyProvider.AddPage(importedPage);
}
catch (ArgumentException ex)
{
throw ex;
}
}
sourceDocument.Close();
reader.Close();
}
