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 text(&self) -> Text

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. The open note’s text. Empty for the nvim backend, which owns its own.

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.revs.current()) 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 the saved snapshot 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 the saved snapshot mismatches the current 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 the saved snapshot 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 space_leads(&self) -> bool

Whether a bare Space should start the leader (vim Normal mode only). Returns false for the direct textarea backend, the nvim backend, vim Insert/Visual modes, and any pending state.

A pure vim-mode fact. It used to also return false while the find bar was open — the bar’s claim smuggled through the nearest differently named field, because the snapshot had nowhere to put it. That is now Self::claim’s job.

pub fn mouse_drives_cursor(&self) -> bool

Whether a press in this editor moves the cursor to the cell under it.

False on the nvim backend, where the terminal and nvim own the mouse: this component’s handle_mouse returns NotConsumed before any jump_to. Anything that treats a click as pointing at something — following a link, most obviously — has to ask this first, or it reads a cursor the click never moved.

pub fn covers(&self, column: u16, row: u16) -> bool

Whether this cell is one this editor would place the cursor on.

Narrower than the editor column, which the panel set hit-tests: the column includes the frame drawn around this component, and self.rect is the interior it was handed at render — minus the find-bar row, which render already excludes. handle_mouse bounds-checks against exactly this and returns NotConsumed outside it, so a press anywhere else leaves the cursor where it was. Callers that read the cursor after a press have to ask, or they read a position the press never set.

pub fn claim(&self) -> EditorClaim

Which editor-internal surface currently holds input.

The find bar outranks the popup because opening the bar closes it (open_or_advance_search), so the two cannot genuinely coexist.

pub fn follow_target_at_cursor(&self) -> Option<FollowTarget>

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)

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 Self::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.

Reads go through the same shared handle as writes — not for ownership (only writes need that) but so there is one connection and one reconnect policy. No flash here: this is a probe run ahead of every Ctrl+V, and “no image on the clipboard” is the ordinary case, not a failure to report.

pub fn take_selection_for_external_paste(&mut self)

Prepare the buffer for content arriving from outside the editor’s own key path — today only the clipboard-image paste, which the screen layer owns because it alone can reach the vault.

Removes the active selection (the incoming content replaces it, as with every other paste) and reconciles the vim engine out of Visual, through the same door the mouse path uses. Without this the engine keeps a mode that the buffer no longer supports: still Visual, selection gone.

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. One step is \t if hard_tab_indent is on, else indent_width spaces. Dedent counts a leading tab as one step. 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. Policy lives here because only the editor knows which backend is active.

pub fn open_replace(&mut self)

Open the find bar with the replace field already revealed, or reveal it on an already-open bar.

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

Viewport post-pass: emphasize search-needle matches (color_search_match, bold) and style task checkboxes — [ ] accent, [x] rows dimmed + struck (spec §5.1). Operates on the rendered buffer rows, so cost is bounded by the visible area regardless of note size.

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