package javax.swing.text;

import java.lang.ref.WeakReference;
import java.util.HashMap;
import javax.swing.event.ChangeEvent;
import java.lang.ref.ReferenceQueue;
import java.util.Map;
import javax.swing.undo.CannotUndoException;
import javax.swing.undo.CannotRedoException;
import javax.swing.undo.AbstractUndoableEdit;
import java.util.ArrayList;
import java.util.Stack;
import java.io.Serializable;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.List;
import java.util.Iterator;
import javax.swing.event.DocumentListener;
import javax.swing.SwingUtilities;
import java.awt.Font;
import java.awt.Color;
import java.awt.font.TextAttribute;
import java.util.Enumeration;
import javax.swing.undo.UndoableEdit;
import javax.swing.event.UndoableEditEvent;
import javax.swing.event.DocumentEvent;
import javax.swing.event.ChangeListener;
import java.util.Vector;

public class DefaultStyledDocument extends AbstractDocument implements StyledDocument
{
    public static final int BUFFER_SIZE_DEFAULT = 4096;
    protected DefaultStyledDocument.ElementBuffer buffer;
    private transient Vector<Style> listeningStyles;
    private transient ChangeListener styleChangeListener;
    private transient ChangeListener styleContextChangeListener;
    private transient DefaultStyledDocument.ChangeUpdateRunnable updateRunnable;
    
    public DefaultStyledDocument(AbstractDocument.Content content, StyleContext styleContext) {
        super(content, styleContext);
        this.listeningStyles = new Vector();
        this.buffer = new DefaultStyledDocument.ElementBuffer(this.createDefaultRoot());
        this.setLogicalStyle(0, styleContext.getStyle("default"));
    }
    
    public DefaultStyledDocument(StyleContext styleContext) {
        this(new GapContent(4096), styleContext);
    }
    
    public DefaultStyledDocument() {
        this(new GapContent(4096), new StyleContext());
    }
    
    @Override
    public Element getDefaultRootElement() {
        return this.buffer.getRootElement();
    }
    
    protected void create(DefaultStyledDocument.ElementSpec[] array) {
        try {
            if (this.getLength() != 0) {
                this.remove(0, this.getLength());
            }
            this.writeLock();
            AbstractDocument.Content content = this.getContent();
            int length = array.length;
            StringBuilder sb = new StringBuilder();
            for (DefaultStyledDocument.ElementSpec elementSpec : array) {
                if (elementSpec.getLength() > 0) {
                    sb.append(elementSpec.getArray(), elementSpec.getOffset(), elementSpec.getLength());
                }
            }
            UndoableEdit insertString = content.insertString(0, sb.toString());
            int length2 = sb.length();
            AbstractDocument.DefaultDocumentEvent edit = new AbstractDocument.DefaultDocumentEvent(0, length2, DocumentEvent.EventType.INSERT);
            edit.addEdit(insertString);
            this.buffer.create(length2, array, edit);
            super.insertUpdate(edit, null);
            edit.end();
            this.fireInsertUpdate(edit);
            this.fireUndoableEditUpdate(new UndoableEditEvent(this, edit));
        }
        catch (BadLocationException ex) {
            throw new StateInvariantError("problem initializing");
        }
        finally {
            this.writeUnlock();
        }
    }
    
    protected void insert(int n, DefaultStyledDocument.ElementSpec[] array) throws BadLocationException {
        if (array == null || array.length == 0) {
            return;
        }
        try {
            this.writeLock();
            AbstractDocument.Content content = this.getContent();
            int length = array.length;
            StringBuilder sb = new StringBuilder();
            for (DefaultStyledDocument.ElementSpec elementSpec : array) {
                if (elementSpec.getLength() > 0) {
                    sb.append(elementSpec.getArray(), elementSpec.getOffset(), elementSpec.getLength());
                }
            }
            if (sb.length() == 0) {
                return;
            }
            UndoableEdit insertString = content.insertString(n, sb.toString());
            int length2 = sb.length();
            AbstractDocument.DefaultDocumentEvent edit = new AbstractDocument.DefaultDocumentEvent(n, length2, DocumentEvent.EventType.INSERT);
            edit.addEdit(insertString);
            this.buffer.insert(n, length2, array, edit);
            super.insertUpdate(edit, null);
            edit.end();
            this.fireInsertUpdate(edit);
            this.fireUndoableEditUpdate(new UndoableEditEvent(this, edit));
        }
        finally {
            this.writeUnlock();
        }
        return;
    }
    
    public void removeElement(Element element) {
        try {
            this.writeLock();
            this.removeElementImpl(element);
        }
        finally {
            this.writeUnlock();
        }
    }
    
    private void removeElementImpl(Element element) {
        if (element.getDocument() != this) {
            throw new IllegalArgumentException("element doesn't belong to document");
        }
        AbstractDocument.BranchElement branchElement = (AbstractDocument.BranchElement)element.getParentElement();
        if (branchElement == null) {
            throw new IllegalArgumentException("can't remove the root element");
        }
        int startOffset = element.getStartOffset();
        int endOffset = element.getEndOffset();
        int n = this.getLength() + 1;
        AbstractDocument.Content content = this.getContent();
        boolean n2 = false;
        int composedTextElement = Utilities.isComposedTextElement(element);
        if (endOffset >= n) {
            if (startOffset <= 0) {
                throw new IllegalArgumentException("can't remove the whole content");
            }
            endOffset = n - 1;
            try {
                if (content.getString(startOffset - 1, 1).charAt(0) == '\n') {
                    --startOffset;
                }
            }
            catch (BadLocationException cause) {
                throw new IllegalStateException(cause);
            }
            n2 = true;
        }
        int n3 = endOffset - startOffset;
        AbstractDocument.DefaultDocumentEvent edit = new AbstractDocument.DefaultDocumentEvent(startOffset, n3, DocumentEvent.EventType.REMOVE);
        UndoableEdit remove = null;
        while (branchElement.getElementCount() == 1) {
            element = branchElement;
            branchElement = (AbstractDocument.BranchElement)branchElement.getParentElement();
            if (branchElement != null) {
                continue;
            }
            throw new IllegalStateException("invalid element structure");
        }
        Element[] array = { element };
        Element[] array2 = new Element[0];
        int elementIndex = branchElement.getElementIndex(startOffset);
        branchElement.replace(elementIndex, 1, array2);
        edit.addEdit(new AbstractDocument.ElementEdit(branchElement, elementIndex, array, array2));
        if (n3 > 0) {
            try {
                remove = content.remove(startOffset, n3);
                if (remove != null) {
                    edit.addEdit(remove);
                }
            }
            catch (BadLocationException cause2) {
                throw new IllegalStateException(cause2);
            }
            n -= n3;
        }
        if (!(n2 == 0)) {
            Element element2;
            for (element2 = branchElement.getElement(branchElement.getElementCount() - 1); element2 != null && !element2.isLeaf(); element2 = element2.getElement(element2.getElementCount() - 1)) {}
            if (element2 == null) {
                throw new IllegalStateException("invalid element structure");
            }
            int startOffset2 = element2.getStartOffset();
            AbstractDocument.BranchElement branchElement2 = (AbstractDocument.BranchElement)element2.getParentElement();
            int elementIndex2 = branchElement2.getElementIndex(startOffset2);
            Element leafElement = this.createLeafElement(branchElement2, element2.getAttributes(), startOffset2, n);
            Element[] array3 = { element2 };
            Element[] array4 = { leafElement };
            branchElement2.replace(elementIndex2, 1, array4);
            edit.addEdit(new AbstractDocument.ElementEdit(branchElement2, elementIndex2, array3, array4));
        }
        this.postRemoveUpdate(edit);
        edit.end();
        this.fireRemoveUpdate(edit);
        if (composedTextElement == 0 || remove == null) {
            this.fireUndoableEditUpdate(new UndoableEditEvent(this, edit));
        }
        return;
    }
    
