Struct Editor 

pub struct Editor {
    pub tabs: Vec<Tab>,
    pub active: usize,
    pub line_numbers: bool,
    pub relative_line_numbers: bool,
    pub show_whitespace: bool,
    pub soft_wrap: bool,
    pub indent: String,
    pub split_root: Option<Pane>,
    pub focused_leaf: usize,
}

The tab strip: a stack of open buffers and the active index.

Fields

tabs: Vec<Tab>

Open buffers, left to right.

active: usize

Index of the active tab.

line_numbers: bool

Whether the line-number gutter is shown.

relative_line_numbers: bool

Whether line numbers are shown relative to the cursor line.

show_whitespace: bool

Whether visible-whitespace glyphs are shown.

soft_wrap: bool

Whether long lines soft-wrap.

indent: String

String Tab inserts in every buffer (spaces or a tab).

split_root: Option<Pane>

Split layout (a binary tree of panes), when the editor area is divided. None is the normal single-pane case.

focused_leaf: usize

In-order index of the focused leaf within split_root (0 when unsplit).

Implementations

impl Editor

pub fn new( line_numbers: bool, show_whitespace: bool, soft_wrap: bool, indent: String, ) -> Self

Create an editor with one empty buffer and the given gutter / whitespace / soft-wrap / indentation settings.

pub fn active_tab(&self) -> Option<&Tab>

The active tab, if any.

pub fn active_tab_mut(&mut self) -> Option<&mut Tab>

Mutable access to the active tab, if any.

pub fn is_split(&self) -> bool

Whether the editor area is split into more than one pane.

pub fn set_split(&mut self, dir: SplitDir)

Split the focused pane in dir, showing another tab (the next one, else the active tab) in the new pane. Creates the split on the first call; later calls split the currently focused pane. Capped at MAX_LEAVES panes.

pub fn unsplit(&mut self)

Remove the focused pane, collapsing the split; a single remaining pane returns to the unsplit state.

pub fn focus_leaf(&mut self, i: usize)

Focus the leaf at in-order index i, making its tab active.

pub fn focus_other_pane(&mut self)

Move focus to the next pane (wrapping), making its tab active.

pub fn focused_leaf(&self) -> usize

The in-order index of the focused pane.

pub fn split_layout(&mut self, area: Rect) -> Vec<LeafBox>

Lay out the split panes into area (focused leaf synced to active). Empty when unsplit.

pub fn split_dividers(&self, area: Rect) -> Vec<(SplitDir, Rect)>

The split divider rectangles for drawing, given the editor area.

pub fn focus_pane_at(&mut self, area: Rect, col: u16, row: u16) -> bool

Focus the pane under (col, row) within area; returns whether a pane was hit.

pub fn resize_split_at(&mut self, area: Rect, col: u16, row: u16) -> bool

Drag a split divider under (col, row) within area; returns whether one was resized.

pub fn new_tab(&mut self)

Create an empty untitled buffer and focus it.

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

Open a new untitled tab pre-filled with content (e.g. AI output), marked dirty so the user is reminded to save it. Becomes the active tab.

pub fn open_image(&mut self, path: &Path, proto: StatefulProtocol)

Open an image file in a tab, rendered with the given protocol.

pub fn refresh_line_numbers(&mut self)

Apply the current line-number settings (visibility + relative) to every buffer.

pub fn refresh_whitespace(&mut self)

Apply the current visible-whitespace setting to every buffer.

pub fn refresh_soft_wrap(&mut self)

Apply the current soft-wrap setting to every buffer.

pub fn refresh_theme(&mut self)

Re-apply the current theme’s styles to every buffer (after a theme switch).

pub fn open(&mut self, path: &Path, preview: bool) -> Result<()>

Open a file: focus it if already open, otherwise load it. preview requests an ephemeral tab that the next preview reuses.

Errors

Returns an error if the file cannot be read.

