Struct TextEditorComponent 

pub struct TextEditorComponent {
    pub wants_context_menu: bool,
    /* 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).

Fields

wants_context_menu: bool

Set by a right-click with no selection: the host (which owns the note path) opens the note’s context menu and clears the flag.

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 cursor_pos(&self) -> (usize, usize)

The cursor’s (row, col) without materialising a snapshot — the Nvim path of view_snapshot clones every buffer line, far too heavy for per-frame consumers that only want the position (status-bar ln/col).

pub fn set_search_needles(&mut self, needles: Vec<String>)

Set the search needles to emphasize in the rendered buffer (the note was opened from a query result). Cleared automatically on the first edit.

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 jump_to_heading(&mut self, heading: &str)

Move the cursor to the first markdown heading line whose text equals heading (any level), e.g. for the OUTLINE drawer’s jump. No-op when the heading is not found, and on the Nvim backend (same policy as Self::indent_lines).

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).