    @Override
    public Style addStyle(String s, Style style) {
        return ((StyleContext)this.getAttributeContext()).addStyle(s, style);
    }
    
    @Override
    public void removeStyle(String s) {
        ((StyleContext)this.getAttributeContext()).removeStyle(s);
    }
    
    @Override
    public Style getStyle(String s) {
        return ((StyleContext)this.getAttributeContext()).getStyle(s);
    }
    
    public Enumeration<?> getStyleNames() {
        return ((StyleContext)this.getAttributeContext()).getStyleNames();
    }
    
    @Override
    public void setLogicalStyle(int n, Style resolveParent) {
        Element paragraphElement = this.getParagraphElement(n);
        if (paragraphElement != null && paragraphElement instanceof AbstractDocument.AbstractElement) {
            try {
                this.writeLock();
                DefaultStyledDocument.StyleChangeUndoableEdit styleChangeUndoableEdit = new DefaultStyledDocument.StyleChangeUndoableEdit((AbstractDocument.AbstractElement)paragraphElement, resolveParent);
                ((AbstractDocument.AbstractElement)paragraphElement).setResolveParent(resolveParent);
                int startOffset = paragraphElement.getStartOffset();
                AbstractDocument.DefaultDocumentEvent edit = new AbstractDocument.DefaultDocumentEvent(startOffset, paragraphElement.getEndOffset() - startOffset, DocumentEvent.EventType.CHANGE);
                edit.addEdit(styleChangeUndoableEdit);
                edit.end();
                this.fireChangedUpdate(edit);
                this.fireUndoableEditUpdate(new UndoableEditEvent(this, edit));
            }
            finally {
                this.writeUnlock();
            }
        }
    }
    
    @Override
    public Style getLogicalStyle(int n) {
        Style style = null;
        Element paragraphElement = this.getParagraphElement(n);
        if (paragraphElement != null) {
            AttributeSet resolveParent = paragraphElement.getAttributes().getResolveParent();
            if ((resolveParent instanceof Style)) {
                style = (Style)resolveParent;
            }
        }
        return style;
    }
    
    @Override
    public void setCharacterAttributes(int i, int n, AttributeSet set, boolean b) {
        if (n == 0) {
            return;
        }
        try {
            this.writeLock();
            AbstractDocument.DefaultDocumentEvent edit = new AbstractDocument.DefaultDocumentEvent(i, n, DocumentEvent.EventType.CHANGE);
            this.buffer.change(i, n, edit);
            AttributeSet copyAttributes = set.copyAttributes();
            while (i < i + n) {
                Element characterElement = this.getCharacterElement(i);
                int endOffset = characterElement.getEndOffset();
                if (i == endOffset) {
                    break;
                }
                MutableAttributeSet set2 = (MutableAttributeSet)characterElement.getAttributes();
                edit.addEdit(new DefaultStyledDocument.AttributeUndoableEdit(characterElement, copyAttributes, b));
                if (b) {
                    set2.removeAttributes(set2);
                }
                set2.addAttributes(set);
                i = endOffset;
            }
            edit.end();
            this.fireChangedUpdate(edit);
            this.fireUndoableEditUpdate(new UndoableEditEvent(this, edit));
        }
        finally {
            this.writeUnlock();
        }
        return;
    }
    
    @Override
    public void setParagraphAttributes(int n, int n2, AttributeSet set, boolean b) {
        try {
            this.writeLock();
            AbstractDocument.DefaultDocumentEvent edit = new AbstractDocument.DefaultDocumentEvent(n, n2, DocumentEvent.EventType.CHANGE);
            AttributeSet copyAttributes = set.copyAttributes();
            Element defaultRootElement = this.getDefaultRootElement();
            int i = defaultRootElement.getElementIndex(n);
            int elementIndex = defaultRootElement.getElementIndex(n + ((n2 > 0) ? (n2 - 1) : 0));
            int equals = Boolean.TRUE.equals(this.getProperty("i18n"));
            int n3 = 0;
            for (; i <= elementIndex; ++i) {
                Element element = defaultRootElement.getElement(i);
                MutableAttributeSet set2 = (MutableAttributeSet)element.getAttributes();
                edit.addEdit(new DefaultStyledDocument.AttributeUndoableEdit(element, copyAttributes, b));
                if (b) {
                    set2.removeAttributes(set2);
                }
                set2.addAttributes(set);
                if (equals && n3 == 0) {
                    n3 = (set2.getAttribute(TextAttribute.RUN_DIRECTION) != null);
                }
            }
            if (n3 != 0) {
                this.updateBidi(edit);
            }
            edit.end();
            this.fireChangedUpdate(edit);
            this.fireUndoableEditUpdate(new UndoableEditEvent(this, edit));
        }
        finally {
            this.writeUnlock();
        }
    }
    
    @Override
    public Element getParagraphElement(int n) {
        Element element;
        for (element = this.getDefaultRootElement(); !element.isLeaf(); element = element.getElement(element.getElementIndex(n))) {}
        if (element != null) {
            return element.getParentElement();
        }
        return element;
    }
    
    @Override
    public Element getCharacterElement(int n) {
        Element element;
        for (element = this.getDefaultRootElement(); !element.isLeaf(); element = element.getElement(element.getElementIndex(n))) {}
        return element;
    }
    
    @Override
    protected void insertUpdate(AbstractDocument.DefaultDocumentEvent defaultDocumentEvent, AttributeSet empty) {
        int offset = defaultDocumentEvent.getOffset();
        int length = defaultDocumentEvent.getLength();
        if (empty == null) {
            empty = SimpleAttributeSet.EMPTY;
        }
        Element paragraphElement = this.getParagraphElement(offset + length);
        AttributeSet set = paragraphElement.getAttributes();
        Element paragraphElement2 = this.getParagraphElement(offset);
        Element element = paragraphElement2.getElement(paragraphElement2.getElementIndex(offset));
        int n = offset + length;
        int n2 = element.getEndOffset() == n;
        AttributeSet attributes = element.getAttributes();
        try {
            Segment o = new Segment();
            Vector o2 = new Vector();
            Object obj = null;
            boolean n3 = false;
            int specsForInsertAfterNewline = 6;
            if (offset > 0) {
                this.getText(offset - 1, 1, o);
                if (o.array[o.offset] == '\n') {
                    n3 = true;
                    specsForInsertAfterNewline = this.createSpecsForInsertAfterNewline(paragraphElement, paragraphElement2, set, o2, offset, n);
                    int i = o2.size() - 1;
                    while (i >= 0) {
                        DefaultStyledDocument.ElementSpec elementSpec = (DefaultStyledDocument.ElementSpec)o2.elementAt(i);
                        if (elementSpec.getType() == 1) {
                            obj = elementSpec;
                            break;
                        }
                        --i;
                    }
                }
            }
            if (n3 == 0) {
                set = paragraphElement2.getAttributes();
            }
            this.getText(offset, length, o);
            char[] array = o.array;
            int n4 = o.offset + o.count;
            int offset2 = o.offset;
            for (int j = o.offset; j < n4; ++j) {
                if (array[j] == '\n') {
                    int n5 = j + 1;
                    o2.addElement(new DefaultStyledDocument.ElementSpec(empty, (short)3, n5 - offset2));
                    o2.addElement(new DefaultStyledDocument.ElementSpec(null, (short)2));
                    obj = new DefaultStyledDocument.ElementSpec(set, (short)1);
                    o2.addElement(obj);
                    offset2 = n5;
                }
            }
            if (offset2 < n4) {
                o2.addElement(new DefaultStyledDocument.ElementSpec(empty, (short)3, n4 - offset2));
            }
            DefaultStyledDocument.ElementSpec elementSpec2 = (DefaultStyledDocument.ElementSpec)o2.firstElement();
            int length2 = this.getLength();
            if (elementSpec2.getType() == 3 && attributes.isEqual(empty)) {
                elementSpec2.setDirection((short)4);
            }
            if (obj != null) {
                if (!(n3 == 0)) {
                    obj.setDirection((short)specsForInsertAfterNewline);
                }
                else if (paragraphElement2.getEndOffset() != n) {
                    obj.setDirection((short)7);
                }
                else {
                    Element parentElement = paragraphElement2.getParentElement();
                    int elementIndex = parentElement.getElementIndex(offset);
                    if (elementIndex + 1 < parentElement.getElementCount() && !parentElement.getElement(elementIndex + 1).isLeaf()) {
                        obj.setDirection((short)5);
                    }
                }
            }
            if (n2 && n < length2) {
                DefaultStyledDocument.ElementSpec elementSpec4 = (DefaultStyledDocument.ElementSpec)o2.lastElement();
                if (elementSpec4.getType() == 3 && elementSpec4.getDirection() != 4 && ((obj == null && (paragraphElement == paragraphElement2 || n3)) || (obj != null && obj.getDirection() != 6))) {
                    Element element2 = paragraphElement.getElement(paragraphElement.getElementIndex(n));
                    if (element2.isLeaf() && empty.isEqual(element2.getAttributes())) {
                        elementSpec4.setDirection((short)5);
                    }
                }
            }
            else if (n2 == 0 && obj != null && obj.getDirection() == 7) {
                DefaultStyledDocument.ElementSpec elementSpec3 = (DefaultStyledDocument.ElementSpec)o2.lastElement();
                if (elementSpec3.getType() == 3 && elementSpec3.getDirection() != 4 && empty.isEqual(attributes)) {
                    elementSpec3.setDirection((short)5);
                }
            }
            if (Utilities.isComposedTextAttributeDefined(empty)) {
                MutableAttributeSet set2 = (MutableAttributeSet)empty;
                set2.addAttributes(attributes);
                set2.addAttribute("$ename", "content");
                set2.addAttribute(StyleConstants.NameAttribute, "content");
                if (set2.isDefined("CR")) {
                    set2.removeAttribute("CR");
                }
            }
            DefaultStyledDocument.ElementSpec[] anArray = new DefaultStyledDocument.ElementSpec[o2.size()];
            o2.copyInto(anArray);
            this.buffer.insert(offset, length, anArray, defaultDocumentEvent);
        }
        catch (BadLocationException ex) {}
        super.insertUpdate(defaultDocumentEvent, empty);
    }
    
