From 72e24a8ee9904be481395279127d507a03d64135 Mon Sep 17 00:00:00 2001 From: "Andreas L. Delmelle" Date: Sun, 6 Feb 2011 13:40:31 +0000 Subject: [PATCH] Code cleanup: - reduce code duplication in getNextKnuthElements() - removed references to experimental BlockStackingLM.bpUnit - changed silly private method label - various fixups git-svn-id: https://svn.apache.org/repos/asf/xmlgraphics/fop/trunk@1067665 13f79535-47bb-0310-9956-ffa450edef68 --- .../BlockContainerLayoutManager.java | 559 +++++------------- 1 file changed, 137 insertions(+), 422 deletions(-) diff --git a/src/java/org/apache/fop/layoutmgr/BlockContainerLayoutManager.java b/src/java/org/apache/fop/layoutmgr/BlockContainerLayoutManager.java index 877da13dd..b74df68bc 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. @@ -98,6 +96,7 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager } /** {@inheritDoc} */ + @Override public void initialize() { abProps = getBlockContainerFO().getCommonAbsolutePosition(); foBlockSpaceBefore = new SpaceVal(getBlockContainerFO().getCommonMarginBlock() @@ -119,20 +118,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 +159,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 +168,7 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager } /** {@inheritDoc} */ + @Override public int getContentAreaBPD() { if (autoHeight) { return -1; @@ -187,11 +178,20 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager } /** {@inheritDoc} */ + @Override + public List getNextKnuthElements(LayoutContext context, int alignment) { + return getNextKnuthElements(context, alignment, null, null, null); + } + + /** {@inheritDoc} */ + @Override public List getNextKnuthElements // CSOK: MethodLength - (LayoutContext context, int alignment) { + (LayoutContext context, int alignment, Stack lmStack, + Position restartPosition, LayoutManager restartAtLM) { + boolean isRestart = (lmStack != null); resetSpaces(); if (isAbsoluteOrFixed()) { - return getNextKnuthElementsAbsolute(context, alignment); + return getNextKnuthElementsAbsolute(context); } autoHeight = false; @@ -244,9 +244,9 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager MinOptMax stackLimit = MinOptMax.getInstance(relDims.bpd); - List returnedList; - List contentList = new LinkedList(); - List returnList = new LinkedList(); + List returnedList; + List contentList = new LinkedList(); + List returnList = new LinkedList(); if (!breakBeforeServed) { breakBeforeServed = true; @@ -269,10 +269,92 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager //Spaces, border and padding to be repeated at each break addPendingMarks(context); - LayoutManager curLM; // currently active LM + LayoutManager curLM = null; // currently active LM LayoutManager prevLM = null; // previously active LM + + LayoutContext childLC = new LayoutContext(0); + if (isRestart) { + if (lmStack.isEmpty()) { + assert restartAtLM != null && restartAtLM.getParent() == this; + curLM = 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 = (LayoutManager) 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) + } + + // 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 + && ElementListUtils.startsWithForcedBreak(returnedList)) { + // a descendant of this block has break-before + contentList.addAll(returnedList); + + // "wrap" the Position inside each element + // moving the elements from contentList to returnList + 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()) { + if (ElementListUtils.endsWithForcedBreak(returnedList)) { + // a descendant of this block has break-after + if (curLM.isFinished() && !hasNextChildLM()) { + // there is no other content in this block; + // it's useless to add space after before a page break + setFinished(true); + } + + wrapPositionElements(contentList, returnList); + + return returnList; + } + } + } + } + + // propagate and clear + context.updateKeepWithNextPending(childLC.getKeepWithNextPending()); + childLC.clearKeepsPending(); + prevLM = curLM; + while ((curLM = getChildLM()) != null) { - LayoutContext childLC = new LayoutContext(0); + curLM.reset(); + childLC = new LayoutContext(0); childLC.copyPendingMarksFrom(context); // curLM is a ? childLC.setStackLimitBP(context.getStackLimitBP().minus(stackLimit)); @@ -291,22 +373,12 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager 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,7 +401,6 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager setFinished(true); } - returnedList = new LinkedList(); wrapPositionElements(contentList, returnList); return returnList; @@ -341,12 +412,10 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager prevLM = curLM; } - returnedList = new LinkedList(); wrapPositionElements(contentList, returnList); } else { - returnList.add(refactoredBecauseOfDuplicateCode(contentRectOffsetX, - contentRectOffsetY)); + returnList.add(generateNonInlinedBox(contentRectOffsetX, contentRectOffsetY)); } addKnuthElementsForBorderPaddingAfter(returnList, true); addKnuthElementsForSpaceAfter(returnList, alignment); @@ -361,8 +430,8 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager return returnList; } - private KnuthBox refactoredBecauseOfDuplicateCode(double contentRectOffsetX, - double contentRectOffsetY) { + private KnuthBox generateNonInlinedBox(double contentRectOffsetX, + double contentRectOffsetY) { MinOptMax range = MinOptMax.getInstance(relDims.ipd); BlockContainerBreaker breaker = new BlockContainerBreaker(this, range); @@ -383,11 +452,11 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager 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)); - */ + 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( @@ -405,279 +474,12 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager } /** {@inheritDoc} */ - public List getNextKnuthElements // CSOK: MethodLength - (LayoutContext context, int alignment, Stack lmStack, - Position restartPosition, LayoutManager restartAtLM) { - 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); - } - - double contentRectOffsetX = 0; - contentRectOffsetX += getBlockContainerFO() - .getCommonMarginBlock().startIndent.getValue(this); - double contentRectOffsetY = 0; - contentRectOffsetY += getBlockContainerFO() - .getCommonBorderPaddingBackground().getBorderBeforeWidth(false); - contentRectOffsetY += getBlockContainerFO() - .getCommonBorderPaddingBackground().getPaddingBefore(false, this); - - updateRelDims(contentRectOffsetX, contentRectOffsetY, autoHeight); - - 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()); - } - - 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; - } - } - } - - 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) - } - - // 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; - } 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; - } - - returnedList = new LinkedList(); - wrapPositionElements(contentList, returnList); - - } else { - returnList.add(refactoredBecauseOfDuplicateCode(contentRectOffsetX, - contentRectOffsetY)); - } - addKnuthElementsForBorderPaddingAfter(returnList, true); - addKnuthElementsForSpaceAfter(returnList, alignment); - - //All child content is processed. Only break-after can occur now, so... - context.clearPendingMarks(); - addKnuthElementsForBreakAfter(returnList, context); - - context.updateKeepWithNextPending(getKeepWithNext()); - - setFinished(true); - return returnList; - } - - /** {@inheritDoc} */ + @Override public boolean isRestartable() { return true; } - private List getNextKnuthElementsAbsolute(LayoutContext context, int alignment) { + private List getNextKnuthElementsAbsolute(LayoutContext context) { autoHeight = false; boolean bpDirectionChanges = blockProgressionDirectionChanges(); @@ -992,8 +794,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 +817,12 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager // "unwrap" the NonLeafPositions stored in parentIter // and put them in a new list; - List positionList = new LinkedList(); + List positionList = new LinkedList(); 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 +841,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 +859,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 StackingIter(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 +896,7 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager * * {@inheritDoc} */ + @Override public Area getParentArea(Area childArea) { if (referenceArea == null) { boolean switchedProgressionDirection = blockProgressionDirectionChanges(); @@ -1203,9 +920,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 +927,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 +963,7 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager * * {@inheritDoc} */ + @Override public void addChildArea(Area childArea) { if (referenceArea != null) { referenceArea.addBlock((Block) childArea); @@ -1266,6 +974,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 +986,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 +1026,13 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager // --------- Property Resolution related functions --------- // /** {@inheritDoc} */ + @Override public boolean getGeneratesReferenceArea() { return true; } /** {@inheritDoc} */ + @Override public boolean getGeneratesBlockArea() { return true; } -- 2.39.5