diff options
Diffstat (limited to 'src/java/org/apache/fop/layoutmgr')
23 files changed, 400 insertions, 258 deletions
diff --git a/src/java/org/apache/fop/layoutmgr/BlockContainerLayoutManager.java b/src/java/org/apache/fop/layoutmgr/BlockContainerLayoutManager.java index c0220e75e..a44669371 100644 --- a/src/java/org/apache/fop/layoutmgr/BlockContainerLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/BlockContainerLayoutManager.java @@ -263,6 +263,7 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager if (!firstVisibleMarkServed) { addKnuthElementsForSpaceBefore(returnList, alignment); + context.updateKeepWithPreviousPending(getKeepWithPreviousStrength()); } addKnuthElementsForBorderPaddingBefore(returnList, !firstVisibleMarkServed); @@ -284,6 +285,11 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager // get elements from curLM returnedList = curLM.getNextKnuthElements(childLC, alignment); + if (contentList.size() == 0 && childLC.isKeepWithPreviousPending()) { + //Propagate keep-with-previous up from the first child + context.updateKeepWithPreviousPending(childLC.getKeepWithPreviousPending()); + childLC.clearKeepWithPreviousPending(); + } if (returnedList.size() == 1 && ((ListElement)returnedList.getFirst()).isForcedBreak()) { // a descendant of this block has break-before @@ -329,6 +335,9 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager return returnList; } } + // propagate and clear + context.updateKeepWithNextPending(childLC.getKeepWithNextPending()); + childLC.clearKeepsPending(); prevLM = curLM; } @@ -377,6 +386,8 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager context.clearPendingMarks(); addKnuthElementsForBreakAfter(returnList, context); + context.updateKeepWithNextPending(getKeepWithNextStrength()); + setFinished(true); return returnList; } @@ -990,26 +1001,22 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager /** {@inheritDoc} */ public int getKeepTogetherStrength() { - int strength = KEEP_AUTO; - strength = Math.max(strength, KeepUtil.getKeepStrength( - getBlockContainerFO().getKeepTogether().getWithinPage())); - strength = Math.max(strength, KeepUtil.getKeepStrength( - getBlockContainerFO().getKeepTogether().getWithinColumn())); + int strength = KeepUtil.getCombinedBlockLevelKeepStrength( + getBlockContainerFO().getKeepTogether()); strength = Math.max(strength, getParentKeepTogetherStrength()); return strength; } /** {@inheritDoc} */ - public boolean mustKeepWithPrevious() { - //TODO Keeps will have to be more sophisticated sooner or later - return !getBlockContainerFO().getKeepWithPrevious().getWithinPage().isAuto() - || !getBlockContainerFO().getKeepWithPrevious().getWithinColumn().isAuto(); + public int getKeepWithNextStrength() { + return KeepUtil.getCombinedBlockLevelKeepStrength( + getBlockContainerFO().getKeepWithNext()); } /** {@inheritDoc} */ - public boolean mustKeepWithNext() { - return !getBlockContainerFO().getKeepWithNext().getWithinPage().isAuto() - || !getBlockContainerFO().getKeepWithNext().getWithinColumn().isAuto(); + public int getKeepWithPreviousStrength() { + return KeepUtil.getCombinedBlockLevelKeepStrength( + getBlockContainerFO().getKeepWithPrevious()); } /** @@ -1021,16 +1028,12 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager // --------- Property Resolution related functions --------- // - /** - * {@inheritDoc} - */ + /** {@inheritDoc} */ public boolean getGeneratesReferenceArea() { return true; } - /** - * {@inheritDoc} - */ + /** {@inheritDoc} */ public boolean getGeneratesBlockArea() { return true; } diff --git a/src/java/org/apache/fop/layoutmgr/BlockLayoutManager.java b/src/java/org/apache/fop/layoutmgr/BlockLayoutManager.java index 253ec2af1..48bf47caf 100644 --- a/src/java/org/apache/fop/layoutmgr/BlockLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/BlockLayoutManager.java @@ -30,6 +30,7 @@ import org.apache.fop.area.Area; import org.apache.fop.area.Block; import org.apache.fop.area.LineArea; import org.apache.fop.datatypes.Length; +import org.apache.fop.fo.properties.KeepProperty; import org.apache.fop.fonts.Font; import org.apache.fop.fonts.FontInfo; import org.apache.fop.fonts.FontTriplet; @@ -209,26 +210,20 @@ public class BlockLayoutManager extends BlockStackingLayoutManager /** {@inheritDoc} */ public int getKeepTogetherStrength() { - int strength = KEEP_AUTO; - strength = Math.max(strength, KeepUtil.getKeepStrength( - getBlockFO().getKeepTogether().getWithinPage())); - strength = Math.max(strength, KeepUtil.getKeepStrength( - getBlockFO().getKeepTogether().getWithinColumn())); + KeepProperty keep = getBlockFO().getKeepTogether(); + int strength = KeepUtil.getCombinedBlockLevelKeepStrength(keep); strength = Math.max(strength, getParentKeepTogetherStrength()); return strength; } /** {@inheritDoc} */ - public boolean mustKeepWithPrevious() { - //TODO Keeps will have to be more sophisticated sooner or later - return !getBlockFO().getKeepWithPrevious().getWithinPage().isAuto() - || !getBlockFO().getKeepWithPrevious().getWithinColumn().isAuto(); + public int getKeepWithNextStrength() { + return KeepUtil.getCombinedBlockLevelKeepStrength(getBlockFO().getKeepWithNext()); } /** {@inheritDoc} */ - public boolean mustKeepWithNext() { - return !getBlockFO().getKeepWithNext().getWithinPage().isAuto() - || !getBlockFO().getKeepWithNext().getWithinColumn().isAuto(); + public int getKeepWithPreviousStrength() { + return KeepUtil.getCombinedBlockLevelKeepStrength(getBlockFO().getKeepWithPrevious()); } /** {@inheritDoc} */ diff --git a/src/java/org/apache/fop/layoutmgr/BlockLevelLayoutManager.java b/src/java/org/apache/fop/layoutmgr/BlockLevelLayoutManager.java index 3dc7ed46e..765bb1086 100644 --- a/src/java/org/apache/fop/layoutmgr/BlockLevelLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/BlockLevelLayoutManager.java @@ -56,11 +56,23 @@ public interface BlockLevelLayoutManager extends LayoutManager { boolean mustKeepTogether(); /** + * Returns the keep-with-previous strength for this element. + * @return the keep-with-previous strength + */ + int getKeepWithPreviousStrength(); + + /** * @return true if this element must be kept with the previous element. */ boolean mustKeepWithPrevious(); /** + * Returns the keep-with-next strength for this element. + * @return the keep-with-next strength + */ + int getKeepWithNextStrength(); + + /** * @return true if this element must be kept with the next element. */ boolean mustKeepWithNext(); diff --git a/src/java/org/apache/fop/layoutmgr/BlockStackingLayoutManager.java b/src/java/org/apache/fop/layoutmgr/BlockStackingLayoutManager.java index c6ead8d59..e9d529ebe 100644 --- a/src/java/org/apache/fop/layoutmgr/BlockStackingLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/BlockStackingLayoutManager.java @@ -265,6 +265,7 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager if (!firstVisibleMarkServed) { addKnuthElementsForSpaceBefore(returnList, alignment); + context.updateKeepWithPreviousPending(getKeepWithPreviousStrength()); } addKnuthElementsForBorderPaddingBefore(returnList, !firstVisibleMarkServed); @@ -296,8 +297,9 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager // get elements from curLM returnedList = curLM.getNextKnuthElements(childLC, alignment); if (contentList.size() == 0 && childLC.isKeepWithPreviousPending()) { - context.setFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING); - childLC.setFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING, false); + //Propagate keep-with-previous up from the first child + context.updateKeepWithPreviousPending(childLC.getKeepWithPreviousPending()); + childLC.clearKeepWithPreviousPending(); } if (returnedList != null && returnedList.size() == 1 @@ -364,9 +366,8 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager } } // propagate and clear - context.setFlags(LayoutContext.KEEP_WITH_NEXT_PENDING, childLC.isKeepWithNextPending()); - childLC.setFlags(LayoutContext.KEEP_WITH_NEXT_PENDING, false); - childLC.setFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING, false); + context.updateKeepWithNextPending(childLC.getKeepWithNextPending()); + childLC.clearKeepsPending(); prevLM = curLM; } @@ -400,12 +401,7 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager wrapPositionElement(forcedBreakAfterLast, returnList, false); } - if (mustKeepWithNext()) { - context.setFlags(LayoutContext.KEEP_WITH_NEXT_PENDING); - } - if (mustKeepWithPrevious()) { - context.setFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING); - } + context.updateKeepWithNextPending(getKeepWithNextStrength()); setFinished(true); @@ -425,14 +421,15 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager || childLC.isKeepWithPreviousPending()) { int strength = getKeepTogetherStrength(); - if (context.isKeepWithNextPending()) { - context.setFlags(LayoutContext.KEEP_WITH_NEXT_PENDING, false); - strength = KEEP_ALWAYS; - } - if (childLC.isKeepWithPreviousPending()) { - childLC.setFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING, false); - strength = KEEP_ALWAYS; - } + + //Handle pending keep-with-next + strength = Math.max(strength, context.getKeepWithNextPending()); + context.clearKeepWithNextPending(); + + //Handle pending keep-with-previous from child LM + strength = Math.max(strength, childLC.getKeepWithPreviousPending()); + childLC.clearKeepWithPreviousPending(); + int penalty = KeepUtil.getPenaltyForKeep(strength); // add a penalty to forbid or discourage a break between blocks @@ -823,12 +820,12 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager /** {@inheritDoc} */ public boolean mustKeepWithPrevious() { - return false; + return getKeepWithPreviousStrength() > KEEP_AUTO; } /** {@inheritDoc} */ public boolean mustKeepWithNext() { - return false; + return getKeepWithNextStrength() > KEEP_AUTO; } /** diff --git a/src/java/org/apache/fop/layoutmgr/FlowLayoutManager.java b/src/java/org/apache/fop/layoutmgr/FlowLayoutManager.java index ecfcbe2b4..c54f0ce12 100644 --- a/src/java/org/apache/fop/layoutmgr/FlowLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/FlowLayoutManager.java @@ -107,8 +107,8 @@ public class FlowLayoutManager extends BlockStackingLayoutManager returnedList = curLM.getNextKnuthElements(childLC, alignment); //log.debug("FLM.getNextKnuthElements> returnedList.size() = " + returnedList.size()); if (returnList.size() == 0 && childLC.isKeepWithPreviousPending()) { - context.setFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING); - childLC.setFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING, false); + context.updateKeepWithPreviousPending(childLC.getKeepWithPreviousPending()); + childLC.clearKeepWithPreviousPending(); } // "wrap" the Position inside each element @@ -124,20 +124,7 @@ public class FlowLayoutManager extends BlockStackingLayoutManager return returnList; } else { if (returnList.size() > 0) { - // there is a block before this one - if (context.isKeepWithNextPending() - || childLC.isKeepWithPreviousPending()) { - //Clear pending keep flag - context.setFlags(LayoutContext.KEEP_WITH_NEXT_PENDING, false); - childLC.setFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING, false); - // add an infinite penalty to forbid a break between blocks - returnList.add(new BreakElement( - new Position(this), KnuthElement.INFINITE, context)); - } else if (!((ListElement) returnList.getLast()).isGlue()) { - // add a null penalty to allow a break between blocks - returnList.add(new BreakElement( - new Position(this), 0, context)); - } + addInBetweenBreak(returnList, context, childLC); } if (returnedList.size() > 0) { returnList.addAll(returnedList); @@ -155,11 +142,12 @@ public class FlowLayoutManager extends BlockStackingLayoutManager } } } - if (childLC.isKeepWithNextPending()) { - //Clear and propagate - childLC.setFlags(LayoutContext.KEEP_WITH_NEXT_PENDING, false); - context.setFlags(LayoutContext.KEEP_WITH_NEXT_PENDING); - } + + //Propagate and clear + context.updateKeepWithNextPending(childLC.getKeepWithNextPending()); + childLC.clearKeepWithNextPending(); + + context.updateKeepWithNextPending(getKeepWithNextStrength()); } SpaceResolver.resolveElementList(returnList); @@ -213,18 +201,16 @@ public class FlowLayoutManager extends BlockStackingLayoutManager } /** {@inheritDoc} */ - public boolean mustKeepWithPrevious() { - return false; + public int getKeepWithNextStrength() { + return KEEP_AUTO; } /** {@inheritDoc} */ - public boolean mustKeepWithNext() { - return false; + public int getKeepWithPreviousStrength() { + return KEEP_AUTO; } - - /** - * {@inheritDoc} - */ + + /** {@inheritDoc} */ public LinkedList getChangedKnuthElements(List oldList, /*int flaggedPenalty,*/ int alignment) { ListIterator oldListIterator = oldList.listIterator(); KnuthElement returnedElement; @@ -357,6 +343,6 @@ public class FlowLayoutManager extends BlockStackingLayoutManager public int getContentAreaBPD() { return (int) getCurrentPV().getBodyRegion().getBPD(); } - + } diff --git a/src/java/org/apache/fop/layoutmgr/FootnoteBodyLayoutManager.java b/src/java/org/apache/fop/layoutmgr/FootnoteBodyLayoutManager.java index 351504cd7..34b931c03 100644 --- a/src/java/org/apache/fop/layoutmgr/FootnoteBodyLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/FootnoteBodyLayoutManager.java @@ -96,4 +96,14 @@ public class FootnoteBodyLayoutManager extends BlockStackingLayoutManager { return getParentKeepTogetherStrength(); } + /** {@inheritDoc} */ + public int getKeepWithNextStrength() { + return KEEP_AUTO; + } + + /** {@inheritDoc} */ + public int getKeepWithPreviousStrength() { + return KEEP_AUTO; + } + } diff --git a/src/java/org/apache/fop/layoutmgr/KeepUtil.java b/src/java/org/apache/fop/layoutmgr/KeepUtil.java index 1fd595ae0..8c80a1b10 100644 --- a/src/java/org/apache/fop/layoutmgr/KeepUtil.java +++ b/src/java/org/apache/fop/layoutmgr/KeepUtil.java @@ -20,6 +20,7 @@ package org.apache.fop.layoutmgr; import org.apache.fop.fo.Constants; +import org.apache.fop.fo.properties.KeepProperty; import org.apache.fop.fo.properties.Property; /** @@ -47,6 +48,29 @@ public class KeepUtil { } /** + * Returns the combined block-level keep strength from a keep property. + * <p> + * Note: This is a temporary method to be used until it is possible to differentiate between + * page and column keeps! + * @param keep the keep property + * @return the combined keep strength + */ + public static int getCombinedBlockLevelKeepStrength(KeepProperty keep) { + return Math.max( + getKeepStrength(keep.getWithinPage()), + getKeepStrength(keep.getWithinColumn())); + } + + /** + * Indicates whether a keep strength indicates a keep constraint. + * @param strength the keep strength + * @return true if the keep is not "auto" + */ + public static boolean hasKeep(int strength) { + return strength > BlockLevelLayoutManager.KEEP_AUTO; + } + + /** * Returns the penalty value to be used for a certain keep strength. * <ul> * <li>"auto": returns 0</li> @@ -67,4 +91,19 @@ public class KeepUtil { return penalty; } + /** + * Returns a string representation of a keep strength value. + * @param keepStrength the keep strength + * @return the string representation + */ + public static String keepStrengthToString(int keepStrength) { + if (keepStrength == BlockLevelLayoutManager.KEEP_AUTO) { + return "auto"; + } else if (keepStrength == BlockLevelLayoutManager.KEEP_ALWAYS) { + return "always"; + } else { + return Integer.toString(keepStrength); + } + } + } diff --git a/src/java/org/apache/fop/layoutmgr/LayoutContext.java b/src/java/org/apache/fop/layoutmgr/LayoutContext.java index 79b5e232f..5ac9808f2 100644 --- a/src/java/org/apache/fop/layoutmgr/LayoutContext.java +++ b/src/java/org/apache/fop/layoutmgr/LayoutContext.java @@ -63,12 +63,12 @@ public class LayoutContext { * This flag indicates that there's a keep-with-next that hasn't * been processed, yet. */ - public static final int KEEP_WITH_NEXT_PENDING = 0x200; + //public static final int KEEP_WITH_NEXT_PENDING = 0x200; /** * This flag indicates that there's a keep-with-previous that hasn't * been processed, yet. */ - public static final int KEEP_WITH_PREVIOUS_PENDING = 0x400; + //public static final int KEEP_WITH_PREVIOUS_PENDING = 0x400; private int flags; // Contains some set of flags defined above @@ -135,7 +135,6 @@ public class LayoutContext { /** Amount of space before / start */ private int spaceBefore = 0; - /** Amount of space after / end */ private int spaceAfter = 0; @@ -145,9 +144,11 @@ public class LayoutContext { private int lineEndBorderAndPaddingWidth = 0; private int breakBefore; - private int breakAfter; + private int pendingKeepWithNext = BlockLevelLayoutManager.KEEP_AUTO; + private int pendingKeepWithPrevious = BlockLevelLayoutManager.KEEP_AUTO; + /** * Copy constructor for creating child layout contexts. * @param parentLC the parent layout context to copy from @@ -167,6 +168,8 @@ public class LayoutContext { this.lineStartBorderAndPaddingWidth = parentLC.lineStartBorderAndPaddingWidth; this.lineEndBorderAndPaddingWidth = parentLC.lineEndBorderAndPaddingWidth; copyPendingMarksFrom(parentLC); + this.pendingKeepWithNext = parentLC.pendingKeepWithNext; + this.pendingKeepWithPrevious = parentLC.pendingKeepWithPrevious; // Copy other fields as necessary. } @@ -228,12 +231,74 @@ public class LayoutContext { return ((this.flags & SUPPRESS_LEADING_SPACE) != 0); } + /** + * Returns the strength of a keep-with-next currently pending. + * @return the keep-with-next strength + */ + public int getKeepWithNextPending() { + return this.pendingKeepWithNext; + } + + /** + * Returns the strength of a keep-with-previous currently pending. + * @return the keep-with-previous strength + */ + public int getKeepWithPreviousPending() { + return this.pendingKeepWithPrevious; + } + + /** + * Clears any pending keep-with-next strength. + */ + public void clearKeepWithNextPending() { + this.pendingKeepWithNext = BlockLevelLayoutManager.KEEP_AUTO; + } + + /** + * Clears any pending keep-with-previous strength. + */ + public void clearKeepWithPreviousPending() { + this.pendingKeepWithPrevious = BlockLevelLayoutManager.KEEP_AUTO; + } + + /** + * Clears both keep-with-previous and keep-with-next strengths. + */ + public void clearKeepsPending() { + clearKeepWithPreviousPending(); + clearKeepWithNextPending(); + } + + /** + * Updates the currently pending keep-with-next strength. + * @param strength the new strength to consider + */ + public void updateKeepWithNextPending(int strength) { + this.pendingKeepWithNext = Math.max(this.pendingKeepWithNext, strength); + } + + /** + * Updates the currently pending keep-with-previous strength. + * @param strength the new strength to consider + */ + public void updateKeepWithPreviousPending(int strength) { + this.pendingKeepWithPrevious = Math.max(this.pendingKeepWithPrevious, strength); + } + + /** + * Indicates whether a keep-with-next constraint is pending. + * @return true if a keep-with-next constraint is pending + */ public boolean isKeepWithNextPending() { - return ((this.flags & KEEP_WITH_NEXT_PENDING) != 0); + return getKeepWithNextPending() != BlockLevelLayoutManager.KEEP_AUTO; } + /** + * Indicates whether a keep-with-previous constraint is pending. + * @return true if a keep-with-previous constraint is pending + */ public boolean isKeepWithPreviousPending() { - return ((this.flags & KEEP_WITH_PREVIOUS_PENDING) != 0); + return getKeepWithPreviousPending() != BlockLevelLayoutManager.KEEP_AUTO; } public void setLeadingSpace(SpaceSpecifier space) { @@ -595,8 +660,9 @@ public class LayoutContext { + "\nStarts New Area: \t" + startsNewArea() + "\nIs Last Area: \t" + isLastArea() + "\nTry Hyphenate: \t" + tryHyphenate() - + "\nKeeps: \t[" + (isKeepWithNextPending() ? "keep-with-next" : "") + "][" - + (isKeepWithPreviousPending() ? "keep-with-previous" : "") + "] pending" + + "\nKeeps: \t[keep-with-next=" + KeepUtil.keepStrengthToString(getKeepWithNextPending()) + + "][keep-with-previous=" + + KeepUtil.keepStrengthToString(getKeepWithPreviousPending()) + "] pending" + "\nBreaks: \tforced [" + (breakBefore != Constants.EN_AUTO ? "break-before" : "") + "][" + (breakAfter != Constants.EN_AUTO ? "break-after" : "") + "]"; } diff --git a/src/java/org/apache/fop/layoutmgr/StaticContentLayoutManager.java b/src/java/org/apache/fop/layoutmgr/StaticContentLayoutManager.java index 0d88f2a1d..42ddcc220 100644 --- a/src/java/org/apache/fop/layoutmgr/StaticContentLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/StaticContentLayoutManager.java @@ -410,5 +410,15 @@ public class StaticContentLayoutManager extends BlockStackingLayoutManager { return KEEP_AUTO; } + /** {@inheritDoc} */ + public int getKeepWithNextStrength() { + return KEEP_AUTO; + } + + /** {@inheritDoc} */ + public int getKeepWithPreviousStrength() { + return KEEP_AUTO; + } + } diff --git a/src/java/org/apache/fop/layoutmgr/inline/InlineLayoutManager.java b/src/java/org/apache/fop/layoutmgr/inline/InlineLayoutManager.java index e9919e02f..f3bb66022 100755 --- a/src/java/org/apache/fop/layoutmgr/inline/InlineLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/inline/InlineLayoutManager.java @@ -314,7 +314,7 @@ public class InlineLayoutManager extends InlineStackingLayoutManager { // get KnuthElements from curLM returnedList = curLM.getNextKnuthElements(childLC, alignment); if (returnList.size() == 0 && childLC.isKeepWithPreviousPending()) { - childLC.setFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING, false); + childLC.clearKeepWithPreviousPending(); } if (returnedList == null || returnedList.size() == 0) { @@ -324,7 +324,7 @@ public class InlineLayoutManager extends InlineStackingLayoutManager { } if (curLM instanceof InlineLevelLayoutManager) { - context.setFlags(LayoutContext.KEEP_WITH_NEXT_PENDING, false); + context.clearKeepWithNextPending(); // "wrap" the Position stored in each element of returnedList ListIterator seqIter = returnedList.listIterator(); while (seqIter.hasNext()) { @@ -365,10 +365,8 @@ public class InlineLayoutManager extends InlineStackingLayoutManager { returnList.add(sequence); } // propagate and clear - context.setFlags(LayoutContext.KEEP_WITH_NEXT_PENDING, - childLC.isKeepWithNextPending()); - childLC.setFlags(LayoutContext.KEEP_WITH_NEXT_PENDING, false); - childLC.setFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING, false); + context.updateKeepWithNextPending(childLC.getKeepWithNextPending()); + childLC.clearKeepsPending(); } lastSequence = (KnuthSequence) returnList.getLast(); lastChildLM = curLM; diff --git a/src/java/org/apache/fop/layoutmgr/inline/LineLayoutManager.java b/src/java/org/apache/fop/layoutmgr/inline/LineLayoutManager.java index 08a3f3eff..8c46796eb 100644 --- a/src/java/org/apache/fop/layoutmgr/inline/LineLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/inline/LineLayoutManager.java @@ -1281,23 +1281,27 @@ public class LineLayoutManager extends InlineStackingLayoutManager return ((BlockLevelLayoutManager) getParent()).getKeepTogetherStrength(); } - /** - * {@inheritDoc} - */ + /** {@inheritDoc} */ public boolean mustKeepWithPrevious() { - return false; + return getKeepWithPreviousStrength() > KEEP_AUTO; } - /** - * {@inheritDoc} - */ + /** {@inheritDoc} */ public boolean mustKeepWithNext() { - return false; + return getKeepWithNextStrength() > KEEP_AUTO; } - /** - * {@inheritDoc} - */ + /** {@inheritDoc} */ + public int getKeepWithNextStrength() { + return KEEP_AUTO; + } + + /** {@inheritDoc} */ + public int getKeepWithPreviousStrength() { + return KEEP_AUTO; + } + + /** {@inheritDoc} */ public int negotiateBPDAdjustment(int adj, KnuthElement lastElement) { LeafPosition pos = (LeafPosition)lastElement.getPosition(); int totalAdj = adj; diff --git a/src/java/org/apache/fop/layoutmgr/list/ListBlockLayoutManager.java b/src/java/org/apache/fop/layoutmgr/list/ListBlockLayoutManager.java index eb64e0bf0..57114eee2 100644 --- a/src/java/org/apache/fop/layoutmgr/list/ListBlockLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/list/ListBlockLayoutManager.java @@ -280,26 +280,20 @@ public class ListBlockLayoutManager extends BlockStackingLayoutManager /** {@inheritDoc} */ public int getKeepTogetherStrength() { - int strength = KEEP_AUTO; - strength = Math.max(strength, KeepUtil.getKeepStrength( - getListBlockFO().getKeepTogether().getWithinPage())); - strength = Math.max(strength, KeepUtil.getKeepStrength( - getListBlockFO().getKeepTogether().getWithinColumn())); + int strength = KeepUtil.getCombinedBlockLevelKeepStrength( + getListBlockFO().getKeepTogether()); strength = Math.max(strength, getParentKeepTogetherStrength()); return strength; } /** {@inheritDoc} */ - public boolean mustKeepWithPrevious() { - //TODO Keeps will have to be more sophisticated sooner or later - return !getListBlockFO().getKeepWithPrevious().getWithinPage().isAuto() - || !getListBlockFO().getKeepWithPrevious().getWithinColumn().isAuto(); + public int getKeepWithNextStrength() { + return KeepUtil.getCombinedBlockLevelKeepStrength(getListBlockFO().getKeepWithNext()); } /** {@inheritDoc} */ - public boolean mustKeepWithNext() { - return !getListBlockFO().getKeepWithNext().getWithinPage().isAuto() - || !getListBlockFO().getKeepWithNext().getWithinColumn().isAuto(); + public int getKeepWithPreviousStrength() { + return KeepUtil.getCombinedBlockLevelKeepStrength(getListBlockFO().getKeepWithPrevious()); } /** {@inheritDoc} */ diff --git a/src/java/org/apache/fop/layoutmgr/list/ListItemContentLayoutManager.java b/src/java/org/apache/fop/layoutmgr/list/ListItemContentLayoutManager.java index be7dbdbba..e3b88b0ac 100644 --- a/src/java/org/apache/fop/layoutmgr/list/ListItemContentLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/list/ListItemContentLayoutManager.java @@ -222,14 +222,20 @@ public class ListItemContentLayoutManager extends BlockStackingLayoutManager { /** {@inheritDoc} */ public int getKeepTogetherStrength() { - int strength = KEEP_AUTO; - strength = Math.max(strength, KeepUtil.getKeepStrength( - getPartFO().getKeepTogether().getWithinPage())); - strength = Math.max(strength, KeepUtil.getKeepStrength( - getPartFO().getKeepTogether().getWithinColumn())); + int strength = KeepUtil.getCombinedBlockLevelKeepStrength(getPartFO().getKeepTogether()); strength = Math.max(strength, getParentKeepTogetherStrength()); return strength; } + /** {@inheritDoc} */ + public int getKeepWithNextStrength() { + return KEEP_AUTO; + } + + /** {@inheritDoc} */ + public int getKeepWithPreviousStrength() { + return KEEP_AUTO; + } + } diff --git a/src/java/org/apache/fop/layoutmgr/list/ListItemLayoutManager.java b/src/java/org/apache/fop/layoutmgr/list/ListItemLayoutManager.java index b727f8860..5e7288f04 100644 --- a/src/java/org/apache/fop/layoutmgr/list/ListItemLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/list/ListItemLayoutManager.java @@ -32,6 +32,7 @@ import org.apache.fop.area.Block; import org.apache.fop.fo.flow.ListItem; import org.apache.fop.fo.flow.ListItemBody; import org.apache.fop.fo.flow.ListItemLabel; +import org.apache.fop.layoutmgr.BlockLevelLayoutManager; import org.apache.fop.layoutmgr.BlockStackingLayoutManager; import org.apache.fop.layoutmgr.BreakElement; import org.apache.fop.layoutmgr.ConditionalElementListener; @@ -80,8 +81,8 @@ public class ListItemLayoutManager extends BlockStackingLayoutManager private MinOptMax effSpaceBefore; private MinOptMax effSpaceAfter; - private boolean keepWithNextPendingOnLabel; - private boolean keepWithNextPendingOnBody; + private int keepWithNextPendingOnLabel; + private int keepWithNextPendingOnBody; private int listItemHeight; @@ -223,10 +224,8 @@ public class ListItemLayoutManager extends BlockStackingLayoutManager SpaceResolver.resolveElementList(labelList); ElementListObserver.observe(labelList, "list-item-label", label.getPartFO().getId()); - if (childLC.isKeepWithPreviousPending()) { - context.setFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING); - } - this.keepWithNextPendingOnLabel = childLC.isKeepWithNextPending(); + context.updateKeepWithPreviousPending(childLC.getKeepWithPreviousPending()); + this.keepWithNextPendingOnLabel = childLC.getKeepWithNextPending(); // body childLC = new LayoutContext(0); @@ -239,10 +238,8 @@ public class ListItemLayoutManager extends BlockStackingLayoutManager SpaceResolver.resolveElementList(bodyList); ElementListObserver.observe(bodyList, "list-item-body", body.getPartFO().getId()); - if (childLC.isKeepWithPreviousPending()) { - context.setFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING); - } - this.keepWithNextPendingOnBody = childLC.isKeepWithNextPending(); + context.updateKeepWithPreviousPending(childLC.getKeepWithPreviousPending()); + this.keepWithNextPendingOnBody = childLC.getKeepWithNextPending(); // create a combined list LinkedList returnedList = getCombinedKnuthElementsForListItem(labelList, bodyList, context); @@ -254,12 +251,10 @@ public class ListItemLayoutManager extends BlockStackingLayoutManager addKnuthElementsForSpaceAfter(returnList, alignment); addKnuthElementsForBreakAfter(returnList, context); - if (keepWithNextPendingOnLabel || keepWithNextPendingOnBody || mustKeepWithNext()) { - context.setFlags(LayoutContext.KEEP_WITH_NEXT_PENDING); - } - if (mustKeepWithPrevious()) { - context.setFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING); - } + context.updateKeepWithNextPending(this.keepWithNextPendingOnLabel); + context.updateKeepWithNextPending(this.keepWithNextPendingOnBody); + context.updateKeepWithNextPending(getKeepWithNextStrength()); + context.updateKeepWithPreviousPending(getKeepWithPreviousStrength()); setFinished(true); resetSpaces(); @@ -281,21 +276,17 @@ public class ListItemLayoutManager extends BlockStackingLayoutManager int totalHeight = Math.max(fullHeights[0], fullHeights[1]); int step; int addedBoxHeight = 0; - boolean keepWithNextActive = false; + int keepWithNextActive = BlockLevelLayoutManager.KEEP_AUTO; LinkedList returnList = new LinkedList(); while ((step = getNextStep(elementLists, start, end, partialHeights)) > 0) { if (end[0] + 1 == elementLists[0].size()) { - if (keepWithNextPendingOnLabel) { - keepWithNextActive = true; - } + keepWithNextActive = Math.max(keepWithNextActive, keepWithNextPendingOnLabel); } if (end[1] + 1 == elementLists[1].size()) { - if (keepWithNextPendingOnBody) { - keepWithNextActive = true; - } + keepWithNextActive = Math.max(keepWithNextActive, keepWithNextPendingOnBody); } // compute penalty height and box height @@ -327,12 +318,12 @@ public class ListItemLayoutManager extends BlockStackingLayoutManager start[0], end[0], start[1], end[1]); returnList.add(new KnuthBox(boxHeight, stepPosition, false)); if (addedBoxHeight < totalHeight) { + int strength = BlockLevelLayoutManager.KEEP_AUTO; + strength = Math.max(strength, keepWithNextActive); + strength = Math.max(strength, getKeepTogetherStrength()); int p = stepPenalty; - if (keepWithNextActive) { - p = KnuthPenalty.INFINITE; - } - if (mustKeepTogether()) { - p = Math.max(p, KeepUtil.getPenaltyForKeep(getKeepTogetherStrength())); + if (p > -KnuthElement.INFINITE) { + p = Math.max(p, KeepUtil.getPenaltyForKeep(strength)); } returnList.add(new BreakElement(stepPosition, penaltyHeight, p, -1, context)); } @@ -637,26 +628,20 @@ public class ListItemLayoutManager extends BlockStackingLayoutManager /** {@inheritDoc} */ public int getKeepTogetherStrength() { - int strength = KEEP_AUTO; - strength = Math.max(strength, KeepUtil.getKeepStrength( - getListItemFO().getKeepTogether().getWithinPage())); - strength = Math.max(strength, KeepUtil.getKeepStrength( - getListItemFO().getKeepTogether().getWithinColumn())); + int strength = KeepUtil.getCombinedBlockLevelKeepStrength( + getListItemFO().getKeepTogether()); strength = Math.max(strength, getParentKeepTogetherStrength()); return strength; } /** {@inheritDoc} */ - public boolean mustKeepWithPrevious() { - //TODO Keeps will have to be more sophisticated sooner or later - return !getListItemFO().getKeepWithPrevious().getWithinPage().isAuto() - || !getListItemFO().getKeepWithPrevious().getWithinColumn().isAuto(); + public int getKeepWithNextStrength() { + return KeepUtil.getCombinedBlockLevelKeepStrength(getListItemFO().getKeepWithNext()); } /** {@inheritDoc} */ - public boolean mustKeepWithNext() { - return !getListItemFO().getKeepWithNext().getWithinPage().isAuto() - || !getListItemFO().getKeepWithNext().getWithinColumn().isAuto(); + public int getKeepWithPreviousStrength() { + return KeepUtil.getCombinedBlockLevelKeepStrength(getListItemFO().getKeepWithPrevious()); } /** {@inheritDoc} */ diff --git a/src/java/org/apache/fop/layoutmgr/table/ActiveCell.java b/src/java/org/apache/fop/layoutmgr/table/ActiveCell.java index 61d0f8e6f..1e5120700 100644 --- a/src/java/org/apache/fop/layoutmgr/table/ActiveCell.java +++ b/src/java/org/apache/fop/layoutmgr/table/ActiveCell.java @@ -24,11 +24,13 @@ import java.util.ListIterator; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; + import org.apache.fop.fo.Constants; import org.apache.fop.fo.flow.table.ConditionalBorder; import org.apache.fop.fo.flow.table.EffRow; import org.apache.fop.fo.flow.table.PrimaryGridUnit; import org.apache.fop.fo.properties.CommonBorderPaddingBackground; +import org.apache.fop.layoutmgr.BlockLevelLayoutManager; import org.apache.fop.layoutmgr.ElementListUtils; import org.apache.fop.layoutmgr.KnuthBox; import org.apache.fop.layoutmgr.KnuthElement; @@ -70,7 +72,7 @@ class ActiveCell { /** True if the next CellPart that will be created will be the last one for this cell. */ private boolean lastCellPart; - private boolean keepWithNextSignal; + private int keepWithNextStrength; private int spanIndex = 0; @@ -202,7 +204,7 @@ class ActiveCell { includedLength = -1; // Avoid troubles with cells having content of zero length totalLength = previousRowsLength + ElementListUtils.calcContentLength(elementList); endRowIndex = rowIndex + pgu.getCell().getNumberRowsSpanned() - 1; - keepWithNextSignal = false; + keepWithNextStrength = BlockLevelLayoutManager.KEEP_AUTO; remainingLength = totalLength - previousRowsLength; afterNextStep = new Step(previousRowsLength); @@ -506,14 +508,14 @@ class ActiveCell { */ CellPart createCellPart() { if (nextStep.end + 1 == elementList.size()) { - keepWithNextSignal = pgu.mustKeepWithNext(); + keepWithNextStrength = pgu.getKeepWithNextStrength(); // TODO if keep-with-next is set on the row, must every cell of the row // contribute some content from children blocks? // see http://mail-archives.apache.org/mod_mbox/xmlgraphics-fop-dev/200802.mbox/ // %3c47BDA379.4050606@anyware-tech.com%3e // Assuming no, but if yes the following code should enable this behaviour // if (pgu.getRow() != null && pgu.getRow().mustKeepWithNext()) { -// keepWithNextSignal = true; +// keepWithNextSignal = true; //to be converted to integer strengths // } } int bpBeforeFirst; @@ -536,8 +538,8 @@ class ActiveCell { } } - boolean keepWithNextSignal() { - return keepWithNextSignal; + int getKeepWithNextStrength() { + return keepWithNextStrength; } diff --git a/src/java/org/apache/fop/layoutmgr/table/ColumnSetup.java b/src/java/org/apache/fop/layoutmgr/table/ColumnSetup.java index bd032e610..9dbd31653 100644 --- a/src/java/org/apache/fop/layoutmgr/table/ColumnSetup.java +++ b/src/java/org/apache/fop/layoutmgr/table/ColumnSetup.java @@ -29,6 +29,7 @@ import org.apache.commons.logging.LogFactory; import org.apache.fop.datatypes.Length; import org.apache.fop.datatypes.PercentBaseContext; import org.apache.fop.fo.FONode; +import org.apache.fop.fo.expr.RelativeNumericProperty; import org.apache.fop.fo.flow.table.Table; import org.apache.fop.fo.flow.table.TableColumn; import org.apache.fop.fo.properties.TableColLength; @@ -196,7 +197,9 @@ public class ColumnSetup { Length colWidth = (Length) i.next(); if (colWidth != null) { sumCols += colWidth.getValue(tlm); - if (colWidth instanceof TableColLength) { + if (colWidth instanceof RelativeNumericProperty) { + factors += ((RelativeNumericProperty) colWidth).getTableUnits(); + } else if (colWidth instanceof TableColLength) { factors += ((TableColLength) colWidth).getTableUnits(); } } diff --git a/src/java/org/apache/fop/layoutmgr/table/RowGroupLayoutManager.java b/src/java/org/apache/fop/layoutmgr/table/RowGroupLayoutManager.java index 72e78b84f..19b97322c 100644 --- a/src/java/org/apache/fop/layoutmgr/table/RowGroupLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/table/RowGroupLayoutManager.java @@ -33,7 +33,6 @@ import org.apache.fop.fo.flow.table.TableColumn; import org.apache.fop.fo.flow.table.TableRow; import org.apache.fop.fo.properties.CommonBorderPaddingBackground; import org.apache.fop.fo.properties.LengthRangeProperty; -import org.apache.fop.layoutmgr.BlockLevelEventProducer; import org.apache.fop.layoutmgr.ElementListObserver; import org.apache.fop.layoutmgr.LayoutContext; import org.apache.fop.layoutmgr.MinOptMaxUtil; @@ -61,10 +60,8 @@ class RowGroupLayoutManager { LinkedList returnList = new LinkedList(); createElementsForRowGroup(context, alignment, bodyType, returnList); - context.setFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING, - rowGroup[0].mustKeepWithPrevious()); - context.setFlags(LayoutContext.KEEP_WITH_NEXT_PENDING, - rowGroup[rowGroup.length - 1].mustKeepWithNext()); + context.updateKeepWithPreviousPending(rowGroup[0].getKeepWithPreviousStrength()); + context.updateKeepWithNextPending(rowGroup[rowGroup.length - 1].getKeepWithNextStrength()); int breakBefore = Constants.EN_AUTO; TableRow firstRow = rowGroup[0].getTableRow(); diff --git a/src/java/org/apache/fop/layoutmgr/table/TableAndCaptionLayoutManager.java b/src/java/org/apache/fop/layoutmgr/table/TableAndCaptionLayoutManager.java index fc0d587ff..c20060723 100644 --- a/src/java/org/apache/fop/layoutmgr/table/TableAndCaptionLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/table/TableAndCaptionLayoutManager.java @@ -49,6 +49,14 @@ public class TableAndCaptionLayoutManager extends BlockStackingLayoutManager { } /** + * Returns the table-and-caption formatting object. + * @return the table-and-caption formatting object + */ + public TableAndCaption getTableAndCaptionFO() { + return (TableAndCaption)this.fobj; + } + + /** * Get the next break possibility. * * @param context the layout context for getting breaks @@ -196,13 +204,29 @@ public class TableAndCaptionLayoutManager extends BlockStackingLayoutManager { public int getKeepTogetherStrength() { int strength = KEEP_AUTO; /* TODO Complete me! - strength = Math.max(strength, KeepUtil.getKeepStrength( - getTableAndCaption().getKeepTogether().getWithinPage())); - strength = Math.max(strength, KeepUtil.getKeepStrength( - getTableAndCaption().getKeepTogether().getWithinColumn())); + int strength = KeepUtil.getCombinedBlockLevelKeepStrength( + getTableAndCaptionFO().getKeepTogether()); */ strength = Math.max(strength, getParentKeepTogetherStrength()); return strength; } + /** {@inheritDoc} */ + public int getKeepWithNextStrength() { + return KEEP_AUTO; + /* TODO Complete me! + return KeepUtil.getCombinedBlockLevelKeepStrength( + getTableAndCaptionFO().getKeepWithNext()); + */ + } + + /** {@inheritDoc} */ + public int getKeepWithPreviousStrength() { + return KEEP_AUTO; + /* TODO Complete me! + return KeepUtil.getCombinedBlockLevelKeepStrength( + getTableAndCaptionFO().getKeepWithPrevious()); + */ + } + }
\ No newline at end of file diff --git a/src/java/org/apache/fop/layoutmgr/table/TableCaptionLayoutManager.java b/src/java/org/apache/fop/layoutmgr/table/TableCaptionLayoutManager.java index 8c4908547..615145fa1 100644 --- a/src/java/org/apache/fop/layoutmgr/table/TableCaptionLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/table/TableCaptionLayoutManager.java @@ -47,7 +47,7 @@ public class TableCaptionLayoutManager extends BlockStackingLayoutManager { } /** @return the table-caption FO */ - public TableCaption getTableCaption() { + public TableCaption getTableCaptionFO() { return (TableCaption)this.fobj; } @@ -201,13 +201,31 @@ public class TableCaptionLayoutManager extends BlockStackingLayoutManager { int strength = KEEP_AUTO; /* TODO Complete me! strength = Math.max(strength, KeepUtil.getKeepStrength( - getTableCaption().getKeepTogether().getWithinPage())); + getTableCaptionFO().getKeepTogether().getWithinPage())); strength = Math.max(strength, KeepUtil.getKeepStrength( - getTableCaption().getKeepTogether().getWithinColumn())); + getTableCaptionFO().getKeepTogether().getWithinColumn())); */ strength = Math.max(strength, getParentKeepTogetherStrength()); return strength; } + /** {@inheritDoc} */ + public int getKeepWithNextStrength() { + return KEEP_AUTO; + /* TODO Complete me! + return KeepUtil.getCombinedBlockLevelKeepStrength( + getTableCaptionFO().getKeepWithNext()); + */ + } + + /** {@inheritDoc} */ + public int getKeepWithPreviousStrength() { + return KEEP_AUTO; + /* TODO Complete me! + return KeepUtil.getCombinedBlockLevelKeepStrength( + getTableCaptionFO().getKeepWithPrevious()); + */ + } + } diff --git a/src/java/org/apache/fop/layoutmgr/table/TableCellLayoutManager.java b/src/java/org/apache/fop/layoutmgr/table/TableCellLayoutManager.java index 291e27ae2..6067af4bc 100644 --- a/src/java/org/apache/fop/layoutmgr/table/TableCellLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/table/TableCellLayoutManager.java @@ -153,8 +153,8 @@ public class TableCellLayoutManager extends BlockStackingLayoutManager log.debug("child LM signals pending keep with next"); } if (contentList.size() == 0 && childLC.isKeepWithPreviousPending()) { - primaryGridUnit.setKeepWithPrevious(); - childLC.setFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING, false); + primaryGridUnit.setKeepWithPreviousStrength(childLC.getKeepWithPreviousPending()); + childLC.clearKeepWithPreviousPending(); } if (prevLM != null) { @@ -169,14 +169,12 @@ public class TableCellLayoutManager extends BlockStackingLayoutManager } if (childLC.isKeepWithNextPending()) { //Clear and propagate - childLC.setFlags(LayoutContext.KEEP_WITH_NEXT_PENDING, false); - context.setFlags(LayoutContext.KEEP_WITH_NEXT_PENDING); + context.updateKeepWithNextPending(childLC.getKeepWithNextPending()); + childLC.clearKeepWithNextPending(); } prevLM = curLM; } - if (context.isKeepWithNextPending()) { - primaryGridUnit.setKeepWithNext(); - } + primaryGridUnit.setKeepWithNextStrength(context.getKeepWithNextPending()); returnedList = new LinkedList(); if (contentList.size() > 0) { @@ -569,24 +567,15 @@ public class TableCellLayoutManager extends BlockStackingLayoutManager } /** {@inheritDoc} */ - public boolean mustKeepWithPrevious() { - //TODO Keeps will have to be more sophisticated sooner or later - return false; //TODO FIX ME - /* - return !fobj.getKeepWithPrevious().getWithinPage().isAuto() - || !fobj.getKeepWithPrevious().getWithinColumn().isAuto(); - */ + public int getKeepWithNextStrength() { + return KEEP_AUTO; //TODO FIX ME (table-cell has no keep-with-next!) } /** {@inheritDoc} */ - public boolean mustKeepWithNext() { - return false; //TODO FIX ME - /* - return !fobj.getKeepWithNext().getWithinPage().isAuto() - || !fobj.getKeepWithNext().getWithinColumn().isAuto(); - */ + public int getKeepWithPreviousStrength() { + return KEEP_AUTO; //TODO FIX ME (table-cell has no keep-with-previous!) } - + // --------- Property Resolution related functions --------- // /** diff --git a/src/java/org/apache/fop/layoutmgr/table/TableContentLayoutManager.java b/src/java/org/apache/fop/layoutmgr/table/TableContentLayoutManager.java index 235bc1fd2..7a2ee171c 100644 --- a/src/java/org/apache/fop/layoutmgr/table/TableContentLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/table/TableContentLayoutManager.java @@ -35,6 +35,7 @@ import org.apache.fop.fo.flow.table.EffRow; import org.apache.fop.fo.flow.table.PrimaryGridUnit; import org.apache.fop.fo.flow.table.Table; import org.apache.fop.fo.flow.table.TableBody; +import org.apache.fop.layoutmgr.BlockLevelLayoutManager; import org.apache.fop.layoutmgr.BreakElement; import org.apache.fop.layoutmgr.ElementListUtils; import org.apache.fop.layoutmgr.KeepUtil; @@ -208,31 +209,37 @@ public class TableContentLayoutManager implements PercentBaseContext { LinkedList returnList = new LinkedList(); EffRow[] rowGroup = iter.getNextRowGroup(); // TODO homogenize the handling of keeps and breaks - context.unsetFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING - | LayoutContext.KEEP_WITH_NEXT_PENDING); + context.clearKeepsPending(); context.setBreakBefore(Constants.EN_AUTO); context.setBreakAfter(Constants.EN_AUTO); - boolean keepWithPrevious = false; + int keepWithPrevious = BlockLevelLayoutManager.KEEP_AUTO; int breakBefore = Constants.EN_AUTO; if (rowGroup != null) { RowGroupLayoutManager rowGroupLM = new RowGroupLayoutManager(getTableLM(), rowGroup, stepper); List nextRowGroupElems = rowGroupLM.getNextKnuthElements(context, alignment, bodyType); - keepWithPrevious = context.isKeepWithPreviousPending(); - boolean keepBetween = context.isKeepWithNextPending(); + keepWithPrevious = Math.max(keepWithPrevious, context.getKeepWithPreviousPending()); breakBefore = context.getBreakBefore(); int breakBetween = context.getBreakAfter(); returnList.addAll(nextRowGroupElems); while ((rowGroup = iter.getNextRowGroup()) != null) { rowGroupLM = new RowGroupLayoutManager(getTableLM(), rowGroup, stepper); + + //Note previous pending keep-with-next and clear the strength + //(as the layout context is reused) + int keepWithNextPending = context.getKeepWithNextPending(); + context.clearKeepWithNextPending(); + + //Get elements for next row group nextRowGroupElems = rowGroupLM.getNextKnuthElements(context, alignment, bodyType); - int penaltyValue = 0; - keepBetween |= context.isKeepWithPreviousPending(); - if (keepBetween) { - penaltyValue = KnuthElement.INFINITE; - } - penaltyValue = Math.max(penaltyValue, - KeepUtil.getPenaltyForKeep(getTableLM().getKeepTogetherStrength())); + + //Determine keep constraints + int penaltyStrength = BlockLevelLayoutManager.KEEP_AUTO; + penaltyStrength = Math.max(penaltyStrength, keepWithNextPending); + penaltyStrength = Math.max(penaltyStrength, context.getKeepWithPreviousPending()); + context.clearKeepWithPreviousPending(); + penaltyStrength = Math.max(penaltyStrength, getTableLM().getKeepTogetherStrength()); + int penaltyValue = KeepUtil.getPenaltyForKeep(penaltyStrength); breakBetween = BreakUtil.compareBreakClasses(breakBetween, context.getBreakBefore()); @@ -255,10 +262,9 @@ public class TableContentLayoutManager implements PercentBaseContext { penaltyLen, penaltyValue, breakBetween, context)); returnList.addAll(nextRowGroupElems); breakBetween = context.getBreakAfter(); - keepBetween = context.isKeepWithNextPending(); } } - context.setFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING, keepWithPrevious); + context.updateKeepWithPreviousPending(keepWithPrevious); context.setBreakBefore(breakBefore); //fox:widow-content-limit diff --git a/src/java/org/apache/fop/layoutmgr/table/TableLayoutManager.java b/src/java/org/apache/fop/layoutmgr/table/TableLayoutManager.java index 5738a027c..75189a6b9 100644 --- a/src/java/org/apache/fop/layoutmgr/table/TableLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/table/TableLayoutManager.java @@ -256,12 +256,11 @@ public class TableLayoutManager extends BlockStackingLayoutManager log.debug(contentKnuthElements); wrapPositionElements(contentKnuthElements, returnList); - if (mustKeepWithPrevious() || childLC.isKeepWithPreviousPending()) { - context.setFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING); - } - if (mustKeepWithNext() || childLC.isKeepWithNextPending()) { - context.setFlags(LayoutContext.KEEP_WITH_NEXT_PENDING); - } + context.updateKeepWithPreviousPending(getKeepWithPreviousStrength()); + context.updateKeepWithPreviousPending(childLC.getKeepWithPreviousPending()); + + context.updateKeepWithNextPending(getKeepWithNextStrength()); + context.updateKeepWithNextPending(childLC.getKeepWithNextPending()); if (getTable().isSeparateBorderModel()) { addKnuthElementsForBorderPaddingAfter(returnList, true); @@ -448,29 +447,19 @@ public class TableLayoutManager extends BlockStackingLayoutManager /** {@inheritDoc} */ public int getKeepTogetherStrength() { - int strength = KEEP_AUTO; - strength = Math.max(strength, KeepUtil.getKeepStrength( - getTable().getKeepTogether().getWithinPage())); - strength = Math.max(strength, KeepUtil.getKeepStrength( - getTable().getKeepTogether().getWithinColumn())); + int strength = KeepUtil.getCombinedBlockLevelKeepStrength(getTable().getKeepTogether()); strength = Math.max(strength, getParentKeepTogetherStrength()); return strength; } - /** - * {@inheritDoc} - */ - public boolean mustKeepWithPrevious() { - return !getTable().getKeepWithPrevious().getWithinPage().isAuto() - || !getTable().getKeepWithPrevious().getWithinColumn().isAuto(); + /** {@inheritDoc} */ + public int getKeepWithNextStrength() { + return KeepUtil.getCombinedBlockLevelKeepStrength(getTable().getKeepWithNext()); } - /** - * {@inheritDoc} - */ - public boolean mustKeepWithNext() { - return !getTable().getKeepWithNext().getWithinPage().isAuto() - || !getTable().getKeepWithNext().getWithinColumn().isAuto(); + /** {@inheritDoc} */ + public int getKeepWithPreviousStrength() { + return KeepUtil.getCombinedBlockLevelKeepStrength(getTable().getKeepWithPrevious()); } // --------- Property Resolution related functions --------- // diff --git a/src/java/org/apache/fop/layoutmgr/table/TableStepper.java b/src/java/org/apache/fop/layoutmgr/table/TableStepper.java index 07894a07b..2d3c990f8 100644 --- a/src/java/org/apache/fop/layoutmgr/table/TableStepper.java +++ b/src/java/org/apache/fop/layoutmgr/table/TableStepper.java @@ -30,9 +30,11 @@ import org.apache.fop.fo.Constants; import org.apache.fop.fo.flow.table.EffRow; import org.apache.fop.fo.flow.table.GridUnit; import org.apache.fop.fo.flow.table.PrimaryGridUnit; +import org.apache.fop.layoutmgr.BlockLevelLayoutManager; import org.apache.fop.layoutmgr.BreakElement; import org.apache.fop.layoutmgr.KeepUtil; import org.apache.fop.layoutmgr.KnuthBox; +import org.apache.fop.layoutmgr.KnuthElement; import org.apache.fop.layoutmgr.KnuthGlue; import org.apache.fop.layoutmgr.KnuthPenalty; import org.apache.fop.layoutmgr.LayoutContext; @@ -198,11 +200,20 @@ public class TableStepper { } //Put all involved grid units into a list + int stepPenalty = 0; List cellParts = new java.util.ArrayList(columnCount); for (Iterator iter = activeCells.iterator(); iter.hasNext();) { ActiveCell activeCell = (ActiveCell) iter.next(); CellPart part = activeCell.createCellPart(); cellParts.add(part); + + //Record highest penalty value of part + if (part.end >= 0) { + KnuthElement endEl = (KnuthElement)part.pgu.getElements().get(part.end); + if (endEl instanceof KnuthPenalty) { + stepPenalty = Math.max(stepPenalty, endEl.getP()); + } + } } //Create elements for step @@ -230,39 +241,37 @@ public class TableStepper { } } - int p = 0; - boolean keepWithNext = false; + int strength = BlockLevelLayoutManager.KEEP_AUTO; for (Iterator iter = activeCells.iterator(); iter.hasNext();) { ActiveCell activeCell = (ActiveCell) iter.next(); - keepWithNext |= activeCell.keepWithNextSignal(); - } - if (keepWithNext) { - p = KnuthPenalty.INFINITE; + strength = Math.max(strength, activeCell.getKeepWithNextStrength()); } if (!rowFinished) { - p = Math.max(p, KeepUtil.getPenaltyForKeep( - rowGroup[activeRowIndex].getKeepTogetherStrength())); + strength = Math.max(strength, rowGroup[activeRowIndex].getKeepTogetherStrength()); //The above call doesn't take the penalty from the table into account, so... - p = Math.max(p, KeepUtil.getPenaltyForKeep( - getTableLM().getKeepTogetherStrength())); + strength = Math.max(strength, getTableLM().getKeepTogetherStrength()); } else if (activeRowIndex < rowGroup.length - 1) { - if (rowGroup[activeRowIndex].mustKeepWithNext() - || rowGroup[activeRowIndex + 1].mustKeepWithPrevious()) { - p = KnuthPenalty.INFINITE; - } + strength = Math.max(strength, + rowGroup[activeRowIndex].getKeepWithNextStrength()); + strength = Math.max(strength, + rowGroup[activeRowIndex + 1].getKeepWithPreviousStrength()); nextBreakClass = BreakUtil.compareBreakClasses(nextBreakClass, rowGroup[activeRowIndex].getBreakAfter()); nextBreakClass = BreakUtil.compareBreakClasses(nextBreakClass, rowGroup[activeRowIndex + 1].getBreakBefore()); } - if (nextBreakClass != Constants.EN_AUTO) { - log.trace("Forced break encountered"); - p = -KnuthPenalty.INFINITE; //Overrides any keeps (see 4.8 in XSL 1.0) - } + int p = KeepUtil.getPenaltyForKeep(strength); if (rowHeightSmallerThanFirstStep) { rowHeightSmallerThanFirstStep = false; p = KnuthPenalty.INFINITE; } + if (p > -KnuthElement.INFINITE) { + p = Math.max(p, stepPenalty); + } + if (nextBreakClass != Constants.EN_AUTO) { + log.trace("Forced break encountered"); + p = -KnuthPenalty.INFINITE; //Overrides any keeps (see 4.8 in XSL 1.0) + } returnList.add(new BreakElement(penaltyPos, effPenaltyLen, p, nextBreakClass, context)); if (penaltyOrGlueLen < 0) { returnList.add(new KnuthGlue(-penaltyOrGlueLen, 0, 0, new Position(null), true)); |