Struct zng::undo::UNDO

pub struct UNDO;

Undo-redo service.

Implementations

impl UNDO

pub fn undo_limit(&self) -> Box<dyn VarBoxed<u32>>

Gets or sets the maximum length of each undo stack of each scope.

Is u32::MAX by default. If the limit is reached the oldest undo action is dropped without redo.

Note that undo scopes get the max undo from UNDO_LIMIT_VAR in context, the context var is set to this var by default.

pub fn undo_interval(&self) -> Box<dyn VarBoxed<Duration>>

Gets or sets the time interval that undo and redo cover each call.

This value applies to all scopes and defines the max interval between actions that are undone in a single call.

Is the keyboard repeat start delay + interval by default.

Note that undo scopes get the interval from UNDO_INTERVAL_VAR in context, the context var is set to this var by default.

pub fn is_enabled(&self) -> bool

Gets if the undo service is enabled in the current context.

If false calls to register are ignored.

pub fn undo_select(&self, selector: impl UndoSelector)

Undo a selection of actions.

Selectors

These types can be used as selector:

• u32 - Count of actions to undo.
• Duration - Interval between each action.
• DInstant - Inclusive timestamp to undo back to.

pub fn redo_select(&self, selector: impl UndoSelector)

Redo a selection of actions.

pub fn undo(&self)

Undo all actions within the undo_interval.

pub fn redo(&self)

Redo all actions within the undo_interval.

pub fn scope(&self) -> Option<WidgetId>

Gets the parent ID that defines an undo scope, or None if undo is registered globally for the entire app.

pub fn register(&self, action: impl UndoAction)

Register an already executed action for undo in the current scope.

pub fn register_op( &self, info: impl UndoInfo, op: impl FnMut(UndoOp) + Send + 'static, )

Register an already executed action for undo in the current scope.

The action is defined as a closure op that matches over UndoOp to implement undo and redo.

pub fn register_full_op<D>( &self, data: D, op: impl FnMut(&mut D, UndoFullOp<'_>) + Send + 'static, )

where D: Any + Send + 'static,

Register an already executed action for undo in the current scope.

The action is defined as a closure op that matches over UndoFullOp referencing data to implement undo and redo.

pub fn run(&self, action: impl RedoAction)

Run the action and register the undo in the current scope.

pub fn run_op( &self, info: impl UndoInfo, op: impl FnMut(UndoOp) + Send + 'static, )

Run the op once with UndoOp::Redo and register it for undo in the current scope.

pub fn run_full_op<D>( &self, data: D, op: impl FnMut(&mut D, UndoFullOp<'_>) + Send + 'static, )

where D: Any + Send + 'static,

Run the op once with UndoFullOp::Init { .. } and UndoFullOp::Op(UndoOp::Redo) and register it for undo in the current scope.

pub fn group(&self, info: impl UndoInfo, actions: impl FnOnce()) -> bool

Run actions as a transaction and commits as a group if any undo action is captured.

pub fn transaction(&self, actions: impl FnOnce()) -> UndoTransaction

Run actions in a new undo scope, capturing all undo actions inside it into a new UndoTransaction.

The transaction can be immediately undone or committed.

pub fn try_group<O, E>( &self, info: impl UndoInfo, actions: impl FnOnce() -> Result<O, E>, ) -> Result<O, E>

Run actions as a transaction and commits as a group if the result is Ok(O) and at least one undo action was registered, or undoes all if result is Err(E).

pub fn try_commit<O, E>( &self, actions: impl FnOnce() -> Result<O, E>, ) -> Result<O, E>

Run actions as a transaction and commits if the result is Ok(O), or undoes all if result is Err(E).

pub fn with_scope<R>( &self, scope: &mut WidgetUndoScope, f: impl FnOnce() -> R, ) -> R

Runs f in a new scope. All undo actions inside f are registered in the scope.

pub fn with_disabled<R>(&self, f: impl FnOnce() -> R) -> R

Runs f in a disabled scope, all undo actions registered inside f are ignored.

pub fn watch_var<T>(&self, info: impl UndoInfo, var: impl Var<T>) -> VarHandle

where T: VarValue,

Track changes on var, registering undo actions for it.

The variable will be tracked until the returned handle or the var is dropped.

Note that this will keep strong clones of previous and new value every time the variable changes, but it will only keep weak references to the variable. Dropping the handle or the var will not remove undo/redo entries for it, they will still try to assign the variable, failing silently if the variable is dropped too.

Var updates caused by undo and redo are tagged with UndoVarModifyTag.

pub fn clear_redo(&self)

Clear all redo actions.

pub fn clear(&self)

Clear all undo and redo actions.

pub fn can_undo(&self) -> bool

If the undo stack is not empty.

pub fn can_redo(&self) -> bool

If the redo stack is not empty.

pub fn undo_stack(&self) -> UndoStackInfo

Clones the timestamp and info of all entries in the current undo stack.

The latest undo action is the last entry in the list.

pub fn redo_stack(&self) -> UndoStackInfo

Clones the timestamp and info of all entries in the current redo stack.

The latest undone action is the last entry in the list. Note that the timestamp marks the moment the original undo registered the action, so the newest timestamp is in the first entry.