Package editor.undo

Class AtomicUndoManager

java.lang.Object
javax.swing.undo.AbstractUndoableEdit
javax.swing.undo.CompoundEdit
javax.swing.undo.UndoManager
editor.undo.AtomicUndoManager
All Implemented Interfaces:
Serializable, EventListener, UndoableEditListener, UndoableEdit
public class AtomicUndoManager extends UndoManager
This class extends UndoManager providing nested atomic (or scoped) undo/redo operations. Note undo/redo operations are captured in StateEditable implementations.

A generic application of this class follows: 

 ...
 _undoMgr = new AtomicUndoManager( 1000 );
 ...
 //
 // This method decorates a typical change operation with undo/redo capability.
 // Notice the XXXOperationUndoItem class.  You'll need to create one of these
 // for each undo operation.  Basically these UndoItem classes are extensions
 // of StateEditable.  They are responsible for capturing the state
 // before and after an operation and also for restoring the state as directed
 // by this undo manager.
 //
 void performUndoableXXXOperation( ... )
 {
   XXXOperationUndoItem undoItem = new XXXOperationUndoItem( ... );
   StateEdit transaction = new StateEdit( undoItem, "XXX Operation" );

   performXXXOperation( ... );

   transaction.end();
   _undoMgr.addEdit( transaction );
 }

 // Your typical change operation.
 void performXXXOperation( ... )
 {
   // do whatever it is you do...
 }

 //
 // This method exercises the atomic and nested features of AtomicUndoManager.
 // The atomic boundaries should be enforced with the try/finally idiom so
 // a failed atomic operation can be safely (and optionally) "rolled back".
 //
 void performUndoableZZZOperation
 {
   try
   {
     _undoMgr.beginUndoAtom( "ZZZ Operation" );

     performUndoableXXXOperation( ... );
     performUndoableYYYOperation( ... );
     ...
   }
   finally
   {
     _undoMgr.endUndoAtom();
   }
 }


 //
 // Create ui components using Actions such as these:
 //
 class UndoAction extends AbstractAction
 {
   UndoAction( String strName, Icon icon )
   {
     super( strName, icon );
   }

   public void actionPerformed( ActionEvent e )
   {
     _undoMgr.undo();
   }

   public boolean isEnabled()
   {
     return _undoMgr.canUndo();
   }
 }

 class RedoAction extends AbstractAction
 {
   RedoAction( String strName, Icon icon )
   {
     super( strName, icon );
   }

   public void actionPerformed( ActionEvent e )
   {
     _undoMgr.redo();
   }

   public boolean isEnabled()
   {
     return _undoMgr.canRedo();
   }
 }
See Also:

  • Constructor Details

    • AtomicUndoManager

      public AtomicUndoManager()
      An AtomicUndoManager with a default limit of 1000 edits.

    • AtomicUndoManager

      public AtomicUndoManager(int iUndoLimit)
      Parameters:
      iUndoLimit - The maximum number of edits this undo manager will hold.

  • Method Details

    • isPaused

      public boolean isPaused()
      Returns:
      Is this undo manager in a Paused state? i.e., are edits being ignored?

    • setPaused

      public void setPaused(boolean bPaused)
      Sets the paused state of the undo manager. If paused, undo operations are ignored
      Parameters:
      bPaused - The paused state.

    • addEdit

      public boolean addEdit(UndoableEdit edit)
      Specified by:
      addEdit in interface UndoableEdit
      Overrides:
      addEdit in class UndoManager
      Parameters:
      edit - The edit to be added. Note nested edits are supported.

    • removeEdit

      public void removeEdit(UndoableEdit edit)
      Parameters:
      edit - The edit to be removed.

    • discardAllEdits

      public void discardAllEdits()
      Overrides:
      discardAllEdits in class UndoManager

    • beginUndoAtom

      public void beginUndoAtom()
      Begin an atomic undo boundary. Edits added to this undo mananger after this call are considered "subatomic" -- they become part of the atom defined by the boundary. The atom's boundary ends with a call to endUndoAtom().

      Note undo atoms can contain other undo atoms allowing for unlimited nesting of atomic undo operations.

    • beginUndoAtom

      public CompoundEdit beginUndoAtom(String strDisplayName)
      Begin an atomic undo boundary. Edits added to this undo mananger after this call are considered "subatomic" -- they become part of the atom defined by the boundary. The atom's boundary ends with a call to endUndoAtom().

      Note undo atoms can contain other undo atoms allowing for unlimited nesting of atomic undo operations.

      Parameters:
      strDisplayName - The name associated with the undo atom. A user interface typically displays this name in Undo/Redo menu items or toolbar button text.
      See Also:

    • endUndoAtom

      public void endUndoAtom()
      Ends the active atomic undo boundary.
      See Also:

    • endUndoAtom

      public void endUndoAtom(CompoundEdit undoAtom)

    • getUndoAtom

      public editor.undo.AtomicUndoManager.DisplayableCompoundEdit getUndoAtom()
      Returns:
      The undo atom currently in progress.

    • redo

      public void redo() throws CannotRedoException
      Specified by:
      redo in interface UndoableEdit
      Overrides:
      redo in class UndoManager
      Throws:
      CannotRedoException

    • undo

      public void undo() throws CannotUndoException
      Specified by:
      undo in interface UndoableEdit
      Overrides:
      undo in class UndoManager
      Throws:
      CannotUndoException

    • getLastUndoTime

      public long getLastUndoTime()

    • undoOrRedo

      public void undoOrRedo() throws CannotRedoException, CannotUndoException
      Overrides:
      undoOrRedo in class UndoManager
      Throws:
      CannotRedoException
      CannotUndoException

    • undoTo

      protected void undoTo(UndoableEdit edit) throws CannotUndoException
      Overrides:
      undoTo in class UndoManager
      Throws:
      CannotUndoException

    • redoTo

      protected void redoTo(UndoableEdit edit) throws CannotRedoException
      Overrides:
      redoTo in class UndoManager
      Throws:
      CannotRedoException

    • addChangeListener

      public void addChangeListener(ChangeListener listener)

    • removeChangeListener

      public void removeChangeListener(ChangeListener listener)

    • recordChange

      public void recordChange(StateEditable change)
      Utility method that records a change that can be undone/redone.