Skip to main content

CommandHistory

Struct CommandHistory 

Source
pub struct CommandHistory { /* private fields */ }
Expand description

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. Cloning shares the same history: every clone reads and writes the one set of stacks.

No method on this type panics on a poisoned mutex: a poisoned lock is recovered rather than propagated, so a panic inside one caller’s Command cannot leave the history permanently unusable for everyone else.

Each CodeEditor owns one of these and records every edit into it, so most applications observe it through CodeEditor::can_undo, CodeEditor::is_modified, and the Message::Undo / Message::Redo messages rather than constructing one directly.

§Example

use iced_code_editor::{CodeEditor, Message};

let mut editor = CodeEditor::new("hello", "rs");
assert!(!editor.can_undo());

let _ = editor.update(&Message::Paste(" world".to_string()));
assert!(editor.can_undo());
assert!(editor.is_modified());

let _ = editor.update(&Message::Undo);
assert_eq!(editor.content(), "hello");
assert!(editor.can_redo());

Implementations§

Source§

impl CommandHistory

Source

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);
Source

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.

The Command trait is internal to this crate, so an application does not call this directly — CodeEditor pushes a command for each edit it performs. The example below shows the observable effect.

§Arguments
  • command - The command to add
§Example
use iced_code_editor::{CodeEditor, Message};

let mut editor = CodeEditor::new("hello", "rs");

// Each edit the editor performs pushes a command.
let _ = editor.update(&Message::Paste("!".to_string()));
assert!(editor.can_undo());

// Pushing after an undo discards the redo stack: the alternative
// future is gone once a new edit diverges from it.
let _ = editor.update(&Message::Undo);
assert!(editor.can_redo());
let _ = editor.update(&Message::Paste("?".to_string()));
assert!(!editor.can_redo());
Source

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

Undoes the last command.

Any open group is closed first, so an in-progress run of typing undoes as one unit rather than being left half-open.

TextBuffer is internal to this crate, so an application drives this through Message::Undo rather than calling it directly.

§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

§Example
use iced_code_editor::{CodeEditor, Message};

let mut editor = CodeEditor::new("hello", "rs");
let _ = editor.update(&Message::Paste(" world".to_string()));
assert_eq!(editor.content(), " worldhello");

let _ = editor.update(&Message::Undo);
assert_eq!(editor.content(), "hello");

// Undoing with an empty stack is a harmless no-op.
let _ = editor.update(&Message::Undo);
assert_eq!(editor.content(), "hello");
Source

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

Redoes the last undone command.

TextBuffer is internal to this crate, so an application drives this through Message::Redo rather than calling it directly.

§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

§Example
use iced_code_editor::{CodeEditor, Message};

let mut editor = CodeEditor::new("hello", "rs");
let _ = editor.update(&Message::Paste(" world".to_string()));
let _ = editor.update(&Message::Undo);
assert_eq!(editor.content(), "hello");

let _ = editor.update(&Message::Redo);
assert_eq!(editor.content(), " worldhello");
Source

pub fn can_undo(&self) -> bool

Returns whether there are commands that can be undone.

An open group counts as undoable even before it is closed, so an “Undo” menu item stays enabled while the user is mid-word.

§Returns

true if undo would do something, false otherwise

§Example
use iced_code_editor::CommandHistory;

let history = CommandHistory::new(100);
assert!(!history.can_undo());
Source

pub fn can_redo(&self) -> bool

Returns whether there are commands that can be redone.

§Returns

true if redo would do something, false otherwise

§Example
use iced_code_editor::{CodeEditor, Message};

let mut editor = CodeEditor::new("hello", "rs");
assert!(!editor.can_redo());

// Redo only becomes available after an undo.
let _ = editor.update(&Message::Paste("!".to_string()));
assert!(!editor.can_redo());
let _ = editor.update(&Message::Undo);
assert!(editor.can_redo());
Source

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.

§Example
use iced_code_editor::{CodeEditor, Message};

