| /* | |
| * Copyright (c) 1998, 2024, Oracle and/or its affiliates. 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. Oracle designates this | |
| * particular file as subject to the "Classpath" exception as provided | |
| * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | |
| * or visit www.oracle.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.AttributedCharacterIterator.Attribute; | |
| 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.CodePointIterator; | |
| 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 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() & AffineTransform.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() { | |
| 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); | |
| } | |
| return dstShape; | |
| } | |
| 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<? extends Attribute, ?> 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 != CharacterIterator.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; | |
| } | |
| } |