org.apache.fop.render.pdf.PDFRenderer Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of fop Show documentation
Show all versions of fop Show documentation
Apache FOP (Formatting Objects Processor) is the world's first print formatter driven by XSL formatting objects (XSL-FO) and the world's first output independent formatter. It is a Java application that reads a formatting object (FO) tree and renders the resulting pages to a specified output. Output formats currently supported include PDF, PCL, PS, AFP, TIFF, PNG, SVG, XML (area tree representation), Print, AWT and TXT. The primary output target is PDF.
/*
* 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: PDFRenderer.java 938005 2010-04-26 11:26:08Z jeremias $ */
package org.apache.fop.render.pdf;
// Java
import java.awt.Color;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.geom.AffineTransform;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.apache.xmlgraphics.image.loader.ImageException;
import org.apache.xmlgraphics.image.loader.ImageFlavor;
import org.apache.xmlgraphics.image.loader.ImageInfo;
import org.apache.xmlgraphics.image.loader.ImageManager;
import org.apache.xmlgraphics.image.loader.ImageSessionContext;
import org.apache.xmlgraphics.image.loader.util.ImageUtil;
import org.apache.fop.ResourceEventProducer;
import org.apache.fop.apps.FOPException;
import org.apache.fop.apps.FOUserAgent;
import org.apache.fop.apps.MimeConstants;
import org.apache.fop.area.Area;
import org.apache.fop.area.Block;
import org.apache.fop.area.BookmarkData;
import org.apache.fop.area.CTM;
import org.apache.fop.area.DestinationData;
import org.apache.fop.area.LineArea;
import org.apache.fop.area.OffDocumentExtensionAttachment;
import org.apache.fop.area.OffDocumentItem;
import org.apache.fop.area.PageSequence;
import org.apache.fop.area.PageViewport;
import org.apache.fop.area.Trait;
import org.apache.fop.area.inline.AbstractTextArea;
import org.apache.fop.area.inline.Image;
import org.apache.fop.area.inline.InlineArea;
import org.apache.fop.area.inline.InlineParent;
import org.apache.fop.area.inline.Leader;
import org.apache.fop.area.inline.SpaceArea;
import org.apache.fop.area.inline.TextArea;
import org.apache.fop.area.inline.Viewport;
import org.apache.fop.area.inline.WordArea;
import org.apache.fop.datatypes.URISpecification;
import org.apache.fop.fo.extensions.ExtensionAttachment;
import org.apache.fop.fo.extensions.xmp.XMPMetadata;
import org.apache.fop.fonts.Font;
import org.apache.fop.fonts.LazyFont;
import org.apache.fop.fonts.SingleByteFont;
import org.apache.fop.fonts.Typeface;
import org.apache.fop.pdf.PDFAMode;
import org.apache.fop.pdf.PDFAction;
import org.apache.fop.pdf.PDFAnnotList;
import org.apache.fop.pdf.PDFDocument;
import org.apache.fop.pdf.PDFEncryptionParams;
import org.apache.fop.pdf.PDFFactory;
import org.apache.fop.pdf.PDFGoTo;
import org.apache.fop.pdf.PDFInfo;
import org.apache.fop.pdf.PDFLink;
import org.apache.fop.pdf.PDFNumber;
import org.apache.fop.pdf.PDFOutline;
import org.apache.fop.pdf.PDFPage;
import org.apache.fop.pdf.PDFPaintingState;
import org.apache.fop.pdf.PDFResourceContext;
import org.apache.fop.pdf.PDFResources;
import org.apache.fop.pdf.PDFTextUtil;
import org.apache.fop.pdf.PDFXMode;
import org.apache.fop.pdf.PDFXObject;
import org.apache.fop.render.AbstractPathOrientedRenderer;
import org.apache.fop.render.Graphics2DAdapter;
import org.apache.fop.render.RendererContext;
import org.apache.fop.render.pdf.PDFLogicalStructureHandler.MarkedContentInfo;
import org.apache.fop.traits.RuleStyle;
import org.apache.fop.util.AbstractPaintingState;
import org.apache.fop.util.CharUtilities;
import org.apache.fop.util.XMLUtil;
import org.apache.fop.util.AbstractPaintingState.AbstractData;
/**
* Renderer that renders areas to PDF.
*/
public class PDFRenderer extends AbstractPathOrientedRenderer implements PDFConfigurationConstants {
/** The MIME type for PDF */
public static final String MIME_TYPE = MimeConstants.MIME_PDF;
/** Normal PDF resolution (72dpi) */
public static final int NORMAL_PDF_RESOLUTION = 72;
/** Controls whether comments are written to the PDF stream. */
protected static final boolean WRITE_COMMENTS = true;
/**
* the PDF Document being created
*/
protected PDFDocument pdfDoc;
/**
* Utility class which enables all sorts of features that are not directly connected to the
* normal rendering process.
*/
protected PDFRenderingUtil pdfUtil;
/**
* Map of pages using the PageViewport as the key
* this is used for prepared pages that cannot be immediately
* rendered
*/
private Map pages;
/**
* Maps unique PageViewport key to PDF page reference
*/
protected Map pageReferences = new java.util.HashMap();
/**
* Maps unique PageViewport key back to PageViewport itself
*/
//protected Map pvReferences = new java.util.HashMap();
/**
* Maps XSL-FO element IDs to their on-page XY-positions
* Must be used in conjunction with the page reference to fully specify the PDFGoTo details
*/
protected Map idPositions = new java.util.HashMap();
/**
* Maps XSL-FO element IDs to PDFGoTo objects targeting the corresponding areas
* These objects may not all be fully filled in yet
*/
protected Map idGoTos = new java.util.HashMap();
/**
* The PDFGoTos in idGoTos that are not complete yet
*/
protected List unfinishedGoTos = new java.util.ArrayList();
// can't use a Set because PDFGoTo.equals returns true if the target is the same,
// even if the object number differs
/**
* The output stream to write the document to
*/
protected OutputStream ostream;
/**
* the /Resources object of the PDF document being created
*/
protected PDFResources pdfResources;
/** The current content generator to produce PDF commands with */
protected PDFContentGenerator generator;
private PDFBorderPainter borderPainter;
/**
* the current annotation list to add annotations to
*/
protected PDFResourceContext currentContext = null;
/**
* the current page to add annotations to
*/
protected PDFPage currentPage;
/**
* the current page's PDF reference string (to avoid numerous function calls)
*/
protected String currentPageRef;
/** page height */
protected int pageHeight;
/** Image handler registry */
private final PDFImageHandlerRegistry imageHandlerRegistry = new PDFImageHandlerRegistry();
private boolean accessEnabled;
private PDFLogicalStructureHandler logicalStructureHandler;
private int pageSequenceIndex;
/** Reference in the structure tree to the image being rendered. */
private String imageReference;
/**
* create the PDF renderer
*/
public PDFRenderer() {
}
/** {@inheritDoc} */
public void setUserAgent(FOUserAgent agent) {
super.setUserAgent(agent);
this.pdfUtil = new PDFRenderingUtil(getUserAgent());
accessEnabled = agent.isAccessibilityEnabled();
}
PDFRenderingUtil getPDFUtil() {
return this.pdfUtil;
}
PDFContentGenerator getGenerator() {
return this.generator;
}
PDFPaintingState getState() {
return getGenerator().getState();
}
/** {@inheritDoc} */
public void startRenderer(OutputStream stream) throws IOException {
if (userAgent == null) {
throw new IllegalStateException("UserAgent must be set before starting the renderer");
}
ostream = stream;
this.pdfDoc = pdfUtil.setupPDFDocument(stream);
if (accessEnabled) {
pdfDoc.getRoot().makeTagged();
logicalStructureHandler = new PDFLogicalStructureHandler(pdfDoc,
userAgent.getEventBroadcaster());
}
}
/**
* Checks if there are any unfinished PDFGoTos left in the list and resolves them
* to a default position on the page. Logs a warning, as this should not happen.
*/
protected void finishOpenGoTos() {
int count = unfinishedGoTos.size();
if (count > 0) {
// TODO : page height may not be the same for all targeted pages
Point2D.Float defaultPos = new Point2D.Float(0f, pageHeight / 1000f); // top-o-page
while (!unfinishedGoTos.isEmpty()) {
PDFGoTo gt = (PDFGoTo) unfinishedGoTos.get(0);
finishIDGoTo(gt, defaultPos);
}
PDFEventProducer eventProducer = PDFEventProducer.Provider.get(
getUserAgent().getEventBroadcaster());
eventProducer.nonFullyResolvedLinkTargets(this, count);
// dysfunctional if pageref is null
}
}
/** {@inheritDoc} */
public void stopRenderer() throws IOException {
finishOpenGoTos();
pdfDoc.getResources().addFonts(pdfDoc, fontInfo);
pdfDoc.outputTrailer(ostream);
this.pdfDoc = null;
ostream = null;
pages = null;
pageReferences.clear();
//pvReferences.clear();
pdfResources = null;
this.generator = null;
currentContext = null;
currentPage = null;
idPositions.clear();
idGoTos.clear();
}
/**
* {@inheritDoc}
*/
public boolean supportsOutOfOrder() {
return !accessEnabled;
}
/**
* {@inheritDoc}
*/
public void processOffDocumentItem(OffDocumentItem odi) {
if (odi instanceof DestinationData) {
// render Destinations
renderDestination((DestinationData) odi);
} else if (odi instanceof BookmarkData) {
// render Bookmark-Tree
renderBookmarkTree((BookmarkData) odi);
} else if (odi instanceof OffDocumentExtensionAttachment) {
ExtensionAttachment attachment = ((OffDocumentExtensionAttachment)odi).getAttachment();
if (XMPMetadata.CATEGORY.equals(attachment.getCategory())) {
pdfUtil.renderXMPMetadata((XMPMetadata)attachment);
}
}
}
private void renderDestination(DestinationData dd) {
String targetID = dd.getIDRef();
if (targetID == null || targetID.length() == 0) {
throw new IllegalArgumentException("DestinationData must contain a ID reference");
}
PageViewport pv = dd.getPageViewport();
if (pv != null) {
PDFGoTo gt = getPDFGoToForID(targetID, pv.getKey());
pdfDoc.getFactory().makeDestination(
dd.getIDRef(), gt.makeReference());
} else {
//Warning already issued by AreaTreeHandler (debug level is sufficient)
log.debug("Unresolved destination item received: " + dd.getIDRef());
}
}
/**
* Renders a Bookmark-Tree object
* @param bookmarks the BookmarkData object containing all the Bookmark-Items
*/
protected void renderBookmarkTree(BookmarkData bookmarks) {
for (int i = 0; i < bookmarks.getCount(); i++) {
BookmarkData ext = bookmarks.getSubData(i);
renderBookmarkItem(ext, null);
}
}
private void renderBookmarkItem(BookmarkData bookmarkItem,
PDFOutline parentBookmarkItem) {
PDFOutline pdfOutline = null;
String targetID = bookmarkItem.getIDRef();
if (targetID == null || targetID.length() == 0) {
throw new IllegalArgumentException("DestinationData must contain a ID reference");
}
PageViewport pv = bookmarkItem.getPageViewport();
if (pv != null) {
String pvKey = pv.getKey();
PDFGoTo gt = getPDFGoToForID(targetID, pvKey);
// create outline object:
PDFOutline parent = parentBookmarkItem != null
? parentBookmarkItem
: pdfDoc.getOutlineRoot();
pdfOutline = pdfDoc.getFactory().makeOutline(parent,
bookmarkItem.getBookmarkTitle(), gt, bookmarkItem.showChildItems());
} else {
//Warning already issued by AreaTreeHandler (debug level is sufficient)
log.debug("Bookmark with IDRef \"" + targetID + "\" has a null PageViewport.");
}
for (int i = 0; i < bookmarkItem.getCount(); i++) {
renderBookmarkItem(bookmarkItem.getSubData(i), pdfOutline);
}
}
/** {@inheritDoc} */
public Graphics2DAdapter getGraphics2DAdapter() {
return new PDFGraphics2DAdapter(this);
}
/** {@inheritDoc} */
protected void saveGraphicsState() {
generator.saveGraphicsState();
}
/** {@inheritDoc} */
protected void restoreGraphicsState() {
generator.restoreGraphicsState();
}
/** Indicates the beginning of a text object. */
protected void beginTextObject() {
generator.beginTextObject();
}
/** Indicates the end of a text object. */
protected void endTextObject() {
generator.endTextObject();
}
/**
* Start the next page sequence.
* For the PDF renderer there is no concept of page sequences
* but it uses the first available page sequence title to set
* as the title of the PDF document, and the language of the
* document.
* @param pageSequence the page sequence
*/
public void startPageSequence(PageSequence pageSequence) {
super.startPageSequence(pageSequence);
LineArea seqTitle = pageSequence.getTitle();
if (seqTitle != null) {
String str = convertTitleToString(seqTitle);
PDFInfo info = this.pdfDoc.getInfo();
if (info.getTitle() == null) {
info.setTitle(str);
}
}
Locale language = null;
if (pageSequence.getLanguage() != null) {
String lang = pageSequence.getLanguage();
String country = pageSequence.getCountry();
if (lang != null) {
language = (country == null) ? new Locale(lang) : new Locale(lang, country);
}
if (pdfDoc.getRoot().getLanguage() == null) {
//Only set if not set already (first non-null is used)
//Note: No checking is performed whether the values are valid!
pdfDoc.getRoot().setLanguage(XMLUtil.toRFC3066(language));
}
}
pdfUtil.generateDefaultXMPMetadata();
if (accessEnabled) {
NodeList nodes = getUserAgent().getStructureTree().getPageSequence(pageSequenceIndex++);
logicalStructureHandler.processStructureTree(nodes, language);
}
}
/**
* The pdf page is prepared by making the page.
* The page is made in the pdf document without any contents
* and then stored to add the contents later.
* The page objects is stored using the area tree PageViewport
* as a key.
*
* @param page the page to prepare
*/
public void preparePage(PageViewport page) {
setupPage(page);
if (pages == null) {
pages = new java.util.HashMap();
}
pages.put(page, currentPage);
}
private void setupPage(PageViewport page) {
this.pdfResources = this.pdfDoc.getResources();
Rectangle2D bounds = page.getViewArea();
double w = bounds.getWidth();
double h = bounds.getHeight();
this.currentPage = this.pdfDoc.getFactory().makePage(
this.pdfResources,
(int) Math.round(w / 1000), (int) Math.round(h / 1000),
page.getPageIndex());
pageReferences.put(page.getKey(), currentPage.referencePDF());
//pvReferences.put(page.getKey(), page);
pdfUtil.generatePageLabel(page.getPageIndex(), page.getPageNumberString());
}
/**
* This method creates a PDF stream for the current page
* uses it as the contents of a new page. The page is written
* immediately to the output stream.
* {@inheritDoc}
*/
public void renderPage(PageViewport page)
throws IOException, FOPException {
if (pages != null
&& (currentPage = (PDFPage) pages.get(page)) != null) {
//Retrieve previously prepared page (out-of-line rendering)
pages.remove(page);
} else {
setupPage(page);
}
currentPageRef = currentPage.referencePDF();
if (accessEnabled) {
logicalStructureHandler.startPage(currentPage);
}
Rectangle bounds = page.getViewArea();
pageHeight = bounds.height;
this.generator = new PDFContentGenerator(this.pdfDoc, this.ostream, this.currentPage);
this.borderPainter = new PDFBorderPainter(this.generator);
// Transform the PDF's default coordinate system (0,0 at lower left) to the PDFRenderer's
saveGraphicsState();
AffineTransform basicPageTransform = new AffineTransform(1, 0, 0, -1, 0,
pageHeight / 1000f);
generator.concatenate(basicPageTransform);
super.renderPage(page);
restoreGraphicsState();
if (accessEnabled) {
logicalStructureHandler.endPage();
}
this.pdfDoc.registerObject(generator.getStream());
currentPage.setContents(generator.getStream());
PDFAnnotList annots = currentPage.getAnnotations();
if (annots != null) {
this.pdfDoc.addObject(annots);
}
this.pdfDoc.addObject(currentPage);
this.borderPainter = null;
this.generator.flushPDFDoc();
this.generator = null;
}
/** {@inheritDoc} */
protected void startVParea(CTM ctm, Rectangle2D clippingRect) {
saveGraphicsState();
// Set the given CTM in the graphics state
/*
currentState.concatenate(
new AffineTransform(CTMHelper.toPDFArray(ctm)));
*/
if (clippingRect != null) {
clipRect((float)clippingRect.getX() / 1000f,
(float)clippingRect.getY() / 1000f,
(float)clippingRect.getWidth() / 1000f,
(float)clippingRect.getHeight() / 1000f);
}
// multiply with current CTM
generator.concatenate(new AffineTransform(CTMHelper.toPDFArray(ctm)));
}
/** {@inheritDoc} */
protected void endVParea() {
restoreGraphicsState();
}
/** {@inheritDoc} */
protected void concatenateTransformationMatrix(AffineTransform at) {
generator.concatenate(at);
}
/**
* Formats a float value (normally coordinates) as Strings.
* @param value the value
* @return the formatted value
*/
protected static String format(float value) {
return PDFNumber.doubleOut(value);
}
/** {@inheritDoc} */
protected void drawBorderLine(float x1, float y1, float x2, float y2,
boolean horz, boolean startOrBefore, int style, Color col) {
PDFBorderPainter.drawBorderLine(generator, x1, y1, x2, y2, horz, startOrBefore, style, col);
}
/** {@inheritDoc} */
protected void clipRect(float x, float y, float width, float height) {
generator.add(format(x) + " " + format(y) + " "
+ format(width) + " " + format(height) + " re ");
clip();
}
/**
* Clip an area.
*/
protected void clip() {
generator.add("W\n" + "n\n");
}
/**
* Moves the current point to (x, y), omitting any connecting line segment.
* @param x x coordinate
* @param y y coordinate
*/
protected void moveTo(float x, float y) {
generator.add(format(x) + " " + format(y) + " m ");
}
/**
* Appends a straight line segment from the current point to (x, y). The
* new current point is (x, y).
* @param x x coordinate
* @param y y coordinate
*/
protected void lineTo(float x, float y) {
generator.add(format(x) + " " + format(y) + " l ");
}
/**
* Closes the current subpath by appending a straight line segment from
* the current point to the starting point of the subpath.
*/
protected void closePath() {
generator.add("h ");
}
/**
* {@inheritDoc}
*/
protected void fillRect(float x, float y, float width, float height) {
if (width > 0 && height > 0) {
generator.add(format(x) + " " + format(y) + " "
+ format(width) + " " + format(height) + " re f\n");
}
}
/**
* Draw a line.
*
* @param startx the start x position
* @param starty the start y position
* @param endx the x end position
* @param endy the y end position
*/
private void drawLine(float startx, float starty, float endx, float endy) {
generator.add(format(startx) + " " + format(starty) + " m ");
generator.add(format(endx) + " " + format(endy) + " l S\n");
}
/**
* Breaks out of the state stack to handle fixed block-containers.
* @return the saved state stack to recreate later
*/
protected List breakOutOfStateStack() {
PDFPaintingState paintingState = getState();
List breakOutList = new java.util.ArrayList();
AbstractPaintingState.AbstractData data;
while (true) {
data = paintingState.getData();
if (paintingState.restore() == null) {
break;
}
if (breakOutList.size() == 0) {
generator.comment("------ break out!");
}
breakOutList.add(0, data); //Insert because of stack-popping
generator.restoreGraphicsState(false);
}
return breakOutList;
}
/**
* Restores the state stack after a break out.
* @param breakOutList the state stack to restore.
*/
protected void restoreStateStackAfterBreakOut(List breakOutList) {
generator.comment("------ restoring context after break-out...");
// currentState.pushAll(breakOutList);
AbstractData data;
Iterator i = breakOutList.iterator();
while (i.hasNext()) {
data = (AbstractData)i.next();
saveGraphicsState();
AffineTransform at = data.getTransform();
concatenateTransformationMatrix(at);
//TODO Break-out: Also restore items such as line width and color
//Left out for now because all this painting stuff is very
//inconsistent. Some values go over PDFState, some don't.
}
generator.comment("------ done.");
}
/**
* Returns area's id if it is the first area in the document with that id
* (i.e. if the area qualifies as a link target).
* Otherwise, or if the area has no id, null is returned.
*
* NOTE: area must be on currentPageViewport, otherwise result may be wrong!
*
* @param area the area for which to return the id
* @return the area's id (null if the area has no id or
* other preceding areas have the same id)
*/
protected String getTargetableID(Area area) {
String id = (String) area.getTrait(Trait.PROD_ID);
if (id == null || id.length() == 0
|| !currentPageViewport.isFirstWithID(id)
|| idPositions.containsKey(id)) {
return null;
} else {
return id;
}
}
/**
* Set XY position in the PDFGoTo and add it to the PDF trailer.
*
* @param gt the PDFGoTo object
* @param position the X,Y position to set
*/
protected void finishIDGoTo(PDFGoTo gt, Point2D.Float position) {
gt.setPosition(position);
pdfDoc.addTrailerObject(gt);
unfinishedGoTos.remove(gt);
}
/**
* Set page reference and XY position in the PDFGoTo and add it to the PDF trailer.
*
* @param gt the PDFGoTo object
* @param pdfPageRef the PDF reference string of the target page object
* @param position the X,Y position to set
*/
protected void finishIDGoTo(PDFGoTo gt, String pdfPageRef, Point2D.Float position) {
gt.setPageReference(pdfPageRef);
finishIDGoTo(gt, position);
}
/**
* Get a PDFGoTo pointing to the given id. Create one if necessary.
* It is possible that the PDFGoTo is not fully resolved yet. In that case
* it must be completed (and added to the PDF trailer) later.
*
* @param targetID the target id of the PDFGoTo
* @param pvKey the unique key of the target PageViewport
*
* @return the PDFGoTo that was found or created
*/
protected PDFGoTo getPDFGoToForID(String targetID, String pvKey) {
// Already a PDFGoTo present for this target? If not, create.
PDFGoTo gt = (PDFGoTo) idGoTos.get(targetID);
if (gt == null) {
String pdfPageRef = (String) pageReferences.get(pvKey);
Point2D.Float position = (Point2D.Float) idPositions.get(targetID);
// can the GoTo already be fully filled in?
if (pdfPageRef != null && position != null) {
// getPDFGoTo shares PDFGoTo objects as much as possible.
// It also takes care of assignObjectNumber and addTrailerObject.
gt = pdfDoc.getFactory().getPDFGoTo(pdfPageRef, position);
} else {
// Not complete yet, can't use getPDFGoTo:
gt = new PDFGoTo(pdfPageRef);
pdfDoc.assignObjectNumber(gt);
// pdfDoc.addTrailerObject() will be called later, from finishIDGoTo()
unfinishedGoTos.add(gt);
}
idGoTos.put(targetID, gt);
}
return gt;
}
/**
* Saves id's absolute position on page for later retrieval by PDFGoTos
*
* @param id the id of the area whose position must be saved
* @param pdfPageRef the PDF page reference string
* @param relativeIPP the *relative* IP position in millipoints
* @param relativeBPP the *relative* BP position in millipoints
* @param tf the transformation to apply once the relative positions have been
* converted to points
*/
protected void saveAbsolutePosition(String id, String pdfPageRef,
int relativeIPP, int relativeBPP, AffineTransform tf) {
Point2D.Float position = new Point2D.Float(relativeIPP / 1000f, relativeBPP / 1000f);
tf.transform(position, position);
idPositions.put(id, position);
// is there already a PDFGoTo waiting to be completed?
PDFGoTo gt = (PDFGoTo) idGoTos.get(id);
if (gt != null) {
finishIDGoTo(gt, pdfPageRef, position);
}
/*
// The code below auto-creates a named destination for every id in the document.
// This should probably be controlled by a user-configurable setting, as it may
// make the PDF file grow noticeably.
// *** NOT YET WELL-TESTED ! ***
if (true) {
PDFFactory factory = pdfDoc.getFactory();
if (gt == null) {
gt = factory.getPDFGoTo(pdfPageRef, position);
idGoTos.put(id, gt); // so others can pick it up too
}
factory.makeDestination(id, gt.referencePDF(), currentPageViewport);
// Note: using currentPageViewport is only correct if the id is indeed on
// the current PageViewport. But even if incorrect, it won't interfere with
// what gets created in the PDF.
// For speedup, we should also create a lookup map id -> PDFDestination
}
*/
}
/**
* Saves id's absolute position on page for later retrieval by PDFGoTos,
* using the currently valid transformation and the currently valid PDF page reference
*
* @param id the id of the area whose position must be saved
* @param relativeIPP the *relative* IP position in millipoints
* @param relativeBPP the *relative* BP position in millipoints
*/
protected void saveAbsolutePosition(String id, int relativeIPP, int relativeBPP) {
saveAbsolutePosition(id, currentPageRef,
relativeIPP, relativeBPP, getState().getTransform());
}
/**
* If the given block area is a possible link target, its id + absolute position will
* be saved. The saved position is only correct if this function is called at the very
* start of renderBlock!
*
* @param block the block area in question
*/
protected void saveBlockPosIfTargetable(Block block) {
String id = getTargetableID(block);
if (id != null) {
// FIXME: Like elsewhere in the renderer code, absolute and relative
// directions are happily mixed here. This makes sure that the
// links point to the right location, but it is not correct.
int ipp = block.getXOffset();
int bpp = block.getYOffset() + block.getSpaceBefore();
int positioning = block.getPositioning();
if (!(positioning == Block.FIXED || positioning == Block.ABSOLUTE)) {
ipp += currentIPPosition;
bpp += currentBPPosition;
}
AffineTransform tf = positioning == Block.FIXED
? getState().getBaseTransform()
: getState().getTransform();
saveAbsolutePosition(id, currentPageRef, ipp, bpp, tf);
}
}
/**
* If the given inline area is a possible link target, its id + absolute position will
* be saved. The saved position is only correct if this function is called at the very
* start of renderInlineArea!
*
* @param inlineArea the inline area in question
*/
protected void saveInlinePosIfTargetable(InlineArea inlineArea) {
String id = getTargetableID(inlineArea);
if (id != null) {
int extraMarginBefore = 5000; // millipoints
int ipp = currentIPPosition;
int bpp = currentBPPosition + inlineArea.getOffset() - extraMarginBefore;
saveAbsolutePosition(id, ipp, bpp);
}
}
/**
* {@inheritDoc}
*/
protected void renderBlock(Block block) {
saveBlockPosIfTargetable(block);
super.renderBlock(block);
}
/** {@inheritDoc} */
protected void renderLineArea(LineArea line) {
super.renderLineArea(line);
}
/**
* {@inheritDoc}
*/
protected void renderInlineArea(InlineArea inlineArea) {
saveInlinePosIfTargetable(inlineArea);
super.renderInlineArea(inlineArea);
}
/**
* Render inline parent area.
* For pdf this handles the inline parent area traits such as
* links, border, background.
* @param ip the inline parent area
*/
public void renderInlineParent(InlineParent ip) {
boolean annotsAllowed = pdfDoc.getProfile().isAnnotationAllowed();
// stuff we only need if a link must be created:
Rectangle2D ipRect = null;
PDFFactory factory = null;
PDFAction action = null;
if (annotsAllowed) {
// make sure the rect is determined *before* calling super!
int ipp = currentIPPosition;
int bpp = currentBPPosition + ip.getOffset();
ipRect = new Rectangle2D.Float(ipp / 1000f, bpp / 1000f,
ip.getIPD() / 1000f, ip.getBPD() / 1000f);
AffineTransform transform = getState().getTransform();
ipRect = transform.createTransformedShape(ipRect).getBounds2D();
factory = pdfDoc.getFactory();
}
// render contents
super.renderInlineParent(ip);
boolean linkTraitFound = false;
// try INTERNAL_LINK first
Trait.InternalLink intLink = (Trait.InternalLink) ip.getTrait(Trait.INTERNAL_LINK);
if (intLink != null) {
linkTraitFound = true;
String pvKey = intLink.getPVKey();
String idRef = intLink.getIDRef();
boolean pvKeyOK = pvKey != null && pvKey.length() > 0;
boolean idRefOK = idRef != null && idRef.length() > 0;
if (pvKeyOK && idRefOK) {
if (annotsAllowed) {
action = getPDFGoToForID(idRef, pvKey);
}
} else {
//Warnings already issued by AreaTreeHandler
}
}
// no INTERNAL_LINK, look for EXTERNAL_LINK
if (!linkTraitFound) {
Trait.ExternalLink extLink = (Trait.ExternalLink) ip.getTrait(Trait.EXTERNAL_LINK);
if (extLink != null) {
String extDest = extLink.getDestination();
if (extDest != null && extDest.length() > 0) {
linkTraitFound = true;
if (annotsAllowed) {
action = factory.getExternalAction(extDest, extLink.newWindow());
}
}
}
}
// warn if link trait found but not allowed, else create link
if (linkTraitFound) {
if (!annotsAllowed) {
log.warn("Skipping annotation for a link due to PDF profile: "
+ pdfDoc.getProfile());
} else if (action != null) {
PDFLink pdfLink = factory.makeLink(ipRect, action);
if (accessEnabled) {
String ptr = (String) ip.getTrait(Trait.PTR);
logicalStructureHandler.addLinkContentItem(pdfLink, ptr);
}
currentPage.addAnnotation(pdfLink);
}
}
}
/** {@inheritDoc} */
public void renderViewport(Viewport viewport) {
imageReference = (String) viewport.getTrait(Trait.PTR);
super.renderViewport(viewport);
imageReference = null;
}
private Typeface getTypeface(String fontName) {
Typeface tf = (Typeface) fontInfo.getFonts().get(fontName);
if (tf instanceof LazyFont) {
tf = ((LazyFont)tf).getRealFont();
}
return tf;
}
/** {@inheritDoc} */
public void renderText(TextArea text) {
renderInlineAreaBackAndBorders(text);
Color ct = (Color) text.getTrait(Trait.COLOR);
updateColor(ct, true);
if (accessEnabled) {
String ptr = (String) text.getTrait(Trait.PTR);
MarkedContentInfo mci = logicalStructureHandler.addTextContentItem(ptr);
if (generator.getTextUtil().isInTextObject()) {
generator.separateTextElements(mci.tag, mci.mcid);
}
generator.beginTextObject(mci.tag, mci.mcid);
} else {
beginTextObject();
}
String fontName = getInternalFontNameForArea(text);
int size = ((Integer) text.getTrait(Trait.FONT_SIZE)).intValue();
// This assumes that *all* CIDFonts use a /ToUnicode mapping
Typeface tf = getTypeface(fontName);
PDFTextUtil textutil = generator.getTextUtil();
textutil.updateTf(fontName, size / 1000f, tf.isMultiByte());
// word.getOffset() = only height of text itself
// currentBlockIPPosition: 0 for beginning of line; nonzero
// where previous line area failed to take up entire allocated space
int rx = currentIPPosition + text.getBorderAndPaddingWidthStart();
int bl = currentBPPosition + text.getOffset() + text.getBaselineOffset();
textutil.writeTextMatrix(new AffineTransform(1, 0, 0, -1, rx / 1000f, bl / 1000f));
super.renderText(text);
textutil.writeTJ();
renderTextDecoration(tf, size, text, bl, rx);
}
/** {@inheritDoc} */
public void renderWord(WordArea word) {
Font font = getFontFromArea(word.getParentArea());
String s = word.getWord();
escapeText(s, word.getLetterAdjustArray(),
font, (AbstractTextArea)word.getParentArea());
super.renderWord(word);
}
/** {@inheritDoc} */
public void renderSpace(SpaceArea space) {
Font font = getFontFromArea(space.getParentArea());
String s = space.getSpace();
AbstractTextArea textArea = (AbstractTextArea)space.getParentArea();
escapeText(s, null, font, textArea);
if (space.isAdjustable()) {
int tws = -((TextArea) space.getParentArea()).getTextWordSpaceAdjust()
- 2 * textArea.getTextLetterSpaceAdjust();
if (tws != 0) {
float adjust = tws / (font.getFontSize() / 1000f);
generator.getTextUtil().adjustGlyphTJ(adjust);
}
}
super.renderSpace(space);
}
/**
* Escapes text according to PDF rules.
* @param s Text to escape
* @param letterAdjust an array of widths for letter adjustment (may be null)
* @param font to font in use
* @param parentArea the parent text area to retrieve certain traits from
*/
protected void escapeText(String s,
int[] letterAdjust,
Font font, AbstractTextArea parentArea) {
escapeText(s, 0, s.length(), letterAdjust, font, parentArea);
}
/**
* Escapes text according to PDF rules.
* @param s Text to escape
* @param start the start position in the text
* @param end the end position in the text
* @param letterAdjust an array of widths for letter adjustment (may be null)
* @param font to font in use
* @param parentArea the parent text area to retrieve certain traits from
*/
protected void escapeText(String s, int start, int end,
int[] letterAdjust,
Font font, AbstractTextArea parentArea) {
String fontName = font.getFontName();
float fontSize = font.getFontSize() / 1000f;
Typeface tf = getTypeface(fontName);
SingleByteFont singleByteFont = null;
if (tf instanceof SingleByteFont) {
singleByteFont = (SingleByteFont)tf;
}
PDFTextUtil textutil = generator.getTextUtil();
int l = s.length();
for (int i = start; i < end; i++) {
char orgChar = s.charAt(i);
char ch;
float glyphAdjust = 0;
if (font.hasChar(orgChar)) {
ch = font.mapChar(orgChar);
if (singleByteFont != null && singleByteFont.hasAdditionalEncodings()) {
int encoding = ch / 256;
if (encoding == 0) {
textutil.updateTf(fontName, fontSize, tf.isMultiByte());
} else {
textutil.updateTf(fontName + "_" + Integer.toString(encoding),
fontSize, tf.isMultiByte());
ch = (char)(ch % 256);
}
}
int tls = (i < l - 1 ? parentArea.getTextLetterSpaceAdjust() : 0);
glyphAdjust -= tls;
} else {
if (CharUtilities.isFixedWidthSpace(orgChar)) {
//Fixed width space are rendered as spaces so copy/paste works in a reader
ch = font.mapChar(CharUtilities.SPACE);
glyphAdjust = font.getCharWidth(ch) - font.getCharWidth(orgChar);
} else {
ch = font.mapChar(orgChar);
}
}
if (letterAdjust != null && i < l - 1) {
glyphAdjust -= letterAdjust[i + 1];
}
textutil.writeTJMappedChar(ch);
float adjust = glyphAdjust / fontSize;
if (adjust != 0) {
textutil.adjustGlyphTJ(adjust);
}
}
}
/** {@inheritDoc} */
protected void updateColor(Color col, boolean fill) {
generator.updateColor(col, fill, null);
}
/** {@inheritDoc} */
public void renderImage(Image image, Rectangle2D pos) {
endTextObject();
String url = image.getURL();
putImage(url, pos, image.getForeignAttributes());
}
/** {@inheritDoc} */
protected void drawImage(String url, Rectangle2D pos, Map foreignAttributes) {
endTextObject();
putImage(url, pos, foreignAttributes);
}
/**
* Adds a PDF XObject (a bitmap or form) to the PDF that will later be referenced.
* @param uri URL of the bitmap
* @param pos Position of the bitmap
* @deprecated Use {@link #putImage(String, Rectangle2D, Map)} instead.
*/
protected void putImage(String uri, Rectangle2D pos) {
putImage(uri, pos, null);
}
/**
* Adds a PDF XObject (a bitmap or form) to the PDF that will later be referenced.
* @param uri URL of the bitmap
* @param pos Position of the bitmap
* @param foreignAttributes foreign attributes associated with the image
*/
protected void putImage(String uri, Rectangle2D pos, Map foreignAttributes) {
Rectangle posInt = new Rectangle(
(int)pos.getX(),
(int)pos.getY(),
(int)pos.getWidth(),
(int)pos.getHeight());
uri = URISpecification.getURL(uri);
PDFXObject xobject = pdfDoc.getXObject(uri);
if (xobject != null) {
float w = (float) pos.getWidth() / 1000f;
float h = (float) pos.getHeight() / 1000f;
placeImage((float)pos.getX() / 1000f,
(float)pos.getY() / 1000f, w, h, xobject);
return;
}
Point origin = new Point(currentIPPosition, currentBPPosition);
int x = origin.x + posInt.x;
int y = origin.y + posInt.y;
ImageManager manager = getUserAgent().getFactory().getImageManager();
ImageInfo info = null;
try {
ImageSessionContext sessionContext = getUserAgent().getImageSessionContext();
info = manager.getImageInfo(uri, sessionContext);
Map hints = ImageUtil.getDefaultHints(sessionContext);
ImageFlavor[] supportedFlavors = imageHandlerRegistry.getSupportedFlavors();
org.apache.xmlgraphics.image.loader.Image img = manager.getImage(
info, supportedFlavors, hints, sessionContext);
//First check for a dynamically registered handler
PDFImageHandler handler
= (PDFImageHandler)imageHandlerRegistry.getHandler(img.getClass());
if (handler != null) {
if (log.isDebugEnabled()) {
log.debug("Using PDFImageHandler: " + handler.getClass().getName());
}
try {
RendererContext context = createRendererContext(
x, y, posInt.width, posInt.height, foreignAttributes);
handler.generateImage(context, img, origin, posInt);
} catch (IOException ioe) {
ResourceEventProducer eventProducer = ResourceEventProducer.Provider.get(
getUserAgent().getEventBroadcaster());
eventProducer.imageWritingError(this, ioe);
return;
}
} else {
throw new UnsupportedOperationException(
"No PDFImageHandler available for image: "
+ info + " (" + img.getClass().getName() + ")");
}
} catch (ImageException ie) {
ResourceEventProducer eventProducer = ResourceEventProducer.Provider.get(
getUserAgent().getEventBroadcaster());
eventProducer.imageError(this, (info != null ? info.toString() : uri), ie, null);
} catch (FileNotFoundException fe) {
ResourceEventProducer eventProducer = ResourceEventProducer.Provider.get(
getUserAgent().getEventBroadcaster());
eventProducer.imageNotFound(this, (info != null ? info.toString() : uri), fe, null);
} catch (IOException ioe) {
ResourceEventProducer eventProducer = ResourceEventProducer.Provider.get(
getUserAgent().getEventBroadcaster());
eventProducer.imageIOError(this, (info != null ? info.toString() : uri), ioe, null);
}
// output new data
try {
this.generator.flushPDFDoc();
} catch (IOException ioe) {
// ioexception will be caught later
log.error(ioe.getMessage());
}
}
/**
* Places a previously registered image at a certain place on the page.
* @param x X coordinate
* @param y Y coordinate
* @param w width for image
* @param h height for image
* @param xobj the image XObject
*/
public void placeImage(float x, float y, float w, float h, PDFXObject xobj) {
if (accessEnabled) {
MarkedContentInfo mci = logicalStructureHandler.addImageContentItem(imageReference);
generator.saveGraphicsState(mci.tag, mci.mcid);
} else {
saveGraphicsState();
}
generator.add(format(w) + " 0 0 "
+ format(-h) + " "
+ format(currentIPPosition / 1000f + x) + " "
+ format(currentBPPosition / 1000f + h + y)
+ " cm\n" + xobj.getName() + " Do\n");
if (accessEnabled) {
generator.restoreGraphicsStateAccess();
} else {
restoreGraphicsState();
}
}
/** {@inheritDoc} */
protected RendererContext createRendererContext(int x, int y, int width, int height,
Map foreignAttributes) {
RendererContext context = super.createRendererContext(
x, y, width, height, foreignAttributes);
context.setProperty(PDFRendererContextConstants.PDF_DOCUMENT, pdfDoc);
context.setProperty(PDFRendererContextConstants.OUTPUT_STREAM, ostream);
context.setProperty(PDFRendererContextConstants.PDF_PAGE, currentPage);
context.setProperty(PDFRendererContextConstants.PDF_CONTEXT, currentContext);
context.setProperty(PDFRendererContextConstants.PDF_STREAM, generator.getStream());
context.setProperty(PDFRendererContextConstants.PDF_FONT_INFO, fontInfo);
context.setProperty(PDFRendererContextConstants.PDF_FONT_NAME, "");
context.setProperty(PDFRendererContextConstants.PDF_FONT_SIZE, new Integer(0));
return context;
}
/** {@inheritDoc} */
public void renderDocument(Document doc, String ns, Rectangle2D pos, Map foreignAttributes) {
if (accessEnabled) {
MarkedContentInfo mci = logicalStructureHandler.addImageContentItem(imageReference);
generator.beginMarkedContentSequence(mci.tag, mci.mcid);
}
super.renderDocument(doc, ns, pos, foreignAttributes);
if (accessEnabled) {
generator.endMarkedContentSequence();
}
}
/**
* Render leader area.
* This renders a leader area which is an area with a rule.
* @param area the leader area to render
*/
public void renderLeader(Leader area) {
renderInlineAreaBackAndBorders(area);
int style = area.getRuleStyle();
int ruleThickness = area.getRuleThickness();
int startx = currentIPPosition + area.getBorderAndPaddingWidthStart();
int starty = currentBPPosition + area.getOffset() + (ruleThickness / 2);
int endx = currentIPPosition
+ area.getBorderAndPaddingWidthStart()
+ area.getIPD();
Color col = (Color)area.getTrait(Trait.COLOR);
endTextObject();
borderPainter.drawLine(new Point(startx, starty), new Point(endx, starty),
ruleThickness, col, RuleStyle.valueOf(style));
super.renderLeader(area);
}
/** {@inheritDoc} */
public String getMimeType() {
return MIME_TYPE;
}
/**
* Sets the PDF/A mode for the PDF renderer.
* @param mode the PDF/A mode
*/
public void setAMode(PDFAMode mode) {
this.pdfUtil.setAMode(mode);
}
/**
* Sets the PDF/X mode for the PDF renderer.
* @param mode the PDF/X mode
*/
public void setXMode(PDFXMode mode) {
this.pdfUtil.setXMode(mode);
}
/**
* Sets the output color profile for the PDF renderer.
* @param outputProfileURI the URI to the output color profile
*/
public void setOutputProfileURI(String outputProfileURI) {
this.pdfUtil.setOutputProfileURI(outputProfileURI);
}
/**
* Sets the filter map to be used by the PDF renderer.
* @param filterMap the filter map
*/
public void setFilterMap(Map filterMap) {
this.pdfUtil.setFilterMap(filterMap);
}
/**
* Sets the encryption parameters used by the PDF renderer.
* @param encryptionParams the encryption parameters
*/
public void setEncryptionParams(PDFEncryptionParams encryptionParams) {
this.pdfUtil.setEncryptionParams(encryptionParams);
}
MarkedContentInfo addCurrentImageToStructureTree() {
return logicalStructureHandler.addImageContentItem(imageReference);
}
}