Attachment #23411 for bug #46905

View | Details | Raw Unified | Return to bug 46905
Collapse All | Expand All




    }

    /** {@inheritDoc} */
    public Keep getKeepTogether() {
        return Keep.KEEP_AUTO;
    }

    /** {@inheritDoc} */
    public Keep getKeepWithNext() {
        return Keep.KEEP_AUTO;
    }

    /** {@inheritDoc} */
    public Keep getKeepWithPrevious() {
        return Keep.KEEP_AUTO;
    }

}




/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/* $Id$ */

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;

/**
 * Utility class for working with keeps.
 */
public class KeepUtil {

    /**
     * Converts a keep property into an integer value.
     * <p>
     * Note: The conversion restricts the effectively available integer range by two values.
     * Integer.MIN_VALUE is used to represent the value "auto" and
     * Integer.MAX_VALUE is used to represebt the value "always".
     * @param keep the keep property
     * @return the keep value as an integer
     */
    public static int getKeepStrength(Property keep) {
        if (keep.isAuto()) {
            return BlockLevelLayoutManager.KEEP_AUTO;
        } else if (keep.getEnum() == Constants.EN_ALWAYS) {
            return BlockLevelLayoutManager.KEEP_ALWAYS;
        } else {
            return keep.getNumber().intValue();
        }
    }

    /**
     * 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>
     *   <li>"always": returns KnuthElement.INFINITE</li>
     *   <li>otherwise: returns KnuthElement.INFINITE - 1</li>
     * </ul>
     * @param keepStrength the keep strength
     * @return the penalty value
     */
    public static int getPenaltyForKeep(int keepStrength) {
        if (keepStrength == BlockLevelLayoutManager.KEEP_AUTO) {
            return 0;
        }
        int penalty = KnuthElement.INFINITE;
        if (keepStrength < BlockLevelLayoutManager.KEEP_ALWAYS) {
            penalty--;
        }
        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);
        }
    }

}




            }
            sb.append(")");
        }
        switch (getBreakClass()) {
        case Constants.EN_PAGE:
            sb.append(" (page context)");
            break;
        case Constants.EN_COLUMN:
            sb.append(" (column context)");
            break;
        case Constants.EN_LINE:
            sb.append(" (line context)");
            break;
        }
        return sb.toString();
    }





import org.apache.fop.fo.Constants;
import org.apache.fop.fo.flow.Block;
import org.apache.fop.fo.properties.CommonHyphenation;
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;

import org.apache.fop.layoutmgr.BreakingAlgorithm;
import org.apache.fop.layoutmgr.ElementListObserver;
import org.apache.fop.layoutmgr.InlineKnuthSequence;
import org.apache.fop.layoutmgr.Keep;
import org.apache.fop.layoutmgr.KnuthBlockBox;
import org.apache.fop.layoutmgr.KnuthBox;
import org.apache.fop.layoutmgr.KnuthElement;

        for (int p = 0; p < knuthParagraphs.size(); p++) {
            // penalty between paragraphs
            if (p > 0) {
                Keep keep = getKeepTogether();
                int penalty = keep.getPenalty();
//                if (penalty < KnuthElement.INFINITE) {
                    returnList.add(new BreakElement(
                            new Position(this), penalty, keep.getContext(), context));
//                }
            }

            LineLayoutPossibilities llPoss;

                            && i >= fobj.getOrphans()
                            && i <= llPoss.getChosenLineCount() - fobj.getWidows()) {
                        // penalty allowing a page break between lines
                        Keep keep = getKeepTogether();
                        int penalty = keep.getPenalty();
//                        if (penalty < KnuthElement.INFINITE) {
                            returnList.add(new BreakElement(
                                    returnPosition, penalty, keep.getContext(), context));
//                        }
                    }
                    int endIndex
                      = ((LineBreakPosition) llPoss.getChosenPosition(i)).getLeafPos();

    }

    /** {@inheritDoc} */
    public KeepProperty getKeepTogetherProperty() {
        return ((BlockLevelLayoutManager) getParent()).getKeepTogetherProperty();
    }

    /** {@inheritDoc} */
    public KeepProperty getKeepWithPreviousProperty() {
        return ((BlockLevelLayoutManager) getParent()).getKeepWithPreviousProperty();
    }

    /** {@inheritDoc} */
    public KeepProperty getKeepWithNextProperty() {
        return ((BlockLevelLayoutManager) getParent()).getKeepWithNextProperty();
    }

    /** {@inheritDoc} */
    public Keep getKeepTogether() {
        return ((BlockLevelLayoutManager) getParent()).getKeepTogether();
    }

    /** {@inheritDoc} */
    public boolean mustKeepWithPrevious() {
        return !getKeepWithPrevious().isAuto();
    }

    /** {@inheritDoc} */
    public boolean mustKeepWithNext() {
        return !getKeepWithNext().isAuto();
    }

    /** {@inheritDoc} */
    public Keep getKeepWithNext() {
        return Keep.KEEP_AUTO;
    }

    /** {@inheritDoc} */
    public Keep getKeepWithPrevious() {
        return Keep.KEEP_AUTO;
    }

    /** {@inheritDoc} */

Lines 399-405 Link Here

(-)src/java/org/apache/fop/layoutmgr/AbstractBreaker.java (-1 / +7 lines)
399	ListElement lastBreakElement = effectiveList.getElement(endElementIndex);	399	ListElement lastBreakElement = effectiveList.getElement(endElementIndex);
400	if (lastBreakElement.isPenalty()) {	400	if (lastBreakElement.isPenalty()) {
401	KnuthPenalty pen = (KnuthPenalty)lastBreakElement;	401	KnuthPenalty pen = (KnuthPenalty)lastBreakElement;
402	lastBreakClass = pen.getBreakClass();	402	// TODO Handle keep.within-column differently so that break class is
		403	// automatically set to the right value
		404	if (pen.getP() >= KnuthPenalty.INFINITE - 1) {
		405	lastBreakClass = Constants.EN_COLUMN;
		406	} else {
		407	lastBreakClass = pen.getBreakClass();
		408	}
403	} else {	409	} else {
404	lastBreakClass = Constants.EN_COLUMN;	410	lastBreakClass = Constants.EN_COLUMN;
405	}	411	}

Lines 19-24 Link Here

(-)src/java/org/apache/fop/layoutmgr/BlockLevelLayoutManager.java (-8 / +11 lines)
19		19
20	package org.apache.fop.layoutmgr;	20	package org.apache.fop.layoutmgr;
21		21
		22	import org.apache.fop.fo.properties.KeepProperty;
		23
22	/**	24	/**
23	* The interface for LayoutManagers which generate block areas	25	* The interface for LayoutManagers which generate block areas
24	*/	26	*/
Lines 35-54 Link Here
35	/** Adjustment class: adjustment for line height */	37	/** Adjustment class: adjustment for line height */
36	int LINE_HEIGHT_ADJUSTMENT = 3;	38	int LINE_HEIGHT_ADJUSTMENT = 3;
37		39
38	/** The integer value for "auto" keep strength */
39	int KEEP_AUTO = Integer.MIN_VALUE;
40	/** The integer value for "always" keep strength */
41	int KEEP_ALWAYS = Integer.MAX_VALUE;
42
43	int negotiateBPDAdjustment(int adj, KnuthElement lastElement);	40	int negotiateBPDAdjustment(int adj, KnuthElement lastElement);
44		41
45	void discardSpace(KnuthGlue spaceGlue);	42	void discardSpace(KnuthGlue spaceGlue);
46		43
		44	KeepProperty getKeepTogetherProperty();
		45
		46	KeepProperty getKeepWithPreviousProperty();
		47
		48	KeepProperty getKeepWithNextProperty();
		49
47	/**	50	/**
48	* Returns the keep-together strength for this element.	51	* Returns the keep-together strength for this element.
49	* @return the keep-together strength	52	* @return the keep-together strength
50	*/	53	*/
51	int getKeepTogetherStrength();	54	Keep getKeepTogether();
52		55
53	/**	56	/**
54	* @return true if this element must be kept together	57	* @return true if this element must be kept together
Lines 59-65 Link Here
59	* Returns the keep-with-previous strength for this element.	62	* Returns the keep-with-previous strength for this element.
60	* @return the keep-with-previous strength	63	* @return the keep-with-previous strength
61	*/	64	*/
62	int getKeepWithPreviousStrength();	65	Keep getKeepWithPrevious();
63		66
64	/**	67	/**
65	* @return true if this element must be kept with the previous element.	68	* @return true if this element must be kept with the previous element.
Lines 70-76 Link Here
70	* Returns the keep-with-next strength for this element.	73	* Returns the keep-with-next strength for this element.
71	* @return the keep-with-next strength	74	* @return the keep-with-next strength
72	*/	75	*/
73	int getKeepWithNextStrength();	76	Keep getKeepWithNext();
74		77
75	/**	78	/**
76	* @return true if this element must be kept with the next element.	79	* @return true if this element must be kept with the next element.




    private int breakBefore;
    private int breakAfter;

    private Keep pendingKeepWithNext = Keep.KEEP_AUTO;
    private Keep pendingKeepWithPrevious = Keep.KEEP_AUTO;

    private int disableColumnBalancing;


     * Returns the strength of a keep-with-next currently pending.
     * @return the keep-with-next strength
     */
    public Keep getKeepWithNextPending() {
        return this.pendingKeepWithNext;
    }


     * Returns the strength of a keep-with-previous currently pending.
     * @return the keep-with-previous strength
     */
    public Keep getKeepWithPreviousPending() {
        return this.pendingKeepWithPrevious;
    }


     * Clears any pending keep-with-next strength.
     */
    public void clearKeepWithNextPending() {
        this.pendingKeepWithNext = Keep.KEEP_AUTO;
    }

    /**
     * Clears any pending keep-with-previous strength.
     */
    public void clearKeepWithPreviousPending() {
        this.pendingKeepWithPrevious = Keep.KEEP_AUTO;
    }

    /**


    /**
     * Updates the currently pending keep-with-next strength.
     * @param keep the new strength to consider
     */
    public void updateKeepWithNextPending(Keep keep) {
        this.pendingKeepWithNext = this.pendingKeepWithNext.compare(keep);
    }

    /**
     * Updates the currently pending keep-with-previous strength.
     * @param keep the new strength to consider
     */
    public void updateKeepWithPreviousPending(Keep keep) {
        this.pendingKeepWithPrevious = this.pendingKeepWithPrevious.compare(keep);
    }

    /**

     * @return true if a keep-with-next constraint is pending
     */
    public boolean isKeepWithNextPending() {
        return !getKeepWithNextPending().isAuto();
    }

    /**

     * @return true if a keep-with-previous constraint is pending
     */
    public boolean isKeepWithPreviousPending() {
        return !getKeepWithPreviousPending().isAuto();
    }

    public void setLeadingSpace(SpaceSpecifier space) {

        + "\nStarts New Area: \t" + startsNewArea()
        + "\nIs Last Area: \t" + isLastArea()
        + "\nTry Hyphenate: \t" + tryHyphenate()
        + "\nKeeps: \t[keep-with-next=" + getKeepWithNextPending()
                + "][keep-with-previous=" + getKeepWithPreviousPending() + "] pending"
                + KeepUtil.keepStrengthToString(getKeepWithPreviousPending()) + "] pending"
        + "\nBreaks: \tforced [" + (breakBefore != Constants.EN_AUTO ? "break-before" : "") + "]["
        + (breakAfter != Constants.EN_AUTO ? "break-after" : "") + "]";
    }




/*
 * Licensed to the Apache Software Foundation (ASF) under one or more contributor license
 * agreements. See the NOTICE file distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file to You under the Apache
 * License, Version 2.0 (the "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under
 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 */

/* $Id$ */

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;

/**
 * TODO javadoc
 */
public class Keep {

    private static final int STRENGTH_AUTO = Integer.MIN_VALUE;

    private static final int STRENGTH_ALWAYS = Integer.MAX_VALUE;

    /** The integer value for "auto" keep strength. */
    public static final Keep KEEP_AUTO = new Keep(STRENGTH_AUTO, Constants.EN_AUTO);

    /** The integer value for "always" keep strength. */
    public static final Keep KEEP_ALWAYS = new Keep(STRENGTH_ALWAYS, Constants.EN_LINE);

    private int strength;

    private int context;

    private Keep(int strength, int context) {
        this.strength = strength;
        this.context = context;
    }

    private static int getKeepStrength(Property keep) {
        if (keep.isAuto()) {
            return STRENGTH_AUTO;
        } else if (keep.getEnum() == Constants.EN_ALWAYS) {
            return STRENGTH_ALWAYS;
        } else {
            return keep.getNumber().intValue();
        }
    }

    public static Keep getKeep(KeepProperty keepProperty) {
        Keep keep = new Keep(STRENGTH_AUTO, Constants.EN_AUTO);
        keep.update(keepProperty.getWithinPage(),   Constants.EN_PAGE);
        keep.update(keepProperty.getWithinColumn(), Constants.EN_COLUMN);
        keep.update(keepProperty.getWithinLine(),   Constants.EN_LINE);
        return keep;
    }

    private void update(Property keep, int context) {
        if (!keep.isAuto()) {
            this.strength = getKeepStrength(keep);
            this.context = context;
        }
    }

    public boolean isAuto() {
        return strength == STRENGTH_AUTO;
    }

    /**
     * Returns the context of this keep.
     *
     * @return one of {@link Constants#EN_LINE}, {@link Constants#EN_COLUMN} or
     * {@link Constants#EN_PAGE}
     */
    public int getContext() {
        return context;
    }

    public int getPenalty() {
        if (strength == STRENGTH_AUTO) {
            return 0;
        } else if (strength == STRENGTH_ALWAYS) {
            return KnuthElement.INFINITE;
        } else {
            return KnuthElement.INFINITE - 1;
        }
    }

    private static int getKeepContextPriority(int context) {
        switch (context) {
        case Constants.EN_LINE:   return 0;
        case Constants.EN_COLUMN: return 1;
        case Constants.EN_PAGE:   return 2;
        case Constants.EN_AUTO:   return 3;
        default: throw new IllegalArgumentException();
        }
    }

    public Keep compare(Keep other) {
        int pThis = getKeepContextPriority(this.context);
        int pOther = getKeepContextPriority(other.context);
        if (pThis < pOther) {
            return this;
        } else if (pThis > pOther) {
            return other;
        } else if (strength >= other.strength) {
            return this;
        } else {
            return other;
        }
    }

    /** {@inheritDoc} */
    public String toString() {
        if (strength == STRENGTH_AUTO) {
            return "auto";
        } else if (strength == STRENGTH_ALWAYS) {
            return "always";
        } else {
            return Integer.toString(strength);
        }
    }

}
  + Revision Id
  + native




