Attachment #27176 for bug #51304

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




<?xml version="1.0" encoding="UTF-8"?>
<!--
  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$ -->
<testcase>
  <info>
    <p>
      This test checks multi-column documents. This test: footnotes in multi-column documents (no spans).
    </p>
  </info>
  <fo>
    <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">
      <fo:layout-master-set>
          <!-- height = 6 x 12pt (content) + 10pt (footnote-separator) -->
          <fo:simple-page-master master-name="3-column" page-height="82pt" page-width="8in">
              <fo:region-body column-count="3" />
          </fo:simple-page-master>
       </fo:layout-master-set>
       <fo:page-sequence master-reference="3-column" font-size="10pt">
          <fo:static-content flow-name="xsl-footnote-separator">
              <fo:block-container border-top-color="#000000" border-top-style="solid" border-top-width="1pt" margin-bottom="3pt" margin-top="6pt" width="100%">
                  <fo:block/>
              </fo:block-container>
          </fo:static-content>
          <fo:flow flow-name="xsl-region-body">
            <fo:block id="block-2" break-before="page">
              <fo:block>line 1</fo:block>
              <fo:block>line 2</fo:block>
              <fo:block>line 3
                <fo:footnote><fo:inline font-size="6pt" vertical-align="top">[*]</fo:inline>
                  <fo:footnote-body>
                    <fo:block>
                      <fo:list-block>
                        <fo:list-item>
                          <fo:list-item-label end-indent="label-end()" start-indent="0">
                            <fo:block>
                              <fo:inline font-size="6pt" vertical-align="top">[*]</fo:inline>
                            </fo:block>
                          </fo:list-item-label>
                          <fo:list-item-body start-indent="0.4cm">
                            <fo:block>footnote footnote footnote footnote footnote footnote footnote footnote</fo:block>
                          </fo:list-item-body>
                        </fo:list-item>
                      </fo:list-block>
                    </fo:block>
                  </fo:footnote-body>
                </fo:footnote>
              </fo:block>
              <fo:block>line 4</fo:block>
              <fo:block>line 5</fo:block>
              <fo:block>line 6</fo:block>
              <fo:block>line 7</fo:block>
              <fo:block>line 8</fo:block>
              <fo:block>line 9
                <fo:footnote><fo:inline font-size="6pt" vertical-align="top">[*]</fo:inline>
                  <fo:footnote-body>
                    <fo:block>
                      <fo:list-block>
                        <fo:list-item>
                          <fo:list-item-label end-indent="label-end()" start-indent="0">
                            <fo:block>
                              <fo:inline font-size="6pt" vertical-align="top">[*]</fo:inline>
                            </fo:block>
                          </fo:list-item-label>
                          <fo:list-item-body start-indent="0.4cm">
                            <fo:block>footnote footnote footnote footnote footnote footnote footnote footnote</fo:block>
                          </fo:list-item-body>
                        </fo:list-item>
                      </fo:list-block>
                    </fo:block>
                  </fo:footnote-body>
                </fo:footnote>
              </fo:block>
              <fo:block>line 10</fo:block>
              <fo:block>line 11</fo:block>
              <fo:block>line 12</fo:block>
              <fo:block>line 13</fo:block>
              <fo:block>line 14</fo:block>
              <fo:block>line 15</fo:block>
              <fo:block>line 16</fo:block>
              <fo:block>line 17
                <fo:footnote><fo:inline font-size="6pt" vertical-align="top">[*]</fo:inline>
                  <fo:footnote-body>
                    <fo:block>
                      <fo:list-block>
                        <fo:list-item>
                          <fo:list-item-label end-indent="label-end()" start-indent="0">
                            <fo:block>
                              <fo:inline font-size="6pt" vertical-align="top">[*]</fo:inline>
                            </fo:block>
                          </fo:list-item-label>
                          <fo:list-item-body start-indent="0.4cm">
                            <fo:block>footnote footnote footnote footnote footnote footnote footnote footnote</fo:block>
                          </fo:list-item-body>
                        </fo:list-item>
                      </fo:list-block>
                    </fo:block>
                  </fo:footnote-body>
                </fo:footnote>
              </fo:block>
              <fo:block>line 18</fo:block>
              <fo:block>line 19</fo:block>
              <fo:block>line 20</fo:block>
              <fo:block>line 21</fo:block>
              <fo:block>line 22</fo:block>
              <fo:block>line 23</fo:block>
              <fo:block>line 24</fo:block>
              <fo:block>line 25</fo:block>
              <fo:block>line 26</fo:block>
              <fo:block>line 27</fo:block>
              <fo:block>line 28</fo:block>
              <fo:block>line 29</fo:block>
              <fo:block>line 30</fo:block>
              <fo:block>line 31</fo:block>
              <fo:block>line 32</fo:block>
              <fo:block>line 33</fo:block>
              <fo:block>line 34</fo:block>
              <fo:block>line 35</fo:block>
            </fo:block>
          </fo:flow>
       </fo:page-sequence>
     </fo:root>
   </fo>
   <checks>
    <!-- Page 1 -->
    <!-- 2 lines of footnote content -->
    <eval expected="2" xpath="count((/*/*/*/page)[1]//footnote//lineArea[not(.//text/word='[*]')])" />
    <!-- 4 lines in first column -->
    <!--eval expected="4" xpath="count((/*/*/*/page)[1]//flow[1]//lineArea)"/-->
    <!-- 4 lines in second column -->
    <eval expected="4" xpath="count((/*/*/*/page)[1]//flow[2]//lineArea)"/>
    <!-- 4 lines in third column -->
    <eval expected="4" xpath="count((/*/*/*/page)[1]//flow[3]//lineArea)"/>
    <!-- Page 2 -->
    <!-- 1 line of footnote content -->
    <eval expected="1" xpath="count((/*/*/*/page)[2]//footnote//lineArea[not(.//text/word='[*]')])" />
    <!-- 5 lines in first column -->
    <eval expected="5" xpath="count((/*/*/*/page)[2]//flow[1]//lineArea)"/>
    <!-- 5 lines in second column -->
    <eval expected="5" xpath="count((/*/*/*/page)[2]//flow[2]//lineArea)"/>
    <!-- 5 lines in third column -->
    <eval expected="5" xpath="count((/*/*/*/page)[2]//flow[3]//lineArea)"/>
   </checks>
</testcase>




