< 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,&nbsp;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,&nbsp;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,&nbsp;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,&nbsp;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 >