Struct bo::editor::Editor

pub struct Editor {

    should_quit: bool,
    cursor_position: Position,
    document: Document,
    offset: ViewportOffset,
    message: String,
    mode: Mode,
    command_buffer: String,
    command_suggestions: Vec<String>,
    current_autocompletion_index: usize,
    config: Config,
    normal_command_buffer: Vec<String>,
    mouse_event_buffer: Vec<Position>,
    search_matches: Vec<(Position, Position)>,
    current_search_match_index: usize,
    alternate_screen: bool,
    last_saved_hash: u64,
    terminal: Box<dyn Console>,
    unsaved_edits: u8,
    row_prefix_length: u8,
    help_message: String,
    history: History,
}

Fields

should_quit: bool

cursor_position: Position

document: Document

offset: ViewportOffset

message: String

mode: Mode

command_buffer: String

command_suggestions: Vec<String>

current_autocompletion_index: usize

config: Config

normal_command_buffer: Vec<String>

mouse_event_buffer: Vec<Position>

search_matches: Vec<(Position, Position)>

current_search_match_index: usize

alternate_screen: bool

last_saved_hash: u64

terminal: Box<dyn Console>

unsaved_edits: u8

row_prefix_length: u8

help_message: String

history: History

Implementations

impl Editor

pub fn new(filename: Option<String>, terminal: Box<dyn Console>) -> Self

pub fn run(&mut self)

Main screen rendering loop

fn process_event(&mut self) -> Result<(), Error>

Main event processing method. An event can be either be a keystroke or a mouse click

fn process_keystroke(&mut self, pressed_key: Key)

React to a keystroke. The reaction itself depends on the editor mode (insert, command, normal) or whether the editor is currently receiving a user input command (eg: “:q”, etc).

fn process_mouse_event(&mut self, mouse_event: MouseEvent)

React to a mouse event. If the mouse is being pressed, record the coordinates, and

fn enter_insert_mode(&mut self)

Switch the Editor mode to Insert

fn enter_normal_mode(&mut self)

Switch the Editor mode to Normal

fn start_receiving_command(&mut self)

Make the Editor ready to receive a command

fn start_receiving_search_pattern(&mut self)

Make the Editor ready to receive a search pattern

fn stop_receiving_command(&mut self)

Stop receiving a command

fn is_receiving_command(&self) -> bool

Return whether the Editor is currently receiving a command

fn is_autocompleting_command(&self) -> bool

Return whether the Editor is currently autosuggesting command based on the user input

fn reset_autocompletions(&mut self)

Reset the state of the command autocompletion

fn pop_normal_command_repetitions(&mut self) -> usize

fn process_received_command(&mut self)

Receive a command entered by the user in the command prompt and take appropriate actions

fn autocomplete_command(&mut self)

Determine which commands could be autocompleted into based on the current state of the user provided command.

If only one command suggestion is found, it will be automatically selected. Else, the command_suggestions vector will be populated with the possible commands.

fn cycle_through_command_suggestions(&mut self)

Cycle through the possible command suggestions by incrementing (or resetting) the current_autocompletion_index value.

fn save(&mut self, new_name: &str)

Save the current document to the target file.

If no filename is associated to the current document, an error message will be displayed.

When the document is saved, all trailing spaces will automatically be deleted.

fn save_to_swap_file(&mut self)

Save all current unsaved edits to a swap file, allowing a seamless recovery in case of a crash.

fn quit(&mut self, force: bool)

Change the internal state of the Editor to mark it as ready to quit.

If force is set to false and some unsaved edits were made, an error will be displayed in the message bar.

fn process_search_command(&mut self, search_pattern: &str)

Search for the user-provided pattern in the document text, and move the cursor to the first occurence, if any.

fn reset_search(&mut self)

Reset all state related to text search back to the default values.

fn revert_to_main_screen(&mut self)

Revert the editor back to the main screen, containing the document text.

fn process_normal_command(&mut self, key: Key)

Process navigation command issued in normal mode, that will resolve in having the cursor be moved around the document.

Note: some commands are accumulative (ie: 2j will move the cursor down twice) and some are not (ie: g will move the cursor to the start of the document only once). A buffer is maintained for the accumulative commands, and is purged when the last char of the command is received. For now, only commans of the form * are supported and I’m not sure I’m planning to support anything more complex than that.

fn process_normal_command_n_times(&mut self, c: char, n: usize)

Execute the provided normal movement command n timess

fn process_insert_command(&mut self, pressed_key: Key)

Process a command issued when the editor is in normal mode

fn get_row(&self, index: RowIndex) -> Option<&Row>

Return the row located at the provide row index if it exists

fn current_row(&self) -> &Row

Return the Row object associated to the current cursor position / vertical offset

fn current_row_index(&self) -> RowIndex

Return the index of the row associated to the current cursor position / vertical offset

fn previous_row_index(&self) -> RowIndex

