From eb9bf5bb7d2b3e9951c1e3293167f698111c272c Mon Sep 17 00:00:00 2001 From: Keiron Liddle Date: Mon, 9 Sep 2002 12:21:23 +0000 Subject: [PATCH] fixed style errors made curArea protected so subclasses can do things with it git-svn-id: https://svn.apache.org/repos/asf/xmlgraphics/fop/trunk@195162 13f79535-47bb-0310-9956-ffa450edef68 --- .../fop/layoutmgr/LeafNodeLayoutManager.java | 108 ++++++++++++++++-- 1 file changed, 97 insertions(+), 11 deletions(-) diff --git a/src/org/apache/fop/layoutmgr/LeafNodeLayoutManager.java b/src/org/apache/fop/layoutmgr/LeafNodeLayoutManager.java index 59ebf978e..c24b99a78 100644 --- a/src/org/apache/fop/layoutmgr/LeafNodeLayoutManager.java +++ b/src/org/apache/fop/layoutmgr/LeafNodeLayoutManager.java @@ -1,6 +1,6 @@ /* * $Id$ - * Copyright (C) 2001 The Apache Software Foundation. All rights reserved. + * Copyright (C) 2001-2002 The Apache Software Foundation. All rights reserved. * For details on use and redistribution please refer to the * LICENSE file included with these sources. */ @@ -17,44 +17,84 @@ import org.apache.fop.fo.properties.VerticalAlign; * Base LayoutManager for leaf-node FObj, ie: ones which have no children. * These are all inline objects. Most of them cannot be split (Text is * an exception to this rule.) + * This class can be extended to handle the creation and adding of the + * inline area. */ public class LeafNodeLayoutManager extends AbstractLayoutManager { - - private InlineArea curArea = null; + /** + * The inline area that this leafnode will add. + */ + protected InlineArea curArea = null; private int alignment; private int lead; private MinOptMax ipd; + /** + * Create a Leaf node layout mananger. + * @param fobj the fo object that created this manager + */ public LeafNodeLayoutManager(FObj fobj) { super(fobj); } + /** + * get the inline area. + * @param context the context used to create the area + * @return the current inline area for this layout manager + */ public InlineArea get(LayoutContext context) { return curArea; } + /** + * Check if this generates inline areas. + * @return true always since this is an inline area manager + */ public boolean generatesInlineAreas() { return true; } + /** + * Check if this inline area is resolved due to changes in + * page or ipd. + * Currently not used. + * @return true if the area is resolved when adding + */ public boolean resolved() { return false; } + /** + * Set the current inline area. + * @param ia the inline area to set for this layout manager + */ public void setCurrentArea(InlineArea ia) { curArea = ia; } + /** + * Set the alignment of the inline area. + * @param al the vertical alignment positioning + */ public void setAlignment(int al) { alignment = al; } + /** + * Set the lead for this inline area. + * The lead is the distance from the top of the object + * to the baseline. + * Currently not used. + * @param l the lead value + */ public void setLead(int l) { lead = l; } /** * This is a leaf-node, so this method is never called. + * @param childArea the childArea to add + * @return not used */ public boolean addChild(Area childArea) { return false; @@ -62,11 +102,20 @@ public class LeafNodeLayoutManager extends AbstractLayoutManager { /** * This is a leaf-node, so this method is never called. + * @param childArea the childArea to get the parent for + * @return the parent area */ public Area getParentArea(Area childArea) { return null; } + /** + * Get the next break position. + * Since this holds an inline area it will return a single + * break position. + * @param context the layout context for this inline area + * @return the break poisition for adding this inline area + */ public BreakPoss getNextBreakPoss(LayoutContext context) { curArea = get(context); if (curArea == null) { @@ -74,16 +123,16 @@ public class LeafNodeLayoutManager extends AbstractLayoutManager { return null; } BreakPoss bp = new BreakPoss(new LeafPosition(this, 0), - BreakPoss.CAN_BREAK_AFTER | - BreakPoss.CAN_BREAK_BEFORE | BreakPoss.ISFIRST | - BreakPoss.ISLAST); + BreakPoss.CAN_BREAK_AFTER + | BreakPoss.CAN_BREAK_BEFORE | BreakPoss.ISFIRST + | BreakPoss.ISLAST); ipd = getAllocationIPD(context.getRefIPD()); bp.setStackingSize(ipd); bp.setNonStackingSize(curArea.getAllocationBPD()); bp.setTrailingSpace(new SpaceSpecifier(false)); int bpd = curArea.getHeight(); - switch(alignment) { + switch (alignment) { case VerticalAlign.MIDDLE: bp.setMiddle(bpd / 2 /* - fontLead/2 */); bp.setLead(bpd / 2 /* + fontLead/2 */); @@ -103,17 +152,35 @@ public class LeafNodeLayoutManager extends AbstractLayoutManager { return bp; } + /** + * Get the allocation ipd of the inline area. + * This method may be overridden to handle percentage values. + * @param refIPD the ipd of the parent reference area + * @return the min/opt/max ipd of the inline area + */ protected MinOptMax getAllocationIPD(int refIPD) { return new MinOptMax(curArea.getIPD()); } + /** + * Reset the position. + * If the reset position is null then this inline area should be + * restarted. + * @param resetPos the position to reset. + */ public void resetPosition(Position resetPos) { // only reset if setting null, start again - if(resetPos == null) { + if (resetPos == null) { setFinished(false); } } + /** + * Add the area for this layout manager. + * This adds the single inline area to the parent. + * @param posIter the position iterator + * @param context the layout context for adding the area + */ public void addAreas(PositionIterator posIter, LayoutContext context) { parentLM.addChild(curArea); @@ -127,9 +194,17 @@ public class LeafNodeLayoutManager extends AbstractLayoutManager { } } + /** + * Offset this area. + * Offset the inline area in the bpd direction when adding the + * inline area. + * This is used for vertical alignment. + * Subclasses should override this if necessary. + * @param context the layout context used for adding the area + */ protected void offsetArea(LayoutContext context) { int bpd = curArea.getHeight(); - switch(alignment) { + switch (alignment) { case VerticalAlign.MIDDLE: curArea.setOffset(context.getBaseline() - bpd / 2 /* - fontLead/2 */); break; @@ -146,17 +221,28 @@ public class LeafNodeLayoutManager extends AbstractLayoutManager { } } + /** + * Adjust the width of the area when adding. + * This uses the min/opt/max values to adjust the with + * of the inline area by a percentage. + * @param context the layout context for adding this area + */ protected void widthAdjustArea(LayoutContext context) { double dAdjust = context.getIPDAdjust(); int width = ipd.opt; - if(dAdjust < 0) { + if (dAdjust < 0) { width = (int)(width + dAdjust * (ipd.opt - ipd.min)); - } else if(dAdjust > 0) { + } else if (dAdjust > 0) { width = (int)(width + dAdjust * (ipd.max - ipd.opt)); } curArea.setWidth(width); } + /** + * Check if can break before this area. + * @param context the layout context to check for the break + * @return true if can break before this area in the context + */ public boolean canBreakBefore(LayoutContext context) { return true; } -- 2.39.5