743 lines
34 KiB
C#
743 lines
34 KiB
C#
using System;
|
|
using System.IO;
|
|
using System.Collections;
|
|
using iTextSharp.text.pdf.interfaces;
|
|
using iTextSharp.text.pdf.collection;
|
|
using Org.BouncyCastle.X509;
|
|
/*
|
|
* Copyright 2003, 2004 by Paulo Soares.
|
|
*
|
|
* The contents of this file are subject to the Mozilla Public License Version 1.1
|
|
* (the "License"); you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at http://www.mozilla.org/MPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
* for the specific language governing rights and limitations under the License.
|
|
*
|
|
* The Original Code is 'iText, a free JAVA-PDF library'.
|
|
*
|
|
* The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
|
|
* the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
|
|
* All Rights Reserved.
|
|
* Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
|
|
* are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
|
|
*
|
|
* Contributor(s): all the names of the contributors are added in the source code
|
|
* where applicable.
|
|
*
|
|
* Alternatively, the contents of this file may be used under the terms of the
|
|
* LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
|
|
* provisions of LGPL are applicable instead of those above. If you wish to
|
|
* allow use of your version of this file only under the terms of the LGPL
|
|
* License and not to allow others to use your version of this file under
|
|
* the MPL, indicate your decision by deleting the provisions above and
|
|
* replace them with the notice and other provisions required by the LGPL.
|
|
* If you do not delete the provisions above, a recipient may use your version
|
|
* of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
|
|
*
|
|
* This library is free software; you can redistribute it and/or modify it
|
|
* under the terms of the MPL as stated above or under the terms of the GNU
|
|
* Library General Public License as published by the Free Software Foundation;
|
|
* either version 2 of the License, or any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
* FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
|
|
* details.
|
|
*
|
|
* If you didn't download this code from the following link, you should check if
|
|
* you aren't using an obsolete version:
|
|
* http://www.lowagie.com/iText/
|
|
*/
|
|
|
|
namespace iTextSharp.text.pdf {
|
|
/** Applies extra content to the pages of a PDF document.
|
|
* This extra content can be all the objects allowed in PdfContentByte
|
|
* including pages from other Pdfs. The original PDF will keep
|
|
* all the interactive elements including bookmarks, links and form fields.
|
|
* <p>
|
|
* It is also possible to change the field values and to
|
|
* flatten them. New fields can be added but not flattened.
|
|
* @author Paulo Soares (psoares@consiste.pt)
|
|
*/
|
|
public class PdfStamper : IPdfViewerPreferences, IPdfEncryptionSettings {
|
|
/**
|
|
* The writer
|
|
*/
|
|
protected PdfStamperImp stamper;
|
|
private Hashtable moreInfo;
|
|
private bool hasSignature;
|
|
private PdfSignatureAppearance sigApp;
|
|
|
|
/** Starts the process of adding extra content to an existing PDF
|
|
* document.
|
|
* @param reader the original document. It cannot be reused
|
|
* @param os the output stream
|
|
* @throws DocumentException on error
|
|
* @throws IOException on error
|
|
*/
|
|
public PdfStamper(PdfReader reader, Stream os) {
|
|
stamper = new PdfStamperImp(reader, os, '\0', false);
|
|
}
|
|
|
|
/**
|
|
* Starts the process of adding extra content to an existing PDF
|
|
* document.
|
|
* @param reader the original document. It cannot be reused
|
|
* @param os the output stream
|
|
* @param pdfVersion the new pdf version or '\0' to keep the same version as the original
|
|
* document
|
|
* @throws DocumentException on error
|
|
* @throws IOException on error
|
|
*/
|
|
public PdfStamper(PdfReader reader, Stream os, char pdfVersion) {
|
|
stamper = new PdfStamperImp(reader, os, pdfVersion, false);
|
|
}
|
|
|
|
/**
|
|
* Starts the process of adding extra content to an existing PDF
|
|
* document, possibly as a new revision.
|
|
* @param reader the original document. It cannot be reused
|
|
* @param os the output stream
|
|
* @param pdfVersion the new pdf version or '\0' to keep the same version as the original
|
|
* document
|
|
* @param append if <CODE>true</CODE> appends the document changes as a new revision. This is
|
|
* only useful for multiple signatures as nothing is gained in speed or memory
|
|
* @throws DocumentException on error
|
|
* @throws IOException on error
|
|
*/
|
|
public PdfStamper(PdfReader reader, Stream os, char pdfVersion, bool append) {
|
|
stamper = new PdfStamperImp(reader, os, pdfVersion, append);
|
|
}
|
|
|
|
/** Gets the optional <CODE>String</CODE> map to add or change values in
|
|
* the info dictionary.
|
|
* @return the map or <CODE>null</CODE>
|
|
*
|
|
*/
|
|
/** An optional <CODE>String</CODE> map to add or change values in
|
|
* the info dictionary. Entries with <CODE>null</CODE>
|
|
* values delete the key in the original info dictionary
|
|
* @param moreInfo additional entries to the info dictionary
|
|
*
|
|
*/
|
|
public Hashtable MoreInfo {
|
|
set {
|
|
moreInfo = value;
|
|
}
|
|
get {
|
|
return moreInfo;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Replaces a page from this document with a page from other document. Only the content
|
|
* is replaced not the fields and annotations. This method must be called before
|
|
* getOverContent() or getUndercontent() are called for the same page.
|
|
* @param r the <CODE>PdfReader</CODE> from where the new page will be imported
|
|
* @param pageImported the page number of the imported page
|
|
* @param pageReplaced the page to replace in this document
|
|
*/
|
|
public void ReplacePage(PdfReader r, int pageImported, int pageReplaced) {
|
|
stamper.ReplacePage(r, pageImported, pageReplaced);
|
|
}
|
|
|
|
/**
|
|
* Inserts a blank page. All the pages above and including <CODE>pageNumber</CODE> will
|
|
* be shifted up. If <CODE>pageNumber</CODE> is bigger than the total number of pages
|
|
* the new page will be the last one.
|
|
* @param pageNumber the page number position where the new page will be inserted
|
|
* @param mediabox the size of the new page
|
|
*/
|
|
public void InsertPage(int pageNumber, Rectangle mediabox) {
|
|
stamper.InsertPage(pageNumber, mediabox);
|
|
}
|
|
|
|
/**
|
|
* Gets the signing instance. The appearances and other parameters can the be set.
|
|
* @return the signing instance
|
|
*/
|
|
public PdfSignatureAppearance SignatureAppearance {
|
|
get {
|
|
return sigApp;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Closes the document. No more content can be written after the
|
|
* document is closed.
|
|
* <p>
|
|
* If closing a signed document with an external signature the closing must be done
|
|
* in the <CODE>PdfSignatureAppearance</CODE> instance.
|
|
* @throws DocumentException on error
|
|
* @throws IOException on error
|
|
*/
|
|
public void Close() {
|
|
if (!hasSignature) {
|
|
stamper.Close(moreInfo);
|
|
return;
|
|
}
|
|
sigApp.PreClose();
|
|
PdfSigGenericPKCS sig = sigApp.SigStandard;
|
|
PdfLiteral lit = (PdfLiteral)sig.Get(PdfName.CONTENTS);
|
|
int totalBuf = (lit.PosLength - 2) / 2;
|
|
byte[] buf = new byte[8192];
|
|
int n;
|
|
Stream inp = sigApp.RangeStream;
|
|
while ((n = inp.Read(buf, 0, buf.Length)) > 0) {
|
|
sig.Signer.Update(buf, 0, n);
|
|
}
|
|
buf = new byte[totalBuf];
|
|
byte[] bsig = sig.SignerContents;
|
|
Array.Copy(bsig, 0, buf, 0, bsig.Length);
|
|
PdfString str = new PdfString(buf);
|
|
str.SetHexWriting(true);
|
|
PdfDictionary dic = new PdfDictionary();
|
|
dic.Put(PdfName.CONTENTS, str);
|
|
sigApp.Close(dic);
|
|
stamper.reader.Close();
|
|
}
|
|
|
|
/** Gets a <CODE>PdfContentByte</CODE> to write under the page of
|
|
* the original document.
|
|
* @param pageNum the page number where the extra content is written
|
|
* @return a <CODE>PdfContentByte</CODE> to write under the page of
|
|
* the original document
|
|
*/
|
|
public PdfContentByte GetUnderContent(int pageNum) {
|
|
return stamper.GetUnderContent(pageNum);
|
|
}
|
|
|
|
/** Gets a <CODE>PdfContentByte</CODE> to write over the page of
|
|
* the original document.
|
|
* @param pageNum the page number where the extra content is written
|
|
* @return a <CODE>PdfContentByte</CODE> to write over the page of
|
|
* the original document
|
|
*/
|
|
public PdfContentByte GetOverContent(int pageNum) {
|
|
return stamper.GetOverContent(pageNum);
|
|
}
|
|
|
|
/** Checks if the content is automatically adjusted to compensate
|
|
* the original page rotation.
|
|
* @return the auto-rotation status
|
|
*/
|
|
/** Flags the content to be automatically adjusted to compensate
|
|
* the original page rotation. The default is <CODE>true</CODE>.
|
|
* @param rotateContents <CODE>true</CODE> to set auto-rotation, <CODE>false</CODE>
|
|
* otherwise
|
|
*/
|
|
public bool RotateContents {
|
|
set {
|
|
stamper.RotateContents = value;
|
|
}
|
|
get {
|
|
return stamper.RotateContents;
|
|
}
|
|
}
|
|
|
|
/** Sets the encryption options for this document. The userPassword and the
|
|
* ownerPassword can be null or have zero length. In this case the ownerPassword
|
|
* is replaced by a random string. The open permissions for the document can be
|
|
* AllowPrinting, AllowModifyContents, AllowCopy, AllowModifyAnnotations,
|
|
* AllowFillIn, AllowScreenReaders, AllowAssembly and AllowDegradedPrinting.
|
|
* The permissions can be combined by ORing them.
|
|
* @param userPassword the user password. Can be null or empty
|
|
* @param ownerPassword the owner password. Can be null or empty
|
|
* @param permissions the user permissions
|
|
* @param strength128Bits <code>true</code> for 128 bit key length, <code>false</code> for 40 bit key length
|
|
* @throws DocumentException if anything was already written to the output
|
|
*/
|
|
public void SetEncryption(byte[] userPassword, byte[] ownerPassword, int permissions, bool strength128Bits) {
|
|
if (stamper.append)
|
|
throw new DocumentException("Append mode does not support changing the encryption status.");
|
|
if (stamper.ContentWritten)
|
|
throw new DocumentException("Content was already written to the output.");
|
|
stamper.SetEncryption(userPassword, ownerPassword, permissions, strength128Bits ? PdfWriter.STANDARD_ENCRYPTION_128 : PdfWriter.STANDARD_ENCRYPTION_40);
|
|
}
|
|
|
|
/** Sets the encryption options for this document. The userPassword and the
|
|
* ownerPassword can be null or have zero length. In this case the ownerPassword
|
|
* is replaced by a random string. The open permissions for the document can be
|
|
* AllowPrinting, AllowModifyContents, AllowCopy, AllowModifyAnnotations,
|
|
* AllowFillIn, AllowScreenReaders, AllowAssembly and AllowDegradedPrinting.
|
|
* The permissions can be combined by ORing them.
|
|
* @param userPassword the user password. Can be null or empty
|
|
* @param ownerPassword the owner password. Can be null or empty
|
|
* @param permissions the user permissions
|
|
* @param encryptionType the type of encryption. It can be one of STANDARD_ENCRYPTION_40, STANDARD_ENCRYPTION_128 or ENCRYPTION_AES128.
|
|
* Optionally DO_NOT_ENCRYPT_METADATA can be ored to output the metadata in cleartext
|
|
* @throws DocumentException if the document is already open
|
|
*/
|
|
public void SetEncryption(byte[] userPassword, byte[] ownerPassword, int permissions, int encryptionType) {
|
|
if (stamper.IsAppend())
|
|
throw new DocumentException("Append mode does not support changing the encryption status.");
|
|
if (stamper.ContentWritten)
|
|
throw new DocumentException("Content was already written to the output.");
|
|
stamper.SetEncryption(userPassword, ownerPassword, permissions, encryptionType);
|
|
}
|
|
|
|
/**
|
|
* Sets the encryption options for this document. The userPassword and the
|
|
* ownerPassword can be null or have zero length. In this case the ownerPassword
|
|
* is replaced by a random string. The open permissions for the document can be
|
|
* AllowPrinting, AllowModifyContents, AllowCopy, AllowModifyAnnotations,
|
|
* AllowFillIn, AllowScreenReaders, AllowAssembly and AllowDegradedPrinting.
|
|
* The permissions can be combined by ORing them.
|
|
* @param strength <code>true</code> for 128 bit key length, <code>false</code> for 40 bit key length
|
|
* @param userPassword the user password. Can be null or empty
|
|
* @param ownerPassword the owner password. Can be null or empty
|
|
* @param permissions the user permissions
|
|
* @throws DocumentException if anything was already written to the output
|
|
*/
|
|
public void SetEncryption(bool strength, String userPassword, String ownerPassword, int permissions) {
|
|
SetEncryption(DocWriter.GetISOBytes(userPassword), DocWriter.GetISOBytes(ownerPassword), permissions, strength);
|
|
}
|
|
|
|
/**
|
|
* Sets the encryption options for this document. The userPassword and the
|
|
* ownerPassword can be null or have zero length. In this case the ownerPassword
|
|
* is replaced by a random string. The open permissions for the document can be
|
|
* AllowPrinting, AllowModifyContents, AllowCopy, AllowModifyAnnotations,
|
|
* AllowFillIn, AllowScreenReaders, AllowAssembly and AllowDegradedPrinting.
|
|
* The permissions can be combined by ORing them.
|
|
* @param encryptionType the type of encryption. It can be one of STANDARD_ENCRYPTION_40, STANDARD_ENCRYPTION_128 or ENCRYPTION_AES128.
|
|
* Optionally DO_NOT_ENCRYPT_METADATA can be ored to output the metadata in cleartext
|
|
* @param userPassword the user password. Can be null or empty
|
|
* @param ownerPassword the owner password. Can be null or empty
|
|
* @param permissions the user permissions
|
|
* @throws DocumentException if the document is already open
|
|
*/
|
|
public void SetEncryption(int encryptionType, String userPassword, String ownerPassword, int permissions) {
|
|
SetEncryption(DocWriter.GetISOBytes(userPassword), DocWriter.GetISOBytes(ownerPassword), permissions, encryptionType);
|
|
}
|
|
|
|
/**
|
|
* Sets the certificate encryption options for this document. An array of one or more public certificates
|
|
* must be provided together with an array of the same size for the permissions for each certificate.
|
|
* The open permissions for the document can be
|
|
* AllowPrinting, AllowModifyContents, AllowCopy, AllowModifyAnnotations,
|
|
* AllowFillIn, AllowScreenReaders, AllowAssembly and AllowDegradedPrinting.
|
|
* The permissions can be combined by ORing them.
|
|
* Optionally DO_NOT_ENCRYPT_METADATA can be ored to output the metadata in cleartext
|
|
* @param certs the public certificates to be used for the encryption
|
|
* @param permissions the user permissions for each of the certicates
|
|
* @param encryptionType the type of encryption. It can be one of STANDARD_ENCRYPTION_40, STANDARD_ENCRYPTION_128 or ENCRYPTION_AES128.
|
|
* @throws DocumentException if the encryption was set too late
|
|
*/
|
|
public void SetEncryption(X509Certificate[] certs, int[] permissions, int encryptionType) {
|
|
if (stamper.IsAppend())
|
|
throw new DocumentException("Append mode does not support changing the encryption status.");
|
|
if (stamper.ContentWritten)
|
|
throw new DocumentException("Content was already written to the output.");
|
|
stamper.SetEncryption(certs, permissions, encryptionType);
|
|
}
|
|
|
|
/** Gets a page from other PDF document. Note that calling this method more than
|
|
* once with the same parameters will retrieve the same object.
|
|
* @param reader the PDF document where the page is
|
|
* @param pageNumber the page number. The first page is 1
|
|
* @return the template representing the imported page
|
|
*/
|
|
public PdfImportedPage GetImportedPage(PdfReader reader, int pageNumber) {
|
|
return stamper.GetImportedPage(reader, pageNumber);
|
|
}
|
|
|
|
/** Gets the underlying PdfWriter.
|
|
* @return the underlying PdfWriter
|
|
*/
|
|
public PdfWriter Writer {
|
|
get {
|
|
return stamper;
|
|
}
|
|
}
|
|
|
|
/** Gets the underlying PdfReader.
|
|
* @return the underlying PdfReader
|
|
*/
|
|
public PdfReader Reader {
|
|
get {
|
|
return stamper.reader;
|
|
}
|
|
}
|
|
|
|
/** Gets the <CODE>AcroFields</CODE> object that allows to get and set field values
|
|
* and to merge FDF forms.
|
|
* @return the <CODE>AcroFields</CODE> object
|
|
*/
|
|
public AcroFields AcroFields {
|
|
get {
|
|
return stamper.AcroFields;
|
|
}
|
|
}
|
|
|
|
/** Determines if the fields are flattened on close. The fields added with
|
|
* {@link #addAnnotation(PdfAnnotation,int)} will never be flattened.
|
|
* @param flat <CODE>true</CODE> to flatten the fields, <CODE>false</CODE>
|
|
* to keep the fields
|
|
*/
|
|
public bool FormFlattening {
|
|
set {
|
|
stamper.FormFlattening = value;
|
|
}
|
|
}
|
|
|
|
/** Determines if the FreeText annotations are flattened on close.
|
|
* @param flat <CODE>true</CODE> to flatten the FreeText annotations, <CODE>false</CODE>
|
|
* (the default) to keep the FreeText annotations as active content.
|
|
*/
|
|
public bool FreeTextFlattening {
|
|
set {
|
|
stamper.FreeTextFlattening = value;
|
|
}
|
|
}
|
|
/**
|
|
* Adds an annotation of form field in a specific page. This page number
|
|
* can be overridden with {@link PdfAnnotation#setPlaceInPage(int)}.
|
|
* @param annot the annotation
|
|
* @param page the page
|
|
*/
|
|
public void AddAnnotation(PdfAnnotation annot, int page) {
|
|
stamper.AddAnnotation(annot, page);
|
|
}
|
|
|
|
/**
|
|
* Adds the comments present in an FDF file.
|
|
* @param fdf the FDF file
|
|
* @throws IOException on error
|
|
*/
|
|
public void AddComments(FdfReader fdf) {
|
|
stamper.AddComments(fdf);
|
|
}
|
|
|
|
/**
|
|
* Sets the bookmarks. The list structure is defined in
|
|
* {@link SimpleBookmark}.
|
|
* @param outlines the bookmarks or <CODE>null</CODE> to remove any
|
|
*/
|
|
public ArrayList Outlines {
|
|
set {
|
|
stamper.Outlines = value;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the thumbnail image for a page.
|
|
* @param image the image
|
|
* @param page the page
|
|
* @throws PdfException on error
|
|
* @throws DocumentException on error
|
|
*/
|
|
public void SetThumbnail(Image image, int page) {
|
|
stamper.SetThumbnail(image, page);
|
|
}
|
|
|
|
/**
|
|
* Adds <CODE>name</CODE> to the list of fields that will be flattened on close,
|
|
* all the other fields will remain. If this method is never called or is called
|
|
* with invalid field names, all the fields will be flattened.
|
|
* <p>
|
|
* Calling <CODE>setFormFlattening(true)</CODE> is needed to have any kind of
|
|
* flattening.
|
|
* @param name the field name
|
|
* @return <CODE>true</CODE> if the field exists, <CODE>false</CODE> otherwise
|
|
*/
|
|
public bool PartialFormFlattening(String name) {
|
|
return stamper.PartialFormFlattening(name);
|
|
}
|
|
|
|
/** Adds a JavaScript action at the document level. When the document
|
|
* opens all this JavaScript runs. The existing JavaScript will be replaced.
|
|
* @param js the JavaScript code
|
|
*/
|
|
public string JavaScript {
|
|
set {
|
|
stamper.AddJavaScript(value, !PdfEncodings.IsPdfDocEncoding(value));
|
|
}
|
|
}
|
|
|
|
/** Adds a file attachment at the document level. Existing attachments will be kept.
|
|
* @param description the file description
|
|
* @param fileStore an array with the file. If it's <CODE>null</CODE>
|
|
* the file will be read from the disk
|
|
* @param file the path to the file. It will only be used if
|
|
* <CODE>fileStore</CODE> is not <CODE>null</CODE>
|
|
* @param fileDisplay the actual file name stored in the pdf
|
|
* @throws IOException on error
|
|
*/
|
|
public void AddFileAttachment(String description, byte[] fileStore, String file, String fileDisplay) {
|
|
AddFileAttachment(description, PdfFileSpecification.FileEmbedded(stamper, file, fileDisplay, fileStore));
|
|
}
|
|
|
|
/** Adds a file attachment at the document level. Existing attachments will be kept.
|
|
* @param description the file description
|
|
* @param fs the file specification
|
|
*/
|
|
public void AddFileAttachment(String description, PdfFileSpecification fs) {
|
|
stamper.AddFileAttachment(description, fs);
|
|
}
|
|
|
|
/**
|
|
* This is the most simple way to change a PDF into a
|
|
* portable collection. Choose one of the following names:
|
|
* <ul>
|
|
* <li>PdfName.D (detailed view)
|
|
* <li>PdfName.T (tiled view)
|
|
* <li>PdfName.H (hidden)
|
|
* </ul>
|
|
* Pass this name as a parameter and your PDF will be
|
|
* a portable collection with all the embedded and
|
|
* attached files as entries.
|
|
* @param initialView can be PdfName.D, PdfName.T or PdfName.H
|
|
*/
|
|
public void MakePackage( PdfName initialView ) {
|
|
PdfCollection collection = new PdfCollection(0);
|
|
collection.Put(PdfName.VIEW, initialView);
|
|
stamper.MakePackage( collection );
|
|
}
|
|
|
|
/**
|
|
* Adds or replaces the Collection Dictionary in the Catalog.
|
|
* @param collection the new collection dictionary.
|
|
*/
|
|
public void MakePackage(PdfCollection collection) {
|
|
stamper.MakePackage(collection);
|
|
}
|
|
|
|
/**
|
|
* Sets the viewer preferences.
|
|
* @param preferences the viewer preferences
|
|
* @see PdfViewerPreferences#setViewerPreferences(int)
|
|
*/
|
|
public virtual int ViewerPreferences {
|
|
set {
|
|
stamper.ViewerPreferences = value;
|
|
}
|
|
}
|
|
|
|
/** Adds a viewer preference
|
|
* @param preferences the viewer preferences
|
|
* @see PdfViewerPreferences#addViewerPreference
|
|
*/
|
|
|
|
public virtual void AddViewerPreference(PdfName key, PdfObject value) {
|
|
stamper.AddViewerPreference(key, value);
|
|
}
|
|
|
|
/**
|
|
* Sets the XMP metadata.
|
|
* @param xmp
|
|
* @see PdfWriter#setXmpMetadata(byte[])
|
|
*/
|
|
public byte[] XmpMetadata {
|
|
set {
|
|
stamper.XmpMetadata = value;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the 1.5 compression status.
|
|
* @return <code>true</code> if the 1.5 compression is on
|
|
*/
|
|
public bool FullCompression {
|
|
get {
|
|
return stamper.FullCompression;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the document's compression to the new 1.5 mode with object streams and xref
|
|
* streams. It can be set at any time but once set it can't be unset.
|
|
*/
|
|
public void SetFullCompression() {
|
|
if (stamper.append)
|
|
return;
|
|
stamper.SetFullCompression();
|
|
}
|
|
|
|
/**
|
|
* Sets the open and close page additional action.
|
|
* @param actionType the action type. It can be <CODE>PdfWriter.PAGE_OPEN</CODE>
|
|
* or <CODE>PdfWriter.PAGE_CLOSE</CODE>
|
|
* @param action the action to perform
|
|
* @param page the page where the action will be applied. The first page is 1
|
|
* @throws PdfException if the action type is invalid
|
|
*/
|
|
public void SetPageAction(PdfName actionType, PdfAction action, int page) {
|
|
stamper.SetPageAction(actionType, action, page);
|
|
}
|
|
|
|
/**
|
|
* Sets the display duration for the page (for presentations)
|
|
* @param seconds the number of seconds to display the page. A negative value removes the entry
|
|
* @param page the page where the duration will be applied. The first page is 1
|
|
*/
|
|
public void SetDuration(int seconds, int page) {
|
|
stamper.SetDuration(seconds, page);
|
|
}
|
|
|
|
/**
|
|
* Sets the transition for the page
|
|
* @param transition the transition object. A <code>null</code> removes the transition
|
|
* @param page the page where the transition will be applied. The first page is 1
|
|
*/
|
|
public void SetTransition(PdfTransition transition, int page) {
|
|
stamper.SetTransition(transition, page);
|
|
}
|
|
|
|
/**
|
|
* Applies a digital signature to a document, possibly as a new revision, making
|
|
* possible multiple signatures. The returned PdfStamper
|
|
* can be used normally as the signature is only applied when closing.
|
|
* <p>
|
|
* A possible use for adding a signature without invalidating an existing one is:
|
|
* <p>
|
|
* <pre>
|
|
* KeyStore ks = KeyStore.getInstance("pkcs12");
|
|
* ks.load(new FileInputStream("my_private_key.pfx"), "my_password".toCharArray());
|
|
* String alias = (String)ks.aliases().nextElement();
|
|
* PrivateKey key = (PrivateKey)ks.getKey(alias, "my_password".toCharArray());
|
|
* Certificate[] chain = ks.getCertificateChain(alias);
|
|
* PdfReader reader = new PdfReader("original.pdf");
|
|
* FileOutputStream fout = new FileOutputStream("signed.pdf");
|
|
* PdfStamper stp = PdfStamper.createSignature(reader, fout, '\0', new
|
|
* File("/temp"), true);
|
|
* PdfSignatureAppearance sap = stp.getSignatureAppearance();
|
|
* sap.setCrypto(key, chain, null, PdfSignatureAppearance.WINCER_SIGNED);
|
|
* sap.setReason("I'm the author");
|
|
* sap.setLocation("Lisbon");
|
|
* // comment next line to have an invisible signature
|
|
* sap.setVisibleSignature(new Rectangle(100, 100, 200, 200), 1, null);
|
|
* stp.close();
|
|
* </pre>
|
|
* @param reader the original document
|
|
* @param os the output stream or <CODE>null</CODE> to keep the document in the temporary file
|
|
* @param pdfVersion the new pdf version or '\0' to keep the same version as the original
|
|
* document
|
|
* @param tempFile location of the temporary file. If it's a directory a temporary file will be created there.
|
|
* If it's a file it will be used directly. The file will be deleted on exit unless <CODE>os</CODE> is null.
|
|
* In that case the document can be retrieved directly from the temporary file. If it's <CODE>null</CODE>
|
|
* no temporary file will be created and memory will be used
|
|
* @param append if <CODE>true</CODE> the signature and all the other content will be added as a
|
|
* new revision thus not invalidating existing signatures
|
|
* @return a <CODE>PdfStamper</CODE>
|
|
* @throws DocumentException on error
|
|
* @throws IOException on error
|
|
*/
|
|
public static PdfStamper CreateSignature(PdfReader reader, Stream os, char pdfVersion, string tempFile, bool append) {
|
|
PdfStamper stp;
|
|
if (tempFile == null) {
|
|
ByteBuffer bout = new ByteBuffer();
|
|
stp = new PdfStamper(reader, bout, pdfVersion, append);
|
|
stp.sigApp = new PdfSignatureAppearance(stp.stamper);
|
|
stp.sigApp.Sigout = bout;
|
|
}
|
|
else {
|
|
if (Directory.Exists(tempFile))
|
|
tempFile = Path.GetTempFileName();
|
|
FileStream fout = new FileStream(tempFile, FileMode.Create, FileAccess.Write);
|
|
stp = new PdfStamper(reader, fout, pdfVersion, append);
|
|
stp.sigApp = new PdfSignatureAppearance(stp.stamper);
|
|
stp.sigApp.SetTempFile(tempFile);
|
|
}
|
|
stp.sigApp.Originalout = os;
|
|
stp.sigApp.SetStamper(stp);
|
|
stp.hasSignature = true;
|
|
PdfDictionary catalog = reader.Catalog;
|
|
PdfDictionary acroForm = (PdfDictionary)PdfReader.GetPdfObject(catalog.Get(PdfName.ACROFORM), catalog);
|
|
if (acroForm != null) {
|
|
acroForm.Remove(PdfName.NEEDAPPEARANCES);
|
|
stp.stamper.MarkUsed(acroForm);
|
|
}
|
|
return stp;
|
|
}
|
|
|
|
/**
|
|
* Applies a digital signature to a document. The returned PdfStamper
|
|
* can be used normally as the signature is only applied when closing.
|
|
* <p>
|
|
* Note that the pdf is created in memory.
|
|
* <p>
|
|
* A possible use is:
|
|
* <p>
|
|
* <pre>
|
|
* KeyStore ks = KeyStore.getInstance("pkcs12");
|
|
* ks.load(new FileInputStream("my_private_key.pfx"), "my_password".toCharArray());
|
|
* String alias = (String)ks.aliases().nextElement();
|
|
* PrivateKey key = (PrivateKey)ks.getKey(alias, "my_password".toCharArray());
|
|
* Certificate[] chain = ks.getCertificateChain(alias);
|
|
* PdfReader reader = new PdfReader("original.pdf");
|
|
* FileOutputStream fout = new FileOutputStream("signed.pdf");
|
|
* PdfStamper stp = PdfStamper.createSignature(reader, fout, '\0');
|
|
* PdfSignatureAppearance sap = stp.getSignatureAppearance();
|
|
* sap.setCrypto(key, chain, null, PdfSignatureAppearance.WINCER_SIGNED);
|
|
* sap.setReason("I'm the author");
|
|
* sap.setLocation("Lisbon");
|
|
* // comment next line to have an invisible signature
|
|
* sap.setVisibleSignature(new Rectangle(100, 100, 200, 200), 1, null);
|
|
* stp.close();
|
|
* </pre>
|
|
* @param reader the original document
|
|
* @param os the output stream
|
|
* @param pdfVersion the new pdf version or '\0' to keep the same version as the original
|
|
* document
|
|
* @throws DocumentException on error
|
|
* @throws IOException on error
|
|
* @return a <CODE>PdfStamper</CODE>
|
|
*/
|
|
public static PdfStamper CreateSignature(PdfReader reader, Stream os, char pdfVersion) {
|
|
return CreateSignature(reader, os, pdfVersion, null, false);
|
|
}
|
|
|
|
/**
|
|
* Applies a digital signature to a document. The returned PdfStamper
|
|
* can be used normally as the signature is only applied when closing.
|
|
* <p>
|
|
* A possible use is:
|
|
* <p>
|
|
* <pre>
|
|
* KeyStore ks = KeyStore.getInstance("pkcs12");
|
|
* ks.load(new FileInputStream("my_private_key.pfx"), "my_password".toCharArray());
|
|
* String alias = (String)ks.aliases().nextElement();
|
|
* PrivateKey key = (PrivateKey)ks.getKey(alias, "my_password".toCharArray());
|
|
* Certificate[] chain = ks.getCertificateChain(alias);
|
|
* PdfReader reader = new PdfReader("original.pdf");
|
|
* FileOutputStream fout = new FileOutputStream("signed.pdf");
|
|
* PdfStamper stp = PdfStamper.createSignature(reader, fout, '\0', new File("/temp"));
|
|
* PdfSignatureAppearance sap = stp.getSignatureAppearance();
|
|
* sap.setCrypto(key, chain, null, PdfSignatureAppearance.WINCER_SIGNED);
|
|
* sap.setReason("I'm the author");
|
|
* sap.setLocation("Lisbon");
|
|
* // comment next line to have an invisible signature
|
|
* sap.setVisibleSignature(new Rectangle(100, 100, 200, 200), 1, null);
|
|
* stp.close();
|
|
* </pre>
|
|
* @param reader the original document
|
|
* @param os the output stream or <CODE>null</CODE> to keep the document in the temporary file
|
|
* @param pdfVersion the new pdf version or '\0' to keep the same version as the original
|
|
* document
|
|
* @param tempFile location of the temporary file. If it's a directory a temporary file will be created there.
|
|
* If it's a file it will be used directly. The file will be deleted on exit unless <CODE>os</CODE> is null.
|
|
* In that case the document can be retrieved directly from the temporary file. If it's <CODE>null</CODE>
|
|
* no temporary file will be created and memory will be used
|
|
* @return a <CODE>PdfStamper</CODE>
|
|
* @throws DocumentException on error
|
|
* @throws IOException on error
|
|
*/
|
|
public static PdfStamper CreateSignature(PdfReader reader, Stream os, char pdfVersion, string tempFile) {
|
|
return CreateSignature(reader, os, pdfVersion, tempFile, false);
|
|
}
|
|
|
|
/**
|
|
* Gets the PdfLayer objects in an existing document as a Map
|
|
* with the names/titles of the layers as keys.
|
|
* @return a Map with all the PdfLayers in the document (and the name/title of the layer as key)
|
|
* @since 2.1.2
|
|
*/
|
|
public Hashtable GetPdfLayers() {
|
|
return stamper.GetPdfLayers();
|
|
}
|
|
}
|
|
}
|