diff options
Diffstat (limited to 'src/java/org/apache/fop/layoutmgr/BlockContainerLayoutManager.java')
| -rw-r--r-- | src/java/org/apache/fop/layoutmgr/BlockContainerLayoutManager.java | 669 |
1 files changed, 160 insertions, 509 deletions
diff --git a/src/java/org/apache/fop/layoutmgr/BlockContainerLayoutManager.java b/src/java/org/apache/fop/layoutmgr/BlockContainerLayoutManager.java index 877da13dd..34403a956 100644 --- a/src/java/org/apache/fop/layoutmgr/BlockContainerLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/BlockContainerLayoutManager.java @@ -23,7 +23,6 @@ import java.awt.Point; import java.awt.geom.Rectangle2D; import java.util.LinkedList; import java.util.List; -import java.util.ListIterator; import java.util.Stack; import org.apache.commons.logging.Log; @@ -41,7 +40,6 @@ import org.apache.fop.fo.properties.CommonAbsolutePosition; import org.apache.fop.fo.properties.KeepProperty; import org.apache.fop.traits.MinOptMax; import org.apache.fop.traits.SpaceVal; -import org.apache.fop.util.ListUtil; /** * LayoutManager for a block-container FO. @@ -88,6 +86,8 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager private MinOptMax effSpaceBefore; private MinOptMax effSpaceAfter; + private double contentRectOffsetX = 0; + private double contentRectOffsetY = 0; /** * Create a new block container layout manager. @@ -98,6 +98,7 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager } /** {@inheritDoc} */ + @Override public void initialize() { abProps = getBlockContainerFO().getCommonAbsolutePosition(); foBlockSpaceBefore = new SpaceVal(getBlockContainerFO().getCommonMarginBlock() @@ -119,20 +120,11 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager .getOptimum(this).getLength(); } - bpUnit = 0; //layoutProps.blockProgressionUnit; - if (bpUnit == 0) { - // use optimum space values - adjustedSpaceBefore = getBlockContainerFO().getCommonMarginBlock() - .spaceBefore.getSpace().getOptimum(this).getLength().getValue(this); - adjustedSpaceAfter = getBlockContainerFO().getCommonMarginBlock() - .spaceAfter.getSpace().getOptimum(this).getLength().getValue(this); - } else { - // use minimum space values - adjustedSpaceBefore = getBlockContainerFO().getCommonMarginBlock() - .spaceBefore.getSpace().getMinimum(this).getLength().getValue(this); - adjustedSpaceAfter = getBlockContainerFO().getCommonMarginBlock() - .spaceAfter.getSpace().getMinimum(this).getLength().getValue(this); - } + // use optimum space values + adjustedSpaceBefore = getBlockContainerFO().getCommonMarginBlock() + .spaceBefore.getSpace().getOptimum(this).getLength().getValue(this); + adjustedSpaceAfter = getBlockContainerFO().getCommonMarginBlock() + .spaceAfter.getSpace().getOptimum(this).getLength().getValue(this); } private void resetSpaces() { @@ -169,8 +161,8 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager } private boolean isAbsoluteOrFixed() { - return (abProps.absolutePosition == EN_ABSOLUTE) - || (abProps.absolutePosition == EN_FIXED); + return (abProps.absolutePosition == EN_ABSOLUTE + || abProps.absolutePosition == EN_FIXED); } private boolean isFixed() { @@ -178,6 +170,7 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager } /** {@inheritDoc} */ + @Override public int getContentAreaBPD() { if (autoHeight) { return -1; @@ -187,126 +180,104 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager } /** {@inheritDoc} */ - public List getNextKnuthElements // CSOK: MethodLength - (LayoutContext context, int alignment) { - resetSpaces(); - if (isAbsoluteOrFixed()) { - return getNextKnuthElementsAbsolute(context, alignment); - } - - autoHeight = false; - //boolean rotated = (getBlockContainerFO().getReferenceOrientation() % 180 != 0); - int maxbpd = context.getStackLimitBP().getOpt(); - int allocBPD; - if (height.getEnum() == EN_AUTO - || (!height.isAbsolute() && getAncestorBlockAreaBPD() <= 0)) { - //auto height when height="auto" or "if that dimension is not specified explicitly - //(i.e., it depends on content's block-progression-dimension)" (XSL 1.0, 7.14.1) - allocBPD = maxbpd; - autoHeight = true; - if (getBlockContainerFO().getReferenceOrientation() == 0) { - //Cannot easily inline element list when ref-or="180" - inlineElementList = true; - } - } else { - allocBPD = height.getValue(this); //this is the content-height - allocBPD += getBPIndents(); - } - vpContentBPD = allocBPD - getBPIndents(); - - referenceIPD = context.getRefIPD(); - if (width.getEnum() == EN_AUTO) { - updateContentAreaIPDwithOverconstrainedAdjust(); - } else { - int contentWidth = width.getValue(this); - updateContentAreaIPDwithOverconstrainedAdjust(contentWidth); - } + @Override + public List getNextKnuthElements(LayoutContext context, int alignment) { + return getNextKnuthElements(context, alignment, null, null, null); + } - double contentRectOffsetX = 0; - contentRectOffsetX += getBlockContainerFO() - .getCommonMarginBlock().startIndent.getValue(this); - double contentRectOffsetY = 0; - contentRectOffsetY += getBlockContainerFO() - .getCommonBorderPaddingBackground().getBorderBeforeWidth(false); - contentRectOffsetY += getBlockContainerFO() - .getCommonBorderPaddingBackground().getPaddingBefore(false, this); + /** + * Overridden to handle writing-mode, and different stack limit + * setup. + * {@inheritDoc} + */ + @Override + protected LayoutContext makeChildLayoutContext(LayoutContext context) { + LayoutContext childLC = new LayoutContext(0); + childLC.setStackLimitBP( + context.getStackLimitBP().minus(MinOptMax.getInstance(relDims.bpd))); + childLC.setRefIPD(relDims.ipd); + childLC.setWritingMode(getBlockContainerFO().getWritingMode()); + return childLC; + } - updateRelDims(contentRectOffsetX, contentRectOffsetY, autoHeight); + /** {@inheritDoc} */ + @Override + public List getNextKnuthElements(LayoutContext context, int alignment, Stack lmStack, + Position restartPosition, LayoutManager restartAtLM) { - int availableIPD = referenceIPD - getIPIndents(); - if (getContentAreaIPD() > availableIPD) { - BlockLevelEventProducer eventProducer = BlockLevelEventProducer.Provider.get( - getBlockContainerFO().getUserAgent().getEventBroadcaster()); - eventProducer.objectTooWide(this, getBlockContainerFO().getName(), - getContentAreaIPD(), context.getRefIPD(), - getBlockContainerFO().getLocator()); + resetSpaces(); + // special treatment for position="absolute|fixed" + if (isAbsoluteOrFixed()) { + return getNextKnuthElementsAbsolute(context); } - MinOptMax stackLimit = MinOptMax.getInstance(relDims.bpd); + boolean isRestart = (lmStack != null); + boolean emptyStack = (!isRestart || lmStack.isEmpty()); - List returnedList; - List contentList = new LinkedList(); - List returnList = new LinkedList(); + setupAreaDimensions(context); - if (!breakBeforeServed) { - breakBeforeServed = true; - if (!context.suppressBreakBefore()) { - if (addKnuthElementsForBreakBefore(returnList, context)) { - return returnList; - } - } - } + List<ListElement> returnedList; + List<ListElement> contentList = new LinkedList<ListElement>(); + List<ListElement> returnList = new LinkedList<ListElement>(); - if (!firstVisibleMarkServed) { - addKnuthElementsForSpaceBefore(returnList, alignment); - context.updateKeepWithPreviousPending(getKeepWithPrevious()); + if (!breakBeforeServed(context, returnList)) { + return returnList; } - addKnuthElementsForBorderPaddingBefore(returnList, !firstVisibleMarkServed); - firstVisibleMarkServed = true; + addFirstVisibleMarks(returnList, context, alignment); if (autoHeight && inlineElementList) { - //Spaces, border and padding to be repeated at each break - addPendingMarks(context); LayoutManager curLM; // currently active LM LayoutManager prevLM = null; // previously active LM - while ((curLM = getChildLM()) != null) { - LayoutContext childLC = new LayoutContext(0); - childLC.copyPendingMarksFrom(context); - // curLM is a ? - childLC.setStackLimitBP(context.getStackLimitBP().minus(stackLimit)); - childLC.setRefIPD(relDims.ipd); - childLC.setWritingMode(getBlockContainerFO().getWritingMode()); - if (curLM == this.childLMs.get(0)) { - childLC.setFlags(LayoutContext.SUPPRESS_BREAK_BEFORE); - //Handled already by the parent (break collapsing, see above) + + LayoutContext childLC; + boolean doReset = isRestart; + if (isRestart) { + if (emptyStack) { + assert restartAtLM != null && restartAtLM.getParent() == this; + curLM = restartAtLM; + } else { + curLM = (LayoutManager) lmStack.pop(); + // make sure the initial LM is not reset + doReset = false; + } + setCurrentChildLM(curLM); + } else { + curLM = getChildLM(); + } + + while (curLM != null) { + if (doReset) { + curLM.reset(); } + childLC = makeChildLayoutContext(context); + // get elements from curLM - returnedList = curLM.getNextKnuthElements(childLC, alignment); + if (!isRestart || emptyStack) { + returnedList = getNextChildElements(curLM, context, childLC, alignment, + null, null, null); + } else { + returnedList = getNextChildElements(curLM, context, childLC, alignment, + lmStack, restartPosition, restartAtLM); + // once encountered, irrelevant for following child LMs + emptyStack = true; + // force reset as of the next child + doReset = true; + } if (contentList.isEmpty() && childLC.isKeepWithPreviousPending()) { //Propagate keep-with-previous up from the first child context.updateKeepWithPreviousPending(childLC.getKeepWithPreviousPending()); childLC.clearKeepWithPreviousPending(); } if (returnedList.size() == 1 - && ((ListElement)returnedList.get(0)).isForcedBreak()) { + && ElementListUtils.startsWithForcedBreak(returnedList)) { // a descendant of this block has break-before - /* - if (returnList.size() == 0) { - // the first child (or its first child ...) has - // break-before; - // all this block, including space before, will be put in - // the - // following page - bSpaceBeforeServed = false; - }*/ contentList.addAll(returnedList); // "wrap" the Position inside each element // moving the elements from contentList to returnList - returnedList = new LinkedList(); wrapPositionElements(contentList, returnList); return returnList; @@ -329,9 +300,7 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager setFinished(true); } - returnedList = new LinkedList(); wrapPositionElements(contentList, returnList); - return returnList; } } @@ -339,20 +308,15 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager context.updateKeepWithNextPending(childLC.getKeepWithNextPending()); childLC.clearKeepsPending(); prevLM = curLM; + curLM = getChildLM(); } - - returnedList = new LinkedList(); wrapPositionElements(contentList, returnList); - } else { - returnList.add(refactoredBecauseOfDuplicateCode(contentRectOffsetX, - contentRectOffsetY)); + returnList.add(generateNonInlinedBox()); } - addKnuthElementsForBorderPaddingAfter(returnList, true); - addKnuthElementsForSpaceAfter(returnList, alignment); - //All child content is processed. Only break-after can occur now, so... - context.clearPendingMarks(); + addLastVisibleMarks(returnList, context, alignment); + addKnuthElementsForBreakAfter(returnList, context); context.updateKeepWithNextPending(getKeepWithNext()); @@ -361,72 +325,19 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager return returnList; } - private KnuthBox refactoredBecauseOfDuplicateCode(double contentRectOffsetX, - double contentRectOffsetY) { - - MinOptMax range = MinOptMax.getInstance(relDims.ipd); - BlockContainerBreaker breaker = new BlockContainerBreaker(this, range); - breaker.doLayout(relDims.bpd, autoHeight); - boolean contentOverflows = breaker.isOverflow(); - if (autoHeight) { - //Update content BPD now that it is known - int newHeight = breaker.deferredAlg.totalWidth; - if (blockProgressionDirectionChanges()) { - setContentAreaIPD(newHeight); - } else { - vpContentBPD = newHeight; - } - updateRelDims(contentRectOffsetX, contentRectOffsetY, false); - } - - Position bcPosition = new BlockContainerPosition(this, breaker); - KnuthBox knuthBox = new KnuthBox(vpContentBPD, notifyPos(bcPosition), false); - //TODO Handle min/opt/max for block-progression-dimension - /* These two elements will be used to add stretchability to the above box - returnList.add(new KnuthPenalty(0, KnuthElement.INFINITE, - false, returnPosition, false)); - returnList.add(new KnuthGlue(0, 1 * constantLineHeight, 0, - LINE_NUMBER_ADJUSTMENT, returnPosition, false)); - */ - - if (contentOverflows) { - BlockLevelEventProducer eventProducer = BlockLevelEventProducer.Provider.get( - getBlockContainerFO().getUserAgent().getEventBroadcaster()); - boolean canRecover = (getBlockContainerFO().getOverflow() != EN_ERROR_IF_OVERFLOW); - eventProducer.viewportOverflow(this, getBlockContainerFO().getName(), - breaker.getOverflowAmount(), needClip(), canRecover, - getBlockContainerFO().getLocator()); - } - return knuthBox; - } - - private boolean blockProgressionDirectionChanges() { - return getBlockContainerFO().getReferenceOrientation() % 180 != 0; - } - - /** {@inheritDoc} */ - public List getNextKnuthElements // CSOK: MethodLength - (LayoutContext context, int alignment, Stack lmStack, - Position restartPosition, LayoutManager restartAtLM) { - resetSpaces(); - if (isAbsoluteOrFixed()) { - return getNextKnuthElementsAbsolute(context, alignment); - } - + private void setupAreaDimensions(LayoutContext context) { autoHeight = false; - //boolean rotated = (getBlockContainerFO().getReferenceOrientation() % 180 != 0); int maxbpd = context.getStackLimitBP().getOpt(); int allocBPD; + BlockContainer fo = getBlockContainerFO(); if (height.getEnum() == EN_AUTO || (!height.isAbsolute() && getAncestorBlockAreaBPD() <= 0)) { //auto height when height="auto" or "if that dimension is not specified explicitly //(i.e., it depends on content's block-progression-dimension)" (XSL 1.0, 7.14.1) allocBPD = maxbpd; autoHeight = true; - if (getBlockContainerFO().getReferenceOrientation() == 0) { - //Cannot easily inline element list when ref-or="180" - inlineElementList = true; - } + //Cannot easily inline element list when ref-or<>"0" + inlineElementList = (fo.getReferenceOrientation() == 0); } else { allocBPD = height.getValue(this); //this is the content-height allocBPD += getBPIndents(); @@ -441,243 +352,71 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager updateContentAreaIPDwithOverconstrainedAdjust(contentWidth); } - double contentRectOffsetX = 0; - contentRectOffsetX += getBlockContainerFO() - .getCommonMarginBlock().startIndent.getValue(this); - double contentRectOffsetY = 0; - contentRectOffsetY += getBlockContainerFO() - .getCommonBorderPaddingBackground().getBorderBeforeWidth(false); - contentRectOffsetY += getBlockContainerFO() - .getCommonBorderPaddingBackground().getPaddingBefore(false, this); + contentRectOffsetX += fo.getCommonMarginBlock().startIndent.getValue(this); + contentRectOffsetY += fo.getCommonBorderPaddingBackground().getBorderBeforeWidth(false); + contentRectOffsetY += fo.getCommonBorderPaddingBackground().getPaddingBefore(false, this); - updateRelDims(contentRectOffsetX, contentRectOffsetY, autoHeight); + updateRelDims(); int availableIPD = referenceIPD - getIPIndents(); if (getContentAreaIPD() > availableIPD) { BlockLevelEventProducer eventProducer = BlockLevelEventProducer.Provider.get( - getBlockContainerFO().getUserAgent().getEventBroadcaster()); - eventProducer.objectTooWide(this, getBlockContainerFO().getName(), + fo.getUserAgent().getEventBroadcaster()); + eventProducer.objectTooWide(this, fo.getName(), getContentAreaIPD(), context.getRefIPD(), - getBlockContainerFO().getLocator()); - } - - MinOptMax stackLimit = MinOptMax.getInstance(relDims.bpd); - - List returnedList; - List contentList = new LinkedList(); - List returnList = new LinkedList(); - - if (!breakBeforeServed) { - breakBeforeServed = true; - if (!context.suppressBreakBefore()) { - if (addKnuthElementsForBreakBefore(returnList, context)) { - return returnList; - } - } + fo.getLocator()); } + } - if (!firstVisibleMarkServed) { - addKnuthElementsForSpaceBefore(returnList, alignment); - context.updateKeepWithPreviousPending(getKeepWithPrevious()); - } - - addKnuthElementsForBorderPaddingBefore(returnList, !firstVisibleMarkServed); - firstVisibleMarkServed = true; - - if (autoHeight && inlineElementList) { - //Spaces, border and padding to be repeated at each break - addPendingMarks(context); - - BlockLevelLayoutManager curLM; // currently active LM - BlockLevelLayoutManager prevLM = null; // previously active LM - - LayoutContext childLC = new LayoutContext(0); - if (lmStack.isEmpty()) { - assert restartAtLM != null && restartAtLM.getParent() == this; - curLM = (BlockLevelLayoutManager) restartAtLM; - curLM.reset(); - setCurrentChildLM(curLM); - - childLC.copyPendingMarksFrom(context); - childLC.setStackLimitBP(context.getStackLimitBP().minus(stackLimit)); - childLC.setRefIPD(relDims.ipd); - childLC.setWritingMode(getBlockContainerFO().getWritingMode()); - if (curLM == this.childLMs.get(0)) { - childLC.setFlags(LayoutContext.SUPPRESS_BREAK_BEFORE); - //Handled already by the parent (break collapsing, see above) - } - - // get elements from curLM - returnedList = curLM.getNextKnuthElements(childLC, alignment); - } else { - curLM = (BlockLevelLayoutManager) lmStack.pop(); - setCurrentChildLM(curLM); - - childLC.copyPendingMarksFrom(context); - childLC.setStackLimitBP(context.getStackLimitBP().minus(stackLimit)); - childLC.setRefIPD(relDims.ipd); - childLC.setWritingMode(getBlockContainerFO().getWritingMode()); - if (curLM == this.childLMs.get(0)) { - childLC.setFlags(LayoutContext.SUPPRESS_BREAK_BEFORE); - //Handled already by the parent (break collapsing, see above) - } + private KnuthBox generateNonInlinedBox() { - // get elements from curLM - returnedList = curLM.getNextKnuthElements(childLC, alignment, lmStack, - restartPosition, restartAtLM); - } - if (contentList.isEmpty() && childLC.isKeepWithPreviousPending()) { - //Propagate keep-with-previous up from the first child - context.updateKeepWithPreviousPending(childLC.getKeepWithPreviousPending()); - childLC.clearKeepWithPreviousPending(); - } - if (returnedList.size() == 1 - && ((ListElement)returnedList.get(0)).isForcedBreak()) { - // a descendant of this block has break-before - /* - if (returnList.size() == 0) { - // the first child (or its first child ...) has - // break-before; - // all this block, including space before, will be put in - // the - // following page - bSpaceBeforeServed = false; - }*/ - contentList.addAll(returnedList); - - // "wrap" the Position inside each element - // moving the elements from contentList to returnList - returnedList = new LinkedList(); - wrapPositionElements(contentList, returnList); - - return returnList; + MinOptMax range = MinOptMax.getInstance(relDims.ipd); + BlockContainerBreaker breaker = new BlockContainerBreaker(this, range); + breaker.doLayout(relDims.bpd, autoHeight); + boolean contentOverflows = breaker.isOverflow(); + if (autoHeight) { + //Update content BPD now that it is known + int newHeight = breaker.deferredAlg.totalWidth; + if (blockProgressionDirectionChanges()) { + setContentAreaIPD(newHeight); } else { - if (prevLM != null) { - // there is a block handled by prevLM - // before the one handled by curLM - addInBetweenBreak(contentList, context, childLC); - } - contentList.addAll(returnedList); - if (!returnedList.isEmpty()) { - if (((ListElement) ListUtil.getLast(returnedList)) - .isForcedBreak()) { - // a descendant of this block has break-after - if (curLM.isFinished()) { - // there is no other content in this block; - // it's useless to add space after before a page break - setFinished(true); - } - - returnedList = new LinkedList(); - wrapPositionElements(contentList, returnList); - - return returnList; - } - } - } - // propagate and clear - context.updateKeepWithNextPending(childLC.getKeepWithNextPending()); - childLC.clearKeepsPending(); - prevLM = curLM; - - while ((curLM = (BlockLevelLayoutManager) getChildLM()) != null) { - curLM.reset(); - childLC = new LayoutContext(0); - childLC.copyPendingMarksFrom(context); - // curLM is a ? - childLC.setStackLimitBP(context.getStackLimitBP().minus(stackLimit)); - childLC.setRefIPD(relDims.ipd); - childLC.setWritingMode(getBlockContainerFO().getWritingMode()); - if (curLM == this.childLMs.get(0)) { - childLC.setFlags(LayoutContext.SUPPRESS_BREAK_BEFORE); - //Handled already by the parent (break collapsing, see above) - } - - // get elements from curLM - returnedList = curLM.getNextKnuthElements(childLC, alignment); - if (contentList.isEmpty() && childLC.isKeepWithPreviousPending()) { - //Propagate keep-with-previous up from the first child - context.updateKeepWithPreviousPending(childLC.getKeepWithPreviousPending()); - childLC.clearKeepWithPreviousPending(); - } - if (returnedList.size() == 1 - && ((ListElement)returnedList.get(0)).isForcedBreak()) { - // a descendant of this block has break-before - /* - if (returnList.size() == 0) { - // the first child (or its first child ...) has - // break-before; - // all this block, including space before, will be put in - // the - // following page - bSpaceBeforeServed = false; - }*/ - contentList.addAll(returnedList); - - // "wrap" the Position inside each element - // moving the elements from contentList to returnList - returnedList = new LinkedList(); - wrapPositionElements(contentList, returnList); - - return returnList; - } else { - if (prevLM != null) { - // there is a block handled by prevLM - // before the one handled by curLM - addInBetweenBreak(contentList, context, childLC); - } - contentList.addAll(returnedList); - if (returnedList.isEmpty()) { - //Avoid NoSuchElementException below (happens with empty blocks) - continue; - } - if (((ListElement) ListUtil.getLast(returnedList)) - .isForcedBreak()) { - // a descendant of this block has break-after - if (curLM.isFinished()) { - // there is no other content in this block; - // it's useless to add space after before a page break - setFinished(true); - } - - returnedList = new LinkedList(); - wrapPositionElements(contentList, returnList); - - return returnList; - } - } - // propagate and clear - context.updateKeepWithNextPending(childLC.getKeepWithNextPending()); - childLC.clearKeepsPending(); - prevLM = curLM; + vpContentBPD = newHeight; } - - returnedList = new LinkedList(); - wrapPositionElements(contentList, returnList); - - } else { - returnList.add(refactoredBecauseOfDuplicateCode(contentRectOffsetX, - contentRectOffsetY)); + updateRelDims(); } - addKnuthElementsForBorderPaddingAfter(returnList, true); - addKnuthElementsForSpaceAfter(returnList, alignment); - //All child content is processed. Only break-after can occur now, so... - context.clearPendingMarks(); - addKnuthElementsForBreakAfter(returnList, context); + Position bcPosition = new BlockContainerPosition(this, breaker); + KnuthBox knuthBox = new KnuthBox(vpContentBPD, notifyPos(bcPosition), false); + //TODO Handle min/opt/max for block-progression-dimension + /* These two elements will be used to add stretchability to the above box + returnList.add(new KnuthPenalty(0, KnuthElement.INFINITE, + false, returnPosition, false)); + returnList.add(new KnuthGlue(0, 1 * constantLineHeight, 0, + LINE_NUMBER_ADJUSTMENT, returnPosition, false)); + */ - context.updateKeepWithNextPending(getKeepWithNext()); + if (contentOverflows) { + BlockLevelEventProducer eventProducer = BlockLevelEventProducer.Provider.get( + getBlockContainerFO().getUserAgent().getEventBroadcaster()); + boolean canRecover = (getBlockContainerFO().getOverflow() != EN_ERROR_IF_OVERFLOW); + eventProducer.viewportOverflow(this, getBlockContainerFO().getName(), + breaker.getOverflowAmount(), needClip(), canRecover, + getBlockContainerFO().getLocator()); + } + return knuthBox; + } - setFinished(true); - return returnList; + private boolean blockProgressionDirectionChanges() { + return getBlockContainerFO().getReferenceOrientation() % 180 != 0; } /** {@inheritDoc} */ + @Override public boolean isRestartable() { return true; } - private List getNextKnuthElementsAbsolute(LayoutContext context, int alignment) { + private List<ListElement> getNextKnuthElementsAbsolute(LayoutContext context) { autoHeight = false; boolean bpDirectionChanges = blockProgressionDirectionChanges(); @@ -783,7 +522,9 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager vpContentBPD = allocBPD - getBPIndents(); setContentAreaIPD(allocIPD - getIPIndents()); - updateRelDims(0, 0, autoHeight); + contentRectOffsetX = 0; + contentRectOffsetY = 0; + updateRelDims(); MinOptMax range = MinOptMax.getInstance(relDims.ipd); BlockContainerBreaker breaker = new BlockContainerBreaker(this, range); @@ -797,9 +538,9 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager } else { vpContentBPD = newHeight; } - updateRelDims(0, 0, false); + updateRelDims(); } - List returnList = new LinkedList(); + List<ListElement> returnList = new LinkedList<ListElement>(); if (!breaker.isEmpty()) { Position bcPosition = new BlockContainerPosition(this, breaker); returnList.add(new KnuthBox(0, notifyPos(bcPosition), false)); @@ -819,9 +560,9 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager return returnList; } - private void updateRelDims(double xOffset, double yOffset, boolean skipAutoHeight) { + private void updateRelDims() { Rectangle2D rect = new Rectangle2D.Double( - xOffset, yOffset, + contentRectOffsetX, contentRectOffsetY, getContentAreaIPD(), this.vpContentBPD); relDims = new FODimension(0, 0); @@ -879,7 +620,7 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager } public int getDifferenceOfFirstPart() { - PageBreakPosition pbp = (PageBreakPosition)this.deferredAlg.getPageBreaks().getFirst(); + PageBreakPosition pbp = this.deferredAlg.getPageBreaks().getFirst(); return pbp.difference; } @@ -908,13 +649,10 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager protected List getNextKnuthElements(LayoutContext context, int alignment) { LayoutManager curLM; // currently active LM - List returnList = new LinkedList(); + List<ListElement> returnList = new LinkedList<ListElement>(); while ((curLM = getChildLM()) != null) { - LayoutContext childLC = new LayoutContext(0); - childLC.setStackLimitBP(context.getStackLimitBP()); - childLC.setRefIPD(context.getRefIPD()); - childLC.setWritingMode(getBlockContainerFO().getWritingMode()); + LayoutContext childLC = makeChildLayoutContext(context); List returnedList = null; if (!curLM.isFinished()) { @@ -992,8 +730,8 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager } /** {@inheritDoc} */ - public void addAreas // CSOK: MethodLength - (PositionIterator parentIter, LayoutContext layoutContext) { + @Override + public void addAreas(PositionIterator parentIter, LayoutContext layoutContext) { getParentArea(null); // if this will create the first block area in a page @@ -1015,14 +753,12 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager // "unwrap" the NonLeafPositions stored in parentIter // and put them in a new list; - List positionList = new LinkedList(); + List<Position> positionList = new LinkedList<Position>(); Position pos; - boolean bSpaceBefore = false; - boolean bSpaceAfter = false; Position firstPos = null; Position lastPos = null; while (parentIter.hasNext()) { - pos = (Position) parentIter.next(); + pos = parentIter.next(); if (pos.getIndex() >= 0) { if (firstPos == null) { firstPos = pos; @@ -1041,20 +777,7 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager //Add child areas inside the reference area //bcpos.getBreaker().addContainedAreas(); } else if (innerPosition == null) { - if (pos instanceof NonLeafPosition) { - // pos was created by this BCLM and was inside an element - // representing space before or after - // this means the space was not discarded - if (positionList.isEmpty() && bcpos == null) { - // pos was in the element representing space-before - bSpaceBefore = true; - } else { - // pos was in the element representing space-after - bSpaceAfter = true; - } - } else { - //ignore (probably a Position for a simple penalty between blocks) - } + //ignore (probably a Position for a simple penalty between blocks) } else if (innerPosition.getLM() == this && !(innerPosition instanceof MappingPosition)) { // pos was created by this BlockLM and was inside a penalty @@ -1072,86 +795,15 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager addMarkersToPage(true, isFirst(firstPos), isLast(lastPos)); if (bcpos == null) { - if (bpUnit == 0) { - // the Positions in positionList were inside the elements - // created by the LineLM - childPosIter = new StackingIter(positionList.listIterator()); - } else { - // the Positions in positionList were inside the elements - // created by the BCLM in the createUnitElements() method - //if (((Position) positionList.getLast()) instanceof - // LeafPosition) { - // // the last item inside positionList is a LeafPosition - // // (a LineBreakPosition, more precisely); this means that - // // the whole paragraph is on the same page - // childPosIter = new KnuthPossPosIter(storedList, 0, - // storedList.size()); - //} else { - // // the last item inside positionList is a Position; - // // this means that the paragraph has been split - // // between consecutive pages - List splitList = new LinkedList(); - int splitLength = 0; - int iFirst = ((MappingPosition) positionList.get(0)) - .getFirstIndex(); - int iLast = ((MappingPosition) ListUtil.getLast(positionList)) - .getLastIndex(); - // copy from storedList to splitList all the elements from - // iFirst to iLast - ListIterator storedListIterator = storedList.listIterator(iFirst); - while (storedListIterator.nextIndex() <= iLast) { - KnuthElement element = (KnuthElement) storedListIterator - .next(); - // some elements in storedList (i.e. penalty items) were created - // by this BlockLM, and must be ignored - if (element.getLayoutManager() != this) { - splitList.add(element); - splitLength += element.getWidth(); - lastLM = element.getLayoutManager(); - } - } - //log.debug("Adding areas from " + iFirst + " to " + iLast); - //log.debug("splitLength= " + splitLength - // + " (" + neededUnits(splitLength) + " units') " - // + (neededUnits(splitLength) * bpUnit - splitLength) - // + " spacing"); - // add space before and / or after the paragraph - // to reach a multiple of bpUnit - if (bSpaceBefore && bSpaceAfter) { - foBlockSpaceBefore = new SpaceVal(getBlockContainerFO() - .getCommonMarginBlock().spaceBefore, this).getSpace(); - foBlockSpaceAfter = new SpaceVal(getBlockContainerFO() - .getCommonMarginBlock().spaceAfter, this).getSpace(); - adjustedSpaceBefore = (neededUnits(splitLength - + foBlockSpaceBefore.getMin() - + foBlockSpaceAfter.getMin()) - * bpUnit - splitLength) / 2; - adjustedSpaceAfter = neededUnits(splitLength - + foBlockSpaceBefore.getMin() - + foBlockSpaceAfter.getMin()) - * bpUnit - splitLength - adjustedSpaceBefore; - } else if (bSpaceBefore) { - adjustedSpaceBefore = neededUnits(splitLength - + foBlockSpaceBefore.getMin()) - * bpUnit - splitLength; - } else { - adjustedSpaceAfter = neededUnits(splitLength - + foBlockSpaceAfter.getMin()) - * bpUnit - splitLength; - } - //log.debug("space before = " + adjustedSpaceBefore - // + " space after = " + adjustedSpaceAfter + " total = " + - // (adjustedSpaceBefore + adjustedSpaceAfter + splitLength)); - childPosIter = new KnuthPossPosIter(splitList, 0, splitList - .size()); - //} - } + // the Positions in positionList were inside the elements + // created by the LineLM + childPosIter = new PositionIterator(positionList.listIterator()); while ((childLM = childPosIter.getNextChildLM()) != null) { // set last area flag lc.setFlags(LayoutContext.LAST_AREA, (layoutContext.isLastArea() && childLM == lastLM)); - /*LF*/lc.setStackLimitBP(layoutContext.getStackLimitBP()); + lc.setStackLimitBP(layoutContext.getStackLimitBP()); // Add the line areas to Area childLM.addAreas(childPosIter, lc); } @@ -1180,6 +832,7 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager * * {@inheritDoc} */ + @Override public Area getParentArea(Area childArea) { if (referenceArea == null) { boolean switchedProgressionDirection = blockProgressionDirectionChanges(); @@ -1203,9 +856,6 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager TraitSetter.addPadding(viewportBlockArea, getBlockContainerFO().getCommonBorderPaddingBackground(), discardPaddingBefore, discardPaddingAfter, false, false, this); - // TraitSetter.addBackground(viewportBlockArea, - // getBlockContainerFO().getCommonBorderPaddingBackground(), - // this); TraitSetter.addMargins(viewportBlockArea, getBlockContainerFO().getCommonBorderPaddingBackground(), startIndent, endIndent, @@ -1213,13 +863,6 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager viewportBlockArea.setCTM(absoluteCTM); viewportBlockArea.setClip(needClip()); - /* - if (getSpaceBefore() != 0) { - viewportBlockArea.addTrait(Trait.SPACE_BEFORE, new Integer(getSpaceBefore())); - } - if (foBlockSpaceAfter.opt != 0) { - viewportBlockArea.addTrait(Trait.SPACE_AFTER, new Integer(foBlockSpaceAfter.opt)); - }*/ if (abProps.absolutePosition == EN_ABSOLUTE || abProps.absolutePosition == EN_FIXED) { @@ -1256,6 +899,7 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager * * {@inheritDoc} */ + @Override public void addChildArea(Area childArea) { if (referenceArea != null) { referenceArea.addBlock((Block) childArea); @@ -1266,6 +910,7 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager * Force current area to be added to parent area. * {@inheritDoc} */ + @Override protected void flush() { viewportBlockArea.addBlock(referenceArea, autoHeight); @@ -1277,28 +922,32 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager } /** {@inheritDoc} */ + @Override public int negotiateBPDAdjustment(int adj, KnuthElement lastElement) { // TODO Auto-generated method stub return 0; } /** {@inheritDoc} */ + @Override public void discardSpace(KnuthGlue spaceGlue) { // TODO Auto-generated method stub - } /** {@inheritDoc} */ + @Override public KeepProperty getKeepTogetherProperty() { return getBlockContainerFO().getKeepTogether(); } /** {@inheritDoc} */ + @Override public KeepProperty getKeepWithPreviousProperty() { return getBlockContainerFO().getKeepWithPrevious(); } /** {@inheritDoc} */ + @Override public KeepProperty getKeepWithNextProperty() { return getBlockContainerFO().getKeepWithNext(); } @@ -1313,11 +962,13 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager // --------- Property Resolution related functions --------- // /** {@inheritDoc} */ + @Override public boolean getGeneratesReferenceArea() { return true; } /** {@inheritDoc} */ + @Override public boolean getGeneratesBlockArea() { return true; } |