Struct Editor

Source

pub struct Editor { /* private fields */ }

Expand description

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

Implementations§

Source §

impl Editor

Source

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

Examples found in repository ?

examples/minimal.rs (line 22)

14fn main() -> anyhow::Result<()> {
15    enable_raw_mode()?;
16    execute!(stdout(), EnterAlternateScreen)?;
17    
18    let backend = CrosstermBackend::new(stdout());
19    let mut terminal = Terminal::new(backend)?;
20    
21    let content = "fn main() {\n    println!(\"Hello, world!\");\n}";
22    let mut editor = Editor::new("rust", content, vesper())?;
23    let mut editor_area = ratatui::layout::Rect::default();
24    
25    loop {
26        terminal.draw(|f| {
27            let area = f.area();
28            editor_area = area;
29            f.render_widget(&editor, editor_area);
30
31            let cursor = editor.get_visible_cursor(&area);
32            if let Some((x,y)) = cursor {
33                f.set_cursor_position(Position::new(x, y));
34            }
35        })?;
36        
37        if let Event::Key(key) = event::read()? {
38            if key.code == KeyCode::Esc {
39                break;
40            }
41            editor.input(key, &editor_area)?;
42        }
43    }
44    
45    disable_raw_mode()?;
46    execute!(stdout(), LeaveAlternateScreen)?;    
47    Ok(())
48}

More examples

Hide additional examples

examples/marks.rs (line 22)

14fn main() -> anyhow::Result<()> {
15    enable_raw_mode()?;
16    execute!(stdout(), EnterAlternateScreen)?;
17    
18    let backend = CrosstermBackend::new(stdout());
19    let mut terminal = Terminal::new(backend)?;
20    
21    let content = "fn main() {\n    println!(\"Hello, world!\");\n}";
22    let mut editor = Editor::new("rust", content, vesper())?;
23    let mut editor_area = ratatui::layout::Rect::default();
24
25    let marks = vec![
26        (3, 7, "#b1fce5"),
27        (16, 24, "#f6c99f"),
28    ];
29
30    editor.set_marks(marks);
31    
32    loop {
33        terminal.draw(|f| {
34            let area = f.area();
35            editor_area = area;
36            f.render_widget(&editor, editor_area);
37            
38            let cursor = editor.get_visible_cursor(&editor_area);
39            if let Some((x,y)) = cursor {
40                f.set_cursor_position(Position::new(x, y));
41            }
42        })?;
43        
44        if let Event::Key(key) = event::read()? {
45            if key.code == KeyCode::Esc {
46                break;
47            }
48            editor.input(key, &editor_area)?;
49        }
50    }
51    
52    disable_raw_mode()?;
53    execute!(stdout(), LeaveAlternateScreen)?;    
54    Ok(())
55}

examples/lsp.rs (line 23)

14fn main() -> anyhow::Result<()> {
15    enable_raw_mode()?;
16    execute!(stdout(), EnterAlternateScreen)?;
17    
18    let backend = CrosstermBackend::new(stdout());
19    let mut terminal = Terminal::new(backend)?;
20    
21    let filename = String::from("test.rs");
22    let content = "fn main() {\n    println!(\"Hello, world!\");\n}";
23    let mut editor = Editor::new("rust", content, vesper())?;
24    let mut editor_area = ratatui::layout::Rect::default();
25
26    editor.set_change_callback(Box::new(
27        move |changes| {
28            for (start_row, start_col, end_row, end_col, text) in changes {
29                println!(
30                    "Edit {}: ({}, {}) -> ({}, {}) text: '{}'",
31                    filename, start_row, start_col, end_row, end_col, text
32                );
33            }
34        }
35    ));
36    
37    loop {
38        terminal.draw(|f| {
39            let area = f.area();
40            editor_area = area;
41            f.render_widget(&editor, editor_area);
42
43            let cursor = editor.get_visible_cursor(&area);
44            if let Some((x,y)) = cursor {
45                f.set_cursor_position(Position::new(x, y));
46            }
47        })?;
48        
49        if let Event::Key(key) = event::read()? {
50            if key.code == KeyCode::Esc {
51                break;
52            }
53            editor.input(key, &editor_area)?;
54        }
55    }
56    
57    disable_raw_mode()?;
58    execute!(stdout(), LeaveAlternateScreen)?;    
59    Ok(())
60}

examples/editor.rs (line 40)

18fn main() -> anyhow::Result<()> {
19    let args: Vec<String> = std::env::args().collect();
20    
21    let filename = if args.len() > 1 {
22        &args[1]
23    } else {
24        eprintln!("Usage: cargo run --release --example editor <filename>");
25        return Ok(());
26    };
27    
28    let language = get_lang(filename);
29    let content = std::fs::read_to_string(filename)?;
30
31    enable_raw_mode()?;
32    execute!(stdout(), EnterAlternateScreen)?;
33    execute!(stdout(), EnableMouseCapture)?;
34
35    let backend = CrosstermBackend::new(stdout());
36    let mut terminal = Terminal::new(backend)?;
37    
38    let theme = vesper();
39
40    let mut editor = Editor::new(&language, &content, theme)?;
41    let mut editor_area = ratatui::layout::Rect::default(); 
42
43    loop {
44
45        terminal.draw(|f| {
46            let area = f.area();
47            editor_area = area;
48            f.render_widget(&editor, area);
49            
50            let cursor = editor.get_visible_cursor(&area);
51            if let Some((x,y)) = cursor {
52                f.set_cursor_position(Position::new(x, y));
53            }
54        })?;
55
56        if event::poll(std::time::Duration::from_millis(100))? {
57            match event::read()? {
58                Event::Key(key) => {
59                    if key.code == KeyCode::Esc {
60                        break;
61                    } else if is_save_pressed(key) {
62                        let content = editor.get_content();
63                        save_to_file(&content, filename)?;
64                    } else {
65                        editor.input(key, &editor_area)?;
66                    }
67                }
68                Event::Mouse(mouse) => {
69                    editor.mouse(mouse, &editor_area)?;
70                },
71                Event::Resize(_, _) => { }
72                _ => {}
73            }
74        }
75    }
76
77    disable_raw_mode()?;
78    execute!(
79        terminal.backend_mut(),
80        LeaveAlternateScreen,
81        DisableMouseCapture
82    )?;
83    Ok(())
84}

examples/half.rs (line 33)

