gt:     for(int i = 0; i < runs.length - 1; i++)
context: /* TextLayout.java --
     Copyright (C) 2006  Free Software Foundation, Inc.
  
  This file is part of GNU Classpath.
  
  GNU Classpath is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2, or (at your option)
  any later version.
  
  GNU Classpath 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 for more details.
  
  You should have received a copy of the GNU General Public License
  along with GNU Classpath; see the file COPYING.  If not, write to the
  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301 USA.
  
  Linking this library statically or dynamically with other modules is
  making a combined work based on this library.  Thus, the terms and
  conditions of the GNU General Public License cover the whole
  combination.
  
  As a special exception, the copyright holders of this library give you
  permission to link this library with independent modules to produce an
  executable, regardless of the license terms of these independent
  modules, and to copy and distribute the resulting executable under
  terms of your choice, provided that you also meet, for each linked
  independent module, the terms and conditions of the license of that
  module.  An independent module is a module which is not derived from
  or based on this library.  If you modify this library, you may extend
  this exception to your version of the library, but you are not
  obligated to do so.  If you do not wish to do so, delete this
  exception statement from your version. */
  
  
  package java.awt.font;
  
  import gnu.java.lang.CPStringBuilder;
  
  import java.awt.Font;
  import java.awt.Graphics2D;
  import java.awt.Shape;
  import java.awt.geom.AffineTransform;
  import java.awt.geom.Line2D;
  import java.awt.geom.Rectangle2D;
  import java.awt.geom.GeneralPath;
  import java.awt.geom.Point2D;
  import java.text.CharacterIterator;
  import java.text.AttributedCharacterIterator;
  import java.text.Bidi;
  import java.util.ArrayList;
  import java.util.Map;
  
  /**
   * @author Sven de Marothy
   */
  public final class TextLayout implements Cloneable
  {
    /**
     * Holds the layout data that belongs to one run of characters.
     */
    private class Run
    {
      /**
       * The actual glyph vector.
       */
      GlyphVector glyphVector;
  
      /**
       * The font for this text run.
       */
      Font font;
  
      /**
       * The start of the run.
       */
      int runStart;
  
      /**
       * The end of the run.
       */
      int runEnd;
  
      /**
       * The layout location of the beginning of the run.
       */
      float location;
  
      /**
       * Initializes the Run instance.
       *
       * @param gv the glyph vector
       * @param start the start index of the run
       * @param end the end index of the run
       */
      Run(GlyphVector gv, Font f, int start, int end)
      {
        glyphVector = gv;
        font = f;
        runStart = start;
        runEnd = end;
      }
  
      /**
       * Returns <code>true</code> when this run is left to right,
       * <code>false</code> otherwise.
       *
       * @return <code>true</code> when this run is left to right,
       *         <code>false</code> otherwise
       */
      boolean isLeftToRight()
      {
        return (glyphVector.getLayoutFlags() & GlyphVector.FLAG_RUN_RTL) == 0;
      }
    }
  
    /**
     * The laid out character runs.
     */
    private Run[] runs;
  
    private FontRenderContext frc;
    private char[] string;
    private int offset;
    private int length;
    private Rectangle2D boundsCache;
    private LineMetrics lm;
  
    /**
     * The total advance of this text layout. This is cache for maximum
     * performance.
     */
    private float totalAdvance = -1F;
  
    /**
     * The cached natural bounds.
     */
    private Rectangle2D naturalBounds;
  
    /**
     * Character indices.
     * Fixt index is the glyphvector, second index is the (first) glyph.
     */
    private int[][] charIndices;
  
    /**
     * Base directionality, determined from the first char.
     */
    private boolean leftToRight;
  
    /**
     * Whether this layout contains whitespace or not.
     */
    private boolean hasWhitespace = false;
  
    /**
     * The {@link Bidi} object that is used for reordering and by
     * {@link #getCharacterLevel(int)}.
     */
    private Bidi bidi;
  
    /**
     * Mpas the logical position of each individual character in the original
     * string to its visual position.
     */
    private int[] logicalToVisual;
  
    /**
     * Maps visual positions of a character to its logical position
     * in the original string.
     */
    private int[] visualToLogical;
  
    /**
     * The cached hashCode.
     */
    private int hash;
  
    /**
     * The default caret policy.
     */
    public static final TextLayout.CaretPolicy DEFAULT_CARET_POLICY =
      new CaretPolicy();
  
    /**
     * Constructs a TextLayout.
     */
    public TextLayout (String str, Font font, FontRenderContext frc)
    {
      this.frc = frc;
      string = str.toCharArray();
      offset = 0;
      length = this.string.length;
      lm = font.getLineMetrics(this.string, offset, length, frc);
  
      // Get base direction and whitespace info
      getStringProperties();
  
      if (Bidi.requiresBidi(string, offset, offset + length))
        {
          bidi = new Bidi(str, leftToRight ? Bidi.DIRECTION_LEFT_TO_RIGHT
                                           : Bidi.DIRECTION_RIGHT_TO_LEFT );
          int rc = bidi.getRunCount();
          byte[] table = new byte[ rc ];
          for(int i = 0; i < table.length; i++)
            table[i] = (byte)bidi.getRunLevel(i);
  
          runs = new Run[rc];
          for(int i = 0; i < rc; i++)
            {
              int start = bidi.getRunStart(i);
              int end = bidi.getRunLimit(i);
              if(start != end) // no empty runs.
                {
                  GlyphVector gv = font.layoutGlyphVector(frc,
                                                          string, start, end,
                             ((table[i] & 1) == 0) ? Font.LAYOUT_LEFT_TO_RIGHT
                                                   : Font.LAYOUT_RIGHT_TO_LEFT );
                  runs[i] = new Run(gv, font, start, end);
                }
            }
          Bidi.reorderVisually( table, 0, runs, 0, runs.length );
          // Clean up null runs.
          ArrayList cleaned = new ArrayList(rc);
          for (int i = 0; i < rc; i++)
            {
              if (runs[i] != null)
                cleaned.add(runs[i]);
            }
          runs = new Run[cleaned.size()];
          runs = (Run[]) cleaned.toArray(runs);
        }
      else
        {
          GlyphVector gv = font.layoutGlyphVector( frc, string, offset, length,
                                       leftToRight ? Font.LAYOUT_LEFT_TO_RIGHT
                                                   : Font.LAYOUT_RIGHT_TO_LEFT );
          Run run = new Run(gv, font, 0, length);
          runs = new Run[]{ run };
        }
      setCharIndices();
      setupMappings();
      layoutRuns();
    }
  
    public TextLayout (String string,
                       Map<? extends AttributedCharacterIterator.Attribute, ?> attributes,
                       FontRenderContext frc)
    {
      this( string, new Font( attributes ), frc );
    }
  
    public TextLayout (AttributedCharacterIterator text, FontRenderContext frc)
    {
      // FIXME: Very rudimentary.
      this(getText(text), getFont(text), frc);
    }
  
    /**
     * Package-private constructor to make a textlayout from an existing one.
     * This is used by TextMeasurer for returning sub-layouts, and it
     * saves a lot of time in not having to relayout the text.
     */
    TextLayout(TextLayout t, int startIndex, int endIndex)
    {
      frc = t.frc;
      boundsCache = null;
      lm = t.lm;
      leftToRight = t.leftToRight;
  
      if( endIndex > t.getCharacterCount() )
        endIndex = t.getCharacterCount();
      string = t.string;
      offset = startIndex + offset;
      length = endIndex - startIndex;
  
      int startingRun = t.charIndices[startIndex][0];
      int nRuns = 1 + t.charIndices[endIndex - 1][0] - startingRun;
  
      runs = new Run[nRuns];
      for( int i = 0; i < nRuns; i++ )
        {
          Run run = t.runs[i + startingRun];
          GlyphVector gv = run.glyphVector;
          Font font = run.font;
          // Copy only the relevant parts of the first and last runs.
          int beginGlyphIndex = (i > 0) ? 0 : t.charIndices[startIndex][1];
          int numEntries = ( i < nRuns - 1) ? gv.getNumGlyphs() :
            1 + t.charIndices[endIndex - 1][1] - beginGlyphIndex;
  
          int[] codes = gv.getGlyphCodes(beginGlyphIndex, numEntries, null);
          gv = font.createGlyphVector(frc, codes);
          runs[i] = new Run(gv, font, run.runStart - startIndex,
                            run.runEnd - startIndex);
        }
      runs[nRuns - 1].runEnd = endIndex - 1;
  
      setCharIndices();
      setupMappings();
      determineWhiteSpace();
      layoutRuns();
    }
  
    private void setCharIndices()
    {
      charIndices = new int[ getCharacterCount() ][2];
      int i = 0;
      int currentChar = 0;
      for(int run = 0; run < runs.length; run++)
        {
          currentChar = -1;
          Run current = runs[run];
          GlyphVector gv = current.glyphVector;
          for( int gi = 0; gi < gv.getNumGlyphs(); gi++)
            {
              if( gv.getGlyphCharIndex( gi ) != currentChar )
                {
                  charIndices[ i ][0] = run;
                  charIndices[ i ][1] = gi;
                  currentChar = gv.getGlyphCharIndex( gi );
                  i++;
                }
            }
        }
    }
  
    /**
     * Initializes the logicalToVisual and visualToLogial maps.
     */
    private void setupMappings()
    {
      int numChars = getCharacterCount();
      logicalToVisual = new int[numChars];
      visualToLogical = new int[numChars];
      int lIndex = 0;
      int vIndex = 0;
      // We scan the runs in visual order and set the mappings accordingly.
      for (int i = 0; i < runs.length; i++)
        {
          Run run = runs[i];
          if (run.isLeftToRight())
            {
              for (lIndex = run.runStart; lIndex < run.runEnd; lIndex++)
                {
                  logicalToVisual[lIndex] = vIndex;
                  visualToLogical[vIndex] = lIndex;
                  vIndex++;
                }
            }
          else
            {
              for (lIndex = run.runEnd - 1; lIndex >= run.runStart; lIndex--)
                {
                  logicalToVisual[lIndex] = vIndex;
                  visualToLogical[vIndex] = lIndex;
                  vIndex++;
                }
            }
        }
    }
  
    private static String getText(AttributedCharacterIterator iter)
    {
      CPStringBuilder sb = new CPStringBuilder();
      int idx = iter.getIndex();
      for(char c = iter.first(); c != CharacterIterator.DONE; c = iter.next())
        sb.append(c);
      iter.setIndex( idx );
      return sb.toString();
    }
  
    private static Font getFont(AttributedCharacterIterator iter)
    {
      Font f = (Font)iter.getAttribute(TextAttribute.FONT);
      if( f == null )
        {
          int size;
          Float i = (Float)iter.getAttribute(TextAttribute.SIZE);
          if( i != null )
            size = (int)i.floatValue();
          else
            size = 14;
          f = new Font("Dialog", Font.PLAIN, size );
        }
      return f;
    }
  
    /**
     * Scan the character run for the first strongly directional character,
     * which in turn defines the base directionality of the whole layout.
     */
    private void getStringProperties()
    {
      boolean gotDirection = false;
      int i = offset;
      int endOffs = offset + length;
      leftToRight = true;
      while( i < endOffs && !gotDirection )
        switch( Character.getDirectionality(string[i++]) )
          {
          case Character.DIRECTIONALITY_LEFT_TO_RIGHT:
          case Character.DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING:
          case Character.DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE:
            gotDirection = true;
            break;
  
          case Character.DIRECTIONALITY_RIGHT_TO_LEFT:
          case Character.DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC:
          case Character.DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING:
          case Character.DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE:
            leftToRight = false;
            gotDirection = true;
            break;
          }
      determineWhiteSpace();
    }
  
    private void determineWhiteSpace()
    {
      // Determine if there's whitespace in the thing.
      // Ignore trailing chars.
      int i = offset + length - 1;
      hasWhitespace = false;
      while( i >= offset && Character.isWhitespace( string[i] ) )
        i--;
      // Check the remaining chars
      while( i >= offset )
        if( Character.isWhitespace( string[i--] ) )
          hasWhitespace = true;
    }
  
    protected Object clone ()
    {
      return new TextLayout( this, 0, length);
    }
  
    public void draw (Graphics2D g2, float x, float y)
    {
      for(int i = 0; i < runs.length; i++)
        {
          Run run = runs[i];
          GlyphVector gv = run.glyphVector;
          g2.drawGlyphVector(gv, x, y);
          Rectangle2D r = gv.getLogicalBounds();
          x += r.getWidth();
        }
    }
  
    public boolean equals (Object obj)
    {
      if( !( obj instanceof TextLayout) )
        return false;
  
      return equals( (TextLayout) obj );
    }
  
    public boolean equals (TextLayout tl)
    {
      if( runs.length != tl.runs.length )
        return false;
      // Compare all glyph vectors.
      for( int i = 0; i < runs.length; i++ )
        if( !runs[i].equals( tl.runs[i] ) )
          return false;
      return true;
    }
  
    public float getAdvance ()
    {
      if (totalAdvance == -1F)
        {
          totalAdvance = 0f;
          for(int i = 0; i < runs.length; i++)
            {
              Run run = runs[i];
              GlyphVector gv = run.glyphVector;
              totalAdvance += gv.getLogicalBounds().getWidth();
            }
        }
      return totalAdvance;
    }
  
    public float getAscent ()
    {
      return lm.getAscent();
    }
  
    public byte getBaseline ()
    {
      return (byte)lm.getBaselineIndex();
    }
  
    public float[] getBaselineOffsets ()
    {
      return lm.getBaselineOffsets();
    }
  
    public Shape getBlackBoxBounds (int firstEndpoint, int secondEndpoint)
    {
      if( secondEndpoint - firstEndpoint <= 0 )
        return new Rectangle2D.Float(); // Hmm?
  
      if( firstEndpoint < 0 || secondEndpoint > getCharacterCount())
        return new Rectangle2D.Float();
  
      GeneralPath gp = new GeneralPath();
  
      int ri = charIndices[ firstEndpoint ][0];
      int gi = charIndices[ firstEndpoint ][1];
  
      double advance = 0;
  
      for( int i = 0; i < ri; i++ )
        {
          Run run = runs[i];
          GlyphVector gv = run.glyphVector;
          advance += gv.getLogicalBounds().getWidth();
        }
  
      for( int i = ri; i <= charIndices[ secondEndpoint - 1 ][0]; i++ )
        {
          Run run = runs[i];
          GlyphVector gv = run.glyphVector;
          int dg;
          if( i == charIndices[ secondEndpoint - 1 ][0] )
            dg = charIndices[ secondEndpoint - 1][1];
          else
            dg = gv.getNumGlyphs() - 1;
  
          for( int j = 0; j <= dg; j++ )
            {
              Rectangle2D r2 = (gv.getGlyphVisualBounds( j )).
                getBounds2D();
              Point2D p = gv.getGlyphPosition( j );
              r2.setRect( advance + r2.getX(), r2.getY(),
                          r2.getWidth(), r2.getHeight() );
              gp.append(r2, false);
            }
  
          advance += gv.getLogicalBounds().getWidth();
        }
      return gp;
    }
  
    public Rectangle2D getBounds()
    {
      if( boundsCache == null )
        boundsCache = getOutline(new AffineTransform()).getBounds();
      return boundsCache;
    }
  
    public float[] getCaretInfo (TextHitInfo hit)
    {
      return getCaretInfo(hit, getNaturalBounds());
    }
  
    public float[] getCaretInfo (TextHitInfo hit, Rectangle2D bounds)
    {
      float[] info = new float[2];
      int index = hit.getCharIndex();
      boolean leading = hit.isLeadingEdge();
      // For the boundary cases we return the boundary runs.
      Run run;
  
      if (index >= length)
        {
          info[0] = getAdvance();
          info[1] = 0;
        }
      else
        {
          if (index < 0)
            {
              run = runs[0];
              index = 0;
              leading = true;
            }
          else
            run = findRunAtIndex(index);
  
          int glyphIndex = index - run.runStart;
          Shape glyphBounds = run.glyphVector.getGlyphLogicalBounds(glyphIndex);
          Rectangle2D glyphRect = glyphBounds.getBounds2D();
          if (isVertical())
            {
              if (leading)
                info[0] = (float) glyphRect.getMinY();
              else
                info[0] = (float) glyphRect.getMaxY();
            }
          else
            {
              if (leading)
                info[0] = (float) glyphRect.getMinX();
              else
                info[0] = (float) glyphRect.getMaxX();
            }
          info[0] += run.location;
          info[1] = run.font.getItalicAngle();
        }
      return info;
    }
  
    public Shape getCaretShape(TextHitInfo hit)
    {
      return getCaretShape(hit, getBounds());
    }
  
    public Shape getCaretShape(TextHitInfo hit, Rectangle2D bounds)
    {
      // TODO: Handle vertical shapes somehow.
      float[] info = getCaretInfo(hit);
      float x1 = info[0];
      float y1 = (float) bounds.getMinY();
      float x2 = info[0];
      float y2 = (float) bounds.getMaxY();
      if (info[1] != 0)
        {
          // Shift x1 and x2 according to the slope.
          x1 -= y1 * info[1];
          x2 -= y2 * info[1];
        }
      GeneralPath path = new GeneralPath(GeneralPath.WIND_EVEN_ODD, 2);
      path.moveTo(x1, y1);
      path.lineTo(x2, y2);
      return path;
    }
  
    public Shape[] getCaretShapes(int offset)
    {
      return getCaretShapes(offset, getNaturalBounds());
    }
  
    public Shape[] getCaretShapes(int offset, Rectangle2D bounds)
    {
      return getCaretShapes(offset, bounds, DEFAULT_CARET_POLICY);
    }
  
    public Shape[] getCaretShapes(int offset, Rectangle2D bounds,
                                  CaretPolicy policy)
    {
      // The RI returns a 2-size array even when there's only one
      // shape in it.
      Shape[] carets = new Shape[2];
      TextHitInfo hit1 = TextHitInfo.afterOffset(offset);
      int caretHit1 = hitToCaret(hit1);
      TextHitInfo hit2 = hit1.getOtherHit();
      int caretHit2 = hitToCaret(hit2);
      if (caretHit1 == caretHit2)
        {
          carets[0] = getCaretShape(hit1);
          carets[1] = null; // The RI returns null in this seldom case.
        }
      else
        {
          Shape caret1 = getCaretShape(hit1);
          Shape caret2 = getCaretShape(hit2);
          TextHitInfo strong = policy.getStrongCaret(hit1, hit2, this);
          if (strong == hit1)
            {
              carets[0] = caret1;
              carets[1] = caret2;
            }
          else
            {
              carets[0] = caret2;
              carets[1] = caret1;
            }
        }
      return carets;
    }
  
    public int getCharacterCount ()
    {
      return length;
    }
  
    public byte getCharacterLevel (int index)
    {
      byte level;
      if( bidi == null )
        level = 0;
      else
        level = (byte) bidi.getLevelAt(index);
      return level;
    }
  
    public float getDescent ()
    {
      return lm.getDescent();
    }
  
    public TextLayout getJustifiedLayout (float justificationWidth)
    {
      TextLayout newLayout = (TextLayout)clone();
  
      if( hasWhitespace )
        newLayout.handleJustify( justificationWidth );
  
      return newLayout;
    }
  
    public float getLeading ()
    {
      return lm.getLeading();
    }
  
    public Shape getLogicalHighlightShape (int firstEndpoint, int secondEndpoint)
    {
      return getLogicalHighlightShape( firstEndpoint, secondEndpoint,
                                       getBounds() );
    }
  
    public Shape getLogicalHighlightShape (int firstEndpoint, int secondEndpoint,
                                           Rectangle2D bounds)
    {
      if( secondEndpoint - firstEndpoint <= 0 )
        return new Rectangle2D.Float(); // Hmm?
  
      if( firstEndpoint < 0 || secondEndpoint > getCharacterCount())
        return new Rectangle2D.Float();
  
      Rectangle2D r = null;
      int ri = charIndices[ firstEndpoint ][0];
      int gi = charIndices[ firstEndpoint ][1];
  
      double advance = 0;
  
      for( int i = 0; i < ri; i++ )
        advance += runs[i].glyphVector.getLogicalBounds().getWidth();
  
      for( int i = ri; i <= charIndices[ secondEndpoint - 1 ][0]; i++ )
        {
          Run run = runs[i];
          GlyphVector gv = run.glyphVector;
          int dg; // last index in this run to use.
          if( i == charIndices[ secondEndpoint - 1 ][0] )
            dg = charIndices[ secondEndpoint - 1][1];
          else
            dg = gv.getNumGlyphs() - 1;
  
          for(; gi <= dg; gi++ )
            {
              Rectangle2D r2 = (gv.getGlyphLogicalBounds( gi )).
                getBounds2D();
              if( r == null )
                r = r2;
              else
                r = r.createUnion(r2);
            }
          gi = 0; // reset glyph index into run for next run.
  
          advance += gv.getLogicalBounds().getWidth();
        }
  
      return r;
    }
  
    public int[] getLogicalRangesForVisualSelection (TextHitInfo firstEndpoint,
                                                     TextHitInfo secondEndpoint)
    {
      // Check parameters.
      checkHitInfo(firstEndpoint);
      checkHitInfo(secondEndpoint);
  
      // Convert to visual and order correctly.
      int start = hitToCaret(firstEndpoint);
      int end = hitToCaret(secondEndpoint);
      if (start > end)
        {
          // Swap start and end so that end >= start.
          int temp = start;
          start = end;
          end = temp;
        }
  
      // Now walk through the visual indices and mark the included pieces.
      boolean[] include = new boolean[length];
      for (int i = start; i < end; i++)
        {
          include[visualToLogical[i]] = true;
        }
  
      // Count included runs.
      int numRuns = 0;
      boolean in = false;
      for (int i = 0; i < length; i++)
        {
          if (include[i] != in) // At each run in/out point we toggle the in var.
            {
              in = ! in;
              if (in) // At each run start we count up.
                numRuns++;
            }
        }
  
      // Put together the ranges array.
      int[] ranges = new int[numRuns * 2];
      int index = 0;
      in = false;
      for (int i = 0; i < length; i++)
        {
          if (include[i] != in)
            {
              ranges[index] = i;
              index++;
              in = ! in;
            }
        }
      // If the last run ends at the very end, include that last bit too.
      if (in)
        ranges[index] = length;
  
      return ranges;
    }
  
    public TextHitInfo getNextLeftHit(int offset)
    {
      return getNextLeftHit(offset, DEFAULT_CARET_POLICY);
    }
  
    public TextHitInfo getNextLeftHit(int offset, CaretPolicy policy)
    {
      if (policy == null)
        throw new IllegalArgumentException("Null policy not allowed");
      if (offset < 0 || offset > length)
        throw new IllegalArgumentException("Offset out of bounds");
  
      TextHitInfo hit1 = TextHitInfo.afterOffset(offset);
      TextHitInfo hit2 = hit1.getOtherHit();
  
      TextHitInfo strong = policy.getStrongCaret(hit1, hit2, this);
      TextHitInfo next = getNextLeftHit(strong);
      TextHitInfo ret = null;
      if (next != null)
        {
          TextHitInfo next2 = getVisualOtherHit(next);
          ret = policy.getStrongCaret(next2, next, this);
        }
      return ret;
    }
  
    public TextHitInfo getNextLeftHit (TextHitInfo hit)
    {
      checkHitInfo(hit);
      int index = hitToCaret(hit);
      TextHitInfo next = null;
      if (index != 0)
        {
          index--;
          next = caretToHit(index);
        }
      return next;
    }
  
    public TextHitInfo getNextRightHit(int offset)
    {
      return getNextRightHit(offset, DEFAULT_CARET_POLICY);
    }
  
    public TextHitInfo getNextRightHit(int offset, CaretPolicy policy)
    {
      if (policy == null)
        throw new IllegalArgumentException("Null policy not allowed");
      if (offset < 0 || offset > length)
        throw new IllegalArgumentException("Offset out of bounds");
  
      TextHitInfo hit1 = TextHitInfo.afterOffset(offset);
      TextHitInfo hit2 = hit1.getOtherHit();
  
      TextHitInfo next = getNextRightHit(policy.getStrongCaret(hit1, hit2, this));
      TextHitInfo ret = null;
      if (next != null)
        {
          TextHitInfo next2 = getVisualOtherHit(next);
          ret = policy.getStrongCaret(next2, next, this);
        }
      return ret;
    }
  
    public TextHitInfo getNextRightHit(TextHitInfo hit)
    {
      checkHitInfo(hit);
      int index = hitToCaret(hit);
      TextHitInfo next = null;
      if (index < length)
        {
          index++;
          next = caretToHit(index);
        }
      return next;
    }
  
    public Shape getOutline (AffineTransform tx)
    {
      float x = 0f;
      GeneralPath gp = new GeneralPath();
      for(int i = 0; i < runs.length; i++)
        {
          GlyphVector gv = runs[i].glyphVector;
          gp.append( gv.getOutline( x, 0f ), false );
          Rectangle2D r = gv.getLogicalBounds();
          x += r.getWidth();
        }
      if( tx != null )
        gp.transform( tx );
      return gp;
    }
  
    public float getVisibleAdvance ()
    {
      float totalAdvance = 0f;
  
      if( runs.length <= 0 )
        return 0f;
  
      // No trailing whitespace
      if( !Character.isWhitespace( string[offset + length - 1]) )
        return getAdvance();
  
      // Get length of all runs up to the last
  