still dark; refactor tui engine input/output

engine/src/tui/tui_input.rs

@@ -0,0 +1,150 @@
+use crate::{*, tui::*};
+
+#[derive(Debug, Clone)]
+pub struct TuiInput {
+    pub(crate) exited: Arc<AtomicBool>,
+    pub(crate) event: crossterm::event::Event,
+}
+
+impl Input<Tui> for TuiInput {
+    type Event = crossterm::event::Event;
+    fn event (&self) -> &crossterm::event::Event {
+        &self.event
+    }
+    fn is_done (&self) -> bool {
+        self.exited.fetch_and(true, Relaxed)
+    }
+    fn done (&self) {
+        self.exited.store(true, Relaxed);
+    }
+}
+
+#[macro_export] macro_rules! key_pat {
+    (Ctrl-Alt-$code:pat) => { key_event_pat!($code, KeyModifiers::CONTROL | KeyModifiers::ALT) };
+    (Ctrl-$code:pat)     => { key_event_pat!($code, KeyModifiers::CONTROL) };
+    (Alt-$code:pat)      => { key_event_pat!($code, KeyModifiers::ALT) };
+    (Shift-$code:pat)    => { key_event_pat!($code, KeyModifiers::SHIFT) };
+    ($code:pat)          => { crossterm::event::Event::Key(KeyEvent {
+        code:      $code,
+        modifiers: KeyModifiers::NONE,
+        kind:      KeyEventKind::Press,
+        state:     KeyEventState::NONE
+    }) };
+}
+
+#[macro_export] macro_rules! key_event_pat {
+    ($code:pat) => {
+        crossterm::event::Event::Key(KeyEvent {
+            code:      $code,
+            modifiers: KeyModifiers::NONE,
+            kind:      KeyEventKind::Press,
+            state:     KeyEventState::NONE
+        })
+    };
+    ($code:pat, $modifiers: pat) => {
+        crossterm::event::Event::Key(KeyEvent {
+            code:      $code,
+            modifiers: $modifiers,
+            kind:      KeyEventKind::Press,
+            state:     KeyEventState::NONE
+        })
+    };
+}
+
+#[macro_export] macro_rules! kexp {
+    (Ctrl-Alt-$code:ident) => { key_event_expr!($code, KeyModifiers::from_bits(0b0000_0110).unwrap()) };
+    (Ctrl-$code:ident)     => { key_event_expr!($code, KeyModifiers::CONTROL) };
+    (Alt-$code:ident)      => { key_event_expr!($code, KeyModifiers::ALT) };
+    (Shift-$code:ident)    => { key_event_expr!($code, KeyModifiers::SHIFT) };
+    ($code:ident)          => { key_event_expr!($code) };
+    ($code:expr)           => { key_event_expr!($code) };
+}
+
+#[macro_export] macro_rules! key_expr {
+    (Ctrl-Alt-$code:ident) => { key_event_expr!($code, KeyModifiers::CONTROL | KeyModifiers::ALT) };
+    (Ctrl-$code:ident)     => { key_event_expr!($code, KeyModifiers::CONTROL) };
+    (Alt-$code:ident)      => { key_event_expr!($code, KeyModifiers::ALT) };
+    (Shift-$code:ident)    => { key_event_expr!($code, KeyModifiers::SHIFT) };
+    ($code:ident)          => { key_event_expr!($code) };
+}
+
+#[macro_export] macro_rules! key_event_expr {
+    ($code:expr, $modifiers: expr) => {
+        crossterm::event::Event::Key(KeyEvent {
+            code:      $code,
+            modifiers: $modifiers,
+            kind:      KeyEventKind::Press,
+            state:     KeyEventState::NONE
+        })
+    };
+    ($code:expr) => {
+        crossterm::event::Event::Key(KeyEvent {
+            code:      $code,
+            modifiers: KeyModifiers::NONE,
+            kind:      KeyEventKind::Press,
+            state:     KeyEventState::NONE
+        })
+    };
+}
+
+/// Define a key
+pub const fn key (code: KeyCode) -> KeyEvent {
+    let modifiers = KeyModifiers::NONE;
+    let kind      = KeyEventKind::Press;
+    let state     = KeyEventState::NONE;
+    KeyEvent { code, modifiers, kind, state }
+}
+
+/// Add Ctrl modifier to key
+pub const fn ctrl (key: KeyEvent) -> KeyEvent {
+    KeyEvent { modifiers: key.modifiers.union(KeyModifiers::CONTROL), ..key }
+}
+
+/// Add Alt modifier to key
+pub const fn alt (key: KeyEvent) -> KeyEvent {
+    KeyEvent { modifiers: key.modifiers.union(KeyModifiers::ALT), ..key }
+}
+
+/// Add Shift modifier to key
+pub const fn shift (key: KeyEvent) -> KeyEvent {
+    KeyEvent { modifiers: key.modifiers.union(KeyModifiers::SHIFT), ..key }
+}
+
+/*
+/// Define a keymap
+#[macro_export] macro_rules! keymap {
+    ($T:ty { $([$k:ident $(($char:literal))?, $m:ident, $n: literal, $d: literal, $f: expr]),* $(,)? }) => {
+        &[
+            $((KeyCode::$k $(($char))?, KeyModifiers::$m, $n, $d, &$f as KeyHandler<$T>)),*
+        ] as &'static [KeyBinding<$T>]
+    }
+}
+
+*/
+
+/*
+
+impl TuiInput {
+    // TODO remove
+    pub fn handle_keymap <T> (&self, state: &mut T, keymap: &KeyMap<T>) -> Usually<bool> {
+        match self.event() {
+            TuiEvent::Input(Key(event)) => {
+                for (code, modifiers, _, _, command) in keymap.iter() {
+                    if *code == event.code && modifiers.bits() == event.modifiers.bits() {
+                        return command(state)
+                    }
+                }
+            },
+            _ => {}
+        };
+        Ok(false)
+    }
+}
+
+pub type KeyHandler<T> = &'static dyn Fn(&mut T)->Usually<bool>;
+
+pub type KeyBinding<T> = (KeyCode, KeyModifiers, &'static str, &'static str, KeyHandler<T>);
+
+pub type KeyMap<T> = [KeyBinding<T>];
+
+*/