UndoableEdit 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
{
/**
* The serialization ID. Verified using the serialver
* 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;
/**
* The constant string “Undo”, 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
* “AbstractUndoableEdit.undoText”.
*/
protected static final String UndoName = "Undo";
/**
* The constant string “Redo”, 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
* “AbstractUndoableEdit.redoText”.
*/
protected static final String RedoName = "Redo";
/**
* Indicates whether this editing action has been executed. A value
* of true means that the action was performed, or that
* a redo operation was successful. A value of false
* means that the action has not yet performed, or that an undo
* operation was successful.
*/
private boolean hasBeenDone;
/**
* Indicates whether this editing action is still alive. The value
* is set to true by the constructor, and to
* false by the {@link #die()} method.
*/
private boolean alive;
/**
* Constructs a new AbstractUndoableEdit. The initial
* state is that the editing action is alive, and
* hasBeenDone is true.
*/
public AbstractUndoableEdit()
{
// The API specification is not clear, but Mauve test code has
// determined that hasBeenDone is initially set to true.
alive = hasBeenDone = true;
}
/**
* Undoes this editing action.
*
* @throws CannotUndoException if {@link #canUndo()} returns
* false, for example because this action has already
* been undone.
*
* @see #canUndo()
* @see #redo()
*/
public void undo()
throws CannotUndoException
{
if (!canUndo())
throw new CannotUndoException();
hasBeenDone = false;
}
/**
* Determines whether it would be possible to undo this editing
* action.
*
* @return true to indicate that this action can be
* undone, false otherwise.
*
* @see #undo()
* @see #canRedo()
*/
public boolean canUndo()
{
return alive && hasBeenDone;
}
/**
* Redoes this editing action.
*
* @throws CannotRedoException if {@link #canRedo()} returns
* false, for example because this action has not
* yet been undone.
*
* @see #canRedo()
* @see #undo()
*/
public void redo()
throws CannotRedoException
{
if (!canRedo())
throw new CannotRedoException();
hasBeenDone = true;
}
/**
* Determines whether it would be possible to redo this editing
* action.
*
* @return true to indicate that this action can be
* redone, false otherwise.
*
* @see #redo()
* @see #canUndo()
*/
public boolean canRedo()
{
return alive && !hasBeenDone;
}
/**
* 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 void die()
{
alive = false;
}
/**
* Incorporates another editing action into this one, thus forming a
* combined action.
*
* The default implementation always returns false,
* indicating that the editing action could not be incorporated.
*
* @param edit the editing action to be incorporated.
*/
public boolean addEdit(UndoableEdit edit)
{
return false;
}
/**
* Incorporates another editing action into this one, thus forming a
* combined action that replaces the argument action.
*
*
The default implementation always returns false,
* indicating that the argument action should not be replaced.
*
* @param edit the editing action to be replaced.
*/
public boolean replaceEdit(UndoableEdit edit)
{
return false;
}
/**
* 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.
*
*
The default implementation returns true.
*
* @return true to indicate that the action is
* significant enough for being separately undoable, or
* false otherwise.
*/
public boolean isSignificant()
{
return true;
}
/**
* Returns a human-readable, localized name that describes this
* editing action and can be displayed to the user.
*
*
The default implementation returns an empty string. */ public String getPresentationName() { return ""; } /** * Calculates a localized name for presenting the undo action to the * user. * *
The default implementation returns the concatenation of the * string “Undo” and the action name, which is * determined by calling {@link #getPresentationName()}. * *
The string “Undo” is retrieved from the {@link
* javax.swing.UIManager}, using the key
* “AbstractUndoableEdit.undoText”. This
* allows the text to be localized.
*/
public String getUndoPresentationName()
{
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;
}
/**
* Calculates a localized name for presenting the redo action to the
* user.
*
*
The default implementation returns the concatenation of the * string “Redo” and the action name, which is * determined by calling {@link #getPresentationName()}. * *
The string “Redo” is retrieved from the {@link
* javax.swing.UIManager}, using the key
* “AbstractUndoableEdit.redoText”. This
* allows the text to be localized.
*/
public String getRedoPresentationName()
{
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;
}
public String toString()
{
return super.toString()
+ " hasBeenDone: " + hasBeenDone
+ " alive: " + alive;
}
}