package org.apache.fop.layoutmgr;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;

    /** List of PageBreakPosition elements. */
    private LinkedList<PageBreakPosition> pageBreaks = null;

    private final class Footnotes {

        // demerits for a page break that splits a footnote
        static final int SPLIT_FOOTNOTE_DEMERITS = 5000;
        // demerits for a page break that defers a whole footnote to the following page
        static final int DEFERRED_FOOTNOTE_DEMERITS = 10000;

        // the length of the footnote separator
        private MinOptMax separatorLength = null;

        /** Footnotes which are cited between the currently considered active node (previous
         * break) and the current considered break. Its type is
         * List&lt;List&lt;KnuthElement&gt;&gt;, it contains the sequences of KnuthElement
         * representing the footnotes bodies.
         */
        private List<List<KnuthElement>> footnotesList = null;
        /** Cumulated bpd of unhandled footnotes. */
        private List<Integer> lengthList = null;
        /** Length of all the footnotes which will be put on the current page. */
        private int totalLength = 0;

     * considered element. That is, footnotes from the currently considered page plus
     * footnotes from its preceding pages.
     */
        /**
         * Length of all the footnotes which have already been inserted, up to the currently
         * considered element. That is, footnotes from the currently considered page plus
         * footnotes from its preceding pages.
         */
        private int insertedFootnotesLength;

        /** True if footnote citations have been met since the beginning of the page sequence. */
        private boolean footnotesPending = false;
        /** True if the elements met after the previous break point contain footnote citations. */
        private boolean newFootnotes = false;
        /** Index of the first footnote met after the previous break point. */
        private int firstNewFootnoteIndex = 0;
        /** Index of the last footnote inserted on the current page. */
        private int listIndex;
        /** Index of the last element of the last footnote inserted on the current page. */
        private int elementIndex;

        private Footnotes() {
        }
    // demerits for a page break that defers a whole footnote to the following page
    private int deferredFootnoteDemerits = 10000;
    private MinOptMax footnoteSeparatorLength = null;

        void initialize() {
            footnotes.insertedFootnotesLength = 0;
            footnotes.listIndex = 0;
            footnotes.elementIndex = -1;
        }

        /**
         * Handles the footnotes cited inside a block-level box. Updates footnotesList and the
         * value of totalLength with the lengths of the given footnotes.
         * @param elementLists list of KnuthElement sequences corresponding to the footnotes
         * bodies
         */
        void handleFootnotes(List<List<KnuthElement>> elementLists) {
            // initialization
            if (!footnotesPending) {
                footnotesPending = true;
                footnotesList = new ArrayList<List<KnuthElement>>();
                lengthList = new ArrayList<Integer>();
                totalLength = 0;
            }
            if (!newFootnotes) {
                newFootnotes = true;
                firstNewFootnoteIndex = footnotesList.size();
            }

            // compute the total length of the footnotes
            for (List<KnuthElement> noteList : elementLists) {

                //Space resolution (Note: this does not respect possible stacking constraints
                //between footnotes!)
                SpaceResolver.resolveElementList(noteList);

                footnotesList.add(noteList);
                int noteLength = ElementListUtils.calcContentLength(noteList);
                int prevLength = (lengthList == null || lengthList.isEmpty())
                        ? 0
                        : ListUtil.getLast(lengthList);
                if (lengthList != null) {
                    lengthList.add(prevLength + noteLength);
                }
                totalLength += noteLength;
            }
        }

        void resetFootnotes(int fromIndex, int toIndex) {
            newFootnotes = false;
            if (footnotesPending) {
                // remove from footnotesList the note lists that will be met
                // after the restarting point
                KnuthElement resetElement;
                int start = footnotesList.size();
                int end = start;
                for (int j = toIndex; j >= fromIndex; j--) {
                    resetElement = getElement(j);
                    if (resetElement instanceof KnuthBlockBox
                            && ((KnuthBlockBox) resetElement).hasAnchors()) {
                        start -= ((KnuthBlockBox) resetElement).getElementLists().size();
                    }
                }
                footnotesList.subList(start, end).clear();
                lengthList.subList(start, end).clear();
                // update totalLength
                totalLength = (lengthList.isEmpty() ? 0 : ListUtil.getLast(lengthList));
                // update footnotesPending;
                footnotesPending = !footnotesList.isEmpty();
                listIndex = footnotesList.size() - 1;
                elementIndex = (listIndex < 0
                        ? -1 : getList(listIndex).size() - 1);
            }
        }

        int getDifference(KnuthPageNode pageNode, int elementIndex) {

            int contentWidth = totalWidth - pageNode.totalWidth;

            int totalIntrusions = 0;

            // compute the total length of the footnotes not yet inserted
            int allFootnotes = totalLength;
            KnuthPageNode lastPageNode = pageNode;
            while (lastPageNode != null
                    && !pageProvider.endPage(lastPageNode.line - 1)) {
                lastPageNode = (KnuthPageNode) lastPageNode.previous;
            }
            allFootnotes -= (lastPageNode == null ? 0 : lastPageNode.totalFootnotes);

            if (allFootnotes > 0) {
                // this page/column contains some footnote citations
                // add the footnote separator width
                totalIntrusions += separatorLength.getOpt();
                totalIntrusions += allFootnotes;
                insertedFootnotesLength = totalLength;
                listIndex = footnotesList.size() - 1;
                this.elementIndex = getList(listIndex).size() - 1;

                int availableWidth = getLineWidth(pageNode.line);
                if ((contentWidth + totalIntrusions) > availableWidth) {
                    // see if part of the footnotes can be deferred
                    boolean canDeferOldFN = canDeferOldFootnotes(pageNode, elementIndex);
                    if (canDeferOldFN || newFootnotes) {
                        availableWidth -= (contentWidth + separatorLength.getOpt());
                        int footnoteSplit = (availableWidth <= 0 ? 0
                                : getFootnoteSplit(pageNode, availableWidth, canDeferOldFN));
                        if (footnoteSplit > 0) {
                            // the total of content + separator + all footnotes does not fit, but
                            // it is allowed to break or even defer footnotes if either:
                            //  - there are new footnotes in the last piece of content, and
                            //    there is space to add at least a piece of the first one
                            //  - or the previous page break deferred some footnote lines, and
                            //    this is the first feasible break; in this case it is allowed
                            //    to break and defer, if necessary, old and new footnotes
                            totalIntrusions -= allFootnotes;
                            totalIntrusions += footnoteSplit;
                            insertedFootnotesLength = pageNode.totalFootnotes + footnoteSplit;
                            // listIndex has been set in getFootnoteSplit()
                            // elementIndex has been set in getFootnoteSplit()
                        } else {
                            // there is no space to add even the smallest piece of footnote,
                            // the whole allFootnotes length was added, so this breakpoint
                            // will be discarded
                        }
                    } else {
                        // we are trying to add a piece of content with no footnotes and
                        // it does not fit in the page, because of previous footnote bodies
                        // that cannot be broken:
                        // the whole allFootnotes length was added, so this breakpoint
                        // will be discarded
                    }
                }
            } else {
                // all footnotes have already been placed on previous pages
            }

            return totalIntrusions;
        }

        int getDemerits() {
            int demerits = 0;
            if (footnotes.listIndex < footnotes.footnotesList.size() - 1) {
                // add demerits for the deferred footnotes
                demerits += (footnotes.footnotesList.size() - 1 - footnotes.listIndex)
                                * DEFERRED_FOOTNOTE_DEMERITS;
            }
            if (footnotes.elementIndex
                    < getList(footnotes.listIndex).size() - 1) {
                // add demerits for the footnote split between pages
                demerits += SPLIT_FOOTNOTE_DEMERITS;
            }
            return demerits;
        }

        boolean deferredFootnotes(int listIndex, int elementIndex, int length) {
            return ((newFootnotes
                     && firstNewFootnoteIndex != 0
                     && (listIndex < firstNewFootnoteIndex - 1
                         || elementIndex < getList(listIndex).size() - 1))
                    || length < totalLength);
        }

        int getFootnoteSplit(int availableLength) {
            return getFootnoteSplit(listIndex,
                    elementIndex,
                    totalLength,
                                    availableLength, true);
        }

        int getFootnoteSplit(KnuthPageNode activeNode, int availableLength,
                    boolean canDeferOldFootnotes) {
            return getFootnoteSplit(activeNode.footnoteListIndex,
                                    activeNode.footnoteElementIndex,
                                    activeNode.totalFootnotes,
                                    availableLength, canDeferOldFootnotes);
        }

        int getFootnoteSplit(int prevListIndex, int prevElementIndex, int prevLength,
                                     int availableLength, boolean canDeferOldFootnotes) {

            // the split should contain a piece of the last footnote
            // together with all previous, not yet inserted footnotes;
            // but if this is not possible, try adding as much content as possible
            int splitLength = 0;
            ListIterator<KnuthElement> noteListIterator;
            KnuthElement element;
            boolean somethingAdded = false;

            // prevListIndex and prevElementIndex points to the last footnote element
            // already placed in a page: advance to the next element
            int listIndex = prevListIndex;
            int elementIndex = prevElementIndex;
            if (elementIndex == getList(listIndex).size() - 1) {
                listIndex++;
                elementIndex = 0;
            } else {
                elementIndex++;
            }

            // try adding whole notes
            if (footnotesList.size() - 1 > listIndex) {
                // add the previous footnotes: these cannot be broken or deferred
                if (!canDeferOldFootnotes && newFootnotes && firstNewFootnoteIndex > 0) {
                    splitLength = lengthList.get(firstNewFootnoteIndex - 1) - prevLength;
                    listIndex = firstNewFootnoteIndex;
                    elementIndex = 0;
                }
                // try adding the new footnotes
                while (lengthList.get(listIndex) - prevLength <= availableLength) {
                    splitLength = lengthList.get(listIndex) - prevLength;
                    somethingAdded = true;
                    listIndex++;
                    elementIndex = 0;
                }
                // as this method is called only if it is not possible to insert
                // all footnotes, at this point listIndex and elementIndex points to
                // an existing element, the next one we will try to insert
            }

            // try adding a split of the next note
            noteListIterator = getList(listIndex).listIterator(elementIndex);

            int prevSplitLength = 0;
            int prevIndex = -1;
            int index = -1;

            while (!somethingAdded || splitLength <= availableLength) {
                if (!somethingAdded) {
                    somethingAdded = true;
                } else {
                    prevSplitLength = splitLength;
                    prevIndex = index;
                }

                // get a sub-sequence from the note element list
                boolean boxPreceding = false;
                while (noteListIterator.hasNext()) {
                    // as this method is called only if it is not possible to insert
                    // all footnotes, and we have already tried (and failed) to insert
                    // this whole footnote, the while loop will never reach the end
                    // of the note sequence
                    element = noteListIterator.next();
                    if (element.isBox()) {
                        // element is a box
                        splitLength += element.getWidth();
                        boxPreceding = true;
                    } else if (element.isGlue()) {
                        // element is a glue
                        if (boxPreceding) {
                            // end of the sub-sequence
                            index = noteListIterator.previousIndex();
                            break;
                        }
                        boxPreceding = false;
                        splitLength += element.getWidth();
                    } else {
                        // element is a penalty
                        if (element.getPenalty() < KnuthElement.INFINITE) {
                            // end of the sub-sequence
                            index = noteListIterator.previousIndex();
                            break;
                        }
                    }
                }
            }

            // if prevSplitLength is 0, this means that the available length isn't enough
            // to insert even the smallest split of the last footnote, so we cannot end a
            // page here
            // if prevSplitLength is > 0 we can insert some footnote content in this page
            // and insert the remaining in the following one
            //TODO: check this conditional, as the first one is always false...?
            if (!somethingAdded) {
                // there was not enough space to add a piece of the first new footnote
                // this is not a good break
                prevSplitLength = 0;
            } else if (prevSplitLength > 0) {
                // prevIndex is -1 if we have added only some whole footnotes
                this.listIndex = (prevIndex != -1) ? listIndex : listIndex - 1;
                this.elementIndex = (prevIndex != -1)
                    ? prevIndex
                    : getList(this.listIndex).size() - 1;
            }
            return prevSplitLength;
        }

        boolean footnotesRemaining() {
            return insertedFootnotesLength < totalLength;
        }

        int currentLength() {
            return lengthList.get(listIndex);
        }

        List<KnuthElement> getList(int index) {
            return footnotesList.get(index);
        }
    }

    private Footnotes footnotes;

    // the method noBreakBetween(int, int) uses these variables
    // to store parameters and result of the last call, in order
    // to reuse them and take less time

        this.pageProvider = pageProvider;
        this.layoutListener = layoutListener;
        best = new BestPageRecords();
        this.footnotes = new Footnotes();
        this.footnotes.separatorLength = footnoteSeparatorLength;
        this.autoHeight = autoHeight;
        this.favorSinglePart = favorSinglePart;
    }

            this.footnoteElementIndex = footnoteElementIndex;
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder(super.toString());
            sb.deleteCharAt(sb.length() - 1);
            sb.append(" totalFootnotes:").append(totalFootnotes);
            sb.append(" footnoteList:").append(footnoteListIndex);
            sb.append(" footnoteElement:").append(footnoteElementIndex).append('>');
            return sb.toString();
        }
    }

    /**
     * this class stores information about how the nodes

            super.addRecord(demerits, node, adjust,
                            availableShrink, availableStretch,
                            difference, fitness);
            bestFootnotesLength[fitness] = footnotes.insertedFootnotesLength;
            bestFootnoteListIndex[fitness] = footnotes.listIndex;
            bestFootnoteElementIndex[fitness] = footnotes.elementIndex;
        }

        public int getFootnotesLength(int fitness) {

    @Override
    protected void initialize() {
        super.initialize();
        footnotes.initialize();
        footnoteListIndex = 0;
        footnoteElementIndex = -1;
    }

    /**

        return super.compareNodes(node1, node2);
    }

    /** {@inheritDoc} */
    @Override
    protected KnuthNode createNode(int position,                // CSOK: ParameterNumber
                                   int line, int fitness,

                                   int difference, double totalDemerits, KnuthNode previous) {
        return new KnuthPageNode(position, line, fitness,
                                 totalWidth, totalStretch, totalShrink,
                                 footnotes.insertedFootnotesLength,
                                 footnotes.listIndex,
                                 footnotes.elementIndex,
                                 adjustRatio, availableShrink, availableStretch,
                                 difference, totalDemerits, previous);
    }

    /** {@inheritDoc} */
    @Override
    protected KnuthNode createNode(int position, int line, int fitness,
                                   int totalWidth, int totalStretch, int totalShrink) {

        super.handleBox(box);
        if (box instanceof KnuthBlockBox
            && ((KnuthBlockBox) box).hasAnchors()) {
            footnotes.handleFootnotes(((KnuthBlockBox) box).getElementLists());
            if (!footnotes.newFootnotes) {
                footnotes.newFootnotes = true;
                footnotes.firstNewFootnoteIndex = footnotes.footnotesList.size() - 1;
            }
        }
    }

        }
    }

    /**
     * Handles the footnotes cited inside a block-level box. Updates footnotesList and the
     * value of totalFootnotesLength with the lengths of the given footnotes.
     * @param elementLists list of KnuthElement sequences corresponding to the footnotes
     * bodies
     */
    private void handleFootnotes(List<List<KnuthElement>> elementLists) {
        // initialization
        if (!footnotesPending) {
            footnotesPending = true;
            footnotesList = new ArrayList<List<KnuthElement>>();
            lengthList = new ArrayList<Integer>();
            totalFootnotesLength = 0;
        }
        if (!newFootnotes) {
            newFootnotes = true;
            firstNewFootnoteIndex = footnotesList.size();
        }

        // compute the total length of the footnotes
        for (List<KnuthElement> noteList : elementLists) {

            //Space resolution (Note: this does not respect possible stacking constraints
            //between footnotes!)
            SpaceResolver.resolveElementList(noteList);

            int noteLength = 0;
            footnotesList.add(noteList);
            for (KnuthElement element : noteList) {
                if (element.isBox() || element.isGlue()) {
                    noteLength += element.getWidth();
                }
            }
            int prevLength = (lengthList == null || lengthList.isEmpty())
                    ? 0
                    : ListUtil.getLast(lengthList);
            if (lengthList != null) {
                lengthList.add(prevLength + noteLength);
            }
            totalFootnotesLength += noteLength;
        }
    }

    /** {@inheritDoc} */
    @Override
    protected int restartFrom(KnuthNode restartingNode, int currentIndex) {
        int returnValue = super.restartFrom(restartingNode, currentIndex);
        footnotes.resetFootnotes(restartingNode.position, currentIndex);
        if (footnotesPending) {
            // remove from footnotesList the note lists that will be met
            // after the restarting point
            for (int j = currentIndex; j >= restartingNode.position; j--) {
                final KnuthElement resetElement = getElement(j);
                if (resetElement instanceof KnuthBlockBox
                        && ((KnuthBlockBox) resetElement).hasAnchors()) {
                    resetFootnotes(((KnuthBlockBox) resetElement).getElementLists());
                }
            }
        }
        return returnValue;
    }

    private void resetFootnotes(List<List<KnuthElement>> elementLists) {
        for (int i = 0; i < elementLists.size(); i++) {
            ListUtil.removeLast(footnotesList);
            ListUtil.removeLast(lengthList);

            // update totalFootnotesLength
            if (!lengthList.isEmpty()) {
                totalFootnotesLength = ListUtil.getLast(lengthList);
            } else {
                totalFootnotesLength = 0;
            }
        }
        // update footnotesPending;
        if (footnotesList.size() == 0) {
            footnotesPending = false;
        }
    }

    /** {@inheritDoc} */
    @Override
    protected void considerLegalBreak(KnuthElement element, int elementIdx) {
        if (element.isPenalty()) {

            }
        }
        super.considerLegalBreak(element, elementIdx);
        footnotes.newFootnotes = false;
    }

    /** {@inheritDoc} */
    @Override
    protected boolean elementCanEndLine(KnuthElement element, int line, int difference) {
        if (!(element.isPenalty()) || pageProvider == null) {

        }
    }

    /** {@inheritDoc} */
    @Override
    protected int computeDifference(KnuthNode activeNode, KnuthElement element,
                                    int elementIndex) {

        int diff = super.computeDifference(activeNode, element, elementIndex);
        //getLineWidth() for auto-height parts return 0 so the diff will be negative
        //...but we don't want to shrink in this case. Stick to optimum.
        return (autoHeight && (diff < 0) ? 0 : diff);
            actualWidth += element.getWidth();
    }

    @Override
    protected boolean hasOutOfLineIntrusions() {
        return footnotes.footnotesPending;
                // this page contains some footnote citations
                // add the footnote separator width
                actualWidth += footnoteSeparatorLength.getOpt();
                if (actualWidth + allFootnotes <= getLineWidth(activeNode.line)) {
                    // there is enough space to insert all footnotes:
                    // add the whole allFootnotes length
                    actualWidth += allFootnotes;
                    insertedFootnotesLength = pageNode.totalFootnotes + allFootnotes;
                    footnoteListIndex = footnotesList.size() - 1;
                    footnoteElementIndex
                        = getFootnoteList(footnoteListIndex).size() - 1;
                } else if (((canDeferOldFN = canDeferOldFootnotes // CSOK: InnerAssignment
                             (pageNode, elementIndex))
                            || newFootnotes)
                           && (footnoteSplit = getFootnoteSplit // CSOK: InnerAssignment
                               (pageNode, getLineWidth(activeNode.line) - actualWidth,
                                canDeferOldFN)) > 0) {
                    // it is allowed to break or even defer footnotes if either:
                    //  - there are new footnotes in the last piece of content, and
                    //    there is space to add at least a piece of the first one
                    //  - or the previous page break deferred some footnote lines, and
                    //    this is the first feasible break; in this case it is allowed
                    //    to break and defer, if necessary, old and new footnotes
                    actualWidth += footnoteSplit;
                    insertedFootnotesLength = pageNode.totalFootnotes + footnoteSplit;
                    // footnoteListIndex has been set in getFootnoteSplit()
                    // footnoteElementIndex has been set in getFootnoteSplit()
                } else {
                    // there is no space to add the smallest piece of footnote,
                    // or we are trying to add a piece of content with no footnotes and
                    // it does not fit in the page, because of previous footnote bodies
                    // that cannot be broken:
                    // add the whole allFootnotes length, so this breakpoint will be discarded
                    actualWidth += allFootnotes;
                    insertedFootnotesLength = pageNode.totalFootnotes + allFootnotes;
                    footnoteListIndex = footnotesList.size() - 1;
                    footnoteElementIndex
                        = getFootnoteList(footnoteListIndex).size() - 1;
    }

    @Override
    protected int getOutOfLineIntrusions(KnuthNode activeNode, int elementIndex) {

        assert (activeNode != null);
        KnuthPageNode pageNode = (KnuthPageNode) activeNode;
        int totalIntrusions = 0;

        if (footnotes.footnotesPending) {
            totalIntrusions += footnotes.getDifference(pageNode, elementIndex);
        } else {
                // all footnotes have already been placed on previous pages
            }
        } else {
            // there are no footnotes
        }

        return totalIntrusions;
            //getLineWidth() for auto-height parts return 0 so the diff will be negative
            return 0; //...but we don't want to shrink in this case. Stick to optimum.
        } else {
            return diff;
    }
    }

    /**
     * Checks whether footnotes from preceding pages may be deferred to the page after

     */
    private boolean canDeferOldFootnotes(KnuthPageNode node, int contentElementIndex) {
        return (noBreakBetween(node.position, contentElementIndex)
                && footnotes.deferredFootnotes(node.footnoteListIndex,
                node.footnoteElementIndex, node.totalFootnotes));
    }

    /**

        return storedValue;
    }

    /**
     * Returns true if their are (pieces of) footnotes to be typeset on the current page.
     * @param listIndex index of the last inserted footnote for the currently considered
     * active node
     * @param elementIndex index of the last element of the last inserted footnote
     * @param length total length of all footnotes inserted so far
     */
    private boolean deferredFootnotes(int listIndex, int elementIndex, int length) {
        return ((newFootnotes
                 && firstNewFootnoteIndex != 0
                 && (listIndex < firstNewFootnoteIndex - 1
                     || elementIndex < getFootnoteList(listIndex).size() - 1))
                || length < totalFootnotesLength);
    }

    /**
     * Tries to split the flow of footnotes to put one part on the current page.
     * @param activeNode currently considered previous page break
     * @param availableLength available space for footnotes
     * @param canDeferOldFootnotes
     * @return ...
     */
    private int getFootnoteSplit(KnuthPageNode activeNode, int availableLength,
                boolean canDeferOldFootnotes) {
        return getFootnoteSplit(activeNode.footnoteListIndex,
                                activeNode.footnoteElementIndex,
                                activeNode.totalFootnotes,
                                availableLength, canDeferOldFootnotes);
    }

    /**
     * Tries to split the flow of footnotes to put one part on the current page.
     * @param prevListIndex index of the last footnote on the previous page
     * @param prevElementIndex index of the last element of the last footnote
     * @param prevLength total length of footnotes inserted so far
     * @param availableLength available space for footnotes on this page
     * @param canDeferOldFootnotes
     * @return ...
     */
    private int getFootnoteSplit(int prevListIndex, int prevElementIndex, int prevLength,
                                 int availableLength, boolean canDeferOldFootnotes) {
        if (availableLength <= 0) {
            return 0;
        } else {
            // the split should contain a piece of the last footnote
            // together with all previous, not yet inserted footnotes;
            // but if this is not possible, try adding as much content as possible
            int splitLength = 0;
            ListIterator<KnuthElement> noteListIterator;
            KnuthElement element;
            boolean somethingAdded = false;

            // prevListIndex and prevElementIndex points to the last footnote element
            // already placed in a page: advance to the next element
            int listIndex = prevListIndex;
            int elementIndex = prevElementIndex;
            if (elementIndex == getFootnoteList(listIndex).size() - 1) {
                listIndex++;
                elementIndex = 0;
            } else {
                elementIndex++;
            }

            // try adding whole notes
            if (footnotesList.size() - 1 > listIndex) {
                // add the previous footnotes: these cannot be broken or deferred
                if (!canDeferOldFootnotes && newFootnotes && firstNewFootnoteIndex > 0) {
                    splitLength = lengthList.get(firstNewFootnoteIndex - 1) - prevLength;
                    listIndex = firstNewFootnoteIndex;
                    elementIndex = 0;
                }
                // try adding the new footnotes
                while (lengthList.get(listIndex) - prevLength
                       <= availableLength) {
                    splitLength = lengthList.get(listIndex) - prevLength;
                    somethingAdded = true;
                    listIndex++;
                    elementIndex = 0;
                }
                // as this method is called only if it is not possible to insert
                // all footnotes, at this point listIndex and elementIndex points to
                // an existing element, the next one we will try to insert
            }

            // try adding a split of the next note
            noteListIterator = getFootnoteList(listIndex).listIterator(elementIndex);

            int prevSplitLength = 0;
            int prevIndex = -1;
            int index = -1;

            while (!(somethingAdded && splitLength > availableLength)) {
                if (!somethingAdded) {
                    somethingAdded = true;
                } else {
                    prevSplitLength = splitLength;
                    prevIndex = index;
                }
                // get a sub-sequence from the note element list
                boolean boxPreceding = false;
                while (noteListIterator.hasNext()) {
                    // as this method is called only if it is not possible to insert
                    // all footnotes, and we have already tried (and failed) to insert
                    // this whole footnote, the while loop will never reach the end
                    // of the note sequence
                    element = noteListIterator.next();
                    if (element.isBox()) {
                        // element is a box
                        splitLength += element.getWidth();
                        boxPreceding = true;
                    } else if (element.isGlue()) {
                        // element is a glue
                        if (boxPreceding) {
                            // end of the sub-sequence
                            index = noteListIterator.previousIndex();
                            break;
                        }
                        boxPreceding = false;
                        splitLength += element.getWidth();
                    } else {
                        // element is a penalty
                        if (element.getPenalty() < KnuthElement.INFINITE) {
                            // end of the sub-sequence
                            index = noteListIterator.previousIndex();
                            break;
                        }
                    }
                }
            }

            // if prevSplitLength is 0, this means that the available length isn't enough
            // to insert even the smallest split of the last footnote, so we cannot end a
            // page here
            // if prevSplitLength is > 0 we can insert some footnote content in this page
            // and insert the remaining in the following one
            //TODO: check this conditional, as the first one is always false...?
            if (!somethingAdded) {
                // there was not enough space to add a piece of the first new footnote
                // this is not a good break
                prevSplitLength = 0;
            } else if (prevSplitLength > 0) {
                // prevIndex is -1 if we have added only some whole footnotes
                footnoteListIndex = (prevIndex != -1) ? listIndex : listIndex - 1;
                footnoteElementIndex = (prevIndex != -1)
                    ? prevIndex
                    : getFootnoteList(footnoteListIndex).size() - 1;
            }
            return prevSplitLength;
        }
    }

    /** {@inheritDoc} */
    @Override
    protected double computeAdjustmentRatio(KnuthNode activeNode, int difference) {
        // compute the adjustment ratio
        if (difference > 0) {
            int maxAdjustment = totalStretch - activeNode.totalStretch;
            // add the footnote separator stretch if some footnote content will be added
            if (((KnuthPageNode) activeNode).totalFootnotes < footnotes.totalLength) {
                maxAdjustment += footnotes.separatorLength.getStretch();
            }
            if (maxAdjustment > 0) {
                return (double) difference / maxAdjustment;

        } else if (difference < 0) {
            int maxAdjustment = totalShrink - activeNode.totalShrink;
            // add the footnote separator shrink if some footnote content will be added
            if (((KnuthPageNode) activeNode).totalFootnotes < footnotes.totalLength) {
                maxAdjustment += footnotes.separatorLength.getShrink();
            }
            if (maxAdjustment > 0) {
                return (double) difference / maxAdjustment;

        }
    }

    /** {@inheritDoc} */
    @Override
    protected double computeDemerits(KnuthNode activeNode, KnuthElement element,
                                    int fitnessClass, double r) {

        // compute demerits
        double f = Math.abs(r);
        f = 1 + 100 * f * f * f;

        if (element.isPenalty()) {
            double penalty = element.getPenalty();
            if (penalty >= 0) {
                f += penalty;
                demerits = f * f;
            } else if (!element.isForcedBreak()) {
                demerits -= penalty * penalty;
            } else {
                demerits = f * f;
            }
        } else {
            demerits = f * f;
        }
        demerits += f * f;

        if (element.isPenalty() && ((KnuthPenalty) element).isPenaltyFlagged()
            && getElement(activeNode.position).isPenalty()

            demerits += incompatibleFitnessDemerit;
        }

        if (footnotes.footnotesPending) {
            demerits += footnotes.getDemerits();
                // add demerits for the deferred footnotes
                demerits += (footnotesList.size() - 1 - footnoteListIndex)
                                * deferredFootnoteDemerits;
        }
            if (footnoteListIndex < footnotesList.size()) {
                if (footnoteElementIndex
                        < getFootnoteList(footnoteListIndex).size() - 1) {
                    // add demerits for the footnote split between pages
                    demerits += splitFootnoteDemerits;
                }
            } else {
                //TODO Why can this happen in the first place? Does anybody know? See #44160
            }
        }
        demerits += activeNode.totalDemerits;
        return demerits;
    }

    /** {@inheritDoc} */
    @Override
    protected void finish() {
        for (int i = startLine; i < endLine; i++) {
            for (KnuthPageNode node = (KnuthPageNode) getNode(i);
                 node != null;
                 node = (KnuthPageNode) node.next) {
                if (node.totalFootnotes < footnotes.totalLength) {
                    // layout remaining footnote bodies
                    createFootnotePages(node);
                }


    private void createFootnotePages(KnuthPageNode lastNode) {

        footnotes.insertedFootnotesLength = lastNode.totalFootnotes;
        footnotes.listIndex = lastNode.footnoteListIndex;
        footnotes.elementIndex = lastNode.footnoteElementIndex;
        int availableBPD = getLineWidth(lastNode.line);
        int split = 0;
        KnuthPageNode prevNode = lastNode;

        // create pages containing the remaining footnote bodies
        while (footnotes.footnotesRemaining()) {
            final int remaining = footnotes.currentLength() - footnotes.insertedFootnotesLength;

            // try adding some more content
            if (remaining <= availableBPD) {
                // all fits, so just add everything
                availableBPD -= remaining;
                footnotes.insertedFootnotesLength = footnotes.currentLength();
                footnotes.elementIndex
                    = getFootnoteList(footnotes.listIndex).size() - 1;
            } else {
                int split = footnotes.getFootnoteSplit(availableBPD);
                if (split > 0) {
                    // add a piece of a footnote
                    availableBPD -= split;
                    footnotes.insertedFootnotesLength += split;
                    // listIndex has already been set in getFootnoteSplit()
                    // elementIndex has already been set in getFootnoteSplit()
                } else {
                    // cannot add any content: create a new node and start again
                    KnuthPageNode node = (KnuthPageNode)
                            createNode(lastNode.position, prevNode.line + 1, 1,
                                    footnotes.insertedFootnotesLength - prevNode.totalFootnotes,
                                    0, 0,
                                    0, 0, 0,
                                    0, 0, prevNode);
                    addNode(node.line, node);
                    removeNode(prevNode.line, prevNode);

                    prevNode = node;
                    availableBPD = getLineWidth(node.line);
                }
            }
        }

        // create the last node
        KnuthPageNode node = (KnuthPageNode)
                             createNode(lastNode.position, prevNode.line + 1, 1,
                                        footnotes.totalLength - prevNode.totalFootnotes, 0, 0,
                                        0, 0, 0,
                                        0, 0, prevNode);
        addNode(node.line, node);

        pageBreaks.subList(0, pageBreaks.size() - 1).clear();
    }

    /** {@inheritDoc} */
    @Override
    public void updateData1(int total, double demerits) {
    }

    /** {@inheritDoc} */
    @Override
    public void updateData2(KnuthNode bestActiveNode,
                            KnuthSequence sequence,

        // compute the indexes of the first footnote list and the first element in that list
        int firstListIndex = ((KnuthPageNode) bestActiveNode.previous).footnoteListIndex;
        int firstElementIndex = ((KnuthPageNode) bestActiveNode.previous).footnoteElementIndex;
        if (footnotes.footnotesList != null
                && firstElementIndex == getFootnoteList(firstListIndex).size() - 1) {
            // advance to the next list
            firstListIndex++;

                ratio, difference));
    }

    /** {@inheritDoc} */
    @Override
    protected int filterActiveNodes() {
        // leave only the active node with fewest total demerits

     * @return  the element-list
     */
    protected final List<KnuthElement> getFootnoteList(int index) {
        return footnotes.getList(index);
    }

    /** @return the associated top-level formatting object. */

        return topLevelLM.getFObj();
    }

    /** {@inheritDoc} */
    @Override
    protected int getLineWidth(int line) {
        int bpd;


    }

    /** {@inheritDoc} */
    @Override
    protected int getIPDdifference() {
        return ipdDifference;
    }

    /** {@inheritDoc} */
    @Override
    protected int handleIpdChange() {
        log.trace("Best node for ipd change:" + bestNodeForIPDChange);




            this.previous = previous;
        }

        @Override
        public String toString() {
            return new StringBuilder(64).append("<")
                    .append(this.getClass().getSimpleName())
                    .append(" at ").append(position)
                    .append(" ").append(totalWidth)
                    .append("+").append(totalStretch)
                    .append("-").append(totalShrink)
                    .append(" line:").append(line)
                    .append(" prev:").append(previous != null ? previous.position : -1)
                    .append(" dem:").append(totalDemerits)
                    .append(" fitness:").append(FitnessClasses.NAMES[fitness])
                    .append(">").toString();
        }
    }


                this.par.add(0, KnuthPenalty.DUMMY_ZERO_PENALTY);
            }
        }

        // content would overflow, insert empty line/page and try again
        return createNode(
                lastTooLong.previous.position, lastTooLong.previous.line + 1, 1,

     */
    protected int computeDifference(KnuthNode activeNode, KnuthElement element,
                                    int elementIndex) {
        // compute the difference
        int diff = getLineWidth(activeNode.line);
        diff -= (totalWidth - activeNode.totalWidth);
        if (element.isPenalty()) {
            diff -= element.getWidth();
        }
        if (hasOutOfLineIntrusions()) {
            diff -= getOutOfLineIntrusions(activeNode, elementIndex);
        }
        return diff;
    }

    /**
     * Hook for subclasses to handle out-of-line content (floats/footnotes).
     * <br/>Default implementation returns {@code false}. Should be overridden
     * by subclasses if/when appropriate.
     * @return  {@code true} if the currently active node would have out-of-line
     *          content intruding on the line
     */
    protected boolean hasOutOfLineIntrusions() {
        return false;
    }

    /**
     * Hook for subclasses to handle out-of-line content (floats/footnotes).
     * This method is called by {@link #computeDifference(KnuthNode, KnuthElement, int)},
     * if {@link #hasOutOfLineIntrusions()} returns {@code true}.
     *
     * @param activeNode    the currently active node
     * @param elementIndex  the element's index
     * @return  the width corresponding to the total out-of-line intrusions
     *          (including static separators)
     */
    protected int getOutOfLineIntrusions(KnuthNode activeNode, int elementIndex) {
        return 0;
    }

    /**
     * Return the adjustment ratio needed to make up for the difference. A ratio of
     * <ul>
     *    <li>0 means that the break has the exact right width</li>
     *    <li>&gt;= -1 &amp;&amp; &lt; 0  means that the break is wider than the line,
     *        but within the minimum values of the glues.</li>
     *    <li>&gt;0 &amp;&amp; &lt; 1 means that the break is smaller than the line width,
     *        but within the maximum values of the glues.</li>
     *    <li>&gt; 1 means that the break is too small to make up for the glues.</li>

Return to bug 51304

Lines 304-316 Link Here

(-)src/java/org/apache/fop/layoutmgr/BreakingAlgorithm.java (-13 / +48 lines)
304	this.previous = previous;	304	this.previous = previous;
305	}	305	}
306		306
307	/** {@inheritDoc} */	307	@Override
308	public String toString() {	308	public String toString() {
309	return "<KnuthNode at " + position + " "	309	return new StringBuilder(64).append("<")
310	+ totalWidth + "+" + totalStretch + "-" + totalShrink	310	.append(this.getClass().getSimpleName())
311	+ " line:" + line + " prev:" + (previous != null ? previous.position : -1)	311	.append(" at ").append(position)
312	+ " dem:" + totalDemerits	312	.append(" ").append(totalWidth)
313	+ " fitness:" + FitnessClasses.NAMES[fitness] + ">";	313	.append("+").append(totalStretch)
		314	.append("-").append(totalShrink)
		315	.append(" line:").append(line)
		316	.append(" prev:").append(previous != null ? previous.position : -1)
		317	.append(" dem:").append(totalDemerits)
		318	.append(" fitness:").append(FitnessClasses.NAMES[fitness])
		319	.append(">").toString();
314	}	320	}
315	}	321	}
316		322
Lines 640-646 Link Here
640	this.par.add(0, KnuthPenalty.DUMMY_ZERO_PENALTY);	646	this.par.add(0, KnuthPenalty.DUMMY_ZERO_PENALTY);
641	}	647	}
642	}	648	}
643		649
644	// content would overflow, insert empty line/page and try again	650	// content would overflow, insert empty line/page and try again
645	return createNode(	651	return createNode(
646	lastTooLong.previous.position, lastTooLong.previous.line + 1, 1,	652	lastTooLong.previous.position, lastTooLong.previous.line + 1, 1,
Lines 1168-1187 Link Here
1168	*/	1174	*/
1169	protected int computeDifference(KnuthNode activeNode, KnuthElement element,	1175	protected int computeDifference(KnuthNode activeNode, KnuthElement element,
1170	int elementIndex) {	1176	int elementIndex) {
1171	// compute the adjustment ratio	1177	// compute the difference
1172	int actualWidth = totalWidth - activeNode.totalWidth;	1178	int diff = getLineWidth(activeNode.line);
		1179	diff -= (totalWidth - activeNode.totalWidth);
1173	if (element.isPenalty()) {	1180	if (element.isPenalty()) {
1174	actualWidth += element.getWidth();	1181	diff -= element.getWidth();
1175	}	1182	}
1176	return getLineWidth() - actualWidth;	1183	if (hasOutOfLineIntrusions()) {
		1184	diff -= getOutOfLineIntrusions(activeNode, elementIndex);
1177	}	1185	}
		1186	return diff;
		1187	}
1178		1188
1179	/**	1189	/**
		1190	* Hook for subclasses to handle out-of-line content (floats/footnotes).
		1191	* <br/>Default implementation returns {@code false}. Should be overridden
		1192	* by subclasses if/when appropriate.
		1193	* @return {@code true} if the currently active node would have out-of-line
		1194	* content intruding on the line
		1195	*/
		1196	protected boolean hasOutOfLineIntrusions() {
		1197	return false;
		1198	}
		1199
		1200	/**
		1201	* Hook for subclasses to handle out-of-line content (floats/footnotes).
		1202	* This method is called by {@link #computeDifference(KnuthNode, KnuthElement, int)},
		1203	* if {@link #hasOutOfLineIntrusions()} returns {@code true}.
		1204	*
		1205	* @param activeNode the currently active node
		1206	* @param elementIndex the element's index
		1207	* @return the width corresponding to the total out-of-line intrusions
		1208	* (including static separators)
		1209	*/
		1210	protected int getOutOfLineIntrusions(KnuthNode activeNode, int elementIndex) {
		1211	return 0;
		1212	}
		1213
		1214	/**
1180	* Return the adjustment ratio needed to make up for the difference. A ratio of	1215	* Return the adjustment ratio needed to make up for the difference. A ratio of
1181	* <ul>	1216	* <ul>
1182	* <li>0 means that the break has the exact right width</li>	1217	* <li>0 means that the break has the exact right width</li>
1183	* <li>>= -1 && < 0 means that the break is wider than the line,	1218	* <li>>= -1 && < 0 means that the break is wider than the line,
1184	* but within the minimim values of the glues.</li>	1219	* but within the minimum values of the glues.</li>
1185	* <li>>0 && < 1 means that the break is smaller than the line width,	1220	* <li>>0 && < 1 means that the break is smaller than the line width,
1186	* but within the maximum values of the glues.</li>	1221	* but within the maximum values of the glues.</li>
1187	* <li>> 1 means that the break is too small to make up for the glues.</li>	1222	* <li>> 1 means that the break is too small to make up for the glues.</li>

Line 0 Link Here

(-)test/layoutengine/standard-testcases/region-body_column-count_footnote_2.xml (+158 lines)
		1	<?xml version="1.0" encoding="UTF-8"?>
		2	<!--
		3	Licensed to the Apache Software Foundation (ASF) under one or more
		4	contributor license agreements. See the NOTICE file distributed with
		5	this work for additional information regarding copyright ownership.
		6	The ASF licenses this file to You under the Apache License, Version 2.0
		7	(the "License"); you may not use this file except in compliance with
		8	the License. You may obtain a copy of the License at
		9
		10	http://www.apache.org/licenses/LICENSE-2.0
		11
		12	Unless required by applicable law or agreed to in writing, software
		13	distributed under the License is distributed on an "AS IS" BASIS,
		14	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		15	See the License for the specific language governing permissions and
		16	limitations under the License.
		17	-->
		18	<!-- $Id$ -->
		19	<testcase>
		20	<info>
		21	<p>
		22	This test checks multi-column documents. This test: footnotes in multi-column documents (no spans).
		23	</p>
		24	</info>
		25	<fo>
		26	<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">
		27	<fo:layout-master-set>
		28	<!-- height = 6 x 12pt (content) + 10pt (footnote-separator) -->
		29	<fo:simple-page-master master-name="3-column" page-height="82pt" page-width="8in">
		30	<fo:region-body column-count="3" />
		31	</fo:simple-page-master>
		32	</fo:layout-master-set>
		33	<fo:page-sequence master-reference="3-column" font-size="10pt">
		34	<fo:static-content flow-name="xsl-footnote-separator">
		35	<fo:block-container border-top-color="#000000" border-top-style="solid" border-top-width="1pt" margin-bottom="3pt" margin-top="6pt" width="100%">
		36	<fo:block/>
		37	</fo:block-container>
		38	</fo:static-content>
		39	<fo:flow flow-name="xsl-region-body">
		40	<fo:block id="block-2" break-before="page">
		41	<fo:block>line 1</fo:block>
		42	<fo:block>line 2</fo:block>
		43	<fo:block>line 3
		44	<fo:footnote><fo:inline font-size="6pt" vertical-align="top">[*]</fo:inline>
		45	<fo:footnote-body>
		46	<fo:block>
		47	<fo:list-block>
		48	<fo:list-item>
		49	<fo:list-item-label end-indent="label-end()" start-indent="0">
		50	<fo:block>
		51	<fo:inline font-size="6pt" vertical-align="top">[*]</fo:inline>
		52	</fo:block>
		53	</fo:list-item-label>
		54	<fo:list-item-body start-indent="0.4cm">
		55	<fo:block>footnote footnote footnote footnote footnote footnote footnote footnote</fo:block>
		56	</fo:list-item-body>
		57	</fo:list-item>
		58	</fo:list-block>
		59	</fo:block>
		60	</fo:footnote-body>
		61	</fo:footnote>
		62	</fo:block>
		63	<fo:block>line 4</fo:block>
		64	<fo:block>line 5</fo:block>
65	<fo:block>line 6</fo:block>
66	<fo:block>line 7</fo:block>
67	<fo:block>line 8</fo:block>
68	<fo:block>line 9
69	<fo:footnote><fo:inline font-size="6pt" vertical-align="top">[*]</fo:inline>
70	<fo:footnote-body>
71	<fo:block>
72	<fo:list-block>
73	<fo:list-item>
74	<fo:list-item-label end-indent="label-end()" start-indent="0">
75	<fo:block>
76	<fo:inline font-size="6pt" vertical-align="top">[*]</fo:inline>
77	</fo:block>
78	</fo:list-item-label>
79	<fo:list-item-body start-indent="0.4cm">
80	<fo:block>footnote footnote footnote footnote footnote footnote footnote footnote</fo:block>
81	</fo:list-item-body>
82	</fo:list-item>
83	</fo:list-block>
84	</fo:block>
85	</fo:footnote-body>
86	</fo:footnote>
87	</fo:block>
88	<fo:block>line 10</fo:block>
89	<fo:block>line 11</fo:block>
90	<fo:block>line 12</fo:block>
91	<fo:block>line 13</fo:block>
92	<fo:block>line 14</fo:block>
93	<fo:block>line 15</fo:block>
94	<fo:block>line 16</fo:block>
95	<fo:block>line 17
96	<fo:footnote><fo:inline font-size="6pt" vertical-align="top">[*]</fo:inline>
97	<fo:footnote-body>
98	<fo:block>
99	<fo:list-block>
100	<fo:list-item>
101	<fo:list-item-label end-indent="label-end()" start-indent="0">
102	<fo:block>
103	<fo:inline font-size="6pt" vertical-align="top">[*]</fo:inline>
104	</fo:block>
105	</fo:list-item-label>
106	<fo:list-item-body start-indent="0.4cm">
107	<fo:block>footnote footnote footnote footnote footnote footnote footnote footnote</fo:block>
108	</fo:list-item-body>
109	</fo:list-item>
110	</fo:list-block>
111	</fo:block>
112	</fo:footnote-body>
113	</fo:footnote>
114	</fo:block>
115	<fo:block>line 18</fo:block>
116	<fo:block>line 19</fo:block>
117	<fo:block>line 20</fo:block>
118	<fo:block>line 21</fo:block>
119	<fo:block>line 22</fo:block>
120	<fo:block>line 23</fo:block>
121	<fo:block>line 24</fo:block>
122	<fo:block>line 25</fo:block>
123	<fo:block>line 26</fo:block>
124	<fo:block>line 27</fo:block>
125	<fo:block>line 28</fo:block>
126	<fo:block>line 29</fo:block>
127	<fo:block>line 30</fo:block>
128	<fo:block>line 31</fo:block>
129	<fo:block>line 32</fo:block>
130	<fo:block>line 33</fo:block>
131	<fo:block>line 34</fo:block>
132	<fo:block>line 35</fo:block>
133	</fo:block>
134	</fo:flow>
135	</fo:page-sequence>
136	</fo:root>
137	</fo>
138	<checks>
139	<!-- Page 1 -->
140	<!-- 2 lines of footnote content -->
141	<eval expected="2" xpath="count((////page)[1]//footnote//lineArea[not(.//text/word='[]')])" />
142	<!-- 4 lines in first column -->
143	<!--eval expected="4" xpath="count((///*/page)[1]//flow[1]//lineArea)"/-->
144	<!-- 4 lines in second column -->
145	<eval expected="4" xpath="count((///*/page)[1]//flow[2]//lineArea)"/>
146	<!-- 4 lines in third column -->
147	<eval expected="4" xpath="count((///*/page)[1]//flow[3]//lineArea)"/>
148	<!-- Page 2 -->
149	<!-- 1 line of footnote content -->
150	<eval expected="1" xpath="count((////page)[2]//footnote//lineArea[not(.//text/word='[]')])" />
151	<!-- 5 lines in first column -->
152	<eval expected="5" xpath="count((///*/page)[2]//flow[1]//lineArea)"/>
153	<!-- 5 lines in second column -->
154	<eval expected="5" xpath="count((///*/page)[2]//flow[2]//lineArea)"/>
155	<!-- 5 lines in third column -->
156	<eval expected="5" xpath="count((///*/page)[2]//flow[3]//lineArea)"/>
157	</checks>
158	</testcase>