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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
use libc::{termios, winsize};
use std::error::Error;
use std::io::{stdout, BufRead, Write};
const CTRL_Q: u8 = 17;
const CTRL_S: u8 = 19;
const CTRL_Y: u8 = 25;
const CTRL_Z: u8 = 26;
const BACKSPACE: u8 = 127;
const ESC: u8 = 27;
pub fn size() -> Result<winsize, Box<dyn Error>> {
unsafe {
let mut window: winsize = std::mem::zeroed();
let status = libc::ioctl(1, libc::TIOCGWINSZ, &mut window);
if status < 0 {
return Err(Box::from(format!(
"terminal size: ioctl failed with code {}",
status
)));
}
return Ok(window);
}
}
fn get_attr() -> Result<termios, Box<dyn Error>> {
unsafe {
let mut attr: termios = std::mem::zeroed();
let status = libc::tcgetattr(1, &mut attr);
if status < 0 {
return Err(Box::from(format!("tcgetattr failed with code {}", status)));
}
return Ok(attr);
}
}
fn set_attr(attrs: &termios) -> Result<(), Box<dyn Error>> {
unsafe {
let status = libc::tcsetattr(1, libc::TCSANOW, attrs);
if status < 0 {
return Err(Box::from(format!("set attributes: code {}", status)));
}
return Ok(());
}
}
fn make_raw() -> termios {
unsafe {
let mut attr: termios = std::mem::zeroed();
libc::cfmakeraw(&mut attr);
attr.c_cc[libc::VMIN] = 0; // Return zero bytes on timeout.
attr.c_cc[libc::VTIME] = 1; // 100 ms timeout.
return attr;
}
}
pub struct RawHandle {
old: termios,
}
impl Drop for RawHandle {
fn drop(&mut self) {
let _ = write!(stdout(), "\x1b[?7h\x1b[H\x1b[J");
let _ = stdout().flush();
let _ = set_attr(&self.old);
}
}
pub fn raw() -> Result<RawHandle, Box<dyn Error>> {
write!(stdout(), "\x1b[?7l")?;
stdout().flush()?;
let old = get_attr()?;
set_attr(&make_raw())?;
return Ok(RawHandle { old: old });
}
pub enum Key {
CtrlQ,
CtrlS,
CtrlZ,
CtrlY,
Up,
Down,
Left,
Right,
Backspace,
Char(u8),
Timeout,
}
pub fn read_key(stdin: &mut dyn BufRead) -> Result<Key, Box<dyn Error>> {
loop {
let mut buf = vec![0; 1];
let n = stdin.read(&mut buf)?;
if n == 0 {
return Ok(Key::Timeout);
}
if buf[0] == CTRL_Q {
return Ok(Key::CtrlQ);
}
if buf[0] == CTRL_S {
return Ok(Key::CtrlS);
}
if buf[0] == CTRL_Y {
return Ok(Key::CtrlY);
}
if buf[0] == CTRL_Z {
return Ok(Key::CtrlZ);
}
if buf[0] == BACKSPACE {
return Ok(Key::Backspace);
}
if buf[0] != ESC {
return Ok(Key::Char(buf[0]));
}
// Try to handle an escape sequence.
let buf = stdin.fill_buf()?;
if buf.len() == 0 {
// Just an escape. Ignore it I guess.
continue;
}
if buf[0] != b'[' {
// Unknown escape sequence, just read another key.
stdin.consume(1);
continue;
}
let mut n = buf.len();
for (i, &c) in buf.iter().enumerate() {
match c {
// Escape sequences usually end with a letter.
b'A'..=b'Z' | b'a'..=b'z' => {
n = i + 1;
break;
}
_ => (),
}
}
let mut escape_sequence = Vec::new();
escape_sequence.extend_from_slice(&buf[1..n]);
stdin.consume(n);
if escape_sequence.len() < 1 {
continue;
}
match escape_sequence[0] {
b'A' => {
return Ok(Key::Up);
}
b'B' => {
return Ok(Key::Down);
}
b'C' => {
return Ok(Key::Right);
}
b'D' => {
return Ok(Key::Left);
}
_ => {
// Unknown escape, just skip it.
continue;
}
}
}
}
fn read_status_report(stdin: &mut dyn BufRead) -> Result<(u16, u16), Box<dyn Error>> {
let buf = stdin.fill_buf()?;
let mut semicolon = buf.len();
let mut r = buf.len();
for (i, &c) in buf.iter().enumerate() {
if c == b';' {
semicolon = i;
}
if c == b'R' {
r = i;
break;
}
}
if buf.len() < 6 || buf[0] != ESC || buf[1] != b'[' || semicolon + 1 > r || r == buf.len() {
return Err(Box::from(format!(
"invalid response: {:?}",
String::from_utf8_lossy(&buf[0..r])
)));
}
let row_str = std::str::from_utf8(&buf[2..semicolon])?;
let col_str = std::str::from_utf8(&buf[semicolon + 1..r])?;
let row = row_str.parse::<u16>()?;
let col = col_str.parse::<u16>()?;
stdin.consume(r + 1);
// Yuck... 1 indexing
return Ok((row - 1, col - 1));
}
pub fn cursor_pos(stdin: &mut dyn BufRead) -> Result<(u16, u16), Box<dyn Error>> {
write!(stdout(), "\x1b[6n")?;
stdout().flush()?;
let pos = read_status_report(stdin)?;
return Ok(pos);
}
|