    short createSpecsForInsertAfterNewline(Element parentElement, Element parentElement2, AttributeSet set, Vector<DefaultStyledDocument.ElementSpec> vector, int n, int n2) {
        if (parentElement.getParentElement() == parentElement2.getParentElement()) {
            vector.addElement(new DefaultStyledDocument.ElementSpec(set, (short)2));
            vector.addElement(new DefaultStyledDocument.ElementSpec(set, (short)1));
            if (parentElement2.getEndOffset() != n2) {
                return 7;
            }
            Element parentElement3 = parentElement2.getParentElement();
            if (parentElement3.getElementIndex(n) + 1 < parentElement3.getElementCount()) {
                return 5;
            }
        }
        else {
            Vector<Element> vector2 = new Vector();
            Vector<Element> vector3 = new Vector();
            for (; parentElement2 != null; parentElement2 = parentElement2.getParentElement()) {
                vector2.addElement(parentElement2);
            }
            int index = -1;
            while (parentElement != null && (index = vector2.indexOf(parentElement)) == -1) {
                vector3.addElement(parentElement);
                parentElement = parentElement.getParentElement();
            }
            if (parentElement != null) {
                for (int i = 0; i < index; ++i) {
                    vector.addElement(new DefaultStyledDocument.ElementSpec(null, (short)2));
                }
                for (int j = vector3.size() - 1; j >= 0; --j) {
                    DefaultStyledDocument.ElementSpec obj = new DefaultStyledDocument.ElementSpec(((Element)vector3.elementAt(j)).getAttributes(), (short)1);
                    if (j > 0) {
                        obj.setDirection((short)5);
                    }
                    vector.addElement(obj);
                }
                if (vector3.size() > 0) {
                    return 5;
                }
                return 7;
            }
        }
        return 6;
    }
    
    @Override
    protected void removeUpdate(AbstractDocument.DefaultDocumentEvent defaultDocumentEvent) {
        super.removeUpdate(defaultDocumentEvent);
        this.buffer.remove(defaultDocumentEvent.getOffset(), defaultDocumentEvent.getLength(), defaultDocumentEvent);
    }
    
    protected AbstractDocument.AbstractElement createDefaultRoot() {
        this.writeLock();
        DefaultStyledDocument.SectionElement sectionElement = new DefaultStyledDocument.SectionElement();
        AbstractDocument.BranchElement branchElement = new AbstractDocument.BranchElement(sectionElement, null);
        Element[] array = { new AbstractDocument.LeafElement(branchElement, null, 0, 1) };
        branchElement.replace(0, 0, array);
        array[0] = branchElement;
        sectionElement.replace(0, 0, array);
        this.writeUnlock();
        return sectionElement;
    }
    
    @Override
    public Color getForeground(AttributeSet set) {
        return ((StyleContext)this.getAttributeContext()).getForeground(set);
    }
    
    @Override
    public Color getBackground(AttributeSet set) {
        return ((StyleContext)this.getAttributeContext()).getBackground(set);
    }
    
    @Override
    public Font getFont(AttributeSet set) {
        return ((StyleContext)this.getAttributeContext()).getFont(set);
    }
    
    protected void styleChanged(Style style) {
        if (this.getLength() != 0) {
            if (this.updateRunnable == null) {
                this.updateRunnable = new DefaultStyledDocument.ChangeUpdateRunnable();
            }
            synchronized (this.updateRunnable) {
                if (!this.updateRunnable.isPending) {
                    SwingUtilities.invokeLater(this.updateRunnable);
                    this.updateRunnable.isPending = true;
                }
            }
        }
    }
    
    @Override
    public void addDocumentListener(DocumentListener documentListener) {
        synchronized (this.listeningStyles) {
            int listenerCount = this.listenerList.getListenerCount(DocumentListener.class);
            super.addDocumentListener(documentListener);
            if (listenerCount == 0) {
                if (this.styleContextChangeListener == null) {
                    this.styleContextChangeListener = this.createStyleContextChangeListener();
                }
                if (this.styleContextChangeListener != null) {
                    StyleContext styleContext = (StyleContext)this.getAttributeContext();
                    Iterator<ChangeListener> iterator = DefaultStyledDocument.AbstractChangeHandler.getStaleListeners(this.styleContextChangeListener).iterator();
                    while (iterator.hasNext()) {
                        styleContext.removeChangeListener((ChangeListener)iterator.next());
                    }
                    styleContext.addChangeListener(this.styleContextChangeListener);
                }
                this.updateStylesListeningTo();
            }
        }
    }
    
    @Override
    public void removeDocumentListener(DocumentListener documentListener) {
        synchronized (this.listeningStyles) {
            super.removeDocumentListener(documentListener);
            if (this.listenerList.getListenerCount(DocumentListener.class) == 0) {
                for (int i = this.listeningStyles.size() - 1; i >= 0; --i) {
                    ((Style)this.listeningStyles.elementAt(i)).removeChangeListener(this.styleChangeListener);
                }
                this.listeningStyles.removeAllElements();
                if (this.styleContextChangeListener != null) {
                    ((StyleContext)this.getAttributeContext()).removeChangeListener(this.styleContextChangeListener);
                }
            }
        }
    }
    
    ChangeListener createStyleChangeListener() {
        return new DefaultStyledDocument.StyleChangeHandler(this);
    }
    
    ChangeListener createStyleContextChangeListener() {
        return new DefaultStyledDocument.StyleContextChangeHandler(this);
    }
    
