Class UndoManager

Constructs an UndoManager.

The limit of the freshly constructed UndoManager is 100.

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

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 {@link #end()} has already been called on this UndoManager.

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

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

See Also: redo canUndo canUndoOrRedo

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

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

See Also: undo canRedo 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.

Discards all editing actions that are currently registered with this UndoManager. Each {@link UndoableEdit} will receive a {@link UndoableEdit#die() die message}.

Determines which significant edit would be redone if {@link #redo()} was called.

Returns: the significant edit that would be redone, or null if no significant edit would be affected by calling {@link #redo()}.

Determines which significant edit would be undone if {@link #undo()} was called.

Returns: the significant edit that would be undone, or null if no significant edit would be affected by calling {@link #undo()}.

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

Returns how many edits this UndoManager can maximally hold.

See Also: UndoManager

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

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

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

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

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

Throws: CannotRedoException if no action can be redone.

See Also: canRedo redo undoOrRedo

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.

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 {@link UndoableEdit#die() die} message in reverse order of addition.

Parameters: limit the new limit.

Throws: IllegalStateException if {@link #end()} has already been called on this UndoManager.

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

Discards a range of edits. All edits in the range [from .. to] will receive a {@linkplain UndoableEdit#die() 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.

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

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 {@link #end()} has been called on this UndoManager, it will behave like a normal {@link CompoundEdit}. In this case, all actions will be undone in reverse order of addition. Typical applications will never call {@link #end()} on their UndoManager.

Throws: CannotUndoException if no action can be undone.

See Also: canUndo redo undoOrRedo

Registers the edit action of an {@link 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 {@link javax.swing.event.UndoableEditEvent} sources do not need to broadcast their events from inside the Swing worker thread.

Parameters: event the event whose edit will be passed to {@link #addEdit}.

See Also: getEdit UndoManager

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.

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

Parameters: edit the last editing action to be undone.