Package org.apache.fop.layoutmgr

Class AbstractBreaker

  • Direct Known Subclasses:
    LocalBreaker, PageBreaker
    public abstract class AbstractBreaker
extends java.lang.Object
    Abstract base class for breakers (page breakers, static region handlers etc.).

    • Field Detail

      • log

        protected static final org.apache.commons.logging.Log log
        logging instance

      • originalRestartAtLM

        protected LayoutManager originalRestartAtLM

      • positionAtBreak

        protected Position positionAtBreak

      • firstElementsForRestart

        protected java.util.List firstElementsForRestart

      • blockListIndex

        protected int blockListIndex
        blockListIndex of the current BlockSequence in blockLists

      • alignment

        protected int alignment
        desired text alignment

      • footnoteSeparatorLength

        protected MinOptMax footnoteSeparatorLength
        footnote separator length

    • Constructor Detail

      • AbstractBreaker

        public AbstractBreaker()

    • Method Detail

      • getCurrentDisplayAlign

        protected abstract int getCurrentDisplayAlign()
        Returns:
        current display alignment

      • hasMoreContent

        protected abstract boolean hasMoreContent()
        Returns:
        true if content not exhausted

      • addAreas

        protected abstract void addAreas​(PositionIterator posIter,
                                 LayoutContext context)
        Tell the layout manager to add all the child areas implied by Position objects which will be returned by the Iterator.
        Parameters:
        posIter - the position iterator
        context - the context

      • getTopLevelLM

        protected abstract LayoutManager getTopLevelLM()
        Returns:
        top level layout manager

      • getCurrentChildLM

        protected abstract LayoutManager getCurrentChildLM()
        Returns:
        current child layout manager

      • isPartOverflowRecoveryActivated

        protected boolean isPartOverflowRecoveryActivated()
        Controls the behaviour of the algorithm in cases where the first element of a part overflows a line/page.
        Returns:
        true if the algorithm should try to send the element to the next line/page.

      • isSinglePartFavored

        protected boolean isSinglePartFavored()
        Returns:
        true if one a single part should be produced if possible (ex. for block-containers)

      • 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.
        Returns:
        the applicable PageProvider, or null if not applicable

      • createLayoutListener

        protected org.apache.fop.layoutmgr.PageBreakingAlgorithm.PageBreakingLayoutListener createLayoutListener()
        Creates and returns a PageBreakingLayoutListener for the PageBreakingAlgorithm to notify about layout problems.
        Returns:
        the listener instance or null if no notifications are needed

      • getNextKnuthElements

        protected abstract java.util.List<KnuthElement> getNextKnuthElements​(LayoutContext context,
                                                                     int alignment)
        Get a sequence of KnuthElements representing the content of the node assigned to the LM
        Parameters:
        context - the LayoutContext used to store layout information
        alignment - the desired text alignment
        Returns:
        the list of KnuthElements

      • getNextKnuthElements

        protected java.util.List<KnuthElement> getNextKnuthElements​(LayoutContext context,
                                                            int alignment,
                                                            Position positionAtIPDChange,
                                                            LayoutManager restartAtLM)
        Get a sequence of KnuthElements representing the content of the node assigned to the LM
        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

      • isEmpty

        public boolean isEmpty()
        Returns:
        true if there's no content that could be handled.

      • startPart

        protected void startPart​(AbstractBreaker.BlockSequence list,
                         int breakClass,
                         boolean emptyContent)
        Start part.
        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.

      • finishPart

        protected abstract void finishPart​(org.apache.fop.layoutmgr.PageBreakingAlgorithm alg,
                                   AbstractBreaker.PageBreakPosition pbp)
        Finish part.
        Parameters:
        alg - a page breaking algorithm
        pbp - a page break posittion

      • createLayoutContext

        protected LayoutContext createLayoutContext()
        Creates the top-level LayoutContext for the breaker operation.
        Returns:
        the top-level LayoutContext

      • updateLayoutContext

        protected void updateLayoutContext​(LayoutContext context)
        Used to update the LayoutContext in subclasses prior to starting a new element list.
        Parameters:
        context - the LayoutContext to update

      • 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.
        Parameters:
        elementList - the Knuth element list

      • doLayout

        public boolean doLayout​(int flowBPD,
                        boolean autoHeight)
        Starts the page breaking process.
        Parameters:
        flowBPD - the constant available block-progression-dimension (used for every part)
        autoHeight - true if warnings about overflows should be disabled because the the BPD is really undefined (for footnote-separators, for example)

      • containsNonRestartableLM

        protected boolean containsNonRestartableLM​(Position position)
        Returns true if the given position or one of its descendants corresponds to a non-restartable LM.
        Parameters:
        position - a position
        Returns:
        true if there is a non-restartable LM in the hierarchy

      • doPhase3

        protected abstract void doPhase3​(org.apache.fop.layoutmgr.PageBreakingAlgorithm alg,
                                 int partCount,
                                 AbstractBreaker.BlockSequence originalList,
                                 AbstractBreaker.BlockSequence effectiveList)
        Phase 3 of Knuth algorithm: Adds the areas
        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)

      • addAreas

        protected void addAreas​(org.apache.fop.layoutmgr.PageBreakingAlgorithm alg,
                        int partCount,
                        AbstractBreaker.BlockSequence originalList,
                        AbstractBreaker.BlockSequence effectiveList)
        Phase 3 of Knuth algorithm: Adds the areas
        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)

      • addAreas

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

      • handleSpanChange

        protected int handleSpanChange​(LayoutContext childLC,
                               int nextSequenceStartsOn)
        Handles span changes reported through the LayoutContext. Only used by the PSLM and called by getNextBlockList().
        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.
        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 restartAtLM,
                               java.util.List<KnuthElement> firstElements)
        Gets the next block list (sequence) and adds it to a list of block lists if it's not empty.
        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
        restartAtLM - 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

      • shouldRedoLayout

        protected boolean shouldRedoLayout()

      • wasLayoutRedone

        protected boolean wasLayoutRedone()

      • lastPageHasIPDChange

        protected boolean lastPageHasIPDChange()