| /* |
| * Copyright (c) 1997, 2008, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| package javax.swing.text; |
| |
| import java.awt.Color; |
| import java.awt.Component; |
| import java.awt.Font; |
| import java.awt.FontMetrics; |
| import java.awt.font.TextAttribute; |
| import java.lang.ref.ReferenceQueue; |
| import java.lang.ref.WeakReference; |
| import java.util.Enumeration; |
| import java.util.HashMap; |
| import java.util.Hashtable; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Stack; |
| import java.util.Vector; |
| import java.util.ArrayList; |
| import java.io.IOException; |
| import java.io.ObjectInputStream; |
| import java.io.ObjectOutputStream; |
| import java.io.Serializable; |
| import javax.swing.Icon; |
| import javax.swing.event.*; |
| import javax.swing.undo.AbstractUndoableEdit; |
| import javax.swing.undo.CannotRedoException; |
| import javax.swing.undo.CannotUndoException; |
| import javax.swing.undo.UndoableEdit; |
| import javax.swing.SwingUtilities; |
| |
| /** |
| * A document that can be marked up with character and paragraph |
| * styles in a manner similar to the Rich Text Format. The element |
| * structure for this document represents style crossings for |
| * style runs. These style runs are mapped into a paragraph element |
| * structure (which may reside in some other structure). The |
| * style runs break at paragraph boundaries since logical styles are |
| * assigned to paragraph boundaries. |
| * <p> |
| * <strong>Warning:</strong> |
| * Serialized objects of this class will not be compatible with |
| * future Swing releases. The current serialization support is |
| * appropriate for short term storage or RMI between applications running |
| * the same version of Swing. As of 1.4, support for long term storage |
| * of all JavaBeans<sup><font size="-2">TM</font></sup> |
| * has been added to the <code>java.beans</code> package. |
| * Please see {@link java.beans.XMLEncoder}. |
| * |
| * @author Timothy Prinzing |
| * @see Document |
| * @see AbstractDocument |
| */ |
| public class DefaultStyledDocument extends AbstractDocument implements StyledDocument { |
| |
| /** |
| * Constructs a styled document. |
| * |
| * @param c the container for the content |
| * @param styles resources and style definitions which may |
| * be shared across documents |
| */ |
| public DefaultStyledDocument(Content c, StyleContext styles) { |
| super(c, styles); |
| listeningStyles = new Vector<Style>(); |
| buffer = new ElementBuffer(createDefaultRoot()); |
| Style defaultStyle = styles.getStyle(StyleContext.DEFAULT_STYLE); |
| setLogicalStyle(0, defaultStyle); |
| } |
| |
| /** |
| * Constructs a styled document with the default content |
| * storage implementation and a shared set of styles. |
| * |
| * @param styles the styles |
| */ |
| public DefaultStyledDocument(StyleContext styles) { |
| this(new GapContent(BUFFER_SIZE_DEFAULT), styles); |
| } |
| |
| /** |
| * Constructs a default styled document. This buffers |
| * input content by a size of <em>BUFFER_SIZE_DEFAULT</em> |
| * and has a style context that is scoped by the lifetime |
| * of the document and is not shared with other documents. |
| */ |
| public DefaultStyledDocument() { |
| this(new GapContent(BUFFER_SIZE_DEFAULT), new StyleContext()); |
| } |
| |
| /** |
| * Gets the default root element. |
| * |
| * @return the root |
| * @see Document#getDefaultRootElement |
| */ |
| public Element getDefaultRootElement() { |
| return buffer.getRootElement(); |
| } |
| |
| /** |
| * Initialize the document to reflect the given element |
| * structure (i.e. the structure reported by the |
| * <code>getDefaultRootElement</code> method. If the |
| * document contained any data it will first be removed. |
| */ |
| protected void create(ElementSpec[] data) { |
| try { |
| if (getLength() != 0) { |
| remove(0, getLength()); |
| } |
| writeLock(); |
| |
| // install the content |
| Content c = getContent(); |
| int n = data.length; |
| StringBuffer sb = new StringBuffer(); |
| for (int i = 0; i < n; i++) { |
| ElementSpec es = data[i]; |
| if (es.getLength() > 0) { |
| sb.append(es.getArray(), es.getOffset(), es.getLength()); |
| } |
| } |
| UndoableEdit cEdit = c.insertString(0, sb.toString()); |
| |
| // build the event and element structure |
| int length = sb.length(); |
| DefaultDocumentEvent evnt = |
| new DefaultDocumentEvent(0, length, DocumentEvent.EventType.INSERT); |
| evnt.addEdit(cEdit); |
| buffer.create(length, data, evnt); |
| |
| // update bidi (possibly) |
| super.insertUpdate(evnt, null); |
| |
| // notify the listeners |
| evnt.end(); |
| fireInsertUpdate(evnt); |
| fireUndoableEditUpdate(new UndoableEditEvent(this, evnt)); |
| } catch (BadLocationException ble) { |
| throw new StateInvariantError("problem initializing"); |
| } finally { |
| writeUnlock(); |
| } |
| |
| } |
| |
| /** |
| * Inserts new elements in bulk. This is useful to allow |
| * parsing with the document in an unlocked state and |
| * prepare an element structure modification. This method |
| * takes an array of tokens that describe how to update an |
| * element structure so the time within a write lock can |
| * be greatly reduced in an asynchronous update situation. |
| * <p> |
| * This method is thread safe, although most Swing methods |
| * are not. Please see |
| * <A HREF="http://java.sun.com/docs/books/tutorial/uiswing/misc/threads.html">How |
| * to Use Threads</A> for more information. |
| * |
| * @param offset the starting offset >= 0 |
| * @param data the element data |
| * @exception BadLocationException for an invalid starting offset |
| */ |
| protected void insert(int offset, ElementSpec[] data) throws BadLocationException { |
| if (data == null || data.length == 0) { |
| return; |
| } |
| |
| try { |
| writeLock(); |
| |
| // install the content |
| Content c = getContent(); |
| int n = data.length; |
| StringBuffer sb = new StringBuffer(); |
| for (int i = 0; i < n; i++) { |
| ElementSpec es = data[i]; |
| if (es.getLength() > 0) { |
| sb.append(es.getArray(), es.getOffset(), es.getLength()); |
| } |
| } |
| if (sb.length() == 0) { |
| // Nothing to insert, bail. |
| return; |
| } |
| UndoableEdit cEdit = c.insertString(offset, sb.toString()); |
| |
| // create event and build the element structure |
| int length = sb.length(); |
| DefaultDocumentEvent evnt = |
| new DefaultDocumentEvent(offset, length, DocumentEvent.EventType.INSERT); |
| evnt.addEdit(cEdit); |
| buffer.insert(offset, length, data, evnt); |
| |
| // update bidi (possibly) |
| super.insertUpdate(evnt, null); |
| |
| // notify the listeners |
| evnt.end(); |
| fireInsertUpdate(evnt); |
| fireUndoableEditUpdate(new UndoableEditEvent(this, evnt)); |
| } finally { |
| writeUnlock(); |
| } |
| } |
| |
| /** |
| * Removes an element from this document. |
| * |
| * <p>The element is removed from its parent element, as well as |
| * the text in the range identified by the element. If the |
| * element isn't associated with the document, {@code |
| * IllegalArgumentException} is thrown.</p> |
| * |
| * <p>As empty branch elements are not allowed in the document, if the |
| * element is the sole child, its parent element is removed as well, |
| * recursively. This means that when replacing all the children of a |
| * particular element, new children should be added <em>before</em> |
| * removing old children. |
| * |
| * <p>Element removal results in two events being fired, the |
| * {@code DocumentEvent} for changes in element structure and {@code |
| * UndoableEditEvent} for changes in document content.</p> |
| * |
| * <p>If the element contains end-of-content mark (the last {@code |
| * "\n"} character in document), this character is not removed; |
| * instead, preceding leaf element is extended to cover the |
| * character. If the last leaf already ends with {@code "\n",} it is |
| * included in content removal.</p> |
| * |
| * <p>If the element is {@code null,} {@code NullPointerException} is |
| * thrown. If the element structure would become invalid after the removal, |
| * for example if the element is the document root element, {@code |
| * IllegalArgumentException} is thrown. If the current element structure is |
| * invalid, {@code IllegalStateException} is thrown.</p> |
| * |
| * @param elem the element to remove |
| * @throws NullPointerException if the element is {@code null} |
| * @throws IllegalArgumentException if the element could not be removed |
| * @throws IllegalStateException if the element structure is invalid |
| * |
| * @since 1.7 |
| */ |
| public void removeElement(Element elem) { |
| try { |
| writeLock(); |
| removeElementImpl(elem); |
| } finally { |
| writeUnlock(); |
| } |
| } |
| |
| private void removeElementImpl(Element elem) { |
| if (elem.getDocument() != this) { |
| throw new IllegalArgumentException("element doesn't belong to document"); |
| } |
| BranchElement parent = (BranchElement) elem.getParentElement(); |
| if (parent == null) { |
| throw new IllegalArgumentException("can't remove the root element"); |
| } |
| |
| int startOffset = elem.getStartOffset(); |
| int removeFrom = startOffset; |
| int endOffset = elem.getEndOffset(); |
| int removeTo = endOffset; |
| int lastEndOffset = getLength() + 1; |
| Content content = getContent(); |
| boolean atEnd = false; |
| boolean isComposedText = Utilities.isComposedTextElement(elem); |
| |
| if (endOffset >= lastEndOffset) { |
| // element includes the last "\n" character, needs special handling |
| if (startOffset <= 0) { |
| throw new IllegalArgumentException("can't remove the whole content"); |
| } |
| removeTo = lastEndOffset - 1; // last "\n" must not be removed |
| try { |
| if (content.getString(startOffset - 1, 1).charAt(0) == '\n') { |
| removeFrom--; // preceding leaf ends with "\n", remove it |
| } |
| } catch (BadLocationException ble) { // can't happen |
| throw new IllegalStateException(ble); |
| } |
| atEnd = true; |
| } |
| int length = removeTo - removeFrom; |
| |
| DefaultDocumentEvent dde = new DefaultDocumentEvent(removeFrom, |
| length, DefaultDocumentEvent.EventType.REMOVE); |
| UndoableEdit ue = null; |
| // do not leave empty branch elements |
| while (parent.getElementCount() == 1) { |
| elem = parent; |
| parent = (BranchElement) parent.getParentElement(); |
| if (parent == null) { // shouldn't happen |
| throw new IllegalStateException("invalid element structure"); |
| } |
| } |
| Element[] removed = { elem }; |
| Element[] added = {}; |
| int index = parent.getElementIndex(startOffset); |
| parent.replace(index, 1, added); |
| dde.addEdit(new ElementEdit(parent, index, removed, added)); |
| if (length > 0) { |
| try { |
| ue = content.remove(removeFrom, length); |
| if (ue != null) { |
| dde.addEdit(ue); |
| } |
| } catch (BadLocationException ble) { |
| // can only happen if the element structure is severely broken |
| throw new IllegalStateException(ble); |
| } |
| lastEndOffset -= length; |
| } |
| |
| if (atEnd) { |
| // preceding leaf element should be extended to cover orphaned "\n" |
| Element prevLeaf = parent.getElement(parent.getElementCount() - 1); |
| while ((prevLeaf != null) && !prevLeaf.isLeaf()) { |
| prevLeaf = prevLeaf.getElement(prevLeaf.getElementCount() - 1); |
| } |
| if (prevLeaf == null) { // shouldn't happen |
| throw new IllegalStateException("invalid element structure"); |
| } |
| int prevStartOffset = prevLeaf.getStartOffset(); |
| BranchElement prevParent = (BranchElement) prevLeaf.getParentElement(); |
| int prevIndex = prevParent.getElementIndex(prevStartOffset); |
| Element newElem; |
| newElem = createLeafElement(prevParent, prevLeaf.getAttributes(), |
| prevStartOffset, lastEndOffset); |
| Element[] prevRemoved = { prevLeaf }; |
| Element[] prevAdded = { newElem }; |
| prevParent.replace(prevIndex, 1, prevAdded); |
| dde.addEdit(new ElementEdit(prevParent, prevIndex, |
| prevRemoved, prevAdded)); |
| } |
| |
| postRemoveUpdate(dde); |
| dde.end(); |
| fireRemoveUpdate(dde); |
| if (! (isComposedText && (ue != null))) { |
| // do not fire UndoabeEdit event for composed text edit (unsupported) |
| fireUndoableEditUpdate(new UndoableEditEvent(this, dde)); |
| } |
| } |
| |
| /** |
| * Adds a new style into the logical style hierarchy. Style attributes |
| * resolve from bottom up so an attribute specified in a child |
| * will override an attribute specified in the parent. |
| * |
| * @param nm the name of the style (must be unique within the |
| * collection of named styles). The name may be null if the style |
| * is unnamed, but the caller is responsible |
| * for managing the reference returned as an unnamed style can't |
| * be fetched by name. An unnamed style may be useful for things |
| * like character attribute overrides such as found in a style |
| * run. |
| * @param parent the parent style. This may be null if unspecified |
| * attributes need not be resolved in some other style. |
| * @return the style |
| */ |
| public Style addStyle(String nm, Style parent) { |
| StyleContext styles = (StyleContext) getAttributeContext(); |
| return styles.addStyle(nm, parent); |
| } |
| |
| /** |
| * Removes a named style previously added to the document. |
| * |
| * @param nm the name of the style to remove |
| */ |
| public void removeStyle(String nm) { |
| StyleContext styles = (StyleContext) getAttributeContext(); |
| styles.removeStyle(nm); |
| } |
| |
| /** |
| * Fetches a named style previously added. |
| * |
| * @param nm the name of the style |
| * @return the style |
| */ |
| public Style getStyle(String nm) { |
| StyleContext styles = (StyleContext) getAttributeContext(); |
| return styles.getStyle(nm); |
| } |
| |
| |
| /** |
| * Fetches the list of of style names. |
| * |
| * @return all the style names |
| */ |
| public Enumeration<?> getStyleNames() { |
| return ((StyleContext) getAttributeContext()).getStyleNames(); |
| } |
| |
| /** |
| * Sets the logical style to use for the paragraph at the |
| * given position. If attributes aren't explicitly set |
| * for character and paragraph attributes they will resolve |
| * through the logical style assigned to the paragraph, which |
| * in turn may resolve through some hierarchy completely |
| * independent of the element hierarchy in the document. |
| * <p> |
| * This method is thread safe, although most Swing methods |
| * are not. Please see |
| * <A HREF="http://java.sun.com/docs/books/tutorial/uiswing/misc/threads.html">How |
| * to Use Threads</A> for more information. |
| * |
| * @param pos the offset from the start of the document >= 0 |
| * @param s the logical style to assign to the paragraph, null if none |
| */ |
| public void setLogicalStyle(int pos, Style s) { |
| Element paragraph = getParagraphElement(pos); |
| if ((paragraph != null) && (paragraph instanceof AbstractElement)) { |
| try { |
| writeLock(); |
| StyleChangeUndoableEdit edit = new StyleChangeUndoableEdit((AbstractElement)paragraph, s); |
| ((AbstractElement)paragraph).setResolveParent(s); |
| int p0 = paragraph.getStartOffset(); |
| int p1 = paragraph.getEndOffset(); |
| DefaultDocumentEvent e = |
| new DefaultDocumentEvent(p0, p1 - p0, DocumentEvent.EventType.CHANGE); |
| e.addEdit(edit); |
| e.end(); |
| fireChangedUpdate(e); |
| fireUndoableEditUpdate(new UndoableEditEvent(this, e)); |
| } finally { |
| writeUnlock(); |
| } |
| } |
| } |
| |
| /** |
| * Fetches the logical style assigned to the paragraph |
| * represented by the given position. |
| * |
| * @param p the location to translate to a paragraph |
| * and determine the logical style assigned >= 0. This |
| * is an offset from the start of the document. |
| * @return the style, null if none |
| */ |
| public Style getLogicalStyle(int p) { |
| Style s = null; |
| Element paragraph = getParagraphElement(p); |
| if (paragraph != null) { |
| AttributeSet a = paragraph.getAttributes(); |
| AttributeSet parent = a.getResolveParent(); |
| if (parent instanceof Style) { |
| s = (Style) parent; |
| } |
| } |
| return s; |
| } |
| |
| /** |
| * Sets attributes for some part of the document. |
| * A write lock is held by this operation while changes |
| * are being made, and a DocumentEvent is sent to the listeners |
| * after the change has been successfully completed. |
| * <p> |
| * This method is thread safe, although most Swing methods |
| * are not. Please see |
| * <A HREF="http://java.sun.com/docs/books/tutorial/uiswing/misc/threads.html">How |
| * to Use Threads</A> for more information. |
| * |
| * @param offset the offset in the document >= 0 |
| * @param length the length >= 0 |
| * @param s the attributes |
| * @param replace true if the previous attributes should be replaced |
| * before setting the new attributes |
| */ |
| public void setCharacterAttributes(int offset, int length, AttributeSet s, boolean replace) { |
| if (length == 0) { |
| return; |
| } |
| try { |
| writeLock(); |
| DefaultDocumentEvent changes = |
| new DefaultDocumentEvent(offset, length, DocumentEvent.EventType.CHANGE); |
| |
| // split elements that need it |
| buffer.change(offset, length, changes); |
| |
| AttributeSet sCopy = s.copyAttributes(); |
| |
| // PENDING(prinz) - this isn't a very efficient way to iterate |
| int lastEnd; |
| for (int pos = offset; pos < (offset + length); pos = lastEnd) { |
| Element run = getCharacterElement(pos); |
| lastEnd = run.getEndOffset(); |
| if (pos == lastEnd) { |
| // offset + length beyond length of document, bail. |
| break; |
| } |
| MutableAttributeSet attr = (MutableAttributeSet) run.getAttributes(); |
| changes.addEdit(new AttributeUndoableEdit(run, sCopy, replace)); |
| if (replace) { |
| attr.removeAttributes(attr); |
| } |
| attr.addAttributes(s); |
| } |
| changes.end(); |
| fireChangedUpdate(changes); |
| fireUndoableEditUpdate(new UndoableEditEvent(this, changes)); |
| } finally { |
| writeUnlock(); |
| } |
| |
| } |
| |
| /** |
| * Sets attributes for a paragraph. |
| * <p> |
| * This method is thread safe, although most Swing methods |
| * are not. Please see |
| * <A HREF="http://java.sun.com/docs/books/tutorial/uiswing/misc/threads.html">How |
| * to Use Threads</A> for more information. |
| * |
| * @param offset the offset into the paragraph >= 0 |
| * @param length the number of characters affected >= 0 |
| * @param s the attributes |
| * @param replace whether to replace existing attributes, or merge them |
| */ |
| public void setParagraphAttributes(int offset, int length, AttributeSet s, |
| boolean replace) { |
| try { |
| writeLock(); |
| DefaultDocumentEvent changes = |
| new DefaultDocumentEvent(offset, length, DocumentEvent.EventType.CHANGE); |
| |
| AttributeSet sCopy = s.copyAttributes(); |
| |
| // PENDING(prinz) - this assumes a particular element structure |
| Element section = getDefaultRootElement(); |
| int index0 = section.getElementIndex(offset); |
| int index1 = section.getElementIndex(offset + ((length > 0) ? length - 1 : 0)); |
| boolean isI18N = Boolean.TRUE.equals(getProperty(I18NProperty)); |
| boolean hasRuns = false; |
| for (int i = index0; i <= index1; i++) { |
| Element paragraph = section.getElement(i); |
| MutableAttributeSet attr = (MutableAttributeSet) paragraph.getAttributes(); |
| changes.addEdit(new AttributeUndoableEdit(paragraph, sCopy, replace)); |
| if (replace) { |
| attr.removeAttributes(attr); |
| } |
| attr.addAttributes(s); |
| if (isI18N && !hasRuns) { |
| hasRuns = (attr.getAttribute(TextAttribute.RUN_DIRECTION) != null); |
| } |
| } |
| |
| if (hasRuns) { |
| updateBidi( changes ); |
| } |
| |
| changes.end(); |
| fireChangedUpdate(changes); |
| fireUndoableEditUpdate(new UndoableEditEvent(this, changes)); |
| } finally { |
| writeUnlock(); |
| } |
| } |
| |
| /** |
| * Gets the paragraph element at the offset <code>pos</code>. |
| * A paragraph consists of at least one child Element, which is usually |
| * a leaf. |
| * |
| * @param pos the starting offset >= 0 |
| * @return the element |
| */ |
| public Element getParagraphElement(int pos) { |
| Element e; |
| for (e = getDefaultRootElement(); ! e.isLeaf(); ) { |
| int index = e.getElementIndex(pos); |
| e = e.getElement(index); |
| } |
| if(e != null) |
| return e.getParentElement(); |
| return e; |
| } |
| |
| /** |
| * Gets a character element based on a position. |
| * |
| * @param pos the position in the document >= 0 |
| * @return the element |
| */ |
| public Element getCharacterElement(int pos) { |
| Element e; |
| for (e = getDefaultRootElement(); ! e.isLeaf(); ) { |
| int index = e.getElementIndex(pos); |
| e = e.getElement(index); |
| } |
| return e; |
| } |
| |
| // --- local methods ------------------------------------------------- |
| |
| /** |
| * Updates document structure as a result of text insertion. This |
| * will happen within a write lock. This implementation simply |
| * parses the inserted content for line breaks and builds up a set |
| * of instructions for the element buffer. |
| * |
| * @param chng a description of the document change |
| * @param attr the attributes |
| */ |
| protected void insertUpdate(DefaultDocumentEvent chng, AttributeSet attr) { |
| int offset = chng.getOffset(); |
| int length = chng.getLength(); |
| if (attr == null) { |
| attr = SimpleAttributeSet.EMPTY; |
| } |
| |
| // Paragraph attributes should come from point after insertion. |
| // You really only notice this when inserting at a paragraph |
| // boundary. |
| Element paragraph = getParagraphElement(offset + length); |
| AttributeSet pattr = paragraph.getAttributes(); |
| // Character attributes should come from actual insertion point. |
| Element pParagraph = getParagraphElement(offset); |
| Element run = pParagraph.getElement(pParagraph.getElementIndex |
| (offset)); |
| int endOffset = offset + length; |
| boolean insertingAtBoundry = (run.getEndOffset() == endOffset); |
| AttributeSet cattr = run.getAttributes(); |
| |
| try { |
| Segment s = new Segment(); |
| Vector<ElementSpec> parseBuffer = new Vector<ElementSpec>(); |
| ElementSpec lastStartSpec = null; |
| boolean insertingAfterNewline = false; |
| short lastStartDirection = ElementSpec.OriginateDirection; |
| // Check if the previous character was a newline. |
| if (offset > 0) { |
| getText(offset - 1, 1, s); |
| if (s.array[s.offset] == '\n') { |
| // Inserting after a newline. |
| insertingAfterNewline = true; |
| lastStartDirection = createSpecsForInsertAfterNewline |
| (paragraph, pParagraph, pattr, parseBuffer, |
| offset, endOffset); |
| for(int counter = parseBuffer.size() - 1; counter >= 0; |
| counter--) { |
| ElementSpec spec = parseBuffer.elementAt(counter); |
| if(spec.getType() == ElementSpec.StartTagType) { |
| lastStartSpec = spec; |
| break; |
| } |
| } |
| } |
| } |
| // If not inserting after a new line, pull the attributes for |
| // new paragraphs from the paragraph under the insertion point. |
| if(!insertingAfterNewline) |
| pattr = pParagraph.getAttributes(); |
| |
| getText(offset, length, s); |
| char[] txt = s.array; |
| int n = s.offset + s.count; |
| int lastOffset = s.offset; |
| |
| for (int i = s.offset; i < n; i++) { |
| if (txt[i] == '\n') { |
| int breakOffset = i + 1; |
| parseBuffer.addElement( |
| new ElementSpec(attr, ElementSpec.ContentType, |
| breakOffset - lastOffset)); |
| parseBuffer.addElement( |
| new ElementSpec(null, ElementSpec.EndTagType)); |
| lastStartSpec = new ElementSpec(pattr, ElementSpec. |
| StartTagType); |
| parseBuffer.addElement(lastStartSpec); |
| lastOffset = breakOffset; |
| } |
| } |
| if (lastOffset < n) { |
| parseBuffer.addElement( |
| new ElementSpec(attr, ElementSpec.ContentType, |
| n - lastOffset)); |
| } |
| |
| ElementSpec first = parseBuffer.firstElement(); |
| |
| int docLength = getLength(); |
| |
| // Check for join previous of first content. |
| if(first.getType() == ElementSpec.ContentType && |
| cattr.isEqual(attr)) { |
| first.setDirection(ElementSpec.JoinPreviousDirection); |
| } |
| |
| // Do a join fracture/next for last start spec if necessary. |
| if(lastStartSpec != null) { |
| if(insertingAfterNewline) { |
| lastStartSpec.setDirection(lastStartDirection); |
| } |
| // Join to the fracture if NOT inserting at the end |
| // (fracture only happens when not inserting at end of |
| // paragraph). |
| else if(pParagraph.getEndOffset() != endOffset) { |
| lastStartSpec.setDirection(ElementSpec. |
| JoinFractureDirection); |
| } |
| // Join to next if parent of pParagraph has another |
| // element after pParagraph, and it isn't a leaf. |
| else { |
| Element parent = pParagraph.getParentElement(); |
| int pParagraphIndex = parent.getElementIndex(offset); |
| if((pParagraphIndex + 1) < parent.getElementCount() && |
| !parent.getElement(pParagraphIndex + 1).isLeaf()) { |
| lastStartSpec.setDirection(ElementSpec. |
| JoinNextDirection); |
| } |
| } |
| } |
| |
| // Do a JoinNext for last spec if it is content, it doesn't |
| // already have a direction set, no new paragraphs have been |
| // inserted or a new paragraph has been inserted and its join |
| // direction isn't originate, and the element at endOffset |
| // is a leaf. |
| if(insertingAtBoundry && endOffset < docLength) { |
| ElementSpec last = parseBuffer.lastElement(); |
| if(last.getType() == ElementSpec.ContentType && |
| last.getDirection() != ElementSpec.JoinPreviousDirection && |
| ((lastStartSpec == null && (paragraph == pParagraph || |
| insertingAfterNewline)) || |
| (lastStartSpec != null && lastStartSpec.getDirection() != |
| ElementSpec.OriginateDirection))) { |
| Element nextRun = paragraph.getElement(paragraph. |
| getElementIndex(endOffset)); |
| // Don't try joining to a branch! |
| if(nextRun.isLeaf() && |
| attr.isEqual(nextRun.getAttributes())) { |
| last.setDirection(ElementSpec.JoinNextDirection); |
| } |
| } |
| } |
| // If not inserting at boundary and there is going to be a |
| // fracture, then can join next on last content if cattr |
| // matches the new attributes. |
| else if(!insertingAtBoundry && lastStartSpec != null && |
| lastStartSpec.getDirection() == |
| ElementSpec.JoinFractureDirection) { |
| ElementSpec last = parseBuffer.lastElement(); |
| if(last.getType() == ElementSpec.ContentType && |
| last.getDirection() != ElementSpec.JoinPreviousDirection && |
| attr.isEqual(cattr)) { |
| last.setDirection(ElementSpec.JoinNextDirection); |
| } |
| } |
| |
| // Check for the composed text element. If it is, merge the character attributes |
| // into this element as well. |
| if (Utilities.isComposedTextAttributeDefined(attr)) { |
| ((MutableAttributeSet)attr).addAttributes(cattr); |
| ((MutableAttributeSet)attr).addAttribute(AbstractDocument.ElementNameAttribute, |
| AbstractDocument.ContentElementName); |
| } |
| |
| ElementSpec[] spec = new ElementSpec[parseBuffer.size()]; |
| parseBuffer.copyInto(spec); |
| buffer.insert(offset, length, spec, chng); |
| } catch (BadLocationException bl) { |
| } |
| |
| super.insertUpdate( chng, attr ); |
| } |
| |
| /** |
| * This is called by insertUpdate when inserting after a new line. |
| * It generates, in <code>parseBuffer</code>, ElementSpecs that will |
| * position the stack in <code>paragraph</code>.<p> |
| * It returns the direction the last StartSpec should have (this don't |
| * necessarily create the last start spec). |
| */ |
| short createSpecsForInsertAfterNewline(Element paragraph, |
| Element pParagraph, AttributeSet pattr, Vector<ElementSpec> parseBuffer, |
| int offset, int endOffset) { |
| // Need to find the common parent of pParagraph and paragraph. |
| if(paragraph.getParentElement() == pParagraph.getParentElement()) { |
| // The simple (and common) case that pParagraph and |
| // paragraph have the same parent. |
| ElementSpec spec = new ElementSpec(pattr, ElementSpec.EndTagType); |
| parseBuffer.addElement(spec); |
| spec = new ElementSpec(pattr, ElementSpec.StartTagType); |
| parseBuffer.addElement(spec); |
| if(pParagraph.getEndOffset() != endOffset) |
| return ElementSpec.JoinFractureDirection; |
| |
| Element parent = pParagraph.getParentElement(); |
| if((parent.getElementIndex(offset) + 1) < parent.getElementCount()) |
| return ElementSpec.JoinNextDirection; |
| } |
| else { |
| // Will only happen for text with more than 2 levels. |
| // Find the common parent of a paragraph and pParagraph |
| Vector<Element> leftParents = new Vector<Element>(); |
| Vector<Element> rightParents = new Vector<Element>(); |
| Element e = pParagraph; |
| while(e != null) { |
| leftParents.addElement(e); |
| e = e.getParentElement(); |
| } |
| e = paragraph; |
| int leftIndex = -1; |
| while(e != null && (leftIndex = leftParents.indexOf(e)) == -1) { |
| rightParents.addElement(e); |
| e = e.getParentElement(); |
| } |
| if(e != null) { |
| // e identifies the common parent. |
| // Build the ends. |
| for(int counter = 0; counter < leftIndex; |
| counter++) { |
| parseBuffer.addElement(new ElementSpec |
| (null, ElementSpec.EndTagType)); |
| } |
| // And the starts. |
| ElementSpec spec; |
| for(int counter = rightParents.size() - 1; |
| counter >= 0; counter--) { |
| spec = new ElementSpec(rightParents.elementAt(counter).getAttributes(), |
| ElementSpec.StartTagType); |
| if(counter > 0) |
| spec.setDirection(ElementSpec.JoinNextDirection); |
| parseBuffer.addElement(spec); |
| } |
| // If there are right parents, then we generated starts |
| // down the right subtree and there will be an element to |
| // join to. |
| if(rightParents.size() > 0) |
| return ElementSpec.JoinNextDirection; |
| // No right subtree, e.getElement(endOffset) is a |
| // leaf. There will be a facture. |
| return ElementSpec.JoinFractureDirection; |
| } |
| // else: Could throw an exception here, but should never get here! |
| } |
| return ElementSpec.OriginateDirection; |
| } |
| |
| /** |
| * Updates document structure as a result of text removal. |
| * |
| * @param chng a description of the document change |
| */ |
| protected void removeUpdate(DefaultDocumentEvent chng) { |
| super.removeUpdate(chng); |
| buffer.remove(chng.getOffset(), chng.getLength(), chng); |
| } |
| |
| /** |
| * Creates the root element to be used to represent the |
| * default document structure. |
| * |
| * @return the element base |
| */ |
| protected AbstractElement createDefaultRoot() { |
| // grabs a write-lock for this initialization and |
| // abandon it during initialization so in normal |
| // operation we can detect an illegitimate attempt |
| // to mutate attributes. |
| writeLock(); |
| BranchElement section = new SectionElement(); |
| BranchElement paragraph = new BranchElement(section, null); |
| |
| LeafElement brk = new LeafElement(paragraph, null, 0, 1); |
| Element[] buff = new Element[1]; |
| buff[0] = brk; |
| paragraph.replace(0, 0, buff); |
| |
| buff[0] = paragraph; |
| section.replace(0, 0, buff); |
| writeUnlock(); |
| return section; |
| } |
| |
| /** |
| * Gets the foreground color from an attribute set. |
| * |
| * @param attr the attribute set |
| * @return the color |
| */ |
| public Color getForeground(AttributeSet attr) { |
| StyleContext styles = (StyleContext) getAttributeContext(); |
| return styles.getForeground(attr); |
| } |
| |
| /** |
| * Gets the background color from an attribute set. |
| * |
| * @param attr the attribute set |
| * @return the color |
| */ |
| public Color getBackground(AttributeSet attr) { |
| StyleContext styles = (StyleContext) getAttributeContext(); |
| return styles.getBackground(attr); |
| } |
| |
| /** |
| * Gets the font from an attribute set. |
| * |
| * @param attr the attribute set |
| * @return the font |
| */ |
| public Font getFont(AttributeSet attr) { |
| StyleContext styles = (StyleContext) getAttributeContext(); |
| return styles.getFont(attr); |
| } |
| |
| /** |
| * Called when any of this document's styles have changed. |
| * Subclasses may wish to be intelligent about what gets damaged. |
| * |
| * @param style The Style that has changed. |
| */ |
| protected void styleChanged(Style style) { |
| // Only propagate change updated if have content |
| if (getLength() != 0) { |
| // lazily create a ChangeUpdateRunnable |
| if (updateRunnable == null) { |
| updateRunnable = new ChangeUpdateRunnable(); |
| } |
| |
| // We may get a whole batch of these at once, so only |
| // queue the runnable if it is not already pending |
| synchronized(updateRunnable) { |
| if (!updateRunnable.isPending) { |
| SwingUtilities.invokeLater(updateRunnable); |
| updateRunnable.isPending = true; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Adds a document listener for notification of any changes. |
| * |
| * @param listener the listener |
| * @see Document#addDocumentListener |
| */ |
| public void addDocumentListener(DocumentListener listener) { |
| synchronized(listeningStyles) { |
| int oldDLCount = listenerList.getListenerCount |
| (DocumentListener.class); |
| super.addDocumentListener(listener); |
| if (oldDLCount == 0) { |
| if (styleContextChangeListener == null) { |
| styleContextChangeListener = |
| createStyleContextChangeListener(); |
| } |
| if (styleContextChangeListener != null) { |
| StyleContext styles = (StyleContext)getAttributeContext(); |
| List<ChangeListener> staleListeners = |
| AbstractChangeHandler.getStaleListeners(styleContextChangeListener); |
| for (ChangeListener l: staleListeners) { |
| styles.removeChangeListener(l); |
| } |
| styles.addChangeListener(styleContextChangeListener); |
| } |
| updateStylesListeningTo(); |
| } |
| } |
| } |
| |
| /** |
| * Removes a document listener. |
| * |
| * @param listener the listener |
| * @see Document#removeDocumentListener |
| */ |
| public void removeDocumentListener(DocumentListener listener) { |
| synchronized(listeningStyles) { |
| super.removeDocumentListener(listener); |
| if (listenerList.getListenerCount(DocumentListener.class) == 0) { |
| for (int counter = listeningStyles.size() - 1; counter >= 0; |
| counter--) { |
| listeningStyles.elementAt(counter). |
| removeChangeListener(styleChangeListener); |
| } |
| listeningStyles.removeAllElements(); |
| if (styleContextChangeListener != null) { |
| StyleContext styles = (StyleContext)getAttributeContext(); |
| styles.removeChangeListener(styleContextChangeListener); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Returns a new instance of StyleChangeHandler. |
| */ |
| ChangeListener createStyleChangeListener() { |
| return new StyleChangeHandler(this); |
| } |
| |
| /** |
| * Returns a new instance of StyleContextChangeHandler. |
| */ |
| ChangeListener createStyleContextChangeListener() { |
| return new StyleContextChangeHandler(this); |
| } |
| |
| /** |
| * Adds a ChangeListener to new styles, and removes ChangeListener from |
| * old styles. |
| */ |
| void updateStylesListeningTo() { |
| synchronized(listeningStyles) { |
| StyleContext styles = (StyleContext)getAttributeContext(); |
| if (styleChangeListener == null) { |
| styleChangeListener = createStyleChangeListener(); |
| } |
| if (styleChangeListener != null && styles != null) { |
| Enumeration styleNames = styles.getStyleNames(); |
| Vector v = (Vector)listeningStyles.clone(); |
| listeningStyles.removeAllElements(); |
| List<ChangeListener> staleListeners = |
| AbstractChangeHandler.getStaleListeners(styleChangeListener); |
| while (styleNames.hasMoreElements()) { |
| String name = (String)styleNames.nextElement(); |
| Style aStyle = styles.getStyle(name); |
| int index = v.indexOf(aStyle); |
| listeningStyles.addElement(aStyle); |
| if (index == -1) { |
| for (ChangeListener l: staleListeners) { |
| aStyle.removeChangeListener(l); |
| } |
| aStyle.addChangeListener(styleChangeListener); |
| } |
| else { |
| v.removeElementAt(index); |
| } |
| } |
| for (int counter = v.size() - 1; counter >= 0; counter--) { |
| Style aStyle = (Style)v.elementAt(counter); |
| aStyle.removeChangeListener(styleChangeListener); |
| } |
| if (listeningStyles.size() == 0) { |
| styleChangeListener = null; |
| } |
| } |
| } |
| } |
| |
| private void readObject(ObjectInputStream s) |
| throws ClassNotFoundException, IOException { |
| listeningStyles = new Vector<Style>(); |
| s.defaultReadObject(); |
| // Reinstall style listeners. |
| if (styleContextChangeListener == null && |
| listenerList.getListenerCount(DocumentListener.class) > 0) { |
| styleContextChangeListener = createStyleContextChangeListener(); |
| if (styleContextChangeListener != null) { |
| StyleContext styles = (StyleContext)getAttributeContext(); |
| styles.addChangeListener(styleContextChangeListener); |
| } |
| updateStylesListeningTo(); |
| } |
| } |
| |
| // --- member variables ----------------------------------------------------------- |
| |
| /** |
| * The default size of the initial content buffer. |
| */ |
| public static final int BUFFER_SIZE_DEFAULT = 4096; |
| |
| protected ElementBuffer buffer; |
| |
| /** Styles listening to. */ |
| private transient Vector<Style> listeningStyles; |
| |
| /** Listens to Styles. */ |
| private transient ChangeListener styleChangeListener; |
| |
| /** Listens to Styles. */ |
| private transient ChangeListener styleContextChangeListener; |
| |
| /** Run to create a change event for the document */ |
| private transient ChangeUpdateRunnable updateRunnable; |
| |
| /** |
| * Default root element for a document... maps out the |
| * paragraphs/lines contained. |
| * <p> |
| * <strong>Warning:</strong> |
| * Serialized objects of this class will not be compatible with |
| * future Swing releases. The current serialization support is |
| * appropriate for short term storage or RMI between applications running |
| * the same version of Swing. As of 1.4, support for long term storage |
| * of all JavaBeans<sup><font size="-2">TM</font></sup> |
| * has been added to the <code>java.beans</code> package. |
| * Please see {@link java.beans.XMLEncoder}. |
| */ |
| protected class SectionElement extends BranchElement { |
| |
| /** |
| * Creates a new SectionElement. |
| */ |
| public SectionElement() { |
| super(null, null); |
| } |
| |
| /** |
| * Gets the name of the element. |
| * |
| * @return the name |
| */ |
| public String getName() { |
| return SectionElementName; |
| } |
| } |
| |
| /** |
| * Specification for building elements. |
| * <p> |
| * <strong>Warning:</strong> |
| * Serialized objects of this class will not be compatible with |
| * future Swing releases. The current serialization support is |
| * appropriate for short term storage or RMI between applications running |
| * the same version of Swing. As of 1.4, support for long term storage |
| * of all JavaBeans<sup><font size="-2">TM</font></sup> |
| * has been added to the <code>java.beans</code> package. |
| * Please see {@link java.beans.XMLEncoder}. |
| */ |
| public static class ElementSpec { |
| |
| /** |
| * A possible value for getType. This specifies |
| * that this record type is a start tag and |
| * represents markup that specifies the start |
| * of an element. |
| */ |
| public static final short StartTagType = 1; |
| |
| /** |
| * A possible value for getType. This specifies |
| * that this record type is a end tag and |
| * represents markup that specifies the end |
| * of an element. |
| */ |
| public static final short EndTagType = 2; |
| |
| /** |
| * A possible value for getType. This specifies |
| * that this record type represents content. |
| */ |
| public static final short ContentType = 3; |
| |
| /** |
| * A possible value for getDirection. This specifies |
| * that the data associated with this record should |
| * be joined to what precedes it. |
| */ |
| public static final short JoinPreviousDirection = 4; |
| |
| /** |
| * A possible value for getDirection. This specifies |
| * that the data associated with this record should |
| * be joined to what follows it. |
| */ |
| public static final short JoinNextDirection = 5; |
| |
| /** |
| * A possible value for getDirection. This specifies |
| * that the data associated with this record should |
| * be used to originate a new element. This would be |
| * the normal value. |
| */ |
| public static final short OriginateDirection = 6; |
| |
| /** |
| * A possible value for getDirection. This specifies |
| * that the data associated with this record should |
| * be joined to the fractured element. |
| */ |
| public static final short JoinFractureDirection = 7; |
| |
| |
| /** |
| * Constructor useful for markup when the markup will not |
| * be stored in the document. |
| * |
| * @param a the attributes for the element |
| * @param type the type of the element (StartTagType, EndTagType, |
| * ContentType) |
| */ |
| public ElementSpec(AttributeSet a, short type) { |
| this(a, type, null, 0, 0); |
| } |
| |
| /** |
| * Constructor for parsing inside the document when |
| * the data has already been added, but len information |
| * is needed. |
| * |
| * @param a the attributes for the element |
| * @param type the type of the element (StartTagType, EndTagType, |
| * ContentType) |
| * @param len the length >= 0 |
| */ |
| public ElementSpec(AttributeSet a, short type, int len) { |
| this(a, type, null, 0, len); |
| } |
| |
| /** |
| * Constructor for creating a spec externally for batch |
| * input of content and markup into the document. |
| * |
| * @param a the attributes for the element |
| * @param type the type of the element (StartTagType, EndTagType, |
| * ContentType) |
| * @param txt the text for the element |
| * @param offs the offset into the text >= 0 |
| * @param len the length of the text >= 0 |
| */ |
| public ElementSpec(AttributeSet a, short type, char[] txt, |
| int offs, int len) { |
| attr = a; |
| this.type = type; |
| this.data = txt; |
| this.offs = offs; |
| this.len = len; |
| this.direction = OriginateDirection; |
| } |
| |
| /** |
| * Sets the element type. |
| * |
| * @param type the type of the element (StartTagType, EndTagType, |
| * ContentType) |
| */ |
| public void setType(short type) { |
| this.type = type; |
| } |
| |
| /** |
| * Gets the element type. |
| * |
| * @return the type of the element (StartTagType, EndTagType, |
| * ContentType) |
| */ |
| public short getType() { |
| return type; |
| } |
| |
| /** |
| * Sets the direction. |
| * |
| * @param direction the direction (JoinPreviousDirection, |
| * JoinNextDirection) |
| */ |
| public void setDirection(short direction) { |
| this.direction = direction; |
| } |
| |
| /** |
| * Gets the direction. |
| * |
| * @return the direction (JoinPreviousDirection, JoinNextDirection) |
| */ |
| public short getDirection() { |
| return direction; |
| } |
| |
| /** |
| * Gets the element attributes. |
| * |
| * @return the attribute set |
| */ |
| public AttributeSet getAttributes() { |
| return attr; |
| } |
| |
| /** |
| * Gets the array of characters. |
| * |
| * @return the array |
| */ |
| public char[] getArray() { |
| return data; |
| } |
| |
| |
| /** |
| * Gets the starting offset. |
| * |
| * @return the offset >= 0 |
| */ |
| public int getOffset() { |
| return offs; |
| } |
| |
| /** |
| * Gets the length. |
| * |
| * @return the length >= 0 |
| */ |
| public int getLength() { |
| return len; |
| } |
| |
| /** |
| * Converts the element to a string. |
| * |
| * @return the string |
| */ |
| public String toString() { |
| String tlbl = "??"; |
| String plbl = "??"; |
| switch(type) { |
| case StartTagType: |
| tlbl = "StartTag"; |
| break; |
| case ContentType: |
| tlbl = "Content"; |
| break; |
| case EndTagType: |
| tlbl = "EndTag"; |
| break; |
| } |
| switch(direction) { |
| case JoinPreviousDirection: |
| plbl = "JoinPrevious"; |
| break; |
| case JoinNextDirection: |
| plbl = "JoinNext"; |
| break; |
| case OriginateDirection: |
| plbl = "Originate"; |
| break; |
| case JoinFractureDirection: |
| plbl = "Fracture"; |
| break; |
| } |
| return tlbl + ":" + plbl + ":" + getLength(); |
| } |
| |
| private AttributeSet attr; |
| private int len; |
| private short type; |
| private short direction; |
| |
| private int offs; |
| private char[] data; |
| } |
| |
| /** |
| * Class to manage changes to the element |
| * hierarchy. |
| * <p> |
| * <strong>Warning:</strong> |
| * Serialized objects of this class will not be compatible with |
| * future Swing releases. The current serialization support is |
| * appropriate for short term storage or RMI between applications running |
| * the same version of Swing. As of 1.4, support for long term storage |
| * of all JavaBeans<sup><font size="-2">TM</font></sup> |
| * has been added to the <code>java.beans</code> package. |
| * Please see {@link java.beans.XMLEncoder}. |
| */ |
| public class ElementBuffer implements Serializable { |
| |
| /** |
| * Creates a new ElementBuffer. |
| * |
| * @param root the root element |
| * @since 1.4 |
| */ |
| public ElementBuffer(Element root) { |
| this.root = root; |
| changes = new Vector<ElemChanges>(); |
| path = new Stack<ElemChanges>(); |
| } |
| |
| /** |
| * Gets the root element. |
| * |
| * @return the root element |
| */ |
| public Element getRootElement() { |
| return root; |
| } |
| |
| /** |
| * Inserts new content. |
| * |
| * @param offset the starting offset >= 0 |
| * @param length the length >= 0 |
| * @param data the data to insert |
| * @param de the event capturing this edit |
| */ |
| public void insert(int offset, int length, ElementSpec[] data, |
| DefaultDocumentEvent de) { |
| if (length == 0) { |
| // Nothing was inserted, no structure change. |
| return; |
| } |
| insertOp = true; |
| beginEdits(offset, length); |
| insertUpdate(data); |
| endEdits(de); |
| |
| insertOp = false; |
| } |
| |
| void create(int length, ElementSpec[] data, DefaultDocumentEvent de) { |
| insertOp = true; |
| beginEdits(offset, length); |
| |
| // PENDING(prinz) this needs to be fixed to create a new |
| // root element as well, but requires changes to the |
| // DocumentEvent to inform the views that there is a new |
| // root element. |
| |
| // Recreate the ending fake element to have the correct offsets. |
| Element elem = root; |
| int index = elem.getElementIndex(0); |
| while (! elem.isLeaf()) { |
| Element child = elem.getElement(index); |
| push(elem, index); |
| elem = child; |
| index = elem.getElementIndex(0); |
| } |
| ElemChanges ec = path.peek(); |
| Element child = ec.parent.getElement(ec.index); |
| ec.added.addElement(createLeafElement(ec.parent, |
| child.getAttributes(), getLength(), |
| child.getEndOffset())); |
| ec.removed.addElement(child); |
| while (path.size() > 1) { |
| pop(); |
| } |
| |
| int n = data.length; |
| |
| // Reset the root elements attributes. |
| AttributeSet newAttrs = null; |
| if (n > 0 && data[0].getType() == ElementSpec.StartTagType) { |
| newAttrs = data[0].getAttributes(); |
| } |
| if (newAttrs == null) { |
| newAttrs = SimpleAttributeSet.EMPTY; |
| } |
| MutableAttributeSet attr = (MutableAttributeSet)root. |
| getAttributes(); |
| de.addEdit(new AttributeUndoableEdit(root, newAttrs, true)); |
| attr.removeAttributes(attr); |
| attr.addAttributes(newAttrs); |
| |
| // fold in the specified subtree |
| for (int i = 1; i < n; i++) { |
| insertElement(data[i]); |
| } |
| |
| // pop the remaining path |
| while (path.size() != 0) { |
| pop(); |
| } |
| |
| endEdits(de); |
| insertOp = false; |
| } |
| |
| /** |
| * Removes content. |
| * |
| * @param offset the starting offset >= 0 |
| * @param length the length >= 0 |
| * @param de the event capturing this edit |
| */ |
| public void remove(int offset, int length, DefaultDocumentEvent de) { |
| beginEdits(offset, length); |
| removeUpdate(); |
| endEdits(de); |
| } |
| |
| /** |
| * Changes content. |
| * |
| * @param offset the starting offset >= 0 |
| * @param length the length >= 0 |
| * @param de the event capturing this edit |
| */ |
| public void change(int offset, int length, DefaultDocumentEvent de) { |
| beginEdits(offset, length); |
| changeUpdate(); |
| endEdits(de); |
| } |
| |
| /** |
| * Inserts an update into the document. |
| * |
| * @param data the elements to insert |
| */ |
| protected void insertUpdate(ElementSpec[] data) { |
| // push the path |
| Element elem = root; |
| int index = elem.getElementIndex(offset); |
| while (! elem.isLeaf()) { |
| Element child = elem.getElement(index); |
| push(elem, (child.isLeaf() ? index : index+1)); |
| elem = child; |
| index = elem.getElementIndex(offset); |
| } |
| |
| // Build a copy of the original path. |
| insertPath = new ElemChanges[path.size()]; |
| path.copyInto(insertPath); |
| |
| // Haven't created the fracture yet. |
| createdFracture = false; |
| |
| // Insert the first content. |
| int i; |
| |
| recreateLeafs = false; |
| if(data[0].getType() == ElementSpec.ContentType) { |
| insertFirstContent(data); |
| pos += data[0].getLength(); |
| i = 1; |
| } |
| else { |
| fractureDeepestLeaf(data); |
| i = 0; |
| } |
| |
| // fold in the specified subtree |
| int n = data.length; |
| for (; i < n; i++) { |
| insertElement(data[i]); |
| } |
| |
| // Fracture, if we haven't yet. |
| if(!createdFracture) |
| fracture(-1); |
| |
| // pop the remaining path |
| while (path.size() != 0) { |
| pop(); |
| } |
| |
| // Offset the last index if necessary. |
| if(offsetLastIndex && offsetLastIndexOnReplace) { |
| insertPath[insertPath.length - 1].index++; |
| } |
| |
| // Make sure an edit is going to be created for each of the |
| // original path items that have a change. |
| for(int counter = insertPath.length - 1; counter >= 0; |
| counter--) { |
| ElemChanges change = insertPath[counter]; |
| if(change.parent == fracturedParent) |
| change.added.addElement(fracturedChild); |
| if((change.added.size() > 0 || |
| change.removed.size() > 0) && !changes.contains(change)) { |
| // PENDING(sky): Do I need to worry about order here? |
| changes.addElement(change); |
| } |
| } |
| |
| // An insert at 0 with an initial end implies some elements |
| // will have no children (the bottomost leaf would have length 0) |
| // this will find what element need to be removed and remove it. |
| if (offset == 0 && fracturedParent != null && |
| data[0].getType() == ElementSpec.EndTagType) { |
| int counter = 0; |
| while (counter < data.length && |
| data[counter].getType() == ElementSpec.EndTagType) { |
| counter++; |
| } |
| ElemChanges change = insertPath[insertPath.length - |
| counter - 1]; |
| change.removed.insertElementAt(change.parent.getElement |
| (--change.index), 0); |
| } |
| } |
| |
| /** |
| * Updates the element structure in response to a removal from the |
| * associated sequence in the document. Any elements consumed by the |
| * span of the removal are removed. |
| */ |
| protected void removeUpdate() { |
| removeElements(root, offset, offset + length); |
| } |
| |
| /** |
| * Updates the element structure in response to a change in the |
| * document. |
| */ |
| protected void changeUpdate() { |
| boolean didEnd = split(offset, length); |
| if (! didEnd) { |
| // need to do the other end |
| while (path.size() != 0) { |
| pop(); |
| } |
| split(offset + length, 0); |
| } |
| while (path.size() != 0) { |
| pop(); |
| } |
| } |
| |
| boolean split(int offs, int len) { |
| boolean splitEnd = false; |
| // push the path |
| Element e = root; |
| int index = e.getElementIndex(offs); |
| while (! e.isLeaf()) { |
| push(e, index); |
| e = e.getElement(index); |
| index = e.getElementIndex(offs); |
| } |
| |
| ElemChanges ec = path.peek(); |
| Element child = ec.parent.getElement(ec.index); |
| // make sure there is something to do... if the |
| // offset is already at a boundary then there is |
| // nothing to do. |
| if (child.getStartOffset() < offs && offs < child.getEndOffset()) { |
| // we need to split, now see if the other end is within |
| // the same parent. |
| int index0 = ec.index; |
| int index1 = index0; |
| if (((offs + len) < ec.parent.getEndOffset()) && (len != 0)) { |
| // it's a range split in the same parent |
| index1 = ec.parent.getElementIndex(offs+len); |
| if (index1 == index0) { |
| // it's a three-way split |
| ec.removed.addElement(child); |
| e = createLeafElement(ec.parent, child.getAttributes(), |
| child.getStartOffset(), offs); |
| ec.added.addElement(e); |
| e = createLeafElement(ec.parent, child.getAttributes(), |
| offs, offs + len); |
| ec.added.addElement(e); |
| e = createLeafElement(ec.parent, child.getAttributes(), |
| offs + len, child.getEndOffset()); |
| ec.added.addElement(e); |
| return true; |
| } else { |
| child = ec.parent.getElement(index1); |
| if ((offs + len) == child.getStartOffset()) { |
| // end is already on a boundary |
| index1 = index0; |
| } |
| } |
| splitEnd = true; |
| } |
| |
| // split the first location |
| pos = offs; |
| child = ec.parent.getElement(index0); |
| ec.removed.addElement(child); |
| e = createLeafElement(ec.parent, child.getAttributes(), |
| child.getStartOffset(), pos); |
| ec.added.addElement(e); |
| e = createLeafElement(ec.parent, child.getAttributes(), |
| pos, child.getEndOffset()); |
| ec.added.addElement(e); |
| |
| // pick up things in the middle |
| for (int i = index0 + 1; i < index1; i++) { |
| child = ec.parent.getElement(i); |
| ec.removed.addElement(child); |
| ec.added.addElement(child); |
| } |
| |
| if (index1 != index0) { |
| child = ec.parent.getElement(index1); |
| pos = offs + len; |
| ec.removed.addElement(child); |
| e = createLeafElement(ec.parent, child.getAttributes(), |
| child.getStartOffset(), pos); |
| ec.added.addElement(e); |
| e = createLeafElement(ec.parent, child.getAttributes(), |
| pos, child.getEndOffset()); |
| ec.added.addElement(e); |
| } |
| } |
| return splitEnd; |
| } |
| |
| /** |
| * Creates the UndoableEdit record for the edits made |
| * in the buffer. |
| */ |
| void endEdits(DefaultDocumentEvent de) { |
| int n = changes.size(); |
| for (int i = 0; i < n; i++) { |
| ElemChanges ec = changes.elementAt(i); |
| Element[] removed = new Element[ec.removed.size()]; |
| ec.removed.copyInto(removed); |
| Element[] added = new Element[ec.added.size()]; |
| ec.added.copyInto(added); |
| int index = ec.index; |
| ((BranchElement) ec.parent).replace(index, removed.length, added); |
| ElementEdit ee = new ElementEdit(ec.parent, index, removed, added); |
| de.addEdit(ee); |
| } |
| |
| changes.removeAllElements(); |
| path.removeAllElements(); |
| |
| /* |
| for (int i = 0; i < n; i++) { |
| ElemChanges ec = (ElemChanges) changes.elementAt(i); |
| System.err.print("edited: " + ec.parent + " at: " + ec.index + |
| " removed " + ec.removed.size()); |
| if (ec.removed.size() > 0) { |
| int r0 = ((Element) ec.removed.firstElement()).getStartOffset(); |
| int r1 = ((Element) ec.removed.lastElement()).getEndOffset(); |
| System.err.print("[" + r0 + "," + r1 + "]"); |
| } |
| System.err.print(" added " + ec.added.size()); |
| if (ec.added.size() > 0) { |
| int p0 = ((Element) ec.added.firstElement()).getStartOffset(); |
| int p1 = ((Element) ec.added.lastElement()).getEndOffset(); |
| System.err.print("[" + p0 + "," + p1 + "]"); |
| } |
| System.err.println(""); |
| } |
| */ |
| } |
| |
| /** |
| * Initialize the buffer |
| */ |
| void beginEdits(int offset, int length) { |
| this.offset = offset; |
| this.length = length; |
| this.endOffset = offset + length; |
| pos = offset; |
| if (changes == null) { |
| changes = new Vector<ElemChanges>(); |
| } else { |
| changes.removeAllElements(); |
| } |
| if (path == null) { |
| path = new Stack<ElemChanges>(); |
| } else { |
| path.removeAllElements(); |
| } |
| fracturedParent = null; |
| fracturedChild = null; |
| offsetLastIndex = offsetLastIndexOnReplace = false; |
| } |
| |
| /** |
| * Pushes a new element onto the stack that represents |
| * the current path. |
| * @param record Whether or not the push should be |
| * recorded as an element change or not. |
| * @param isFracture true if pushing on an element that was created |
| * as the result of a fracture. |
| */ |
| void push(Element e, int index, boolean isFracture) { |
| ElemChanges ec = new ElemChanges(e, index, isFracture); |
| path.push(ec); |
| } |
| |
| void push(Element e, int index) { |
| push(e, index, false); |
| } |
| |
| void pop() { |
| ElemChanges ec = path.peek(); |
| path.pop(); |
| if ((ec.added.size() > 0) || (ec.removed.size() > 0)) { |
| changes.addElement(ec); |
| } else if (! path.isEmpty()) { |
| Element e = ec.parent; |
| if(e.getElementCount() == 0) { |
| // if we pushed a branch element that didn't get |
| // used, make sure its not marked as having been added. |
| ec = path.peek(); |
| ec.added.removeElement(e); |
| } |
| } |
| } |
| |
| /** |
| * move the current offset forward by n. |
| */ |
| void advance(int n) { |
| pos += n; |
| } |
| |
| void insertElement(ElementSpec es) { |
| ElemChanges ec = path.peek(); |
| switch(es.getType()) { |
| case ElementSpec.StartTagType: |
| switch(es.getDirection()) { |
| case ElementSpec.JoinNextDirection: |
| // Don't create a new element, use the existing one |
| // at the specified location. |
| Element parent = ec.parent.getElement(ec.index); |
| |
| if(parent.isLeaf()) { |
| // This happens if inserting into a leaf, followed |
| // by a join next where next sibling is not a leaf. |
| if((ec.index + 1) < ec.parent.getElementCount()) |
| parent = ec.parent.getElement(ec.index + 1); |
| else |
| throw new StateInvariantError("Join next to leaf"); |
| } |
| // Not really a fracture, but need to treat it like |
| // one so that content join next will work correctly. |
| // We can do this because there will never be a join |
| // next followed by a join fracture. |
| push(parent, 0, true); |
| break; |
| case ElementSpec.JoinFractureDirection: |
| if(!createdFracture) { |
| // Should always be something on the stack! |
| fracture(path.size() - 1); |
| } |
| // If parent isn't a fracture, fracture will be |
| // fracturedChild. |
| if(!ec.isFracture) { |
| push(fracturedChild, 0, true); |
| } |
| else |
| // Parent is a fracture, use 1st element. |
| push(ec.parent.getElement(0), 0, true); |
| break; |
| default: |
| Element belem = createBranchElement(ec.parent, |
| es.getAttributes()); |
| ec.added.addElement(belem); |
| push(belem, 0); |
| break; |
| } |
| break; |
| case ElementSpec.EndTagType: |
| pop(); |
| break; |
| case ElementSpec.ContentType: |
| int len = es.getLength(); |
| if (es.getDirection() != ElementSpec.JoinNextDirection) { |
| Element leaf = createLeafElement(ec.parent, es.getAttributes(), |
| pos, pos + len); |
| ec.added.addElement(leaf); |
| } |
| else { |
| // JoinNext on tail is only applicable if last element |
| // and attributes come from that of first element. |
| // With a little extra testing it would be possible |
| // to NOT due this again, as more than likely fracture() |
| // created this element. |
| if(!ec.isFracture) { |
| Element first = null; |
| if(insertPath != null) { |
| for(int counter = insertPath.length - 1; |
| counter >= 0; counter--) { |
| if(insertPath[counter] == ec) { |
| if(counter != (insertPath.length - 1)) |
| first = ec.parent.getElement(ec.index); |
| break; |
| } |
| } |
| } |
| if(first == null) |
| first = ec.parent.getElement(ec.index + 1); |
| Element leaf = createLeafElement(ec.parent, first. |
| getAttributes(), pos, first.getEndOffset()); |
| ec.added.addElement(leaf); |
| ec.removed.addElement(first); |
| } |
| else { |
| // Parent was fractured element. |
| Element first = ec.parent.getElement(0); |
| Element leaf = createLeafElement(ec.parent, first. |
| getAttributes(), pos, first.getEndOffset()); |
| ec.added.addElement(leaf); |
| ec.removed.addElement(first); |
| } |
| } |
| pos += len; |
| break; |
| } |
| } |
| |
| /** |
| * Remove the elements from <code>elem</code> in range |
| * <code>rmOffs0</code>, <code>rmOffs1</code>. This uses |
| * <code>canJoin</code> and <code>join</code> to handle joining |
| * the endpoints of the insertion. |
| * |
| * @return true if elem will no longer have any elements. |
| */ |
| boolean removeElements(Element elem, int rmOffs0, int rmOffs1) { |
| if (! elem.isLeaf()) { |
| // update path for changes |
| int index0 = elem.getElementIndex(rmOffs0); |
| int index1 = elem.getElementIndex(rmOffs1); |
| push(elem, index0); |
| ElemChanges ec = path.peek(); |
| |
| // if the range is contained by one element, |
| // we just forward the request |
| if (index0 == index1) { |
| Element child0 = elem.getElement(index0); |
| if(rmOffs0 <= child0.getStartOffset() && |
| rmOffs1 >= child0.getEndOffset()) { |
| // Element totally removed. |
| ec.removed.addElement(child0); |
| } |
| else if(removeElements(child0, rmOffs0, rmOffs1)) { |
| ec.removed.addElement(child0); |
| } |
| } else { |
| // the removal range spans elements. If we can join |
| // the two endpoints, do it. Otherwise we remove the |
| // interior and forward to the endpoints. |
| Element child0 = elem.getElement(index0); |
| Element child1 = elem.getElement(index1); |
| boolean containsOffs1 = (rmOffs1 < elem.getEndOffset()); |
| if (containsOffs1 && canJoin(child0, child1)) { |
| // remove and join |
| for (int i = index0; i <= index1; i++) { |
| ec.removed.addElement(elem.getElement(i)); |
| } |
| Element e = join(elem, child0, child1, rmOffs0, rmOffs1); |
| ec.added.addElement(e); |
| } else { |
| // remove interior and forward |
| int rmIndex0 = index0 + 1; |
| int rmIndex1 = index1 - 1; |
| if (child0.getStartOffset() == rmOffs0 || |
| (index0 == 0 && |
| child0.getStartOffset() > rmOffs0 && |
| child0.getEndOffset() <= rmOffs1)) { |
| // start element completely consumed |
| child0 = null; |
| rmIndex0 = index0; |
| } |
| if (!containsOffs1) { |
| child1 = null; |
| rmIndex1++; |
| } |
| else if (child1.getStartOffset() == rmOffs1) { |
| // end element not touched |
| child1 = null; |
| } |
| if (rmIndex0 <= rmIndex1) { |
| ec.index = rmIndex0; |
| } |
| for (int i = rmIndex0; i <= rmIndex1; i++) { |
| ec.removed.addElement(elem.getElement(i)); |
| } |
| if (child0 != null) { |
| if(removeElements(child0, rmOffs0, rmOffs1)) { |
| ec.removed.insertElementAt(child0, 0); |
| ec.index = index0; |
| } |
| } |
| if (child1 != null) { |
| if(removeElements(child1, rmOffs0, rmOffs1)) { |
| ec.removed.addElement(child1); |
| } |
| } |
| } |
| } |
| |
| // publish changes |
| pop(); |
| |
| // Return true if we no longer have any children. |
| if(elem.getElementCount() == (ec.removed.size() - |
| ec.added.size())) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Can the two given elements be coelesced together |
| * into one element? |
| */ |
| boolean canJoin(Element e0, Element e1) { |
| if ((e0 == null) || (e1 == null)) { |
| return false; |
| } |
| // Don't join a leaf to a branch. |
| boolean leaf0 = e0.isLeaf(); |
| boolean leaf1 = e1.isLeaf(); |
| if(leaf0 != leaf1) { |
| return false; |
| } |
| if (leaf0) { |
| // Only join leaves if the attributes match, otherwise |
| // style information will be lost. |
| return e0.getAttributes().isEqual(e1.getAttributes()); |
| } |
| // Only join non-leafs if the names are equal. This may result |
| // in loss of style information, but this is typically acceptable |
| // for non-leafs. |
| String name0 = e0.getName(); |
| String name1 = e1.getName(); |
| if (name0 != null) { |
| return name0.equals(name1); |
| } |
| if (name1 != null) { |
| return name1.equals(name0); |
| } |
| // Both names null, treat as equal. |
| return true; |
| } |
| |
| /** |
| * Joins the two elements carving out a hole for the |
| * given removed range. |
| */ |
| Element join(Element p, Element left, Element right, int rmOffs0, int rmOffs1) { |
| if (left.isLeaf() && right.isLeaf()) { |
| return createLeafElement(p, left.getAttributes(), left.getStartOffset(), |
| right.getEndOffset()); |
| } else if ((!left.isLeaf()) && (!right.isLeaf())) { |
| // join two branch elements. This copies the children before |
| // the removal range on the left element, and after the removal |
| // range on the right element. The two elements on the edge |
| // are joined if possible and needed. |
| Element to = createBranchElement(p, left.getAttributes()); |
| int ljIndex = left.getElementIndex(rmOffs0); |
| int rjIndex = right.getElementIndex(rmOffs1); |
| Element lj = left.getElement(ljIndex); |
| if (lj.getStartOffset() >= rmOffs0) { |
| lj = null; |
| } |
| Element rj = right.getElement(rjIndex); |
| if (rj.getStartOffset() == rmOffs1) { |
| rj = null; |
| } |
| Vector<Element> children = new Vector<Element>(); |
| |
| // transfer the left |
| for (int i = 0; i < ljIndex; i++) { |
| children.addElement(clone(to, left.getElement(i))); |
| } |
| |
| // transfer the join/middle |
| if (canJoin(lj, rj)) { |
| Element e = join(to, lj, rj, rmOffs0, rmOffs1); |
| children.addElement(e); |
| } else { |
| if (lj != null) { |
| children.addElement(cloneAsNecessary(to, lj, rmOffs0, rmOffs1)); |
| } |
| if (rj != null) { |
| children.addElement(cloneAsNecessary(to, rj, rmOffs0, rmOffs1)); |
| } |
| } |
| |
| // transfer the right |
| int n = right.getElementCount(); |
| for (int i = (rj == null) ? rjIndex : rjIndex + 1; i < n; i++) { |
| children.addElement(clone(to, right.getElement(i))); |
| } |
| |
| // install the children |
| Element[] c = new Element[children.size()]; |
| children.copyInto(c); |
| ((BranchElement)to).replace(0, 0, c); |
| return to; |
| } else { |
| throw new StateInvariantError( |
| "No support to join leaf element with non-leaf element"); |
| } |
| } |
| |
| /** |
| * Creates a copy of this element, with a different |
| * parent. |
| * |
| * @param parent the parent element |
| * @param clonee the element to be cloned |
| * @return the copy |
| */ |
| public Element clone(Element parent, Element clonee) { |
| if (clonee.isLeaf()) { |
| return createLeafElement(parent, clonee.getAttributes(), |
| clonee.getStartOffset(), |
| clonee.getEndOffset()); |
| } |
| Element e = createBranchElement(parent, clonee.getAttributes()); |
| int n = clonee.getElementCount(); |
| Element[] children = new Element[n]; |
| for (int i = 0; i < n; i++) { |
| children[i] = clone(e, clonee.getElement(i)); |
| } |
| ((BranchElement)e).replace(0, 0, children); |
| return e; |
| } |
| |
| /** |
| * Creates a copy of this element, with a different |
| * parent. Children of this element included in the |
| * removal range will be discarded. |
| */ |
| Element cloneAsNecessary(Element parent, Element clonee, int rmOffs0, int rmOffs1) { |
| if (clonee.isLeaf()) { |
| return createLeafElement(parent, clonee.getAttributes(), |
| clonee.getStartOffset(), |
| clonee.getEndOffset()); |
| } |
| Element e = createBranchElement(parent, clonee.getAttributes()); |
| int n = clonee.getElementCount(); |
| ArrayList<Element> childrenList = new ArrayList<Element>(n); |
| for (int i = 0; i < n; i++) { |
| Element elem = clonee.getElement(i); |
| if (elem.getStartOffset() < rmOffs0 || elem.getEndOffset() > rmOffs1) { |
| childrenList.add(cloneAsNecessary(e, elem, rmOffs0, rmOffs1)); |
| } |
| } |
| Element[] children = new Element[childrenList.size()]; |
| children = childrenList.toArray(children); |
| ((BranchElement)e).replace(0, 0, children); |
| return e; |
| } |
| |
| /** |
| * Determines if a fracture needs to be performed. A fracture |
| * can be thought of as moving the right part of a tree to a |
| * new location, where the right part is determined by what has |
| * been inserted. <code>depth</code> is used to indicate a |
| * JoinToFracture is needed to an element at a depth |
| * of <code>depth</code>. Where the root is 0, 1 is the children |
| * of the root... |
| * <p>This will invoke <code>fractureFrom</code> if it is determined |
| * a fracture needs to happen. |
| */ |
| void fracture(int depth) { |
| int cLength = insertPath.length; |
| int lastIndex = -1; |
| boolean needRecreate = recreateLeafs; |
| ElemChanges lastChange = insertPath[cLength - 1]; |
| // Use childAltered to determine when a child has been altered, |
| // that is the point of insertion is less than the element count. |
| boolean childAltered = ((lastChange.index + 1) < |
| lastChange.parent.getElementCount()); |
| int deepestAlteredIndex = (needRecreate) ? cLength : -1; |
| int lastAlteredIndex = cLength - 1; |
| |
| createdFracture = true; |
| // Determine where to start recreating from. |
| // Start at - 2, as first one is indicated by recreateLeafs and |
| // childAltered. |
| for(int counter = cLength - 2; counter >= 0; counter--) { |
| ElemChanges change = insertPath[counter]; |
| if(change.added.size() > 0 || counter == depth) { |
| lastIndex = counter; |
| if(!needRecreate && childAltered) { |
| needRecreate = true; |
| if(deepestAlteredIndex == -1) |
| deepestAlteredIndex = lastAlteredIndex + 1; |
| } |
| } |
| if(!childAltered && change.index < |
| change.parent.getElementCount()) { |
| childAltered = true; |
| lastAlteredIndex = counter; |
| } |
| } |
| if(needRecreate) { |
| // Recreate all children to right of parent starting |
| // at lastIndex. |
| if(lastIndex == -1) |
| lastIndex = cLength - 1; |
| fractureFrom(insertPath, lastIndex, deepestAlteredIndex); |
| } |
| } |
| |
| /** |
| * Recreates the elements to the right of the insertion point. |
| * This starts at <code>startIndex</code> in <code>changed</code>, |
| * and calls duplicate to duplicate existing elements. |
| * This will also duplicate the elements along the insertion |
| * point, until a depth of <code>endFractureIndex</code> is |
| * reached, at which point only the elements to the right of |
| * the insertion point are duplicated. |
| */ |
| void fractureFrom(ElemChanges[] changed, int startIndex, |
| int endFractureIndex) { |
| // Recreate the element representing the inserted index. |
| ElemChanges change = changed[startIndex]; |
| Element child; |
| Element newChild; |
| int changeLength = changed.length; |
| |
| if((startIndex + 1) == changeLength) |
| child = change.parent.getElement(change.index); |
| else |
| child = change.parent.getElement(change.index - 1); |
| if(child.isLeaf()) { |
| newChild = createLeafElement(change.parent, |
| child.getAttributes(), Math.max(endOffset, |
| child.getStartOffset()), child.getEndOffset()); |
| } |
| else { |
| newChild = createBranchElement(change.parent, |
| child.getAttributes()); |
| } |
| fracturedParent = change.parent; |
| fracturedChild = newChild; |
| |
| // Recreate all the elements to the right of the |
| // insertion point. |
| Element parent = newChild; |
| |
| while(++startIndex < endFractureIndex) { |
| boolean isEnd = ((startIndex + 1) == endFractureIndex); |
| boolean isEndLeaf = ((startIndex + 1) == changeLength); |
| |
| // Create the newChild, a duplicate of the elment at |
| // index. This isn't done if isEnd and offsetLastIndex are true |
| // indicating a join previous was done. |
| change = changed[startIndex]; |
| |
| // Determine the child to duplicate, won't have to duplicate |
| // if at end of fracture, or offseting index. |
| if(isEnd) { |
| if(offsetLastIndex || !isEndLeaf) |
| child = null; |
| else |
| child = change.parent.getElement(change.index); |
| } |
| else { |
| child = change.parent.getElement(change.index - 1); |
| } |
| // Duplicate it. |
| if(child != null) { |
| if(child.isLeaf()) { |
| newChild = createLeafElement(parent, |
| child.getAttributes(), Math.max(endOffset, |
| child.getStartOffset()), child.getEndOffset()); |
| } |
| else { |
| newChild = createBranchElement(parent, |
| child.getAttributes()); |
| } |
| } |
| else |
| newChild = null; |
| |
| // Recreate the remaining children (there may be none). |
| int kidsToMove = change.parent.getElementCount() - |
| change.index; |
| Element[] kids; |
| int moveStartIndex; |
| int kidStartIndex = 1; |
| |
| if(newChild == null) { |
| // Last part of fracture. |
| if(isEndLeaf) { |
| kidsToMove--; |
| moveStartIndex = change.index + 1; |
| } |
| else { |
| moveStartIndex = change.index; |
| } |
| kidStartIndex = 0; |
| kids = new Element[kidsToMove]; |
| } |
| else { |
| if(!isEnd) { |
| // Branch. |
| kidsToMove++; |
| moveStartIndex = change.index; |
| } |
| else { |
| // Last leaf, need to recreate part of it. |
| moveStartIndex = change.index + 1; |
| } |
| kids = new Element[kidsToMove]; |
| kids[0] = newChild; |
| } |
| |
| for(int counter = kidStartIndex; counter < kidsToMove; |
| counter++) { |
| Element toMove =change.parent.getElement(moveStartIndex++); |
| kids[counter] = recreateFracturedElement(parent, toMove); |
| change.removed.addElement(toMove); |
| } |
| ((BranchElement)parent).replace(0, 0, kids); |
| parent = newChild; |
| } |
| } |
| |
| /** |
| * Recreates <code>toDuplicate</code>. This is called when an |
| * element needs to be created as the result of an insertion. This |
| * will recurse and create all the children. This is similiar to |
| * <code>clone</code>, but deteremines the offsets differently. |
| */ |
| Element recreateFracturedElement(Element parent, Element toDuplicate) { |
| if(toDuplicate.isLeaf()) { |
| return createLeafElement(parent, toDuplicate.getAttributes(), |
| Math.max(toDuplicate.getStartOffset(), |
| endOffset), |
| toDuplicate.getEndOffset()); |
| } |
| // Not a leaf |
| Element newParent = createBranchElement(parent, toDuplicate. |
| getAttributes()); |
| int childCount = toDuplicate.getElementCount(); |
| Element[] newKids = new Element[childCount]; |
| for(int counter = 0; counter < childCount; counter++) { |
| newKids[counter] = recreateFracturedElement(newParent, |
| toDuplicate.getElement(counter)); |
| } |
| ((BranchElement)newParent).replace(0, 0, newKids); |
| return newParent; |
| } |
| |
| /** |
| * Splits the bottommost leaf in <code>path</code>. |
| * This is called from insert when the first element is NOT content. |
| */ |
| void fractureDeepestLeaf(ElementSpec[] specs) { |
| // Split the bottommost leaf. It will be recreated elsewhere. |
| ElemChanges ec = path.peek(); |
| Element child = ec.parent.getElement(ec.index); |
| // Inserts at offset 0 do not need to recreate child (it would |
| // have a length of 0!). |
| if (offset != 0) { |
| Element newChild = createLeafElement(ec.parent, |
| child.getAttributes(), |
| child.getStartOffset(), |
| offset); |
| |
| ec.added.addElement(newChild); |
| } |
| ec.removed.addElement(child); |
| if(child.getEndOffset() != endOffset) |
| recreateLeafs = true; |
| else |
| offsetLastIndex = true; |
| } |
| |
| /** |
| * Inserts the first content. This needs to be separate to handle |
| * joining. |
| */ |
| void insertFirstContent(ElementSpec[] specs) { |
| ElementSpec firstSpec = specs[0]; |
| ElemChanges ec = path.peek(); |
| Element child = ec.parent.getElement(ec.index); |
| int firstEndOffset = offset + firstSpec.getLength(); |
| boolean isOnlyContent = (specs.length == 1); |
| |
| switch(firstSpec.getDirection()) { |
| case ElementSpec.JoinPreviousDirection: |
| if(child.getEndOffset() != firstEndOffset && |
| !isOnlyContent) { |
| // Create the left split part containing new content. |
| Element newE = createLeafElement(ec.parent, |
| child.getAttributes(), child.getStartOffset(), |
| firstEndOffset); |
| ec.added.addElement(newE); |
| ec.removed.addElement(child); |
| // Remainder will be created later. |
| if(child.getEndOffset() != endOffset) |
| recreateLeafs = true; |
| else |
| offsetLastIndex = true; |
| } |
| else { |
| offsetLastIndex = true; |
| offsetLastIndexOnReplace = true; |
| } |
| // else Inserted at end, and is total length. |
| // Update index incase something added/removed. |
| break; |
| case ElementSpec.JoinNextDirection: |
| if(offset != 0) { |
| // Recreate the first element, its offset will have |
| // changed. |
| Element newE = createLeafElement(ec.parent, |
| child.getAttributes(), child.getStartOffset(), |
| offset); |
| ec.added.addElement(newE); |
| // Recreate the second, merge part. We do no checking |
| // to see if JoinNextDirection is valid here! |
| Element nextChild = ec.parent.getElement(ec.index + 1); |
| if(isOnlyContent) |
| newE = createLeafElement(ec.parent, nextChild. |
| getAttributes(), offset, nextChild.getEndOffset()); |
| else |
| newE = createLeafElement(ec.parent, nextChild. |
| getAttributes(), offset, firstEndOffset); |
| ec.added.addElement(newE); |
| ec.removed.addElement(child); |
| ec.removed.addElement(nextChild); |
| } |
| // else nothin to do. |
| // PENDING: if !isOnlyContent could raise here! |
| break; |
| default: |
| // Inserted into middle, need to recreate split left |
| // new content, and split right. |
| if(child.getStartOffset() != offset) { |
| Element newE = createLeafElement(ec.parent, |
| child.getAttributes(), child.getStartOffset(), |
| offset); |
| ec.added.addElement(newE); |
| } |
| ec.removed.addElement(child); |
| // new content |
| Element newE = createLeafElement(ec.parent, |
| firstSpec.getAttributes(), |
| offset, firstEndOffset); |
| ec.added.addElement(newE); |
| if(child.getEndOffset() != endOffset) { |
| // Signals need to recreate right split later. |
| recreateLeafs = true; |
| } |
| else { |
| offsetLastIndex = true; |
| } |
| break; |
| } |
| } |
| |
| Element root; |
| transient int pos; // current position |
| transient int offset; |
| transient int length; |
| transient int endOffset; |
| transient Vector<ElemChanges> changes; |
| transient Stack<ElemChanges> path; |
| transient boolean insertOp; |
| |
| transient boolean recreateLeafs; // For insert. |
| |
| /** For insert, path to inserted elements. */ |
| transient ElemChanges[] insertPath; |
| /** Only for insert, set to true when the fracture has been created. */ |
| transient boolean createdFracture; |
| /** Parent that contains the fractured child. */ |
| transient Element fracturedParent; |
| /** Fractured child. */ |
| transient Element fracturedChild; |
| /** Used to indicate when fracturing that the last leaf should be |
| * skipped. */ |
| transient boolean offsetLastIndex; |
| /** Used to indicate that the parent of the deepest leaf should |
| * offset the index by 1 when adding/removing elements in an |
| * insert. */ |
| transient boolean offsetLastIndexOnReplace; |
| |
| /* |
| * Internal record used to hold element change specifications |
| */ |
| class ElemChanges { |
| |
| ElemChanges(Element parent, int index, boolean isFracture) { |
| this.parent = parent; |
| this.index = index; |
| this.isFracture = isFracture; |
| added = new Vector<Element>(); |
| removed = new Vector<Element>(); |
| } |
| |
| public String toString() { |
| return "added: " + added + "\nremoved: " + removed + "\n"; |
| } |
| |
| Element parent; |
| int index; |
| Vector<Element> added; |
| Vector<Element> removed; |
| boolean isFracture; |
| } |
| |
| } |
| |
| /** |
| * An UndoableEdit used to remember AttributeSet changes to an |
| * Element. |
| */ |
| public static class AttributeUndoableEdit extends AbstractUndoableEdit { |
| public AttributeUndoableEdit(Element element, AttributeSet newAttributes, |
| boolean isReplacing) { |
| super(); |
| this.element = element; |
| this.newAttributes = newAttributes; |
| this.isReplacing = isReplacing; |
| // If not replacing, it may be more efficient to only copy the |
| // changed values... |
| copy = element.getAttributes().copyAttributes(); |
| } |
| |
| /** |
| * Redoes a change. |
| * |
| * @exception CannotRedoException if the change cannot be redone |
| */ |
| public void redo() throws CannotRedoException { |
| super.redo(); |
| MutableAttributeSet as = (MutableAttributeSet)element |
| .getAttributes(); |
| if(isReplacing) |
| as.removeAttributes(as); |
| as.addAttributes(newAttributes); |
| } |
| |
| /** |
| * Undoes a change. |
| * |
| * @exception CannotUndoException if the change cannot be undone |
| */ |
| public void undo() throws CannotUndoException { |
| super.undo(); |
| MutableAttributeSet as = (MutableAttributeSet)element.getAttributes(); |
| as.removeAttributes(as); |
| as.addAttributes(copy); |
| } |
| |
| // AttributeSet containing additional entries, must be non-mutable! |
| protected AttributeSet newAttributes; |
| // Copy of the AttributeSet the Element contained. |
| protected AttributeSet copy; |
| // true if all the attributes in the element were removed first. |
| protected boolean isReplacing; |
| // Efected Element. |
| protected Element element; |
| } |
| |
| /** |
| * UndoableEdit for changing the resolve parent of an Element. |
| */ |
| static class StyleChangeUndoableEdit extends AbstractUndoableEdit { |
| public StyleChangeUndoableEdit(AbstractElement element, |
| Style newStyle) { |
| super(); |
| this.element = element; |
| this.newStyle = newStyle; |
| oldStyle = element.getResolveParent(); |
| } |
| |
| /** |
| * Redoes a change. |
| * |
| * @exception CannotRedoException if the change cannot be redone |
| */ |
| public void redo() throws CannotRedoException { |
| super.redo(); |
| element.setResolveParent(newStyle); |
| } |
| |
| /** |
| * Undoes a change. |
| * |
| * @exception CannotUndoException if the change cannot be undone |
| */ |
| public void undo() throws CannotUndoException { |
| super.undo(); |
| element.setResolveParent(oldStyle); |
| } |
| |
| /** Element to change resolve parent of. */ |
| protected AbstractElement element; |
| /** New style. */ |
| protected Style newStyle; |
| /** Old style, before setting newStyle. */ |
| protected AttributeSet oldStyle; |
| } |
| |
| /** |
| * Base class for style change handlers with support for stale objects detection. |
| */ |
| abstract static class AbstractChangeHandler implements ChangeListener { |
| |
| /* This has an implicit reference to the handler object. */ |
| private class DocReference extends WeakReference<DefaultStyledDocument> { |
| |
| DocReference(DefaultStyledDocument d, ReferenceQueue<DefaultStyledDocument> q) { |
| super(d, q); |
| } |
| |
| /** |
| * Return a reference to the style change handler object. |
| */ |
| ChangeListener getListener() { |
| return AbstractChangeHandler.this; |
| } |
| } |
| |
| /** Class-specific reference queues. */ |
| private final static Map<Class, ReferenceQueue<DefaultStyledDocument>> queueMap |
| = new HashMap<Class, ReferenceQueue<DefaultStyledDocument>>(); |
| |
| /** A weak reference to the document object. */ |
| private DocReference doc; |
| |
| AbstractChangeHandler(DefaultStyledDocument d) { |
| Class c = getClass(); |
| ReferenceQueue<DefaultStyledDocument> q; |
| synchronized (queueMap) { |
| q = queueMap.get(c); |
| if (q == null) { |
| q = new ReferenceQueue<DefaultStyledDocument>(); |
| queueMap.put(c, q); |
| } |
| } |
| doc = new DocReference(d, q); |
| } |
| |
| /** |
| * Return a list of stale change listeners. |
| * |
| * A change listener becomes "stale" when its document is cleaned by GC. |
| */ |
| static List<ChangeListener> getStaleListeners(ChangeListener l) { |
| List<ChangeListener> staleListeners = new ArrayList<ChangeListener>(); |
| ReferenceQueue<DefaultStyledDocument> q = queueMap.get(l.getClass()); |
| |
| if (q != null) { |
| DocReference r; |
| synchronized (q) { |
| while ((r = (DocReference) q.poll()) != null) { |
| staleListeners.add(r.getListener()); |
| } |
| } |
| } |
| |
| return staleListeners; |
| } |
| |
| /** |
| * The ChangeListener wrapper which guards against dead documents. |
| */ |
| public void stateChanged(ChangeEvent e) { |
| DefaultStyledDocument d = doc.get(); |
| if (d != null) { |
| fireStateChanged(d, e); |
| } |
| } |
| |
| /** Run the actual class-specific stateChanged() method. */ |
| abstract void fireStateChanged(DefaultStyledDocument d, ChangeEvent e); |
| } |
| |
| /** |
| * Added to all the Styles. When instances of this receive a |
| * stateChanged method, styleChanged is invoked. |
| */ |
| static class StyleChangeHandler extends AbstractChangeHandler { |
| |
| StyleChangeHandler(DefaultStyledDocument d) { |
| super(d); |
| } |
| |
| void fireStateChanged(DefaultStyledDocument d, ChangeEvent e) { |
| Object source = e.getSource(); |
| if (source instanceof Style) { |
| d.styleChanged((Style) source); |
| } else { |
| d.styleChanged(null); |
| } |
| } |
| } |
| |
| |
| /** |
| * Added to the StyleContext. When the StyleContext changes, this invokes |
| * <code>updateStylesListeningTo</code>. |
| */ |
| static class StyleContextChangeHandler extends AbstractChangeHandler { |
| |
| StyleContextChangeHandler(DefaultStyledDocument d) { |
| super(d); |
| } |
| |
| void fireStateChanged(DefaultStyledDocument d, ChangeEvent e) { |
| d.updateStylesListeningTo(); |
| } |
| } |
| |
| |
| /** |
| * When run this creates a change event for the complete document |
| * and fires it. |
| */ |
| class ChangeUpdateRunnable implements Runnable { |
| boolean isPending = false; |
| |
| public void run() { |
| synchronized(this) { |
| isPending = false; |
| } |
| |
| try { |
| writeLock(); |
| DefaultDocumentEvent dde = new DefaultDocumentEvent(0, |
| getLength(), |
| DocumentEvent.EventType.CHANGE); |
| dde.end(); |
| fireChangedUpdate(dde); |
| } finally { |
| writeUnlock(); |
| } |
| } |
| } |
| } |