Package 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

  • Field Details

    • firstPart

      private boolean firstPart

    • pageBreakHandled

      private boolean pageBreakHandled

    • needColumnBalancing

      private boolean needColumnBalancing

    • pageProvider

      private PageProvider pageProvider

    • separatorArea

      private Block separatorArea

    • spanAllActive

      private boolean spanAllActive

    • layoutRedone

      private boolean layoutRedone

    • previousIndex

      private int previousIndex

    • handlingStartOfFloat

      private boolean handlingStartOfFloat

    • handlingEndOfFloat

      private boolean handlingEndOfFloat

    • floatHeight

      private int floatHeight

    • floatYOffset

      private int floatYOffset

    • relayedFootnotesList

      private List relayedFootnotesList

    • relayedLengthList

      private List relayedLengthList

    • relayedTotalFootnotesLength

      private int relayedTotalFootnotesLength

    • relayedInsertedFootnotesLength

      private int relayedInsertedFootnotesLength

    • relayedFootnotesPending

      private boolean relayedFootnotesPending

    • relayedNewFootnotes

      private boolean relayedNewFootnotes

    • relayedFirstNewFootnoteIndex

      private int relayedFirstNewFootnoteIndex

    • relayedFootnoteListIndex

      private int relayedFootnoteListIndex

    • relayedFootnoteElementIndex

      private int relayedFootnoteElementIndex

    • relayedFootnoteSeparatorLength

      private MinOptMax relayedFootnoteSeparatorLength

    • previousFootnoteListIndex

      private int previousFootnoteListIndex

    • previousFootnoteElementIndex

      private int previousFootnoteElementIndex

    • prevousColumnCount

      private int prevousColumnCount

    • childFLM

      private FlowLayoutManager childFLM
      The FlowLayoutManager object, which processes the single fo:flow of the fo:page-sequence

    • footnoteSeparatorLM

      private StaticContentLayoutManager footnoteSeparatorLM

  • Constructor Details

    • PageBreaker

      public PageBreaker(PageSequenceLayoutManager pslm)
      Construct page breaker.
      Parameters:
      pslm - the page sequence layout manager

  • Method Details

    • 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

    • doLayout

      boolean doLayout(int flowBPD)
      Starts the page breaking process.
      Parameters:
      flowBPD - the constant available block-progression-dimension (used for every part)

    • 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 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

    • containsFootnotes

      private boolean containsFootnotes(List contentList, LayoutContext context)

    • getFootnoteKnuthElements

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

    • handleFootnoteSeparator

      private void handleFootnoteSeparator()

    • getNextKnuthElements

      protected 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 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(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(PageBreakingAlgorithm alg, int partCount, AbstractBreaker.BlockSequence originalList, AbstractBreaker.BlockSequence effectiveList)
      Overrides:
      prepareToRedoLayout in class AbstractBreaker

    • redoLayout

      private void redoLayout(PageBreakingAlgorithm alg, int partCount, AbstractBreaker.BlockSequence originalList, AbstractBreaker.BlockSequence effectiveList)
      Restart the algorithm at the break corresponding to the given partCount. Used to re-do the part after the last break in case of either column-balancing or a last page-master.

    • setLastPageIndex

      private void setLastPageIndex(int currentPageNum)

    • 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(PageBreakingAlgorithm alg, AbstractBreaker.PageBreakPosition pbp)
      Finish part.
      Specified by:
      finishPart in class AbstractBreaker
      Parameters:
      alg - a page breaking algorithm
      pbp - a page break posittion

    • addFootnoteAreas

      private void addFootnoteAreas(List<KnuthElement> footnote)

    • addFootnoteAreas

      private void addFootnoteAreas(List<KnuthElement> footnote, int startIndex, int endIndex)

    • 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

    • handleBreakTrait

      private void handleBreakTrait(int breakVal)
      Depending on the kind of break condition, move to next column or page. May need to make an empty page if next page would not have the desired "handedness".
      Parameters:
      breakVal - - value of break-before or break-after trait.

    • handleBreakTrait

      private void handleBreakTrait(int breakVal, boolean emptyContent)

    • handleBreakBeforeFollowingPage

      private void handleBreakBeforeFollowingPage(int breakVal)

    • needBlankPageBeforeNew

      private boolean needBlankPageBeforeNew(int breakVal)
      Check if a blank page is needed to accommodate desired even or odd page number.
      Parameters:
      breakVal - - value of break-before or break-after trait.

    • needNewPage

      private boolean needNewPage(int breakVal)
      See if need to generate a new page
      Parameters:
      breakVal - - value of break-before or break-after trait.

    • 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(PageBreakingAlgorithm alg, int optimalPageCount, AbstractBreaker.BlockSequence blockList, LayoutContext childLC)
      Overrides:
      handleFloatLayout in class AbstractBreaker

    • addAreasForFloats

      protected void addAreasForFloats(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 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(PageBreakingAlgorithm alg)