UndoableEdits.
*
* The use of a CompoundEdit is divided in two separate
* phases.
CompoundEdit is
* initialized. After a new instance of CompoundEdit has
* been created, {@link #addEdit(UndoableEdit)} is called for each
* element of the compound. To terminate the initialization phase,
* call {@link #end()}.CompoundEdit can be
* used, typically by invoking {@link #undo()} and
* {@link #redo()}.UndoableEdits being combined into a compound
* editing action.
*/
protected Vectortrue. The {@link #end()} method changes the flag to
* false.
*/
private boolean inProgress;
/**
* Constructs a new CompoundEdit.
*/
public CompoundEdit()
{
edits = new VectorCompoundEdit. The compound elements will receive the
* undo message in the reverse order of addition.
*
* @throws CannotUndoException if {@link #canUndo()} returns
* false. This can happen if {@link #end()} has not
* been called on this CompoundEdit, or if this edit
* has already been undone.
*
* @see #canUndo()
* @see #redo()
*/
public void undo()
throws CannotUndoException
{
// AbstractUndoableEdit.undo() will throw a CannotUndoException if
// canUndo returns false.
super.undo();
for (int i = edits.size() - 1; i >= 0; i--)
edits.elementAt(i).undo();
}
/**
* Redoes all edits that are part of of this
* CompoundEdit. The compound elements will receive the
* undo message in the same order as they were added.
*
* @throws CannotRedoException if {@link #canRedo()} returns
* false. This can happen if {@link #end()} has not
* been called on this CompoundEdit, or if this edit
* has already been redone.
*
* @see #canRedo()
* @see #undo()
*/
public void redo()
throws CannotRedoException
{
// AbstractUndoableEdit.redo() will throw a CannotRedoException if
// canRedo returns false.
super.redo();
for (int i = 0; i < edits.size(); i++)
edits.elementAt(i).redo();
}
/**
* Returns the the UndoableEdit that was last added to
* this compound.
*/
protected UndoableEdit lastEdit()
{
if (edits.size() == 0)
return null;
else
return edits.elementAt(edits.size() - 1);
}
/**
* Informs this edit action, and all compound edits, that they will
* no longer be used. Some actions might use this information to
* release resources such as open files. Called by {@link
* UndoManager} before this action is removed from the edit queue.
*
* The compound elements will receive the
* die message in the reverse order of addition.
*/
public void die()
{
for (int i = edits.size() - 1; i >= 0; i--)
edits.elementAt(i).die();
super.die();
}
/**
* Incorporates another editing action into this one, thus forming a
* combined edit.
*
*
If this edit’s {@link #end()} method has been called
* before, false is returned immediately. Otherwise,
* the {@linkplain #lastEdit() last added edit} is given the
* opportunity to {@linkplain UndoableEdit#addEdit(UndoableEdit)
* incorporate} edit. If this fails, edit
* is given the opportunity to {@linkplain
* UndoableEdit#replaceEdit(UndoableEdit) replace} the last added
* edit. If this fails as well, edit gets added as a
* new compound to {@link #edits}.
*
* @param edit the editing action being added.
*
* @return true if edit could somehow be
* incorporated; false if edit has not
* been incorporated because {@link #end()} was called before.
*/
public boolean addEdit(UndoableEdit edit)
{
UndoableEdit last;
// If end has been called before, do nothing.
if (!inProgress)
return false;
last = lastEdit();
// If edit is the very first edit, just add it to the list.
if (last == null)
{
edits.add(edit);
return true;
}
// Try to incorporate edit into last.
if (last.addEdit(edit))
return true;
// Try to replace last by edit.
if (edit.replaceEdit(last))
{
edits.set(edits.size() - 1, edit);
return true;
}
// If everything else has failed, add edit to the list of compound
// edits.
edits.add(edit);
return true;
}
/**
* Informs this CompoundEdit that its construction
* phase has been completed. After this method has been called,
* {@link #undo()} and {@link #redo()} may be called, {@link
* #isInProgress()} will return false, and all attempts
* to {@linkplain #addEdit(UndoableEdit) add further edits} will
* fail.
*/
public void end()
{
inProgress = false;
}
/**
* Determines whether it would be possible to undo this editing
* action. The result will be true if {@link #end()}
* has been called on this CompoundEdit, {@link #die()}
* has not yet been called, and the edit has not been undone
* already.
*
* @return true to indicate that this action can be
* undone; false otherwise.
*
* @see #undo()
* @see #canRedo()
*/
public boolean canUndo()
{
return !inProgress && super.canUndo();
}
/**
* Determines whether it would be possible to redo this editing
* action. The result will be true if {@link #end()}
* has been called on this CompoundEdit, {@link #die()}
* has not yet been called, and the edit has not been redone
* already.
*
* @return true to indicate that this action can be
* redone; false otherwise.
*
* @see #redo()
* @see #canUndo()
*/
public boolean canRedo()
{
return !inProgress && super.canRedo();
}
/**
* Determines whether the initial construction phase of this
* CompoundEdit is still in progress. During this
* phase, edits {@linkplain #addEdit(UndoableEdit) may be
* added}. After initialization has been terminated by calling
* {@link #end()}, {@link #undo()} and {@link #redo()} can be used.
*
* @return true if the initialization phase is still in
* progress; false if {@link #end()} has been called.
*
* @see #end()
*/
public boolean isInProgress()
{
return inProgress;
}
/**
* 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.
*
*
A CompoundEdit is significant if any of its
* elements are significant.
*/
public boolean isSignificant()
{
for (int i = edits.size() - 1; i >= 0; i--)
if (edits.elementAt(i).isSignificant())
return true;
return false;
}
/**
* Returns a human-readable, localized name that describes this
* editing action and can be displayed to the user.
*
*
The implementation delegates the call to the {@linkplain * #lastEdit() last added edit action}. If no edit has been added * yet, the inherited implementation will be invoked, which always * returns an empty string. */ public String getPresentationName() { UndoableEdit last; last = lastEdit(); if (last == null) return super.getPresentationName(); else return last.getPresentationName(); } /** * Calculates a localized message text for presenting the undo * action to the user. * *
The implementation delegates the call to the {@linkplain * #lastEdit() last added edit action}. If no edit has been added * yet, the {@linkplain * AbstractUndoableEdit#getUndoPresentationName() inherited * implementation} will be invoked. */ public String getUndoPresentationName() { UndoableEdit last; last = lastEdit(); if (last == null) return super.getUndoPresentationName(); else return last.getUndoPresentationName(); } /** * Calculates a localized message text for presenting the redo * action to the user. * *
The implementation delegates the call to the {@linkplain * #lastEdit() last added edit action}. If no edit has been added * yet, the {@linkplain * AbstractUndoableEdit#getRedoPresentationName() inherited * implementation} will be invoked. */ public String getRedoPresentationName() { UndoableEdit last; last = lastEdit(); if (last == null) return super.getRedoPresentationName(); else return last.getRedoPresentationName(); } /** * Calculates a string that may be useful for debugging. */ public String toString() { return super.toString() + " inProgress: " + inProgress + " edits: " + edits; } }