org.apache.fop.render.pdf.pdfbox.PDFBoxAdapter Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of fop-pdf-images Show documentation
Show all versions of fop-pdf-images Show documentation
Apache FOP PDF Images plug-in extends FOP in order to add support for using PDF images in fo:external-graphic elements when generating PDF files.
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (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.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* $Id: PDFBoxAdapter.java 1785316 2017-03-03 14:59:17Z ssteiner $ */
package org.apache.fop.render.pdf.pdfbox;
import java.awt.Rectangle;
import java.awt.geom.AffineTransform;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import org.apache.commons.io.IOUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.pdfbox.cos.COSArray;
import org.apache.pdfbox.cos.COSBase;
import org.apache.pdfbox.cos.COSBoolean;
import org.apache.pdfbox.cos.COSDictionary;
import org.apache.pdfbox.cos.COSFloat;
import org.apache.pdfbox.cos.COSInteger;
import org.apache.pdfbox.cos.COSName;
import org.apache.pdfbox.cos.COSNull;
import org.apache.pdfbox.cos.COSObject;
import org.apache.pdfbox.cos.COSStream;
import org.apache.pdfbox.cos.COSString;
import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.pdmodel.PDDocumentCatalog;
import org.apache.pdfbox.pdmodel.PDPage;
import org.apache.pdfbox.pdmodel.PDResources;
import org.apache.pdfbox.pdmodel.common.COSObjectable;
import org.apache.pdfbox.pdmodel.common.PDRectangle;
import org.apache.pdfbox.pdmodel.common.PDStream;
import org.apache.pdfbox.pdmodel.interactive.form.PDAcroForm;
import org.apache.fop.fonts.FontInfo;
import org.apache.fop.fonts.Typeface;
import org.apache.fop.pdf.PDFArray;
import org.apache.fop.pdf.PDFDictionary;
import org.apache.fop.pdf.PDFDocument;
import org.apache.fop.pdf.PDFName;
import org.apache.fop.pdf.PDFNumber;
import org.apache.fop.pdf.PDFObject;
import org.apache.fop.pdf.PDFPage;
import org.apache.fop.pdf.PDFRoot;
import org.apache.fop.pdf.PDFStream;
/**
* This class provides an adapter for transferring content from a PDFBox PDDocument to
* FOP's PDFDocument. It is used to parse PDF using PDFBox and write content using
* FOP's PDF library.
*/
public class PDFBoxAdapter {
/** logging instance */
protected static final Log log = LogFactory.getLog(PDFBoxAdapter.class);
private static final Set FILTER_FILTER = new HashSet(
Arrays.asList(new String[] {"Filter", "DecodeParms"}));
private final PDFPage targetPage;
private final PDFDocument pdfDoc;
private final Map clonedVersion;
private final Map objectCache;
private Map newXObj = new HashMap();
private Map pageNumbers;
private Collection parentFonts = new ArrayList();
private int currentMCID;
/**
* Creates a new PDFBoxAdapter.
* @param targetPage The target FOP PDF page object
* @param objectCachePerFile the object cache for reusing objects shared by multiple pages.
* @param pageNumbers references to page object numbers
*/
public PDFBoxAdapter(PDFPage targetPage, Map objectCachePerFile,
Map pageNumbers) {
this(targetPage, objectCachePerFile, pageNumbers, new HashMap());
}
public PDFBoxAdapter(PDFPage targetPage, Map objectCachePerFile,
Map pageNumbers, Map objectCache) {
this.targetPage = targetPage;
this.pdfDoc = this.targetPage.getDocument();
this.clonedVersion = objectCachePerFile;
this.pageNumbers = pageNumbers;
this.objectCache = objectCache;
}
public PDFPage getTargetPage() {
return targetPage;
}
public int getCurrentMCID() {
return currentMCID;
}
public void setCurrentMCID(int currentMCID) {
this.currentMCID = currentMCID;
}
protected Object cloneForNewDocument(Object base) throws IOException {
return cloneForNewDocument(base, base);
}
protected Object cloneForNewDocument(Object base, Object keyBase) throws IOException {
return cloneForNewDocument(base, keyBase, Collections.EMPTY_LIST);
}
protected Object cloneForNewDocument(Object base, Object keyBase, Collection exclude) throws IOException {
if (base == null) {
return null;
}
Object cached = getCachedClone(keyBase);
if (cached != null) {
// we are done, it has already been converted.
return cached;
} else if (base instanceof List) {
PDFArray array = new PDFArray();
cacheClonedObject(keyBase, array);
List list = (List)base;
for (Object o : list) {
array.add(cloneForNewDocument(o, o, exclude));
}
return array;
} else if (base instanceof COSObjectable && !(base instanceof COSBase)) {
Object o = ((COSObjectable)base).getCOSObject();
Object retval = cloneForNewDocument(o, o, exclude);
return cacheClonedObject(keyBase, retval);
} else if (base instanceof COSObject) {
return readCOSObject((COSObject) base, exclude);
} else if (base instanceof COSArray) {
PDFArray newArray = new PDFArray();
cacheClonedObject(keyBase, newArray);
COSArray array = (COSArray)base;
for (int i = 0; i < array.size(); i++) {
newArray.add(cloneForNewDocument(array.get(i), array.get(i), exclude));
}
return newArray;
// } else if (base instanceof COSStreamArray) {
// COSStreamArray array = (COSStreamArray)base;
// PDFArray newArray = new PDFArray();
// cacheClonedObject(keyBase, newArray);
// for (int i = 0, c = array.getStreamCount(); i < c; i++) {
// newArray.add(cloneForNewDocument(array.get(i)));
// }
// return newArray;
} else if (base instanceof COSStream) {
return readCOSStream((COSStream) base, keyBase);
} else if (base instanceof COSDictionary) {
return readCOSDictionary((COSDictionary) base, keyBase, exclude);
} else if (base instanceof COSName) {
byte[] name = ((COSName)base).getName().getBytes("ISO-8859-1");
PDFName newName = new PDFName(new String(name, "ISO-8859-1"));
return cacheClonedObject(keyBase, newName);
} else if (base instanceof COSInteger) {
PDFNumber number = new PDFNumber();
number.setNumber(((COSInteger)base).longValue());
return cacheClonedObject(keyBase, number);
} else if (base instanceof COSFloat) {
PDFNumber number = new PDFNumber();
number.setNumber(((COSFloat)base).floatValue());
return cacheClonedObject(keyBase, number);
} else if (base instanceof COSBoolean) {
//TODO Do we need a PDFBoolean here?
Boolean retval = ((COSBoolean)base).getValueAsObject();
if (keyBase instanceof COSObject) {
return cacheClonedObject(keyBase, new PDFBoolean(retval));
} else {
return cacheClonedObject(keyBase, retval);
}
} else if (base instanceof COSString) {
return readCOSString((COSString) base, keyBase);
} else if (base instanceof COSNull) {
return cacheClonedObject(keyBase, null);
} else {
throw new UnsupportedOperationException("NYI: " + base.getClass().getName());
}
}
private PDFDictionary readCOSDictionary(COSDictionary dic, Object keyBase, Collection exclude) throws IOException {
PDFDictionary newDict = new PDFDictionary();
cacheClonedObject(keyBase, newDict);
for (Map.Entry e : dic.entrySet()) {
if (!exclude.contains(e.getKey())) {
newDict.put(e.getKey().getName(), cloneForNewDocument(e.getValue(), e.getValue(), exclude));
}
}
return newDict;
}
private Object readCOSObject(COSObject object, Collection exclude) throws IOException {
if (log.isTraceEnabled()) {
log.trace("Cloning indirect object: "
+ object.getObjectNumber()
+ " " + object.getGenerationNumber());
}
Object obj = cloneForNewDocument(object.getObject(), object, exclude);
if (obj instanceof PDFObject) {
PDFObject pdfobj = (PDFObject)obj;
//pdfDoc.registerObject(pdfobj);
if (!pdfobj.hasObjectNumber()) {
throw new IllegalStateException("PDF object was not registered!");
}
if (log.isTraceEnabled()) {
log.trace("Object registered: "
+ pdfobj.getObjectNumber()
+ " " + pdfobj.getGeneration()
+ " for COSObject: "
+ object.getObjectNumber()
+ " " + object.getGenerationNumber());
}
}
return obj;
}
private Object readCOSString(COSString string, Object keyBase) throws IOException {
//retval = ((COSString)base).getString(); //this is unsafe for binary content
byte[] bytes = string.getBytes();
//Be on the safe side and use the byte array to avoid encoding problems
//as PDFBox doesn't indicate whether the string is just
//a string (PDF 1.4, 3.2.3) or a text string (PDF 1.4, 3.8.1).
if (keyBase instanceof COSObject) {
return cacheClonedObject(keyBase, new PDFString(bytes));
} else {
if (PDFString.isUSASCII(bytes)) {
return cacheClonedObject(keyBase, string.getString());
} else {
return cacheClonedObject(keyBase, bytes);
}
}
}
private Object readCOSStream(COSStream originalStream, Object keyBase) throws IOException {
InputStream in;
Set filter;
if (pdfDoc.isEncryptionActive()
|| (originalStream.containsKey(COSName.DECODE_PARMS) && !originalStream.containsKey(COSName.FILTER))) {
in = originalStream.getUnfilteredStream();
filter = FILTER_FILTER;
} else {
//transfer encoded data (don't reencode)
in = originalStream.getFilteredStream();
filter = Collections.EMPTY_SET;
}
PDFStream stream = new PDFStream();
OutputStream out = stream.getBufferOutputStream();
IOUtils.copyLarge(in, out);
transferDict(originalStream, stream, filter);
return cacheClonedObject(keyBase, stream);
}
protected Object getCachedClone(Object base) throws IOException {
Object key = PDFBoxAdapterUtil.getBaseKey(base);
Object o = clonedVersion.get(key);
if (o == null) {
return objectCache.get(key);
}
return o;
}
protected Object cacheClonedObject(Object base, Object cloned) throws IOException {
Object key = PDFBoxAdapterUtil.getBaseKey(base);
if (key == null) {
return cloned;
}
PDFObject pdfobj = (PDFObject) cloned;
if (pdfobj != null && !pdfobj.hasObjectNumber() && !(base instanceof COSDictionary)) {
pdfDoc.registerObject(pdfobj);
if (log.isTraceEnabled()) {
log.trace(key + ": " + pdfobj.getClass().getName() + " registered as "
+ pdfobj.getObjectNumber() + " " + pdfobj.getGeneration());
}
}
clonedVersion.put(key, cloned);
if (key instanceof Integer) {
objectCache.put(key, cloned);
}
return cloned;
}
private void transferDict(COSDictionary orgDict, PDFStream targetDict, Set filter) throws IOException {
transferDict(orgDict, targetDict, filter, false);
}
private void transferDict(COSDictionary orgDict, PDFStream targetDict, Set filter, boolean inclusive)
throws IOException {
Set keys = orgDict.keySet();
for (COSName key : keys) {
if (inclusive && !filter.contains(key.getName())) {
continue;
} else if (!inclusive && filter.contains(key.getName())) {
continue;
}
targetDict.put(key.getName(),
cloneForNewDocument(orgDict.getItem(key)));
}
}
/**
* Creates a stream (from FOP's PDF library) from a PDF page parsed with PDFBox.
* @param sourceDoc the source PDF the given page to be copied belongs to
* @param page the page to transform into a stream
* @param key value to use as key for the stream
* @param atdoc adjustment for stream
* @param fontinfo fonts
* @param pos rectangle
* @return the stream
* @throws IOException if an I/O error occurs
*/
public String createStreamFromPDFBoxPage(PDDocument sourceDoc, PDPage page, String key,
AffineTransform atdoc, FontInfo fontinfo, Rectangle pos)
throws IOException {
handleAnnotations(sourceDoc, page, atdoc);
if (pageNumbers.containsKey(targetPage.getPageIndex())) {
pageNumbers.get(targetPage.getPageIndex()).set(0, targetPage.makeReference());
}
COSDictionary sourcePageResources = getResources(page);
PDStream pdStream = getContents(page);
COSDictionary fonts = (COSDictionary)sourcePageResources.getDictionaryObject(COSName.FONT);
COSDictionary fontsBackup = null;
UniqueName uniqueName = new UniqueName(key, sourcePageResources);
String newStream = null;
if (fonts != null && pdfDoc.isMergeFontsEnabled()) {
fontsBackup = new COSDictionary(fonts);
MergeFontsPDFWriter m = new MergeFontsPDFWriter(fonts, fontinfo, uniqueName, parentFonts, currentMCID);
newStream = m.writeText(pdStream);
// if (newStream != null) {
// for (Object f : fonts.keySet().toArray()) {
// COSDictionary fontdata = (COSDictionary)fonts.getDictionaryObject((COSName)f);
// if (getUniqueFontName(fontdata) != null) {
// fonts.removeItem((COSName)f);
// }
// }
// }
}
if (newStream == null) {
PDFWriter writer = new PDFWriter(uniqueName, currentMCID);
newStream = writer.writeText(pdStream);
currentMCID = writer.getCurrentMCID();
}
pdStream = new PDStream(sourceDoc, new ByteArrayInputStream(newStream.getBytes("ISO-8859-1")));
mergeXObj(sourcePageResources, fontinfo, uniqueName);
PDFDictionary pageResources = (PDFDictionary)cloneForNewDocument(sourcePageResources);
PDFDictionary fontDict = (PDFDictionary)pageResources.get("Font");
if (fontDict != null && pdfDoc.isMergeFontsEnabled()) {
for (Map.Entry fontEntry : fontinfo.getUsedFonts().entrySet()) {
Typeface font = fontEntry.getValue();
if (font instanceof FOPPDFFont) {
FOPPDFFont pdfFont = (FOPPDFFont)font;
if (pdfFont.getRef() == null) {
pdfFont.setRef(new PDFDictionary());
pdfDoc.assignObjectNumber(pdfFont.getRef());
}
fontDict.put(fontEntry.getKey(), pdfFont.getRef());
}
}
}
updateXObj(sourcePageResources, pageResources);
if (fontsBackup != null) {
sourcePageResources.setItem(COSName.FONT, fontsBackup);
}
COSStream originalPageContents = pdStream.getCOSObject();
bindOptionalContent(sourceDoc);
PDFStream pageStream;
Set filter;
// if (originalPageContents instanceof COSStreamArray) {
// COSStreamArray array = (COSStreamArray)originalPageContents;
// pageStream = new PDFStream();
// InputStream in = array.getUnfilteredStream();
// OutputStream out = pageStream.getBufferOutputStream();
// IOUtils.copyLarge(in, out);
// filter = FILTER_FILTER;
// } else {
pageStream = (PDFStream)cloneForNewDocument(originalPageContents);
filter = Collections.EMPTY_SET;
// }
if (pageStream == null) {
pageStream = new PDFStream();
}
if (originalPageContents != null) {
transferDict(originalPageContents, pageStream, filter);
}
transferPageDict(fonts, uniqueName, sourcePageResources);
PDRectangle mediaBox = page.getMediaBox();
PDRectangle cropBox = page.getCropBox();
PDRectangle viewBox = cropBox != null ? cropBox : mediaBox;
//Handle the /Rotation entry on the page dict
int rotation = PDFUtil.getNormalizedRotation(page);
//Transform to FOP's user space
float w = (float)pos.getWidth() / 1000f;
float h = (float)pos.getHeight() / 1000f;
if (rotation == 90 || rotation == 270) {
float tmp = w;
w = h;
h = tmp;
}
atdoc.setTransform(AffineTransform.getScaleInstance(w / viewBox.getWidth(), h / viewBox.getHeight()));
atdoc.translate(0, viewBox.getHeight());
atdoc.rotate(-Math.PI);
atdoc.scale(-1, 1);
atdoc.translate(-viewBox.getLowerLeftX(), -viewBox.getLowerLeftY());
PDFBoxAdapterUtil.rotate(rotation, viewBox, atdoc);
StringBuilder boxStr = new StringBuilder();
boxStr.append(PDFNumber.doubleOut(mediaBox.getLowerLeftX())).append(' ')
.append(PDFNumber.doubleOut(mediaBox.getLowerLeftY())).append(' ')
.append(PDFNumber.doubleOut(mediaBox.getWidth())).append(' ')
.append(PDFNumber.doubleOut(mediaBox.getHeight())).append(" re W n\n");
return boxStr.toString() + IOUtils.toString(pdStream.createInputStream(null), "ISO-8859-1");
}
private PDStream getContents(PDPage page) throws IOException {
PDStream pdStream = new PDStream(new COSStream());
OutputStream os = pdStream.createOutputStream();
IOUtils.copy(page.getContents(), os);
os.close();
return pdStream;
}
private COSDictionary getResources(PDPage page) {
PDResources res = page.getResources();
if (res == null) {
return new COSDictionary();
}
return res.getCOSObject();
}
private void mergeXObj(COSDictionary sourcePageResources, FontInfo fontinfo, UniqueName uniqueName)
throws IOException {
COSDictionary xobj = (COSDictionary) sourcePageResources.getDictionaryObject(COSName.XOBJECT);
if (xobj != null && pdfDoc.isMergeFontsEnabled()) {
for (Map.Entry i : xobj.entrySet()) {
COSObject v = (COSObject) i.getValue();
COSStream stream = (COSStream) v.getObject();
COSDictionary res = (COSDictionary) stream.getDictionaryObject(COSName.RESOURCES);
if (res != null) {
COSDictionary src = (COSDictionary) res.getDictionaryObject(COSName.FONT);
if (src != null) {
COSDictionary target = (COSDictionary) sourcePageResources.getDictionaryObject(COSName.FONT);
if (target == null) {
sourcePageResources.setItem(COSName.FONT, src);
} else {
for (Map.Entry entry : src.entrySet()) {
if (!target.keySet().contains(entry.getKey())) {
target.setItem(uniqueName.getName(entry.getKey()), entry.getValue());
}
}
}
PDFWriter writer = new MergeFontsPDFWriter(src, fontinfo, uniqueName, parentFonts, 0);
String c = writer.writeText(new PDStream(stream));
if (c != null) {
stream.removeItem(COSName.FILTER);
newXObj.put(i.getKey(), c);
for (Object e : src.keySet().toArray()) {
COSName name = (COSName) e;
src.setItem(uniqueName.getName(name), src.getItem(name));
src.removeItem(name);
}
}
}
}
}
}
}
private void updateXObj(COSDictionary sourcePageResources, PDFDictionary pageResources) throws IOException {
COSDictionary xobj = (COSDictionary) sourcePageResources.getDictionaryObject(COSName.XOBJECT);
if (xobj != null && pdfDoc.isMergeFontsEnabled()) {
PDFDictionary target = (PDFDictionary) pageResources.get("XObject");
for (COSName entry : xobj.keySet()) {
if (newXObj.containsKey(entry)) {
PDFStream s = (PDFStream) target.get(entry.getName());
s.setData(newXObj.get(entry).getBytes("ISO-8859-1"));
PDFDictionary xobjr = (PDFDictionary) s.get("Resources");
xobjr.put("Font", pageResources.get("Font"));
}
}
}
}
private void transferPageDict(COSDictionary fonts, UniqueName uniqueName, COSDictionary sourcePageResources)
throws IOException {
if (fonts != null) {
for (Map.Entry f : fonts.entrySet()) {
String name = uniqueName.getName(f.getKey());
targetPage.getPDFResources().addFont(name, (PDFDictionary)cloneForNewDocument(f.getValue()));
}
}
for (Map.Entry e : sourcePageResources.entrySet()) {
transferDict(e, uniqueName);
}
}
private void transferDict(Map.Entry dict, UniqueName uniqueName) throws IOException {
COSBase src;
if (dict.getValue() instanceof COSObject) {
src = ((COSObject) dict.getValue()).getObject();
} else {
src = dict.getValue();
}
if (dict.getKey() != COSName.FONT && src instanceof COSDictionary) {
String name = dict.getKey().getName();
PDFDictionary newDict = (PDFDictionary) targetPage.getPDFResources().get(name);
if (newDict == null) {
newDict = new PDFDictionary(targetPage.getPDFResources());
}
COSDictionary srcDict = (COSDictionary) src;
for (Map.Entry v : srcDict.entrySet()) {
newDict.put(uniqueName.getName(v.getKey()), cloneForNewDocument(v.getValue()));
}
targetPage.getPDFResources().put(name, newDict);
}
}
private void bindOptionalContent(PDDocument sourceDoc) throws IOException {
/*
* PDOptionalContentProperties ocProperties =
* sourceDoc.getDocumentCatalog().getOCProperties(); PDFDictionary ocDictionary =
* (PDFDictionary) cloneForNewDocument(ocProperties); if (ocDictionary != null) {
* this.pdfDoc.getRoot().put(COSName.OCPROPERTIES.getName(), ocDictionary); }
*/
}
private void handleAnnotations(PDDocument sourceDoc, PDPage page, AffineTransform at) throws IOException {
PDDocumentCatalog srcCatalog = sourceDoc.getDocumentCatalog();
PDAcroForm srcAcroForm = srcCatalog.getAcroForm();
List pageAnnotations = page.getAnnotations();
if (srcAcroForm == null && pageAnnotations.isEmpty()) {
return;
}
PDFBoxAdapterUtil.moveAnnotations(page, pageAnnotations, at);
//Pseudo-cache the target page in place of the original source page.
//This essentially replaces the original page reference with the target page.
COSObject cosPage = null;
COSDictionary parentDic = (COSDictionary) page.getCOSObject().getDictionaryObject(COSName.PARENT, COSName.P);
COSArray kids = (COSArray) parentDic.getDictionaryObject(COSName.KIDS);
for (int i = 0; i < kids.size(); i++) {
//Hopefully safe to cast, as kids need to be indirect objects
COSObject kid = (COSObject) kids.get(i);
if (!pageNumbers.containsKey(i)) {
PDFArray a = new PDFArray();
a.add(null);
pdfDoc.assignObjectNumber(a);
pdfDoc.addTrailerObject(a);
pageNumbers.put(i, a);
}
cacheClonedObject(kid, pageNumbers.get(i));
if (kid.getObject() == page.getCOSObject()) {
cosPage = kid;
}
}
if (cosPage == null) {
throw new IOException("Illegal PDF. Page not part of parent page node.");
}
Set fields = copyAnnotations(page);
boolean formAlreadyCopied = getCachedClone(srcAcroForm) != null;
PDFRoot catalog = this.pdfDoc.getRoot();
PDFDictionary destAcroForm = (PDFDictionary)catalog.get(COSName.ACRO_FORM.getName());
if (formAlreadyCopied) {
//skip, already copied
} else if (destAcroForm == null) {
if (srcAcroForm != null) {
//With this, only the first PDF's AcroForm is copied over. If later AcroForms have
//different properties besides the actual fields, these get lost. Only fields
//get merged.
Collection exclude = Collections.singletonList(COSName.FIELDS);
destAcroForm = (PDFDictionary)cloneForNewDocument(srcAcroForm, srcAcroForm, exclude);
} else {
//Work-around for incorrectly split PDFs which lack an AcroForm but have widgets
//on pages. This doesn't handle the case where field dicts have "C" entries
//(for the "CO" entry), so this may produce problems, but we have almost no chance
//to guess the calculation order.
destAcroForm = new PDFDictionary(pdfDoc.getRoot());
}
pdfDoc.assignObjectNumber(destAcroForm);
pdfDoc.addTrailerObject(destAcroForm);
catalog.put(COSName.ACRO_FORM.getName(), destAcroForm);
}
PDFArray clonedFields = (PDFArray) destAcroForm.get(COSName.FIELDS.getName());
if (clonedFields == null) {
clonedFields = new PDFArray();
destAcroForm.put(COSName.FIELDS.getName(), clonedFields);
}
for (COSObject field : fields) {
PDFDictionary clone = (PDFDictionary) cloneForNewDocument(field, field, Arrays.asList(COSName.KIDS));
clonedFields.add(clone);
}
}
private Set copyAnnotations(PDPage page) throws IOException {
COSArray annots = (COSArray) page.getCOSObject().getDictionaryObject(COSName.ANNOTS);
Set fields = Collections.emptySet();
if (annots != null) {
fields = new TreeSet(new CompareFields());
for (Object annot1 : annots) {
Collection exclude = new ArrayList();
exclude.add(COSName.P);
if (annot1 instanceof COSObject) {
COSObject annot = (COSObject) annot1;
getField(annot, fields);
if (((COSDictionary) annot.getObject()).getItem(COSName.STRUCT_PARENT) != null) {
exclude.add(COSName.PARENT);
}
}
PDFObject clonedAnnot = (PDFObject) cloneForNewDocument(annot1, annot1, exclude);
if (clonedAnnot instanceof PDFDictionary) {
clonedAnnot.setParent(targetPage);
PDFBoxAdapterUtil.updateAnnotationLink((PDFDictionary) clonedAnnot);
}
targetPage.addAnnotation(clonedAnnot);
}
}
return fields;
}
private COSDictionary getField(COSObject fieldObject, Set fields) {
COSDictionary field = (COSDictionary) fieldObject.getObject();
COSObject parent;
while ((parent = getParent(field)) != null) {
fieldObject = parent;
field = (COSDictionary) fieldObject.getObject();
}
fields.add(fieldObject);
return field;
}
private COSObject getParent(COSDictionary field) {
COSBase parent = field.getItem(COSName.PARENT);
if (parent instanceof COSObject) {
return (COSObject) parent;
}
return null;
}
static class CompareFields implements Comparator, Serializable {
private static final long serialVersionUID = -6081505461660440801L;
public int compare(COSObject o1, COSObject o2) {
return (int) (o1.getObjectNumber() - o2.getObjectNumber());
}
}
}