Struct EditCore 

pub struct EditCore { /* private fields */ }

The caret + selection model, the IME composition in progress, and the field’s admission filter. Selection offsets are bytes into the bound text (matching text_selection and cosmic-text’s byte-indexed layout).

The composition can be part of a secret being typed: Self::clear_preedit zeroes it, and an owner of secret text calls it before dropping the core.

Implementations

impl EditCore

pub fn new() -> EditCore

A collapsed caret at the start.

pub fn at(pos: usize) -> EditCore

A collapsed caret at byte pos.

pub fn set_filter(&mut self, filter: Option<fn(char) -> bool>)

Install (or clear) the per-character admission filter.

pub fn filter(&self) -> Option<fn(char) -> bool>

The installed admission filter.

pub fn admit<'a>(&self, s: &'a str) -> Cow<'a, str>

s with every character the filter rejects removed.

pub fn selection(&self) -> Selection

The full selection (anchor + cursor).

pub fn caret(&self) -> usize

Live caret byte offset.

pub fn anchor(&self) -> usize

The selection anchor (equal to the caret when nothing is selected).

pub fn affinity(&self) -> TextAffinity

The caret’s visual side at an ambiguous (bidi / soft-wrap) boundary.

pub fn caret_position(&self) -> TextPosition

Live caret offset plus its visual side at an ambiguous boundary.

pub fn has_selection(&self) -> bool

Whether any characters are selected.

pub fn range(&self) -> Range<usize>

Sorted [start, end) byte range of the selection.

pub fn selected_range(&self) -> Option<Range<usize>>

The selected byte range, None when collapsed.

pub fn selected<'a>(&self, text: &'a str) -> Option<&'a str>

The selected slice of text.

pub fn set_caret(&mut self, byte: usize)

Move the caret to byte, collapsing the selection.

pub fn set_caret_position(&mut self, position: TextPosition)

Move to an exact shaped position, collapsing the selection.

pub fn set_selection(&mut self, anchor: usize, cursor: usize)

Set both endpoints explicitly.

pub fn set_selection_position(&mut self, anchor: usize, cursor: TextPosition)

Set both endpoints and the caret’s visual side.

pub fn collapse(&mut self)

Collapse the selection onto the cursor.

pub fn clamp_to(&mut self, text: &str)

Clamp both endpoints into [0, len] and onto grapheme boundaries. Call after the bound text changed underneath the caret (a remote / external edit) so motion never slices a code point.

pub fn select_all(&mut self, text: &str)

Select the entire buffer.

pub fn motion(&mut self, text: &str, m: Motion, extend: bool)

Apply a caret motion. extend keeps the anchor fixed (shift-select). A plain (non-extend) horizontal step with a live selection collapses to the near edge rather than stepping past it — the native editor behaviour.

pub fn motion_to(&mut self, m: Motion, target: TextPosition, extend: bool)

Apply motion m whose destination the host already resolved through laid-out geometry (visual bidi order, a soft-wrapped row edge). Same selection rules as Self::motion.

pub fn place(&mut self, byte: usize, extend: bool)

Seat the caret from a click at byte byte; extend (shift-click) keeps the anchor so the selection grows.

pub fn place_position(&mut self, position: TextPosition, extend: bool)

Seat the caret from an exact shaped position.

pub fn select_word(&mut self, text: &str, byte: usize)

Select the word under byte (double-click) and anchor to it.

pub fn select_line(&mut self, text: &str, byte: usize)

Select the \n-delimited line under byte (triple-click).

pub fn insert(&mut self, s: &str) -> Edit

Insert s through the admission filter, replacing any selection. Returns the byte-space Edit and moves the caret to just after the inserted text. An insert the filter empties (or an empty s) is a no-op that leaves the selection alone.

pub fn replace(&mut self, range: Range<usize>, s: &str) -> Edit

Replace range (bytes) with s through the admission filter, leaving the caret after the replacement — for edits that target a span other than the selection (autocorrect, a spelling suggestion).

pub fn delete_selection(&mut self) -> Edit

Delete the selection; a no-op when nothing is selected.

pub fn delete_backward(&mut self, text: &str, word: bool) -> Edit

Backspace: delete the selection, else the grapheme (or word, with word) before the caret. Returns the resulting Edit (a no-op at the start).

pub fn delete_forward(&mut self, text: &str, word: bool) -> Edit

Delete forward (Delete key): the selection, else the grapheme (or word) after the caret. The caret stays put. No-op at the end of the buffer.

pub fn preedit(&self) -> &str

The composition in progress (empty when none).

pub fn has_preedit(&self) -> bool

Whether an IME composition is in progress.

pub fn preedit_cursor(&self) -> Option<(usize, usize)>

The IME’s cursor inside the composition, as it reported it.

pub fn set_preedit(&mut self, text: &str, cursor: Option<(usize, usize)>)

Show text as the composition at the caret. The admission filter applies; when it drops characters the IME’s cursor no longer addresses the shown text and falls back to the composition’s end.

pub fn clear_preedit(&mut self)

Drop (and zero) the composition without committing it.

pub fn commit(&mut self, text: &str) -> Edit

The IME committed text: the composition ends and text replaces the selection like typing would.

pub fn display_text<'a>(&self, text: &'a str) -> Cow<'a, str>

text with the composition shown at the caret.

pub fn preedit_display_range(&self, text: &str) -> Option<Range<usize>>

The display byte range the composition occupies.

pub fn to_display(&self, text: &str, byte: usize) -> usize

A committed-text byte mapped into the display text: offsets after the caret shift past the composition.

pub fn from_display(&self, text: &str, byte: usize) -> usize

A display byte mapped back into the committed text; anything inside the composition maps to the caret.

pub fn display_caret(&self, text: &str) -> usize

Where the caret draws in the display text: inside the composition at the IME’s cursor, snapped to a grapheme boundary of the composition.

Trait Implementations

impl Clone for EditCore

fn clone(&self) -> EditCore

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EditCore

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

Formats the value using the given formatter.

impl Default for EditCore

fn default() -> EditCore

Returns the “default value” for a type.