19fn main() -> anyhow::Result<()> {
20    let filename = "src/code.rs";
21    let language = "rust";
22    let content = std::fs::read_to_string(filename)?;    
23    
24    enable_raw_mode()?;
25    execute!(stdout(), EnterAlternateScreen)?;
26    execute!(stdout(), EnableMouseCapture)?;
27
28    let backend = CrosstermBackend::new(stdout());
29    let mut terminal = Terminal::new(backend)?;
30    
31    let theme = vesper();
32
33    let mut editor = Editor::new(&language, &content, theme)?;
34
35    let mut editor_area = ratatui::layout::Rect::default(); 
36
37    let layout = Layout::default()
38        .direction(Direction::Vertical)
39        .constraints([
40            Constraint::Percentage(50), 
41            Constraint::Percentage(50)
42        ].as_ref());
43
44    loop {
45        terminal.draw(|f| {    
46            let block = Block::default()
47                .title(" Editor ")
48                .borders(Borders::ALL);
49            let chunks = layout.split(f.area());
50            let inner = block.inner(chunks[0]);
51            editor_area = inner;
52            f.render_widget(block, chunks[0]);
53            f.render_widget(&editor, editor_area);
54            
55            let cursor = editor.get_visible_cursor(&editor_area);
56            if let Some((x,y)) = cursor {
57                f.set_cursor_position(Position::new(x, y));
58            }
59        })?;
60        
61        if event::poll(std::time::Duration::from_millis(100))? {
62            match event::read()? {
63                Event::Key(key) => {
64                    if key.code == KeyCode::Esc {
65                        break;
66                    } else {
67                        editor.input(key, &editor_area)?;
68                    }
69                }
70                Event::Mouse(mouse) => {
71                    editor.mouse(mouse, &editor_area)?;
72                },
73                Event::Resize(_, _) => { }
74                _ => {}
75            }
76        }
77    }
78
79    disable_raw_mode()?;
80    execute!(
81        terminal.backend_mut(),
82        LeaveAlternateScreen,
83        DisableMouseCapture
84    )?;
85    Ok(())
86}

examples/split.rs (line 36)

20fn main() -> anyhow::Result<()> {
21    let filename1 = "src/code.rs";
22    let filename2 = "src/editor.rs";
23    let language = "rust";
24    let content1 = std::fs::read_to_string(filename1).unwrap_or_default();
25    let content2 = std::fs::read_to_string(filename2).unwrap_or_default();
26
27    enable_raw_mode()?;
28    execute!(stdout(), EnterAlternateScreen)?;
29    execute!(stdout(), EnableMouseCapture)?;
30
31    let backend = CrosstermBackend::new(stdout());
32    let mut terminal = Terminal::new(backend)?;
33    
34    let theme = vesper();
35
36    let mut editor1 = Editor::new(&language, &content1, theme.clone())?;
37    let mut editor2 = Editor::new(&language, &content2, theme)?;
38
39    let mut editor1_area = ratatui::layout::Rect::default(); 
40    let mut editor2_area = ratatui::layout::Rect::default(); 
41
42    let mut active_editor = 0;
43
44    loop {
45        terminal.draw(|f| {
46            let chunks = Layout::default()
47                .direction(Direction::Horizontal)
48                .constraints([
49                    Constraint::Percentage(50),
50                    Constraint::Percentage(50)
51                ])
52                .split(f.area());
53
54            let block1 = Block::default()
55                .title(filename1)
56                .borders(Borders::ALL);
57            let block2 = Block::default()
58                .title(filename2)
59                .borders(Borders::ALL);
60
61            editor1_area = block1.inner(chunks[0]);
62            editor2_area = block2.inner(chunks[1]);
63
64            f.render_widget(block1, chunks[0]);
65            f.render_widget(block2, chunks[1]);
66            f.render_widget(&editor1, editor1_area);
67            f.render_widget(&editor2, editor2_area);
68            
69            let cursor = match active_editor {
70                0 => editor1.get_visible_cursor(&editor1_area),
71                _ => editor2.get_visible_cursor(&editor2_area),
72            };
73            
74            if let Some((x,y)) = cursor {
75                f.set_cursor_position(Position::new(x, y));
76            }
77        })?;
78
79        if event::poll(std::time::Duration::from_millis(100))? {
80            match event::read()? {
81                Event::Key(key) => {
82                    if key.code == KeyCode::Esc {
83                        break;
84                    } else if key.code == KeyCode::Tab {
85                        active_editor = (active_editor + 1) % 2;
86                    } else {
87                        match active_editor {
88                            0 => editor1.input(key, &editor1_area)?,
89                            1 => editor2.input(key, &editor2_area)?,
90                            _ => {}
91                        }
92                    }
93                }
94                Event::Mouse(mouse) => {
95                    if let Some(new_active) = detect_active_editor(&mouse, editor1_area, editor2_area) {
96                        active_editor = new_active;
97                    }
98
99                    match active_editor {
100                        0 => editor1.mouse(mouse, &editor1_area)?,
101                        1 => editor2.mouse(mouse, &editor2_area)?,
102                        _ => {}
103                    }
104                },
105
106                Event::Resize(_, _) => {}
107                _ => {}
108            }
109        }
110    }
111
112    disable_raw_mode()?;
113    execute!(
114        terminal.backend_mut(),
115        LeaveAlternateScreen,
116        DisableMouseCapture
117    )?;
118    Ok(())
119}

Source

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

Source

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

Examples found in repository ?

examples/minimal.rs (line 41)

14fn main() -> anyhow::Result<()> {
15    enable_raw_mode()?;
16    execute!(stdout(), EnterAlternateScreen)?;
17    
18    let backend = CrosstermBackend::new(stdout());
19    let mut terminal = Terminal::new(backend)?;
20    
21    let content = "fn main() {\n    println!(\"Hello, world!\");\n}";
22    let mut editor = Editor::new("rust", content, vesper())?;
23    let mut editor_area = ratatui::layout::Rect::default();
24    
25    loop {
26        terminal.draw(|f| {
27            let area = f.area();
28            editor_area = area;
29            f.render_widget(&editor, editor_area);
30
31            let cursor = editor.get_visible_cursor(&area);
32            if let Some((x,y)) = cursor {
33                f.set_cursor_position(Position::new(x, y));
34            }
35        })?;
36        
37        if let Event::Key(key) = event::read()? {
38            if key.code == KeyCode::Esc {
39                break;
40            }
41            editor.input(key, &editor_area)?;
42        }
43    }
44    
45    disable_raw_mode()?;
46    execute!(stdout(), LeaveAlternateScreen)?;    
47    Ok(())
48}

