/* * 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.util.Vector;import java.io.Serializable;import javax.swing.undo.*;import javax.swing.SwingUtilities; /** * An implementation of the AbstractDocument.Content interface that is * a brute force implementation that is useful for relatively small * documents and/or debugging.  It manages the character content * as a simple character array.  It is also quite inefficient. * <p> * It is generally recommended that the gap buffer or piece table * implementations be used instead.  This buffer does not scale up * to large sizes. * <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 */public final class StringContent implements AbstractDocument.Content, Serializable {     /**     * Creates a new StringContent object.  Initial size defaults to 10.     */    public StringContent() {        this(10);    }     /**     * Creates a new StringContent object, with the initial     * size specified.  If the length is < 1, a size of 1 is used.     *     * @param initialLength the initial size     */    public StringContent(int initialLength) {        if (initialLength < 1) {            initialLength = 1;        }        data = new char[initialLength];        data[0] = '\n';        count = 1;    }     /**     * Returns the length of the content.     *     * @return the length >= 1     * @see AbstractDocument.Content#length     */    public int length() {        return count;    }     /**     * Inserts a string into the content.     *     * @param where the starting position >= 0 && < length()     * @param str the non-null string to insert     * @return an UndoableEdit object for undoing     * @exception BadLocationException if the specified position is invalid     * @see AbstractDocument.Content#insertString     */    public UndoableEdit insertString(int where, String str) throws BadLocationException {        if (where >= count || where < 0) {            throw new BadLocationException("Invalid location", count);        }        char[] chars = str.toCharArray();        replace(where, 0, chars, 0, chars.length);        if (marks != null) {            updateMarksForInsert(where, str.length());        }        return new InsertUndo(where, str.length());    }     /**     * Removes part of the content.  where + nitems must be < length().     *     * @param where the starting position >= 0     * @param nitems the number of characters to remove >= 0     * @return an UndoableEdit object for undoing     * @exception BadLocationException if the specified position is invalid     * @see AbstractDocument.Content#remove     */    public UndoableEdit remove(int where, int nitems) throws BadLocationException {        if (where + nitems >= count) {            throw new BadLocationException("Invalid range", count);        }        String removedString = getString(where, nitems);        UndoableEdit edit = new RemoveUndo(where, removedString);        replace(where, nitems, empty, 0, 0);        if (marks != null) {            updateMarksForRemove(where, nitems);        }        return edit;     }     /**     * Retrieves a portion of the content.  where + len must be <= length().     *     * @param where the starting position >= 0     * @param len the length to retrieve >= 0     * @return a string representing the content; may be empty     * @exception BadLocationException if the specified position is invalid     * @see AbstractDocument.Content#getString     */    public String getString(int where, int len) throws BadLocationException {        if (where + len > count) {            throw new BadLocationException("Invalid range", count);        }        return new String(data, where, len);    }     /**     * Retrieves a portion of the content.  where + len must be <= length()     *     * @param where the starting position >= 0     * @param len the number of characters to retrieve >= 0     * @param chars the Segment object to return the characters in     * @exception BadLocationException if the specified position is invalid     * @see AbstractDocument.Content#getChars     */    public void getChars(int where, int len, Segment chars) throws BadLocationException {        if (where + len > count) {            throw new BadLocationException("Invalid location", count);        }        chars.array = data;        chars.offset = where;        chars.count = len;    }     /**     * Creates a position within the content that will     * track change as the content is mutated.     *     * @param offset the offset to create a position for >= 0     * @return the position     * @exception BadLocationException if the specified position is invalid     */    public Position createPosition(int offset) throws BadLocationException {        // some small documents won't have any sticky positions        // at all, so the buffer is created lazily.        if (marks == null) {            marks = new Vector<PosRec>();        }        return new StickyPosition(offset);    }     // --- local methods ---------------------------------------     /**     * Replaces some of the characters in the array     * @param offset  offset into the array to start the replace     * @param length  number of characters to remove     * @param replArray replacement array     * @param replOffset offset into the replacement array     * @param replLength number of character to use from the     *   replacement array.     */    void replace(int offset, int length,                 char[] replArray, int replOffset, int replLength) {        int delta = replLength - length;        int src = offset + length;        int nmove = count - src;        int dest = src + delta;        if ((count + delta) >= data.length) {            // need to grow the array            int newLength = Math.max(2*data.length, count + delta);            char[] newData = new char[newLength];            System.arraycopy(data, 0, newData, 0, offset);            System.arraycopy(replArray, replOffset, newData, offset, replLength);            System.arraycopy(data, src, newData, dest, nmove);            data = newData;        } else {            // patch the existing array            System.arraycopy(data, src, data, dest, nmove);            System.arraycopy(replArray, replOffset, data, offset, replLength);        }        count = count + delta;    }     void resize(int ncount) {        char[] ndata = new char[ncount];        System.arraycopy(data, 0, ndata, 0, Math.min(ncount, count));        data = ndata;    }     synchronized void updateMarksForInsert(int offset, int length) {        if (offset == 0) {            // zero is a special case where we update only            // marks after it.            offset = 1;        }        int n = marks.size();        for (int i = 0; i < n; i++) {            PosRec mark = marks.elementAt(i);            if (mark.unused) {                // this record is no longer used, get rid of it                marks.removeElementAt(i);                i -= 1;                n -= 1;            } else if (mark.offset >= offset) {                mark.offset += length;            }        }    }     synchronized void updateMarksForRemove(int offset, int length) {        int n = marks.size();        for (int i = 0; i < n; i++) {            PosRec mark = marks.elementAt(i);            if (mark.unused) {                // this record is no longer used, get rid of it                marks.removeElementAt(i);                i -= 1;                n -= 1;            } else if (mark.offset >= (offset + length)) {                mark.offset -= length;            } else if (mark.offset >= offset) {                mark.offset = offset;            }        }    }     /**     * Returns a Vector containing instances of UndoPosRef for the     * Positions in the range     * <code>offset</code> to <code>offset</code> + <code>length</code>.     * If <code>v</code> is not null the matching Positions are placed in     * there. The vector with the resulting Positions are returned.     * <p>     * This is meant for internal usage, and is generally not of interest     * to subclasses.     *     * @param v the Vector to use, with a new one created on null     * @param offset the starting offset >= 0     * @param length the length >= 0     * @return the set of instances     */    protected Vector getPositionsInRange(Vector v, int offset,                                                      int length) {        int n = marks.size();        int end = offset + length;        Vector placeIn = (v == null) ? new Vector() : v;        for (int i = 0; i < n; i++) {            PosRec mark = marks.elementAt(i);            if (mark.unused) {                // this record is no longer used, get rid of it                marks.removeElementAt(i);                i -= 1;                n -= 1;            } else if(mark.offset >= offset && mark.offset <= end)                placeIn.addElement(new UndoPosRef(mark));        }        return placeIn;    }     /**     * Resets the location for all the UndoPosRef instances     * in <code>positions</code>.     * <p>     * This is meant for internal usage, and is generally not of interest     * to subclasses.     *     * @param positions the positions of the instances     */    protected void updateUndoPositions(Vector positions) {        for(int counter = positions.size() - 1; counter >= 0; counter--) {            UndoPosRef ref = (UndoPosRef)positions.elementAt(counter);            // Check if the Position is still valid.            if(ref.rec.unused) {                positions.removeElementAt(counter);            }            else                ref.resetLocation();        }    }     private static final char[] empty = new char[0];    private char[] data;    private int count;    transient Vector<PosRec> marks;     /**     * holds the data for a mark... separately from     * the real mark so that the real mark can be     * collected if there are no more references to     * it.... the update table holds only a reference     * to this grungy thing.     */    final class PosRec {         PosRec(int offset) {            this.offset = offset;        }         int offset;        boolean unused;    }     /**     * This really wants to be a weak reference but     * in 1.1 we don't have a 100% pure solution for     * this... so this class trys to hack a solution     * to causing the marks to be collected.     */    final class StickyPosition implements Position {         StickyPosition(int offset) {            rec = new PosRec(offset);            marks.addElement(rec);        }         public int getOffset() {            return rec.offset;        }         protected void finalize() throws Throwable {            // schedule the record to be removed later            // on another thread.            rec.unused = true;        }         public String toString() {            return Integer.toString(getOffset());        }         PosRec rec;    }     /**     * Used to hold a reference to a Position that is being reset as the     * result of removing from the content.     */    final class UndoPosRef {        UndoPosRef(PosRec rec) {            this.rec = rec;            this.undoLocation = rec.offset;        }         /**         * Resets the location of the Position to the offset when the         * receiver was instantiated.         */        protected void resetLocation() {            rec.offset = undoLocation;        }         /** Location to reset to when resetLocatino is invoked. */        protected int undoLocation;        /** Position to reset offset. */        protected PosRec rec;    }     /**     * UnoableEdit created for inserts.     */    class InsertUndo extends AbstractUndoableEdit {        protected InsertUndo(int offset, int length) {            super();            this.offset = offset;            this.length = length;        }         public void undo() throws CannotUndoException {            super.undo();            try {                synchronized(StringContent.this) {                    // Get the Positions in the range being removed.                    if(marks != null)                        posRefs = getPositionsInRange(null, offset, length);                    string = getString(offset, length);                    remove(offset, length);                }            } catch (BadLocationException bl) {              throw new CannotUndoException();            }        }         public void redo() throws CannotRedoException {            super.redo();            try {                synchronized(StringContent.this) {                    insertString(offset, string);                    string = null;                    // Update the Positions that were in the range removed.                    if(posRefs != null) {                        updateUndoPositions(posRefs);                        posRefs = null;                    }              }            } catch (BadLocationException bl) {              throw new CannotRedoException();            }        }         // Where the string goes.        protected int offset;        // Length of the string.        protected int length;        // The string that was inserted. To cut down on space needed this        // will only be valid after an undo.        protected String string;        // An array of instances of UndoPosRef for the Positions in the        // range that was removed, valid after undo.        protected Vector posRefs;    }      /**     * UndoableEdit created for removes.     */    class RemoveUndo extends AbstractUndoableEdit {        protected RemoveUndo(int offset, String string) {            super();            this.offset = offset;            this.string = string;            this.length = string.length();            if(marks != null)                posRefs = getPositionsInRange(null, offset, length);        }         public void undo() throws CannotUndoException {            super.undo();            try {                synchronized(StringContent.this) {                    insertString(offset, string);                    // Update the Positions that were in the range removed.                    if(posRefs != null) {                        updateUndoPositions(posRefs);                        posRefs = null;                    }                    string = null;                }            } catch (BadLocationException bl) {              throw new CannotUndoException();            }        }         public void redo() throws CannotRedoException {            super.redo();            try {                synchronized(StringContent.this) {                    string = getString(offset, length);                    // Get the Positions in the range being removed.                    if(marks != null)                        posRefs = getPositionsInRange(null, offset, length);                    remove(offset, length);                }            } catch (BadLocationException bl) {              throw new CannotRedoException();            }        }         // Where the string goes.        protected int offset;        // Length of the string.        protected int length;        // The string that was inserted. This will be null after an undo.        protected String string;        // An array of instances of UndoPosRef for the Positions in the        // range that was removed, valid before undo.        protected Vector posRefs;    }}