Class UndoManager

The constructor produces an empty UndoManager with no transaction history. It is unusual to call this -- an UndoManager is automatically constructed for a Model by the Model constructor.

This read-only property returns the current Transaction for recording additional model change events. This is initialized and augmented by handleChanged before it is added to history by a top-level call to commitTransaction. The value will be null between transactions, and may be null during a transaction before any recorded changes occur.

This read-only property returns the whole history, a list of all of the Transactions, each representing a transaction with some number of ChangedEvents. The first Transaction is the oldest.

You should not modify this List.

This read-only property returns the index into history for the current undoable Transaction. The value is -1 if there is no undoable Transaction to be undone. The initial value is -1, when no transactions have been committed.

Gets or sets whether this UndoManager records any changes. The default value is false -- you need to set this to true if you want the user to be able to undo or redo.

You can temporarily turn off recording by setting Diagram.skipsUndoManager and Model.skipsUndoManager to true.

This read-only property is true after the first call to startTransaction and before a corresponding call to commitTransaction or rollbackTransaction.

During a transaction canUndo and canRedo will be false. currentTransaction may be non-null if any ChangedEvents were recorded.

This read-only property is true during a call to undo or redo.

Gets or sets the maximum number of transactions that this undo manager will remember. When a transaction is committed and the number exceeds this value, the UndoManager will discard the oldest transaction(s) in order to meet this limit. The initial value is 999. Any new value must be an integer. A negative value is treated as if there were no limit. A zero value will not remember any Transactions in the history, but will allow commits and rollbacks to occur normally, including raising "Transaction" type ChangedEvents.

This property is useful in helping limit the memory consumption of typical applications. But this does not limit the number of ChangedEvents that are recorded, because there may be an unlimited number of those within each Transaction. Decreasing this value will not necessarily remove any existing Transactions if there currently exist more in history than the new value permits.

This read-only property returns an iterator for all of the Models that this UndoManager is handling.

This read-only property returns a stack of ongoing transaction names. The outermost transaction name will be the first item in the list. The last one will be the name of the most recent (nested) call to startTransaction.

You should not modify this List.

This read-only property returns the current transaction level. The value is zero when there is no ongoing transaction. The initial value is zero. startTransaction will increment this value; commitTransaction or rollbackTransaction will decrement it. When this value is greater than zero, canUndo and canRedo will be false, because a transaction is ongoing and additional logically related model change events may occur.

This read-only property returns the Transaction in the history to be redone next. The value may be null if the UndoManager is not ready to perform a redo.

This read-only property returns the Transaction in the history to be undone next. The value may be null if the UndoManager is not ready to perform an undo.

Make sure this UndoManager knows about a Model for which it may receive ChangedEvents when the given Model is changed. The model will also receive notifications about transactions and undo or redo operations.

You should not call this method during a transaction.

This predicate returns true if you can call redo. This will return false if isEnabled is false (as it is by default), if any transaction is ongoing, or if there is no transactionToRedo that can be redone.

This predicate returns true if you can call undo. This will return false if isEnabled is false (as it is by default), if any transaction is ongoing, or if there is no transactionToUndo that can be undone.

Clear all of the Transactions and clear all other state, including any ongoing transaction without rolling back. However, this maintains its references to its Models.

You should not call this method during a transaction.

Commit the current transaction started by a call to startTransaction.

You must have started a transaction previously.

If this call stops a top-level transaction, we mark the currentTransaction as complete (Transaction.isComplete), we add the Transaction to the history list, and we return true.

Committing a top-level transaction when there have been some undos without corresponding redos will throw away the Transactions holding changes that happened after the current state, before adding the new Transaction to the history list.

For convenience, this method is called by Model.commitTransaction and Diagram.commitTransaction.

Maybe record a ChangedEvent in the currentTransaction. This calls skipsEvent to see if this should ignore the change. If skipsEvent returns false, this creates a copy of the ChangedEvent and adds it to the currentTransaction. If there is no currentTransaction, this first creates and remembers it.

This method always ignores all changes while performing an undo or redo. This method is also a no-op if isEnabled is false.

After an undo, re-perform the changes in transactionToRedo. canRedo must be true for this method to have any effect.

This is called by CommandHandler.redo.

This will raise a "StartingRedo" ChangedEvent of type ChangeType.Transaction, perform the Transaction.redo on the transactionToRedo, and then raise a "FinishedRedo" ChangedEvent of type ChangeType.Transaction. The two ChangedEvents are to let model listeners know that a redo is about to take place and that it just finished. isUndoingRedoing will temporarily be set to true during this operation.

Inform this UndoManager that it will no longer be receiving ChangedEvents when the given Model is changed. The model will no longer receive notifications about transactions and undo or redo operations.

You should not call this method during a transaction. If you call this method between transactions when there is a transaction history, you should be careful that there are no ChangedEvents referring to that model in any Transactions.

Rollback the current transaction started by a call to startTransaction, undoing any changes.

You must have started a transaction previously.

This undoes and then discards the changes in the currentTransaction.

For convenience, this method is called by Model.rollbackTransaction and Diagram.rollbackTransaction.

This predicate is called by handleChanged to decide if a ChangedEvent is not interesting enough to be remembered.

Transactional events (of change type ChangeType.Transaction) are always skipped. Changed events for GraphObjects that are in Layer.isTemporary layers are also skipped.

Sometimes changed events do not even get to handleChanged because Model.skipsUndoManager or Diagram.skipsUndoManager is true.

Begin a transaction, where the changes are held by a Transaction object as the value of currentTransaction. You must call either commitTransaction or rollbackTransaction afterwards.

For convenience, this method is called by Model.startTransaction and Diagram.startTransaction.

Transactions can be nested. Starting or ending a nested transaction will return false. Nested transactions will share the same Transaction list of ChangedEvents.

Starting a transaction will not necessarily cause currentTransaction to be non-null. A Transaction object is usually only created by handleChanged when a ChangedEvent first occurs.

Reverse the effects of the transactionToUndo. canUndo must be true for this method to have any effect.

This is called by CommandHandler.undo.

This will raise a "StartingUndo" ChangedEvent of type ChangeType.Transaction, perform the Transaction.undo on the transactionToUndo, and then raise a "FinishedUndo" ChangedEvent of type ChangeType.Transaction. The two ChangedEvents are to let model listeners know that an undo is about to take place and that it just finished. isUndoingRedoing will temporarily be set to true during this operation.