Return the RowIndex corresponding to the previous row, with respect to the current one

fn next_row_index(&self) -> RowIndex

Return the RowIndex corresponding to the previous row, with respect to the current one

fn current_x_position(&self) -> usize

Return the current x position, taking the offset into account

fn current_grapheme(&self) -> &str

Return the character currently under the cursor

fn previous_grapheme(&self) -> &str

Return the character currently at the left of the cursor

fn current_line_number(&self) -> LineNumber

Return the line number associated to the current cursor position / vertical offset

fn delete_current_line(&mut self)

Delete the line currently under the cursor

fn delete_current_grapheme(&mut self)

Delete the grapheme currently under the cursor

fn insert_newline_after_current_line(&mut self)

Insert a newline after the current one, move cursor to it in insert mode

fn insert_newline_before_current_line(&mut self)

Insert a newline before the current one, move cursor to it in insert mode

fn append_to_line(&mut self)

Move to the end of the line, and switch to Insert mode

fn join_current_line_with_next_one(&mut self)

Join the current line with the next one, using a space as a separator

fn goto_start_or_end_of_paragraph(&mut self, boundary: &Boundary, times: usize)

Move the cursor to the next line after the current paraghraph, or the line before the current paragraph.

fn goto_start_or_end_of_document(&mut self, boundary: &Boundary)

Move the cursor either to the first or last line of the document

fn goto_start_or_end_of_line(&mut self, boundary: &Boundary)

Move the cursor either to the start or end of the line

fn goto_start_or_end_of_word(&mut self, boundary: &Boundary, times: usize)

Move to the start of the next word or previous one.

fn goto_first_non_whitespace(&mut self)

Move the cursor to the first non whitespace character in the line

fn goto_middle_of_terminal(&mut self)

Move the cursor to the middle of the terminal

fn goto_first_line_of_terminal(&mut self)

Move the cursor to the middle of the terminal

fn goto_last_line_of_terminal(&mut self)

Move the cursor to the last line of the terminal

fn goto_percentage_in_document(&mut self, percent: usize)

Move to {n}% in the file

fn goto_matching_closing_symbol(&mut self)

Go to the matching closing symbol (whether that’s a quote, curly/square/regular brace, etc).

fn goto_next_search_match(&mut self)

Move to the first character of the next search match

fn goto_previous_search_match(&mut self)

Move to the first character of the previous search match

fn goto_line(&mut self, line_number: LineNumber, x_position: usize)

Move the cursor to the nth line in the file and adjust the viewport

fn goto_position(&mut self, pos: Position)

fn goto_x_y(&mut self, x: usize, y: RowIndex)

Move the cursor to the first column of the nth line

fn move_cursor(&mut self, direction: &Direction, times: usize)

Move the cursor up/down/left/right by adjusting its x/y position

fn move_cursor_to_position_y(&mut self, y: RowIndex)

Move the cursor to the given y RowIndex.

Depending on the both the current and destination cursor position, multiple scenarii can unfold:

• we move the cursor in the same view by simply changing the cursor y position
• we move the cursor to a different view, by changing both the cursor y position and the offset, and positioning the cursor at the middle of that new view
• we move the cursor to the first view in the document, by changing the cursor y position and setting the y offset to 0
• we move the cursor to the last view in the document, by changing the cursor y position and setting the y offset to (len_doc - view_height)

fn move_cursor_to_position_x(&mut self, x: usize)

Move the cursor to the associated x non-negative position, adjusting the x offset if that takes the cursor out of the current view.

fn is_dirty(&self) -> bool

Return whether the document has seen some edits since the last save

fn undo_last_operation(&mut self)

Undo the last registered operation in history

fn get_x_index_of_currently_selected_suggestion(&self) -> usize

Return the x index of the first character of the currently selected autocompletion suggestion

fn refresh_screen(&mut self) -> Result<(), Error>

Refresh the screen by displaying all rows and bars

fn generate_status(&self) -> String

Generate the content of the status bar

fn draw_status_bar(&self)

Display the content of the status bar to the screen

fn draw_message_bar(&self)

Display the content of the message bar to the screen

fn generate_command_autocompletion_message(&self) -> String

Generate the command autocompletion message, that will be displayed in the message bar

fn display_message(&mut self, message: String)

Make sure the provided message gets displayed in the message bar

fn reset_message(&mut self)

Erase the currently displayed message

fn display_welcome_message(&self)

Display a welcome message, when no document has been opened

fn draw_help_screen(&mut self)

Display the automatically generated help panel on the screen

fn draw_rows(&self)

Iterate over each visible document rows and display it on the screen. If no document is currently opened, display the welcome message. If the document is shorter than the viewport height, display empty lines as ~.

fn draw_row(&self, row: &Row, line_number: LineNumber)

Display the content of a particular document row to the screen

Trait Implementations

impl Debug for Editor

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Serialize for Editor

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.