1 /*
   2  * Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 /*
  27  * (C) Copyright IBM Corp. 1998-2003, All Rights Reserved
  28  *
  29  */
  30 
  31 package java.awt.font;
  32 
  33 import java.awt.Color;
  34 import java.awt.Font;
  35 import java.awt.Graphics2D;
  36 import java.awt.Rectangle;
  37 import java.awt.Shape;
  38 import java.awt.geom.AffineTransform;
  39 import java.awt.geom.GeneralPath;
  40 import java.awt.geom.Point2D;
  41 import java.awt.geom.Rectangle2D;
  42 import java.awt.im.InputMethodHighlight;
  43 import java.awt.image.BufferedImage;
  44 import java.text.Annotation;
  45 import java.text.AttributedCharacterIterator;
  46 import java.text.AttributedCharacterIterator.Attribute;
  47 import java.text.Bidi;
  48 import java.text.CharacterIterator;
  49 import java.util.Hashtable;
  50 import java.util.Map;
  51 import sun.font.AttributeValues;
  52 import sun.font.BidiUtils;
  53 import sun.font.CoreMetrics;
  54 import sun.font.Decoration;
  55 import sun.font.FontLineMetrics;
  56 import sun.font.FontResolver;
  57 import sun.font.GraphicComponent;
  58 import sun.font.LayoutPathImpl;
  59 import sun.font.LayoutPathImpl.EmptyPath;
  60 import sun.font.LayoutPathImpl.SegmentPathBuilder;
  61 import sun.font.TextLabelFactory;
  62 import sun.font.TextLineComponent;
  63 import sun.text.CodePointIterator;
  64 
  65 import java.awt.geom.Line2D;
  66 
  67 final class TextLine {
  68 
  69     static final class TextLineMetrics {
  70         public final float ascent;
  71         public final float descent;
  72         public final float leading;
  73         public final float advance;
  74 
  75         public TextLineMetrics(float ascent,
  76                            float descent,
  77                            float leading,
  78                            float advance) {
  79             this.ascent = ascent;
  80             this.descent = descent;
  81             this.leading = leading;
  82             this.advance = advance;
  83         }
  84     }
  85 
  86     private TextLineComponent[] fComponents;
  87     private float[] fBaselineOffsets;
  88     private int[] fComponentVisualOrder; // if null, ltr
  89     private float[] locs; // x,y pairs for components in visual order
  90     private char[] fChars;
  91     private int fCharsStart;
  92     private int fCharsLimit;
  93     private int[] fCharVisualOrder;  // if null, ltr
  94     private int[] fCharLogicalOrder; // if null, ltr
  95     private byte[] fCharLevels;     // if null, 0
  96     private boolean fIsDirectionLTR;
  97     private LayoutPathImpl lp;
  98     private boolean isSimple;
  99     private Rectangle pixelBounds;
 100     private FontRenderContext frc;
 101 
 102     private TextLineMetrics fMetrics = null; // built on demand in getMetrics
 103 
 104     public TextLine(FontRenderContext frc,
 105                     TextLineComponent[] components,
 106                     float[] baselineOffsets,
 107                     char[] chars,
 108                     int charsStart,
 109                     int charsLimit,
 110                     int[] charLogicalOrder,
 111                     byte[] charLevels,
 112                     boolean isDirectionLTR) {
 113 
 114         int[] componentVisualOrder = computeComponentOrder(components,
 115                                                            charLogicalOrder);
 116 
 117         this.frc = frc;
 118         fComponents = components;
 119         fBaselineOffsets = baselineOffsets;
 120         fComponentVisualOrder = componentVisualOrder;
 121         fChars = chars;
 122         fCharsStart = charsStart;
 123         fCharsLimit = charsLimit;
 124         fCharLogicalOrder = charLogicalOrder;
 125         fCharLevels = charLevels;
 126         fIsDirectionLTR = isDirectionLTR;
 127         checkCtorArgs();
 128 
 129         init();
 130     }
 131 
 132     private void checkCtorArgs() {
 133 
 134         int checkCharCount = 0;
 135         for (int i=0; i < fComponents.length; i++) {
 136             checkCharCount += fComponents[i].getNumCharacters();
 137         }
 138 
 139         if (checkCharCount != this.characterCount()) {
 140             throw new IllegalArgumentException("Invalid TextLine!  " +
 141                                 "char count is different from " +
 142                                 "sum of char counts of components.");
 143         }
 144     }
 145 
 146     private void init() {
 147 
 148         // first, we need to check for graphic components on the TOP or BOTTOM baselines.  So
 149         // we perform the work that used to be in getMetrics here.
 150 
 151         float ascent = 0;
 152         float descent = 0;
 153         float leading = 0;
 154         float advance = 0;
 155 
 156         // ascent + descent must not be less than this value
 157         float maxGraphicHeight = 0;
 158         float maxGraphicHeightWithLeading = 0;
 159 
 160         // walk through EGA's
 161         TextLineComponent tlc;
 162         boolean fitTopAndBottomGraphics = false;
 163 
 164         isSimple = true;
 165 
 166         for (int i = 0; i < fComponents.length; i++) {
 167             tlc = fComponents[i];
 168 
 169             isSimple &= tlc.isSimple();
 170 
 171             CoreMetrics cm = tlc.getCoreMetrics();
 172 
 173             byte baseline = (byte)cm.baselineIndex;
 174 
 175             if (baseline >= 0) {
 176                 float baselineOffset = fBaselineOffsets[baseline];
 177 
 178                 ascent = Math.max(ascent, -baselineOffset + cm.ascent);
 179 
 180                 float gd = baselineOffset + cm.descent;
 181                 descent = Math.max(descent, gd);
 182 
 183                 leading = Math.max(leading, gd + cm.leading);
 184             }
 185             else {
 186                 fitTopAndBottomGraphics = true;
 187                 float graphicHeight = cm.ascent + cm.descent;
 188                 float graphicHeightWithLeading = graphicHeight + cm.leading;
 189                 maxGraphicHeight = Math.max(maxGraphicHeight, graphicHeight);
 190                 maxGraphicHeightWithLeading = Math.max(maxGraphicHeightWithLeading,
 191                                                        graphicHeightWithLeading);
 192             }
 193         }
 194 
 195         if (fitTopAndBottomGraphics) {
 196             if (maxGraphicHeight > ascent + descent) {
 197                 descent = maxGraphicHeight - ascent;
 198             }
 199             if (maxGraphicHeightWithLeading > ascent + leading) {
 200                 leading = maxGraphicHeightWithLeading - ascent;
 201             }
 202         }
 203 
 204         leading -= descent;
 205 
 206         // we now know enough to compute the locs, but we need the final loc
 207         // for the advance before we can create the metrics object
 208 
 209         if (fitTopAndBottomGraphics) {
 210             // we have top or bottom baselines, so expand the baselines array
 211             // full offsets are needed by CoreMetrics.effectiveBaselineOffset
 212             fBaselineOffsets = new float[] {
 213                 fBaselineOffsets[0],
 214                 fBaselineOffsets[1],
 215                 fBaselineOffsets[2],
 216                 descent,
 217                 -ascent
 218             };
 219         }
 220 
 221         float x = 0;
 222         float y = 0;
 223         CoreMetrics pcm = null;
 224 
 225         boolean needPath = false;
 226         locs = new float[fComponents.length * 2 + 2];
 227 
 228         for (int i = 0, n = 0; i < fComponents.length; ++i, n += 2) {
 229             tlc = fComponents[getComponentLogicalIndex(i)];
 230             CoreMetrics cm = tlc.getCoreMetrics();
 231 
 232             if ((pcm != null) &&
 233                 (pcm.italicAngle != 0 || cm.italicAngle != 0) &&  // adjust because of italics
 234                 (pcm.italicAngle != cm.italicAngle ||
 235                  pcm.baselineIndex != cm.baselineIndex ||
 236                  pcm.ssOffset != cm.ssOffset)) {
 237 
 238                 // 1) compute the area of overlap - min effective ascent and min effective descent
 239                 // 2) compute the x positions along italic angle of ascent and descent for left and right
 240                 // 3) compute maximum left - right, adjust right position by this value
 241                 // this is a crude form of kerning between textcomponents
 242 
 243                 // note glyphvectors preposition glyphs based on offset,
 244                 // so tl doesn't need to adjust glyphvector position
 245                 // 1)
 246                 float pb = pcm.effectiveBaselineOffset(fBaselineOffsets);
 247                 float pa = pb - pcm.ascent;
 248                 float pd = pb + pcm.descent;
 249                 // pb += pcm.ssOffset;
 250 
 251                 float cb = cm.effectiveBaselineOffset(fBaselineOffsets);
 252                 float ca = cb - cm.ascent;
 253                 float cd = cb + cm.descent;
 254                 // cb += cm.ssOffset;
 255 
 256                 float a = Math.max(pa, ca);
 257                 float d = Math.min(pd, cd);
 258 
 259                 // 2)
 260                 float pax = pcm.italicAngle * (pb - a);
 261                 float pdx = pcm.italicAngle * (pb - d);
 262 
 263                 float cax = cm.italicAngle * (cb - a);
 264                 float cdx = cm.italicAngle * (cb - d);
 265 
 266                 // 3)
 267                 float dax = pax - cax;
 268                 float ddx = pdx - cdx;
 269                 float dx = Math.max(dax, ddx);
 270 
 271                 x += dx;
 272                 y = cb;
 273             } else {
 274                 // no italic adjustment for x, but still need to compute y
 275                 y = cm.effectiveBaselineOffset(fBaselineOffsets); // + cm.ssOffset;
 276             }
 277 
 278             locs[n] = x;
 279             locs[n+1] = y;
 280 
 281             x += tlc.getAdvance();
 282             pcm = cm;
 283 
 284             needPath |= tlc.getBaselineTransform() != null;
 285         }
 286 
 287         // do we want italic padding at the right of the line?
 288         if (pcm.italicAngle != 0) {
 289             float pb = pcm.effectiveBaselineOffset(fBaselineOffsets);
 290             float pa = pb - pcm.ascent;
 291             float pd = pb + pcm.descent;
 292             pb += pcm.ssOffset;
 293 
 294             float d;
 295             if (pcm.italicAngle > 0) {
 296                 d = pb + pcm.ascent;
 297             } else {
 298                 d = pb - pcm.descent;
 299             }
 300             d *= pcm.italicAngle;
 301 
 302             x += d;
 303         }
 304         locs[locs.length - 2] = x;
 305         // locs[locs.length - 1] = 0; // final offset is always back on baseline
 306 
 307         // ok, build fMetrics since we have the final advance
 308         advance = x;
 309         fMetrics = new TextLineMetrics(ascent, descent, leading, advance);
 310 
 311         // build path if we need it
 312         if (needPath) {
 313             isSimple = false;
 314 
 315             Point2D.Double pt = new Point2D.Double();
 316             double tx = 0, ty = 0;
 317             SegmentPathBuilder builder = new SegmentPathBuilder();
 318             builder.moveTo(locs[0], 0);
 319             for (int i = 0, n = 0; i < fComponents.length; ++i, n += 2) {
 320                 tlc = fComponents[getComponentLogicalIndex(i)];
 321                 AffineTransform at = tlc.getBaselineTransform();
 322                 if (at != null &&
 323                     ((at.getType() & AffineTransform.TYPE_TRANSLATION) != 0)) {
 324                     double dx = at.getTranslateX();
 325                     double dy = at.getTranslateY();
 326                     builder.moveTo(tx += dx, ty += dy);
 327                 }
 328                 pt.x = locs[n+2] - locs[n];
 329                 pt.y = 0;
 330                 if (at != null) {
 331                     at.deltaTransform(pt, pt);
 332                 }
 333                 builder.lineTo(tx += pt.x, ty += pt.y);
 334             }
 335             lp = builder.complete();
 336 
 337             if (lp == null) { // empty path
 338                 tlc = fComponents[getComponentLogicalIndex(0)];
 339                 AffineTransform at = tlc.getBaselineTransform();
 340                 if (at != null) {
 341                     lp = new EmptyPath(at);
 342                 }
 343             }
 344         }
 345     }
 346 
 347     public Rectangle getPixelBounds(FontRenderContext frc, float x, float y) {
 348         Rectangle result = null;
 349 
 350         // if we have a matching frc, set it to null so we don't have to test it
 351         // for each component
 352         if (frc != null && frc.equals(this.frc)) {
 353             frc = null;
 354         }
 355 
 356         // only cache integral locations with the default frc, this is a bit strict
 357         int ix = (int)Math.floor(x);
 358         int iy = (int)Math.floor(y);
 359         float rx = x - ix;
 360         float ry = y - iy;
 361         boolean canCache = frc == null && rx == 0 && ry == 0;
 362 
 363         if (canCache && pixelBounds != null) {
 364             result = new Rectangle(pixelBounds);
 365             result.x += ix;
 366             result.y += iy;
 367             return result;
 368         }
 369 
 370         // couldn't use cache, or didn't have it, so compute
 371 
 372         if (isSimple) { // all glyphvectors with no decorations, no layout path
 373             for (int i = 0, n = 0; i < fComponents.length; i++, n += 2) {
 374                 TextLineComponent tlc = fComponents[getComponentLogicalIndex(i)];
 375                 Rectangle pb = tlc.getPixelBounds(frc, locs[n] + rx, locs[n+1] + ry);
 376                 if (!pb.isEmpty()) {
 377                     if (result == null) {
 378                         result = pb;
 379                     } else {
 380                         result.add(pb);
 381                     }
 382                 }
 383             }
 384             if (result == null) {
 385                 result = new Rectangle(0, 0, 0, 0);
 386             }
 387         } else { // draw and test
 388             final int MARGIN = 3;
 389             Rectangle2D r2d = getVisualBounds();
 390             if (lp != null) {
 391                 r2d = lp.mapShape(r2d).getBounds();
 392             }
 393             Rectangle bounds = r2d.getBounds();
 394             BufferedImage im = new BufferedImage(bounds.width + MARGIN * 2,
 395                                                  bounds.height + MARGIN * 2,
 396                                                  BufferedImage.TYPE_INT_ARGB);
 397 
 398             Graphics2D g2d = im.createGraphics();
 399             g2d.setColor(Color.WHITE);
 400             g2d.fillRect(0, 0, im.getWidth(), im.getHeight());
 401 
 402             g2d.setColor(Color.BLACK);
 403             draw(g2d, rx + MARGIN - bounds.x, ry + MARGIN - bounds.y);
 404 
 405             result = computePixelBounds(im);
 406             result.x -= MARGIN - bounds.x;
 407             result.y -= MARGIN - bounds.y;
 408         }
 409 
 410         if (canCache) {
 411             pixelBounds = new Rectangle(result);
 412         }
 413 
 414         result.x += ix;
 415         result.y += iy;
 416         return result;
 417     }
 418 
 419     static Rectangle computePixelBounds(BufferedImage im) {
 420         int w = im.getWidth();
 421         int h = im.getHeight();
 422 
 423         int l = -1, t = -1, r = w, b = h;
 424 
 425         {
 426             // get top
 427             int[] buf = new int[w];
 428             loop: while (++t < h) {
 429                 im.getRGB(0, t, buf.length, 1, buf, 0, w); // w ignored
 430                 for (int i = 0; i < buf.length; i++) {
 431                     if (buf[i] != -1) {
 432                         break loop;
 433                     }
 434                 }
 435             }
 436         }
 437 
 438         // get bottom
 439         {
 440             int[] buf = new int[w];
 441             loop: while (--b > t) {
 442                 im.getRGB(0, b, buf.length, 1, buf, 0, w); // w ignored
 443                 for (int i = 0; i < buf.length; ++i) {
 444                     if (buf[i] != -1) {
 445                         break loop;
 446                     }
 447                 }
 448             }
 449             ++b;
 450         }
 451 
 452         // get left
 453         {
 454             loop: while (++l < r) {
 455                 for (int i = t; i < b; ++i) {
 456                     int v = im.getRGB(l, i);
 457                     if (v != -1) {
 458                         break loop;
 459                     }
 460                 }
 461             }
 462         }
 463 
 464         // get right
 465         {
 466             loop: while (--r > l) {
 467                 for (int i = t; i < b; ++i) {
 468                     int v = im.getRGB(r, i);
 469                     if (v != -1) {
 470                         break loop;
 471                     }
 472                 }
 473             }
 474             ++r;
 475         }
 476 
 477         return new Rectangle(l, t, r-l, b-t);
 478     }
 479 
 480     private abstract static class Function {
 481 
 482         abstract float computeFunction(TextLine line,
 483                                        int componentIndex,
 484                                        int indexInArray);
 485     }
 486 
 487     private static Function fgPosAdvF = new Function() {
 488         float computeFunction(TextLine line,
 489                               int componentIndex,
 490                               int indexInArray) {
 491 
 492             TextLineComponent tlc = line.fComponents[componentIndex];
 493                 int vi = line.getComponentVisualIndex(componentIndex);
 494             return line.locs[vi * 2] + tlc.getCharX(indexInArray) + tlc.getCharAdvance(indexInArray);
 495         }
 496     };
 497 
 498     private static Function fgAdvanceF = new Function() {
 499 
 500         float computeFunction(TextLine line,
 501                               int componentIndex,
 502                               int indexInArray) {
 503 
 504             TextLineComponent tlc = line.fComponents[componentIndex];
 505             return tlc.getCharAdvance(indexInArray);
 506         }
 507     };
 508 
 509     private static Function fgXPositionF = new Function() {
 510 
 511         float computeFunction(TextLine line,
 512                               int componentIndex,
 513                               int indexInArray) {
 514 
 515                 int vi = line.getComponentVisualIndex(componentIndex);
 516             TextLineComponent tlc = line.fComponents[componentIndex];
 517             return line.locs[vi * 2] + tlc.getCharX(indexInArray);
 518         }
 519     };
 520 
 521     private static Function fgYPositionF = new Function() {
 522 
 523         float computeFunction(TextLine line,
 524                               int componentIndex,
 525                               int indexInArray) {
 526 
 527             TextLineComponent tlc = line.fComponents[componentIndex];
 528             float charPos = tlc.getCharY(indexInArray);
 529 
 530             // charPos is relative to the component - adjust for
 531             // baseline
 532 
 533             return charPos + line.getComponentShift(componentIndex);
 534         }
 535     };
 536 
 537     public int characterCount() {
 538 
 539         return fCharsLimit - fCharsStart;
 540     }
 541 
 542     public boolean isDirectionLTR() {
 543 
 544         return fIsDirectionLTR;
 545     }
 546 
 547     public TextLineMetrics getMetrics() {
 548         return fMetrics;
 549     }
 550 
 551     public int visualToLogical(int visualIndex) {
 552 
 553         if (fCharLogicalOrder == null) {
 554             return visualIndex;
 555         }
 556 
 557         if (fCharVisualOrder == null) {
 558             fCharVisualOrder = BidiUtils.createInverseMap(fCharLogicalOrder);
 559         }
 560 
 561         return fCharVisualOrder[visualIndex];
 562     }
 563 
 564     public int logicalToVisual(int logicalIndex) {
 565 
 566         return (fCharLogicalOrder == null)?
 567             logicalIndex : fCharLogicalOrder[logicalIndex];
 568     }
 569 
 570     public byte getCharLevel(int logicalIndex) {
 571 
 572         return fCharLevels==null? 0 : fCharLevels[logicalIndex];
 573     }
 574 
 575     public boolean isCharLTR(int logicalIndex) {
 576 
 577         return (getCharLevel(logicalIndex) & 0x1) == 0;
 578     }
 579 
 580     public int getCharType(int logicalIndex) {
 581 
 582         return Character.getType(fChars[logicalIndex + fCharsStart]);
 583     }
 584 
 585     public boolean isCharSpace(int logicalIndex) {
 586 
 587         return Character.isSpaceChar(fChars[logicalIndex + fCharsStart]);
 588     }
 589 
 590     public boolean isCharWhitespace(int logicalIndex) {
 591 
 592         return Character.isWhitespace(fChars[logicalIndex + fCharsStart]);
 593     }
 594 
 595     public float getCharAngle(int logicalIndex) {
 596 
 597         return getCoreMetricsAt(logicalIndex).italicAngle;
 598     }
 599 
 600     public CoreMetrics getCoreMetricsAt(int logicalIndex) {
 601 
 602         if (logicalIndex < 0) {
 603             throw new IllegalArgumentException("Negative logicalIndex.");
 604         }
 605 
 606         if (logicalIndex > fCharsLimit - fCharsStart) {
 607             throw new IllegalArgumentException("logicalIndex too large.");
 608         }
 609 
 610         int currentTlc = 0;
 611         int tlcStart = 0;
 612         int tlcLimit = 0;
 613 
 614         do {
 615             tlcLimit += fComponents[currentTlc].getNumCharacters();
 616             if (tlcLimit > logicalIndex) {
 617                 break;
 618             }
 619             ++currentTlc;
 620             tlcStart = tlcLimit;
 621         } while(currentTlc < fComponents.length);
 622 
 623         return fComponents[currentTlc].getCoreMetrics();
 624     }
 625 
 626     public float getCharAscent(int logicalIndex) {
 627 
 628         return getCoreMetricsAt(logicalIndex).ascent;
 629     }
 630 
 631     public float getCharDescent(int logicalIndex) {
 632 
 633         return getCoreMetricsAt(logicalIndex).descent;
 634     }
 635 
 636     public float getCharShift(int logicalIndex) {
 637 
 638         return getCoreMetricsAt(logicalIndex).ssOffset;
 639     }
 640 
 641     private float applyFunctionAtIndex(int logicalIndex, Function f) {
 642 
 643         if (logicalIndex < 0) {
 644             throw new IllegalArgumentException("Negative logicalIndex.");
 645         }
 646 
 647         int tlcStart = 0;
 648 
 649         for(int i=0; i < fComponents.length; i++) {
 650 
 651             int tlcLimit = tlcStart + fComponents[i].getNumCharacters();
 652             if (tlcLimit > logicalIndex) {
 653                 return f.computeFunction(this, i, logicalIndex - tlcStart);
 654             }
 655             else {
 656                 tlcStart = tlcLimit;
 657             }
 658         }
 659 
 660         throw new IllegalArgumentException("logicalIndex too large.");
 661     }
 662 
 663     public float getCharAdvance(int logicalIndex) {
 664 
 665         return applyFunctionAtIndex(logicalIndex, fgAdvanceF);
 666     }
 667 
 668     public float getCharXPosition(int logicalIndex) {
 669 
 670         return applyFunctionAtIndex(logicalIndex, fgXPositionF);
 671     }
 672 
 673     public float getCharYPosition(int logicalIndex) {
 674 
 675         return applyFunctionAtIndex(logicalIndex, fgYPositionF);
 676     }
 677 
 678     public float getCharLinePosition(int logicalIndex) {
 679 
 680         return getCharXPosition(logicalIndex);
 681     }
 682 
 683     public float getCharLinePosition(int logicalIndex, boolean leading) {
 684         Function f = isCharLTR(logicalIndex) == leading ? fgXPositionF : fgPosAdvF;
 685         return applyFunctionAtIndex(logicalIndex, f);
 686     }
 687 
 688     public boolean caretAtOffsetIsValid(int offset) {
 689 
 690         if (offset < 0) {
 691             throw new IllegalArgumentException("Negative offset.");
 692         }
 693 
 694         int tlcStart = 0;
 695 
 696         for(int i=0; i < fComponents.length; i++) {
 697 
 698             int tlcLimit = tlcStart + fComponents[i].getNumCharacters();
 699             if (tlcLimit > offset) {
 700                 return fComponents[i].caretAtOffsetIsValid(offset-tlcStart);
 701             }
 702             else {
 703                 tlcStart = tlcLimit;
 704             }
 705         }
 706 
 707         throw new IllegalArgumentException("logicalIndex too large.");
 708     }
 709 
 710     /**
 711      * map a component visual index to the logical index.
 712      */
 713     private int getComponentLogicalIndex(int vi) {
 714         if (fComponentVisualOrder == null) {
 715             return vi;
 716         }
 717         return fComponentVisualOrder[vi];
 718     }
 719 
 720     /**
 721      * map a component logical index to the visual index.
 722      */
 723     private int getComponentVisualIndex(int li) {
 724         if (fComponentVisualOrder == null) {
 725                 return li;
 726         }
 727         for (int i = 0; i < fComponentVisualOrder.length; ++i) {
 728                 if (fComponentVisualOrder[i] == li) {
 729                     return i;
 730                 }
 731         }
 732         throw new IndexOutOfBoundsException("bad component index: " + li);
 733     }
 734 
 735     public Rectangle2D getCharBounds(int logicalIndex) {
 736 
 737         if (logicalIndex < 0) {
 738             throw new IllegalArgumentException("Negative logicalIndex.");
 739         }
 740 
 741         int tlcStart = 0;
 742 
 743         for (int i=0; i < fComponents.length; i++) {
 744 
 745             int tlcLimit = tlcStart + fComponents[i].getNumCharacters();
 746             if (tlcLimit > logicalIndex) {
 747 
 748                 TextLineComponent tlc = fComponents[i];
 749                 int indexInTlc = logicalIndex - tlcStart;
 750                 Rectangle2D chBounds = tlc.getCharVisualBounds(indexInTlc);
 751 
 752                         int vi = getComponentVisualIndex(i);
 753                 chBounds.setRect(chBounds.getX() + locs[vi * 2],
 754                                  chBounds.getY() + locs[vi * 2 + 1],
 755                                  chBounds.getWidth(),
 756                                  chBounds.getHeight());
 757                 return chBounds;
 758             }
 759             else {
 760                 tlcStart = tlcLimit;
 761             }
 762         }
 763 
 764         throw new IllegalArgumentException("logicalIndex too large.");
 765     }
 766 
 767     private float getComponentShift(int index) {
 768         CoreMetrics cm = fComponents[index].getCoreMetrics();
 769         return cm.effectiveBaselineOffset(fBaselineOffsets);
 770     }
 771 
 772     public void draw(Graphics2D g2, float x, float y) {
 773         if (lp == null) {
 774             for (int i = 0, n = 0; i < fComponents.length; i++, n += 2) {
 775                 TextLineComponent tlc = fComponents[getComponentLogicalIndex(i)];
 776                 tlc.draw(g2, locs[n] + x, locs[n+1] + y);
 777             }
 778         } else {
 779             AffineTransform oldTx = g2.getTransform();
 780             Point2D.Float pt = new Point2D.Float();
 781             for (int i = 0, n = 0; i < fComponents.length; i++, n += 2) {
 782                 TextLineComponent tlc = fComponents[getComponentLogicalIndex(i)];
 783                 lp.pathToPoint(locs[n], locs[n+1], false, pt);
 784                 pt.x += x;
 785                 pt.y += y;
 786                 AffineTransform at = tlc.getBaselineTransform();
 787 
 788                 if (at != null) {
 789                     g2.translate(pt.x - at.getTranslateX(), pt.y - at.getTranslateY());
 790                     g2.transform(at);
 791                     tlc.draw(g2, 0, 0);
 792                     g2.setTransform(oldTx);
 793                 } else {
 794                     tlc.draw(g2, pt.x, pt.y);
 795                 }
 796             }
 797         }
 798     }
 799 
 800     /**
 801      * Return the union of the visual bounds of all the components.
 802      * This incorporates the path.  It does not include logical
 803      * bounds (used by carets).
 804      */
 805     public Rectangle2D getVisualBounds() {
 806         Rectangle2D result = null;
 807 
 808         for (int i = 0, n = 0; i < fComponents.length; i++, n += 2) {
 809             TextLineComponent tlc = fComponents[getComponentLogicalIndex(i)];
 810             Rectangle2D r = tlc.getVisualBounds();
 811 
 812             Point2D.Float pt = new Point2D.Float(locs[n], locs[n+1]);
 813             if (lp == null) {
 814                 r.setRect(r.getMinX() + pt.x, r.getMinY() + pt.y,
 815                           r.getWidth(), r.getHeight());
 816             } else {
 817                 lp.pathToPoint(pt, false, pt);
 818 
 819                 AffineTransform at = tlc.getBaselineTransform();
 820                 if (at != null) {
 821                     AffineTransform tx = AffineTransform.getTranslateInstance
 822                         (pt.x - at.getTranslateX(), pt.y - at.getTranslateY());
 823                     tx.concatenate(at);
 824                     r = tx.createTransformedShape(r).getBounds2D();
 825                 } else {
 826                     r.setRect(r.getMinX() + pt.x, r.getMinY() + pt.y,
 827                               r.getWidth(), r.getHeight());
 828                 }
 829             }
 830 
 831             if (result == null) {
 832                 result = r;
 833             } else {
 834                 result.add(r);
 835             }
 836         }
 837 
 838         if (result == null) {
 839             result = new Rectangle2D.Float(Float.MAX_VALUE, Float.MAX_VALUE, Float.MIN_VALUE, Float.MIN_VALUE);
 840         }
 841 
 842         return result;
 843     }
 844 
 845     public Rectangle2D getItalicBounds() {
 846 
 847         float left = Float.MAX_VALUE, right = -Float.MAX_VALUE;
 848         float top = Float.MAX_VALUE, bottom = -Float.MAX_VALUE;
 849 
 850         for (int i=0, n = 0; i < fComponents.length; i++, n += 2) {
 851             TextLineComponent tlc = fComponents[getComponentLogicalIndex(i)];
 852 
 853             Rectangle2D tlcBounds = tlc.getItalicBounds();
 854             float x = locs[n];
 855             float y = locs[n+1];
 856 
 857             left = Math.min(left, x + (float)tlcBounds.getX());
 858             right = Math.max(right, x + (float)tlcBounds.getMaxX());
 859 
 860             top = Math.min(top, y + (float)tlcBounds.getY());
 861             bottom = Math.max(bottom, y + (float)tlcBounds.getMaxY());
 862         }
 863 
 864         return new Rectangle2D.Float(left, top, right-left, bottom-top);
 865     }
 866 
 867     public Shape getOutline(AffineTransform tx) {
 868 
 869         GeneralPath dstShape = new GeneralPath(GeneralPath.WIND_NON_ZERO);
 870 
 871         for (int i=0, n = 0; i < fComponents.length; i++, n += 2) {
 872             TextLineComponent tlc = fComponents[getComponentLogicalIndex(i)];
 873 
 874             dstShape.append(tlc.getOutline(locs[n], locs[n+1]), false);
 875         }
 876 
 877         if (tx != null) {
 878             dstShape.transform(tx);
 879         }
 880         return dstShape;
 881     }
 882 
 883     public int hashCode() {
 884         return (fComponents.length << 16) ^
 885                     (fComponents[0].hashCode() << 3) ^ (fCharsLimit-fCharsStart);
 886     }
 887 
 888     public String toString() {
 889         StringBuilder buf = new StringBuilder();
 890 
 891         for (int i = 0; i < fComponents.length; i++) {
 892             buf.append(fComponents[i]);
 893         }
 894 
 895         return buf.toString();
 896     }
 897 
 898     /**
 899      * Create a TextLine from the text.  The Font must be able to
 900      * display all of the text.
 901      * attributes==null is equivalent to using an empty Map for
 902      * attributes
 903      */
 904     public static TextLine fastCreateTextLine(FontRenderContext frc,
 905                                               char[] chars,
 906                                               Font font,
 907                                               CoreMetrics lm,
 908                                               Map<? extends Attribute, ?> attributes) {
 909 
 910         boolean isDirectionLTR = true;
 911         byte[] levels = null;
 912         int[] charsLtoV = null;
 913         Bidi bidi = null;
 914         int characterCount = chars.length;
 915 
 916         boolean requiresBidi = false;
 917         byte[] embs = null;
 918 
 919         AttributeValues values = null;
 920         if (attributes != null) {
 921             values = AttributeValues.fromMap(attributes);
 922             if (values.getRunDirection() >= 0) {
 923                 isDirectionLTR = values.getRunDirection() == 0;
 924                 requiresBidi = !isDirectionLTR;
 925             }
 926             if (values.getBidiEmbedding() != 0) {
 927                 requiresBidi = true;
 928                 byte level = (byte)values.getBidiEmbedding();
 929                 embs = new byte[characterCount];
 930                 for (int i = 0; i < embs.length; ++i) {
 931                     embs[i] = level;
 932                 }
 933             }
 934         }
 935 
 936         // dlf: get baseRot from font for now???
 937 
 938         if (!requiresBidi) {
 939             requiresBidi = Bidi.requiresBidi(chars, 0, chars.length);
 940         }
 941 
 942         if (requiresBidi) {
 943           int bidiflags = values == null
 944               ? Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT
 945               : values.getRunDirection();
 946 
 947           bidi = new Bidi(chars, 0, embs, 0, chars.length, bidiflags);
 948           if (!bidi.isLeftToRight()) {
 949               levels = BidiUtils.getLevels(bidi);
 950               int[] charsVtoL = BidiUtils.createVisualToLogicalMap(levels);
 951               charsLtoV = BidiUtils.createInverseMap(charsVtoL);
 952               isDirectionLTR = bidi.baseIsLeftToRight();
 953           }
 954         }
 955 
 956         Decoration decorator = Decoration.getDecoration(values);
 957 
 958         int layoutFlags = 0; // no extra info yet, bidi determines run and line direction
 959         TextLabelFactory factory = new TextLabelFactory(frc, chars, bidi, layoutFlags);
 960 
 961         TextLineComponent[] components = new TextLineComponent[1];
 962 
 963         components = createComponentsOnRun(0, chars.length,
 964                                            chars,
 965                                            charsLtoV, levels,
 966                                            factory, font, lm,
 967                                            frc,
 968                                            decorator,
 969                                            components,
 970                                            0);
 971 
 972         int numComponents = components.length;
 973         while (components[numComponents-1] == null) {
 974             numComponents -= 1;
 975         }
 976 
 977         if (numComponents != components.length) {
 978             TextLineComponent[] temp = new TextLineComponent[numComponents];
 979             System.arraycopy(components, 0, temp, 0, numComponents);
 980             components = temp;
 981         }
 982 
 983         return new TextLine(frc, components, lm.baselineOffsets,
 984                             chars, 0, chars.length, charsLtoV, levels, isDirectionLTR);
 985     }
 986 
 987     private static TextLineComponent[] expandArray(TextLineComponent[] orig) {
 988 
 989         TextLineComponent[] newComponents = new TextLineComponent[orig.length + 8];
 990         System.arraycopy(orig, 0, newComponents, 0, orig.length);
 991 
 992         return newComponents;
 993     }
 994 
 995     /**
 996      * Returns an array in logical order of the TextLineComponents on
 997      * the text in the given range, with the given attributes.
 998      */
 999     public static TextLineComponent[] createComponentsOnRun(int runStart,
1000                                                             int runLimit,
1001                                                             char[] chars,
1002                                                             int[] charsLtoV,
1003                                                             byte[] levels,
1004                                                             TextLabelFactory factory,
1005                                                             Font font,
1006                                                             CoreMetrics cm,
1007                                                             FontRenderContext frc,
1008                                                             Decoration decorator,
1009                                                             TextLineComponent[] components,
1010                                                             int numComponents) {
1011 
1012         int pos = runStart;
1013         do {
1014             int chunkLimit = firstVisualChunk(charsLtoV, levels, pos, runLimit); // <= displayLimit
1015 
1016             do {
1017                 int startPos = pos;
1018                 int lmCount;
1019 
1020                 if (cm == null) {
1021                     LineMetrics lineMetrics = font.getLineMetrics(chars, startPos, chunkLimit, frc);
1022                     cm = CoreMetrics.get(lineMetrics);
1023                     lmCount = lineMetrics.getNumChars();
1024                 }
1025                 else {
1026                     lmCount = (chunkLimit-startPos);
1027                 }
1028 
1029                 TextLineComponent nextComponent =
1030                     factory.createExtended(font, cm, decorator, startPos, startPos + lmCount);
1031 
1032                 ++numComponents;
1033                 if (numComponents >= components.length) {
1034                     components = expandArray(components);
1035                 }
1036 
1037                 components[numComponents-1] = nextComponent;
1038 
1039                 pos += lmCount;
1040             } while (pos < chunkLimit);
1041 
1042         } while (pos < runLimit);
1043 
1044         return components;
1045     }
1046 
1047     /**
1048      * Returns an array (in logical order) of the TextLineComponents representing
1049      * the text.  The components are both logically and visually contiguous.
1050      */
1051     public static TextLineComponent[] getComponents(StyledParagraph styledParagraph,
1052                                                     char[] chars,
1053                                                     int textStart,
1054                                                     int textLimit,
1055                                                     int[] charsLtoV,
1056                                                     byte[] levels,
1057                                                     TextLabelFactory factory) {
1058 
1059         FontRenderContext frc = factory.getFontRenderContext();
1060 
1061         int numComponents = 0;
1062         TextLineComponent[] tempComponents = new TextLineComponent[1];
1063 
1064         int pos = textStart;
1065         do {
1066             int runLimit = Math.min(styledParagraph.getRunLimit(pos), textLimit);
1067 
1068             Decoration decorator = styledParagraph.getDecorationAt(pos);
1069 
1070             Object graphicOrFont = styledParagraph.getFontOrGraphicAt(pos);
1071 
1072             if (graphicOrFont instanceof GraphicAttribute) {
1073                 // AffineTransform baseRot = styledParagraph.getBaselineRotationAt(pos);
1074                 // !!! For now, let's assign runs of text with both fonts and graphic attributes
1075                 // a null rotation (e.g. the baseline rotation goes away when a graphic
1076                 // is applied.
1077                 AffineTransform baseRot = null;
1078                 GraphicAttribute graphicAttribute = (GraphicAttribute) graphicOrFont;
1079                 do {
1080                     int chunkLimit = firstVisualChunk(charsLtoV, levels,
1081                                     pos, runLimit);
1082 
1083                     GraphicComponent nextGraphic =
1084                         new GraphicComponent(graphicAttribute, decorator, charsLtoV, levels, pos, chunkLimit, baseRot);
1085                     pos = chunkLimit;
1086 
1087                     ++numComponents;
1088                     if (numComponents >= tempComponents.length) {
1089                         tempComponents = expandArray(tempComponents);
1090                     }
1091 
1092                     tempComponents[numComponents-1] = nextGraphic;
1093 
1094                 } while(pos < runLimit);
1095             }
1096             else {
1097                 Font font = (Font) graphicOrFont;
1098 
1099                 tempComponents = createComponentsOnRun(pos, runLimit,
1100                                                         chars,
1101                                                         charsLtoV, levels,
1102                                                         factory, font, null,
1103                                                         frc,
1104                                                         decorator,
1105                                                         tempComponents,
1106                                                         numComponents);
1107                 pos = runLimit;
1108                 numComponents = tempComponents.length;
1109                 while (tempComponents[numComponents-1] == null) {
1110                     numComponents -= 1;
1111                 }
1112             }
1113 
1114         } while (pos < textLimit);
1115 
1116         TextLineComponent[] components;
1117         if (tempComponents.length == numComponents) {
1118             components = tempComponents;
1119         }
1120         else {
1121             components = new TextLineComponent[numComponents];
1122             System.arraycopy(tempComponents, 0, components, 0, numComponents);
1123         }
1124 
1125         return components;
1126     }
1127 
1128     /**
1129      * Create a TextLine from the Font and character data over the
1130      * range.  The range is relative to both the StyledParagraph and the
1131      * character array.
1132      */
1133     public static TextLine createLineFromText(char[] chars,
1134                                               StyledParagraph styledParagraph,
1135                                               TextLabelFactory factory,
1136                                               boolean isDirectionLTR,
1137                                               float[] baselineOffsets) {
1138 
1139         factory.setLineContext(0, chars.length);
1140 
1141         Bidi lineBidi = factory.getLineBidi();
1142         int[] charsLtoV = null;
1143         byte[] levels = null;
1144 
1145         if (lineBidi != null) {
1146             levels = BidiUtils.getLevels(lineBidi);
1147             int[] charsVtoL = BidiUtils.createVisualToLogicalMap(levels);
1148             charsLtoV = BidiUtils.createInverseMap(charsVtoL);
1149         }
1150 
1151         TextLineComponent[] components =
1152             getComponents(styledParagraph, chars, 0, chars.length, charsLtoV, levels, factory);
1153 
1154         return new TextLine(factory.getFontRenderContext(), components, baselineOffsets,
1155                             chars, 0, chars.length, charsLtoV, levels, isDirectionLTR);
1156     }
1157 
1158     /**
1159      * Compute the components order from the given components array and
1160      * logical-to-visual character mapping.  May return null if canonical.
1161      */
1162     private static int[] computeComponentOrder(TextLineComponent[] components,
1163                                                int[] charsLtoV) {
1164 
1165         /*
1166          * Create a visual ordering for the glyph sets.  The important thing
1167          * here is that the values have the proper rank with respect to
1168          * each other, not the exact values.  For example, the first glyph
1169          * set that appears visually should have the lowest value.  The last
1170          * should have the highest value.  The values are then normalized
1171          * to map 1-1 with positions in glyphs.
1172          *
1173          */
1174         int[] componentOrder = null;
1175         if (charsLtoV != null && components.length > 1) {
1176             componentOrder = new int[components.length];
1177             int gStart = 0;
1178             for (int i = 0; i < components.length; i++) {
1179                 componentOrder[i] = charsLtoV[gStart];
1180                 gStart += components[i].getNumCharacters();
1181             }
1182 
1183             componentOrder = BidiUtils.createContiguousOrder(componentOrder);
1184             componentOrder = BidiUtils.createInverseMap(componentOrder);
1185         }
1186         return componentOrder;
1187     }
1188 
1189 
1190     /**
1191      * Create a TextLine from the text.  chars is just the text in the iterator.
1192      */
1193     public static TextLine standardCreateTextLine(FontRenderContext frc,
1194                                                   AttributedCharacterIterator text,
1195                                                   char[] chars,
1196                                                   float[] baselineOffsets) {
1197 
1198         StyledParagraph styledParagraph = new StyledParagraph(text, chars);
1199         Bidi bidi = new Bidi(text);
1200         if (bidi.isLeftToRight()) {
1201             bidi = null;
1202         }
1203         int layoutFlags = 0; // no extra info yet, bidi determines run and line direction
1204         TextLabelFactory factory = new TextLabelFactory(frc, chars, bidi, layoutFlags);
1205 
1206         boolean isDirectionLTR = true;
1207         if (bidi != null) {
1208             isDirectionLTR = bidi.baseIsLeftToRight();
1209         }
1210         return createLineFromText(chars, styledParagraph, factory, isDirectionLTR, baselineOffsets);
1211     }
1212 
1213 
1214 
1215     /*
1216      * A utility to get a range of text that is both logically and visually
1217      * contiguous.
1218      * If the entire range is ok, return limit, otherwise return the first
1219      * directional change after start.  We could do better than this, but
1220      * it doesn't seem worth it at the moment.
1221     private static int firstVisualChunk(int order[], byte direction[],
1222                                         int start, int limit)
1223     {
1224         if (order != null) {
1225             int min = order[start];
1226             int max = order[start];
1227             int count = limit - start;
1228             for (int i = start + 1; i < limit; i++) {
1229                 min = Math.min(min, order[i]);
1230                 max = Math.max(max, order[i]);
1231                 if (max - min >= count) {
1232                     if (direction != null) {
1233                         byte baseLevel = direction[start];
1234                         for (int j = start + 1; j < i; j++) {
1235                             if (direction[j] != baseLevel) {
1236                                 return j;
1237                             }
1238                         }
1239                     }
1240                     return i;
1241                 }
1242             }
1243         }
1244         return limit;
1245     }
1246      */
1247 
1248     /**
1249      * When this returns, the ACI's current position will be at the start of the
1250      * first run which does NOT contain a GraphicAttribute.  If no such run exists
1251      * the ACI's position will be at the end, and this method will return false.
1252      */
1253     static boolean advanceToFirstFont(AttributedCharacterIterator aci) {
1254 
1255         for (char ch = aci.first();
1256              ch != CharacterIterator.DONE;
1257              ch = aci.setIndex(aci.getRunLimit()))
1258         {
1259 
1260             if (aci.getAttribute(TextAttribute.CHAR_REPLACEMENT) == null) {
1261                 return true;
1262             }
1263         }
1264 
1265         return false;
1266     }
1267 
1268     static float[] getNormalizedOffsets(float[] baselineOffsets, byte baseline) {
1269 
1270         if (baselineOffsets[baseline] != 0) {
1271             float base = baselineOffsets[baseline];
1272             float[] temp = new float[baselineOffsets.length];
1273             for (int i = 0; i < temp.length; i++)
1274                 temp[i] = baselineOffsets[i] - base;
1275             baselineOffsets = temp;
1276         }
1277         return baselineOffsets;
1278     }
1279 
1280     static Font getFontAtCurrentPos(AttributedCharacterIterator aci) {
1281 
1282         Object value = aci.getAttribute(TextAttribute.FONT);
1283         if (value != null) {
1284             return (Font) value;
1285         }
1286         if (aci.getAttribute(TextAttribute.FAMILY) != null) {
1287             return Font.getFont(aci.getAttributes());
1288         }
1289 
1290         int ch = CodePointIterator.create(aci).next();
1291         if (ch != CodePointIterator.DONE) {
1292             FontResolver resolver = FontResolver.getInstance();
1293             return resolver.getFont(resolver.getFontIndex(ch), aci.getAttributes());
1294         }
1295         return null;
1296     }
1297 
1298   /*
1299    * The new version requires that chunks be at the same level.
1300    */
1301     private static int firstVisualChunk(int order[], byte direction[],
1302                                         int start, int limit)
1303     {
1304         if (order != null && direction != null) {
1305           byte dir = direction[start];
1306           while (++start < limit && direction[start] == dir) {}
1307           return start;
1308         }
1309         return limit;
1310     }
1311 
1312   /*
1313    * create a new line with characters between charStart and charLimit
1314    * justified using the provided width and ratio.
1315    */
1316     public TextLine getJustifiedLine(float justificationWidth, float justifyRatio, int justStart, int justLimit) {
1317 
1318         TextLineComponent[] newComponents = new TextLineComponent[fComponents.length];
1319         System.arraycopy(fComponents, 0, newComponents, 0, fComponents.length);
1320 
1321         float leftHang = 0;
1322         float adv = 0;
1323         float justifyDelta = 0;
1324         boolean rejustify = false;
1325         do {
1326             adv = getAdvanceBetween(newComponents, 0, characterCount());
1327 
1328             // all characters outside the justification range must be in the base direction
1329             // of the layout, otherwise justification makes no sense.
1330 
1331             float justifyAdvance = getAdvanceBetween(newComponents, justStart, justLimit);
1332 
1333             // get the actual justification delta
1334             justifyDelta = (justificationWidth - justifyAdvance) * justifyRatio;
1335 
1336             // generate an array of GlyphJustificationInfo records to pass to
1337             // the justifier.  Array is visually ordered.
1338 
1339             // get positions that each component will be using
1340             int[] infoPositions = new int[newComponents.length];
1341             int infoCount = 0;
1342             for (int visIndex = 0; visIndex < newComponents.length; visIndex++) {
1343                     int logIndex = getComponentLogicalIndex(visIndex);
1344                 infoPositions[logIndex] = infoCount;
1345                 infoCount += newComponents[logIndex].getNumJustificationInfos();
1346             }
1347             GlyphJustificationInfo[] infos = new GlyphJustificationInfo[infoCount];
1348 
1349             // get justification infos
1350             int compStart = 0;
1351             for (int i = 0; i < newComponents.length; i++) {
1352                 TextLineComponent comp = newComponents[i];
1353                 int compLength = comp.getNumCharacters();
1354                 int compLimit = compStart + compLength;
1355                 if (compLimit > justStart) {
1356                     int rangeMin = Math.max(0, justStart - compStart);
1357                     int rangeMax = Math.min(compLength, justLimit - compStart);
1358                     comp.getJustificationInfos(infos, infoPositions[i], rangeMin, rangeMax);
1359 
1360                     if (compLimit >= justLimit) {
1361                         break;
1362                     }
1363                 }
1364             }
1365 
1366             // records are visually ordered, and contiguous, so start and end are
1367             // simply the places where we didn't fetch records
1368             int infoStart = 0;
1369             int infoLimit = infoCount;
1370             while (infoStart < infoLimit && infos[infoStart] == null) {
1371                 ++infoStart;
1372             }
1373 
1374             while (infoLimit > infoStart && infos[infoLimit - 1] == null) {
1375                 --infoLimit;
1376             }
1377 
1378             // invoke justifier on the records
1379             TextJustifier justifier = new TextJustifier(infos, infoStart, infoLimit);
1380 
1381             float[] deltas = justifier.justify(justifyDelta);
1382 
1383             boolean canRejustify = rejustify == false;
1384             boolean wantRejustify = false;
1385             boolean[] flags = new boolean[1];
1386 
1387             // apply justification deltas
1388             compStart = 0;
1389             for (int i = 0; i < newComponents.length; i++) {
1390                 TextLineComponent comp = newComponents[i];
1391                 int compLength = comp.getNumCharacters();
1392                 int compLimit = compStart + compLength;
1393                 if (compLimit > justStart) {
1394                     int rangeMin = Math.max(0, justStart - compStart);
1395                     int rangeMax = Math.min(compLength, justLimit - compStart);
1396                     newComponents[i] = comp.applyJustificationDeltas(deltas, infoPositions[i] * 2, flags);
1397 
1398                     wantRejustify |= flags[0];
1399 
1400                     if (compLimit >= justLimit) {
1401                         break;
1402                     }
1403                 }
1404             }
1405 
1406             rejustify = wantRejustify && !rejustify; // only make two passes
1407         } while (rejustify);
1408 
1409         return new TextLine(frc, newComponents, fBaselineOffsets, fChars, fCharsStart,
1410                             fCharsLimit, fCharLogicalOrder, fCharLevels,
1411                             fIsDirectionLTR);
1412     }
1413 
1414     // return the sum of the advances of text between the logical start and limit
1415     public static float getAdvanceBetween(TextLineComponent[] components, int start, int limit) {
1416         float advance = 0;
1417 
1418         int tlcStart = 0;
1419         for(int i = 0; i < components.length; i++) {
1420             TextLineComponent comp = components[i];
1421 
1422             int tlcLength = comp.getNumCharacters();
1423             int tlcLimit = tlcStart + tlcLength;
1424             if (tlcLimit > start) {
1425                 int measureStart = Math.max(0, start - tlcStart);
1426                 int measureLimit = Math.min(tlcLength, limit - tlcStart);
1427                 advance += comp.getAdvanceBetween(measureStart, measureLimit);
1428                 if (tlcLimit >= limit) {
1429                     break;
1430                 }
1431             }
1432 
1433             tlcStart = tlcLimit;
1434         }
1435 
1436         return advance;
1437     }
1438 
1439     LayoutPathImpl getLayoutPath() {
1440         return lp;
1441     }
1442 }