/*
* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
/*
* (C) Copyright Taligent, Inc. 1996 - 1997, All Rights Reserved
* (C) Copyright IBM Corp. 1996-2003, All Rights Reserved
*
* The original version of this source code and documentation is
* copyrighted and owned by Taligent, Inc., a wholly-owned subsidiary
* of IBM. These materials are provided under terms of a License
* Agreement between Taligent and Sun. This technology is protected
* by multiple US and International patents.
*
* This notice and attribution to Taligent may not be removed.
* Taligent is a registered trademark of Taligent, Inc.
*
*/
package java.awt.font;
import java.awt.
Color;
import java.awt.
Font;
import java.awt.
Graphics2D;
import java.awt.
Rectangle;
import java.awt.
Shape;
import java.awt.font.
NumericShaper;
import java.awt.font.
TextLine.
TextLineMetrics;
import java.awt.geom.
AffineTransform;
import java.awt.geom.
GeneralPath;
import java.awt.geom.
NoninvertibleTransformException;
import java.awt.geom.
Point2D;
import java.awt.geom.
Rectangle2D;
import java.text.
AttributedString;
import java.text.
AttributedCharacterIterator;
import java.text.
AttributedCharacterIterator.
Attribute;
import java.text.
CharacterIterator;
import java.util.
Map;
import java.util.
HashMap;
import java.util.
Hashtable;
import sun.font.
AttributeValues;
import sun.font.
CoreMetrics;
import sun.font.
Decoration;
import sun.font.
FontLineMetrics;
import sun.font.
FontResolver;
import sun.font.
GraphicComponent;
import sun.font.
LayoutPathImpl;
import sun.text.
CodePointIterator;
/**
*
* <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,
* <li>cursor positioning and movement, including split cursors for
* mixed directional text,
* <li>highlighting, including both logical and visual highlighting
* for mixed directional text,
* <li>multiple baselines (roman, hanging, and centered),
* <li>hit testing,
* <li>justification,
* <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
* <li>fonts are chosen for style runs, first by using a font if the
* attribute {@link TextAttribute#FONT} is present, otherwise by computing
* a default font using the attributes that have been defined
* <li>if text is on multiple baselines, the runs or subruns are further
* 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");
* FontRenderContext frc = g.getFontRenderContext();
* TextLayout layout = new TextLayout("This is a string", font, frc);
* layout.draw(g, (float)loc.getX(), (float)loc.getY());
*
* Rectangle2D bounds = layout.getBounds();
* bounds.setRect(bounds.getX()+loc.getX(),
* bounds.getY()+loc.getY(),
* bounds.getWidth(),
* 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()),
* (float) (click.getY() - loc.getY()));
* </pre>
* </blockquote>
* <p>
* Responding to a right-arrow key press:
* <blockquote><pre>
* int insertionIndex = ...;
* TextHitInfo next = layout.getNextRightHit(insertionIndex);
* if (next != null) {
* // translate graphics to origin of layout on screen
* g.translate(loc.getX(), loc.getY());
* Shape[] carets = layout.getCaretShapes(next.getInsertionIndex());
* g.draw(carets[0]);
* if (carets[1] != null) {
* g.draw(carets[1]);
* }
* }
* </pre></blockquote>
* <p>
* Drawing a selection range corresponding to a substring in the source text.
* The selected area may not be visually contiguous:
* <blockquote><pre>
* // selStart, selLimit should be relative to the layout,
* // not to the source text
*
* int selStart = ..., selLimit = ...;
* Color selectionColor = ...;
* Shape selection = layout.getLogicalHighlightShape(selStart, selLimit);
* // selection may consist of disjoint areas
* // graphics is assumed to be tranlated to origin of layout
* g.setColor(selectionColor);
* g.fill(selection);
* </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);
* int[] ranges = getLogicalRangesForVisualSelection(selStart, selLimit);
* // ranges[0], ranges[1] is the first selection range,
* // ranges[2], ranges[3] is the second selection range, etc.
* </pre></blockquote>
* <p>
* Note: Font rotations can cause text baselines to be rotated, and
* multiple runs with different rotations can cause the baseline to
* bend or zig-zag. In order to account for this (rare) possibility,
* some APIs are specified to return metrics and take parameters 'in
* baseline-relative coordinates' (e.g. ascent, advance), and others
* are in 'in standard coordinates' (e.g. getBounds). Values in
* baseline-relative coordinates map the 'x' coordinate to the
* distance along the baseline, (positive x is forward along the
* baseline), and the 'y' coordinate to a distance along the
* perpendicular to the baseline at 'x' (positive y is 90 degrees
* clockwise from the baseline vector). Values in standard
* coordinates are measured along the x and y axes, with 0,0 at the
* origin of the TextLayout. Documentation for each relevant API
* indicates what values are in what coordinate system. In general,
* measurement-related APIs are in baseline-relative coordinates,
* while display-related APIs are in standard coordinates.
*
* @see LineBreakMeasurer
* @see TextAttribute
* @see TextHitInfo
* @see LayoutPath
*/
public final class
TextLayout implements
Cloneable {
private int
characterCount;
private boolean
isVerticalLine = false;
private byte
baseline;
private float[]
baselineOffsets; // why have these ?
private
TextLine textLine;
// cached values computed from GlyphSets and set info:
// all are recomputed from scratch in buildCache()
private
TextLine.
TextLineMetrics lineMetrics = null;
private float
visibleAdvance;
private int
hashCodeCache;
/*
* TextLayouts are supposedly immutable. If you mutate a TextLayout under
* the covers (like the justification code does) you'll need to set this
* back to false. Could be replaced with textLine != null <--> cacheIsValid.
*/
private boolean
cacheIsValid = false;
// This value is obtained from an attribute, and constrained to the
// interval [0,1]. If 0, the layout cannot be justified.
private float
justifyRatio;
// If a layout is produced by justification, then that layout
// cannot be justified. To enforce this constraint the
// justifyRatio of the justified layout is set to this value.
private static final float
ALREADY_JUSTIFIED = -53.9f;
// dx and dy specify the distance between the TextLayout's origin
// and the origin of the leftmost GlyphSet (TextLayoutComponent,
// actually). They were used for hanging punctuation support,
// which is no longer implemented. Currently they are both always 0,
// and TextLayout is not guaranteed to work with non-zero dx, dy
// values right now. They were left in as an aide and reminder to
// anyone who implements hanging punctuation or other similar stuff.
// They are static now so they don't take up space in TextLayout
// instances.
private static float
dx;
private static float
dy;
/*
* Natural bounds is used internally. It is built on demand in
* getNaturalBounds.
*/
private
Rectangle2D naturalBounds = null;
/*
* boundsRect encloses all of the bits this TextLayout can draw. It
* is build on demand in getBounds.
*/
private
Rectangle2D boundsRect = null;
/*
* flag to supress/allow carets inside of ligatures when hit testing or
* arrow-keying
*/
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) {
// default implementation just calls private method on layout
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.");
}
if (
string == null) {
throw new
IllegalArgumentException("Null string passed to TextLayout constructor.");
}
if (
string.
length() == 0) {
throw new
IllegalArgumentException("Zero length string passed to TextLayout constructor.");
}
Map<? extends
Attribute, ?>
attributes = null;
if (
font.
hasLayoutAttributes()) {
attributes =
font.
getAttributes();
}
char[]
text =
string.
toCharArray();
if (
sameBaselineUpTo(
font,
text, 0,
text.length) ==
text.length) {
fastInit(
text,
font,
attributes,
frc);
} else {
AttributedString as =
attributes == null
? new
AttributedString(
string)
: new
AttributedString(
string,
attributes);
as.
addAttribute(
TextAttribute.
FONT,
font);
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) {
throw new
IllegalArgumentException("Null string passed to TextLayout constructor.");
}
if (
attributes == null) {
throw new
IllegalArgumentException("Null map passed to TextLayout constructor.");
}
if (
string.
length() == 0) {
throw new
IllegalArgumentException("Zero length string passed to TextLayout constructor.");
}
char[]
text =
string.
toCharArray();
Font font =
singleFont(
text, 0,
text.length,
attributes);
if (
font != null) {
fastInit(
text,
font,
attributes,
frc);
} else {
AttributedString as = new
AttributedString(
string,
attributes);
standardInit(
as.
getIterator(),
text,
frc);
}
}
/*
* Determines a font for the attributes, and if a single font can render
* all the text on one baseline, return it, otherwise null. If the
* attributes specify a font, assume it can display all the text without
* checking.
* If the AttributeSet contains an embedded graphic, return null.
*/
private static
Font singleFont(char[]
text,
int
start,
int
limit,
Map<? extends
Attribute, ?>
attributes) {
if (
attributes.
get(
TextAttribute.
CHAR_REPLACEMENT) != null) {
return null;
}
Font font = null;
try {
font = (
Font)
attributes.
get(
TextAttribute.
FONT);
}
catch (
ClassCastException e) {
}
if (
font == null) {
if (
attributes.
get(
TextAttribute.
FAMILY) != null) {
font =
Font.
getFont(
attributes);
if (
font.
canDisplayUpTo(
text,
start,
limit) != -1) {
return null;
}
} else {
FontResolver resolver =
FontResolver.
getInstance();
CodePointIterator iter =
CodePointIterator.
create(
text,
start,
limit);
int
fontIndex =
resolver.
nextFontRunIndex(
iter);
if (
iter.
charIndex() ==
limit) {
font =
resolver.
getFont(
fontIndex,
attributes);
}
}
}
if (
sameBaselineUpTo(
font,
text,
start,
limit) !=
limit) {
return null;
}
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.");
}
int
start =
text.
getBeginIndex();
int
limit =
text.
getEndIndex();
if (
start ==
limit) {
throw new
IllegalArgumentException("Zero length iterator passed to TextLayout constructor.");
}
int
len =
limit -
start;
text.
first();
char[]
chars = new char[
len];
int
n = 0;
for (char
c =
text.
first();
c !=
CharacterIterator.
DONE;
c =
text.
next())
{
chars[
n++] =
c;
}
text.
first();
if (
text.
getRunLimit() ==
limit) {
Map<? extends
Attribute, ?>
attributes =
text.
getAttributes();
Font font =
singleFont(
chars, 0,
len,
attributes);
if (
font != null) {
fastInit(
chars,
font,
attributes,
frc);
return;
}
}
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) {
this.
characterCount =
textLine.
characterCount();
this.
baseline =
baseline;
this.
baselineOffsets =
baselineOffsets;
this.
textLine =
textLine;
this.
justifyRatio =
justifyRatio;
}
/**
* Initialize the paragraph-specific data.
*/
private void
paragraphInit(byte
aBaseline,
CoreMetrics lm,
Map<? extends
Attribute, ?>
paragraphAttrs,
char[]
text) {
baseline =
aBaseline;
// normalize to current baseline
baselineOffsets =
TextLine.
getNormalizedOffsets(
lm.
baselineOffsets,
baseline);
justifyRatio =
AttributeValues.
getJustification(
paragraphAttrs);
NumericShaper shaper =
AttributeValues.
getNumericShaping(
paragraphAttrs);
if (
shaper != null) {
shaper.
shape(
text, 0,
text.length);
}
}
/*
* the fast init generates a single glyph set. This requires:
* all one style
* all renderable by one font (ie no embedded graphics)
* all on one baseline
*/
private void
fastInit(char[]
chars,
Font font,
Map<? extends
Attribute, ?>
attrs,
FontRenderContext frc) {
// Object vf = attrs.get(TextAttribute.ORIENTATION);
// isVerticalLine = TextAttribute.ORIENTATION_VERTICAL.equals(vf);
isVerticalLine = false;
LineMetrics lm =
font.
getLineMetrics(
chars, 0,
chars.length,
frc);
CoreMetrics cm =
CoreMetrics.
get(
lm);
byte
glyphBaseline = (byte)
cm.
baselineIndex;
if (
attrs == null) {
baseline =
glyphBaseline;
baselineOffsets =
cm.
baselineOffsets;
justifyRatio = 1.0f;
} else {
paragraphInit(
glyphBaseline,
cm,
attrs,
chars);
}
characterCount =
chars.length;
textLine =
TextLine.
fastCreateTextLine(
frc,
chars,
font,
cm,
attrs);
}
/*
* the standard init generates multiple glyph sets based on style,
* renderable, and baseline runs.
* @param chars the text in the iterator, extracted into a char array
*/
private void
standardInit(
AttributedCharacterIterator text, char[]
chars,
FontRenderContext frc) {
characterCount =
chars.length;
// set paragraph attributes
{
// If there's an embedded graphic at the start of the
// paragraph, look for the first non-graphic character
// and use it and its font to initialize the paragraph.
// If not, use the first graphic to initialize.
Map<? extends
Attribute, ?>
paragraphAttrs =
text.
getAttributes();
boolean
haveFont =
TextLine.
advanceToFirstFont(
text);
if (
haveFont) {
Font defaultFont =
TextLine.
getFontAtCurrentPos(
text);
int
charsStart =
text.
getIndex() -
text.
getBeginIndex();
LineMetrics lm =
defaultFont.
getLineMetrics(
chars,
charsStart,
charsStart+1,
frc);
CoreMetrics cm =
CoreMetrics.
get(
lm);
paragraphInit((byte)
cm.
baselineIndex,
cm,
paragraphAttrs,
chars);
}
else {
// hmmm what to do here? Just try to supply reasonable
// values I guess.
GraphicAttribute graphic = (
GraphicAttribute)
paragraphAttrs.
get(
TextAttribute.
CHAR_REPLACEMENT);
byte
defaultBaseline =
getBaselineFromGraphic(
graphic);
CoreMetrics cm =
GraphicComponent.
createCoreMetrics(
graphic);
paragraphInit(
defaultBaseline,
cm,
paragraphAttrs,
chars);
}
}
textLine =
TextLine.
standardCreateTextLine(
frc,
text,
chars,
baselineOffsets);
}
/*
* A utility to rebuild the ascent/descent/leading/advance cache.
* You'll need to call this if you clone and mutate (like justification,
* editing methods do)
*/
private void
ensureCache() {
if (!
cacheIsValid) {
buildCache();
}
}
private void
buildCache() {
lineMetrics =
textLine.
getMetrics();
// compute visibleAdvance
if (
textLine.
isDirectionLTR()) {
int
lastNonSpace =
characterCount-1;
while (
lastNonSpace != -1) {
int
logIndex =
textLine.
visualToLogical(
lastNonSpace);
if (!
textLine.
isCharSpace(
logIndex)) {
break;
}
else {
--
lastNonSpace;
}
}
if (
lastNonSpace ==
characterCount-1) {
visibleAdvance =
lineMetrics.
advance;
}
else if (
lastNonSpace == -1) {
visibleAdvance = 0;
}
else {
int
logIndex =
textLine.
visualToLogical(
lastNonSpace);
visibleAdvance =
textLine.
getCharLinePosition(
logIndex)
+
textLine.
getCharAdvance(
logIndex);
}
}
else {
int
leftmostNonSpace = 0;
while (
leftmostNonSpace !=
characterCount) {
int
logIndex =
textLine.
visualToLogical(
leftmostNonSpace);
if (!
textLine.
isCharSpace(
logIndex)) {
break;
}
else {
++
leftmostNonSpace;
}
}
if (
leftmostNonSpace ==
characterCount) {
visibleAdvance = 0;
}
else if (
leftmostNonSpace == 0) {
visibleAdvance =
lineMetrics.
advance;
}
else {
int
logIndex =
textLine.
visualToLogical(
leftmostNonSpace);
float
pos =
textLine.
getCharLinePosition(
logIndex);
visibleAdvance =
lineMetrics.
advance -
pos;
}
}
// naturalBounds, boundsRect will be generated on demand
naturalBounds = null;
boundsRect = null;
// hashCode will be regenerated on demand
hashCodeCache = 0;
cacheIsValid = true;
}
/**
* The 'natural bounds' encloses all the carets the layout can draw.
*
*/
private
Rectangle2D getNaturalBounds() {
ensureCache();
if (
naturalBounds == null) {
naturalBounds =
textLine.
getItalicBounds();
}
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.
* {jbr} actually, that's not quite true. The justification code
* mutates after cloning. It doesn't actually change the glyphvectors
* (that's impossible) but it replaces them with justified sets. This
* is a problem for GlyphIterator creation, since new GlyphIterators
* are created by cloning a prototype. If the prototype has outdated
* glyphvectors, so will the new ones. A partial solution is to set the
* prototypical GlyphIterator to null when the glyphvectors change. If
* you forget this one time, you're hosed.
*/
try {
return super.clone();
}
catch (
CloneNotSupportedException e) {
throw new
InternalError(
e);
}
}
/*
* Utility to throw an expection if an invalid TextHitInfo is passed
* as a parameter. Avoids code duplication.
*/
private void
checkTextHit(
TextHitInfo hit) {
if (
hit == null) {
throw new
IllegalArgumentException("TextHitInfo is null.");
}
if (
hit.
getInsertionIndex() < 0 ||
hit.
getInsertionIndex() >
characterCount) {
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) {
if (
justificationWidth <= 0) {
throw new
IllegalArgumentException("justificationWidth <= 0 passed to TextLayout.getJustifiedLayout()");
}
if (
justifyRatio ==
ALREADY_JUSTIFIED) {
throw new
Error("Can't justify again.");
}
ensureCache(); // make sure textLine is not null
// default justification range to exclude trailing logical whitespace
int
limit =
characterCount;
while (
limit > 0 &&
textLine.
isCharWhitespace(
limit-1)) {
--
limit;
}
TextLine newLine =
textLine.
getJustifiedLine(
justificationWidth,
justifyRatio, 0,
limit);
if (
newLine != null) {
return new
TextLayout(
newLine,
baseline,
baselineOffsets,
ALREADY_JUSTIFIED);
}
return this;
}
/**
* Justify this layout. Overridden by subclassers to control justification
* (if there were subclassers, that is...)
*
* The layout will only justify if the paragraph attributes (from the
* source text, possibly defaulted by the layout attributes) indicate a
* non-zero justification ratio. The text will be justified to the
* indicated width. The current implementation also adjusts hanging
* punctuation and trailing whitespace to overhang the justification width.
* Once justified, the layout may not be rejustified.
* <p>
* Some code may rely on immutablity of layouts. Subclassers should not
* call this directly, but instead should call getJustifiedLayout, which
* will call this method on a clone of this layout, preserving
* the original.
*
* @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.
* @see #getJustifiedLayout(float)
*/
protected void
handleJustify(float
justificationWidth) {
// 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) {
* maxD = max(maxD, g.getDescent() + offsets[g.getBaseline()]);
* 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) {
Rectangle2D vb =
textLine.
getVisualBounds();
if (
dx != 0 ||
dy != 0) {
vb.
setRect(
vb.
getX() -
dx,
vb.
getY() -
dy,
vb.
getWidth(),
vb.
getHeight());
}
boundsRect =
vb;
}
Rectangle2D bounds = new
Rectangle2D.
Float();
bounds.
setRect(
boundsRect);
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;
}
/*
* carets and hit testing
*
* Positions on a text line are represented by instances of TextHitInfo.
* Any TextHitInfo with characterOffset between 0 and characterCount-1,
* inclusive, represents a valid position on the line. Additionally,
* [-1, trailing] and [characterCount, leading] are valid positions, and
* represent positions at the logical start and end of the line,
* respectively.
*
* The characterOffsets in TextHitInfo's used and returned by TextLayout
* are relative to the beginning of the text layout, not necessarily to
* the beginning of the text storage the client is using.
*
*
* Every valid TextHitInfo has either one or two carets associated with it.
* A caret is a visual location in the TextLayout indicating where text at
* the TextHitInfo will be displayed on screen. If a TextHitInfo
* represents a location on a directional boundary, then there are two
* possible visible positions for newly inserted text. Consider the
* following example, in which capital letters indicate right-to-left text,
* and the overall line direction is left-to-right:
*
* Text Storage: [ a, b, C, D, E, f ]
* Display: a b E D C f
*
* The text hit info (1, t) represents the trailing side of 'b'. If 'q',
* a left-to-right character is inserted into the text storage at this
* location, it will be displayed between the 'b' and the 'E':
*
* Text Storage: [ a, b, q, C, D, E, f ]
* Display: a b q E D C f
*
* However, if a 'W', which is right-to-left, is inserted into the storage
* after 'b', the storage and display will be:
*
* Text Storage: [ a, b, W, C, D, E, f ]
* Display: a b E D C W f
*
* So, for the original text storage, two carets should be displayed for
* location (1, t): one visually between 'b' and 'E' and one visually
* between 'C' and 'f'.
*
*
* When two carets are displayed for a TextHitInfo, one caret is the
* 'strong' caret and the other is the 'weak' caret. The strong caret
* indicates where an inserted character will be displayed when that
* character's direction is the same as the direction of the TextLayout.
* The weak caret shows where an character inserted character will be
* displayed when the character's direction is opposite that of the
* TextLayout.
*
*
* Clients should not be overly concerned with the details of correct
* caret display. TextLayout.getCaretShapes(TextHitInfo) will return an
* array of two paths representing where carets should be displayed.
* The first path in the array is the strong caret; the second element,
* if non-null, is the weak caret. If the second element is null,
* then there is no weak caret for the given TextHitInfo.
*
*
* Since text can be visually reordered, logically consecutive
* TextHitInfo's may not be visually consecutive. One implication of this
* is that a client cannot tell from inspecting a TextHitInfo whether the
* hit represents the first (or last) caret in the layout. Clients
* can call getVisualOtherHit(); if the visual companion is
* (-1, TRAILING) or (characterCount, LEADING), then the hit is at the
* first (last) caret position in the layout.
*/
private float[]
getCaretInfo(int
caret,
Rectangle2D bounds,
float[]
info) {
float
top1X,
top2X;
float
bottom1X,
bottom2X;
if (
caret == 0 ||
caret ==
characterCount) {
float
pos;
int
logIndex;
if (
caret ==
characterCount) {
logIndex =
textLine.
visualToLogical(
characterCount-1);
pos =
textLine.
getCharLinePosition(
logIndex)
+
textLine.
getCharAdvance(
logIndex);
}
else {
logIndex =
textLine.
visualToLogical(
caret);
pos =
textLine.
getCharLinePosition(
logIndex);
}
float
angle =
textLine.
getCharAngle(
logIndex);
float
shift =
textLine.
getCharShift(
logIndex);
pos +=
angle *
shift;
top1X =
top2X =
pos +
angle*
textLine.
getCharAscent(
logIndex);
bottom1X =
bottom2X =
pos -
angle*
textLine.
getCharDescent(
logIndex);
}
else {
{
int
logIndex =
textLine.
visualToLogical(
caret-1);
float
angle1 =
textLine.
getCharAngle(
logIndex);
float
pos1 =
textLine.
getCharLinePosition(
logIndex)
+
textLine.
getCharAdvance(
logIndex);
if (
angle1 != 0) {
pos1 +=
angle1 *
textLine.
getCharShift(
logIndex);
top1X =
pos1 +
angle1*
textLine.
getCharAscent(
logIndex);
bottom1X =
pos1 -
angle1*
textLine.
getCharDescent(
logIndex);
}
else {
top1X =
bottom1X =
pos1;
}
}
{
int
logIndex =
textLine.
visualToLogical(
caret);
float
angle2 =
textLine.
getCharAngle(
logIndex);
float
pos2 =
textLine.
getCharLinePosition(
logIndex);
if (
angle2 != 0) {
pos2 +=
angle2*
textLine.
getCharShift(
logIndex);
top2X =
pos2 +
angle2*
textLine.
getCharAscent(
logIndex);
bottom2X =
pos2 -
angle2*
textLine.
getCharDescent(
logIndex);
}
else {
top2X =
bottom2X =
pos2;
}
}
}
float
topX = (
top1X +
top2X) / 2;
float
bottomX = (
bottom1X +
bottom2X) / 2;
if (
info == null) {
info = new float[2];
}
if (
isVerticalLine) {
info[1] = (float) ((
topX -
bottomX) /
bounds.
getWidth());
info[0] = (float) (
topX + (
info[1]*
bounds.
getX()));
}
else {
info[1] = (float) ((
topX -
bottomX) /
bounds.
getHeight());
info[0] = (float) (
bottomX + (
info[1]*
bounds.
getMaxY()));
}
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)
* @see Font#getItalicAngle
*/
public float[]
getCaretInfo(
TextHitInfo hit,
Rectangle2D bounds) {
ensureCache();
checkTextHit(
hit);
return
getCaretInfoTestInternal(
hit,
bounds);
}
// this version provides extra info in the float array
// the first two values are as above
// the next four values are the endpoints of the caret, as computed
// using the hit character's offset (baseline + ssoffset) and
// natural ascent and descent.
// these values are trimmed to the bounds where required to fit,
// but otherwise independent of it.
private float[]
getCaretInfoTestInternal(
TextHitInfo hit,
Rectangle2D bounds) {
ensureCache();
checkTextHit(
hit);
float[]
info = new float[6];
// get old data first
getCaretInfo(
hitToCaret(
hit),
bounds,
info);
// then add our new data
double
iangle,
ixbase,
p1x,
p1y,
p2x,
p2y;
int
charix =
hit.
getCharIndex();
boolean
lead =
hit.
isLeadingEdge();
boolean
ltr =
textLine.
isDirectionLTR();
boolean
horiz = !
isVertical();
if (
charix == -1 ||
charix ==
characterCount) {
// !!! note: want non-shifted, baseline ascent and descent here!
// TextLine should return appropriate line metrics object for these values
TextLineMetrics m =
textLine.
getMetrics();
boolean
low =
ltr == (
charix == -1);
iangle = 0;
if (
horiz) {
p1x =
p2x =
low ? 0 :
m.
advance;
p1y = -
m.
ascent;
p2y =
m.
descent;
} else {
p1y =
p2y =
low ? 0 :
m.
advance;
p1x =
m.
descent;
p2x =
m.
ascent;
}
} else {
CoreMetrics thiscm =
textLine.
getCoreMetricsAt(
charix);
iangle =
thiscm.
italicAngle;
ixbase =
textLine.
getCharLinePosition(
charix,
lead);
if (
thiscm.
baselineIndex < 0) {
// this is a graphic, no italics, use entire line height for caret
TextLineMetrics m =
textLine.
getMetrics();
if (
horiz) {
p1x =
p2x =
ixbase;
if (
thiscm.
baselineIndex ==
GraphicAttribute.
TOP_ALIGNMENT) {
p1y = -
m.
ascent;
p2y =
p1y +
thiscm.
height;
} else {
p2y =
m.
descent;
p1y =
p2y -
thiscm.
height;
}
} else {
p1y =
p2y =
ixbase;
p1x =
m.
descent;
p2x =
m.
ascent;
// !!! top/bottom adjustment not implemented for vertical
}
} else {
float
bo =
baselineOffsets[
thiscm.
baselineIndex];
if (
horiz) {
ixbase +=
iangle *
thiscm.
ssOffset;
p1x =
ixbase +
iangle *
thiscm.
ascent;
p2x =
ixbase -
iangle *
thiscm.
descent;
p1y =
bo -
thiscm.
ascent;
p2y =
bo +
thiscm.
descent;
} else {
ixbase -=
iangle *
thiscm.
ssOffset;
p1y =
ixbase +
iangle *
thiscm.
ascent;
p2y =
ixbase -
iangle *
thiscm.
descent;
p1x =
bo +
thiscm.
ascent;
p2x =
bo +
thiscm.
descent;
}
}
}
info[2] = (float)
p1x;
info[3] = (float)
p1y;
info[4] = (float)
p2x;
info[5] = (float)
p2y;
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();
if (
hitIndex < 0) {
return
textLine.
isDirectionLTR() ? 0 :
characterCount;
} else if (
hitIndex >=
characterCount) {
return
textLine.
isDirectionLTR() ?
characterCount : 0;
}
int
visIndex =
textLine.
logicalToVisual(
hitIndex);
if (
hit.
isLeadingEdge() !=
textLine.
isCharLTR(
hitIndex)) {
++
visIndex;
}
return
visIndex;
}
/**
* Given a caret index, return a hit whose caret is at the index.
* The hit is NOT guaranteed to be strong!!!
*
* @param caret a caret index.
* @return a hit on this layout whose strong caret is at the requested
* index.
*/
private
TextHitInfo caretToHit(int
caret) {
if (
caret == 0 ||
caret ==
characterCount) {
if ((
caret ==
characterCount) ==
textLine.
isDirectionLTR()) {
return
TextHitInfo.
leading(
characterCount);
}
else {
return
TextHitInfo.
trailing(-1);
}
}
else {
int
charIndex =
textLine.
visualToLogical(
caret);
boolean
leading =
textLine.
isCharLTR(
charIndex);
return
leading?
TextHitInfo.
leading(
charIndex)
:
TextHitInfo.
trailing(
charIndex);
}
}
private boolean
caretIsValid(int
caret) {
if (
caret ==
characterCount ||
caret == 0) {
return true;
}
int
offset =
textLine.
visualToLogical(
caret);
if (!
textLine.
isCharLTR(
offset)) {
offset =
textLine.
visualToLogical(
caret-1);
if (
textLine.
isCharLTR(
offset)) {
return true;
}
}
// At this point, the leading edge of the character
// at offset is at the given caret.
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);
int
caret =
hitToCaret(
hit);
if (
caret ==
characterCount) {
return null;
}
do {
++
caret;
} while (!
caretIsValid(
caret));
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()");
}
if (
policy == null) {
throw new
IllegalArgumentException("Null CaretPolicy passed to TextLayout.getNextRightHit()");
}
TextHitInfo hit1 =
TextHitInfo.
afterOffset(
offset);
TextHitInfo hit2 =
hit1.
getOtherHit();
TextHitInfo nextHit =
getNextRightHit(
policy.
getStrongCaret(
hit1,
hit2, this));
if (
nextHit != null) {
TextHitInfo otherHit =
getVisualOtherHit(
nextHit);
return
policy.
getStrongCaret(
otherHit,
nextHit, this);
}
else {
return null;
}
}
/**
* 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);
int
caret =
hitToCaret(
hit);
if (
caret == 0) {
return null;
}
do {
--
caret;
} while(!
caretIsValid(
caret));
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()");
}
if (
offset < 0 ||
offset >
characterCount) {
throw new
IllegalArgumentException("Offset out of bounds in TextLayout.getNextLeftHit()");
}
TextHitInfo hit1 =
TextHitInfo.
afterOffset(
offset);
TextHitInfo hit2 =
hit1.
getOtherHit();
TextHitInfo nextHit =
getNextLeftHit(
policy.
getStrongCaret(
hit1,
hit2, this));
if (
nextHit != null) {
TextHitInfo otherHit =
getVisualOtherHit(
nextHit);
return
policy.
getStrongCaret(
otherHit,
nextHit, this);
}
else {
return null;
}
}
/**
* 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);
}
/**
* Returns the hit on the opposite side of the specified hit's caret.
* @param hit the specified hit
* @return a hit that is on the opposite side of the specified hit's
* caret.
*/
public
TextHitInfo getVisualOtherHit(
TextHitInfo hit) {
ensureCache();
checkTextHit(
hit);
int
hitCharIndex =
hit.
getCharIndex();
int
charIndex;
boolean
leading;
if (
hitCharIndex == -1 ||
hitCharIndex ==
characterCount) {
int
visIndex;
if (
textLine.
isDirectionLTR() == (
hitCharIndex == -1)) {
visIndex = 0;
}
else {
visIndex =
characterCount-1;
}
charIndex =
textLine.
visualToLogical(
visIndex);
if (
textLine.
isDirectionLTR() == (
hitCharIndex == -1)) {
// at left end
leading =
textLine.
isCharLTR(
charIndex);
}
else {
// at right end
leading = !
textLine.
isCharLTR(
charIndex);
}
}
else {
int
visIndex =
textLine.
logicalToVisual(
hitCharIndex);
boolean
movedToRight;
if (
textLine.
isCharLTR(
hitCharIndex) ==
hit.
isLeadingEdge()) {
--
visIndex;
movedToRight = false;
}
else {
++
visIndex;
movedToRight = true;
}
if (
visIndex > -1 &&
visIndex <
characterCount) {
charIndex =
textLine.
visualToLogical(
visIndex);
leading =
movedToRight ==
textLine.
isCharLTR(
charIndex);
}
else {
charIndex =
(
movedToRight ==
textLine.
isDirectionLTR())?
characterCount : -1;
leading =
charIndex ==
characterCount;
}
}
return
leading?
TextHitInfo.
leading(
charIndex) :
TextHitInfo.
trailing(
charIndex);
}
private double[]
getCaretPath(
TextHitInfo hit,
Rectangle2D bounds) {
float[]
info =
getCaretInfo(
hit,
bounds);
return new double[] {
info[2],
info[3],
info[4],
info[5] };
}
/**
* Return an array of four floats corresponding the endpoints of the caret
* x0, y0, x1, y1.
*
* This creates a line along the slope of the caret intersecting the
* baseline at the caret
* position, and extending from ascent above the baseline to descent below
* it.
*/
private double[]
getCaretPath(int
caret,
Rectangle2D bounds,
boolean
clipToBounds) {
float[]
info =
getCaretInfo(
caret,
bounds, null);
double
pos =
info[0];
double
slope =
info[1];
double
x0,
y0,
x1,
y1;
double
x2 = -3141.59,
y2 = -2.7; // values are there to make compiler happy
double
left =
bounds.
getX();
double
right =
left +
bounds.
getWidth();
double
top =
bounds.
getY();
double
bottom =
top +
bounds.
getHeight();
boolean
threePoints = false;
if (
isVerticalLine) {
if (
slope >= 0) {
x0 =
left;
x1 =
right;
}
else {
x1 =
left;
x0 =
right;
}
y0 =
pos +
x0 *
slope;
y1 =
pos +
x1 *
slope;
// y0 <= y1, always
if (
clipToBounds) {
if (
y0 <
top) {
if (
slope <= 0 ||
y1 <=
top) {
y0 =
y1 =
top;
}
else {
threePoints = true;
y0 =
top;
y2 =
top;
x2 =
x1 + (
top-
y1)/
slope;
if (
y1 >
bottom) {
y1 =
bottom;
}
}
}
else if (
y1 >
bottom) {
if (
slope >= 0 ||
y0 >=
bottom) {
y0 =
y1 =
bottom;
}
else {
threePoints = true;
y1 =
bottom;
y2 =
bottom;
x2 =
x0 + (
bottom-
x1)/
slope;
}
}
}
}
else {
if (
slope >= 0) {
y0 =
bottom;
y1 =
top;
}
else {
y1 =
bottom;
y0 =
top;
}
x0 =
pos -
y0 *
slope;
x1 =
pos -
y1 *
slope;
// x0 <= x1, always
if (
clipToBounds) {
if (
x0 <
left) {
if (
slope <= 0 ||
x1 <=
left) {
x0 =
x1 =
left;
}
else {
threePoints = true;
x0 =
left;
x2 =
left;
y2 =
y1 - (
left-
x1)/
slope;
if (
x1 >
right) {
x1 =
right;
}
}
}
else if (
x1 >
right) {
if (
slope >= 0 ||
x0 >=
right) {
x0 =
x1 =
right;
}
else {
threePoints = true;
x1 =
right;
x2 =
right;
y2 =
y0 - (
right-
x0)/
slope;
}
}
}
}
return
threePoints?
new double[] {
x0,
y0,
x2,
y2,
x1,
y1 } :
new double[] {
x0,
y0,
x1,
y1 };
}
private static
GeneralPath pathToShape(double[]
path, boolean
close,
LayoutPathImpl lp) {
GeneralPath result = new
GeneralPath(
GeneralPath.
WIND_EVEN_ODD,
path.length);
result.
moveTo((float)
path[0], (float)
path[1]);
for (int
i = 2;
i <
path.length;
i += 2) {
result.
lineTo((float)
path[
i], (float)
path[
i+1]);
}
if (
close) {
result.
closePath();
}
if (
lp != null) {
result = (
GeneralPath)
lp.
mapShape(
result);
}
return
result;
}
/**
* 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);
if (
bounds == null) {
throw new
IllegalArgumentException("Null Rectangle2D passed to TextLayout.getCaret()");
}
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());
}
/**
* Return the "stronger" of the TextHitInfos. The TextHitInfos
* should be logical or visual counterparts. They are not
* checked for validity.
*/
private final
TextHitInfo getStrongHit(
TextHitInfo hit1,
TextHitInfo hit2) {
// right now we're using the following rule for strong hits:
// A hit on a character with a lower level
// is stronger than one on a character with a higher level.
// If this rule ties, the hit on the leading edge of a character wins.
// If THIS rule ties, hit1 wins. Both rules shouldn't tie, unless the
// infos aren't counterparts of some sort.
byte
hit1Level =
getCharacterLevel(
hit1.
getCharIndex());
byte
hit2Level =
getCharacterLevel(
hit2.
getCharIndex());
if (
hit1Level ==
hit2Level) {
if (
hit2.
isLeadingEdge() && !
hit1.
isLeadingEdge()) {
return
hit2;
}
else {
return
hit1;
}
}
else {
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) {
// hmm, allow indices at endpoints? For now, yes.
if (
index < -1 ||
index >
characterCount) {
throw new
IllegalArgumentException("Index is out of range in getCharacterLevel.");
}
ensureCache();
if (
index == -1 ||
index ==
characterCount) {
return (byte) (
textLine.
isDirectionLTR()? 0 : 1);
}
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();
if (
offset < 0 ||
offset >
characterCount) {
throw new
IllegalArgumentException("Offset out of bounds in TextLayout.getCaretShapes()");
}
if (
bounds == null) {
throw new
IllegalArgumentException("Null Rectangle2D passed to TextLayout.getCaretShapes()");
}
if (
policy == null) {
throw new
IllegalArgumentException("Null CaretPolicy passed to TextLayout.getCaretShapes()");
}
Shape[]
result = new
Shape[2];
TextHitInfo hit =
TextHitInfo.
afterOffset(
offset);
int
hitCaret =
hitToCaret(
hit);
LayoutPathImpl lp =
textLine.
getLayoutPath();
Shape hitShape =
pathToShape(
getCaretPath(
hit,
bounds), false,
lp);
TextHitInfo otherHit =
hit.
getOtherHit();
int
otherCaret =
hitToCaret(
otherHit);
if (
hitCaret ==
otherCaret) {
result[0] =
hitShape;
}
else { // more than one caret
Shape otherShape =
pathToShape(
getCaretPath(
otherHit,
bounds), false,
lp);
TextHitInfo strongHit =
policy.
getStrongCaret(
hit,
otherHit, this);
boolean
hitIsStrong =
strongHit.
equals(
hit);
if (
hitIsStrong) {// then other is weak
result[0] =
hitShape;
result[1] =
otherShape;
}
else {
result[0] =
otherShape;
result[1] =
hitShape;
}
}
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);
}
// A utility to return a path enclosing the given path
// Path0 must be left or top of path1
// {jbr} no assumptions about size of path0, path1 anymore.
private
GeneralPath boundingShape(double[]
path0, double[]
path1) {
// Really, we want the path to be a convex hull around all of the
// points in path0 and path1. But we can get by with less than
// that. We do need to prevent the two segments which
// join path0 to path1 from crossing each other. So, if we
// traverse path0 from top to bottom, we'll traverse path1 from
// bottom to top (and vice versa).
GeneralPath result =
pathToShape(
path0, false, null);
boolean
sameDirection;
if (
isVerticalLine) {
sameDirection = (
path0[1] >
path0[
path0.length-1]) ==
(
path1[1] >
path1[
path1.length-1]);
}
else {
sameDirection = (
path0[0] >
path0[
path0.length-2]) ==
(
path1[0] >
path1[
path1.length-2]);
}
int
start;
int
limit;
int
increment;
if (
sameDirection) {
start =
path1.length-2;
limit = -2;
increment = -2;
}
else {
start = 0;
limit =
path1.length;
increment = 2;
}
for (int
i =
start;
i !=
limit;
i +=
increment) {
result.
lineTo((float)
path1[
i], (float)
path1[
i+1]);
}
result.
closePath();
return
result;
}
// A utility to convert a pair of carets into a bounding path
// {jbr} Shape is never outside of bounds.
private
GeneralPath caretBoundingShape(int
caret0,
int
caret1,
Rectangle2D bounds) {
if (
caret0 >
caret1) {
int
temp =
caret0;
caret0 =
caret1;
caret1 =
temp;
}
return
boundingShape(
getCaretPath(
caret0,
bounds, true),
getCaretPath(
caret1,
bounds, true));
}
/*
* A utility to return the path bounding the area to the left (top) of the
* layout.
* Shape is never outside of bounds.
*/
private
GeneralPath leftShape(
Rectangle2D bounds) {
double[]
path0;
if (
isVerticalLine) {
path0 = new double[] {
bounds.
getX(),
bounds.
getY(),
bounds.
getX() +
bounds.
getWidth(),
bounds.
getY() };
} else {
path0 = new double[] {
bounds.
getX(),
bounds.
getY() +
bounds.
getHeight(),
bounds.
getX(),
bounds.
getY() };
}
double[]
path1 =
getCaretPath(0,
bounds, true);
return
boundingShape(
path0,
path1);
}
/*
* A utility to return the path bounding the area to the right (bottom) of
* the layout.
*/
private
GeneralPath rightShape(
Rectangle2D bounds) {
double[]
path1;
if (
isVerticalLine) {
path1 = new double[] {
bounds.
getX(),
bounds.
getY() +
bounds.
getHeight(),
bounds.
getX() +
bounds.
getWidth(),
bounds.
getY() +
bounds.
getHeight()
};
} else {
path1 = new double[] {
bounds.
getX() +
bounds.
getWidth(),
bounds.
getY() +
bounds.
getHeight(),
bounds.
getX() +
bounds.
getWidth(),
bounds.
getY()
};
}
double[]
path0 =
getCaretPath(
characterCount,
bounds, true);
return
boundingShape(
path0,
path1);
}
/**
* 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,
TextHitInfo secondEndpoint) {
ensureCache();
checkTextHit(
firstEndpoint);
checkTextHit(
secondEndpoint);
// !!! probably want to optimize for all LTR text
boolean[]
included = new boolean[
characterCount];
int
startIndex =
hitToCaret(
firstEndpoint);
int
limitIndex =
hitToCaret(
secondEndpoint);
if (
startIndex >
limitIndex) {
int
t =
startIndex;
startIndex =
limitIndex;
limitIndex =
t;
}
/*
* now we have the visual indexes of the glyphs at the start and limit
* of the selection range walk through runs marking characters that
* were included in the visual range there is probably a more efficient
* way to do this, but this ought to work, so hey
*/
if (
startIndex <
limitIndex) {
int
visIndex =
startIndex;
while (
visIndex <
limitIndex) {
included[
textLine.
visualToLogical(
visIndex)] = true;
++
visIndex;
}
}
/*
* count how many runs we have, ought to be one or two, but perhaps
* things are especially weird
*/
int
count = 0;
boolean
inrun = false;
for (int
i = 0;
i <
characterCount;
i++) {
if (
included[
i] !=
inrun) {
inrun = !
inrun;
if (
inrun) {
count++;
}
}
}
int[]
ranges = new int[
count * 2];
count = 0;
inrun = false;
for (int
i = 0;
i <
characterCount;
i++) {
if (
included[
i] !=
inrun) {
ranges[
count++] =
i;
inrun = !
inrun;
}
}
if (
inrun) {
ranges[
count++] =
characterCount;
}
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:
* <br><pre>
* d<u><b>efCBA </b></u>
* </pre>
* The logical selection ranges are 0-3, 4-6 (ABC, ef) because the
* visually contiguous text is logically discontiguous. Also note that
* since the rightmost position on the layout (to the right of 'A') is
* 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,
TextHitInfo secondEndpoint,
Rectangle2D bounds)
{
ensureCache();
checkTextHit(
firstEndpoint);
checkTextHit(
secondEndpoint);
if(
bounds == null) {
throw new
IllegalArgumentException("Null Rectangle2D passed to TextLayout.getVisualHighlightShape()");
}
GeneralPath result = new
GeneralPath(
GeneralPath.
WIND_EVEN_ODD);
int
firstCaret =
hitToCaret(
firstEndpoint);
int
secondCaret =
hitToCaret(
secondEndpoint);
result.
append(
caretBoundingShape(
firstCaret,
secondCaret,
bounds),
false);
if (
firstCaret == 0 ||
secondCaret == 0) {
GeneralPath ls =
leftShape(
bounds);
if (!
ls.
getBounds().
isEmpty())
result.
append(
ls, false);
}
if (
firstCaret ==
characterCount ||
secondCaret ==
characterCount) {
GeneralPath rs =
rightShape(
bounds);
if (!
rs.
getBounds().
isEmpty()) {
result.
append(
rs, false);
}
}
LayoutPathImpl lp =
textLine.
getLayoutPath();
if (
lp != null) {
result = (
GeneralPath)
lp.
mapShape(
result); // dlf cast safe?
}
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,
* with a logical selection from 0 to 4 ('ABCd'). The text appears as
* follows, with bold standing in for the selection, and underlining for
* the extension:
* <br><pre>
* <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
* coordinates.
* @see #getVisualHighlightShape(TextHitInfo, TextHitInfo, Rectangle2D)
*/
public
Shape getLogicalHighlightShape(int
firstEndpoint,
int
secondEndpoint,
Rectangle2D bounds) {
if (
bounds == null) {
throw new
IllegalArgumentException("Null Rectangle2D passed to TextLayout.getLogicalHighlightShape()");
}
ensureCache();
if (
firstEndpoint >
secondEndpoint) {
int
t =
firstEndpoint;
firstEndpoint =
secondEndpoint;
secondEndpoint =
t;
}
if(
firstEndpoint < 0 ||
secondEndpoint >
characterCount) {
throw new
IllegalArgumentException("Range is invalid in TextLayout.getLogicalHighlightShape()");
}
GeneralPath result = new
GeneralPath(
GeneralPath.
WIND_EVEN_ODD);
int[]
carets = new int[10]; // would this ever not handle all cases?
int
count = 0;
if (
firstEndpoint <
secondEndpoint) {
int
logIndex =
firstEndpoint;
do {
carets[
count++] =
hitToCaret(
TextHitInfo.
leading(
logIndex));
boolean
ltr =
textLine.
isCharLTR(
logIndex);
do {
logIndex++;
} while (
logIndex <
secondEndpoint &&
textLine.
isCharLTR(
logIndex) ==
ltr);
int
hitCh =
logIndex;
carets[
count++] =
hitToCaret(
TextHitInfo.
trailing(
hitCh - 1));
if (
count ==
carets.length) {
int[]
temp = new int[
carets.length + 10];
System.
arraycopy(
carets, 0,
temp, 0,
count);
carets =
temp;
}
} while (
logIndex <
secondEndpoint);
}
else {
count = 2;
carets[0] =
carets[1] =
hitToCaret(
TextHitInfo.
leading(
firstEndpoint));
}
// now create paths for pairs of carets
for (int
i = 0;
i <
count;
i += 2) {
result.
append(
caretBoundingShape(
carets[
i],
carets[
i+1],
bounds),
false);
}
if (
firstEndpoint !=
secondEndpoint) {
if ((
textLine.
isDirectionLTR() &&
firstEndpoint == 0) || (!
textLine.
isDirectionLTR() &&
secondEndpoint ==
characterCount)) {
GeneralPath ls =
leftShape(
bounds);
if (!
ls.
getBounds().
isEmpty()) {
result.
append(
ls, false);
}
}
if ((
textLine.
isDirectionLTR() &&
secondEndpoint ==
characterCount) ||
(!
textLine.
isDirectionLTR() &&
firstEndpoint == 0)) {
GeneralPath rs =
rightShape(
bounds);
if (!
rs.
getBounds().
isEmpty()) {
result.
append(
rs, false);
}
}
}
LayoutPathImpl lp =
textLine.
getLayoutPath();
if (
lp != null) {
result = (
GeneralPath)
lp.
mapShape(
result); // dlf cast safe?
}
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());
}
/**
* Returns the black box bounds of the characters in the specified range.
* 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();
if (
firstEndpoint >
secondEndpoint) {
int
t =
firstEndpoint;
firstEndpoint =
secondEndpoint;
secondEndpoint =
t;
}
if (
firstEndpoint < 0 ||
secondEndpoint >
characterCount) {
throw new
IllegalArgumentException("Invalid range passed to TextLayout.getBlackBoxBounds()");
}
/*
* return an area that consists of the bounding boxes of all the
* characters from firstEndpoint to limit
*/
GeneralPath result = new
GeneralPath(
GeneralPath.
WIND_NON_ZERO);
if (
firstEndpoint <
characterCount) {
for (int
logIndex =
firstEndpoint;
logIndex <
secondEndpoint;
logIndex++) {
Rectangle2D r =
textLine.
getCharBounds(
logIndex);
if (!
r.
isEmpty()) {
result.
append(
r, false);
}
}
}
if (
dx != 0 ||
dy != 0) {
AffineTransform tx =
AffineTransform.
getTranslateInstance(
dx,
dy);
result = (
GeneralPath)
tx.
createTransformedShape(
result);
}
LayoutPathImpl lp =
textLine.
getLayoutPath();
if (
lp != null) {
result = (
GeneralPath)
lp.
mapShape(
result);
}
//return new Highlight(result, false);
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) {
// distanceOffBaseline is negative if you're 'above' baseline
float
lineDistance =
isVerticalLine?
y :
x;
float
distanceOffBaseline =
isVerticalLine? -
x :
y;
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) {
// check boundary conditions
LayoutPathImpl lp =
textLine.
getLayoutPath();
boolean
prev = false;
if (
lp != null) {
Point2D.
Float pt = new
Point2D.
Float(
x,
y);
prev =
lp.
pointToPath(
pt,
pt);
x =
pt.
x;
y =
pt.
y;
}
if (
isVertical()) {
if (
y <
bounds.
getMinY()) {
return
TextHitInfo.
leading(0);
} else if (
y >=
bounds.
getMaxY()) {
return
TextHitInfo.
trailing(
characterCount-1);
}
} else {
if (
x <
bounds.
getMinX()) {
return
isLeftToRight() ?
TextHitInfo.
leading(0) :
TextHitInfo.
trailing(
characterCount-1);
} else if (
x >=
bounds.
getMaxX()) {
return
isLeftToRight() ?
TextHitInfo.
trailing(
characterCount-1) :
TextHitInfo.
leading(0);
}
}
// revised hit test
// the original seems too complex and fails miserably with italic offsets
// the natural tendency is to move towards the character you want to hit
// so we'll just measure distance to the center of each character's visual
// bounds, pick the closest one, then see which side of the character's
// center line (italic) the point is on.
// this tends to make it easier to hit narrow characters, which can be a
// bit odd if you're visually over an adjacent wide character. this makes
// a difference with bidi, so perhaps i need to revisit this yet again.
double
distance =
Double.
MAX_VALUE;
int
index = 0;
int
trail = -1;
CoreMetrics lcm = null;
float
icx = 0,
icy = 0,
ia = 0,
cy = 0,
dya = 0,
ydsq = 0;
for (int
i = 0;
i <
characterCount; ++
i) {
if (!
textLine.
caretAtOffsetIsValid(
i)) {
continue;
}
if (
trail == -1) {
trail =
i;
}
CoreMetrics cm =
textLine.
getCoreMetricsAt(
i);
if (
cm !=
lcm) {
lcm =
cm;
// just work around baseline mess for now
if (
cm.
baselineIndex ==
GraphicAttribute.
TOP_ALIGNMENT) {
cy = -(
textLine.
getMetrics().
ascent -
cm.
ascent) +
cm.
ssOffset;
} else if (
cm.
baselineIndex ==
GraphicAttribute.
BOTTOM_ALIGNMENT) {
cy =
textLine.
getMetrics().
descent -
cm.
descent +
cm.
ssOffset;
} else {
cy =
cm.
effectiveBaselineOffset(
baselineOffsets) +
cm.
ssOffset;
}
float
dy = (
cm.
descent -
cm.
ascent) / 2 -
cy;
dya =
dy *
cm.
italicAngle;
cy +=
dy;
ydsq = (
cy -
y)*(
cy -
y);
}
float
cx =
textLine.
getCharXPosition(
i);
float
ca =
textLine.
getCharAdvance(
i);
float
dx =
ca / 2;
cx +=
dx -
dya;
// proximity in x (along baseline) is two times as important as proximity in y
double
nd =
Math.
sqrt(4*(
cx -
x)*(
cx -
x) +
ydsq);
if (
nd <
distance) {
distance =
nd;
index =
i;
trail = -1;
icx =
cx;
icy =
cy;
ia =
cm.
italicAngle;
}
}
boolean
left =
x <
icx - (
y -
icy) *
ia;
boolean
leading =
textLine.
isCharLTR(
index) ==
left;
if (
trail == -1) {
trail =
characterCount;
}
TextHitInfo result =
leading ?
TextHitInfo.
leading(
index) :
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) {
return false;
}
if (
rhs == this) {
return true;
}
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) {
throw new
IllegalArgumentException("Null Graphics2D passed to TextLayout.draw()");
}
textLine.
draw(
g2,
x -
dx,
y -
dy);
}
/**
* Package-only method for testing ONLY. Please don't abuse.
*/
TextLine getTextLineForTesting() {
return
textLine;
}
/**
*
* Return the index of the first character with a different baseline from the
* character at start, or limit if all characters between start and limit have
* the same baseline.
*/
private static int
sameBaselineUpTo(
Font font, char[]
text,
int
start, int
limit) {
// current implementation doesn't support multiple baselines
return
limit;
/*
byte bl = font.getBaselineFor(text[start++]);
while (start < limit && font.getBaselineFor(text[start]) == bl) {
++start;
}
return start;
*/
}
static byte
getBaselineFromGraphic(
GraphicAttribute graphic) {
byte
alignment = (byte)
graphic.
getAlignment();
if (
alignment ==
GraphicAttribute.
BOTTOM_ALIGNMENT ||
alignment ==
GraphicAttribute.
TOP_ALIGNMENT) {
return (byte)
GraphicAttribute.
ROMAN_BASELINE;
}
else {
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();
if (
lp != null) {
result =
lp.
mapShape(
result);
}
return
result;
}
/**
* Return the LayoutPath, or null if the layout path is the
* default path (x maps to advance, y maps to offset).
* @return the layout path
* @since 1.6
*/
public
LayoutPath getLayoutPath() {
return
textLine.
getLayoutPath();
}
/**
* Convert a hit to a point in standard coordinates. The point is
* on the baseline of the character at the leading or trailing
* edge of the character, as appropriate. If the path is
* broken at the side of the character represented by the hit, the
* point will be adjacent to the character.
* @param hit the hit to check. This must be a valid hit on
* the TextLayout.
* @param point the returned point. The point is in standard
* coordinates.
* @throws IllegalArgumentException if the hit is not valid for the
* TextLayout.
* @throws NullPointerException if hit or point is null.
* @since 1.6
*/
public void
hitToPoint(
TextHitInfo hit,
Point2D point) {
if (
hit == null ||
point == null) {
throw new
NullPointerException((
hit == null ? "hit" : "point") +
" can't be null");
}
ensureCache();
checkTextHit(
hit);
float
adv = 0;
float
off = 0;
int
ix =
hit.
getCharIndex();
boolean
leading =
hit.
isLeadingEdge();
boolean
ltr;
if (
ix == -1 ||
ix ==
textLine.
characterCount()) {
ltr =
textLine.
isDirectionLTR();
adv = (
ltr == (
ix == -1)) ? 0 :
lineMetrics.
advance;
} else {
ltr =
textLine.
isCharLTR(
ix);
adv =
textLine.
getCharLinePosition(
ix,
leading);
off =
textLine.
getCharYPosition(
ix);
}
point.
setLocation(
adv,
off);
LayoutPath lp =
textLine.
getLayoutPath();
if (
lp != null) {
lp.
pathToPoint(
point,
ltr !=
leading,
point);
}
}
}