785291 785632 787733 787769 788371 793645 git-svn-id: https://svn.apache.org/repos/asf/xmlgraphics/fop/trunk@796809 13f79535-47bb-0310-9956-ffa450edef68tags/fop-1_0
@@ -290,14 +290,6 @@ public abstract class AbstractBreaker { | |||
ElementListObserver.observe(elementList, "breaker", null); | |||
} | |||
/** | |||
* Starts the page breaking process. | |||
* @param flowBPD the constant available block-progression-dimension (used for every part) | |||
*/ | |||
public void doLayout(int flowBPD) { | |||
doLayout(flowBPD, false); | |||
} | |||
/** | |||
* Starts the page breaking process. | |||
* @param flowBPD the constant available block-progression-dimension (used for every part) |
@@ -47,22 +47,22 @@ public abstract class AbstractLayoutManager extends AbstractBaseLayoutManager | |||
private static Log log = LogFactory.getLog(AbstractLayoutManager.class); | |||
/** Parent LayoutManager for this LayoutManager */ | |||
protected LayoutManager parentLM = null; | |||
protected LayoutManager parentLM; | |||
/** List of child LayoutManagers */ | |||
protected List childLMs = null; | |||
protected List childLMs; | |||
/** Iterator for child LayoutManagers */ | |||
protected ListIterator fobjIter = null; | |||
protected ListIterator fobjIter; | |||
/** Marker map for markers related to this LayoutManager */ | |||
private Map markers = null; | |||
private Map markers; | |||
/** True if this LayoutManager has handled all of its content. */ | |||
private boolean isFinished = false; | |||
private boolean isFinished; | |||
/** child LM during getNextKnuthElement phase */ | |||
protected LayoutManager curChildLM = null; | |||
protected LayoutManager curChildLM; | |||
/** child LM iterator during getNextKnuthElement phase */ | |||
protected ListIterator childLMiter = null; | |||
protected ListIterator childLMiter; | |||
private int lastGeneratedPosition = -1; | |||
private int smallestPosNumberChecked = Integer.MAX_VALUE; |
@@ -117,7 +117,7 @@ public class AreaAdditionUtil { | |||
// set space after for each LM, in order to implement | |||
// display-align = distribute | |||
lc.setSpaceAfter(layoutContext.getSpaceAfter()); | |||
lc.setStackLimitsFrom(layoutContext); | |||
lc.setStackLimitBP(layoutContext.getStackLimitBP()); | |||
childLM.addAreas(childPosIter, lc); | |||
} | |||
@@ -67,9 +67,6 @@ public class BlockLayoutManager extends BlockStackingLayoutManager | |||
private MinOptMax effSpaceBefore; | |||
private MinOptMax effSpaceAfter; | |||
/** The list of child BreakPoss instances. */ | |||
protected List childBreaks = new java.util.ArrayList(); | |||
/** | |||
* Creates a new BlockLayoutManager. | |||
* @param inBlock the block FO object to create the layout manager for. | |||
@@ -252,8 +249,8 @@ public class BlockLayoutManager extends BlockStackingLayoutManager | |||
// and put them in a new list; | |||
LinkedList positionList = new LinkedList(); | |||
Position pos; | |||
boolean bSpaceBefore = false; | |||
boolean bSpaceAfter = false; | |||
boolean spaceBefore = false; | |||
boolean spaceAfter = false; | |||
Position firstPos = null; | |||
Position lastPos = null; | |||
while (parentIter.hasNext()) { | |||
@@ -276,11 +273,11 @@ public class BlockLayoutManager extends BlockStackingLayoutManager | |||
// this means the space was not discarded | |||
if (positionList.size() == 0) { | |||
// pos was in the element representing space-before | |||
bSpaceBefore = true; | |||
spaceBefore = true; | |||
//log.trace(" space before"); | |||
} else { | |||
// pos was in the element representing space-after | |||
bSpaceAfter = true; | |||
spaceAfter = true; | |||
//log.trace(" space-after"); | |||
} | |||
} else if (innerPosition.getLM() == this | |||
@@ -305,7 +302,7 @@ public class BlockLayoutManager extends BlockStackingLayoutManager | |||
// the Positions in positionList were inside the elements | |||
// created by the LineLM | |||
childPosIter = new StackingIter(positionList.listIterator()); | |||
} else { | |||
} else { | |||
// the Positions in positionList were inside the elements | |||
// created by the BlockLM in the createUnitElements() method | |||
//if (((Position) positionList.getLast()) instanceof | |||
@@ -344,7 +341,7 @@ public class BlockLayoutManager extends BlockStackingLayoutManager | |||
// + " spacing"); | |||
// add space before and / or after the paragraph | |||
// to reach a multiple of bpUnit | |||
if (bSpaceBefore && bSpaceAfter) { | |||
if (spaceBefore && spaceAfter) { | |||
foSpaceBefore = new SpaceVal(getBlockFO() | |||
.getCommonMarginBlock().spaceBefore, this).getSpace(); | |||
foSpaceAfter = new SpaceVal(getBlockFO() | |||
@@ -357,7 +354,7 @@ public class BlockLayoutManager extends BlockStackingLayoutManager | |||
+ foSpaceBefore.min | |||
+ foSpaceAfter.min) | |||
* bpUnit - splitLength - adjustedSpaceBefore; | |||
} else if (bSpaceBefore) { | |||
} else if (spaceBefore) { | |||
adjustedSpaceBefore = neededUnits(splitLength | |||
+ foSpaceBefore.min) | |||
* bpUnit - splitLength; |
@@ -52,31 +52,26 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager | |||
*/ | |||
private static Log log = LogFactory.getLog(BlockStackingLayoutManager.class); | |||
/** | |||
* Reference to FO whose areas it's managing or to the traits | |||
* of the FO. | |||
*/ | |||
//protected LayoutManager curChildLM = null; AbstractLayoutManager also defines this! | |||
protected BlockParent parentArea = null; | |||
protected BlockParent parentArea; | |||
/** Value of the block-progression-unit (non-standard property) */ | |||
protected int bpUnit = 0; | |||
protected int bpUnit; | |||
/** space-before value adjusted for block-progression-unit handling */ | |||
protected int adjustedSpaceBefore = 0; | |||
protected int adjustedSpaceBefore; | |||
/** space-after value adjusted for block-progression-unit handling */ | |||
protected int adjustedSpaceAfter = 0; | |||
protected int adjustedSpaceAfter; | |||
/** Only used to store the original list when createUnitElements is called */ | |||
protected List storedList = null; | |||
protected List storedList; | |||
/** Indicates whether break before has been served or not */ | |||
protected boolean breakBeforeServed = false; | |||
protected boolean breakBeforeServed; | |||
/** Indicates whether the first visible mark has been returned by this LM, yet */ | |||
protected boolean firstVisibleMarkServed = false; | |||
protected boolean firstVisibleMarkServed; | |||
/** Reference IPD available */ | |||
protected int referenceIPD = 0; | |||
protected int referenceIPD; | |||
/** the effective start-indent value */ | |||
protected int startIndent = 0; | |||
protected int startIndent; | |||
/** the effective end-indent value */ | |||
protected int endIndent = 0; | |||
protected int endIndent; | |||
/** | |||
* Holds the (one-time use) fo:block space-before | |||
* and -after properties. Large fo:blocks are split | |||
@@ -86,13 +81,13 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager | |||
* Block and space-after at the end of the last Block | |||
* used in rendering the fo:block. | |||
*/ | |||
protected MinOptMax foSpaceBefore = null; | |||
protected MinOptMax foSpaceBefore; | |||
/** see foSpaceBefore */ | |||
protected MinOptMax foSpaceAfter = null; | |||
protected MinOptMax foSpaceAfter; | |||
private Position auxiliaryPosition; | |||
private int contentAreaIPD = 0; | |||
private int contentAreaIPD; | |||
/** | |||
* @param node the fo this LM deals with | |||
@@ -246,38 +241,27 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager | |||
/** {@inheritDoc} */ | |||
public List getNextKnuthElements(LayoutContext context, int alignment) { | |||
//log.debug("BLM.getNextKnuthElements> keep-together = " | |||
// + layoutProps.keepTogether.getType()); | |||
//log.debug(" keep-with-previous = " + | |||
// layoutProps.keepWithPrevious.getType()); | |||
//log.debug(" keep-with-next = " + | |||
// layoutProps.keepWithNext.getType()); | |||
BlockLevelLayoutManager curLM; // currently active LM | |||
BlockLevelLayoutManager prevLM = null; // previously active LM | |||
referenceIPD = context.getRefIPD(); | |||
updateContentAreaIPDwithOverconstrainedAdjust(); | |||
List returnedList = null; | |||
List contentList = new LinkedList(); | |||
List returnList = new LinkedList(); | |||
List elements = new LinkedList(); | |||
if (!breakBeforeServed) { | |||
breakBeforeServed = true; | |||
if (!context.suppressBreakBefore()) { | |||
if (addKnuthElementsForBreakBefore(returnList, context)) { | |||
return returnList; | |||
if (addKnuthElementsForBreakBefore(elements, context)) { | |||
return elements; | |||
} | |||
} | |||
} | |||
if (!firstVisibleMarkServed) { | |||
addKnuthElementsForSpaceBefore(returnList, alignment); | |||
addKnuthElementsForSpaceBefore(elements, alignment); | |||
context.updateKeepWithPreviousPending(getKeepWithPreviousStrength()); | |||
} | |||
addKnuthElementsForBorderPaddingBefore(returnList, !firstVisibleMarkServed); | |||
addKnuthElementsForBorderPaddingBefore(elements, !firstVisibleMarkServed); | |||
firstVisibleMarkServed = true; | |||
//Spaces, border and padding to be repeated at each break | |||
@@ -286,142 +270,107 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager | |||
//Used to indicate a special break-after case when all content has already been generated. | |||
BreakElement forcedBreakAfterLast = null; | |||
while ((curLM = (BlockLevelLayoutManager) getChildLM()) != null) { | |||
LayoutManager currentChildLM; | |||
while ((currentChildLM = (LayoutManager) getChildLM()) != null) { | |||
LayoutContext childLC = new LayoutContext(0); | |||
childLC.copyPendingMarksFrom(context); | |||
if (curLM instanceof LineLayoutManager) { | |||
// curLM is a LineLayoutManager | |||
// set stackLimit for lines (stack limit is now i-p-direction, not b-p-direction!) | |||
childLC.setStackLimitBP(context.getStackLimitBP()); | |||
childLC.setStackLimitIP(new MinOptMax(getContentAreaIPD())); | |||
childLC.setRefIPD(getContentAreaIPD()); | |||
} else { | |||
// curLM is a ? | |||
//childLC.setStackLimit(MinOptMax.subtract(context | |||
// .getStackLimit(), stackSize)); | |||
childLC.setStackLimitBP(context.getStackLimitBP()); | |||
childLC.setRefIPD(referenceIPD); | |||
} | |||
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()) { | |||
List childrenElements = getNextChildElements(currentChildLM, context, childLC, | |||
alignment); | |||
if (contentList.isEmpty()) { | |||
//Propagate keep-with-previous up from the first child | |||
context.updateKeepWithPreviousPending(childLC.getKeepWithPreviousPending()); | |||
childLC.clearKeepWithPreviousPending(); | |||
} | |||
if (returnedList != null | |||
&& returnedList.size() == 1 | |||
&& ((ListElement) returnedList.get(0)).isForcedBreak()) { | |||
if (curLM.isFinished() && !hasNextChildLM()) { | |||
// a descendant of this block has break-before | |||
forcedBreakAfterLast = (BreakElement) returnedList.get(0); | |||
context.clearPendingMarks(); | |||
break; | |||
} | |||
if (contentList.isEmpty()) { | |||
// Empty fo:block, zero-length box makes sure the IDs and/or markers | |||
// are registered and borders/padding are painted. | |||
returnList.add(new KnuthBox(0, notifyPos(new Position(this)), false)); | |||
} | |||
// a descendant of this block has break-before | |||
contentList.addAll(returnedList); | |||
/* extension: conversione di tutta la sequenza fin'ora ottenuta */ | |||
if (bpUnit > 0) { | |||
storedList = contentList; | |||
contentList = createUnitElements(contentList); | |||
} | |||
/* end of extension */ | |||
// "wrap" the Position inside each element | |||
// moving the elements from contentList to returnList | |||
returnedList = new LinkedList(); | |||
wrapPositionElements(contentList, returnList); | |||
return returnList; | |||
} else { | |||
if (returnedList == null || returnedList.isEmpty()) { | |||
//Avoid NoSuchElementException below (happens with empty blocks) | |||
continue; | |||
} | |||
if (prevLM != null | |||
&& !ElementListUtils.startsWithForcedBreak(returnedList)) { | |||
if (childrenElements != null && !childrenElements.isEmpty()) { | |||
if (!contentList.isEmpty() | |||
&& !ElementListUtils.startsWithForcedBreak(childrenElements)) { | |||
// there is a block handled by prevLM before the one | |||
// handled by curLM, and the one handled | |||
// by the current LM does not begin with a break | |||
addInBetweenBreak(contentList, context, childLC); | |||
} | |||
contentList.addAll(returnedList); | |||
if (ElementListUtils.endsWithForcedBreak(returnedList)) { | |||
// a descendant of this block has break-after | |||
if (curLM.isFinished() && !hasNextChildLM()) { | |||
forcedBreakAfterLast = (BreakElement) ListUtil | |||
.removeLast(contentList); | |||
if (childrenElements.size() == 1 | |||
&& ElementListUtils.startsWithForcedBreak(childrenElements)) { | |||
if (currentChildLM.isFinished() && !hasNextChildLM()) { | |||
// a descendant of this block has break-before | |||
forcedBreakAfterLast = (BreakElement) childrenElements.get(0); | |||
context.clearPendingMarks(); | |||
break; | |||
} | |||
/* extension: conversione di tutta la sequenza fin'ora ottenuta */ | |||
if (bpUnit > 0) { | |||
storedList = contentList; | |||
contentList = createUnitElements(contentList); | |||
if (contentList.isEmpty()) { | |||
// Empty fo:block, zero-length box makes sure the IDs and/or markers | |||
// are registered and borders/padding are painted. | |||
elements.add(new KnuthBox(0, notifyPos(new Position(this)), false)); | |||
} | |||
/* end of extension */ | |||
// a descendant of this block has break-before | |||
contentList.addAll(childrenElements); | |||
returnedList = new LinkedList(); | |||
wrapPositionElements(contentList, returnList); | |||
wrapPositionElements(contentList, elements); | |||
return returnList; | |||
return elements; | |||
} else { | |||
contentList.addAll(childrenElements); | |||
if (ElementListUtils.endsWithForcedBreak(childrenElements)) { | |||
// a descendant of this block has break-after | |||
if (currentChildLM.isFinished() && !hasNextChildLM()) { | |||
forcedBreakAfterLast = (BreakElement) ListUtil.removeLast(contentList); | |||
context.clearPendingMarks(); | |||
break; | |||
} | |||
wrapPositionElements(contentList, elements); | |||
return elements; | |||
} | |||
} | |||
context.updateKeepWithNextPending(childLC.getKeepWithNextPending()); | |||
} | |||
// propagate and clear | |||
context.updateKeepWithNextPending(childLC.getKeepWithNextPending()); | |||
childLC.clearKeepsPending(); | |||
prevLM = curLM; | |||
} | |||
/* Extension: conversione di tutta la sequenza fin'ora ottenuta */ | |||
if (bpUnit > 0) { | |||
storedList = contentList; | |||
contentList = createUnitElements(contentList); | |||
} | |||
/* end of extension */ | |||
returnedList = new LinkedList(); | |||
if (!contentList.isEmpty()) { | |||
wrapPositionElements(contentList, returnList); | |||
wrapPositionElements(contentList, elements); | |||
} else if (forcedBreakAfterLast == null) { | |||
// Empty fo:block, zero-length box makes sure the IDs and/or markers | |||
// are registered. | |||
returnList.add(new KnuthBox(0, notifyPos(new Position(this)), true)); | |||
elements.add(new KnuthBox(0, notifyPos(new Position(this)), true)); | |||
} | |||
addKnuthElementsForBorderPaddingAfter(returnList, true); | |||
addKnuthElementsForSpaceAfter(returnList, alignment); | |||
addKnuthElementsForBorderPaddingAfter(elements, true); | |||
addKnuthElementsForSpaceAfter(elements, alignment); | |||
//All child content is processed. Only break-after can occur now, so... | |||
context.clearPendingMarks(); | |||
if (forcedBreakAfterLast == null) { | |||
addKnuthElementsForBreakAfter(returnList, context); | |||
} | |||
if (forcedBreakAfterLast != null) { | |||
addKnuthElementsForBreakAfter(elements, context); | |||
} else { | |||
forcedBreakAfterLast.clearPendingMarks(); | |||
returnList.add(forcedBreakAfterLast); | |||
elements.add(forcedBreakAfterLast); | |||
} | |||
context.updateKeepWithNextPending(getKeepWithNextStrength()); | |||
setFinished(true); | |||
return returnList; | |||
return elements; | |||
} | |||
private List getNextChildElements(LayoutManager childLM, LayoutContext context, | |||
LayoutContext childLC, int alignment) { | |||
childLC.copyPendingMarksFrom(context); | |||
childLC.setStackLimitBP(context.getStackLimitBP()); | |||
if (childLM instanceof LineLayoutManager) { | |||
childLC.setRefIPD(getContentAreaIPD()); | |||
} else { | |||
childLC.setRefIPD(referenceIPD); | |||
} | |||
if (childLM == this.childLMs.get(0)) { | |||
childLC.setFlags(LayoutContext.SUPPRESS_BREAK_BEFORE); | |||
//Handled already by the parent (break collapsing, see above) | |||
} | |||
return childLM.getNextKnuthElements(childLC, alignment); | |||
} | |||
/** |
@@ -1272,12 +1272,8 @@ public abstract class BreakingAlgorithm { | |||
* @return the width/length in millipoints | |||
*/ | |||
protected int getLineWidth(int line) { | |||
if (this.lineWidth < 0) { | |||
throw new IllegalStateException("lineWidth must be set" | |||
+ (this.lineWidth != 0 ? " and positive, but it is: " + this.lineWidth : "")); | |||
} else { | |||
return this.lineWidth; | |||
} | |||
assert lineWidth >= 0; | |||
return this.lineWidth; | |||
} | |||
/** @return the constant line/part width or -1 if there is no such value */ |
@@ -25,11 +25,10 @@ import java.util.ListIterator; | |||
import org.apache.commons.logging.Log; | |||
import org.apache.commons.logging.LogFactory; | |||
import org.apache.fop.area.Area; | |||
import org.apache.fop.area.BlockParent; | |||
import org.apache.fop.fo.pagination.Flow; | |||
import org.apache.fop.layoutmgr.inline.InlineLevelLayoutManager; | |||
import org.apache.fop.layoutmgr.inline.WrapperLayoutManager; | |||
/** | |||
* LayoutManager for an fo:flow object. | |||
@@ -63,110 +62,89 @@ public class FlowLayoutManager extends BlockStackingLayoutManager | |||
/** {@inheritDoc} */ | |||
public List getNextKnuthElements(LayoutContext context, int alignment) { | |||
// set layout dimensions | |||
int flowIPD = getCurrentPV().getCurrentSpan().getColumnWidth(); | |||
int flowBPD = getCurrentPV().getBodyRegion().getBPD(); | |||
// currently active LM | |||
LayoutManager curLM; | |||
List returnedList; | |||
List returnList = new LinkedList(); | |||
while ((curLM = getChildLM()) != null) { | |||
if (!(curLM instanceof WrapperLayoutManager) | |||
&& curLM instanceof InlineLevelLayoutManager) { | |||
log.error("inline area not allowed under flow - ignoring"); | |||
curLM.setFinished(true); | |||
continue; | |||
} | |||
int span = EN_NONE; | |||
int disableColumnBalancing = EN_FALSE; | |||
if (curLM instanceof BlockLayoutManager) { | |||
span = ((BlockLayoutManager)curLM).getBlockFO().getSpan(); | |||
disableColumnBalancing = ((BlockLayoutManager) curLM).getBlockFO() | |||
.getDisableColumnBalancing(); | |||
} else if (curLM instanceof BlockContainerLayoutManager) { | |||
span = ((BlockContainerLayoutManager)curLM).getBlockContainerFO().getSpan(); | |||
disableColumnBalancing = ((BlockContainerLayoutManager) curLM).getBlockContainerFO() | |||
.getDisableColumnBalancing(); | |||
} | |||
List elements = new LinkedList(); | |||
int currentSpan = context.getCurrentSpan(); | |||
if (currentSpan != span) { | |||
if (span == EN_ALL) { | |||
context.setDisableColumnBalancing(disableColumnBalancing); | |||
} | |||
log.debug("span change from " + currentSpan + " to " + span); | |||
context.signalSpanChange(span); | |||
SpaceResolver.resolveElementList(returnList); | |||
return returnList; | |||
LayoutManager currentChildLM; | |||
while ((currentChildLM = getChildLM()) != null) { | |||
if (handleSpanChange(currentChildLM, elements, context)) { | |||
SpaceResolver.resolveElementList(elements); | |||
return elements; | |||
} | |||
// Set up a LayoutContext | |||
//MinOptMax bpd = context.getStackLimit(); | |||
LayoutContext childLC = new LayoutContext(0); | |||
childLC.setStackLimitBP(context.getStackLimitBP()); | |||
childLC.setRefIPD(context.getRefIPD()); | |||
childLC.setWritingMode(getCurrentPage().getSimplePageMaster().getWritingMode()); | |||
// get elements from curLM | |||
returnedList = curLM.getNextKnuthElements(childLC, alignment); | |||
//log.debug("FLM.getNextKnuthElements> returnedList.size() = " + returnedList.size()); | |||
if (returnList.size() == 0 && childLC.isKeepWithPreviousPending()) { | |||
List childrenElements = getNextChildElements(currentChildLM, context, childLC, | |||
alignment); | |||
if (elements.isEmpty()) { | |||
context.updateKeepWithPreviousPending(childLC.getKeepWithPreviousPending()); | |||
childLC.clearKeepWithPreviousPending(); | |||
} | |||
// "wrap" the Position inside each element | |||
List tempList = returnedList; | |||
returnedList = new LinkedList(); | |||
wrapPositionElements(tempList, returnedList); | |||
if (returnedList.size() == 1 | |||
&& ElementListUtils.endsWithForcedBreak(returnedList)) { | |||
// a descendant of this flow has break-before | |||
returnList.addAll(returnedList); | |||
SpaceResolver.resolveElementList(returnList); | |||
return returnList; | |||
} else if (returnedList.size() > 0) { | |||
if (returnList.size() > 0 | |||
&& !ElementListUtils.startsWithForcedBreak(returnedList)) { | |||
addInBetweenBreak(returnList, context, childLC); | |||
} | |||
returnList.addAll(returnedList); | |||
if (ElementListUtils.endsWithForcedBreak(returnList)) { | |||
if (curLM.isFinished() && !hasNextChildLM()) { | |||
//If the layout manager is finished at this point, the pending | |||
//marks become irrelevant. | |||
childLC.clearPendingMarks(); | |||
//setFinished(true); | |||
break; | |||
} | |||
// a descendant of this flow has break-after | |||
SpaceResolver.resolveElementList(returnList); | |||
return returnList; | |||
} | |||
if (!elements.isEmpty() | |||
&& !ElementListUtils.startsWithForcedBreak(childrenElements)) { | |||
addInBetweenBreak(elements, context, childLC); | |||
} | |||
//Propagate and clear | |||
context.updateKeepWithNextPending(childLC.getKeepWithNextPending()); | |||
childLC.clearKeepWithNextPending(); | |||
context.updateKeepWithNextPending(getKeepWithNextStrength()); | |||
elements.addAll(childrenElements); | |||
if (ElementListUtils.endsWithForcedBreak(elements)) { | |||
// a descendant of this flow has break-before or break-after | |||
if (currentChildLM.isFinished() && !hasNextChildLM()) { | |||
setFinished(true); | |||
} | |||
SpaceResolver.resolveElementList(elements); | |||
return elements; | |||
} | |||
} | |||
SpaceResolver.resolveElementList(returnList); | |||
SpaceResolver.resolveElementList(elements); | |||
setFinished(true); | |||
if (returnList.size() > 0) { | |||
return returnList; | |||
assert !elements.isEmpty(); | |||
return elements; | |||
} | |||
private boolean handleSpanChange(LayoutManager childLM, List elements, LayoutContext context) { | |||
int span = EN_NONE; | |||
int disableColumnBalancing = EN_FALSE; | |||
if (childLM instanceof BlockLayoutManager) { | |||
span = ((BlockLayoutManager)childLM).getBlockFO().getSpan(); | |||
disableColumnBalancing = ((BlockLayoutManager) childLM).getBlockFO() | |||
.getDisableColumnBalancing(); | |||
} else if (childLM instanceof BlockContainerLayoutManager) { | |||
span = ((BlockContainerLayoutManager)childLM).getBlockContainerFO().getSpan(); | |||
disableColumnBalancing = ((BlockContainerLayoutManager) childLM).getBlockContainerFO() | |||
.getDisableColumnBalancing(); | |||
} | |||
int currentSpan = context.getCurrentSpan(); | |||
if (currentSpan != span) { | |||
if (span == EN_ALL) { | |||
context.setDisableColumnBalancing(disableColumnBalancing); | |||
} | |||
log.debug("span change from " + currentSpan + " to " + span); | |||
context.signalSpanChange(span); | |||
return true; | |||
} else { | |||
return null; | |||
return false; | |||
} | |||
} | |||
private List getNextChildElements(LayoutManager childLM, LayoutContext context, | |||
LayoutContext childLC, int alignment) { | |||
childLC.setStackLimitBP(context.getStackLimitBP()); | |||
childLC.setRefIPD(context.getRefIPD()); | |||
childLC.setWritingMode(getCurrentPage().getSimplePageMaster().getWritingMode()); | |||
// get elements from curLM | |||
List childrenElements = childLM.getNextKnuthElements(childLC, alignment); | |||
assert !childrenElements.isEmpty(); | |||
// "wrap" the Position inside each element | |||
List tempList = childrenElements; | |||
childrenElements = new LinkedList(); | |||
wrapPositionElements(tempList, childrenElements); | |||
return childrenElements; | |||
} | |||
/** | |||
* {@inheritDoc} | |||
*/ |
@@ -57,16 +57,12 @@ public class InlineKnuthSequence extends KnuthSequence { | |||
return true; | |||
} | |||
/* (non-Javadoc) | |||
* {@inheritDoc} | |||
*/ | |||
/** {@inheritDoc} */ | |||
public boolean canAppendSequence(KnuthSequence sequence) { | |||
return sequence.isInlineSequence() && !isClosed; | |||
} | |||
/* (non-Javadoc) | |||
* {@inheritDoc} | |||
*/ | |||
/** {@inheritDoc} */ | |||
public boolean appendSequence(KnuthSequence sequence) { | |||
if (!canAppendSequence(sequence)) { | |||
return false; | |||
@@ -83,18 +79,14 @@ public class InlineKnuthSequence extends KnuthSequence { | |||
return true; | |||
} | |||
/* (non-Javadoc) | |||
* {@inheritDoc} | |||
*/ | |||
/** {@inheritDoc} */ | |||
public boolean appendSequence(KnuthSequence sequence, boolean keepTogether, | |||
BreakElement breakElement) { | |||
return appendSequence(sequence); | |||
} | |||
/* (non-Javadoc) | |||
* {@inheritDoc} | |||
*/ | |||
/** {@inheritDoc} */ | |||
public KnuthSequence endSequence() { | |||
if (!isClosed) { | |||
add(new KnuthPenalty(0, -KnuthElement.INFINITE, false, null, false)); |
@@ -78,15 +78,6 @@ public class LayoutContext { | |||
* level LM to allow them to optimize returned break possibilities. | |||
*/ | |||
private MinOptMax stackLimitBP; | |||
/** | |||
* Total available stacking dimension for a "galley-level" layout | |||
* manager in inline-progression-direction. It is passed by the | |||
* parent LM. For LineLM, the block LM determines this based on | |||
* indent properties. | |||
* These LM <b>may</b> wish to pass this information down to lower | |||
* level LM to allow them to optimize returned break possibilities. | |||
*/ | |||
private MinOptMax stackLimitIP; | |||
/** to keep track of spanning in multi-column layout */ | |||
private int currentSpan = Constants.NOT_SET; | |||
@@ -158,7 +149,7 @@ public class LayoutContext { | |||
this.flags = parentLC.flags; | |||
this.refIPD = parentLC.refIPD; | |||
this.writingMode = parentLC.writingMode; | |||
setStackLimitsFrom(parentLC); | |||
setStackLimitBP(parentLC.getStackLimitBP()); | |||
this.leadingSpace = parentLC.leadingSpace; //??? | |||
this.trailingSpace = parentLC.trailingSpace; //??? | |||
this.hyphContext = parentLC.hyphContext; | |||
@@ -183,7 +174,6 @@ public class LayoutContext { | |||
this.flags = flags; | |||
this.refIPD = 0; | |||
stackLimitBP = new MinOptMax(0); | |||
stackLimitIP = new MinOptMax(0); | |||
leadingSpace = null; | |||
trailingSpace = null; | |||
} | |||
@@ -397,31 +387,6 @@ public class LayoutContext { | |||
return stackLimitBP; | |||
} | |||
/** | |||
* Sets the stack limit in inline-progression-dimension. | |||
* @param limit the stack limit | |||
*/ | |||
public void setStackLimitIP(MinOptMax limit) { | |||
stackLimitIP = limit; | |||
} | |||
/** | |||
* Returns the stack limit in inline-progression-dimension. | |||
* @return the stack limit | |||
*/ | |||
public MinOptMax getStackLimitIP() { | |||
return stackLimitIP; | |||
} | |||
/** | |||
* Sets (Copies) the stack limits in both directions from another layout context. | |||
* @param context the layout context to take the values from | |||
*/ | |||
public void setStackLimitsFrom(LayoutContext context) { | |||
setStackLimitBP(context.getStackLimitBP()); | |||
setStackLimitIP(context.getStackLimitIP()); | |||
} | |||
/** | |||
* Sets the inline-progression-dimension of the nearest ancestor reference area. | |||
*/ | |||
@@ -662,8 +627,6 @@ public class LayoutContext { | |||
return "Layout Context:" | |||
+ "\nStack Limit BPD: \t" | |||
+ (getStackLimitBP() == null ? "null" : getStackLimitBP().toString()) | |||
+ "\nStack Limit IPD: \t" | |||
+ (getStackLimitIP() == null ? "null" : getStackLimitIP().toString()) | |||
+ "\nTrailing Space: \t" | |||
+ (getTrailingSpace() == null ? "null" : getTrailingSpace().toString()) | |||
+ "\nLeading Space: \t" |
@@ -21,15 +21,15 @@ package org.apache.fop.layoutmgr; | |||
public class LeafPosition extends Position { | |||
private int iLeafPos; | |||
private int leafPos; | |||
public LeafPosition(LayoutManager lm, int pos) { | |||
super(lm); | |||
iLeafPos = pos; | |||
leafPos = pos; | |||
} | |||
public int getLeafPos() { | |||
return iLeafPos; | |||
return leafPos; | |||
} | |||
public boolean generatesAreas() { |
@@ -77,6 +77,14 @@ public class PageBreaker extends AbstractBreaker { | |||
return pslm.getPageProvider(); | |||
} | |||
/** | |||
* Starts the page breaking process. | |||
* @param flowBPD the constant available block-progression-dimension (used for every part) | |||
*/ | |||
void doLayout(int flowBPD) { | |||
doLayout(flowBPD, false); | |||
} | |||
/** {@inheritDoc} */ | |||
protected PageBreakingLayoutListener createLayoutListener() { | |||
return new PageBreakingLayoutListener() { |
@@ -21,10 +21,6 @@ package org.apache.fop.layoutmgr; | |||
import java.util.LinkedList; | |||
import java.util.List; | |||
import java.util.ListIterator; | |||
import org.apache.commons.logging.Log; | |||
import org.apache.commons.logging.LogFactory; | |||
import org.apache.fop.area.Area; | |||
import org.apache.fop.area.Block; | |||
@@ -35,10 +31,7 @@ import org.apache.fop.fo.pagination.PageSequence; | |||
import org.apache.fop.fo.pagination.SideRegion; | |||
import org.apache.fop.fo.pagination.StaticContent; | |||
import org.apache.fop.layoutmgr.PageBreakingAlgorithm.PageBreakingLayoutListener; | |||
import org.apache.fop.layoutmgr.inline.InlineLevelLayoutManager; | |||
import org.apache.fop.layoutmgr.inline.TextLayoutManager; | |||
import org.apache.fop.traits.MinOptMax; | |||
import org.apache.fop.util.ListUtil; | |||
/** | |||
* LayoutManager for an fo:flow object. | |||
@@ -48,11 +41,6 @@ import org.apache.fop.util.ListUtil; | |||
*/ | |||
public class StaticContentLayoutManager extends BlockStackingLayoutManager { | |||
/** | |||
* logging instance | |||
*/ | |||
private static Log log = LogFactory.getLog(StaticContentLayoutManager.class); | |||
private RegionReference targetRegion; | |||
private Block targetBlock; | |||
private SideRegion regionFO; | |||
@@ -89,96 +77,7 @@ public class StaticContentLayoutManager extends BlockStackingLayoutManager { | |||
/** {@inheritDoc} */ | |||
public List getNextKnuthElements(LayoutContext context, int alignment) { | |||
if (true) { | |||
throw new UnsupportedOperationException( | |||
"Shouldn't this method be emptied because it's never called at all?"); | |||
} | |||
//TODO Empty this method?!? | |||
// set layout dimensions | |||
setContentAreaIPD(context.getRefIPD()); | |||
setContentAreaBPD(context.getStackLimitBP().opt); | |||
//TODO Copied from elsewhere. May be worthwhile to factor out the common parts. | |||
// currently active LM | |||
BlockLevelLayoutManager curLM; | |||
BlockLevelLayoutManager prevLM = null; | |||
MinOptMax stackSize = new MinOptMax(); | |||
List returnedList; | |||
List returnList = new LinkedList(); | |||
while ((curLM = ((BlockLevelLayoutManager) getChildLM())) != null) { | |||
if (curLM instanceof InlineLevelLayoutManager) { | |||
log.error("inline area not allowed under flow - ignoring"); | |||
curLM.setFinished(true); | |||
continue; | |||
} | |||
// Set up a LayoutContext | |||
MinOptMax bpd = context.getStackLimitBP(); | |||
LayoutContext childLC = new LayoutContext(0); | |||
childLC.setStackLimitBP(MinOptMax.subtract(bpd, stackSize)); | |||
childLC.setRefIPD(context.getRefIPD()); | |||
// get elements from curLM | |||
returnedList = curLM.getNextKnuthElements(childLC, alignment); | |||
//log.debug("FLM.getNextKnuthElements> returnedList.size() = " | |||
// + returnedList.size()); | |||
// "wrap" the Position inside each element | |||
List tempList = returnedList; | |||
KnuthElement tempElement; | |||
returnedList = new LinkedList(); | |||
ListIterator listIter = tempList.listIterator(); | |||
while (listIter.hasNext()) { | |||
tempElement = (KnuthElement)listIter.next(); | |||
tempElement.setPosition(new NonLeafPosition(this, tempElement.getPosition())); | |||
returnedList.add(tempElement); | |||
} | |||
if (returnedList.size() == 1 | |||
&& ((KnuthElement)returnedList.get(0)).isPenalty() | |||
&& ((KnuthPenalty)returnedList.get(0)).getP() == -KnuthElement.INFINITE) { | |||
// a descendant of this flow has break-before | |||
returnList.addAll(returnedList); | |||
return returnList; | |||
} else { | |||
if (!returnList.isEmpty()) { | |||
// there is a block before this one | |||
if (prevLM.mustKeepWithNext() | |||
|| curLM.mustKeepWithPrevious()) { | |||
// add an infinite penalty to forbid a break between blocks | |||
returnList.add(new KnuthPenalty(0, | |||
KnuthElement.INFINITE, false, | |||
new Position(this), false)); | |||
} else if (!((KnuthElement) ListUtil.getLast(returnList)) | |||
.isGlue()) { | |||
// add a null penalty to allow a break between blocks | |||
returnList.add(new KnuthPenalty(0, 0, false, new Position(this), false)); | |||
} | |||
} | |||
/*LF*/ if (!returnedList.isEmpty()) { // controllare! | |||
returnList.addAll(returnedList); | |||
final KnuthElement last = (KnuthElement) ListUtil | |||
.getLast(returnedList); | |||
if (last.isPenalty() | |||
&& ((KnuthPenalty) last).getP() == -KnuthElement.INFINITE) { | |||
// a descendant of this flow has break-after | |||
/*LF*/ //log.debug("FLM - break after!!"); | |||
return returnList; | |||
} | |||
/*LF*/ } | |||
} | |||
prevLM = curLM; | |||
} | |||
setFinished(true); | |||
if (returnList.isEmpty()) { | |||
return null; | |||
} else { | |||
return returnList; | |||
} | |||
throw new IllegalStateException(); | |||
} | |||
/** |
@@ -27,6 +27,7 @@ import java.util.ListIterator; | |||
import org.apache.commons.logging.Log; | |||
import org.apache.commons.logging.LogFactory; | |||
import org.apache.fop.area.Area; | |||
import org.apache.fop.area.Block; | |||
import org.apache.fop.area.LineArea; | |||
@@ -43,7 +44,6 @@ import org.apache.fop.layoutmgr.PageSequenceLayoutManager; | |||
import org.apache.fop.layoutmgr.Position; | |||
import org.apache.fop.layoutmgr.PositionIterator; | |||
import org.apache.fop.layoutmgr.SpaceSpecifier; | |||
import org.apache.fop.traits.MinOptMax; | |||
/** | |||
* Content Layout Manager. | |||
@@ -111,8 +111,6 @@ public class ContentLayoutManager extends AbstractBaseLayoutManager | |||
LayoutContext childLC = new LayoutContext(LayoutContext.NEW_AREA); | |||
childLC.setLeadingSpace(new SpaceSpecifier(false)); | |||
childLC.setTrailingSpace(new SpaceSpecifier(false)); | |||
// set stackLimit for lines | |||
childLC.setStackLimitIP(new MinOptMax(ipd)); | |||
childLC.setRefIPD(ipd); | |||
int lineHeight = 14000; | |||
@@ -129,8 +127,7 @@ public class ContentLayoutManager extends AbstractBaseLayoutManager | |||
stackSize = 0; | |||
List contentList = | |||
getNextKnuthElements(childLC, Constants.EN_START); | |||
List contentList = getNextKnuthElements(childLC, Constants.EN_START); | |||
ListIterator contentIter = contentList.listIterator(); | |||
while (contentIter.hasNext()) { | |||
KnuthElement element = (KnuthElement) contentIter.next(); | |||
@@ -149,8 +146,7 @@ public class ContentLayoutManager extends AbstractBaseLayoutManager | |||
lc.setFlags(LayoutContext.RESOLVE_LEADING_SPACE, true); | |||
lc.setLeadingSpace(new SpaceSpecifier(false)); | |||
lc.setTrailingSpace(new SpaceSpecifier(false)); | |||
KnuthPossPosIter contentPosIter = | |||
new KnuthPossPosIter(contentList, 0, contentList.size()); | |||
KnuthPossPosIter contentPosIter = new KnuthPossPosIter(contentList, 0, contentList.size()); | |||
curLM.addAreas(contentPosIter, lc); | |||
} | |||
@@ -248,8 +248,6 @@ public class InlineLayoutManager extends InlineStackingLayoutManager { | |||
List returnList = new LinkedList(); | |||
KnuthSequence lastSequence = null; | |||
SpaceSpecifier leadingSpace = context.getLeadingSpace(); | |||
if (fobj instanceof Title) { | |||
alignmentContext = new AlignmentContext(font, | |||
lineHeight.getOptimum(this).getLength().getValue(this), | |||
@@ -274,14 +272,6 @@ public class InlineLayoutManager extends InlineStackingLayoutManager { | |||
if (getSpaceStart() != null) { | |||
context.getLeadingSpace().addSpace(new SpaceVal(getSpaceStart(), this)); | |||
} | |||
// Check for "fence" | |||
if (hasLeadingFence(!context.isFirstArea())) { | |||
// Reset leading space sequence for child areas | |||
leadingSpace = new SpaceSpecifier(false); | |||
} | |||
// Reset state variables | |||
clearPrevIPD(); // Clear stored prev content dimensions | |||
} | |||
StringBuffer trace = new StringBuffer("InlineLM:"); |
@@ -19,12 +19,13 @@ | |||
package org.apache.fop.layoutmgr.inline; | |||
import java.util.LinkedList; | |||
import java.util.Iterator; | |||
import java.util.LinkedList; | |||
import java.util.List; | |||
import java.util.ListIterator; | |||
import java.util.HashMap; | |||
import org.apache.fop.area.Area; | |||
import org.apache.fop.area.inline.Space; | |||
import org.apache.fop.fo.FObj; | |||
import org.apache.fop.fo.properties.SpaceProperty; | |||
import org.apache.fop.layoutmgr.AbstractLayoutManager; | |||
@@ -34,8 +35,6 @@ import org.apache.fop.layoutmgr.LayoutManager; | |||
import org.apache.fop.layoutmgr.NonLeafPosition; | |||
import org.apache.fop.layoutmgr.Position; | |||
import org.apache.fop.layoutmgr.PositionIterator; | |||
import org.apache.fop.area.Area; | |||
import org.apache.fop.area.inline.Space; | |||
import org.apache.fop.traits.MinOptMax; | |||
/** | |||
@@ -62,12 +61,6 @@ public abstract class InlineStackingLayoutManager extends AbstractLayoutManager | |||
} | |||
} | |||
/** | |||
* Size of any start or end borders and padding. | |||
*/ | |||
private MinOptMax allocIPD = new MinOptMax(0); | |||
/** | |||
* Size of border and padding in BPD (ie, before and after). | |||
*/ | |||
@@ -78,9 +71,6 @@ public abstract class InlineStackingLayoutManager extends AbstractLayoutManager | |||
/** The child layout context */ | |||
protected LayoutContext childLC; | |||
/** Used to store previous content IPD for each child LM. */ | |||
private HashMap hmPrevIPD = new HashMap(); | |||
/** | |||
* Create an inline stacking layout manager. | |||
* This is used for fo's that create areas that | |||
@@ -148,22 +138,6 @@ public abstract class InlineStackingLayoutManager extends AbstractLayoutManager | |||
return null; | |||
} | |||
/** | |||
* TODO: Explain this method | |||
* @param lm ??? | |||
* @return ??? | |||
*/ | |||
protected MinOptMax getPrevIPD(LayoutManager lm) { | |||
return (MinOptMax) hmPrevIPD.get(lm); | |||
} | |||
/** | |||
* Clear the previous IPD calculation. | |||
*/ | |||
protected void clearPrevIPD() { | |||
hmPrevIPD.clear(); | |||
} | |||
/** | |||
* Returns the current area. | |||
* @return the current area |
@@ -115,8 +115,8 @@ public class LineLayoutManager extends InlineStackingLayoutManager | |||
* inline break positions. | |||
*/ | |||
private static class LineBreakPosition extends LeafPosition { | |||
private int iParIndex; // index of the Paragraph this Position refers to | |||
private int iStartIndex; //index of the first element this Position refers to | |||
private int parIndex; // index of the Paragraph this Position refers to | |||
private int startIndex; //index of the first element this Position refers to | |||
private int availableShrink; | |||
private int availableStretch; | |||
private int difference; | |||
@@ -129,16 +129,16 @@ public class LineLayoutManager extends InlineStackingLayoutManager | |||
private int spaceAfter; | |||
private int baseline; | |||
LineBreakPosition(LayoutManager lm, int index, int iStartIndex, int iBreakIndex, | |||
LineBreakPosition(LayoutManager lm, int index, int startIndex, int breakIndex, | |||
int shrink, int stretch, int diff, | |||
double ipdA, double adjust, int ind, | |||
int lh, int lw, int sb, int sa, int bl) { | |||
super(lm, iBreakIndex); | |||
super(lm, breakIndex); | |||
availableShrink = shrink; | |||
availableStretch = stretch; | |||
difference = diff; | |||
iParIndex = index; | |||
this.iStartIndex = iStartIndex; | |||
parIndex = index; | |||
this.startIndex = startIndex; | |||
ipdAdjust = ipdA; | |||
dAdjust = adjust; | |||
startIndent = ind; | |||
@@ -166,18 +166,13 @@ public class LineLayoutManager extends InlineStackingLayoutManager | |||
private Length lineHeight; | |||
private int lead; | |||
private int follow; | |||
private AlignmentContext alignmentContext = null; | |||
private AlignmentContext alignmentContext; | |||
private List knuthParagraphs = null; | |||
private int iReturnedLBP = 0; | |||
// parameters of Knuth's algorithm: | |||
// penalty value for flagged penalties | |||
private int flaggedPenalty = 50; | |||
private List knuthParagraphs; | |||
private LineLayoutPossibilities lineLayouts; | |||
private List lineLayoutsList; | |||
private int iLineWidth = 0; | |||
private int ipd = 0; | |||
/** | |||
* this constant is used to create elements when text-align is center: | |||
@@ -237,7 +232,7 @@ public class LineLayoutManager extends InlineStackingLayoutManager | |||
} else { | |||
lineFiller = new MinOptMax(lastLineEndIndent, | |||
lastLineEndIndent, | |||
layoutManager.iLineWidth); | |||
layoutManager.ipd); | |||
} | |||
// add auxiliary elements at the beginning of the paragraph | |||
@@ -318,11 +313,9 @@ public class LineLayoutManager extends InlineStackingLayoutManager | |||
private int activePossibility; | |||
private int addedPositions; | |||
private int textIndent; | |||
private int fillerMinWidth; | |||
private int lineHeight; | |||
private int lead; | |||
private int follow; | |||
private int maxDiff; | |||
private static final double MAX_DEMERITS = 10e6; | |||
public LineBreakingAlgorithm (int pageAlign, | |||
@@ -333,22 +326,17 @@ public class LineLayoutManager extends InlineStackingLayoutManager | |||
super(textAlign, textAlignLast, first, false, maxFlagCount); | |||
pageAlignment = pageAlign; | |||
textIndent = indent; | |||
fillerMinWidth = fillerWidth; | |||
lineHeight = lh; | |||
lead = ld; | |||
follow = fl; | |||
thisLLM = llm; | |||
activePossibility = -1; | |||
maxDiff = fobj.getWidows() >= fobj.getOrphans() | |||
? fobj.getWidows() | |||
: fobj.getOrphans(); | |||
} | |||
public void updateData1(int lineCount, double demerits) { | |||
lineLayouts.addPossibility(lineCount, demerits); | |||
if (super.log.isTraceEnabled()) { | |||
super.log.trace( | |||
"Layout possibility in " + lineCount + " lines; break at position:"); | |||
if (log.isTraceEnabled()) { | |||
log.trace("Layout possibility in " + lineCount + " lines; break at position:"); | |||
} | |||
} | |||
@@ -429,7 +417,7 @@ public class LineLayoutManager extends InlineStackingLayoutManager | |||
// true if this line contains only zero-height, auxiliary boxes | |||
// and the actual line width is 0; in this case, the line "collapses" | |||
// i.e. the line area will have bpd = 0 | |||
boolean bZeroHeightLine = (difference == iLineWidth); | |||
boolean bZeroHeightLine = (difference == ipd); | |||
// if line-stacking-strategy is "font-height", the line height | |||
// is not affected by its content | |||
@@ -485,7 +473,7 @@ public class LineLayoutManager extends InlineStackingLayoutManager | |||
firstElementIndex, lastElementIndex, | |||
availableShrink, availableStretch, | |||
difference, ratio, 0, indent, | |||
0, iLineWidth, 0, 0, 0); | |||
0, ipd, 0, 0, 0); | |||
} else { | |||
return new LineBreakPosition(thisLLM, | |||
knuthParagraphs.indexOf(par), | |||
@@ -493,7 +481,7 @@ public class LineLayoutManager extends InlineStackingLayoutManager | |||
availableShrink, availableStretch, | |||
difference, ratio, 0, indent, | |||
lineLead + lineFollow, | |||
iLineWidth, spaceBefore, spaceAfter, | |||
ipd, spaceBefore, spaceAfter, | |||
lineLead); | |||
} | |||
} | |||
@@ -577,14 +565,12 @@ public class LineLayoutManager extends InlineStackingLayoutManager | |||
FontInfo fi = fobj.getFOEventHandler().getFontInfo(); | |||
FontTriplet[] fontkeys = fobj.getCommonFont().getFontState(fi); | |||
Font fs = fi.getFontInstance(fontkeys[0], fobj.getCommonFont().fontSize.getValue(this)); | |||
alignmentContext | |||
= new AlignmentContext(fs, lineHeight.getValue(this), context.getWritingMode()); | |||
alignmentContext = new AlignmentContext(fs, lineHeight.getValue(this), | |||
context.getWritingMode()); | |||
context.setAlignmentContext(alignmentContext); | |||
// Get a break from currently active child LM | |||
// Set up constraints for inline level managers | |||
clearPrevIPD(); | |||
//PHASE 1: Create Knuth elements | |||
if (knuthParagraphs == null) { | |||
// it's the first time this method is called | |||
@@ -605,34 +591,6 @@ public class LineLayoutManager extends InlineStackingLayoutManager | |||
//PHASE 2: Create line breaks | |||
return createLineBreaks(context.getBPAlignment(), context); | |||
/* | |||
LineBreakPosition lbp = null; | |||
if (breakpoints == null) { | |||
// find the optimal line breaking points for each paragraph | |||
breakpoints = new ArrayList(); | |||
ListIterator paragraphsIterator | |||
= knuthParagraphs.listIterator(knuthParagraphs.size()); | |||
Paragraph currPar = null; | |||
while (paragraphsIterator.hasPrevious()) { | |||
currPar = (Paragraph) paragraphsIterator.previous(); | |||
findBreakingPoints(currPar, context.getStackLimit().opt); | |||
} | |||
}*/ | |||
//PHASE 3: Return lines | |||
/* | |||
// get a break point from the list | |||
lbp = (LineBreakPosition) breakpoints.get(iReturnedLBP ++); | |||
if (iReturnedLBP == breakpoints.size()) { | |||
setFinished(true); | |||
} | |||
BreakPoss curLineBP = new BreakPoss(lbp); | |||
curLineBP.setFlag(BreakPoss.ISLAST, isFinished()); | |||
curLineBP.setStackingSize(new MinOptMax(lbp.lineHeight)); | |||
return curLineBP; | |||
*/ | |||
} | |||
/** | |||
@@ -642,22 +600,20 @@ public class LineLayoutManager extends InlineStackingLayoutManager | |||
private void collectInlineKnuthElements(LayoutContext context) { | |||
LayoutContext inlineLC = new LayoutContext(context); | |||
InlineLevelLayoutManager curLM; | |||
List returnedList = null; | |||
iLineWidth = context.getStackLimitIP().opt; | |||
ipd = context.getRefIPD(); | |||
// convert all the text in a sequence of paragraphs made | |||
// of KnuthBox, KnuthGlue and KnuthPenalty objects | |||
boolean bPrevWasKnuthBox = false; | |||
boolean previousIsBox = false; | |||
StringBuffer trace = new StringBuffer("LineLM:"); | |||
Paragraph lastPar = null; | |||
InlineLevelLayoutManager curLM; | |||
while ((curLM = (InlineLevelLayoutManager) getChildLM()) != null) { | |||
returnedList = curLM.getNextKnuthElements(inlineLC, effectiveAlignment); | |||
if (returnedList == null | |||
|| returnedList.size() == 0) { | |||
List inlineElements = curLM.getNextKnuthElements(inlineLC, effectiveAlignment); | |||
if (inlineElements == null || inlineElements.size() == 0) { | |||
/* curLM.getNextKnuthElements() returned null or an empty list; | |||
* this can happen if there is nothing more to layout, | |||
* so just iterate once more to see if there are other children */ | |||
@@ -665,7 +621,7 @@ public class LineLayoutManager extends InlineStackingLayoutManager | |||
} | |||
if (lastPar != null) { | |||
KnuthSequence firstSeq = (KnuthSequence) returnedList.get(0); | |||
KnuthSequence firstSeq = (KnuthSequence) inlineElements.get(0); | |||
// finish last paragraph before a new block sequence | |||
if (!firstSeq.isInlineSequence()) { | |||
@@ -675,7 +631,7 @@ public class LineLayoutManager extends InlineStackingLayoutManager | |||
if (log.isTraceEnabled()) { | |||
trace.append(" ]"); | |||
} | |||
bPrevWasKnuthBox = false; | |||
previousIsBox = false; | |||
} | |||
// does the first element of the first paragraph add to an existing word? | |||
@@ -683,27 +639,24 @@ public class LineLayoutManager extends InlineStackingLayoutManager | |||
KnuthElement thisElement; | |||
thisElement = (KnuthElement) firstSeq.get(0); | |||
if (thisElement.isBox() && !thisElement.isAuxiliary() | |||
&& bPrevWasKnuthBox) { | |||
&& previousIsBox) { | |||
lastPar.addALetterSpace(); | |||
} | |||
} | |||
} | |||
// loop over the KnuthSequences (and single KnuthElements) in returnedList | |||
ListIterator iter = returnedList.listIterator(); | |||
ListIterator iter = inlineElements.listIterator(); | |||
while (iter.hasNext()) { | |||
KnuthSequence sequence = (KnuthSequence) iter.next(); | |||
// the sequence contains inline Knuth elements | |||
if (sequence.isInlineSequence()) { | |||
// look at the last element | |||
ListElement lastElement = sequence.getLast(); | |||
if (lastElement == null) { | |||
throw new NullPointerException( | |||
"Sequence was empty! lastElement is null"); | |||
} | |||
bPrevWasKnuthBox = lastElement.isBox() | |||
&& !((KnuthElement) lastElement).isAuxiliary() | |||
&& ((KnuthElement) lastElement).getW() != 0; | |||
assert lastElement != null; | |||
previousIsBox = lastElement.isBox() | |||
&& !((KnuthElement) lastElement).isAuxiliary() | |||
&& ((KnuthElement) lastElement).getW() != 0; | |||
// if last paragraph is open, add the new elements to the paragraph | |||
// else this is the last paragraph | |||
@@ -728,8 +681,7 @@ public class LineLayoutManager extends InlineStackingLayoutManager | |||
// finish last paragraph if it was closed with a linefeed | |||
if (lastElement.isPenalty() | |||
&& ((KnuthPenalty) lastElement).getP() | |||
== -KnuthPenalty.INFINITE) { | |||
&& ((KnuthPenalty) lastElement).getP() == -KnuthPenalty.INFINITE) { | |||
// a penalty item whose value is -inf | |||
// represents a preserved linefeed, | |||
// which forces a line break | |||
@@ -737,7 +689,7 @@ public class LineLayoutManager extends InlineStackingLayoutManager | |||
if (!lastPar.containsBox()) { | |||
//only a forced linefeed on this line | |||
//-> compensate with an auxiliary glue | |||
lastPar.add(new KnuthGlue(iLineWidth, 0, iLineWidth, null, true)); | |||
lastPar.add(new KnuthGlue(ipd, 0, ipd, null, true)); | |||
} | |||
lastPar.endParagraph(); | |||
ElementListObserver.observe(lastPar, "line", null); | |||
@@ -745,7 +697,7 @@ public class LineLayoutManager extends InlineStackingLayoutManager | |||
if (log.isTraceEnabled()) { | |||
trace.append(" ]"); | |||
} | |||
bPrevWasKnuthBox = false; | |||
previousIsBox = false; | |||
} | |||
} else { // the sequence is a block sequence | |||
// the positions will be wrapped with this LM in postProcessLineBreaks | |||
@@ -766,134 +718,6 @@ public class LineLayoutManager extends InlineStackingLayoutManager | |||
log.trace(trace); | |||
} | |||
/** | |||
* Find a set of breaking points. | |||
* This method is called only once by getNextBreakPoss, and it | |||
* subsequently calls the other findBreakingPoints() method with | |||
* different parameters, until a set of breaking points is found. | |||
* | |||
* @param par the list of elements that must be parted | |||
* into lines | |||
* @param lineWidth the desired length ot the lines | |||
*/ | |||
/* | |||
private void findBreakingPoints(Paragraph par, int lineWidth) { | |||
// maximum adjustment ratio permitted | |||
float maxAdjustment = 1; | |||
// first try | |||
if (!findBreakingPoints(par, lineWidth, maxAdjustment, false)) { | |||
// the first try failed, now try something different | |||
log.debug("No set of breaking points found with maxAdjustment = " + maxAdjustment); | |||
if (hyphenationProperties.hyphenate == Constants.EN_TRUE) { | |||
// consider every hyphenation point as a legal break | |||
findHyphenationPoints(par); | |||
} else { | |||
// try with a higher threshold | |||
maxAdjustment = 5; | |||
} | |||
if (!findBreakingPoints(par, lineWidth, maxAdjustment, false)) { | |||
// the second try failed too, try with a huge threshold; | |||
// if this fails too, use a different algorithm | |||
log.debug("No set of breaking points found with maxAdjustment = " + maxAdjustment | |||
+ (hyphenationProperties.hyphenate == Constants.EN_TRUE ? " and hyphenation" : "")); | |||
maxAdjustment = 20; | |||
if (!findBreakingPoints(par, lineWidth, maxAdjustment, true)) { | |||
log.debug("No set of breaking points found, using first-fit algorithm"); | |||
} | |||
} | |||
} | |||
} | |||
private boolean findBreakingPoints(Paragraph par, int lineWidth, | |||
double threshold, boolean force) { | |||
KnuthParagraph knuthPara = new KnuthParagraph(par); | |||
int lines = knuthPara.findBreakPoints(lineWidth, threshold, force); | |||
if (lines == 0) { | |||
return false; | |||
} | |||
for (int i = lines-1; i >= 0; i--) { | |||
int line = i+1; | |||
if (log.isTraceEnabled()) { | |||
log.trace("Making line from " + knuthPara.getStart(i) + " to " + | |||
knuthPara.getEnd(i)); | |||
} | |||
// compute indent and adjustment ratio, according to | |||
// the value of text-align and text-align-last | |||
int difference = knuthPara.getDifference(i); | |||
if (line == lines) { | |||
difference += par.lineFillerWidth; | |||
} | |||
int textAlign = (line < lines) | |||
? textAlignment : textAlignmentLast; | |||
int indent = (textAlign == EN_CENTER) | |||
? difference / 2 | |||
: (textAlign == EN_END) ? difference : 0; | |||
indent += (line == 1 && knuthParagraphs.indexOf(par) == 0) | |||
? textIndent.getValue(this) : 0; | |||
double ratio = (textAlign == EN_JUSTIFY) | |||
? knuthPara.getAdjustRatio(i) : 0; | |||
int start = knuthPara.getStart(i); | |||
int end = knuthPara.getEnd(i); | |||
makeLineBreakPosition(par, start, end, 0, ratio, indent); | |||
} | |||
return true; | |||
} | |||
private void makeLineBreakPosition(Paragraph par, | |||
int firstElementIndex, int lastElementIndex, | |||
int insertIndex, double ratio, int indent) { | |||
// line height calculation | |||
int halfLeading = (lineHeight - lead - follow) / 2; | |||
// height above the main baseline | |||
int lineLead = lead + halfLeading; | |||
// maximum size of top and bottom alignment | |||
int lineFollow = follow + halfLeading; | |||
ListIterator inlineIterator | |||
= par.listIterator(firstElementIndex); | |||
for (int j = firstElementIndex; | |||
j <= lastElementIndex; | |||
j++) { | |||
KnuthElement element = (KnuthElement) inlineIterator.next(); | |||
if (element.isBox()) { | |||
KnuthInlineBox box = (KnuthInlineBox)element; | |||
if (box.getLead() > lineLead) { | |||
lineLead = box.getLead(); | |||
} | |||
if (box.getTotal() > lineFollow) { | |||
lineFollow = box.getTotal(); | |||
} | |||
if (box.getMiddle() > lineLead + middleShift) { | |||
lineLead += box.getMiddle() | |||
- lineLead - middleShift; | |||
} | |||
if (box.getMiddle() > middlefollow - middleShift) { | |||
middlefollow += box.getMiddle() | |||
- middlefollow + middleShift; | |||
} | |||
} | |||
} | |||
if (lineFollow - lineLead > middlefollow) { | |||
middlefollow = lineFollow - lineLead; | |||
} | |||
breakpoints.add(insertIndex, | |||
new LineBreakPosition(this, | |||
knuthParagraphs.indexOf(par), | |||
lastElementIndex , | |||
ratio, 0, indent, | |||
lineLead + middlefollow, | |||
lineLead)); | |||
}*/ | |||
/** | |||
* Phase 2 of Knuth algorithm: find optimal break points. | |||
* @param alignment alignment in BP direction of the paragraph | |||
@@ -901,10 +725,8 @@ public class LineLayoutManager extends InlineStackingLayoutManager | |||
* @return a list of Knuth elements representing broken lines | |||
*/ | |||
private List createLineBreaks(int alignment, LayoutContext context) { | |||
// find the optimal line breaking points for each paragraph | |||
ListIterator paragraphsIterator | |||
= knuthParagraphs.listIterator(knuthParagraphs.size()); | |||
ListIterator paragraphsIterator = knuthParagraphs.listIterator(knuthParagraphs.size()); | |||
lineLayoutsList = new ArrayList(knuthParagraphs.size()); | |||
LineLayoutPossibilities llPoss; | |||
while (paragraphsIterator.hasPrevious()) { | |||
@@ -957,7 +779,7 @@ public class LineLayoutManager extends InlineStackingLayoutManager | |||
} else { | |||
allowedBreaks = BreakingAlgorithm.NO_FLAGGED_PENALTIES; | |||
} | |||
alg.setConstantLineWidth(iLineWidth); | |||
alg.setConstantLineWidth(ipd); | |||
iBPcount = alg.findBreakingPoints(currPar, | |||
maxAdjustment, false, allowedBreaks); | |||
if (iBPcount == 0 || alignment == EN_JUSTIFY) { | |||
@@ -1013,26 +835,26 @@ public class LineLayoutManager extends InlineStackingLayoutManager | |||
alg.resetAlgorithm(); | |||
lineLayouts.savePossibilities(true); | |||
// try with shorter lines | |||
int savedLineWidth = iLineWidth; | |||
iLineWidth = (int) (iLineWidth * 0.95); | |||
int savedLineWidth = ipd; | |||
ipd = (int) (ipd * 0.95); | |||
iBPcount = alg.findBreakingPoints(currPar, | |||
maxAdjustment, true, allowedBreaks); | |||
maxAdjustment, true, allowedBreaks); | |||
// use normal lines, when possible | |||
lineLayouts.restorePossibilities(); | |||
iLineWidth = savedLineWidth; | |||
ipd = savedLineWidth; | |||
} | |||
if (!lineLayouts.canUseLessLines()) { | |||
alg.resetAlgorithm(); | |||
lineLayouts.savePossibilities(true); | |||
// try with longer lines | |||
int savedLineWidth = iLineWidth; | |||
iLineWidth = (int) (iLineWidth * 1.05); | |||
alg.setConstantLineWidth(iLineWidth); | |||
int savedLineWidth = ipd; | |||
ipd = (int) (ipd * 1.05); | |||
alg.setConstantLineWidth(ipd); | |||
iBPcount = alg.findBreakingPoints(currPar, | |||
maxAdjustment, true, allowedBreaks); | |||
// use normal lines, when possible | |||
lineLayouts.restorePossibilities(); | |||
iLineWidth = savedLineWidth; | |||
ipd = savedLineWidth; | |||
} | |||
//log.debug("LLM.getNextKnuthElements> now, layouts with more lines? " + lineLayouts.canUseMoreLines()); | |||
//log.debug(" now, layouts with fewer lines? " + lineLayouts.canUseLessLines()); | |||
@@ -1114,15 +936,14 @@ public class LineLayoutManager extends InlineStackingLayoutManager | |||
while (elementIterator.nextIndex() <= endIndex) { | |||
KnuthElement element = (KnuthElement) elementIterator.next(); | |||
if (element instanceof KnuthInlineBox | |||
&& ((KnuthInlineBox) element).isAnchor()) { | |||
&& ((KnuthInlineBox) element).isAnchor()) { | |||
footnoteList.add(((KnuthInlineBox) element).getFootnoteBodyLM()); | |||
} else if (element instanceof KnuthBlockBox) { | |||
footnoteList.addAll(((KnuthBlockBox) element).getFootnoteBodyLMs()); | |||
} | |||
} | |||
startIndex = endIndex + 1; | |||
LineBreakPosition lbp | |||
= (LineBreakPosition) llPoss.getChosenPosition(i); | |||
LineBreakPosition lbp = (LineBreakPosition) llPoss.getChosenPosition(i); | |||
returnList.add(new KnuthBlockBox | |||
(lbp.lineHeight + lbp.spaceBefore + lbp.spaceAfter, | |||
footnoteList, lbp, false)); | |||
@@ -1580,7 +1401,7 @@ public class LineLayoutManager extends InlineStackingLayoutManager | |||
Position pos = (Position) parentIter.next(); | |||
boolean isLastPosition = !parentIter.hasNext(); | |||
if (pos instanceof LineBreakPosition) { | |||
addInlineArea(context, pos, isLastPosition); | |||
addInlineArea(context, (LineBreakPosition) pos, isLastPosition); | |||
} else if ((pos instanceof NonLeafPosition) && pos.generatesAreas()) { | |||
addBlockArea(context, pos, isLastPosition); | |||
} else { | |||
@@ -1600,147 +1421,129 @@ public class LineLayoutManager extends InlineStackingLayoutManager | |||
* @param pos the position for which the line is generated | |||
* @param isLastPosition true if this is the last position of this LM | |||
*/ | |||
private void addInlineArea(LayoutContext context, Position pos, boolean isLastPosition) { | |||
ListIterator seqIterator = null; | |||
KnuthElement tempElement = null; | |||
// the TLM which created the last KnuthElement in this line | |||
LayoutManager lastLM = null; | |||
LineBreakPosition lbp = (LineBreakPosition) pos; | |||
int iCurrParIndex; | |||
iCurrParIndex = lbp.iParIndex; | |||
KnuthSequence seq = (KnuthSequence) knuthParagraphs.get(iCurrParIndex); | |||
int iStartElement = lbp.iStartIndex; | |||
int iEndElement = lbp.getLeafPos(); | |||
LineArea lineArea | |||
= new LineArea((lbp.getLeafPos() < seq.size() - 1 | |||
? textAlignment : textAlignmentLast), | |||
lbp.difference, lbp.availableStretch, lbp.availableShrink); | |||
if (lbp.startIndent != 0) { | |||
lineArea.addTrait(Trait.START_INDENT, new Integer(lbp.startIndent)); | |||
} | |||
lineArea.setBPD(lbp.lineHeight); | |||
lineArea.setIPD(lbp.lineWidth); | |||
lineArea.addTrait(Trait.SPACE_BEFORE, new Integer(lbp.spaceBefore)); | |||
lineArea.addTrait(Trait.SPACE_AFTER, new Integer(lbp.spaceAfter)); | |||
alignmentContext.resizeLine(lbp.lineHeight, lbp.baseline); | |||
if (seq instanceof Paragraph) { | |||
Paragraph currPar = (Paragraph) seq; | |||
// ignore the first elements added by the LineLayoutManager | |||
iStartElement += (iStartElement == 0) ? currPar.ignoreAtStart : 0; | |||
// if this is the last line area that for this paragraph, | |||
// ignore the last elements added by the LineLayoutManager and | |||
// subtract the last-line-end-indent from the area ipd | |||
if (iEndElement == (currPar.size() - 1)) { | |||
iEndElement -= currPar.ignoreAtEnd; | |||
lineArea.setIPD(lineArea.getIPD() - lastLineEndIndent.getValue(this)); | |||
} | |||
private void addInlineArea(LayoutContext context, LineBreakPosition lbp, | |||
boolean isLastPosition) { | |||
// the TLM which created the last KnuthElement in this line | |||
LayoutManager lastLM = null; | |||
KnuthSequence seq = (KnuthSequence) knuthParagraphs.get(lbp.parIndex); | |||
int startElementIndex = lbp.startIndex; | |||
int endElementIndex = lbp.getLeafPos(); | |||
LineArea lineArea = new LineArea( | |||
(lbp.getLeafPos() < seq.size() - 1 ? textAlignment : textAlignmentLast), | |||
lbp.difference, lbp.availableStretch, lbp.availableShrink); | |||
if (lbp.startIndent != 0) { | |||
lineArea.addTrait(Trait.START_INDENT, new Integer(lbp.startIndent)); | |||
} | |||
lineArea.setBPD(lbp.lineHeight); | |||
lineArea.setIPD(lbp.lineWidth); | |||
lineArea.addTrait(Trait.SPACE_BEFORE, new Integer(lbp.spaceBefore)); | |||
lineArea.addTrait(Trait.SPACE_AFTER, new Integer(lbp.spaceAfter)); | |||
alignmentContext.resizeLine(lbp.lineHeight, lbp.baseline); | |||
if (seq instanceof Paragraph) { | |||
Paragraph currPar = (Paragraph) seq; | |||
// ignore the first elements added by the LineLayoutManager | |||
startElementIndex += (startElementIndex == 0) ? currPar.ignoreAtStart : 0; | |||
// if this is the last line area that for this paragraph, | |||
// ignore the last elements added by the LineLayoutManager and | |||
// subtract the last-line-end-indent from the area ipd | |||
if (endElementIndex == (currPar.size() - 1)) { | |||
endElementIndex -= currPar.ignoreAtEnd; | |||
lineArea.setIPD(lineArea.getIPD() - lastLineEndIndent.getValue(this)); | |||
} | |||
} | |||
// Remove trailing spaces if allowed so | |||
if (whiteSpaceTreament == EN_IGNORE_IF_SURROUNDING_LINEFEED | |||
// Remove trailing spaces if allowed so | |||
if (whiteSpaceTreament == EN_IGNORE_IF_SURROUNDING_LINEFEED | |||
|| whiteSpaceTreament == EN_IGNORE | |||
|| whiteSpaceTreament == EN_IGNORE_IF_BEFORE_LINEFEED) { | |||
// ignore the last element in the line if it is a KnuthGlue object | |||
seqIterator = seq.listIterator(iEndElement); | |||
tempElement = (KnuthElement) seqIterator.next(); | |||
if (tempElement.isGlue()) { | |||
iEndElement--; | |||
// this returns the same KnuthElement | |||
seqIterator.previous(); | |||
if (seqIterator.hasPrevious()) { | |||
tempElement = (KnuthElement) seqIterator.previous(); | |||
} else { | |||
tempElement = null; | |||
} | |||
} | |||
if (tempElement != null) { | |||
lastLM = tempElement.getLayoutManager(); | |||
// ignore the last element in the line if it is a KnuthGlue object | |||
ListIterator seqIterator = seq.listIterator(endElementIndex); | |||
KnuthElement lastElement = (KnuthElement) seqIterator.next(); | |||
lastLM = lastElement.getLayoutManager(); | |||
if (lastElement.isGlue()) { | |||
endElementIndex--; | |||
// this returns the same KnuthElement | |||
seqIterator.previous(); | |||
if (seqIterator.hasPrevious()) { | |||
lastLM = ((KnuthElement) seqIterator.previous()).getLayoutManager(); | |||
} | |||
} | |||
} | |||
// Remove leading spaces if allowed so | |||
if (whiteSpaceTreament == EN_IGNORE_IF_SURROUNDING_LINEFEED | |||
// Remove leading spaces if allowed so | |||
if (whiteSpaceTreament == EN_IGNORE_IF_SURROUNDING_LINEFEED | |||
|| whiteSpaceTreament == EN_IGNORE | |||
|| whiteSpaceTreament == EN_IGNORE_IF_AFTER_LINEFEED) { | |||
// ignore KnuthGlue and KnuthPenalty objects | |||
// at the beginning of the line | |||
seqIterator = seq.listIterator(iStartElement); | |||
tempElement = (KnuthElement) seqIterator.next(); | |||
while (!tempElement.isBox() && seqIterator.hasNext()) { | |||
tempElement = (KnuthElement) seqIterator.next(); | |||
iStartElement++; | |||
} | |||
} | |||
// Add the inline areas to lineArea | |||
PositionIterator inlinePosIter | |||
= new KnuthPossPosIter(seq, iStartElement, iEndElement + 1); | |||
iStartElement = lbp.getLeafPos() + 1; | |||
if (iStartElement == seq.size()) { | |||
// advance to next paragraph | |||
iStartElement = 0; | |||
// ignore KnuthGlue and KnuthPenalty objects | |||
// at the beginning of the line | |||
ListIterator seqIterator = seq.listIterator(startElementIndex); | |||
while (seqIterator.hasNext() && !((KnuthElement) seqIterator.next()).isBox()) { | |||
startElementIndex++; | |||
} | |||
} | |||
// Add the inline areas to lineArea | |||
PositionIterator inlinePosIter = new KnuthPossPosIter(seq, startElementIndex, | |||
endElementIndex + 1); | |||
LayoutContext lc = new LayoutContext(0); | |||
lc.setAlignmentContext(alignmentContext); | |||
lc.setSpaceAdjust(lbp.dAdjust); | |||
lc.setIPDAdjust(lbp.ipdAdjust); | |||
lc.setLeadingSpace(new SpaceSpecifier(true)); | |||
lc.setTrailingSpace(new SpaceSpecifier(false)); | |||
lc.setFlags(LayoutContext.RESOLVE_LEADING_SPACE, true); | |||
/* | |||
* extension (not in the XSL FO recommendation): if the left and right margins | |||
* have been optimized, recompute indents and / or adjust ratio, according | |||
* to the paragraph horizontal alignment | |||
*/ | |||
if (false && textAlignment == EN_JUSTIFY) { | |||
// re-compute space adjust ratio | |||
int updatedDifference = context.getStackLimitIP().opt | |||
- lbp.lineWidth + lbp.difference; | |||
double updatedRatio = 0.0; | |||
if (updatedDifference > 0) { | |||
updatedRatio = (float) updatedDifference / lbp.availableStretch; | |||
} else if (updatedDifference < 0) { | |||
updatedRatio = (float) updatedDifference / lbp.availableShrink; | |||
} | |||
lc.setIPDAdjust(updatedRatio); | |||
//log.debug("LLM.addAreas> old difference = " + lbp.difference + " new difference = " + updatedDifference); | |||
//log.debug(" old ratio = " + lbp.ipdAdjust + " new ratio = " + updatedRatio); | |||
} else if (false && textAlignment == EN_CENTER) { | |||
// re-compute indent | |||
int updatedIndent = lbp.startIndent | |||
+ (context.getStackLimitIP().opt - lbp.lineWidth) / 2; | |||
lineArea.addTrait(Trait.START_INDENT, new Integer(updatedIndent)); | |||
} else if (false && textAlignment == EN_END) { | |||
// re-compute indent | |||
int updatedIndent = lbp.startIndent | |||
+ (context.getStackLimitIP().opt - lbp.lineWidth); | |||
lineArea.addTrait(Trait.START_INDENT, new Integer(updatedIndent)); | |||
} | |||
LayoutContext lc = new LayoutContext(0); | |||
lc.setAlignmentContext(alignmentContext); | |||
lc.setSpaceAdjust(lbp.dAdjust); | |||
lc.setIPDAdjust(lbp.ipdAdjust); | |||
lc.setLeadingSpace(new SpaceSpecifier(true)); | |||
lc.setTrailingSpace(new SpaceSpecifier(false)); | |||
lc.setFlags(LayoutContext.RESOLVE_LEADING_SPACE, true); | |||
setCurrentArea(lineArea); | |||
setChildContext(lc); | |||
LayoutManager childLM; | |||
while ((childLM = inlinePosIter.getNextChildLM()) != null) { | |||
lc.setFlags(LayoutContext.LAST_AREA, (childLM == lastLM)); | |||
childLM.addAreas(inlinePosIter, lc); | |||
lc.setLeadingSpace(lc.getTrailingSpace()); | |||
lc.setTrailingSpace(new SpaceSpecifier(false)); | |||
/* | |||
* extension (not in the XSL FO recommendation): if the left and right margins | |||
* have been optimized, recompute indents and / or adjust ratio, according | |||
* to the paragraph horizontal alignment | |||
*/ | |||
if (false && textAlignment == EN_JUSTIFY) { | |||
// re-compute space adjust ratio | |||
int updatedDifference = context.getRefIPD() | |||
- lbp.lineWidth + lbp.difference; | |||
double updatedRatio = 0.0; | |||
if (updatedDifference > 0) { | |||
updatedRatio = (float) updatedDifference / lbp.availableStretch; | |||
} else if (updatedDifference < 0) { | |||
updatedRatio = (float) updatedDifference / lbp.availableShrink; | |||
} | |||
lc.setIPDAdjust(updatedRatio); | |||
//log.debug("LLM.addAreas> old difference = " + lbp.difference + " new difference = " + updatedDifference); | |||
//log.debug(" old ratio = " + lbp.ipdAdjust + " new ratio = " + updatedRatio); | |||
} else if (false && textAlignment == EN_CENTER) { | |||
// re-compute indent | |||
int updatedIndent = lbp.startIndent | |||
+ (context.getRefIPD() - lbp.lineWidth) / 2; | |||
lineArea.addTrait(Trait.START_INDENT, new Integer(updatedIndent)); | |||
} else if (false && textAlignment == EN_END) { | |||
// re-compute indent | |||
int updatedIndent = lbp.startIndent | |||
+ (context.getRefIPD() - lbp.lineWidth); | |||
lineArea.addTrait(Trait.START_INDENT, new Integer(updatedIndent)); | |||
} | |||
// when can this be null? | |||
// if display-align is distribute, add space after | |||
if (context.getSpaceAfter() > 0 | |||
&& (!context.isLastArea() || !isLastPosition)) { | |||
lineArea.setBPD(lineArea.getBPD() + context.getSpaceAfter()); | |||
} | |||
lineArea.finalise(); | |||
parentLM.addChildArea(lineArea); | |||
setCurrentArea(lineArea); | |||
setChildContext(lc); | |||
LayoutManager childLM; | |||
while ((childLM = inlinePosIter.getNextChildLM()) != null) { | |||
lc.setFlags(LayoutContext.LAST_AREA, (childLM == lastLM)); | |||
childLM.addAreas(inlinePosIter, lc); | |||
lc.setLeadingSpace(lc.getTrailingSpace()); | |||
lc.setTrailingSpace(new SpaceSpecifier(false)); | |||
} | |||
// if display-align is distribute, add space after | |||
if (context.getSpaceAfter() > 0 | |||
&& (!context.isLastArea() || !isLastPosition)) { | |||
lineArea.setBPD(lineArea.getBPD() + context.getSpaceAfter()); | |||
} | |||
lineArea.finalise(); | |||
parentLM.addChildArea(lineArea); | |||
} | |||
/** | |||
@@ -1783,7 +1586,7 @@ public class LineLayoutManager extends InlineStackingLayoutManager | |||
// set last area flag | |||
blocklc.setFlags(LayoutContext.LAST_AREA, | |||
(context.isLastArea() && childLM == lastLM)); | |||
blocklc.setStackLimitsFrom(context); | |||
blocklc.setStackLimitBP(context.getStackLimitBP()); | |||
// Add the line areas to Area | |||
childLM.addAreas(childPosIter, blocklc); | |||
blocklc.setLeadingSpace(blocklc.getTrailingSpace()); |