pub fn reload_clean_from_disk(&mut self) -> usize

Reload every clean (non-dirty) file-backed buffer from disk, preserving the cursor where it still fits. Used after an external change to the working tree (e.g. a git branch switch). Dirty buffers are left untouched so unsaved edits are never discarded. Returns the number of buffers reloaded.

pub fn promote_active(&mut self)

Promote the active preview tab to a permanent tab.

pub fn save_active(&mut self, opts: SaveOptions) -> Result<PathBuf>

Save the active buffer to its existing path.

Errors

Returns an error if the buffer has no path, or the write fails.

pub fn save_active_as( &mut self, path: PathBuf, opts: SaveOptions, ) -> Result<PathBuf>

Save the active buffer to path and adopt it as the buffer’s path.

Errors

Returns an error if the write fails.

pub fn close_active(&mut self) -> Option<PathBuf>

Close the active tab; keeps at least one empty buffer open. Returns the closed tab’s file path, if it had one (for “reopen closed tab”).

pub fn close_all(&mut self) -> Vec<PathBuf>

Close every tab, leaving a single empty untitled buffer. Returns the file paths of the closed tabs, oldest first (for “reopen closed tab”).

pub fn next_tab(&mut self)

Activate the next tab, wrapping around.

pub fn prev_tab(&mut self)

Activate the previous tab, wrapping around.

pub fn cursor_1based(&self) -> (usize, usize)

1-based (line, column) of the active cursor, for the status bar.

pub fn active_line_count(&self) -> usize

Total line count of the active buffer (for the scrollbar).

pub fn goto(&mut self, line: usize, col: Option<usize>, area: Rect)

Jump the active buffer to a 1-based line and optional 1-based column, keeping the target visible within area. The line is clamped to the buffer’s range (an out-of-range line would otherwise panic).

pub fn cursor_line_home(&mut self)

Move the active cursor to the start of its current line. Smart Home: jump to the first non-blank character of the line; if already there (or the line is blank), jump to column 0. Pressing Home repeatedly toggles between the two.

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

Move the active cursor to the very start of the buffer and scroll it into area.

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

Move the active cursor to the very end of the buffer (past the last character) and scroll it into area.

pub fn cursor_line_end(&mut self)

Move the active cursor to the end of its current line.

pub fn cursor_line_start(&mut self)

Move the active cursor to column 0 of its current line (the literal line start, unlike the smart-Home cursor_line_home).

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

Move the active cursor to the first line of the current paragraph and scroll it into area. Paragraphs are delimited by blank (empty or whitespace-only) lines; from a blank line, climbs to the paragraph above.

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

Move the active cursor to the end of the last line of the current paragraph and scroll it into area. See [cursor_paragraph_start].

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

Move the active cursor to the first line of the current section and scroll it into area. Sections are delimited by a run of two or more consecutive blank lines (a larger break than a paragraph).

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

Move the active cursor to the end of the last line of the current section and scroll it into area. See [cursor_section_start].

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

Move the active cursor down one line (Go → Line → Next).

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

Move the active cursor up one line (Go → Line → Previous).

pub fn cursor_line(&self) -> usize

0-based line of the active cursor (0 when there is no buffer).

pub fn poll_parse(&mut self) -> bool

Install any completed background reparse for the active buffer (large files). Returns true if the syntax tree changed (request a redraw).

pub fn parse_pending(&self) -> bool

Whether a background reparse is in flight for the active buffer.

pub fn switch_undo_branch(&mut self) -> bool

Cycle which undo-tree branch the next redo follows in the active buffer. Returns true if the current state has more than one branch.

pub fn top_visible_line(&self) -> usize

The 0-based index of the active buffer’s first visible line (vertical scroll offset), or 0 when there is no buffer.

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

Set the passive word-occurrence marks on the active buffer.

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

Move to the start of the next paragraph (Go → Paragraph → Next).

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

Move to the start of the previous paragraph (Go → Paragraph → Previous).

