< prev index next >
src/java.desktop/share/classes/java/awt/font/TextLayout.java
Print this page
*** 68,78 ****
import sun.font.GraphicComponent;
import sun.font.LayoutPathImpl;
/**
*
! * <code>TextLayout</code> is an immutable graphical representation of styled
* character data.
* <p>
* It provides the following capabilities:
* <ul>
* <li>implicit bidirectional analysis and reordering,
--- 68,78 ----
import sun.font.GraphicComponent;
import sun.font.LayoutPathImpl;
/**
*
! * {@code TextLayout} is an immutable graphical representation of styled
* character data.
* <p>
* It provides the following capabilities:
* <ul>
* <li>implicit bidirectional analysis and reordering,
*** 86,106 ****
* <li>default font substitution,
* <li>metric information such as ascent, descent, and advance, and
* <li>rendering
* </ul>
* <p>
! * A <code>TextLayout</code> object can be rendered using
! * its <code>draw</code> method.
* <p>
! * <code>TextLayout</code> can be constructed either directly or through
* the use of a {@link LineBreakMeasurer}. When constructed directly, the
! * source text represents a single paragraph. <code>LineBreakMeasurer</code>
* allows styled text to be broken into lines that fit within a particular
! * width. See the <code>LineBreakMeasurer</code> documentation for more
* information.
* <p>
! * <code>TextLayout</code> construction logically proceeds as follows:
* <ul>
* <li>paragraph attributes are extracted and examined,
* <li>text is analyzed for bidirectional reordering, and reordering
* information is computed if needed,
* <li>text is segmented into style runs
--- 86,106 ----
* <li>default font substitution,
* <li>metric information such as ascent, descent, and advance, and
* <li>rendering
* </ul>
* <p>
! * A {@code TextLayout} object can be rendered using
! * its {@code draw} method.
* <p>
! * {@code TextLayout} can be constructed either directly or through
* the use of a {@link LineBreakMeasurer}. When constructed directly, the
! * source text represents a single paragraph. {@code LineBreakMeasurer}
* allows styled text to be broken into lines that fit within a particular
! * width. See the {@code LineBreakMeasurer} documentation for more
* information.
* <p>
! * {@code TextLayout} construction logically proceeds as follows:
* <ul>
* <li>paragraph attributes are extracted and examined,
* <li>text is analyzed for bidirectional reordering, and reordering
* information is computed if needed,
* <li>text is segmented into style runs
*** 111,149 ****
* broken into subruns sharing a common baseline,
* <li>glyphvectors are generated for each run using the chosen font,
* <li>final bidirectional reordering is performed on the glyphvectors
* </ul>
* <p>
! * All graphical information returned from a <code>TextLayout</code>
* object's methods is relative to the origin of the
! * <code>TextLayout</code>, which is the intersection of the
! * <code>TextLayout</code> object's baseline with its left edge. Also,
! * coordinates passed into a <code>TextLayout</code> object's methods
! * are assumed to be relative to the <code>TextLayout</code> object's
* origin. Clients usually need to translate between a
! * <code>TextLayout</code> object's coordinate system and the coordinate
* system in another object (such as a
* {@link java.awt.Graphics Graphics} object).
* <p>
! * <code>TextLayout</code> objects are constructed from styled text,
* but they do not retain a reference to their source text. Thus,
! * changes in the text previously used to generate a <code>TextLayout</code>
! * do not affect the <code>TextLayout</code>.
* <p>
! * Three methods on a <code>TextLayout</code> object
! * (<code>getNextRightHit</code>, <code>getNextLeftHit</code>, and
! * <code>hitTestChar</code>) return instances of {@link TextHitInfo}.
! * The offsets contained in these <code>TextHitInfo</code> objects
! * are relative to the start of the <code>TextLayout</code>, <b>not</b>
! * to the text used to create the <code>TextLayout</code>. Similarly,
! * <code>TextLayout</code> methods that accept <code>TextHitInfo</code>
! * instances as parameters expect the <code>TextHitInfo</code> object's
! * offsets to be relative to the <code>TextLayout</code>, not to any
* underlying text storage model.
* <p>
* <strong>Examples</strong>:<p>
! * Constructing and drawing a <code>TextLayout</code> and its bounding
* rectangle:
* <blockquote><pre>
* Graphics2D g = ...;
* Point2D loc = ...;
* Font font = Font.getFont("Helvetica-bold-italic");
--- 111,149 ----
* broken into subruns sharing a common baseline,
* <li>glyphvectors are generated for each run using the chosen font,
* <li>final bidirectional reordering is performed on the glyphvectors
* </ul>
* <p>
! * All graphical information returned from a {@code TextLayout}
* object's methods is relative to the origin of the
! * {@code TextLayout}, which is the intersection of the
! * {@code TextLayout} object's baseline with its left edge. Also,
! * coordinates passed into a {@code TextLayout} object's methods
! * are assumed to be relative to the {@code TextLayout} object's
* origin. Clients usually need to translate between a
! * {@code TextLayout} object's coordinate system and the coordinate
* system in another object (such as a
* {@link java.awt.Graphics Graphics} object).
* <p>
! * {@code TextLayout} objects are constructed from styled text,
* but they do not retain a reference to their source text. Thus,
! * changes in the text previously used to generate a {@code TextLayout}
! * do not affect the {@code TextLayout}.
* <p>
! * Three methods on a {@code TextLayout} object
! * ({@code getNextRightHit}, {@code getNextLeftHit}, and
! * {@code hitTestChar}) return instances of {@link TextHitInfo}.
! * The offsets contained in these {@code TextHitInfo} objects
! * are relative to the start of the {@code TextLayout}, <b>not</b>
! * to the text used to create the {@code TextLayout}. Similarly,
! * {@code TextLayout} methods that accept {@code TextHitInfo}
! * instances as parameters expect the {@code TextHitInfo} object's
! * offsets to be relative to the {@code TextLayout}, not to any
* underlying text storage model.
* <p>
* <strong>Examples</strong>:<p>
! * Constructing and drawing a {@code TextLayout} and its bounding
* rectangle:
* <blockquote><pre>
* Graphics2D g = ...;
* Point2D loc = ...;
* Font font = Font.getFont("Helvetica-bold-italic");
*** 158,168 ****
* bounds.getHeight());
* g.draw(bounds);
* </pre>
* </blockquote>
* <p>
! * Hit-testing a <code>TextLayout</code> (determining which character is at
* a particular graphical location):
* <blockquote><pre>
* Point2D click = ...;
* TextHitInfo hit = layout.hitTestChar(
* (float) (click.getX() - loc.getX()),
--- 158,168 ----
* bounds.getHeight());
* g.draw(bounds);
* </pre>
* </blockquote>
* <p>
! * Hit-testing a {@code TextLayout} (determining which character is at
* a particular graphical location):
* <blockquote><pre>
* Point2D click = ...;
* TextHitInfo hit = layout.hitTestChar(
* (float) (click.getX() - loc.getX()),
*** 201,211 ****
* </pre></blockquote>
* <p>
* Drawing a visually contiguous selection range. The selection range may
* correspond to more than one substring in the source text. The ranges of
* the corresponding source text substrings can be obtained with
! * <code>getLogicalRangesForVisualSelection()</code>:
* <blockquote><pre>
* TextHitInfo selStart = ..., selLimit = ...;
* Shape selection = layout.getVisualHighlightShape(selStart, selLimit);
* g.setColor(selectionColor);
* g.fill(selection);
--- 201,211 ----
* </pre></blockquote>
* <p>
* Drawing a visually contiguous selection range. The selection range may
* correspond to more than one substring in the source text. The ranges of
* the corresponding source text substrings can be obtained with
! * {@code getLogicalRangesForVisualSelection()}:
* <blockquote><pre>
* TextHitInfo selStart = ..., selLimit = ...;
* Shape selection = layout.getVisualHighlightShape(selStart, selLimit);
* g.setColor(selectionColor);
* g.fill(selection);
*** 297,338 ****
*/
private boolean caretsInLigaturesAreAllowed = false;
/**
* Defines a policy for determining the strong caret location.
! * This class contains one method, <code>getStrongCaret</code>, which
* is used to specify the policy that determines the strong caret in
* dual-caret text. The strong caret is used to move the caret to the
* left or right. Instances of this class can be passed to
! * <code>getCaretShapes</code>, <code>getNextLeftHit</code> and
! * <code>getNextRightHit</code> to customize strong caret
* selection.
* <p>
! * To specify alternate caret policies, subclass <code>CaretPolicy</code>
! * and override <code>getStrongCaret</code>. <code>getStrongCaret</code>
! * should inspect the two <code>TextHitInfo</code> arguments and choose
* one of them as the strong caret.
* <p>
* Most clients do not need to use this class.
*/
public static class CaretPolicy {
/**
! * Constructs a <code>CaretPolicy</code>.
*/
public CaretPolicy() {
}
/**
! * Chooses one of the specified <code>TextHitInfo</code> instances as
! * a strong caret in the specified <code>TextLayout</code>.
! * @param hit1 a valid hit in <code>layout</code>
! * @param hit2 a valid hit in <code>layout</code>
! * @param layout the <code>TextLayout</code> in which
! * <code>hit1</code> and <code>hit2</code> are used
! * @return <code>hit1</code> or <code>hit2</code>
! * (or an equivalent <code>TextHitInfo</code>), indicating the
* strong caret.
*/
public TextHitInfo getStrongCaret(TextHitInfo hit1,
TextHitInfo hit2,
TextLayout layout) {
--- 297,338 ----
*/
private boolean caretsInLigaturesAreAllowed = false;
/**
* Defines a policy for determining the strong caret location.
! * This class contains one method, {@code getStrongCaret}, which
* is used to specify the policy that determines the strong caret in
* dual-caret text. The strong caret is used to move the caret to the
* left or right. Instances of this class can be passed to
! * {@code getCaretShapes}, {@code getNextLeftHit} and
! * {@code getNextRightHit} to customize strong caret
* selection.
* <p>
! * To specify alternate caret policies, subclass {@code CaretPolicy}
! * and override {@code getStrongCaret}. {@code getStrongCaret}
! * should inspect the two {@code TextHitInfo} arguments and choose
* one of them as the strong caret.
* <p>
* Most clients do not need to use this class.
*/
public static class CaretPolicy {
/**
! * Constructs a {@code CaretPolicy}.
*/
public CaretPolicy() {
}
/**
! * Chooses one of the specified {@code TextHitInfo} instances as
! * a strong caret in the specified {@code TextLayout}.
! * @param hit1 a valid hit in {@code layout}
! * @param hit2 a valid hit in {@code layout}
! * @param layout the {@code TextLayout} in which
! * {@code hit1} and {@code hit2} are used
! * @return {@code hit1} or {@code hit2}
! * (or an equivalent {@code TextHitInfo}), indicating the
* strong caret.
*/
public TextHitInfo getStrongCaret(TextHitInfo hit1,
TextHitInfo hit2,
TextLayout layout) {
*** 341,375 ****
return layout.getStrongHit(hit1, hit2);
}
}
/**
! * This <code>CaretPolicy</code> is used when a policy is not specified
* by the client. With this policy, a hit on a character whose direction
* is the same as the line direction is stronger than a hit on a
* counterdirectional character. If the characters' directions are
* the same, a hit on the leading edge of a character is stronger
* than a hit on the trailing edge of a character.
*/
public static final CaretPolicy DEFAULT_CARET_POLICY = new CaretPolicy();
/**
! * Constructs a <code>TextLayout</code> from a <code>String</code>
* and a {@link Font}. All the text is styled using the specified
! * <code>Font</code>.
* <p>
! * The <code>String</code> must specify a single paragraph of text,
* because an entire paragraph is required for the bidirectional
* algorithm.
* @param string the text to display
! * @param font a <code>Font</code> used to style the text
* @param frc contains information about a graphics device which is needed
* to measure the text correctly.
* Text measurements can vary slightly depending on the
* device resolution, and attributes such as antialiasing. This
* parameter does not specify a translation between the
! * <code>TextLayout</code> and user space.
*/
public TextLayout(String string, Font font, FontRenderContext frc) {
if (font == null) {
throw new IllegalArgumentException("Null font passed to TextLayout constructor.");
--- 341,375 ----
return layout.getStrongHit(hit1, hit2);
}
}
/**
! * This {@code CaretPolicy} is used when a policy is not specified
* by the client. With this policy, a hit on a character whose direction
* is the same as the line direction is stronger than a hit on a
* counterdirectional character. If the characters' directions are
* the same, a hit on the leading edge of a character is stronger
* than a hit on the trailing edge of a character.
*/
public static final CaretPolicy DEFAULT_CARET_POLICY = new CaretPolicy();
/**
! * Constructs a {@code TextLayout} from a {@code String}
* and a {@link Font}. All the text is styled using the specified
! * {@code Font}.
* <p>
! * The {@code String} must specify a single paragraph of text,
* because an entire paragraph is required for the bidirectional
* algorithm.
* @param string the text to display
! * @param font a {@code Font} used to style the text
* @param frc contains information about a graphics device which is needed
* to measure the text correctly.
* Text measurements can vary slightly depending on the
* device resolution, and attributes such as antialiasing. This
* parameter does not specify a translation between the
! * {@code TextLayout} and user space.
*/
public TextLayout(String string, Font font, FontRenderContext frc) {
if (font == null) {
throw new IllegalArgumentException("Null font passed to TextLayout constructor.");
*** 399,423 ****
standardInit(as.getIterator(), text, frc);
}
}
/**
! * Constructs a <code>TextLayout</code> from a <code>String</code>
* and an attribute set.
* <p>
* All the text is styled using the provided attributes.
* <p>
! * <code>string</code> must specify a single paragraph of text because an
* entire paragraph is required for the bidirectional algorithm.
* @param string the text to display
* @param attributes the attributes used to style the text
* @param frc contains information about a graphics device which is needed
* to measure the text correctly.
* Text measurements can vary slightly depending on the
* device resolution, and attributes such as antialiasing. This
* parameter does not specify a translation between the
! * <code>TextLayout</code> and user space.
*/
public TextLayout(String string, Map<? extends Attribute,?> attributes,
FontRenderContext frc)
{
if (string == null) {
--- 399,423 ----
standardInit(as.getIterator(), text, frc);
}
}
/**
! * Constructs a {@code TextLayout} from a {@code String}
* and an attribute set.
* <p>
* All the text is styled using the provided attributes.
* <p>
! * {@code string} must specify a single paragraph of text because an
* entire paragraph is required for the bidirectional algorithm.
* @param string the text to display
* @param attributes the attributes used to style the text
* @param frc contains information about a graphics device which is needed
* to measure the text correctly.
* Text measurements can vary slightly depending on the
* device resolution, and attributes such as antialiasing. This
* parameter does not specify a translation between the
! * {@code TextLayout} and user space.
*/
public TextLayout(String string, Map<? extends Attribute,?> attributes,
FontRenderContext frc)
{
if (string == null) {
*** 486,507 ****
return font;
}
/**
! * Constructs a <code>TextLayout</code> from an iterator over styled text.
* <p>
* The iterator must specify a single paragraph of text because an
* entire paragraph is required for the bidirectional
* algorithm.
* @param text the styled text to display
* @param frc contains information about a graphics device which is needed
* to measure the text correctly.
* Text measurements can vary slightly depending on the
* device resolution, and attributes such as antialiasing. This
* parameter does not specify a translation between the
! * <code>TextLayout</code> and user space.
*/
public TextLayout(AttributedCharacterIterator text, FontRenderContext frc) {
if (text == null) {
throw new IllegalArgumentException("Null iterator passed to TextLayout constructor.");
--- 486,507 ----
return font;
}
/**
! * Constructs a {@code TextLayout} from an iterator over styled text.
* <p>
* The iterator must specify a single paragraph of text because an
* entire paragraph is required for the bidirectional
* algorithm.
* @param text the styled text to display
* @param frc contains information about a graphics device which is needed
* to measure the text correctly.
* Text measurements can vary slightly depending on the
* device resolution, and attributes such as antialiasing. This
* parameter does not specify a translation between the
! * {@code TextLayout} and user space.
*/
public TextLayout(AttributedCharacterIterator text, FontRenderContext frc) {
if (text == null) {
throw new IllegalArgumentException("Null iterator passed to TextLayout constructor.");
*** 537,556 ****
standardInit(text, chars, frc);
}
/**
! * Creates a <code>TextLayout</code> from a {@link TextLine} and
* some paragraph data. This method is used by {@link TextMeasurer}.
* @param textLine the line measurement attributes to apply to the
! * the resulting <code>TextLayout</code>
* @param baseline the baseline of the text
* @param baselineOffsets the baseline offsets for this
! * <code>TextLayout</code>. This should already be normalized to
! * <code>baseline</code>
! * @param justifyRatio <code>0</code> if the <code>TextLayout</code>
! * cannot be justified; <code>1</code> otherwise.
*/
TextLayout(TextLine textLine,
byte baseline,
float[] baselineOffsets,
float justifyRatio) {
--- 537,556 ----
standardInit(text, chars, frc);
}
/**
! * Creates a {@code TextLayout} from a {@link TextLine} and
* some paragraph data. This method is used by {@link TextMeasurer}.
* @param textLine the line measurement attributes to apply to the
! * the resulting {@code TextLayout}
* @param baseline the baseline of the text
* @param baselineOffsets the baseline offsets for this
! * {@code TextLayout}. This should already be normalized to
! * {@code baseline}
! * @param justifyRatio {@code 0} if the {@code TextLayout}
! * cannot be justified; {@code 1} otherwise.
*/
TextLayout(TextLine textLine,
byte baseline,
float[] baselineOffsets,
float justifyRatio) {
*** 741,751 ****
return naturalBounds;
}
/**
! * Creates a copy of this <code>TextLayout</code>.
*/
protected Object clone() {
/*
* !!! I think this is safe. Once created, nothing mutates the
* glyphvectors or arrays. But we need to make sure.
--- 741,751 ----
return naturalBounds;
}
/**
! * Creates a copy of this {@code TextLayout}.
*/
protected Object clone() {
/*
* !!! I think this is safe. Once created, nothing mutates the
* glyphvectors or arrays. But we need to make sure.
*** 780,800 ****
throw new IllegalArgumentException("TextHitInfo is out of range");
}
}
/**
! * Creates a copy of this <code>TextLayout</code> justified to the
* specified width.
* <p>
! * If this <code>TextLayout</code> has already been justified, an
! * exception is thrown. If this <code>TextLayout</code> object's
! * justification ratio is zero, a <code>TextLayout</code> identical
! * to this <code>TextLayout</code> is returned.
* @param justificationWidth the width to use when justifying the line.
* For best results, it should not be too different from the current
* advance of the line.
! * @return a <code>TextLayout</code> justified to the specified width.
* @exception Error if this layout has already been justified, an Error is
* thrown.
*/
public TextLayout getJustifiedLayout(float justificationWidth) {
--- 780,800 ----
throw new IllegalArgumentException("TextHitInfo is out of range");
}
}
/**
! * Creates a copy of this {@code TextLayout} justified to the
* specified width.
* <p>
! * If this {@code TextLayout} has already been justified, an
! * exception is thrown. If this {@code TextLayout} object's
! * justification ratio is zero, a {@code TextLayout} identical
! * to this {@code TextLayout} is returned.
* @param justificationWidth the width to use when justifying the line.
* For best results, it should not be too different from the current
* advance of the line.
! * @return a {@code TextLayout} justified to the specified width.
* @exception Error if this layout has already been justified, an Error is
* thrown.
*/
public TextLayout getJustifiedLayout(float justificationWidth) {
*** 847,953 ****
// never called
}
/**
! * Returns the baseline for this <code>TextLayout</code>.
! * The baseline is one of the values defined in <code>Font</code>,
* which are roman, centered and hanging. Ascent and descent are
! * relative to this baseline. The <code>baselineOffsets</code>
* are also relative to this baseline.
! * @return the baseline of this <code>TextLayout</code>.
* @see #getBaselineOffsets()
* @see Font
*/
public byte getBaseline() {
return baseline;
}
/**
* Returns the offsets array for the baselines used for this
! * <code>TextLayout</code>.
* <p>
* The array is indexed by one of the values defined in
! * <code>Font</code>, which are roman, centered and hanging. The
! * values are relative to this <code>TextLayout</code> object's
! * baseline, so that <code>getBaselineOffsets[getBaseline()] == 0</code>.
! * Offsets are added to the position of the <code>TextLayout</code>
* object's baseline to get the position for the new baseline.
* @return the offsets array containing the baselines used for this
! * <code>TextLayout</code>.
* @see #getBaseline()
* @see Font
*/
public float[] getBaselineOffsets() {
float[] offsets = new float[baselineOffsets.length];
System.arraycopy(baselineOffsets, 0, offsets, 0, offsets.length);
return offsets;
}
/**
! * Returns the advance of this <code>TextLayout</code>.
* The advance is the distance from the origin to the advance of the
* rightmost (bottommost) character. This is in baseline-relative
* coordinates.
! * @return the advance of this <code>TextLayout</code>.
*/
public float getAdvance() {
ensureCache();
return lineMetrics.advance;
}
/**
! * Returns the advance of this <code>TextLayout</code>, minus trailing
* whitespace. This is in baseline-relative coordinates.
! * @return the advance of this <code>TextLayout</code> without the
* trailing whitespace.
* @see #getAdvance()
*/
public float getVisibleAdvance() {
ensureCache();
return visibleAdvance;
}
/**
! * Returns the ascent of this <code>TextLayout</code>.
* The ascent is the distance from the top (right) of the
! * <code>TextLayout</code> to the baseline. It is always either
* positive or zero. The ascent is sufficient to
* accommodate superscripted text and is the maximum of the sum of the
* ascent, offset, and baseline of each glyph. The ascent is
* the maximum ascent from the baseline of all the text in the
* TextLayout. It is in baseline-relative coordinates.
! * @return the ascent of this <code>TextLayout</code>.
*/
public float getAscent() {
ensureCache();
return lineMetrics.ascent;
}
/**
! * Returns the descent of this <code>TextLayout</code>.
* The descent is the distance from the baseline to the bottom (left) of
! * the <code>TextLayout</code>. It is always either positive or zero.
* The descent is sufficient to accommodate subscripted text and is the
* maximum of the sum of the descent, offset, and baseline of each glyph.
* This is the maximum descent from the baseline of all the text in
* the TextLayout. It is in baseline-relative coordinates.
! * @return the descent of this <code>TextLayout</code>.
*/
public float getDescent() {
ensureCache();
return lineMetrics.descent;
}
/**
! * Returns the leading of the <code>TextLayout</code>.
* The leading is the suggested interline spacing for this
! * <code>TextLayout</code>. This is in baseline-relative
* coordinates.
* <p>
* The leading is computed from the leading, descent, and baseline
! * of all glyphvectors in the <code>TextLayout</code>. The algorithm
* is roughly as follows:
* <blockquote><pre>
* maxD = 0;
* maxDL = 0;
* for (GlyphVector g in all glyphvectors) {
--- 847,953 ----
// never called
}
/**
! * Returns the baseline for this {@code TextLayout}.
! * The baseline is one of the values defined in {@code Font},
* which are roman, centered and hanging. Ascent and descent are
! * relative to this baseline. The {@code baselineOffsets}
* are also relative to this baseline.
! * @return the baseline of this {@code TextLayout}.
* @see #getBaselineOffsets()
* @see Font
*/
public byte getBaseline() {
return baseline;
}
/**
* Returns the offsets array for the baselines used for this
! * {@code TextLayout}.
* <p>
* The array is indexed by one of the values defined in
! * {@code Font}, which are roman, centered and hanging. The
! * values are relative to this {@code TextLayout} object's
! * baseline, so that {@code getBaselineOffsets[getBaseline()] == 0}.
! * Offsets are added to the position of the {@code TextLayout}
* object's baseline to get the position for the new baseline.
* @return the offsets array containing the baselines used for this
! * {@code TextLayout}.
* @see #getBaseline()
* @see Font
*/
public float[] getBaselineOffsets() {
float[] offsets = new float[baselineOffsets.length];
System.arraycopy(baselineOffsets, 0, offsets, 0, offsets.length);
return offsets;
}
/**
! * Returns the advance of this {@code TextLayout}.
* The advance is the distance from the origin to the advance of the
* rightmost (bottommost) character. This is in baseline-relative
* coordinates.
! * @return the advance of this {@code TextLayout}.
*/
public float getAdvance() {
ensureCache();
return lineMetrics.advance;
}
/**
! * Returns the advance of this {@code TextLayout}, minus trailing
* whitespace. This is in baseline-relative coordinates.
! * @return the advance of this {@code TextLayout} without the
* trailing whitespace.
* @see #getAdvance()
*/
public float getVisibleAdvance() {
ensureCache();
return visibleAdvance;
}
/**
! * Returns the ascent of this {@code TextLayout}.
* The ascent is the distance from the top (right) of the
! * {@code TextLayout} to the baseline. It is always either
* positive or zero. The ascent is sufficient to
* accommodate superscripted text and is the maximum of the sum of the
* ascent, offset, and baseline of each glyph. The ascent is
* the maximum ascent from the baseline of all the text in the
* TextLayout. It is in baseline-relative coordinates.
! * @return the ascent of this {@code TextLayout}.
*/
public float getAscent() {
ensureCache();
return lineMetrics.ascent;
}
/**
! * Returns the descent of this {@code TextLayout}.
* The descent is the distance from the baseline to the bottom (left) of
! * the {@code TextLayout}. It is always either positive or zero.
* The descent is sufficient to accommodate subscripted text and is the
* maximum of the sum of the descent, offset, and baseline of each glyph.
* This is the maximum descent from the baseline of all the text in
* the TextLayout. It is in baseline-relative coordinates.
! * @return the descent of this {@code TextLayout}.
*/
public float getDescent() {
ensureCache();
return lineMetrics.descent;
}
/**
! * Returns the leading of the {@code TextLayout}.
* The leading is the suggested interline spacing for this
! * {@code TextLayout}. This is in baseline-relative
* coordinates.
* <p>
* The leading is computed from the leading, descent, and baseline
! * of all glyphvectors in the {@code TextLayout}. The algorithm
* is roughly as follows:
* <blockquote><pre>
* maxD = 0;
* maxDL = 0;
* for (GlyphVector g in all glyphvectors) {
*** 955,980 ****
* maxDL = max(maxDL, g.getDescent() + g.getLeading() +
* offsets[g.getBaseline()]);
* }
* return maxDL - maxD;
* </pre></blockquote>
! * @return the leading of this <code>TextLayout</code>.
*/
public float getLeading() {
ensureCache();
return lineMetrics.leading;
}
/**
! * Returns the bounds of this <code>TextLayout</code>.
* The bounds are in standard coordinates.
* <p>Due to rasterization effects, this bounds might not enclose all of the
* pixels rendered by the TextLayout.</p>
* It might not coincide exactly with the ascent, descent,
! * origin or advance of the <code>TextLayout</code>.
* @return a {@link Rectangle2D} that is the bounds of this
! * <code>TextLayout</code>.
*/
public Rectangle2D getBounds() {
ensureCache();
if (boundsRect == null) {
--- 955,980 ----
* maxDL = max(maxDL, g.getDescent() + g.getLeading() +
* offsets[g.getBaseline()]);
* }
* return maxDL - maxD;
* </pre></blockquote>
! * @return the leading of this {@code TextLayout}.
*/
public float getLeading() {
ensureCache();
return lineMetrics.leading;
}
/**
! * Returns the bounds of this {@code TextLayout}.
* The bounds are in standard coordinates.
* <p>Due to rasterization effects, this bounds might not enclose all of the
* pixels rendered by the TextLayout.</p>
* It might not coincide exactly with the ascent, descent,
! * origin or advance of the {@code TextLayout}.
* @return a {@link Rectangle2D} that is the bounds of this
! * {@code TextLayout}.
*/
public Rectangle2D getBounds() {
ensureCache();
if (boundsRect == null) {
*** 993,1054 ****
return bounds;
}
/**
! * Returns the pixel bounds of this <code>TextLayout</code> when
* rendered in a graphics with the given
! * <code>FontRenderContext</code> at the given location. The
* graphics render context need not be the same as the
! * <code>FontRenderContext</code> used to create this
! * <code>TextLayout</code>, and can be null. If it is null, the
! * <code>FontRenderContext</code> of this <code>TextLayout</code>
* is used.
! * @param frc the <code>FontRenderContext</code> of the <code>Graphics</code>.
! * @param x the x-coordinate at which to render this <code>TextLayout</code>.
! * @param y the y-coordinate at which to render this <code>TextLayout</code>.
! * @return a <code>Rectangle</code> bounding the pixels that would be affected.
* @see GlyphVector#getPixelBounds
* @since 1.6
*/
public Rectangle getPixelBounds(FontRenderContext frc, float x, float y) {
return textLine.getPixelBounds(frc, x, y);
}
/**
! * Returns <code>true</code> if this <code>TextLayout</code> has
! * a left-to-right base direction or <code>false</code> if it has
! * a right-to-left base direction. The <code>TextLayout</code>
* has a base direction of either left-to-right (LTR) or
* right-to-left (RTL). The base direction is independent of the
* actual direction of text on the line, which may be either LTR,
* RTL, or mixed. Left-to-right layouts by default should position
* flush left. If the layout is on a tabbed line, the
* tabs run left to right, so that logically successive layouts position
* left to right. The opposite is true for RTL layouts. By default they
* should position flush left, and tabs run right-to-left.
! * @return <code>true</code> if the base direction of this
! * <code>TextLayout</code> is left-to-right; <code>false</code>
* otherwise.
*/
public boolean isLeftToRight() {
return textLine.isDirectionLTR();
}
/**
! * Returns <code>true</code> if this <code>TextLayout</code> is vertical.
! * @return <code>true</code> if this <code>TextLayout</code> is vertical;
! * <code>false</code> otherwise.
*/
public boolean isVertical() {
return isVerticalLine;
}
/**
* Returns the number of characters represented by this
! * <code>TextLayout</code>.
! * @return the number of characters in this <code>TextLayout</code>.
*/
public int getCharacterCount() {
return characterCount;
}
--- 993,1054 ----
return bounds;
}
/**
! * Returns the pixel bounds of this {@code TextLayout} when
* rendered in a graphics with the given
! * {@code FontRenderContext} at the given location. The
* graphics render context need not be the same as the
! * {@code FontRenderContext} used to create this
! * {@code TextLayout}, and can be null. If it is null, the
! * {@code FontRenderContext} of this {@code TextLayout}
* is used.
! * @param frc the {@code FontRenderContext} of the {@code Graphics}.
! * @param x the x-coordinate at which to render this {@code TextLayout}.
! * @param y the y-coordinate at which to render this {@code TextLayout}.
! * @return a {@code Rectangle} bounding the pixels that would be affected.
* @see GlyphVector#getPixelBounds
* @since 1.6
*/
public Rectangle getPixelBounds(FontRenderContext frc, float x, float y) {
return textLine.getPixelBounds(frc, x, y);
}
/**
! * Returns {@code true} if this {@code TextLayout} has
! * a left-to-right base direction or {@code false} if it has
! * a right-to-left base direction. The {@code TextLayout}
* has a base direction of either left-to-right (LTR) or
* right-to-left (RTL). The base direction is independent of the
* actual direction of text on the line, which may be either LTR,
* RTL, or mixed. Left-to-right layouts by default should position
* flush left. If the layout is on a tabbed line, the
* tabs run left to right, so that logically successive layouts position
* left to right. The opposite is true for RTL layouts. By default they
* should position flush left, and tabs run right-to-left.
! * @return {@code true} if the base direction of this
! * {@code TextLayout} is left-to-right; {@code false}
* otherwise.
*/
public boolean isLeftToRight() {
return textLine.isDirectionLTR();
}
/**
! * Returns {@code true} if this {@code TextLayout} is vertical.
! * @return {@code true} if this {@code TextLayout} is vertical;
! * {@code false} otherwise.
*/
public boolean isVertical() {
return isVerticalLine;
}
/**
* Returns the number of characters represented by this
! * {@code TextLayout}.
! * @return the number of characters in this {@code TextLayout}.
*/
public int getCharacterCount() {
return characterCount;
}
*** 1197,1215 ****
return info;
}
/**
! * Returns information about the caret corresponding to <code>hit</code>.
* The first element of the array is the intersection of the caret with
* the baseline, as a distance along the baseline. The second element
* of the array is the inverse slope (run/rise) of the caret, measured
* with respect to the baseline at that point.
* <p>
* This method is meant for informational use. To display carets, it
! * is better to use <code>getCaretShapes</code>.
! * @param hit a hit on a character in this <code>TextLayout</code>
* @param bounds the bounds to which the caret info is constructed.
* The bounds is in baseline-relative coordinates.
* @return a two-element array containing the position and slope of
* the caret. The returned caret info is in baseline-relative coordinates.
* @see #getCaretShapes(int, Rectangle2D, TextLayout.CaretPolicy)
--- 1197,1215 ----
return info;
}
/**
! * Returns information about the caret corresponding to {@code hit}.
* The first element of the array is the intersection of the caret with
* the baseline, as a distance along the baseline. The second element
* of the array is the inverse slope (run/rise) of the caret, measured
* with respect to the baseline at that point.
* <p>
* This method is meant for informational use. To display carets, it
! * is better to use {@code getCaretShapes}.
! * @param hit a hit on a character in this {@code TextLayout}
* @param bounds the bounds to which the caret info is constructed.
* The bounds is in baseline-relative coordinates.
* @return a two-element array containing the position and slope of
* the caret. The returned caret info is in baseline-relative coordinates.
* @see #getCaretShapes(int, Rectangle2D, TextLayout.CaretPolicy)
*** 1308,1335 ****
return info;
}
/**
! * Returns information about the caret corresponding to <code>hit</code>.
! * This method is a convenience overload of <code>getCaretInfo</code> and
! * uses the natural bounds of this <code>TextLayout</code>.
! * @param hit a hit on a character in this <code>TextLayout</code>
* @return the information about a caret corresponding to a hit. The
* returned caret info is in baseline-relative coordinates.
*/
public float[] getCaretInfo(TextHitInfo hit) {
return getCaretInfo(hit, getNaturalBounds());
}
/**
! * Returns a caret index corresponding to <code>hit</code>.
* Carets are numbered from left to right (top to bottom) starting from
* zero. This always places carets next to the character hit, on the
* indicated side of the character.
! * @param hit a hit on a character in this <code>TextLayout</code>
* @return a caret index corresponding to the specified hit.
*/
private int hitToCaret(TextHitInfo hit) {
int hitIndex = hit.getCharIndex();
--- 1308,1335 ----
return info;
}
/**
! * Returns information about the caret corresponding to {@code hit}.
! * This method is a convenience overload of {@code getCaretInfo} and
! * uses the natural bounds of this {@code TextLayout}.
! * @param hit a hit on a character in this {@code TextLayout}
* @return the information about a caret corresponding to a hit. The
* returned caret info is in baseline-relative coordinates.
*/
public float[] getCaretInfo(TextHitInfo hit) {
return getCaretInfo(hit, getNaturalBounds());
}
/**
! * Returns a caret index corresponding to {@code hit}.
* Carets are numbered from left to right (top to bottom) starting from
* zero. This always places carets next to the character hit, on the
* indicated side of the character.
! * @param hit a hit on a character in this {@code TextLayout}
* @return a caret index corresponding to the specified hit.
*/
private int hitToCaret(TextHitInfo hit) {
int hitIndex = hit.getCharIndex();
*** 1399,1414 ****
return textLine.caretAtOffsetIsValid(offset);
}
/**
* Returns the hit for the next caret to the right (bottom); if there
! * is no such hit, returns <code>null</code>.
* If the hit character index is out of bounds, an
* {@link IllegalArgumentException} is thrown.
* @param hit a hit on a character in this layout
* @return a hit whose caret appears at the next position to the
! * right (bottom) of the caret of the provided hit or <code>null</code>.
*/
public TextHitInfo getNextRightHit(TextHitInfo hit) {
ensureCache();
checkTextHit(hit);
--- 1399,1414 ----
return textLine.caretAtOffsetIsValid(offset);
}
/**
* Returns the hit for the next caret to the right (bottom); if there
! * is no such hit, returns {@code null}.
* If the hit character index is out of bounds, an
* {@link IllegalArgumentException} is thrown.
* @param hit a hit on a character in this layout
* @return a hit whose caret appears at the next position to the
! * right (bottom) of the caret of the provided hit or {@code null}.
*/
public TextHitInfo getNextRightHit(TextHitInfo hit) {
ensureCache();
checkTextHit(hit);
*** 1425,1445 ****
return caretToHit(caret);
}
/**
* Returns the hit for the next caret to the right (bottom); if no
! * such hit, returns <code>null</code>. The hit is to the right of
* the strong caret at the specified offset, as determined by the
* specified policy.
* The returned hit is the stronger of the two possible
* hits, as determined by the specified policy.
! * @param offset an insertion offset in this <code>TextLayout</code>.
! * Cannot be less than 0 or greater than this <code>TextLayout</code>
* object's character count.
* @param policy the policy used to select the strong caret
* @return a hit whose caret appears at the next position to the
! * right (bottom) of the caret of the provided hit, or <code>null</code>.
*/
public TextHitInfo getNextRightHit(int offset, CaretPolicy policy) {
if (offset < 0 || offset > characterCount) {
throw new IllegalArgumentException("Offset out of bounds in TextLayout.getNextRightHit()");
--- 1425,1445 ----
return caretToHit(caret);
}
/**
* Returns the hit for the next caret to the right (bottom); if no
! * such hit, returns {@code null}. The hit is to the right of
* the strong caret at the specified offset, as determined by the
* specified policy.
* The returned hit is the stronger of the two possible
* hits, as determined by the specified policy.
! * @param offset an insertion offset in this {@code TextLayout}.
! * Cannot be less than 0 or greater than this {@code TextLayout}
* object's character count.
* @param policy the policy used to select the strong caret
* @return a hit whose caret appears at the next position to the
! * right (bottom) of the caret of the provided hit, or {@code null}.
*/
public TextHitInfo getNextRightHit(int offset, CaretPolicy policy) {
if (offset < 0 || offset > characterCount) {
throw new IllegalArgumentException("Offset out of bounds in TextLayout.getNextRightHit()");
*** 1463,1496 ****
}
}
/**
* Returns the hit for the next caret to the right (bottom); if no
! * such hit, returns <code>null</code>. The hit is to the right of
* the strong caret at the specified offset, as determined by the
* default policy.
* The returned hit is the stronger of the two possible
* hits, as determined by the default policy.
! * @param offset an insertion offset in this <code>TextLayout</code>.
! * Cannot be less than 0 or greater than the <code>TextLayout</code>
* object's character count.
* @return a hit whose caret appears at the next position to the
! * right (bottom) of the caret of the provided hit, or <code>null</code>.
*/
public TextHitInfo getNextRightHit(int offset) {
return getNextRightHit(offset, DEFAULT_CARET_POLICY);
}
/**
* Returns the hit for the next caret to the left (top); if no such
! * hit, returns <code>null</code>.
* If the hit character index is out of bounds, an
! * <code>IllegalArgumentException</code> is thrown.
! * @param hit a hit on a character in this <code>TextLayout</code>.
* @return a hit whose caret appears at the next position to the
! * left (top) of the caret of the provided hit, or <code>null</code>.
*/
public TextHitInfo getNextLeftHit(TextHitInfo hit) {
ensureCache();
checkTextHit(hit);
--- 1463,1496 ----
}
}
/**
* Returns the hit for the next caret to the right (bottom); if no
! * such hit, returns {@code null}. The hit is to the right of
* the strong caret at the specified offset, as determined by the
* default policy.
* The returned hit is the stronger of the two possible
* hits, as determined by the default policy.
! * @param offset an insertion offset in this {@code TextLayout}.
! * Cannot be less than 0 or greater than the {@code TextLayout}
* object's character count.
* @return a hit whose caret appears at the next position to the
! * right (bottom) of the caret of the provided hit, or {@code null}.
*/
public TextHitInfo getNextRightHit(int offset) {
return getNextRightHit(offset, DEFAULT_CARET_POLICY);
}
/**
* Returns the hit for the next caret to the left (top); if no such
! * hit, returns {@code null}.
* If the hit character index is out of bounds, an
! * {@code IllegalArgumentException} is thrown.
! * @param hit a hit on a character in this {@code TextLayout}.
* @return a hit whose caret appears at the next position to the
! * left (top) of the caret of the provided hit, or {@code null}.
*/
public TextHitInfo getNextLeftHit(TextHitInfo hit) {
ensureCache();
checkTextHit(hit);
*** 1507,1527 ****
return caretToHit(caret);
}
/**
* Returns the hit for the next caret to the left (top); if no
! * such hit, returns <code>null</code>. The hit is to the left of
* the strong caret at the specified offset, as determined by the
* specified policy.
* The returned hit is the stronger of the two possible
* hits, as determined by the specified policy.
! * @param offset an insertion offset in this <code>TextLayout</code>.
! * Cannot be less than 0 or greater than this <code>TextLayout</code>
* object's character count.
* @param policy the policy used to select the strong caret
* @return a hit whose caret appears at the next position to the
! * left (top) of the caret of the provided hit, or <code>null</code>.
*/
public TextHitInfo getNextLeftHit(int offset, CaretPolicy policy) {
if (policy == null) {
throw new IllegalArgumentException("Null CaretPolicy passed to TextLayout.getNextLeftHit()");
--- 1507,1527 ----
return caretToHit(caret);
}
/**
* Returns the hit for the next caret to the left (top); if no
! * such hit, returns {@code null}. The hit is to the left of
* the strong caret at the specified offset, as determined by the
* specified policy.
* The returned hit is the stronger of the two possible
* hits, as determined by the specified policy.
! * @param offset an insertion offset in this {@code TextLayout}.
! * Cannot be less than 0 or greater than this {@code TextLayout}
* object's character count.
* @param policy the policy used to select the strong caret
* @return a hit whose caret appears at the next position to the
! * left (top) of the caret of the provided hit, or {@code null}.
*/
public TextHitInfo getNextLeftHit(int offset, CaretPolicy policy) {
if (policy == null) {
throw new IllegalArgumentException("Null CaretPolicy passed to TextLayout.getNextLeftHit()");
*** 1545,1564 ****
}
}
/**
* Returns the hit for the next caret to the left (top); if no
! * such hit, returns <code>null</code>. The hit is to the left of
* the strong caret at the specified offset, as determined by the
* default policy.
* The returned hit is the stronger of the two possible
* hits, as determined by the default policy.
! * @param offset an insertion offset in this <code>TextLayout</code>.
! * Cannot be less than 0 or greater than this <code>TextLayout</code>
* object's character count.
* @return a hit whose caret appears at the next position to the
! * left (top) of the caret of the provided hit, or <code>null</code>.
*/
public TextHitInfo getNextLeftHit(int offset) {
return getNextLeftHit(offset, DEFAULT_CARET_POLICY);
}
--- 1545,1564 ----
}
}
/**
* Returns the hit for the next caret to the left (top); if no
! * such hit, returns {@code null}. The hit is to the left of
* the strong caret at the specified offset, as determined by the
* default policy.
* The returned hit is the stronger of the two possible
* hits, as determined by the default policy.
! * @param offset an insertion offset in this {@code TextLayout}.
! * Cannot be less than 0 or greater than this {@code TextLayout}
* object's character count.
* @return a hit whose caret appears at the next position to the
! * left (top) of the caret of the provided hit, or {@code null}.
*/
public TextHitInfo getNextLeftHit(int offset) {
return getNextLeftHit(offset, DEFAULT_CARET_POLICY);
}
*** 1775,1788 ****
/**
* Returns a {@link Shape} representing the caret at the specified
* hit inside the specified bounds.
* @param hit the hit at which to generate the caret
! * @param bounds the bounds of the <code>TextLayout</code> to use
* in generating the caret. The bounds is in baseline-relative
* coordinates.
! * @return a <code>Shape</code> representing the caret. The returned
* shape is in standard coordinates.
*/
public Shape getCaretShape(TextHitInfo hit, Rectangle2D bounds) {
ensureCache();
checkTextHit(hit);
--- 1775,1788 ----
/**
* Returns a {@link Shape} representing the caret at the specified
* hit inside the specified bounds.
* @param hit the hit at which to generate the caret
! * @param bounds the bounds of the {@code TextLayout} to use
* in generating the caret. The bounds is in baseline-relative
* coordinates.
! * @return a {@code Shape} representing the caret. The returned
* shape is in standard coordinates.
*/
public Shape getCaretShape(TextHitInfo hit, Rectangle2D bounds) {
ensureCache();
checkTextHit(hit);
*** 1793,1806 ****
return pathToShape(getCaretPath(hit, bounds), false, textLine.getLayoutPath());
}
/**
! * Returns a <code>Shape</code> representing the caret at the specified
! * hit inside the natural bounds of this <code>TextLayout</code>.
* @param hit the hit at which to generate the caret
! * @return a <code>Shape</code> representing the caret. The returned
* shape is in standard coordinates.
*/
public Shape getCaretShape(TextHitInfo hit) {
return getCaretShape(hit, getNaturalBounds());
--- 1793,1806 ----
return pathToShape(getCaretPath(hit, bounds), false, textLine.getLayoutPath());
}
/**
! * Returns a {@code Shape} representing the caret at the specified
! * hit inside the natural bounds of this {@code TextLayout}.
* @param hit the hit at which to generate the caret
! * @return a {@code Shape} representing the caret. The returned
* shape is in standard coordinates.
*/
public Shape getCaretShape(TextHitInfo hit) {
return getCaretShape(hit, getNaturalBounds());
*** 1835,1847 ****
return (hit1Level < hit2Level)? hit1 : hit2;
}
}
/**
! * Returns the level of the character at <code>index</code>.
! * Indices -1 and <code>characterCount</code> are assigned the base
! * level of this <code>TextLayout</code>.
* @param index the index of the character from which to get the level
* @return the level of the character at the specified index.
*/
public byte getCharacterLevel(int index) {
--- 1835,1847 ----
return (hit1Level < hit2Level)? hit1 : hit2;
}
}
/**
! * Returns the level of the character at {@code index}.
! * Indices -1 and {@code characterCount} are assigned the base
! * level of this {@code TextLayout}.
* @param index the index of the character from which to get the level
* @return the level of the character at the specified index.
*/
public byte getCharacterLevel(int index) {
*** 1858,1874 ****
return textLine.getCharLevel(index);
}
/**
* Returns two paths corresponding to the strong and weak caret.
! * @param offset an offset in this <code>TextLayout</code>
* @param bounds the bounds to which to extend the carets. The
* bounds is in baseline-relative coordinates.
! * @param policy the specified <code>CaretPolicy</code>
* @return an array of two paths. Element zero is the strong
* caret. If there are two carets, element one is the weak caret,
! * otherwise it is <code>null</code>. The returned shapes
* are in standard coordinates.
*/
public Shape[] getCaretShapes(int offset, Rectangle2D bounds, CaretPolicy policy) {
ensureCache();
--- 1858,1874 ----
return textLine.getCharLevel(index);
}
/**
* Returns two paths corresponding to the strong and weak caret.
! * @param offset an offset in this {@code TextLayout}
* @param bounds the bounds to which to extend the carets. The
* bounds is in baseline-relative coordinates.
! * @param policy the specified {@code CaretPolicy}
* @return an array of two paths. Element zero is the strong
* caret. If there are two carets, element one is the weak caret,
! * otherwise it is {@code null}. The returned shapes
* are in standard coordinates.
*/
public Shape[] getCaretShapes(int offset, Rectangle2D bounds, CaretPolicy policy) {
ensureCache();
*** 1918,1949 ****
return result;
}
/**
* Returns two paths corresponding to the strong and weak caret.
! * This method is a convenience overload of <code>getCaretShapes</code>
* that uses the default caret policy.
! * @param offset an offset in this <code>TextLayout</code>
* @param bounds the bounds to which to extend the carets. This is
* in baseline-relative coordinates.
* @return two paths corresponding to the strong and weak caret as
! * defined by the <code>DEFAULT_CARET_POLICY</code>. These are
* in standard coordinates.
*/
public Shape[] getCaretShapes(int offset, Rectangle2D bounds) {
// {sfb} parameter checking is done in overloaded version
return getCaretShapes(offset, bounds, DEFAULT_CARET_POLICY);
}
/**
* Returns two paths corresponding to the strong and weak caret.
! * This method is a convenience overload of <code>getCaretShapes</code>
! * that uses the default caret policy and this <code>TextLayout</code>
* object's natural bounds.
! * @param offset an offset in this <code>TextLayout</code>
* @return two paths corresponding to the strong and weak caret as
! * defined by the <code>DEFAULT_CARET_POLICY</code>. These are
* in standard coordinates.
*/
public Shape[] getCaretShapes(int offset) {
// {sfb} parameter checking is done in overloaded version
return getCaretShapes(offset, getNaturalBounds(), DEFAULT_CARET_POLICY);
--- 1918,1949 ----
return result;
}
/**
* Returns two paths corresponding to the strong and weak caret.
! * This method is a convenience overload of {@code getCaretShapes}
* that uses the default caret policy.
! * @param offset an offset in this {@code TextLayout}
* @param bounds the bounds to which to extend the carets. This is
* in baseline-relative coordinates.
* @return two paths corresponding to the strong and weak caret as
! * defined by the {@code DEFAULT_CARET_POLICY}. These are
* in standard coordinates.
*/
public Shape[] getCaretShapes(int offset, Rectangle2D bounds) {
// {sfb} parameter checking is done in overloaded version
return getCaretShapes(offset, bounds, DEFAULT_CARET_POLICY);
}
/**
* Returns two paths corresponding to the strong and weak caret.
! * This method is a convenience overload of {@code getCaretShapes}
! * that uses the default caret policy and this {@code TextLayout}
* object's natural bounds.
! * @param offset an offset in this {@code TextLayout}
* @return two paths corresponding to the strong and weak caret as
! * defined by the {@code DEFAULT_CARET_POLICY}. These are
* in standard coordinates.
*/
public Shape[] getCaretShapes(int offset) {
// {sfb} parameter checking is done in overloaded version
return getCaretShapes(offset, getNaturalBounds(), DEFAULT_CARET_POLICY);
*** 2066,2076 ****
/**
* Returns the logical ranges of text corresponding to a visual selection.
* @param firstEndpoint an endpoint of the visual range
* @param secondEndpoint the other endpoint of the visual range.
! * This endpoint can be less than <code>firstEndpoint</code>.
* @return an array of integers representing start/limit pairs for the
* selected ranges.
* @see #getVisualHighlightShape(TextHitInfo, TextHitInfo, Rectangle2D)
*/
public int[] getLogicalRangesForVisualSelection(TextHitInfo firstEndpoint,
--- 2066,2076 ----
/**
* Returns the logical ranges of text corresponding to a visual selection.
* @param firstEndpoint an endpoint of the visual range
* @param secondEndpoint the other endpoint of the visual range.
! * This endpoint can be less than {@code firstEndpoint}.
* @return an array of integers representing start/limit pairs for the
* selected ranges.
* @see #getVisualHighlightShape(TextHitInfo, TextHitInfo, Rectangle2D)
*/
public int[] getLogicalRangesForVisualSelection(TextHitInfo firstEndpoint,
*** 2139,2161 ****
return ranges;
}
/**
* Returns a path enclosing the visual selection in the specified range,
! * extended to <code>bounds</code>.
* <p>
* If the selection includes the leftmost (topmost) position, the selection
! * is extended to the left (top) of <code>bounds</code>. If the
* selection includes the rightmost (bottommost) position, the selection
* is extended to the right (bottom) of the bounds. The height
* (width on vertical lines) of the selection is always extended to
! * <code>bounds</code>.
* <p>
* Although the selection is always contiguous, the logically selected
* text can be discontiguous on lines with mixed-direction text. The
* logical ranges of text selected can be retrieved using
! * <code>getLogicalRangesForVisualSelection</code>. For example,
* consider the text 'ABCdef' where capital letters indicate
* right-to-left text, rendered on a right-to-left line, with a visual
* selection from 0L (the leading edge of 'A') to 3T (the trailing edge
* of 'd'). The text appears as follows, with bold underlined areas
* representing the selection:
--- 2139,2161 ----
return ranges;
}
/**
* Returns a path enclosing the visual selection in the specified range,
! * extended to {@code bounds}.
* <p>
* If the selection includes the leftmost (topmost) position, the selection
! * is extended to the left (top) of {@code bounds}. If the
* selection includes the rightmost (bottommost) position, the selection
* is extended to the right (bottom) of the bounds. The height
* (width on vertical lines) of the selection is always extended to
! * {@code bounds}.
* <p>
* Although the selection is always contiguous, the logically selected
* text can be discontiguous on lines with mixed-direction text. The
* logical ranges of text selected can be retrieved using
! * {@code getLogicalRangesForVisualSelection}. For example,
* consider the text 'ABCdef' where capital letters indicate
* right-to-left text, rendered on a right-to-left line, with a visual
* selection from 0L (the leading edge of 'A') to 3T (the trailing edge
* of 'd'). The text appears as follows, with bold underlined areas
* representing the selection:
*** 2168,2178 ****
* selected, the selection is extended to the right of the bounds.
* @param firstEndpoint one end of the visual selection
* @param secondEndpoint the other end of the visual selection
* @param bounds the bounding rectangle to which to extend the selection.
* This is in baseline-relative coordinates.
! * @return a <code>Shape</code> enclosing the selection. This is in
* standard coordinates.
* @see #getLogicalRangesForVisualSelection(TextHitInfo, TextHitInfo)
* @see #getLogicalHighlightShape(int, int, Rectangle2D)
*/
public Shape getVisualHighlightShape(TextHitInfo firstEndpoint,
--- 2168,2178 ----
* selected, the selection is extended to the right of the bounds.
* @param firstEndpoint one end of the visual selection
* @param secondEndpoint the other end of the visual selection
* @param bounds the bounding rectangle to which to extend the selection.
* This is in baseline-relative coordinates.
! * @return a {@code Shape} enclosing the selection. This is in
* standard coordinates.
* @see #getLogicalRangesForVisualSelection(TextHitInfo, TextHitInfo)
* @see #getLogicalHighlightShape(int, int, Rectangle2D)
*/
public Shape getVisualHighlightShape(TextHitInfo firstEndpoint,
*** 2216,2250 ****
return result;
}
/**
! * Returns a <code>Shape</code> enclosing the visual selection in the
* specified range, extended to the bounds. This method is a
! * convenience overload of <code>getVisualHighlightShape</code> that
! * uses the natural bounds of this <code>TextLayout</code>.
* @param firstEndpoint one end of the visual selection
* @param secondEndpoint the other end of the visual selection
! * @return a <code>Shape</code> enclosing the selection. This is
* in standard coordinates.
*/
public Shape getVisualHighlightShape(TextHitInfo firstEndpoint,
TextHitInfo secondEndpoint) {
return getVisualHighlightShape(firstEndpoint, secondEndpoint, getNaturalBounds());
}
/**
! * Returns a <code>Shape</code> enclosing the logical selection in the
! * specified range, extended to the specified <code>bounds</code>.
* <p>
* If the selection range includes the first logical character, the
! * selection is extended to the portion of <code>bounds</code> before
! * the start of this <code>TextLayout</code>. If the range includes
* the last logical character, the selection is extended to the portion
! * of <code>bounds</code> after the end of this <code>TextLayout</code>.
* The height (width on vertical lines) of the selection is always
! * extended to <code>bounds</code>.
* <p>
* The selection can be discontiguous on lines with mixed-direction text.
* Only those characters in the logical range between start and limit
* appear selected. For example, consider the text 'ABCdef' where capital
* letters indicate right-to-left text, rendered on a right-to-left line,
--- 2216,2250 ----
return result;
}
/**
! * Returns a {@code Shape} enclosing the visual selection in the
* specified range, extended to the bounds. This method is a
! * convenience overload of {@code getVisualHighlightShape} that
! * uses the natural bounds of this {@code TextLayout}.
* @param firstEndpoint one end of the visual selection
* @param secondEndpoint the other end of the visual selection
! * @return a {@code Shape} enclosing the selection. This is
* in standard coordinates.
*/
public Shape getVisualHighlightShape(TextHitInfo firstEndpoint,
TextHitInfo secondEndpoint) {
return getVisualHighlightShape(firstEndpoint, secondEndpoint, getNaturalBounds());
}
/**
! * Returns a {@code Shape} enclosing the logical selection in the
! * specified range, extended to the specified {@code bounds}.
* <p>
* If the selection range includes the first logical character, the
! * selection is extended to the portion of {@code bounds} before
! * the start of this {@code TextLayout}. If the range includes
* the last logical character, the selection is extended to the portion
! * of {@code bounds} after the end of this {@code TextLayout}.
* The height (width on vertical lines) of the selection is always
! * extended to {@code bounds}.
* <p>
* The selection can be discontiguous on lines with mixed-direction text.
* Only those characters in the logical range between start and limit
* appear selected. For example, consider the text 'ABCdef' where capital
* letters indicate right-to-left text, rendered on a right-to-left line,
*** 2255,2270 ****
* <u><b>d</b></u>ef<u><b>CBA </b></u>
* </pre>
* The selection is discontiguous because the selected characters are
* visually discontiguous. Also note that since the range includes the
* first logical character (A), the selection is extended to the portion
! * of the <code>bounds</code> before the start of the layout, which in
* this case (a right-to-left line) is the right portion of the
! * <code>bounds</code>.
* @param firstEndpoint an endpoint in the range of characters to select
* @param secondEndpoint the other endpoint of the range of characters
! * to select. Can be less than <code>firstEndpoint</code>. The range
* includes the character at min(firstEndpoint, secondEndpoint), but
* excludes max(firstEndpoint, secondEndpoint).
* @param bounds the bounding rectangle to which to extend the selection.
* This is in baseline-relative coordinates.
* @return an area enclosing the selection. This is in standard
--- 2255,2270 ----
* <u><b>d</b></u>ef<u><b>CBA </b></u>
* </pre>
* The selection is discontiguous because the selected characters are
* visually discontiguous. Also note that since the range includes the
* first logical character (A), the selection is extended to the portion
! * of the {@code bounds} before the start of the layout, which in
* this case (a right-to-left line) is the right portion of the
! * {@code bounds}.
* @param firstEndpoint an endpoint in the range of characters to select
* @param secondEndpoint the other endpoint of the range of characters
! * to select. Can be less than {@code firstEndpoint}. The range
* includes the character at min(firstEndpoint, secondEndpoint), but
* excludes max(firstEndpoint, secondEndpoint).
* @param bounds the bounding rectangle to which to extend the selection.
* This is in baseline-relative coordinates.
* @return an area enclosing the selection. This is in standard
*** 2352,2372 ****
}
return result;
}
/**
! * Returns a <code>Shape</code> enclosing the logical selection in the
* specified range, extended to the natural bounds of this
! * <code>TextLayout</code>. This method is a convenience overload of
! * <code>getLogicalHighlightShape</code> that uses the natural bounds of
! * this <code>TextLayout</code>.
* @param firstEndpoint an endpoint in the range of characters to select
* @param secondEndpoint the other endpoint of the range of characters
! * to select. Can be less than <code>firstEndpoint</code>. The range
* includes the character at min(firstEndpoint, secondEndpoint), but
* excludes max(firstEndpoint, secondEndpoint).
! * @return a <code>Shape</code> enclosing the selection. This is in
* standard coordinates.
*/
public Shape getLogicalHighlightShape(int firstEndpoint, int secondEndpoint) {
return getLogicalHighlightShape(firstEndpoint, secondEndpoint, getNaturalBounds());
--- 2352,2372 ----
}
return result;
}
/**
! * Returns a {@code Shape} enclosing the logical selection in the
* specified range, extended to the natural bounds of this
! * {@code TextLayout}. This method is a convenience overload of
! * {@code getLogicalHighlightShape} that uses the natural bounds of
! * this {@code TextLayout}.
* @param firstEndpoint an endpoint in the range of characters to select
* @param secondEndpoint the other endpoint of the range of characters
! * to select. Can be less than {@code firstEndpoint}. The range
* includes the character at min(firstEndpoint, secondEndpoint), but
* excludes max(firstEndpoint, secondEndpoint).
! * @return a {@code Shape} enclosing the selection. This is in
* standard coordinates.
*/
public Shape getLogicalHighlightShape(int firstEndpoint, int secondEndpoint) {
return getLogicalHighlightShape(firstEndpoint, secondEndpoint, getNaturalBounds());
*** 2377,2388 ****
* The black box bounds is an area consisting of the union of the bounding
* boxes of all the glyphs corresponding to the characters between start
* and limit. This area can be disjoint.
* @param firstEndpoint one end of the character range
* @param secondEndpoint the other end of the character range. Can be
! * less than <code>firstEndpoint</code>.
! * @return a <code>Shape</code> enclosing the black box bounds. This is
* in standard coordinates.
*/
public Shape getBlackBoxBounds(int firstEndpoint, int secondEndpoint) {
ensureCache();
--- 2377,2388 ----
* The black box bounds is an area consisting of the union of the bounding
* boxes of all the glyphs corresponding to the characters between start
* and limit. This area can be disjoint.
* @param firstEndpoint one end of the character range
* @param secondEndpoint the other end of the character range. Can be
! * less than {@code firstEndpoint}.
! * @return a {@code Shape} enclosing the black box bounds. This is
* in standard coordinates.
*/
public Shape getBlackBoxBounds(int firstEndpoint, int secondEndpoint) {
ensureCache();
*** 2428,2438 ****
return result;
}
/**
* Returns the distance from the point (x, y) to the caret along
! * the line direction defined in <code>caretInfo</code>. Distance is
* negative if the point is to the left of the caret on a horizontal
* line, or above the caret on a vertical line.
* Utility for use by hitTestChar.
*/
private float caretToPointDistance(float[] caretInfo, float x, float y) {
--- 2428,2438 ----
return result;
}
/**
* Returns the distance from the point (x, y) to the caret along
! * the line direction defined in {@code caretInfo}. Distance is
* negative if the point is to the left of the caret on a horizontal
* line, or above the caret on a vertical line.
* Utility for use by hitTestChar.
*/
private float caretToPointDistance(float[] caretInfo, float x, float y) {
*** 2444,2465 ****
return lineDistance - caretInfo[0] +
(distanceOffBaseline*caretInfo[1]);
}
/**
! * Returns a <code>TextHitInfo</code> corresponding to the
* specified point.
! * Coordinates outside the bounds of the <code>TextLayout</code>
* map to hits on the leading edge of the first logical character,
* or the trailing edge of the last logical character, as appropriate,
* regardless of the position of that character in the line. Only the
* direction along the baseline is used to make this evaluation.
* @param x the x offset from the origin of this
! * <code>TextLayout</code>. This is in standard coordinates.
* @param y the y offset from the origin of this
! * <code>TextLayout</code>. This is in standard coordinates.
! * @param bounds the bounds of the <code>TextLayout</code>. This
* is in baseline-relative coordinates.
* @return a hit describing the character and edge (leading or trailing)
* under the specified point.
*/
public TextHitInfo hitTestChar(float x, float y, Rectangle2D bounds) {
--- 2444,2465 ----
return lineDistance - caretInfo[0] +
(distanceOffBaseline*caretInfo[1]);
}
/**
! * Returns a {@code TextHitInfo} corresponding to the
* specified point.
! * Coordinates outside the bounds of the {@code TextLayout}
* map to hits on the leading edge of the first logical character,
* or the trailing edge of the last logical character, as appropriate,
* regardless of the position of that character in the line. Only the
* direction along the baseline is used to make this evaluation.
* @param x the x offset from the origin of this
! * {@code TextLayout}. This is in standard coordinates.
* @param y the y offset from the origin of this
! * {@code TextLayout}. This is in standard coordinates.
! * @param bounds the bounds of the {@code TextLayout}. This
* is in baseline-relative coordinates.
* @return a hit describing the character and edge (leading or trailing)
* under the specified point.
*/
public TextHitInfo hitTestChar(float x, float y, Rectangle2D bounds) {
*** 2550,2607 ****
TextHitInfo.trailing(trail-1);
return result;
}
/**
! * Returns a <code>TextHitInfo</code> corresponding to the
* specified point. This method is a convenience overload of
! * <code>hitTestChar</code> that uses the natural bounds of this
! * <code>TextLayout</code>.
* @param x the x offset from the origin of this
! * <code>TextLayout</code>. This is in standard coordinates.
* @param y the y offset from the origin of this
! * <code>TextLayout</code>. This is in standard coordinates.
* @return a hit describing the character and edge (leading or trailing)
* under the specified point.
*/
public TextHitInfo hitTestChar(float x, float y) {
return hitTestChar(x, y, getNaturalBounds());
}
/**
! * Returns the hash code of this <code>TextLayout</code>.
! * @return the hash code of this <code>TextLayout</code>.
*/
public int hashCode() {
if (hashCodeCache == 0) {
ensureCache();
hashCodeCache = textLine.hashCode();
}
return hashCodeCache;
}
/**
! * Returns <code>true</code> if the specified <code>Object</code> is a
! * <code>TextLayout</code> object and if the specified <code>Object</code>
! * equals this <code>TextLayout</code>.
! * @param obj an <code>Object</code> to test for equality
! * @return <code>true</code> if the specified <code>Object</code>
! * equals this <code>TextLayout</code>; <code>false</code>
* otherwise.
*/
public boolean equals(Object obj) {
return (obj instanceof TextLayout) && equals((TextLayout)obj);
}
/**
! * Returns <code>true</code> if the two layouts are equal.
* Two layouts are equal if they contain equal glyphvectors in the same order.
! * @param rhs the <code>TextLayout</code> to compare to this
! * <code>TextLayout</code>
! * @return <code>true</code> if the specified <code>TextLayout</code>
! * equals this <code>TextLayout</code>.
*
*/
public boolean equals(TextLayout rhs) {
if (rhs == null) {
--- 2550,2607 ----
TextHitInfo.trailing(trail-1);
return result;
}
/**
! * Returns a {@code TextHitInfo} corresponding to the
* specified point. This method is a convenience overload of
! * {@code hitTestChar} that uses the natural bounds of this
! * {@code TextLayout}.
* @param x the x offset from the origin of this
! * {@code TextLayout}. This is in standard coordinates.
* @param y the y offset from the origin of this
! * {@code TextLayout}. This is in standard coordinates.
* @return a hit describing the character and edge (leading or trailing)
* under the specified point.
*/
public TextHitInfo hitTestChar(float x, float y) {
return hitTestChar(x, y, getNaturalBounds());
}
/**
! * Returns the hash code of this {@code TextLayout}.
! * @return the hash code of this {@code TextLayout}.
*/
public int hashCode() {
if (hashCodeCache == 0) {
ensureCache();
hashCodeCache = textLine.hashCode();
}
return hashCodeCache;
}
/**
! * Returns {@code true} if the specified {@code Object} is a
! * {@code TextLayout} object and if the specified {@code Object}
! * equals this {@code TextLayout}.
! * @param obj an {@code Object} to test for equality
! * @return {@code true} if the specified {@code Object}
! * equals this {@code TextLayout}; {@code false}
* otherwise.
*/
public boolean equals(Object obj) {
return (obj instanceof TextLayout) && equals((TextLayout)obj);
}
/**
! * Returns {@code true} if the two layouts are equal.
* Two layouts are equal if they contain equal glyphvectors in the same order.
! * @param rhs the {@code TextLayout} to compare to this
! * {@code TextLayout}
! * @return {@code true} if the specified {@code TextLayout}
! * equals this {@code TextLayout}.
*
*/
public boolean equals(TextLayout rhs) {
if (rhs == null) {
*** 2614,2643 ****
ensureCache();
return textLine.equals(rhs.textLine);
}
/**
! * Returns debugging information for this <code>TextLayout</code>.
! * @return the <code>textLine</code> of this <code>TextLayout</code>
! * as a <code>String</code>.
*/
public String toString() {
ensureCache();
return textLine.toString();
}
/**
! * Renders this <code>TextLayout</code> at the specified location in
* the specified {@link java.awt.Graphics2D Graphics2D} context.
* The origin of the layout is placed at x, y. Rendering may touch
! * any point within <code>getBounds()</code> of this position. This
! * leaves the <code>g2</code> unchanged. Text is rendered along the
* baseline path.
! * @param g2 the <code>Graphics2D</code> context into which to render
* the layout
! * @param x the X coordinate of the origin of this <code>TextLayout</code>
! * @param y the Y coordinate of the origin of this <code>TextLayout</code>
* @see #getBounds()
*/
public void draw(Graphics2D g2, float x, float y) {
if (g2 == null) {
--- 2614,2643 ----
ensureCache();
return textLine.equals(rhs.textLine);
}
/**
! * Returns debugging information for this {@code TextLayout}.
! * @return the {@code textLine} of this {@code TextLayout}
! * as a {@code String}.
*/
public String toString() {
ensureCache();
return textLine.toString();
}
/**
! * Renders this {@code TextLayout} at the specified location in
* the specified {@link java.awt.Graphics2D Graphics2D} context.
* The origin of the layout is placed at x, y. Rendering may touch
! * any point within {@code getBounds()} of this position. This
! * leaves the {@code g2} unchanged. Text is rendered along the
* baseline path.
! * @param g2 the {@code Graphics2D} context into which to render
* the layout
! * @param x the X coordinate of the origin of this {@code TextLayout}
! * @param y the Y coordinate of the origin of this {@code TextLayout}
* @see #getBounds()
*/
public void draw(Graphics2D g2, float x, float y) {
if (g2 == null) {
*** 2687,2702 ****
return alignment;
}
}
/**
! * Returns a <code>Shape</code> representing the outline of this
! * <code>TextLayout</code>.
* @param tx an optional {@link AffineTransform} to apply to the
! * outline of this <code>TextLayout</code>.
! * @return a <code>Shape</code> that is the outline of this
! * <code>TextLayout</code>. This is in standard coordinates.
*/
public Shape getOutline(AffineTransform tx) {
ensureCache();
Shape result = textLine.getOutline(tx);
LayoutPathImpl lp = textLine.getLayoutPath();
--- 2687,2702 ----
return alignment;
}
}
/**
! * Returns a {@code Shape} representing the outline of this
! * {@code TextLayout}.
* @param tx an optional {@link AffineTransform} to apply to the
! * outline of this {@code TextLayout}.
! * @return a {@code Shape} that is the outline of this
! * {@code TextLayout}. This is in standard coordinates.
*/
public Shape getOutline(AffineTransform tx) {
ensureCache();
Shape result = textLine.getOutline(tx);
LayoutPathImpl lp = textLine.getLayoutPath();
< prev index next >