1use std::io;
7use std::time::Duration;
8
9#[derive(Clone, Debug, PartialEq, Eq, Hash)]
13pub struct KeyEvent {
14 pub key: Key,
15 pub modifiers: Modifiers,
16}
17
18#[derive(Clone, Debug, PartialEq, Eq, Hash)]
20pub enum Key {
21 Char(char),
23 Enter,
25 Escape,
27 Backspace,
29 Delete,
31 Tab,
33 BackTab,
35 Up,
37 Down,
38 Left,
39 Right,
40 Home,
42 End,
44 PageUp,
46 PageDown,
48 Insert,
50 F(u8),
52}
53
54#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
56pub struct Modifiers {
57 pub ctrl: bool,
58 pub alt: bool,
59 pub shift: bool,
60}
61
62impl Modifiers {
63 pub fn new() -> Self {
64 Self::default()
65 }
66
67 pub fn ctrl() -> Self {
68 Self {
69 ctrl: true,
70 ..Self::default()
71 }
72 }
73
74 pub fn alt() -> Self {
75 Self {
76 alt: true,
77 ..Self::default()
78 }
79 }
80
81 pub fn shift() -> Self {
82 Self {
83 shift: true,
84 ..Self::default()
85 }
86 }
87}
88
89#[derive(Clone, Debug, PartialEq)]
93pub enum MouseEvent {
94 Press {
96 row: u16,
97 col: u16,
98 button: MouseButton,
99 },
100 Release { row: u16, col: u16 },
102 ScrollUp { row: u16, col: u16 },
104 ScrollDown { row: u16, col: u16 },
106 Move { row: u16, col: u16 },
108}
109
110#[derive(Clone, Copy, Debug, PartialEq, Eq)]
112pub enum MouseButton {
113 Left,
114 Right,
115 Middle,
116}
117
118#[derive(Clone, Debug, PartialEq)]
122pub enum Event {
123 Key(KeyEvent),
125 Mouse(MouseEvent),
127 Resize { cols: u16, rows: u16 },
129 Paste(String),
131}
132
133#[derive(Default)]
141pub struct EventParser {
142 buf: Vec<u8>,
143}
144
145impl EventParser {
146 pub fn new() -> Self {
147 Self { buf: Vec::new() }
148 }
149
150 pub fn feed(&mut self, bytes: &[u8]) {
152 self.buf.extend_from_slice(bytes);
153 }
154
155 pub fn parse(&mut self) -> Option<Event> {
160 if self.buf.is_empty() {
161 return None;
162 }
163
164 if self.buf[0] == 0x1b && self.buf.len() > 1 {
166 return self.parse_escape_sequence();
167 }
168
169 let byte = self.buf[0];
171 self.buf.drain(..1); match byte {
174 0x0D | 0x0A => Some(Event::Key(KeyEvent {
176 key: Key::Enter,
177 modifiers: Modifiers::new(),
178 })),
179 0x09 => Some(Event::Key(KeyEvent {
180 key: Key::Tab,
181 modifiers: Modifiers::new(),
182 })),
183 0x7F => Some(Event::Key(KeyEvent {
184 key: Key::Backspace,
185 modifiers: Modifiers::new(),
186 })),
187 0x1B => Some(Event::Key(KeyEvent {
188 key: Key::Escape,
189 modifiers: Modifiers::new(),
190 })),
191 0x01..=0x1A => Some(Event::Key(KeyEvent {
193 key: Key::Char((b'a' + (byte - 0x01)) as char),
194 modifiers: Modifiers::ctrl(),
195 })),
196 byte if byte >= 0x20 => Some(Event::Key(KeyEvent {
198 key: Key::Char(byte as char),
199 modifiers: Modifiers::new(),
200 })),
201 _ => None,
203 }
204 }
205
206 fn parse_escape_sequence(&mut self) -> Option<Event> {
208 let buf = &self.buf;
209
210 if buf.len() >= 6 && &buf[0..6] == b"\x1b[200~" {
212 if let Some(end) = self.find_bracketed_paste_end() {
214 let paste_content = String::from_utf8_lossy(&buf[6..end]).to_string();
215 self.buf.drain(..end + 6);
216 return Some(Event::Paste(paste_content));
217 }
218 return None;
220 }
221
222 if buf.len() >= 2 && buf[1] == b'[' {
224 return self.parse_csi_sequence();
225 }
226
227 if buf.len() >= 2 {
229 let alt_key = buf[1];
230 self.buf.drain(..2);
231 match alt_key {
232 0x0D | 0x0A => Some(Event::Key(KeyEvent {
233 key: Key::Enter,
234 modifiers: Modifiers::alt(),
235 })),
236 0x7F => Some(Event::Key(KeyEvent {
237 key: Key::Backspace,
238 modifiers: Modifiers::alt(),
239 })),
240 byte if byte >= 0x20 => Some(Event::Key(KeyEvent {
241 key: Key::Char(byte as char),
242 modifiers: Modifiers::alt(),
243 })),
244 _ => None,
245 }
246 } else {
247 None
250 }
251 }
252
253 fn parse_csi_sequence(&mut self) -> Option<Event> {
255 let end_pos = self.buf[2..]
257 .iter()
258 .position(|&b| (0x40..=0x7E).contains(&b))
259 .map(|p| p + 2);
260
261 let end = match end_pos {
262 Some(p) => p,
263 None => {
264 if self.buf.len() > 20 {
268 self.buf.drain(..1); return None;
270 }
271 return None;
272 }
273 };
274
275 let params = self.buf[2..end].to_vec();
277 let final_byte = self.buf[end];
278
279 self.buf.drain(..=end);
281
282 self.dispatch_csi(¶ms, final_byte)
284 }
285
286 fn dispatch_csi(&self, params: &[u8], final_byte: u8) -> Option<Event> {
288 let param_str = std::str::from_utf8(params).unwrap_or("");
294 let is_sgr_mouse = param_str.starts_with('<');
295 let clean_str = if is_sgr_mouse {
296 ¶m_str[1..]
297 } else {
298 param_str
299 };
300 let nums: Vec<u16> = clean_str
301 .split(';')
302 .filter_map(|s| s.parse().ok())
303 .collect();
304
305 let mods = Self::parse_modifiers(nums.get(1));
306
307 match final_byte {
308 b'A' => Some(Event::Key(KeyEvent {
310 key: Key::Up,
311 modifiers: mods,
312 })),
313 b'B' => Some(Event::Key(KeyEvent {
314 key: Key::Down,
315 modifiers: mods,
316 })),
317 b'C' => Some(Event::Key(KeyEvent {
318 key: Key::Right,
319 modifiers: mods,
320 })),
321 b'D' => Some(Event::Key(KeyEvent {
322 key: Key::Left,
323 modifiers: mods,
324 })),
325 b'H' => Some(Event::Key(KeyEvent {
326 key: Key::Home,
327 modifiers: mods,
328 })),
329 b'F' => Some(Event::Key(KeyEvent {
330 key: Key::End,
331 modifiers: mods,
332 })),
333
334 b'P' => Some(Event::Key(KeyEvent {
336 key: Key::F(1),
337 modifiers: mods,
338 })),
339 b'Q' => Some(Event::Key(KeyEvent {
340 key: Key::F(2),
341 modifiers: mods,
342 })),
343 b'R' => Some(Event::Key(KeyEvent {
344 key: Key::F(3),
345 modifiers: mods,
346 })),
347 b'S' => Some(Event::Key(KeyEvent {
348 key: Key::F(4),
349 modifiers: mods,
350 })),
351
352 b'~' => match nums.first().copied().unwrap_or(0) {
354 1 => Some(Event::Key(KeyEvent {
355 key: Key::Home,
356 modifiers: mods,
357 })),
358 2 => Some(Event::Key(KeyEvent {
359 key: Key::Insert,
360 modifiers: mods,
361 })),
362 3 => Some(Event::Key(KeyEvent {
363 key: Key::Delete,
364 modifiers: mods,
365 })),
366 4 => Some(Event::Key(KeyEvent {
367 key: Key::End,
368 modifiers: mods,
369 })),
370 5 => Some(Event::Key(KeyEvent {
371 key: Key::PageUp,
372 modifiers: mods,
373 })),
374 6 => Some(Event::Key(KeyEvent {
375 key: Key::PageDown,
376 modifiers: mods,
377 })),
378 11..=15 => Some(Event::Key(KeyEvent {
379 key: Key::F((nums[0] - 10) as u8),
380 modifiers: mods,
381 })),
382 17..=21 => Some(Event::Key(KeyEvent {
383 key: Key::F((nums[0] - 11) as u8),
384 modifiers: mods,
385 })),
386 23 => Some(Event::Key(KeyEvent {
387 key: Key::F(12),
388 modifiers: mods,
389 })),
390 _ => None,
391 },
392
393 b'M' => self.parse_xterm_mouse(&nums, false),
395 b'm' => self.parse_xterm_mouse(&nums, true),
396
397 _ => None,
398 }
399 }
400
401 fn parse_modifiers(mod_code: Option<&u16>) -> Modifiers {
410 let code = mod_code.copied().unwrap_or(0);
411 Modifiers {
412 shift: code == 2 || code == 4 || code == 6 || code == 8,
413 alt: code == 3 || code == 7,
414 ctrl: code == 5 || code == 6 || code == 7 || code == 8,
415 }
416 }
417
418 fn parse_xterm_mouse(&self, nums: &[u16], release: bool) -> Option<Event> {
425 if nums.len() < 3 {
426 return None;
427 }
428 let button_code = nums[0];
429 let col = nums[1].saturating_sub(1);
430 let row = nums[2].saturating_sub(1);
431
432 if release {
433 Some(Event::Mouse(MouseEvent::Release { row, col }))
434 } else {
435 match button_code {
436 0 => Some(Event::Mouse(MouseEvent::Press {
437 row,
438 col,
439 button: MouseButton::Left,
440 })),
441 1 => Some(Event::Mouse(MouseEvent::Press {
442 row,
443 col,
444 button: MouseButton::Middle,
445 })),
446 2 => Some(Event::Mouse(MouseEvent::Press {
447 row,
448 col,
449 button: MouseButton::Right,
450 })),
451 64 => Some(Event::Mouse(MouseEvent::ScrollUp { row, col })),
452 65 => Some(Event::Mouse(MouseEvent::ScrollDown { row, col })),
453 _ => None,
454 }
455 }
456 }
457
458 fn find_bracketed_paste_end(&self) -> Option<usize> {
460 let end_marker = b"\x1b[201~";
461 self.buf
462 .windows(end_marker.len())
463 .position(|w| w == end_marker)
464 }
465}
466
467pub struct EventReader {
474 #[allow(dead_code)]
475 tx: std::sync::mpsc::Sender<Event>,
476 rx: std::sync::mpsc::Receiver<Event>,
477}
478
479impl EventReader {
480 pub fn new() -> io::Result<Self> {
485 let (tx, rx) = std::sync::mpsc::channel();
486 Ok(Self { tx, rx })
487 }
488
489 pub fn start(&self) {
494 }
498
499 pub fn recv_timeout(&self, timeout: Duration) -> Option<Event> {
501 self.rx.recv_timeout(timeout).ok()
502 }
503}
504
505#[cfg(test)]
506mod tests {
507 use super::*;
508
509 #[test]
510 fn test_parse_regular_char() {
511 let mut parser = EventParser::new();
512 parser.feed(b"a");
513 let event = parser.parse().unwrap();
514 assert_eq!(
515 event,
516 Event::Key(KeyEvent {
517 key: Key::Char('a'),
518 modifiers: Modifiers::new(),
519 })
520 );
521 }
522
523 #[test]
524 fn test_parse_enter() {
525 let mut parser = EventParser::new();
526 parser.feed(b"\r");
527 let event = parser.parse().unwrap();
528 assert_eq!(
529 event,
530 Event::Key(KeyEvent {
531 key: Key::Enter,
532 modifiers: Modifiers::new(),
533 })
534 );
535 }
536
537 #[test]
538 fn test_parse_tab() {
539 let mut parser = EventParser::new();
540 parser.feed(b"\t");
541 let event = parser.parse().unwrap();
542 assert_eq!(
543 event,
544 Event::Key(KeyEvent {
545 key: Key::Tab,
546 modifiers: Modifiers::new(),
547 })
548 );
549 }
550
551 #[test]
552 fn test_parse_backspace() {
553 let mut parser = EventParser::new();
554 parser.feed(b"\x7f");
555 let event = parser.parse().unwrap();
556 assert_eq!(
557 event,
558 Event::Key(KeyEvent {
559 key: Key::Backspace,
560 modifiers: Modifiers::new(),
561 })
562 );
563 }
564
565 #[test]
566 fn test_parse_ctrl_a() {
567 let mut parser = EventParser::new();
568 parser.feed(b"\x01");
569 let event = parser.parse().unwrap();
570 assert_eq!(
571 event,
572 Event::Key(KeyEvent {
573 key: Key::Char('a'),
574 modifiers: Modifiers::ctrl(),
575 })
576 );
577 }
578
579 #[test]
580 fn test_parse_ctrl_c() {
581 let mut parser = EventParser::new();
582 parser.feed(b"\x03");
583 let event = parser.parse().unwrap();
584 assert_eq!(
585 event,
586 Event::Key(KeyEvent {
587 key: Key::Char('c'),
588 modifiers: Modifiers::ctrl(),
589 })
590 );
591 }
592
593 #[test]
594 fn test_parse_arrow_up() {
595 let mut parser = EventParser::new();
596 parser.feed(b"\x1b[A");
597 let event = parser.parse().unwrap();
598 assert_eq!(
599 event,
600 Event::Key(KeyEvent {
601 key: Key::Up,
602 modifiers: Modifiers::new(),
603 })
604 );
605 }
606
607 #[test]
608 fn test_parse_arrow_down() {
609 let mut parser = EventParser::new();
610 parser.feed(b"\x1b[B");
611 let event = parser.parse().unwrap();
612 assert_eq!(
613 event,
614 Event::Key(KeyEvent {
615 key: Key::Down,
616 modifiers: Modifiers::new(),
617 })
618 );
619 }
620
621 #[test]
622 fn test_parse_arrow_right() {
623 let mut parser = EventParser::new();
624 parser.feed(b"\x1b[C");
625 let event = parser.parse().unwrap();
626 assert_eq!(
627 event,
628 Event::Key(KeyEvent {
629 key: Key::Right,
630 modifiers: Modifiers::new(),
631 })
632 );
633 }
634
635 #[test]
636 fn test_parse_arrow_left() {
637 let mut parser = EventParser::new();
638 parser.feed(b"\x1b[D");
639 let event = parser.parse().unwrap();
640 assert_eq!(
641 event,
642 Event::Key(KeyEvent {
643 key: Key::Left,
644 modifiers: Modifiers::new(),
645 })
646 );
647 }
648
649 #[test]
650 fn test_parse_ctrl_arrow_up() {
651 let mut parser = EventParser::new();
652 parser.feed(b"\x1b[1;5A");
654 let event = parser.parse().unwrap();
655 assert_eq!(
656 event,
657 Event::Key(KeyEvent {
658 key: Key::Up,
659 modifiers: Modifiers {
660 ctrl: true,
661 alt: false,
662 shift: false
663 },
664 })
665 );
666 }
667
668 #[test]
669 fn test_parse_shift_arrow_up() {
670 let mut parser = EventParser::new();
671 parser.feed(b"\x1b[1;2A");
673 let event = parser.parse().unwrap();
674 assert_eq!(
675 event,
676 Event::Key(KeyEvent {
677 key: Key::Up,
678 modifiers: Modifiers {
679 ctrl: false,
680 alt: false,
681 shift: true
682 },
683 })
684 );
685 }
686
687 #[test]
688 fn test_parse_alt_key() {
689 let mut parser = EventParser::new();
690 parser.feed(b"\x1ba");
691 let event = parser.parse().unwrap();
692 assert_eq!(
693 event,
694 Event::Key(KeyEvent {
695 key: Key::Char('a'),
696 modifiers: Modifiers::alt(),
697 })
698 );
699 }
700
701 #[test]
702 fn test_parse_home() {
703 let mut parser = EventParser::new();
704 parser.feed(b"\x1b[H");
705 let event = parser.parse().unwrap();
706 assert_eq!(
707 event,
708 Event::Key(KeyEvent {
709 key: Key::Home,
710 modifiers: Modifiers::new(),
711 })
712 );
713 }
714
715 #[test]
716 fn test_parse_end() {
717 let mut parser = EventParser::new();
718 parser.feed(b"\x1b[F");
719 let event = parser.parse().unwrap();
720 assert_eq!(
721 event,
722 Event::Key(KeyEvent {
723 key: Key::End,
724 modifiers: Modifiers::new(),
725 })
726 );
727 }
728
729 #[test]
730 fn test_parse_page_up() {
731 let mut parser = EventParser::new();
732 parser.feed(b"\x1b[5~");
733 let event = parser.parse().unwrap();
734 assert_eq!(
735 event,
736 Event::Key(KeyEvent {
737 key: Key::PageUp,
738 modifiers: Modifiers::new(),
739 })
740 );
741 }
742
743 #[test]
744 fn test_parse_page_down() {
745 let mut parser = EventParser::new();
746 parser.feed(b"\x1b[6~");
747 let event = parser.parse().unwrap();
748 assert_eq!(
749 event,
750 Event::Key(KeyEvent {
751 key: Key::PageDown,
752 modifiers: Modifiers::new(),
753 })
754 );
755 }
756
757 #[test]
758 fn test_parse_delete() {
759 let mut parser = EventParser::new();
760 parser.feed(b"\x1b[3~");
761 let event = parser.parse().unwrap();
762 assert_eq!(
763 event,
764 Event::Key(KeyEvent {
765 key: Key::Delete,
766 modifiers: Modifiers::new(),
767 })
768 );
769 }
770
771 #[test]
772 fn test_parse_multiple_events() {
773 let mut parser = EventParser::new();
774 parser.feed(b"abc");
775 let a = parser.parse().unwrap();
776 let b = parser.parse().unwrap();
777 let c = parser.parse().unwrap();
778 assert_eq!(
779 a,
780 Event::Key(KeyEvent {
781 key: Key::Char('a'),
782 modifiers: Modifiers::new()
783 })
784 );
785 assert_eq!(
786 b,
787 Event::Key(KeyEvent {
788 key: Key::Char('b'),
789 modifiers: Modifiers::new()
790 })
791 );
792 assert_eq!(
793 c,
794 Event::Key(KeyEvent {
795 key: Key::Char('c'),
796 modifiers: Modifiers::new()
797 })
798 );
799 }
800
801 #[test]
802 fn test_modifiers_ctrl() {
803 let mods = Modifiers::ctrl();
804 assert!(mods.ctrl);
805 assert!(!mods.alt);
806 assert!(!mods.shift);
807 }
808
809 #[test]
810 fn test_modifiers_alt() {
811 let mods = Modifiers::alt();
812 assert!(!mods.ctrl);
813 assert!(mods.alt);
814 assert!(!mods.shift);
815 }
816
817 #[test]
818 fn test_parse_sgr_mouse_scroll_up() {
819 let mut parser = EventParser::new();
822 parser.feed(b"\x1b[<64;10;5M");
823 let event = parser.parse().unwrap();
824 assert_eq!(event, Event::Mouse(MouseEvent::ScrollUp { row: 4, col: 9 }));
825 }
826
827 #[test]
828 fn test_parse_sgr_mouse_scroll_down() {
829 let mut parser = EventParser::new();
832 parser.feed(b"\x1b[<65;10;5M");
833 let event = parser.parse().unwrap();
834 assert_eq!(
835 event,
836 Event::Mouse(MouseEvent::ScrollDown { row: 4, col: 9 })
837 );
838 }
839
840 #[test]
841 fn test_parse_sgr_mouse_left_click() {
842 let mut parser = EventParser::new();
844 parser.feed(b"\x1b[<0;1;1M");
845 let event = parser.parse().unwrap();
846 assert_eq!(
847 event,
848 Event::Mouse(MouseEvent::Press {
849 row: 0,
850 col: 0,
851 button: MouseButton::Left,
852 })
853 );
854 }
855}