    void updateStylesListeningTo() {
        synchronized (this.listeningStyles) {
            StyleContext styleContext = (StyleContext)this.getAttributeContext();
            if (this.styleChangeListener == null) {
                this.styleChangeListener = this.createStyleChangeListener();
            }
            if (this.styleChangeListener != null && styleContext != null) {
                Enumeration<Object> styleNames = styleContext.getStyleNames();
                Vector<Object> vector = (Vector)this.listeningStyles.clone();
                this.listeningStyles.removeAllElements();
                List<ChangeListener> staleListeners = DefaultStyledDocument.AbstractChangeHandler.getStaleListeners(this.styleChangeListener);
                while (styleNames.hasMoreElements()) {
                    Style style = styleContext.getStyle((String)styleNames.nextElement());
                    int index = vector.indexOf(style);
                    this.listeningStyles.addElement(style);
                    if (index == -1) {
                        Iterator<Object> iterator = staleListeners.iterator();
                        while (iterator.hasNext()) {
                            style.removeChangeListener((ChangeListener)iterator.next());
                        }
                        style.addChangeListener(this.styleChangeListener);
                    }
                    else {
                        vector.removeElementAt(index);
                    }
                }
                for (int i = vector.size() - 1; i >= 0; --i) {
                    ((Style)vector.elementAt(i)).removeChangeListener(this.styleChangeListener);
                }
                if (this.listeningStyles.size() == 0) {
                    this.styleChangeListener = null;
                }
            }
        }
    }
    
    private void readObject(ObjectInputStream objectInputStream) throws ClassNotFoundException, IOException {
        this.listeningStyles = new Vector();
        objectInputStream.defaultReadObject();
        if (this.styleContextChangeListener == null && this.listenerList.getListenerCount(DocumentListener.class) > 0) {
            this.styleContextChangeListener = this.createStyleContextChangeListener();
            if (this.styleContextChangeListener != null) {
                ((StyleContext)this.getAttributeContext()).addChangeListener(this.styleContextChangeListener);
            }
            this.updateStylesListeningTo();
        }
    }
    
    protected class SectionElement extends AbstractDocument.BranchElement
    {
        public SectionElement() {
            super(null, null);
        }
        
        @Override
        public String getName() {
            return "section";
        }
    }
    
    public static class ElementSpec
    {
        public static final short StartTagType = 1;
        public static final short EndTagType = 2;
        public static final short ContentType = 3;
        public static final short JoinPreviousDirection = 4;
        public static final short JoinNextDirection = 5;
        public static final short OriginateDirection = 6;
        public static final short JoinFractureDirection = 7;
        private AttributeSet attr;
        private int len;
        private short type;
        private short direction;
        private int offs;
        private char[] data;
        
        public ElementSpec(AttributeSet set, short n) {
            this(set, n, null, 0, 0);
        }
        
        public ElementSpec(AttributeSet set, short n, int n2) {
            this(set, n, null, 0, n2);
        }
        
        public ElementSpec(AttributeSet attr, short type, char[] data, int offs, int len) {
            this.attr = attr;
            this.type = type;
            this.data = data;
            this.offs = offs;
            this.len = len;
            this.direction = 6;
        }
        
        public void setType(short type) {
            this.type = type;
        }
        
        public short getType() {
            return this.type;
        }
        
        public void setDirection(short direction) {
            this.direction = direction;
        }
        
        public short getDirection() {
            return this.direction;
        }
        
        public AttributeSet getAttributes() {
            return this.attr;
        }
        
        public char[] getArray() {
            return this.data;
        }
        
        public int getOffset() {
            return this.offs;
        }
        
        public int getLength() {
            return this.len;
        }
        
        @Override
        public String toString() {
            String str = "??";
            String str2 = "??";
            switch (this.type) {
                case 1: {
                    str = "StartTag";
                    break;
                }
                case 3: {
                    str = "Content";
                    break;
                }
                case 2: {
                    str = "EndTag";
                    break;
                }
            }
            switch (this.direction) {
                case 4: {
                    str2 = "JoinPrevious";
                    break;
                }
                case 5: {
                    str2 = "JoinNext";
                    break;
                }
                case 6: {
                    str2 = "Originate";
                    break;
                }
                case 7: {
                    str2 = "Fracture";
                    break;
                }
            }
            return str + ":" + str2 + ":" + this.getLength();
        }
    }
    
    public class ElementBuffer implements Serializable
    {
        Element root;
        transient int pos;
        transient int offset;
        transient int length;
        transient int endOffset;
        transient Vector<DefaultStyledDocument.ElementBuffer.ElemChanges> changes;
        transient Stack<DefaultStyledDocument.ElementBuffer.ElemChanges> path;
        transient boolean insertOp;
        transient boolean recreateLeafs;
        transient DefaultStyledDocument.ElementBuffer.ElemChanges[] insertPath;
        transient boolean createdFracture;
        transient Element fracturedParent;
        transient Element fracturedChild;
        transient boolean offsetLastIndex;
        transient boolean offsetLastIndexOnReplace;
        
        public ElementBuffer(Element root) {
            this.root = root;
            this.changes = new Vector();
            this.path = new Stack();
        }
        
        public Element getRootElement() {
            return this.root;
        }
        
        public void insert(int n, int n2, DefaultStyledDocument.ElementSpec[] array, AbstractDocument.DefaultDocumentEvent defaultDocumentEvent) {
            if (n2 == 0) {
                return;
            }
            this.insertOp = true;
            this.beginEdits(n, n2);
            this.insertUpdate(array);
            this.endEdits(defaultDocumentEvent);
            this.insertOp = false;
            return;
        }
        
        void create(int n, DefaultStyledDocument.ElementSpec[] array, AbstractDocument.DefaultDocumentEvent defaultDocumentEvent) {
            this.insertOp = true;
            this.beginEdits(this.offset, n);
            Element root = this.root;
            int n2 = root.getElementIndex(0);
            while (!root.isLeaf()) {
                Element element = root.getElement(n2);
                this.push(root, n2);
                root = element;
                n2 = root.getElementIndex(0);
            }
            DefaultStyledDocument.ElementBuffer.ElemChanges elemChanges = (DefaultStyledDocument.ElementBuffer.ElemChanges)this.path.peek();
            Element element2 = elemChanges.parent.getElement(elemChanges.index);
            elemChanges.added.addElement(DefaultStyledDocument.this.createLeafElement(elemChanges.parent, element2.getAttributes(), DefaultStyledDocument.this.getLength(), element2.getEndOffset()));
            elemChanges.removed.addElement(element2);
            while (this.path.size() > 1) {
                this.pop();
            }
            int length = array.length;
            AttributeSet set = null;
            if (length > 0 && array[0].getType() == 1) {
                set = array[0].getAttributes();
            }
            if (set == null) {
                set = SimpleAttributeSet.EMPTY;
            }
            MutableAttributeSet set2 = (MutableAttributeSet)this.root.getAttributes();
            defaultDocumentEvent.addEdit(new DefaultStyledDocument.AttributeUndoableEdit(this.root, set, true));
            set2.removeAttributes(set2);
            set2.addAttributes(set);
            for (int i = 1; i < length; ++i) {
                this.insertElement(array[i]);
            }
            while (this.path.size() != 0) {
                this.pop();
            }
            this.endEdits(defaultDocumentEvent);
            this.insertOp = false;
        }
        
        public void remove(int n, int n2, AbstractDocument.DefaultDocumentEvent defaultDocumentEvent) {
            this.beginEdits(n, n2);
            this.removeUpdate();
            this.endEdits(defaultDocumentEvent);
        }
        
        public void change(int n, int n2, AbstractDocument.DefaultDocumentEvent defaultDocumentEvent) {
            this.beginEdits(n, n2);
            this.changeUpdate();
            this.endEdits(defaultDocumentEvent);
        }
        