More examples

Hide additional examples

examples/marks.rs (line 48)

14fn main() -> anyhow::Result<()> {
15    enable_raw_mode()?;
16    execute!(stdout(), EnterAlternateScreen)?;
17    
18    let backend = CrosstermBackend::new(stdout());
19    let mut terminal = Terminal::new(backend)?;
20    
21    let content = "fn main() {\n    println!(\"Hello, world!\");\n}";
22    let mut editor = Editor::new("rust", content, vesper())?;
23    let mut editor_area = ratatui::layout::Rect::default();
24
25    let marks = vec![
26        (3, 7, "#b1fce5"),
27        (16, 24, "#f6c99f"),
28    ];
29
30    editor.set_marks(marks);
31    
32    loop {
33        terminal.draw(|f| {
34            let area = f.area();
35            editor_area = area;
36            f.render_widget(&editor, editor_area);
37            
38            let cursor = editor.get_visible_cursor(&editor_area);
39            if let Some((x,y)) = cursor {
40                f.set_cursor_position(Position::new(x, y));
41            }
42        })?;
43        
44        if let Event::Key(key) = event::read()? {
45            if key.code == KeyCode::Esc {
46                break;
47            }
48            editor.input(key, &editor_area)?;
49        }
50    }
51    
52    disable_raw_mode()?;
53    execute!(stdout(), LeaveAlternateScreen)?;    
54    Ok(())
55}

examples/lsp.rs (line 53)

14fn main() -> anyhow::Result<()> {
15    enable_raw_mode()?;
16    execute!(stdout(), EnterAlternateScreen)?;
17    
18    let backend = CrosstermBackend::new(stdout());
19    let mut terminal = Terminal::new(backend)?;
20    
21    let filename = String::from("test.rs");
22    let content = "fn main() {\n    println!(\"Hello, world!\");\n}";
23    let mut editor = Editor::new("rust", content, vesper())?;
24    let mut editor_area = ratatui::layout::Rect::default();
25
26    editor.set_change_callback(Box::new(
27        move |changes| {
28            for (start_row, start_col, end_row, end_col, text) in changes {
29                println!(
30                    "Edit {}: ({}, {}) -> ({}, {}) text: '{}'",
31                    filename, start_row, start_col, end_row, end_col, text
32                );
33            }
34        }
35    ));
36    
37    loop {
38        terminal.draw(|f| {
39            let area = f.area();
40            editor_area = area;
41            f.render_widget(&editor, editor_area);
42
43            let cursor = editor.get_visible_cursor(&area);
44            if let Some((x,y)) = cursor {
45                f.set_cursor_position(Position::new(x, y));
46            }
47        })?;
48        
49        if let Event::Key(key) = event::read()? {
50            if key.code == KeyCode::Esc {
51                break;
52            }
53            editor.input(key, &editor_area)?;
54        }
55    }
56    
57    disable_raw_mode()?;
58    execute!(stdout(), LeaveAlternateScreen)?;    
59    Ok(())
60}

examples/editor.rs (line 65)

18fn main() -> anyhow::Result<()> {
19    let args: Vec<String> = std::env::args().collect();
20    
21    let filename = if args.len() > 1 {
22        &args[1]
23    } else {
24        eprintln!("Usage: cargo run --release --example editor <filename>");
25        return Ok(());
26    };
27    
28    let language = get_lang(filename);
29    let content = std::fs::read_to_string(filename)?;
30
31    enable_raw_mode()?;
32    execute!(stdout(), EnterAlternateScreen)?;
33    execute!(stdout(), EnableMouseCapture)?;
34
35    let backend = CrosstermBackend::new(stdout());
36    let mut terminal = Terminal::new(backend)?;
37    
38    let theme = vesper();
39
40    let mut editor = Editor::new(&language, &content, theme)?;
41    let mut editor_area = ratatui::layout::Rect::default(); 
42
43    loop {
44
45        terminal.draw(|f| {
46            let area = f.area();
47            editor_area = area;
48            f.render_widget(&editor, area);
49            
50            let cursor = editor.get_visible_cursor(&area);
51            if let Some((x,y)) = cursor {
52                f.set_cursor_position(Position::new(x, y));
53            }
54        })?;
55
56        if event::poll(std::time::Duration::from_millis(100))? {
57            match event::read()? {
58                Event::Key(key) => {
59                    if key.code == KeyCode::Esc {
60                        break;
61                    } else if is_save_pressed(key) {
62                        let content = editor.get_content();
63                        save_to_file(&content, filename)?;
64                    } else {
65                        editor.input(key, &editor_area)?;
66                    }
67                }
68                Event::Mouse(mouse) => {
69                    editor.mouse(mouse, &editor_area)?;
70                },
71                Event::Resize(_, _) => { }
72                _ => {}
73            }
74        }
75    }
76
77    disable_raw_mode()?;
78    execute!(
79        terminal.backend_mut(),
80        LeaveAlternateScreen,
81        DisableMouseCapture
82    )?;
83    Ok(())
84}

examples/half.rs (line 67)

19fn main() -> anyhow::Result<()> {
20    let filename = "src/code.rs";
21    let language = "rust";
22    let content = std::fs::read_to_string(filename)?;    
23    
24    enable_raw_mode()?;
25    execute!(stdout(), EnterAlternateScreen)?;
26    execute!(stdout(), EnableMouseCapture)?;
27
28    let backend = CrosstermBackend::new(stdout());
29    let mut terminal = Terminal::new(backend)?;
30    
31    let theme = vesper();
32
33    let mut editor = Editor::new(&language, &content, theme)?;
34
35    let mut editor_area = ratatui::layout::Rect::default(); 
36
37    let layout = Layout::default()
38        .direction(Direction::Vertical)
39        .constraints([
40            Constraint::Percentage(50), 
41            Constraint::Percentage(50)
42        ].as_ref());
43
44    loop {
45        terminal.draw(|f| {    
46            let block = Block::default()
47                .title(" Editor ")
48                .borders(Borders::ALL);
49            let chunks = layout.split(f.area());
50            let inner = block.inner(chunks[0]);
51            editor_area = inner;
52            f.render_widget(block, chunks[0]);
53            f.render_widget(&editor, editor_area);
54            
55            let cursor = editor.get_visible_cursor(&editor_area);
56            if let Some((x,y)) = cursor {
57                f.set_cursor_position(Position::new(x, y));
58            }
59        })?;
60        
61        if event::poll(std::time::Duration::from_millis(100))? {
62            match event::read()? {
63                Event::Key(key) => {
64                    if key.code == KeyCode::Esc {
65                        break;
66                    } else {
67                        editor.input(key, &editor_area)?;
68                    }
69                }
70                Event::Mouse(mouse) => {
71                    editor.mouse(mouse, &editor_area)?;
72                },
73                Event::Resize(_, _) => { }
74                _ => {}
75            }
76        }
77    }
78
79    disable_raw_mode()?;
80    execute!(
81        terminal.backend_mut(),
82        LeaveAlternateScreen,
83        DisableMouseCapture
84    )?;
85    Ok(())
86}

