/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* 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.
*/
/**
* An implementation of the AbstractDocument.Content interface that is
* a brute force implementation that is useful for relatively small
* 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
*/
/**
* 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
*/
if (initialLength < 1) {
initialLength = 1;
}
data = new char[initialLength];
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
*/
}
}
}
/**
* 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
*/
}
}
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
*/
}
}
/**
* 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
*/
}
}
/**
* 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
*/
// some small documents won't have any sticky positions
// at all, so the buffer is created lazily.
}
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.
*/
// need to grow the array
} else {
// patch the existing array
}
}
}
if (offset == 0) {
// zero is a special case where we update only
// marks after it.
offset = 1;
}
for (int i = 0; i < n; i++) {
// this record is no longer used, get rid of it
marks.removeElementAt(i);
i -= 1;
n -= 1;
}
}
}
for (int i = 0; i < n; i++) {
// this record is no longer used, get rid of it
marks.removeElementAt(i);
i -= 1;
n -= 1;
}
}
}
/**
* 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
*/
int length) {
for (int i = 0; i < n; i++) {
// this record is no longer used, get rid of it
marks.removeElementAt(i);
i -= 1;
n -= 1;
}
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
*/
// Check if the Position is still valid.
}
else
ref.resetLocation();
}
}
private char[] data;
private int count;
/**
* 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 {
}
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.
*/
}
public int getOffset() {
}
// schedule the record to be removed later
// on another thread.
}
}
}
/**
* Used to hold a reference to a Position that is being reset as the
* result of removing from the content.
*/
final class UndoPosRef {
}
/**
* Resets the location of the Position to the offset when the
* receiver was instantiated.
*/
protected void resetLocation() {
}
/** Location to reset to when resetLocatino is invoked. */
protected int undoLocation;
/** Position to reset offset. */
}
/**
* UnoableEdit created for inserts.
*/
super();
}
super.undo();
try {
synchronized(StringContent.this) {
// Get the Positions in the range being removed.
}
} catch (BadLocationException bl) {
throw new CannotUndoException();
}
}
super.redo();
try {
synchronized(StringContent.this) {
// Update the Positions that were in the range removed.
}
}
} 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.
// An array of instances of UndoPosRef for the Positions in the
// range that was removed, valid after undo.
}
/**
* UndoableEdit created for removes.
*/
super();
}
super.undo();
try {
synchronized(StringContent.this) {
// Update the Positions that were in the range removed.
}
}
} catch (BadLocationException bl) {
throw new CannotUndoException();
}
}
super.redo();
try {
synchronized(StringContent.this) {
// Get the Positions in the range being removed.
}
} 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.
// An array of instances of UndoPosRef for the Positions in the
// range that was removed, valid before undo.
}
}