Package editor.undo

Class 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:
    Serialized Form

    • Constructor Detail

      • 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 Detail

      • 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.

      • removeEdit

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

      • 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:
        UndoManager.getUndoPresentationName()

      • endUndoAtom

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

      • endUndoAtom

        public void endUndoAtom​(CompoundEdit undoAtom)

      • getUndoAtom

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

      • getLastUndoTime

        public long getLastUndoTime()

      • 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.