import org.apache.fop.datatypes.Length;
import org.apache.fop.fo.flow.BlockContainer;
import org.apache.fop.fo.properties.CommonAbsolutePosition;
import org.apache.fop.fo.properties.KeepProperty;
import org.apache.fop.traits.MinOptMax;
import org.apache.fop.traits.SpaceVal;
import org.apache.fop.util.ListUtil;


        if (!firstVisibleMarkServed) {
            addKnuthElementsForSpaceBefore(returnList, alignment);
            context.updateKeepWithPreviousPending(getKeepWithPrevious());
        }

        addKnuthElementsForBorderPaddingBefore(returnList, !firstVisibleMarkServed);

        context.clearPendingMarks();
        addKnuthElementsForBreakAfter(returnList, context);

        context.updateKeepWithNextPending(getKeepWithNext());

        setFinished(true);
        return returnList;

    }

    /** {@inheritDoc} */
    public KeepProperty getKeepTogetherProperty() {
        return getBlockContainerFO().getKeepTogether();
                getBlockContainerFO().getKeepTogether());
        strength = Math.max(strength, getParentKeepTogetherStrength());
        return strength;
    }

    /** {@inheritDoc} */
    public KeepProperty getKeepWithPreviousProperty() {
        return getBlockContainerFO().getKeepWithPrevious();
                getBlockContainerFO().getKeepWithNext());
    }

    /** {@inheritDoc} */
    public KeepProperty getKeepWithNextProperty() {
        return getBlockContainerFO().getKeepWithNext();
                getBlockContainerFO().getKeepWithPrevious());
    }

    /**

Lines 41-49 Link Here

(-)src/java/org/apache/fop/layoutmgr/BreakElement.java (-1 / +16 lines)
41	* @param context the layout context which contains the pending conditional elements	41	* @param context the layout context which contains the pending conditional elements
42	*/	42	*/
43	public BreakElement(Position position, int penaltyValue, LayoutContext context) {	43	public BreakElement(Position position, int penaltyValue, LayoutContext context) {
44	this(position, 0, penaltyValue, -1, context);	44	this(position, penaltyValue, -1, context);
45	}	45	}
46		46
		47	public BreakElement(Position position, int penaltyValue, int breakClass, LayoutContext context) {
		48	this(position, 0, penaltyValue, breakClass, context);
		49	}
		50
47	/**	51	/**
48	* Constructor for hard breaks.	52	* Constructor for hard breaks.
49	*	53	*
Lines 168-173 Link Here
168	sb.append("; w:");	172	sb.append("; w:");
169	sb.append(penaltyWidth);	173	sb.append(penaltyWidth);
170	sb.append("]");	174	sb.append("]");
		175	switch (getBreakClass()) {
		176	case Constants.EN_PAGE:
		177	sb.append(" (page context)");
		178	break;
		179	case Constants.EN_COLUMN:
		180	sb.append(" (column context)");
		181	break;
		182	case Constants.EN_LINE:
		183	sb.append(" (line context)");
		184	break;
		185	}
171	return sb.toString();	186	return sb.toString();
172	}	187	}
173		188




            context.updateKeepWithNextPending(childLC.getKeepWithNextPending());
            childLC.clearKeepWithNextPending();

            context.updateKeepWithNextPending(getKeepWithNext());
        }

        SpaceResolver.resolveElementList(returnList);

    }

    /** {@inheritDoc} */
    public Keep getKeepTogether() {
        return Keep.KEEP_AUTO;
    }

    /** {@inheritDoc} */
    public Keep getKeepWithNext() {
        return Keep.KEEP_AUTO;
    }

    /** {@inheritDoc} */
    public Keep getKeepWithPrevious() {
        return Keep.KEEP_AUTO;
    }

    /** {@inheritDoc} */




    }

    /** {@inheritDoc} */
    public Keep getKeepTogether() {
        return getParentKeepTogether();
    }

    /** {@inheritDoc} */
    public Keep getKeepWithNext() {
        return Keep.KEEP_AUTO;
    }

    /** {@inheritDoc} */
    public Keep getKeepWithPrevious() {
        return Keep.KEEP_AUTO;
    }

}




    }

    /** {@inheritDoc} */
    public KeepProperty getKeepTogetherProperty() {
        return getBlockFO().getKeepTogether();
        int strength = KeepUtil.getCombinedBlockLevelKeepStrength(keep);
        strength = Math.max(strength, getParentKeepTogetherStrength());
        return strength;
    }

    /** {@inheritDoc} */
    public KeepProperty getKeepWithPreviousProperty() {
        return getBlockFO().getKeepWithPrevious();
    }

    /** {@inheritDoc} */
    public KeepProperty getKeepWithNextProperty() {
        return getBlockFO().getKeepWithNext();
    }

    /** {@inheritDoc} */





import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.apache.fop.fo.Constants;
import org.apache.fop.fo.FObj;
import org.apache.fop.layoutmgr.AbstractBreaker.PageBreakPosition;

        footnoteElementIndex = -1;
    }

    private boolean deferred = false;
    private boolean overridePageKeep = false;

    protected KnuthNode recoverFromTooLong(KnuthNode lastTooLong) {
        if (log.isDebugEnabled()) {
            log.debug("Recovering from too long: " + lastTooLong);
        }
        KnuthNode node = lastTooLong.previous;
        if (!deferred) {
            deferred = true;
            while (!pageProvider.startPage(lastTooLong.line - 1)) {
                lastTooLong = lastTooLong.previous;
            }
            node = lastTooLong.previous;
            // content would overflow, insert empty line/page and try again
            for (int i = 0; i < pageProvider.getColumnCount(lastTooLong.previous.line); i++) {
                node = createNode(
                        node.position, node.line + 1, 1,
                        0, 0, 0,
                        0, 0, 0,
                        0, 0, node);
            }
//        } else {
//            overridePageKeep = true;
        }
        return node;
    }

    protected KnuthNode createNode(int position, int line, int fitness,
                                   int totalWidth, int totalStretch, int totalShrink,
                                   double adjustRatio, int availableShrink, int availableStretch,

        newFootnotes = false;
    }

    protected boolean elementCanEndLine(KnuthElement element, int line) {
        if (!(element instanceof KnuthPenalty) || pageProvider == null) {
            return true;
        } else {
            KnuthPenalty p = (KnuthPenalty) element;
            if (p.getP() <= 0) {
                return true;
            } else {
                int context = p.getBreakClass();
                switch (context) {
                case Constants.EN_LINE:
                case Constants.EN_COLUMN:
                    return p.getP() < KnuthPenalty.INFINITE;
                case Constants.EN_PAGE:
                    return p.getP() < KnuthPenalty.INFINITE || overridePageKeep
                            || !pageProvider.endPage(line - 1);
                case Constants.EN_AUTO:
                    log.warn("keep is not auto but context is");
                    return true;
                default:
                    if (p.getP() < KnuthPenalty.INFINITE) {
                        log.warn("Non recognized keep context:" + context);
                        return true;
                    } else {
                        return false;
                    }
                }
            }
        }
    }

    protected int computeDifference(KnuthNode activeNode, KnuthElement element,
                                    int elementIndex) {
        KnuthPageNode pageNode = (KnuthPageNode) activeNode;

                        splitLength += element.getW();
                    } else {
                        // element is a penalty
//                        if (element.getP() < KnuthElement.INFINITE) {
                            // end of the sub-sequence
                            index = noteListIterator.previousIndex();
                            break;
//                        }
                    }
                }
            }

        double f = Math.abs(r);
        f = 1 + 100 * f * f * f;
        if (element.isPenalty() && element.getP() >= 0) {
            if (element.getP() < KnuthPenalty.INFINITE) {
                f += element.getP();
            }
            demerits = f * f;
        } else if (element.isPenalty() && !element.isForcedBreak()) {
            double penalty = element.getP();




        return this.lastReportedBPD;
    }

    // Wish there were a more elegant way to do this in Java
    private int[] getColIndexAndColCount(int index) {
        int columnCount = 0;
        int colIndex = startColumnOfCurrentElementList + index;
        int pageIndex = -1;
        do {
            colIndex -= columnCount;
            pageIndex++;
            Page page = getPage(false, pageIndex, RELTO_CURRENT_ELEMENT_LIST);
            columnCount = page.getPageViewport().getCurrentSpan().getColumnCount();
        } while (colIndex >= columnCount);
        return new int[] {colIndex, columnCount};
    }

    boolean startPage(int index) {
        return getColIndexAndColCount(index)[0] == 0;
    }

    boolean endPage(int index) {
        int[] colIndexAndColCount = getColIndexAndColCount(index);
        return colIndexAndColCount[0] == colIndexAndColCount[1] - 1;
    }

    int getColumnCount(int index) {
        return getColIndexAndColCount(index)[1];
    }

    /**
     * Returns the part index (0<x<partCount) which denotes the first part on the last page
     * generated by the current element list.




import org.apache.fop.area.Area;
import org.apache.fop.area.Block;
import org.apache.fop.fo.flow.ListBlock;
import org.apache.fop.fo.properties.KeepProperty;
import org.apache.fop.layoutmgr.BlockStackingLayoutManager;
import org.apache.fop.layoutmgr.ConditionalElementListener;
import org.apache.fop.layoutmgr.ElementListUtils;
import org.apache.fop.layoutmgr.KeepUtil;
import org.apache.fop.layoutmgr.LayoutContext;
import org.apache.fop.layoutmgr.LayoutManager;
import org.apache.fop.layoutmgr.NonLeafPosition;

    }

    /** {@inheritDoc} */
    public KeepProperty getKeepTogetherProperty() {
        return getListBlockFO().getKeepTogether();
                getListBlockFO().getKeepTogether());
        strength = Math.max(strength, getParentKeepTogetherStrength());
        return strength;
    }

    /** {@inheritDoc} */
    public KeepProperty getKeepWithPreviousProperty() {
        return getListBlockFO().getKeepWithPrevious();
    }

    /** {@inheritDoc} */
    public KeepProperty getKeepWithNextProperty() {
        return getListBlockFO().getKeepWithNext();
    }

    /** {@inheritDoc} */




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.fo.properties.KeepProperty;
import org.apache.fop.layoutmgr.BlockStackingLayoutManager;
import org.apache.fop.layoutmgr.BreakElement;
import org.apache.fop.layoutmgr.ConditionalElementListener;
import org.apache.fop.layoutmgr.ElementListObserver;
import org.apache.fop.layoutmgr.ElementListUtils;
import org.apache.fop.layoutmgr.Keep;
import org.apache.fop.layoutmgr.KnuthBlockBox;
import org.apache.fop.layoutmgr.KnuthBox;
import org.apache.fop.layoutmgr.KnuthElement;

    private MinOptMax effSpaceBefore;
    private MinOptMax effSpaceAfter;

    private Keep keepWithNextPendingOnLabel;
    private Keep keepWithNextPendingOnBody;

    private int listItemHeight;



        context.updateKeepWithNextPending(this.keepWithNextPendingOnLabel);
        context.updateKeepWithNextPending(this.keepWithNextPendingOnBody);
        context.updateKeepWithNextPending(getKeepWithNext());
        context.updateKeepWithPreviousPending(getKeepWithPrevious());

        setFinished(true);
        resetSpaces();

        int totalHeight = Math.max(fullHeights[0], fullHeights[1]);
        int step;
        int addedBoxHeight = 0;
        Keep keepWithNextActive = Keep.KEEP_AUTO;

        LinkedList returnList = new LinkedList();
        while ((step = getNextStep(elementLists, start, end, partialHeights)) > 0) {

            if (end[0] + 1 == elementLists[0].size()) {
                keepWithNextActive = keepWithNextActive.compare(keepWithNextPendingOnLabel);
            }
            if (end[1] + 1 == elementLists[1].size()) {
                keepWithNextActive = keepWithNextActive.compare(keepWithNextPendingOnBody);
            }

            // compute penalty height and box height

            }

            if (addedBoxHeight < totalHeight) {
                Keep keep = keepWithNextActive.compare(getKeepTogether());
                strength = Math.max(strength, keepWithNextActive);
                strength = Math.max(strength, getKeepTogetherStrength());
                int p = stepPenalty;
                if (p > -KnuthElement.INFINITE) {
                    p = Math.max(p, keep.getPenalty());
                }
                returnList.add(new BreakElement(stepPosition, penaltyHeight, p, keep.getContext(),
                        context));
            }
        }


    }

    /** {@inheritDoc} */
    public KeepProperty getKeepTogetherProperty() {
        return getListItemFO().getKeepTogether();
                getListItemFO().getKeepTogether());
        strength = Math.max(strength, getParentKeepTogetherStrength());
        return strength;
    }

    /** {@inheritDoc} */
    public KeepProperty getKeepWithPreviousProperty() {
        return getListItemFO().getKeepWithPrevious();
    }

    /** {@inheritDoc} */
    public KeepProperty getKeepWithNextProperty() {
        return getListItemFO().getKeepWithNext();
    }

    /** {@inheritDoc} */




