Struct TextEditorComponent 

pub struct TextEditorComponent { /* private fields */ }

Snapshot of the textarea backend used to classify a key event as a text edit (text differs) vs. a pure cursor move (text same, cursor moved) vs. a no-op (both same).

Implementations

impl TextEditorComponent

pub fn new(key_bindings: KeyBindings, settings: &AppSettings) -> Self

pub fn set_vault(&mut self, vault: Arc<NoteVault>)

Attach a vault so autocomplete can query notes/tags. Activates the controller immediately on the textarea backend; on Nvim, the vault is stashed and the controller is spun up later if maybe_recover_from_dead_nvim falls back to Textarea.

pub fn lines(&self) -> &[String]

Returns the buffer lines for direct access.

For the Textarea backend, returns the live lines. For the Nvim backend, returns an empty slice — use get_text() instead, which reads from the snapshot.

pub fn view_snapshot(&self) -> EditorSnapshot<'_>

Single producer for the editor’s atomic (lines, cursor, content_revision) view. Downstream consumers (MarkdownEditorView, click_to_logical_u16, the autocomplete host) take a &EditorSnapshot and stop guarding against drift between cursor and lines on every leaf access — the snapshot owns that invariant at construction time.

On the Textarea backend the snapshot borrows live lines (no clone) and the cursor is already in-bounds. On the Nvim backend the lines are cloned out from behind the Mutex (same cost as today’s render path) and the cursor row is clamped to lines.len() - 1 before the snapshot is returned.

Production hot paths that also need &mut self.view (notably render) must instead inline the snapshot via snapshot_from_backend(&self.backend, self.content_revision) so the borrow checker can split the borrows across distinct fields.

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

pub fn get_text(&self) -> String

pub fn content_revision(&self) -> NonZeroU64

Current content revision. Bumped on every text-mutating handler; stable across cursor moves and idle frames. Used by the autosave path to record “this snapshot was saved” without rebuilding the buffer text on completion. NonZeroU64 makes 0 unrepresentable so callers can express “no revision” as Option<NonZeroU64>::None without a magic-value sentinel.

pub fn mark_saved_at_revision(&mut self, rev: NonZeroU64)

Mark the buffer as clean iff its current revision still matches rev (i.e. no edits landed between the save being issued and completing). Diverged revision → no-op: leave saved_content_rev alone, because some OTHER mechanism (a synchronous try_save racing this completion) may have already marked a NEWER revision clean, and a stale completion must not clobber that. is_dirty already reads true when saved_content_rev != Some(self.content_revision), so doing nothing on a mismatch keeps the editor correctly dirty without overwriting a legitimately-newer saved snapshot.

pub fn mark_saved(&mut self, text: String)

Synchronous mark-saved used by try_save and set_text. Unlike mark_saved_at_revision (which no-ops on a stale revision because it can race a sync mark_saved), this one CLOBBERS saved_content_rev to None when the supplied text diverges: the sync caller holds &mut self for the whole save, so there is no concurrent newer clean state to preserve, and the user typing between get_text() and this call must show as dirty.

pub fn is_dirty(&self) -> bool

pub fn link_at_cursor(&self) -> Option<LinkTarget>

Returns the link or label target under the cursor, or None if the cursor is not inside a wikilink, markdown link, or hashtag span.

pub fn paste_text(&mut self, text: &str, tx: &AppTx)

Inserts text at the cursor, replacing any active selection. When text is a URL (http/https/ftp/ftps/mailto) and a selection is active, the selection is wrapped as a markdown link [selection](url) instead of being replaced by the raw URL.

On the Nvim backend the URL-wrap shortcut is skipped (would require reading the visual selection from nvim) — text is forwarded via nvim_paste, which honours the current mode (insert/normal/visual).

pub fn insert_at_cursor(&mut self, text: &str, tx: &AppTx)

Inserts text at the cursor, replacing any active selection. Routes through nvim_paste on the Nvim backend (delegates to [paste_text] for that case — URL-wrap is a no-op when nothing in the supplied text matches linkable_url, so the two paths are equivalent on Nvim).

pub fn take_clipboard_image(&mut self) -> Option<ClipboardImage>

Snapshot of the system clipboard image, if any. Returns owned RGBA bytes plus the image dimensions. The screen layer is responsible for encoding (e.g. PNG) and persisting via the vault.

pub fn apply_text_action(&mut self, action: TextAction)

Wrap a selection in (or insert at the cursor) markdown markers for Bold/Italic/Strikethrough. No-op for other actions and on the Nvim backend.

pub fn smart_enter(&mut self) -> bool

Smart Enter: continue list markers, preserve indent, dedent on empty indent-only lines, clear empty list markers. Returns true if handled (caller should not insert a plain newline). Always false on Nvim backend or when there is an active selection.

pub fn indent_lines(&mut self, dedent: bool)

Indent or dedent whole lines. Tab unit is \t if hard_tab_indent is on, else tab_length spaces. Dedent counts a leading tab as one unit. No-op on Nvim backend.

impl TextEditorComponent

pub fn open_or_advance_search(&mut self)

Open the find bar; if already open, advance to the next match. No-op on the Nvim backend (which has its own / search). Public so EditorScreen can route the configurable FindInBuffer shortcut here.

pub fn close_autocomplete(&mut self)

Close the autocomplete popup, if any. Cheap; safe on any backend (no-op when autocomplete is None). Use whenever focus moves away from the editor or another overlay takes over key input.

pub fn set_redraw_tx(&mut self, tx: &AppTx)

Bind the redraw channel up front (e.g. on note open) so the background full-parse task can wake the event-driven render loop on the FIRST render of a large buffer, before any keystroke has run handle_input. No-op after the first successful bind.

Trait Implementations

impl Component for TextEditorComponent

fn handle_input(&mut self, event: &InputEvent, tx: &AppTx) -> EventState

Handle an event. Send AppEvents through tx for app-level effects. Returns whether this component consumed the event.

fn render( &mut self, f: &mut Frame<'_>, rect: Rect, theme: &Theme, focused: bool, )

fn hint_shortcuts(&self) -> Vec<(String, String)>

Context-sensitive shortcut hints shown in the hints bar when this component is focused. Each entry is (key_display, label).