Class PageBreakingAlgorithm

java.lang.Object
org.apache.fop.layoutmgr.BreakingAlgorithm
org.apache.fop.layoutmgr.PageBreakingAlgorithm
Direct Known Subclasses:
BalancingColumnBreakingAlgorithm

class PageBreakingAlgorithm extends BreakingAlgorithm
  • Field Details

    • log

      private static org.apache.commons.logging.Log log
      the logger for the class
    • topLevelLM

      private final LayoutManager topLevelLM
    • pageProvider

      private final PageProvider pageProvider
    • layoutListener

    • pageBreaks

      List of PageBreakPosition elements.
    • footnotesList

      private List<List<KnuthElement>> footnotesList
      Footnotes which are cited between the currently considered active node (previous break) and the current considered break. Its type is List<List<KnuthElement>>, it contains the sequences of KnuthElement representing the footnotes bodies.
    • lengthList

      private List<Integer> lengthList
      Cumulated bpd of unhandled footnotes.
    • totalFootnotesLength

      private int totalFootnotesLength
      Length of all the footnotes which will be put on the current page.
    • insertedFootnotesLength

      private int insertedFootnotesLength
      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.
    • footnotesPending

      private boolean footnotesPending
      True if footnote citations have been met since the beginning of the page sequence.
    • newFootnotes

      private boolean newFootnotes
      True if the elements met after the previous break point contain footnote citations.
    • firstNewFootnoteIndex

      private int firstNewFootnoteIndex
      Index of the first footnote met after the previous break point.
    • footnoteListIndex

      private int footnoteListIndex
      Index of the last footnote inserted on the current page.
    • footnoteElementIndex

      private int footnoteElementIndex
      Index of the last element of the last footnote inserted on the current page.
    • splitFootnoteDemerits

      private final int splitFootnoteDemerits
      See Also:
    • deferredFootnoteDemerits

      private final int deferredFootnoteDemerits
      See Also:
    • footnoteSeparatorLength

      private MinOptMax footnoteSeparatorLength
    • storedPrevBreakIndex

      private int storedPrevBreakIndex
    • storedBreakIndex

      private int storedBreakIndex
    • storedValue

      private boolean storedValue
    • autoHeight

      private boolean autoHeight
    • favorSinglePart

      private boolean favorSinglePart
    • ipdDifference

      private int ipdDifference
    • bestNodeForIPDChange

      private BreakingAlgorithm.KnuthNode bestNodeForIPDChange
    • bestNodeForLastPage

      public BreakingAlgorithm.KnuthNode bestNodeForLastPage
    • currentKeepContext

      private int currentKeepContext
    • lastBeforeKeepContextSwitch

      private BreakingAlgorithm.KnuthNode lastBeforeKeepContextSwitch
    • handlingStartOfFloat

      private boolean handlingStartOfFloat
    • handlingEndOfFloat

      private boolean handlingEndOfFloat
    • floatHeight

      private int floatHeight
    • bestFloatEdgeNode

      private BreakingAlgorithm.KnuthNode bestFloatEdgeNode
    • floatPosition

      private AbstractBreaker.FloatPosition floatPosition
    • previousFootnoteListIndex

      private int previousFootnoteListIndex
    • previousFootnoteElementIndex

      private int previousFootnoteElementIndex
    • relayingFootnotes

      private boolean relayingFootnotes
  • Constructor Details

  • Method Details

    • initialize

      protected void initialize()
      Initializes the algorithm's variables.
      Overrides:
      initialize in class BreakingAlgorithm
    • recoverFromTooLong

      protected BreakingAlgorithm.KnuthNode recoverFromTooLong(BreakingAlgorithm.KnuthNode lastTooLong)
      Overridden to defer a part to the next page, if it must be kept within one page, but is too large to fit in the last column. Recover from a BreakingAlgorithm.KnuthNode leading to a line that is too long. The default implementation creates a new node corresponding to a break point after the previous node that led to a line that was too short.
      Overrides:
      recoverFromTooLong in class BreakingAlgorithm
      Parameters:
      lastTooLong - the node that leads to a "too long" line
      Returns:
      node corresponding to a breakpoint after the previous "too short" line
    • compareNodes

      Compare two KnuthNodes and return the node with the least demerit.
      Overrides:
      compareNodes in class BreakingAlgorithm
      Parameters:
      node1 - The first knuth node.
      node2 - The other knuth node.
      Returns:
      the node with the least demerit.
    • createNode

      protected BreakingAlgorithm.KnuthNode createNode(int position, int line, int fitness, int totalWidth, int totalStretch, int totalShrink, double adjustRatio, int availableShrink, int availableStretch, int difference, double totalDemerits, BreakingAlgorithm.KnuthNode previous)
      Creates a new active node for a feasible breakpoint at the given position. Only called in forced mode.
      Overrides:
      createNode in class BreakingAlgorithm
      Parameters:
      position - index of the element in the Knuth sequence
      line - number of the line ending at the breakpoint
      fitness - fitness class of the line ending at the breakpoint. One of 0, 1, 2, 3.
      totalWidth - accumulated width of the KnuthElements up to after the breakpoint
      totalStretch - accumulated stretchability of the KnuthElements up to after the breakpoint
      totalShrink - accumulated shrinkability of the KnuthElements up to after the breakpoint
      adjustRatio - adjustment ratio if the line ends at this breakpoint
      availableShrink - available stretch of the line ending at this breakpoint
      availableStretch - available shrink of the line ending at this breakpoint
      difference - difference between target and actual line width
      totalDemerits - minimum total demerits up to the breakpoint
      previous - active node for the preceding breakpoint
      Returns:
      a new node
    • createNode

      protected BreakingAlgorithm.KnuthNode createNode(int position, int line, int fitness, int totalWidth, int totalStretch, int totalShrink)
      Creates a new active node for a break from the best active node of the given fitness class to the element at the given position.
      Overrides:
      createNode in class BreakingAlgorithm
      Parameters:
      position - index of the element in the Knuth sequence
      line - number of the line ending at the breakpoint
      fitness - fitness class of the line ending at the breakpoint. One of 0, 1, 2, 3.
      totalWidth - accumulated width of the KnuthElements up to after the breakpoint
      totalStretch - accumulated stretchability of the KnuthElements up to after the breakpoint
      totalShrink - accumulated shrinkability of the KnuthElements up to after the breakpoint
      Returns:
      a new node
      See Also:
    • handleBox

      protected void handleBox(KnuthBox box)
      Page-breaking specific handling of the given box. Currently it adds the footnotes cited in the given box to the list of to-be-handled footnotes. Handle a KnuthBox.
      Note: default implementation just adds the box's width to the total content width. Subclasses that do not keep track of this themselves, but override this method, should remember to call super.handleBox(box) to avoid unwanted side-effects.
      Overrides:
      handleBox in class BreakingAlgorithm
      Parameters:
      box - the KnuthBox to handle
    • handlePenaltyAt

      protected void handlePenaltyAt(KnuthPenalty penalty, int position, int allowedBreaks)
      Overridden to consider penalties with value KnuthElement.INFINITE as legal break-points, if the current keep-context allows this (a keep-*.within-page="always" constraint still permits column-breaks) Handle a KnuthPenalty at the given position, taking into account the type of breaks allowed.
      Overrides:
      handlePenaltyAt in class BreakingAlgorithm
      Parameters:
      penalty - the KnuthPenalty to handle
      position - the position of the penalty in the list
      allowedBreaks - the type of breaks that are allowed
    • handleFootnotes

      private void handleFootnotes(List<List<KnuthElement>> elementLists)
      Handles the footnotes cited inside a block-level box. Updates footnotesList and the value of totalFootnotesLength with the lengths of the given footnotes.
      Parameters:
      elementLists - list of KnuthElement sequences corresponding to the footnotes bodies
    • restartFrom

      protected int restartFrom(BreakingAlgorithm.KnuthNode restartingNode, int currentIndex)
      Restart from the given node at the given index.
      Overrides:
      restartFrom in class BreakingAlgorithm
      Parameters:
      restartingNode - the BreakingAlgorithm.KnuthNode to restart from
      currentIndex - the current position index
      Returns:
      the index of the restart point
    • resetFootnotes

      private void resetFootnotes(List<List<KnuthElement>> elementLists)
    • considerLegalBreak

      protected void considerLegalBreak(KnuthElement element, int elementIdx)
      Determines if the given breakpoint is a feasible breakpoint. That is, if a decent line may be built between one of the currently active nodes and this breakpoint.
      Overrides:
      considerLegalBreak in class BreakingAlgorithm
      Parameters:
      element - the paragraph's element to consider
      elementIdx - the element's index inside the paragraph
    • elementCanEndLine

      protected boolean elementCanEndLine(KnuthElement element, int line, int difference)
      Check if the given KnuthElement can end the line with the given number.
      Overrides:
      elementCanEndLine in class BreakingAlgorithm
      Parameters:
      element - the element
      line - the line number
      difference - an integer
      Returns:
      true if the element can end the line
    • computeDifference

      protected int computeDifference(BreakingAlgorithm.KnuthNode activeNode, KnuthElement element, int elementIndex)
      Return the difference between the natural width of a line that would be made between the given active node and the given element, and the available width of the real line.
      Overrides:
      computeDifference in class BreakingAlgorithm
      Parameters:
      activeNode - node for the previous breakpoint
      element - currently considered breakpoint
      elementIndex - index of the element that is considered as a breakpoint
      Returns:
      The difference in width. Positive numbers mean extra space in the line, negative number that the line overflows.
    • handleWhitespaceManagementPenalty

      private int handleWhitespaceManagementPenalty(PageBreakingAlgorithm.KnuthPageNode activeNode, WhitespaceManagementPenalty penalty, int elementIndex)
      Evaluates the variants corresponding to the given penalty until one that leads to an acceptable adjustment ratio is found. That variant will be added to the list of pending variants in the given active node.
    • canDeferOldFootnotes

      private boolean canDeferOldFootnotes(PageBreakingAlgorithm.KnuthPageNode node, int contentElementIndex)
      Checks whether footnotes from preceding pages may be deferred to the page after the given element.
      Parameters:
      node - active node for the preceding page break
      contentElementIndex - index of the Knuth element considered for the current page break
      Returns:
      true if footnotes can be deferred
    • noBreakBetween

      private boolean noBreakBetween(int prevBreakIndex, int breakIndex)
      Returns true if there may be no breakpoint between the two given elements.
      Parameters:
      prevBreakIndex - index of the element from the currently considered active node
      breakIndex - index of the currently considered breakpoint
      Returns:
      true if no element between the two can be a breakpoint
    • deferredFootnotes

      private boolean deferredFootnotes(int listIndex, int elementIndex, int length)
      Returns true if their are (pieces of) footnotes to be typeset on the current page.
      Parameters:
      listIndex - index of the last inserted footnote for the currently considered active node
      elementIndex - index of the last element of the last inserted footnote
      length - total length of all footnotes inserted so far
    • getFootnoteSplit

      private int getFootnoteSplit(PageBreakingAlgorithm.KnuthPageNode activeNode, int availableLength, boolean canDeferOldFootnotes)
      Tries to split the flow of footnotes to put one part on the current page.
      Parameters:
      activeNode - currently considered previous page break
      availableLength - available space for footnotes
      canDeferOldFootnotes -
      Returns:
      ...
    • getFootnoteSplit

      private int getFootnoteSplit(int prevListIndex, int prevElementIndex, int prevLength, int availableLength, boolean canDeferOldFootnotes)
      Tries to split the flow of footnotes to put one part on the current page.
      Parameters:
      prevListIndex - index of the last footnote on the previous page
      prevElementIndex - index of the last element of the last footnote
      prevLength - total length of footnotes inserted so far
      availableLength - available space for footnotes on this page
      canDeferOldFootnotes -
      Returns:
      ...
    • computeAdjustmentRatio

      protected double computeAdjustmentRatio(BreakingAlgorithm.KnuthNode activeNode, int difference)
      Return the adjustment ratio needed to make up for the difference. A ratio of
      • 0 means that the break has the exact right width
      • >= -1 && < 0 means that the break is wider than the line, but within the minimim values of the glues.
      • >0 && < 1 means that the break is smaller than the line width, but within the maximum values of the glues.
      • > 1 means that the break is too small to make up for the glues.
      Overrides:
      computeAdjustmentRatio in class BreakingAlgorithm
      Parameters:
      activeNode - the currently active node
      difference - the difference between content-length and available width
      Returns:
      The adjustment ratio.
    • computeDemerits

      protected double computeDemerits(BreakingAlgorithm.KnuthNode activeNode, KnuthElement element, int fitnessClass, double r)
      Computes the demerits of the current breaking (that is, up to the given element), if the next-to-last chosen breakpoint is the given active node. This adds to the total demerits of the given active node, the demerits of a line starting at this node and ending at the given element.
      Overrides:
      computeDemerits in class BreakingAlgorithm
      Parameters:
      activeNode - considered preceding line break
      element - considered current line break
      fitnessClass - fitness of the current line
      r - adjustment ratio for the current line
      Returns:
      the demerit of the current line
    • finish

      protected void finish()
      Hook for subclasses to trigger special behavior after ending the main loop in BreakingAlgorithm.findBreakingPoints(KnuthSequence,int,double,boolean,int)
      Overrides:
      finish in class BreakingAlgorithm
    • createFootnotePages

      private void createFootnotePages(PageBreakingAlgorithm.KnuthPageNode lastNode)
    • getPageBreaks

      Returns:
      a list of AbstractBreaker.PageBreakPosition elements corresponding to the computed page- and column-breaks
    • insertPageBreakAsFirst

      public void insertPageBreakAsFirst(AbstractBreaker.PageBreakPosition pageBreak)
      Insert the given AbstractBreaker.PageBreakPosition as the first element in the list of page-breaks
      Parameters:
      pageBreak - the position to insert
    • removeAllPageBreaks

      public void removeAllPageBreaks()
      Removes all page breaks from the result list. This is used by block-containers and static-content when it is only desired to know where there is an overflow but later the whole content should be painted as one part.
    • updateData1

      public void updateData1(int total, double demerits)
      Empty method, hook for subclasses. Called before determining the optimal breakpoints corresponding to a given active node.
      Specified by:
      updateData1 in class BreakingAlgorithm
      Parameters:
      total - number of lines for the active node
      demerits - total demerits of the paragraph for the active node
    • updateData2

      public void updateData2(BreakingAlgorithm.KnuthNode bestActiveNode, KnuthSequence sequence, int total)
      Empty method, hook for subclasses. Called when determining the optimal breakpoints for a given active node.
      Specified by:
      updateData2 in class BreakingAlgorithm
      Parameters:
      bestActiveNode - a node in the chain of best active nodes, corresponding to one of the optimal breakpoints
      sequence - the corresponding paragraph
      total - the number of lines into which the paragraph will be broken
    • filterActiveNodes

      protected int filterActiveNodes()
      Filter active nodes.
      Specified by:
      filterActiveNodes in class BreakingAlgorithm
      Returns:
      an integer
    • getFootnoteList

      protected final List<KnuthElement> getFootnoteList(int index)
      Obtain the element-list corresponding to the footnote at the given index.
      Parameters:
      index - the index in the list of footnotes
      Returns:
      the element-list
    • getFObj

      public FObj getFObj()
      Returns:
      the associated top-level formatting object.
    • getLineWidth

      protected int getLineWidth(int line)
      Returns the line/part width of a given line/part.
      Overrides:
      getLineWidth in class BreakingAlgorithm
      Parameters:
      line - the line/part number
      Returns:
      the width/length in millipoints
    • recoverFromOverflow

      protected BreakingAlgorithm.KnuthNode recoverFromOverflow()
      Description copied from class: BreakingAlgorithm
      Recover from an overflow condition.
      Overrides:
      recoverFromOverflow in class BreakingAlgorithm
      Returns:
      the new lastForced node
    • getIPDdifference

      protected int getIPDdifference()
      obtain ipd difference
      Overrides:
      getIPDdifference in class BreakingAlgorithm
      Returns:
      an integer
    • handleIpdChange

      protected int handleIpdChange()
      handle ipd change
      Overrides:
      handleIpdChange in class BreakingAlgorithm
      Returns:
      an integer
    • addNode

      protected void addNode(int line, BreakingAlgorithm.KnuthNode node)
      Add a node at the end of the given line's existing active nodes. If this is the first node in the line, adjust endLine accordingly.
      Overrides:
      addNode in class BreakingAlgorithm
      Parameters:
      line - number of the line ending at the node's corresponding breakpoint
      node - the active node to add
    • getBestNodeBeforeIPDChange

      BreakingAlgorithm.KnuthNode getBestNodeBeforeIPDChange()
    • compareIPDs

      private int compareIPDs(int line)
    • getBestNodeForLastPage

      BreakingAlgorithm.KnuthNode getBestNodeForLastPage()
    • handlingFloat

      protected boolean handlingFloat()
      Overrides:
      handlingFloat in class BreakingAlgorithm
    • createForcedNodes

      protected void createForcedNodes(BreakingAlgorithm.KnuthNode node, int line, int elementIdx, int difference, double r, double demerits, int fitnessClass, int availableShrink, int availableStretch, int newWidth, int newStretch, int newShrink)
      Overrides:
      createForcedNodes in class BreakingAlgorithm
    • handleFloat

      protected int handleFloat()
      Overrides:
      handleFloat in class BreakingAlgorithm
    • getBestFloatEdgeNode

      protected BreakingAlgorithm.KnuthNode getBestFloatEdgeNode()
    • getFloatPosition

      protected AbstractBreaker.FloatPosition getFloatPosition()
    • getFloatHeight

      protected int getFloatHeight()
    • handlingStartOfFloat

      protected boolean handlingStartOfFloat()
    • handlingEndOfFloat

      protected boolean handlingEndOfFloat()
    • deactivateNode

      protected void deactivateNode(BreakingAlgorithm.KnuthNode node, int line)
      Deactivate the given node
      Overrides:
      deactivateNode in class BreakingAlgorithm
      Parameters:
      node - the node
      line - the line number
    • disableFloatHandling

      protected void disableFloatHandling()
      Overrides:
      disableFloatHandling in class BreakingAlgorithm
    • loadFootnotes

      public void loadFootnotes(List fl, List ll, int tfl, int ifl, boolean fp, boolean nf, int fnfi, int fli, int fei, MinOptMax fsl, int pfli, int pfei)
    • relayFootnotes

      public void relayFootnotes(PageSequenceLayoutManager pslm)