some more core refactor before fixing the mess

crates/tek_core/src/engine/exit.rs

@@ -0,0 +1,32 @@
+use crate::*;
+
+pub trait Exit: Send {
+    fn exited (&self) -> bool;
+    fn exit (&mut self);
+    fn boxed (self) -> Box<dyn Exit> where Self: Sized + 'static {
+        Box::new(self)
+    }
+}
+
+/// Marker trait for [Component]s that can [Exit]
+pub trait ExitableComponent<E>: Exit + Component<E> where E: Engine {
+    /// Perform type erasure for collecting heterogeneous components.
+    fn boxed (self) -> Box<dyn ExitableComponent<E>> where Self: Sized + 'static {
+        Box::new(self)
+    }
+}
+
+impl<E: Engine, C: Component<E> + Exit> ExitableComponent<E> for C {}
+
+#[macro_export] macro_rules! exit {
+    ($T:ty) => {
+        impl Exit for $T {
+            fn exited (&self) -> bool {
+                self.exited
+            }
+            fn exit (&mut self) {
+                self.exited = true
+            }
+        }
+    }
+}

crates/tek_core/src/engine/focus.rs

@@ -0,0 +1,98 @@
+use crate::*;
+
+/// A component that may contain [Focusable] components.
+pub trait Focus <const N: usize, E: Engine>: Render<E> + Handle<E> {
+    fn focus (&self) -> usize;
+    fn focus_mut (&mut self) -> &mut usize;
+    fn focusable (&self) -> [&dyn Focusable<E>;N];
+    fn focusable_mut (&mut self) -> [&mut dyn Focusable<E>;N];
+
+    fn focused (&self) -> &dyn Focusable<E> {
+        let focus = self.focus();
+        self.focusable()[focus]
+    }
+    fn focused_mut (&mut self) -> &mut dyn Focusable<E> {
+        let focus = self.focus();
+        self.focusable_mut()[focus]
+    }
+    fn focus_prev (&mut self) {
+        let focus = self.focus();
+        self.focus_set(if focus > 0 { focus - 1 } else { N - 1 });
+    }
+    fn focus_next (&mut self) {
+        let focus = self.focus();
+        self.focus_set(if focus < N - 1 { focus + 1 } else { 0 });
+    }
+    fn focus_set (&mut self, focus: usize) {
+        *self.focus_mut() = focus;
+        let focusable = self.focusable_mut();
+        for index in 0..N {
+            focusable[index].set_focused(index == focus);
+        }
+    }
+}
+
+/// A component that may be focused.
+pub trait Focusable<E: Engine>: Render<E> + Handle<E> {
+    fn is_focused (&self) -> bool;
+    fn set_focused (&mut self, focused: bool);
+}
+
+impl<F: Focusable<E>, E: Engine> Focusable<E> for Option<F>
+    where Option<F>: Render<E>
+{
+    fn is_focused (&self) -> bool {
+        match self {
+            Some(focusable) => focusable.is_focused(),
+            None => false
+        }
+    }
+    fn set_focused (&mut self, focused: bool) {
+        if let Some(focusable) = self {
+            focusable.set_focused(focused)
+        }
+    }
+}
+
+/// Implement the [Focus] trait for a component.
+#[macro_export] macro_rules! focus {
+    ($struct:ident ($focus:ident) : $count:expr => [
+       $($focusable:ident),*
+    ]) => {
+        impl Focus<$count, E> for $struct {
+            fn focus (&self) -> usize {
+                self.$focus
+            }
+            fn focus_mut (&mut self) -> &mut usize {
+                &mut self.$focus
+            }
+            fn focusable (&self) -> [&dyn Focusable<E>;$count] {
+                [
+                    $(&self.$focusable as &dyn Focusable<E>,)*
+                ]
+            }
+            fn focusable_mut (&mut self) -> [&mut dyn Focusable<E>;$count] {
+                [
+                    $(&mut self.$focusable as &mut dyn Focusable<E>,)*
+                ]
+            }
+        }
+    }
+}
+
+/// Implement the [Focusable] trait for a component.
+#[macro_export] macro_rules! focusable {
+    ($struct:ident) => {
+        focusable!($struct (focused));
+    };
+    ($struct:ident ($focused:ident)) => {
+        impl Focusable for $struct {
+            fn is_focused (&self) -> bool {
+                self.$focused
+            }
+            fn set_focused (&mut self, focused: bool) {
+                self.$focused = focused
+            }
+        }
+    }
+}

crates/tek_core/src/engine/keymap.rs

@@ -0,0 +1,85 @@
+use crate::*;
+
+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>];
+
+pub fn handle_keymap <T> (
+    state: &mut T, event: &TuiEvent, keymap: &KeyMap<T>,
+) -> Usually<bool> {
+    match event {
+        TuiEvent::Input(crossterm::event::Event::Key(event)) => {
+            for (code, modifiers, _, _, command) in keymap.iter() {
+                if *code == event.code && modifiers.bits() == event.modifiers.bits() {
+                    return command(state)
+                }
+            }
+        },
+        _ => {}
+    };
+    Ok(false)
+}
+
+/// 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>]
+    }
+}
+
+#[macro_export] macro_rules! map_key {
+    ($k:ident $(($char:literal))?, $m:ident, $n: literal, $d: literal, $f: expr) => {
+        (KeyCode::$k $(($char))?, KeyModifiers::$m, $n, $d, &$f as &dyn Fn()->Usually<bool>)
+    }
+}
+
+#[macro_export] macro_rules! key {
+    ($code:pat) => {
+        TuiEvent::Input(crossterm::event::Event::Key(crossterm::event::KeyEvent {
+            code:      $code,
+            modifiers: crossterm::event::KeyModifiers::NONE,
+            kind:      crossterm::event::KeyEventKind::Press,
+            state:     crossterm::event::KeyEventState::NONE
+        }))
+    };
+    (Ctrl-$code:pat) => {
+        TuiEvent::Input(crossterm::event::Event::Key(crossterm::event::KeyEvent {
+            code:      $code,
+            modifiers: crossterm::event::KeyModifiers::CONTROL,
+            kind:      crossterm::event::KeyEventKind::Press,
+            state:     crossterm::event::KeyEventState::NONE
+        }))
+    };
+    (Alt-$code:pat) => {
+        TuiEvent::Input(crossterm::event::Event::Key(crossterm::event::KeyEvent {
+            code:      $code,
+            modifiers: crossterm::event::KeyModifiers::ALT,
+            kind:      crossterm::event::KeyEventKind::Press,
+            state:     crossterm::event::KeyEventState::NONE
+        }))
+    }
+}
+
+#[macro_export] macro_rules! match_key {
+    ($event:expr, {
+        $($key:pat=>$block:expr),* $(,)?
+    }) => {
+        match $event {
+            $(crossterm::event::Event::Key(crossterm::event::KeyEvent {
+                code:      $key,
+                modifiers: crossterm::event::KeyModifiers::NONE,
+                kind:      crossterm::event::KeyEventKind::Press,
+                state:     crossterm::event::KeyEventState::NONE
+            }) => {
+                $block
+            })*
+            _ => Ok(None)
+        }
+    }
+}