/*
* 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;
import java.awt.color.ICC_Profile;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Date;
import java.util.EnumMap;
import java.util.List;
import java.util.Map;
import java.util.TimeZone;
import org.apache.commons.io.IOUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.xmlgraphics.java2d.color.profile.ColorProfileUtil;
import org.apache.xmlgraphics.util.DateFormatUtil;
import org.apache.xmlgraphics.xmp.Metadata;
import org.apache.xmlgraphics.xmp.schemas.DublinCoreSchema;
import org.apache.xmlgraphics.xmp.schemas.XMPBasicAdapter;
import org.apache.xmlgraphics.xmp.schemas.XMPBasicSchema;
import org.apache.fop.accessibility.Accessibility;
import org.apache.fop.apps.FOUserAgent;
import org.apache.fop.apps.io.InternalResourceResolver;
import org.apache.fop.fo.extensions.xmp.XMPMetadata;
import org.apache.fop.pdf.PDFAMode;
import org.apache.fop.pdf.PDFArray;
import org.apache.fop.pdf.PDFConformanceException;
import org.apache.fop.pdf.PDFDictionary;
import org.apache.fop.pdf.PDFDocument;
import org.apache.fop.pdf.PDFEmbeddedFile;
import org.apache.fop.pdf.PDFEmbeddedFiles;
import org.apache.fop.pdf.PDFEncryptionManager;
import org.apache.fop.pdf.PDFEncryptionParams;
import org.apache.fop.pdf.PDFFileSpec;
import org.apache.fop.pdf.PDFICCBasedColorSpace;
import org.apache.fop.pdf.PDFICCStream;
import org.apache.fop.pdf.PDFInfo;
import org.apache.fop.pdf.PDFLayer;
import org.apache.fop.pdf.PDFMetadata;
import org.apache.fop.pdf.PDFName;
import org.apache.fop.pdf.PDFNames;
import org.apache.fop.pdf.PDFNavigator;
import org.apache.fop.pdf.PDFNull;
import org.apache.fop.pdf.PDFNumber;
import org.apache.fop.pdf.PDFOutputIntent;
import org.apache.fop.pdf.PDFPage;
import org.apache.fop.pdf.PDFPageLabels;
import org.apache.fop.pdf.PDFReference;
import org.apache.fop.pdf.PDFSetOCGStateAction;
import org.apache.fop.pdf.PDFText;
import org.apache.fop.pdf.PDFTransitionAction;
import org.apache.fop.pdf.PDFXMode;
import org.apache.fop.pdf.Version;
import org.apache.fop.pdf.VersionController;
import org.apache.fop.render.pdf.extensions.PDFActionExtension;
import org.apache.fop.render.pdf.extensions.PDFArrayExtension;
import org.apache.fop.render.pdf.extensions.PDFCollectionEntryExtension;
import org.apache.fop.render.pdf.extensions.PDFDictionaryAttachment;
import org.apache.fop.render.pdf.extensions.PDFDictionaryExtension;
import org.apache.fop.render.pdf.extensions.PDFDictionaryType;
import org.apache.fop.render.pdf.extensions.PDFEmbeddedFileAttachment;
import org.apache.fop.render.pdf.extensions.PDFObjectType;
import org.apache.fop.render.pdf.extensions.PDFPageExtension;
import org.apache.fop.render.pdf.extensions.PDFReferenceExtension;
import static org.apache.fop.render.pdf.PDFEncryptionOption.ENCRYPTION_PARAMS;
import static org.apache.fop.render.pdf.PDFEncryptionOption.NO_ACCESSCONTENT;
import static org.apache.fop.render.pdf.PDFEncryptionOption.NO_ANNOTATIONS;
import static org.apache.fop.render.pdf.PDFEncryptionOption.NO_ASSEMBLEDOC;
import static org.apache.fop.render.pdf.PDFEncryptionOption.NO_COPY_CONTENT;
import static org.apache.fop.render.pdf.PDFEncryptionOption.NO_EDIT_CONTENT;
import static org.apache.fop.render.pdf.PDFEncryptionOption.NO_FILLINFORMS;
import static org.apache.fop.render.pdf.PDFEncryptionOption.NO_PRINT;
import static org.apache.fop.render.pdf.PDFEncryptionOption.NO_PRINTHQ;
import static org.apache.fop.render.pdf.PDFEncryptionOption.OWNER_PASSWORD;
import static org.apache.fop.render.pdf.PDFEncryptionOption.USER_PASSWORD;
/**
* Utility class which enables all sorts of features that are not directly connected to the
* normal rendering process.
*/
class PDFRenderingUtil {
/** logging instance */
private static Log log = LogFactory.getLog(PDFRenderingUtil.class);
private FOUserAgent userAgent;
/** the PDF Document being created */
private PDFDocument pdfDoc;
private PDFRendererOptionsConfig rendererConfig;
/** the ICC stream used as output profile by this document for PDF/A and PDF/X functionality. */
private PDFICCStream outputProfile;
/** the default sRGB color space. */
private PDFICCBasedColorSpace sRGBColorSpace;
PDFRenderingUtil(FOUserAgent userAgent) {
this.userAgent = userAgent;
initialize();
}
private void initialize() {
rendererConfig = PDFRendererOptionsConfig.DEFAULT.merge(createFromUserAgent(userAgent));
if (rendererConfig.getPDFAMode().isLevelA()) {
// PDF/A Level A requires tagged PDF
userAgent.getRendererOptions().put(Accessibility.ACCESSIBILITY, Boolean.TRUE);
}
}
private static PDFRendererOptionsConfig createFromUserAgent(FOUserAgent userAgent) {
Map<PDFRendererOption, Object> properties
= new EnumMap<PDFRendererOption, Object>(PDFRendererOption.class);
for (PDFRendererOption option : PDFRendererOption.values()) {
Object value = userAgent.getRendererOption(option);
properties.put(option, option.parse(value));
}
PDFEncryptionParams encryptionConfig = new EncryptionParamsBuilder().createParams(userAgent);
return new PDFRendererOptionsConfig(properties, encryptionConfig);
}
void mergeRendererOptionsConfig(PDFRendererOptionsConfig config) {
rendererConfig = rendererConfig.merge(config);
}
private void updateInfo() {
PDFInfo info = pdfDoc.getInfo();
info.setCreator(userAgent.getCreator());
info.setCreationDate(userAgent.getCreationDate());
info.setAuthor(userAgent.getAuthor());
info.setTitle(userAgent.getTitle());
info.setSubject(userAgent.getSubject());
info.setKeywords(userAgent.getKeywords());
}
private void updatePDFProfiles() {
pdfDoc.getProfile().setPDFAMode(rendererConfig.getPDFAMode());
pdfDoc.getProfile().setPDFUAMode(rendererConfig.getPDFUAMode());
userAgent.setPdfUAEnabled(pdfDoc.getProfile().getPDFUAMode().isEnabled());
pdfDoc.getProfile().setPDFXMode(rendererConfig.getPDFXMode());
pdfDoc.getProfile().setPDFVTMode(rendererConfig.getPDFVTMode());
}
private void addsRGBColorSpace() throws IOException {
if (rendererConfig.getDisableSRGBColorSpace()) {
if (rendererConfig.getPDFAMode() != PDFAMode.DISABLED
|| rendererConfig.getPDFXMode() != PDFXMode.DISABLED
|| rendererConfig.getOutputProfileURI() != null) {
throw new IllegalStateException("It is not possible to disable the sRGB color"
+ " space if PDF/A or PDF/X functionality is enabled or an"
+ " output profile is set!");
}
} else {
if (this.sRGBColorSpace != null) {
return;
}
//Map sRGB as default RGB profile for DeviceRGB
this.sRGBColorSpace = PDFICCBasedColorSpace.setupsRGBAsDefaultRGBColorSpace(pdfDoc);
}
}
private void addDefaultOutputProfile() throws IOException {
if (this.outputProfile != null) {
return;
}
ICC_Profile profile;
InputStream in = null;
URI outputProfileUri = rendererConfig.getOutputProfileURI();
if (outputProfileUri != null) {
this.outputProfile = pdfDoc.getFactory().makePDFICCStream();
in = userAgent.getResourceResolver().getResource(rendererConfig.getOutputProfileURI());
try {
profile = ColorProfileUtil.getICC_Profile(in);
} finally {
IOUtils.closeQuietly(in);
}
this.outputProfile.setColorSpace(profile, null);
} else {
//Fall back to sRGB profile
outputProfile = sRGBColorSpace.getICCStream();
}
}
/**
* Adds an OutputIntent to the PDF as mandated by PDF/A-1 when uncalibrated color spaces
* are used (which is true if we use DeviceRGB to represent sRGB colors).
* @throws IOException in case of an I/O problem
*/
private void addPDFA1OutputIntent() throws IOException {
addDefaultOutputProfile();
String desc = ColorProfileUtil.getICCProfileDescription(this.outputProfile.getICCProfile());
PDFOutputIntent outputIntent = pdfDoc.getFactory().makeOutputIntent();
outputIntent.setSubtype(PDFOutputIntent.GTS_PDFA1);
outputIntent.setDestOutputProfile(this.outputProfile);
outputIntent.setOutputConditionIdentifier(desc);
outputIntent.setInfo(outputIntent.getOutputConditionIdentifier());
pdfDoc.getRoot().addOutputIntent(outputIntent);
}
/**
* Adds an OutputIntent to the PDF as mandated by PDF/X when uncalibrated color spaces
* are used (which is true if we use DeviceRGB to represent sRGB colors).
* @throws IOException in case of an I/O problem
*/
private void addPDFXOutputIntent() throws IOException {
addDefaultOutputProfile();
String desc = ColorProfileUtil.getICCProfileDescription(this.outputProfile.getICCProfile());
int deviceClass = this.outputProfile.getICCProfile().getProfileClass();
if (deviceClass != ICC_Profile.CLASS_OUTPUT) {
throw new PDFConformanceException(pdfDoc.getProfile().getPDFXMode() + " requires that"
+ " the DestOutputProfile be an Output Device Profile. "
+ desc + " does not match that requirement.");
}
PDFOutputIntent outputIntent = pdfDoc.getFactory().makeOutputIntent();
outputIntent.setSubtype(PDFOutputIntent.GTS_PDFX);
outputIntent.setDestOutputProfile(this.outputProfile);
outputIntent.setOutputConditionIdentifier(desc);
outputIntent.setInfo(outputIntent.getOutputConditionIdentifier());
pdfDoc.getRoot().addOutputIntent(outputIntent);
}
public void renderXMPMetadata(XMPMetadata metadata) {
Metadata docXMP = metadata.getMetadata();
Metadata fopXMP = PDFMetadata.createXMPFromPDFDocument(pdfDoc);
//Merge FOP's own metadata into the one from the XSL-FO document
List<Class> exclude = new ArrayList<Class>();
if (pdfDoc.getProfile().getPDFAMode().isPart1()) {
exclude.add(DublinCoreSchema.class);
}
fopXMP.mergeInto(docXMP, exclude);
XMPBasicAdapter xmpBasic = XMPBasicSchema.getAdapter(docXMP);
//Metadata was changed so update metadata date
xmpBasic.setMetadataDate(new java.util.Date());
PDFMetadata.updateInfoFromMetadata(docXMP, pdfDoc.getInfo());
PDFMetadata pdfMetadata = pdfDoc.getFactory().makeMetadata(
docXMP, metadata.isReadOnly());
pdfDoc.getRoot().setMetadata(pdfMetadata);
}
public void generateDefaultXMPMetadata() {
if (pdfDoc.getRoot().getMetadata() == null) {
//If at this time no XMP metadata for the overall document has been set, create it
//from the PDFInfo object.
Metadata xmp = PDFMetadata.createXMPFromPDFDocument(pdfDoc);
PDFMetadata pdfMetadata = pdfDoc.getFactory().makeMetadata(
xmp, true);
pdfDoc.getRoot().setMetadata(pdfMetadata);
}
}
public void renderDictionaryExtension(PDFDictionaryAttachment attachment, PDFPage currentPage) {
PDFDictionaryExtension extension = attachment.getExtension();
PDFDictionaryType type = extension.getDictionaryType();
if (type == PDFDictionaryType.Action) {
addNavigatorAction(extension);
} else if (type == PDFDictionaryType.Layer) {
addLayer(extension);
} else if (type == PDFDictionaryType.Navigator) {
addNavigator(extension);
} else {
renderDictionaryExtension(extension, currentPage);
}
}
public void addLayer(PDFDictionaryExtension extension) {
assert extension.getDictionaryType() == PDFDictionaryType.Layer;
String id = extension.getProperty(PDFDictionaryExtension.PROPERTY_ID);
if ((id != null) && (id.length() > 0)) {
PDFLayer layer = pdfDoc.getFactory().makeLayer(id);
layer.setResolver(new PDFLayer.Resolver(layer, extension) {
public void performResolution() {
PDFDictionaryExtension extension = (PDFDictionaryExtension) getExtension();
Object name = extension.findEntryValue("Name");
Object intent = extension.findEntryValue("Intent");
Object usage = makeDictionary(extension.findEntryValue("Usage"));
getLayer().populate(name, intent, usage);
}
});
}
}
public void addNavigatorAction(PDFDictionaryExtension extension) {
assert extension.getDictionaryType() == PDFDictionaryType.Action;
String id = extension.getProperty(PDFDictionaryExtension.PROPERTY_ID);
if ((id != null) && (id.length() > 0)) {
String type = extension.getProperty(PDFActionExtension.PROPERTY_TYPE);
if (type != null) {
if (type.equals("SetOCGState")) {
PDFSetOCGStateAction action = pdfDoc.getFactory().makeSetOCGStateAction(id);
action.setResolver(new PDFSetOCGStateAction.Resolver(action, extension) {
public void performResolution() {
PDFDictionaryExtension extension = (PDFDictionaryExtension) getExtension();
Object state = makeArray(extension.findEntryValue("State"));
Object preserveRB = extension.findEntryValue("PreserveRB");
Object nextAction = makeDictionaryOrArray(extension.findEntryValue("Next"));
getAction().populate(state, preserveRB, nextAction);
}
});
} else if (type.equals("Trans")) {
PDFTransitionAction action = pdfDoc.getFactory().makeTransitionAction(id);
action.setResolver(new PDFTransitionAction.Resolver(action, extension) {
public void performResolution() {
PDFDictionaryExtension extension = (PDFDictionaryExtension) getExtension();
Object transition = makeDictionary(extension.findEntryValue("Trans"));
Object nextAction = makeDictionaryOrArray(extension.findEntryValue("Next"));
getAction().populate(transition, nextAction);
}
});
} else {
throw new UnsupportedOperationException();
}
}
}
}
public void addNavigator(PDFDictionaryExtension extension) {
assert extension.getDictionaryType() == PDFDictionaryType.Navigator;
String id = extension.getProperty(PDFDictionaryExtension.PROPERTY_ID);
if ((id != null) && (id.length() > 0)) {
PDFNavigator navigator = pdfDoc.getFactory().makeNavigator(id);
navigator.setResolver(new PDFNavigator.Resolver(navigator, extension) {
public void performResolution() {
PDFDictionaryExtension extension = (PDFDictionaryExtension) getExtension();
Object nextAction = makeDictionary(extension.findEntryValue("NA"));
Object next = makeDictionary(extension.findEntryValue("Next"));
Object prevAction = makeDictionary(extension.findEntryValue("PA"));
Object prev = makeDictionary(extension.findEntryValue("Prev"));
Object duration = extension.findEntryValue("Dur");
getNavigator().populate(nextAction, next, prevAction, prev, duration);
}
});
}
}
private Object makeArray(Object value) {
if (value == null) {
return null;
} else if (value instanceof PDFReferenceExtension) {
return resolveReference((PDFReferenceExtension) value);
} else if (value instanceof List<?>) {
return populateArray(new PDFArray(), (List<?>) value);
} else {
throw new IllegalArgumentException();
}
}
private Object populateArray(PDFArray array, List<?> entries) {
for (PDFCollectionEntryExtension entry : (List<PDFCollectionEntryExtension>) entries) {
PDFObjectType type = entry.getType();
if (type == PDFObjectType.Array) {
array.add(makeArray(entry.getValue()));
} else if (type == PDFObjectType.Boolean) {
array.add(entry.getValueAsBoolean());
} else if (type == PDFObjectType.Dictionary) {
array.add(makeDictionary(entry.getValue()));
} else if (type == PDFObjectType.Name) {
array.add(new PDFName(entry.getValueAsString()));
} else if (type == PDFObjectType.Number) {
array.add(new PDFNumber(entry.getValueAsNumber()));
} else if (type == PDFObjectType.Reference) {
assert (entry instanceof PDFReferenceExtension);
array.add(resolveReference((PDFReferenceExtension) entry));
} else if (type == PDFObjectType.String) {
array.add(entry.getValue());
}
}
return array;
}
private Object makeDictionary(Object value) {
if (value == null) {
return null;
} else if (value instanceof PDFReferenceExtension) {
return resolveReference((PDFReferenceExtension) value);
} else if (value instanceof List<?>) {
return populateDictionary(new PDFDictionary(), (List<?>) value);
} else {
throw new IllegalArgumentException();
}
}
private Object populateDictionary(PDFDictionary dictionary, List<?> entries) {
for (PDFCollectionEntryExtension entry : (List<PDFCollectionEntryExtension>) entries) {
PDFObjectType type = entry.getType();
String key = entry.getKey();
if (type == PDFObjectType.Array) {
dictionary.put(key, makeArray(entry.getValue()));
} else if (type == PDFObjectType.Boolean) {
dictionary.put(key, entry.getValueAsBoolean());
} else if (type == PDFObjectType.Dictionary) {
dictionary.put(key, makeDictionary(entry.getValue()));
} else if (type == PDFObjectType.Name) {
dictionary.put(key, new PDFName(entry.getValueAsString()));
} else if (type == PDFObjectType.Number) {
dictionary.put(key, new PDFNumber(entry.getValueAsNumber()));
} else if (type == PDFObjectType.Reference) {
assert (entry instanceof PDFReferenceExtension);
dictionary.put(key, resolveReference((PDFReferenceExtension) entry));
} else if (type == PDFObjectType.String) {
dictionary.put(key, entry.getValue());
}
}
return dictionary;
}
private Object makeDictionaryOrArray(Object value) {
if (value == null) {
return null;
} else if (value instanceof PDFReferenceExtension) {
return resolveReference((PDFReferenceExtension) value);
} else if (value instanceof List<?>) {
if (hasKeyedEntry((List<?>) value)) {
return populateDictionary(new PDFDictionary(), (List<?>) value);
} else {
return populateArray(new PDFArray(), (List<?>) value);
}
} else {
throw new IllegalArgumentException();
}
}
private boolean hasKeyedEntry(List<?> entries) {
for (PDFCollectionEntryExtension entry : (List<PDFCollectionEntryExtension>) entries) {
if (entry.getKey() != null) {
return true;
}
}
return false;
}
public void renderDictionaryExtension(PDFDictionaryExtension extension, PDFPage currentPage) {
PDFDictionaryType type = extension.getDictionaryType();
if (type == PDFDictionaryType.Catalog) {
augmentDictionary(pdfDoc.getRoot(), extension);
} else if (type == PDFDictionaryType.Page) {
assert extension instanceof PDFPageExtension;
if (((PDFPageExtension) extension).matchesPageNumber(currentPage.getPageIndex() + 1)) {
augmentDictionary(currentPage, extension);
}
} else if (type == PDFDictionaryType.Info) {
PDFInfo info = pdfDoc.getInfo();
for (PDFCollectionEntryExtension entry : extension.getEntries()) {
info.put(entry.getKey(), entry.getValueAsString());
}
} else if (type == PDFDictionaryType.VT) {
if (currentPage.get("DPart") != null) {
augmentDictionary((PDFDictionary)currentPage.get("DPart"), extension);
}
} else if (type == PDFDictionaryType.PagePiece) {
String date = DateFormatUtil.formatPDFDate(new Date(), TimeZone.getDefault());
if (currentPage.get("PieceInfo") == null) {
currentPage.put("PieceInfo", new PDFDictionary());
currentPage.put("LastModified", date);
}
PDFDictionary d = augmentDictionary((PDFDictionary)currentPage.get("PieceInfo"), extension);
d.put("LastModified", date);
} else {
throw new IllegalStateException();
}
}
private PDFDictionary augmentDictionary(PDFDictionary dictionary, PDFDictionaryExtension extension) {
for (PDFCollectionEntryExtension entry : extension.getEntries()) {
if (entry instanceof PDFDictionaryExtension) {
String[] keys = entry.getKey().split("/");
for (int i = 0; i < keys.length; i++) {
if (keys[i].isEmpty()) {
throw new IllegalStateException("pdf:dictionary key: " + entry.getKey() + " not valid");
}
if (i == keys.length - 1) {
dictionary.put(keys[i],
augmentDictionary(new PDFDictionary(dictionary), (PDFDictionaryExtension) entry));
} else {
PDFDictionary d = new PDFDictionary();
dictionary.put(keys[i], d);
dictionary = d;
}
}
} else if (entry instanceof PDFArrayExtension) {
dictionary.put(entry.getKey(), augmentArray(new PDFArray(dictionary), (PDFArrayExtension) entry));
} else {
augmentDictionary(dictionary, entry);
}
}
return dictionary;
}
private void augmentDictionary(PDFDictionary dictionary, PDFCollectionEntryExtension entry) {
PDFObjectType type = entry.getType();
String key = entry.getKey();
if (type == PDFObjectType.Boolean) {
dictionary.put(key, entry.getValueAsBoolean());
} else if (type == PDFObjectType.Name) {
dictionary.put(key, new PDFName(entry.getValueAsString()));
} else if (type == PDFObjectType.Number) {
dictionary.put(key, new PDFNumber(entry.getValueAsNumber()));
} else if (type == PDFObjectType.Reference) {
assert entry instanceof PDFReferenceExtension;
dictionary.put(key, resolveReference((PDFReferenceExtension) entry));
} else if (type == PDFObjectType.String) {
dictionary.put(key, entry.getValueAsString());
} else {
throw new IllegalStateException();
}
}
private Object resolveReference(PDFReferenceExtension entry) {
PDFReference reference = (PDFReference) entry.getResolvedReference();
if (reference == null) {
reference = pdfDoc.resolveExtensionReference(entry.getReferenceId());
if (reference != null) {
entry.setResolvedReference(reference);
}
return reference;
}
return PDFNull.INSTANCE;
}
private PDFArray augmentArray(PDFArray array, PDFArrayExtension extension) {
for (PDFCollectionEntryExtension entry : extension.getEntries()) {
if (entry instanceof PDFDictionaryExtension) {
array.add(augmentDictionary(new PDFDictionary(array), (PDFDictionaryExtension) entry));
} else if (entry instanceof PDFArrayExtension) {
array.add(augmentArray(new PDFArray(array), (PDFArrayExtension) entry));
} else {
augmentArray(array, entry);
}
}
return array;
}
private void augmentArray(PDFArray array, PDFCollectionEntryExtension entry) {
PDFObjectType type = entry.getType();
if (type == PDFObjectType.Boolean) {
array.add(entry.getValueAsBoolean());
} else if (type == PDFObjectType.Name) {
array.add(new PDFName(entry.getValueAsString()));
} else if (type == PDFObjectType.Number) {
array.add(new PDFNumber(entry.getValueAsNumber()));
} else if (type == PDFObjectType.Reference) {
assert entry instanceof PDFReferenceExtension;
array.add(resolveReference((PDFReferenceExtension) entry));
} else if (type == PDFObjectType.String) {
array.add(entry.getValueAsString());
} else {
throw new IllegalStateException();
}
}
public PDFDocument setupPDFDocument(OutputStream out) throws IOException {
if (this.pdfDoc != null) {
throw new IllegalStateException("PDFDocument already set up");
}
String producer = userAgent.getProducer() != null ? userAgent.getProducer() : "";
final Version maxPDFVersion = rendererConfig.getPDFVersion();
if (maxPDFVersion == null) {
this.pdfDoc = new PDFDocument(producer);
} else {
VersionController controller
= VersionController.getFixedVersionController(maxPDFVersion);
this.pdfDoc = new PDFDocument(producer, controller);
}
updateInfo();
updatePDFProfiles();
pdfDoc.setFilterMap(rendererConfig.getFilterMap());
pdfDoc.outputHeader(out);
//Setup encryption if necessary
PDFEncryptionManager.setupPDFEncryption(rendererConfig.getEncryptionParameters(), pdfDoc);
addsRGBColorSpace();
if (rendererConfig.getOutputProfileURI() != null) {
addDefaultOutputProfile();
}
PDFXMode pdfXMode = rendererConfig.getPDFXMode();
if (pdfXMode != PDFXMode.DISABLED) {
log.debug(pdfXMode + " is active.");
log.warn("Note: " + pdfXMode
+ " support is work-in-progress and not fully implemented, yet!");
addPDFXOutputIntent();
}
PDFAMode pdfAMode = rendererConfig.getPDFAMode();
if (pdfAMode.isEnabled()) {
log.debug("PDF/A is active. Conformance Level: " + pdfAMode);
addPDFA1OutputIntent();
}
this.pdfDoc.enableAccessibility(userAgent.isAccessibilityEnabled());
pdfDoc.setMergeFontsEnabled(rendererConfig.getMergeFontsEnabled());
pdfDoc.setLinearizationEnabled(rendererConfig.getLinearizationEnabled());
return this.pdfDoc;
}
/**
* Generates a page label in the PDF document.
* @param pageIndex the index of the page
* @param pageNumber the formatted page number
*/
public void generatePageLabel(int pageIndex, String pageNumber) {
//Produce page labels
PDFPageLabels pageLabels = this.pdfDoc.getRoot().getPageLabels();
if (pageLabels == null) {
//Set up PageLabels
pageLabels = this.pdfDoc.getFactory().makePageLabels();
this.pdfDoc.getRoot().setPageLabels(pageLabels);
}
pageLabels.addPageLabel(pageIndex, pageNumber);
}
/**
* Adds an embedded file to the PDF file.
* @param embeddedFile the object representing the embedded file to be added
* @throws IOException if an I/O error occurs
*/
public void addEmbeddedFile(PDFEmbeddedFileAttachment embeddedFile)
throws IOException {
this.pdfDoc.getProfile().verifyEmbeddedFilesAllowed();
PDFNames names = this.pdfDoc.getRoot().getNames();
if (names == null) {
//Add Names if not already present
names = this.pdfDoc.getFactory().makeNames();
this.pdfDoc.getRoot().setNames(names);
}
//Create embedded file
PDFEmbeddedFile file = new PDFEmbeddedFile();
this.pdfDoc.registerObject(file);
URI srcURI;
try {
srcURI = InternalResourceResolver.cleanURI(embeddedFile.getSrc());
} catch (URISyntaxException use) {
throw new RuntimeException(use);
}
InputStream in = userAgent.getResourceResolver().getResource(srcURI);
if (in == null) {
throw new FileNotFoundException(embeddedFile.getSrc());
}
try {
OutputStream out = file.getBufferOutputStream();
IOUtils.copyLarge(in, out);
} finally {
IOUtils.closeQuietly(in);
}
PDFDictionary dict = new PDFDictionary();
dict.put("F", file);
String filename = PDFText.toPDFString(embeddedFile.getFilename(), '_');
PDFFileSpec fileSpec = new PDFFileSpec(filename);
pdfDoc.getRoot().addAF(fileSpec, filename);
fileSpec.setEmbeddedFile(dict);
if (embeddedFile.getDesc() != null) {
fileSpec.setDescription(embeddedFile.getDesc());
}
this.pdfDoc.registerObject(fileSpec);
//Make sure there is an EmbeddedFiles in the Names dictionary
PDFEmbeddedFiles embeddedFiles = names.getEmbeddedFiles();
if (embeddedFiles == null) {
embeddedFiles = new PDFEmbeddedFiles();
this.pdfDoc.assignObjectNumber(embeddedFiles);
this.pdfDoc.addTrailerObject(embeddedFiles);
names.setEmbeddedFiles(embeddedFiles);
}
//Add to EmbeddedFiles in the Names dictionary
PDFArray nameArray = embeddedFiles.getNames();
if (nameArray == null) {
nameArray = new PDFArray();
embeddedFiles.setNames(nameArray);
}
String name = PDFText.toPDFString(filename);
nameArray.add(name);
nameArray.add(new PDFReference(fileSpec));
}
private static final class EncryptionParamsBuilder {
private PDFEncryptionParams params;
private EncryptionParamsBuilder() {
}
private PDFEncryptionParams createParams(FOUserAgent userAgent) {
params = (PDFEncryptionParams) userAgent.getRendererOptions().get(ENCRYPTION_PARAMS);
String userPassword = (String) userAgent.getRendererOption(USER_PASSWORD);
if (userPassword != null) {
getEncryptionParams().setUserPassword(userPassword);
}
String ownerPassword = (String) userAgent.getRendererOption(OWNER_PASSWORD);
if (ownerPassword != null) {
getEncryptionParams().setOwnerPassword(ownerPassword);
}
Object noPrint = userAgent.getRendererOption(NO_PRINT);
if (noPrint != null) {
getEncryptionParams().setAllowPrint(!booleanValueOf(noPrint));
}
Object noCopyContent = userAgent.getRendererOption(NO_COPY_CONTENT);
if (noCopyContent != null) {
getEncryptionParams().setAllowCopyContent(!booleanValueOf(noCopyContent));
}
Object noEditContent = userAgent.getRendererOption(NO_EDIT_CONTENT);
if (noEditContent != null) {
getEncryptionParams().setAllowEditContent(!booleanValueOf(noEditContent));
}
Object noAnnotations = userAgent.getRendererOption(NO_ANNOTATIONS);
if (noAnnotations != null) {
getEncryptionParams().setAllowEditAnnotations(!booleanValueOf(noAnnotations));
}
Object noFillInForms = userAgent.getRendererOption(NO_FILLINFORMS);
if (noFillInForms != null) {
getEncryptionParams().setAllowFillInForms(!booleanValueOf(noFillInForms));
}
Object noAccessContent = userAgent.getRendererOption(NO_ACCESSCONTENT);
if (noAccessContent != null) {
getEncryptionParams().setAllowAccessContent(!booleanValueOf(noAccessContent));
}
Object noAssembleDoc = userAgent.getRendererOption(NO_ASSEMBLEDOC);
if (noAssembleDoc != null) {
getEncryptionParams().setAllowAssembleDocument(!booleanValueOf(noAssembleDoc));
}
Object noPrintHQ = userAgent.getRendererOption(NO_PRINTHQ);
if (noPrintHQ != null) {
getEncryptionParams().setAllowPrintHq(!booleanValueOf(noPrintHQ));
}
return params;
}
private PDFEncryptionParams getEncryptionParams() {
if (params == null) {
params = new PDFEncryptionParams();
}
return params;
}
private static boolean booleanValueOf(Object obj) {
if (obj instanceof Boolean) {
return (Boolean) obj;
} else if (obj instanceof String) {
return Boolean.valueOf((String) obj);
} else {
throw new IllegalArgumentException("Boolean or \"true\" or \"false\" expected.");
}
}
}
}