--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/share/classes/java/awt/font/TextLine.java Sat Dec 01 00:00:00 2007 +0000
@@ -0,0 +1,1437 @@
+/*
+ * Copyright 1998-2006 Sun Microsystems, Inc. All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+/*
+ * (C) Copyright IBM Corp. 1998-2003, All Rights Reserved
+ *
+ */
+
+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.geom.AffineTransform;
+import java.awt.geom.GeneralPath;
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+import java.awt.im.InputMethodHighlight;
+import java.awt.image.BufferedImage;
+import java.text.Annotation;
+import java.text.AttributedCharacterIterator;
+import java.text.Bidi;
+import java.text.CharacterIterator;
+import java.util.Hashtable;
+import java.util.Map;
+import sun.font.AttributeValues;
+import sun.font.BidiUtils;
+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.font.LayoutPathImpl.EmptyPath;
+import sun.font.LayoutPathImpl.SegmentPathBuilder;
+import sun.font.TextLabelFactory;
+import sun.font.TextLineComponent;
+import sun.text.CodePointIterator;
+
+import java.awt.geom.Line2D;
+
+final class TextLine {
+
+ static final class TextLineMetrics {
+ public final float ascent;
+ public final float descent;
+ public final float leading;
+ public final float advance;
+
+ public TextLineMetrics(float ascent,
+ float descent,
+ float leading,
+ float advance) {
+ this.ascent = ascent;
+ this.descent = descent;
+ this.leading = leading;
+ this.advance = advance;
+ }
+ }
+
+ private TextLineComponent[] fComponents;
+ private float[] fBaselineOffsets;
+ private int[] fComponentVisualOrder; // if null, ltr
+ private float[] locs; // x,y pairs for components in visual order
+ private char[] fChars;
+ private int fCharsStart;
+ private int fCharsLimit;
+ private int[] fCharVisualOrder; // if null, ltr
+ private int[] fCharLogicalOrder; // if null, ltr
+ private byte[] fCharLevels; // if null, 0
+ private boolean fIsDirectionLTR;
+ private LayoutPathImpl lp;
+ private boolean isSimple;
+ private Rectangle pixelBounds;
+ private FontRenderContext frc;
+
+ private TextLineMetrics fMetrics = null; // built on demand in getMetrics
+
+ public TextLine(FontRenderContext frc,
+ TextLineComponent[] components,
+ float[] baselineOffsets,
+ char[] chars,
+ int charsStart,
+ int charsLimit,
+ int[] charLogicalOrder,
+ byte[] charLevels,
+ boolean isDirectionLTR) {
+
+ int[] componentVisualOrder = computeComponentOrder(components,
+ charLogicalOrder);
+
+ this.frc = frc;
+ fComponents = components;
+ fBaselineOffsets = baselineOffsets;
+ fComponentVisualOrder = componentVisualOrder;
+ fChars = chars;
+ fCharsStart = charsStart;
+ fCharsLimit = charsLimit;
+ fCharLogicalOrder = charLogicalOrder;
+ fCharLevels = charLevels;
+ fIsDirectionLTR = isDirectionLTR;
+ checkCtorArgs();
+
+ init();
+ }
+
+ private void checkCtorArgs() {
+
+ int checkCharCount = 0;
+ for (int i=0; i < fComponents.length; i++) {
+ checkCharCount += fComponents[i].getNumCharacters();
+ }
+
+ if (checkCharCount != this.characterCount()) {
+ throw new IllegalArgumentException("Invalid TextLine! " +
+ "char count is different from " +
+ "sum of char counts of components.");
+ }
+ }
+
+ private void init() {
+
+ // first, we need to check for graphic components on the TOP or BOTTOM baselines. So
+ // we perform the work that used to be in getMetrics here.
+
+ float ascent = 0;
+ float descent = 0;
+ float leading = 0;
+ float advance = 0;
+
+ // ascent + descent must not be less than this value
+ float maxGraphicHeight = 0;
+ float maxGraphicHeightWithLeading = 0;
+
+ // walk through EGA's
+ TextLineComponent tlc;
+ boolean fitTopAndBottomGraphics = false;
+
+ isSimple = true;
+
+ for (int i = 0; i < fComponents.length; i++) {
+ tlc = fComponents[i];
+
+ isSimple &= tlc.isSimple();
+
+ CoreMetrics cm = tlc.getCoreMetrics();
+
+ byte baseline = (byte)cm.baselineIndex;
+
+ if (baseline >= 0) {
+ float baselineOffset = fBaselineOffsets[baseline];
+
+ ascent = Math.max(ascent, -baselineOffset + cm.ascent);
+
+ float gd = baselineOffset + cm.descent;
+ descent = Math.max(descent, gd);
+
+ leading = Math.max(leading, gd + cm.leading);
+ }
+ else {
+ fitTopAndBottomGraphics = true;
+ float graphicHeight = cm.ascent + cm.descent;
+ float graphicHeightWithLeading = graphicHeight + cm.leading;
+ maxGraphicHeight = Math.max(maxGraphicHeight, graphicHeight);
+ maxGraphicHeightWithLeading = Math.max(maxGraphicHeightWithLeading,
+ graphicHeightWithLeading);
+ }
+ }
+
+ if (fitTopAndBottomGraphics) {
+ if (maxGraphicHeight > ascent + descent) {
+ descent = maxGraphicHeight - ascent;
+ }
+ if (maxGraphicHeightWithLeading > ascent + leading) {
+ leading = maxGraphicHeightWithLeading - ascent;
+ }
+ }
+
+ leading -= descent;
+
+ // we now know enough to compute the locs, but we need the final loc
+ // for the advance before we can create the metrics object
+
+ if (fitTopAndBottomGraphics) {
+ // we have top or bottom baselines, so expand the baselines array
+ // full offsets are needed by CoreMetrics.effectiveBaselineOffset
+ fBaselineOffsets = new float[] {
+ fBaselineOffsets[0],
+ fBaselineOffsets[1],
+ fBaselineOffsets[2],
+ descent,
+ -ascent
+ };
+ }
+
+ float x = 0;
+ float y = 0;
+ CoreMetrics pcm = null;
+
+ boolean needPath = false;
+ locs = new float[fComponents.length * 2 + 2];
+
+ for (int i = 0, n = 0; i < fComponents.length; ++i, n += 2) {
+ tlc = fComponents[getComponentLogicalIndex(i)];
+ CoreMetrics cm = tlc.getCoreMetrics();
+
+ if ((pcm != null) &&
+ (pcm.italicAngle != 0 || cm.italicAngle != 0) && // adjust because of italics
+ (pcm.italicAngle != cm.italicAngle ||
+ pcm.baselineIndex != cm.baselineIndex ||
+ pcm.ssOffset != cm.ssOffset)) {
+
+ // 1) compute the area of overlap - min effective ascent and min effective descent
+ // 2) compute the x positions along italic angle of ascent and descent for left and right
+ // 3) compute maximum left - right, adjust right position by this value
+ // this is a crude form of kerning between textcomponents
+
+ // note glyphvectors preposition glyphs based on offset,
+ // so tl doesn't need to adjust glyphvector position
+ // 1)
+ float pb = pcm.effectiveBaselineOffset(fBaselineOffsets);
+ float pa = pb - pcm.ascent;
+ float pd = pb + pcm.descent;
+ // pb += pcm.ssOffset;
+
+ float cb = cm.effectiveBaselineOffset(fBaselineOffsets);
+ float ca = cb - cm.ascent;
+ float cd = cb + cm.descent;
+ // cb += cm.ssOffset;
+
+ float a = Math.max(pa, ca);
+ float d = Math.min(pd, cd);
+
+ // 2)
+ float pax = pcm.italicAngle * (pb - a);
+ float pdx = pcm.italicAngle * (pb - d);
+
+ float cax = cm.italicAngle * (cb - a);
+ float cdx = cm.italicAngle * (cb - d);
+
+ // 3)
+ float dax = pax - cax;
+ float ddx = pdx - cdx;
+ float dx = Math.max(dax, ddx);
+
+ x += dx;
+ y = cb;
+ } else {
+ // no italic adjustment for x, but still need to compute y
+ y = cm.effectiveBaselineOffset(fBaselineOffsets); // + cm.ssOffset;
+ }
+
+ locs[n] = x;
+ locs[n+1] = y;
+
+ x += tlc.getAdvance();
+ pcm = cm;
+
+ needPath |= tlc.getBaselineTransform() != null;
+ }
+
+ // do we want italic padding at the right of the line?
+ if (pcm.italicAngle != 0) {
+ float pb = pcm.effectiveBaselineOffset(fBaselineOffsets);
+ float pa = pb - pcm.ascent;
+ float pd = pb + pcm.descent;
+ pb += pcm.ssOffset;
+
+ float d;
+ if (pcm.italicAngle > 0) {
+ d = pb + pcm.ascent;
+ } else {
+ d = pb - pcm.descent;
+ }
+ d *= pcm.italicAngle;
+
+ x += d;
+ }
+ locs[locs.length - 2] = x;
+ // locs[locs.length - 1] = 0; // final offset is always back on baseline
+
+ // ok, build fMetrics since we have the final advance
+ advance = x;
+ fMetrics = new TextLineMetrics(ascent, descent, leading, advance);
+
+ // build path if we need it
+ if (needPath) {
+ isSimple = false;
+
+ Point2D.Double pt = new Point2D.Double();
+ double tx = 0, ty = 0;
+ SegmentPathBuilder builder = new SegmentPathBuilder();
+ builder.moveTo(locs[0], 0);
+ for (int i = 0, n = 0; i < fComponents.length; ++i, n += 2) {
+ tlc = fComponents[getComponentLogicalIndex(i)];
+ AffineTransform at = tlc.getBaselineTransform();
+ if (at != null && ((at.getType() & at.TYPE_TRANSLATION) != 0)) {
+ double dx = at.getTranslateX();
+ double dy = at.getTranslateY();
+ builder.moveTo(tx += dx, ty += dy);
+ }
+ pt.x = locs[n+2] - locs[n];
+ pt.y = 0;
+ if (at != null) {
+ at.deltaTransform(pt, pt);
+ }
+ builder.lineTo(tx += pt.x, ty += pt.y);
+ }
+ lp = builder.complete();
+
+ if (lp == null) { // empty path
+ tlc = fComponents[getComponentLogicalIndex(0)];
+ AffineTransform at = tlc.getBaselineTransform();
+ if (at != null) {
+ lp = new EmptyPath(at);
+ }
+ }
+ }
+ }
+
+ public Rectangle getPixelBounds(FontRenderContext frc, float x, float y) {
+ Rectangle result = null;
+
+ // if we have a matching frc, set it to null so we don't have to test it
+ // for each component
+ if (frc != null && frc.equals(this.frc)) {
+ frc = null;
+ }
+
+ // only cache integral locations with the default frc, this is a bit strict
+ int ix = (int)Math.floor(x);
+ int iy = (int)Math.floor(y);
+ float rx = x - ix;
+ float ry = y - iy;
+ boolean canCache = frc == null && rx == 0 && ry == 0;
+
+ if (canCache && pixelBounds != null) {
+ result = new Rectangle(pixelBounds);
+ result.x += ix;
+ result.y += iy;
+ return result;
+ }
+
+ // couldn't use cache, or didn't have it, so compute
+
+ if (isSimple) { // all glyphvectors with no decorations, no layout path
+ for (int i = 0, n = 0; i < fComponents.length; i++, n += 2) {
+ TextLineComponent tlc = fComponents[getComponentLogicalIndex(i)];
+ Rectangle pb = tlc.getPixelBounds(frc, locs[n] + rx, locs[n+1] + ry);
+ if (!pb.isEmpty()) {
+ if (result == null) {
+ result = pb;
+ } else {
+ result.add(pb);
+ }
+ }
+ }
+ if (result == null) {
+ result = new Rectangle(0, 0, 0, 0);
+ }
+ } else { // draw and test
+ final int MARGIN = 3;
+ Rectangle2D r2d = getVisualBounds();
+ if (lp != null) {
+ r2d = lp.mapShape(r2d).getBounds();
+ }
+ Rectangle bounds = r2d.getBounds();
+ BufferedImage im = new BufferedImage(bounds.width + MARGIN * 2,
+ bounds.height + MARGIN * 2,
+ BufferedImage.TYPE_INT_ARGB);
+
+ Graphics2D g2d = im.createGraphics();
+ g2d.setColor(Color.WHITE);
+ g2d.fillRect(0, 0, im.getWidth(), im.getHeight());
+
+ g2d.setColor(Color.BLACK);
+ draw(g2d, rx + MARGIN - bounds.x, ry + MARGIN - bounds.y);
+
+ result = computePixelBounds(im);
+ result.x -= MARGIN - bounds.x;
+ result.y -= MARGIN - bounds.y;
+ }
+
+ if (canCache) {
+ pixelBounds = new Rectangle(result);
+ }
+
+ result.x += ix;
+ result.y += iy;
+ return result;
+ }
+
+ static Rectangle computePixelBounds(BufferedImage im) {
+ int w = im.getWidth();
+ int h = im.getHeight();
+
+ int l = -1, t = -1, r = w, b = h;
+
+ {
+ // get top
+ int[] buf = new int[w];
+ loop: while (++t < h) {
+ im.getRGB(0, t, buf.length, 1, buf, 0, w); // w ignored
+ for (int i = 0; i < buf.length; i++) {
+ if (buf[i] != -1) {
+ break loop;
+ }
+ }
+ }
+ }
+
+ // get bottom
+ {
+ int[] buf = new int[w];
+ loop: while (--b > t) {
+ im.getRGB(0, b, buf.length, 1, buf, 0, w); // w ignored
+ for (int i = 0; i < buf.length; ++i) {
+ if (buf[i] != -1) {
+ break loop;
+ }
+ }
+ }
+ ++b;
+ }
+
+ // get left
+ {
+ loop: while (++l < r) {
+ for (int i = t; i < b; ++i) {
+ int v = im.getRGB(l, i);
+ if (v != -1) {
+ break loop;
+ }
+ }
+ }
+ }
+
+ // get right
+ {
+ loop: while (--r > l) {
+ for (int i = t; i < b; ++i) {
+ int v = im.getRGB(r, i);
+ if (v != -1) {
+ break loop;
+ }
+ }
+ }
+ ++r;
+ }
+
+ return new Rectangle(l, t, r-l, b-t);
+ }
+
+ private abstract static class Function {
+
+ abstract float computeFunction(TextLine line,
+ int componentIndex,
+ int indexInArray);
+ }
+
+ private static Function fgPosAdvF = new Function() {
+ float computeFunction(TextLine line,
+ int componentIndex,
+ int indexInArray) {
+
+ TextLineComponent tlc = line.fComponents[componentIndex];
+ int vi = line.getComponentVisualIndex(componentIndex);
+ return line.locs[vi * 2] + tlc.getCharX(indexInArray) + tlc.getCharAdvance(indexInArray);
+ }
+ };
+
+ private static Function fgAdvanceF = new Function() {
+
+ float computeFunction(TextLine line,
+ int componentIndex,
+ int indexInArray) {
+
+ TextLineComponent tlc = line.fComponents[componentIndex];
+ return tlc.getCharAdvance(indexInArray);
+ }
+ };
+
+ private static Function fgXPositionF = new Function() {
+
+ float computeFunction(TextLine line,
+ int componentIndex,
+ int indexInArray) {
+
+ int vi = line.getComponentVisualIndex(componentIndex);
+ TextLineComponent tlc = line.fComponents[componentIndex];
+ return line.locs[vi * 2] + tlc.getCharX(indexInArray);
+ }
+ };
+
+ private static Function fgYPositionF = new Function() {
+
+ float computeFunction(TextLine line,
+ int componentIndex,
+ int indexInArray) {
+
+ TextLineComponent tlc = line.fComponents[componentIndex];
+ float charPos = tlc.getCharY(indexInArray);
+
+ // charPos is relative to the component - adjust for
+ // baseline
+
+ return charPos + line.getComponentShift(componentIndex);
+ }
+ };
+
+ public int characterCount() {
+
+ return fCharsLimit - fCharsStart;
+ }
+
+ public boolean isDirectionLTR() {
+
+ return fIsDirectionLTR;
+ }
+
+ public TextLineMetrics getMetrics() {
+ return fMetrics;
+ }
+
+ public int visualToLogical(int visualIndex) {
+
+ if (fCharLogicalOrder == null) {
+ return visualIndex;
+ }
+
+ if (fCharVisualOrder == null) {
+ fCharVisualOrder = BidiUtils.createInverseMap(fCharLogicalOrder);
+ }
+
+ return fCharVisualOrder[visualIndex];
+ }
+
+ public int logicalToVisual(int logicalIndex) {
+
+ return (fCharLogicalOrder == null)?
+ logicalIndex : fCharLogicalOrder[logicalIndex];
+ }
+
+ public byte getCharLevel(int logicalIndex) {
+
+ return fCharLevels==null? 0 : fCharLevels[logicalIndex];
+ }
+
+ public boolean isCharLTR(int logicalIndex) {
+
+ return (getCharLevel(logicalIndex) & 0x1) == 0;
+ }
+
+ public int getCharType(int logicalIndex) {
+
+ return Character.getType(fChars[logicalIndex + fCharsStart]);
+ }
+
+ public boolean isCharSpace(int logicalIndex) {
+
+ return Character.isSpaceChar(fChars[logicalIndex + fCharsStart]);
+ }
+
+ public boolean isCharWhitespace(int logicalIndex) {
+
+ return Character.isWhitespace(fChars[logicalIndex + fCharsStart]);
+ }
+
+ public float getCharAngle(int logicalIndex) {
+
+ return getCoreMetricsAt(logicalIndex).italicAngle;
+ }
+
+ public CoreMetrics getCoreMetricsAt(int logicalIndex) {
+
+ if (logicalIndex < 0) {
+ throw new IllegalArgumentException("Negative logicalIndex.");
+ }
+
+ if (logicalIndex > fCharsLimit - fCharsStart) {
+ throw new IllegalArgumentException("logicalIndex too large.");
+ }
+
+ int currentTlc = 0;
+ int tlcStart = 0;
+ int tlcLimit = 0;
+
+ do {
+ tlcLimit += fComponents[currentTlc].getNumCharacters();
+ if (tlcLimit > logicalIndex) {
+ break;
+ }
+ ++currentTlc;
+ tlcStart = tlcLimit;
+ } while(currentTlc < fComponents.length);
+
+ return fComponents[currentTlc].getCoreMetrics();
+ }
+
+ public float getCharAscent(int logicalIndex) {
+
+ return getCoreMetricsAt(logicalIndex).ascent;
+ }
+
+ public float getCharDescent(int logicalIndex) {
+
+ return getCoreMetricsAt(logicalIndex).descent;
+ }
+
+ public float getCharShift(int logicalIndex) {
+
+ return getCoreMetricsAt(logicalIndex).ssOffset;
+ }
+
+ private float applyFunctionAtIndex(int logicalIndex, Function f) {
+
+ if (logicalIndex < 0) {
+ throw new IllegalArgumentException("Negative logicalIndex.");
+ }
+
+ int tlcStart = 0;
+
+ for(int i=0; i < fComponents.length; i++) {
+
+ int tlcLimit = tlcStart + fComponents[i].getNumCharacters();
+ if (tlcLimit > logicalIndex) {
+ return f.computeFunction(this, i, logicalIndex - tlcStart);
+ }
+ else {
+ tlcStart = tlcLimit;
+ }
+ }
+
+ throw new IllegalArgumentException("logicalIndex too large.");
+ }
+
+ public float getCharAdvance(int logicalIndex) {
+
+ return applyFunctionAtIndex(logicalIndex, fgAdvanceF);
+ }
+
+ public float getCharXPosition(int logicalIndex) {
+
+ return applyFunctionAtIndex(logicalIndex, fgXPositionF);
+ }
+
+ public float getCharYPosition(int logicalIndex) {
+
+ return applyFunctionAtIndex(logicalIndex, fgYPositionF);
+ }
+
+ public float getCharLinePosition(int logicalIndex) {
+
+ return getCharXPosition(logicalIndex);
+ }
+
+ public float getCharLinePosition(int logicalIndex, boolean leading) {
+ Function f = isCharLTR(logicalIndex) == leading ? fgXPositionF : fgPosAdvF;
+ return applyFunctionAtIndex(logicalIndex, f);
+ }
+
+ public boolean caretAtOffsetIsValid(int offset) {
+
+ if (offset < 0) {
+ throw new IllegalArgumentException("Negative offset.");
+ }
+
+ int tlcStart = 0;
+
+ for(int i=0; i < fComponents.length; i++) {
+
+ int tlcLimit = tlcStart + fComponents[i].getNumCharacters();
+ if (tlcLimit > offset) {
+ return fComponents[i].caretAtOffsetIsValid(offset-tlcStart);
+ }
+ else {
+ tlcStart = tlcLimit;
+ }
+ }
+
+ throw new IllegalArgumentException("logicalIndex too large.");
+ }
+
+ /**
+ * map a component visual index to the logical index.
+ */
+ private int getComponentLogicalIndex(int vi) {
+ if (fComponentVisualOrder == null) {
+ return vi;
+ }
+ return fComponentVisualOrder[vi];
+ }
+
+ /**
+ * map a component logical index to the visual index.
+ */
+ private int getComponentVisualIndex(int li) {
+ if (fComponentVisualOrder == null) {
+ return li;
+ }
+ for (int i = 0; i < fComponentVisualOrder.length; ++i) {
+ if (fComponentVisualOrder[i] == li) {
+ return i;
+ }
+ }
+ throw new IndexOutOfBoundsException("bad component index: " + li);
+ }
+
+ public Rectangle2D getCharBounds(int logicalIndex) {
+
+ if (logicalIndex < 0) {
+ throw new IllegalArgumentException("Negative logicalIndex.");
+ }
+
+ int tlcStart = 0;
+
+ for (int i=0; i < fComponents.length; i++) {
+
+ int tlcLimit = tlcStart + fComponents[i].getNumCharacters();
+ if (tlcLimit > logicalIndex) {
+
+ TextLineComponent tlc = fComponents[i];
+ int indexInTlc = logicalIndex - tlcStart;
+ Rectangle2D chBounds = tlc.getCharVisualBounds(indexInTlc);
+
+ int vi = getComponentVisualIndex(i);
+ chBounds.setRect(chBounds.getX() + locs[vi * 2],
+ chBounds.getY() + locs[vi * 2 + 1],
+ chBounds.getWidth(),
+ chBounds.getHeight());
+ return chBounds;
+ }
+ else {
+ tlcStart = tlcLimit;
+ }
+ }
+
+ throw new IllegalArgumentException("logicalIndex too large.");
+ }
+
+ private float getComponentShift(int index) {
+ CoreMetrics cm = fComponents[index].getCoreMetrics();
+ return cm.effectiveBaselineOffset(fBaselineOffsets);
+ }
+
+ public void draw(Graphics2D g2, float x, float y) {
+ if (lp == null) {
+ for (int i = 0, n = 0; i < fComponents.length; i++, n += 2) {
+ TextLineComponent tlc = fComponents[getComponentLogicalIndex(i)];
+ tlc.draw(g2, locs[n] + x, locs[n+1] + y);
+ }
+ } else {
+ AffineTransform oldTx = g2.getTransform();
+ Point2D.Float pt = new Point2D.Float();
+ for (int i = 0, n = 0; i < fComponents.length; i++, n += 2) {
+ TextLineComponent tlc = fComponents[getComponentLogicalIndex(i)];
+ lp.pathToPoint(locs[n], locs[n+1], false, pt);
+ pt.x += x;
+ pt.y += y;
+ AffineTransform at = tlc.getBaselineTransform();
+
+ if (at != null) {
+ g2.translate(pt.x - at.getTranslateX(), pt.y - at.getTranslateY());
+ g2.transform(at);
+ tlc.draw(g2, 0, 0);
+ g2.setTransform(oldTx);
+ } else {
+ tlc.draw(g2, pt.x, pt.y);
+ }
+ }
+ }
+ }
+
+ /**
+ * Return the union of the visual bounds of all the components.
+ * This incorporates the path. It does not include logical
+ * bounds (used by carets).
+ */
+ public Rectangle2D getVisualBounds() {
+ Rectangle2D result = null;
+
+ for (int i = 0, n = 0; i < fComponents.length; i++, n += 2) {
+ TextLineComponent tlc = fComponents[getComponentLogicalIndex(i)];
+ Rectangle2D r = tlc.getVisualBounds();
+
+ Point2D.Float pt = new Point2D.Float(locs[n], locs[n+1]);
+ if (lp == null) {
+ r.setRect(r.getMinX() + pt.x, r.getMinY() + pt.y,
+ r.getWidth(), r.getHeight());
+ } else {
+ lp.pathToPoint(pt, false, pt);
+
+ AffineTransform at = tlc.getBaselineTransform();
+ if (at != null) {
+ AffineTransform tx = AffineTransform.getTranslateInstance
+ (pt.x - at.getTranslateX(), pt.y - at.getTranslateY());
+ tx.concatenate(at);
+ r = tx.createTransformedShape(r).getBounds2D();
+ } else {
+ r.setRect(r.getMinX() + pt.x, r.getMinY() + pt.y,
+ r.getWidth(), r.getHeight());
+ }
+ }
+
+ if (result == null) {
+ result = r;
+ } else {
+ result.add(r);
+ }
+ }
+
+ if (result == null) {
+ result = new Rectangle2D.Float(Float.MAX_VALUE, Float.MAX_VALUE, Float.MIN_VALUE, Float.MIN_VALUE);
+ }
+
+ return result;
+ }
+
+ public Rectangle2D getItalicBounds() {
+
+ float left = Float.MAX_VALUE, right = -Float.MAX_VALUE;
+ float top = Float.MAX_VALUE, bottom = -Float.MAX_VALUE;
+
+ for (int i=0, n = 0; i < fComponents.length; i++, n += 2) {
+ TextLineComponent tlc = fComponents[getComponentLogicalIndex(i)];
+
+ Rectangle2D tlcBounds = tlc.getItalicBounds();
+ float x = locs[n];
+ float y = locs[n+1];
+
+ left = Math.min(left, x + (float)tlcBounds.getX());
+ right = Math.max(right, x + (float)tlcBounds.getMaxX());
+
+ top = Math.min(top, y + (float)tlcBounds.getY());
+ bottom = Math.max(bottom, y + (float)tlcBounds.getMaxY());
+ }
+
+ return new Rectangle2D.Float(left, top, right-left, bottom-top);
+ }
+
+ public Shape getOutline(AffineTransform tx) {
+
+ GeneralPath dstShape = new GeneralPath(GeneralPath.WIND_NON_ZERO);
+
+ for (int i=0, n = 0; i < fComponents.length; i++, n += 2) {
+ TextLineComponent tlc = fComponents[getComponentLogicalIndex(i)];
+
+ dstShape.append(tlc.getOutline(locs[n], locs[n+1]), false);
+ }
+
+ if (tx != null) {
+ dstShape.transform(tx);
+ }
+ return dstShape;
+ }
+
+ public int hashCode() {
+ return (fComponents.length << 16) ^
+ (fComponents[0].hashCode() << 3) ^ (fCharsLimit-fCharsStart);
+ }
+
+ public String toString() {
+ StringBuilder buf = new StringBuilder();
+
+ for (int i = 0; i < fComponents.length; i++) {
+ buf.append(fComponents[i]);
+ }
+
+ return buf.toString();
+ }
+
+ /**
+ * Create a TextLine from the text. The Font must be able to
+ * display all of the text.
+ * attributes==null is equivalent to using an empty Map for
+ * attributes
+ */
+ public static TextLine fastCreateTextLine(FontRenderContext frc,
+ char[] chars,
+ Font font,
+ CoreMetrics lm,
+ Map attributes) {
+
+ boolean isDirectionLTR = true;
+ byte[] levels = null;
+ int[] charsLtoV = null;
+ Bidi bidi = null;
+ int characterCount = chars.length;
+
+ boolean requiresBidi = false;
+ byte[] embs = null;
+
+ AttributeValues values = null;
+ if (attributes != null) {
+ values = AttributeValues.fromMap(attributes);
+ if (values.getRunDirection() >= 0) {
+ isDirectionLTR = values.getRunDirection() == 0;
+ requiresBidi = !isDirectionLTR;
+ }
+ if (values.getBidiEmbedding() != 0) {
+ requiresBidi = true;
+ byte level = (byte)values.getBidiEmbedding();
+ embs = new byte[characterCount];
+ for (int i = 0; i < embs.length; ++i) {
+ embs[i] = level;
+ }
+ }
+ }
+
+ // dlf: get baseRot from font for now???
+
+ if (!requiresBidi) {
+ requiresBidi = Bidi.requiresBidi(chars, 0, chars.length);
+ }
+
+ if (requiresBidi) {
+ int bidiflags = values == null
+ ? Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT
+ : values.getRunDirection();
+
+ bidi = new Bidi(chars, 0, embs, 0, chars.length, bidiflags);
+ if (!bidi.isLeftToRight()) {
+ levels = BidiUtils.getLevels(bidi);
+ int[] charsVtoL = BidiUtils.createVisualToLogicalMap(levels);
+ charsLtoV = BidiUtils.createInverseMap(charsVtoL);
+ isDirectionLTR = bidi.baseIsLeftToRight();
+ }
+ }
+
+ Decoration decorator = Decoration.getDecoration(values);
+
+ int layoutFlags = 0; // no extra info yet, bidi determines run and line direction
+ TextLabelFactory factory = new TextLabelFactory(frc, chars, bidi, layoutFlags);
+
+ TextLineComponent[] components = new TextLineComponent[1];
+
+ components = createComponentsOnRun(0, chars.length,
+ chars,
+ charsLtoV, levels,
+ factory, font, lm,
+ frc,
+ decorator,
+ components,
+ 0);
+
+ int numComponents = components.length;
+ while (components[numComponents-1] == null) {
+ numComponents -= 1;
+ }
+
+ if (numComponents != components.length) {
+ TextLineComponent[] temp = new TextLineComponent[numComponents];
+ System.arraycopy(components, 0, temp, 0, numComponents);
+ components = temp;
+ }
+
+ return new TextLine(frc, components, lm.baselineOffsets,
+ chars, 0, chars.length, charsLtoV, levels, isDirectionLTR);
+ }
+
+ private static TextLineComponent[] expandArray(TextLineComponent[] orig) {
+
+ TextLineComponent[] newComponents = new TextLineComponent[orig.length + 8];
+ System.arraycopy(orig, 0, newComponents, 0, orig.length);
+
+ return newComponents;
+ }
+
+ /**
+ * Returns an array in logical order of the TextLineComponents on
+ * the text in the given range, with the given attributes.
+ */
+ public static TextLineComponent[] createComponentsOnRun(int runStart,
+ int runLimit,
+ char[] chars,
+ int[] charsLtoV,
+ byte[] levels,
+ TextLabelFactory factory,
+ Font font,
+ CoreMetrics cm,
+ FontRenderContext frc,
+ Decoration decorator,
+ TextLineComponent[] components,
+ int numComponents) {
+
+ int pos = runStart;
+ do {
+ int chunkLimit = firstVisualChunk(charsLtoV, levels, pos, runLimit); // <= displayLimit
+
+ do {
+ int startPos = pos;
+ int lmCount;
+
+ if (cm == null) {
+ LineMetrics lineMetrics = font.getLineMetrics(chars, startPos, chunkLimit, frc);
+ cm = CoreMetrics.get(lineMetrics);
+ lmCount = lineMetrics.getNumChars();
+ }
+ else {
+ lmCount = (chunkLimit-startPos);
+ }
+
+ TextLineComponent nextComponent =
+ factory.createExtended(font, cm, decorator, startPos, startPos + lmCount);
+
+ ++numComponents;
+ if (numComponents >= components.length) {
+ components = expandArray(components);
+ }
+
+ components[numComponents-1] = nextComponent;
+
+ pos += lmCount;
+ } while (pos < chunkLimit);
+
+ } while (pos < runLimit);
+
+ return components;
+ }
+
+ /**
+ * Returns an array (in logical order) of the TextLineComponents representing
+ * the text. The components are both logically and visually contiguous.
+ */
+ public static TextLineComponent[] getComponents(StyledParagraph styledParagraph,
+ char[] chars,
+ int textStart,
+ int textLimit,
+ int[] charsLtoV,
+ byte[] levels,
+ TextLabelFactory factory) {
+
+ FontRenderContext frc = factory.getFontRenderContext();
+
+ int numComponents = 0;
+ TextLineComponent[] tempComponents = new TextLineComponent[1];
+
+ int pos = textStart;
+ do {
+ int runLimit = Math.min(styledParagraph.getRunLimit(pos), textLimit);
+
+ Decoration decorator = styledParagraph.getDecorationAt(pos);
+
+ Object graphicOrFont = styledParagraph.getFontOrGraphicAt(pos);
+
+ if (graphicOrFont instanceof GraphicAttribute) {
+ // AffineTransform baseRot = styledParagraph.getBaselineRotationAt(pos);
+ // !!! For now, let's assign runs of text with both fonts and graphic attributes
+ // a null rotation (e.g. the baseline rotation goes away when a graphic
+ // is applied.
+ AffineTransform baseRot = null;
+ GraphicAttribute graphicAttribute = (GraphicAttribute) graphicOrFont;
+ do {
+ int chunkLimit = firstVisualChunk(charsLtoV, levels,
+ pos, runLimit);
+
+ GraphicComponent nextGraphic =
+ new GraphicComponent(graphicAttribute, decorator, charsLtoV, levels, pos, chunkLimit, baseRot);
+ pos = chunkLimit;
+
+ ++numComponents;
+ if (numComponents >= tempComponents.length) {
+ tempComponents = expandArray(tempComponents);
+ }
+
+ tempComponents[numComponents-1] = nextGraphic;
+
+ } while(pos < runLimit);
+ }
+ else {
+ Font font = (Font) graphicOrFont;
+
+ tempComponents = createComponentsOnRun(pos, runLimit,
+ chars,
+ charsLtoV, levels,
+ factory, font, null,
+ frc,
+ decorator,
+ tempComponents,
+ numComponents);
+ pos = runLimit;
+ numComponents = tempComponents.length;
+ while (tempComponents[numComponents-1] == null) {
+ numComponents -= 1;
+ }
+ }
+
+ } while (pos < textLimit);
+
+ TextLineComponent[] components;
+ if (tempComponents.length == numComponents) {
+ components = tempComponents;
+ }
+ else {
+ components = new TextLineComponent[numComponents];
+ System.arraycopy(tempComponents, 0, components, 0, numComponents);
+ }
+
+ return components;
+ }
+
+ /**
+ * Create a TextLine from the Font and character data over the
+ * range. The range is relative to both the StyledParagraph and the
+ * character array.
+ */
+ public static TextLine createLineFromText(char[] chars,
+ StyledParagraph styledParagraph,
+ TextLabelFactory factory,
+ boolean isDirectionLTR,
+ float[] baselineOffsets) {
+
+ factory.setLineContext(0, chars.length);
+
+ Bidi lineBidi = factory.getLineBidi();
+ int[] charsLtoV = null;
+ byte[] levels = null;
+
+ if (lineBidi != null) {
+ levels = BidiUtils.getLevels(lineBidi);
+ int[] charsVtoL = BidiUtils.createVisualToLogicalMap(levels);
+ charsLtoV = BidiUtils.createInverseMap(charsVtoL);
+ }
+
+ TextLineComponent[] components =
+ getComponents(styledParagraph, chars, 0, chars.length, charsLtoV, levels, factory);
+
+ return new TextLine(factory.getFontRenderContext(), components, baselineOffsets,
+ chars, 0, chars.length, charsLtoV, levels, isDirectionLTR);
+ }
+
+ /**
+ * Compute the components order from the given components array and
+ * logical-to-visual character mapping. May return null if canonical.
+ */
+ private static int[] computeComponentOrder(TextLineComponent[] components,
+ int[] charsLtoV) {
+
+ /*
+ * Create a visual ordering for the glyph sets. The important thing
+ * here is that the values have the proper rank with respect to
+ * each other, not the exact values. For example, the first glyph
+ * set that appears visually should have the lowest value. The last
+ * should have the highest value. The values are then normalized
+ * to map 1-1 with positions in glyphs.
+ *
+ */
+ int[] componentOrder = null;
+ if (charsLtoV != null && components.length > 1) {
+ componentOrder = new int[components.length];
+ int gStart = 0;
+ for (int i = 0; i < components.length; i++) {
+ componentOrder[i] = charsLtoV[gStart];
+ gStart += components[i].getNumCharacters();
+ }
+
+ componentOrder = BidiUtils.createContiguousOrder(componentOrder);
+ componentOrder = BidiUtils.createInverseMap(componentOrder);
+ }
+ return componentOrder;
+ }
+
+
+ /**
+ * Create a TextLine from the text. chars is just the text in the iterator.
+ */
+ public static TextLine standardCreateTextLine(FontRenderContext frc,
+ AttributedCharacterIterator text,
+ char[] chars,
+ float[] baselineOffsets) {
+
+ StyledParagraph styledParagraph = new StyledParagraph(text, chars);
+ Bidi bidi = new Bidi(text);
+ if (bidi.isLeftToRight()) {
+ bidi = null;
+ }
+ int layoutFlags = 0; // no extra info yet, bidi determines run and line direction
+ TextLabelFactory factory = new TextLabelFactory(frc, chars, bidi, layoutFlags);
+
+ boolean isDirectionLTR = true;
+ if (bidi != null) {
+ isDirectionLTR = bidi.baseIsLeftToRight();
+ }
+ return createLineFromText(chars, styledParagraph, factory, isDirectionLTR, baselineOffsets);
+ }
+
+
+
+ /*
+ * A utility to get a range of text that is both logically and visually
+ * contiguous.
+ * If the entire range is ok, return limit, otherwise return the first
+ * directional change after start. We could do better than this, but
+ * it doesn't seem worth it at the moment.
+ private static int firstVisualChunk(int order[], byte direction[],
+ int start, int limit)
+ {
+ if (order != null) {
+ int min = order[start];
+ int max = order[start];
+ int count = limit - start;
+ for (int i = start + 1; i < limit; i++) {
+ min = Math.min(min, order[i]);
+ max = Math.max(max, order[i]);
+ if (max - min >= count) {
+ if (direction != null) {
+ byte baseLevel = direction[start];
+ for (int j = start + 1; j < i; j++) {
+ if (direction[j] != baseLevel) {
+ return j;
+ }
+ }
+ }
+ return i;
+ }
+ }
+ }
+ return limit;
+ }
+ */
+
+ /**
+ * When this returns, the ACI's current position will be at the start of the
+ * first run which does NOT contain a GraphicAttribute. If no such run exists
+ * the ACI's position will be at the end, and this method will return false.
+ */
+ static boolean advanceToFirstFont(AttributedCharacterIterator aci) {
+
+ for (char ch = aci.first(); ch != aci.DONE; ch = aci.setIndex(aci.getRunLimit())) {
+
+ if (aci.getAttribute(TextAttribute.CHAR_REPLACEMENT) == null) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ static float[] getNormalizedOffsets(float[] baselineOffsets, byte baseline) {
+
+ if (baselineOffsets[baseline] != 0) {
+ float base = baselineOffsets[baseline];
+ float[] temp = new float[baselineOffsets.length];
+ for (int i = 0; i < temp.length; i++)
+ temp[i] = baselineOffsets[i] - base;
+ baselineOffsets = temp;
+ }
+ return baselineOffsets;
+ }
+
+ static Font getFontAtCurrentPos(AttributedCharacterIterator aci) {
+
+ Object value = aci.getAttribute(TextAttribute.FONT);
+ if (value != null) {
+ return (Font) value;
+ }
+ if (aci.getAttribute(TextAttribute.FAMILY) != null) {
+ return Font.getFont(aci.getAttributes());
+ }
+
+ int ch = CodePointIterator.create(aci).next();
+ if (ch != CodePointIterator.DONE) {
+ FontResolver resolver = FontResolver.getInstance();
+ return resolver.getFont(resolver.getFontIndex(ch), aci.getAttributes());
+ }
+ return null;
+ }
+
+ /*
+ * The new version requires that chunks be at the same level.
+ */
+ private static int firstVisualChunk(int order[], byte direction[],
+ int start, int limit)
+ {
+ if (order != null && direction != null) {
+ byte dir = direction[start];
+ while (++start < limit && direction[start] == dir) {}
+ return start;
+ }
+ return limit;
+ }
+
+ /*
+ * create a new line with characters between charStart and charLimit
+ * justified using the provided width and ratio.
+ */
+ public TextLine getJustifiedLine(float justificationWidth, float justifyRatio, int justStart, int justLimit) {
+
+ TextLineComponent[] newComponents = new TextLineComponent[fComponents.length];
+ System.arraycopy(fComponents, 0, newComponents, 0, fComponents.length);
+
+ float leftHang = 0;
+ float adv = 0;
+ float justifyDelta = 0;
+ boolean rejustify = false;
+ do {
+ adv = getAdvanceBetween(newComponents, 0, characterCount());
+
+ // all characters outside the justification range must be in the base direction
+ // of the layout, otherwise justification makes no sense.
+
+ float justifyAdvance = getAdvanceBetween(newComponents, justStart, justLimit);
+
+ // get the actual justification delta
+ justifyDelta = (justificationWidth - justifyAdvance) * justifyRatio;
+
+ // generate an array of GlyphJustificationInfo records to pass to
+ // the justifier. Array is visually ordered.
+
+ // get positions that each component will be using
+ int[] infoPositions = new int[newComponents.length];
+ int infoCount = 0;
+ for (int visIndex = 0; visIndex < newComponents.length; visIndex++) {
+ int logIndex = getComponentLogicalIndex(visIndex);
+ infoPositions[logIndex] = infoCount;
+ infoCount += newComponents[logIndex].getNumJustificationInfos();
+ }
+ GlyphJustificationInfo[] infos = new GlyphJustificationInfo[infoCount];
+
+ // get justification infos
+ int compStart = 0;
+ for (int i = 0; i < newComponents.length; i++) {
+ TextLineComponent comp = newComponents[i];
+ int compLength = comp.getNumCharacters();
+ int compLimit = compStart + compLength;
+ if (compLimit > justStart) {
+ int rangeMin = Math.max(0, justStart - compStart);
+ int rangeMax = Math.min(compLength, justLimit - compStart);
+ comp.getJustificationInfos(infos, infoPositions[i], rangeMin, rangeMax);
+
+ if (compLimit >= justLimit) {
+ break;
+ }
+ }
+ }
+
+ // records are visually ordered, and contiguous, so start and end are
+ // simply the places where we didn't fetch records
+ int infoStart = 0;
+ int infoLimit = infoCount;
+ while (infoStart < infoLimit && infos[infoStart] == null) {
+ ++infoStart;
+ }
+
+ while (infoLimit > infoStart && infos[infoLimit - 1] == null) {
+ --infoLimit;
+ }
+
+ // invoke justifier on the records
+ TextJustifier justifier = new TextJustifier(infos, infoStart, infoLimit);
+
+ float[] deltas = justifier.justify(justifyDelta);
+
+ boolean canRejustify = rejustify == false;
+ boolean wantRejustify = false;
+ boolean[] flags = new boolean[1];
+
+ // apply justification deltas
+ compStart = 0;
+ for (int i = 0; i < newComponents.length; i++) {
+ TextLineComponent comp = newComponents[i];
+ int compLength = comp.getNumCharacters();
+ int compLimit = compStart + compLength;
+ if (compLimit > justStart) {
+ int rangeMin = Math.max(0, justStart - compStart);
+ int rangeMax = Math.min(compLength, justLimit - compStart);
+ newComponents[i] = comp.applyJustificationDeltas(deltas, infoPositions[i] * 2, flags);
+
+ wantRejustify |= flags[0];
+
+ if (compLimit >= justLimit) {
+ break;
+ }
+ }
+ }
+
+ rejustify = wantRejustify && !rejustify; // only make two passes
+ } while (rejustify);
+
+ return new TextLine(frc, newComponents, fBaselineOffsets, fChars, fCharsStart,
+ fCharsLimit, fCharLogicalOrder, fCharLevels,
+ fIsDirectionLTR);
+ }
+
+ // return the sum of the advances of text between the logical start and limit
+ public static float getAdvanceBetween(TextLineComponent[] components, int start, int limit) {
+ float advance = 0;
+
+ int tlcStart = 0;
+ for(int i = 0; i < components.length; i++) {
+ TextLineComponent comp = components[i];
+
+ int tlcLength = comp.getNumCharacters();
+ int tlcLimit = tlcStart + tlcLength;
+ if (tlcLimit > start) {
+ int measureStart = Math.max(0, start - tlcStart);
+ int measureLimit = Math.min(tlcLength, limit - tlcStart);
+ advance += comp.getAdvanceBetween(measureStart, measureLimit);
+ if (tlcLimit >= limit) {
+ break;
+ }
+ }
+
+ tlcStart = tlcLimit;
+ }
+
+ return advance;
+ }
+
+ LayoutPathImpl getLayoutPath() {
+ return lp;
+ }
+}