pub fn vesper() -> Vec<(&'static str, &'static str)>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
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 38)
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 31)
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 34)
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}