Class UndoManager

public UndoManager()

Constructs an UndoManager.

The limit of the freshly constructed UndoManager is 100.

public boolean addEdit(UndoableEdit edit)

Registers an undoable editing action with this UndoManager. If the capacity limit is reached, the oldest action will be discarded (and receives a die message. Equally, any actions that were undone (but not re-done) will be discarded, too.

Specified by:

addEdit in interface UndoableEdit

Overrides:

addEdit in interface CompoundEdit

Parameters:

edit - the editing action that is added to this UndoManager.

Returns:

true if edit could be incorporated; false if edit has not been incorporated because end() has already been called on this UndoManager.

public boolean canRedo()

Determines whether it would be possible to redo this editing action.

Specified by:

canRedo in interface UndoableEdit

Overrides:

canRedo in interface CompoundEdit

Returns:

true to indicate that this action can be redone; false otherwise.

See Also:

redo(), canUndo(), canUndoOrRedo()

public boolean canUndo()

Determines whether it would be possible to undo this editing action.

Specified by:

canUndo in interface UndoableEdit

Overrides:

canUndo in interface CompoundEdit

Returns:

true to indicate that this action can be undone; false otherwise.

See Also:

undo(), canRedo(), canUndoOrRedo()

public boolean canUndoOrRedo()

Determines whether it would be possible to either undo or redo this editing action.

This is useful for applications that do not present a separate undo and redo facility, but just have a single menu item for undoing and redoing the very last action. Such applications will use an UndoManager whose limit is 1.

Returns:

true to indicate that this action can be undone or redone; false if neither is possible at the current time.

public void discardAllEdits()

Discards all editing actions that are currently registered with this UndoManager. Each UndoableEdit will receive a die message.

protected UndoableEdit editToBeRedone()

Determines which significant edit would be redone if redo() was called.

Returns:

the significant edit that would be redone, or null if no significant edit would be affected by calling redo().

protected UndoableEdit editToBeUndone()

Determines which significant edit would be undone if undo() was called.

Returns:

the significant edit that would be undone, or null if no significant edit would be affected by calling undo().

public void end()

Puts this UndoManager into a state where it acts as a normal CompoundEdit. It is unlikely that an application would want to do this.

Overrides:

end in interface CompoundEdit

public int getLimit()

Returns how many edits this UndoManager can maximally hold.

See Also:

setLimit(int)

public String getRedoPresentationName()

Calculates a localized text for presenting the redo action to the user, for example in the form of a menu command.

Specified by:

getRedoPresentationName in interface UndoableEdit

Overrides:

getRedoPresentationName in interface CompoundEdit

public String getUndoOrRedoPresentationName()

Calculates a localized text for presenting the undo or redo action to the user, for example in the form of a menu command.

This is useful for applications that do not present a separate undo and redo facility, but just have a single menu item for undoing and redoing the very last action. Such applications will use an UndoManager whose limit is 1.

Returns:

the redo presentation name if the last action has already been undone, or the undo presentation name otherwise.

See Also:

getUndoPresentationName(), getRedoPresentationName()

public String getUndoPresentationName()

Calculates a localized text for presenting the undo action to the user, for example in the form of a menu command.

Specified by:

getUndoPresentationName in interface UndoableEdit

Overrides:

getUndoPresentationName in interface CompoundEdit

public void redo()
            throws CannotRedoException

Redoes one significant edit action. If insignificant actions have been posted in between, the insignificant ones will be redone first.

However, if end() has been called on this UndoManager, it will behave like a normal CompoundEdit. In this case, all actions will be redone in order of addition. Typical applications will never call end() on their UndoManager.

Specified by:

redo in interface UndoableEdit

Overrides:

redo in interface CompoundEdit

Throws:

CannotRedoException - if no action can be redone.

See Also:

canRedo(), redo(), undoOrRedo()

protected void redoTo(UndoableEdit edit)
            throws CannotRedoException

Redoes all editing actions in the same order as they were added to this UndoManager, up to the specified action.

Parameters:

edit - the last editing action to be redone.

public void setLimit(int limit)

Changes the maximal number of edits that this UndoManager can process. If there are currently more edits than the new limit allows, they will receive a die message in reverse order of addition.

Parameters:

limit - the new limit.

Throws:

IllegalStateException - if end() has already been called on this UndoManager.

public String toString()

Returns a string representation for this UndoManager. This may be useful for debugging purposes. For the text of menu items, please refer to getUndoPresentationName(), getRedoPresentationName(), and getUndoOrRedoPresentationName().

Overrides:

toString in interface CompoundEdit

protected void trimEdits(int from,
                         int to)

Discards a range of edits. All edits in the range [from .. to] will receive a die message before being removed from the edits array. If from is greater than to, nothing happens.

Parameters:

from - the lower bound of the range of edits to be discarded.

to - the upper bound of the range of edits to be discarded.

protected void trimForLimit()

Called by various internal methods in order to enforce the limit value.

public void undo()
            throws CannotUndoException

Undoes one significant edit action. If insignificant actions have been posted after the last signficant action, the insignificant ones will be undone first.

However, if end() has been called on this UndoManager, it will behave like a normal CompoundEdit. In this case, all actions will be undone in reverse order of addition. Typical applications will never call end() on their UndoManager.

Specified by:

undo in interface UndoableEdit

Overrides:

undo in interface CompoundEdit

Throws:

CannotUndoException - if no action can be undone.

See Also:

canUndo(), redo(), undoOrRedo()

public void undoOrRedo()
            throws CannotRedoException,
                   CannotUndoException

Undoes or redoes the last action. If the last action has already been undone, it will be re-done, and vice versa.

This is useful for applications that do not present a separate undo and redo facility, but just have a single menu item for undoing and redoing the very last action. Such applications will use an UndoManager whose limit is 1.

protected void undoTo(UndoableEdit edit)
            throws CannotUndoException

Undoes all editing actions in reverse order of addition, up to the specified action,

Parameters:

edit - the last editing action to be undone.

public void undoableEditHappened(UndoableEditEvent event)

Registers the edit action of an UndoableEditEvent with this UndoManager.

Thread Safety: This method may safely be invoked from concurrent threads. The caller does not need to perform external synchronization. This means that UndoableEditEvent sources do not need to broadcast their events from inside the Swing worker thread.

Specified by:

undoableEditHappened in interface UndoableEditListener

Parameters:

event - the event whose edit will be passed to addEdit(UndoableEdit).

See Also:

UndoableEditEvent.getEdit(), addEdit(UndoableEdit)