|
Java Platform 1.2 Beta 4 |
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object | +--java.awt.font.LineBreakMeasurer
LineBreakMeasurer is constructed with an iterator over styled text. The iterator's range should be a single paragraph in the text. LineBreakMeasurer maintains a position in the text for the start of of the next text segment; initially, this position is the start of text. Paragraphs are assigned an overall direction (either left-to-right or right-to-left) according to the bidirectional formatting rules. All segments obtained from a paragraph have the same direction as the paragraph.
Segments of text are obtained by calling the method nextLayout(), which will return a TextLayout representing the text that fits within the wrapping width. nextLayout() moves the current position to the end of the layout returned from nextLayout().
LineBreakMeasurer implements the most commonly used line-breaking policy: Every word which will fit within the wrapping width is placed on the line. If the first word will not fit, then all of the characters which fit within the wrapping width are placed on the line. At least one character is placed on each line.
The TextLayout instances returned by LineBreakMeasurer treat tabs ('\t') like 0-width spaces. Clients who wish to obtain tab-delimited segments for positioning should use the overload of nextLayout() which takes a limiting offset in the text. The limiting offset should be the first character after the tab. The TextLayouts returned from this method will end at the limit provided (or before, if the text between the current position and the limit won't fit entirely within the given wrapping width).
Clients who are laying out tab-delimited text need a slightly
different line-breaking policy after the first segment has been
placed on a line. Instead of fitting partial words in the
remaining space, they should place words which don't fit in the
remaining space entirely on the next line. This change of policy
can be requested in the overload of nextLayout() which takes a
boolean parameter. If this parameter is true
,
nextLayout() will return null if the first word won't fit in
the given space. See the tab sample below.
In general, if the text used to construct the LineBreakMeasurer changes, a new LineBreakMeasurer must be constructed to reflect the change. (The old LineBreakMeasurer will continue to function properly, but it won't be aware of the text change.) However, if the text change is the insertion or deletion of a single character, an existing LineBreakMeasurer may be 'updated' by calling insertChar() or deleteChar(). Updating an existing LineBreakMeasurer is much faster than creating a new one. Clients that modify text based on user typing will want to take advantage of these methods.
Examples:
Drawing a paragraph in a component
public void paint(Graphics graphics) { Point2D pen = new Point2D(10, 20); // let styledText be an AttributedCharacterIterator containing at least // one character LineBreakMeasurer measurer = new LineBreakMeasurer(styledText); float wrappingWidth = getSize().width - 15; while (measurer.getPosition() < fStyledText.length()) { TextLayout layout = measurer.nextLayout(wrappingWidth); pen.y += (layout.getAscent()); float dx = layout.isLeftToRight() ? 0 : (wrappingWidth - layout.getAdvance()); layout.draw(graphics, pen.x + dx, pen.y); pen.y += layout.getDescent() + layout.getLeading(); } }
Drawing text with tabs. For simplicity, the overall text direction is assumed to be left-to-right
public void paint(Graphics graphics) { float leftMargin = 10, rightMargin = 310; float[] tabStops = { 100, 250 }; // assume styledText is an AttributedCharacterIterator, and the number // of tabs in styledText is tabCount int[] tabLocations = new int[tabCount+1]; int i = 0; for (char c = styledText.first(); c != styledText.DONE; c = styledText.next()) { if (c == '\t') { tabLocations[i++] = styledText.getIndex(); } } tabLocations[tabCount] = styledText.getEndIndex() - 1; // Now tabLocations has an entry for every tab's offset in // the text. For convenience, the last entry is tabLocations // is the offset of the last character in the text. LineBreakMeasurer measurer = new LineBreakMeasurer(styledText); int currentTab = 0; float verticalPos = 20; while (measurer.getPosition() < styledText.getEndIndex()) { // Lay out and draw each line. All segments on a line // must be computed before any drawing can occur, since // we must know the largest ascent on the line. // TextLayouts are computed and stored in a Vector; // their horizontal positions are stored in a parallel // Vector. // lineContainsText is true after first segment is drawn boolean lineContainsText = false; boolean lineComplete = false; float maxAscent = 0, maxDescent = 0; float horizontalPos = leftMargin; Vector layouts = new Vector(1); Vector penPositions = new Vector(1); while (!lineComplete) { float wrappingWidth = rightMargin - horizontalPos; TextLayout layout = measurer.nextLayout(wrappingWidth, tabLocations[currentTab]+1, lineContainsText); // layout can be null if lineContainsText is true if (layout != null) { layouts.addElement(layout); penPositions.addElement(new Float(horizontalPos)); horizontalPos += layout.getAdvance(); maxAscent = Math.max(maxAscent, layout.getAscent()); maxDescent = Math.max(maxDescent, layout.getDescent() + layout.getLeading()); } else { lineComplete = true; } lineContainsText = true; if (measurer.getPosition() == tabLocations[currentTab]+1) { currentTab++; } if (measurer.getPosition() == styledText.getEndIndex()) lineComplete = true; else if (horizontalPos >= tabStops[tabStops.length-1]) lineComplete = true; if (!lineComplete) { // move to next tab stop int j; for (j=0; horizontalPos >= tabStops[j]; j++) {} horizontalPos = tabStops[j]; } } verticalPos += maxAscent; Enumeration layoutEnum = layouts.elements(); Enumeration positionEnum = penPositions.elements(); // now iterate through layouts and draw them while (layoutEnum.hasMoreElements()) { TextLayout nextLayout = (TextLayout) layoutEnum.nextElement(); Float nextPosition = (Float) positionEnum.nextElement(); nextLayout.draw(graphics, nextPosition.floatValue(), verticalPos); } verticalPos += maxDescent; } }
TextLayout
Constructor Summary | |
LineBreakMeasurer(AttributedCharacterIterator text,
BreakIterator breakIter,
FontRenderContext frc)
Construct a LineBreakMeasurer for the given text. |
|
LineBreakMeasurer(AttributedCharacterIterator text,
FontRenderContext frc)
Construct a LineBreakMeasurer for the given text. |
Method Summary | |
void | deleteChar(AttributedCharacterIterator newParagraph,
int deletePos)
Update the LineBreakMeasurer after a single character was deleted from the text. |
int | getPosition()
Return the current position of the LineBreakMeasurer. |
void | insertChar(AttributedCharacterIterator newParagraph,
int insertPos)
Update the LineBreakMeasurer after a single character was inserted into the text. |
TextLayout | nextLayout(float wrappingWidth,
int offsetLimit,
boolean requireNextWord)
Return the next layout, and update the current position. |
TextLayout | nextLayout(float maxAdvance)
Return the next layout, and update the current position. |
int | nextOffset(float wrappingWidth,
int offsetLimit,
boolean requireNextWord)
Return the position at the end of the next layout. |
int | nextOffset(float maxAdvance)
Return the position at the end of the next layout. |
void | setPosition(int newPosition)
Set the current position of the LineBreakMeasurer. |
Methods inherited from class java.lang.Object | |
clone , equals , finalize , getClass , hashCode , notify , notifyAll , toString , wait , wait , wait |
Constructor Detail |
public LineBreakMeasurer(AttributedCharacterIterator text, FontRenderContext frc)
text
- the text for which the LineBreakMeasurer will
produce TextLayouts. Must contain at least one character.
If the text available through iter changes, further
calls to this LineBreakMeasurer instance are undefined (except,
in some cases,
when insertChar or deleteChar are invoked
afterward - see below).
text
- the text from which to construct lines
frc
- the FontRenderContext in which the text is measuredinsertChar(java.text.AttributedCharacterIterator, int)
,
deleteChar(java.text.AttributedCharacterIterator, int)
public LineBreakMeasurer(AttributedCharacterIterator text, BreakIterator breakIter, FontRenderContext frc)
text
- the text for which the LineBreakMeasurer will
produce TextLayouts. Must contain at least one character.
If the text available through iter changes, further
calls to this LineBreakMeasurer instance are undefined (except,
in some cases,
when insertChar or deleteChar are invoked
afterward - see below).
text
- the text from which to construct lines
breakIter
- the BreakIterator which defines line breaks
frc
- the FontRenderContext in which the text is measuredinsertChar(java.text.AttributedCharacterIterator, int)
,
deleteChar(java.text.AttributedCharacterIterator, int)
Method Detail |
public int nextOffset(float maxAdvance)
maxAdvance
- the maximum visible advance permitted for
the text in the next layout.public int nextOffset(float wrappingWidth, int offsetLimit, boolean requireNextWord)
wrappingWidth
- the maximum visible advance permitted for
the text in the next layout.
offsetLimit
- the first character which may not be included
in the next layout, even if the text after the limit would fit
within the wrapping width. Must be greater than the current
position.
requireNextWord
- if true, the current position will be
returned if the entire next word will not fit within
wrappingWidth. If false, the offset returned will be at least
one greater than the current position.public TextLayout nextLayout(float maxAdvance)
maxAdvance
- the maximum visible advance permitted for
the text in the next layout.public TextLayout nextLayout(float wrappingWidth, int offsetLimit, boolean requireNextWord)
wrappingWidth
- the maximum visible advance permitted
for the text in the next layout.
offsetLimit
- the first character which may not be
included in the next layout, even if the text after the limit
would fit within the wrapping width. Must be greater than the
current position.
requireNextWord
- if true, and if the entire word at the
current position won't fit within wrapping width, null will be
returned. If false, a valid layout will be returned
that includes at least the character at the current position.public int getPosition()
setPosition(int)
public void setPosition(int newPosition)
newPosition
- the current position of the LineBreakMeasurer.
The position should be within the text used to construct the
LineBreakMeasurer (or in the text most recently passed to
insertChar or deleteChar).getPosition()
public void insertChar(AttributedCharacterIterator newParagraph, int insertPos)
newParagraph
- the text after the insertion
insertPos
- the position in the text at which the character
was inserteddeleteChar(java.text.AttributedCharacterIterator, int)
public void deleteChar(AttributedCharacterIterator newParagraph, int deletePos)
newParagraph
- the text after the deletion
deletePos
- the position in the text at which the character
was deletedinsertChar(java.text.AttributedCharacterIterator, int)
|
Java Platform 1.2 Beta 4 |
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |