1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
use std::io::{self, stdout, Write};
use std::path::PathBuf;
use crossterm::{
cursor,
cursor::position,
event::{self, read, Event, KeyCode, KeyEvent},
execute, queue, style,
terminal::{self, disable_raw_mode, enable_raw_mode},
Result,
};
const HELP: &str = r#"
- Use q to quit
- Move cursor with h, j, k, l
"#;
pub struct Editor {
file: PathBuf,
}
impl Editor {
pub fn read_char() -> Result<char> {
loop {
if let Ok(Event::Key(KeyEvent {
code: KeyCode::Char(c),
..
})) = event::read()
{
return Ok(c);
}
}
}
pub async fn print_events() -> Result<()> {
loop {
// Handle key events
match Editor::read_char()? {
'h' => execute!(io::stdout(), cursor::MoveLeft(1))?,
'j' => execute!(io::stdout(), cursor::MoveDown(1))?,
'k' => execute!(io::stdout(), cursor::MoveUp(1))?,
'l' => execute!(io::stdout(), cursor::MoveRight(1))?,
'q' => {
execute!(
io::stdout(),
style::ResetColor,
cursor::Show,
terminal::LeaveAlternateScreen
)?;
break;
}
_ => println!("use 'q' to quit."),
}
}
Ok(())
}
pub fn run() -> Result<()> {
enable_raw_mode()?;
let mut stdout = stdout();
execute!(stdout, terminal::EnterAlternateScreen)?;
use std::thread;
// Same number of threads as there are CPU cores.
let num_threads = num_cpus::get().max(1);
// A channel that sends the shutdown signal.
let (s, r) = piper::chan::<()>(0);
let mut threads = Vec::new();
// Create an executor thread pool.
for _ in 0..num_threads {
// Spawn an executor thread that waits for the shutdown signal.
let r = r.clone();
threads.push(thread::spawn(move || smol::run(r.recv())));
}
// No need to `run()`, now we can just block on the main future.
smol::block_on(Editor::print_events());
// Send a shutdown signal.
drop(s);
// Wait for threads to finish.
for t in threads {
t.join().unwrap();
}
disable_raw_mode()
}
}
|
