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 / TextLine.class (.txt) < prev    next >
Encoding:
Java Class File  |  1979-12-31  |  12.9 KB  |  873 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.Toolkit;
  7. import java.awt.geom.AffineTransform;
  8. import java.awt.geom.GeneralPath;
  9. import java.awt.geom.Rectangle2D;
  10. import java.awt.geom.RectangularShape;
  11. import java.awt.im.InputMethodHighlight;
  12. import java.text.Annotation;
  13. import java.text.AttributedCharacterIterator;
  14. import java.util.Hashtable;
  15. import java.util.Map;
  16. import sun.awt.font.Bidi;
  17. import sun.awt.font.ExtendedTextLabel;
  18. import sun.awt.font.ExtendedTextLabelComponent;
  19. import sun.awt.font.GraphicComponent;
  20. import sun.awt.font.TextLabelFactory;
  21. import sun.awt.font.TextLineComponent;
  22.  
  23. final class TextLine {
  24.    private TextLineComponent[] fComponents;
  25.    private float[] fBaselineOffsets;
  26.    private int[] fComponentVisualOrder;
  27.    private char[] fChars;
  28.    private int fCharsStart;
  29.    private int fCharsLimit;
  30.    private int[] fCharVisualOrder;
  31.    private int[] fCharLogicalOrder;
  32.    private byte[] fCharLevels;
  33.    private boolean fIsDirectionLTR;
  34.    private TextLineMetrics fMetrics = null;
  35.    private static Function fgAdvanceF = new 1();
  36.    private static Function fgXPositionF = new 2();
  37.    private static Function fgYPositionF = new 3();
  38.  
  39.    public TextLine(TextLineComponent[] var1, float[] var2, char[] var3, int var4, int var5, int[] var6, byte[] var7, boolean var8) {
  40.       int[] var9 = computeComponentOrder(var1, var6);
  41.       this.fComponents = var1;
  42.       this.fBaselineOffsets = var2;
  43.       this.fComponentVisualOrder = var9;
  44.       this.fChars = var3;
  45.       this.fCharsStart = var4;
  46.       this.fCharsLimit = var5;
  47.       this.fCharLogicalOrder = var6;
  48.       this.fCharLevels = var7;
  49.       this.fIsDirectionLTR = var8;
  50.       this.checkCtorArgs();
  51.    }
  52.  
  53.    private void checkCtorArgs() {
  54.       int var1 = 0;
  55.  
  56.       for(int var2 = 0; var2 < this.fComponents.length; ++var2) {
  57.          var1 += this.fComponents[var2].getNumCharacters();
  58.       }
  59.  
  60.       if (var1 != this.characterCount()) {
  61.          throw new IllegalArgumentException("Invalid TextLine!  char count is different from sum of char counts of components.");
  62.       }
  63.    }
  64.  
  65.    public int characterCount() {
  66.       return this.fCharsLimit - this.fCharsStart;
  67.    }
  68.  
  69.    public boolean isDirectionLTR() {
  70.       return this.fIsDirectionLTR;
  71.    }
  72.  
  73.    public TextLineMetrics getMetrics() {
  74.       if (this.fMetrics == null) {
  75.          float var1 = 0.0F;
  76.          float var2 = 0.0F;
  77.          float var3 = 0.0F;
  78.          float var4 = 0.0F;
  79.          float var5 = 0.0F;
  80.          float var6 = 0.0F;
  81.          boolean var8 = false;
  82.  
  83.          for(int var9 = 0; var9 < this.fComponents.length; ++var9) {
  84.             TextLineComponent var7 = this.fComponents[var9];
  85.             Rectangle2D var10 = var7.getLogicalBounds();
  86.             var4 += (float)((RectangularShape)var10).getWidth();
  87.             byte var11 = (byte)var7.getLineMetrics().getBaselineIndex();
  88.             LineMetrics var12 = var7.getLineMetrics();
  89.             if (var11 >= 0) {
  90.                float var13 = this.fBaselineOffsets[var11];
  91.                var1 = Math.max(var1, -var13 + var12.getAscent());
  92.                float var14 = var13 + var12.getDescent();
  93.                var2 = Math.max(var2, var14);
  94.                var3 = Math.max(var3, var14 + var12.getLeading());
  95.             } else {
  96.                var8 = true;
  97.                float var16 = var12.getAscent() + var12.getDescent();
  98.                float var17 = var16 + var12.getLeading();
  99.                var5 = Math.max(var5, var16);
  100.                var6 = Math.max(var6, var17);
  101.             }
  102.          }
  103.  
  104.          if (var8) {
  105.             if (var5 > var1 + var2) {
  106.                var2 = var5 - var1;
  107.             }
  108.  
  109.             if (var6 > var1 + var3) {
  110.                var3 = var6 - var1;
  111.             }
  112.          }
  113.  
  114.          var3 -= var2;
  115.          this.fMetrics = new TextLineMetrics(var1, var2, var3, var4);
  116.       }
  117.  
  118.       return this.fMetrics;
  119.    }
  120.  
  121.    public int visualToLogical(int var1) {
  122.       if (this.fCharLogicalOrder == null) {
  123.          return var1;
  124.       } else {
  125.          if (this.fCharVisualOrder == null) {
  126.             this.fCharVisualOrder = Bidi.getInverseOrder(this.fCharLogicalOrder);
  127.          }
  128.  
  129.          return this.fCharVisualOrder[var1];
  130.       }
  131.    }
  132.  
  133.    public int logicalToVisual(int var1) {
  134.       return this.fCharLogicalOrder == null ? var1 : this.fCharLogicalOrder[var1];
  135.    }
  136.  
  137.    public byte getCharLevel(int var1) {
  138.       return this.fCharLevels == null ? 0 : this.fCharLevels[var1];
  139.    }
  140.  
  141.    public boolean isCharLTR(int var1) {
  142.       return (this.getCharLevel(var1) & 1) == 0;
  143.    }
  144.  
  145.    public int getCharType(int var1) {
  146.       return Character.getType(this.fChars[var1 + this.fCharsStart]);
  147.    }
  148.  
  149.    public boolean isCharSpace(int var1) {
  150.       return Character.isSpaceChar(this.fChars[var1 + this.fCharsStart]);
  151.    }
  152.  
  153.    public boolean isCharWhitespace(int var1) {
  154.       return Character.isWhitespace(this.fChars[var1 + this.fCharsStart]);
  155.    }
  156.  
  157.    public float getCharAngle(int var1) {
  158.       if (var1 < 0) {
  159.          throw new IllegalArgumentException("Negative logicalIndex.");
  160.       } else if (var1 > this.fCharsLimit - this.fCharsStart) {
  161.          throw new IllegalArgumentException("logicalIndex too large.");
  162.       } else {
  163.          int var2 = 0;
  164.          int var3 = 0;
  165.  
  166.          do {
  167.             var3 += this.fComponents[var2].getNumCharacters();
  168.             if (var3 > var1) {
  169.                break;
  170.             }
  171.  
  172.             ++var2;
  173.          } while(var2 < this.fComponents.length);
  174.  
  175.          return this.fComponents[var2].getItalicAngle();
  176.       }
  177.    }
  178.  
  179.    private LineMetrics getLineMetricsAt(int var1) {
  180.       if (var1 < 0) {
  181.          throw new IllegalArgumentException("Negative logicalIndex.");
  182.       } else if (var1 > this.fCharsLimit - this.fCharsStart) {
  183.          throw new IllegalArgumentException("logicalIndex too large.");
  184.       } else {
  185.          int var2 = 0;
  186.          boolean var3 = false;
  187.          int var4 = 0;
  188.  
  189.          do {
  190.             var4 += this.fComponents[var2].getNumCharacters();
  191.             if (var4 > var1) {
  192.                break;
  193.             }
  194.  
  195.             ++var2;
  196.          } while(var2 < this.fComponents.length);
  197.  
  198.          return this.fComponents[var2].getLineMetrics();
  199.       }
  200.    }
  201.  
  202.    public float getCharAscent(int var1) {
  203.       return this.getLineMetricsAt(var1).getAscent();
  204.    }
  205.  
  206.    public float getCharDescent(int var1) {
  207.       return this.getLineMetricsAt(var1).getDescent();
  208.    }
  209.  
  210.    private float applyFunctionAtIndex(int var1, Function var2) {
  211.       if (var1 < 0) {
  212.          throw new IllegalArgumentException("Negative logicalIndex.");
  213.       } else {
  214.          int var3 = 0;
  215.  
  216.          for(int var4 = 0; var4 < this.fComponents.length; ++var4) {
  217.             int var5 = var3 + this.fComponents[var4].getNumCharacters();
  218.             if (var5 > var1) {
  219.                return var2.computeFunction(this, var4, var1 - var3);
  220.             }
  221.  
  222.             var3 = var5;
  223.          }
  224.  
  225.          throw new IllegalArgumentException("logicalIndex too large.");
  226.       }
  227.    }
  228.  
  229.    public float getCharAdvance(int var1) {
  230.       return this.applyFunctionAtIndex(var1, fgAdvanceF);
  231.    }
  232.  
  233.    public float getCharXPosition(int var1) {
  234.       return this.applyFunctionAtIndex(var1, fgXPositionF);
  235.    }
  236.  
  237.    public float getCharYPosition(int var1) {
  238.       return this.applyFunctionAtIndex(var1, fgYPositionF);
  239.    }
  240.  
  241.    public float getCharLinePosition(int var1) {
  242.       return this.getCharXPosition(var1);
  243.    }
  244.  
  245.    public boolean caretAtOffsetIsValid(int var1) {
  246.       if (var1 < 0) {
  247.          throw new IllegalArgumentException("Negative offset.");
  248.       } else {
  249.          int var2 = 0;
  250.  
  251.          for(int var3 = 0; var3 < this.fComponents.length; ++var3) {
  252.             int var4 = var2 + this.fComponents[var3].getNumCharacters();
  253.             if (var4 > var1) {
  254.                return this.fComponents[var3].caretAtOffsetIsValid(var1 - var2);
  255.             }
  256.  
  257.             var2 = var4;
  258.          }
  259.  
  260.          throw new IllegalArgumentException("logicalIndex too large.");
  261.       }
  262.    }
  263.  
  264.    public Rectangle2D getCharBounds(int var1) {
  265.       if (var1 < 0) {
  266.          throw new IllegalArgumentException("Negative logicalIndex.");
  267.       } else {
  268.          int var2 = 0;
  269.  
  270.          for(int var3 = 0; var3 < this.fComponents.length; ++var3) {
  271.             int var4 = var2 + this.fComponents[var3].getNumCharacters();
  272.             if (var4 > var1) {
  273.                TextLineComponent var5 = this.fComponents[var3];
  274.                int var6 = var1 - var2;
  275.                Rectangle2D var7 = var5.getCharVisualBounds(var6);
  276.                float var8 = 0.0F;
  277.                if (this.fComponentVisualOrder == null) {
  278.                   for(int var9 = 0; var9 < var3; ++var9) {
  279.                      Rectangle2D var10 = this.fComponents[var9].getLogicalBounds();
  280.                      var8 += (float)((RectangularShape)var10).getWidth();
  281.                   }
  282.                } else {
  283.                   for(int var12 = 0; this.fComponentVisualOrder[var12] != var3; ++var12) {
  284.                      int var13 = this.fComponentVisualOrder[var12];
  285.                      Rectangle2D var11 = this.fComponents[var13].getLogicalBounds();
  286.                      var8 += (float)((RectangularShape)var11).getWidth();
  287.                   }
  288.                }
  289.  
  290.                var7.setRect(((RectangularShape)var7).getX() + (double)var8, ((RectangularShape)var7).getY(), ((RectangularShape)var7).getWidth(), ((RectangularShape)var7).getHeight());
  291.                return var7;
  292.             }
  293.  
  294.             var2 = var4;
  295.          }
  296.  
  297.          throw new IllegalArgumentException("logicalIndex too large.");
  298.       }
  299.    }
  300.  
  301.    private float getComponentShift(int var1) {
  302.       byte var2 = (byte)this.fComponents[var1].getLineMetrics().getBaselineIndex();
  303.       if (var2 >= 0) {
  304.          return this.fBaselineOffsets[var2];
  305.       } else {
  306.          TextLineMetrics var3 = this.getMetrics();
  307.          LineMetrics var4 = this.fComponents[var1].getLineMetrics();
  308.          return var2 == -1 ? var4.getAscent() - var3.ascent : var3.descent - var4.getDescent();
  309.       }
  310.    }
  311.  
  312.    public void draw(Graphics2D var1, float var2, float var3) {
  313.       float var4 = var2;
  314.  
  315.       for(int var5 = 0; var5 < this.fComponents.length; ++var5) {
  316.          int var6 = this.fComponentVisualOrder == null ? var5 : this.fComponentVisualOrder[var5];
  317.          TextLineComponent var7 = this.fComponents[var6];
  318.          float var8 = this.getComponentShift(var6);
  319.          var7.draw(var1, var4, var3 + var8);
  320.          if (var5 != this.fComponents.length - 1) {
  321.             Rectangle2D var9 = var7.getLogicalBounds();
  322.             var4 += (float)((RectangularShape)var9).getWidth();
  323.          }
  324.       }
  325.  
  326.    }
  327.  
  328.    public Rectangle2D getBounds() {
  329.       float var1 = 0.0F;
  330.       float var2 = Float.MAX_VALUE;
  331.       float var3 = Float.MIN_VALUE;
  332.       float var4 = Float.MAX_VALUE;
  333.       float var5 = Float.MIN_VALUE;
  334.  
  335.       for(int var6 = 0; var6 < this.fComponents.length; ++var6) {
  336.          int var7 = this.fComponentVisualOrder == null ? var6 : this.fComponentVisualOrder[var6];
  337.          TextLineComponent var8 = this.fComponents[var7];
  338.          Rectangle2D var9 = var8.getVisualBounds();
  339.          var2 = Math.min(var2, (float)((RectangularShape)var9).getX() + var1);
  340.          var3 = Math.max(var3, (float)((RectangularShape)var9).getMaxX() + var1);
  341.          float var10 = this.getComponentShift(var7);
  342.          var4 = Math.min(var4, (float)((RectangularShape)var9).getY() + var10);
  343.          var5 = Math.max(var5, (float)((RectangularShape)var9).getMaxY() + var10);
  344.          Rectangle2D var11 = var8.getLogicalBounds();
  345.          var1 += (float)((RectangularShape)var11).getWidth();
  346.       }
  347.  
  348.       return new Rectangle2D.Float(var2, var4, var3 - var2, var5 - var4);
  349.    }
  350.  
  351.    public Shape getOutline(AffineTransform var1) {
  352.       GeneralPath var2 = new GeneralPath(1);
  353.       float var3 = 0.0F;
  354.  
  355.       for(int var4 = 0; var4 < this.fComponents.length; ++var4) {
  356.          int var5 = this.fComponentVisualOrder == null ? var4 : this.fComponentVisualOrder[var4];
  357.          TextLineComponent var6 = this.fComponents[var5];
  358.          float var7 = this.getComponentShift(var5);
  359.          var2.append(var6.getOutline(var3, var7), false);
  360.          Rectangle2D var8 = var6.getLogicalBounds();
  361.          var3 += (float)((RectangularShape)var8).getWidth();
  362.       }
  363.  
  364.       if (var1 != null) {
  365.          var2.transform(var1);
  366.       }
  367.  
  368.       return var2;
  369.    }
  370.  
  371.    public int hashCode() {
  372.       return this.fComponents.length << 16 ^ this.fComponents[0].hashCode() << 3 ^ this.fCharsLimit - this.fCharsStart;
  373.    }
  374.  
  375.    public String toString() {
  376.       StringBuffer var1 = new StringBuffer();
  377.  
  378.       for(int var2 = 0; var2 < this.fComponents.length; ++var2) {
  379.          var1.append(this.fComponents[var2]);
  380.       }
  381.  
  382.       return var1.toString();
  383.    }
  384.  
  385.    public static TextLine fastCreateTextLine(FontRenderContext var0, char[] var1, int var2, int var3, Font var4, LineMetrics var5, Map var6) {
  386.       boolean var7 = true;
  387.       byte[] var8 = null;
  388.       int[] var9 = null;
  389.       Bidi var10 = null;
  390.       int var12 = var3 - var2;
  391.       char[] var11;
  392.       if (var2 != 0) {
  393.          var11 = new char[var12];
  394.          System.arraycopy(var1, var2, var11, 0, var12);
  395.       } else {
  396.          var11 = var1;
  397.       }
  398.  
  399.       boolean var13 = false;
  400.       boolean var14 = false;
  401.       byte[] var15 = null;
  402.       if (var6 != null) {
  403.          try {
  404.             Boolean var16 = (Boolean)var6.get(TextAttribute.RUN_DIRECTION);
  405.             if (var16 != null) {
  406.                var14 = true;
  407.                var7 = TextAttribute.RUN_DIRECTION_LTR.equals(var16);
  408.                var13 = !var7;
  409.             }
  410.          } catch (ClassCastException var22) {
  411.          }
  412.  
  413.          try {
  414.             Integer var24 = (Integer)var6.get(TextAttribute.BIDI_EMBEDDING);
  415.             if (var24 != null) {
  416.                int var17 = var24;
  417.                if (var17 >= -15 && var17 < 16) {
  418.                   byte var18 = (byte)var17;
  419.                   var13 = true;
  420.                   var15 = new byte[var12];
  421.  
  422.                   for(int var19 = 0; var19 < var15.length; ++var19) {
  423.                      var15[var19] = var18;
  424.                   }
  425.                }
  426.             }
  427.          } catch (ClassCastException var23) {
  428.          }
  429.       }
  430.  
  431.       if (!var13) {
  432.          for(int var25 = 0; var25 < var11.length; ++var25) {
  433.             if (Bidi.requiresBidi(var11[var25])) {
  434.                var13 = true;
  435.                break;
  436.             }
  437.          }
  438.       }
  439.  
  440.       if (var13) {
  441.          if (!var14) {
  442.             var7 = Bidi.defaultIsLTR(var11, 0, var12);
  443.          }
  444.  
  445.          if (var15 == null) {
  446.             var15 = Bidi.getEmbeddingArray(var11, var7);
  447.          }
  448.  
  449.          var10 = new Bidi(var11, var15, var7);
  450.          var8 = var10.getLevels();
  451.          var9 = var10.getLogicalToVisualMap();
  452.       }
  453.  
  454.       if (var6 != null) {
  455.          var6 = addInputMethodAttrs(var6);
  456.       }
  457.  
  458.       TextLabelFactory var26 = new TextLabelFactory(var0, var11, var10);
  459.       TextLineComponent[] var27;
  460.       if (var10 != null && var10.getLevelLimit(0) != var12) {
  461.          int var29 = 0;
  462.  
  463.          for(int var31 = 0; var31 < var12; ++var29) {
  464.             var31 = var10.getLevelLimit(var31);
  465.          }
  466.  
  467.          var27 = new TextLineComponent[var29];
  468.          var29 = 0;
  469.  
  470.          int var20;
  471.          for(int var32 = 0; var32 < var12; var32 = var20) {
  472.             var20 = var10.getLevelLimit(var32);
  473.             ExtendedTextLabel var21 = var26.createExtended(var4, var5, var32, var20);
  474.             var27[var29] = new ExtendedTextLabelComponent(var21, var6);
  475.             ++var29;
  476.          }
  477.       } else {
  478.          var27 = new TextLineComponent[1];
  479.          ExtendedTextLabel var28 = var26.createExtended(var4, var5, 0, var12);
  480.          var27[0] = new ExtendedTextLabelComponent(var28, var6);
  481.       }
  482.  
  483.       return new TextLine(var27, var5.getBaselineOffsets(), var1, var2, var3, var9, var8, var7);
  484.    }
  485.  
  486.    private static TextLineComponent[] expandArrays(TextLineComponent[] var0) {
  487.       TextLineComponent[] var1 = new TextLineComponent[var0.length + 8];
  488.       System.arraycopy(var0, 0, var1, 0, var0.length);
  489.       return var1;
  490.    }
  491.  
  492.    private static Map addInputMethodAttrs(Map var0) {
  493.       Object var1 = var0.get(TextAttribute.INPUT_METHOD_HIGHLIGHT);
  494.  
  495.       try {
  496.          if (var1 != null) {
  497.             if (var1 instanceof Annotation) {
  498.                var1 = ((Annotation)var1).getValue();
  499.             }
  500.  
  501.             InputMethodHighlight var2 = (InputMethodHighlight)var1;
  502.             Map var3 = null;
  503.  
  504.             try {
  505.                var3 = var2.getStyle();
  506.             } catch (NoSuchMethodError var5) {
  507.             }
  508.  
  509.             if (var3 == null) {
  510.                Toolkit var4 = Toolkit.getDefaultToolkit();
  511.                var3 = var4.mapInputMethodHighlight(var2);
  512.             }
  513.  
  514.             if (var3 != null) {
  515.                Hashtable var7 = new Hashtable(5, 0.9F);
  516.                var7.putAll(var0);
  517.                var7.putAll(var3);
  518.                return var7;
  519.             }
  520.          }
  521.       } catch (ClassCastException var6) {
  522.       }
  523.  
  524.       return var0;
  525.    }
  526.  
  527.    public static TextLineComponent[] getComponents(FontSource var0, char[] var1, int var2, int var3, int[] var4, byte[] var5, TextLabelFactory var6) {
  528.       FontRenderContext var7 = var6.getFontRenderContext();
  529.       int var8 = 0;
  530.       TextLineComponent[] var9 = new TextLineComponent[8];
  531.       int var10 = var2;
  532.  
  533.       do {
  534.          int var11 = var0.getRunLimit(var10);
  535.          if (var11 > var3) {
  536.             var11 = var3;
  537.          }
  538.  
  539.          GraphicAttribute var12 = var0.graphicAt(var10);
  540.          int var22;
  541.          if (var12 != null) {
  542.             do {
  543.                var22 = var2 + firstVisualChunk(var4, var5, var10 - var2, var11 - var2);
  544.                Map var23 = var0.attributesAt(var10);
  545.                GraphicComponent var24 = new GraphicComponent(var12, var23, var4, var5, var10 - var2, var22 - var2);
  546.                var10 = var22;
  547.                ++var8;
  548.                if (var8 >= var9.length) {
  549.                   var9 = expandArrays(var9);
  550.                }
  551.  
  552.                var9[var8 - 1] = var24;
  553.             } while(var22 < var11);
  554.          } else {
  555.             do {
  556.                var22 = var11;
  557.                Font var14 = var0.fontAt(var10);
  558.                if (var14 == null) {
  559.                   var14 = var0.getBestFontAt(var10);
  560.                   var22 = var14.canDisplayUpTo(var1, var10, var11);
  561.                   if (var22 == var10) {
  562.                      ++var22;
  563.                   }
  564.                }
  565.  
  566.                do {
  567.                   int var15 = var2 + firstVisualChunk(var4, var5, var10 - var2, var22 - var2);
  568.  
  569.                   do {
  570.                      Map var16 = var0.attributesAt(var10);
  571.                      int var17 = var10;
  572.                      LineMetrics var18 = var14.getLineMetrics(var1, var10, var15, var7);
  573.                      var10 += var18.getNumChars();
  574.                      ExtendedTextLabel var19 = var6.createExtended(var14, var18, var17, var10);
  575.                      var16 = addInputMethodAttrs(var16);
  576.                      ExtendedTextLabelComponent var20 = new ExtendedTextLabelComponent(var19, var16);
  577.                      ++var8;
  578.                      if (var8 >= var9.length) {
  579.                         var9 = expandArrays(var9);
  580.                      }
  581.  
  582.                      var9[var8 - 1] = var20;
  583.                   } while(var10 < var15);
  584.                } while(var10 < var22);
  585.             } while(var10 < var11);
  586.          }
  587.       } while(var10 < var3);
  588.  
  589.       TextLineComponent[] var21;
  590.       if (var9.length == var8) {
  591.          var21 = var9;
  592.       } else {
  593.          var21 = new TextLineComponent[var8];
  594.          System.arraycopy(var9, 0, var21, 0, var8);
  595.       }
  596.  
  597.       return var21;
  598.    }
  599.  
  600.    public static TextLine createLineFromText(char[] var0, int var1, int var2, FontSource var3, TextLabelFactory var4, boolean var5, float[] var6) {
  601.       var4.setLineContext(var1, var2);
  602.       Bidi var7 = var4.getLineBidi();
  603.       int[] var8 = null;
  604.       byte[] var9 = null;
  605.       if (var7 != null) {
  606.          var8 = var7.getLogicalToVisualMap();
  607.          var9 = var7.getLevels();
  608.       }
  609.  
  610.       TextLineComponent[] var10 = getComponents(var3, var0, var1, var2, var8, var9, var4);
  611.       return new TextLine(var10, var6, var0, var1, var2, var8, var9, var5);
  612.    }
  613.  
  614.    private static int[] computeComponentOrder(TextLineComponent[] var0, int[] var1) {
  615.       int[] var2 = null;
  616.       if (var1 != null && var0.length > 1) {
  617.          var2 = new int[var0.length];
  618.          int var3 = 0;
  619.  
  620.          for(int var4 = 0; var4 < var0.length; ++var4) {
  621.             var2[var4] = var1[var3];
  622.             var3 += var0[var4].getNumCharacters();
  623.          }
  624.  
  625.          var2 = Bidi.getContiguousOrder(var2);
  626.          var2 = Bidi.getInverseOrder(var2);
  627.       }
  628.  
  629.       return var2;
  630.    }
  631.  
  632.    static Bidi createBidiOnParagraph(AttributedCharacterIterator var0, char[] var1) {
  633.       int var2 = var0.getBeginIndex();
  634.       int var3 = var0.getEndIndex();
  635.       int var4 = var3 - var2;
  636.       if (var1 == null) {
  637.          int var5 = 0;
  638.          var1 = new char[var4];
  639.  
  640.          for(char var6 = var0.first(); var6 != '\uffff'; var6 = var0.next()) {
  641.             var1[var5++] = var6;
  642.          }
  643.       } else if (var1.length != var4) {
  644.          throw new IllegalArgumentException("chars length is not iter length");
  645.       }
  646.  
  647.       boolean var19 = true;
  648.       Bidi var20 = null;
  649.       boolean var7 = false;
  650.       boolean var8 = false;
  651.       byte[] var9 = null;
  652.       var0.first();
  653.  
  654.       try {
  655.          Boolean var10 = (Boolean)var0.getAttribute(TextAttribute.RUN_DIRECTION);
  656.          if (var10 != null) {
  657.             var8 = true;
  658.             var19 = TextAttribute.RUN_DIRECTION_LTR.equals(var10);
  659.             var7 = !var19;
  660.          }
  661.       } catch (ClassCastException var17) {
  662.       }
  663.  
  664.       int var21 = var2;
  665.       int var11 = 0;
  666.       int var12 = var8 && !var19 ? 1 : 0;
  667.  
  668.       int var14;
  669.       do {
  670.          var0.setIndex(var21);
  671.          Object var13 = var0.getAttribute(TextAttribute.BIDI_EMBEDDING);
  672.          var14 = var0.getRunLimit(TextAttribute.BIDI_EMBEDDING);
  673.          if (var13 != null) {
  674.             try {
  675.                int var15 = (Integer)var13;
  676.                if (var15 >= -15 && var15 < 16) {
  677.                   var11 = (byte)var15;
  678.                   if (var9 == null) {
  679.                      var9 = new byte[var4];
  680.                      var7 = true;
  681.                      if (!var8) {
  682.                         var8 = true;
  683.                         var19 = Bidi.defaultIsLTR(var1, 0, var4);
  684.                         var12 = var19 ? 0 : 1;
  685.                      }
  686.  
  687.                      if (!var19) {
  688.                         for(int var16 = 0; var16 < var21 - var2; ++var16) {
  689.                            var9[var16] = (byte)var12;
  690.                         }
  691.                      }
  692.                   }
  693.                }
  694.             } catch (ClassCastException var18) {
  695.             }
  696.          } else if (var9 != null) {
  697.             var11 = var12;
  698.          }
  699.  
  700.          if (var9 != null && var11 != 0) {
  701.             for(int var23 = var21 - var2; var23 < var14 - var2; ++var23) {
  702.                var9[var23] = (byte)var11;
  703.             }
  704.          }
  705.  
  706.          var21 = var14;
  707.       } while(var14 < var3);
  708.  
  709.       if (!var7) {
  710.          for(int var22 = 0; var22 < var4; ++var22) {
  711.             if (Bidi.requiresBidi(var1[var22])) {
  712.                var7 = true;
  713.                break;
  714.             }
  715.          }
  716.       }
  717.  
  718.       if (var7) {
  719.          if (!var8) {
  720.             var19 = Bidi.defaultIsLTR(var1, 0, var4);
  721.          }
  722.  
  723.          if (var9 == null) {
  724.             var9 = Bidi.getEmbeddingArray(var1, var19);
  725.          }
  726.  
  727.          var20 = new Bidi(var1, var9, var19);
  728.       }
  729.  
  730.       return var20;
  731.    }
  732.  
  733.    public static TextLine standardCreateTextLine(FontRenderContext var0, AttributedCharacterIterator var1, char[] var2, float[] var3) {
  734.       ACIFontSource var4 = new ACIFontSource(var1);
  735.       Bidi var5 = createBidiOnParagraph(var1, var2);
  736.       TextLabelFactory var6 = new TextLabelFactory(var0, var2, var5);
  737.       boolean var7 = true;
  738.       if (var5 != null) {
  739.          var7 = var5.isDirectionLTR();
  740.       }
  741.  
  742.       return createLineFromText(var2, 0, var2.length, var4, var6, var7, var3);
  743.    }
  744.  
  745.    private static int firstVisualChunk(int[] var0, byte[] var1, int var2, int var3) {
  746.       if (var0 != null && var1 != null) {
  747.          byte var4 = var1[var2];
  748.  
  749.          do {
  750.             ++var2;
  751.          } while(var2 < var3 && var1[var2] == var4);
  752.  
  753.          return var2;
  754.       } else {
  755.          return var3;
  756.       }
  757.    }
  758.  
  759.    public TextLine getJustifiedLine(float var1, float var2, int var3, int var4) {
  760.       TextLineComponent[] var5 = new TextLineComponent[this.fComponents.length];
  761.       System.arraycopy(this.fComponents, 0, var5, 0, this.fComponents.length);
  762.       float var6 = 0.0F;
  763.       float var7 = 0.0F;
  764.       float var8 = 0.0F;
  765.       boolean var9 = false;
  766.  
  767.       do {
  768.          getAdvanceBetween(var5, 0, this.characterCount());
  769.          float var10 = getAdvanceBetween(var5, var3, var4);
  770.          var8 = (var1 - var10) * var2;
  771.          int[] var11 = new int[var5.length];
  772.          int var12 = 0;
  773.  
  774.          for(int var13 = 0; var13 < var5.length; ++var13) {
  775.             int var14 = this.fComponentVisualOrder == null ? var13 : this.fComponentVisualOrder[var13];
  776.             var11[var14] = var12;
  777.             var12 += var5[var14].getNumJustificationInfos();
  778.          }
  779.  
  780.          GlyphJustificationInfo[] var31 = new GlyphJustificationInfo[var12];
  781.          byte var15 = 0;
  782.  
  783.          for(int var16 = 0; var16 < var5.length; ++var16) {
  784.             TextLineComponent var17 = var5[var16];
  785.             int var18 = var17.getNumCharacters();
  786.             int var19 = var15 + var18;
  787.             if (var19 > var3) {
  788.                int var20 = Math.max(0, var3 - var15);
  789.                int var21 = Math.min(var18, var4 - var15);
  790.                var17.getJustificationInfos(var31, var11[var16], var20, var21);
  791.                if (var19 >= var4) {
  792.                   break;
  793.                }
  794.             }
  795.          }
  796.  
  797.          int var33 = 0;
  798.  
  799.          int var34;
  800.          for(var34 = var12; var33 < var34 && var31[var33] == null; ++var33) {
  801.          }
  802.  
  803.          while(var34 > var33 && var31[var34 - 1] == null) {
  804.             --var34;
  805.          }
  806.  
  807.          TextJustifier var35 = new TextJustifier(var31, var33, var34);
  808.          float[] var36 = var35.justify(var8);
  809.          boolean var37 = !var9;
  810.          boolean var22 = false;
  811.          boolean[] var23 = new boolean[1];
  812.          var15 = 0;
  813.  
  814.          for(int var24 = 0; var24 < var5.length; ++var24) {
  815.             TextLineComponent var25 = var5[var24];
  816.             int var26 = var25.getNumCharacters();
  817.             int var27 = var15 + var26;
  818.             if (var27 > var3) {
  819.                int var28 = Math.max(0, var3 - var15);
  820.                Math.min(var26, var4 - var15);
  821.                var5[var24] = var25.applyJustificationDeltas(var36, var11[var24] * 2, var23);
  822.                var22 |= var23[0];
  823.                if (var27 >= var4) {
  824.                   break;
  825.                }
  826.             }
  827.          }
  828.  
  829.          var9 = var22 && !var9;
  830.       } while(var9);
  831.  
  832.       return new TextLine(var5, this.fBaselineOffsets, this.fChars, this.fCharsStart, this.fCharsLimit, this.fCharLogicalOrder, this.fCharLevels, this.fIsDirectionLTR);
  833.    }
  834.  
  835.    public static float getAdvanceBetween(TextLineComponent[] var0, int var1, int var2) {
  836.       float var3 = 0.0F;
  837.       int var4 = 0;
  838.  
  839.       for(int var5 = 0; var5 < var0.length; ++var5) {
  840.          TextLineComponent var6 = var0[var5];
  841.          int var7 = var6.getNumCharacters();
  842.          int var8 = var4 + var7;
  843.          if (var8 > var1) {
  844.             int var9 = Math.max(0, var1 - var4);
  845.             int var10 = Math.min(var7, var2 - var4);
  846.             var3 += var6.getAdvanceBetween(var9, var10);
  847.             if (var8 >= var2) {
  848.                break;
  849.             }
  850.          }
  851.  
  852.          var4 = var8;
  853.       }
  854.  
  855.       return var3;
  856.    }
  857.  
  858.    // $FF: synthetic method
  859.    static TextLineComponent[] access$100(TextLine var0) {
  860.       return var0.fComponents;
  861.    }
  862.  
  863.    // $FF: synthetic method
  864.    static int[] access$200(TextLine var0) {
  865.       return var0.fComponentVisualOrder;
  866.    }
  867.  
  868.    // $FF: synthetic method
  869.    static float access$300(TextLine var0, int var1) {
  870.       return var0.getComponentShift(var1);
  871.    }
  872. }
  873.