StateEdit.java (getPresentationName): Docfix.

2003-11-26  Sascha Brawer  <brawer@dandelis.ch>

	* javax/swing/undo/StateEdit.java (getPresentationName): Docfix.
	* javax/swing/undo/AbstractUndoableEdit.java (canUndo, canRedo,
	isSignificant): Likewise.

2003-11-26  Sascha Brawer  <brawer@dandelis.ch>

	* javax/swing/undo/CompoundEdit.java: Re-format, document.
	(inProgress): Set initial value to true.
	(undo, redo, die, canUndo, canRedo): Also call inherited
	implementation; simplify code structure.
	(getPresentationName, getUndoPresentationName,
	getRedoPresentationName): Make behavior dependent on lastEdit.
	(addEdit, isSignificant): Completely re-written.

2003-11-26  Sascha Brawer  <brawer@dandelis.ch>

	* javax/swing/undo/StateEdit.java: Re-format, document.
	(undo, redo): Also call inherited implementation.

2003-11-26  Sascha Brawer  <brawer@dandelis.ch>

	* javax/swing/undo/StateEditable.java: Re-format, document.

2003-11-26  Sascha Brawer  <brawer@dandelis.ch>

	* javax/swing/undo/AbstractUndoableEdit.java: Re-format, document.
	(AbstractUndoableEdit): Initialize hasBeenDone to true.
	(canUndo, canRedo): Simplify.
	(getUndoPresentationName, getRedoPresentationName): Support
	localized message; call getPresentationName() only once.

From-SVN: r73967

1 files changed, 214 insertions, 109 deletions

diff --git a/libjava/javax/swing/undo/AbstractUndoableEdit.java b/libjava/javax/swing/undo/AbstractUndoableEdit.java
index d845e43..e694c0a 100644
--- a/libjava/javax/swing/undo/AbstractUndoableEdit.java
+++ b/libjava/javax/swing/undo/AbstractUndoableEdit.java
@@ -1,4 +1,4 @@
-/* AbstractTableModel.java --
+/* AbstractUndoableEdit.java
    Copyright (C) 2002, 2003 Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
@@ -39,180 +39,285 @@ exception statement from your version. */
 package javax.swing.undo;
 
 import java.io.Serializable;
+import javax.swing.UIManager;
+
 
 /**
- * AbstractUndoableEdit
- * @author Andrew Selkirk
+ * A default implementation of <code>UndoableEdit</code> that can be
+ * used as a base for implementing editing operations.
+ *
+ * @author Andrew Selkirk (aselkirk@sympatico.ca)
+ * @author Sascha Brawer (brawer@dandelis.ch)
  */
-public class AbstractUndoableEdit implements UndoableEdit, Serializable
+public class AbstractUndoableEdit
+  implements UndoableEdit, Serializable
 {
+  /**
+   * The serialization ID.  Verified using the <code>serialver</code>
+   * tool of Apple/Sun JDK 1.3.1 on MacOS X 10.1.5, and Sun JDK
+   * 1.4.1_01 on GNU/Linux.
+   */
   static final long serialVersionUID = 580150227676302096L;
 
-  //-------------------------------------------------------------
-  // Constants --------------------------------------------------
-  //-------------------------------------------------------------
 
   /**
-   * String returned by getRedoPresentationName()
+   * The constant string &#x201c;Undo&#x201d;, which was returned by
+   * {@link #getUndoPresentationName()} on early versions of the
+   * platform. However, this field has become obsolete with version
+   * 1.3.1.  That method now retrieves a localized string from the
+   * {@link javax.swing.UIManager}, using the key
+   * <code>&#x201c;AbstractUndoableEdit.undoText&#x201d;</code>.
    */
-  protected static final String RedoName = "Redo";
+  protected static final String UndoName = "Undo";
+
 
   /**
-   * String returned by getUndoPresentationName()
+   * The constant string &#x201c;Redo&#x201d;, which was returned by
+   * {@link #getRedoPresentationName()} on early versions of the
+   * platform. However, this field has become obsolete with version
+   * 1.3.1.  That method now retrieves a localized string from the
+   * {@link javax.swing.UIManager}, using the key
+   * <code>&#x201c;AbstractUndoableEdit.redoText&#x201d;</code>.
    */
-  protected static final String UndoName = "Undo";
-
+  protected static final String RedoName = "Redo";
 
-  //-------------------------------------------------------------
-  // Variables --------------------------------------------------
-  //-------------------------------------------------------------
 
   /**
-   * TODO
+   * Indicates whether this editing action has been executed.  A value
+   * of <code>true</code> means that the action was performed, or that
+   * a redo operation was successful. A value of <code>false</code>
+   * means that the action has not yet performed, or that an undo
+   * operation was successful.
    */
-  private boolean hasBeenDone = false;
+  private boolean hasBeenDone;
+
 
   /**
-   * The edit is alive
+   * Indicates whether this editing action is still alive. The value
+   * is set to <code>true</code> by the constructor, and to
+   * <code>false</code> by the {@link #die()} method.
    */
-  private boolean alive = true;
+  private boolean alive;
 
 
-  //-------------------------------------------------------------
-  // Initialization ---------------------------------------------
-  //-------------------------------------------------------------
-
   /**
-   * Create new AbstractUndoableEdit
+   * Constructs a new <code>AbstractUndoableEdit</code>. The initial
+   * state is that the editing action is alive, and
+   * <code>hasBeenDone</code> is <code>true</code>.
    */
   public AbstractUndoableEdit()
   {
-  } // AbstractUndoableEdit()
-
+    // The API specification is not clear, but Mauve test code has
+    // determined that hasBeenDone is initially set to true.
+    alive = hasBeenDone = true;
+  }
 