examples/split.rs (line 88)

20fn main() -> anyhow::Result<()> {
21    let filename1 = "src/code.rs";
22    let filename2 = "src/editor.rs";
23    let language = "rust";
24    let content1 = std::fs::read_to_string(filename1).unwrap_or_default();
25    let content2 = std::fs::read_to_string(filename2).unwrap_or_default();
26
27    enable_raw_mode()?;
28    execute!(stdout(), EnterAlternateScreen)?;
29    execute!(stdout(), EnableMouseCapture)?;
30
31    let backend = CrosstermBackend::new(stdout());
32    let mut terminal = Terminal::new(backend)?;
33    
34    let theme = vesper();
35
36    let mut editor1 = Editor::new(&language, &content1, theme.clone())?;
37    let mut editor2 = Editor::new(&language, &content2, theme)?;
38
39    let mut editor1_area = ratatui::layout::Rect::default(); 
40    let mut editor2_area = ratatui::layout::Rect::default(); 
41
42    let mut active_editor = 0;
43
44    loop {
45        terminal.draw(|f| {
46            let chunks = Layout::default()
47                .direction(Direction::Horizontal)
48                .constraints([
49                    Constraint::Percentage(50),
50                    Constraint::Percentage(50)
51                ])
52                .split(f.area());
53
54            let block1 = Block::default()
55                .title(filename1)
56                .borders(Borders::ALL);
57            let block2 = Block::default()
58                .title(filename2)
59                .borders(Borders::ALL);
60
61            editor1_area = block1.inner(chunks[0]);
62            editor2_area = block2.inner(chunks[1]);
63
64            f.render_widget(block1, chunks[0]);
65            f.render_widget(block2, chunks[1]);
66            f.render_widget(&editor1, editor1_area);
67            f.render_widget(&editor2, editor2_area);
68            
69            let cursor = match active_editor {
70                0 => editor1.get_visible_cursor(&editor1_area),
71                _ => editor2.get_visible_cursor(&editor2_area),
72            };
73            
74            if let Some((x,y)) = cursor {
75                f.set_cursor_position(Position::new(x, y));
76            }
77        })?;
78
79        if event::poll(std::time::Duration::from_millis(100))? {
80            match event::read()? {
81                Event::Key(key) => {
82                    if key.code == KeyCode::Esc {
83                        break;
84                    } else if key.code == KeyCode::Tab {
85                        active_editor = (active_editor + 1) % 2;
86                    } else {
87                        match active_editor {
88                            0 => editor1.input(key, &editor1_area)?,
89                            1 => editor2.input(key, &editor2_area)?,
90                            _ => {}
91                        }
92                    }
93                }
94                Event::Mouse(mouse) => {
95                    if let Some(new_active) = detect_active_editor(&mouse, editor1_area, editor2_area) {
96                        active_editor = new_active;
97                    }
98
99                    match active_editor {
100                        0 => editor1.mouse(mouse, &editor1_area)?,
101                        1 => editor2.mouse(mouse, &editor2_area)?,
102                        _ => {}
103                    }
104                },
105
106                Event::Resize(_, _) => {}
107                _ => {}
108            }
109        }
110    }
111
112    disable_raw_mode()?;
113    execute!(
114        terminal.backend_mut(),
115        LeaveAlternateScreen,
116        DisableMouseCapture
117    )?;
118    Ok(())
119}

Source

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

Source

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

Examples found in repository ?

examples/editor.rs (line 69)

18fn main() -> anyhow::Result<()> {
19    let args: Vec<String> = std::env::args().collect();
20    
21    let filename = if args.len() > 1 {
22        &args[1]
23    } else {
24        eprintln!("Usage: cargo run --release --example editor <filename>");
25        return Ok(());
26    };
27    
28    let language = get_lang(filename);
29    let content = std::fs::read_to_string(filename)?;
30
31    enable_raw_mode()?;
32    execute!(stdout(), EnterAlternateScreen)?;
33    execute!(stdout(), EnableMouseCapture)?;
34
35    let backend = CrosstermBackend::new(stdout());
36    let mut terminal = Terminal::new(backend)?;
37    
38    let theme = vesper();
39
40    let mut editor = Editor::new(&language, &content, theme)?;
41    let mut editor_area = ratatui::layout::Rect::default(); 
42
43    loop {
44
45        terminal.draw(|f| {
46            let area = f.area();
47            editor_area = area;
48            f.render_widget(&editor, area);
49            
50            let cursor = editor.get_visible_cursor(&area);
51            if let Some((x,y)) = cursor {
52                f.set_cursor_position(Position::new(x, y));
53            }
54        })?;
55
56        if event::poll(std::time::Duration::from_millis(100))? {
57            match event::read()? {
58                Event::Key(key) => {
59                    if key.code == KeyCode::Esc {
60                        break;
61                    } else if is_save_pressed(key) {
62                        let content = editor.get_content();
63                        save_to_file(&content, filename)?;
64                    } else {
65                        editor.input(key, &editor_area)?;
66                    }
67                }
68                Event::Mouse(mouse) => {
69                    editor.mouse(mouse, &editor_area)?;
70                },
71                Event::Resize(_, _) => { }
72                _ => {}
73            }
74        }
75    }
76
77    disable_raw_mode()?;
78    execute!(
79        terminal.backend_mut(),
80        LeaveAlternateScreen,
81        DisableMouseCapture
82    )?;
83    Ok(())
84}

More examples

Hide additional examples