        protected void insertUpdate(DefaultStyledDocument.ElementSpec[] array) {
            Element root = this.root;
            int n = root.getElementIndex(this.offset);
            while (!root.isLeaf()) {
                Element element = root.getElement(n);
                this.push(root, element.isLeaf() ? n : (n + 1));
                root = element;
                n = root.getElementIndex(this.offset);
            }
            this.insertPath = new DefaultStyledDocument.ElementBuffer.ElemChanges[this.path.size()];
            this.path.copyInto(this.insertPath);
            this.createdFracture = false;
            this.recreateLeafs = false;
            int i;
            if (array[0].getType() == 3) {
                this.insertFirstContent(array);
                this.pos += array[0].getLength();
                i = 1;
            }
            else {
                this.fractureDeepestLeaf(array);
                i = 0;
            }
            while (i < array.length) {
                this.insertElement(array[i]);
                ++i;
            }
            if (!this.createdFracture) {
                this.fracture(-1);
            }
            while (this.path.size() != 0) {
                this.pop();
            }
            if (this.offsetLastIndex && this.offsetLastIndexOnReplace) {
                DefaultStyledDocument.ElementBuffer.ElemChanges elemChanges = this.insertPath[this.insertPath.length - 1];
                ++elemChanges.index;
            }
            for (int j = this.insertPath.length - 1; j >= 0; --j) {
                DefaultStyledDocument.ElementBuffer.ElemChanges elemChanges2 = this.insertPath[j];
                if (elemChanges2.parent == this.fracturedParent) {
                    elemChanges2.added.addElement(this.fracturedChild);
                }
                if ((elemChanges2.added.size() > 0 || elemChanges2.removed.size() > 0) && !this.changes.contains(elemChanges2)) {
                    this.changes.addElement(elemChanges2);
                }
            }
            if (this.offset == 0 && this.fracturedParent != null && array[0].getType() == 2) {
                int n2;
                for (n2 = 0; n2 < array.length && array[n2].getType() == 2; ++n2) {}
                DefaultStyledDocument.ElementBuffer.ElemChanges elemChanges3 = this.insertPath[this.insertPath.length - n2 - 1];
                Vector<Element> removed = elemChanges3.removed;
                Element parent = elemChanges3.parent;
                int index = elemChanges3.index - 1;
                elemChanges3.index = index;
                removed.insertElementAt(parent.getElement(index), 0);
            }
        }
        
        protected void removeUpdate() {
            this.removeElements(this.root, this.offset, this.offset + this.length);
        }
        
        protected void changeUpdate() {
            if (!this.split(this.offset, this.length)) {
                while (this.path.size() != 0) {
                    this.pop();
                }
                this.split(this.offset + this.length, 0);
            }
            while (this.path.size() != 0) {
                this.pop();
            }
        }
        
        boolean split(int pos, int n) {
            boolean n2 = false;
            Element element = this.root;
            for (int n3 = element.getElementIndex(pos); !element.isLeaf(); element = element.getElement(n3), n3 = element.getElementIndex(pos)) {
                this.push(element, n3);
            }
            DefaultStyledDocument.ElementBuffer.ElemChanges elemChanges = (DefaultStyledDocument.ElementBuffer.ElemChanges)this.path.peek();
            Element element2 = elemChanges.parent.getElement(elemChanges.index);
            if (element2.getStartOffset() < pos && pos < element2.getEndOffset()) {
                int n4 = elemChanges.index;
                if (pos + n < elemChanges.parent.getEndOffset() && n != 0) {
                    n4 = elemChanges.parent.getElementIndex(pos + n);
                    if (n4 == n4) {
                        elemChanges.removed.addElement(element2);
                        elemChanges.added.addElement(DefaultStyledDocument.this.createLeafElement(elemChanges.parent, element2.getAttributes(), element2.getStartOffset(), pos));
                        elemChanges.added.addElement(DefaultStyledDocument.this.createLeafElement(elemChanges.parent, element2.getAttributes(), pos, pos + n));
                        elemChanges.added.addElement(DefaultStyledDocument.this.createLeafElement(elemChanges.parent, element2.getAttributes(), pos + n, element2.getEndOffset()));
                        return true;
                    }
                    if (pos + n == elemChanges.parent.getElement(n4).getStartOffset()) {
                    }
                    n2 = true;
                }
                this.pos = pos;
                Element element3 = elemChanges.parent.getElement(n4);
                elemChanges.removed.addElement(element3);
                elemChanges.added.addElement(DefaultStyledDocument.this.createLeafElement(elemChanges.parent, element3.getAttributes(), element3.getStartOffset(), this.pos));
                elemChanges.added.addElement(DefaultStyledDocument.this.createLeafElement(elemChanges.parent, element3.getAttributes(), this.pos, element3.getEndOffset()));
                for (int i = n4 + 1; i < n4; ++i) {
                    Element element4 = elemChanges.parent.getElement(i);
                    elemChanges.removed.addElement(element4);
                    elemChanges.added.addElement(element4);
                }
                if (n4 != n4) {
                    Element element5 = elemChanges.parent.getElement(n4);
                    this.pos = pos + n;
                    elemChanges.removed.addElement(element5);
                    elemChanges.added.addElement(DefaultStyledDocument.this.createLeafElement(elemChanges.parent, element5.getAttributes(), element5.getStartOffset(), this.pos));
                    elemChanges.added.addElement(DefaultStyledDocument.this.createLeafElement(elemChanges.parent, element5.getAttributes(), this.pos, element5.getEndOffset()));
                }
            }
            return n2;
        }
        
        void endEdits(AbstractDocument.DefaultDocumentEvent defaultDocumentEvent) {
            for (int size = this.changes.size(), i = 0; i < size; ++i) {
                DefaultStyledDocument.ElementBuffer.ElemChanges elemChanges = (DefaultStyledDocument.ElementBuffer.ElemChanges)this.changes.elementAt(i);
                Element[] anArray = new Element[elemChanges.removed.size()];
                elemChanges.removed.copyInto(anArray);
                Element[] anArray2 = new Element[elemChanges.added.size()];
                elemChanges.added.copyInto(anArray2);
                int index = elemChanges.index;
                ((AbstractDocument.BranchElement)elemChanges.parent).replace(index, anArray.length, anArray2);
                defaultDocumentEvent.addEdit(new AbstractDocument.ElementEdit(elemChanges.parent, index, anArray, anArray2));
            }
            this.changes.removeAllElements();
            this.path.removeAllElements();
        }
        
        void beginEdits(int n, int length) {
            this.offset = n;
            this.length = length;
            this.endOffset = n + length;
            this.pos = n;
            if (this.changes == null) {
                this.changes = new Vector();
            }
            else {
                this.changes.removeAllElements();
            }
            if (this.path == null) {
                this.path = new Stack();
            }
            else {
                this.path.removeAllElements();
            }
            this.fracturedParent = null;
            this.fracturedChild = null;
            boolean b = false;
            this.offsetLastIndexOnReplace = b;
            this.offsetLastIndex = b;
        }
        
        void push(Element element, int n, boolean b) {
            this.path.push(new DefaultStyledDocument.ElementBuffer.ElemChanges(element, n, b));
        }
        
        void push(Element element, int n) {
            this.push(element, n, false);
        }
        
        void pop() {
            DefaultStyledDocument.ElementBuffer.ElemChanges obj = (DefaultStyledDocument.ElementBuffer.ElemChanges)this.path.peek();
            this.path.pop();
            if (obj.added.size() > 0 || obj.removed.size() > 0) {
                this.changes.addElement(obj);
            }
            else if (!this.path.isEmpty()) {
                Element parent = obj.parent;
                if (parent.getElementCount() == 0) {
                    ((DefaultStyledDocument.ElementBuffer.ElemChanges)this.path.peek()).added.removeElement(parent);
                }
            }
        }
        
        void advance(int n) {
            this.pos += n;
        }
        
