home *** CD-ROM | disk | FTP | other *** search
/ Computer Shopper 144 / DPCS0200.iso / Internet / Supanet / system / swing.jar / javax / swing / text / DefaultStyledDocument$ElementBuffer.class (.txt) < prev    next >
Encoding:
Java Class File  |  1998-11-05  |  12.3 KB  |  729 lines

  1. package javax.swing.text;
  2.  
  3. import java.io.Serializable;
  4. import java.util.Stack;
  5. import java.util.Vector;
  6.  
  7. public class DefaultStyledDocument$ElementBuffer implements Serializable {
  8.    // $FF: synthetic field
  9.    private final DefaultStyledDocument this$0;
  10.    Element root;
  11.    transient int pos;
  12.    transient int offset;
  13.    transient int length;
  14.    transient int endOffset;
  15.    transient Vector endJoin;
  16.    transient Vector changes;
  17.    transient Stack path;
  18.    transient boolean insertOp;
  19.    transient boolean recreateLeafs;
  20.    transient DefaultStyledDocument.ElementBuffer.ElemChanges[] insertPath;
  21.    transient boolean createdFracture;
  22.    transient Element fracturedParent;
  23.    transient Element fracturedChild;
  24.    transient boolean offsetLastIndex;
  25.    transient boolean offsetLastIndexOnReplace;
  26.  
  27.    public DefaultStyledDocument$ElementBuffer(DefaultStyledDocument var1, Element var2) {
  28.       this.this$0 = var1;
  29.       this.root = var2;
  30.       this.changes = new Vector();
  31.       this.path = new Stack();
  32.       this.endJoin = new Vector();
  33.    }
  34.  
  35.    void advance(int var1) {
  36.       this.pos += var1;
  37.    }
  38.  
  39.    void beginEdits(int var1, int var2) {
  40.       this.offset = var1;
  41.       this.length = var2;
  42.       this.endOffset = var1 + var2;
  43.       this.pos = var1;
  44.       if (this.changes == null) {
  45.          this.changes = new Vector();
  46.       } else {
  47.          this.changes.removeAllElements();
  48.       }
  49.  
  50.       if (this.path == null) {
  51.          this.path = new Stack();
  52.       } else {
  53.          this.path.removeAllElements();
  54.       }
  55.  
  56.       if (this.endJoin == null) {
  57.          this.endJoin = new Vector();
  58.       } else {
  59.          this.endJoin.removeAllElements();
  60.       }
  61.  
  62.       this.fracturedParent = null;
  63.       this.fracturedChild = null;
  64.       this.offsetLastIndex = this.offsetLastIndexOnReplace = false;
  65.    }
  66.  
  67.    boolean canJoin(Element var1, Element var2) {
  68.       if (var1 != null && var2 != null) {
  69.          if (var1.isLeaf() != var2.isLeaf()) {
  70.             return false;
  71.          } else {
  72.             return var1.getName().equals("paragraph") && var2.getName().equals("paragraph") ? true : var1.getAttributes().isEqual(var2.getAttributes());
  73.          }
  74.       } else {
  75.          return false;
  76.       }
  77.    }
  78.  
  79.    public void change(int var1, int var2, AbstractDocument.DefaultDocumentEvent var3) {
  80.       this.beginEdits(var1, var2);
  81.       this.changeUpdate();
  82.       this.endEdits(var3);
  83.    }
  84.  
  85.    protected void changeUpdate() {
  86.       boolean var1 = this.split(this.offset, this.length);
  87.       if (!var1) {
  88.          while(this.path.size() != 0) {
  89.             this.pop();
  90.          }
  91.  
  92.          this.split(this.offset + this.length, 0);
  93.       }
  94.  
  95.       while(this.path.size() != 0) {
  96.          this.pop();
  97.       }
  98.  
  99.    }
  100.  
  101.    public Element clone(Element var1, Element var2) {
  102.       if (var2.isLeaf()) {
  103.          return this.this$0.createLeafElement(var1, var2.getAttributes(), var2.getStartOffset(), var2.getEndOffset());
  104.       } else {
  105.          Element var3 = this.this$0.createBranchElement(var1, var2.getAttributes());
  106.          int var4 = var2.getElementCount();
  107.          Element[] var5 = new Element[var4];
  108.  
  109.          for(int var6 = 0; var6 < var4; ++var6) {
  110.             var5[var6] = this.clone(var3, var2.getElement(var6));
  111.          }
  112.  
  113.          ((AbstractDocument.BranchElement)var3).replace(0, 0, var5);
  114.          return var3;
  115.       }
  116.    }
  117.  
  118.    void create(int var1, DefaultStyledDocument.ElementSpec[] var2, AbstractDocument.DefaultDocumentEvent var3) {
  119.       this.insertOp = true;
  120.       this.beginEdits(this.offset, var1);
  121.       this.push(this.root, 0);
  122.       DefaultStyledDocument.ElementBuffer.ElemChanges var4 = (DefaultStyledDocument.ElementBuffer.ElemChanges)this.path.peek();
  123.  
  124.       for(int var5 = 0; var5 < this.root.getElementCount(); ++var5) {
  125.          var4.removed.addElement(this.root.getElement(var5));
  126.       }
  127.  
  128.       int var6 = var2.length;
  129.  
  130.       for(int var7 = 1; var7 < var6; ++var7) {
  131.          this.insertElement(var2[var7]);
  132.       }
  133.  
  134.       while(this.path.size() != 0) {
  135.          this.pop();
  136.       }
  137.  
  138.       this.endEdits(var3);
  139.       this.insertOp = false;
  140.    }
  141.  
  142.    void endEdits(AbstractDocument.DefaultDocumentEvent var1) {
  143.       int var2 = this.changes.size();
  144.  
  145.       for(int var3 = 0; var3 < var2; ++var3) {
  146.          DefaultStyledDocument.ElementBuffer.ElemChanges var4 = (DefaultStyledDocument.ElementBuffer.ElemChanges)this.changes.elementAt(var3);
  147.          Element[] var5 = new Element[var4.removed.size()];
  148.          var4.removed.copyInto(var5);
  149.          Element[] var6 = new Element[var4.added.size()];
  150.          var4.added.copyInto(var6);
  151.          int var7 = var4.index;
  152.          ((AbstractDocument.BranchElement)var4.parent).replace(var7, var5.length, var6);
  153.          AbstractDocument.ElementEdit var8 = new AbstractDocument.ElementEdit((AbstractDocument.BranchElement)var4.parent, var7, var5, var6);
  154.          var1.addEdit(var8);
  155.       }
  156.  
  157.    }
  158.  
  159.    void fracture(int var1) {
  160.       int var2 = this.insertPath.length;
  161.       int var3 = -1;
  162.       boolean var4 = this.recreateLeafs;
  163.       DefaultStyledDocument.ElementBuffer.ElemChanges var5 = this.insertPath[var2 - 1];
  164.       boolean var6 = var5.index + 1 < var5.parent.getElementCount();
  165.       int var7 = var4 ? var2 : -1;
  166.       int var8 = var2 - 1;
  167.       this.createdFracture = true;
  168.  
  169.       for(int var9 = var2 - 2; var9 >= 0; --var9) {
  170.          DefaultStyledDocument.ElementBuffer.ElemChanges var10 = this.insertPath[var9];
  171.          if (var10.added.size() > 0 || var9 == var1) {
  172.             var3 = var9;
  173.             if (!var4 && var6) {
  174.                var4 = true;
  175.                if (var7 == -1) {
  176.                   var7 = var8 + 1;
  177.                }
  178.             }
  179.          }
  180.  
  181.          if (!var6 && var10.index < var10.parent.getElementCount()) {
  182.             var6 = true;
  183.             var8 = var9;
  184.          }
  185.       }
  186.  
  187.       if (var4) {
  188.          if (var3 == -1) {
  189.             var3 = var2 - 1;
  190.          }
  191.  
  192.          this.fractureFrom(this.insertPath, var3, var7);
  193.       }
  194.  
  195.    }
  196.  
  197.    void fractureDeepestLeaf(DefaultStyledDocument.ElementSpec[] var1) {
  198.       DefaultStyledDocument.ElementBuffer.ElemChanges var2 = (DefaultStyledDocument.ElementBuffer.ElemChanges)this.path.peek();
  199.       Element var3 = var2.parent.getElement(var2.index);
  200.       Element var4 = this.this$0.createLeafElement(var2.parent, var3.getAttributes(), var3.getStartOffset(), this.offset);
  201.       var2.added.addElement(var4);
  202.       var2.removed.addElement(var3);
  203.       if (var3.getEndOffset() != this.endOffset) {
  204.          this.recreateLeafs = true;
  205.       } else {
  206.          this.offsetLastIndex = true;
  207.       }
  208.  
  209.    }
  210.  
  211.    void fractureFrom(DefaultStyledDocument.ElementBuffer.ElemChanges[] var1, int var2, int var3) {
  212.       DefaultStyledDocument.ElementBuffer.ElemChanges var4 = var1[var2];
  213.       int var7 = var1.length;
  214.       Element var5;
  215.       if (var2 + 1 == var7) {
  216.          var5 = var4.parent.getElement(var4.index);
  217.       } else {
  218.          var5 = var4.parent.getElement(var4.index - 1);
  219.       }
  220.  
  221.       Element var6;
  222.       if (var5.isLeaf()) {
  223.          var6 = this.this$0.createLeafElement(var4.parent, var5.getAttributes(), Math.max(this.endOffset, var5.getStartOffset()), var5.getEndOffset());
  224.       } else {
  225.          var6 = this.this$0.createBranchElement(var4.parent, var5.getAttributes());
  226.       }
  227.  
  228.       this.fracturedParent = var4.parent;
  229.       this.fracturedChild = var6;
  230.       Element var8 = var6;
  231.  
  232.       while(true) {
  233.          ++var2;
  234.          if (var2 >= var3) {
  235.             return;
  236.          }
  237.  
  238.          boolean var9 = var2 + 1 == var3;
  239.          boolean var10 = var2 + 1 == var7;
  240.          var4 = var1[var2];
  241.          if (var9) {
  242.             if (!this.offsetLastIndex && var10) {
  243.                var5 = var4.parent.getElement(var4.index);
  244.             } else {
  245.                var5 = null;
  246.             }
  247.          } else {
  248.             var5 = var4.parent.getElement(var4.index - 1);
  249.          }
  250.  
  251.          if (var5 != null) {
  252.             if (var5.isLeaf()) {
  253.                var6 = this.this$0.createLeafElement(var8, var5.getAttributes(), Math.max(this.endOffset, var5.getStartOffset()), var5.getEndOffset());
  254.             } else {
  255.                var6 = this.this$0.createBranchElement(var8, var5.getAttributes());
  256.             }
  257.          } else {
  258.             var6 = null;
  259.          }
  260.  
  261.          int var11 = var4.parent.getElementCount() - var4.index;
  262.          byte var14 = 1;
  263.          Element[] var12;
  264.          int var13;
  265.          if (var6 == null) {
  266.             if (var10) {
  267.                --var11;
  268.                var13 = var4.index + 1;
  269.             } else {
  270.                var13 = var4.index;
  271.             }
  272.  
  273.             var14 = 0;
  274.             var12 = new Element[var11];
  275.          } else {
  276.             if (!var9) {
  277.                ++var11;
  278.                var13 = var4.index;
  279.             } else {
  280.                var13 = var4.index + 1;
  281.             }
  282.  
  283.             var12 = new Element[var11];
  284.             var12[0] = var6;
  285.          }
  286.  
  287.          for(int var15 = var14; var15 < var11; ++var15) {
  288.             Element var16 = var4.parent.getElement(var13++);
  289.             var12[var15] = this.recreateFracturedElement(var8, var16);
  290.             var4.removed.addElement(var16);
  291.          }
  292.  
  293.          ((AbstractDocument.BranchElement)var8).replace(0, 0, var12);
  294.          var8 = var6;
  295.       }
  296.    }
  297.  
  298.    public Element getRootElement() {
  299.       return this.root;
  300.    }
  301.  
  302.    public void insert(int var1, int var2, DefaultStyledDocument.ElementSpec[] var3, AbstractDocument.DefaultDocumentEvent var4) {
  303.       this.insertOp = true;
  304.       this.beginEdits(var1, var2);
  305.       this.insertUpdate(var3);
  306.       this.endEdits(var4);
  307.       this.insertOp = false;
  308.    }
  309.  
  310.    void insertElement(DefaultStyledDocument.ElementSpec var1) {
  311.       DefaultStyledDocument.ElementBuffer.ElemChanges var2 = (DefaultStyledDocument.ElementBuffer.ElemChanges)this.path.peek();
  312.       switch (var1.getType()) {
  313.          case 1:
  314.             switch (var1.getDirection()) {
  315.                case 5:
  316.                   Element var6 = var2.parent.getElement(var2.index);
  317.                   if (var6.isLeaf()) {
  318.                      if (var2.index + 1 >= var2.parent.getElementCount()) {
  319.                         throw new StateInvariantError("Join next to leaf");
  320.                      }
  321.  
  322.                      var6 = var2.parent.getElement(var2.index + 1);
  323.                   }
  324.  
  325.                   this.push(var6, 0, true);
  326.                   return;
  327.                case 6:
  328.                default:
  329.                   Element var9 = this.this$0.createBranchElement(var2.parent, var1.getAttributes());
  330.                   var2.added.addElement(var9);
  331.                   this.push(var9, 0);
  332.                   return;
  333.                case 7:
  334.                   if (!this.createdFracture) {
  335.                      this.fracture(this.path.size() - 1);
  336.                   }
  337.  
  338.                   if (!var2.isFracture) {
  339.                      this.push(this.fracturedChild, 0, true);
  340.                   } else {
  341.                      this.push(var2.parent.getElement(0), 0, true);
  342.                   }
  343.  
  344.                   return;
  345.             }
  346.          case 2:
  347.             this.pop();
  348.             break;
  349.          case 3:
  350.             int var3 = var1.getLength();
  351.             if (var1.getDirection() != 5) {
  352.                Element var8 = this.this$0.createLeafElement(var2.parent, var1.getAttributes(), this.pos, this.pos + var3);
  353.                var2.added.addElement(var8);
  354.             } else if (var2.isFracture) {
  355.                Element var7 = var2.parent.getElement(0);
  356.                Element var11 = this.this$0.createLeafElement(var2.parent, var7.getAttributes(), this.pos, var7.getEndOffset());
  357.                var2.added.addElement(var11);
  358.                var2.removed.addElement(var7);
  359.             } else {
  360.                Element var4 = null;
  361.                if (this.insertPath != null) {
  362.                   for(int var5 = this.insertPath.length - 1; var5 >= 0; --var5) {
  363.                      if (this.insertPath[var5] == var2) {
  364.                         if (var5 != this.insertPath.length - 1) {
  365.                            var4 = var2.parent.getElement(var2.index);
  366.                         }
  367.                         break;
  368.                      }
  369.                   }
  370.                }
  371.  
  372.                if (var4 == null) {
  373.                   var4 = var2.parent.getElement(var2.index + 1);
  374.                }
  375.  
  376.                Element var10 = this.this$0.createLeafElement(var2.parent, var4.getAttributes(), this.pos, var4.getEndOffset());
  377.                var2.added.addElement(var10);
  378.                var2.removed.addElement(var4);
  379.             }
  380.  
  381.             this.pos += var3;
  382.       }
  383.  
  384.    }
  385.  
  386.    void insertFirstContent(DefaultStyledDocument.ElementSpec[] var1) {
  387.       DefaultStyledDocument.ElementSpec var2 = var1[0];
  388.       DefaultStyledDocument.ElementBuffer.ElemChanges var3 = (DefaultStyledDocument.ElementBuffer.ElemChanges)this.path.peek();
  389.       Element var4 = var3.parent.getElement(var3.index);
  390.       int var5 = this.offset + var2.getLength();
  391.       boolean var6 = var1.length == 1;
  392.       switch (var2.getDirection()) {
  393.          case 4:
  394.             if (var4.getEndOffset() != var5 && !var6) {
  395.                Element var10 = this.this$0.createLeafElement(var3.parent, var4.getAttributes(), var4.getStartOffset(), var5);
  396.                var3.added.addElement(var10);
  397.                var3.removed.addElement(var4);
  398.                if (var4.getEndOffset() != this.endOffset) {
  399.                   this.recreateLeafs = true;
  400.                } else {
  401.                   this.offsetLastIndex = true;
  402.                }
  403.             } else {
  404.                this.offsetLastIndex = true;
  405.                this.offsetLastIndexOnReplace = true;
  406.             }
  407.             break;
  408.          case 5:
  409.             if (this.offset != 0) {
  410.                Element var7 = this.this$0.createLeafElement(var3.parent, var4.getAttributes(), var4.getStartOffset(), this.offset);
  411.                var3.added.addElement(var7);
  412.                Element var8 = var3.parent.getElement(var3.index + 1);
  413.                if (var6) {
  414.                   var7 = this.this$0.createLeafElement(var3.parent, var8.getAttributes(), this.offset, var8.getEndOffset());
  415.                } else {
  416.                   var7 = this.this$0.createLeafElement(var3.parent, var8.getAttributes(), this.offset, var5);
  417.                }
  418.  
  419.                var3.added.addElement(var7);
  420.                var3.removed.addElement(var4);
  421.                var3.removed.addElement(var8);
  422.             }
  423.             break;
  424.          default:
  425.             if (var4.getStartOffset() != this.offset) {
  426.                Element var11 = this.this$0.createLeafElement(var3.parent, var4.getAttributes(), var4.getStartOffset(), this.offset);
  427.                var3.added.addElement(var11);
  428.             }
  429.  
  430.             var3.removed.addElement(var4);
  431.             Element var12 = this.this$0.createLeafElement(var3.parent, var2.getAttributes(), this.offset, var5);
  432.             var3.added.addElement(var12);
  433.             if (var4.getEndOffset() != this.endOffset) {
  434.                this.recreateLeafs = true;
  435.             } else {
  436.                this.offsetLastIndex = true;
  437.             }
  438.       }
  439.  
  440.    }
  441.  
  442.    protected void insertUpdate(DefaultStyledDocument.ElementSpec[] var1) {
  443.       Element var2 = this.root;
  444.  
  445.       Element var4;
  446.       for(int var3 = var2.getElementIndex(this.offset); !var2.isLeaf(); var3 = var4.getElementIndex(this.offset)) {
  447.          var4 = var2.getElement(var3);
  448.          this.push(var2, var4.isLeaf() ? var3 : var3 + 1);
  449.          var2 = var4;
  450.       }
  451.  
  452.       this.insertPath = new DefaultStyledDocument.ElementBuffer.ElemChanges[this.path.size()];
  453.       this.path.copyInto(this.insertPath);
  454.       this.createdFracture = false;
  455.       this.recreateLeafs = false;
  456.       int var8;
  457.       if (var1[0].getType() == 3) {
  458.          this.insertFirstContent(var1);
  459.          this.pos += var1[0].getLength();
  460.          var8 = 1;
  461.       } else {
  462.          this.fractureDeepestLeaf(var1);
  463.          var8 = 0;
  464.       }
  465.  
  466.       for(int var5 = var1.length; var8 < var5; ++var8) {
  467.          this.insertElement(var1[var8]);
  468.       }
  469.  
  470.       if (!this.createdFracture) {
  471.          this.fracture(-1);
  472.       }
  473.  
  474.       while(this.path.size() != 0) {
  475.          this.pop();
  476.       }
  477.  
  478.       if (this.offsetLastIndex && this.offsetLastIndexOnReplace) {
  479.          ++this.insertPath[this.insertPath.length - 1].index;
  480.       }
  481.  
  482.       for(int var6 = this.insertPath.length - 1; var6 >= 0; --var6) {
  483.          DefaultStyledDocument.ElementBuffer.ElemChanges var7 = this.insertPath[var6];
  484.          if (var7.parent == this.fracturedParent) {
  485.             var7.added.addElement(this.fracturedChild);
  486.          }
  487.  
  488.          if ((var7.added.size() > 0 || var7.removed.size() > 0) && !this.changes.contains(var7)) {
  489.             this.changes.addElement(var7);
  490.          }
  491.       }
  492.  
  493.    }
  494.  
  495.    Element join(Element var1, Element var2, Element var3, int var4, int var5) {
  496.       if (var2.isLeaf() && var3.isLeaf()) {
  497.          return this.this$0.createLeafElement(var1, var2.getAttributes(), var2.getStartOffset(), var3.getEndOffset());
  498.       } else if (!var2.isLeaf() && !var3.isLeaf()) {
  499.          Element var6 = this.this$0.createBranchElement(var1, var2.getAttributes());
  500.          int var7 = var2.getElementIndex(var4);
  501.          int var8 = var3.getElementIndex(var5);
  502.          Element var9 = var2.getElement(var7);
  503.          if (var9.getStartOffset() == var4) {
  504.             var9 = null;
  505.          }
  506.  
  507.          Element var10 = var3.getElement(var8);
  508.          if (var10.getStartOffset() == var5) {
  509.             var10 = null;
  510.          }
  511.  
  512.          Vector var11 = new Vector();
  513.  
  514.          for(int var12 = 0; var12 < var7; ++var12) {
  515.             var11.addElement(this.clone(var6, var2.getElement(var12)));
  516.          }
  517.  
  518.          if (this.canJoin(var9, var10)) {
  519.             Element var13 = this.join(var6, var9, var10, var4, var5);
  520.             var11.addElement(var13);
  521.          } else {
  522.             if (var9 != null) {
  523.                var11.addElement(this.clone(var6, var9));
  524.             }
  525.  
  526.             if (var10 != null) {
  527.                var11.addElement(this.clone(var6, var10));
  528.             }
  529.          }
  530.  
  531.          int var16 = var3.getElementCount();
  532.  
  533.          for(int var14 = var10 == null ? var8 : var8 + 1; var14 < var16; ++var14) {
  534.             var11.addElement(this.clone(var6, var3.getElement(var14)));
  535.          }
  536.  
  537.          Element[] var15 = new Element[var11.size()];
  538.          var11.copyInto(var15);
  539.          ((AbstractDocument.BranchElement)var6).replace(0, 0, var15);
  540.          return var6;
  541.       } else {
  542.          throw new StateInvariantError("No support to join leaf element with non-leaf element");
  543.       }
  544.    }
  545.  
  546.    void pop() {
  547.       DefaultStyledDocument.ElementBuffer.ElemChanges var1 = (DefaultStyledDocument.ElementBuffer.ElemChanges)this.path.peek();
  548.       this.path.pop();
  549.       if (var1.added.size() <= 0 && var1.removed.size() <= 0) {
  550.          if (!this.path.isEmpty()) {
  551.             Element var2 = var1.parent;
  552.             if (var2.getElementCount() == 0) {
  553.                var1 = (DefaultStyledDocument.ElementBuffer.ElemChanges)this.path.peek();
  554.                var1.added.removeElement(var2);
  555.             }
  556.          }
  557.       } else {
  558.          this.changes.addElement(var1);
  559.       }
  560.  
  561.    }
  562.  
  563.    void push(Element var1, int var2) {
  564.       this.push(var1, var2, false);
  565.    }
  566.  
  567.    void push(Element var1, int var2, boolean var3) {
  568.       DefaultStyledDocument.ElementBuffer.ElemChanges var4 = new DefaultStyledDocument.ElementBuffer.ElemChanges(this, var1, var2, var3);
  569.       this.path.push(var4);
  570.    }
  571.  
  572.    Element recreateFracturedElement(Element var1, Element var2) {
  573.       if (var2.isLeaf()) {
  574.          return this.this$0.createLeafElement(var1, var2.getAttributes(), Math.max(var2.getStartOffset(), this.endOffset), var2.getEndOffset());
  575.       } else {
  576.          Element var3 = this.this$0.createBranchElement(var1, var2.getAttributes());
  577.          int var4 = var2.getElementCount();
  578.          Element[] var5 = new Element[var4];
  579.  
  580.          for(int var6 = 0; var6 < var4; ++var6) {
  581.             var5[var6] = this.recreateFracturedElement(var3, var2.getElement(var6));
  582.          }
  583.  
  584.          ((AbstractDocument.BranchElement)var3).replace(0, 0, var5);
  585.          return var3;
  586.       }
  587.    }
  588.  
  589.    public void remove(int var1, int var2, AbstractDocument.DefaultDocumentEvent var3) {
  590.       this.beginEdits(var1, var2);
  591.       this.removeUpdate();
  592.       this.endEdits(var3);
  593.    }
  594.  
  595.    boolean removeElements(Element var1, int var2, int var3) {
  596.       if (!var1.isLeaf()) {
  597.          int var4 = var1.getElementIndex(var2);
  598.          int var5 = var1.getElementIndex(var3);
  599.          this.push(var1, var4);
  600.          DefaultStyledDocument.ElementBuffer.ElemChanges var6 = (DefaultStyledDocument.ElementBuffer.ElemChanges)this.path.peek();
  601.          if (var4 == var5) {
  602.             Element var13 = var1.getElement(var4);
  603.             if (var2 <= var13.getStartOffset() && var3 >= var13.getEndOffset()) {
  604.                var6.removed.addElement(var13);
  605.             } else if (this.removeElements(var13, var2, var3)) {
  606.                var6.removed.addElement(var13);
  607.             }
  608.          } else {
  609.             Element var7 = var1.getElement(var4);
  610.             Element var8 = var1.getElement(var5);
  611.             boolean var9 = var3 < var1.getEndOffset();
  612.             if (var9 && this.canJoin(var7, var8)) {
  613.                for(int var14 = var4; var14 <= var5; ++var14) {
  614.                   var6.removed.addElement(var1.getElement(var14));
  615.                }
  616.  
  617.                Element var15 = this.join(var1, var7, var8, var2, var3);
  618.                var6.added.addElement(var15);
  619.             } else {
  620.                int var10 = var4 + 1;
  621.                int var11 = var5 - 1;
  622.                if (var7.getStartOffset() == var2 || var4 == 0 && var7.getStartOffset() > var2 && var7.getEndOffset() <= var3) {
  623.                   var7 = null;
  624.                   var10 = var4;
  625.                }
  626.  
  627.                if (!var9) {
  628.                   var8 = null;
  629.                   ++var11;
  630.                } else if (var8.getStartOffset() == var3) {
  631.                   var8 = null;
  632.                }
  633.  
  634.                if (var10 <= var11) {
  635.                   var6.index = var10;
  636.                }
  637.  
  638.                for(int var12 = var10; var12 <= var11; ++var12) {
  639.                   var6.removed.addElement(var1.getElement(var12));
  640.                }
  641.  
  642.                if (var7 != null && this.removeElements(var7, var2, var3)) {
  643.                   var6.removed.insertElementAt(var7, 0);
  644.                   var6.index = var4;
  645.                }
  646.  
  647.                if (var8 != null && this.removeElements(var8, var2, var3)) {
  648.                   var6.removed.addElement(var8);
  649.                }
  650.             }
  651.          }
  652.  
  653.          this.pop();
  654.          if (var1.getElementCount() == var6.removed.size() - var6.added.size()) {
  655.             return true;
  656.          }
  657.       }
  658.  
  659.       return false;
  660.    }
  661.  
  662.    protected void removeUpdate() {
  663.       this.removeElements(this.root, this.offset, this.offset + this.length);
  664.    }
  665.  
  666.    boolean split(int var1, int var2) {
  667.       boolean var3 = false;
  668.       Element var4 = this.root;
  669.  
  670.       for(int var5 = var4.getElementIndex(var1); !var4.isLeaf(); var5 = var4.getElementIndex(var1)) {
  671.          this.push(var4, var5);
  672.          var4 = var4.getElement(var5);
  673.       }
  674.  
  675.       DefaultStyledDocument.ElementBuffer.ElemChanges var6 = (DefaultStyledDocument.ElementBuffer.ElemChanges)this.path.peek();
  676.       Element var7 = var6.parent.getElement(var6.index);
  677.       if (var7.getStartOffset() != var1) {
  678.          int var8 = var6.index;
  679.          int var9 = var8;
  680.          if (var1 + var2 < var6.parent.getEndOffset() && var2 != 0) {
  681.             var9 = var6.parent.getElementIndex(var1 + var2);
  682.             if (var9 == var8) {
  683.                var6.removed.addElement(var7);
  684.                var4 = this.this$0.createLeafElement(var6.parent, var7.getAttributes(), var7.getStartOffset(), var1);
  685.                var6.added.addElement(var4);
  686.                var4 = this.this$0.createLeafElement(var6.parent, var7.getAttributes(), var1, var1 + var2);
  687.                var6.added.addElement(var4);
  688.                var4 = this.this$0.createLeafElement(var6.parent, var7.getAttributes(), var1 + var2, var7.getEndOffset());
  689.                var6.added.addElement(var4);
  690.                return true;
  691.             }
  692.  
  693.             var7 = var6.parent.getElement(var9);
  694.             if (var1 + var2 == var7.getStartOffset()) {
  695.                var9 = var8;
  696.             }
  697.  
  698.             var3 = true;
  699.          }
  700.  
  701.          this.pos = var1;
  702.          var7 = var6.parent.getElement(var8);
  703.          var6.removed.addElement(var7);
  704.          var4 = this.this$0.createLeafElement(var6.parent, var7.getAttributes(), var7.getStartOffset(), this.pos);
  705.          var6.added.addElement(var4);
  706.          var4 = this.this$0.createLeafElement(var6.parent, var7.getAttributes(), this.pos, var7.getEndOffset());
  707.          var6.added.addElement(var4);
  708.  
  709.          for(int var10 = var8 + 1; var10 < var9; ++var10) {
  710.             var7 = var6.parent.getElement(var10);
  711.             var6.removed.addElement(var7);
  712.             var6.added.addElement(var7);
  713.          }
  714.  
  715.          if (var9 != var8) {
  716.             var7 = var6.parent.getElement(var9);
  717.             this.pos = var1 + var2;
  718.             var6.removed.addElement(var7);
  719.             var4 = this.this$0.createLeafElement(var6.parent, var7.getAttributes(), var7.getStartOffset(), this.pos);
  720.             var6.added.addElement(var4);
  721.             var4 = this.this$0.createLeafElement(var6.parent, var7.getAttributes(), this.pos, var7.getEndOffset());
  722.             var6.added.addElement(var4);
  723.          }
  724.       }
  725.  
  726.       return var3;
  727.    }
  728. }
  729.