import org.apache.fop.fo.flow.AbstractListItemPart;
import org.apache.fop.fo.flow.ListItemBody;
import org.apache.fop.fo.flow.ListItemLabel;
import org.apache.fop.fo.properties.KeepProperty;
import org.apache.fop.layoutmgr.BlockStackingLayoutManager;
import org.apache.fop.layoutmgr.Keep;
import org.apache.fop.layoutmgr.LayoutContext;
import org.apache.fop.layoutmgr.LayoutManager;
import org.apache.fop.layoutmgr.NonLeafPosition;

    }

    /** {@inheritDoc} */
    public KeepProperty getKeepTogetherProperty() {
        return getPartFO().getKeepTogether();
        strength = Math.max(strength, getParentKeepTogetherStrength());
        return strength;
    }

    /** {@inheritDoc} */
    public Keep getKeepWithNext() {
        return Keep.KEEP_AUTO;
    }

    /** {@inheritDoc} */
    public Keep getKeepWithPrevious() {
        return Keep.KEEP_AUTO;
    }

}





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.Keep;
import org.apache.fop.layoutmgr.KnuthBlockBox;
import org.apache.fop.layoutmgr.KnuthBox;
import org.apache.fop.layoutmgr.KnuthElement;

    /** True if the next CellPart that will be created will be the last one for this cell. */
    private boolean lastCellPart;

    private Keep keepWithNext;

    private int spanIndex = 0;


        includedLength = -1;  // Avoid troubles with cells having content of zero length
        totalLength = previousRowsLength + ElementListUtils.calcContentLength(elementList);
        endRowIndex = rowIndex + pgu.getCell().getNumberRowsSpanned() - 1;
        keepWithNext = Keep.KEEP_AUTO;
        remainingLength = totalLength - previousRowsLength;

        afterNextStep = new Step(previousRowsLength);

            KnuthElement el = (KnuthElement) knuthIter.next();
            if (el.isPenalty()) {
                prevIsBox = false;
                if (el.getP() < KnuthElement.INFINITE
                        || ((KnuthPenalty) el).getBreakClass() == Constants.EN_PAGE) {
                    // TODO too much is being done in that test, only to handle
                    // keep.within-column properly.

                    // First legal break point
                    breakFound = true;
                    KnuthPenalty p = (KnuthPenalty) el;

     */
    CellPart createCellPart() {
        if (nextStep.end + 1 == elementList.size()) {
            keepWithNext = pgu.getKeepWithNext();
            // 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/

        }
    }

    Keep getKeepWithNext() {
        return keepWithNext;
    }

    int getPenaltyValue() {




import org.apache.fop.fo.flow.table.PrimaryGridUnit;
import org.apache.fop.fo.flow.table.Table;
import org.apache.fop.fo.flow.table.TablePart;
import org.apache.fop.layoutmgr.BlockLevelLayoutManager;
import org.apache.fop.layoutmgr.BreakElement;
import org.apache.fop.layoutmgr.ElementListUtils;
import org.apache.fop.layoutmgr.Keep;
import org.apache.fop.layoutmgr.KnuthBox;
import org.apache.fop.layoutmgr.KnuthElement;
import org.apache.fop.layoutmgr.KnuthGlue;

        context.clearKeepsPending();
        context.setBreakBefore(Constants.EN_AUTO);
        context.setBreakAfter(Constants.EN_AUTO);
        Keep keepWithPrevious = Keep.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 = keepWithPrevious.compare(context.getKeepWithPreviousPending());
            breakBefore = context.getBreakBefore();
            int breakBetween = context.getBreakAfter();
            returnList.addAll(nextRowGroupElems);


                //Note previous pending keep-with-next and clear the strength
                //(as the layout context is reused)
                Keep keepWithNextPending = context.getKeepWithNextPending();
                context.clearKeepWithNextPending();

                //Get elements for next row group

                 */

                //Determine keep constraints
                Keep keep = keepWithNextPending.compare(context.getKeepWithPreviousPending());
                penaltyStrength = Math.max(penaltyStrength, keepWithNextPending);
                penaltyStrength = Math.max(penaltyStrength, context.getKeepWithPreviousPending());
                context.clearKeepWithPreviousPending();
                keep = keep.compare(getTableLM().getKeepTogether());
                int penaltyValue = keep.getPenalty();
                int breakClass = keep.getContext();

                breakBetween = BreakUtil.compareBreakClasses(breakBetween,
                        context.getBreakBefore());
                if (breakBetween != Constants.EN_AUTO) {
                    penaltyValue = -KnuthElement.INFINITE;
                    breakClass = breakBetween;
                }
                BreakElement breakElement;
                ListIterator elemIter = returnList.listIterator(returnList.size());

                    breakElement = (BreakElement) elem;
                }
                breakElement.setPenaltyValue(penaltyValue);
                breakElement.setBreakClass(breakClass);
                returnList.addAll(nextRowGroupElems);
                breakBetween = context.getBreakAfter();
            }

Lines 60-67 Link Here

(-)src/java/org/apache/fop/layoutmgr/table/RowGroupLayoutManager.java (-2 / +2 lines)
60	LinkedList returnList = new LinkedList();	60	LinkedList returnList = new LinkedList();
61	createElementsForRowGroup(context, alignment, bodyType, returnList);	61	createElementsForRowGroup(context, alignment, bodyType, returnList);
62		62
63	context.updateKeepWithPreviousPending(rowGroup[0].getKeepWithPreviousStrength());	63	context.updateKeepWithPreviousPending(rowGroup[0].getKeepWithPrevious());
64	context.updateKeepWithNextPending(rowGroup[rowGroup.length - 1].getKeepWithNextStrength());	64	context.updateKeepWithNextPending(rowGroup[rowGroup.length - 1].getKeepWithNext());
65		65
66	int breakBefore = Constants.EN_AUTO;	66	int breakBefore = Constants.EN_AUTO;
67	TableRow firstRow = rowGroup[0].getTableRow();	67	TableRow firstRow = rowGroup[0].getTableRow();




import org.apache.fop.fo.FObj;
import org.apache.fop.fo.flow.table.Table;
import org.apache.fop.fo.flow.table.TableColumn;
import org.apache.fop.fo.properties.KeepProperty;
import org.apache.fop.layoutmgr.BlockLevelEventProducer;
import org.apache.fop.layoutmgr.BlockStackingLayoutManager;
import org.apache.fop.layoutmgr.BreakElement;
import org.apache.fop.layoutmgr.ConditionalElementListener;
import org.apache.fop.layoutmgr.KeepUtil;
import org.apache.fop.layoutmgr.KnuthElement;
import org.apache.fop.layoutmgr.KnuthGlue;
import org.apache.fop.layoutmgr.LayoutContext;

        log.debug(contentKnuthElements);
        wrapPositionElements(contentKnuthElements, returnList);

        context.updateKeepWithPreviousPending(getKeepWithPrevious());
        context.updateKeepWithPreviousPending(childLC.getKeepWithPreviousPending());

        context.updateKeepWithNextPending(getKeepWithNext());
        context.updateKeepWithNextPending(childLC.getKeepWithNextPending());

        if (getTable().isSeparateBorderModel()) {

    }

    /** {@inheritDoc} */
    public KeepProperty getKeepTogetherProperty() {
        return getTable().getKeepTogether();
        strength = Math.max(strength, getParentKeepTogetherStrength());
        return strength;
    }

    /** {@inheritDoc} */
    public KeepProperty getKeepWithPreviousProperty() {
        return getTable().getKeepWithPrevious();
    }

    /** {@inheritDoc} */
    public KeepProperty getKeepWithNextProperty() {
        return getTable().getKeepWithNext();
    }

    // --------- Property Resolution related functions --------- //





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.Trait;

import org.apache.fop.fo.flow.table.GridUnit;
import org.apache.fop.fo.flow.table.PrimaryGridUnit;
import org.apache.fop.fo.flow.table.Table;
import org.apache.fop.fo.flow.table.TablePart;
import org.apache.fop.fo.flow.table.TableCell;
import org.apache.fop.fo.flow.table.TableColumn;
import org.apache.fop.fo.flow.table.TablePart;
import org.apache.fop.fo.flow.table.TableRow;
import org.apache.fop.fo.properties.CommonBorderPaddingBackground;
import org.apache.fop.fo.properties.CommonBorderPaddingBackground.BorderInfo;
import org.apache.fop.layoutmgr.AreaAdditionUtil;
import org.apache.fop.layoutmgr.BlockLevelLayoutManager;
import org.apache.fop.layoutmgr.BlockStackingLayoutManager;
import org.apache.fop.layoutmgr.Keep;
import org.apache.fop.layoutmgr.KnuthBox;
import org.apache.fop.layoutmgr.KnuthElement;
import org.apache.fop.layoutmgr.KnuthGlue;

                log.debug("child LM signals pending keep with next");
            }
            if (contentList.isEmpty() && childLC.isKeepWithPreviousPending()) {
                primaryGridUnit.setKeepWithPrevious(childLC.getKeepWithPreviousPending());
                childLC.clearKeepWithPreviousPending();
            }


            }
            prevLM = curLM;
        }
        primaryGridUnit.setKeepWithNext(context.getKeepWithNextPending());

        returnedList = new LinkedList();
        if (!contentList.isEmpty()) {

    }

    /** {@inheritDoc} */
    public Keep getKeepTogether() {
        Keep keep = Keep.KEEP_AUTO;
        if (primaryGridUnit.getRow() != null) {
            keep = Keep.getKeep(primaryGridUnit.getRow().getKeepTogether());
                    primaryGridUnit.getRow().getKeepTogether().getWithinPage()));
            strength = Math.max(strength, KeepUtil.getKeepStrength(
                    primaryGridUnit.getRow().getKeepTogether().getWithinColumn()));
        }
        keep = keep.compare(getParentKeepTogether());
        return keep;
    }

    /** {@inheritDoc} */
    public Keep getKeepWithNext() {
        return Keep.KEEP_AUTO; //TODO FIX ME (table-cell has no keep-with-next!)
    }

    /** {@inheritDoc} */
    public Keep getKeepWithPrevious() {
        return Keep.KEEP_AUTO; //TODO FIX ME (table-cell has no keep-with-previous!)
    }

    // --------- Property Resolution related functions --------- //