let mut editor = CodeEditor::new("hello", "rs");
let _ = editor.update(&Message::Paste("!".to_string()));
assert!(editor.is_modified());

// After the host has written the file to disk.
editor.mark_saved();
assert!(!editor.is_modified());

// Undoing back past the save point marks the document dirty again.
let _ = editor.update(&Message::Undo);
assert!(editor.is_modified());
Source

pub fn is_modified(&self) -> bool

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

Compares the current undo depth against the depth recorded by Self::mark_saved, so undoing back to the saved state reports “not modified” again rather than staying permanently dirty.

§Returns

true if there are unsaved changes, false otherwise

§Example
use iced_code_editor::CommandHistory;

let history = CommandHistory::new(100);
// A fresh history has nothing to save.
assert!(!history.is_modified());
Source

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());
Source

pub fn begin_group(&self)

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, so one undo removes a whole word rather than one character at a time.

Calling this while a group is already open does nothing, so grouping does not nest.

§Example
use iced_code_editor::CommandHistory;

let history = CommandHistory::new(100);

history.begin_group();
// An open group counts as undoable, so an "Undo" menu item stays
// enabled while the user is still typing.
assert!(history.can_undo());

// Nothing was actually pushed, so closing it adds no entry.
history.end_group();
assert_eq!(history.undo_count(), 0);
Source

pub fn end_group(&self)

Ends the current command grouping.

The grouped commands are added to the history as a single composite command, so one undo reverses all of them. If no commands were grouped, nothing is added — an empty group leaves no trace.

Safe to call when no group is open.

§Example
use iced_code_editor::CommandHistory;

let history = CommandHistory::new(100);

history.begin_group();
history.end_group();
// An empty group adds nothing to the undo stack.
assert_eq!(history.undo_count(), 0);
assert!(!history.can_undo());

// Closing when nothing is open is harmless.
history.end_group();
Source

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);
Source

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);
Source

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);
Source

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§

Source§

impl Clone for CommandHistory

Source§

fn clone(&self) -> CommandHistory

Returns a duplicate of the value. Read more
1.0.0 (const: unstable) · Source§

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

Performs copy-assignment from source. Read more
Source§

impl Debug for CommandHistory

Source§

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

Formats the value using the given formatter. Read more
Source§

impl Default for CommandHistory

Source§

fn default() -> Self

Returns the “default value” for a type. Read more

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> Downcast for T
where T: Any,

Source§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
Source§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
Source§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
Source§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
Source§

impl<T> Downcast<T> for T

Source§

fn downcast(&self) -> &T

Source§

impl<T> DowncastSync for T
where T: Any + Send + Sync,

Source§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync> ⓘ

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T> Instrument for T

Source§

fn instrument(self, span: Span) -> Instrumented<Self> ⓘ

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Source§

fn in_current_span(self) -> Instrumented<Self> ⓘ

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<State, Message> IntoBoot<State, Message> for State

Source§

fn into_boot(self) -> (State, Task<Message>)

Turns some type into the initial state of some Application.
Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<T> MaybeClone for T

Source§

impl<T> MaybeDebug for T

Source§

impl<T> MaybeSend for T
where T: Send,

Source§

impl<T> MaybeSync for T
where T: Sync,

Source§

impl<T> NoneValue for T
where T: Default,

Source§

type NoneType = T

Source§

fn null_value() -> T

The none-equivalent value.
Source§

impl<T> Pointable for T

Source§

const ALIGN: usize

The alignment of pointer.
Source§

type Init = T

The type for initializers.
Source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
Source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
Source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
Source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = !

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<T> Upcast<T> for T

Source§

fn upcast(&self) -> Option<&T>

Source§

impl<T> WasmNotSend for T
where T: Send,

Source§

impl<T> WasmNotSendSync for T

Source§

impl<T> WasmNotSync for T
where T: Sync,

Source§

impl<T> WithSubscriber for T

Source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘ
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more