-  //-------------------------------------------------------------
-  // Interface: UndoableEdit ------------------------------------
-  //-------------------------------------------------------------
 
   /**
-   * addEdit
-   * @param anEdit TODO
-   * @returns TODO
+   * Undoes this editing action.
+   *
+   * @throws CannotUndoException if {@link #canUndo()} returns
+   * <code>false</code>, for example because this action has already
+   * been undone.
+   *
+   * @see #canUndo()
+   * @see #redo()
    */
-  public boolean addEdit(UndoableEdit anEdit)
+  public void undo()
+    throws CannotUndoException
   {
-    return false;
-  } // addEdit()
-
+    if (!canUndo())
+      throw new CannotUndoException();
+    hasBeenDone = false;
+  }
+  
+  
   /**
-   * canRedo()
-   * @returns true if redoable, false otherwise
+   * Determines whether it would be possible to undo this editing
+   * action.
+   *
+   * @return <code>true</code> to indicate that this action can be
+   * undone, <code>false</code> otherwise.
+   *
+   * @see #undo()
+   * @see #canRedo()
    */
-  public boolean canRedo()
+  public boolean canUndo()
   {
-    if (alive == true && hasBeenDone == false)
-      return true;
-    return false;
-  } // canRedo()
-
+    return alive && hasBeenDone;
+  }
+  
+  
   /**
-   * canUndo()
-   * @returns true if undoable, false otherwise
+   * Redoes this editing action.
+   *
+   * @throws CannotRedoException if {@link #canRedo()} returns
+   * <code>false</code>, for example because this action has not
+   * yet been undone.
+   *
+   * @see #canRedo()
+   * @see #undo()
    */
-  public boolean canUndo()
+  public void redo()
+    throws CannotRedoException
   {
-    if (alive == true && hasBeenDone == true)
-      return true;
-    return false;
-  } // canUndo()
-
+    if (!canRedo())
+      throw new CannotRedoException();
+    hasBeenDone = true;
+  }
+  
+  
   /**
-   * die
+   * Determines whether it would be possible to redo this editing
+   * action.
+   *
+   * @return <code>true</code> to indicate that this action can be
+   * redone, <code>false</code> otherwise.
+   *
+   * @see #redo()
+   * @see #canUndo()
    */
-  public void die()
+  public boolean canRedo()
   {
-    alive = false;
-  } // die()
+    return alive && !hasBeenDone;
+  }
+
 
   /**
-   * getPresentation
-   * @returns TODO
+   * Informs this edit action that it will no longer be used. Some
+   * actions might use this information to release resources, for
+   * example open files.  Called by {@link UndoManager} before this
+   * action is removed from the edit queue.
    */
-  public String getPresentationName()
+  public void die()
   {
-    return "";
-  } // getPresentationName()
+    alive = false;
+  }
+
 
   /**
-   * getRedoPresentationName
-   * @returns TODO
+   * Incorporates another editing action into this one, thus forming a
+   * combined action.
+   *
+   * <p>The default implementation always returns <code>false</code>,
+   * indicating that the editing action could not be incorporated.
+   *
+   * @param edit the editing action to be incorporated.
    */