examples/half.rs (line 71)

19fn main() -> anyhow::Result<()> {
20    let filename = "src/code.rs";
21    let language = "rust";
22    let content = std::fs::read_to_string(filename)?;    
23    
24    enable_raw_mode()?;
25    execute!(stdout(), EnterAlternateScreen)?;
26    execute!(stdout(), EnableMouseCapture)?;
27
28    let backend = CrosstermBackend::new(stdout());
29    let mut terminal = Terminal::new(backend)?;
30    
31    let theme = vesper();
32
33    let mut editor = Editor::new(&language, &content, theme)?;
34
35    let mut editor_area = ratatui::layout::Rect::default(); 
36
37    let layout = Layout::default()
38        .direction(Direction::Vertical)
39        .constraints([
40            Constraint::Percentage(50), 
41            Constraint::Percentage(50)
42        ].as_ref());
43
44    loop {
45        terminal.draw(|f| {    
46            let block = Block::default()
47                .title(" Editor ")
48                .borders(Borders::ALL);
49            let chunks = layout.split(f.area());
50            let inner = block.inner(chunks[0]);
51            editor_area = inner;
52            f.render_widget(block, chunks[0]);
53            f.render_widget(&editor, editor_area);
54            
55            let cursor = editor.get_visible_cursor(&editor_area);
56            if let Some((x,y)) = cursor {
57                f.set_cursor_position(Position::new(x, y));
58            }
59        })?;
60        
61        if event::poll(std::time::Duration::from_millis(100))? {
62            match event::read()? {
63                Event::Key(key) => {
64                    if key.code == KeyCode::Esc {
65                        break;
66                    } else {
67                        editor.input(key, &editor_area)?;
68                    }
69                }
70                Event::Mouse(mouse) => {
71                    editor.mouse(mouse, &editor_area)?;
72                },
73                Event::Resize(_, _) => { }
74                _ => {}
75            }
76        }
77    }
78
79    disable_raw_mode()?;
80    execute!(
81        terminal.backend_mut(),
82        LeaveAlternateScreen,
83        DisableMouseCapture
84    )?;
85    Ok(())
86}

examples/split.rs (line 100)

20fn main() -> anyhow::Result<()> {
21    let filename1 = "src/code.rs";
22    let filename2 = "src/editor.rs";
23    let language = "rust";
24    let content1 = std::fs::read_to_string(filename1).unwrap_or_default();
25    let content2 = std::fs::read_to_string(filename2).unwrap_or_default();
26
27    enable_raw_mode()?;
28    execute!(stdout(), EnterAlternateScreen)?;
29    execute!(stdout(), EnableMouseCapture)?;
30
31    let backend = CrosstermBackend::new(stdout());
32    let mut terminal = Terminal::new(backend)?;
33    
34    let theme = vesper();
35
36    let mut editor1 = Editor::new(&language, &content1, theme.clone())?;
37    let mut editor2 = Editor::new(&language, &content2, theme)?;
38
39    let mut editor1_area = ratatui::layout::Rect::default(); 
40    let mut editor2_area = ratatui::layout::Rect::default(); 
41
42    let mut active_editor = 0;
43
44    loop {
45        terminal.draw(|f| {
46            let chunks = Layout::default()
47                .direction(Direction::Horizontal)
48                .constraints([
49                    Constraint::Percentage(50),
50                    Constraint::Percentage(50)
51                ])
52                .split(f.area());
53
54            let block1 = Block::default()
55                .title(filename1)
56                .borders(Borders::ALL);
57            let block2 = Block::default()
58                .title(filename2)
59                .borders(Borders::ALL);
60
61            editor1_area = block1.inner(chunks[0]);
62            editor2_area = block2.inner(chunks[1]);
63
64            f.render_widget(block1, chunks[0]);
65            f.render_widget(block2, chunks[1]);
66            f.render_widget(&editor1, editor1_area);
67            f.render_widget(&editor2, editor2_area);
68            
69            let cursor = match active_editor {
70                0 => editor1.get_visible_cursor(&editor1_area),
71                _ => editor2.get_visible_cursor(&editor2_area),
72            };
73            
74            if let Some((x,y)) = cursor {
75                f.set_cursor_position(Position::new(x, y));
76            }
77        })?;
78
79        if event::poll(std::time::Duration::from_millis(100))? {
80            match event::read()? {
81                Event::Key(key) => {
82                    if key.code == KeyCode::Esc {
83                        break;
84                    } else if key.code == KeyCode::Tab {
85                        active_editor = (active_editor + 1) % 2;
86                    } else {
87                        match active_editor {
88                            0 => editor1.input(key, &editor1_area)?,
89                            1 => editor2.input(key, &editor2_area)?,
90                            _ => {}
91                        }
92                    }
93                }
94                Event::Mouse(mouse) => {
95                    if let Some(new_active) = detect_active_editor(&mouse, editor1_area, editor2_area) {
96                        active_editor = new_active;
97                    }
98
99                    match active_editor {
100                        0 => editor1.mouse(mouse, &editor1_area)?,
101                        1 => editor2.mouse(mouse, &editor2_area)?,
102                        _ => {}
103                    }
104                },
105
106                Event::Resize(_, _) => {}
107                _ => {}
108            }
109        }
110    }
111
112    disable_raw_mode()?;
113    execute!(
114        terminal.backend_mut(),
115        LeaveAlternateScreen,
116        DisableMouseCapture
117    )?;
118    Ok(())
119}

Source

pub fn clear_selection(&mut self)

Clears any active selection.

Source

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

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

Source

pub fn selection_anchor(&self) -> usize

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

Source

pub fn get_content(&self) -> String

Examples found in repository ?

examples/editor.rs (line 62)

