< 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&trade;
- * 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> &gt; <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 >