org.apache.fop.layoutmgr

## Class PageBreaker

- java.lang.Object
- - org.apache.fop.layoutmgr.AbstractBreaker
  - - org.apache.fop.layoutmgr.PageBreaker

-     public class PageBreaker
      extends AbstractBreaker

  Handles the breaking of pages in an fo:flow

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from class org.apache.fop.layoutmgr.AbstractBreaker

      `AbstractBreaker.BlockSequence, AbstractBreaker.FloatPosition, AbstractBreaker.PageBreakPosition`

  - ### Field Summary

    - ### Fields inherited from class org.apache.fop.layoutmgr.AbstractBreaker

      `alignment, blockListIndex, blockLists, firstElementsForRestart, footnoteSeparatorLength, log, originalRestartAtLM, positionAtBreak, pslm`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `PageBreaker(PageSequenceLayoutManager pslm)` Construct page breaker.

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | `addAreas(PositionIterator posIter, LayoutContext context)` Adds an area to the flow layout manager
    `protected void` | `addAreasForFloats(org.apache.fop.layoutmgr.PageBreakingAlgorithm alg, int startPart, int partCount, AbstractBreaker.BlockSequence originalList, AbstractBreaker.BlockSequence effectiveList, LayoutContext childLC, int lastBreak, int startElementIndex, int endElementIndex)`
    `protected PageBreakingAlgorithm.PageBreakingLayoutListener` | `createLayoutListener()` Creates and returns a PageBreakingLayoutListener for the PageBreakingAlgorithm to notify about layout problems.
    `protected void` | `doPhase3(org.apache.fop.layoutmgr.PageBreakingAlgorithm alg, int partCount, AbstractBreaker.BlockSequence originalList, AbstractBreaker.BlockSequence effectiveList)` Phase 3 of Knuth algorithm: Adds the areas
    `protected void` | `finishPart(org.apache.fop.layoutmgr.PageBreakingAlgorithm alg, AbstractBreaker.PageBreakPosition pbp)` Finish part.
    `protected FlowLayoutManager` | `getCurrentChildLM()`
    `protected int` | `getCurrentDisplayAlign()`
    `protected int` | `getFloatHeight()`
    `protected int` | `getFloatYOffset()`
    `static java.util.List<java.util.List<KnuthElement>>` | `getFootnoteKnuthElements(FlowLayoutManager flowLM, LayoutContext context, java.util.List<FootnoteBodyLayoutManager> footnoteBodyLMs)`
    `protected int` | `getNextBlockList(LayoutContext childLC, int nextSequenceStartsOn)` Gets the next block list (sequence) and adds it to a list of block lists if it's not empty.
    `protected int` | `getNextBlockList(LayoutContext childLC, int nextSequenceStartsOn, Position positionAtIPDChange, LayoutManager restartLM, java.util.List firstElements)` Gets the next block list (sequence) and adds it to a list of block lists if it's not empty.
    `protected java.util.List` | `getNextKnuthElements(LayoutContext context, int alignment)` Get a sequence of KnuthElements representing the content of the node assigned to the LM
    `protected java.util.List` | `getNextKnuthElements(LayoutContext context, int alignment, Position positionAtIPDChange, LayoutManager restartAtLM)` Get a sequence of KnuthElements representing the content of the node assigned to the LM
    `int` | `getOffsetDueToFloat()`
    `protected PageProvider` | `getPageProvider()` Returns the PageProvider if any.
    `protected LayoutManager` | `getTopLevelLM()`
    `protected void` | `handleEmptyContent()` This method is called when no content is available for a part.
    `protected void` | `handleEndOfFloat(int fHeight)`
    `protected int` | `handleFloatLayout(org.apache.fop.layoutmgr.PageBreakingAlgorithm alg, int optimalPageCount, AbstractBreaker.BlockSequence blockList, LayoutContext childLC)`
    `protected int` | `handleSpanChange(LayoutContext childLC, int nextSequenceStartsOn)` Handles span changes reported through the `LayoutContext`.
    `protected void` | `handleStartOfFloat(int fHeight, int fYOffset)`
    `protected boolean` | `handlingEndOfFloat()`
    `protected boolean` | `handlingFloat()`
    `protected boolean` | `handlingStartOfFloat()`
    `protected boolean` | `hasMoreContent()`
    `void` | `holdFootnotes(java.util.List fl, java.util.List ll, int tfl, int ifl, boolean fp, boolean nf, int fnfi, int fli, int fei, MinOptMax fsl, int pfli, int pfei)`
    `protected boolean` | `lastPageHasIPDChange(int optimalPageCount)`
    `protected void` | `observeElementList(java.util.List elementList)` Used for debugging purposes.
    `protected void` | `prepareToRedoLayout(org.apache.fop.layoutmgr.PageBreakingAlgorithm alg, int partCount, AbstractBreaker.BlockSequence originalList, AbstractBreaker.BlockSequence effectiveList)`
    `void` | `retrieveFootones(org.apache.fop.layoutmgr.PageBreakingAlgorithm alg)`
    `protected boolean` | `shouldRedoLayout()`
    `protected boolean` | `shouldRedoLayout(int partCount)`
    `protected void` | `startPart(AbstractBreaker.BlockSequence list, int breakClass, boolean emptyContent)` Start part.
    `protected void` | `updateLayoutContext(LayoutContext context)` Used to update the LayoutContext in subclasses prior to starting a new element list.
    `protected boolean` | `wasLayoutRedone()`

    - ### Methods inherited from class org.apache.fop.layoutmgr.AbstractBreaker

      `addAreas, addAreas, addAreas, containsNonRestartableLM, createLayoutContext, doLayout, isEmpty, isPartOverflowRecoveryActivated, isSinglePartFavored`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### PageBreaker

          public PageBreaker(PageSequenceLayoutManager pslm)

      Construct page breaker.
      Parameters:
        `pslm` - the page sequence layout manager

  - ### Method Detail

    - #### updateLayoutContext

          protected void updateLayoutContext(LayoutContext context)

      Used to update the LayoutContext in subclasses prior to starting a new element list.
      Overrides:
        `updateLayoutContext` in class `AbstractBreaker`
      Parameters:
        `context` - the LayoutContext to update

    - #### getTopLevelLM

          protected LayoutManager getTopLevelLM()

      Specified by:
        `getTopLevelLM` in class `AbstractBreaker`
      Returns:
        top level layout manager

    - #### getPageProvider

          protected PageProvider getPageProvider()

      Returns the PageProvider if any. PageBreaker overrides this method because each page may have a different available BPD which needs to be accessible to the breaking algorithm.
      Overrides:
        `getPageProvider` in class `AbstractBreaker`
      Returns:
        the applicable PageProvider, or null if not applicable

    - #### createLayoutListener

          protected PageBreakingAlgorithm.PageBreakingLayoutListener createLayoutListener()

      Creates and returns a PageBreakingLayoutListener for the PageBreakingAlgorithm to notify about layout problems.
      Overrides:
        `createLayoutListener` in class `AbstractBreaker`
      Returns:
        the listener instance or null if no notifications are needed

    - #### handleSpanChange

          protected int handleSpanChange(LayoutContext childLC,
                                         int nextSequenceStartsOn)

      Handles span changes reported through the `LayoutContext`. Only used by the PSLM and called by `getNextBlockList()`.
      Overrides:
        `handleSpanChange` in class `AbstractBreaker`
      Parameters:
        `childLC` - the LayoutContext
        `nextSequenceStartsOn` - previous value for break handling
      Returns:
        effective value for break handling

    - #### getNextBlockList

          protected int getNextBlockList(LayoutContext childLC,
                                         int nextSequenceStartsOn)

      Gets the next block list (sequence) and adds it to a list of block lists if it's not empty.
      Overrides:
        `getNextBlockList` in class `AbstractBreaker`
      Parameters:
        `childLC` - LayoutContext to use
        `nextSequenceStartsOn` - indicates on what page the next sequence should start
      Returns:
        the page on which the next content should appear after a hard break

    - #### getNextBlockList

          protected int getNextBlockList(LayoutContext childLC,
                                         int nextSequenceStartsOn,
                                         Position positionAtIPDChange,
                                         LayoutManager restartLM,
                                         java.util.List firstElements)

      Gets the next block list (sequence) and adds it to a list of block lists if it's not empty.
      Overrides:
        `getNextBlockList` in class `AbstractBreaker`
      Parameters:
        `childLC` - LayoutContext to use
        `nextSequenceStartsOn` - indicates on what page the next sequence should start
        `positionAtIPDChange` - last element on the part before an IPD change
        `restartLM` - the layout manager from which to restart, if IPD change occurs between two LMs
        `firstElements` - elements from non-restartable LMs on the new page
      Returns:
        the page on which the next content should appear after a hard break

    - #### getFootnoteKnuthElements

          public static java.util.List<java.util.List<KnuthElement>> getFootnoteKnuthElements(FlowLayoutManager flowLM,
                                                                                              LayoutContext context,
                                                                                              java.util.List<FootnoteBodyLayoutManager> footnoteBodyLMs)

    - #### getNextKnuthElements

          protected java.util.List getNextKnuthElements(LayoutContext context,
                                                        int alignment)

      Get a sequence of KnuthElements representing the content of the node assigned to the LM
      Specified by:
        `getNextKnuthElements` in class `AbstractBreaker`
      Parameters:
        `context` - the LayoutContext used to store layout information
        `alignment` - the desired text alignment
      Returns:
        the list of KnuthElements

    - #### getNextKnuthElements

          protected java.util.List getNextKnuthElements(LayoutContext context,
                                                        int alignment,
                                                        Position positionAtIPDChange,
                                                        LayoutManager restartAtLM)

      Get a sequence of KnuthElements representing the content of the node assigned to the LM
      Overrides:
        `getNextKnuthElements` in class `AbstractBreaker`
      Parameters:
        `context` - the LayoutContext used to store layout information
        `alignment` - the desired text alignment
        `positionAtIPDChange` - last element on the part before an IPD change
        `restartAtLM` - the layout manager from which to restart, if IPD change occurs between two LMs
      Returns:
        the list of KnuthElements

    - #### getCurrentDisplayAlign

          protected int getCurrentDisplayAlign()

      Specified by:
        `getCurrentDisplayAlign` in class `AbstractBreaker`
      Returns:
        current display alignment

    - #### hasMoreContent

          protected boolean hasMoreContent()

      Specified by:
        `hasMoreContent` in class `AbstractBreaker`
      Returns:
        whether or not this flow has more page break opportunities

    - #### addAreas

          protected void addAreas(PositionIterator posIter,
                                  LayoutContext context)

      Adds an area to the flow layout manager
      Specified by:
        `addAreas` in class `AbstractBreaker`
      Parameters:
        `posIter` - the position iterator
        `context` - the layout context

    - #### doPhase3

          protected void doPhase3(org.apache.fop.layoutmgr.PageBreakingAlgorithm alg,
                                  int partCount,
                                  AbstractBreaker.BlockSequence originalList,
                                  AbstractBreaker.BlockSequence effectiveList)

      Phase 3 of Knuth algorithm: Adds the areas This implementation checks whether to trigger column-balancing, or whether to take into account a 'last-page' condition.
      Specified by:
        `doPhase3` in class `AbstractBreaker`
      Parameters:
        `alg` - PageBreakingAlgorithm instance which determined the breaks
        `partCount` - number of parts (pages) to be rendered
        `originalList` - original Knuth element list
        `effectiveList` - effective Knuth element list (after adjustments)

    - #### prepareToRedoLayout

          protected void prepareToRedoLayout(org.apache.fop.layoutmgr.PageBreakingAlgorithm alg,
                                             int partCount,
                                             AbstractBreaker.BlockSequence originalList,
                                             AbstractBreaker.BlockSequence effectiveList)

      Overrides:
        `prepareToRedoLayout` in class `AbstractBreaker`

    - #### startPart

          protected void startPart(AbstractBreaker.BlockSequence list,
                                   int breakClass,
                                   boolean emptyContent)

      Start part.
      Overrides:
        `startPart` in class `AbstractBreaker`
      Parameters:
        `list` - a block sequence
        `breakClass` - a break class

    - #### handleEmptyContent

          protected void handleEmptyContent()

      This method is called when no content is available for a part. Used to force empty pages.
      Overrides:
        `handleEmptyContent` in class `AbstractBreaker`

    - #### finishPart

          protected void finishPart(org.apache.fop.layoutmgr.PageBreakingAlgorithm alg,
                                    AbstractBreaker.PageBreakPosition pbp)

      Finish part.
      Specified by:
        `finishPart` in class `AbstractBreaker`
      Parameters:
        `alg` - a page breaking algorithm
        `pbp` - a page break posittion

    - #### getCurrentChildLM

          protected FlowLayoutManager getCurrentChildLM()

      Specified by:
        `getCurrentChildLM` in class `AbstractBreaker`
      Returns:
        current child layout manager

    - #### observeElementList

          protected void observeElementList(java.util.List elementList)

      Used for debugging purposes. Notifies all registered observers about the element list. Override to set different parameters.
      Overrides:
        `observeElementList` in class `AbstractBreaker`
      Parameters:
        `elementList` - the Knuth element list

    - #### shouldRedoLayout

          protected boolean shouldRedoLayout()

      Overrides:
        `shouldRedoLayout` in class `AbstractBreaker`

    - #### shouldRedoLayout

          protected boolean shouldRedoLayout(int partCount)

    - #### wasLayoutRedone

          protected boolean wasLayoutRedone()

      Overrides:
        `wasLayoutRedone` in class `AbstractBreaker`

    - #### lastPageHasIPDChange

          protected boolean lastPageHasIPDChange(int optimalPageCount)

      Overrides:
        `lastPageHasIPDChange` in class `AbstractBreaker`

    - #### handlingStartOfFloat

          protected boolean handlingStartOfFloat()

    - #### handleStartOfFloat

          protected void handleStartOfFloat(int fHeight,
                                            int fYOffset)

    - #### getFloatHeight

          protected int getFloatHeight()

    - #### getFloatYOffset

          protected int getFloatYOffset()

    - #### handlingEndOfFloat

          protected boolean handlingEndOfFloat()

    - #### handleEndOfFloat

          protected void handleEndOfFloat(int fHeight)

    - #### handlingFloat

          protected boolean handlingFloat()

    - #### getOffsetDueToFloat

          public int getOffsetDueToFloat()

    - #### handleFloatLayout

          protected int handleFloatLayout(org.apache.fop.layoutmgr.PageBreakingAlgorithm alg,
                                          int optimalPageCount,
                                          AbstractBreaker.BlockSequence blockList,
                                          LayoutContext childLC)

      Overrides:
        `handleFloatLayout` in class `AbstractBreaker`

    - #### addAreasForFloats

          protected void addAreasForFloats(org.apache.fop.layoutmgr.PageBreakingAlgorithm alg,
                                           int startPart,
                                           int partCount,
                                           AbstractBreaker.BlockSequence originalList,
                                           AbstractBreaker.BlockSequence effectiveList,
                                           LayoutContext childLC,
                                           int lastBreak,
                                           int startElementIndex,
                                           int endElementIndex)

      Overrides:
        `addAreasForFloats` in class `AbstractBreaker`

    - #### holdFootnotes

          public void holdFootnotes(java.util.List fl,
                                    java.util.List ll,
                                    int tfl,
                                    int ifl,
                                    boolean fp,
                                    boolean nf,
                                    int fnfi,
                                    int fli,
                                    int fei,
                                    MinOptMax fsl,
                                    int pfli,
                                    int pfei)

    - #### retrieveFootones

          public void retrieveFootones(org.apache.fop.layoutmgr.PageBreakingAlgorithm alg)

Copyright 1999-2021 The Apache Software Foundation. All Rights Reserved.