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