home *** CD-ROM | disk | FTP | other *** search
/ S283 Planetary Science &n…he Search for Life DVD 2 / DVD-ROM.iso / install / jre1_3 / lib / rt.jar / java / awt / font / TextLayout.class (.txt) < prev    next >
Encoding:
Java Class File  |  1979-12-31  |  17.7 KB  |  1,200 lines
  1. package java.awt.font;
  2.  
  3. import java.awt.Font;
  4. import java.awt.Graphics2D;
  5. import java.awt.Shape;
  6. import java.awt.geom.AffineTransform;
  7. import java.awt.geom.GeneralPath;
  8. import java.awt.geom.Rectangle2D;
  9. import java.awt.geom.RectangularShape;
  10. import java.text.AttributedCharacterIterator;
  11. import java.text.AttributedString;
  12. import java.util.Hashtable;
  13. import java.util.Map;
  14. import sun.java2d.SunGraphicsEnvironment;
  15.  
  16. public final class TextLayout implements Cloneable {
  17.    private int characterCount;
  18.    private boolean isVerticalLine = false;
  19.    private byte baseline;
  20.    private float[] baselineOffsets;
  21.    private TextLine textLine;
  22.    private TextLine.TextLineMetrics lineMetrics = null;
  23.    private float visibleAdvance;
  24.    private int hashCodeCache;
  25.    private boolean cacheIsValid = false;
  26.    private float justifyRatio;
  27.    private static final float ALREADY_JUSTIFIED = -53.9F;
  28.    // $FF: renamed from: dx float
  29.    private static float field_0;
  30.    // $FF: renamed from: dy float
  31.    private static float field_1;
  32.    private Rectangle2D naturalBounds = null;
  33.    private Rectangle2D boundsRect = null;
  34.    private boolean caretsInLigaturesAreAllowed = false;
  35.    public static final CaretPolicy DEFAULT_CARET_POLICY = new CaretPolicy();
  36.  
  37.    public TextLayout(String var1, Font var2, FontRenderContext var3) {
  38.       if (var2 == null) {
  39.          throw new IllegalArgumentException("Null font passed to TextLayout constructor.");
  40.       } else if (var1 == null) {
  41.          throw new IllegalArgumentException("Null string passed to TextLayout constructor.");
  42.       } else if (var1.length() == 0) {
  43.          throw new IllegalArgumentException("Zero length string passed to TextLayout constructor.");
  44.       } else {
  45.          char[] var4 = var1.toCharArray();
  46.          if (sameBaselineUpTo(var2, var4, 0, var4.length) == var4.length) {
  47.             this.fastInit(var4, 0, var4.length, var2, (Map)null, var3);
  48.          } else {
  49.             AttributedString var5 = new AttributedString(var1);
  50.             var5.addAttribute(TextAttribute.FONT, var2);
  51.             this.standardInit(var5.getIterator(), var4, var3);
  52.          }
  53.  
  54.       }
  55.    }
  56.  
  57.    public TextLayout(String var1, Map var2, FontRenderContext var3) {
  58.       if (var1 == null) {
  59.          throw new IllegalArgumentException("Null string passed to TextLayout constructor.");
  60.       } else if (var2 == null) {
  61.          throw new IllegalArgumentException("Null map passed to TextLayout constructor.");
  62.       } else if (var1.length() == 0) {
  63.          throw new IllegalArgumentException("Zero length string passed to TextLayout constructor.");
  64.       } else {
  65.          char[] var4 = var1.toCharArray();
  66.          Font var5 = singleFont(var4, 0, var4.length, var2);
  67.          if (var5 != null) {
  68.             this.fastInit(var4, 0, var4.length, var5, var2, var3);
  69.          } else {
  70.             AttributedString var6 = new AttributedString(var1, var2);
  71.             this.standardInit(var6.getIterator(), var4, var3);
  72.          }
  73.  
  74.       }
  75.    }
  76.  
  77.    private static Font singleFont(char[] var0, int var1, int var2, Map var3) {
  78.       if (var3.get(TextAttribute.CHAR_REPLACEMENT) != null) {
  79.          return null;
  80.       } else {
  81.          Font var4 = (Font)var3.get(TextAttribute.FONT);
  82.          if (var4 == null) {
  83.             var4 = Font.getFont(var3);
  84.             if (var4.canDisplayUpTo(var0, var1, var2) != var2) {
  85.                return null;
  86.             }
  87.          }
  88.  
  89.          return sameBaselineUpTo(var4, var0, var1, var2) != var2 ? null : var4;
  90.       }
  91.    }
  92.  
  93.    public TextLayout(AttributedCharacterIterator var1, FontRenderContext var2) {
  94.       if (var1 == null) {
  95.          throw new IllegalArgumentException("Null iterator passed to TextLayout constructor.");
  96.       } else {
  97.          int var3 = var1.getBeginIndex();
  98.          int var4 = var1.getEndIndex();
  99.          if (var3 == var4) {
  100.             throw new IllegalArgumentException("Zero length iterator passed to TextLayout constructor.");
  101.          } else {
  102.             int var5 = var4 - var3;
  103.             var1.first();
  104.             char[] var6 = new char[var5];
  105.             int var7 = 0;
  106.  
  107.             for(char var8 = var1.first(); var8 != '\uffff'; var8 = var1.next()) {
  108.                var6[var7++] = var8;
  109.             }
  110.  
  111.             var1.first();
  112.             if (var1.getRunLimit() == var4) {
  113.                var1.first();
  114.                Map var9 = var1.getAttributes();
  115.                Font var10 = singleFont(var6, 0, var5, var9);
  116.                if (var10 != null) {
  117.                   this.fastInit(var6, 0, var5, var10, var9, var2);
  118.                   return;
  119.                }
  120.             }
  121.  
  122.             this.standardInit(var1, var6, var2);
  123.          }
  124.       }
  125.    }
  126.  
  127.    TextLayout(TextLine var1, byte var2, float[] var3, float var4) {
  128.       this.characterCount = var1.characterCount();
  129.       this.baseline = var2;
  130.       this.baselineOffsets = var3;
  131.       this.textLine = var1;
  132.       this.justifyRatio = var4;
  133.    }
  134.  
  135.    private void paragraphInit(byte var1, LineMetrics var2, Map var3) {
  136.       this.isVerticalLine = false;
  137.       this.baseline = var1;
  138.       this.baselineOffsets = var2.getBaselineOffsets();
  139.       if (this.baselineOffsets[this.baseline] != 0.0F) {
  140.          float var4 = this.baselineOffsets[this.baseline];
  141.          float[] var5 = new float[this.baselineOffsets.length];
  142.  
  143.          for(int var6 = 0; var6 < var5.length; ++var6) {
  144.             var5[var6] = this.baselineOffsets[var6] - var4;
  145.          }
  146.  
  147.          this.baselineOffsets = var5;
  148.       }
  149.  
  150.       Float var7 = (Float)var3.get(TextAttribute.JUSTIFICATION);
  151.       if (var7 == null) {
  152.          this.justifyRatio = 1.0F;
  153.       } else {
  154.          this.justifyRatio = var7;
  155.          if (this.justifyRatio < 0.0F) {
  156.             this.justifyRatio = 0.0F;
  157.          } else if (this.justifyRatio > 1.0F) {
  158.             this.justifyRatio = 1.0F;
  159.          }
  160.       }
  161.  
  162.    }
  163.  
  164.    private void fastInit(char[] var1, int var2, int var3, Font var4, Map var5, FontRenderContext var6) {
  165.       this.isVerticalLine = false;
  166.       LineMetrics var7 = var4.getLineMetrics(var1, var2, var2 + 1, var6);
  167.       byte var8 = (byte)var7.getBaselineIndex();
  168.       if (var5 == null) {
  169.          this.baseline = var8;
  170.          this.baselineOffsets = var7.getBaselineOffsets();
  171.          this.justifyRatio = 1.0F;
  172.       } else {
  173.          this.paragraphInit(var8, var7, var5);
  174.       }
  175.  
  176.       this.characterCount = var3 - var2;
  177.       this.textLine = TextLine.fastCreateTextLine(var6, var1, var2, var3, var4, var7, var5);
  178.    }
  179.  
  180.    private void standardInit(AttributedCharacterIterator var1, char[] var2, FontRenderContext var3) {
  181.       this.characterCount = var1.getEndIndex() - var1.getBeginIndex();
  182.       char var4 = var1.first();
  183.       Map var5 = var1.getAttributes();
  184.       Map var6 = var5;
  185.       GraphicAttribute var7 = (GraphicAttribute)var5.get(TextAttribute.CHAR_REPLACEMENT);
  186.       boolean var8 = false;
  187.       if (var7 != null) {
  188.          var8 = true;
  189.  
  190.          for(var4 = var1.setIndex(var1.getRunLimit()); var4 != '\uffff'; var4 = var1.setIndex(var1.getRunLimit())) {
  191.             var6 = var1.getAttributes();
  192.             if (var6.get(TextAttribute.CHAR_REPLACEMENT) == null) {
  193.                var8 = false;
  194.                break;
  195.             }
  196.          }
  197.  
  198.          if (var8) {
  199.             var4 = var1.first();
  200.          }
  201.       }
  202.  
  203.       if (var8) {
  204.          byte var9 = getBaselineFromGraphic(var7);
  205.          Font var10 = new Font(new Hashtable(5, 0.9F));
  206.          LineMetrics var11 = var10.getLineMetrics(var2, 0, 1, var3);
  207.          float[] var12 = var11.getBaselineOffsets();
  208.          this.paragraphInit(var9, var11, var5);
  209.       } else {
  210.          Font var13 = (Font)var6.get(TextAttribute.FONT);
  211.          if (var13 == null) {
  212.             var13 = SunGraphicsEnvironment.getBestFontFor(var1, var1.getIndex(), var1.getEndIndex());
  213.          }
  214.  
  215.          int var14 = var1.getIndex() - var1.getBeginIndex();
  216.          LineMetrics var15 = var13.getLineMetrics(var2, var14, var14 + 1, var3);
  217.          this.paragraphInit(var13.getBaselineFor(var4), var15, var5);
  218.       }
  219.  
  220.       this.textLine = TextLine.standardCreateTextLine(var3, var1, var2, this.baselineOffsets);
  221.    }
  222.  
  223.    private void ensureCache() {
  224.       if (!this.cacheIsValid) {
  225.          this.buildCache();
  226.       }
  227.  
  228.    }
  229.  
  230.    private void buildCache() {
  231.       this.lineMetrics = this.textLine.getMetrics();
  232.       if (this.textLine.isDirectionLTR()) {
  233.          int var1;
  234.          for(var1 = this.characterCount - 1; var1 != -1; --var1) {
  235.             int var2 = this.textLine.visualToLogical(var1);
  236.             if (!this.textLine.isCharSpace(var2)) {
  237.                break;
  238.             }
  239.          }
  240.  
  241.          if (var1 == this.characterCount - 1) {
  242.             this.visibleAdvance = this.lineMetrics.advance;
  243.          } else if (var1 == -1) {
  244.             this.visibleAdvance = 0.0F;
  245.          } else {
  246.             int var5 = this.textLine.visualToLogical(var1);
  247.             this.visibleAdvance = this.textLine.getCharLinePosition(var5) + this.textLine.getCharAdvance(var5);
  248.          }
  249.       } else {
  250.          int var4;
  251.          for(var4 = 0; var4 != this.characterCount; ++var4) {
  252.             int var6 = this.textLine.visualToLogical(var4);
  253.             if (!this.textLine.isCharSpace(var6)) {
  254.                break;
  255.             }
  256.          }
  257.  
  258.          if (var4 == this.characterCount) {
  259.             this.visibleAdvance = 0.0F;
  260.          } else if (var4 == 0) {
  261.             this.visibleAdvance = this.lineMetrics.advance;
  262.          } else {
  263.             int var7 = this.textLine.visualToLogical(var4);
  264.             float var3 = this.textLine.getCharLinePosition(var7);
  265.             this.visibleAdvance = this.lineMetrics.advance - var3;
  266.          }
  267.       }
  268.  
  269.       this.naturalBounds = null;
  270.       this.boundsRect = null;
  271.       this.hashCodeCache = 0;
  272.       this.cacheIsValid = true;
  273.    }
  274.  
  275.    private Rectangle2D getNaturalBounds() {
  276.       this.ensureCache();
  277.       if (this.naturalBounds == null) {
  278.          int var1 = this.textLine.visualToLogical(0);
  279.          float var2 = this.textLine.getCharAngle(var1);
  280.          float var3 = this.isVerticalLine ? -field_1 : -field_0;
  281.          if (var2 < 0.0F) {
  282.             var3 += var2 * this.textLine.getCharAscent(var1);
  283.          } else if (var2 > 0.0F) {
  284.             var3 -= var2 * this.textLine.getCharDescent(var1);
  285.          }
  286.  
  287.          int var4 = this.textLine.visualToLogical(this.characterCount - 1);
  288.          var2 = this.textLine.getCharAngle(var4);
  289.          float var5 = this.lineMetrics.advance;
  290.          if (var2 < 0.0F) {
  291.             var5 -= var2 * this.textLine.getCharDescent(var4);
  292.          } else if (var2 > 0.0F) {
  293.             var5 += var2 * this.textLine.getCharAscent(var4);
  294.          }
  295.  
  296.          float var6 = var5 - var3;
  297.          if (this.isVerticalLine) {
  298.             this.naturalBounds = new Rectangle2D.Float(-this.lineMetrics.descent, var3, this.lineMetrics.ascent + this.lineMetrics.descent, var6);
  299.          } else {
  300.             this.naturalBounds = new Rectangle2D.Float(var3, -this.lineMetrics.ascent, var6, this.lineMetrics.ascent + this.lineMetrics.descent);
  301.          }
  302.       }
  303.  
  304.       return this.naturalBounds;
  305.    }
  306.  
  307.    protected Object clone() {
  308.       try {
  309.          return super.clone();
  310.       } catch (CloneNotSupportedException var2) {
  311.          throw new InternalError();
  312.       }
  313.    }
  314.  
  315.    private void checkTextHit(TextHitInfo var1) {
  316.       if (var1 == null) {
  317.          throw new IllegalArgumentException("TextHitInfo is null.");
  318.       } else if (var1.getInsertionIndex() < 0 || var1.getInsertionIndex() > this.characterCount) {
  319.          throw new IllegalArgumentException("TextHitInfo is out of range");
  320.       }
  321.    }
  322.  
  323.    public TextLayout getJustifiedLayout(float var1) {
  324.       if (var1 <= 0.0F) {
  325.          throw new IllegalArgumentException("justificationWidth <= 0 passed to TextLayout.getJustifiedLayout()");
  326.       } else if (this.justifyRatio == -53.9F) {
  327.          throw new Error("Can't justify again.");
  328.       } else {
  329.          int var2;
  330.          for(var2 = this.characterCount; var2 > 0 && this.textLine.isCharWhitespace(var2 - 1); --var2) {
  331.          }
  332.  
  333.          TextLine var3 = this.textLine.getJustifiedLine(var1, this.justifyRatio, 0, var2);
  334.          return var3 != null ? new TextLayout(var3, this.baseline, this.baselineOffsets, -53.9F) : this;
  335.       }
  336.    }
  337.  
  338.    protected void handleJustify(float var1) {
  339.    }
  340.  
  341.    public byte getBaseline() {
  342.       return this.baseline;
  343.    }
  344.  
  345.    public float[] getBaselineOffsets() {
  346.       float[] var1 = new float[this.baselineOffsets.length];
  347.       System.arraycopy(this.baselineOffsets, 0, var1, 0, var1.length);
  348.       return var1;
  349.    }
  350.  
  351.    public float getAdvance() {
  352.       this.ensureCache();
  353.       return this.lineMetrics.advance;
  354.    }
  355.  
  356.    public float getVisibleAdvance() {
  357.       this.ensureCache();
  358.       return this.visibleAdvance;
  359.    }
  360.  
  361.    public float getAscent() {
  362.       this.ensureCache();
  363.       return this.lineMetrics.ascent;
  364.    }
  365.  
  366.    public float getDescent() {
  367.       this.ensureCache();
  368.       return this.lineMetrics.descent;
  369.    }
  370.  
  371.    public float getLeading() {
  372.       this.ensureCache();
  373.       return this.lineMetrics.leading;
  374.    }
  375.  
  376.    public Rectangle2D getBounds() {
  377.       this.ensureCache();
  378.       if (this.boundsRect == null) {
  379.          Rectangle2D var1 = this.textLine.getBounds();
  380.          if (field_0 != 0.0F || field_1 != 0.0F) {
  381.             var1.setRect(((RectangularShape)var1).getX() - (double)field_0, ((RectangularShape)var1).getY() - (double)field_1, ((RectangularShape)var1).getWidth(), ((RectangularShape)var1).getHeight());
  382.          }
  383.  
  384.          this.boundsRect = var1;
  385.       }
  386.  
  387.       Rectangle2D.Float var2 = new Rectangle2D.Float();
  388.       ((Rectangle2D)var2).setRect(this.boundsRect);
  389.       return var2;
  390.    }
  391.  
  392.    public boolean isLeftToRight() {
  393.       return this.textLine.isDirectionLTR();
  394.    }
  395.  
  396.    public boolean isVertical() {
  397.       return this.isVerticalLine;
  398.    }
  399.  
  400.    public int getCharacterCount() {
  401.       return this.characterCount;
  402.    }
  403.  
  404.    private float[] getCaretInfo(int var1, Rectangle2D var2, float[] var3) {
  405.       float var4;
  406.       float var5;
  407.       float var6;
  408.       float var7;
  409.       if (var1 != 0 && var1 != this.characterCount) {
  410.          int var11 = this.textLine.visualToLogical(var1 - 1);
  411.          float var14 = this.textLine.getCharAngle(var11);
  412.          float var17 = this.textLine.getCharLinePosition(var11) + this.textLine.getCharAdvance(var11);
  413.          if (var14 != 0.0F) {
  414.             var4 = var17 + var14 * this.textLine.getCharAscent(var11);
  415.             var6 = var17 - var14 * this.textLine.getCharDescent(var11);
  416.          } else {
  417.             var6 = var17;
  418.             var4 = var17;
  419.          }
  420.  
  421.          var11 = this.textLine.visualToLogical(var1);
  422.          var14 = this.textLine.getCharAngle(var11);
  423.          var17 = this.textLine.getCharLinePosition(var11);
  424.          if (var14 != 0.0F) {
  425.             var5 = var17 + var14 * this.textLine.getCharAscent(var11);
  426.             var7 = var17 - var14 * this.textLine.getCharDescent(var11);
  427.          } else {
  428.             var7 = var17;
  429.             var5 = var17;
  430.          }
  431.       } else {
  432.          float var8;
  433.          int var9;
  434.          if (var1 == this.characterCount) {
  435.             var9 = this.textLine.visualToLogical(this.characterCount - 1);
  436.             var8 = this.textLine.getCharLinePosition(var9) + this.textLine.getCharAdvance(var9);
  437.          } else {
  438.             var9 = this.textLine.visualToLogical(var1);
  439.             var8 = this.textLine.getCharLinePosition(var9);
  440.          }
  441.  
  442.          float var10 = this.textLine.getCharAngle(var9);
  443.          var4 = var5 = var8 + var10 * this.textLine.getCharAscent(var9);
  444.          var6 = var7 = var8 - var10 * this.textLine.getCharDescent(var9);
  445.       }
  446.  
  447.       float var13 = (var4 + var5) / 2.0F;
  448.       float var16 = (var6 + var7) / 2.0F;
  449.       if (var3 == null) {
  450.          var3 = new float[2];
  451.       }
  452.  
  453.       if (this.isVerticalLine) {
  454.          var3[1] = (float)((double)(var13 - var16) / ((RectangularShape)var2).getWidth());
  455.          var3[0] = (float)((double)var13 + (double)var3[1] * ((RectangularShape)var2).getX());
  456.       } else {
  457.          var3[1] = (float)((double)(var13 - var16) / ((RectangularShape)var2).getHeight());
  458.          var3[0] = (float)((double)var16 + (double)var3[1] * ((RectangularShape)var2).getMaxY());
  459.       }
  460.  
  461.       return var3;
  462.    }
  463.  
  464.    public float[] getCaretInfo(TextHitInfo var1, Rectangle2D var2) {
  465.       this.ensureCache();
  466.       this.checkTextHit(var1);
  467.       return this.getCaretInfo(this.hitToCaret(var1), var2, (float[])null);
  468.    }
  469.  
  470.    public float[] getCaretInfo(TextHitInfo var1) {
  471.       return this.getCaretInfo(var1, this.getNaturalBounds());
  472.    }
  473.  
  474.    private int hitToCaret(TextHitInfo var1) {
  475.       int var2 = var1.getCharIndex();
  476.       if (var2 < 0) {
  477.          return this.textLine.isDirectionLTR() ? 0 : this.characterCount;
  478.       } else if (var2 >= this.characterCount) {
  479.          return this.textLine.isDirectionLTR() ? this.characterCount : 0;
  480.       } else {
  481.          int var3 = this.textLine.logicalToVisual(var2);
  482.          if (var1.isLeadingEdge() != this.textLine.isCharLTR(var2)) {
  483.             ++var3;
  484.          }
  485.  
  486.          return var3;
  487.       }
  488.    }
  489.  
  490.    private TextHitInfo caretToHit(int var1) {
  491.       if (var1 != 0 && var1 != this.characterCount) {
  492.          int var2 = this.textLine.visualToLogical(var1);
  493.          boolean var3 = this.textLine.isCharLTR(var2);
  494.          return var3 ? TextHitInfo.leading(var2) : TextHitInfo.trailing(var2);
  495.       } else {
  496.          return var1 == this.characterCount == this.textLine.isDirectionLTR() ? TextHitInfo.leading(this.characterCount) : TextHitInfo.trailing(-1);
  497.       }
  498.    }
  499.  
  500.    private boolean caretIsValid(int var1) {
  501.       if (var1 != this.characterCount && var1 != 0) {
  502.          int var2 = this.textLine.visualToLogical(var1);
  503.          if (!this.textLine.isCharLTR(var2)) {
  504.             var2 = this.textLine.visualToLogical(var1 - 1);
  505.             if (this.textLine.isCharLTR(var2)) {
  506.                return true;
  507.             }
  508.          }
  509.  
  510.          return this.textLine.caretAtOffsetIsValid(var2);
  511.       } else {
  512.          return true;
  513.       }
  514.    }
  515.  
  516.    public TextHitInfo getNextRightHit(TextHitInfo var1) {
  517.       this.ensureCache();
  518.       this.checkTextHit(var1);
  519.       int var2 = this.hitToCaret(var1);
  520.       if (var2 == this.characterCount) {
  521.          return null;
  522.       } else {
  523.          do {
  524.             ++var2;
  525.          } while(!this.caretIsValid(var2));
  526.  
  527.          return this.caretToHit(var2);
  528.       }
  529.    }
  530.  
  531.    public TextHitInfo getNextRightHit(int var1, CaretPolicy var2) {
  532.       if (var1 >= 0 && var1 <= this.characterCount) {
  533.          if (var2 == null) {
  534.             throw new IllegalArgumentException("Null CaretPolicy passed to TextLayout.getNextRightHit()");
  535.          } else {
  536.             TextHitInfo var3 = TextHitInfo.afterOffset(var1);
  537.             TextHitInfo var4 = var3.getOtherHit();
  538.             TextHitInfo var5 = this.getNextRightHit(var2.getStrongCaret(var3, var4, this));
  539.             if (var5 != null) {
  540.                TextHitInfo var6 = this.getVisualOtherHit(var5);
  541.                return var2.getStrongCaret(var6, var5, this);
  542.             } else {
  543.                return null;
  544.             }
  545.          }
  546.       } else {
  547.          throw new IllegalArgumentException("Offset out of bounds in TextLayout.getNextRightHit()");
  548.       }
  549.    }
  550.  
  551.    public TextHitInfo getNextRightHit(int var1) {
  552.       return this.getNextRightHit(var1, DEFAULT_CARET_POLICY);
  553.    }
  554.  
  555.    public TextHitInfo getNextLeftHit(TextHitInfo var1) {
  556.       this.ensureCache();
  557.       this.checkTextHit(var1);
  558.       int var2 = this.hitToCaret(var1);
  559.       if (var2 == 0) {
  560.          return null;
  561.       } else {
  562.          do {
  563.             --var2;
  564.          } while(!this.caretIsValid(var2));
  565.  
  566.          return this.caretToHit(var2);
  567.       }
  568.    }
  569.  
  570.    public TextHitInfo getNextLeftHit(int var1, CaretPolicy var2) {
  571.       if (var2 == null) {
  572.          throw new IllegalArgumentException("Null CaretPolicy passed to TextLayout.getNextLeftHit()");
  573.       } else if (var1 >= 0 && var1 <= this.characterCount) {
  574.          TextHitInfo var3 = TextHitInfo.afterOffset(var1);
  575.          TextHitInfo var4 = var3.getOtherHit();
  576.          TextHitInfo var5 = this.getNextLeftHit(var2.getStrongCaret(var3, var4, this));
  577.          if (var5 != null) {
  578.             TextHitInfo var6 = this.getVisualOtherHit(var5);
  579.             return var2.getStrongCaret(var6, var5, this);
  580.          } else {
  581.             return null;
  582.          }
  583.       } else {
  584.          throw new IllegalArgumentException("Offset out of bounds in TextLayout.getNextLeftHit()");
  585.       }
  586.    }
  587.  
  588.    public TextHitInfo getNextLeftHit(int var1) {
  589.       return this.getNextLeftHit(var1, DEFAULT_CARET_POLICY);
  590.    }
  591.  
  592.    public TextHitInfo getVisualOtherHit(TextHitInfo var1) {
  593.       this.ensureCache();
  594.       this.checkTextHit(var1);
  595.       int var2 = var1.getCharIndex();
  596.       int var3;
  597.       boolean var4;
  598.       if (var2 != -1 && var2 != this.characterCount) {
  599.          int var7 = this.textLine.logicalToVisual(var2);
  600.          boolean var6;
  601.          if (this.textLine.isCharLTR(var2) == var1.isLeadingEdge()) {
  602.             --var7;
  603.             var6 = false;
  604.          } else {
  605.             ++var7;
  606.             var6 = true;
  607.          }
  608.  
  609.          if (var7 > -1 && var7 < this.characterCount) {
  610.             var3 = this.textLine.visualToLogical(var7);
  611.             var4 = var6 == this.textLine.isCharLTR(var3);
  612.          } else {
  613.             var3 = var6 == this.textLine.isDirectionLTR() ? this.characterCount : -1;
  614.             var4 = var3 == this.characterCount;
  615.          }
  616.       } else {
  617.          int var5;
  618.          if (this.textLine.isDirectionLTR() == (var2 == -1)) {
  619.             var5 = 0;
  620.          } else {
  621.             var5 = this.characterCount - 1;
  622.          }
  623.  
  624.          var3 = this.textLine.visualToLogical(var5);
  625.          if (this.textLine.isDirectionLTR() == (var2 == -1)) {
  626.             var4 = this.textLine.isCharLTR(var3);
  627.          } else {
  628.             var4 = !this.textLine.isCharLTR(var3);
  629.          }
  630.       }
  631.  
  632.       return var4 ? TextHitInfo.leading(var3) : TextHitInfo.trailing(var3);
  633.    }
  634.  
  635.    private double[] getCaretPath(int var1, Rectangle2D var2, boolean var3) {
  636.       float[] var4 = this.getCaretInfo(var1, var2, (float[])null);
  637.       double var5 = (double)var4[0];
  638.       double var7 = (double)var4[1];
  639.       double var17 = -3141.59;
  640.       double var19 = -2.7;
  641.       double var21 = ((RectangularShape)var2).getX();
  642.       double var23 = var21 + ((RectangularShape)var2).getWidth();
  643.       double var25 = ((RectangularShape)var2).getY();
  644.       double var27 = var25 + ((RectangularShape)var2).getHeight();
  645.       boolean var29 = false;
  646.       double var9;
  647.       double var11;
  648.       double var13;
  649.       double var15;
  650.       if (this.isVerticalLine) {
  651.          if (var7 >= (double)0.0F) {
  652.             var9 = var21;
  653.             var13 = var23;
  654.          } else {
  655.             var13 = var21;
  656.             var9 = var23;
  657.          }
  658.  
  659.          var11 = var5 + var9 * var7;
  660.          var15 = var5 + var13 * var7;
  661.          if (var3) {
  662.             if (var11 < var25) {
  663.                if (!(var7 <= (double)0.0F) && !(var15 <= var25)) {
  664.                   var29 = true;
  665.                   var11 = var25;
  666.                   var19 = var25;
  667.                   var17 = var13 + (var25 - var15) / var7;
  668.                   if (var15 > var27) {
  669.                      var15 = var27;
  670.                   }
  671.                } else {
  672.                   var15 = var25;
  673.                   var11 = var25;
  674.                }
  675.             } else if (var15 > var27) {
  676.                if (!(var7 >= (double)0.0F) && !(var11 >= var27)) {
  677.                   var29 = true;
  678.                   var15 = var27;
  679.                   var19 = var27;
  680.                   var17 = var9 + (var27 - var13) / var7;
  681.                } else {
  682.                   var15 = var27;
  683.                   var11 = var27;
  684.                }
  685.             }
  686.          }
  687.       } else {
  688.          if (var7 >= (double)0.0F) {
  689.             var11 = var27;
  690.             var15 = var25;
  691.          } else {
  692.             var15 = var27;
  693.             var11 = var25;
  694.          }
  695.  
  696.          var9 = var5 - var11 * var7;
  697.          var13 = var5 - var15 * var7;
  698.          if (var3) {
  699.             if (var9 < var21) {
  700.                if (!(var7 <= (double)0.0F) && !(var13 <= var21)) {
  701.                   var29 = true;
  702.                   var9 = var21;
  703.                   var17 = var21;
  704.                   var19 = var15 - (var21 - var13) / var7;
  705.                   if (var13 > var23) {
  706.                      var13 = var23;
  707.                   }
  708.                } else {
  709.                   var13 = var21;
  710.                   var9 = var21;
  711.                }
  712.             } else if (var13 > var23) {
  713.                if (!(var7 >= (double)0.0F) && !(var9 >= var23)) {
  714.                   var29 = true;
  715.                   var13 = var23;
  716.                   var17 = var23;
  717.                   var19 = var11 - (var23 - var9) / var7;
  718.                } else {
  719.                   var13 = var23;
  720.                   var9 = var23;
  721.                }
  722.             }
  723.          }
  724.       }
  725.  
  726.       return var29 ? new double[]{var9, var11, var17, var19, var13, var15} : new double[]{var9, var11, var13, var15};
  727.    }
  728.  
  729.    private static GeneralPath pathToShape(double[] var0, boolean var1) {
  730.       GeneralPath var2 = new GeneralPath(0, var0.length);
  731.       var2.moveTo((float)var0[0], (float)var0[1]);
  732.  
  733.       for(int var3 = 2; var3 < var0.length; var3 += 2) {
  734.          var2.lineTo((float)var0[var3], (float)var0[var3 + 1]);
  735.       }
  736.  
  737.       if (var1) {
  738.          var2.closePath();
  739.       }
  740.  
  741.       return var2;
  742.    }
  743.  
  744.    public Shape getCaretShape(TextHitInfo var1, Rectangle2D var2) {
  745.       this.checkTextHit(var1);
  746.       if (var2 == null) {
  747.          throw new IllegalArgumentException("Null Rectangle2D passed to TextLayout.getCaret()");
  748.       } else {
  749.          int var3 = this.hitToCaret(var1);
  750.          GeneralPath var4 = pathToShape(this.getCaretPath(var3, var2, false), false);
  751.          return var4;
  752.       }
  753.    }
  754.  
  755.    public Shape getCaretShape(TextHitInfo var1) {
  756.       return this.getCaretShape(var1, this.getNaturalBounds());
  757.    }
  758.  
  759.    private final TextHitInfo getStrongHit(TextHitInfo var1, TextHitInfo var2) {
  760.       byte var3 = this.getCharacterLevel(var1.getCharIndex());
  761.       byte var4 = this.getCharacterLevel(var2.getCharIndex());
  762.       if (var3 == var4) {
  763.          return var2.isLeadingEdge() && !var1.isLeadingEdge() ? var2 : var1;
  764.       } else {
  765.          return var3 < var4 ? var1 : var2;
  766.       }
  767.    }
  768.  
  769.    public byte getCharacterLevel(int var1) {
  770.       if (var1 != -1 && var1 != this.characterCount) {
  771.          if (var1 >= 0 && var1 < this.characterCount) {
  772.             return this.textLine.getCharLevel(var1);
  773.          } else {
  774.             throw new IllegalArgumentException("Index is out of range in getCharacterLevel.");
  775.          }
  776.       } else {
  777.          return (byte)(this.textLine.isDirectionLTR() ? 0 : 1);
  778.       }
  779.    }
  780.  
  781.    public Shape[] getCaretShapes(int var1, Rectangle2D var2, CaretPolicy var3) {
  782.       this.ensureCache();
  783.       if (var1 >= 0 && var1 <= this.characterCount) {
  784.          if (var2 == null) {
  785.             throw new IllegalArgumentException("Null Rectangle2D passed to TextLayout.getCaretShapes()");
  786.          } else if (var3 == null) {
  787.             throw new IllegalArgumentException("Null CaretPolicy passed to TextLayout.getCaretShapes()");
  788.          } else {
  789.             Shape[] var4 = new Shape[2];
  790.             TextHitInfo var5 = TextHitInfo.afterOffset(var1);
  791.             int var6 = this.hitToCaret(var5);
  792.             GeneralPath var7 = pathToShape(this.getCaretPath(var6, var2, false), false);
  793.             TextHitInfo var8 = var5.getOtherHit();
  794.             int var9 = this.hitToCaret(var8);
  795.             if (var6 == var9) {
  796.                var4[0] = var7;
  797.             } else {
  798.                GeneralPath var10 = pathToShape(this.getCaretPath(var9, var2, false), false);
  799.                TextHitInfo var11 = var3.getStrongCaret(var5, var8, this);
  800.                boolean var12 = var11.equals(var5);
  801.                if (var12) {
  802.                   var4[0] = var7;
  803.                   var4[1] = var10;
  804.                } else {
  805.                   var4[0] = var10;
  806.                   var4[1] = var7;
  807.                }
  808.             }
  809.  
  810.             return var4;
  811.          }
  812.       } else {
  813.          throw new IllegalArgumentException("Offset out of bounds in TextLayout.getCaretShapes()");
  814.       }
  815.    }
  816.  
  817.    public Shape[] getCaretShapes(int var1, Rectangle2D var2) {
  818.       return this.getCaretShapes(var1, var2, DEFAULT_CARET_POLICY);
  819.    }
  820.  
  821.    public Shape[] getCaretShapes(int var1) {
  822.       return this.getCaretShapes(var1, this.getNaturalBounds(), DEFAULT_CARET_POLICY);
  823.    }
  824.  
  825.    private GeneralPath boundingShape(double[] var1, double[] var2) {
  826.       GeneralPath var3 = pathToShape(var1, false);
  827.       boolean var4;
  828.       if (this.isVerticalLine) {
  829.          var4 = var1[1] > var1[var1.length - 1] == var2[1] > var2[var2.length - 1];
  830.       } else {
  831.          var4 = var1[0] > var1[var1.length - 2] == var2[0] > var2[var2.length - 2];
  832.       }
  833.  
  834.       int var5;
  835.       int var6;
  836.       byte var7;
  837.       if (var4) {
  838.          var5 = var2.length - 2;
  839.          var6 = -2;
  840.          var7 = -2;
  841.       } else {
  842.          var5 = 0;
  843.          var6 = var2.length;
  844.          var7 = 2;
  845.       }
  846.  
  847.       for(int var8 = var5; var8 != var6; var8 += var7) {
  848.          var3.lineTo((float)var2[var8], (float)var2[var8 + 1]);
  849.       }
  850.  
  851.       var3.closePath();
  852.       return var3;
  853.    }
  854.  
  855.    private GeneralPath caretBoundingShape(int var1, int var2, Rectangle2D var3) {
  856.       if (var1 > var2) {
  857.          int var4 = var1;
  858.          var1 = var2;
  859.          var2 = var4;
  860.       }
  861.  
  862.       return this.boundingShape(this.getCaretPath(var1, var3, true), this.getCaretPath(var2, var3, true));
  863.    }
  864.  
  865.    private GeneralPath leftShape(Rectangle2D var1) {
  866.       double[] var2;
  867.       if (this.isVerticalLine) {
  868.          var2 = new double[]{((RectangularShape)var1).getX(), ((RectangularShape)var1).getY(), ((RectangularShape)var1).getX() + ((RectangularShape)var1).getWidth(), ((RectangularShape)var1).getY()};
  869.       } else {
  870.          var2 = new double[]{((RectangularShape)var1).getX(), ((RectangularShape)var1).getY() + ((RectangularShape)var1).getHeight(), ((RectangularShape)var1).getX(), ((RectangularShape)var1).getY()};
  871.       }
  872.  
  873.       double[] var3 = this.getCaretPath(0, var1, true);
  874.       return this.boundingShape(var2, var3);
  875.    }
  876.  
  877.    private GeneralPath rightShape(Rectangle2D var1) {
  878.       double[] var2;
  879.       if (this.isVerticalLine) {
  880.          var2 = new double[]{((RectangularShape)var1).getX(), ((RectangularShape)var1).getY() + ((RectangularShape)var1).getHeight(), ((RectangularShape)var1).getX() + ((RectangularShape)var1).getWidth(), ((RectangularShape)var1).getY() + ((RectangularShape)var1).getHeight()};
  881.       } else {
  882.          var2 = new double[]{((RectangularShape)var1).getX() + ((RectangularShape)var1).getWidth(), ((RectangularShape)var1).getY() + ((RectangularShape)var1).getHeight(), ((RectangularShape)var1).getX() + ((RectangularShape)var1).getWidth(), ((RectangularShape)var1).getY()};
  883.       }
  884.  
  885.       double[] var3 = this.getCaretPath(this.characterCount, var1, true);
  886.       return this.boundingShape(var3, var2);
  887.    }
  888.  
  889.    public int[] getLogicalRangesForVisualSelection(TextHitInfo var1, TextHitInfo var2) {
  890.       this.ensureCache();
  891.       this.checkTextHit(var1);
  892.       this.checkTextHit(var2);
  893.       boolean[] var3 = new boolean[this.characterCount];
  894.       int var4 = this.hitToCaret(var1);
  895.       int var5 = this.hitToCaret(var2);
  896.       if (var4 > var5) {
  897.          int var6 = var4;
  898.          var4 = var5;
  899.          var5 = var6;
  900.       }
  901.  
  902.       if (var4 < var5) {
  903.          for(int var11 = var4; var11 < var5; ++var11) {
  904.             var3[this.textLine.visualToLogical(var11)] = true;
  905.          }
  906.       }
  907.  
  908.       int var12 = 0;
  909.       boolean var7 = false;
  910.  
  911.       for(int var8 = 0; var8 < this.characterCount; ++var8) {
  912.          if (var3[var8] != var7) {
  913.             var7 = !var7;
  914.             if (var7) {
  915.                ++var12;
  916.             }
  917.          }
  918.       }
  919.  
  920.       int[] var9 = new int[var12 * 2];
  921.       var12 = 0;
  922.       var7 = false;
  923.  
  924.       for(int var10 = 0; var10 < this.characterCount; ++var10) {
  925.          if (var3[var10] != var7) {
  926.             var9[var12++] = var10;
  927.             var7 = !var7;
  928.          }
  929.       }
  930.  
  931.       if (var7) {
  932.          var9[var12++] = this.characterCount;
  933.       }
  934.  
  935.       return var9;
  936.    }
  937.  
  938.    public Shape getVisualHighlightShape(TextHitInfo var1, TextHitInfo var2, Rectangle2D var3) {
  939.       this.ensureCache();
  940.       this.checkTextHit(var1);
  941.       this.checkTextHit(var2);
  942.       if (var3 == null) {
  943.          throw new IllegalArgumentException("Null Rectangle2D passed to TextLayout.getVisualHighlightShape()");
  944.       } else {
  945.          GeneralPath var4 = new GeneralPath(0);
  946.          int var5 = this.hitToCaret(var1);
  947.          int var6 = this.hitToCaret(var2);
  948.          var4.append(this.caretBoundingShape(var5, var6, var3), false);
  949.          if (var5 == 0 || var6 == 0) {
  950.             var4.append(this.leftShape(var3), false);
  951.          }
  952.  
  953.          if (var5 == this.characterCount || var6 == this.characterCount) {
  954.             var4.append(this.rightShape(var3), false);
  955.          }
  956.  
  957.          return var4;
  958.       }
  959.    }
  960.  
  961.    public Shape getVisualHighlightShape(TextHitInfo var1, TextHitInfo var2) {
  962.       return this.getVisualHighlightShape(var1, var2, this.getNaturalBounds());
  963.    }
  964.  
  965.    public Shape getLogicalHighlightShape(int var1, int var2, Rectangle2D var3) {
  966.       if (var3 == null) {
  967.          throw new IllegalArgumentException("Null Rectangle2D passed to TextLayout.getLogicalHighlightShape()");
  968.       } else {
  969.          this.ensureCache();
  970.          if (var1 > var2) {
  971.             int var4 = var1;
  972.             var1 = var2;
  973.             var2 = var4;
  974.          }
  975.  
  976.          if (var1 >= 0 && var2 <= this.characterCount) {
  977.             int[] var10 = new int[10];
  978.             int var5 = 0;
  979.             if (var1 < var2) {
  980.                int var6 = var1;
  981.  
  982.                do {
  983.                   var10[var5++] = this.hitToCaret(TextHitInfo.leading(var6));
  984.                   boolean var7 = this.textLine.isCharLTR(var6);
  985.  
  986.                   do {
  987.                      ++var6;
  988.                   } while(var6 < var2 && this.textLine.isCharLTR(var6) == var7);
  989.  
  990.                   var10[var5++] = this.hitToCaret(TextHitInfo.trailing(var6 - 1));
  991.                   if (var5 == var10.length) {
  992.                      int[] var9 = new int[var10.length + 10];
  993.                      System.arraycopy(var10, 0, var9, 0, var5);
  994.                      var10 = var9;
  995.                   }
  996.                } while(var6 < var2);
  997.             } else {
  998.                var5 = 2;
  999.                var10[0] = var10[1] = this.hitToCaret(TextHitInfo.leading(var1));
  1000.             }
  1001.  
  1002.             GeneralPath var12 = new GeneralPath(0);
  1003.  
  1004.             for(int var13 = 0; var13 < var5; var13 += 2) {
  1005.                var12.append(this.caretBoundingShape(var10[var13], var10[var13 + 1], var3), false);
  1006.             }
  1007.  
  1008.             if (this.textLine.isDirectionLTR() && var1 == 0 || !this.textLine.isDirectionLTR() && var2 == this.characterCount) {
  1009.                var12.append(this.leftShape(var3), false);
  1010.             }
  1011.  
  1012.             if (this.textLine.isDirectionLTR() && var2 == this.characterCount || !this.textLine.isDirectionLTR() && var1 == 0) {
  1013.                var12.append(this.rightShape(var3), false);
  1014.             }
  1015.  
  1016.             return var12;
  1017.          } else {
  1018.             throw new IllegalArgumentException("Range is invalid in TextLayout.getLogicalHighlightShape()");
  1019.          }
  1020.       }
  1021.    }
  1022.  
  1023.    public Shape getLogicalHighlightShape(int var1, int var2) {
  1024.       return this.getLogicalHighlightShape(var1, var2, this.getNaturalBounds());
  1025.    }
  1026.  
  1027.    public Shape getBlackBoxBounds(int var1, int var2) {
  1028.       this.ensureCache();
  1029.       if (var1 > var2) {
  1030.          int var3 = var1;
  1031.          var1 = var2;
  1032.          var2 = var3;
  1033.       }
  1034.  
  1035.       if (var1 >= 0 && var2 <= this.characterCount) {
  1036.          GeneralPath var6 = new GeneralPath(1);
  1037.          if (var1 < this.characterCount) {
  1038.             for(int var4 = var1; var4 < var2; ++var4) {
  1039.                if (!this.textLine.isCharWhitespace(var4)) {
  1040.                   Rectangle2D var5 = this.textLine.getCharBounds(var4);
  1041.                   var6.append(var5, false);
  1042.                }
  1043.             }
  1044.          }
  1045.  
  1046.          if (field_0 != 0.0F || field_1 != 0.0F) {
  1047.             AffineTransform var7 = new AffineTransform();
  1048.             var7.setToTranslation((double)field_0, (double)field_1);
  1049.             var6 = (GeneralPath)var6.createTransformedShape(var7);
  1050.          }
  1051.  
  1052.          return var6;
  1053.       } else {
  1054.          throw new IllegalArgumentException("Invalid range passed to TextLayout.getBlackBoxBounds()");
  1055.       }
  1056.    }
  1057.  
  1058.    private float caretToPointDistance(float[] var1, float var2, float var3) {
  1059.       float var4 = this.isVerticalLine ? var3 : var2;
  1060.       float var5 = this.isVerticalLine ? -var2 : var3;
  1061.       return var4 - var1[0] + var5 * var1[1];
  1062.    }
  1063.  
  1064.    public TextHitInfo hitTestChar(float var1, float var2, Rectangle2D var3) {
  1065.       this.ensureCache();
  1066.       float[] var6 = new float[2];
  1067.       int var4 = 0;
  1068.       var6 = this.getCaretInfo(var4, var3, var6);
  1069.       if (this.caretToPointDistance(var6, var1, var2) < 0.0F) {
  1070.          return this.textLine.isDirectionLTR() ? TextHitInfo.trailing(-1) : TextHitInfo.leading(this.characterCount);
  1071.       } else {
  1072.          int var5 = this.characterCount;
  1073.          var6 = this.getCaretInfo(var5, var3, var6);
  1074.          if (this.caretToPointDistance(var6, var1, var2) >= 0.0F) {
  1075.             return this.textLine.isDirectionLTR() ? TextHitInfo.leading(this.characterCount) : TextHitInfo.trailing(-1);
  1076.          } else {
  1077.             while(var4 + 1 != var5) {
  1078.                int var7;
  1079.                for(var7 = (var4 + var5) / 2; !this.caretIsValid(var7); ++var7) {
  1080.                }
  1081.  
  1082.                if (var7 == var5) {
  1083.                   var7 = (var4 + var5) / 2;
  1084.  
  1085.                   do {
  1086.                      --var7;
  1087.                   } while(!this.caretIsValid(var7));
  1088.  
  1089.                   if (var7 == var4) {
  1090.                      break;
  1091.                   }
  1092.                }
  1093.  
  1094.                var6 = this.getCaretInfo(var7, var3, var6);
  1095.                float var8 = this.caretToPointDistance(var6, var1, var2);
  1096.                if (var8 == 0.0F) {
  1097.                   int var9 = this.textLine.visualToLogical(var7);
  1098.                   boolean var10 = this.textLine.isCharLTR(var9);
  1099.                   return var10 ? TextHitInfo.leading(var9) : TextHitInfo.trailing(var9);
  1100.                }
  1101.  
  1102.                if (var8 < 0.0F) {
  1103.                   var5 = var7;
  1104.                } else {
  1105.                   var4 = var7;
  1106.                }
  1107.             }
  1108.  
  1109.             int var14 = this.textLine.visualToLogical(var4);
  1110.             float var16 = this.textLine.getCharLinePosition(var14) + (this.isVerticalLine ? -field_1 : -field_0);
  1111.             int var18 = this.textLine.visualToLogical(var5 - 1);
  1112.             if (var5 - var4 > 1) {
  1113.                float var20 = this.textLine.getCharLinePosition(var18);
  1114.                var16 += (var20 - var16) / 2.0F;
  1115.             }
  1116.  
  1117.             var16 += this.textLine.getCharAdvance(var18) / 2.0F;
  1118.             var6[0] = var16;
  1119.             var6[1] = this.textLine.getCharAngle(var14);
  1120.             if (var6[1] != 0.0F) {
  1121.                var6[0] += var6[1] * (this.isVerticalLine ? this.textLine.getCharXPosition(var14) : this.textLine.getCharYPosition(var14));
  1122.             }
  1123.  
  1124.             float var19 = this.caretToPointDistance(var6, var1, var2);
  1125.             TextHitInfo var21;
  1126.             if (var19 < 0.0F) {
  1127.                var21 = this.textLine.isCharLTR(var14) ? TextHitInfo.leading(var14) : TextHitInfo.trailing(var14);
  1128.             } else {
  1129.                var14 = this.textLine.visualToLogical(var5 - 1);
  1130.                boolean var11 = !this.textLine.isCharLTR(var14);
  1131.                var21 = var11 ? TextHitInfo.leading(var14) : TextHitInfo.trailing(var14);
  1132.             }
  1133.  
  1134.             return var21;
  1135.          }
  1136.       }
  1137.    }
  1138.  
  1139.    public TextHitInfo hitTestChar(float var1, float var2) {
  1140.       return this.hitTestChar(var1, var2, this.getNaturalBounds());
  1141.    }
  1142.  
  1143.    public int hashCode() {
  1144.       if (this.hashCodeCache == 0) {
  1145.          this.hashCodeCache = this.textLine.hashCode();
  1146.       }
  1147.  
  1148.       return this.hashCodeCache;
  1149.    }
  1150.  
  1151.    public boolean equals(Object var1) {
  1152.       return var1 instanceof TextLayout && this.equals((TextLayout)var1);
  1153.    }
  1154.  
  1155.    public boolean equals(TextLayout var1) {
  1156.       if (var1 == null) {
  1157.          return false;
  1158.       } else {
  1159.          return var1 == this ? true : this.textLine.equals(var1.textLine);
  1160.       }
  1161.    }
  1162.  
  1163.    public String toString() {
  1164.       return this.textLine.toString();
  1165.    }
  1166.  
  1167.    public void draw(Graphics2D var1, float var2, float var3) {
  1168.       if (var1 == null) {
  1169.          throw new IllegalArgumentException("Null Graphics2D passed to TextLayout.draw()");
  1170.       } else {
  1171.          this.textLine.draw(var1, var2 - field_0, var3 - field_1);
  1172.       }
  1173.    }
  1174.  
  1175.    TextLine getTextLineForTesting() {
  1176.       return this.textLine;
  1177.    }
  1178.  
  1179.    private static int sameBaselineUpTo(Font var0, char[] var1, int var2, int var3) {
  1180.       for(byte var4 = var0.getBaselineFor(var1[var2++]); var2 < var3 && var0.getBaselineFor(var1[var2]) == var4; ++var2) {
  1181.       }
  1182.  
  1183.       return var2;
  1184.    }
  1185.  
  1186.    static byte getBaselineFromGraphic(GraphicAttribute var0) {
  1187.       byte var1 = (byte)var0.getAlignment();
  1188.       return var1 != -2 && var1 != -1 ? var1 : 0;
  1189.    }
  1190.  
  1191.    public Shape getOutline(AffineTransform var1) {
  1192.       return this.textLine.getOutline(var1);
  1193.    }
  1194.  
  1195.    // $FF: synthetic method
  1196.    static TextHitInfo access$000(TextLayout var0, TextHitInfo var1, TextHitInfo var2) {
  1197.       return var0.getStrongHit(var1, var2);
  1198.    }
  1199. }
  1200.