iText 5 itextpdf.jar Source Code
itextpdf.jar is a component in iText 5 Java library to provide core functionalities.
iText Java library allows you to generate and manage PDF documents.
The Source Code files are provided at iText GitHub site.
You can compile it to generate your JAR file, using pom.xml as the build configuration file.
The source code of itextpdf-5.5.14.jar is provided below:
✍: FYIcenter.com
⏎ com/itextpdf/text/pdf/PdfCopy.java
/*
*
* This file is part of the iText (R) project.
Copyright (c) 1998-2020 iText Group NV
* Authors: Bruno Lowagie, Paulo Soares, et al.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License version 3
* as published by the Free Software Foundation with the addition of the
* following permission added to Section 15 as permitted in Section 7(a):
* FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
* ITEXT GROUP. ITEXT GROUP DISCLAIMS THE WARRANTY OF NON INFRINGEMENT
* OF THIRD PARTY RIGHTS
*
* This program 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 Affero General Public License for more details.
* You should have received a copy of the GNU Affero General Public License
* along with this program; if not, see http://www.gnu.org/licenses or write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA, 02110-1301 USA, or download the license from the following URL:
* http://itextpdf.com/terms-of-use/
*
* The interactive user interfaces in modified source and object code versions
* of this program must display Appropriate Legal Notices, as required under
* Section 5 of the GNU Affero General Public License.
*
* In accordance with Section 7(b) of the GNU Affero General Public License,
* a covered work must retain the producer line in every PDF that is created
* or manipulated using iText.
*
* You can be released from the requirements of the license by purchasing
* a commercial license. Buying such a license is mandatory as soon as you
* develop commercial activities involving the iText software without
* disclosing the source code of your own applications.
* These activities include: offering paid services to customers as an ASP,
* serving PDFs on the fly in a web application, shipping iText with a closed
* source product.
*
* For more information, please contact iText Software Corp. at this
* address: sales@itextpdf.com
*/
package com.itextpdf.text.pdf;
import com.itextpdf.text.Document;
import com.itextpdf.text.DocumentException;
import com.itextpdf.text.ExceptionConverter;
import com.itextpdf.text.Rectangle;
import com.itextpdf.text.error_messages.MessageLocalization;
import com.itextpdf.text.exceptions.BadPasswordException;
import com.itextpdf.text.log.Counter;
import com.itextpdf.text.log.CounterFactory;
import com.itextpdf.text.log.Logger;
import com.itextpdf.text.log.LoggerFactory;
import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
/**
* Make copies of PDF documents. Documents can be edited after reading and
* before writing them out.
* @author Mark Thompson
*/
public class PdfCopy extends PdfWriter {
private static final Logger LOGGER = LoggerFactory.getLogger(PdfCopy.class);
/**
* This class holds information about indirect references, since they are
* renumbered by iText.
*/
static class IndirectReferences {
PdfIndirectReference theRef;
boolean hasCopied;
IndirectReferences(PdfIndirectReference ref) {
theRef = ref;
hasCopied = false;
}
void setCopied() { hasCopied = true; }
void setNotCopied() { hasCopied = false; }
boolean getCopied() { return hasCopied; }
PdfIndirectReference getRef() { return theRef; }
@Override
public String toString() {
String ext = "";
if (hasCopied) ext += " Copied";
return getRef() + ext;
}
}
protected static Counter COUNTER = CounterFactory.getCounter(PdfCopy.class);
protected Counter getCounter() {
return COUNTER;
}
protected HashMap<RefKey, IndirectReferences> indirects;
protected HashMap<PdfReader, HashMap<RefKey, IndirectReferences>> indirectMap;
protected HashMap<PdfObject, PdfObject> parentObjects;
protected HashSet<PdfObject> disableIndirects;
protected PdfReader reader;
protected int[] namePtr = {0};
/** Holds value of property rotateContents. */
private boolean rotateContents = true;
protected PdfArray fieldArray;
protected HashSet<PdfTemplate> fieldTemplates;
private PdfStructTreeController structTreeController = null;
private int currentStructArrayNumber = 0;
//remember to avoid coping
protected PRIndirectReference structTreeRootReference;
//to remove unused objects
protected LinkedHashMap<RefKey, PdfIndirectObject> indirectObjects;
//PdfIndirectObjects, that generate PdfWriter.addToBody(PdfObject) method, already saved to PdfBody
protected ArrayList<PdfIndirectObject> savedObjects;
//imported pages from getImportedPage(PdfReader, int, boolean)
protected ArrayList<ImportedPage> importedPages;
//for correct update of kids in StructTreeRootController
protected boolean updateRootKids = false;
static private final PdfName annotId = new PdfName("iTextAnnotId");
static private int annotIdCnt = 0;
protected boolean mergeFields = false;
private boolean needAppearances = false;
private boolean hasSignature;
private PdfIndirectReference acroForm;
private HashMap<PdfArray, ArrayList<Integer>> tabOrder;
private ArrayList<Object> calculationOrderRefs;
private PdfDictionary resources;
protected ArrayList<AcroFields> fields;
private ArrayList<String> calculationOrder;
private HashMap<String, Object> fieldTree;
private HashMap<Integer, PdfIndirectObject> unmergedMap;
private HashMap<RefKey, PdfIndirectObject> unmergedIndirectRefsMap;
private HashMap<Integer, PdfIndirectObject> mergedMap;
private HashSet<PdfIndirectObject> mergedSet;
private boolean mergeFieldsInternalCall = false;
private static final PdfName iTextTag = new PdfName("_iTextTag_");
private static final Integer zero = Integer.valueOf(0);
private HashSet<Object> mergedRadioButtons = new HashSet<Object>();
private HashMap<Object, PdfString> mergedTextFields = new HashMap<Object, PdfString>();
private HashSet<PdfReader> readersWithImportedStructureTreeRootKids = new HashSet<PdfReader>();
protected static class ImportedPage {
int pageNumber;
PdfReader reader;
PdfArray mergedFields;
PdfIndirectReference annotsIndirectReference;
ImportedPage(PdfReader reader, int pageNumber, boolean keepFields) {
this.pageNumber = pageNumber;
this.reader = reader;
if (keepFields) {
mergedFields = new PdfArray();
}
}
@Override
public boolean equals(Object o) {
if (!(o instanceof ImportedPage)) return false;
ImportedPage other = (ImportedPage)o;
return this.pageNumber == other.pageNumber && this.reader.equals(other.reader);
}
@Override
public String toString() {
return Integer.toString(pageNumber);
}
}
/**
* Constructor
* @param document document
* @param os outputstream
*/
public PdfCopy(Document document, OutputStream os) throws DocumentException {
super(new PdfDocument(), os);
document.addDocListener(pdf);
pdf.addWriter(this);
indirectMap = new HashMap<PdfReader, HashMap<RefKey, IndirectReferences>>();
parentObjects = new HashMap<PdfObject, PdfObject>();
disableIndirects = new HashSet<PdfObject>();
indirectObjects = new LinkedHashMap<RefKey, PdfIndirectObject>();
savedObjects = new ArrayList<PdfIndirectObject>();
importedPages = new ArrayList<ImportedPage>();
}
/**
* Setting page events isn't possible with Pdf(Smart)Copy.
* Use the PageStamp class if you want to add content to copied pages.
* @see com.itextpdf.text.pdf.PdfWriter#setPageEvent(com.itextpdf.text.pdf.PdfPageEvent)
*/
@Override
public void setPageEvent(PdfPageEvent event) {
throw new UnsupportedOperationException();
}
/** Getter for property rotateContents.
* @return Value of property rotateContents.
*
*/
public boolean isRotateContents() {
return this.rotateContents;
}
/** Setter for property rotateContents.
* @param rotateContents New value of property rotateContents.
*
*/
public void setRotateContents(boolean rotateContents) {
this.rotateContents = rotateContents;
}
public void setMergeFields() {
this.mergeFields = true;
resources = new PdfDictionary();
fields = new ArrayList<AcroFields>();
calculationOrder = new ArrayList<String>();
fieldTree = new LinkedHashMap<String, Object>();
unmergedMap = new HashMap<Integer, PdfIndirectObject>();
unmergedIndirectRefsMap = new HashMap<RefKey, PdfIndirectObject>();
mergedMap = new HashMap<Integer, PdfIndirectObject>();
mergedSet = new HashSet<PdfIndirectObject>();
}
/**
* Grabs a page from the input document
* @param reader the reader of the document
* @param pageNumber which page to get
* @return the page
*/
@Override
public PdfImportedPage getImportedPage(PdfReader reader, int pageNumber) {
if (mergeFields && !mergeFieldsInternalCall) {
throw new IllegalArgumentException(MessageLocalization.getComposedMessage("1.method.cannot.be.used.in.mergeFields.mode.please.use.addDocument", "getImportedPage"));
}
if (mergeFields) {
ImportedPage newPage = new ImportedPage(reader, pageNumber, mergeFields);
importedPages.add(newPage);
}
if (structTreeController != null)
structTreeController.reader = null;
disableIndirects.clear();
parentObjects.clear();
return getImportedPageImpl(reader, pageNumber);
}
public PdfImportedPage getImportedPage(PdfReader reader, int pageNumber, boolean keepTaggedPdfStructure) throws BadPdfFormatException {
if (mergeFields && !mergeFieldsInternalCall) {
throw new IllegalArgumentException(MessageLocalization.getComposedMessage("1.method.cannot.be.used.in.mergeFields.mode.please.use.addDocument", "getImportedPage"));
}
updateRootKids = false;
if (!keepTaggedPdfStructure) {
if (mergeFields) {
ImportedPage newPage = new ImportedPage(reader, pageNumber, mergeFields);
importedPages.add(newPage);
}
return getImportedPageImpl(reader, pageNumber);
}
if (structTreeController != null) {
if (reader != structTreeController.reader)
structTreeController.setReader(reader);
} else {
structTreeController = new PdfStructTreeController(reader, this);
}
ImportedPage newPage = new ImportedPage(reader, pageNumber, mergeFields);
switch (checkStructureTreeRootKids(newPage)) {
case -1: //-1 - clear , update
clearIndirects(reader);
updateRootKids = true;
break;
case 0: //0 - not clear, not update
updateRootKids = false;
break;
case 1: //1 - not clear, update
updateRootKids = true;
break;
}
importedPages.add(newPage);
disableIndirects.clear();
parentObjects.clear();
return getImportedPageImpl(reader, pageNumber);
}
private void clearIndirects(PdfReader reader) {
HashMap<RefKey, IndirectReferences> currIndirects = indirectMap.get(reader);
ArrayList<RefKey> forDelete = new ArrayList<RefKey>();
for (Map.Entry<RefKey, IndirectReferences> entry: currIndirects.entrySet()) {
PdfIndirectReference iRef = entry.getValue().theRef;
RefKey key = new RefKey(iRef);
PdfIndirectObject iobj = indirectObjects.get(key);
if (iobj == null) {
forDelete.add(entry.getKey());
}
else if (iobj.object.isArray() || iobj.object.isDictionary() || iobj.object.isStream()) {
forDelete.add(entry.getKey());
}
}
for (RefKey key: forDelete)
currIndirects.remove(key);
}
//0 - not clear, not update
//-1 - clear , update
//1 - not clear, update
private int checkStructureTreeRootKids(ImportedPage newPage) {
//start of document;
if (importedPages.size() == 0) return 1;
boolean readerExist = false;
for (ImportedPage page: importedPages) {
if (page.reader.equals(newPage.reader)) {
readerExist = true;
break;
}
}
//add new reader;
if (!readerExist) return 1;
ImportedPage lastPage = importedPages.get(importedPages.size() - 1);
boolean equalReader = lastPage.reader.equals(newPage.reader);
//reader exist, correct order;
if (equalReader && newPage.pageNumber > lastPage.pageNumber) {
if (readersWithImportedStructureTreeRootKids.contains(newPage.reader))
return 0;
else
return 1;
}
//reader exist, incorrect order;
return -1;
}
protected void structureTreeRootKidsForReaderImported(PdfReader reader) {
readersWithImportedStructureTreeRootKids.add(reader);
}
protected void fixStructureTreeRoot(HashSet<RefKey> activeKeys, HashSet<PdfName> activeClassMaps) {
HashMap<PdfName, PdfObject> newClassMap = new HashMap<PdfName, PdfObject>(activeClassMaps.size());
for (PdfName key: activeClassMaps) {
PdfObject cm = structureTreeRoot.classes.get(key);
if (cm != null) newClassMap.put(key, cm);
}
structureTreeRoot.classes = newClassMap;
PdfArray kids = structureTreeRoot.getAsArray(PdfName.K);
if (kids != null) {
for (int i = 0; i < kids.size(); ++i) {
PdfIndirectReference iref = (PdfIndirectReference)kids.getPdfObject(i);
RefKey key = new RefKey(iref);
if (!activeKeys.contains(key)) kids.remove(i--);
}
}
}
protected PdfImportedPage getImportedPageImpl(PdfReader reader, int pageNumber) {
if (currentPdfReaderInstance != null) {
if (currentPdfReaderInstance.getReader() != reader) {
// TODO: Removed - the user should be responsible for closing all PdfReaders. But, this could cause a lot of memory leaks in code out there that hasn't been properly closing things - maybe add a finalizer to PdfReader that calls PdfReader#close() ??
// try {
// currentPdfReaderInstance.getReader().close();
// currentPdfReaderInstance.getReaderFile().close();
// }
// catch (IOException ioe) {
// // empty on purpose
// }
currentPdfReaderInstance = super.getPdfReaderInstance(reader);
}
}
else {
currentPdfReaderInstance = super.getPdfReaderInstance(reader);
}
//currentPdfReaderInstance.setOutputToPdf(false);
return currentPdfReaderInstance.getImportedPage(pageNumber);
}
/**
* Translate a PRIndirectReference to a PdfIndirectReference
* In addition, translates the object numbers, and copies the
* referenced object to the output file.
* NB: PRIndirectReferences (and PRIndirectObjects) really need to know what
* file they came from, because each file has its own namespace. The translation
* we do from their namespace to ours is *at best* heuristic, and guaranteed to
* fail under some circumstances.
*/
protected PdfIndirectReference copyIndirect(PRIndirectReference in, boolean keepStructure, boolean directRootKids) throws IOException, BadPdfFormatException {
PdfIndirectReference theRef;
RefKey key = new RefKey(in);
IndirectReferences iRef = indirects.get(key);
PdfObject obj = PdfReader.getPdfObjectRelease(in);
if ((keepStructure) && (directRootKids))
if (obj instanceof PdfDictionary) {
PdfDictionary dict = (PdfDictionary) obj;
if (dict.contains(PdfName.PG))
return null;
}
if (iRef != null) {
theRef = iRef.getRef();
if (iRef.getCopied()) {
return theRef;
}
}
else {
theRef = body.getPdfIndirectReference();
iRef = new IndirectReferences(theRef);
indirects.put(key, iRef);
}
if (obj != null && obj.isDictionary()) {
PdfObject type = PdfReader.getPdfObjectRelease(((PdfDictionary)obj).get(PdfName.TYPE));
if (type != null) {
if ((PdfName.PAGE.equals(type))) {
return theRef;
}
if ((PdfName.CATALOG.equals(type))) {
LOGGER.warn(MessageLocalization.getComposedMessage("make.copy.of.catalog.dictionary.is.forbidden"));
return null;
}
}
}
iRef.setCopied();
if (obj != null) parentObjects.put(obj, in);
PdfObject res = copyObject(obj, keepStructure, directRootKids);
if (disableIndirects.contains(obj))
iRef.setNotCopied();
if (res != null)
{
addToBody(res, theRef);
return theRef;
}
else {
indirects.remove(key);
return null;
}
}
/**
* Translate a PRIndirectReference to a PdfIndirectReference
* In addition, translates the object numbers, and copies the
* referenced object to the output file.
* NB: PRIndirectReferences (and PRIndirectObjects) really need to know what
* file they came from, because each file has its own namespace. The translation
* we do from their namespace to ours is *at best* heuristic, and guaranteed to
* fail under some circumstances.
*/
protected PdfIndirectReference copyIndirect(PRIndirectReference in) throws IOException, BadPdfFormatException {
return copyIndirect(in, false, false);
}
/**
* Translate a PRDictionary to a PdfDictionary. Also translate all of the
* objects contained in it.
*/
protected PdfDictionary copyDictionary(PdfDictionary in, boolean keepStruct, boolean directRootKids)
throws IOException, BadPdfFormatException {
PdfDictionary out = new PdfDictionary(in.size());
PdfObject type = PdfReader.getPdfObjectRelease(in.get(PdfName.TYPE));
if (keepStruct)
{
if ((directRootKids) && (in.contains(PdfName.PG)))
{
PdfObject curr = in;
disableIndirects.add(curr);
while (parentObjects.containsKey(curr) && !(disableIndirects.contains(curr))) {
curr = parentObjects.get(curr);
disableIndirects.add(curr);
}
return null;
}
PdfName structType = in.getAsName(PdfName.S);
structTreeController.addRole(structType);
structTreeController.addClass(in);
}
if (structTreeController != null && structTreeController.reader != null && (in.contains(PdfName.STRUCTPARENTS) || in.contains(PdfName.STRUCTPARENT))) {
PdfName key = PdfName.STRUCTPARENT;
if (in.contains(PdfName.STRUCTPARENTS)) {
key = PdfName.STRUCTPARENTS;
}
PdfObject value = in.get(key);
out.put(key, new PdfNumber(currentStructArrayNumber));
structTreeController.copyStructTreeForPage((PdfNumber) value, currentStructArrayNumber++);
}
for (Object element : in.getKeys()) {
PdfName key = (PdfName)element;
PdfObject value = in.get(key);
if (structTreeController != null && structTreeController.reader != null && (key.equals(PdfName.STRUCTPARENTS) || key.equals(PdfName.STRUCTPARENT))) {
continue;
}
if (PdfName.PAGE.equals(type)) {
if (!key.equals(PdfName.B) && !key.equals(PdfName.PARENT)) {
parentObjects.put(value, in);
PdfObject res = copyObject(value, keepStruct, directRootKids);
if (res != null)
out.put(key, res);
}
}
else {
PdfObject res;
if (tagged && value.isIndirect() && isStructTreeRootReference((PRIndirectReference)value)) {
res = structureTreeRoot.getReference();
} else {
res = copyObject(value, keepStruct, directRootKids);
}
if (res != null)
out.put(key, res);
}
}
return out;
}
/**
* Translate a PRDictionary to a PdfDictionary. Also translate all of the
* objects contained in it.
*/
protected PdfDictionary copyDictionary(PdfDictionary in)
throws IOException, BadPdfFormatException {
return copyDictionary(in, false, false);
}
/**
* Translate a PRStream to a PdfStream. The data part copies itself.
*/
protected PdfStream copyStream(PRStream in) throws IOException, BadPdfFormatException {
PRStream out = new PRStream(in, null);
for (Object element : in.getKeys()) {
PdfName key = (PdfName) element;
PdfObject value = in.get(key);
parentObjects.put(value, in);
PdfObject res = copyObject(value);
if (res != null)
out.put(key, res);
}
return out;
}
/**
* Translate a PRArray to a PdfArray. Also translate all of the objects contained
* in it
*/
protected PdfArray copyArray(PdfArray in, boolean keepStruct, boolean directRootKids) throws IOException, BadPdfFormatException {
PdfArray out = new PdfArray(in.size());
for (Iterator<PdfObject> i = in.listIterator(); i.hasNext();) {
PdfObject value = i.next();
parentObjects.put(value, in);
PdfObject res = copyObject(value, keepStruct, directRootKids);
if (res != null)
out.add(res);
}
return out;
}
/**
* Translate a PRArray to a PdfArray. Also translate all of the objects contained
* in it
*/
protected PdfArray copyArray(PdfArray in) throws IOException, BadPdfFormatException {
return copyArray(in, false, false);
}
/**
* Translate a PR-object to a Pdf-object
*/
protected PdfObject copyObject(PdfObject in, boolean keepStruct, boolean directRootKids) throws IOException,BadPdfFormatException {
if (in == null)
return PdfNull.PDFNULL;
switch (in.type) {
case PdfObject.DICTIONARY:
return copyDictionary((PdfDictionary)in, keepStruct, directRootKids);
case PdfObject.INDIRECT:
if (!keepStruct && !directRootKids)
// fix for PdfSmartCopy
return copyIndirect((PRIndirectReference)in);
else
return copyIndirect((PRIndirectReference)in, keepStruct, directRootKids);
case PdfObject.ARRAY:
return copyArray((PdfArray)in, keepStruct, directRootKids);
case PdfObject.NUMBER:
case PdfObject.NAME:
case PdfObject.STRING:
case PdfObject.NULL:
case PdfObject.BOOLEAN:
case 0://PdfIndirectReference
return in;
case PdfObject.STREAM:
return copyStream((PRStream)in);
// return in;
default:
if (in.type < 0) {
String lit = ((PdfLiteral)in).toString();
if (lit.equals("true") || lit.equals("false")) {
return new PdfBoolean(lit);
}
return new PdfLiteral(lit);
}
System.out.println("CANNOT COPY type " + in.type);
return null;
}
}
/**
* Translate a PR-object to a Pdf-object
*/
protected PdfObject copyObject(PdfObject in) throws IOException,BadPdfFormatException {
return copyObject(in, false, false);
}
/**
* convenience method. Given an imported page, set our "globals"
*/
protected int setFromIPage(PdfImportedPage iPage) {
int pageNum = iPage.getPageNumber();
PdfReaderInstance inst = currentPdfReaderInstance = iPage.getPdfReaderInstance();
reader = inst.getReader();
setFromReader(reader);
return pageNum;
}
/**
* convenience method. Given a reader, set our "globals"
*/
protected void setFromReader(PdfReader reader) {
this.reader = reader;
indirects = indirectMap.get(reader);
if (indirects == null) {
indirects = new HashMap<RefKey, IndirectReferences>();
indirectMap.put(reader,indirects);
}
}
/**
* Add an imported page to our output
* @param iPage an imported page
* @throws IOException, BadPdfFormatException
*/
public void addPage(PdfImportedPage iPage) throws IOException, BadPdfFormatException {
if (mergeFields && !mergeFieldsInternalCall) {
throw new IllegalArgumentException(MessageLocalization.getComposedMessage("1.method.cannot.be.used.in.mergeFields.mode.please.use.addDocument", "addPage"));
}
int pageNum = setFromIPage(iPage);
PdfDictionary thePage = reader.getPageN(pageNum);
PRIndirectReference origRef = reader.getPageOrigRef(pageNum);
reader.releasePage(pageNum);
RefKey key = new RefKey(origRef);
PdfIndirectReference pageRef;
IndirectReferences iRef = indirects.get(key);
if (iRef != null && !iRef.getCopied()) {
pageReferences.add(iRef.getRef());
iRef.setCopied();
}
pageRef = getCurrentPage();
if (iRef == null) {
iRef = new IndirectReferences(pageRef);
indirects.put(key, iRef);
}
iRef.setCopied();
if (tagged)
structTreeRootReference = (PRIndirectReference)reader.getCatalog().get(PdfName.STRUCTTREEROOT);
PdfDictionary newPage = copyDictionary(thePage);
if (mergeFields) {
ImportedPage importedPage = importedPages.get(importedPages.size() - 1);
importedPage.annotsIndirectReference = body.getPdfIndirectReference();
newPage.put(PdfName.ANNOTS, importedPage.annotsIndirectReference);
}
root.addPage(newPage);
iPage.setCopied();
++currentPageNumber;
pdf.setPageCount(currentPageNumber);
structTreeRootReference = null;
}
/**
* Adds a blank page.
* @param rect The page dimension
* @param rotation The rotation angle in degrees
* @throws DocumentException
* @since 2.1.5
*/
public void addPage(Rectangle rect, int rotation) throws DocumentException {
if (mergeFields && !mergeFieldsInternalCall) {
throw new IllegalArgumentException(MessageLocalization.getComposedMessage("1.method.cannot.be.used.in.mergeFields.mode.please.use.addDocument", "addPage"));
}
PdfRectangle mediabox = new PdfRectangle(rect, rotation);
PageResources resources = new PageResources();
PdfPage page = new PdfPage(mediabox, new HashMap<String, PdfRectangle>(), resources.getResources(), 0);
page.put(PdfName.TABS, getTabs());
root.addPage(page);
++currentPageNumber;
pdf.setPageCount(currentPageNumber);
}
public void addDocument(PdfReader reader, List<Integer> pagesToKeep) throws DocumentException, IOException {
if (indirectMap.containsKey(reader)) {
throw new IllegalArgumentException(MessageLocalization.getComposedMessage("document.1.has.already.been.added", reader.toString()));
}
reader.selectPages(pagesToKeep, false);
addDocument(reader);
}
/**
* Copy document fields to a destination document.
* @param reader a document where fields are copied from.
* @throws DocumentException
* @throws IOException
*/
public void copyDocumentFields(PdfReader reader) throws DocumentException, IOException {
if (!document.isOpen()) {
throw new DocumentException(MessageLocalization.getComposedMessage("the.document.is.not.open.yet.you.can.only.add.meta.information"));
}
if (indirectMap.containsKey(reader)) {
throw new IllegalArgumentException(MessageLocalization.getComposedMessage("document.1.has.already.been.added", reader.toString()));
}
if (!reader.isOpenedWithFullPermissions())
throw new BadPasswordException(MessageLocalization.getComposedMessage("pdfreader.not.opened.with.owner.password"));
if (!mergeFields)
throw new IllegalArgumentException(MessageLocalization.getComposedMessage("1.method.can.be.only.used.in.mergeFields.mode.please.use.addDocument", "copyDocumentFields"));
indirects = new HashMap<RefKey, IndirectReferences>();
indirectMap.put(reader, indirects);
reader.consolidateNamedDestinations();
reader.shuffleSubsetNames();
if (tagged && PdfStructTreeController.checkTagged(reader)) {
structTreeRootReference = (PRIndirectReference)reader.getCatalog().get(PdfName.STRUCTTREEROOT);
if (structTreeController != null) {
if (reader != structTreeController.reader)
structTreeController.setReader(reader);
} else {
structTreeController = new PdfStructTreeController(reader, this);
}
}
List<PdfObject> annotationsToBeCopied = new ArrayList<PdfObject>();
for (int i = 1; i <= reader.getNumberOfPages(); i++) {
PdfDictionary page = reader.getPageNRelease(i);
if (page != null && page.contains(PdfName.ANNOTS)) {
PdfArray annots = page.getAsArray(PdfName.ANNOTS);
if (annots != null && annots.size() > 0) {
if (importedPages.size() < i)
throw new DocumentException(MessageLocalization.getComposedMessage("there.are.not.enough.imported.pages.for.copied.fields"));
indirectMap.get(reader).put(new RefKey(reader.pageRefs.getPageOrigRef(i)), new IndirectReferences(pageReferences.get(i - 1)));
for (int j = 0; j < annots.size(); j++) {
PdfDictionary annot = annots.getAsDict(j);
if (annot != null) {
annot.put(annotId, new PdfNumber(++annotIdCnt));
annotationsToBeCopied.add(annots.getPdfObject(j));
}
}
}
}
}
for (PdfObject annot : annotationsToBeCopied) {
copyObject(annot);
}
if (tagged && structTreeController != null)
structTreeController.attachStructTreeRootKids(null);
AcroFields acro = reader.getAcroFields();
boolean needapp = !acro.isGenerateAppearances();
if (needapp)
needAppearances = true;
fields.add(acro);
updateCalculationOrder(reader);
structTreeRootReference = null;
}
public void addDocument(PdfReader reader) throws DocumentException, IOException {
if ( ! document.isOpen() ) {
throw new DocumentException(MessageLocalization.getComposedMessage("the.document.is.not.open.yet.you.can.only.add.meta.information"));
}
if (indirectMap.containsKey(reader)) {
throw new IllegalArgumentException(MessageLocalization.getComposedMessage("document.1.has.already.been.added", reader.toString()));
}
if (!reader.isOpenedWithFullPermissions())
throw new BadPasswordException(MessageLocalization.getComposedMessage("pdfreader.not.opened.with.owner.password"));
if (mergeFields) {
reader.consolidateNamedDestinations();
reader.shuffleSubsetNames();
for (int i = 1; i <= reader.getNumberOfPages(); i++) {
PdfDictionary page = reader.getPageNRelease(i);
if (page != null && page.contains(PdfName.ANNOTS)) {
PdfArray annots = page.getAsArray(PdfName.ANNOTS);
if (annots != null) {
for (int j = 0; j < annots.size(); j++) {
PdfDictionary annot = annots.getAsDict(j);
if (annot != null)
annot.put(annotId, new PdfNumber(++annotIdCnt));
}
}
}
}
AcroFields acro = reader.getAcroFields();
// when a document with NeedAppearances is encountered, the flag is set
// in the resulting document.
boolean needapp = !acro.isGenerateAppearances();
if (needapp)
needAppearances = true;
fields.add(acro);
updateCalculationOrder(reader);
}
boolean tagged = this.tagged && PdfStructTreeController.checkTagged(reader);
mergeFieldsInternalCall = true;
for (int i = 1; i <= reader.getNumberOfPages(); i++) {
addPage(getImportedPage(reader, i, tagged));
}
mergeFieldsInternalCall = false;
}
@Override
public PdfIndirectObject addToBody(final PdfObject object, final PdfIndirectReference ref) throws IOException {
return this.addToBody(object, ref, false);
}
@Override
public PdfIndirectObject addToBody(final PdfObject object, final PdfIndirectReference ref, boolean formBranching) throws IOException {
if (formBranching) {
updateReferences(object);
}
PdfIndirectObject iobj;
if ((tagged || mergeFields) && indirectObjects != null && (object.isArray() || object.isDictionary() || object.isStream() || object.isNull())) {
RefKey key = new RefKey(ref);
PdfIndirectObject obj = indirectObjects.get(key);
if (obj == null) {
obj = new PdfIndirectObject(ref, object, this);
indirectObjects.put(key, obj);
}
iobj = obj;
} else {
iobj = super.addToBody(object, ref);
}
if (mergeFields && object.isDictionary()) {
PdfNumber annotId = ((PdfDictionary)object).getAsNumber(PdfCopy.annotId);
if (annotId != null) {
if (formBranching) {
mergedMap.put(annotId.intValue(), iobj);
mergedSet.add(iobj);
} else {
unmergedMap.put(annotId.intValue(), iobj);
unmergedIndirectRefsMap.put(new RefKey(iobj.number, iobj.generation), iobj);
}
}
}
return iobj;
}
@Override
protected void cacheObject(PdfIndirectObject iobj) {
if ((tagged || mergeFields) && indirectObjects != null) {
savedObjects.add(iobj);
RefKey key = new RefKey(iobj.number, iobj.generation);
if (!indirectObjects.containsKey(key)) indirectObjects.put(key, iobj);
}
}
@Override
protected void flushTaggedObjects() throws IOException {
try {
fixTaggedStructure();
} catch (ClassCastException ex) {
} finally {flushIndirectObjects();}
}
@Override
protected void flushAcroFields() throws IOException, BadPdfFormatException {
if (mergeFields) {
try {
//save annotations that appear just at page level (comments, popups)
for (ImportedPage page : importedPages) {
PdfDictionary pageDict = page.reader.getPageN(page.pageNumber);
if (pageDict != null) {
PdfArray pageFields = pageDict.getAsArray(PdfName.ANNOTS);
if (pageFields == null || pageFields.size() == 0)
continue;
for (AcroFields.Item items: page.reader.getAcroFields().getFields().values()) {
for(PdfIndirectReference ref: items.widget_refs) {
pageFields.arrayList.remove(ref);
}
}
indirects = indirectMap.get(page.reader);
for (PdfObject ref: pageFields.arrayList)
page.mergedFields.add(copyObject(ref));
}
}
//ok, remove old fields and build create new one
for (PdfReader reader : indirectMap.keySet()) {
reader.removeFields();
}
mergeFields();
createAcroForms();
} catch (ClassCastException ex) {
} finally {
if (!tagged)
flushIndirectObjects();
}
}
}
protected void fixTaggedStructure() throws IOException {
HashMap<Integer, PdfIndirectReference> numTree = structureTreeRoot.getNumTree();
HashSet<RefKey> activeKeys = new HashSet<RefKey>();
ArrayList<PdfIndirectReference> actives = new ArrayList<PdfIndirectReference>();
int pageRefIndex = 0;
if (mergeFields && acroForm != null) {
actives.add(acroForm);
activeKeys.add(new RefKey(acroForm));
}
for (PdfIndirectReference page : pageReferences) {
actives.add(page);
activeKeys.add(new RefKey(page));
}
//from end, because some objects can appear on several pages because of MCR (out16.pdf)
for (int i = numTree.size() - 1; i >= 0; --i) {
PdfIndirectReference currNum = numTree.get(i);
if (currNum == null) {
continue;
}
RefKey numKey = new RefKey(currNum);
PdfObject obj = indirectObjects.get(numKey).object;
if (obj.isDictionary()) {
boolean addActiveKeys = false;
if (pageReferences.contains(((PdfDictionary)obj).get(PdfName.PG))) {
addActiveKeys = true;
} else {
PdfDictionary k = PdfStructTreeController.getKDict((PdfDictionary)obj);
if (k != null && pageReferences.contains(k.get(PdfName.PG))) {
addActiveKeys = true;
}
}
if (addActiveKeys) {
activeKeys.add(numKey);
actives.add(currNum);
} else {
numTree.remove(i);
}
} else if (obj.isArray()) {
activeKeys.add(numKey);
actives.add(currNum);
PdfArray currNums = (PdfArray)obj;
PdfIndirectReference currPage = pageReferences.get(pageRefIndex++);
actives.add(currPage);
activeKeys.add(new RefKey(currPage));
PdfIndirectReference prevKid = null;
for (int j = 0; j < currNums.size(); j++) {
PdfIndirectReference currKid = (PdfIndirectReference)currNums.getDirectObject(j);
if (currKid.equals(prevKid)) continue;
RefKey kidKey = new RefKey(currKid);
activeKeys.add(kidKey);
actives.add(currKid);
PdfIndirectObject iobj = indirectObjects.get(kidKey);
if (iobj.object.isDictionary()) {
PdfDictionary dict = (PdfDictionary)iobj.object;
PdfIndirectReference pg = (PdfIndirectReference)dict.get(PdfName.PG);
//if pg is real page - do nothing, else set correct pg and remove first MCID if exists
if (pg != null && !pageReferences.contains(pg) && !pg.equals(currPage)){
dict.put(PdfName.PG, currPage);
PdfArray kids = dict.getAsArray(PdfName.K);
if (kids != null) {
PdfObject firstKid = kids.getDirectObject(0);
if (firstKid.isNumber()) kids.remove(0);
}
}
}
prevKid = currKid;
}
}
}
HashSet<PdfName> activeClassMaps = new HashSet<PdfName>();
//collect all active objects from current active set (include kids, classmap, attributes)
findActives(actives, activeKeys, activeClassMaps);
//find parents of active objects
ArrayList<PdfIndirectReference> newRefs = findActiveParents(activeKeys);
//find new objects with incorrect Pg; if find, set Pg from first correct kid. This correct kid must be.
fixPgKey(newRefs, activeKeys);
//remove unused kids of StructTreeRoot and remove unused objects from class map
fixStructureTreeRoot(activeKeys, activeClassMaps);
for(Map.Entry<RefKey, PdfIndirectObject> entry: indirectObjects.entrySet()) {
if (!activeKeys.contains(entry.getKey())) {
entry.setValue(null);
}
else {
if (entry.getValue().object.isArray()) {
removeInactiveReferences((PdfArray)entry.getValue().object, activeKeys);
} else if (entry.getValue().object.isDictionary()) {
PdfObject kids = ((PdfDictionary)entry.getValue().object).get(PdfName.K);
if (kids != null && kids.isArray())
removeInactiveReferences((PdfArray)kids, activeKeys);
}
}
}
}
private void removeInactiveReferences(PdfArray array, HashSet<RefKey> activeKeys) {
for (int i = 0; i < array.size(); ++i) {
PdfObject obj = array.getPdfObject(i);
if ((obj.type() == 0 && !activeKeys.contains(new RefKey((PdfIndirectReference)obj))) ||
(obj.isDictionary() && containsInactivePg((PdfDictionary)obj, activeKeys)))
array.remove(i--);
}
}
private boolean containsInactivePg(PdfDictionary dict, HashSet<RefKey> activeKeys) {
PdfObject pg = dict.get(PdfName.PG);
if (pg != null && !activeKeys.contains(new RefKey((PdfIndirectReference)pg)))
return true;
return false;
}
//return new found objects
private ArrayList<PdfIndirectReference> findActiveParents(HashSet<RefKey> activeKeys){
ArrayList<PdfIndirectReference> newRefs = new ArrayList<PdfIndirectReference>();
ArrayList<RefKey> tmpActiveKeys = new ArrayList<RefKey>(activeKeys);
for (int i = 0; i < tmpActiveKeys.size(); ++i) {
PdfIndirectObject iobj = indirectObjects.get(tmpActiveKeys.get(i));
if (iobj == null || !iobj.object.isDictionary()) continue;
PdfObject parent = ((PdfDictionary)iobj.object).get(PdfName.P);
if (parent != null && parent.type() == 0) {
RefKey key = new RefKey((PdfIndirectReference)parent);
if (!activeKeys.contains(key)) {
activeKeys.add(key);
tmpActiveKeys.add(key);
newRefs.add((PdfIndirectReference) parent);
}
}
}
return newRefs;
}
private void fixPgKey(ArrayList<PdfIndirectReference> newRefs, HashSet<RefKey> activeKeys){
for (PdfIndirectReference iref: newRefs) {
PdfIndirectObject iobj = indirectObjects.get(new RefKey(iref));
if (iobj == null || !iobj.object.isDictionary()) continue;
PdfDictionary dict = (PdfDictionary)iobj.object;
PdfObject pg = dict.get(PdfName.PG);
if (pg == null || activeKeys.contains(new RefKey((PdfIndirectReference)pg))) continue;
PdfArray kids = dict.getAsArray(PdfName.K);
if (kids == null) continue;
for (int i = 0; i < kids.size(); ++i) {
PdfObject obj = kids.getPdfObject(i);
if (obj.type() != 0) {
kids.remove(i--);
} else {
PdfIndirectObject kid = indirectObjects.get(new RefKey((PdfIndirectReference)obj));
if (kid != null && kid.object.isDictionary()) {
PdfObject kidPg = ((PdfDictionary)kid.object).get(PdfName.PG);
if (kidPg != null && activeKeys.contains(new RefKey((PdfIndirectReference)kidPg))) {
dict.put(PdfName.PG, kidPg);
break;
}
}
}
}
}
}
private void findActives(ArrayList<PdfIndirectReference> actives, HashSet<RefKey> activeKeys, HashSet<PdfName> activeClassMaps){
//collect all active objects from current active set (include kids, classmap, attributes)
for (int i = 0; i < actives.size(); ++i) {
RefKey key = new RefKey(actives.get(i));
PdfIndirectObject iobj = indirectObjects.get(key);
if (iobj == null || iobj.object == null) continue;
switch (iobj.object.type()){
case 0://PdfIndirectReference
findActivesFromReference((PdfIndirectReference)iobj.object, actives, activeKeys);
break;
case PdfObject.ARRAY:
findActivesFromArray((PdfArray)iobj.object, actives, activeKeys, activeClassMaps);
break;
case PdfObject.DICTIONARY:
case PdfObject.STREAM:
findActivesFromDict((PdfDictionary)iobj.object, actives, activeKeys, activeClassMaps);
break;
}
}
}
private void findActivesFromReference(PdfIndirectReference iref, ArrayList<PdfIndirectReference> actives, HashSet<RefKey> activeKeys) {
RefKey key = new RefKey(iref);
PdfIndirectObject iobj = indirectObjects.get(key);
if (iobj != null && iobj.object.isDictionary() && containsInactivePg((PdfDictionary) iobj.object, activeKeys)) return;
if(!activeKeys.contains(key)) {
activeKeys.add(key);
actives.add(iref);
}
}
private void findActivesFromArray(PdfArray array, ArrayList<PdfIndirectReference> actives, HashSet<RefKey> activeKeys, HashSet<PdfName> activeClassMaps) {
for (PdfObject obj: array) {
switch (obj.type()) {
case 0://PdfIndirectReference
findActivesFromReference((PdfIndirectReference)obj, actives, activeKeys);
break;
case PdfObject.ARRAY:
findActivesFromArray((PdfArray)obj, actives, activeKeys, activeClassMaps);
break;
case PdfObject.DICTIONARY:
case PdfObject.STREAM:
findActivesFromDict((PdfDictionary)obj, actives, activeKeys, activeClassMaps);
break;
}
}
}
private void findActivesFromDict(PdfDictionary dict, ArrayList<PdfIndirectReference> actives, HashSet<RefKey> activeKeys, HashSet<PdfName> activeClassMaps) {
if (containsInactivePg(dict, activeKeys)) return;
for (PdfName key: dict.getKeys()) {
PdfObject obj = dict.get(key);
if (key.equals(PdfName.P)) continue;
else if (key.equals(PdfName.C)) { //classmap
if (obj.isArray()) {
for (PdfObject cm: (PdfArray)obj) {
if (cm.isName()) activeClassMaps.add((PdfName)cm);
}
}
else if (obj.isName()) activeClassMaps.add((PdfName)obj);
continue;
}
switch (obj.type()) {
case 0://PdfIndirectReference
findActivesFromReference((PdfIndirectReference)obj, actives, activeKeys);
break;
case PdfObject.ARRAY:
findActivesFromArray((PdfArray)obj, actives, activeKeys, activeClassMaps);
break;
case PdfObject.DICTIONARY:
case PdfObject.STREAM:
findActivesFromDict((PdfDictionary)obj, actives, activeKeys, activeClassMaps);
break;
}
}
}
protected void flushIndirectObjects() throws IOException {
for (PdfIndirectObject iobj: savedObjects)
indirectObjects.remove(new RefKey(iobj.number, iobj.generation));
HashSet<RefKey> inactives = new HashSet<RefKey>();
for(Map.Entry<RefKey, PdfIndirectObject> entry: indirectObjects.entrySet()) {
if (entry.getValue() != null)
writeObjectToBody(entry.getValue());
else
inactives.add(entry.getKey());
}
ArrayList<PdfBody.PdfCrossReference> pdfCrossReferences = new ArrayList<PdfBody.PdfCrossReference>(body.xrefs);
for (PdfBody.PdfCrossReference cr : pdfCrossReferences) {
RefKey key = new RefKey(cr.getRefnum(), 0);
if (inactives.contains(key))
body.xrefs.remove(cr);
}
indirectObjects = null;
}
private void writeObjectToBody(PdfIndirectObject object) throws IOException {
boolean skipWriting = false;
if (mergeFields) {
updateAnnotationReferences(object.object);
if (object.object.isDictionary() || object.object.isStream()) {
PdfDictionary dictionary = (PdfDictionary)object.object;
if (unmergedIndirectRefsMap.containsKey(new RefKey(object.number, object.generation))) {
PdfNumber annotId = dictionary.getAsNumber(PdfCopy.annotId);
if (annotId != null && mergedMap.containsKey(annotId.intValue()))
skipWriting = true;
}
if (mergedSet.contains(object)) {
PdfNumber annotId = dictionary.getAsNumber(PdfCopy.annotId);
if (annotId != null) {
PdfIndirectObject unmerged = unmergedMap.get(annotId.intValue());
if (unmerged != null && unmerged.object.isDictionary()) {
PdfNumber structParent = ((PdfDictionary)unmerged.object).getAsNumber(PdfName.STRUCTPARENT);
if (structParent != null) {
dictionary.put(PdfName.STRUCTPARENT, structParent);
}
}
}
}
}
}
if (!skipWriting) {
PdfDictionary dictionary = null;
PdfNumber annotId = null;
if (mergeFields && object.object.isDictionary()) {
dictionary = (PdfDictionary)object.object;
annotId = dictionary.getAsNumber(PdfCopy.annotId);
if (annotId != null)
dictionary.remove(PdfCopy.annotId);
}
body.add(object.object, object.number, object.generation, true);
if (annotId != null) {
dictionary.put(PdfCopy.annotId, annotId);
}
}
}
private void updateAnnotationReferences(PdfObject obj) {
if (obj.isArray()) {
PdfArray array = (PdfArray)obj;
for (int i = 0; i < array.size(); i++) {
PdfObject o = array.getPdfObject(i);
if (o != null && o.type() == 0) {
PdfIndirectObject entry = unmergedIndirectRefsMap.get(new RefKey((PdfIndirectReference)o));
if (entry != null) {
if (entry.object.isDictionary()) {
PdfNumber annotId = ((PdfDictionary) entry.object).getAsNumber(PdfCopy.annotId);
if (annotId != null) {
PdfIndirectObject merged = mergedMap.get(annotId.intValue());
if (merged != null) {
array.set(i, merged.getIndirectReference());
}
}
}
}
} else {
updateAnnotationReferences(o);
}
}
} else if (obj.isDictionary() || obj.isStream()) {
PdfDictionary dictionary = (PdfDictionary)obj;
for (PdfName key : dictionary.getKeys()) {
PdfObject o = dictionary.get(key);
if (o != null && o.type() == 0) {
PdfIndirectObject entry = unmergedIndirectRefsMap.get(new RefKey((PdfIndirectReference)o));
if (entry != null) {
if (entry.object.isDictionary()) {
PdfNumber annotId = ((PdfDictionary) entry.object).getAsNumber(PdfCopy.annotId);
if (annotId != null) {
PdfIndirectObject merged = mergedMap.get(annotId.intValue());
if (merged != null) {
dictionary.put(key, merged.getIndirectReference());
}
}
}
}
} else {
updateAnnotationReferences(o);
}
}
}
}
private void updateCalculationOrder(PdfReader reader) {
PdfDictionary catalog = reader.getCatalog();
PdfDictionary acro = catalog.getAsDict(PdfName.ACROFORM);
if (acro == null)
return;
PdfArray co = acro.getAsArray(PdfName.CO);
if (co == null || co.size() == 0)
return;
AcroFields af = reader.getAcroFields();
for (int k = 0; k < co.size(); ++k) {
PdfObject obj = co.getPdfObject(k);
if (obj == null || !obj.isIndirect())
continue;
String name = getCOName(reader, (PRIndirectReference) obj);
if (af.getFieldItem(name) == null)
continue;
name = "." + name;
if (calculationOrder.contains(name))
continue;
calculationOrder.add(name);
}
}
private static String getCOName(PdfReader reader, PRIndirectReference ref) {
String name = "";
while (ref != null) {
PdfObject obj = PdfReader.getPdfObject(ref);
if (obj == null || obj.type() != PdfObject.DICTIONARY)
break;
PdfDictionary dic = (PdfDictionary)obj;
PdfString t = dic.getAsString(PdfName.T);
if (t != null) {
name = t.toUnicodeString()+ "." + name;
}
ref = (PRIndirectReference)dic.get(PdfName.PARENT);
}
if (name.endsWith("."))
name = name.substring(0, name.length() - 2);
return name;
}
private void mergeFields() {
int pageOffset = 0;
for (int k = 0; k < fields.size(); ++k) {
AcroFields af = fields.get(k);
Map<String, AcroFields.Item> fd = af.getFields();
if (pageOffset < importedPages.size() && importedPages.get(pageOffset).reader == af.reader) {
addPageOffsetToField(fd, pageOffset);
pageOffset += af.reader.getNumberOfPages();
}
mergeWithMaster(fd);
}
}
private void addPageOffsetToField(Map<String, AcroFields.Item> fd, int pageOffset) {
if (pageOffset == 0)
return;
for (AcroFields.Item item: fd.values()) {
for (int k = 0; k < item.size(); ++k) {
int p = item.getPage(k).intValue();
item.forcePage(k, p + pageOffset);
}
}
}
private void mergeWithMaster(Map<String, AcroFields.Item> fd) {
for (Map.Entry<String, AcroFields.Item> entry: fd.entrySet()) {
String name = entry.getKey();
mergeField(name, entry.getValue());
}
}
@SuppressWarnings("unchecked")
private void mergeField(String name, AcroFields.Item item) {
HashMap<String, Object> map = fieldTree;
StringTokenizer tk = new StringTokenizer(name, ".");
if (!tk.hasMoreTokens())
return;
while (true) {
String s = tk.nextToken();
Object obj = map.get(s);
if (tk.hasMoreTokens()) {
if (obj == null) {
obj = new LinkedHashMap<String, Object>();
map.put(s, obj);
map = (HashMap<String, Object>)obj;
continue;
}
else if (obj instanceof HashMap)
map = (HashMap<String, Object>)obj;
else
return;
}
else {
if (obj instanceof HashMap)
return;
PdfDictionary merged = item.getMerged(0);
if (obj == null) {
PdfDictionary field = new PdfDictionary();
if (PdfName.SIG.equals(merged.get(PdfName.FT)))
hasSignature = true;
for (Object element : merged.getKeys()) {
PdfName key = (PdfName)element;
if (fieldKeys.contains(key))
field.put(key, merged.get(key));
}
ArrayList<Object> list = new ArrayList<Object>();
list.add(field);
createWidgets(list, item);
map.put(s, list);
}
else {
ArrayList<Object> list = (ArrayList<Object>)obj;
PdfDictionary field = (PdfDictionary)list.get(0);
PdfName type1 = (PdfName)field.get(PdfName.FT);
PdfName type2 = (PdfName)merged.get(PdfName.FT);
if (type1 == null || !type1.equals(type2))
return;
int flag1 = 0;
PdfObject f1 = field.get(PdfName.FF);
if (f1 != null && f1.isNumber())
flag1 = ((PdfNumber)f1).intValue();
int flag2 = 0;
PdfObject f2 = merged.get(PdfName.FF);
if (f2 != null && f2.isNumber())
flag2 = ((PdfNumber)f2).intValue();
if (type1.equals(PdfName.BTN)) {
if (((flag1 ^ flag2) & PdfFormField.FF_PUSHBUTTON) != 0)
return;
if ((flag1 & PdfFormField.FF_PUSHBUTTON) == 0 && ((flag1 ^ flag2) & PdfFormField.FF_RADIO) != 0)
return;
}
else if (type1.equals(PdfName.CH)) {
if (((flag1 ^ flag2) & PdfFormField.FF_COMBO) != 0)
return;
}
createWidgets(list, item);
}
return;
}
}
}
private void createWidgets(ArrayList<Object> list, AcroFields.Item item) {
for (int k = 0; k < item.size(); ++k) {
list.add(item.getPage(k));
PdfDictionary merged = item.getMerged(k);
PdfObject dr = merged.get(PdfName.DR);
if (dr != null)
PdfFormField.mergeResources(resources, (PdfDictionary)PdfReader.getPdfObject(dr));
PdfDictionary widget = new PdfDictionary();
for (Object element : merged.getKeys()) {
PdfName key = (PdfName)element;
if (widgetKeys.contains(key))
widget.put(key, merged.get(key));
}
widget.put(iTextTag, new PdfNumber(item.getTabOrder(k).intValue() + 1));
list.add(widget);
}
}
private PdfObject propagate(PdfObject obj) throws IOException {
if (obj == null) {
return new PdfNull();
} else if (obj.isArray()) {
PdfArray a = (PdfArray)obj;
for (int i = 0; i < a.size(); i++) {
a.set(i, propagate(a.getPdfObject(i)));
}
return a;
} else if (obj.isDictionary() || obj.isStream()) {
PdfDictionary d = (PdfDictionary)obj;
for (PdfName key : d.getKeys()) {
d.put(key, propagate(d.get(key)));
}
return d;
} else if (obj.isIndirect()) {
obj = PdfReader.getPdfObject(obj);
return addToBody(propagate(obj)).getIndirectReference();
} else
return obj;
}
private void createAcroForms() throws IOException, BadPdfFormatException {
if (fieldTree.isEmpty()) {
//write annotations that appear just at page level (comments, popups)
for (ImportedPage importedPage : importedPages) {
if (importedPage.mergedFields.size() > 0)
addToBody(importedPage.mergedFields, importedPage.annotsIndirectReference);
}
return;
}
PdfDictionary form = new PdfDictionary();
form.put(PdfName.DR, propagate(resources));
if (needAppearances) {
form.put(PdfName.NEEDAPPEARANCES, PdfBoolean.PDFTRUE);
}
form.put(PdfName.DA, new PdfString("/Helv 0 Tf 0 g "));
tabOrder = new HashMap<PdfArray, ArrayList<Integer>>();
calculationOrderRefs = new ArrayList<Object>(calculationOrder);
form.put(PdfName.FIELDS, branchForm(fieldTree, null, ""));
if (hasSignature)
form.put(PdfName.SIGFLAGS, new PdfNumber(3));
PdfArray co = new PdfArray();
for (int k = 0; k < calculationOrderRefs.size(); ++k) {
Object obj = calculationOrderRefs.get(k);
if (obj instanceof PdfIndirectReference)
co.add((PdfIndirectReference)obj);
}
if (co.size() > 0)
form.put(PdfName.CO, co);
this.acroForm = addToBody(form).getIndirectReference();
for (ImportedPage importedPage : importedPages) {
addToBody(importedPage.mergedFields, importedPage.annotsIndirectReference);
}
}
private void updateReferences(PdfObject obj) {
if (obj.isDictionary() || obj.isStream()) {
PdfDictionary dictionary = (PdfDictionary)obj;
for (PdfName key : dictionary.getKeys()) {
PdfObject o = dictionary.get(key);
if (o.isIndirect()) {
PdfReader reader = ((PRIndirectReference)o).getReader();
HashMap<RefKey,IndirectReferences> indirects = indirectMap.get(reader);
IndirectReferences indRef = indirects.get(new RefKey((PRIndirectReference)o));
if (indRef != null) {
dictionary.put(key, indRef.getRef());
}
} else {
updateReferences(o);
}
}
} else if (obj.isArray()) {
PdfArray array = (PdfArray)obj;
for (int i = 0; i < array.size(); i++) {
PdfObject o = array.getPdfObject(i);
if (o.isIndirect()) {
PdfReader reader = ((PRIndirectReference)o).getReader();
HashMap<RefKey,IndirectReferences> indirects = indirectMap.get(reader);
IndirectReferences indRef = indirects.get(new RefKey((PRIndirectReference)o));
if (indRef != null) {
array.set(i, indRef.getRef());
}
} else {
updateReferences(o);
}
}
}
}
@SuppressWarnings("unchecked")
private PdfArray branchForm(HashMap<String, Object> level, PdfIndirectReference parent, String fname) throws IOException, BadPdfFormatException {
PdfArray arr = new PdfArray();
for (Map.Entry<String, Object> entry: level.entrySet()) {
String name = entry.getKey();
Object obj = entry.getValue();
PdfIndirectReference ind = getPdfIndirectReference();
PdfDictionary dic = new PdfDictionary();
if (parent != null)
dic.put(PdfName.PARENT, parent);
dic.put(PdfName.T, new PdfString(name, PdfObject.TEXT_UNICODE));
String fname2 = fname + "." + name;
int coidx = calculationOrder.indexOf(fname2);
if (coidx >= 0)
calculationOrderRefs.set(coidx, ind);
if (obj instanceof HashMap) {
dic.put(PdfName.KIDS, branchForm((HashMap<String, Object>) obj, ind, fname2));
arr.add(ind);
addToBody(dic, ind, true);
}
else {
ArrayList<Object> list = (ArrayList<Object>)obj;
dic.mergeDifferent((PdfDictionary) list.get(0));
if (list.size() == 3) {
dic.mergeDifferent((PdfDictionary)list.get(2));
int page = ((Integer)list.get(1)).intValue();
PdfArray annots = importedPages.get(page - 1).mergedFields;
PdfNumber nn = (PdfNumber)dic.get(iTextTag);
dic.remove(iTextTag);
dic.put(PdfName.TYPE, PdfName.ANNOT);
adjustTabOrder(annots, ind, nn);
} else {
PdfDictionary field = (PdfDictionary)list.get(0);
PdfArray kids = new PdfArray();
for (int k = 1; k < list.size(); k += 2) {
int page = ((Integer)list.get(k)).intValue();
PdfArray annots = importedPages.get(page - 1).mergedFields;
PdfDictionary widget = new PdfDictionary();
widget.merge((PdfDictionary)list.get(k + 1));
widget.put(PdfName.PARENT, ind);
PdfNumber nn = (PdfNumber)widget.get(iTextTag);
widget.remove(iTextTag);
if (PdfCopy.isTextField(field)) {
PdfString v = field.getAsString(PdfName.V);
PdfObject ap = widget.getDirectObject(PdfName.AP);
if (v != null && ap != null) {
if (!mergedTextFields.containsKey(list)) {
mergedTextFields.put(list, v);
} else {
try {
TextField tx = new TextField(this, null, null);
fields.get(0).decodeGenericDictionary(widget, tx);
Rectangle box = PdfReader.getNormalizedRectangle(widget.getAsArray(PdfName.RECT));
if (tx.getRotation() == 90 || tx.getRotation() == 270)
box = box.rotate();
tx.setBox(box);
tx.setText(mergedTextFields.get(list).toUnicodeString());
PdfAppearance app = tx.getAppearance();
((PdfDictionary)ap).put(PdfName.N, app.getIndirectReference());
} catch (DocumentException e) {
//do nothing
}
}
}
} else if (PdfCopy.isCheckButton(field)) {
PdfName v = field.getAsName(PdfName.V);
PdfName as = widget.getAsName(PdfName.AS);
if (v != null && as != null)
widget.put(PdfName.AS, v);
} else if (PdfCopy.isRadioButton(field)) {
PdfName v = field.getAsName(PdfName.V);
PdfName as = widget.getAsName(PdfName.AS);
if (v != null && as != null && !as.equals(getOffStateName(widget))) {
if (!mergedRadioButtons.contains(list)) {
mergedRadioButtons.add(list);
widget.put(PdfName.AS, v);
} else {
widget.put(PdfName.AS, getOffStateName(widget));
}
}
}
widget.put(PdfName.TYPE, PdfName.ANNOT);
PdfIndirectReference wref = addToBody(widget, getPdfIndirectReference(), true).getIndirectReference();
adjustTabOrder(annots, wref, nn);
kids.add(wref);
}
dic.put(PdfName.KIDS, kids);
}
arr.add(ind);
addToBody(dic, ind, true);
}
}
return arr;
}
private void adjustTabOrder(PdfArray annots, PdfIndirectReference ind, PdfNumber nn) {
int v = nn.intValue();
ArrayList<Integer> t = tabOrder.get(annots);
if (t == null) {
t = new ArrayList<Integer>();
int size = annots.size() - 1;
for (int k = 0; k < size; ++k) {
t.add(zero);
}
t.add(Integer.valueOf(v));
tabOrder.put(annots, t);
annots.add(ind);
}
else {
int size = t.size() - 1;
for (int k = size; k >= 0; --k) {
if (t.get(k).intValue() <= v) {
t.add(k + 1, Integer.valueOf(v));
annots.add(k + 1, ind);
size = -2;
break;
}
}
if (size != -2) {
t.add(0, Integer.valueOf(v));
annots.add(0, ind);
}
}
}
/*
* the getCatalog method is part of PdfWriter.
* we wrap this so that we can extend it
*/
@Override
protected PdfDictionary getCatalog(PdfIndirectReference rootObj) {
try {
PdfDictionary theCat = pdf.getCatalog(rootObj);
buildStructTreeRootForTagged(theCat);
if (fieldArray != null) {
addFieldResources(theCat);
} else if (mergeFields && acroForm != null) {
theCat.put(PdfName.ACROFORM, acroForm);
}
return theCat;
}
catch (IOException e) {
throw new ExceptionConverter(e);
}
}
protected boolean isStructTreeRootReference(PdfIndirectReference prRef) {
if (prRef == null || structTreeRootReference == null)
return false;
return prRef.number == structTreeRootReference.number && prRef.generation == structTreeRootReference.generation;
}
private void addFieldResources(PdfDictionary catalog) throws IOException {
if (fieldArray == null)
return;
PdfDictionary acroForm = new PdfDictionary();
catalog.put(PdfName.ACROFORM, acroForm);
acroForm.put(PdfName.FIELDS, fieldArray);
acroForm.put(PdfName.DA, new PdfString("/Helv 0 Tf 0 g "));
if (fieldTemplates.isEmpty())
return;
PdfDictionary dr = new PdfDictionary();
acroForm.put(PdfName.DR, dr);
for (PdfTemplate template: fieldTemplates) {
PdfFormField.mergeResources(dr, (PdfDictionary)template.getResources());
}
// if (dr.get(PdfName.ENCODING) == null) dr.put(PdfName.ENCODING, PdfName.WIN_ANSI_ENCODING);
PdfDictionary fonts = dr.getAsDict(PdfName.FONT);
if (fonts == null) {
fonts = new PdfDictionary();
dr.put(PdfName.FONT, fonts);
}
if (!fonts.contains(PdfName.HELV)) {
PdfDictionary dic = new PdfDictionary(PdfName.FONT);
dic.put(PdfName.BASEFONT, PdfName.HELVETICA);
dic.put(PdfName.ENCODING, PdfName.WIN_ANSI_ENCODING);
dic.put(PdfName.NAME, PdfName.HELV);
dic.put(PdfName.SUBTYPE, PdfName.TYPE1);
fonts.put(PdfName.HELV, addToBody(dic).getIndirectReference());
}
if (!fonts.contains(PdfName.ZADB)) {
PdfDictionary dic = new PdfDictionary(PdfName.FONT);
dic.put(PdfName.BASEFONT, PdfName.ZAPFDINGBATS);
dic.put(PdfName.NAME, PdfName.ZADB);
dic.put(PdfName.SUBTYPE, PdfName.TYPE1);
fonts.put(PdfName.ZADB, addToBody(dic).getIndirectReference());
}
}
/**
* Signals that the <CODE>Document</CODE> was closed and that no other
* <CODE>Elements</CODE> will be added.
* <P>
* The pages-tree is built and written to the outputstream.
* A Catalog is constructed, as well as an Info-object,
* the reference table is composed and everything is written
* to the outputstream embedded in a Trailer.
*/
@Override
public void close() {
if (open) {
pdf.close();
super.close();
// Users are responsible for closing PdfReader
// if (ri != null) {
// try {
// ri.getReader().close();
// ri.getReaderFile().close();
// }
// catch (IOException ioe) {
// // empty on purpose
// }
// }
}
}
public PdfIndirectReference add(PdfOutline outline) { return null; }
@Override
public void addAnnotation(PdfAnnotation annot) { }
@Override
PdfIndirectReference add(PdfPage page, PdfContents contents) throws PdfException { return null; }
@Override
public void freeReader(PdfReader reader) throws IOException {
if (mergeFields)
throw new UnsupportedOperationException(MessageLocalization.getComposedMessage("it.is.not.possible.to.free.reader.in.merge.fields.mode"));
PdfArray array = reader.trailer.getAsArray(PdfName.ID);
if (array != null)
originalFileID = array.getAsString(0).getBytes();
indirectMap.remove(reader);
// TODO: Removed - the user should be responsible for closing all PdfReaders. But, this could cause a lot of memory leaks in code out there that hasn't been properly closing things - maybe add a finalizer to PdfReader that calls PdfReader#close() ??
// if (currentPdfReaderInstance != null) {
// if (currentPdfReaderInstance.getReader() == reader) {
// try {
// currentPdfReaderInstance.getReader().close();
// currentPdfReaderInstance.getReaderFile().close();
// }
// catch (IOException ioe) {
// // empty on purpose
// }
currentPdfReaderInstance = null;
// }
// }
super.freeReader(reader);
}
protected PdfName getOffStateName(PdfDictionary widget) {
return PdfName.Off;
}
protected static final HashSet<PdfName> widgetKeys = new HashSet<PdfName>();
protected static final HashSet<PdfName> fieldKeys = new HashSet<PdfName>();
static {
widgetKeys.add(PdfName.SUBTYPE);
widgetKeys.add(PdfName.CONTENTS);
widgetKeys.add(PdfName.RECT);
widgetKeys.add(PdfName.NM);
widgetKeys.add(PdfName.M);
widgetKeys.add(PdfName.F);
widgetKeys.add(PdfName.BS);
widgetKeys.add(PdfName.BORDER);
widgetKeys.add(PdfName.AP);
widgetKeys.add(PdfName.AS);
widgetKeys.add(PdfName.C);
widgetKeys.add(PdfName.A);
widgetKeys.add(PdfName.STRUCTPARENT);
widgetKeys.add(PdfName.OC);
widgetKeys.add(PdfName.H);
widgetKeys.add(PdfName.MK);
widgetKeys.add(PdfName.DA);
widgetKeys.add(PdfName.Q);
widgetKeys.add(PdfName.P);
widgetKeys.add(PdfName.TYPE);
widgetKeys.add(annotId);
fieldKeys.add(PdfName.AA);
fieldKeys.add(PdfName.FT);
fieldKeys.add(PdfName.TU);
fieldKeys.add(PdfName.TM);
fieldKeys.add(PdfName.FF);
fieldKeys.add(PdfName.V);
fieldKeys.add(PdfName.DV);
fieldKeys.add(PdfName.DS);
fieldKeys.add(PdfName.RV);
fieldKeys.add(PdfName.OPT);
fieldKeys.add(PdfName.MAXLEN);
fieldKeys.add(PdfName.TI);
fieldKeys.add(PdfName.I);
fieldKeys.add(PdfName.LOCK);
fieldKeys.add(PdfName.SV);
}
static Integer getFlags(PdfDictionary field) {
PdfName type = field.getAsName(PdfName.FT);
if (!PdfName.BTN.equals(type))
return null;
PdfNumber flags = field.getAsNumber(PdfName.FF);
if (flags == null)
return null;
return flags.intValue();
}
static boolean isCheckButton(PdfDictionary field) {
Integer flags = getFlags(field);
return flags == null || ((flags.intValue() & PdfFormField.FF_PUSHBUTTON) == 0 && (flags.intValue() & PdfFormField.FF_RADIO) == 0);
}
static boolean isRadioButton(PdfDictionary field) {
Integer flags = getFlags(field);
return flags != null && (flags.intValue() & PdfFormField.FF_PUSHBUTTON) == 0 && (flags.intValue() & PdfFormField.FF_RADIO) != 0;
}
static boolean isTextField(PdfDictionary field) {
PdfName type = field.getAsName(PdfName.FT);
return PdfName.TX.equals(type);
}
/**
* Create a page stamp. New content and annotations, including new fields, are allowed.
* The fields added cannot have parents in another pages. This method modifies the PdfReader instance.<p>
* The general usage to stamp something in a page is:
* <p>
* <pre>
* PdfImportedPage page = copy.getImportedPage(reader, 1);
* PdfCopy.PageStamp ps = copy.createPageStamp(page);
* ps.addAnnotation(PdfAnnotation.createText(copy, new Rectangle(50, 180, 70, 200), "Hello", "No Thanks", true, "Comment"));
* PdfContentByte under = ps.getUnderContent();
* under.addImage(img);
* PdfContentByte over = ps.getOverContent();
* over.beginText();
* over.setFontAndSize(bf, 18);
* over.setTextMatrix(30, 30);
* over.showText("total page " + totalPage);
* over.endText();
* ps.alterContents();
* copy.addPage(page);
* </pre>
* @param iPage an imported page
* @return the <CODE>PageStamp</CODE>
*/
public PageStamp createPageStamp(PdfImportedPage iPage) {
int pageNum = iPage.getPageNumber();
PdfReader reader = iPage.getPdfReaderInstance().getReader();
if (isTagged())
throw new RuntimeException(MessageLocalization.getComposedMessage("creating.page.stamp.not.allowed.for.tagged.reader"));
PdfDictionary pageN = reader.getPageN(pageNum);
return new PageStamp(reader, pageN, this);
}
public static class PageStamp {
PdfDictionary pageN;
PdfCopy.StampContent under;
PdfCopy.StampContent over;
PageResources pageResources;
PdfReader reader;
PdfCopy cstp;
PageStamp(PdfReader reader, PdfDictionary pageN, PdfCopy cstp) {
this.pageN = pageN;
this.reader = reader;
this.cstp = cstp;
}
public PdfContentByte getUnderContent(){
if (under == null) {
if (pageResources == null) {
pageResources = new PageResources();
PdfDictionary resources = pageN.getAsDict(PdfName.RESOURCES);
pageResources.setOriginalResources(resources, cstp.namePtr);
}
under = new PdfCopy.StampContent(cstp, pageResources);
}
return under;
}
public PdfContentByte getOverContent(){
if (over == null) {
if (pageResources == null) {
pageResources = new PageResources();
PdfDictionary resources = pageN.getAsDict(PdfName.RESOURCES);
pageResources.setOriginalResources(resources, cstp.namePtr);
}
over = new PdfCopy.StampContent(cstp, pageResources);
}
return over;
}
public void alterContents() throws IOException {
if (over == null && under == null)
return;
PdfArray ar = null;
PdfObject content = PdfReader.getPdfObject(pageN.get(PdfName.CONTENTS), pageN);
if (content == null) {
ar = new PdfArray();
pageN.put(PdfName.CONTENTS, ar);
} else if (content.isArray()) {
ar = (PdfArray)content;
} else if (content.isStream()) {
ar = new PdfArray();
ar.add(pageN.get(PdfName.CONTENTS));
pageN.put(PdfName.CONTENTS, ar);
} else {
ar = new PdfArray();
pageN.put(PdfName.CONTENTS, ar);
}
ByteBuffer out = new ByteBuffer();
if (under != null) {
out.append(PdfContents.SAVESTATE);
applyRotation(pageN, out);
out.append(under.getInternalBuffer());
out.append(PdfContents.RESTORESTATE);
}
if (over != null)
out.append(PdfContents.SAVESTATE);
PdfStream stream = new PdfStream(out.toByteArray());
stream.flateCompress(cstp.getCompressionLevel());
PdfIndirectReference ref1 = cstp.addToBody(stream).getIndirectReference();
ar.addFirst(ref1);
out.reset();
if (over != null) {
out.append(' ');
out.append(PdfContents.RESTORESTATE);
out.append(PdfContents.SAVESTATE);
applyRotation(pageN, out);
out.append(over.getInternalBuffer());
out.append(PdfContents.RESTORESTATE);
stream = new PdfStream(out.toByteArray());
stream.flateCompress(cstp.getCompressionLevel());
ar.add(cstp.addToBody(stream).getIndirectReference());
}
pageN.put(PdfName.RESOURCES, pageResources.getResources());
}
void applyRotation(PdfDictionary pageN, ByteBuffer out) {
if (!cstp.rotateContents)
return;
Rectangle page = reader.getPageSizeWithRotation(pageN);
int rotation = page.getRotation();
switch (rotation) {
case 90:
out.append(PdfContents.ROTATE90);
out.append(page.getTop());
out.append(' ').append('0').append(PdfContents.ROTATEFINAL);
break;
case 180:
out.append(PdfContents.ROTATE180);
out.append(page.getRight());
out.append(' ');
out.append(page.getTop());
out.append(PdfContents.ROTATEFINAL);
break;
case 270:
out.append(PdfContents.ROTATE270);
out.append('0').append(' ');
out.append(page.getRight());
out.append(PdfContents.ROTATEFINAL);
break;
}
}
private void addDocumentField(PdfIndirectReference ref) {
if (cstp.fieldArray == null)
cstp.fieldArray = new PdfArray();
cstp.fieldArray.add(ref);
}
private void expandFields(PdfFormField field, ArrayList<PdfAnnotation> allAnnots) {
allAnnots.add(field);
ArrayList<PdfFormField> kids = field.getKids();
if (kids != null) {
for (PdfFormField f : kids)
expandFields(f, allAnnots);
}
}
public void addAnnotation(PdfAnnotation annot) {
try {
ArrayList<PdfAnnotation> allAnnots = new ArrayList<PdfAnnotation>();
if (annot.isForm()) {
PdfFormField field = (PdfFormField)annot;
if (field.getParent() != null)
return;
expandFields(field, allAnnots);
if (cstp.fieldTemplates == null)
cstp.fieldTemplates = new HashSet<PdfTemplate>();
}
else
allAnnots.add(annot);
for (int k = 0; k < allAnnots.size(); ++k) {
annot = allAnnots.get(k);
if (annot.isForm()) {
if (!annot.isUsed()) {
HashSet<PdfTemplate> templates = annot.getTemplates();
if (templates != null)
cstp.fieldTemplates.addAll(templates);
}
PdfFormField field = (PdfFormField)annot;
if (field.getParent() == null)
addDocumentField(field.getIndirectReference());
}
if (annot.isAnnotation()) {
PdfObject pdfobj = PdfReader.getPdfObject(pageN.get(PdfName.ANNOTS), pageN);
PdfArray annots = null;
if (pdfobj == null || !pdfobj.isArray()) {
annots = new PdfArray();
pageN.put(PdfName.ANNOTS, annots);
}
else
annots = (PdfArray)pdfobj;
annots.add(annot.getIndirectReference());
if (!annot.isUsed()) {
PdfRectangle rect = (PdfRectangle)annot.get(PdfName.RECT);
if (rect != null && (rect.left() != 0 || rect.right() != 0 || rect.top() != 0 || rect.bottom() != 0)) {
int rotation = reader.getPageRotation(pageN);
Rectangle pageSize = reader.getPageSizeWithRotation(pageN);
switch (rotation) {
case 90:
annot.put(PdfName.RECT, new PdfRectangle(
pageSize.getTop() - rect.bottom(),
rect.left(),
pageSize.getTop() - rect.top(),
rect.right()));
break;
case 180:
annot.put(PdfName.RECT, new PdfRectangle(
pageSize.getRight() - rect.left(),
pageSize.getTop() - rect.bottom(),
pageSize.getRight() - rect.right(),
pageSize.getTop() - rect.top()));
break;
case 270:
annot.put(PdfName.RECT, new PdfRectangle(
rect.bottom(),
pageSize.getRight() - rect.left(),
rect.top(),
pageSize.getRight() - rect.right()));
break;
}
}
}
}
if (!annot.isUsed()) {
annot.setUsed();
cstp.addToBody(annot, annot.getIndirectReference());
}
}
}
catch (IOException e) {
throw new ExceptionConverter(e);
}
}
}
public static class StampContent extends PdfContentByte {
PageResources pageResources;
/** Creates a new instance of StampContent */
StampContent(PdfWriter writer, PageResources pageResources) {
super(writer);
this.pageResources = pageResources;
}
/**
* Gets a duplicate of this <CODE>PdfContentByte</CODE>. All
* the members are copied by reference but the buffer stays different.
*
* @return a copy of this <CODE>PdfContentByte</CODE>
*/
@Override
public PdfContentByte getDuplicate() {
return new PdfCopy.StampContent(writer, pageResources);
}
@Override
PageResources getPageResources() {
return pageResources;
}
}
}
⏎ com/itextpdf/text/pdf/PdfCopy.java
Or download all of them as a single archive file:
File name: itextpdf-5.5.14-fyi.zip File size: 2163839 bytes Release date: 2009-10-09 Download
⇒ iText-2.1.6.jar - iText, a JAVA-PDF library
⇐ iText layout.jar Source Code
2021-07-03, 133861👍, 0💬