18fn main() -> anyhow::Result<()> {
19    let args: Vec<String> = std::env::args().collect();
20    
21    let filename = if args.len() > 1 {
22        &args[1]
23    } else {
24        eprintln!("Usage: cargo run --release --example editor <filename>");
25        return Ok(());
26    };
27    
28    let language = get_lang(filename);
29    let content = std::fs::read_to_string(filename)?;
30
31    enable_raw_mode()?;
32    execute!(stdout(), EnterAlternateScreen)?;
33    execute!(stdout(), EnableMouseCapture)?;
34
35    let backend = CrosstermBackend::new(stdout());
36    let mut terminal = Terminal::new(backend)?;
37    
38    let theme = vesper();
39
40    let mut editor = Editor::new(&language, &content, theme)?;
41    let mut editor_area = ratatui::layout::Rect::default(); 
42
43    loop {
44
45        terminal.draw(|f| {
46            let area = f.area();
47            editor_area = area;
48            f.render_widget(&editor, area);
49            
50            let cursor = editor.get_visible_cursor(&area);
51            if let Some((x,y)) = cursor {
52                f.set_cursor_position(Position::new(x, y));
53            }
54        })?;
55
56        if event::poll(std::time::Duration::from_millis(100))? {
57            match event::read()? {
58                Event::Key(key) => {
59                    if key.code == KeyCode::Esc {
60                        break;
61                    } else if is_save_pressed(key) {
62                        let content = editor.get_content();
63                        save_to_file(&content, filename)?;
64                    } else {
65                        editor.input(key, &editor_area)?;
66                    }
67                }
68                Event::Mouse(mouse) => {
69                    editor.mouse(mouse, &editor_area)?;
70                },
71                Event::Resize(_, _) => { }
72                _ => {}
73            }
74        }
75    }
76
77    disable_raw_mode()?;
78    execute!(
79        terminal.backend_mut(),
80        LeaveAlternateScreen,
81        DisableMouseCapture
82    )?;
83    Ok(())
84}

Source

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

Source

pub fn get_cursor(&self) -> usize

Source

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

Source

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

Source

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

Examples found in repository ?

examples/marks.rs (line 30)

14fn main() -> anyhow::Result<()> {
15    enable_raw_mode()?;
16    execute!(stdout(), EnterAlternateScreen)?;
17    
18    let backend = CrosstermBackend::new(stdout());
19    let mut terminal = Terminal::new(backend)?;
20    
21    let content = "fn main() {\n    println!(\"Hello, world!\");\n}";
22    let mut editor = Editor::new("rust", content, vesper())?;
23    let mut editor_area = ratatui::layout::Rect::default();
24
25    let marks = vec![
26        (3, 7, "#b1fce5"),
27        (16, 24, "#f6c99f"),
28    ];
29
30    editor.set_marks(marks);
31    
32    loop {
33        terminal.draw(|f| {
34            let area = f.area();
35            editor_area = area;
36            f.render_widget(&editor, editor_area);
37            
38            let cursor = editor.get_visible_cursor(&editor_area);
39            if let Some((x,y)) = cursor {
40                f.set_cursor_position(Position::new(x, y));
41            }
42        })?;
43        
44        if let Event::Key(key) = event::read()? {
45            if key.code == KeyCode::Esc {
46                break;
47            }
48            editor.input(key, &editor_area)?;
49        }
50    }
51    
52    disable_raw_mode()?;
53    execute!(stdout(), LeaveAlternateScreen)?;    
54    Ok(())
55}

Source

pub fn remove_marks(&mut self)

Source

pub fn has_marks(&self) -> bool

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

pub fn get_offset_y(&self) -> usize

Source

pub fn get_offset_x(&self) -> usize

Source

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

Source

pub fn code_ref(&self) -> &Code

Source

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

Examples found in repository ?

examples/lsp.rs (lines 26-35)

14fn main() -> anyhow::Result<()> {
15    enable_raw_mode()?;
16    execute!(stdout(), EnterAlternateScreen)?;
17    
18    let backend = CrosstermBackend::new(stdout());
19    let mut terminal = Terminal::new(backend)?;
20    
21    let filename = String::from("test.rs");
22    let content = "fn main() {\n    println!(\"Hello, world!\");\n}";
23    let mut editor = Editor::new("rust", content, vesper())?;
24    let mut editor_area = ratatui::layout::Rect::default();
25
26    editor.set_change_callback(Box::new(
27        move |changes| {
28            for (start_row, start_col, end_row, end_col, text) in changes {
29                println!(
30                    "Edit {}: ({}, {}) -> ({}, {}) text: '{}'",
31                    filename, start_row, start_col, end_row, end_col, text
32                );
33            }
34        }
35    ));
36    
37    loop {
38        terminal.draw(|f| {
39            let area = f.area();
40            editor_area = area;
41            f.render_widget(&editor, editor_area);
42
43            let cursor = editor.get_visible_cursor(&area);
44            if let Some((x,y)) = cursor {
45                f.set_cursor_position(Position::new(x, y));
46            }
47        })?;
48        
49        if let Event::Key(key) = event::read()? {
50            if key.code == KeyCode::Esc {
51                break;
52            }
53            editor.input(key, &editor_area)?;
54        }
55    }
56    
57    disable_raw_mode()?;
58    execute!(stdout(), LeaveAlternateScreen)?;    
59    Ok(())
60}

Source

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

Source

pub fn reset_highlight_cache(&self)

Source

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

calculates visible cursor position

Examples found in repository ?

examples/minimal.rs (line 31)

14fn main() -> anyhow::Result<()> {
15    enable_raw_mode()?;
16    execute!(stdout(), EnterAlternateScreen)?;
17    
18    let backend = CrosstermBackend::new(stdout());
19    let mut terminal = Terminal::new(backend)?;
20    
21    let content = "fn main() {\n    println!(\"Hello, world!\");\n}";
22    let mut editor = Editor::new("rust", content, vesper())?;
23    let mut editor_area = ratatui::layout::Rect::default();
24    
25    loop {
26        terminal.draw(|f| {
27            let area = f.area();
28            editor_area = area;
29            f.render_widget(&editor, editor_area);
30
31            let cursor = editor.get_visible_cursor(&area);
32            if let Some((x,y)) = cursor {
33                f.set_cursor_position(Position::new(x, y));
34            }
35        })?;
36        
37        if let Event::Key(key) = event::read()? {
38            if key.code == KeyCode::Esc {
39                break;
40            }
41            editor.input(key, &editor_area)?;
42        }
43    }
44    
45    disable_raw_mode()?;
46    execute!(stdout(), LeaveAlternateScreen)?;    
47    Ok(())
48}

More examples

Hide additional examples

examples/marks.rs (line 38)