import org.apache.fop.area.Block;
import org.apache.fop.fo.flow.table.TableAndCaption;
import org.apache.fop.layoutmgr.BlockStackingLayoutManager;
import org.apache.fop.layoutmgr.Keep;
import org.apache.fop.layoutmgr.LayoutContext;
import org.apache.fop.layoutmgr.PositionIterator;


    }

    /** {@inheritDoc} */
    public Keep getKeepWithNext() {
        return Keep.KEEP_AUTO;
        /* TODO Complete me!
        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 Keep getKeepWithPrevious() {
        return Keep.KEEP_AUTO;
        /* TODO Complete me!
        return KeepUtil.getCombinedBlockLevelKeepStrength(
                getTableAndCaptionFO().getKeepWithPrevious());




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.Keep;
import org.apache.fop.layoutmgr.KnuthBlockBox;
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;

                }
            }

            Keep keep = Keep.KEEP_AUTO;
            int stepPenalty = 0;
            for (Iterator iter = activeCells.iterator(); iter.hasNext();) {
                ActiveCell activeCell = (ActiveCell) iter.next();
                keep = keep.compare(activeCell.getKeepWithNext());
                stepPenalty = Math.max(stepPenalty, activeCell.getPenaltyValue());
            }
            if (!rowFinished) {
                keep = keep.compare(rowGroup[activeRowIndex].getKeepTogether());
                //The above call doesn't take the penalty from the table into account, so...
                keep = keep.compare(getTableLM().getKeepTogether());
            } else if (activeRowIndex < rowGroup.length - 1) {
                keep = keep.compare(rowGroup[activeRowIndex].getKeepWithNext());
                keep = keep.compare(rowGroup[activeRowIndex + 1].getKeepWithPrevious());
                strength = Math.max(strength,
                        rowGroup[activeRowIndex + 1].getKeepWithPreviousStrength());
                nextBreakClass = BreakUtil.compareBreakClasses(nextBreakClass,
                        rowGroup[activeRowIndex].getBreakAfter());
                nextBreakClass = BreakUtil.compareBreakClasses(nextBreakClass,
                        rowGroup[activeRowIndex + 1].getBreakBefore());
            }
            int p = keep.getPenalty();
            if (rowHeightSmallerThanFirstStep) {
                rowHeightSmallerThanFirstStep = false;
                p = KnuthPenalty.INFINITE;
            }
            p = Math.max(p, stepPenalty);
            int breakClass = keep.getContext();
            }
            if (nextBreakClass != Constants.EN_AUTO) {
                log.trace("Forced break encountered");
                p = -KnuthPenalty.INFINITE; //Overrides any keeps (see 4.8 in XSL 1.0)
                breakClass = nextBreakClass;
            }
            returnList.add(new BreakElement(penaltyPos, effPenaltyLen, p, breakClass, context));
            if (penaltyOrGlueLen < 0) {
                returnList.add(new KnuthGlue(-penaltyOrGlueLen, 0, 0, new Position(null), true));
            }




import org.apache.fop.area.Block;
import org.apache.fop.fo.flow.table.TableCaption;
import org.apache.fop.layoutmgr.BlockStackingLayoutManager;
import org.apache.fop.layoutmgr.Keep;
import org.apache.fop.layoutmgr.LayoutContext;
import org.apache.fop.layoutmgr.PositionIterator;


    }

    /** {@inheritDoc} */
    public Keep getKeepWithNext() {
        return Keep.KEEP_AUTO;
        /* TODO Complete me!
        strength = Math.max(strength, KeepUtil.getKeepStrength(
                getTableCaptionFO().getKeepTogether().getWithinPage()));
        strength = Math.max(strength, KeepUtil.getKeepStrength(
                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 Keep getKeepWithPrevious() {
        return Keep.KEEP_AUTO;
        /* TODO Complete me!
        return KeepUtil.getCombinedBlockLevelKeepStrength(
                getTableCaptionFO().getKeepWithPrevious());




import org.apache.fop.fo.FObj;
import org.apache.fop.fo.properties.BreakPropertySet;
import org.apache.fop.fo.properties.CommonBorderPaddingBackground;
import org.apache.fop.fo.properties.KeepProperty;
import org.apache.fop.fo.properties.SpaceProperty;
import org.apache.fop.layoutmgr.inline.InlineLayoutManager;
import org.apache.fop.layoutmgr.inline.LineLayoutManager;


        if (!firstVisibleMarkServed) {
            addKnuthElementsForSpaceBefore(returnList, alignment);
            context.updateKeepWithPreviousPending(getKeepWithPrevious());
        }

        addKnuthElementsForBorderPaddingBefore(returnList, !firstVisibleMarkServed);

            returnList.add(forcedBreakAfterLast);
        }

        context.updateKeepWithNextPending(getKeepWithNext());

        setFinished(true);


                || context.isKeepWithNextPending()
                || childLC.isKeepWithPreviousPending()) {

            Keep keep = getKeepTogether();

            //Handle pending keep-with-next
            keep = keep.compare(context.getKeepWithNextPending());
            context.clearKeepWithNextPending();

            //Handle pending keep-with-previous from child LM
            keep = keep.compare(childLC.getKeepWithPreviousPending());
            childLC.clearKeepWithPreviousPending();

            int penalty = keep.getPenalty();

            // add a penalty to forbid or discourage a break between blocks
            contentList.add(new BreakElement(
                    new Position(this), penalty, keep.getContext(), context));
            return;
        }


     * Retrieves and returns the keep-together strength from the parent element.
     * @return the keep-together strength
     */
    protected Keep getParentKeepTogether() {
        Keep keep = Keep.KEEP_AUTO;
        if (getParent() instanceof BlockLevelLayoutManager) {
            keep = ((BlockLevelLayoutManager)getParent()).getKeepTogether();
        } else if (getParent() instanceof InlineLayoutManager) {
            if (((InlineLayoutManager) getParent()).mustKeepTogether()) {
                keep = Keep.KEEP_ALWAYS;
            }
            //TODO Fix me
            //strength = ((InlineLayoutManager) getParent()).getKeepTogetherStrength();
        }
        return keep;
    }

    /** {@inheritDoc} */
    public boolean mustKeepTogether() {
        return !getKeepTogether().isAuto();
    }

    /** {@inheritDoc} */
    public boolean mustKeepWithPrevious() {
        return !getKeepWithPrevious().isAuto();
    }

    /** {@inheritDoc} */
    public boolean mustKeepWithNext() {
        return !getKeepWithNext().isAuto();
    }

    public KeepProperty getKeepTogetherProperty() {
        throw new IllegalStateException();
    }

    public KeepProperty getKeepWithPreviousProperty() {
        throw new IllegalStateException();
    }

    public KeepProperty getKeepWithNextProperty() {
        throw new IllegalStateException();
    }

    /** {@inheritDoc} */
    public Keep getKeepTogether() {
        Keep keep = Keep.getKeep(getKeepTogetherProperty());
        keep = keep.compare(getParentKeepTogether());
        return keep;
    }

    /** {@inheritDoc} */
    public Keep getKeepWithPrevious() {
        return Keep.getKeep(getKeepWithPreviousProperty());
    }

    /** {@inheritDoc} */
    public Keep getKeepWithNext() {
        return Keep.getKeep(getKeepWithNextProperty());
    }

    /**
     * Adds the unresolved elements for border and padding to a layout context so break
     * possibilities can be properly constructed.




import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.apache.fop.fo.Constants;
import org.apache.fop.fo.FONode;

/**


        if (log.isTraceEnabled()) {
            log.trace("Looping over " + (par.size() - startIndex) + " elements");
            log.trace(par);
        }

        KnuthNode lastForced = getNode(0);

                // only if its penalty is not infinite;
                // consider all penalties, non-flagged penalties or non-forcing penalties
                // according to the value of allowedBreaks
                KnuthPenalty p = (KnuthPenalty) thisElement;
                if (((p.getP() < KnuthElement.INFINITE || p.getBreakClass() != Constants.EN_LINE)
                        && (!(allowedBreaks == NO_FLAGGED_PENALTIES) || !p.isFlagged())
                        && (!(allowedBreaks == ONLY_FORCED_BREAKS)
                                || p.isForcedBreak()))) {
                    considerLegalBreak(thisElement, i);
                }
                previousIsBox = false;

                // were "bad" breaks since the beginning;
                // if it is not the node we just restarted from, lastDeactivated can
                // replace either lastTooShort or lastTooLong
                // TODO re-enable and make it work with keep.within-column
//                if (lastDeactivated != null && lastDeactivated != lastForced) {
//                    if (lastDeactivated.adjustRatio > 0) {
//                        lastTooShort = lastDeactivated;
//                    } else {
//                        lastTooLong = lastDeactivated;
//                    }
//                }
                if (lastTooShort == null || lastForced.position == lastTooShort.position) {
                    if (isPartOverflowRecoveryActivated()) {
                        if (this.lastRecovered == null) {

                                log.debug("Recovery point: " + lastRecovered);
                            }
                        }
                        KnuthNode node = recoverFromTooLong(lastTooLong);
                        KnuthNode node = createNode(
                                lastTooLong.previous.position, lastTooLong.previous.line + 1, 1,
                                0, 0, 0,
                                0, 0, 0,
                                0, 0, lastTooLong.previous);
                        lastForced = node;
                        node.fitRecoveryCounter = lastTooLong.previous.fitRecoveryCounter + 1;
                        if (log.isDebugEnabled()) {

        return line;
    }

    protected KnuthNode recoverFromTooLong(KnuthNode lastTooLong) {
        // content would overflow, insert empty line/page and try again
        KnuthNode node = createNode(
                lastTooLong.previous.position, lastTooLong.previous.line + 1, 1,
                0, 0, 0,
                0, 0, 0,
                0, 0, lastTooLong.previous);
        return node;
    }

    /**
     * This method tries to find the context FO for a position in a KnuthSequence.
     * @param seq the KnuthSequence to inspect

        lastDeactivated = null;
        lastTooLong = null;
        for (int line = startLine; line < endLine; line++) {
            if (!elementCanEndLine(element, line + 1)) {
                continue;
            }
            for (KnuthNode node = getNode(line); node != null; node = node.next) {
                if (node.position == elementIdx) {
                    continue;

                    }

                    if (r <= -1) {
                        log.debug("Considering tooLong, demerits=" + demerits);
                        if (lastTooLong == null || demerits < lastTooLong.totalDemerits) {
                            lastTooLong = createNode(elementIdx, line + 1, fitnessClass,
                                    newWidth, newStretch, newShrink,

        }
    }

    protected boolean elementCanEndLine(KnuthElement element, int line) {
        return !(element instanceof KnuthPenalty)
                || ((KnuthPenalty) element).getP() < KnuthPenalty.INFINITE;
    }

    /**
     * Adds new active nodes for breaks at the given element.
     * @param line number of the previous line; this element will end line number (line+1)




import java.util.List;

import org.apache.fop.fo.Constants;
import org.apache.fop.layoutmgr.Keep;
import org.apache.fop.layoutmgr.KeepUtil;
import org.apache.fop.layoutmgr.table.TableRowIterator;
import org.apache.fop.traits.MinOptMax;
import org.apache.fop.util.BreakUtil;

     *
     * @return the strength of the keep-with-previous constraint
     */
    public Keep getKeepWithPrevious() {
        Keep keep = Keep.KEEP_AUTO;
        TableRow row = getTableRow();
        if (row != null) {
            keep = Keep.getKeep(row.getKeepWithPrevious());
                    KeepUtil.getCombinedBlockLevelKeepStrength(row.getKeepWithPrevious()));
        }
        for (Iterator iter = gridUnits.iterator(); iter.hasNext();) {
            GridUnit gu = (GridUnit) iter.next();
            if (gu.isPrimary()) {
                keep = keep.compare(gu.getPrimary().getKeepWithPrevious());
            }
        }
        return keep;
    }

    /**

     *
     * @return the strength of the keep-with-next constraint
     */
    public Keep getKeepWithNext() {
        Keep keep = Keep.KEEP_AUTO;
        TableRow row = getTableRow();
        if (row != null) {
            keep = Keep.getKeep(row.getKeepWithNext());
                    KeepUtil.getCombinedBlockLevelKeepStrength(row.getKeepWithNext()));
        }
        for (Iterator iter = gridUnits.iterator(); iter.hasNext();) {
            GridUnit gu = (GridUnit) iter.next();
            if (!gu.isEmpty() && gu.getColSpanIndex() == 0 && gu.isLastGridUnitRowSpan()) {
                keep = keep.compare(gu.getPrimary().getKeepWithNext());
            }
        }
        return keep;
    }

    /**

     * not take the parent table's keeps into account!
     * @return the keep-together strength
     */
    public Keep getKeepTogether() {
        TableRow row = getTableRow();
        Keep keep = Keep.KEEP_AUTO;
        if (row != null) {
            keep = Keep.getKeep(row.getKeepTogether());
                    row.getKeepTogether().getWithinPage()));
            strength = Math.max(strength, KeepUtil.getKeepStrength(
                    row.getKeepTogether().getWithinColumn()));
        }
        return keep;
    }

    /**





package org.apache.fop.fo.flow.table;

import java.util.LinkedList;
import java.util.List;

import org.apache.fop.fo.Constants;
import org.apache.fop.fo.FONode;
import org.apache.fop.fo.properties.CommonBorderPaddingBackground;
import org.apache.fop.layoutmgr.BlockLevelLayoutManager;
import org.apache.fop.layoutmgr.ElementListUtils;
import org.apache.fop.layoutmgr.Keep;
import org.apache.fop.layoutmgr.table.TableCellLayoutManager;

/**

    private boolean isSeparateBorderModel;
    private int halfBorderSeparationBPD;

    private Keep keepWithPrevious = Keep.KEEP_AUTO;
    private Keep keepWithNext = Keep.KEEP_AUTO;
    private int breakBefore = Constants.EN_AUTO;
    private int breakAfter = Constants.EN_AUTO;


     *
     * @return the keep-with-previous strength
     */
    public Keep getKeepWithPrevious() {
        return keepWithPrevious;
    }

    /**
     * Don't use, reserved for TableCellLM. TODO
     * @param keep the keep strength
     */
    public void setKeepWithPrevious(Keep keep) {
        this.keepWithPrevious = keep;
    }

    /**

     *
     * @return the keep-with-next strength
     */
    public Keep getKeepWithNext() {
        return keepWithNext;
    }

    /**
     * Don't use, reserved for TableCellLM. TODO
     * @param keep the keep strength
     */
    public void setKeepWithNext(Keep keep) {
        this.keepWithNext = keep;
    }

    /**

Return to bug 46905

Lines 415-432 Link Here

(-)src/java/org/apache/fop/layoutmgr/StaticContentLayoutManager.java (-6 / +6 lines)
415	}	415	}
416		416
417	/** {@inheritDoc} */	417	/** {@inheritDoc} */
418	public int getKeepTogetherStrength() {	418	public Keep getKeepTogether() {
419	return KEEP_AUTO;	419	return Keep.KEEP_AUTO;
420	}	420	}
421		421
422	/** {@inheritDoc} */	422	/** {@inheritDoc} */
423	public int getKeepWithNextStrength() {	423	public Keep getKeepWithNext() {
424	return KEEP_AUTO;	424	return Keep.KEEP_AUTO;
425	}	425	}
426		426
427	/** {@inheritDoc} */	427	/** {@inheritDoc} */
428	public int getKeepWithPreviousStrength() {	428	public Keep getKeepWithPrevious() {
429	return KEEP_AUTO;	429	return Keep.KEEP_AUTO;
430	}	430	}
431		431
432	}	432	}

Lines 36-41 Link Here

(-)src/java/org/apache/fop/layoutmgr/inline/LineLayoutManager.java (-19 / +35 lines)
36	import org.apache.fop.fo.Constants;	36	import org.apache.fop.fo.Constants;
37	import org.apache.fop.fo.flow.Block;	37	import org.apache.fop.fo.flow.Block;
38	import org.apache.fop.fo.properties.CommonHyphenation;	38	import org.apache.fop.fo.properties.CommonHyphenation;
		39	import org.apache.fop.fo.properties.KeepProperty;
39	import org.apache.fop.fonts.Font;	40	import org.apache.fop.fonts.Font;
40	import org.apache.fop.fonts.FontInfo;	41	import org.apache.fop.fonts.FontInfo;
41	import org.apache.fop.fonts.FontTriplet;	42	import org.apache.fop.fonts.FontTriplet;
Lines 46-52 Link Here
46	import org.apache.fop.layoutmgr.BreakingAlgorithm;	47	import org.apache.fop.layoutmgr.BreakingAlgorithm;
47	import org.apache.fop.layoutmgr.ElementListObserver;	48	import org.apache.fop.layoutmgr.ElementListObserver;
48	import org.apache.fop.layoutmgr.InlineKnuthSequence;	49	import org.apache.fop.layoutmgr.InlineKnuthSequence;
49	import org.apache.fop.layoutmgr.KeepUtil;	50	import org.apache.fop.layoutmgr.Keep;
50	import org.apache.fop.layoutmgr.KnuthBlockBox;	51	import org.apache.fop.layoutmgr.KnuthBlockBox;
51	import org.apache.fop.layoutmgr.KnuthBox;	52	import org.apache.fop.layoutmgr.KnuthBox;
52	import org.apache.fop.layoutmgr.KnuthElement;	53	import org.apache.fop.layoutmgr.KnuthElement;
Lines 1054-1065 Link Here
1054	for (int p = 0; p < knuthParagraphs.size(); p++) {	1055	for (int p = 0; p < knuthParagraphs.size(); p++) {
1055	// penalty between paragraphs	1056	// penalty between paragraphs
1056	if (p > 0) {	1057	if (p > 0) {
1057	int strength = getKeepTogetherStrength();	1058	Keep keep = getKeepTogether();
1058	int penalty = KeepUtil.getPenaltyForKeep(strength);	1059	int penalty = keep.getPenalty();
1059	if (penalty < KnuthElement.INFINITE) {	1060	// if (penalty < KnuthElement.INFINITE) {
1060	returnList.add(new BreakElement(	1061	returnList.add(new BreakElement(
1061	new Position(this), penalty, context));	1062	new Position(this), penalty, keep.getContext(), context));
1062	}	1063	// }
1063	}	1064	}
1064		1065
1065	LineLayoutPossibilities llPoss;	1066	LineLayoutPossibilities llPoss;
Lines 1098-1109 Link Here
1098	&& i >= fobj.getOrphans()	1099	&& i >= fobj.getOrphans()
1099	&& i <= llPoss.getChosenLineCount() - fobj.getWidows()) {	1100	&& i <= llPoss.getChosenLineCount() - fobj.getWidows()) {
1100	// penalty allowing a page break between lines	1101	// penalty allowing a page break between lines
1101	int strength = getKeepTogetherStrength();	1102	Keep keep = getKeepTogether();
1102	int penalty = KeepUtil.getPenaltyForKeep(strength);	1103	int penalty = keep.getPenalty();
1103	if (penalty < KnuthElement.INFINITE) {	1104	// if (penalty < KnuthElement.INFINITE) {
1104	returnList.add(new BreakElement(	1105	returnList.add(new BreakElement(
1105	returnPosition, penalty, context));	1106	returnPosition, penalty, keep.getContext(), context));
1106	}	1107	// }
1107	}	1108	}
1108	int endIndex	1109	int endIndex
1109	= ((LineBreakPosition) llPoss.getChosenPosition(i)).getLeafPos();	1110	= ((LineBreakPosition) llPoss.getChosenPosition(i)).getLeafPos();
Lines 1283-1310 Link Here
1283	}	1284	}
1284		1285
1285	/** {@inheritDoc} */	1286	/** {@inheritDoc} */
1286	public int getKeepTogetherStrength() {	1287	public KeepProperty getKeepTogetherProperty() {
1287	return ((BlockLevelLayoutManager) getParent()).getKeepTogetherStrength();	1288	return ((BlockLevelLayoutManager) getParent()).getKeepTogetherProperty();
1288	}	1289	}
1289		1290
1290	/** {@inheritDoc} */	1291	/** {@inheritDoc} */
		1292	public KeepProperty getKeepWithPreviousProperty() {
		1293	return ((BlockLevelLayoutManager) getParent()).getKeepWithPreviousProperty();
		1294	}
		1295
		1296	/** {@inheritDoc} */
		1297	public KeepProperty getKeepWithNextProperty() {
		1298	return ((BlockLevelLayoutManager) getParent()).getKeepWithNextProperty();
		1299	}
		1300
		1301	/** {@inheritDoc} */
		1302	public Keep getKeepTogether() {
		1303	return ((BlockLevelLayoutManager) getParent()).getKeepTogether();
		1304	}
		1305
		1306	/** {@inheritDoc} */
1291	public boolean mustKeepWithPrevious() {	1307	public boolean mustKeepWithPrevious() {
1292	return getKeepWithPreviousStrength() > KEEP_AUTO;	1308	return !getKeepWithPrevious().isAuto();
1293	}	1309	}
1294		1310
1295	/** {@inheritDoc} */	1311	/** {@inheritDoc} */
1296	public boolean mustKeepWithNext() {	1312	public boolean mustKeepWithNext() {
1297	return getKeepWithNextStrength() > KEEP_AUTO;	1313	return !getKeepWithNext().isAuto();
1298	}	1314	}
1299		1315
1300	/** {@inheritDoc} */	1316	/** {@inheritDoc} */
1301	public int getKeepWithNextStrength() {	1317	public Keep getKeepWithNext() {
1302	return KEEP_AUTO;	1318	return Keep.KEEP_AUTO;
1303	}	1319	}
1304		1320
1305	/** {@inheritDoc} */	1321	/** {@inheritDoc} */
1306	public int getKeepWithPreviousStrength() {	1322	public Keep getKeepWithPrevious() {
1307	return KEEP_AUTO;	1323	return Keep.KEEP_AUTO;
1308	}	1324	}
1309		1325
1310	/** {@inheritDoc} */	1326	/** {@inheritDoc} */

