/* * $Id: BlockLayoutManager.java,v 1.32 2003/03/05 20:38:26 jeremias Exp $ * ============================================================================ * The Apache Software License, Version 1.1 * ============================================================================ * * Copyright (C) 1999-2003 The Apache Software Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without modifica- * tion, are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * * 3. The end-user documentation included with the redistribution, if any, must * include the following acknowledgment: "This product includes software * developed by the Apache Software Foundation (http://www.apache.org/)." * Alternately, this acknowledgment may appear in the software itself, if * and wherever such third-party acknowledgments normally appear. * * 4. The names "FOP" and "Apache Software Foundation" must not be used to * endorse or promote products derived from this software without prior * written permission. For written permission, please contact * apache@apache.org. * * 5. Products derived from this software may not be called "Apache", nor may * "Apache" appear in their name, without prior written permission of the * Apache Software Foundation. * * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE * APACHE SOFTWARE FOUNDATION OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLU- * DING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ============================================================================ * * This software consists of voluntary contributions made by many individuals * on behalf of the Apache Software Foundation and was originally created by * James Tauber . For more information on the Apache * Software Foundation, please see . */ package org.apache.fop.layoutmgr; import java.util.ListIterator; import java.util.ArrayList; import java.util.List; import org.apache.fop.fo.FObj; import org.apache.fop.fo.TextInfo; import org.apache.fop.fo.PropertyManager; import org.apache.fop.area.Area; import org.apache.fop.area.Block; import org.apache.fop.area.LineArea; import org.apache.fop.traits.LayoutProps; import org.apache.fop.fo.properties.CommonBorderAndPadding; import org.apache.fop.fo.properties.CommonBackground; import org.apache.fop.traits.MinOptMax; /** * LayoutManager for a block FO. */ public class BlockLayoutManager extends BlockStackingLayoutManager { private Block curBlockArea; private LayoutProps layoutProps; private CommonBorderAndPadding borderProps; private CommonBackground backgroundProps; private int lead = 12000; private int lineHeight = 14000; private int follow = 2000; private int iStartPos = 0; protected List childBreaks = new java.util.ArrayList(); /** * Iterator for Block layout. * This iterator combines consecutive inline areas and * creates a line layout manager. * The use of this iterator means that it can be reset properly. */ protected class BlockLMiter extends LMiter { private ListIterator proxy; public BlockLMiter(LayoutProcessor lp, ListIterator pr) { super(lp, null); proxy = pr; } protected boolean preLoadNext() { while (proxy.hasNext()) { LayoutProcessor lm = (LayoutProcessor) proxy.next(); lm.setParent(BlockLayoutManager.this); if (lm.generatesInlineAreas()) { LineLayoutManager lineLM = createLineManager(lm); listLMs.add(lineLM); } else { listLMs.add(lm); } if (curPos < listLMs.size()) { return true; } } return false; } protected LineLayoutManager createLineManager( LayoutManager firstlm) { LayoutProcessor lm; List inlines = new ArrayList(); inlines.add(firstlm); while (proxy.hasNext()) { lm = (LayoutProcessor) proxy.next(); lm.setParent(BlockLayoutManager.this); if (lm.generatesInlineAreas()) { inlines.add(lm); } else { proxy.previous(); break; } } LineLayoutManager child; child = new LineLayoutManager(lineHeight, lead, follow); child.setUserAgent(getUserAgent()); child.setFObj(fobj); child.setLMiter(inlines.listIterator()); return child; } } public BlockLayoutManager() { } /** * Set the FO object for this layout manager * * @param fo the fo for this layout manager */ public void setFObj(FObj fo) { super.setFObj(fo); childLMiter = new BlockLMiter(this, childLMiter); } public void setBlockTextInfo(TextInfo ti) { lead = ti.fs.getAscender(); follow = ti.fs.getDescender(); lineHeight = ti.lineHeight; } /** * This method provides a hook for a LayoutManager to intialize traits * for the areas it will create, based on Properties set on its FO. */ protected void initProperties(PropertyManager pm) { layoutProps = pm.getLayoutProps(); borderProps = pm.getBorderAndPadding(); backgroundProps = pm.getBackgroundProps(); } public BreakPoss getNextBreakPoss(LayoutContext context) { LayoutProcessor curLM; // currently active LM int ipd = context.getRefIPD(); MinOptMax stackSize = new MinOptMax(); // if starting add space before stackSize.add(layoutProps.spaceBefore.getSpace()); BreakPoss lastPos = null; while ((curLM = getChildLM()) != null) { // Make break positions and return blocks! // Set up a LayoutContext BreakPoss bp; LayoutContext childLC = new LayoutContext(0); // if line layout manager then set stack limit to ipd // line LM actually generates a LineArea which is a block if (curLM.generatesInlineAreas()) { // set stackLimit for lines childLC.setStackLimit(new MinOptMax(ipd/* - iIndents - iTextIndent*/)); childLC.setRefIPD(ipd); } else { childLC.setStackLimit( MinOptMax.subtract(context.getStackLimit(), stackSize)); childLC.setRefIPD(ipd); } boolean over = false; while (!curLM.isFinished()) { if ((bp = curLM.getNextBreakPoss(childLC)) != null) { if (stackSize.opt + bp.getStackingSize().opt > context.getStackLimit().max) { // reset to last break if (lastPos != null) { LayoutProcessor lm = lastPos.getLayoutManager(); lm.resetPosition(lastPos.getPosition()); if (lm != curLM) { curLM.resetPosition(null); } } else { curLM.resetPosition(null); } over = true; break; } stackSize.add(bp.getStackingSize()); lastPos = bp; childBreaks.add(bp); if (bp.nextBreakOverflows()) { over = true; break; } if (curLM.generatesInlineAreas()) { // Reset stackLimit for non-first lines childLC.setStackLimit(new MinOptMax(ipd/* - iIndents*/)); } else { childLC.setStackLimit(MinOptMax.subtract( context.getStackLimit(), stackSize)); } } } if (getChildLM() == null || over) { if (getChildLM() == null) { setFinished(true); stackSize.add(layoutProps.spaceAfter.getSpace()); } BreakPoss breakPoss = new BreakPoss( new LeafPosition(this, childBreaks.size() - 1)); if (over) { breakPoss.setFlag(BreakPoss.NEXT_OVERFLOWS, true); } breakPoss.setStackingSize(stackSize); return breakPoss; } } setFinished(true); BreakPoss breakPoss = new BreakPoss(new LeafPosition(this, -2)); breakPoss.setStackingSize(stackSize); return breakPoss; } public void addAreas(PositionIterator parentIter, LayoutContext layoutContext) { getParentArea(null); // if adjusted space before double adjust = layoutContext.getSpaceAdjust(); addBlockSpacing(adjust, layoutProps.spaceBefore.getSpace()); addID(); addMarkers(true, true); LayoutProcessor childLM; LayoutContext lc = new LayoutContext(0); while (parentIter.hasNext()) { LeafPosition lfp = (LeafPosition) parentIter.next(); if (lfp.getLeafPos() == -2) { curBlockArea = null; flush(); return; } // Add the block areas to Area PositionIterator breakPosIter = new BreakPossPosIter(childBreaks, iStartPos, lfp.getLeafPos() + 1); iStartPos = lfp.getLeafPos() + 1; while ((childLM = breakPosIter.getNextChildLM()) != null) { childLM.addAreas(breakPosIter, lc); } } addMarkers(false, true); flush(); // if adjusted space after addBlockSpacing(adjust, layoutProps.spaceAfter.getSpace()); curBlockArea = null; } /** * Return an Area which can contain the passed childArea. The childArea * may not yet have any content, but it has essential traits set. * In general, if the LayoutManager already has an Area it simply returns * it. Otherwise, it makes a new Area of the appropriate class. * It gets a parent area for its area by calling its parent LM. * Finally, based on the dimensions of the parent area, it initializes * its own area. This includes setting the content IPD and the maximum * BPD. */ public Area getParentArea(Area childArea) { if (curBlockArea == null) { curBlockArea = new Block(); // set traits TraitSetter.addBorders(curBlockArea, borderProps); TraitSetter.addBackground(curBlockArea, backgroundProps); // Set up dimensions // Must get dimensions from parent area Area parentArea = parentLM.getParentArea(curBlockArea); int referenceIPD = parentArea.getIPD(); curBlockArea.setIPD(referenceIPD); curBlockArea.setWidth(referenceIPD); // Get reference IPD from parentArea setCurrentArea(curBlockArea); // ??? for generic operations } return curBlockArea; } public void addChild(Area childArea) { if (curBlockArea != null) { if (childArea instanceof LineArea) { curBlockArea.addLineArea((LineArea) childArea); } else { curBlockArea.addBlock((Block) childArea); } } } public void resetPosition(Position resetPos) { if (resetPos == null) { reset(null); childBreaks.clear(); iStartPos = 0; } else { //reset(resetPos); LayoutManager lm = resetPos.getLM(); } } }