public abstract class BlockStackingLayoutManager extends AbstractLayoutManager
implements BlockLevelLayoutManager {
- /**
- * logging instance
- */
+ /** logging instance */
private static Log log = LogFactory.getLog(BlockStackingLayoutManager.class);
/** parent area */
/** space-after value adjusted for block-progression-unit handling */
protected int adjustedSpaceAfter;
/** Only used to store the original list when createUnitElements is called */
- protected List storedList;
+ protected List<KnuthElement> storedList;
/** Indicates whether break before has been served or not */
protected boolean breakBeforeServed;
/** Indicates whether the first visible mark has been returned by this LM, yet */
* If so, add it. Otherwise initiate breaking.
* @param childArea the area to add: will be some block-stacked Area.
*/
+ @Override
public void addChildArea(Area childArea) {
addChildToArea(childArea, getCurrentArea());
}
- /** {@inheritDoc} */
- protected void notifyEndOfLayout() {
- super.notifyEndOfLayout();
- // Free memory of the area tree
- //this.parentArea = null;
- }
-
/**
* Force current area to be added to parent area.
*/
}
/** {@inheritDoc} */
+ @Override
public List getNextKnuthElements(LayoutContext context, int alignment) {
referenceIPD = context.getRefIPD();
updateContentAreaIPDwithOverconstrainedAdjust();
- List contentList = new LinkedList();
- List elements = new LinkedList();
+ List<ListElement> contentList = new LinkedList<ListElement>();
+ List<ListElement> elements = new LinkedList<ListElement>();
if (!breakBeforeServed) {
breakBeforeServed = true;
BreakElement forcedBreakAfterLast = null;
LayoutManager currentChildLM;
- while ((currentChildLM = (LayoutManager) getChildLM()) != null) {
+ while ((currentChildLM = getChildLM()) != null) {
LayoutContext childLC = new LayoutContext(0);
- List childrenElements = getNextChildElements(currentChildLM, context, childLC,
- alignment);
+ List<ListElement> childrenElements
+ = getNextChildElements(currentChildLM, context, childLC, alignment);
if (contentList.isEmpty()) {
//Propagate keep-with-previous up from the first child
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));
+ elements.add(makeAuxiliaryZeroWidthBox());
}
// a descendant of this block has break-before
contentList.addAll(childrenElements);
} else if (forcedBreakAfterLast == null) {
// Empty fo:block, zero-length box makes sure the IDs and/or markers
// are registered.
- elements.add(new KnuthBox(0, notifyPos(new Position(this)), true));
+ elements.add(makeAuxiliaryZeroWidthBox());
}
addKnuthElementsForBorderPaddingAfter(elements, true);
}
/** {@inheritDoc} */
+ @Override
public List getNextKnuthElements // CSOK: MethodLength
(LayoutContext context, int alignment, Stack lmStack,
Position restartPosition, LayoutManager restartAtLM) {
referenceIPD = context.getRefIPD();
updateContentAreaIPDwithOverconstrainedAdjust();
- List contentList = new LinkedList();
- List elements = new LinkedList();
+ List<ListElement> contentList = new LinkedList<ListElement>();
+ List<ListElement> elements = new LinkedList<ListElement>();
if (!breakBeforeServed) {
breakBeforeServed = true;
BreakElement forcedBreakAfterLast = null;
LayoutContext childLC = new LayoutContext(0);
- List childrenElements;
+ List<ListElement> childrenElements;
LayoutManager currentChildLM;
if (lmStack.isEmpty()) {
assert restartAtLM != null && restartAtLM.getParent() == this;
childrenElements = getNextChildElements(currentChildLM, context, childLC,
alignment);
} else {
- currentChildLM = (BlockLevelLayoutManager) lmStack.pop();
+ currentChildLM = (LayoutManager) lmStack.pop();
setCurrentChildLM(currentChildLM);
childrenElements = getNextChildElements(currentChildLM, context, childLC, alignment,
lmStack, restartPosition, restartAtLM);
// a descendant of this block has break-before
forcedBreakAfterLast = (BreakElement) childrenElements.get(0);
context.clearPendingMarks();
-// break; TODO
}
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));
+ elements.add(makeAuxiliaryZeroWidthBox());
}
// a descendant of this block has break-before
contentList.addAll(childrenElements);
if (currentChildLM.isFinished() && !hasNextChildLM()) {
forcedBreakAfterLast = (BreakElement) ListUtil.removeLast(contentList);
context.clearPendingMarks();
-// break; TODO
}
wrapPositionElements(contentList, elements);
context.updateKeepWithNextPending(childLC.getKeepWithNextPending());
}
- while ((currentChildLM = (LayoutManager) getChildLM()) != null) {
+ while ((currentChildLM = getChildLM()) != null) {
currentChildLM.reset(); // TODO won't work with forced breaks
childLC = new LayoutContext(0);
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));
+ elements.add(makeAuxiliaryZeroWidthBox());
}
// a descendant of this block has break-before
contentList.addAll(childrenElements);
} else if (forcedBreakAfterLast == null) {
// Empty fo:block, zero-length box makes sure the IDs and/or markers
// are registered.
- elements.add(new KnuthBox(0, notifyPos(new Position(this)), true));
+ elements.add(makeAuxiliaryZeroWidthBox());
}
addKnuthElementsForBorderPaddingAfter(elements, true);
return elements;
}
- private List getNextChildElements(LayoutManager childLM, LayoutContext context,
+ private KnuthBox makeZeroWidthBox() {
+ return new KnuthBox(0, new NonLeafPosition(this, null), false);
+ }
+
+ private KnuthBox makeAuxiliaryZeroWidthBox() {
+ return new KnuthBox(0, notifyPos(new Position(this)), true);
+ }
+
+ private KnuthPenalty makeZeroWidthPenalty(int penaltyValue) {
+ return new KnuthPenalty(0, penaltyValue, false, new NonLeafPosition(this, null), false);
+ }
+
+ private KnuthGlue makeSpaceAdjustmentGlue(int width, Adjustment adjustmentClass,
+ boolean isAuxiliary) {
+ return new KnuthGlue(width, 0, 0,
+ adjustmentClass,
+ new NonLeafPosition(this, null),
+ isAuxiliary);
+ }
+
+ private List<ListElement> getNextChildElements(LayoutManager childLM, LayoutContext context,
LayoutContext childLC, int alignment) {
return getNextChildElements(childLM, context, childLC, alignment, null, null, null);
}
- private List getNextChildElements(LayoutManager childLM, LayoutContext context,
+ private List<ListElement> getNextChildElements(LayoutManager childLM, LayoutContext context,
LayoutContext childLC, int alignment, Stack lmStack, Position restartPosition,
LayoutManager restartAtLM) {
childLC.copyPendingMarksFrom(context);
* @param parentLC the parent layout context
* @param childLC the currently active child layout context
*/
- protected void addInBetweenBreak(List contentList, LayoutContext parentLC,
+ protected void addInBetweenBreak(List<ListElement> contentList, LayoutContext parentLC,
LayoutContext childLC) {
if (mustKeepTogether()
return;
}
- ListElement last = (ListElement) ListUtil.getLast(contentList);
+ ListElement last = ListUtil.getLast(contentList);
if (last.isGlue()) {
// the last element in contentList is a glue;
// it is a feasible breakpoint, there is no need to add
}
}
- /**
- * {@inheritDoc}
- */
+ /** {@inheritDoc} */
public int negotiateBPDAdjustment(int adj, KnuthElement lastElement) {
-/*LF*/ //log.debug(" BLM.negotiateBPDAdjustment> " + adj);
-/*LF*/ //log.debug(" lastElement e' " + (lastElement.isPenalty()
- // ? "penalty" : (lastElement.isGlue() ? "glue" : "box" )));
-/*LF*/ //log.debug(" position e' " + lastElement.getPosition().getClass().getName());
-/*LF*/ //log.debug(" " + (bpUnit > 0 ? "unit" : ""));
+ assert (lastElement != null && lastElement.getPosition() != null);
Position innerPosition = lastElement.getPosition().getPosition();
if (innerPosition == null && lastElement.isGlue()) {
== Adjustment.SPACE_BEFORE_ADJUSTMENT) {
// this adjustment applies to space-before
adjustedSpaceBefore += adj;
-/*LF*/ //log.debug(" BLM.negotiateBPDAdjustment> spazio prima: " + adj);
} else {
// this adjustment applies to space-after
adjustedSpaceAfter += adj;
-/*LF*/ //log.debug(" BLM.negotiateBPDAdjustment> spazio dopo: " + adj);
}
return adj;
} else if (innerPosition instanceof MappingPosition) {
MappingPosition mappingPos = (MappingPosition)innerPosition;
if (lastElement.isGlue()) {
// lastElement is a glue
-/*LF*/ //log.debug(" BLM.negotiateBPDAdjustment> bpunit con glue");
ListIterator storedListIterator = storedList.listIterator(
mappingPos.getFirstIndex());
int newAdjustment = 0;
newAdjustment += ((BlockLevelLayoutManager)storedElement
.getLayoutManager()).negotiateBPDAdjustment(
adj - newAdjustment, storedElement);
-/*LF*/ //log.debug(" BLM.negotiateBPDAdjustment> (progressivo) righe: "
- // + newAdjustment);
}
}
newAdjustment = (newAdjustment > 0 ? bpUnit * neededUnits(newAdjustment)
// lastElement is a penalty: this means that the paragraph
// has been split between consecutive pages:
// this may involve a change in the number of lines
-/*LF*/ //log.debug(" BLM.negotiateBPDAdjustment> bpunit con penalty");
KnuthPenalty storedPenalty = (KnuthPenalty)
storedList.get(mappingPos.getLastIndex());
if (storedPenalty.getWidth() > 0) {
// the original penalty has width > 0
-/*LF*/ //log.debug(" BLM.negotiateBPDAdjustment> chiamata passata");
return ((BlockLevelLayoutManager)storedPenalty.getLayoutManager())
.negotiateBPDAdjustment(storedPenalty.getWidth(),
storedPenalty);
} else {
// the original penalty has width = 0
// the adjustment involves only the spaces before and after
-/*LF*/ //log.debug(" BLM.negotiateBPDAdjustment> chiamata gestita");
return adj;
}
}
int returnValue = ((BlockLevelLayoutManager)lastElement.getLayoutManager())
.negotiateBPDAdjustment(adj, lastElement);
lastElement.setPosition(savedPos);
-/*LF*/ //log.debug(" BLM.negotiateBPDAdjustment> righe: " + returnValue);
return returnValue;
} else {
// this should never happen
}
}
- /**
- * {@inheritDoc}
- */
+ /** {@inheritDoc} */
public void discardSpace(KnuthGlue spaceGlue) {
- //log.debug(" BLM.discardSpace> " + spaceGlue.getPosition().getClass().getName());
- Position innerPosition = ((NonLeafPosition) spaceGlue.getPosition()).getPosition();
+ assert (spaceGlue != null && spaceGlue.getPosition() != null);
+ Position innerPosition = spaceGlue.getPosition().getPosition();
if (innerPosition == null || innerPosition.getLM() == this) {
// if this block has block-progression-unit > 0, innerPosition can be
}
}
- /**
- * {@inheritDoc}
- */
- public List getChangedKnuthElements(List oldList, int alignment) { // CSOK: MethodLength
-/*LF*/ //log.debug("");
-/*LF*/ //log.debug(" BLM.getChangedKnuthElements> inizio: oldList.size() = "
- // + oldList.size());
- ListIterator oldListIterator = oldList.listIterator();
- KnuthElement returnedElement;
+ /** {@inheritDoc} */
+ @Override
+ public List getChangedKnuthElements(List oldList, int alignment) {
+ ListIterator<KnuthElement> oldListIterator = oldList.listIterator();
KnuthElement currElement = null;
KnuthElement prevElement = null;
- List returnedList = new LinkedList();
- List returnList = new LinkedList();
+ List<KnuthElement> returnedList = new LinkedList<KnuthElement>();
+ List<KnuthElement> returnList = new LinkedList<KnuthElement>();
int fromIndex = 0;
// "unwrap" the Positions stored in the elements
- KnuthElement oldElement = null;
+ KnuthElement oldElement;
while (oldListIterator.hasNext()) {
- oldElement = (KnuthElement)oldListIterator.next();
- Position innerPosition = ((NonLeafPosition) oldElement.getPosition()).getPosition();
- //log.debug(" BLM> unwrapping: "
- // + (oldElement.isBox() ? "box " : (oldElement.isGlue() ? "glue " : "penalty"))
- // + " creato da " + oldElement.getLayoutManager().getClass().getName());
- //log.debug(" BLM> unwrapping: "
- // + oldElement.getPosition().getClass().getName());
+ oldElement = oldListIterator.next();
+ assert oldElement.getPosition() != null;
+ Position innerPosition = oldElement.getPosition().getPosition();
if (innerPosition != null) {
- // oldElement was created by a descendant of this BlockLM
+ // oldElement was created by a descendant
oldElement.setPosition(innerPosition);
} else {
- // thisElement was created by this BlockLM
+ // oldElement was created by this LM:
// modify its position in order to recognize it was not created
// by a child
oldElement.setPosition(new Position(this));
}
// create the iterator
- List workList;
- if (bpUnit == 0) {
- workList = oldList;
- } else {
- // the storedList must be used instead of oldList;
- // find the index of the first element of returnedList
- // corresponding to the first element of oldList
- oldListIterator = oldList.listIterator();
- KnuthElement el = (KnuthElement) oldListIterator.next();
- while (!(el.getPosition() instanceof MappingPosition)) {
- el = (KnuthElement) oldListIterator.next();
- }
- int iFirst = ((MappingPosition) el.getPosition()).getFirstIndex();
-
- // find the index of the last element of returnedList
- // corresponding to the last element of oldList
- oldListIterator = oldList.listIterator(oldList.size());
- el = (KnuthElement) oldListIterator.previous();
- while (!(el.getPosition() instanceof MappingPosition)) {
- el = (KnuthElement) oldListIterator.previous();
- }
- int iLast = ((MappingPosition) el.getPosition()).getLastIndex();
-
- //log-debug(" si usa storedList da " + iFirst + " a " + iLast
- // + " compresi su " + storedList.size() + " elementi totali");
- workList = storedList.subList(iFirst, iLast + 1);
- }
- ListIterator workListIterator = workList.listIterator();
-
- //log.debug(" BLM.getChangedKnuthElements> workList.size() = "
- // + workList.size() + " da 0 a " + (workList.size() - 1));
-
+ List<KnuthElement> workList = oldList;
+ ListIterator<KnuthElement> workListIterator = workList.listIterator();
while (workListIterator.hasNext()) {
- currElement = (KnuthElement) workListIterator.next();
- //log.debug("elemento n. " + workListIterator.previousIndex()
- // + " nella workList");
+ currElement = workListIterator.next();
if (prevElement != null
&& prevElement.getLayoutManager() != currElement.getLayoutManager()) {
// prevElement is the last element generated by the same LM
- BlockLevelLayoutManager prevLM = (BlockLevelLayoutManager)
- prevElement.getLayoutManager();
- BlockLevelLayoutManager currLM = (BlockLevelLayoutManager)
- currElement.getLayoutManager();
- boolean bSomethingAdded = false;
+ BlockLevelLayoutManager prevLM
+ = (BlockLevelLayoutManager)prevElement.getLayoutManager();
+ BlockLevelLayoutManager currLM
+ = (BlockLevelLayoutManager)currElement.getLayoutManager();
+ boolean somethingAdded = false;
if (prevLM != this) {
- //log.debug(" BLM.getChangedKnuthElements> chiamata da "
- // + fromIndex + " a " + workListIterator.previousIndex() + " su "
- // + prevLM.getClass().getName());
returnedList.addAll(prevLM.getChangedKnuthElements(workList.subList(
fromIndex, workListIterator.previousIndex()), alignment));
- bSomethingAdded = true;
+ somethingAdded = true;
} else {
- // prevLM == this
// do nothing
- //log.debug(" BLM.getChangedKnuthElements> elementi propri, "
- // + "ignorati, da " + fromIndex + " a " + workListIterator.previousIndex()
- // + " su " + prevLM.getClass().getName());
}
fromIndex = workListIterator.previousIndex();
* while in getNextKE they were changed to BreakElements?
*/
// there is another block after this one
- if (bSomethingAdded
+ if (somethingAdded
&& (this.mustKeepTogether()
|| prevLM.mustKeepWithNext()
|| currLM.mustKeepWithPrevious())) {
// add an infinite penalty to forbid a break between blocks
- returnedList.add(new KnuthPenalty(0, KnuthElement.INFINITE, false,
- new Position(this), false));
- } else if (bSomethingAdded
- && !((KnuthElement) ListUtil.getLast(returnedList))
- .isGlue()) {
+ returnedList.add(makeZeroWidthPenalty(KnuthPenalty.INFINITE));
+ } else if (somethingAdded
+ && !ListUtil.getLast(returnedList).isGlue()) {
// add a null penalty to allow a break between blocks
- returnedList.add(new KnuthPenalty(0, 0, false, new Position(this), false));
+ returnedList.add(makeZeroWidthPenalty(KnuthPenalty.INFINITE));
}
}
prevElement = currElement;
}
if (currElement != null) {
- BlockLevelLayoutManager currLM = (BlockLevelLayoutManager)
- currElement.getLayoutManager();
+ LayoutManager currLM = currElement.getLayoutManager();
if (currLM != this) {
- //log.debug(" BLM.getChangedKnuthElements> chiamata da " + fromIndex
- // + " a " + oldList.size() + " su " + currLM.getClass().getName());
returnedList.addAll(currLM.getChangedKnuthElements(
workList.subList(fromIndex, workList.size()), alignment));
} else {
- // currLM == this
// there are no more elements to add
// remove the last penalty added to returnedList
if (!returnedList.isEmpty()) {
ListUtil.removeLast(returnedList);
}
- //log.debug(" BLM.getChangedKnuthElements> elementi propri, ignorati, da "
- // + fromIndex + " a " + workList.size());
}
}
// append elements representing space-before
boolean spaceBeforeIsConditional = true;
if (fobj instanceof org.apache.fop.fo.flow.Block) {
- spaceBeforeIsConditional = ((org.apache.fop.fo.flow.Block)fobj)
- .getCommonMarginBlock().spaceBefore.getSpace().isDiscard();
+ spaceBeforeIsConditional = getSpaceBeforeProperty().isDiscard();
}
- if (bpUnit > 0
- || adjustedSpaceBefore != 0) {
+ if (adjustedSpaceBefore != 0) {
if (!spaceBeforeIsConditional) {
// add elements to prevent the glue to be discarded
- returnList.add(new KnuthBox(0,
- new NonLeafPosition(this, null), false));
- returnList.add(new KnuthPenalty(0, KnuthElement.INFINITE, false,
- new NonLeafPosition(this, null), false));
- }
- if (bpUnit > 0) {
- returnList.add(new KnuthGlue(0, 0, 0,
- Adjustment.SPACE_BEFORE_ADJUSTMENT, new NonLeafPosition(this, null), true));
- } else {
- returnList.add(new KnuthGlue(adjustedSpaceBefore, 0, 0,
- Adjustment.SPACE_BEFORE_ADJUSTMENT, new NonLeafPosition(this, null), true));
+ returnList.add(makeZeroWidthBox());
+ returnList.add(makeZeroWidthPenalty(KnuthPenalty.INFINITE));
}
- }
-
- //log.debug(" BLM.getChangedKnuthElements> intermedio: returnedList.size() = "
- // + returnedList.size());
-/* estensione: conversione complessiva */
-/*LF*/ if (bpUnit > 0) {
-/*LF*/ storedList = returnedList;
-/*LF*/ returnedList = createUnitElements(returnedList);
-/*LF*/ }
-/* estensione */
+ returnList.add(makeSpaceAdjustmentGlue(adjustedSpaceBefore,
+ Adjustment.SPACE_BEFORE_ADJUSTMENT,
+ false));
+ }
// "wrap" the Position stored in each element of returnedList
// and add elements to returnList
- ListIterator listIter = returnedList.listIterator();
- while (listIter.hasNext()) {
- returnedElement = (KnuthElement)listIter.next();
- returnedElement.setPosition(new NonLeafPosition(this, returnedElement.getPosition()));
- returnList.add(returnedElement);
+ for (KnuthElement el : returnedList) {
+ el.setPosition(new NonLeafPosition(this, el.getPosition()));
+ returnList.add(el);
}
// append elements representing space-after
boolean spaceAfterIsConditional = true;
if (fobj instanceof org.apache.fop.fo.flow.Block) {
- spaceAfterIsConditional = ((org.apache.fop.fo.flow.Block)fobj)
- .getCommonMarginBlock().spaceAfter.getSpace().isDiscard();
+ spaceAfterIsConditional = getSpaceAfterProperty().isDiscard();
}
- if (bpUnit > 0 || adjustedSpaceAfter != 0) {
+ if (adjustedSpaceAfter != 0) {
if (!spaceAfterIsConditional) {
- returnList.add(new KnuthPenalty(0,
- KnuthElement.INFINITE, false,
- new NonLeafPosition(this, null), false));
- }
- if (bpUnit > 0) {
- returnList.add(new KnuthGlue(0, 0, 0,
- Adjustment.SPACE_AFTER_ADJUSTMENT,
- new NonLeafPosition(this, null),
- spaceAfterIsConditional));
- } else {
- returnList.add(new KnuthGlue(adjustedSpaceAfter, 0, 0,
- Adjustment.SPACE_AFTER_ADJUSTMENT,
- new NonLeafPosition(this, null),
- spaceAfterIsConditional));
+ returnList.add(makeZeroWidthPenalty(KnuthPenalty.INFINITE));
}
+
+ returnList.add(makeSpaceAdjustmentGlue(adjustedSpaceAfter,
+ Adjustment.SPACE_AFTER_ADJUSTMENT,
+ spaceAfterIsConditional));
+
if (!spaceAfterIsConditional) {
- returnList.add(new KnuthBox(0,
- new NonLeafPosition(this, null), true));
+ returnList.add(makeZeroWidthBox());
}
}
- //log.debug(" BLM.getChangedKnuthElements> finished: returnList.size() = "
- // + returnList.size());
return returnList;
}
* @param context the layout context
* @return true if an element has been added due to a break-before.
*/
- protected boolean addKnuthElementsForBreakBefore(List returnList,
- LayoutContext context) {
+ protected boolean addKnuthElementsForBreakBefore(List returnList, LayoutContext context) {
int breakBefore = getBreakBefore();
if (breakBefore == EN_PAGE
|| breakBefore == EN_COLUMN
* @param context the layout context
* @return true if an element has been added due to a break-after.
*/
- protected boolean addKnuthElementsForBreakAfter(List returnList,
- LayoutContext context) {
+ protected boolean addKnuthElementsForBreakAfter(List returnList, LayoutContext context) {
int breakAfter = -1;
if (fobj instanceof BreakPropertySet) {
breakAfter = ((BreakPropertySet)fobj).getBreakAfter();
* @param returnList return list to add the additional elements to
* @param alignment vertical alignment
*/
- protected void addKnuthElementsForSpaceBefore(List returnList/*,
- Position returnPosition*/, int alignment) {
+ protected void addKnuthElementsForSpaceBefore(List returnList, int alignment) {
SpaceProperty spaceBefore = getSpaceBeforeProperty();
// append elements representing space-before
if (spaceBefore != null
RelSide.BEFORE,
true, false, this));
}
- /*
- if (bpUnit > 0
- || spaceBefore != null
- && !(spaceBefore.getMinimum(this).getLength().getValue(this) == 0
- && spaceBefore.getMaximum(this).getLength().getValue(this) == 0)) {
- if (spaceBefore != null && !spaceBefore.getSpace().isDiscard()) {
- // add elements to prevent the glue to be discarded
- returnList.add(new KnuthBox(0, getAuxiliaryPosition(), false));
- returnList.add(new KnuthPenalty(0, KnuthElement.INFINITE,
- false, getAuxiliaryPosition(), false));
- }
- if (bpUnit > 0) {
- returnList.add(new KnuthGlue(0, 0, 0,
- BlockLevelLayoutManager.SPACE_BEFORE_ADJUSTMENT,
- getAuxiliaryPosition(), true));
- } else { //if (alignment == EN_JUSTIFY) {
- returnList.add(new KnuthGlue(
- spaceBefore.getOptimum(this).getLength().getValue(this),
- spaceBefore.getMaximum(this).getLength().getValue(this)
- - spaceBefore.getOptimum(this).getLength().getValue(this),
- spaceBefore.getOptimum(this).getLength().getValue(this)
- - spaceBefore.getMinimum(this).getLength().getValue(this),
- BlockLevelLayoutManager.SPACE_BEFORE_ADJUSTMENT,
- getAuxiliaryPosition(), true));
-// } else {
-// returnList.add(new KnuthGlue(
-// spaceBefore.getOptimum().getLength().getValue(this),
-// 0, 0, BlockLevelLayoutManager.SPACE_BEFORE_ADJUSTMENT,
-// returnPosition, true));
- }
- }*/
}
/**
* @param returnList return list to add the additional elements to
* @param alignment vertical alignment
*/
- protected void addKnuthElementsForSpaceAfter(List returnList/*, Position returnPosition*/,
- int alignment) {
+ protected void addKnuthElementsForSpaceAfter(List returnList, int alignment) {
SpaceProperty spaceAfter = getSpaceAfterProperty();
// append elements representing space-after
if (spaceAfter != null
RelSide.AFTER,
false, true, this));
}
- /*
- if (bpUnit > 0
- || spaceAfter != null
- && !(spaceAfter.getMinimum(this).getLength().getValue(this) == 0
- && spaceAfter.getMaximum(this).getLength().getValue(this) == 0)) {
- if (spaceAfter != null && !spaceAfter.getSpace().isDiscard()) {
- returnList.add(new KnuthPenalty(0, KnuthElement.INFINITE,
- false, getAuxiliaryPosition(), false));
- }
- if (bpUnit > 0) {
- returnList.add(new KnuthGlue(0, 0, 0,
- BlockLevelLayoutManager.SPACE_AFTER_ADJUSTMENT,
- getAuxiliaryPosition(), true));
- } else { //if (alignment == EN_JUSTIFY) {
- returnList.add(new KnuthGlue(
- spaceAfter.getOptimum(this).getLength().getValue(this),
- spaceAfter.getMaximum(this).getLength().getValue(this)
- - spaceAfter.getOptimum(this).getLength().getValue(this),
- spaceAfter.getOptimum(this).getLength().getValue(this)
- - spaceAfter.getMinimum(this).getLength().getValue(this),
- BlockLevelLayoutManager.SPACE_AFTER_ADJUSTMENT, getAuxiliaryPosition(),
- (!spaceAfter.getSpace().isDiscard()) ? false : true));
-// } else {
-// returnList.add(new KnuthGlue(
-// spaceAfter.getOptimum().getLength().getValue(this), 0, 0,
-// BlockLevelLayoutManager.SPACE_AFTER_ADJUSTMENT, returnPosition,
-// (!spaceAfter.getSpace().isDiscard()) ? false : true));
- }
- if (spaceAfter != null && !spaceAfter.getSpace().isDiscard()) {
- returnList.add(new KnuthBox(0, getAuxiliaryPosition(), true));
- }
- }*/
- }
-
- /**
- * Create unit elements.
- * @param oldList the old list
- * @return the new list
- */
- protected List createUnitElements(List oldList) { // CSOK: MethodLength
- //log.debug("Start conversion: " + oldList.size()
- // + " elements, space-before.min=" + layoutProps.spaceBefore.getSpace().min
- // + " space-after.min=" + layoutProps.spaceAfter.getSpace().min);
- // add elements at the beginning and at the end of oldList
- // representing minimum spaces
- LayoutManager lm = ((KnuthElement)oldList.get(0)).getLayoutManager();
- boolean bAddedBoxBefore = false;
- boolean bAddedBoxAfter = false;
- if (adjustedSpaceBefore > 0) {
- oldList.add(0, new KnuthBox(adjustedSpaceBefore,
- new Position(lm), true));
- bAddedBoxBefore = true;
- }
- if (adjustedSpaceAfter > 0) {
- oldList.add(new KnuthBox(adjustedSpaceAfter,
- new Position(lm), true));
- bAddedBoxAfter = true;
- }
-
- MinOptMax totalLength = MinOptMax.ZERO;
- LinkedList newList = new LinkedList();
-
- //log.debug(" Prima scansione");
- // scan the list once to compute total min, opt and max length
- ListIterator oldListIterator = oldList.listIterator();
- while (oldListIterator.hasNext()) {
- KnuthElement element = (KnuthElement) oldListIterator.next();
- if (element.isBox()) {
- totalLength = totalLength.plus(element.getWidth());
- //log.debug("box " + element.getWidth());
- } else if (element.isGlue()) {
- totalLength = totalLength.minusMin(element.getShrink());
- totalLength = totalLength.plusMax(element.getStretch());
- //leafValue = ((LeafPosition) element.getPosition()).getLeafPos();
- //log.debug("glue " + element.getWidth() + " + "
- // + ((KnuthGlue) element).getStretch() + " - "
- // + ((KnuthGlue) element).getShrink());
- } else {
- //log.debug((((KnuthPenalty)element).getPenalty() == KnuthElement.INFINITE
- // ? "PENALTY " : "penalty ") + element.getWidth());
- }
- }
- // compute the total amount of "units"
- MinOptMax totalUnits = MinOptMax.getInstance(neededUnits(totalLength.getMin()),
- neededUnits(totalLength.getOpt()),
- neededUnits(totalLength.getMax()));
- //log.debug(" totalLength= " + totalLength);
- //log.debug(" unita'= " + totalUnits);
-
- //log.debug(" Seconda scansione");
- // scan the list once more, stopping at every breaking point
- // in order to compute partial min, opt and max length
- // and create the new elements
- oldListIterator = oldList.listIterator();
- boolean prevIsBox;
- MinOptMax lengthBeforeBreak = MinOptMax.ZERO;
- MinOptMax lengthAfterBreak = totalLength;
- MinOptMax unitsBeforeBreak;
- MinOptMax unitsAfterBreak;
- MinOptMax unsuppressibleUnits = MinOptMax.ZERO;
- int firstIndex = 0;
- int lastIndex = -1;
- while (oldListIterator.hasNext()) {
- KnuthElement element = (KnuthElement) oldListIterator.next();
- lastIndex++;
- if (element.isBox()) {
- lengthBeforeBreak = lengthBeforeBreak.plus(element.getWidth());
- lengthAfterBreak = lengthAfterBreak.minus(element.getWidth());
- prevIsBox = true;
- } else if (element.isGlue()) {
- lengthBeforeBreak = lengthBeforeBreak.minusMin(element.getShrink());
- lengthAfterBreak = lengthAfterBreak.plusMin(element.getShrink());
- lengthBeforeBreak = lengthBeforeBreak.plusMax(element.getStretch());
- lengthAfterBreak = lengthAfterBreak.minusMax(element.getStretch());
- prevIsBox = false;
- } else {
- lengthBeforeBreak = lengthBeforeBreak.plus(element.getWidth());
- prevIsBox = false;
- }
-
- // create the new elements
- if (element.isPenalty() && element.getPenalty() < KnuthElement.INFINITE
- || element.isGlue() && prevIsBox
- || !oldListIterator.hasNext()) {
- // suppress elements after the breaking point
- int iStepsForward = 0;
- while (oldListIterator.hasNext()) {
- KnuthElement el = (KnuthElement) oldListIterator.next();
- iStepsForward++;
- if (el.isGlue()) {
- // suppressed glue
- lengthAfterBreak = lengthAfterBreak.plusMin(el.getShrink());
- lengthAfterBreak = lengthAfterBreak.minusMax(el.getStretch());
- } else if (el.isPenalty()) {
- // suppressed penalty, do nothing
- } else {
- // box, end of suppressions
- break;
- }
- }
- // compute the partial amount of "units" before and after the break
- unitsBeforeBreak = MinOptMax.getInstance(neededUnits(lengthBeforeBreak.getMin()),
- neededUnits(lengthBeforeBreak.getOpt()),
- neededUnits(lengthBeforeBreak.getMax()));
- unitsAfterBreak = MinOptMax.getInstance(neededUnits(lengthAfterBreak.getMin()),
- neededUnits(lengthAfterBreak.getOpt()),
- neededUnits(lengthAfterBreak.getMax()));
-
- // rewind the iterator and lengthAfterBreak
- for (int i = 0; i < iStepsForward; i++) {
- KnuthElement el = (KnuthElement) oldListIterator.previous();
- if (el.isGlue()) {
- lengthAfterBreak = lengthAfterBreak.minusMin(el.getShrink());
- lengthAfterBreak = lengthAfterBreak.plusMax(el.getStretch());
- }
- }
-
- // compute changes in length, stretch and shrink
- int uLengthChange = unitsBeforeBreak.getOpt() + unitsAfterBreak.getOpt()
- - totalUnits.getOpt();
- int uStretchChange = unitsBeforeBreak.getStretch()
- + unitsAfterBreak.getStretch() - totalUnits.getStretch();
- int uShrinkChange = unitsBeforeBreak.getShrink()
- + unitsAfterBreak.getShrink() - totalUnits.getShrink();
-
- // compute the number of normal, stretch and shrink unit
- // that must be added to the new sequence
- int uNewNormal = unitsBeforeBreak.getOpt() - unsuppressibleUnits.getOpt();
- int uNewStretch = unitsBeforeBreak.getStretch()
- - unsuppressibleUnits.getStretch();
- int uNewShrink = unitsBeforeBreak.getShrink()
- - unsuppressibleUnits.getShrink();
-
- //log.debug("("
- // + unsuppressibleUnits.min + "-" + unsuppressibleUnits.opt + "-"
- // + unsuppressibleUnits.max + ") "
- // + " -> " + unitsBeforeBreak.min + "-" + unitsBeforeBreak.opt + "-"
- // + unitsBeforeBreak.max
- // + " + " + unitsAfterBreak.min + "-" + unitsAfterBreak.opt + "-"
- // + unitsAfterBreak.max
- // + (uLengthChange != 0 ? " [length " + uLengthChange + "] " : "")
- // + (uStretchChange != 0 ? " [stretch " + uStretchChange + "] " : "")
- // + (uShrinkChange != 0 ? " [shrink " + uShrinkChange + "]" : ""));
-
- // create the MappingPosition which will be stored in the new elements
- // correct firstIndex and lastIndex
- int firstIndexCorrection = 0;
- int lastIndexCorrection = 0;
- if (bAddedBoxBefore) {
- if (firstIndex != 0) {
- firstIndexCorrection++;
- }
- lastIndexCorrection++;
- }
- if (bAddedBoxAfter && lastIndex == (oldList.size() - 1)) {
- lastIndexCorrection++;
- }
- MappingPosition mappingPos = new MappingPosition(this,
- firstIndex - firstIndexCorrection,
- lastIndex - lastIndexCorrection);
-
- // new box
- newList.add(new KnuthBox((uNewNormal - uLengthChange) * bpUnit, mappingPos, false));
- unsuppressibleUnits = unsuppressibleUnits.plus(uNewNormal - uLengthChange);
- //log.debug(" box " + (uNewNormal - uLengthChange));
-
- // new infinite penalty, glue and box, if necessary
- if (uNewStretch - uStretchChange > 0
- || uNewShrink - uShrinkChange > 0) {
- int iStretchUnits = (uNewStretch - uStretchChange > 0
- ? (uNewStretch - uStretchChange) : 0);
- int iShrinkUnits = (uNewShrink - uShrinkChange > 0
- ? (uNewShrink - uShrinkChange) : 0);
- newList.add(new KnuthPenalty(0, KnuthElement.INFINITE, false,
- mappingPos,
- false));
- newList.add(new KnuthGlue(0,
- iStretchUnits * bpUnit,
- iShrinkUnits * bpUnit,
- Adjustment.LINE_NUMBER_ADJUSTMENT,
- mappingPos,
- false));
- //log.debug(" PENALTY");
- //log.debug(" glue 0 " + iStretchUnits + " " + iShrinkUnits);
- unsuppressibleUnits = unsuppressibleUnits.plusMax(iStretchUnits);
- unsuppressibleUnits = unsuppressibleUnits.minusMin(iShrinkUnits);
- if (!oldListIterator.hasNext()) {
- newList.add(new KnuthBox(0, mappingPos, false));
- //log.debug(" box 0");
- }
- }
-
- // new breaking sequence
- if (uStretchChange != 0
- || uShrinkChange != 0) {
- // new infinite penalty, glue, penalty and glue
- newList.add(new KnuthPenalty(0, KnuthElement.INFINITE, false,
- mappingPos,
- false));
- newList.add(new KnuthGlue(0,
- uStretchChange * bpUnit,
- uShrinkChange * bpUnit,
- Adjustment.LINE_NUMBER_ADJUSTMENT,
- mappingPos,
- false));
- newList.add(new KnuthPenalty(uLengthChange * bpUnit,
- 0, false, element.getPosition(), false));
- newList.add(new KnuthGlue(0,
- -uStretchChange * bpUnit,
- -uShrinkChange * bpUnit,
- Adjustment.LINE_NUMBER_ADJUSTMENT,
- mappingPos,
- false));
- //log.debug(" PENALTY");
- //log.debug(" glue 0 " + uStretchChange + " " + uShrinkChange);
- //log.debug(" penalty " + uLengthChange + " * unit");
- //log.debug(" glue 0 " + (- uStretchChange) + " "
- // + (- uShrinkChange));
- } else if (oldListIterator.hasNext()) {
- // new penalty
- newList.add(new KnuthPenalty(uLengthChange * bpUnit,
- 0, false,
- mappingPos,
- false));
- //log.debug(" penalty " + uLengthChange + " * unit");
- }
- // update firstIndex
- firstIndex = lastIndex + 1;
- }
-
- if (element.isPenalty()) {
- lengthBeforeBreak = lengthBeforeBreak.minus(element.getWidth());
- }
-
- }
-
- // remove elements at the beginning and at the end of oldList
- // representing minimum spaces
- if (adjustedSpaceBefore > 0) {
- oldList.remove(0);
- }
- if (adjustedSpaceAfter > 0) {
- ListUtil.removeLast(oldList);
- }
-
- // if space-before.conditionality is "discard", correct newList
- boolean correctFirstElement = false;
- if (fobj instanceof org.apache.fop.fo.flow.Block) {
- correctFirstElement = ((org.apache.fop.fo.flow.Block)fobj)
- .getCommonMarginBlock().spaceBefore.getSpace().isDiscard();
- }
- if (correctFirstElement) {
- // remove the wrong element
- KnuthBox wrongBox = (KnuthBox) newList.removeFirst();
- // if this paragraph is at the top of a page, the space before
- // must be ignored; compute the length change
- int decreasedLength = (neededUnits(totalLength.getOpt())
- - neededUnits(totalLength.getOpt() - adjustedSpaceBefore))
- * bpUnit;
- // insert the correct elements
- newList.addFirst(new KnuthBox(wrongBox.getWidth() - decreasedLength,
- wrongBox.getPosition(), false));
- newList.addFirst(new KnuthGlue(decreasedLength, 0, 0,
- Adjustment.SPACE_BEFORE_ADJUSTMENT,
- wrongBox.getPosition(), false));
- //log.debug(" rimosso box " + neededUnits(wrongBox.getWidth()));
- //log.debug(" aggiunto glue " + neededUnits(decreasedLength) + " 0 0");
- //log.debug(" aggiunto box " + neededUnits(
- // wrongBox.getWidth() - decreasedLength));
- }
-
- // if space-after.conditionality is "discard", correct newList
- boolean correctLastElement = false;
- if (fobj instanceof org.apache.fop.fo.flow.Block) {
- correctLastElement = ((org.apache.fop.fo.flow.Block)fobj)
- .getCommonMarginBlock().spaceAfter.getSpace().isDiscard();
- }
- if (correctLastElement) {
- // remove the wrong element
- KnuthBox wrongBox = (KnuthBox) newList.removeLast();
- // if the old sequence is box(h) penalty(inf) glue(x,y,z) box(0)
- // (it cannot be parted and has some stretch or shrink)
- // the wrong box is the first one, not the last one
- LinkedList preserveList = new LinkedList();
- if (wrongBox.getWidth() == 0) {
- preserveList.add(wrongBox);
- preserveList.addFirst((KnuthGlue) newList.removeLast());
- preserveList.addFirst((KnuthPenalty) newList.removeLast());
- wrongBox = (KnuthBox) newList.removeLast();
- }
-
- // if this paragraph is at the bottom of a page, the space after
- // must be ignored; compute the length change
- int decreasedLength = (neededUnits(totalLength.getOpt())
- - neededUnits(totalLength.getOpt() - adjustedSpaceAfter))
- * bpUnit;
- // insert the correct box
- newList.addLast(new KnuthBox(wrongBox.getWidth() - decreasedLength,
- wrongBox.getPosition(), false));
- // add preserved elements
- if (!preserveList.isEmpty()) {
- newList.addAll(preserveList);
- }
- // insert the correct glue
- newList.addLast(new KnuthGlue(decreasedLength, 0, 0, Adjustment.SPACE_AFTER_ADJUSTMENT,
- wrongBox.getPosition(), false));
- //log.debug(" rimosso box " + neededUnits(wrongBox.getWidth()));
- //log.debug(" aggiunto box " + neededUnits(
- // wrongBox.getWidth() - decreasedLength));
- //log.debug(" aggiunto glue " + neededUnits(decreasedLength) + " 0 0");
- }
-
- return newList;
}
/** A stack iterator. */
/** A mapping position. */
protected static class MappingPosition extends Position {
- private int iFirstIndex;
- private int iLastIndex;
+ private int firstIndex;
+ private int lastIndex;
/**
* Construct mapping position.
*/
public MappingPosition(LayoutManager lm, int first, int last) {
super(lm);
- iFirstIndex = first;
- iLastIndex = last;
+ firstIndex = first;
+ lastIndex = last;
}
/** @return first index */
public int getFirstIndex() {
- return iFirstIndex;
+ return firstIndex;
}
/** @return last index */
public int getLastIndex() {
- return iLastIndex;
+ return lastIndex;
}
}
* Returns the IPD of the content area
* @return the IPD of the content area
*/
+ @Override
public int getContentAreaIPD() {
return contentAreaIPD;
}
* Returns the BPD of the content area
* @return the BPD of the content area
*/
+ @Override
public int getContentAreaBPD() {
return -1;
}
/** {@inheritDoc} */
+ @Override
public void reset() {
super.reset();
breakBeforeServed = false;
projects / xmlgraphics-fop.git / commitdiff