pub fn goto_paragraph(&mut self, n: usize, area: Rect)

Jump to the 1-based nth paragraph (Go → Paragraph → Number).

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

Move to the start of the next section (Go → Section → Next).

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

Move to the start of the previous section (Go → Section → Previous).

pub fn goto_section(&mut self, n: usize, area: Rect)

Jump to the 1-based nth section (Go → Section → Number).

pub fn goto_offset(&mut self, off: usize, area: Rect)

Move the active cursor to char offset off and scroll it into view. Move the active cursor to char offset off and scroll it into view.

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

Move to the start of the current sentence (Go → Sentence → Start).

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

Move to the end of the current sentence — its last non-blank char (Go → Sentence → End).

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

Move to the start of the next sentence (Go → Sentence → Next).

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

Move to the start of the previous sentence (Go → Sentence → Previous).

pub fn goto_sentence(&mut self, n: usize, area: Rect)

Jump to the 1-based nth sentence (Go → Sentence → Number).

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

Move to the start of the current word — or the previous word’s start if the cursor is not on a word (Go → Word → Start).

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

Move to the end of the current word (Go → Word → End).

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

Move to the start of the next word (Go → Word → Next).

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

Move to the start of the previous word (Go → Word → Previous).

pub fn goto_word(&mut self, n: usize, area: Rect)

Jump to the 1-based nth word (Go → Word → Number).

pub fn goto_percent(&mut self, pct: usize, area: Rect)

Jump to pct% through the file (by line), clamped to 0..=100.

pub fn goto_byte(&mut self, byte: usize, area: Rect)

Jump to the character at byte offset byte (clamped to the buffer end).

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

Select the current line, including its trailing newline (so it can be cut as a whole line), and scroll it into area.

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

Select the whole paragraph under the cursor (blank-line delimited) and scroll it into area.

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

Select the whole section under the cursor (delimited by runs of two or more blank lines) and scroll it into area.

pub fn insert_str(&mut self, text: &str, area: Rect) -> bool

Insert text at the active buffer’s cursor and scroll it into area. Returns whether the text was inserted (false when there is no editable buffer, e.g. an image tab). Marks the buffer dirty and promotes a preview.

pub fn select_all(&mut self)

Select the entire active buffer.

pub fn duplicate_line(&mut self)

Duplicate the cursor line (or the selection) in the active buffer.

pub fn join_lines(&mut self)

Join the active buffer’s current line with the next (or all selected lines into one).

pub fn sort_lines(&mut self)

Sort the active buffer’s selected lines ascending, or the whole buffer when nothing is selected.

pub fn trim_trailing_whitespace(&mut self)

Strip trailing whitespace from the selected lines (or the whole buffer).

pub fn remove_duplicate_lines(&mut self)

Remove duplicate lines in the selection (or the whole buffer).

pub fn reverse_lines(&mut self)

Reverse the order of the selected lines (or the whole buffer).

pub fn sort_unique(&mut self)

Sort the selected lines ascending and drop duplicates (or the whole buffer).

pub fn shuffle_lines(&mut self)

Randomly reorder the selected lines (or the whole buffer).

pub fn move_line(&mut self, down: bool, area: Rect)

Move the active buffer’s cursor line up or down by one row, scrolling it into area.

pub fn select_word(&mut self, forward: bool, area: Rect)

Extend the selection by one word: forward grows the active end to the next word boundary on the right (“Select More”), otherwise to the previous word boundary on the left (“Select Less”).

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

Jump the cursor to the partner of the bracket at (or just before) it, scrolling it into area. No-op when the cursor is not on a bracket.

pub fn delete_forward(&mut self)

Forward-delete (the Delete key): step right, then delete back.

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

Move the cursor up by lines (PageUp).

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

Move the cursor down by lines (PageDown).

Trait Implementations

impl Default for Editor

fn default() -> Self

Returns the “default value” for a type.