Lines 145-152 Link Here

(-)src/java/org/apache/fop/layoutmgr/LayoutContext.java (-17 / +16 lines)
145	private int breakBefore;	145	private int breakBefore;
146	private int breakAfter;	146	private int breakAfter;
147		147
148	private int pendingKeepWithNext = BlockLevelLayoutManager.KEEP_AUTO;	148	private Keep pendingKeepWithNext = Keep.KEEP_AUTO;
149	private int pendingKeepWithPrevious = BlockLevelLayoutManager.KEEP_AUTO;	149	private Keep pendingKeepWithPrevious = Keep.KEEP_AUTO;
150		150
151	private int disableColumnBalancing;	151	private int disableColumnBalancing;
152		152
Lines 237-243 Link Here
237	* Returns the strength of a keep-with-next currently pending.	237	* Returns the strength of a keep-with-next currently pending.
238	* @return the keep-with-next strength	238	* @return the keep-with-next strength
239	*/	239	*/
240	public int getKeepWithNextPending() {	240	public Keep getKeepWithNextPending() {
241	return this.pendingKeepWithNext;	241	return this.pendingKeepWithNext;
242	}	242	}
243		243
Lines 245-251 Link Here
245	* Returns the strength of a keep-with-previous currently pending.	245	* Returns the strength of a keep-with-previous currently pending.
246	* @return the keep-with-previous strength	246	* @return the keep-with-previous strength
247	*/	247	*/
248	public int getKeepWithPreviousPending() {	248	public Keep getKeepWithPreviousPending() {
249	return this.pendingKeepWithPrevious;	249	return this.pendingKeepWithPrevious;
250	}	250	}
251		251
Lines 253-266 Link Here
253	* Clears any pending keep-with-next strength.	253	* Clears any pending keep-with-next strength.
254	*/	254	*/
255	public void clearKeepWithNextPending() {	255	public void clearKeepWithNextPending() {
256	this.pendingKeepWithNext = BlockLevelLayoutManager.KEEP_AUTO;	256	this.pendingKeepWithNext = Keep.KEEP_AUTO;
257	}	257	}
258		258
259	/**	259	/**
260	* Clears any pending keep-with-previous strength.	260	* Clears any pending keep-with-previous strength.
261	*/	261	*/
262	public void clearKeepWithPreviousPending() {	262	public void clearKeepWithPreviousPending() {
263	this.pendingKeepWithPrevious = BlockLevelLayoutManager.KEEP_AUTO;	263	this.pendingKeepWithPrevious = Keep.KEEP_AUTO;
264	}	264	}
265		265
266	/**	266	/**
Lines 273-290 Link Here
273		273
274	/**	274	/**
275	* Updates the currently pending keep-with-next strength.	275	* Updates the currently pending keep-with-next strength.
276	* @param strength the new strength to consider	276	* @param keep the new strength to consider
277	*/	277	*/
278	public void updateKeepWithNextPending(int strength) {	278	public void updateKeepWithNextPending(Keep keep) {
279	this.pendingKeepWithNext = Math.max(this.pendingKeepWithNext, strength);	279	this.pendingKeepWithNext = this.pendingKeepWithNext.compare(keep);
280	}	280	}
281		281
282	/**	282	/**
283	* Updates the currently pending keep-with-previous strength.	283	* Updates the currently pending keep-with-previous strength.
284	* @param strength the new strength to consider	284	* @param keep the new strength to consider
285	*/	285	*/
286	public void updateKeepWithPreviousPending(int strength) {	286	public void updateKeepWithPreviousPending(Keep keep) {
287	this.pendingKeepWithPrevious = Math.max(this.pendingKeepWithPrevious, strength);	287	this.pendingKeepWithPrevious = this.pendingKeepWithPrevious.compare(keep);
288	}	288	}
289		289
290	/**	290	/**
Lines 292-298 Link Here
292	* @return true if a keep-with-next constraint is pending	292	* @return true if a keep-with-next constraint is pending
293	*/	293	*/
294	public boolean isKeepWithNextPending() {	294	public boolean isKeepWithNextPending() {
295	return getKeepWithNextPending() != BlockLevelLayoutManager.KEEP_AUTO;	295	return !getKeepWithNextPending().isAuto();
296	}	296	}
297		297
298	/**	298	/**
Lines 300-306 Link Here
300	* @return true if a keep-with-previous constraint is pending	300	* @return true if a keep-with-previous constraint is pending
301	*/	301	*/
302	public boolean isKeepWithPreviousPending() {	302	public boolean isKeepWithPreviousPending() {
303	return getKeepWithPreviousPending() != BlockLevelLayoutManager.KEEP_AUTO;	303	return !getKeepWithPreviousPending().isAuto();
304	}	304	}
305		305
306	public void setLeadingSpace(SpaceSpecifier space) {	306	public void setLeadingSpace(SpaceSpecifier space) {
Lines 677-685 Link Here
677	+ "\nStarts New Area: \t" + startsNewArea()	677	+ "\nStarts New Area: \t" + startsNewArea()
678	+ "\nIs Last Area: \t" + isLastArea()	678	+ "\nIs Last Area: \t" + isLastArea()
679	+ "\nTry Hyphenate: \t" + tryHyphenate()	679	+ "\nTry Hyphenate: \t" + tryHyphenate()
680	+ "\nKeeps: \t[keep-with-next=" + KeepUtil.keepStrengthToString(getKeepWithNextPending())	680	+ "\nKeeps: \t[keep-with-next=" + getKeepWithNextPending()
681	+ "][keep-with-previous="	681	+ "][keep-with-previous=" + getKeepWithPreviousPending() + "] pending"
682	+ KeepUtil.keepStrengthToString(getKeepWithPreviousPending()) + "] pending"
683	+ "\nBreaks: \tforced [" + (breakBefore != Constants.EN_AUTO ? "break-before" : "") + "]["	682	+ "\nBreaks: \tforced [" + (breakBefore != Constants.EN_AUTO ? "break-before" : "") + "]["
684	+ (breakAfter != Constants.EN_AUTO ? "break-after" : "") + "]";	683	+ (breakAfter != Constants.EN_AUTO ? "break-after" : "") + "]";
685	}	684	}

Lines 37-42 Link Here

(-)src/java/org/apache/fop/layoutmgr/BlockContainerLayoutManager.java (-13 / +9 lines)
37	import org.apache.fop.datatypes.Length;	37	import org.apache.fop.datatypes.Length;
38	import org.apache.fop.fo.flow.BlockContainer;	38	import org.apache.fop.fo.flow.BlockContainer;
39	import org.apache.fop.fo.properties.CommonAbsolutePosition;	39	import org.apache.fop.fo.properties.CommonAbsolutePosition;
		40	import org.apache.fop.fo.properties.KeepProperty;
40	import org.apache.fop.traits.MinOptMax;	41	import org.apache.fop.traits.MinOptMax;
41	import org.apache.fop.traits.SpaceVal;	42	import org.apache.fop.traits.SpaceVal;
42	import org.apache.fop.util.ListUtil;	43	import org.apache.fop.util.ListUtil;
Lines 261-267 Link Here
261		262
262	if (!firstVisibleMarkServed) {	263	if (!firstVisibleMarkServed) {
263	addKnuthElementsForSpaceBefore(returnList, alignment);	264	addKnuthElementsForSpaceBefore(returnList, alignment);
264	context.updateKeepWithPreviousPending(getKeepWithPreviousStrength());	265	context.updateKeepWithPreviousPending(getKeepWithPrevious());
265	}	266	}
266		267
267	addKnuthElementsForBorderPaddingBefore(returnList, !firstVisibleMarkServed);	268	addKnuthElementsForBorderPaddingBefore(returnList, !firstVisibleMarkServed);
Lines 391-397 Link Here
391	context.clearPendingMarks();	392	context.clearPendingMarks();
392	addKnuthElementsForBreakAfter(returnList, context);	393	addKnuthElementsForBreakAfter(returnList, context);
393		394
394	context.updateKeepWithNextPending(getKeepWithNextStrength());	395	context.updateKeepWithNextPending(getKeepWithNext());
395		396
396	setFinished(true);	397	setFinished(true);
397	return returnList;	398	return returnList;
Lines 1011-1033 Link Here
1011	}	1012	}
1012		1013
1013	/** {@inheritDoc} */	1014	/** {@inheritDoc} */
1014	public int getKeepTogetherStrength() {	1015	public KeepProperty getKeepTogetherProperty() {
1015	int strength = KeepUtil.getCombinedBlockLevelKeepStrength(	1016	return getBlockContainerFO().getKeepTogether();
1016	getBlockContainerFO().getKeepTogether());
1017	strength = Math.max(strength, getParentKeepTogetherStrength());
1018	return strength;
1019	}	1017	}
1020		1018
1021	/** {@inheritDoc} */	1019	/** {@inheritDoc} */
1022	public int getKeepWithNextStrength() {	1020	public KeepProperty getKeepWithPreviousProperty() {
1023	return KeepUtil.getCombinedBlockLevelKeepStrength(	1021	return getBlockContainerFO().getKeepWithPrevious();
1024	getBlockContainerFO().getKeepWithNext());
1025	}	1022	}
1026		1023
1027	/** {@inheritDoc} */	1024	/** {@inheritDoc} */
1028	public int getKeepWithPreviousStrength() {	1025	public KeepProperty getKeepWithNextProperty() {
1029	return KeepUtil.getCombinedBlockLevelKeepStrength(	1026	return getBlockContainerFO().getKeepWithNext();
1030	getBlockContainerFO().getKeepWithPrevious());
1031	}	1027	}
1032		1028
1033	/**	1029	/**

Lines 154-160 Link Here

(-)src/java/org/apache/fop/layoutmgr/FlowLayoutManager.java (-7 / +7 lines)
154	context.updateKeepWithNextPending(childLC.getKeepWithNextPending());	154	context.updateKeepWithNextPending(childLC.getKeepWithNextPending());
155	childLC.clearKeepWithNextPending();	155	childLC.clearKeepWithNextPending();
156		156
157	context.updateKeepWithNextPending(getKeepWithNextStrength());	157	context.updateKeepWithNextPending(getKeepWithNext());
158	}	158	}
159		159
160	SpaceResolver.resolveElementList(returnList);	160	SpaceResolver.resolveElementList(returnList);
Lines 203-220 Link Here
203	}	203	}
204		204
205	/** {@inheritDoc} */	205	/** {@inheritDoc} */
206	public int getKeepTogetherStrength() {	206	public Keep getKeepTogether() {
207	return KEEP_AUTO;	207	return Keep.KEEP_AUTO;
208	}	208	}
209		209
210	/** {@inheritDoc} */	210	/** {@inheritDoc} */
211	public int getKeepWithNextStrength() {	211	public Keep getKeepWithNext() {
212	return KEEP_AUTO;	212	return Keep.KEEP_AUTO;
213	}	213	}
214		214
215	/** {@inheritDoc} */	215	/** {@inheritDoc} */
216	public int getKeepWithPreviousStrength() {	216	public Keep getKeepWithPrevious() {
217	return KEEP_AUTO;	217	return Keep.KEEP_AUTO;
218	}	218	}
219		219
220	/** {@inheritDoc} */	220	/** {@inheritDoc} */

Lines 1-109 Link Here

(-)src/java/org/apache/fop/layoutmgr/KeepUtil.java (-109 lines)
1	/*
2	* Licensed to the Apache Software Foundation (ASF) under one or more
3	* contributor license agreements. See the NOTICE file distributed with
4	* this work for additional information regarding copyright ownership.
5	* The ASF licenses this file to You under the Apache License, Version 2.0
6	* (the "License"); you may not use this file except in compliance with
7	* the License. You may obtain a copy of the License at
8	*
9	* http://www.apache.org/licenses/LICENSE-2.0
10	*
11	* Unless required by applicable law or agreed to in writing, software
12	* distributed under the License is distributed on an "AS IS" BASIS,
13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	* See the License for the specific language governing permissions and
15	* limitations under the License.
16	*/
17
18	/* $Id$ */
19
20	package org.apache.fop.layoutmgr;
21
22	import org.apache.fop.fo.Constants;
23	import org.apache.fop.fo.properties.KeepProperty;
24	import org.apache.fop.fo.properties.Property;
25
26	/**
27	* Utility class for working with keeps.
28	*/
29	public class KeepUtil {
30
31	/**
32	* Converts a keep property into an integer value.
33	* <p>
34	* Note: The conversion restricts the effectively available integer range by two values.
35	* Integer.MIN_VALUE is used to represent the value "auto" and
36	* Integer.MAX_VALUE is used to represebt the value "always".
37	* @param keep the keep property
38	* @return the keep value as an integer
39	*/
40	public static int getKeepStrength(Property keep) {
41	if (keep.isAuto()) {
42	return BlockLevelLayoutManager.KEEP_AUTO;
43	} else if (keep.getEnum() == Constants.EN_ALWAYS) {
44	return BlockLevelLayoutManager.KEEP_ALWAYS;
45	} else {
46	return keep.getNumber().intValue();
47	}
48	}
49
50	/**
51	* Returns the combined block-level keep strength from a keep property.
52	* <p>
53	* Note: This is a temporary method to be used until it is possible to differentiate between
54	* page and column keeps!
55	* @param keep the keep property
56	* @return the combined keep strength
57	*/
58	public static int getCombinedBlockLevelKeepStrength(KeepProperty keep) {
59	return Math.max(
60	getKeepStrength(keep.getWithinPage()),
61	getKeepStrength(keep.getWithinColumn()));
62	}
63
64	/**
65	* Indicates whether a keep strength indicates a keep constraint.
66	* @param strength the keep strength
67	* @return true if the keep is not "auto"
68	*/
69	public static boolean hasKeep(int strength) {
70	return strength > BlockLevelLayoutManager.KEEP_AUTO;
71	}
72
73	/**
74	* Returns the penalty value to be used for a certain keep strength.
75	* <ul>
76	* <li>"auto": returns 0</li>
77	* <li>"always": returns KnuthElement.INFINITE</li>
78	* <li>otherwise: returns KnuthElement.INFINITE - 1</li>
79	* </ul>
80	* @param keepStrength the keep strength
81	* @return the penalty value
82	*/
83	public static int getPenaltyForKeep(int keepStrength) {
84	if (keepStrength == BlockLevelLayoutManager.KEEP_AUTO) {
85	return 0;
86	}
87	int penalty = KnuthElement.INFINITE;
88	if (keepStrength < BlockLevelLayoutManager.KEEP_ALWAYS) {
89	penalty--;
90	}
91	return penalty;
92	}
93
94	/**
95	* Returns a string representation of a keep strength value.
96	* @param keepStrength the keep strength
97	* @return the string representation
98	*/
99	public static String keepStrengthToString(int keepStrength) {
100	if (keepStrength == BlockLevelLayoutManager.KEEP_AUTO) {
101	return "auto";
102	} else if (keepStrength == BlockLevelLayoutManager.KEEP_ALWAYS) {
103	return "always";
104	} else {
105	return Integer.toString(keepStrength);
106	}
107	}
108
109	}

