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;

/*

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;

/*

private Rectangle2D naturalBounds = null;

/*

private Rectangle2D boundsRect = null;

/*

private boolean caretsInLigaturesAreAllowed = false;

/**

public static class CaretPolicy {

/**

public CaretPolicy() {

}

/**

public TextHitInfo getStrongCaret(TextHitInfo hit1,

TextHitInfo hit2,

TextLayout layout) {

// default implementation just calls private method on layout

return layout.getStrongHit(hit1, hit2);

}

}

/**

public static final CaretPolicy DEFAULT_CARET_POLICY = new CaretPolicy();

/**

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);

}

}

/**

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);

}

}

/*

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;

}

/**

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);

}

/**

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;

}

/**

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);

}

}

/*

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);

}

/*

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);

}

/*

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;

}

/**

private Rectangle2D getNaturalBounds() {

ensureCache();

if (naturalBounds == null) {

naturalBounds = textLine.getItalicBounds();

}

return naturalBounds;

}

/**

protected Object clone() {

/*

try {

return super.clone();

}

catch (CloneNotSupportedException e) {

throw new InternalError(e);

}

}

/*

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");

}

}

/**

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;

}

/**

protected void handleJustify(float justificationWidth) {

// never called

}

/**

public byte getBaseline() {

return baseline;

}

/**

public float[] getBaselineOffsets() {

float[] offsets = new float[baselineOffsets.length];

System.arraycopy(baselineOffsets, 0, offsets, 0, offsets.length);

return offsets;

}

/**

public float getAdvance() {

ensureCache();

return lineMetrics.advance;

}

/**

public float getVisibleAdvance() {

ensureCache();

return visibleAdvance;

}

/**

public float getAscent() {

ensureCache();

return lineMetrics.ascent;

}

/**

public float getDescent() {

ensureCache();

return lineMetrics.descent;

}

/**

public float getLeading() {

ensureCache();

return lineMetrics.leading;

}

/**

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;

}

/**