        void insertElement(DefaultStyledDocument.ElementSpec elementSpec) {
            DefaultStyledDocument.ElementBuffer.ElemChanges elemChanges = (DefaultStyledDocument.ElementBuffer.ElemChanges)this.path.peek();
            switch (elementSpec.getType()) {
                case 1: {
                    switch (elementSpec.getDirection()) {
                        case 5: {
                            Element element = elemChanges.parent.getElement(elemChanges.index);
                            if (element.isLeaf()) {
                                if (elemChanges.index + 1 < elemChanges.parent.getElementCount()) {
                                    element = elemChanges.parent.getElement(elemChanges.index + 1);
                                }
                                else {
                                    throw new StateInvariantError("Join next to leaf");
                                }
                            }
                            this.push(element, 0, true);
                            break;
                        }
                        case 7: {
                            if (!this.createdFracture) {
                                this.fracture(this.path.size() - 1);
                            }
                            if (!elemChanges.isFracture) {
                                this.push(this.fracturedChild, 0, true);
                                break;
                            }
                            this.push(elemChanges.parent.getElement(0), 0, true);
                            break;
                        }
                        default: {
                            Element branchElement = DefaultStyledDocument.this.createBranchElement(elemChanges.parent, elementSpec.getAttributes());
                            elemChanges.added.addElement(branchElement);
                            this.push(branchElement, 0);
                            break;
                        }
                    }
                    break;
                }
                case 2: {
                    this.pop();
                    break;
                }
                case 3: {
                    int length = elementSpec.getLength();
                    if (elementSpec.getDirection() != 5) {
                        elemChanges.added.addElement(DefaultStyledDocument.this.createLeafElement(elemChanges.parent, elementSpec.getAttributes(), this.pos, this.pos + length));
                    }
                    else if (!elemChanges.isFracture) {
                        Element obj = null;
                        if (this.insertPath != null) {
                            int i = this.insertPath.length - 1;
                            while (i >= 0) {
                                if (this.insertPath[i] == elemChanges) {
                                    if (i != this.insertPath.length - 1) {
                                        obj = elemChanges.parent.getElement(elemChanges.index);
                                        break;
                                    }
                                    break;
                                }
                                else {
                                    --i;
                                }
                            }
                        }
                        if (obj == null) {
                            obj = elemChanges.parent.getElement(elemChanges.index + 1);
                        }
                        elemChanges.added.addElement(DefaultStyledDocument.this.createLeafElement(elemChanges.parent, obj.getAttributes(), this.pos, obj.getEndOffset()));
                        elemChanges.removed.addElement(obj);
                    }
                    else {
                        Element element2 = elemChanges.parent.getElement(0);
                        elemChanges.added.addElement(DefaultStyledDocument.this.createLeafElement(elemChanges.parent, element2.getAttributes(), this.pos, element2.getEndOffset()));
                        elemChanges.removed.addElement(element2);
                    }
                    this.pos += length;
                    break;
                }
            }
        }
        
        boolean removeElements(Element element, int n, int n2) {
            if (!element.isLeaf()) {
                int i = element.getElementIndex(n);
                int elementIndex = element.getElementIndex(n2);
                this.push(element, i);
                DefaultStyledDocument.ElementBuffer.ElemChanges elemChanges = (DefaultStyledDocument.ElementBuffer.ElemChanges)this.path.peek();
                if (i == elementIndex) {
                    Element element4 = element.getElement(i);
                    if (n <= element4.getStartOffset() && n2 >= element4.getEndOffset()) {
                        elemChanges.removed.addElement(element4);
                    }
                    else if (this.removeElements(element4, n, n2)) {
                        elemChanges.removed.addElement(element4);
                    }
                }
                else {
                    Element element2 = element.getElement(i);
                    Element element3 = element.getElement(elementIndex);
                    int n3 = n2 < element.getEndOffset();
                    if (n3 && this.canJoin(element2, element3)) {
                        for (; i <= elementIndex; ++i) {
                            elemChanges.removed.addElement(element.getElement(i));
                        }
                        elemChanges.added.addElement(this.join(element, element2, element3, n, n2));
                    }
                    else {
                        int j = i + 1;
                        int n4 = elementIndex - 1;
                        if (element2.getStartOffset() == n || (i == 0 && element2.getStartOffset() > n && element2.getEndOffset() <= n2)) {
                            element2 = null;
                            j = i;
                        }
                        if (n3 == 0) {
                            element3 = null;
                            ++n4;
                        }
                        else if (element3.getStartOffset() == n2) {
                            element3 = null;
                        }
                        if (j <= n4) {
                            elemChanges.index = j;
                        }
                        for (; j <= n4; ++j) {
                            elemChanges.removed.addElement(element.getElement(j));
                        }
                        if (element2 != null && this.removeElements(element2, n, n2)) {
                            elemChanges.removed.insertElementAt(element2, 0);
                            elemChanges.index = i;
                        }
                        if (element3 != null && this.removeElements(element3, n, n2)) {
                            elemChanges.removed.addElement(element3);
                        }
                    }
                }
                this.pop();
                if (element.getElementCount() == elemChanges.removed.size() - elemChanges.added.size()) {
                    return true;
                }
            }
            return false;
        }
        
        boolean canJoin(Element element, Element element2) {
            if (element == null || element2 == null) {
                return false;
            }
            int leaf = element.isLeaf();
            if (leaf != (element2.isLeaf() ? 1 : 0)) {
                return false;
            }
            if (!(leaf == 0)) {
                return element.getAttributes().isEqual(element2.getAttributes());
            }
            String name = element.getName();
            String name2 = element2.getName();
            if (name != null) {
                return name.equals(name2);
            }
            return name2 == null || name2.equals(name);
        }
        
        Element join(Element element, Element element2, Element element3, int n, int n2) {
            if (element2.isLeaf() && element3.isLeaf()) {
                return DefaultStyledDocument.this.createLeafElement(element, element2.getAttributes(), element2.getStartOffset(), element3.getEndOffset());
            }
            if (!element2.isLeaf() && !element3.isLeaf()) {
                Element branchElement = DefaultStyledDocument.this.createBranchElement(element, element2.getAttributes());
                int elementIndex = element2.getElementIndex(n);
                int elementIndex2 = element3.getElementIndex(n2);
                Element element4 = element2.getElement(elementIndex);
                if (element4.getStartOffset() >= n) {
                    element4 = null;
                }
                Element element5 = element3.getElement(elementIndex2);
                if (element5.getStartOffset() == n2) {
                    element5 = null;
                }
                Vector o = new Vector();
                for (int i = 0; i < elementIndex; ++i) {
                    o.addElement(this.clone(branchElement, element2.getElement(i)));
                }
                if (this.canJoin(element4, element5)) {
                    o.addElement(this.join(branchElement, element4, element5, n, n2));
                }
                else {
                    if (element4 != null) {
                        o.addElement(this.cloneAsNecessary(branchElement, element4, n, n2));
                    }
                    if (element5 != null) {
                        o.addElement(this.cloneAsNecessary(branchElement, element5, n, n2));
                    }
                }
                for (int elementCount = element3.getElementCount(), j = (element5 == null) ? elementIndex2 : (elementIndex2 + 1); j < elementCount; ++j) {
                    o.addElement(this.clone(branchElement, element3.getElement(j)));
                }
                Element[] anArray = new Element[o.size()];
                o.copyInto(anArray);
                ((AbstractDocument.BranchElement)branchElement).replace(0, 0, anArray);
                return branchElement;
            }
            else {
                throw new StateInvariantError("No support to join leaf element with non-leaf element");
            }
        }
        
        public Element clone(Element element, Element element2) {
            if (element2.isLeaf()) {
                return DefaultStyledDocument.this.createLeafElement(element, element2.getAttributes(), element2.getStartOffset(), element2.getEndOffset());
            }
            Element branchElement = DefaultStyledDocument.this.createBranchElement(element, element2.getAttributes());
            int elementCount = element2.getElementCount();
            Element[] array = new Element[elementCount];
            for (int i = 0; i < elementCount; ++i) {
                array[i] = this.clone(branchElement, element2.getElement(i));
            }
            ((AbstractDocument.BranchElement)branchElement).replace(0, 0, array);
            return branchElement;
        }
        