Lines 169-174 Link Here

(-)src/java/org/apache/fop/layoutmgr/KnuthPenalty.java (+11 lines)
169	}	169	}
170	sb.append(")");	170	sb.append(")");
171	}	171	}
		172	switch (getBreakClass()) {
		173	case Constants.EN_PAGE:
		174	sb.append(" (page context)");
		175	break;
		176	case Constants.EN_COLUMN:
		177	sb.append(" (column context)");
		178	break;
		179	case Constants.EN_LINE:
		180	sb.append(" (line context)");
		181	break;
		182	}
172	return sb.toString();	183	return sb.toString();
173	}	184	}
174		185

Line 0 Link Here

(-)src/java/org/apache/fop/layoutmgr/Keep.java (+132 lines)
		1	/*
		2	* Licensed to the Apache Software Foundation (ASF) under one or more contributor license
		3	* agreements. See the NOTICE file distributed with this work for additional information
		4	* regarding copyright ownership. The ASF licenses this file to You under the Apache
		5	* License, Version 2.0 (the "License"); you may not use this file except in compliance
		6	* with the License. You may obtain a copy of the License at
		7	*
		8	* http://www.apache.org/licenses/LICENSE-2.0
		9	*
		10	* Unless required by applicable law or agreed to in writing, software distributed under
		11	* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
		12	* KIND, either express or implied. See the License for the specific language governing
		13	* permissions and limitations under the License.
		14	*/
		15
		16	/* $Id$ */
		17
		18	package org.apache.fop.layoutmgr;
		19
		20	import org.apache.fop.fo.Constants;
		21	import org.apache.fop.fo.properties.KeepProperty;
		22	import org.apache.fop.fo.properties.Property;
		23
		24	/**
		25	* TODO javadoc
		26	*/
		27	public class Keep {
		28
		29	private static final int STRENGTH_AUTO = Integer.MIN_VALUE;
		30
		31	private static final int STRENGTH_ALWAYS = Integer.MAX_VALUE;
		32
		33	/** The integer value for "auto" keep strength. */
		34	public static final Keep KEEP_AUTO = new Keep(STRENGTH_AUTO, Constants.EN_AUTO);
		35
		36	/** The integer value for "always" keep strength. */
		37	public static final Keep KEEP_ALWAYS = new Keep(STRENGTH_ALWAYS, Constants.EN_LINE);
		38
		39	private int strength;
		40
		41	private int context;
		42
		43	private Keep(int strength, int context) {
		44	this.strength = strength;
		45	this.context = context;
		46	}
		47
		48	private static int getKeepStrength(Property keep) {
		49	if (keep.isAuto()) {
		50	return STRENGTH_AUTO;
		51	} else if (keep.getEnum() == Constants.EN_ALWAYS) {
		52	return STRENGTH_ALWAYS;
		53	} else {
		54	return keep.getNumber().intValue();
		55	}
		56	}
		57
		58	public static Keep getKeep(KeepProperty keepProperty) {
		59	Keep keep = new Keep(STRENGTH_AUTO, Constants.EN_AUTO);
		60	keep.update(keepProperty.getWithinPage(), Constants.EN_PAGE);
		61	keep.update(keepProperty.getWithinColumn(), Constants.EN_COLUMN);
		62	keep.update(keepProperty.getWithinLine(), Constants.EN_LINE);
		63	return keep;
		64	}
65
66	private void update(Property keep, int context) {
67	if (!keep.isAuto()) {
68	this.strength = getKeepStrength(keep);
69	this.context = context;
70	}
71	}
72
73	public boolean isAuto() {
74	return strength == STRENGTH_AUTO;
75	}
76
77	/**
78	* Returns the context of this keep.
79	*
80	* @return one of {@link Constants#EN_LINE}, {@link Constants#EN_COLUMN} or
81	* {@link Constants#EN_PAGE}
82	*/
83	public int getContext() {
84	return context;
85	}
86
87	public int getPenalty() {
88	if (strength == STRENGTH_AUTO) {
89	return 0;
90	} else if (strength == STRENGTH_ALWAYS) {
91	return KnuthElement.INFINITE;
92	} else {
93	return KnuthElement.INFINITE - 1;
94	}
95	}
96
97	private static int getKeepContextPriority(int context) {
98	switch (context) {
99	case Constants.EN_LINE: return 0;
100	case Constants.EN_COLUMN: return 1;
101	case Constants.EN_PAGE: return 2;
102	case Constants.EN_AUTO: return 3;
103	default: throw new IllegalArgumentException();
104	}
105	}
106
107	public Keep compare(Keep other) {
108	int pThis = getKeepContextPriority(this.context);
109	int pOther = getKeepContextPriority(other.context);
110	if (pThis < pOther) {
111	return this;
112	} else if (pThis > pOther) {
113	return other;
114	} else if (strength >= other.strength) {
115	return this;
116	} else {
117	return other;
118	}
119	}
120
121	/** {@inheritDoc} */
122	public String toString() {
123	if (strength == STRENGTH_AUTO) {
124	return "auto";
125	} else if (strength == STRENGTH_ALWAYS) {
126	return "always";
127	} else {
128	return Integer.toString(strength);
129	}
130	}
131
132	}
0	+ Revision Id	133	+ Revision Id
1	+ native	134	+ native

Lines 92-109 Link Here

(-)src/java/org/apache/fop/layoutmgr/FootnoteBodyLayoutManager.java (-6 / +6 lines)
92	}	92	}
93		93
94	/** {@inheritDoc} */	94	/** {@inheritDoc} */
95	public int getKeepTogetherStrength() {	95	public Keep getKeepTogether() {
96	return getParentKeepTogetherStrength();	96	return getParentKeepTogether();
97	}	97	}
98		98
99	/** {@inheritDoc} */	99	/** {@inheritDoc} */
100	public int getKeepWithNextStrength() {	100	public Keep getKeepWithNext() {
101	return KEEP_AUTO;	101	return Keep.KEEP_AUTO;
102	}	102	}
103		103
104	/** {@inheritDoc} */	104	/** {@inheritDoc} */
105	public int getKeepWithPreviousStrength() {	105	public Keep getKeepWithPrevious() {
106	return KEEP_AUTO;	106	return Keep.KEEP_AUTO;
107	}	107	}
108		108
109	}	109	}

Lines 26-31 Link Here

(-)src/java/org/apache/fop/layoutmgr/PageBreakingAlgorithm.java (-3 / +65 lines)
26		26
27	import org.apache.commons.logging.Log;	27	import org.apache.commons.logging.Log;
28	import org.apache.commons.logging.LogFactory;	28	import org.apache.commons.logging.LogFactory;
		29
29	import org.apache.fop.fo.Constants;	30	import org.apache.fop.fo.Constants;
30	import org.apache.fop.fo.FObj;	31	import org.apache.fop.fo.FObj;
31	import org.apache.fop.layoutmgr.AbstractBreaker.PageBreakPosition;	32	import org.apache.fop.layoutmgr.AbstractBreaker.PageBreakPosition;
Lines 185-190 Link Here
185	footnoteElementIndex = -1;	186	footnoteElementIndex = -1;
186	}	187	}
187		188
		189	private boolean deferred = false;
		190	private boolean overridePageKeep = false;
		191
		192	protected KnuthNode recoverFromTooLong(KnuthNode lastTooLong) {
		193	if (log.isDebugEnabled()) {
		194	log.debug("Recovering from too long: " + lastTooLong);
		195	}
		196	KnuthNode node = lastTooLong.previous;
		197	if (!deferred) {
		198	deferred = true;
		199	while (!pageProvider.startPage(lastTooLong.line - 1)) {
		200	lastTooLong = lastTooLong.previous;
		201	}
		202	node = lastTooLong.previous;
		203	// content would overflow, insert empty line/page and try again
		204	for (int i = 0; i < pageProvider.getColumnCount(lastTooLong.previous.line); i++) {
		205	node = createNode(
		206	node.position, node.line + 1, 1,
		207	0, 0, 0,
		208	0, 0, 0,
		209	0, 0, node);
		210	}
		211	// } else {
		212	// overridePageKeep = true;
		213	}
		214	return node;
		215	}
		216
188	protected KnuthNode createNode(int position, int line, int fitness,	217	protected KnuthNode createNode(int position, int line, int fitness,
189	int totalWidth, int totalStretch, int totalShrink,	218	int totalWidth, int totalStretch, int totalShrink,
190	double adjustRatio, int availableShrink, int availableStretch,	219	double adjustRatio, int availableShrink, int availableStretch,
Lines 309-314 Link Here
309	newFootnotes = false;	338	newFootnotes = false;
310	}	339	}
311		340
		341	protected boolean elementCanEndLine(KnuthElement element, int line) {
		342	if (!(element instanceof KnuthPenalty) \|\| pageProvider == null) {
		343	return true;
		344	} else {
		345	KnuthPenalty p = (KnuthPenalty) element;
		346	if (p.getP() <= 0) {
		347	return true;
		348	} else {
		349	int context = p.getBreakClass();
		350	switch (context) {
		351	case Constants.EN_LINE:
		352	case Constants.EN_COLUMN:
		353	return p.getP() < KnuthPenalty.INFINITE;
		354	case Constants.EN_PAGE:
		355	return p.getP() < KnuthPenalty.INFINITE \|\| overridePageKeep
		356	\|\| !pageProvider.endPage(line - 1);
		357	case Constants.EN_AUTO:
		358	log.warn("keep is not auto but context is");
		359	return true;
		360	default:
		361	if (p.getP() < KnuthPenalty.INFINITE) {
		362	log.warn("Non recognized keep context:" + context);
		363	return true;
		364	} else {
		365	return false;
		366	}
		367	}
		368	}
		369	}
		370	}
		371
312	protected int computeDifference(KnuthNode activeNode, KnuthElement element,	372	protected int computeDifference(KnuthNode activeNode, KnuthElement element,
313	int elementIndex) {	373	int elementIndex) {
314	KnuthPageNode pageNode = (KnuthPageNode) activeNode;	374	KnuthPageNode pageNode = (KnuthPageNode) activeNode;
Lines 561-571 Link Here
561	splitLength += element.getW();	621	splitLength += element.getW();
562	} else {	622	} else {
563	// element is a penalty	623	// element is a penalty
564	if (element.getP() < KnuthElement.INFINITE) {	624	// if (element.getP() < KnuthElement.INFINITE) {
565	// end of the sub-sequence	625	// end of the sub-sequence
566	index = noteListIterator.previousIndex();	626	index = noteListIterator.previousIndex();
567	break;	627	break;
568	}	628	// }
569	}	629	}
570	}	630	}
571	}	631	}
Lines 625-631 Link Here
625	double f = Math.abs(r);	685	double f = Math.abs(r);
626	f = 1 + 100 * f * f * f;	686	f = 1 + 100 * f * f * f;
627	if (element.isPenalty() && element.getP() >= 0) {	687	if (element.isPenalty() && element.getP() >= 0) {
628	f += element.getP();	688	if (element.getP() < KnuthPenalty.INFINITE) {
		689	f += element.getP();
		690	}
629	demerits = f * f;	691	demerits = f * f;
630	} else if (element.isPenalty() && !element.isForcedBreak()) {	692	} else if (element.isPenalty() && !element.isForcedBreak()) {
631	double penalty = element.getP();	693	double penalty = element.getP();

Lines 146-151 Link Here

(-)src/java/org/apache/fop/layoutmgr/PageProvider.java (+27 lines)
146	return this.lastReportedBPD;	146	return this.lastReportedBPD;
147	}	147	}
148		148
		149	// Wish there were a more elegant way to do this in Java
		150	private int[] getColIndexAndColCount(int index) {
		151	int columnCount = 0;
		152	int colIndex = startColumnOfCurrentElementList + index;
		153	int pageIndex = -1;
		154	do {
		155	colIndex -= columnCount;
		156	pageIndex++;
		157	Page page = getPage(false, pageIndex, RELTO_CURRENT_ELEMENT_LIST);
		158	columnCount = page.getPageViewport().getCurrentSpan().getColumnCount();
		159	} while (colIndex >= columnCount);
		160	return new int[] {colIndex, columnCount};
		161	}
		162
		163	boolean startPage(int index) {
		164	return getColIndexAndColCount(index)[0] == 0;
		165	}
		166
		167	boolean endPage(int index) {
		168	int[] colIndexAndColCount = getColIndexAndColCount(index);
		169	return colIndexAndColCount[0] == colIndexAndColCount[1] - 1;
		170	}
		171
		172	int getColumnCount(int index) {
		173	return getColIndexAndColCount(index)[1];
		174	}
		175
149	/**	176	/**
150	* Returns the part index (0<x<partCount) which denotes the first part on the last page	177	* Returns the part index (0<x<partCount) which denotes the first part on the last page
151	* generated by the current element list.	178	* generated by the current element list.

Lines 29-38 Link Here

(-)src/java/org/apache/fop/layoutmgr/list/ListBlockLayoutManager.java (-10 / +7 lines)
29	import org.apache.fop.area.Area;	29	import org.apache.fop.area.Area;
30	import org.apache.fop.area.Block;	30	import org.apache.fop.area.Block;
31	import org.apache.fop.fo.flow.ListBlock;	31	import org.apache.fop.fo.flow.ListBlock;
		32	import org.apache.fop.fo.properties.KeepProperty;
32	import org.apache.fop.layoutmgr.BlockStackingLayoutManager;	33	import org.apache.fop.layoutmgr.BlockStackingLayoutManager;
33	import org.apache.fop.layoutmgr.ConditionalElementListener;	34	import org.apache.fop.layoutmgr.ConditionalElementListener;
34	import org.apache.fop.layoutmgr.ElementListUtils;	35	import org.apache.fop.layoutmgr.ElementListUtils;
35	import org.apache.fop.layoutmgr.KeepUtil;
36	import org.apache.fop.layoutmgr.LayoutContext;	36	import org.apache.fop.layoutmgr.LayoutContext;
37	import org.apache.fop.layoutmgr.LayoutManager;	37	import org.apache.fop.layoutmgr.LayoutManager;
38	import org.apache.fop.layoutmgr.NonLeafPosition;	38	import org.apache.fop.layoutmgr.NonLeafPosition;
Lines 279-299 Link Here
279	}	279	}
280		280
281	/** {@inheritDoc} */	281	/** {@inheritDoc} */
282	public int getKeepTogetherStrength() {	282	public KeepProperty getKeepTogetherProperty() {
283	int strength = KeepUtil.getCombinedBlockLevelKeepStrength(	283	return getListBlockFO().getKeepTogether();
284	getListBlockFO().getKeepTogether());
285	strength = Math.max(strength, getParentKeepTogetherStrength());
286	return strength;
287	}	284	}
288		285
289	/** {@inheritDoc} */	286	/** {@inheritDoc} */
290	public int getKeepWithNextStrength() {	287	public KeepProperty getKeepWithPreviousProperty() {
291	return KeepUtil.getCombinedBlockLevelKeepStrength(getListBlockFO().getKeepWithNext());	288	return getListBlockFO().getKeepWithPrevious();
292	}	289	}
293		290
294	/** {@inheritDoc} */	291	/** {@inheritDoc} */
295	public int getKeepWithPreviousStrength() {	292	public KeepProperty getKeepWithNextProperty() {
296	return KeepUtil.getCombinedBlockLevelKeepStrength(getListBlockFO().getKeepWithPrevious());	293	return getListBlockFO().getKeepWithNext();
297	}	294	}
298		295
299	/** {@inheritDoc} */	296	/** {@inheritDoc} */

