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
`protected void` `addAreas(org.apache.fop.layoutmgr.PageBreakingAlgorithm alg, int startPart, int partCount, AbstractBreaker.BlockSequence originalList, AbstractBreaker.BlockSequence effectiveList, LayoutContext childLC)` Phase 3 of Knuth algorithm: Adds the areas
`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 List<List<KnuthElement>>` `getFootnoteKnuthElements(FlowLayoutManager flowLM, LayoutContext context, 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, List<ListElement> firstElements)` Gets the next block list (sequence) and adds it to a list of block lists if it's not empty.
`protected List<ListElement>` `getNextKnuthElements(LayoutContext context, int alignment)` Get a sequence of KnuthElements representing the content of the node assigned to the LM
`protected List<ListElement>` `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(List fl, List<Integer> 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(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, 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,
                                   List<ListElement> 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 List<List<KnuthElement>> getFootnoteKnuthElements(FlowLayoutManager flowLM,
                                                                    LayoutContext context,
                                                                    List<FootnoteBodyLayoutManager> footnoteBodyLMs)

#### getNextKnuthElements

    protected List<ListElement> 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 List<ListElement> 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(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(List fl,
                              List<Integer> 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)

#### addAreas

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

Description copied from class: `AbstractBreaker`
Phase 3 of Knuth algorithm: Adds the areas

Overrides:
  `addAreas` in class `AbstractBreaker`
Parameters:
  `alg` - PageBreakingAlgorithm instance which determined the breaks
  `startPart` - index of the first part (page) to be rendered
  `partCount` - number of parts (pages) to be rendered
  `originalList` - original Knuth element list
  `effectiveList` - effective Knuth element list (after adjustments)