Struct CodeEditor 

pub struct CodeEditor { /* private fields */ }

Represents the text editor, which holds the code buffer, cursor, selection, theme, scroll offsets, highlight cache, clipboard, and user mark intervals.

Implementations

impl Editor

pub fn new( lang: &str, text: &str, theme: Vec<(&str, &str)>, ) -> Result<Editor, Error>

Create an editor for the given language, text, and syntax theme.

Errors

Returns an error when neither the requested language grammar nor the text fallback grammar can be loaded.

pub fn new_with_highlights( lang: &str, text: &str, theme: Vec<(&str, &str)>, custom_highlights: Option<HashMap<String, String>>, ) -> Result<Editor, Error>

Create an editor with optional custom highlight overrides.

Errors

Returns an error when neither the requested language grammar nor the text fallback grammar can be loaded.

pub fn set_text_style(&mut self, style: Style)

Set the style for ordinary text (the foreground of unhighlighted code).

pub fn set_line_number_style(&mut self, style: Style)

Set the style for the line-number gutter.

pub fn set_relative_line_numbers(&mut self, on: bool)

Enable or disable relative (hybrid) line numbering.

pub fn set_cursor_style(&mut self, style: Option<Style>)

Set the block-cursor style. Pass Some(style) to draw a visible cursor cell (its bg is the cursor color), or None to draw no cursor.

pub fn set_syntax_theme(&mut self, theme: &[(&str, &str)])

