Struct CommandHistory 

pub struct CommandHistory { /* private fields */ }

Manages command history for undo/redo operations.

The history maintains two stacks:

• Undo stack: Commands that can be undone
• Redo stack: Commands that can be redone (cleared when new commands are added)

Thread-safe using Arc<Mutex<>> for interior mutability.

Implementations

impl CommandHistory

pub fn new(max_size: usize) -> Self

Creates a new command history with the specified size limit.

Arguments

• max_size - Maximum number of commands to keep in history

Returns

A new CommandHistory instance

Example

use iced_code_editor::CommandHistory;

let history = CommandHistory::new(100);

pub fn push(&self, command: Box<dyn Command>)

Adds a command to the history.

This clears the redo stack and adds the command to the undo stack. If currently grouping commands, adds to the current group instead.

Arguments

• command - The command to add

pub fn undo(&self, buffer: &mut TextBuffer, cursor: &mut (usize, usize)) -> bool

Undoes the last command.

Arguments

• buffer - The text buffer to modify
• cursor - The cursor position to update

Returns

true if a command was undone, false if nothing to undo

pub fn redo(&self, buffer: &mut TextBuffer, cursor: &mut (usize, usize)) -> bool

Redoes the last undone command.

Arguments

• buffer - The text buffer to modify
• cursor - The cursor position to update

Returns

true if a command was redone, false if nothing to redo

pub fn can_undo(&self) -> bool

Returns whether there are commands that can be undone.

pub fn can_redo(&self) -> bool

Returns whether there are commands that can be redone.

pub fn mark_saved(&self)

Marks the current position as the save point.

This is used to track whether the document has been modified since the last save. Call this after successfully saving the file.

pub fn is_modified(&self) -> bool

Returns whether the document has been modified since the last save.

Returns

true if there are unsaved changes, false otherwise

pub fn clear(&self)

Clears all history.

This removes all undo/redo commands and resets the save point. Useful when starting a new document or resetting the editor state.

Example

use iced_code_editor::CommandHistory;

let history = CommandHistory::new(100);
// ... perform some operations ...

// Clear everything when opening a new document
history.clear();
assert_eq!(history.undo_count(), 0);
assert_eq!(history.redo_count(), 0);
assert!(!history.is_modified());

pub fn begin_group(&self, description: &str)

Begins grouping subsequent commands into a composite.

All commands added via push() will be grouped together until end_group() is called. This is useful for grouping consecutive typing operations.

Arguments

• description - Description for the composite command

pub fn end_group(&self)

Ends the current command grouping.

The grouped commands are added to the history as a single composite command. If no commands were grouped, nothing is added.

pub fn max_size(&self) -> usize

Returns the maximum history size.

Returns

The maximum number of commands that can be stored in history.

Example

use iced_code_editor::CommandHistory;

let history = CommandHistory::new(100);
assert_eq!(history.max_size(), 100);

pub fn set_max_size(&self, max_size: usize)

Sets the maximum history size.

If the current history exceeds the new size, older commands are removed. This is useful for adjusting memory usage based on system resources.

Arguments

• max_size - New maximum size (number of commands to keep)

Example

use iced_code_editor::CommandHistory;

let history = CommandHistory::new(100);

// Increase limit for memory-rich environments
history.set_max_size(500);
assert_eq!(history.max_size(), 500);

// Decrease limit for constrained environments
history.set_max_size(50);
assert_eq!(history.max_size(), 50);

pub fn undo_count(&self) -> usize

Returns the current number of undo operations available.

This can be useful for displaying history statistics or managing UI state (e.g., enabling/disabling undo buttons).

Returns

The number of commands that can be undone.

Example

use iced_code_editor::CommandHistory;

let history = CommandHistory::new(100);
assert_eq!(history.undo_count(), 0);

// After adding commands...
// assert!(history.undo_count() > 0);

pub fn redo_count(&self) -> usize

Returns the current number of redo operations available.

This can be useful for displaying history statistics or managing UI state (e.g., enabling/disabling redo buttons).

Returns

The number of commands that can be redone.

Example

use iced_code_editor::CommandHistory;

let history = CommandHistory::new(100);
assert_eq!(history.redo_count(), 0);

// After undoing some commands...
// assert!(history.redo_count() > 0);

Trait Implementations

impl Clone for CommandHistory

fn clone(&self) -> CommandHistory

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CommandHistory

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

Formats the value using the given formatter.

impl Default for CommandHistory

fn default() -> Self

Returns the “default value” for a type.