The set of nodes is sorted into lines indexed into activeLines.
The nodes in each line are linked together in a single linked list by the
KnuthNode.next field. The activeLines array contains a link to the head of
the linked list in index 'line*2' and a link to the tail at index 'line*2+1'.
The set of active nodes can be traversed by
for (int line = startLine; line < endLine; line++) {
for (KnuthNode node = getNode(line); node != null; node = node.next) {
// Do something with 'node'
}
}
ALL_BREAKS
public static final int ALL_BREAKS
All feasible breaks are ok.
INFINITE_RATIO
protected static final int INFINITE_RATIO
Maximum adjustment ration
NO_FLAGGED_PENALTIES
public static final int NO_FLAGGED_PENALTIES
This forbids hyphenation.
ONLY_FORCED_BREAKS
public static final int ONLY_FORCED_BREAKS
wrap-option = "no-wrap".
activeLines
protected BreakingAlgorithm.KnuthNode[] activeLines
The set of active nodes in ascending line order. For each line l, activeLines[2l] contains a
link to l's first active node, and activeLines[2l+1] a link to l's last active node. The
line number l corresponds to the number of the line ending at the node's breakpoint.
activeNodeCount
protected int activeNodeCount
The number of active nodes.
alignment
protected int alignment
Alignment of the paragraph/page. One of EN_START, EN_JUSTIFY, etc.
alignmentLast
protected int alignmentLast
Alignment of the paragraph's last line.
bFirst
protected boolean bFirst
Used to handle the text-indent property (indent the first line of a paragraph).
considerTooShort
protected boolean considerTooShort
If set to true, doesn't ignore break possibilities which are definitely too short.
endLine
protected int endLine
The highest + 1 available line in the set of active nodes.
incompatibleFitnessDemerit
protected int incompatibleFitnessDemerit
Demerit for consecutive lines belonging to incompatible fitness classes .
lineWidth
protected int lineWidth
The width of a line (or height of a column in page-breaking mode).
-1 indicates that the line widths are different for each line.
log
protected static Log log
the logger for the class
maxFlaggedPenaltiesCount
protected int maxFlaggedPenaltiesCount
Maximum number of consecutive lines ending with a flagged penalty.
Only a value >= 1 is a significant limit.
repeatedFlaggedDemerit
protected int repeatedFlaggedDemerit
Demerit for consecutive lines ending at flagged penalties.
startLine
protected int startLine
The lowest available line in the set of active nodes.
totalShrink
protected int totalShrink
The total shrink of all elements handled so far.
totalStretch
protected int totalStretch
The total stretch of all elements handled so far.
totalWidth
protected int totalWidth
The total width of all elements handled so far.
addNode
protected void addNode(int line,
BreakingAlgorithm.KnuthNode node)
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.
line
- number of the line ending at the node's corresponding breakpointnode
- the active node to add
computeAdjustmentRatio
protected double computeAdjustmentRatio(BreakingAlgorithm.KnuthNode activeNode,
int difference)
Return the adjust ration needed to make up for the difference. A ration 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.
activeNode
- difference
-
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.
activeNode
- considered preceding line breakelement
- considered current line breakfitnessClass
- fitness of the current liner
- adjustment ratio for the current line
- the demerit of the current 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.
activeNode
- node for the previous breakpointelement
- currently considered breakpoint
- The difference in width. Positive numbers mean extra space in the line,
negative number that the line overflows.
considerLegalBreak
protected void considerLegalBreak(KnuthElement element,
int elementIdx)
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.
element
- the paragraph's element to considerelementIdx
- the element's index inside the paragraph
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.
createNode(int,int,int,int,int,int,double,int,int,int,double,BreakingAlgorithm.KnuthNode)
, BreakingAlgorithm.BestRecords
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.
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
filterActiveNodes
protected abstract int filterActiveNodes()
findBreakingPoints
public int findBreakingPoints(KnuthSequence par,
double threshold,
boolean force,
int allowedBreaks)
findBreakingPoints
public int findBreakingPoints(KnuthSequence par,
int startIndex,
double threshold,
boolean force,
int allowedBreaks)
Finds an optimal set of breakpoints for the given paragraph.
par
- the paragraph to breakstartIndex
- index of the Knuth element at which the breaking must startthreshold
- upper bound of the adjustment ratioforce
- true if a set of breakpoints must be found even if there are no
feasible onesallowedBreaks
- one of ONLY_FORCED_BREAKS, NO_FLAGGED_PENALTIES, ALL_BREAKS
finish
protected void finish()
getAlignment
public int getAlignment()
- the alignment for normal lines/parts
getAlignmentLast
public int getAlignmentLast()
- the alignment for the last line/part
getElement
protected KnuthElement getElement(int idx)
Return the element at index idx in the paragraph.
idx
- index of the element.
- the element at index idx in the paragraph.
getLineWidth
protected int getLineWidth()
- the constant line/part width or -1 if there is no such value
getLineWidth
protected int getLineWidth(int line)
Returns the line/part width of a given line/part.
line
- the line/part number
- the width/length in millipoints
getMaxRecoveryAttempts
protected int getMaxRecoveryAttempts()
- the number of times the algorithm should try to move overflowing content to the
next line/page.
getNode
protected BreakingAlgorithm.KnuthNode getNode(int line)
Returns the first active node for the given line.
line
- the line/part number
- the requested active node
handleBox
protected void handleBox(KnuthBox box)
Empty method, hook for subclasses.
initialize
protected void initialize()
Resets the algorithm's variables.
isPartOverflowRecoveryActivated
protected boolean isPartOverflowRecoveryActivated()
Controls the behaviour of the algorithm in cases where the first element of a part
overflows a line/page.
- true if the algorithm should try to send the element to the next line/page.
removeNode
protected void removeNode(int line,
BreakingAlgorithm.KnuthNode node)
Remove the given active node registered for the given line. If there are no more active nodes
for this line, adjust the startLine accordingly.
line
- number of the line ending at the node's corresponding breakpointnode
- the node to deactivate
setConstantLineWidth
public void setConstantLineWidth(int lineWidth)
toString
public String toString(String prepend)
Creates a string representation of the active nodes. Used for debugging.
prepend
- a string to prepend on each entry
updateData1
public abstract void updateData1(int total,
double demerits)
Empty method, hook for subclasses. Called before determining the optimal
breakpoints corresponding to a given active node.
total
- number of lines for the active nodedemerits
- total demerits of the paragraph for the active node
updateData2
public abstract 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.
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
calculateBreakPoints(KnuthNode, KnuthSequence, int)