org.apache.fop.render.pdf.pdfbox.PDFCloner 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.
The newest version!
/*
* 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$ */
package org.apache.fop.render.pdf.pdfbox;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import java.util.Set;
import org.apache.commons.io.IOUtils;
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.common.COSObjectable;
import org.apache.pdfbox.pdmodel.common.PDStream;
import org.apache.fop.pdf.DCTFilter;
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.PDFStream;
public class PDFCloner {
private boolean trailer;
private PDFBoxAdapter adapter;
PDFCloner(PDFBoxAdapter adapter, boolean trailer) {
this.adapter = adapter;
this.trailer = trailer;
}
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 = adapter.getCachedClone(keyBase);
if (cached != null) {
// we are done, it has already been converted.
return cached;
} 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) {
PDFName newName = new PDFName(((COSName)base).getName());
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());
}
}
protected Object readCOSObject(COSObject object, Collection exclude) throws IOException {
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!");
}
}
return obj;
}
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())) {
String name = e.getKey().getName();
if (adapter.uniqueName != null) {
name = adapter.uniqueName.getName(e.getKey());
}
newDict.put(name, cloneForNewDocument(e.getValue(), e.getValue(), exclude));
}
}
return newDict;
}
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, new String(string.getBytes(), PDFDocument.ENCODING));
} else {
return cacheClonedObject(keyBase, bytes);
}
}
}
private Object readCOSStream(COSStream originalStream, Object keyBase) throws IOException {
InputStream in;
Set filter;
PDFStream stream = new PDFStream();
if (adapter.pdfDoc.isEncryptionActive() && originalStream.getItem(COSName.FILTER) == COSName.DCT_DECODE) {
stream.getFilterList().addFilter(new DCTFilter());
in = originalStream.createRawInputStream();
filter = Collections.EMPTY_SET;
} else if (adapter.pdfDoc.isEncryptionActive()
|| (originalStream.containsKey(COSName.DECODE_PARMS) && !originalStream.containsKey(COSName.FILTER))) {
in = originalStream.createInputStream();
filter = adapter.FILTER_FILTER;
} else {
//transfer encoded data (don't reencode)
in = originalStream.createRawInputStream();
filter = Collections.EMPTY_SET;
}
OutputStream out = stream.getBufferOutputStream();
if ((originalStream.getItem(COSName.TYPE) == COSName.PATTERN
|| originalStream.getItem(COSName.SUBTYPE) == COSName.FORM) && adapter.uniqueName != null) {
PDFWriter writer = new PDFWriter(adapter.uniqueName, adapter.currentMCID);
try {
String newStream = writer.writeText(new PDStream(originalStream));
if (writer.keyUsed) {
filter = adapter.FILTER_FILTER;
byte[] bytes = newStream.getBytes(PDFDocument.ENCODING);
out.write(bytes);
out.close();
try (OutputStream originalStreamOS = originalStream.createUnfilteredStream()) {
originalStreamOS.write(bytes);
}
in = null;
}
} catch (IOException e) {
//ignore
}
}
if (in != null) {
IOUtils.copyLarge(in, out);
}
adapter.transferDict(originalStream, stream, filter);
return cacheClonedObject(keyBase, stream);
}
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)) {
if (trailer) {
adapter.pdfDoc.registerTrailerObject(pdfobj);
} else {
adapter.pdfDoc.registerObject(pdfobj);
}
}
adapter.clonedVersion.put(key, cloned);
if (key instanceof Integer) {
adapter.objectCache.put(key, cloned);
}
return cloned;
}
}