-  public String getRedoPresentationName()
+  public boolean addEdit(UndoableEdit edit)
   {
-    if (getPresentationName().equals(""))
-      return RedoName;
-    return RedoName + " " + getPresentationName();
-  } // getRedoPresentationName()
-
+    return false;
+  }
+  
+  
   /**
-   * getUndoPresentationName
-   * @returns TODO
+   * Incorporates another editing action into this one, thus forming a
+   * combined action that replaces the argument action.
+   *
+   * <p>The default implementation always returns <code>false</code>,
+   * indicating that the argument action should not be replaced.
+   *
+   * @param edit the editing action to be replaced.
    */
-  public String getUndoPresentationName()
+  public boolean replaceEdit(UndoableEdit edit)
   {
-    if (getPresentationName().equals(""))
-      return UndoName;
-    return UndoName + " " + getPresentationName();
-  } // getUndoPresentationName()
-
+    return false;
+  }
+  
+  
   /**
-   * isSignificant
-   * @returns true
+   * Determines whether this editing action is significant enough for
+   * being seperately undoable by the user. A typical significant
+   * action would be the resizing of an object. However, changing the
+   * selection in a text document would usually not be considered
+   * significant.
+   *
+   * <p>The default implementation returns <code>true</code>.
+   *
+   * @return <code>true</code> to indicate that the action is
+   * significant enough for being separately undoable, or
+   * <code>false</code> otherwise.
    */
   public boolean isSignificant()
   {
     return true;
-  } // isSignificant()
-
+  }
+  
+  
   /**
-   * redo
-   * @throws CannotRedoException TODO
+   * Returns a human-readable, localized name that describes this
+   * editing action and can be displayed to the user.
+   *
+   * <p>The default implementation returns an empty string.
    */
-  public void redo() throws CannotRedoException
+  public String getPresentationName()
   {
-    if (! canRedo())
-      throw new CannotRedoException();
-    hasBeenDone = true;
-  } // redo()
+    return "";
+  }
+
 
   /**
-   * replaceEdit
-   * @param anEdit TODO
-   * @returns TODO
+   * Calculates a localized name for presenting the undo action to the
+   * user.
+   *
+   * <p>The default implementation returns the concatenation of the
+   * string &#x201c;Undo&#x201d; and the action name, which is
+   * determined by calling {@link #getPresentationName()}.
+   *
+   * <p>The string &#x201c;Undo&#x201d; is retrieved from the {@link
+   * javax.swing.UIManager}, using the key
+   * <code>&#x201c;AbstractUndoableEdit.undoText&#x201d;</code>.  This
+   * allows the text to be localized.
    */
-  public boolean replaceEdit(UndoableEdit anEdit)
+  public String getUndoPresentationName()
   {
-    return false;
-  } // replaceEdit()
+    String msg, pres;
+
+    msg = UIManager.getString("AbstractUndoableEdit.undoText");
+    if (msg == null)
+      msg = UndoName;
+
+    pres = getPresentationName();
+    if ((pres == null) || (pres.length() == 0))
+      return msg;
+    else
+      return msg + ' ' + pres;
+  }
+
 
   /**
-   * String representation
-   * @returns String representation
+   * Calculates a localized name for presenting the redo action to the
+   * user.
+   *
+   * <p>The default implementation returns the concatenation of the
+   * string &#x201c;Redo&#x201d; and the action name, which is
+   * determined by calling {@link #getPresentationName()}.
+   *
+   * <p>The string &#x201c;Redo&#x201d; is retrieved from the {@link
+   * javax.swing.UIManager}, using the key
+   * <code>&#x201c;AbstractUndoableEdit.redoText&#x201d;</code>.  This
+   * allows the text to be localized.
    */
-  public String toString()
+  public String getRedoPresentationName()
   {
-    return (super.toString() + " hasBeenDone: " + hasBeenDone
-	    + " alive: " + alive);
+    String msg, pres;
+
+    msg = UIManager.getString("AbstractUndoableEdit.redoText");
+    if (msg == null)
+      msg = RedoName;
+
+    pres = getPresentationName();
+    if ((pres == null) || (pres.length() == 0))
+      return msg;
+    else
+      return msg + ' ' + pres;
   }
 
-  /**
-   * undo
-   * @throws CannotUndoException TODO
-   */
-  public void undo() throws CannotUndoException
+
+  public String toString()
   {
-    if (! canUndo())
-      throw new CannotUndoException();
-    hasBeenDone = false;
-  } // undo()
-} // AbstractUndoableEdit
+    return super.toString()
+      + " hasBeenDone: " + hasBeenDone
+      + " alive: " + alive;
+  }
+}