Replace the syntax-highlight theme (token name -> #rrggbb) and drop the cached highlights so the new colors take effect on the next render.

pub fn set_selection_style(&mut self, style: Style)

Set the style applied to the active selection.

pub fn focus(&mut self, area: &Rect)

Scroll the viewport so the cursor is visible within area.

pub fn handle_mouse_down(&mut self, cursor: usize)

Handles a mouse button press at the given cursor position, updating selection and click state.

pub fn handle_mouse_drag(&mut self, cursor: usize)

Handles a mouse drag event at the given cursor position, extending the selection.

pub fn cursor_from_mouse( &self, mouse_x: u16, mouse_y: u16, area: &Rect, ) -> Option<usize>

Converts mouse coordinates to a cursor position within the editor area, returning None if outside.

pub fn clear_selection(&mut self)

Clears any active selection.

pub fn extend_selection(&mut self, new_cursor: usize)

Extends or starts a selection from the current cursor to new_cursor.

pub fn selection_anchor(&self) -> usize

Returns the selection anchor position, or the cursor if no selection exists.

pub fn apply<A>(&mut self, action: A)

where A: Action,

Apply an editing action to the buffer.

pub fn set_content(&mut self, content: &str)

Replace the entire buffer contents with content as a single undo step.

pub fn apply_batch(&mut self, batch: &EditBatch)

Apply a batch of edits as a single undo step.

pub fn set_cursor(&mut self, cursor: usize)

Move the cursor to the given char offset, clamped to the buffer. Clears the vertical-movement goal column; line up/down re-establish it afterward.

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

Select the range [anchor, cursor), putting the caret at cursor. An empty range (anchor == cursor) just clears the selection.

pub fn fit_cursor(&mut self)

Clamp the cursor so it stays within the buffer and its current line.

pub fn scroll_up(&mut self)

Scroll the viewport up one line.

pub fn scroll_down(&mut self, area_height: usize)

Scroll the viewport down one line, bounded by the last line.

pub fn get_content(&self) -> String

Return the entire buffer contents as an owned string.

pub fn get_content_slice(&self, start: usize, end: usize) -> String

Return the text of the char range [start, end) as an owned string.

pub fn get_cursor(&self) -> usize

Return the cursor’s char offset.

pub fn cursor_line(&self) -> usize

The 0-based line (row) the cursor is on.

pub fn comment_prefix(&self) -> String

The line-comment prefix for this buffer’s language (e.g. // or #).

pub fn set_cursor_line(&mut self, line: usize)

Move the cursor to the start of 0-based line (clamped to the buffer) and clear any selection.

pub fn set_clipboard(&mut self, text: &str) -> Result<(), Error>

Set the clipboard text, falling back to an in-memory clipboard when the system clipboard is unavailable.

Errors

Currently always returns Ok; the system-clipboard failure path falls back to the in-memory clipboard.

pub fn get_clipboard(&self) -> Result<String, Error>

Return the clipboard text, preferring the system clipboard and falling back to the in-memory clipboard.

Errors

Returns an error when neither the system nor in-memory clipboard has text.

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

Insert text at the cursor as one edit — one undo step — replacing the selection if there is one and re-indenting the pasted block to the cursor’s level (see Code::smart_paste).

Shared by the Paste action, which pastes the clipboard, and the host’s bracketed-paste handler, which pastes the text the terminal hands over. Going through one path is what keeps a terminal paste undoable in a single step: replayed as individual key events it would leave one undo entry per character.

pub fn set_marks(&mut self, marks: Vec<(usize, usize, &str)>)

Set the highlight marks as (start char, end char, hex color) ranges.

pub fn marks(&self) -> Option<&Vec<(usize, usize, Color)>>

The current highlight marks (search matches and similar), as (start char, end char, color) ranges, if any.

pub fn remove_marks(&mut self)

Clear all highlight marks.

pub fn set_fold_ranges(&mut self, ranges: Vec<(usize, usize)>)

Record the foldable line ranges reported by the language server. Drops any active fold whose range is no longer offered.

pub fn toggle_fold(&mut self, line: usize) -> bool

Toggle the fold whose start is line: unfold it if folded, else fold it if a foldable range starts there. Returns true if anything changed.

pub fn toggle_manual_fold(&mut self, start: usize, end: usize) -> bool

Toggle a fold over the explicit inclusive (start, end) line range, without a language server having reported it — used for Org drawer folding, where the range is computed on the fly. Folds the range if it is open, unfolds it if already folded, keeping the caret out of the hidden region. Returns true if the fold state changed (always, unless the range is empty). The folded start line renders the ▸ marker and a trailing ..., matching code folding.

pub fn is_line_hidden(&self, line: usize) -> bool

Whether line is hidden inside a currently-folded range (start < line <= end).

pub fn has_folds(&self) -> bool

Whether any fold is currently active.

pub fn fold_all(&mut self)

Fold every foldable range.

pub fn unfold_all(&mut self)

Unfold every active fold.

pub fn set_inlay_hints(&mut self, hints: Vec<(usize, usize, String)>)

Set the inline hints to display: (line, char column within line, label).

pub fn set_semantic_tokens(&mut self, tokens: Vec<(usize, usize, String)>)

Replace the LSP semantic-token overlay (T123a): (start char, end char, theme capture name) spans, merged into Tree-sitter’s own highlighting at render time (draw_syntax_layer).

pub fn has_inlay_hints(&self) -> bool

Whether any inline hints are set.

pub fn fold_marker(&self, line: usize) -> Option<bool>

The fold marker for line: Some(true) if a folded range starts here, Some(false) if a foldable (but open) range starts here, else None.

pub fn set_spell_marks(&mut self, marks: Vec<(usize, usize)>)

Set the spell-check underline marks (char ranges of misspelled words).

pub fn clear_spell_marks(&mut self)

Clear all spell-check underline marks.

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

The current spell-check underline marks (char ranges), if any.

pub fn set_word_marks(&mut self, marks: Vec<(usize, usize)>)

Set the passive word-occurrence marks (char ranges); empty clears them.

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

The current word-occurrence marks (char ranges), if any.

pub fn set_diagnostic_marks(&mut self, marks: Vec<(usize, usize, Color)>)

Set the LSP diagnostic underline marks: (start char, end char, color).

pub fn clear_diagnostic_marks(&mut self)

Clear all LSP diagnostic underline marks.

pub fn diagnostic_marks(&self) -> Option<&Vec<(usize, usize, Color)>>

The current LSP diagnostic underline marks, if any.

pub fn set_gutter_marks(&mut self, marks: Vec<(usize, &str)>)

Set the git diff gutter marks: (line index, hex color) per changed line.

pub fn clear_gutter_marks(&mut self)

Clear all git diff gutter marks.

pub fn gutter_marks(&self) -> Option<&Vec<(usize, Color)>>

The current git diff gutter marks (line index, color), if any.

pub fn comment_string_ranges(&self) -> Vec<(usize, usize)>

Char ranges of comment and string tokens in the buffer, for the host’s spell checker to scan. Empty when the language has no Tree-sitter query.

pub fn char_text(&self, start: usize, end: usize) -> String

The text of the char range [start, end) as an owned string.

pub fn word_at(&self, pos: usize) -> Option<(usize, usize, String)>

The word (and its char range) at pos, using the buffer’s word boundaries; None when pos is not inside a word.

pub fn has_marks(&self) -> bool

Whether any highlight marks are set.

pub fn get_marks(&self) -> Option<&Vec<(usize, usize, Color)>>

Return the highlight marks as (start, end, color) ranges, if any.

pub fn get_selection_text(&mut self) -> Option<String>

Return the text of the current selection, or None when empty.

pub fn get_selection(&mut self) -> Option<Selection>

Return the current selection, if any.

pub fn set_selection(&mut self, selection: Option<Selection>)

Set (or clear) the current selection.

pub fn set_offset_y(&mut self, offset_y: usize)

Set the vertical scroll offset (first visible line).

pub fn set_offset_x(&mut self, offset_x: usize)

Set the horizontal scroll offset (first visible column).

pub fn get_offset_y(&self) -> usize

Return the vertical scroll offset (first visible line).

pub fn get_offset_x(&self) -> usize

Return the horizontal scroll offset (first visible column).

pub fn soft_wrap_enabled(&self) -> bool

Whether soft wrap is on (no horizontal scrolling when it is).

pub fn gutter_width(&self) -> usize

Width (columns) of the line-number gutter, so the host can compute the visible text width for a horizontal scrollbar.

pub fn max_line_width(&self) -> usize

The longest line’s width in characters (used to size a horizontal scrollbar). A tab counts as one character.

pub fn code_mut(&mut self) -> &mut Code

Return a mutable reference to the underlying code buffer.

pub fn code_ref(&self) -> &Code

Return a shared reference to the underlying code buffer.

pub fn top_line(&self) -> usize

The 0-based index of the first visible line (the vertical scroll offset).

pub fn poll_parse(&mut self) -> bool

Install any completed background reparse (large buffers). Returns true when the syntax tree was updated, so the host can redraw.

pub fn parse_pending(&self) -> bool

Whether a background reparse is in flight for this buffer.

pub fn switch_undo_branch(&mut self) -> bool

Cycle which undo-tree branch the next redo will follow. Returns true when the current state has more than one branch.

pub fn revision(&self) -> u64

A counter that increases on every content edit, for cheap change detection (e.g. deciding when to push a didChange to a language server).

pub fn language(&self) -> &str

The buffer’s language identifier (e.g. "rust", "text").

pub fn line_ending(&self) -> &'static str

The buffer’s line ending: "LF" or "CRLF".

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

The current selection as a sorted (start, end) char range, or None when there is no (non-empty) selection.

pub fn set_change_callback( &mut self, callback: Box<dyn Fn(Vec<(usize, usize, usize, usize, String)>)>, )

Set the change callback function for handling document changes

pub fn highlight_interval( &self, start: usize, end: usize, theme: &HashMap<String, Style>, ) -> Vec<(usize, usize, Style)>

Return cached syntax highlights for the char range [start, end).

pub fn reset_highlight_cache(&self)

Clear the cached syntax highlights so they are recomputed on next render.

pub fn get_visible_cursor(&self, area: &Rect) -> Option<(u16, u16)>

Compute the cursor’s visible (x, y) cell within area, or None when the cursor is scrolled out of view.

pub fn show_line_numbers(&mut self, show: bool)

Show or hide the line-number gutter.

pub fn toggle_line_numbers(&mut self) -> bool

Toggle the line-number gutter; returns the new visibility.

pub fn show_whitespace(&mut self, show: bool)

Show or hide visible-whitespace glyphs (space, tab, line ending).

pub fn set_auto_pair(&mut self, on: bool)

Enable or disable bracket/quote auto-pairing.

pub fn set_rainbow_brackets(&mut self, on: bool)

Enable or disable rainbow (depth-colored) brackets.

pub fn set_eol_note(&mut self, note: Option<(usize, String)>)

Set (or clear with None) the end-of-line virtual note: (line, text) drawn dimmed after that line’s content. Used for inline git blame.

pub fn set_breakpoints(&mut self, lines: Vec<usize>)

Set the debugger breakpoint lines (0-based) drawn in the gutter.

pub fn set_debug_line(&mut self, line: Option<usize>)

Set (or clear) the debugger’s currently-stopped line (0-based).

pub fn set_soft_wrap(&mut self, on: bool)

Enable or disable soft wrap (long lines wrap instead of scrolling).

pub fn toggle_soft_wrap(&mut self) -> bool

Toggle soft wrap; returns the new state.

pub fn set_indent(&mut self, indent: Option<String>)

Set the indent string inserted by Tab / the Indent action (spaces or a tab). None restores the per-language default.

pub fn toggle_whitespace(&mut self) -> bool

Toggle visible-whitespace glyphs; returns the new visibility.

pub fn set_whitespace_style(&mut self, style: Style)

Set the style used for visible-whitespace glyphs (typically dimmed).

pub fn set_bracket_style(&mut self, style: Style)

Set the style used to highlight the bracket matching the one at the cursor.

pub fn set_left_code_padding(&mut self, char_count: usize)

Set the left padding (in characters) between the gutter and the code.

impl Editor

pub fn input(&mut self, key: KeyEvent, area: &Rect) -> Result<(), Error>

Handle a crossterm key event, then scroll to keep the cursor visible.

Errors

Returns an error when an applied action fails.

pub fn mouse(&mut self, mouse: MouseEvent, area: &Rect) -> Result<(), Error>

Handle a crossterm mouse event (scroll, click, drag, selection).

Errors

Returns an error when an applied action fails.

pub fn autoscroll_tick(&mut self, area: &Rect) -> bool

Repeat the last drag while the pointer is held still outside the top or bottom edge (T581). Call periodically; a no-op when no drag is in progress or the pointer is inside the view. Returns whether it acted.

impl Editor

pub fn has_multi_carets(&self) -> bool

Whether more than one caret is active.

pub fn clear_carets(&mut self)

Drop all extra carets, keeping just the primary cursor.

pub fn caret_selections(&self) -> Vec<(usize, usize)>

Selection ranges for every caret (primary + extras), for rendering.

pub fn caret_positions(&self) -> Vec<usize>

Cursor offsets for every caret (primary + extras), for rendering.

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

Insert text at every caret (replacing each selection), as one undo step. Carets are processed in ascending order with a running offset shift, so each edit’s coordinates stay valid in the live buffer.

Panics

Never in practice: the running shift only ever reflects text‘s length and prior carets’ removed spans, both bounded by the buffer this same call is editing, so the isize conversion cannot overflow.

pub fn multi_delete(&mut self, forward: bool)

Delete at every caret (each selection, else one char), as one undo step.

Panics

Never in practice: same bound as Self::multi_insert — the running shift only ever reflects removed spans within the buffer this same call is editing, so the isize conversion cannot overflow.

pub fn multi_move(&mut self, dir: CaretMove, shift: bool)

Move every caret in dir (extending its selection when shift).

pub fn add_next_occurrence(&mut self)

Ctrl+D: select the next occurrence of the current selection (or the word at the cursor) and add it as a new caret, which becomes primary.

pub fn add_all_occurrences(&mut self)

Select every occurrence of the current selection (or the word at the cursor) in the buffer: replace any existing extra carets with one selected caret per match, the last of which becomes primary. No-op when there is only a single match.

pub fn add_caret_at(&mut self, pos: usize)

Alt+click: add an extra caret at character offset pos.

pub fn add_caret_above(&mut self)

Add a caret on the line above the main cursor, at the same column (clamped to that line’s length). No-op on the first line.

pub fn add_caret_below(&mut self)

Add a caret on the line below the main cursor, at the same column (clamped to that line’s length). No-op on the last line.

pub fn column_select(&mut self, down: bool)

Extend a column (rectangular) selection by one line: add a caret on the line past the current block frontier, spanning the same columns as the primary caret’s selection (or a bare caret when there is no selection). Columns clamp to each line’s length. No-op at the buffer’s top/bottom. The resulting carets edit together via Editor::multi_insert etc.

impl Editor

pub fn cursor_up(&mut self)

Move the cursor up one line.

pub fn cursor_down(&mut self)

Move the cursor down one line.

pub fn cursor_left(&mut self)

Move the cursor one character to the left.

pub fn cursor_right(&mut self)

Move the cursor one character to the right.

pub fn select_up(&mut self)

Extend the selection one line up.

pub fn select_down(&mut self)

Extend the selection one line down.

pub fn select_left(&mut self)

Extend the selection one character to the left.

pub fn select_right(&mut self)

Extend the selection one character to the right.

pub fn cursor_start(&mut self)

Move the cursor to the very start of the buffer.

pub fn cursor_end(&mut self)

Move the cursor to the very end of the buffer.

pub fn select_to_start(&mut self)

Extend the selection to the start of the buffer.

pub fn select_to_end(&mut self)

Extend the selection to the end of the buffer.

pub fn start_of_line(&mut self)

Move the cursor to the start of the current line.

pub fn end_of_line(&mut self)

Move the cursor to the end of the current line.

pub fn start_of_text(&mut self)

Move to the first non-whitespace character of the line.

pub fn start_of_text_toggle(&mut self)

Toggle between the first non-whitespace character and column 0.

pub fn select_to_start_of_line(&mut self)

Extend the selection to the start of the current line.

pub fn select_to_end_of_line(&mut self)

Extend the selection to the end of the current line.

pub fn select_to_start_of_text(&mut self)

Extend the selection to the first non-whitespace character of the line.

pub fn select_to_start_of_text_toggle(&mut self)

Extend the selection, toggling between the first non-whitespace character and column 0.

pub fn select_line(&mut self)

Select the whole current line (including its trailing newline if any).

pub fn word_right(&mut self)

Move the cursor to the start of the next word.

pub fn word_left(&mut self)

Move the cursor to the start of the previous word.

pub fn sub_word_right(&mut self)

Move the cursor right by one sub-word (approximated as a whole word).

pub fn sub_word_left(&mut self)

Move the cursor left by one sub-word (approximated as a whole word).

pub fn select_word_right(&mut self)

Extend the selection to the start of the next word.

pub fn select_word_left(&mut self)

Extend the selection to the start of the previous word.

pub fn select_sub_word_right(&mut self)

Extend the selection right by one sub-word (approximated as a whole word).

pub fn select_sub_word_left(&mut self)

Extend the selection left by one sub-word (approximated as a whole word).

pub fn delete_word_right(&mut self)

Delete from the cursor to the start of the next word.

pub fn delete_word_left(&mut self)

Delete from the cursor back to the start of the previous word.

pub fn delete_sub_word_right(&mut self)

Delete the next sub-word (approximated as a whole word).

pub fn delete_sub_word_left(&mut self)

Delete the previous sub-word (approximated as a whole word).

pub fn paragraph_next(&mut self)

Move the cursor to the start of the next paragraph.

pub fn paragraph_previous(&mut self)

Move the cursor to the start of the previous paragraph.

pub fn select_to_paragraph_next(&mut self)

Extend the selection to the start of the next paragraph.

pub fn select_to_paragraph_previous(&mut self)

Extend the selection to the start of the previous paragraph.

pub fn page_up(&mut self, view_h: usize)

Move the cursor up one page (the viewport height).

pub fn page_down(&mut self, view_h: usize)

Move the cursor down one page (the viewport height).

pub fn select_page_up(&mut self, view_h: usize)

Extend the selection up one page (the viewport height).

pub fn select_page_down(&mut self, view_h: usize)

Extend the selection down one page (the viewport height).

pub fn half_page_up(&mut self, view_h: usize)

Move the cursor up half a page.

pub fn half_page_down(&mut self, view_h: usize)

Move the cursor down half a page.

pub fn center(&mut self, view_h: usize)

Center the viewport on the cursor line.

pub fn cursor_to_view_top(&mut self)

Move the cursor to the top/center/bottom visible line, keeping its column.

pub fn cursor_to_view_center(&mut self, view_h: usize)

Move the cursor to the center visible line, keeping its column.

pub fn cursor_to_view_bottom(&mut self, view_h: usize)

Move the cursor to the bottom visible line, keeping its column.

pub fn insert_newline(&mut self)

Insert a newline at the cursor.

pub fn insert_tab(&mut self)

Insert a tab (indent) at the cursor.

pub fn backspace(&mut self)

Delete the character before the cursor.

pub fn delete(&mut self)

Forward delete (the character at the cursor).

pub fn undo(&mut self)

Undo the last edit.

pub fn redo(&mut self)

Redo the last undone edit.

pub fn copy(&mut self)

Copy the selection to the clipboard.

pub fn cut(&mut self)

Cut the selection to the clipboard.

pub fn paste(&mut self)

Paste the clipboard at the cursor.

pub fn select_all(&mut self)

Select the entire buffer.

pub fn duplicate(&mut self)

Duplicate the selection (or current line).

pub fn duplicate_line(&mut self)

Duplicate the current line.

pub fn delete_line(&mut self)

Delete the current line.

pub fn indent_line(&mut self)

Indent the current line.

pub fn outdent_line(&mut self)

Outdent the current line.

pub fn indent_selection(&mut self)

Indent the selection.

pub fn outdent_selection(&mut self)

Outdent the selection.

pub fn copy_line(&mut self)

Copy the current line to the clipboard (without changing the selection).

pub fn cut_line(&mut self)

Cut the current line to the clipboard.

pub fn deselect(&mut self)

Drop the selection, keeping the cursor.

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

Insert literal text (used by paste-primary fallbacks/tests).

impl Editor

pub fn matching_bracket_offset(&self) -> Option<usize>

Public accessor for the matching bracket offset, used by the host to jump the cursor to a bracket’s partner (Ctrl+] / the palette).

impl Editor

pub fn move_line_up(&mut self)

Move the cursor’s line up one row, swapping it with the line above. No-op on the first line. Records one undoable edit and keeps the cursor on the moved line.

pub fn move_line_down(&mut self)

Move the cursor’s line down one row, swapping it with the line below. No-op on the last line. Records one undoable edit and keeps the cursor on the moved line.

pub fn join_lines(&mut self)

Join the current line with the next, or — when the selection spans several lines — join all of them into one. Adjacent lines are merged with a single space, trimming the trailing space of each line and the leading space of the next. Records one undoable edit. No-op when there is nothing to join (a single line with no line below it).

pub fn sort_lines(&mut self)

Sort the selected lines ascending (byte order), or the whole buffer when nothing is selected. Records one undoable edit. No-op on fewer than two lines in range.

pub fn trim_trailing_whitespace(&mut self)

Strip trailing whitespace from each line in range (selection, or the whole buffer when nothing is selected).

pub fn remove_duplicate_lines(&mut self)

Remove duplicate lines in range, keeping the first occurrence of each.

pub fn reverse_lines(&mut self)

Reverse the order of the lines in range.

pub fn shuffle_lines(&mut self)

Randomly reorder the lines in range (Fisher–Yates, seeded from the OS).

pub fn sort_unique(&mut self)

Sort the lines in range ascending and drop duplicates.

Trait Implementations

impl Widget for &Editor

Draws the main editor view in the provided area using the ratatui rendering buffer.

Renders the main editor view in four distinct layers:

1. Line numbers and text content are drawn in the visible viewport.
2. Syntax highlighting is overlaid on top of the text.
3. The selection highlight is rendered above the syntax layer.
4. User marks are rendered as the final uppermost overlay.

Arguments

• self - The Editor instance (as reference) to render.
• area - The rectangular area on the terminal to draw within.
• buf - The ratatui Buffer that represents the screen cells to draw to.

fn render(self, area: Rect, buf: &mut Buffer)

Draws the current state of the widget in the given buffer. That is the only method required to implement a custom widget.