14fn main() -> anyhow::Result<()> {
15    enable_raw_mode()?;
16    execute!(stdout(), EnterAlternateScreen)?;
17    
18    let backend = CrosstermBackend::new(stdout());
19    let mut terminal = Terminal::new(backend)?;
20    
21    let content = "fn main() {\n    println!(\"Hello, world!\");\n}";
22    let mut editor = Editor::new("rust", content, vesper())?;
23    let mut editor_area = ratatui::layout::Rect::default();
24
25    let marks = vec![
26        (3, 7, "#b1fce5"),
27        (16, 24, "#f6c99f"),
28    ];
29
30    editor.set_marks(marks);
31    
32    loop {
33        terminal.draw(|f| {
34            let area = f.area();
35            editor_area = area;
36            f.render_widget(&editor, editor_area);
37            
38            let cursor = editor.get_visible_cursor(&editor_area);
39            if let Some((x,y)) = cursor {
40                f.set_cursor_position(Position::new(x, y));
41            }
42        })?;
43        
44        if let Event::Key(key) = event::read()? {
45            if key.code == KeyCode::Esc {
46                break;
47            }
48            editor.input(key, &editor_area)?;
49        }
50    }
51    
52    disable_raw_mode()?;
53    execute!(stdout(), LeaveAlternateScreen)?;    
54    Ok(())
55}

examples/lsp.rs (line 43)

14fn main() -> anyhow::Result<()> {
15    enable_raw_mode()?;
16    execute!(stdout(), EnterAlternateScreen)?;
17    
18    let backend = CrosstermBackend::new(stdout());
19    let mut terminal = Terminal::new(backend)?;
20    
21    let filename = String::from("test.rs");
22    let content = "fn main() {\n    println!(\"Hello, world!\");\n}";
23    let mut editor = Editor::new("rust", content, vesper())?;
24    let mut editor_area = ratatui::layout::Rect::default();
25
26    editor.set_change_callback(Box::new(
27        move |changes| {
28            for (start_row, start_col, end_row, end_col, text) in changes {
29                println!(
30                    "Edit {}: ({}, {}) -> ({}, {}) text: '{}'",
31                    filename, start_row, start_col, end_row, end_col, text
32                );
33            }
34        }
35    ));
36    
37    loop {
38        terminal.draw(|f| {
39            let area = f.area();
40            editor_area = area;
41            f.render_widget(&editor, editor_area);
42
43            let cursor = editor.get_visible_cursor(&area);
44            if let Some((x,y)) = cursor {
45                f.set_cursor_position(Position::new(x, y));
46            }
47        })?;
48        
49        if let Event::Key(key) = event::read()? {
50            if key.code == KeyCode::Esc {
51                break;
52            }
53            editor.input(key, &editor_area)?;
54        }
55    }
56    
57    disable_raw_mode()?;
58    execute!(stdout(), LeaveAlternateScreen)?;    
59    Ok(())
60}

examples/editor.rs (line 50)

18fn main() -> anyhow::Result<()> {
19    let args: Vec<String> = std::env::args().collect();
20    
21    let filename = if args.len() > 1 {
22        &args[1]
23    } else {
24        eprintln!("Usage: cargo run --release --example editor <filename>");
25        return Ok(());
26    };
27    
28    let language = get_lang(filename);
29    let content = std::fs::read_to_string(filename)?;
30
31    enable_raw_mode()?;
32    execute!(stdout(), EnterAlternateScreen)?;
33    execute!(stdout(), EnableMouseCapture)?;
34
35    let backend = CrosstermBackend::new(stdout());
36    let mut terminal = Terminal::new(backend)?;
37    
38    let theme = vesper();
39
40    let mut editor = Editor::new(&language, &content, theme)?;
41    let mut editor_area = ratatui::layout::Rect::default(); 
42
43    loop {
44
45        terminal.draw(|f| {
46            let area = f.area();
47            editor_area = area;
48            f.render_widget(&editor, area);
49            
50            let cursor = editor.get_visible_cursor(&area);
51            if let Some((x,y)) = cursor {
52                f.set_cursor_position(Position::new(x, y));
53            }
54        })?;
55
56        if event::poll(std::time::Duration::from_millis(100))? {
57            match event::read()? {
58                Event::Key(key) => {
59                    if key.code == KeyCode::Esc {
60                        break;
61                    } else if is_save_pressed(key) {
62                        let content = editor.get_content();
63                        save_to_file(&content, filename)?;
64                    } else {
65                        editor.input(key, &editor_area)?;
66                    }
67                }
68                Event::Mouse(mouse) => {
69                    editor.mouse(mouse, &editor_area)?;
70                },
71                Event::Resize(_, _) => { }
72                _ => {}
73            }
74        }
75    }
76
77    disable_raw_mode()?;
78    execute!(
79        terminal.backend_mut(),
80        LeaveAlternateScreen,
81        DisableMouseCapture
82    )?;
83    Ok(())
84}

examples/half.rs (line 55)

19fn main() -> anyhow::Result<()> {
20    let filename = "src/code.rs";
21    let language = "rust";
22    let content = std::fs::read_to_string(filename)?;    
23    
24    enable_raw_mode()?;
25    execute!(stdout(), EnterAlternateScreen)?;
26    execute!(stdout(), EnableMouseCapture)?;
27
28    let backend = CrosstermBackend::new(stdout());
29    let mut terminal = Terminal::new(backend)?;
30    
31    let theme = vesper();
32
33    let mut editor = Editor::new(&language, &content, theme)?;
34
35    let mut editor_area = ratatui::layout::Rect::default(); 
36
37    let layout = Layout::default()
38        .direction(Direction::Vertical)
39        .constraints([
40            Constraint::Percentage(50), 
41            Constraint::Percentage(50)
42        ].as_ref());
43
44    loop {
45        terminal.draw(|f| {    
46            let block = Block::default()
47                .title(" Editor ")
48                .borders(Borders::ALL);
49            let chunks = layout.split(f.area());
50            let inner = block.inner(chunks[0]);
51            editor_area = inner;
52            f.render_widget(block, chunks[0]);
53            f.render_widget(&editor, editor_area);
54            
55            let cursor = editor.get_visible_cursor(&editor_area);
56            if let Some((x,y)) = cursor {
57                f.set_cursor_position(Position::new(x, y));
58            }
59        })?;
60        
61        if event::poll(std::time::Duration::from_millis(100))? {
62            match event::read()? {
63                Event::Key(key) => {
64                    if key.code == KeyCode::Esc {
65                        break;
66                    } else {
67                        editor.input(key, &editor_area)?;
68                    }
69                }
70                Event::Mouse(mouse) => {
71                    editor.mouse(mouse, &editor_area)?;
72                },
73                Event::Resize(_, _) => { }
74                _ => {}
75            }
76        }
77    }
78
79    disable_raw_mode()?;
80    execute!(
81        terminal.backend_mut(),
82        LeaveAlternateScreen,
83        DisableMouseCapture
84    )?;
85    Ok(())
86}

