Package org.apache.fop.layoutmgr
Class PageBreakingAlgorithm
java.lang.Object
org.apache.fop.layoutmgr.BreakingAlgorithm
org.apache.fop.layoutmgr.PageBreakingAlgorithm
- Direct Known Subclasses:
BalancingColumnBreakingAlgorithm
-
Nested Class Summary
Nested ClassesModifier and TypeClassDescriptionprotected class
this class stores information about how the nodes which could start a line ending at the current elementprotected class
This class represents a feasible breaking point with extra information about footnotes.static interface
Interface to notify about layout events during page breaking.Nested classes/interfaces inherited from class org.apache.fop.layoutmgr.BreakingAlgorithm
BreakingAlgorithm.BestRecords, BreakingAlgorithm.FitnessClasses, BreakingAlgorithm.KnuthNode
-
Field Summary
FieldsModifier and TypeFieldDescriptionprivate boolean
private BreakingAlgorithm.KnuthNode
private BreakingAlgorithm.KnuthNode
private int
private final int
private boolean
private int
Index of the first footnote met after the previous break point.private int
private AbstractBreaker.FloatPosition
private int
Index of the last element of the last footnote inserted on the current page.private int
Index of the last footnote inserted on the current page.private MinOptMax
private List
<List<KnuthElement>> Footnotes which are cited between the currently considered active node (previous break) and the current considered break.private boolean
True if footnote citations have been met since the beginning of the page sequence.private boolean
private boolean
private int
Length of all the footnotes which have already been inserted, up to the currently considered element.private int
private BreakingAlgorithm.KnuthNode
private final PageBreakingAlgorithm.PageBreakingLayoutListener
Cumulated bpd of unhandled footnotes.private static org.apache.commons.logging.Log
the logger for the classprivate boolean
True if the elements met after the previous break point contain footnote citations.List of PageBreakPosition elements.private final PageProvider
private int
private int
private boolean
private final int
private int
private int
private boolean
private final LayoutManager
private int
Length of all the footnotes which will be put on the current page.Fields inherited from class org.apache.fop.layoutmgr.BreakingAlgorithm
activeLines, activeNodeCount, alignment, alignmentLast, ALL_BREAKS, best, considerTooShort, endLine, incompatibleFitnessDemerit, indentFirstPart, INFINITE_RATIO, lineWidth, maxFlaggedPenaltiesCount, NO_FLAGGED_PENALTIES, ONLY_FORCED_BREAKS, par, repeatedFlaggedDemerit, startLine, totalShrink, totalStretch, totalWidth
-
Constructor Summary
ConstructorsConstructorDescriptionPageBreakingAlgorithm
(LayoutManager topLevelLM, PageProvider pageProvider, PageBreakingAlgorithm.PageBreakingLayoutListener layoutListener, int alignment, int alignmentLast, MinOptMax footnoteSeparatorLength, boolean partOverflowRecovery, boolean autoHeight, boolean favorSinglePart) Construct a page breaking algorithm. -
Method Summary
Modifier and TypeMethodDescriptionprotected void
addNode
(int line, BreakingAlgorithm.KnuthNode node) Add a node at the end of the given line's existing active nodes.private boolean
canDeferOldFootnotes
(PageBreakingAlgorithm.KnuthPageNode node, int contentElementIndex) Checks whether footnotes from preceding pages may be deferred to the page after the given element.private int
compareIPDs
(int line) protected BreakingAlgorithm.KnuthNode
Compare two KnuthNodes and return the node with the least demerit.protected double
computeAdjustmentRatio
(BreakingAlgorithm.KnuthNode activeNode, int difference) Return the adjustment ratio needed to make up for the difference.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.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.protected void
considerLegalBreak
(KnuthElement element, int elementIdx) Determines if the given breakpoint is a feasible breakpoint.private void
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) 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.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.protected void
deactivateNode
(BreakingAlgorithm.KnuthNode node, int line) Deactivate the given nodeprivate boolean
deferredFootnotes
(int listIndex, int elementIndex, int length) Returns true if their are (pieces of) footnotes to be typeset on the current page.protected void
protected boolean
elementCanEndLine
(KnuthElement element, int line, int difference) Check if the givenKnuthElement
can end the line with the given number.protected int
Filter active nodes.protected void
finish()
Hook for subclasses to trigger special behavior after ending the main loop inBreakingAlgorithm.findBreakingPoints(KnuthSequence,int,double,boolean,int)
protected BreakingAlgorithm.KnuthNode
(package private) BreakingAlgorithm.KnuthNode
(package private) BreakingAlgorithm.KnuthNode
protected int
protected AbstractBreaker.FloatPosition
getFObj()
protected final List
<KnuthElement> getFootnoteList
(int index) Obtain the element-list corresponding to the footnote at the given index.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.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.protected int
obtain ipd differenceprotected int
getLineWidth
(int line) Returns the line/part width of a given line/part.protected void
Page-breaking specific handling of the given box.protected int
private void
handleFootnotes
(List<List<KnuthElement>> elementLists) Handles the footnotes cited inside a block-level box.protected int
handle ipd changeprotected void
handlePenaltyAt
(KnuthPenalty penalty, int position, int allowedBreaks) Overridden to consider penalties with valueKnuthElement.INFINITE
as legal break-points, if the current keep-context allows this (a keep-*.within-page="always" constraint still permits column-breaks) Handle aKnuthPenalty
at the given position, taking into account the type of breaks allowed.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.protected boolean
protected boolean
protected boolean
protected void
Initializes the algorithm's variables.void
Insert the givenAbstractBreaker.PageBreakPosition
as the first element in the list of page-breaksvoid
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) private boolean
noBreakBetween
(int prevBreakIndex, int breakIndex) Returns true if there may be no breakpoint between the two given elements.protected BreakingAlgorithm.KnuthNode
Recover from an overflow condition.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.void
void
Removes all page breaks from the result list.private void
resetFootnotes
(List<List<KnuthElement>> elementLists) protected int
restartFrom
(BreakingAlgorithm.KnuthNode restartingNode, int currentIndex) Restart from the given node at the given index.void
updateData1
(int total, double demerits) Empty method, hook for subclasses.void
updateData2
(BreakingAlgorithm.KnuthNode bestActiveNode, KnuthSequence sequence, int total) Empty method, hook for subclasses.Methods inherited from class org.apache.fop.layoutmgr.BreakingAlgorithm
activateNode, calculateBreakPoints, findBreakingPoints, findBreakingPoints, forceNode, getAlignment, getAlignmentLast, getElement, getLastTooLong, getLastTooShort, getLineWidth, getMaxRecoveryAttempts, getNode, handleElementAt, handleGlueAt, isPartOverflowRecoveryActivated, removeNode, replaceLastDeactivated, setConstantLineWidth, toString
-
Field Details
-
log
private static org.apache.commons.logging.Log logthe logger for the class -
topLevelLM
-
pageProvider
-
layoutListener
-
pageBreaks
List of PageBreakPosition elements. -
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
Cumulated bpd of unhandled footnotes. -
totalFootnotesLength
private int totalFootnotesLengthLength of all the footnotes which will be put on the current page. -
insertedFootnotesLength
private int insertedFootnotesLengthLength 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 footnotesPendingTrue if footnote citations have been met since the beginning of the page sequence. -
newFootnotes
private boolean newFootnotesTrue if the elements met after the previous break point contain footnote citations. -
firstNewFootnoteIndex
private int firstNewFootnoteIndexIndex of the first footnote met after the previous break point. -
footnoteListIndex
private int footnoteListIndexIndex of the last footnote inserted on the current page. -
footnoteElementIndex
private int footnoteElementIndexIndex 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
-
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
-
bestNodeForLastPage
-
currentKeepContext
private int currentKeepContext -
lastBeforeKeepContextSwitch
-
handlingStartOfFloat
private boolean handlingStartOfFloat -
handlingEndOfFloat
private boolean handlingEndOfFloat -
floatHeight
private int floatHeight -
bestFloatEdgeNode
-
floatPosition
-
previousFootnoteListIndex
private int previousFootnoteListIndex -
previousFootnoteElementIndex
private int previousFootnoteElementIndex -
relayingFootnotes
private boolean relayingFootnotes
-
-
Constructor Details
-
PageBreakingAlgorithm
public PageBreakingAlgorithm(LayoutManager topLevelLM, PageProvider pageProvider, PageBreakingAlgorithm.PageBreakingLayoutListener layoutListener, int alignment, int alignmentLast, MinOptMax footnoteSeparatorLength, boolean partOverflowRecovery, boolean autoHeight, boolean favorSinglePart) Construct a page breaking algorithm.- Parameters:
topLevelLM
- the top level layout managerpageProvider
- the page providerlayoutListener
- the layout listeneralignment
- alignment of the paragraph/page. One ofConstants.EN_START
,Constants.EN_JUSTIFY
,Constants.EN_CENTER
,Constants.EN_END
. For pages,Constants.EN_BEFORE
andConstants.EN_AFTER
are mapped to the corresponding inline properties,Constants.EN_START
andConstants.EN_END
.alignmentLast
- alignment of the paragraph's last linefootnoteSeparatorLength
- length of footnote separatorpartOverflowRecovery
-true
if too long elements should be moved to the next line/partautoHeight
- true if auto heightfavorSinglePart
- true if favoring single part- See Also:
-
-
Method Details
-
initialize
protected void initialize()Initializes the algorithm's variables.- Overrides:
initialize
in classBreakingAlgorithm
-
recoverFromTooLong
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 aBreakingAlgorithm.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 classBreakingAlgorithm
- Parameters:
lastTooLong
- the node that leads to a "too long" line- Returns:
- node corresponding to a breakpoint after the previous "too short" line
-
compareNodes
protected BreakingAlgorithm.KnuthNode compareNodes(BreakingAlgorithm.KnuthNode node1, BreakingAlgorithm.KnuthNode node2) Compare two KnuthNodes and return the node with the least demerit.- Overrides:
compareNodes
in classBreakingAlgorithm
- 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 classBreakingAlgorithm
- Parameters:
position
- index of the element in the Knuth sequenceline
- number of the line ending at the breakpointfitness
- 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 breakpointtotalStretch
- accumulated stretchability of the KnuthElements up to after the breakpointtotalShrink
- accumulated shrinkability of the KnuthElements up to after the breakpointadjustRatio
- adjustment ratio if the line ends at this breakpointavailableShrink
- available stretch of the line ending at this breakpointavailableStretch
- available shrink of the line ending at this breakpointdifference
- difference between target and actual line widthtotalDemerits
- minimum total demerits up to the breakpointprevious
- 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 classBreakingAlgorithm
- Parameters:
position
- index of the element in the Knuth sequenceline
- number of the line ending at the breakpointfitness
- 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 breakpointtotalStretch
- accumulated stretchability of the KnuthElements up to after the breakpointtotalShrink
- accumulated shrinkability of the KnuthElements up to after the breakpoint- Returns:
- a new node
- See Also:
-
handleBox
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 aKnuthBox
.
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 callsuper.handleBox(box)
to avoid unwanted side-effects.- Overrides:
handleBox
in classBreakingAlgorithm
- Parameters:
box
- theKnuthBox
to handle
-
handlePenaltyAt
Overridden to consider penalties with valueKnuthElement.INFINITE
as legal break-points, if the current keep-context allows this (a keep-*.within-page="always" constraint still permits column-breaks) Handle aKnuthPenalty
at the given position, taking into account the type of breaks allowed.- Overrides:
handlePenaltyAt
in classBreakingAlgorithm
- Parameters:
penalty
- theKnuthPenalty
to handleposition
- the position of the penalty in the listallowedBreaks
- the type of breaks that are allowed
-
handleFootnotes
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
Restart from the given node at the given index.- Overrides:
restartFrom
in classBreakingAlgorithm
- Parameters:
restartingNode
- theBreakingAlgorithm.KnuthNode
to restart fromcurrentIndex
- the current position index- Returns:
- the index of the restart point
-
resetFootnotes
-
considerLegalBreak
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 classBreakingAlgorithm
- Parameters:
element
- the paragraph's element to considerelementIdx
- the element's index inside the paragraph
-
elementCanEndLine
Check if the givenKnuthElement
can end the line with the given number.- Overrides:
elementCanEndLine
in classBreakingAlgorithm
- Parameters:
element
- the elementline
- the line numberdifference
- 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 classBreakingAlgorithm
- Parameters:
activeNode
- node for the previous breakpointelement
- currently considered breakpointelementIndex
- 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 breakcontentElementIndex
- 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 nodebreakIndex
- 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 nodeelementIndex
- index of the last element of the last inserted footnotelength
- 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 breakavailableLength
- available space for footnotescanDeferOldFootnotes
-- 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 pageprevElementIndex
- index of the last element of the last footnoteprevLength
- total length of footnotes inserted so faravailableLength
- available space for footnotes on this pagecanDeferOldFootnotes
-- Returns:
- ...
-
computeAdjustmentRatio
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 classBreakingAlgorithm
- Parameters:
activeNode
- the currently active nodedifference
- 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 classBreakingAlgorithm
- Parameters:
activeNode
- considered preceding line breakelement
- considered current line breakfitnessClass
- fitness of the current liner
- 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 inBreakingAlgorithm.findBreakingPoints(KnuthSequence,int,double,boolean,int)
- Overrides:
finish
in classBreakingAlgorithm
-
createFootnotePages
-
getPageBreaks
- Returns:
- a list of
AbstractBreaker.PageBreakPosition
elements corresponding to the computed page- and column-breaks
-
insertPageBreakAsFirst
Insert the givenAbstractBreaker.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 classBreakingAlgorithm
- Parameters:
total
- number of lines for the active nodedemerits
- 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 classBreakingAlgorithm
- Parameters:
bestActiveNode
- a node in the chain of best active nodes, corresponding to one of the optimal breakpointssequence
- the corresponding paragraphtotal
- the number of lines into which the paragraph will be broken
-
filterActiveNodes
protected int filterActiveNodes()Filter active nodes.- Specified by:
filterActiveNodes
in classBreakingAlgorithm
- Returns:
- an integer
-
getFootnoteList
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
- 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 classBreakingAlgorithm
- Parameters:
line
- the line/part number- Returns:
- the width/length in millipoints
-
recoverFromOverflow
Description copied from class:BreakingAlgorithm
Recover from an overflow condition.- Overrides:
recoverFromOverflow
in classBreakingAlgorithm
- Returns:
- the new
lastForced
node
-
getIPDdifference
protected int getIPDdifference()obtain ipd difference- Overrides:
getIPDdifference
in classBreakingAlgorithm
- Returns:
- an integer
-
handleIpdChange
protected int handleIpdChange()handle ipd change- Overrides:
handleIpdChange
in classBreakingAlgorithm
- Returns:
- an integer
-
addNode
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 classBreakingAlgorithm
- Parameters:
line
- number of the line ending at the node's corresponding breakpointnode
- 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 classBreakingAlgorithm
-
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 classBreakingAlgorithm
-
handleFloat
protected int handleFloat()- Overrides:
handleFloat
in classBreakingAlgorithm
-
getBestFloatEdgeNode
-
getFloatPosition
-
getFloatHeight
protected int getFloatHeight() -
handlingStartOfFloat
protected boolean handlingStartOfFloat() -
handlingEndOfFloat
protected boolean handlingEndOfFloat() -
deactivateNode
Deactivate the given node- Overrides:
deactivateNode
in classBreakingAlgorithm
- Parameters:
node
- the nodeline
- the line number
-
disableFloatHandling
protected void disableFloatHandling()- Overrides:
disableFloatHandling
in classBreakingAlgorithm
-
loadFootnotes
-
relayFootnotes
-