        Element cloneAsNecessary(Element element, Element element2, int n, int n2) {
            if (element2.isLeaf()) {
                return DefaultStyledDocument.this.createLeafElement(element, element2.getAttributes(), element2.getStartOffset(), element2.getEndOffset());
            }
            Element branchElement = DefaultStyledDocument.this.createBranchElement(element, element2.getAttributes());
            int elementCount = element2.getElementCount();
            ArrayList<Element> list = new ArrayList(elementCount);
            for (int i = 0; i < elementCount; ++i) {
                Element element3 = element2.getElement(i);
                if (element3.getStartOffset() < n || element3.getEndOffset() > n2) {
                    list.add(this.cloneAsNecessary(branchElement, element3, n, n2));
                }
            }
            ((AbstractDocument.BranchElement)branchElement).replace(0, 0, (Element[])list.toArray(new Element[list.size()]));
            return branchElement;
        }
        
        void fracture(int n) {
            int length = this.insertPath.length;
            int n2 = -1;
            int recreateLeafs = this.recreateLeafs;
            DefaultStyledDocument.ElementBuffer.ElemChanges elemChanges = this.insertPath[length - 1];
            int n3 = elemChanges.index + 1 < elemChanges.parent.getElementCount();
            int n4 = (recreateLeafs != 0) ? length : -1;
            int n5 = length - 1;
            this.createdFracture = true;
            for (int i = length - 2; i >= 0; --i) {
                DefaultStyledDocument.ElementBuffer.ElemChanges elemChanges2 = this.insertPath[i];
                if (elemChanges2.added.size() > 0 || i == n) {
                    n2 = i;
                    if (recreateLeafs == 0 && n3 != 0) {
                        recreateLeafs = 1;
                        if (n4 == -1) {
                            n4 = n5 + 1;
                        }
                    }
                }
                if (n3 == 0 && elemChanges2.index < elemChanges2.parent.getElementCount()) {
                    n3 = 1;
                    n5 = i;
                }
            }
            if (recreateLeafs != 0) {
                if (n2 == -1) {
                    n2 = length - 1;
                }
                this.fractureFrom(this.insertPath, n2, n4);
            }
        }
        
        void fractureFrom(DefaultStyledDocument.ElementBuffer.ElemChanges[] array, int n, int n2) {
            DefaultStyledDocument.ElementBuffer.ElemChanges elemChanges = array[n];
            int length = array.length;
            Element element;
            if (n + 1 == length) {
                element = elemChanges.parent.getElement(elemChanges.index);
            }
            else {
                element = elemChanges.parent.getElement(elemChanges.index - 1);
            }
            Element fracturedChild;
            if (element.isLeaf()) {
                fracturedChild = DefaultStyledDocument.this.createLeafElement(elemChanges.parent, element.getAttributes(), Math.max(this.endOffset, element.getStartOffset()), element.getEndOffset());
            }
            else {
                fracturedChild = DefaultStyledDocument.this.createBranchElement(elemChanges.parent, element.getAttributes());
            }
            this.fracturedParent = elemChanges.parent;
            this.fracturedChild = fracturedChild;
            while (++n < n2) {
                int n3 = n + 1 == n2;
                int n4 = n + 1 == length;
                DefaultStyledDocument.ElementBuffer.ElemChanges elemChanges2 = array[n];
                Element element2;
                if (!(n3 == 0)) {
                    if (this.offsetLastIndex || n4 == 0) {
                        element2 = null;
                    }
                    else {
                        element2 = elemChanges2.parent.getElement(elemChanges2.index);
                    }
                }
                else {
                    element2 = elemChanges2.parent.getElement(elemChanges2.index - 1);
                }
                Element element3;
                if (element2 != null) {
                    if (element2.isLeaf()) {
                        element3 = DefaultStyledDocument.this.createLeafElement(fracturedChild, element2.getAttributes(), Math.max(this.endOffset, element2.getStartOffset()), element2.getEndOffset());
                    }
                    else {
                        element3 = DefaultStyledDocument.this.createBranchElement(fracturedChild, element2.getAttributes());
                    }
                }
                else {
                    element3 = null;
                }
                int n5 = elemChanges2.parent.getElementCount() - elemChanges2.index;
                int i = 1;
                int n6;
                Element[] array2;
                if (element3 == null) {
                    if (!(n4 == 0)) {
                        --n5;
                        n6 = elemChanges2.index + 1;
                    }
                    else {
                        n6 = elemChanges2.index;
                    }
                    i = 0;
                    array2 = new Element[n5];
                }
                else {
                    if (n3 == 0) {
                        ++n5;
                        n6 = elemChanges2.index;
                    }
                    else {
                        n6 = elemChanges2.index + 1;
                    }
                    array2 = new Element[n5];
                    array2[0] = element3;
                }
                for (; i < n5; ++i) {
                    Element element4 = elemChanges2.parent.getElement(n6++);
                    array2[i] = this.recreateFracturedElement(fracturedChild, element4);
                    elemChanges2.removed.addElement(element4);
                }
                ((AbstractDocument.BranchElement)fracturedChild).replace(0, 0, array2);
                fracturedChild = element3;
            }
        }
        
        Element recreateFracturedElement(Element element, Element element2) {
            if (element2.isLeaf()) {
                return DefaultStyledDocument.this.createLeafElement(element, element2.getAttributes(), Math.max(element2.getStartOffset(), this.endOffset), element2.getEndOffset());
            }
            Element branchElement = DefaultStyledDocument.this.createBranchElement(element, element2.getAttributes());
            int elementCount = element2.getElementCount();
            Element[] array = new Element[elementCount];
            for (int i = 0; i < elementCount; ++i) {
                array[i] = this.recreateFracturedElement(branchElement, element2.getElement(i));
            }
            ((AbstractDocument.BranchElement)branchElement).replace(0, 0, array);
            return branchElement;
        }
        
        void fractureDeepestLeaf(DefaultStyledDocument.ElementSpec[] array) {
            DefaultStyledDocument.ElementBuffer.ElemChanges elemChanges = (DefaultStyledDocument.ElementBuffer.ElemChanges)this.path.peek();
            Element element = elemChanges.parent.getElement(elemChanges.index);
            if (this.offset != 0) {
                elemChanges.added.addElement(DefaultStyledDocument.this.createLeafElement(elemChanges.parent, element.getAttributes(), element.getStartOffset(), this.offset));
            }
            elemChanges.removed.addElement(element);
            if (element.getEndOffset() != this.endOffset) {
                this.recreateLeafs = true;
            }
            else {
                this.offsetLastIndex = true;
            }
        }
        
