Open Door - Reporting, Charts, Enquiry Drill-Downs

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;
            }
        }
        
        /**
        * 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);
        }
    }
}