Struct MarkdownEditorView 

pub struct MarkdownEditorView {
    pub layout: Layout,
    pub text_snapshot: Text,
    pub cursor_snapshot: (usize, usize),
    pub last_cursor_screen: Option<(u16, u16)>,
    /* private fields */
}

Fields

layout: Layout

text_snapshot: Text

The text the caches below were built from.

Held rather than borrowed because render runs without the frame’s snapshot in scope. Keeping it costs nothing: a Text clone shares its structure, so this is the same text rather than a copy of it — which is why the twenty lines that used to copy changed rows into a Vec<String> are now one assignment.

cursor_snapshot: (usize, usize)

last_cursor_screen: Option<(u16, u16)>

Cursor’s last on-screen position (col, row), or None when the cursor was scrolled off-screen or the view was unfocused at the time of the previous render. Used as the anchor for floating overlays like the autocomplete popup, which is drawn after the editor itself.

Implementations

impl MarkdownEditorView

pub fn new() -> Self

pub fn last_parse_was_incremental(&self) -> bool

Returns Some(generation) if Gate 1 just installed a placeholder ParsedBuffer and the owning component should spawn a background full parse for this generation. Consumes the flag so the owner does not spawn twice; the owner is responsible for calling install_full_parse when the task completes. Whether the most recent Gate 1 invocation took the incremental splice path. Read-only diagnostic for the incremental-parse property tests (tui/tests/incremental_property.rs); not part of the production render path.

pub fn take_pending_full_parse(&mut self) -> Option<u64>

pub fn install_full_parse(&mut self, generation: u64, buf: ParsedBuffer)

Install the result of a background full parse. No-op when the editor has advanced past generation — that result is stale and a fresh spawn is already in flight. Invalidates the layout + rendered_cache so the next update() rebuilds Gate 2 against the fresh ParsedBuffer.

pub fn take_pending_full_layout(&mut self) -> Option<PendingLayoutJob>

Returns Some(job) if Gate 2 just installed a Layout::unwrapped stub and the owning component should spawn a background Layout::compute for it. Consumes the flag so the owner does not spawn twice; the owner is responsible for calling install_full_layout when the task completes.

pub fn install_full_layout(&mut self, generation: u64, layout: Layout)

Install the result of a background Layout::compute. No-op when the editor has advanced past generation (a fresh spawn is already in flight — mirrors install_full_parse’s staleness gate) or when the pane was resized since the job was captured (layout.width() no longer matches last_layout_width — a generation match alone cannot catch this, since a resize with no content change never bumps content_revision).

pub fn set_overlays(&mut self, overlays: Vec<Overlay>)

Hand the view this frame’s overlays, in logical coordinates. Must be called after update, which clears them.

The view appends the two kinds it derives itself — task decorations and needle emphasis. Those come from the lines it already holds, and it is the only thing that knows which rows are visible, so scanning them anywhere else would mean shipping the viewport outward.

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

Vault-search needles to emphasise. Sticky across frames, unlike overlays: they come from the query that opened the note.

pub fn clear_visual_goal(&mut self)

Declare that the edit just performed was a bulk one — it changed rows the cursor does not point at.

compute_damage_range’s fast path trusts the cursor row to be the only edited row and will otherwise under-report the damage, leaving distant rows rendered from a stale parse. Every edit that rewrites more than the cursor’s neighbourhood must call this. Forget where a run of ↑/↓ was aiming. Any other cursor movement ends it.

pub fn move_cursor_visually( &mut self, buf: &mut RopeBuffer, down: bool, extend: bool, ) -> bool

Move the cursor one drawn line, which is what an arrow key means in a wrapped editor: one press moves one line the reader can see, not past the whole remainder of a soft-wrapped paragraph.

Lives on the view because only the view has the layout — the buffer holds the text and the cursor, and neither alone can answer “which line is this drawn on”. That split is exactly why the incumbent could not do this.

Returns false when the layout does not describe the buffer’s current text — an edit lands before the frame that re-lays it out — and the caller falls back to a logical move rather than reading a stale layout.

pub fn note_damage(&mut self, rows: Range<usize>, line_delta: isize)

Record which rows an edit changed, for the next update to act on.

line_delta is what this edit did to the row count. Several edits can land between two frames, and a range recorded before one of them that moved rows no longer means what it said — so the accumulated hull is brought into the new numbering first. This matters more than it used to: the layout now patches across a line-count change rather than rebuilding, so an under-reported hull leaves rows wrapped as they used to be.

pub fn note_bulk_edit(&mut self)

pub fn update(&mut self, snap: &EditorSnapshot, rect: Rect)

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

pub fn parsed_buffer_kinds(&self) -> &[LineConstructKind]

Test accessor: the kinds vector of the current parsed buffer. Used by the proptest harness to assert incremental = full parse.

pub fn parsed_buffer_lines(&self) -> &[ParsedLine]

Test accessor: the parsed lines of the current parsed buffer.

pub fn click_at_screen( &self, screen_row: usize, screen_col: usize, ) -> (u16, u16)

Markdown-aware mouse click: maps a rendered screen column to the correct logical column, accounting for hidden markdown sigils (links, bold markers, etc.).

Reads self’s view-internal caches (layout, lines_snapshot, parsed_buffer), all rebuilt from the same EditorSnapshot in the last update() call. The snapshot invariant guarantees vl.logical_row is a valid index into both lines_snapshot and parsed_buffer.lines, so direct indexing is safe — the previous defensive (Some, Some) else fallback block (Fix #2 in the holistic review) is no longer needed. Map a screen-relative click (row/col offset from the editor’s top-left corner) to logical (row, col). Owns the visual-scroll-offset arithmetic so callers do not reach into visual_scroll_offset — the view knows where it is scrolled.

Trait Implementations

impl Clone for MarkdownEditorView

fn clone(&self) -> MarkdownEditorView

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for MarkdownEditorView

fn default() -> Self

Returns the “default value” for a type.