        void insertFirstContent(DefaultStyledDocument.ElementSpec[] array) {
            DefaultStyledDocument.ElementSpec elementSpec = array[0];
            DefaultStyledDocument.ElementBuffer.ElemChanges elemChanges = (DefaultStyledDocument.ElementBuffer.ElemChanges)this.path.peek();
            Element element = elemChanges.parent.getElement(elemChanges.index);
            int n = this.offset + elementSpec.getLength();
            int n2 = array.length == 1;
            switch (elementSpec.getDirection()) {
                case 4: {
                    if (element.getEndOffset() != n && n2 == 0) {
                        elemChanges.added.addElement(DefaultStyledDocument.this.createLeafElement(elemChanges.parent, element.getAttributes(), element.getStartOffset(), n));
                        elemChanges.removed.addElement(element);
                        if (element.getEndOffset() != this.endOffset) {
                            this.recreateLeafs = true;
                        }
                        else {
                            this.offsetLastIndex = true;
                        }
                        break;
                    }
                    else {
                        this.offsetLastIndex = true;
                        this.offsetLastIndexOnReplace = true;
                        break;
                    }
                }
                case 5: {
                    if (this.offset != 0) {
                        elemChanges.added.addElement(DefaultStyledDocument.this.createLeafElement(elemChanges.parent, element.getAttributes(), element.getStartOffset(), this.offset));
                        Element element2 = elemChanges.parent.getElement(elemChanges.index + 1);
                        Element obj;
                        if (!(n2 == 0)) {
                            obj = DefaultStyledDocument.this.createLeafElement(elemChanges.parent, element2.getAttributes(), this.offset, element2.getEndOffset());
                        }
                        else {
                            obj = DefaultStyledDocument.this.createLeafElement(elemChanges.parent, element2.getAttributes(), this.offset, n);
                        }
                        elemChanges.added.addElement(obj);
                        elemChanges.removed.addElement(element);
                        elemChanges.removed.addElement(element2);
                        break;
                    }
                    else {
                        break;
                    }
                }
                default: {
                    if (element.getStartOffset() != this.offset) {
                        elemChanges.added.addElement(DefaultStyledDocument.this.createLeafElement(elemChanges.parent, element.getAttributes(), element.getStartOffset(), this.offset));
                    }
                    elemChanges.removed.addElement(element);
                    elemChanges.added.addElement(DefaultStyledDocument.this.createLeafElement(elemChanges.parent, elementSpec.getAttributes(), this.offset, n));
                    if (element.getEndOffset() != this.endOffset) {
                        this.recreateLeafs = true;
                        break;
                    }
                    this.offsetLastIndex = true;
                    break;
                }
            }
        }
        
        class ElemChanges
        {
            Element parent;
            int index;
            Vector<Element> added;
            Vector<Element> removed;
            boolean isFracture;
            
            ElemChanges(Element parent, int index, boolean isFracture) {
                this.parent = parent;
                this.index = index;
                this.isFracture = isFracture;
                this.added = new Vector();
                this.removed = new Vector();
            }
            
            @Override
            public String toString() {
                return "added: " + this.added + "\nremoved: " + this.removed + "\n";
            }
        }
    }
    
    public static class AttributeUndoableEdit extends AbstractUndoableEdit
    {
        protected AttributeSet newAttributes;
        protected AttributeSet copy;
        protected boolean isReplacing;
        protected Element element;
        
        public AttributeUndoableEdit(Element element, AttributeSet newAttributes, boolean isReplacing) {
            this.element = element;
            this.newAttributes = newAttributes;
            this.isReplacing = isReplacing;
            this.copy = element.getAttributes().copyAttributes();
        }
        
        @Override
        public void redo() throws CannotRedoException {
            super.redo();
            MutableAttributeSet set = (MutableAttributeSet)this.element.getAttributes();
            if (this.isReplacing) {
                set.removeAttributes(set);
            }
            set.addAttributes(this.newAttributes);
        }
        
        @Override
        public void undo() throws CannotUndoException {
            super.undo();
            MutableAttributeSet set = (MutableAttributeSet)this.element.getAttributes();
            set.removeAttributes(set);
            set.addAttributes(this.copy);
        }
    }
    
    static class StyleChangeUndoableEdit extends AbstractUndoableEdit
    {
        protected AbstractDocument.AbstractElement element;
        protected Style newStyle;
        protected AttributeSet oldStyle;
        
        public StyleChangeUndoableEdit(AbstractDocument.AbstractElement element, Style newStyle) {
            this.element = element;
            this.newStyle = newStyle;
            this.oldStyle = element.getResolveParent();
        }
        
        @Override
        public void redo() throws CannotRedoException {
            super.redo();
            this.element.setResolveParent(this.newStyle);
        }
        
        @Override
        public void undo() throws CannotUndoException {
            super.undo();
            this.element.setResolveParent(this.oldStyle);
        }
    }
    
    abstract static class AbstractChangeHandler implements ChangeListener
    {
        private static final Map<Class, ReferenceQueue<DefaultStyledDocument>> queueMap;
        private DefaultStyledDocument.AbstractChangeHandler.DocReference doc;
        
        AbstractChangeHandler(DefaultStyledDocument defaultStyledDocument) {
            Class<Object> class1 = this.getClass();
            ReferenceQueue<Object> referenceQueue;
            synchronized (DefaultStyledDocument.AbstractChangeHandler.queueMap) {
                referenceQueue = (ReferenceQueue)DefaultStyledDocument.AbstractChangeHandler.queueMap.get(class1);
                if (referenceQueue == null) {
                    referenceQueue = new ReferenceQueue();
                    DefaultStyledDocument.AbstractChangeHandler.queueMap.put(class1, referenceQueue);
                }
            }
            this.doc = defaultStyledDocument.new DefaultStyledDocument.AbstractChangeHandler.DocReference(referenceQueue);
        }
        
        static List<ChangeListener> getStaleListeners(ChangeListener changeListener) {
            ArrayList<ChangeListener> list = new ArrayList();
            ReferenceQueue<Object> referenceQueue = (ReferenceQueue)DefaultStyledDocument.AbstractChangeHandler.queueMap.get(changeListener.getClass());
            if (referenceQueue != null) {
                synchronized (referenceQueue) {
                    DefaultStyledDocument.AbstractChangeHandler.DocReference docReference;
                    while ((docReference = (DefaultStyledDocument.AbstractChangeHandler.DocReference)referenceQueue.poll()) != null) {
                        list.add(docReference.getListener());
                    }
                }
            }
            return list;
        }
        
        @Override
        public void stateChanged(ChangeEvent changeEvent) {
            DefaultStyledDocument defaultStyledDocument = (DefaultStyledDocument)this.doc.get();
            if (defaultStyledDocument != null) {
                this.fireStateChanged(defaultStyledDocument, changeEvent);
            }
        }
        
        abstract void fireStateChanged(DefaultStyledDocument p0, ChangeEvent p1);
        
        static {
            queueMap = new HashMap();
        }
        
        private class DocReference extends WeakReference<DefaultStyledDocument>
        {
            DocReference(DefaultStyledDocument referent, ReferenceQueue<DefaultStyledDocument> q) {
                super(referent, q);
            }
            
            ChangeListener getListener() {
                return DefaultStyledDocument.AbstractChangeHandler.this;
            }
        }
    }
    
    static class StyleChangeHandler extends DefaultStyledDocument.AbstractChangeHandler
    {
        StyleChangeHandler(DefaultStyledDocument defaultStyledDocument) {
            super(defaultStyledDocument);
        }
        
        @Override
        void fireStateChanged(DefaultStyledDocument defaultStyledDocument, ChangeEvent changeEvent) {
            Object source = changeEvent.getSource();
            if ((source instanceof Style)) {
                defaultStyledDocument.styleChanged((Style)source);
            }
            else {
                defaultStyledDocument.styleChanged(null);
            }
        }
    }
    
    static class StyleContextChangeHandler extends DefaultStyledDocument.AbstractChangeHandler
    {
        StyleContextChangeHandler(DefaultStyledDocument defaultStyledDocument) {
            super(defaultStyledDocument);
        }
        
        @Override
        void fireStateChanged(DefaultStyledDocument defaultStyledDocument, ChangeEvent changeEvent) {
            defaultStyledDocument.updateStylesListeningTo();
        }
    }
    
    class ChangeUpdateRunnable implements Runnable
    {
        boolean isPending;
        
        ChangeUpdateRunnable() {
            this.isPending = false;
        }
        
        @Override
        public void run() {
            synchronized (this) {
                this.isPending = false;
            }
            try {
                DefaultStyledDocument.this.writeLock();
                AbstractDocument.DefaultDocumentEvent defaultDocumentEvent = new AbstractDocument.DefaultDocumentEvent(0, DefaultStyledDocument.this.getLength(), DocumentEvent.EventType.CHANGE);
                defaultDocumentEvent.end();
                DefaultStyledDocument.this.fireChangedUpdate(defaultDocumentEvent);
            }
            finally {
                DefaultStyledDocument.this.writeUnlock();
            }
        }
    }
}