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.