* * The region may clip the area and it establishes a position from where * the region is placed.
* * @param port The region viewport to be rendered */ protected void renderRegionViewport(RegionViewport port) { if (port != null) { Rectangle2D view = port.getViewArea(); // The CTM will transform coordinates relative to // this region-reference area into page coords, so // set origin for the region to 0,0. currentBPPosition = 0; currentIPPosition = 0; RegionReference regionReference = port.getRegionReference(); handleRegionTraits(port); // shouldn't the viewport have the CTM startVParea(regionReference.getCTM()); // do after starting viewport area if (regionReference.getRegionClass() == FO_REGION_BODY) { renderBodyRegion((BodyRegion) regionReference); } else { renderRegion(regionReference); } endVParea(); } } /** * (todo) Description of the Method * * @param ctm The coordinate transformation matrix to use */ protected void startVParea(CTM ctm) { } /** * Handle the traits for a region * This is used to draw the traits for the given page region. * (See Sect. 6.4.1.2 of XSL-FO spec.) * @param rv the RegionViewport whose region is to be drawn */ protected void handleRegionTraits(RegionViewport rv) { // draw border and background } /** * (todo) Description of the Method */ protected void endVParea() { } /** * Renders a region reference area. * * @param region The region reference area */ protected void renderRegion(RegionReference region) { List blocks = region.getBlocks(); renderBlocks(null, blocks); } /** * Renders a body region area. * * @param region The body region */ protected void renderBodyRegion(BodyRegion region) { BeforeFloat bf = region.getBeforeFloat(); if (bf != null) { renderBeforeFloat(bf); } MainReference mr = region.getMainReference(); if (mr != null) { renderMainReference(mr); } Footnote foot = region.getFootnote(); if (foot != null) { renderFootnote(foot); } } /** * Renders a before float area. * * @param bf The before float area */ protected void renderBeforeFloat(BeforeFloat bf) { List blocks = bf.getChildAreas(); if (blocks != null) { renderBlocks(null, blocks); Block sep = bf.getSeparator(); if (sep != null) { renderBlock(sep); } } } /** * Renders a footnote * * @param footnote The footnote */ protected void renderFootnote(Footnote footnote) { currentBPPosition += footnote.getTop(); List blocks = footnote.getChildAreas(); if (blocks != null) { Block sep = footnote.getSeparator(); if (sep != null) { renderBlock(sep); } renderBlocks(null, blocks); } } /** * Renders the main reference area. ** The main reference area contains a list of spans that are * stacked on the page. * The spans contain a list of normal flow reference areas * that are positioned into columns. *
* * @param mr The main reference area */ protected void renderMainReference(MainReference mr) { int saveIPPos = currentIPPosition; Span span = null; List spans = mr.getSpans(); int saveBPPos = currentBPPosition; int saveSpanBPPos = saveBPPos; for (int count = 0; count < spans.size(); count++) { span = (Span) spans.get(count); int offset = (mr.getWidth() - (mr.getColumnCount() - 1) * mr.getColumnGap()) / mr.getColumnCount() + mr.getColumnGap(); for (int c = 0; c < span.getColumnCount(); c++) { NormalFlow flow = (NormalFlow) span.getNormalFlow(c); if (flow != null) { currentBPPosition = saveSpanBPPos; renderFlow(flow); currentIPPosition += flow.getIPD(); currentIPPosition += offset; } } currentIPPosition = saveIPPos; currentBPPosition = saveSpanBPPos + span.getHeight(); saveSpanBPPos = currentBPPosition; } currentBPPosition = saveBPPos; } /** * Renders a flow reference area. * * @param flow The flow reference area */ protected void renderFlow(NormalFlow flow) { // the normal flow reference area contains stacked blocks List blocks = flow.getChildAreas(); if (blocks != null) { renderBlocks(null, blocks); } } /** * Handle block traits. * This method is called when the correct ip and bp posiiton is * set. This should be overridden to draw border and background * traits for the block area. * * @param block the block area */ protected void handleBlockTraits(Block block) { // draw border and background } /** * Renders a block viewport. * * @param bv The block viewport * @param children The children to render within the block viewport */ protected void renderBlockViewport(BlockViewport bv, List children) { // clip and position viewport if necessary if (bv.getPositioning() == Block.ABSOLUTE) { // save positions int saveIP = currentIPPosition; int saveBP = currentBPPosition; CTM ctm = bv.getCTM(); currentIPPosition = 0; currentBPPosition = 0; startVParea(ctm); handleBlockTraits(bv); renderBlocks(bv, children); endVParea(); // clip if necessary currentIPPosition = saveIP; currentBPPosition = saveBP; } else { // save position and offset int saveIP = currentIPPosition; int saveBP = currentBPPosition; handleBlockTraits(bv); renderBlocks(bv, children); currentIPPosition = saveIP; currentBPPosition = saveBP + bv.getAllocBPD(); } } /** * Renders a list of block areas. * * @param parent the parent block if the parent is a block, otherwise * a null value. * @param blocks The block areas */ protected void renderBlocks(Block parent, List blocks) { int saveIP = currentIPPosition; int saveBP = currentBPPosition; // Calculate the position of the content rectangle. if (parent != null && !Boolean.TRUE.equals(parent.getTrait(Trait.IS_VIEWPORT_AREA))) { currentBPPosition += parent.getBorderAndPaddingWidthBefore(); /* This is unnecessary now as we're going to use the *-indent traits currentIPPosition += parent.getBorderAndPaddingWidthStart(); Integer spaceStart = (Integer) parent.getTrait(Trait.SPACE_START); if (spaceStart != null) { currentIPPosition += spaceStart.intValue(); }*/ } // the position of the containing block is used for // absolutely positioned areas int contBP = currentBPPosition; int contIP = currentIPPosition; containingBPPosition = currentBPPosition; containingIPPosition = currentIPPosition; for (int count = 0; count < blocks.size(); count++) { Object obj = blocks.get(count); if (obj instanceof Block) { currentIPPosition = contIP; containingBPPosition = contBP; containingIPPosition = contIP; renderBlock((Block) obj); containingBPPosition = contBP; containingIPPosition = contIP; } else { // a line area is rendered from the top left position // of the line, each inline object is offset from there LineArea line = (LineArea) obj; currentIPPosition = contIP + parent.getStartIndent() + line.getStartIndent(); renderLineArea(line); //InlineArea child = (InlineArea) line.getInlineAreas().get(0); currentBPPosition += line.getAllocBPD(); } currentIPPosition = saveIP; } } /** * Renders a block area. * * @param block The block area */ protected void renderBlock(Block block) { List children = block.getChildAreas(); if (block instanceof BlockViewport) { if (children != null) { renderBlockViewport((BlockViewport) block, children); } else { handleBlockTraits(block); // simply move position currentBPPosition += block.getAllocBPD(); } } else { // save position and offset int saveIP = currentIPPosition; int saveBP = currentBPPosition; if (block.getPositioning() == Block.ABSOLUTE) { currentIPPosition = containingIPPosition + block.getXOffset(); currentBPPosition = containingBPPosition + block.getYOffset(); handleBlockTraits(block); if (children != null) { renderBlocks(block, children); } // absolute blocks do not effect the layout currentBPPosition = saveBP; } else { // relative blocks are offset currentIPPosition += block.getXOffset(); currentBPPosition += block.getYOffset(); handleBlockTraits(block); if (children != null) { renderBlocks(block, children); } // stacked and relative blocks effect stacking currentIPPosition = saveIP; currentBPPosition = saveBP + block.getAllocBPD(); } } } /** * Renders a line area.* * A line area may have grouped styling for its children such as underline, * background.
* * @param line The line area */ protected void renderLineArea(LineArea line) { List children = line.getInlineAreas(); for (int count = 0; count < children.size(); count++) { InlineArea inline = (InlineArea) children.get(count); renderInlineArea(inline); } } protected void renderInlineArea(InlineArea inlineArea) { if (inlineArea instanceof TextArea) { renderText((TextArea) inlineArea); } else if (inlineArea instanceof InlineParent) { renderInlineParent((InlineParent) inlineArea); } else if (inlineArea instanceof InlineBlockParent) { renderInlineBlockParent((InlineBlockParent) inlineArea); } else if (inlineArea instanceof Space) { renderInlineSpace((Space) inlineArea); } else if (inlineArea instanceof Character) { renderCharacter((Character) inlineArea); } else if (inlineArea instanceof Viewport) { renderViewport((Viewport) inlineArea); } else if (inlineArea instanceof Leader) { renderLeader((Leader) inlineArea); } } protected void renderCharacter(Character ch) { currentIPPosition += ch.getAllocIPD(); } protected void renderInlineSpace(Space space) { // an inline space moves the inline progression position // for the current block by the width or height of the space // it may also have styling (only on this object) that needs // handling currentIPPosition += space.getAllocIPD(); } protected void renderLeader(Leader area) { currentIPPosition += area.getAllocIPD(); } protected void renderText(TextArea text) { currentIPPosition += text.getAllocIPD(); } protected void renderInlineParent(InlineParent ip) { int saveIP = currentIPPosition; Iterator iter = ip.getChildAreas().iterator(); while (iter.hasNext()) { renderInlineArea((InlineArea) iter.next()); } currentIPPosition = saveIP + ip.getAllocIPD(); } protected void renderInlineBlockParent(InlineBlockParent ibp) { // For inline content the BP position is updated by the enclosing line area int saveBP = currentBPPosition; renderBlock(ibp.getChildArea()); currentBPPosition = saveBP; } protected void renderViewport(Viewport viewport) { Area content = viewport.getContent(); int saveBP = currentBPPosition; currentBPPosition += viewport.getOffset(); Rectangle2D contpos = viewport.getContentPosition(); if (content instanceof Image) { renderImage((Image) content, contpos); } else if (content instanceof Container) { renderContainer((Container) content); } else if (content instanceof ForeignObject) { renderForeignObject((ForeignObject) content, contpos); } currentIPPosition += viewport.getAllocIPD(); currentBPPosition = saveBP; } /** * Renders an image area. * * @param image The image * @param pos The target position of the image * (todo) Make renderImage() protected */ public void renderImage(Image image, Rectangle2D pos) { // Default: do nothing. // Some renderers (ex. Text) don't support images. } /** * Tells the renderer to render an inline container. * @param cont The inline container area */ protected void renderContainer(Container cont) { int saveIP = currentIPPosition; int saveBP = currentBPPosition; List blocks = cont.getBlocks(); renderBlocks(null, blocks); currentIPPosition = saveIP; currentBPPosition = saveBP; } /** * Renders a foreign object area. * * @param fo The foreign object area * @param pos The target position of the foreign object * (todo) Make renderForeignObject() protected */ public void renderForeignObject(ForeignObject fo, Rectangle2D pos) { // Default: do nothing. // Some renderers (ex. Text) don't support foreign objects. } /** * Render the xml document with the given xml namespace. * The Render Context is by the handle to render into the current * rendering target. * @param ctx rendering context * @param doc DOM Document containing the source document * @param namespace Namespace URI of the document */ public void renderXML(RendererContext ctx, Document doc, String namespace) { String mime = ctx.getMimeType(); XMLHandler handler = userAgent.getXMLHandlerRegistry().getXMLHandler( mime, namespace); if (handler != null) { try { handler.handleXML(ctx, doc, namespace); } catch (Throwable t) { // could not handle document log.error("Some XML content will be ignored. " + "Could not render XML", t); } } else { if (warnedXMLHandlers == null) { warnedXMLHandlers = new java.util.HashSet(); } if (!warnedXMLHandlers.contains(namespace)) { // no handler found for document warnedXMLHandlers.add(namespace); log.warn("Some XML content will be ignored. " + "No handler defined for XML: " + namespace); } } } /** * Get the MIME type of the renderer. * * @return The MIME type of the renderer */ public String getMimeType() { return null; } }