Lines 32-44 Link Here

(-)src/java/org/apache/fop/layoutmgr/list/ListItemLayoutManager.java (-23 / +19 lines)
32	import org.apache.fop.fo.flow.ListItem;	32	import org.apache.fop.fo.flow.ListItem;
33	import org.apache.fop.fo.flow.ListItemBody;	33	import org.apache.fop.fo.flow.ListItemBody;
34	import org.apache.fop.fo.flow.ListItemLabel;	34	import org.apache.fop.fo.flow.ListItemLabel;
35	import org.apache.fop.layoutmgr.BlockLevelLayoutManager;	35	import org.apache.fop.fo.properties.KeepProperty;
36	import org.apache.fop.layoutmgr.BlockStackingLayoutManager;	36	import org.apache.fop.layoutmgr.BlockStackingLayoutManager;
37	import org.apache.fop.layoutmgr.BreakElement;	37	import org.apache.fop.layoutmgr.BreakElement;
38	import org.apache.fop.layoutmgr.ConditionalElementListener;	38	import org.apache.fop.layoutmgr.ConditionalElementListener;
39	import org.apache.fop.layoutmgr.ElementListObserver;	39	import org.apache.fop.layoutmgr.ElementListObserver;
40	import org.apache.fop.layoutmgr.ElementListUtils;	40	import org.apache.fop.layoutmgr.ElementListUtils;
41	import org.apache.fop.layoutmgr.KeepUtil;	41	import org.apache.fop.layoutmgr.Keep;
42	import org.apache.fop.layoutmgr.KnuthBlockBox;	42	import org.apache.fop.layoutmgr.KnuthBlockBox;
43	import org.apache.fop.layoutmgr.KnuthBox;	43	import org.apache.fop.layoutmgr.KnuthBox;
44	import org.apache.fop.layoutmgr.KnuthElement;	44	import org.apache.fop.layoutmgr.KnuthElement;
Lines 83-90 Link Here
83	private MinOptMax effSpaceBefore;	83	private MinOptMax effSpaceBefore;
84	private MinOptMax effSpaceAfter;	84	private MinOptMax effSpaceAfter;
85		85
86	private int keepWithNextPendingOnLabel;	86	private Keep keepWithNextPendingOnLabel;
87	private int keepWithNextPendingOnBody;	87	private Keep keepWithNextPendingOnBody;
88		88
89	private int listItemHeight;	89	private int listItemHeight;
90		90
Lines 254-261 Link Here
254		254
255	context.updateKeepWithNextPending(this.keepWithNextPendingOnLabel);	255	context.updateKeepWithNextPending(this.keepWithNextPendingOnLabel);
256	context.updateKeepWithNextPending(this.keepWithNextPendingOnBody);	256	context.updateKeepWithNextPending(this.keepWithNextPendingOnBody);
257	context.updateKeepWithNextPending(getKeepWithNextStrength());	257	context.updateKeepWithNextPending(getKeepWithNext());
258	context.updateKeepWithPreviousPending(getKeepWithPreviousStrength());	258	context.updateKeepWithPreviousPending(getKeepWithPrevious());
259		259
260	setFinished(true);	260	setFinished(true);
261	resetSpaces();	261	resetSpaces();
Lines 276-291 Link Here
276	int totalHeight = Math.max(fullHeights[0], fullHeights[1]);	276	int totalHeight = Math.max(fullHeights[0], fullHeights[1]);
277	int step;	277	int step;
278	int addedBoxHeight = 0;	278	int addedBoxHeight = 0;
279	int keepWithNextActive = BlockLevelLayoutManager.KEEP_AUTO;	279	Keep keepWithNextActive = Keep.KEEP_AUTO;
280		280
281	LinkedList returnList = new LinkedList();	281	LinkedList returnList = new LinkedList();
282	while ((step = getNextStep(elementLists, start, end, partialHeights)) > 0) {	282	while ((step = getNextStep(elementLists, start, end, partialHeights)) > 0) {
283		283
284	if (end[0] + 1 == elementLists[0].size()) {	284	if (end[0] + 1 == elementLists[0].size()) {
285	keepWithNextActive = Math.max(keepWithNextActive, keepWithNextPendingOnLabel);	285	keepWithNextActive = keepWithNextActive.compare(keepWithNextPendingOnLabel);
286	}	286	}
287	if (end[1] + 1 == elementLists[1].size()) {	287	if (end[1] + 1 == elementLists[1].size()) {
288	keepWithNextActive = Math.max(keepWithNextActive, keepWithNextPendingOnBody);	288	keepWithNextActive = keepWithNextActive.compare(keepWithNextPendingOnBody);
289	}	289	}
290		290
291	// compute penalty height and box height	291	// compute penalty height and box height
Lines 339-352 Link Here
339	}	339	}
340		340
341	if (addedBoxHeight < totalHeight) {	341	if (addedBoxHeight < totalHeight) {
342	int strength = BlockLevelLayoutManager.KEEP_AUTO;	342	Keep keep = keepWithNextActive.compare(getKeepTogether());
343	strength = Math.max(strength, keepWithNextActive);
344	strength = Math.max(strength, getKeepTogetherStrength());
345	int p = stepPenalty;	343	int p = stepPenalty;
346	if (p > -KnuthElement.INFINITE) {	344	if (p > -KnuthElement.INFINITE) {
347	p = Math.max(p, KeepUtil.getPenaltyForKeep(strength));	345	p = Math.max(p, keep.getPenalty());
348	}	346	}
349	returnList.add(new BreakElement(stepPosition, penaltyHeight, p, -1, context));	347	returnList.add(new BreakElement(stepPosition, penaltyHeight, p, keep.getContext(),
		348	context));
350	}	349	}
351	}	350	}
352		351
Lines 644-664 Link Here
644	}	643	}
645		644
646	/** {@inheritDoc} */	645	/** {@inheritDoc} */
647	public int getKeepTogetherStrength() {	646	public KeepProperty getKeepTogetherProperty() {
648	int strength = KeepUtil.getCombinedBlockLevelKeepStrength(	647	return getListItemFO().getKeepTogether();
649	getListItemFO().getKeepTogether());
650	strength = Math.max(strength, getParentKeepTogetherStrength());
651	return strength;
652	}	648	}
653		649
654	/** {@inheritDoc} */	650	/** {@inheritDoc} */
655	public int getKeepWithNextStrength() {	651	public KeepProperty getKeepWithPreviousProperty() {
656	return KeepUtil.getCombinedBlockLevelKeepStrength(getListItemFO().getKeepWithNext());	652	return getListItemFO().getKeepWithPrevious();
657	}	653	}
658		654
659	/** {@inheritDoc} */	655	/** {@inheritDoc} */
660	public int getKeepWithPreviousStrength() {	656	public KeepProperty getKeepWithNextProperty() {
661	return KeepUtil.getCombinedBlockLevelKeepStrength(getListItemFO().getKeepWithPrevious());	657	return getListItemFO().getKeepWithNext();
662	}	658	}
663		659
664	/** {@inheritDoc} */	660	/** {@inheritDoc} */

Lines 28-35 Link Here

(-)src/java/org/apache/fop/layoutmgr/list/ListItemContentLayoutManager.java (-9 / +8 lines)
28	import org.apache.fop.fo.flow.AbstractListItemPart;	28	import org.apache.fop.fo.flow.AbstractListItemPart;
29	import org.apache.fop.fo.flow.ListItemBody;	29	import org.apache.fop.fo.flow.ListItemBody;
30	import org.apache.fop.fo.flow.ListItemLabel;	30	import org.apache.fop.fo.flow.ListItemLabel;
		31	import org.apache.fop.fo.properties.KeepProperty;
31	import org.apache.fop.layoutmgr.BlockStackingLayoutManager;	32	import org.apache.fop.layoutmgr.BlockStackingLayoutManager;
32	import org.apache.fop.layoutmgr.KeepUtil;	33	import org.apache.fop.layoutmgr.Keep;
33	import org.apache.fop.layoutmgr.LayoutContext;	34	import org.apache.fop.layoutmgr.LayoutContext;
34	import org.apache.fop.layoutmgr.LayoutManager;	35	import org.apache.fop.layoutmgr.LayoutManager;
35	import org.apache.fop.layoutmgr.NonLeafPosition;	36	import org.apache.fop.layoutmgr.NonLeafPosition;
Lines 221-240 Link Here
221	}	222	}
222		223
223	/** {@inheritDoc} */	224	/** {@inheritDoc} */
224	public int getKeepTogetherStrength() {	225	public KeepProperty getKeepTogetherProperty() {
225	int strength = KeepUtil.getCombinedBlockLevelKeepStrength(getPartFO().getKeepTogether());	226	return getPartFO().getKeepTogether();
226	strength = Math.max(strength, getParentKeepTogetherStrength());
227	return strength;
228	}	227	}
229		228
230	/** {@inheritDoc} */	229	/** {@inheritDoc} */
231	public int getKeepWithNextStrength() {	230	public Keep getKeepWithNext() {
232	return KEEP_AUTO;	231	return Keep.KEEP_AUTO;
233	}	232	}
234		233
235	/** {@inheritDoc} */	234	/** {@inheritDoc} */
236	public int getKeepWithPreviousStrength() {	235	public Keep getKeepWithPrevious() {
237	return KEEP_AUTO;	236	return Keep.KEEP_AUTO;
238	}	237	}
239		238
240	}	239	}

Lines 35-44 Link Here

(-)src/java/org/apache/fop/layoutmgr/table/TableContentLayoutManager.java (-11 / +10 lines)
35	import org.apache.fop.fo.flow.table.PrimaryGridUnit;	35	import org.apache.fop.fo.flow.table.PrimaryGridUnit;
36	import org.apache.fop.fo.flow.table.Table;	36	import org.apache.fop.fo.flow.table.Table;
37	import org.apache.fop.fo.flow.table.TablePart;	37	import org.apache.fop.fo.flow.table.TablePart;
38	import org.apache.fop.layoutmgr.BlockLevelLayoutManager;
39	import org.apache.fop.layoutmgr.BreakElement;	38	import org.apache.fop.layoutmgr.BreakElement;
40	import org.apache.fop.layoutmgr.ElementListUtils;	39	import org.apache.fop.layoutmgr.ElementListUtils;
41	import org.apache.fop.layoutmgr.KeepUtil;	40	import org.apache.fop.layoutmgr.Keep;
42	import org.apache.fop.layoutmgr.KnuthBox;	41	import org.apache.fop.layoutmgr.KnuthBox;
43	import org.apache.fop.layoutmgr.KnuthElement;	42	import org.apache.fop.layoutmgr.KnuthElement;
44	import org.apache.fop.layoutmgr.KnuthGlue;	43	import org.apache.fop.layoutmgr.KnuthGlue;
Lines 213-225 Link Here
213	context.clearKeepsPending();	212	context.clearKeepsPending();
214	context.setBreakBefore(Constants.EN_AUTO);	213	context.setBreakBefore(Constants.EN_AUTO);
215	context.setBreakAfter(Constants.EN_AUTO);	214	context.setBreakAfter(Constants.EN_AUTO);
216	int keepWithPrevious = BlockLevelLayoutManager.KEEP_AUTO;	215	Keep keepWithPrevious = Keep.KEEP_AUTO;
217	int breakBefore = Constants.EN_AUTO;	216	int breakBefore = Constants.EN_AUTO;
218	if (rowGroup != null) {	217	if (rowGroup != null) {
219	RowGroupLayoutManager rowGroupLM = new RowGroupLayoutManager(getTableLM(), rowGroup,	218	RowGroupLayoutManager rowGroupLM = new RowGroupLayoutManager(getTableLM(), rowGroup,
220	stepper);	219	stepper);
221	List nextRowGroupElems = rowGroupLM.getNextKnuthElements(context, alignment, bodyType);	220	List nextRowGroupElems = rowGroupLM.getNextKnuthElements(context, alignment, bodyType);
222	keepWithPrevious = Math.max(keepWithPrevious, context.getKeepWithPreviousPending());	221	keepWithPrevious = keepWithPrevious.compare(context.getKeepWithPreviousPending());
223	breakBefore = context.getBreakBefore();	222	breakBefore = context.getBreakBefore();
224	int breakBetween = context.getBreakAfter();	223	int breakBetween = context.getBreakAfter();
225	returnList.addAll(nextRowGroupElems);	224	returnList.addAll(nextRowGroupElems);
Lines 228-234 Link Here
228		227
229	//Note previous pending keep-with-next and clear the strength	228	//Note previous pending keep-with-next and clear the strength
230	//(as the layout context is reused)	229	//(as the layout context is reused)
231	int keepWithNextPending = context.getKeepWithNextPending();	230	Keep keepWithNextPending = context.getKeepWithNextPending();
232	context.clearKeepWithNextPending();	231	context.clearKeepWithNextPending();
233		232
234	//Get elements for next row group	233	//Get elements for next row group
Lines 246-262 Link Here
246	*/	245	*/
247		246
248	//Determine keep constraints	247	//Determine keep constraints
249	int penaltyStrength = BlockLevelLayoutManager.KEEP_AUTO;	248	Keep keep = keepWithNextPending.compare(context.getKeepWithPreviousPending());
250	penaltyStrength = Math.max(penaltyStrength, keepWithNextPending);
251	penaltyStrength = Math.max(penaltyStrength, context.getKeepWithPreviousPending());
252	context.clearKeepWithPreviousPending();	249	context.clearKeepWithPreviousPending();
253	penaltyStrength = Math.max(penaltyStrength, getTableLM().getKeepTogetherStrength());	250	keep = keep.compare(getTableLM().getKeepTogether());
254	int penaltyValue = KeepUtil.getPenaltyForKeep(penaltyStrength);	251	int penaltyValue = keep.getPenalty();
		252	int breakClass = keep.getContext();
255		253
256	breakBetween = BreakUtil.compareBreakClasses(breakBetween,	254	breakBetween = BreakUtil.compareBreakClasses(breakBetween,
257	context.getBreakBefore());	255	context.getBreakBefore());
258	if (breakBetween != Constants.EN_AUTO) {	256	if (breakBetween != Constants.EN_AUTO) {
259	penaltyValue = -KnuthElement.INFINITE;	257	penaltyValue = -KnuthElement.INFINITE;
		258	breakClass = breakBetween;
260	}	259	}
261	BreakElement breakElement;	260	BreakElement breakElement;
262	ListIterator elemIter = returnList.listIterator(returnList.size());	261	ListIterator elemIter = returnList.listIterator(returnList.size());
Lines 267-273 Link Here
267	breakElement = (BreakElement) elem;	266	breakElement = (BreakElement) elem;
268	}	267	}
269	breakElement.setPenaltyValue(penaltyValue);	268	breakElement.setPenaltyValue(penaltyValue);
270	breakElement.setBreakClass(breakBetween);	269	breakElement.setBreakClass(breakClass);
271	returnList.addAll(nextRowGroupElems);	270	returnList.addAll(nextRowGroupElems);
272	breakBetween = context.getBreakAfter();	271	breakBetween = context.getBreakAfter();
273	}	272	}

