< prev index next >
src/java.desktop/share/classes/javax/swing/undo/UndoManager.java
Print this page
@@ -30,30 +30,30 @@
import java.util.*;
/**
* {@code UndoManager} manages a list of {@code UndoableEdits},
* providing a way to undo or redo the appropriate edits. There are
- * two ways to add edits to an <code>UndoManager</code>. Add the edit
- * directly using the <code>addEdit</code> method, or add the
- * <code>UndoManager</code> to a bean that supports
- * <code>UndoableEditListener</code>. The following examples creates
- * an <code>UndoManager</code> and adds it as an
- * <code>UndoableEditListener</code> to a <code>JTextField</code>:
+ * two ways to add edits to an {@code UndoManager}. Add the edit
+ * directly using the {@code addEdit} method, or add the
+ * {@code UndoManager} to a bean that supports
+ * {@code UndoableEditListener}. The following examples creates
+ * an {@code UndoManager} and adds it as an
+ * {@code UndoableEditListener} to a {@code JTextField}:
* <pre>
* UndoManager undoManager = new UndoManager();
* JTextField tf = ...;
* tf.getDocument().addUndoableEditListener(undoManager);
* </pre>
* <p>
- * <code>UndoManager</code> maintains an ordered list of edits and the
+ * {@code UndoManager} maintains an ordered list of edits and the
* index of the next edit in that list. The index of the next edit is
* either the size of the current list of edits, or if
- * <code>undo</code> has been invoked it corresponds to the index
+ * {@code undo} has been invoked it corresponds to the index
* of the last significant edit that was undone. When
- * <code>undo</code> is invoked all edits from the index of the next
+ * {@code undo} is invoked all edits from the index of the next
* edit to the last significant edit are undone, in reverse order.
- * For example, consider an <code>UndoManager</code> consisting of the
+ * For example, consider an {@code UndoManager} consisting of the
* following edits: <b>A</b> <i>b</i> <i>c</i> <b>D</b>. Edits with a
* upper-case letter in bold are significant, those in lower-case
* and italicized are insignificant.
* <p>
* <a name="figure1"></a>
@@ -62,12 +62,12 @@
* <img src="doc-files/UndoManager-1.gif" alt="">
* <tr><td align=center>Figure 1
* </table>
* <p>
* As shown in <a href="#figure1">figure 1</a>, if <b>D</b> was just added, the
- * index of the next edit will be 4. Invoking <code>undo</code>
- * results in invoking <code>undo</code> on <b>D</b> and setting the
+ * index of the next edit will be 4. Invoking {@code undo}
+ * results in invoking {@code undo} on <b>D</b> and setting the
* index of the next edit to 3 (edit <i>c</i>), as shown in the following
* figure.
* <p>
* <a name="figure2"></a>
* <table border=0 summary="">
@@ -75,34 +75,34 @@
* <img src="doc-files/UndoManager-2.gif" alt="">
* <tr><td align=center>Figure 2
* </table>
* <p>
* The last significant edit is <b>A</b>, so that invoking
- * <code>undo</code> again invokes <code>undo</code> on <i>c</i>,
+ * {@code undo} again invokes {@code undo} on <i>c</i>,
* <i>b</i>, and <b>A</b>, in that order, setting the index of the
* next edit to 0, as shown in the following figure.
* <p>
* <a name="figure3"></a>
* <table border=0 summary="">
* <tr><td>
* <img src="doc-files/UndoManager-3.gif" alt="">
* <tr><td align=center>Figure 3
* </table>
* <p>
- * Invoking <code>redo</code> results in invoking <code>redo</code> on
+ * Invoking {@code redo} results in invoking {@code redo} on
* all edits between the index of the next edit and the next
* significant edit (or the end of the list). Continuing with the previous
- * example if <code>redo</code> were invoked, <code>redo</code> would in
+ * example if {@code redo} were invoked, {@code redo} would in
* turn be invoked on <b>A</b>, <i>b</i> and <i>c</i>. In addition
* the index of the next edit is set to 3 (as shown in <a
* href="#figure2">figure 2</a>).
* <p>
- * Adding an edit to an <code>UndoManager</code> results in
+ * Adding an edit to an {@code UndoManager} results in
* removing all edits from the index of the next edit to the end of
* the list. Continuing with the previous example, if a new edit,
* <i>e</i>, is added the edit <b>D</b> is removed from the list
- * (after having <code>die</code> invoked on it). If <i>c</i> is not
+ * (after having {@code die} invoked on it). If <i>c</i> is not
* incorporated by the next edit
* (<code><i>c</i>.addEdit(<i>e</i>)</code> returns true), or replaced
* by it (<code><i>e</i>.replaceEdit(<i>c</i>)</code> returns true),
* the new edit is added after <i>c</i>, as shown in the following
* figure.
@@ -112,35 +112,35 @@
* <tr><td>
* <img src="doc-files/UndoManager-4.gif" alt="">
* <tr><td align=center>Figure 4
* </table>
* <p>
- * Once <code>end</code> has been invoked on an <code>UndoManager</code>
- * the superclass behavior is used for all <code>UndoableEdit</code>
- * methods. Refer to <code>CompoundEdit</code> for more details on its
+ * Once {@code end} has been invoked on an {@code UndoManager}
+ * the superclass behavior is used for all {@code UndoableEdit}
+ * methods. Refer to {@code CompoundEdit} for more details on its
* behavior.
* <p>
* Unlike the rest of Swing, this class is thread safe.
* <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™
- * has been added to the <code>java.beans</code> package.
+ * has been added to the {@code java.beans} package.
* Please see {@link java.beans.XMLEncoder}.
*
* @author Ray Ryan
*/
@SuppressWarnings("serial") // Same-version serialization only
public class UndoManager extends CompoundEdit implements UndoableEditListener {
int indexOfNextAdd;
int limit;
/**
- * Creates a new <code>UndoManager</code>.
+ * Creates a new {@code UndoManager}.
*/
public UndoManager() {
super();
indexOfNextAdd = 0;
limit = 100;
@@ -159,11 +159,11 @@
public synchronized int getLimit() {
return limit;
}
/**
- * Empties the undo manager sending each edit a <code>die</code> message
+ * Empties the undo manager sending each edit a {@code die} message
* in the process.
*
* @see AbstractUndoableEdit#die
*/
public synchronized void discardAllEdits() {
@@ -225,13 +225,13 @@
}
/**
* Removes edits in the specified range.
* All edits in the given range (inclusive, and in reverse order)
- * will have <code>die</code> invoked on them and are removed from
+ * will have {@code die} invoked on them and are removed from
* the list of edits. This has no effect if
- * <code>from</code> > <code>to</code>.
+ * {@code from > to}.
*
* @param from the minimum index to remove
* @param to the maximum index to remove
*/
protected void trimEdits(int from, int to) {
@@ -259,14 +259,14 @@
// System.out.println("new index " + indexOfNextAdd);
}
}
/**
- * Sets the maximum number of edits this <code>UndoManager</code>
+ * Sets the maximum number of edits this {@code UndoManager}
* holds. A value less than 0 indicates the number of edits is not
* limited. If edits need to be discarded to shrink the limit,
- * <code>die</code> will be invoked on them in the reverse
+ * {@code die} will be invoked on them in the reverse
* order they were added. The default is 100.
*
* @param l the new limit
* @throws RuntimeException if this {@code UndoManager} is not in progress
* ({@code end} has been invoked)
@@ -281,12 +281,12 @@
trimForLimit();
}
/**
- * Returns the next significant edit to be undone if <code>undo</code>
- * is invoked. This returns <code>null</code> if there are no edits
+ * Returns the next significant edit to be undone if {@code undo}
+ * is invoked. This returns {@code null} if there are no edits
* to be undone.
*
* @return the next significant edit to be undone
*/
protected UndoableEdit editToBeUndone() {
@@ -300,12 +300,12 @@
return null;
}
/**
- * Returns the next significant edit to be redone if <code>redo</code>
- * is invoked. This returns <code>null</code> if there are no edits
+ * Returns the next significant edit to be redone if {@code redo}
+ * is invoked. This returns {@code null} if there are no edits
* to be redone.
*
* @return the next significant edit to be redone
*/
protected UndoableEdit editToBeRedone() {
@@ -322,15 +322,15 @@
return null;
}
/**
* Undoes all changes from the index of the next edit to
- * <code>edit</code>, updating the index of the next edit appropriately.
+ * {@code edit}, updating the index of the next edit appropriately.
*
* @param edit the edit to be undo to
* @throws CannotUndoException if one of the edits throws
- * <code>CannotUndoException</code>
+ * {@code CannotUndoException}
*/
protected void undoTo(UndoableEdit edit) throws CannotUndoException {
boolean done = false;
while (!done) {
UndoableEdit next = edits.elementAt(--indexOfNextAdd);
@@ -339,15 +339,15 @@
}
}
/**
* Redoes all changes from the index of the next edit to
- * <code>edit</code>, updating the index of the next edit appropriately.
+ * {@code edit}, updating the index of the next edit appropriately.
*
* @param edit the edit to be redo to
* @throws CannotRedoException if one of the edits throws
- * <code>CannotRedoException</code>
+ * {@code CannotRedoException}
*/
protected void redoTo(UndoableEdit edit) throws CannotRedoException {
boolean done = false;
while (!done) {
UndoableEdit next = edits.elementAt(indexOfNextAdd++);
@@ -355,21 +355,21 @@
done = next == edit;
}
}
/**
- * Convenience method that invokes one of <code>undo</code> or
- * <code>redo</code>. If any edits have been undone (the index of
+ * Convenience method that invokes one of {@code undo} or
+ * {@code redo}. If any edits have been undone (the index of
* the next edit is less than the length of the edits list) this
- * invokes <code>redo</code>, otherwise it invokes <code>undo</code>.
+ * invokes {@code redo}, otherwise it invokes {@code undo}.
*
* @see #canUndoOrRedo
* @see #getUndoOrRedoPresentationName
* @throws CannotUndoException if one of the edits throws
- * <code>CannotUndoException</code>
+ * {@code CannotUndoException}
* @throws CannotRedoException if one of the edits throws
- * <code>CannotRedoException</code>
+ * {@code CannotRedoException}
*/
public synchronized void undoOrRedo() throws CannotRedoException,
CannotUndoException {
if (indexOfNextAdd == edits.size()) {
undo();
@@ -377,14 +377,14 @@
redo();
}
}
/**
- * Returns true if it is possible to invoke <code>undo</code> or
- * <code>redo</code>.
+ * Returns true if it is possible to invoke {@code undo} or
+ * {@code redo}.
*
- * @return true if invoking <code>canUndoOrRedo</code> is valid
+ * @return true if invoking {@code canUndoOrRedo} is valid
* @see #undoOrRedo
*/
public synchronized boolean canUndoOrRedo() {
if (indexOfNextAdd == edits.size()) {
return canUndo();
@@ -392,18 +392,18 @@
return canRedo();
}
}
/**
- * Undoes the appropriate edits. If <code>end</code> has been
+ * Undoes the appropriate edits. If {@code end} has been
* invoked this calls through to the superclass, otherwise
- * this invokes <code>undo</code> on all edits between the
+ * this invokes {@code undo} on all edits between the
* index of the next edit and the last significant edit, updating
* the index of the next edit appropriately.
*
* @throws CannotUndoException if one of the edits throws
- * <code>CannotUndoException</code> or there are no edits
+ * {@code CannotUndoException} or there are no edits
* to be undone
* @see CompoundEdit#end
* @see #canUndo
* @see #editToBeUndone
*/
@@ -418,14 +418,14 @@
super.undo();
}
}
/**
- * Returns true if edits may be undone. If <code>end</code> has
+ * Returns true if edits may be undone. If {@code end} has
* been invoked, this returns the value from super. Otherwise
* this returns true if there are any edits to be undone
- * (<code>editToBeUndone</code> returns non-<code>null</code>).
+ * ({@code editToBeUndone} returns non-{@code null}).
*
* @return true if there are edits to be undone
* @see CompoundEdit#canUndo
* @see #editToBeUndone
*/
@@ -437,18 +437,18 @@
return super.canUndo();
}
}
/**
- * Redoes the appropriate edits. If <code>end</code> has been
+ * Redoes the appropriate edits. If {@code end} has been
* invoked this calls through to the superclass. Otherwise
- * this invokes <code>redo</code> on all edits between the
+ * this invokes {@code redo} on all edits between the
* index of the next edit and the next significant edit, updating
* the index of the next edit appropriately.
*
* @throws CannotRedoException if one of the edits throws
- * <code>CannotRedoException</code> or there are no edits
+ * {@code CannotRedoException} or there are no edits
* to be redone
* @see CompoundEdit#end
* @see #canRedo
* @see #editToBeRedone
*/
@@ -463,14 +463,14 @@
super.redo();
}
}
/**
- * Returns true if edits may be redone. If <code>end</code> has
+ * Returns true if edits may be redone. If {@code end} has
* been invoked, this returns the value from super. Otherwise,
* this returns true if there are any edits to be redone
- * (<code>editToBeRedone</code> returns non-<code>null</code>).
+ * ({@code editToBeRedone} returns non-{@code null}).
*
* @return true if there are edits to be redone
* @see CompoundEdit#canRedo
* @see #editToBeRedone
*/
@@ -482,19 +482,19 @@
return super.canRedo();
}
}
/**
- * Adds an <code>UndoableEdit</code> to this
- * <code>UndoManager</code>, if it's possible. This removes all
+ * Adds an {@code UndoableEdit} to this
+ * {@code UndoManager}, if it's possible. This removes all
* edits from the index of the next edit to the end of the edits
- * list. If <code>end</code> has been invoked the edit is not added
- * and <code>false</code> is returned. If <code>end</code> hasn't
- * been invoked this returns <code>true</code>.
+ * list. If {@code end} has been invoked the edit is not added
+ * and {@code false} is returned. If {@code end} hasn't
+ * been invoked this returns {@code true}.
*
* @param anEdit the edit to be added
- * @return true if <code>anEdit</code> can be incorporated into this
+ * @return true if {@code anEdit} can be incorporated into this
* edit
* @see CompoundEdit#end
* @see CompoundEdit#addEdit
*/
public synchronized boolean addEdit(UndoableEdit anEdit) {
@@ -521,12 +521,12 @@
return retVal;
}
/**
- * Turns this <code>UndoManager</code> into a normal
- * <code>CompoundEdit</code>. This removes all edits that have
+ * Turns this {@code UndoManager} into a normal
+ * {@code CompoundEdit}. This removes all edits that have
* been undone.
*
* @see CompoundEdit#end
*/
public synchronized void end() {
@@ -534,15 +534,15 @@
this.trimEdits(indexOfNextAdd, edits.size()-1);
}
/**
* Convenience method that returns either
- * <code>getUndoPresentationName</code> or
- * <code>getRedoPresentationName</code>. If the index of the next
+ * {@code getUndoPresentationName} or
+ * {@code getRedoPresentationName}. If the index of the next
* edit equals the size of the edits list,
- * <code>getUndoPresentationName</code> is returned, otherwise
- * <code>getRedoPresentationName</code> is returned.
+ * {@code getUndoPresentationName} is returned, otherwise
+ * {@code getRedoPresentationName} is returned.
*
* @return undo or redo name
*/
public synchronized String getUndoOrRedoPresentationName() {
if (indexOfNextAdd == edits.size()) {
@@ -552,15 +552,15 @@
}
}
/**
* Returns a description of the undoable form of this edit.
- * If <code>end</code> has been invoked this calls into super.
+ * If {@code end} has been invoked this calls into super.
* Otherwise if there are edits to be undone, this returns
* the value from the next significant edit that will be undone.
- * If there are no edits to be undone and <code>end</code> has not
- * been invoked this returns the value from the <code>UIManager</code>
+ * If there are no edits to be undone and {@code end} has not
+ * been invoked this returns the value from the {@code UIManager}
* property "AbstractUndoableEdit.undoText".
*
* @return a description of the undoable form of this edit
* @see #undo
* @see CompoundEdit#getUndoPresentationName
@@ -577,15 +577,15 @@
}
}
/**
* Returns a description of the redoable form of this edit.
- * If <code>end</code> has been invoked this calls into super.
+ * If {@code end} has been invoked this calls into super.
* Otherwise if there are edits to be redone, this returns
* the value from the next significant edit that will be redone.
- * If there are no edits to be redone and <code>end</code> has not
- * been invoked this returns the value from the <code>UIManager</code>
+ * If there are no edits to be redone and {@code end} has not
+ * been invoked this returns the value from the {@code UIManager}
* property "AbstractUndoableEdit.redoText".
*
* @return a description of the redoable form of this edit
* @see #redo
* @see CompoundEdit#getRedoPresentationName
@@ -601,15 +601,15 @@
return super.getRedoPresentationName();
}
}
/**
- * An <code>UndoableEditListener</code> method. This invokes
- * <code>addEdit</code> with <code>e.getEdit()</code>.
+ * An {@code UndoableEditListener} method. This invokes
+ * {@code addEdit} with {@code e.getEdit()}.
*
- * @param e the <code>UndoableEditEvent</code> the
- * <code>UndoableEditEvent</code> will be added from
+ * @param e the {@code UndoableEditEvent} the
+ * {@code UndoableEditEvent} will be added from
* @see #addEdit
*/
public void undoableEditHappened(UndoableEditEvent e) {
addEdit(e.getEdit());
}
< prev index next >