Struct UndoRedoManager 

pub struct UndoRedoManager {
    pub node_stacks: Vec<NodeUndoRedoStack>,
    pub content_snapshots: Vec<(ChangesetId, ContentSnapshot)>,
}

Manager for undo/redo operations across all text nodes

Fields

node_stacks: Vec<NodeUndoRedoStack>

Per-node undo/redo stacks Using Vec instead of HashMap for no_std compatibility

content_snapshots: Vec<(ChangesetId, ContentSnapshot)>

Styled-content snapshots keyed by TextChangeset.id (see ContentSnapshot); FIFO-capped at [MAX_CONTENT_SNAPSHOTS].

Implementations

impl UndoRedoManager

pub const fn new() -> Self

Create a new empty undo/redo manager

pub fn store_content_snapshot( &mut self, id: ChangesetId, pre: Vec<InlineContent>, post: Vec<InlineContent>, )

Store the styled pre/post content for a changeset (see ContentSnapshot).

pub fn get_content_snapshot(&self, id: ChangesetId) -> Option<&ContentSnapshot>

Look up the styled snapshot for a changeset id.

pub fn reinstate_undo(&mut self, operation: UndoableOperation)

MWA-C-undo_redo: put a redone operation back on the undo stack WITHOUT clearing the redo stack (see NodeUndoRedoStack::push_undo_preserving_redo).

Panics

Panics if the operation’s changeset target node is None.

pub fn get_or_create_stack_mut( &mut self, node_id: NodeId, ) -> &mut NodeUndoRedoStack

Get or create a stack for a specific node

Panics

Panics if the per-node stack list is unexpectedly empty after insertion.

pub fn get_stack(&self, node_id: NodeId) -> Option<&NodeUndoRedoStack>

Get a stack for a specific node (immutable)

pub fn record_operation( &mut self, changeset: TextChangeset, pre_state: NodeStateSnapshot, )

Record a text operation (push to undo stack)

This should be called AFTER a changeset has been successfully applied. The pre_state should contain the node state BEFORE the changeset was applied.

Arguments

• changeset - The changeset that was applied
• pre_state - Node state before the changeset

Panics

Panics if the changeset’s target node is None.

pub fn can_undo(&self, node_id: NodeId) -> bool

Check if undo is available for a node

pub fn can_redo(&self, node_id: NodeId) -> bool

Check if redo is available for a node

pub fn peek_undo(&self, node_id: NodeId) -> Option<&UndoableOperation>

Peek at the next undo operation for a node (without removing it)

This allows user callbacks to inspect what would be undone.

pub fn peek_redo(&self, node_id: NodeId) -> Option<&UndoableOperation>

Peek at the next redo operation for a node (without removing it)

This allows user callbacks to inspect what would be redone.

pub fn pop_undo(&mut self, node_id: NodeId) -> Option<UndoableOperation>

Pop an operation from the undo stack

This should be called during undo processing to get the operation to revert. After reverting, the operation should be pushed to the redo stack.

Returns

• Some(operation) - The operation to undo
• None - No undo history available

pub fn pop_redo(&mut self, node_id: NodeId) -> Option<UndoableOperation>

Pop an operation from the redo stack

This should be called during redo processing to get the operation to re-apply. After re-applying, the operation should be pushed to the undo stack.

Returns

• Some(operation) - The operation to redo
• None - No redo history available

pub fn push_redo(&mut self, operation: UndoableOperation)

Push an operation to the redo stack (after successful undo)

This should be called AFTER an undo operation has been successfully applied.

Panics

Panics if the operation’s changeset target node is None.

pub fn push_undo(&mut self, operation: UndoableOperation)

Push an operation to the undo stack (after successful redo)

This should be called AFTER a redo operation has been successfully applied.

Panics

Panics if the operation’s changeset target node is None.

Trait Implementations

impl Clone for UndoRedoManager

fn clone(&self) -> UndoRedoManager

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for UndoRedoManager

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for UndoRedoManager

fn default() -> UndoRedoManager

Returns the “default value” for a type.

impl NodeIdRemap for UndoRedoManager

fn remap_node_ids(&mut self, dom: DomId, map: &NodeIdMap)

Remap the per-node undo/redo stacks after a DOM rebuild.

This is the worst offender of the “stale manager” family: the stacks are keyed by a bare NodeId, so deleting a PRECEDING SIBLING (which shifts every following index down by one) used to leave the whole undo history silently re-attached to a DIFFERENT, still-live element — undo would edit the wrong node, with no panic and no error.

A stack is attributed to a DOM through the DomNodeId target of its operations (an empty stack carries no information and is treated as belonging to the DOM being reconciled). Stacks for unmounted nodes are dropped, and the content snapshots they referenced are GC’d with them.