examples/split.rs (line 70)

20fn main() -> anyhow::Result<()> {
21    let filename1 = "src/code.rs";
22    let filename2 = "src/editor.rs";
23    let language = "rust";
24    let content1 = std::fs::read_to_string(filename1).unwrap_or_default();
25    let content2 = std::fs::read_to_string(filename2).unwrap_or_default();
26
27    enable_raw_mode()?;
28    execute!(stdout(), EnterAlternateScreen)?;
29    execute!(stdout(), EnableMouseCapture)?;
30
31    let backend = CrosstermBackend::new(stdout());
32    let mut terminal = Terminal::new(backend)?;
33    
34    let theme = vesper();
35
36    let mut editor1 = Editor::new(&language, &content1, theme.clone())?;
37    let mut editor2 = Editor::new(&language, &content2, theme)?;
38
39    let mut editor1_area = ratatui::layout::Rect::default(); 
40    let mut editor2_area = ratatui::layout::Rect::default(); 
41
42    let mut active_editor = 0;
43
44    loop {
45        terminal.draw(|f| {
46            let chunks = Layout::default()
47                .direction(Direction::Horizontal)
48                .constraints([
49                    Constraint::Percentage(50),
50                    Constraint::Percentage(50)
51                ])
52                .split(f.area());
53
54            let block1 = Block::default()
55                .title(filename1)
56                .borders(Borders::ALL);
57            let block2 = Block::default()
58                .title(filename2)
59                .borders(Borders::ALL);
60
61            editor1_area = block1.inner(chunks[0]);
62            editor2_area = block2.inner(chunks[1]);
63
64            f.render_widget(block1, chunks[0]);
65            f.render_widget(block2, chunks[1]);
66            f.render_widget(&editor1, editor1_area);
67            f.render_widget(&editor2, editor2_area);
68            
69            let cursor = match active_editor {
70                0 => editor1.get_visible_cursor(&editor1_area),
71                _ => editor2.get_visible_cursor(&editor2_area),
72            };
73            
74            if let Some((x,y)) = cursor {
75                f.set_cursor_position(Position::new(x, y));
76            }
77        })?;
78
79        if event::poll(std::time::Duration::from_millis(100))? {
80            match event::read()? {
81                Event::Key(key) => {
82                    if key.code == KeyCode::Esc {
83                        break;
84                    } else if key.code == KeyCode::Tab {
85                        active_editor = (active_editor + 1) % 2;
86                    } else {
87                        match active_editor {
88                            0 => editor1.input(key, &editor1_area)?,
89                            1 => editor2.input(key, &editor2_area)?,
90                            _ => {}
91                        }
92                    }
93                }
94                Event::Mouse(mouse) => {
95                    if let Some(new_active) = detect_active_editor(&mouse, editor1_area, editor2_area) {
96                        active_editor = new_active;
97                    }
98
99                    match active_editor {
100                        0 => editor1.mouse(mouse, &editor1_area)?,
101                        1 => editor2.mouse(mouse, &editor2_area)?,
102                        _ => {}
103                    }
104                },
105
106                Event::Resize(_, _) => {}
107                _ => {}
108            }
109        }
110    }
111
112    disable_raw_mode()?;
113    execute!(
114        terminal.backend_mut(),
115        LeaveAlternateScreen,
116        DisableMouseCapture
117    )?;
118    Ok(())
119}

Trait Implementations§

Renders the main editor view in four distinct layers:

Line numbers and text content are drawn in the visible viewport.
Syntax highlighting is overlaid on top of the text.
The selection highlight is rendered above the syntax layer.
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.

Source §

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.

Auto Trait Implementations§

§

impl !Freeze for Editor

§

impl !RefUnwindSafe for Editor

§

impl !Send for Editor

§

impl !Sync for Editor

§

impl Unpin for Editor

§

impl UnsafeUnpin for Editor

§

impl !UnwindSafe for Editor

Blanket Implementations§

Source §

impl<T> Any for T
where T: 'static + ?Sized,

Source §

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

Source §

impl<T> Borrow<T> for T
where T: ?Sized,

Source §

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

Source §

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source §

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

Source §

impl<T> From<T> for T

Source §

fn from(t: T) -> T

Returns the argument unchanged.

Source §

impl<T, U> Into for T
where U: From<T>,

Source §

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source §

impl<T> IntoEither for T

Source §

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

Source §

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

Source §

impl<T> Same for T

Source §

type Output = T

Should always be Self

Source §

impl<T, U> TryFrom for T
where U: Into<T>,

Source §

type Error = Infallible

The type returned in the event of a conversion error.

Source §

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

Source §

impl<T, U> TryInto for T
where U: TryFrom<T>,

Source §

type Error = >::Error

The type returned in the event of a conversion error.

Source §

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

Struct Editor Copy item path

Implementations§

impl Editor

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

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

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

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

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

pub fn clear_selection(&mut self)

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

pub fn selection_anchor(&self) -> usize

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

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

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

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

pub fn fit_cursor(&mut self)

pub fn scroll_up(&mut self)

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

pub fn get_content(&self) -> String

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

pub fn get_cursor(&self) -> usize

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

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

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

pub fn remove_marks(&mut self)

pub fn has_marks(&self) -> bool

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

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

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

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

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

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

pub fn get_offset_y(&self) -> usize

pub fn get_offset_x(&self) -> usize

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

pub fn code_ref(&self) -> &Code

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

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

pub fn reset_highlight_cache(&self)

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

Trait Implementations§

impl Widget for &Editor

§Arguments

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

Auto Trait Implementations§

impl !Freeze for Editor

impl !RefUnwindSafe for Editor

impl !Send for Editor

impl !Sync for Editor

impl Unpin for Editor

impl UnsafeUnpin for Editor

impl !UnwindSafe for Editor

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> From<T> for T

fn from(t: T) -> T

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> IntoEither for T

fn into_either(self, into_left: bool) -> Either<Self, Self>

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>where F: FnOnce(&Self) -> bool,

impl<T> Same for T

type Output = T

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Struct Editor

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<T, U> Into<U> for T
where U: From<T>,

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,