home *** CD-ROM | disk | FTP | other *** search
/ Computer Shopper 139 / dpcs0999.iso / Web / CFserver / data1.cab / Java / netscape / application / TextParagraph.class (.txt) < prev    next >
Encoding:
Java Class File  |  1999-04-12  |  22.9 KB  |  1,552 lines
  1. package netscape.application;
  2.  
  3. import netscape.util.ClassInfo;
  4. import netscape.util.Codable;
  5. import netscape.util.CodingException;
  6. import netscape.util.Decoder;
  7. import netscape.util.Encoder;
  8. import netscape.util.Hashtable;
  9. import netscape.util.InconsistencyException;
  10. import netscape.util.Vector;
  11.  
  12. public class TextParagraph implements Cloneable, Codable {
  13.    TextView _owner;
  14.    TextParagraphFormat _format;
  15.    Vector _runVector;
  16.    // $FF: renamed from: _y int
  17.    int field_0;
  18.    int _height;
  19.    int[] _lineBreaks;
  20.    int _breakCount;
  21.    int[] _lineHeights;
  22.    int _heightCount;
  23.    int[] _baselines;
  24.    int _baselineCount;
  25.    int[] _lineRemainders;
  26.    int _remainderCount;
  27.    int _charCount;
  28.    int _startChar;
  29.    static final String FORMAT_KEY = "format";
  30.    static final String RUNVECTOR_KEY = "runVector";
  31.  
  32.    public TextParagraph() {
  33.    }
  34.  
  35.    TextParagraph(TextView var1) {
  36.       this();
  37.       this.init(var1);
  38.    }
  39.  
  40.    TextParagraph(TextView var1, TextParagraphFormat var2) {
  41.       this();
  42.       this.init(var1, var2);
  43.    }
  44.  
  45.    void init(TextView var1, TextParagraphFormat var2) {
  46.       this._owner = var1;
  47.       this._runVector = new Vector();
  48.       this.setFormat(var2);
  49.    }
  50.  
  51.    void init(TextView var1) {
  52.       this.init(var1, (TextParagraphFormat)null);
  53.    }
  54.  
  55.    Object objectAt(Vector var1, int var2) {
  56.       return var2 >= 0 && var2 < var1.count() ? var1.elementAt(var2) : null;
  57.    }
  58.  
  59.    public Object clone() {
  60.       Object var3 = null;
  61.       this.collectEmptyRuns();
  62.  
  63.       try {
  64.          var3 = super.clone();
  65.       } catch (CloneNotSupportedException var7) {
  66.          throw new InconsistencyException(this + ": clone() not supported :" + var7);
  67.       }
  68.  
  69.       if (var3 != null) {
  70.          TextParagraph var1 = (TextParagraph)var3;
  71.          var1._owner = null;
  72.          if (this._format != null) {
  73.             var1._format = (TextParagraphFormat)this._format.clone();
  74.          } else {
  75.             var1._format = null;
  76.          }
  77.  
  78.          var1._runVector = new Vector();
  79.          int var5 = this._runVector.count();
  80.  
  81.          for(int var4 = 0; var4 < var5; ++var4) {
  82.             TextStyleRun var2 = (TextStyleRun)this._runVector.elementAt(var4);
  83.             var1.addRun(var2.createEmptyRun());
  84.          }
  85.  
  86.          var1._lineBreaks = null;
  87.          var1._lineHeights = null;
  88.          var1._baselines = null;
  89.          var1._lineRemainders = null;
  90.       }
  91.  
  92.       return var3;
  93.    }
  94.  
  95.    void setOwner(TextView var1) {
  96.       this._owner = var1;
  97.    }
  98.  
  99.    TextView owner() {
  100.       return this._owner;
  101.    }
  102.  
  103.    void setY(int var1) {
  104.       this.field_0 = var1;
  105.    }
  106.  
  107.    void setStartChar(int var1) {
  108.       this._startChar = var1;
  109.    }
  110.  
  111.    void setFormat(TextParagraphFormat var1) {
  112.       if (var1 != null || this._format != null) {
  113.          if (var1 != null) {
  114.             this._format = (TextParagraphFormat)var1.clone();
  115.          } else {
  116.             this._format = null;
  117.          }
  118.  
  119.          if (this._charCount > 0) {
  120.             this.computeLineBreaksAndHeights(this._owner.bounds.width);
  121.          }
  122.  
  123.       }
  124.    }
  125.  
  126.    TextParagraphFormat format() {
  127.       return this._format;
  128.    }
  129.  
  130.    TextParagraphFormat currentParagraphFormat() {
  131.       if (this._format != null) {
  132.          return this._format;
  133.       } else {
  134.          TextParagraphFormat var1 = null;
  135.          if (this._owner != null) {
  136.             var1 = (TextParagraphFormat)this._owner.defaultAttributes().get("ParagraphFormatKey");
  137.          }
  138.  
  139.          return var1 != null ? var1 : new TextParagraphFormat();
  140.       }
  141.    }
  142.  
  143.    Vector runVector() {
  144.       return this._runVector;
  145.    }
  146.  
  147.    TextStyleRun firstRun() {
  148.       return (TextStyleRun)this._runVector.firstElement();
  149.    }
  150.  
  151.    TextStyleRun lastRun() {
  152.       return (TextStyleRun)this._runVector.lastElement();
  153.    }
  154.  
  155.    void addRun(TextStyleRun var1) {
  156.       if (var1 != null) {
  157.          var1.setParagraph(this);
  158.          this._runVector.addElement(var1);
  159.       }
  160.  
  161.    }
  162.  
  163.    void collectEmptyRuns() {
  164.       int var1 = 1;
  165.  
  166.       for(int var2 = this._runVector.count(); var1 < var2; ++var1) {
  167.          TextStyleRun var3 = (TextStyleRun)this._runVector.elementAt(var1);
  168.          if (var3.charCount() == 0 && (var3._attributes == null || var3._attributes.get("LinkDestinationKey") == null)) {
  169.             this._runVector.removeElementAt(var1);
  170.             --var1;
  171.             --var2;
  172.          }
  173.       }
  174.  
  175.    }
  176.  
  177.    void addRuns(Vector var1) {
  178.       if (var1 != null) {
  179.          int var2 = var1.count();
  180.  
  181.          for(int var3 = 0; var3 < var2; ++var3) {
  182.             this.addRun((TextStyleRun)var1.elementAt(var3));
  183.          }
  184.       }
  185.  
  186.    }
  187.  
  188.    void insertRunAt(TextStyleRun var1, int var2) {
  189.       if (var1 != null && var2 >= 0) {
  190.          var1.setParagraph(this);
  191.          this._runVector.insertElementAt(var1, var2);
  192.       }
  193.  
  194.    }
  195.  
  196.    TextStyleRun runBefore(TextStyleRun var1) {
  197.       if (var1 == null) {
  198.          return null;
  199.       } else {
  200.          int var2 = this._runVector.indexOfIdentical(var1);
  201.          return var2 < 1 ? null : (TextStyleRun)this._runVector.elementAt(var2 - 1);
  202.       }
  203.    }
  204.  
  205.    TextStyleRun runAfter(TextStyleRun var1) {
  206.       if (var1 == null) {
  207.          return null;
  208.       } else {
  209.          int var2 = this._runVector.indexOfIdentical(var1);
  210.          return var2 == this._runVector.count() - 1 ? null : (TextStyleRun)this._runVector.elementAt(var2 + 1);
  211.       }
  212.    }
  213.  
  214.    Vector runsBefore(TextStyleRun var1) {
  215.       Vector var2 = TextView.newVector();
  216.       if (var1 == null) {
  217.          return var2;
  218.       } else {
  219.          int var4 = this._runVector.indexOfIdentical(var1);
  220.          if (var4 == -1) {
  221.             return var2;
  222.          } else {
  223.             for(int var3 = 0; var3 < var4; ++var3) {
  224.                var2.addElement(this._runVector.elementAt(var3));
  225.             }
  226.  
  227.             return var2;
  228.          }
  229.       }
  230.    }
  231.  
  232.    Vector runsAfter(TextStyleRun var1) {
  233.       Vector var2 = TextView.newVector();
  234.       if (var1 == null) {
  235.          return var2;
  236.       } else {
  237.          int var3 = this._runVector.indexOfIdentical(var1);
  238.          if (var3 == -1) {
  239.             return var2;
  240.          } else {
  241.             for(int var4 = this._runVector.count(); var3 < var4; ++var3) {
  242.                var2.addElement(this._runVector.elementAt(var3));
  243.             }
  244.  
  245.             return var2;
  246.          }
  247.       }
  248.    }
  249.  
  250.    Vector runsFromTo(TextStyleRun var1, TextStyleRun var2) {
  251.       Vector var3 = TextView.newVector();
  252.       if (var1 == var2 && var1 != null) {
  253.          var3.addElement(var1);
  254.          return var3;
  255.       } else {
  256.          int var4;
  257.          if (var1 == null) {
  258.             var4 = 0;
  259.          } else {
  260.             var4 = this._runVector.indexOfIdentical(var1);
  261.          }
  262.  
  263.          int var5;
  264.          if (var2 == null) {
  265.             var5 = this._runVector.count() - 1;
  266.          } else {
  267.             var5 = this._runVector.indexOfIdentical(var2);
  268.          }
  269.  
  270.          if (var4 >= 0 && var5 >= 0) {
  271.             while(var4 <= var5) {
  272.                var3.addElement(this._runVector.elementAt(var4));
  273.                ++var4;
  274.             }
  275.  
  276.             return var3;
  277.          } else {
  278.             return var3;
  279.          }
  280.       }
  281.    }
  282.  
  283.    void removeRun(TextStyleRun var1) {
  284.       if (var1 != null) {
  285.          this._runVector.removeElement(var1);
  286.       }
  287.  
  288.    }
  289.  
  290.    void removeRuns(Vector var1) {
  291.       if (var1 != null) {
  292.          int var2 = var1.count();
  293.  
  294.          while(var2-- > 0) {
  295.             this._runVector.removeElement(var1.elementAt(var2));
  296.          }
  297.  
  298.       }
  299.    }
  300.  
  301.    void removeRunAt(int var1) {
  302.       this._runVector.removeElementAt(var1);
  303.    }
  304.  
  305.    boolean isEmpty() {
  306.       int var3 = 0;
  307.  
  308.       TextStyleRun var1;
  309.       for(int var2 = this._runVector.count(); var2-- > 0 && var3 == 0; var3 += var1.charCount()) {
  310.          var1 = (TextStyleRun)this._runVector.elementAt(var2);
  311.       }
  312.  
  313.       return var3 == 0;
  314.    }
  315.  
  316.    int[] _growArrayTo(int[] var1, int var2) {
  317.       if (var2 < 1) {
  318.          return var1;
  319.       } else if (var1 != null && var1.length >= var2) {
  320.          return var1;
  321.       } else {
  322.          int[] var4 = var1;
  323.          int var3;
  324.          if (var1 != null) {
  325.             for(var3 = var1.length; var3 < var2; var3 *= 2) {
  326.             }
  327.          } else {
  328.             var3 = 20;
  329.          }
  330.  
  331.          var1 = new int[var3];
  332.          if (var4 == null) {
  333.             return var1;
  334.          } else {
  335.             System.arraycopy(var4, 0, var1, 0, var4.length);
  336.             return var1;
  337.          }
  338.       }
  339.    }
  340.  
  341.    void _addLineBreak(int var1) {
  342.       if (var1 >= 0) {
  343.          this._lineBreaks = this._growArrayTo(this._lineBreaks, this._breakCount + 1);
  344.          this._lineBreaks[this._breakCount] = var1;
  345.          ++this._breakCount;
  346.       }
  347.    }
  348.  
  349.    void _addLineHeightAndBaseline(int var1, int var2) {
  350.       if (var1 >= 0 && var2 >= 0) {
  351.          this._lineHeights = this._growArrayTo(this._lineHeights, this._heightCount + 1);
  352.          this._lineHeights[this._heightCount] = var1;
  353.          ++this._heightCount;
  354.          this._baselines = this._growArrayTo(this._baselines, this._baselineCount + 1);
  355.          this._baselines[this._baselineCount] = var2;
  356.          ++this._baselineCount;
  357.       }
  358.    }
  359.  
  360.    void _addLineRemainder(int var1) {
  361.       if (var1 < 0) {
  362.          var1 = 0;
  363.       }
  364.  
  365.       this._lineRemainders = this._growArrayTo(this._lineRemainders, this._remainderCount + 1);
  366.       this._lineRemainders[this._remainderCount] = var1;
  367.       ++this._remainderCount;
  368.    }
  369.  
  370.    int addWidthOfInitialTabs(int var1) {
  371.       int var8 = 0;
  372.       int[] var9 = this.currentParagraphFormat().tabPositions();
  373.       int var3 = 0;
  374.  
  375.       for(int var4 = this._runVector.count(); var3 < var4; ++var3) {
  376.          TextStyleRun var2 = (TextStyleRun)this._runVector.elementAt(var3);
  377.          FastStringBuffer var7 = var2._contents;
  378.          if (var7 == null || var7.length() == 0) {
  379.             break;
  380.          }
  381.  
  382.          int var5 = 0;
  383.  
  384.          int var6;
  385.          for(var6 = var7.length(); var5 < var6 && var7.charAt(var5) == '\t'; ++var5) {
  386.             ++var8;
  387.          }
  388.  
  389.          if (var5 < var6) {
  390.             break;
  391.          }
  392.       }
  393.  
  394.       if (var8 == 0) {
  395.          return var1;
  396.       } else {
  397.          var3 = 0;
  398.  
  399.          int var12;
  400.          for(var12 = var9.length; var3 < var12 && var9[var3] < var1; ++var3) {
  401.          }
  402.  
  403.          if (var3 == var12) {
  404.             return var1;
  405.          } else {
  406.             var3 += var8;
  407.             return var3 >= var9.length ? var9[var9.length - 1] : var9[var3 - 1];
  408.          }
  409.       }
  410.    }
  411.  
  412.    void computeLineBreaksAndHeights(int var1) {
  413.       this.computeLineBreaksAndHeights(var1, 0);
  414.    }
  415.  
  416.    void computeLineBreaksAndHeights(int var1, int var2) {
  417.       TextParagraphFormat var20 = this.currentParagraphFormat();
  418.       if (var2 > 0) {
  419.          --var2;
  420.       }
  421.  
  422.       this._breakCount = var2;
  423.       this._heightCount = var2;
  424.       this._baselineCount = var2;
  425.       this._remainderCount = var2;
  426.       if (var20._justification == 0 && var2 == 0) {
  427.          this._lineRemainders = null;
  428.       }
  429.  
  430.       var1 -= var20._leftMargin + var20._rightMargin;
  431.       if (var1 < 1) {
  432.          var1 = 1;
  433.       }
  434.  
  435.       int var9;
  436.       int var13;
  437.       if (var2 == 0) {
  438.          var9 = var1 - var20._leftIndent;
  439.          if (var9 < 1) {
  440.             var9 = 1;
  441.          }
  442.  
  443.          var13 = var9;
  444.          this._height = 0;
  445.          this._charCount = 0;
  446.       } else {
  447.          var9 = var1;
  448.          var13 = var1;
  449.          this._height = 0;
  450.  
  451.          for(int var5 = 0; var5 < var2; ++var5) {
  452.             this._height += this._lineHeights[var5];
  453.          }
  454.  
  455.          this._charCount = this._lineBreaks[var2 - 1];
  456.       }
  457.  
  458.       int var4 = this._runVector.count();
  459.       int var10 = this._charCount;
  460.       int var11 = 0;
  461.       int var12 = 0;
  462.       int var15 = 0;
  463.       int var14 = 0;
  464.       int var18 = var20._leftMargin;
  465.       int var19 = var18;
  466.       if (var2 == 0) {
  467.          var18 += var20._leftIndent;
  468.       }
  469.  
  470.       if (var20.wrapsUnderFirstCharacter()) {
  471.          var19 = this.addWidthOfInitialTabs(var20._leftMargin + var20._leftIndent);
  472.          var1 -= var19 - var18;
  473.          var9 = var1;
  474.       }
  475.  
  476.       TextStyleRun var3;
  477.       int var6;
  478.       int var7;
  479.       int var23;
  480.       if (var2 == 0) {
  481.          var23 = 0;
  482.          var3 = null;
  483.          var7 = 0;
  484.          var6 = 0;
  485.       } else {
  486.          var3 = this.runForCharPosition(this._startChar + this._charCount);
  487.          var23 = this._runVector.indexOfIdentical(var3) + 1;
  488.          var7 = var3.charCount();
  489.          var6 = this._startChar + this._charCount - var3.rangeIndex();
  490.          this._charCount += var7 - this._charCount;
  491.       }
  492.  
  493.       while(true) {
  494.          while(var3 == null || var6 >= var7) {
  495.             if (var23 == this._runVector.count()) {
  496.                this._addLineBreak(var10);
  497.                if (var11 == 0) {
  498.                   var3 = (TextStyleRun)this._runVector.firstElement();
  499.                   var11 = var3.height() + var20._lineSpacing;
  500.                   var12 = var3.baseline();
  501.                } else {
  502.                   var11 += var20._lineSpacing;
  503.                }
  504.  
  505.                this._addLineHeightAndBaseline(var11, var12);
  506.                this._height += var11;
  507.                this._addLineRemainder(var9);
  508.                ++this._charCount;
  509.                return;
  510.             }
  511.  
  512.             var3 = (TextStyleRun)this._runVector.elementAt(var23++);
  513.             if (var3.charCount() != 0) {
  514.                var6 = 0;
  515.                var7 = var3.charCount();
  516.                this._charCount += var7;
  517.                break;
  518.             }
  519.          }
  520.  
  521.          while(var6 < var7) {
  522.             int var8 = var3.charsForWidth(var6, var18, var9, var13, var20._tabStops);
  523.             if (var8 > 0) {
  524.                var6 += var8;
  525.                var10 += var8;
  526.                int var16 = var3.baseline();
  527.                int var17 = var3.height() - var3.baseline();
  528.                if (var14 < var16) {
  529.                   var14 = var16;
  530.                }
  531.  
  532.                if (var15 < var17) {
  533.                   var15 = var17;
  534.                }
  535.  
  536.                if (var14 + var15 > var11) {
  537.                   var11 = var14 + var15;
  538.                }
  539.  
  540.                if (var14 > var12) {
  541.                   var12 = var14;
  542.                }
  543.  
  544.                var18 += var9 - var3._remainder;
  545.                var9 = var3._remainder;
  546.             }
  547.  
  548.             if (var6 < var7) {
  549.                this._addLineBreak(var10);
  550.                this._addLineHeightAndBaseline(var11 + var20._lineSpacing, var12);
  551.                this._height += var11 + var20._lineSpacing;
  552.                this._addLineRemainder(var9);
  553.                var13 = var1;
  554.                var9 = var1;
  555.                var12 = 0;
  556.                var11 = 0;
  557.                var15 = 0;
  558.                var14 = 0;
  559.                var18 = var19;
  560.             }
  561.          }
  562.       }
  563.    }
  564.  
  565.    int characterStartingLine(int var1) {
  566.       if (var1 == 0) {
  567.          return this._startChar;
  568.       } else {
  569.          return var1 < this._breakCount ? this._startChar + this._lineBreaks[var1 - 1] : -1;
  570.       }
  571.    }
  572.  
  573.    Rect rectForLine(int var1) {
  574.       TextParagraphFormat var4 = this.currentParagraphFormat();
  575.       if (var1 >= this._breakCount) {
  576.          return null;
  577.       } else {
  578.          int var2 = this.field_0;
  579.  
  580.          int var3;
  581.          for(var3 = 0; var3 < var1; ++var3) {
  582.             var2 += this._lineHeights[var3];
  583.          }
  584.  
  585.          return TextView.newRect(var4._leftMargin, var2, this._owner.bounds.width - var4._rightMargin, this._lineHeights[var3]);
  586.       }
  587.    }
  588.  
  589.    Range rangeForLine(int var1) {
  590.       if (var1 >= this._breakCount) {
  591.          return new Range(this._startChar + this._charCount, 0);
  592.       } else {
  593.          return var1 == 0 ? new Range(this._startChar, this._lineBreaks[var1]) : new Range(this._startChar + this._lineBreaks[var1 - 1], this._lineBreaks[var1] - this._lineBreaks[var1 - 1]);
  594.       }
  595.    }
  596.  
  597.    int runIndexForCharPosition(int var1) {
  598.       int var3 = var1 - this._startChar;
  599.       int var4 = this._runVector.count();
  600.  
  601.       for(int var5 = 0; var5 < var4; ++var5) {
  602.          TextStyleRun var2 = (TextStyleRun)this._runVector.elementAt(var5);
  603.          if (var2.charCount() > var3) {
  604.             return var5;
  605.          }
  606.  
  607.          var3 -= var2.charCount();
  608.       }
  609.  
  610.       return this._runVector.count() - 1;
  611.    }
  612.  
  613.    TextStyleRun runForCharPosition(int var1) {
  614.       int var2 = this.runIndexForCharPosition(var1);
  615.       return var2 >= 0 ? (TextStyleRun)this._runVector.elementAt(var2) : null;
  616.    }
  617.  
  618.    char characterAt(int var1) {
  619.       if (this._charCount < 2) {
  620.          return '\n';
  621.       } else {
  622.          int var4 = var1 - this._startChar;
  623.          int var5 = this._runVector.count();
  624.  
  625.          for(int var6 = 0; var6 < var5; ++var6) {
  626.             TextStyleRun var2 = (TextStyleRun)this._runVector.elementAt(var6);
  627.             if (var2.charCount() > var4) {
  628.                char var3 = var2.charAt(var4);
  629.                return var3;
  630.             }
  631.  
  632.             var4 -= var2.charCount();
  633.          }
  634.  
  635.          return (char)(var4 < 2 ? '\n' : '\u0000');
  636.       }
  637.    }
  638.  
  639.    int lineForPosition(int var1) {
  640.       int var2 = var1 - this._startChar;
  641.       if (this._breakCount > 0 && var2 == this._lineBreaks[this._breakCount - 1]) {
  642.          return this._breakCount - 1;
  643.       } else {
  644.          int var3;
  645.          for(var3 = 0; var3 < this._breakCount && var2 >= this._lineBreaks[var3]; ++var3) {
  646.          }
  647.  
  648.          return var3 >= this._breakCount ? -1 : var3;
  649.       }
  650.    }
  651.  
  652.    TextPositionInfo positionForPoint(int var1, int var2, boolean var3) {
  653.       TextStyleRun var4 = null;
  654.       int var16 = 0;
  655.       TextParagraphFormat var18 = this.currentParagraphFormat();
  656.       int var7 = this.field_0;
  657.  
  658.       int var6;
  659.       for(var6 = 0; var6 < this._breakCount && (var2 < var7 || var2 > var7 + this._lineHeights[var6]); ++var6) {
  660.          var7 += this._lineHeights[var6];
  661.       }
  662.  
  663.       int var8;
  664.       if (var6 == 0) {
  665.          var8 = this._startChar;
  666.       } else {
  667.          var8 = this._startChar + this._lineBreaks[var6 - 1];
  668.       }
  669.  
  670.       int var9 = this._startChar + this._lineBreaks[var6];
  671.       int var17 = this._runVector.count();
  672.       int var10 = this._startChar;
  673.  
  674.       for(var6 = 0; var6 < var17; ++var6) {
  675.          var4 = (TextStyleRun)this._runVector.elementAt(var6);
  676.          if (var10 + var4.charCount() > var8) {
  677.             var16 = var8 - var10;
  678.             break;
  679.          }
  680.  
  681.          var10 += var4.charCount();
  682.       }
  683.  
  684.       if (var4 == null) {
  685.          return null;
  686.       } else {
  687.          int var11;
  688.          if (var18._justification == 0) {
  689.             var11 = var18._leftMargin;
  690.          } else if (var18._justification == 2) {
  691.             var11 = var18._leftMargin + this._lineRemainders[var6];
  692.          } else {
  693.             var11 = var18._leftMargin + this._lineRemainders[var6] / 2;
  694.          }
  695.  
  696.          int var12 = this._owner.bounds.width - var18._leftMargin - var18._rightMargin;
  697.          if (var6 == 0) {
  698.             var11 += var18._leftIndent;
  699.             var12 -= var18._leftIndent;
  700.          } else if (var18.wrapsUnderFirstCharacter()) {
  701.             int var19 = var11;
  702.             var11 = this.addWidthOfInitialTabs(var11 + var18._leftIndent);
  703.             var12 -= var11 - var19;
  704.          }
  705.  
  706.          if (var12 < 1) {
  707.             var12 = 1;
  708.          }
  709.  
  710.          if (var1 > var11 + var12 - this._lineRemainders[var6]) {
  711.             TextPositionInfo var5 = this.infoForPosition(var9, -1);
  712.             var5.setAtEndOfLine(true);
  713.             return var5;
  714.          } else if (var1 <= var11) {
  715.             return this.infoForPosition(var8, var2);
  716.          } else {
  717.             int var14;
  718.             for(var14 = var6 + 1; var4 != null && var4.charCount() == 0; ++var14) {
  719.                var4 = this.runAfter(var4);
  720.             }
  721.  
  722.             if (var4 == null) {
  723.                return this.infoForPosition(var8 + var10, var2);
  724.             } else {
  725.                while(var8 <= var9) {
  726.                   int var15 = var4.widthOfContents(var16, 1, var11, var18._tabStops);
  727.                   if (var1 >= var11 && var1 <= var11 + var15) {
  728.                      if (var3) {
  729.                         return this.infoForPosition(var8, var2);
  730.                      }
  731.  
  732.                      var15 /= 2;
  733.                      if (var1 >= var11 + var15) {
  734.                         return this.infoForPosition(var8 + 1, var2);
  735.                      }
  736.  
  737.                      return this.infoForPosition(var8, var2);
  738.                   }
  739.  
  740.                   ++var16;
  741.                   if (var16 >= var4.charCount()) {
  742.                      for(var4 = (TextStyleRun)this.objectAt(this._runVector, var14++); var4 != null && var4.charCount() == 0; ++var14) {
  743.                         var4 = this.runAfter(var4);
  744.                      }
  745.  
  746.                      if (var4 == null) {
  747.                         return this.infoForPosition(var8 + var10, var2);
  748.                      }
  749.  
  750.                      var16 = 0;
  751.                   }
  752.  
  753.                   ++var8;
  754.                   var11 += var15;
  755.                }
  756.  
  757.                return null;
  758.             }
  759.          }
  760.       }
  761.    }
  762.  
  763.    TextPositionInfo _infoForPosition(int var1) {
  764.       int var4 = 0;
  765.       int var5 = 0;
  766.       int var6 = 1;
  767.       int var7 = 0;
  768.       int var10 = 0;
  769.       TextParagraphFormat var15 = this.currentParagraphFormat();
  770.       int var3 = var1 - this._startChar;
  771.       int var12 = var3;
  772.       int var13 = this._owner.bounds.width - var15._leftMargin - var15._rightMargin;
  773.       int var8 = this.field_0;
  774.  
  775.       for(var4 = 0; var4 < this._breakCount - 1 && this._lineBreaks[var4] < var3; ++var4) {
  776.          var8 += this._lineHeights[var4];
  777.       }
  778.  
  779.       TextStyleRun var2;
  780.       int var11;
  781.       if (var4 > 0) {
  782.          var2 = this.runForCharPosition(this._startChar + this._lineBreaks[var4 - 1]);
  783.          var11 = this._lineBreaks[var4 - 1] + this._startChar - var2.rangeIndex();
  784.          var3 -= this._lineBreaks[var4 - 1];
  785.       } else {
  786.          var2 = (TextStyleRun)this._runVector.firstElement();
  787.          var11 = 0;
  788.       }
  789.  
  790.       while(var4 < this._breakCount) {
  791.          if (var4 == 0) {
  792.             var5 = this._lineBreaks[var4];
  793.          } else {
  794.             var5 = this._lineBreaks[var4] - this._lineBreaks[var4 - 1];
  795.          }
  796.  
  797.          if (var5 > var3) {
  798.             var5 = var3;
  799.          }
  800.  
  801.          if (var15._justification == 0) {
  802.             var7 = var15._leftMargin;
  803.          } else if (var15._justification == 2) {
  804.             var7 = var15._leftMargin + this._lineRemainders[var4];
  805.          } else {
  806.             var7 = var15._leftMargin + this._lineRemainders[var4] / 2;
  807.          }
  808.  
  809.          int var14 = var13;
  810.          if (var4 == 0) {
  811.             var7 += var15._leftIndent;
  812.             var14 = var13 - var15._leftIndent;
  813.          } else if (var15.wrapsUnderFirstCharacter()) {
  814.             int var16 = this.addWidthOfInitialTabs(var7 + var15._leftIndent);
  815.             var14 = var13 - (var16 - var7);
  816.             var7 = var16;
  817.          }
  818.  
  819.          if (var14 < 1) {
  820.             var14 = 1;
  821.          }
  822.  
  823.          if (var5 == 0) {
  824.             return new TextPositionInfo(var2, var7, var8, var4, this._lineHeights[var4], var11, var1);
  825.          }
  826.  
  827.          while(var5 > 0) {
  828.             int var9 = var2.charCount() - var11;
  829.             if (var5 < var9) {
  830.                if (var5 <= var3) {
  831.                   var10 = var2.widthOfContents(var11, var5, var7, var15._tabStops);
  832.                }
  833.  
  834.                var11 += var5;
  835.                var3 -= var5;
  836.                var5 = 0;
  837.             } else {
  838.                if (var5 <= var3) {
  839.                   var10 = var2.widthOfContents(var11, var5, var7, var15._tabStops);
  840.                }
  841.  
  842.                var5 -= var9;
  843.                var3 -= var9;
  844.  
  845.                for(var2 = (TextStyleRun)this.objectAt(this._runVector, var6++); var2 != null && var2.charCount() == 0; var2 = (TextStyleRun)this.objectAt(this._runVector, var6++)) {
  846.                }
  847.  
  848.                var11 = 0;
  849.             }
  850.  
  851.             var7 += var10;
  852.             var14 -= var10;
  853.             if (var3 == 0 || var2 == null && var3 == 1) {
  854.                if (var2 == null) {
  855.                   var2 = (TextStyleRun)this._runVector.lastElement();
  856.                   var11 = var2.charCount();
  857.                }
  858.  
  859.                TextPositionInfo var20 = new TextPositionInfo(var2, var7, var8, var4, this._lineHeights[var4], var11, var1);
  860.                if (var12 == this._lineBreaks[var4]) {
  861.                   var20.setAtEndOfLine(true);
  862.                   if (var4 == this._breakCount - 1) {
  863.                      var20.setAtEndOfParagraph(true);
  864.                   }
  865.                }
  866.  
  867.                return var20;
  868.             }
  869.          }
  870.  
  871.          var8 += this._lineHeights[var4];
  872.          ++var4;
  873.       }
  874.  
  875.       return null;
  876.    }
  877.  
  878.    TextPositionInfo infoForPosition(int var1, int var2) {
  879.       TextParagraphFormat var7 = this.currentParagraphFormat();
  880.       TextPositionInfo var3 = this._infoForPosition(var1);
  881.       if (var3 == null) {
  882.          var3 = this._infoForPosition(this._startChar + this._charCount);
  883.          return var3;
  884.       } else if (var2 < var3.maxY()) {
  885.          return var3;
  886.       } else {
  887.          TextPositionInfo var4 = this._infoForPosition(var1 + 1);
  888.          if (var4 != null && var4._lineNumber != var3._lineNumber) {
  889.             int var5 = var4._lineNumber;
  890.             int var6;
  891.             if (var7._justification == 0) {
  892.                var6 = var7._leftMargin;
  893.             } else if (var7._justification == 2) {
  894.                var6 = var7._leftMargin + this._lineRemainders[var5];
  895.             } else {
  896.                var6 = var7._leftMargin + this._lineRemainders[var5] / 2;
  897.             }
  898.  
  899.             var3 = new TextPositionInfo(var3._textRun, var6, var4._y, var4._lineNumber, var4._lineHeight, var3._positionInRun, var3._absPosition);
  900.             var3.setNextLine(true);
  901.             return var3;
  902.          } else {
  903.             return var3;
  904.          }
  905.       }
  906.    }
  907.  
  908.    TextPositionInfo insertCharOrStringAt(char var1, String var2, int var3) {
  909.       TextStyleRun var7 = null;
  910.       if (var2 == null && var1 == 0) {
  911.          return null;
  912.       } else {
  913.          int var11 = var3 - this._startChar;
  914.          int var10 = this._runVector.count();
  915.  
  916.          int var9;
  917.          for(var9 = 0; var9 < var10; ++var9) {
  918.             var7 = (TextStyleRun)this.objectAt(this._runVector, var9);
  919.             if (var7 == null) {
  920.                break;
  921.             }
  922.  
  923.             if (var7.charCount() >= var11) {
  924.                if (var7.containsATextAttachment()) {
  925.                   if (var11 == 0) {
  926.                      TextStyleRun var8 = var7.createEmptyRun();
  927.                      this.insertRunAt(var8, this._runVector.indexOfIdentical(var7));
  928.                      var7 = var8;
  929.                   } else {
  930.                      Object var16 = null;
  931.                      if (var9 > 0) {
  932.                         TextStyleRun var20 = (TextStyleRun)this.objectAt(this._runVector, var9 - 1);
  933.                         TextStyleRun var18 = var20.createEmptyRun(TextView.attributesByRemovingStaticAttributes(var20.attributes()));
  934.                         this.insertRunAt(var18, this._runVector.indexOfIdentical(var7) + 1);
  935.                         var7 = var18;
  936.                      } else {
  937.                         var7 = (TextStyleRun)this.objectAt(this._runVector, 0);
  938.                         TextStyleRun var19 = var7.createEmptyRun(TextView.attributesByRemovingStaticAttributes(var7.attributes()));
  939.                         this.insertRunAt(var19, 1);
  940.                         var7 = var19;
  941.                      }
  942.  
  943.                      if (var7 == null) {
  944.                         var7 = new TextStyleRun(this, "", (Hashtable)null);
  945.                         this.addRun(var7);
  946.                      }
  947.                   }
  948.  
  949.                   var11 = 0;
  950.                }
  951.                break;
  952.             }
  953.  
  954.             var11 -= var7.charCount();
  955.          }
  956.  
  957.          if ((var9 >= var10 || var7 == null) && var11 == 1) {
  958.             var7 = (TextStyleRun)this._runVector.lastElement();
  959.             var11 = var7.charCount();
  960.          } else if (var7 == null) {
  961.             return null;
  962.          }
  963.  
  964.          int var12 = this.lineForPosition(var3 - 1);
  965.          int var14 = this._lineBreaks[var12] + this._startChar;
  966.          TextPositionInfo var4 = this.infoForPosition(var14, -1);
  967.          int var15 = this._height;
  968.          int var13;
  969.          if (var2 != null) {
  970.             var7.insertStringAt(var2, var11);
  971.             var13 = var2.length();
  972.          } else {
  973.             var7.insertCharAt(var1, var11);
  974.             var13 = 1;
  975.          }
  976.  
  977.          this.computeLineBreaksAndHeights(this._owner.bounds.width, var12);
  978.          TextPositionInfo var5 = this.infoForPosition(var3 + var13, -1);
  979.          if (var15 != this._height) {
  980.             var5.setRedrawCurrentParagraphOnly(false);
  981.             var5.setRedrawCurrentLineOnly(false);
  982.             return var5;
  983.          } else {
  984.             var5.setRedrawCurrentParagraphOnly(true);
  985.             if (var5._lineNumber != var4._lineNumber) {
  986.                var5.setRedrawCurrentParagraphOnly(false);
  987.                if (var4._lineNumber < var5._lineNumber) {
  988.                   var5.setUpdateLine(var4._lineNumber);
  989.                } else {
  990.                   var5.setUpdateLine(var5._lineNumber);
  991.                }
  992.  
  993.                return var5;
  994.             } else {
  995.                var5.setRedrawCurrentParagraphOnly(true);
  996.                TextPositionInfo var6 = this.infoForPosition(var14 + 1, -1);
  997.                if (var6 != null && var4 != null && var6._lineNumber == var4._lineNumber) {
  998.                   if (this.currentParagraphFormat().wrapsUnderFirstCharacter()) {
  999.                      var5.setRedrawCurrentLineOnly(false);
  1000.                   } else {
  1001.                      var5.setRedrawCurrentLineOnly(true);
  1002.                   }
  1003.                } else {
  1004.                   var5.setRedrawCurrentLineOnly(false);
  1005.                }
  1006.  
  1007.                return var5;
  1008.             }
  1009.          }
  1010.       }
  1011.    }
  1012.  
  1013.    TextPositionInfo removeCharAt(int var1) {
  1014.       TextStyleRun var7 = null;
  1015.       if (var1 <= this._startChar) {
  1016.          return null;
  1017.       } else {
  1018.          --var1;
  1019.          int var10 = var1 - this._startChar;
  1020.          int var9 = this._runVector.count();
  1021.  
  1022.          int var8;
  1023.          for(var8 = 0; var8 < var9; ++var8) {
  1024.             var7 = (TextStyleRun)this._runVector.elementAt(var8);
  1025.             if (var7.charCount() > var10) {
  1026.                break;
  1027.             }
  1028.  
  1029.             var10 -= var7.charCount();
  1030.          }
  1031.  
  1032.          if ((var8 >= var9 || var7 == null) && var10 == 0) {
  1033.             var7 = (TextStyleRun)this._runVector.lastElement();
  1034.             var10 = var7.charCount() - 1;
  1035.          } else if (var7 == null) {
  1036.             return null;
  1037.          }
  1038.  
  1039.          int var11 = this.lineForPosition(var1 - 1);
  1040.          int var12;
  1041.          if (var11 == 0) {
  1042.             var12 = this._startChar + 1;
  1043.          } else {
  1044.             var12 = this._lineBreaks[var11 - 1] + this._startChar + 1;
  1045.          }
  1046.  
  1047.          int var13 = this._lineBreaks[var11] + this._startChar + 1;
  1048.          if (var13 > this._startChar + this._charCount) {
  1049.             var13 = this._startChar + this._charCount;
  1050.          }
  1051.  
  1052.          TextPositionInfo var3 = this.infoForPosition(var13, -1);
  1053.          TextPositionInfo var2 = this.infoForPosition(var12, -1);
  1054.          int var14 = this._height;
  1055.          var7.removeCharAt(var10);
  1056.          if (var7.charCount() == 0 && this._runVector.count() > 1) {
  1057.             this._runVector.removeElement(var7);
  1058.          }
  1059.  
  1060.          this.computeLineBreaksAndHeights(this._owner.bounds.width);
  1061.          TextPositionInfo var4 = this.infoForPosition(var1, -1);
  1062.          if (var14 == this._height) {
  1063.             var4.setRedrawCurrentParagraphOnly(true);
  1064.          }
  1065.  
  1066.          if (var4._lineNumber != var2._lineNumber) {
  1067.             if (var2._lineNumber < var4._lineNumber) {
  1068.                var4.setUpdateLine(var2._lineNumber);
  1069.             } else {
  1070.                var4.setUpdateLine(var4._lineNumber);
  1071.             }
  1072.  
  1073.             return var4;
  1074.          } else {
  1075.             TextPositionInfo var6 = this.infoForPosition(var13 - 1, -1);
  1076.             if (var3._lineNumber != var6._lineNumber) {
  1077.                if (var3._lineNumber < var6._lineNumber) {
  1078.                   var4.setUpdateLine(var3._lineNumber);
  1079.                } else {
  1080.                   var4.setUpdateLine(var6._lineNumber);
  1081.                }
  1082.  
  1083.                return var4;
  1084.             } else {
  1085.                TextPositionInfo var5 = this.infoForPosition(var12, -1);
  1086.                if (var14 == this._height && var5 != null && var2 != null && var5._lineNumber == var2._lineNumber) {
  1087.                   if (this.currentParagraphFormat().wrapsUnderFirstCharacter()) {
  1088.                      var4.setRedrawCurrentLineOnly(false);
  1089.                   } else {
  1090.                      var4.setRedrawCurrentLineOnly(true);
  1091.                   }
  1092.                }
  1093.  
  1094.                return var4;
  1095.             }
  1096.          }
  1097.       }
  1098.    }
  1099.  
  1100.    TextStyleRun createNewRunAt(int var1) {
  1101.       TextPositionInfo var2 = this.infoForPosition(var1, -1);
  1102.       if (var2 == null) {
  1103.          return null;
  1104.       } else {
  1105.          int var4 = this._runVector.indexOfIdentical(var2._textRun);
  1106.          TextStyleRun var3 = var2._textRun.breakAt(var2._positionInRun);
  1107.          this.insertRunAt(var3, var4 + 1);
  1108.          return var3;
  1109.       }
  1110.    }
  1111.  
  1112.    TextParagraph createNewParagraphAt(int var1) {
  1113.       Object var3 = null;
  1114.       TextParagraphFormat var9 = this.currentParagraphFormat();
  1115.       this.collectEmptyRuns();
  1116.       TextStyleRun var11 = this.runForCharPosition(var1);
  1117.       int var10 = var1 - var11.rangeIndex();
  1118.       TextParagraph var2 = new TextParagraph(this._owner, var9);
  1119.       int var7;
  1120.       if (var10 == 0) {
  1121.          var7 = this._runVector.indexOfIdentical(var11);
  1122.          Hashtable var12 = TextView.attributesByRemovingStaticAttributes(var11.attributes());
  1123.          if (var7 == 0) {
  1124.             TextStyleRun var13 = var11.createEmptyRun(var12);
  1125.             this._runVector.insertElementAt(var13, 0);
  1126.          } else {
  1127.             --var7;
  1128.          }
  1129.  
  1130.          var2.addRun(new TextStyleRun(this, "", var12));
  1131.       } else if (var11.containsATextAttachment()) {
  1132.          var7 = this._runVector.indexOfIdentical(var11);
  1133.          int var17 = var7 - 1;
  1134.  
  1135.          TextStyleRun var5;
  1136.          for(var5 = null; var17 > 0; --var17) {
  1137.             var5 = (TextStyleRun)this.objectAt(this._runVector, var17);
  1138.             if (var5 == null || !var5.containsATextAttachment()) {
  1139.                break;
  1140.             }
  1141.          }
  1142.  
  1143.          if (var5 == null) {
  1144.             TextStyleRun var14 = new TextStyleRun(this, "", (Hashtable)null);
  1145.             var2.addRun(var14);
  1146.          } else {
  1147.             TextStyleRun var15 = new TextStyleRun(this, "", TextView.attributesByRemovingStaticAttributes(var5.attributes()));
  1148.             var2.addRun(var15);
  1149.          }
  1150.       } else {
  1151.          TextStyleRun var4 = var11.breakAt(var10);
  1152.          var2.addRun(var4);
  1153.          var7 = this._runVector.indexOfIdentical(var11);
  1154.       }
  1155.  
  1156.       if (var7 < 0) {
  1157.          return var2;
  1158.       } else {
  1159.          ++var7;
  1160.          int var6 = this._runVector.count();
  1161.  
  1162.          int var8;
  1163.          for(var8 = 0; var7 < var6; ++var8) {
  1164.             var2.addRun((TextStyleRun)this._runVector.elementAt(var7));
  1165.             ++var7;
  1166.          }
  1167.  
  1168.          while(var8-- > 0) {
  1169.             this._runVector.removeLastElement();
  1170.          }
  1171.  
  1172.          return var2;
  1173.       }
  1174.    }
  1175.  
  1176.    void drawBackgroundForLine(Graphics var1, int var2, int var3, int var4) {
  1177.       Rect var7 = null;
  1178.       TextParagraphFormat var16 = this.currentParagraphFormat();
  1179.       TextParagraphFormat var17 = (TextParagraphFormat)this._owner.defaultAttributes().get("ParagraphFormatKey");
  1180.       int var12 = this._owner.bounds.width - var16._leftMargin - var16._rightMargin;
  1181.       int var13 = this._owner.bounds.width - var17._leftMargin - var17._rightMargin;
  1182.       if (var2 == 0) {
  1183.          int var10000 = var12 - var16._leftIndent;
  1184.       }
  1185.  
  1186.       if (var2 >= 0 && var2 < this._breakCount && (this._owner.hasSelectionRange() || this._owner.insertionPointVisible)) {
  1187.          int var10 = this._owner.selectionStart();
  1188.          int var11 = this._owner.selectionEnd();
  1189.          TextPositionInfo var5 = this._owner.selectionStartInfo();
  1190.          TextPositionInfo var6 = this._owner.selectionEndInfo();
  1191.          int var14;
  1192.          if (var2 == 0) {
  1193.             var14 = this._startChar;
  1194.          } else {
  1195.             var14 = this._startChar + this._lineBreaks[var2 - 1];
  1196.          }
  1197.  
  1198.          int var15 = this._startChar + this._lineBreaks[var2];
  1199.          if (var2 == this._breakCount - 1) {
  1200.             ++var15;
  1201.          }
  1202.  
  1203.          if (var10 != var11 && var10 <= var15 && var11 >= var14) {
  1204.             Rect var8;
  1205.             Rect var9;
  1206.             if (var14 >= var10 && var15 <= var11) {
  1207.                var7 = TextView.newRect(var17._leftMargin, var4, var13, this._lineHeights[var2]);
  1208.                var9 = null;
  1209.                var8 = null;
  1210.             } else if (var14 >= var10 && var15 > var11 && var14 < var11) {
  1211.                if (var10 == var14) {
  1212.                   var7 = TextView.newRect(var3, var4, var6._x - var3, this._lineHeights[var2]);
  1213.                } else {
  1214.                   var7 = TextView.newRect(var17._leftMargin, var4, var6._x - var17._leftMargin, this._lineHeights[var2]);
  1215.                }
  1216.  
  1217.                var8 = TextView.newRect(var7.maxX(), var4, var13 - var7.width, this._lineHeights[var2]);
  1218.                var9 = null;
  1219.             } else if (var14 < var10 && var10 < var15 && var15 <= var11) {
  1220.                if (var5._textRun._paragraph == this && var5._lineNumber <= var2) {
  1221.                   var7 = TextView.newRect(var5._x, var4, this._owner.bounds.width - var17._rightMargin - var5._x, this._lineHeights[var2]);
  1222.                   var8 = TextView.newRect(var17._leftMargin, var4, var7.x - var17._leftMargin, this._lineHeights[var2]);
  1223.                } else {
  1224.                   var8 = TextView.newRect(var17._leftMargin, var4, var13, this._lineHeights[var2]);
  1225.                }
  1226.  
  1227.                var9 = null;
  1228.             } else if (var14 < var10 && var15 > var11) {
  1229.                var7 = TextView.newRect(var5._x, var4, var6._x - var5._x, this._lineHeights[var2]);
  1230.                var8 = TextView.newRect(var7.maxX(), var4, var13 - var7.width, this._lineHeights[var2]);
  1231.                var9 = TextView.newRect(var17._leftMargin, var4, var7.x - var17._leftMargin, this._lineHeights[var2]);
  1232.             } else {
  1233.                var8 = TextView.newRect(var17._leftMargin, var4, var13, this._lineHeights[var2]);
  1234.                var9 = null;
  1235.             }
  1236.  
  1237.             if (!this._owner.isTransparent()) {
  1238.                var1.setColor(this._owner._backgroundColor);
  1239.                if (var8 != null) {
  1240.                   var1.fillRect(var8);
  1241.                   TextView.returnRect(var8);
  1242.                }
  1243.  
  1244.                if (var9 != null) {
  1245.                   var1.fillRect(var9);
  1246.                   TextView.returnRect(var9);
  1247.                }
  1248.             }
  1249.  
  1250.             if (this._owner.hasSelectionRange() && var7 != null && this._owner.isSelectable()) {
  1251.                if (var7.width == 0 && var7.x == var3) {
  1252.                   var7.sizeTo(4, var7.height);
  1253.                }
  1254.  
  1255.                if (!this._owner.isEditing()) {
  1256.                   if (!this._owner.isTransparent()) {
  1257.                      var1.setColor(this._owner._backgroundColor);
  1258.                      var1.fillRect(var7);
  1259.                   }
  1260.                } else {
  1261.                   var1.setColor(this._owner._selectionColor);
  1262.                   var1.fillRect(var7);
  1263.                }
  1264.  
  1265.                TextView.returnRect(var7);
  1266.             }
  1267.  
  1268.          } else {
  1269.             if (!this._owner.isTransparent()) {
  1270.                var1.setColor(this._owner._backgroundColor);
  1271.                var1.fillRect(var17._leftMargin, var4, var13, this._lineHeights[var2]);
  1272.             }
  1273.  
  1274.          }
  1275.       } else {
  1276.          if (!this._owner.isTransparent()) {
  1277.             var1.setColor(this._owner._backgroundColor);
  1278.             var1.fillRect(var17._leftMargin, var4, var13, this._lineHeights[var2]);
  1279.          }
  1280.  
  1281.       }
  1282.    }
  1283.  
  1284.    void drawLine(Graphics var1, int var2) {
  1285.       int var5 = 0;
  1286.       int var6 = 1;
  1287.       int var11 = 0;
  1288.       TextParagraphFormat var14 = this.currentParagraphFormat();
  1289.       if (var2 < this._breakCount) {
  1290.          int var12 = this._owner.bounds.width - var14._leftMargin - var14._rightMargin;
  1291.          int var8 = this.field_0;
  1292.          if (!this._owner.isTransparent()) {
  1293.             var1.setColor(this._owner._backgroundColor);
  1294.             var1.fillRect(0, var8, var14._leftMargin, this._height);
  1295.             var1.fillRect(this._owner.bounds.width - var14._rightMargin, var8, var14._rightMargin + 1, this._height);
  1296.          }
  1297.  
  1298.          TextStyleRun var3 = (TextStyleRun)this._runVector.firstElement();
  1299.          int var10 = 0;
  1300.  
  1301.          for(int var4 = 0; var4 <= var2; ++var4) {
  1302.             int var7;
  1303.             if (var14._justification == 0) {
  1304.                var7 = var14._leftMargin;
  1305.             } else if (var14._justification == 2) {
  1306.                var7 = var14._leftMargin + this._lineRemainders[var4];
  1307.             } else {
  1308.                var7 = var14._leftMargin + this._lineRemainders[var4] / 2;
  1309.             }
  1310.  
  1311.             int var13 = var12;
  1312.             if (var4 == 0) {
  1313.                var7 += var14._leftIndent;
  1314.                var13 = var12 - var14._leftIndent;
  1315.             } else if (var14.wrapsUnderFirstCharacter()) {
  1316.                int var15 = this.addWidthOfInitialTabs(var7 + var14._leftIndent);
  1317.                var13 = var12 - (var15 - var7);
  1318.                var7 = var15;
  1319.             }
  1320.  
  1321.             if (var4 == 0) {
  1322.                var5 = this._lineBreaks[var4];
  1323.             } else {
  1324.                var5 = this._lineBreaks[var4] - this._lineBreaks[var4 - 1];
  1325.             }
  1326.  
  1327.             if (var4 == var2) {
  1328.                this.drawBackgroundForLine(var1, var4, var7, var8);
  1329.             }
  1330.  
  1331.             while(var5 > 0) {
  1332.                int var9 = var3.charCount() - var10;
  1333.                if (var5 < var9) {
  1334.                   if (var4 == var2) {
  1335.                      var11 = var3.drawCharacters(var1, var10, var5, var7, var8 + this._baselines[var4], var14._tabStops);
  1336.                   }
  1337.  
  1338.                   var10 += var5;
  1339.                   var5 = 0;
  1340.                } else {
  1341.                   if (var4 == var2) {
  1342.                      var11 = var3.drawCharacters(var1, var10, var9, var7, var8 + this._baselines[var4], var14._tabStops);
  1343.                   }
  1344.  
  1345.                   var5 -= var9;
  1346.  
  1347.                   for(var3 = (TextStyleRun)this.objectAt(this._runVector, var6++); var3 != null && var3.charCount() == 0; var3 = (TextStyleRun)this.objectAt(this._runVector, var6++)) {
  1348.                   }
  1349.  
  1350.                   var10 = 0;
  1351.                }
  1352.  
  1353.                var7 += var11;
  1354.                var13 -= var11;
  1355.             }
  1356.  
  1357.             var8 += this._lineHeights[var4];
  1358.          }
  1359.  
  1360.       }
  1361.    }
  1362.  
  1363.    void drawView(Graphics var1, Rect var2) {
  1364.       int var7 = 0;
  1365.       int var8 = 1;
  1366.       TextParagraphFormat var17 = this.currentParagraphFormat();
  1367.       TextParagraphFormat var18 = (TextParagraphFormat)this._owner.defaultAttributes().get("ParagraphFormatKey");
  1368.       int var15 = this._owner.bounds.width - var17._leftMargin - var17._rightMargin;
  1369.       int var10 = this.field_0;
  1370.       if (!this._owner.isTransparent()) {
  1371.          var1.setColor(this._owner._backgroundColor);
  1372.          var1.fillRect(var2.maxX() - var18._rightMargin, var10, var18._rightMargin + 1, this._height);
  1373.       }
  1374.  
  1375.       TextStyleRun var3 = (TextStyleRun)this._runVector.firstElement();
  1376.       int var12 = 0;
  1377.       Rect var4 = TextView.newRect();
  1378.       Rect var5 = var1.clipRect();
  1379.  
  1380.       for(int var6 = 0; var6 < this._breakCount; ++var6) {
  1381.          int var9;
  1382.          if (var17._justification == 0) {
  1383.             var9 = var2.x + var17._leftMargin;
  1384.          } else if (var17._justification == 2) {
  1385.             var9 = var2.x + var17._leftMargin + this._lineRemainders[var6];
  1386.          } else {
  1387.             var9 = var2.x + var17._leftMargin + this._lineRemainders[var6] / 2;
  1388.          }
  1389.  
  1390.          int var14 = var15;
  1391.          if (var6 == 0) {
  1392.             var9 += var17._leftIndent;
  1393.             var14 = var15 - var17._leftIndent;
  1394.          } else if (var17.wrapsUnderFirstCharacter()) {
  1395.             int var19 = this.addWidthOfInitialTabs(var9 + var17._leftIndent);
  1396.             var14 = var15 - (var19 - var9);
  1397.             var9 = var19;
  1398.          }
  1399.  
  1400.          if (var6 == 0) {
  1401.             var7 = this._lineBreaks[var6];
  1402.          } else {
  1403.             var7 = this._lineBreaks[var6] - this._lineBreaks[var6 - 1];
  1404.          }
  1405.  
  1406.          var4.setBounds(0, var10, this._owner.bounds.width, this._lineHeights[var6]);
  1407.          boolean var16 = var5.intersects(var4);
  1408.          if (!this._owner.isTransparent()) {
  1409.             var1.setColor(this._owner.backgroundColor());
  1410.             var1.fillRect(var2.x, var10, var9 - var2.x, this._lineHeights[var6]);
  1411.          }
  1412.  
  1413.          if (var16) {
  1414.             this.drawBackgroundForLine(var1, var6, var9, var10);
  1415.          }
  1416.  
  1417.          while(var7 > 0) {
  1418.             int var11 = var3.charCount() - var12;
  1419.             int var13;
  1420.             if (var7 < var11) {
  1421.                if (var16) {
  1422.                   var13 = var3.drawCharacters(var1, var12, var7, var9, var10 + this._baselines[var6], var17._tabStops);
  1423.                } else {
  1424.                   var13 = 0;
  1425.                }
  1426.  
  1427.                var12 += var7;
  1428.                var7 = 0;
  1429.             } else {
  1430.                if (var16) {
  1431.                   var13 = var3.drawCharacters(var1, var12, var11, var9, var10 + this._baselines[var6], var17._tabStops);
  1432.                } else {
  1433.                   var13 = 0;
  1434.                }
  1435.  
  1436.                var7 -= var11;
  1437.  
  1438.                for(var3 = (TextStyleRun)this.objectAt(this._runVector, var8++); var3 != null && var3.charCount() == 0; var3 = (TextStyleRun)this.objectAt(this._runVector, var8++)) {
  1439.                }
  1440.  
  1441.                var12 = 0;
  1442.             }
  1443.  
  1444.             var9 += var13;
  1445.             var14 -= var13;
  1446.          }
  1447.  
  1448.          var10 += this._lineHeights[var6];
  1449.       }
  1450.  
  1451.       TextView.returnRect(var4);
  1452.    }
  1453.  
  1454.    void draw() {
  1455.       if (this._owner != null) {
  1456.          Rect var1 = TextView.newRect(0, this.field_0, this._owner.bounds.width, this._height);
  1457.          this._owner.draw(var1);
  1458.          TextView.returnRect(var1);
  1459.       }
  1460.  
  1461.    }
  1462.  
  1463.    void subsumeParagraph(TextParagraph var1) {
  1464.       if (var1 != null) {
  1465.          int var3 = var1._runVector.count();
  1466.  
  1467.          for(int var4 = 0; var4 < var3; ++var4) {
  1468.             TextStyleRun var2 = (TextStyleRun)var1._runVector.elementAt(var4);
  1469.             if (var2.charCount() > 0 || this._runVector.isEmpty() && var4 + 1 == var3) {
  1470.                this.addRun(var2);
  1471.             }
  1472.          }
  1473.  
  1474.       }
  1475.    }
  1476.  
  1477.    public String toString() {
  1478.       FastStringBuffer var2 = new FastStringBuffer();
  1479.       var2.append("[");
  1480.       int var4 = this._runVector.count();
  1481.  
  1482.       for(int var3 = 0; var3 < var4; ++var3) {
  1483.          TextStyleRun var1 = (TextStyleRun)this._runVector.elementAt(var3);
  1484.          var2.append(var1.toString());
  1485.       }
  1486.  
  1487.       var2.append("]\n");
  1488.       return var2.toString();
  1489.    }
  1490.  
  1491.    public void describeClassInfo(ClassInfo var1) {
  1492.       var1.addClass("netscape.application.TextParagraph", 1);
  1493.       var1.addField("format", (byte)18);
  1494.       var1.addField("runVector", (byte)18);
  1495.    }
  1496.  
  1497.    public void encode(Encoder var1) throws CodingException {
  1498.       var1.encodeObject("format", this._format);
  1499.       var1.encodeObject("runVector", this._runVector);
  1500.    }
  1501.  
  1502.    public void decode(Decoder var1) throws CodingException {
  1503.       this._format = (TextParagraphFormat)var1.decodeObject("format");
  1504.       this._runVector = (Vector)var1.decodeObject("runVector");
  1505.       int var3 = this._runVector.count();
  1506.  
  1507.       while(var3-- > 0) {
  1508.          TextStyleRun var2 = (TextStyleRun)this._runVector.elementAt(var3);
  1509.          var2.setParagraph(this);
  1510.       }
  1511.  
  1512.    }
  1513.  
  1514.    public void finishDecoding() throws CodingException {
  1515.    }
  1516.  
  1517.    String stringForRange(Range var1) {
  1518.       StringBuffer var3 = new StringBuffer();
  1519.       int var6 = this._startChar;
  1520.       Range var7 = TextView.allocateRange();
  1521.       int var4 = 0;
  1522.  
  1523.       for(int var5 = this._runVector.count(); var4 < var5; ++var4) {
  1524.          TextStyleRun var2 = (TextStyleRun)this._runVector.elementAt(var4);
  1525.          var7.index = var6;
  1526.          var7.length = var2.charCount();
  1527.          var7.intersectWith(var1);
  1528.          if (var7.index != Range.nullRange().index) {
  1529.             String var8 = var2.text().substring(var7.index - var6, var7.index - var6 + var7.length);
  1530.             var3.append(var8);
  1531.          }
  1532.  
  1533.          var6 += var2.charCount();
  1534.       }
  1535.  
  1536.       if (var1.index + var1.length - 1 == this._startChar + this._charCount - 1) {
  1537.          var3.append("\n");
  1538.       }
  1539.  
  1540.       TextView.recycleRange(var7);
  1541.       return var3.toString();
  1542.    }
  1543.  
  1544.    Range range() {
  1545.       return TextView.allocateRange(this._startChar, this._charCount);
  1546.    }
  1547.  
  1548.    int lineCount() {
  1549.       return this._breakCount;
  1550.    }
  1551. }
  1552.