Lines 30-41 Link Here

(-)src/java/org/apache/fop/layoutmgr/table/TableStepper.java (-16 / +12 lines)
30	import org.apache.fop.fo.flow.table.EffRow;	30	import org.apache.fop.fo.flow.table.EffRow;
31	import org.apache.fop.fo.flow.table.GridUnit;	31	import org.apache.fop.fo.flow.table.GridUnit;
32	import org.apache.fop.fo.flow.table.PrimaryGridUnit;	32	import org.apache.fop.fo.flow.table.PrimaryGridUnit;
33	import org.apache.fop.layoutmgr.BlockLevelLayoutManager;
34	import org.apache.fop.layoutmgr.BreakElement;	33	import org.apache.fop.layoutmgr.BreakElement;
35	import org.apache.fop.layoutmgr.KeepUtil;	34	import org.apache.fop.layoutmgr.Keep;
36	import org.apache.fop.layoutmgr.KnuthBlockBox;	35	import org.apache.fop.layoutmgr.KnuthBlockBox;
37	import org.apache.fop.layoutmgr.KnuthBox;	36	import org.apache.fop.layoutmgr.KnuthBox;
38	import org.apache.fop.layoutmgr.KnuthElement;
39	import org.apache.fop.layoutmgr.KnuthGlue;	37	import org.apache.fop.layoutmgr.KnuthGlue;
40	import org.apache.fop.layoutmgr.KnuthPenalty;	38	import org.apache.fop.layoutmgr.KnuthPenalty;
41	import org.apache.fop.layoutmgr.LayoutContext;	39	import org.apache.fop.layoutmgr.LayoutContext;
Lines 241-280 Link Here
241	}	239	}
242	}	240	}
243		241
244	int strength = BlockLevelLayoutManager.KEEP_AUTO;	242	Keep keep = Keep.KEEP_AUTO;
245	int stepPenalty = 0;	243	int stepPenalty = 0;
246	for (Iterator iter = activeCells.iterator(); iter.hasNext();) {	244	for (Iterator iter = activeCells.iterator(); iter.hasNext();) {
247	ActiveCell activeCell = (ActiveCell) iter.next();	245	ActiveCell activeCell = (ActiveCell) iter.next();
248	strength = Math.max(strength, activeCell.getKeepWithNextStrength());	246	keep = keep.compare(activeCell.getKeepWithNext());
249	stepPenalty = Math.max(stepPenalty, activeCell.getPenaltyValue());	247	stepPenalty = Math.max(stepPenalty, activeCell.getPenaltyValue());
250	}	248	}
251	if (!rowFinished) {	249	if (!rowFinished) {
252	strength = Math.max(strength, rowGroup[activeRowIndex].getKeepTogetherStrength());	250	keep = keep.compare(rowGroup[activeRowIndex].getKeepTogether());
253	//The above call doesn't take the penalty from the table into account, so...	251	//The above call doesn't take the penalty from the table into account, so...
254	strength = Math.max(strength, getTableLM().getKeepTogetherStrength());	252	keep = keep.compare(getTableLM().getKeepTogether());
255	} else if (activeRowIndex < rowGroup.length - 1) {	253	} else if (activeRowIndex < rowGroup.length - 1) {
256	strength = Math.max(strength,	254	keep = keep.compare(rowGroup[activeRowIndex].getKeepWithNext());
257	rowGroup[activeRowIndex].getKeepWithNextStrength());	255	keep = keep.compare(rowGroup[activeRowIndex + 1].getKeepWithPrevious());
258	strength = Math.max(strength,
259	rowGroup[activeRowIndex + 1].getKeepWithPreviousStrength());
260	nextBreakClass = BreakUtil.compareBreakClasses(nextBreakClass,	256	nextBreakClass = BreakUtil.compareBreakClasses(nextBreakClass,
261	rowGroup[activeRowIndex].getBreakAfter());	257	rowGroup[activeRowIndex].getBreakAfter());
262	nextBreakClass = BreakUtil.compareBreakClasses(nextBreakClass,	258	nextBreakClass = BreakUtil.compareBreakClasses(nextBreakClass,
263	rowGroup[activeRowIndex + 1].getBreakBefore());	259	rowGroup[activeRowIndex + 1].getBreakBefore());
264	}	260	}
265	int p = KeepUtil.getPenaltyForKeep(strength);	261	int p = keep.getPenalty();
266	if (rowHeightSmallerThanFirstStep) {	262	if (rowHeightSmallerThanFirstStep) {
267	rowHeightSmallerThanFirstStep = false;	263	rowHeightSmallerThanFirstStep = false;
268	p = KnuthPenalty.INFINITE;	264	p = KnuthPenalty.INFINITE;
269	}	265	}
270	if (p > -KnuthElement.INFINITE) {	266	p = Math.max(p, stepPenalty);
271	p = Math.max(p, stepPenalty);	267	int breakClass = keep.getContext();
272	}
273	if (nextBreakClass != Constants.EN_AUTO) {	268	if (nextBreakClass != Constants.EN_AUTO) {
274	log.trace("Forced break encountered");	269	log.trace("Forced break encountered");
275	p = -KnuthPenalty.INFINITE; //Overrides any keeps (see 4.8 in XSL 1.0)	270	p = -KnuthPenalty.INFINITE; //Overrides any keeps (see 4.8 in XSL 1.0)
		271	breakClass = nextBreakClass;
276	}	272	}
277	returnList.add(new BreakElement(penaltyPos, effPenaltyLen, p, nextBreakClass, context));	273	returnList.add(new BreakElement(penaltyPos, effPenaltyLen, p, breakClass, context));
278	if (penaltyOrGlueLen < 0) {	274	if (penaltyOrGlueLen < 0) {
279	returnList.add(new KnuthGlue(-penaltyOrGlueLen, 0, 0, new Position(null), true));	275	returnList.add(new KnuthGlue(-penaltyOrGlueLen, 0, 0, new Position(null), true));
280	}	276	}

Lines 23-30 Link Here

(-)src/java/org/apache/fop/fo/flow/table/EffRow.java (-21 / +15 lines)
23	import java.util.List;	23	import java.util.List;
24		24
25	import org.apache.fop.fo.Constants;	25	import org.apache.fop.fo.Constants;
26	import org.apache.fop.layoutmgr.BlockLevelLayoutManager;	26	import org.apache.fop.layoutmgr.Keep;
27	import org.apache.fop.layoutmgr.KeepUtil;
28	import org.apache.fop.layoutmgr.table.TableRowIterator;	27	import org.apache.fop.layoutmgr.table.TableRowIterator;
29	import org.apache.fop.traits.MinOptMax;	28	import org.apache.fop.traits.MinOptMax;
30	import org.apache.fop.util.BreakUtil;	29	import org.apache.fop.util.BreakUtil;
Lines 170-189 Link Here
170	*	169	*
171	* @return the strength of the keep-with-previous constraint	170	* @return the strength of the keep-with-previous constraint
172	*/	171	*/
173	public int getKeepWithPreviousStrength() {	172	public Keep getKeepWithPrevious() {
174	int strength = BlockLevelLayoutManager.KEEP_AUTO;	173	Keep keep = Keep.KEEP_AUTO;
175	TableRow row = getTableRow();	174	TableRow row = getTableRow();
176	if (row != null) {	175	if (row != null) {
177	strength = Math.max(strength,	176	keep = Keep.getKeep(row.getKeepWithPrevious());
178	KeepUtil.getCombinedBlockLevelKeepStrength(row.getKeepWithPrevious()));
179	}	177	}
180	for (Iterator iter = gridUnits.iterator(); iter.hasNext();) {	178	for (Iterator iter = gridUnits.iterator(); iter.hasNext();) {
181	GridUnit gu = (GridUnit) iter.next();	179	GridUnit gu = (GridUnit) iter.next();
182	if (gu.isPrimary()) {	180	if (gu.isPrimary()) {
183	strength = Math.max(strength, gu.getPrimary().getKeepWithPreviousStrength());	181	keep = keep.compare(gu.getPrimary().getKeepWithPrevious());
184	}	182	}
185	}	183	}
186	return strength;	184	return keep;
187	}	185	}
188		186
189	/**	187	/**
Lines 192-211 Link Here
192	*	190	*
193	* @return the strength of the keep-with-next constraint	191	* @return the strength of the keep-with-next constraint
194	*/	192	*/
195	public int getKeepWithNextStrength() {	193	public Keep getKeepWithNext() {
196	int strength = BlockLevelLayoutManager.KEEP_AUTO;	194	Keep keep = Keep.KEEP_AUTO;
197	TableRow row = getTableRow();	195	TableRow row = getTableRow();
198	if (row != null) {	196	if (row != null) {
199	strength = Math.max(strength,	197	keep = Keep.getKeep(row.getKeepWithNext());
200	KeepUtil.getCombinedBlockLevelKeepStrength(row.getKeepWithNext()));
201	}	198	}
202	for (Iterator iter = gridUnits.iterator(); iter.hasNext();) {	199	for (Iterator iter = gridUnits.iterator(); iter.hasNext();) {
203	GridUnit gu = (GridUnit) iter.next();	200	GridUnit gu = (GridUnit) iter.next();
204	if (!gu.isEmpty() && gu.getColSpanIndex() == 0 && gu.isLastGridUnitRowSpan()) {	201	if (!gu.isEmpty() && gu.getColSpanIndex() == 0 && gu.isLastGridUnitRowSpan()) {
205	strength = Math.max(strength, gu.getPrimary().getKeepWithNextStrength());	202	keep = keep.compare(gu.getPrimary().getKeepWithNext());
206	}	203	}
207	}	204	}
208	return strength;	205	return keep;
209	}	206	}
210		207
211	/**	208	/**
Lines 213-228 Link Here
213	* not take the parent table's keeps into account!	210	* not take the parent table's keeps into account!
214	* @return the keep-together strength	211	* @return the keep-together strength
215	*/	212	*/
216	public int getKeepTogetherStrength() {	213	public Keep getKeepTogether() {
217	TableRow row = getTableRow();	214	TableRow row = getTableRow();
218	int strength = BlockLevelLayoutManager.KEEP_AUTO;	215	Keep keep = Keep.KEEP_AUTO;
219	if (row != null) {	216	if (row != null) {
220	strength = Math.max(strength, KeepUtil.getKeepStrength(	217	keep = Keep.getKeep(row.getKeepTogether());
221	row.getKeepTogether().getWithinPage()));
222	strength = Math.max(strength, KeepUtil.getKeepStrength(
223	row.getKeepTogether().getWithinColumn()));
224	}	218	}
225	return strength;	219	return keep;
226	}	220	}
227		221
228	/**	222	/**

Lines 19-32 Link Here

(-)src/java/org/apache/fop/fo/flow/table/PrimaryGridUnit.java (-12 / +11 lines)
19		19
20	package org.apache.fop.fo.flow.table;	20	package org.apache.fop.fo.flow.table;
21		21
22	import java.util.LinkedList;
23	import java.util.List;	22	import java.util.List;
24		23
25	import org.apache.fop.fo.Constants;	24	import org.apache.fop.fo.Constants;
26	import org.apache.fop.fo.FONode;	25	import org.apache.fop.fo.FONode;
27	import org.apache.fop.fo.properties.CommonBorderPaddingBackground;	26	import org.apache.fop.fo.properties.CommonBorderPaddingBackground;
28	import org.apache.fop.layoutmgr.BlockLevelLayoutManager;
29	import org.apache.fop.layoutmgr.ElementListUtils;	27	import org.apache.fop.layoutmgr.ElementListUtils;
		28	import org.apache.fop.layoutmgr.Keep;
30	import org.apache.fop.layoutmgr.table.TableCellLayoutManager;	29	import org.apache.fop.layoutmgr.table.TableCellLayoutManager;
31		30
32	/**	31	/**
Lines 54-61 Link Here
54	private boolean isSeparateBorderModel;	53	private boolean isSeparateBorderModel;
55	private int halfBorderSeparationBPD;	54	private int halfBorderSeparationBPD;
56		55
57	private int keepWithPrevious = BlockLevelLayoutManager.KEEP_AUTO;	56	private Keep keepWithPrevious = Keep.KEEP_AUTO;
58	private int keepWithNext = BlockLevelLayoutManager.KEEP_AUTO;	57	private Keep keepWithNext = Keep.KEEP_AUTO;
59	private int breakBefore = Constants.EN_AUTO;	58	private int breakBefore = Constants.EN_AUTO;
60	private int breakAfter = Constants.EN_AUTO;	59	private int breakAfter = Constants.EN_AUTO;
61		60
Lines 334-349 Link Here
334	*	333	*
335	* @return the keep-with-previous strength	334	* @return the keep-with-previous strength
336	*/	335	*/
337	public int getKeepWithPreviousStrength() {	336	public Keep getKeepWithPrevious() {
338	return keepWithPrevious;	337	return keepWithPrevious;
339	}	338	}
340		339
341	/**	340	/**
342	* Don't use, reserved for TableCellLM. TODO	341	* Don't use, reserved for TableCellLM. TODO
343	* @param strength the keep strength	342	* @param keep the keep strength
344	*/	343	*/
345	public void setKeepWithPreviousStrength(int strength) {	344	public void setKeepWithPrevious(Keep keep) {
346	this.keepWithPrevious = strength;	345	this.keepWithPrevious = keep;
347	}	346	}
348		347
349	/**	348	/**
Lines 352-367 Link Here
352	*	351	*
353	* @return the keep-with-next strength	352	* @return the keep-with-next strength
354	*/	353	*/
355	public int getKeepWithNextStrength() {	354	public Keep getKeepWithNext() {
356	return keepWithNext;	355	return keepWithNext;
357	}	356	}
358		357
359	/**	358	/**
360	* Don't use, reserved for TableCellLM. TODO	359	* Don't use, reserved for TableCellLM. TODO
361	* @param strength the keep strength	360	* @param keep the keep strength
362	*/	361	*/
363	public void setKeepWithNextStrength(int strength) {	362	public void setKeepWithNext(Keep keep) {
364	this.keepWithNext = strength;	363	this.keepWithNext = keep;
365	}	364	}
366		365
367	/**	366	/**