Struct EditBuffer 

pub struct EditBuffer { /* private fields */ }

The open note’s text, cursor, selection and edit history.

Every mutation goes through a transaction (Self::begin), and a transaction is exactly one entry in the history. Nothing has to count history entries, predict how many an operation will push, or reconstruct where a group started: the entry holds the states it ran between.

Implementations

impl EditBuffer

pub fn new(text: Text) -> Self

pub fn text(&self) -> &Text

pub fn cursor(&self) -> Position

pub fn selection(&self) -> Option<Span>

The selected range, or None when nothing is selected.

The selection lives here rather than beside the buffer so that “moving the cursor without extending drops the selection” is a property of the thing that owns both, and not a rule every caller has to remember. Reaching for a search result and forgetting to drop the anchor is how an invisible selection gets deleted by the next keystroke.

pub fn snapshot(&self) -> Snapshot

Everything a reader needs, consistent by construction.

pub fn set_cursor(&mut self, to: Position) -> bool

Move the cursor, dropping any selection.

Returns false — and moves nothing — when to addresses a state this buffer has left. Not an assertion: a position outliving the text it was made against is a real thing that happens to real callers, an event arriving after a background edit being the obvious way. Refusing it is a keystroke that did nothing, which is recoverable in a way editing the wrong place is not.

pub fn extend_to(&mut self, to: Position) -> bool

Move the cursor, keeping or starting a selection.

The counterpart of Self::set_cursor, and the reason that one can drop the anchor unconditionally: every caller says which it means.

pub fn select(&mut self, span: Span) -> bool

Select span, leaving the cursor at its end.

pub fn clear_selection(&mut self)

pub fn set_text(&mut self, text: Text)

Replace the whole buffer and forget its history.

For opening a different note, not for editing. The history describes states the new text cannot reach, so keeping it would let an undo jump from one note into another.

pub fn set_history_budget(&mut self, bytes: usize)

How many bytes of edit history to retain.

pub fn begin(&mut self) -> Txn<'_>

Open a transaction that will record its own undo group.

pub fn begin_extending(&mut self) -> Txn<'_>

Open a transaction that folds into the previous group.

For a backend that has decided this edit continues what the last one started — the next character of a typing run. Where a group ends is the backend’s judgement, because only the backend knows what the user was doing; this crate keeps no clock and no policy.

Falls back to Self::begin when there is nothing to fold into.

pub fn undo(&mut self) -> Option<Change>

Undo the newest group, restoring the text, cursor and selection it began from.

All of it or none of it. The entry holds the state the group started from, so there is no replay to run out of, no count to get wrong, and no way to land part-way through an action the user asked to undo whole.

pub fn redo(&mut self) -> Option<Change>

Redo the group a previous Self::undo took back.

Trait Implementations

impl Debug for EditBuffer

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

Formats the value using the given formatter.

impl Default for EditBuffer

fn default() -> Self

Returns the “default value” for a type.