remodularize 3

tui/src/lib.rs

@@ -19,10 +19,13 @@ mod tui_theme;  pub use self::tui_theme::*;
 mod tui_border; pub use self::tui_border::*;
 mod tui_field;  pub use self::tui_field::*;
 mod tui_buffer; pub use self::tui_buffer::*;
+mod tui_file;   pub use self::tui_file::*;
 
 pub(crate) use std::sync::{Arc, RwLock, atomic::{AtomicUsize, AtomicBool, Ordering::*}};
 pub(crate) use std::io::{stdout, Stdout};
 pub(crate) use std::error::Error;
+pub(crate) use std::path::PathBuf;
+pub(crate) use std::ffi::OsString;
 
 /// Standard result type.
 pub type Usually<T> = Result<T, Box<dyn Error>>;

tui/src/tui_file.rs

@@ -0,0 +1,87 @@
+use crate::*;
+/// Browses for phrase to import/export
+#[derive(Debug, Clone)]
+pub struct FileBrowser {
+    pub cwd:    PathBuf,
+    pub dirs:   Vec<(OsString, String)>,
+    pub files:  Vec<(OsString, String)>,
+    pub filter: String,
+    pub index:  usize,
+    pub scroll: usize,
+    pub size:   Measure<TuiOut>
+}
+/// Commands supported by [FileBrowser]
+#[derive(Debug, Clone, PartialEq)]
+pub enum FileBrowserCommand {
+    Begin,
+    Cancel,
+    Confirm,
+    Select(usize),
+    Chdir(PathBuf),
+    Filter(Arc<str>),
+}
+render!(TuiOut: (self: FileBrowser) => /*Stack::down(|add|{
+    let mut i = 0;
+    for (_, name) in self.dirs.iter() {
+        if i >= self.scroll {
+            add(&Tui::bold(i == self.index, name.as_str()))?;
+        }
+        i += 1;
+    }
+    for (_, name) in self.files.iter() {
+        if i >= self.scroll {
+            add(&Tui::bold(i == self.index, name.as_str()))?;
+        }
+        i += 1;
+    }
+    add(&format!("{}/{i}", self.index))?;
+    Ok(())
+})*/"todo");
+impl FileBrowser {
+    pub fn new (cwd: Option<PathBuf>) -> Usually<Self> {
+        let cwd = if let Some(cwd) = cwd { cwd } else { std::env::current_dir()? };
+        let mut dirs  = vec![];
+        let mut files = vec![];
+        for entry in std::fs::read_dir(&cwd)? {
+            let entry = entry?;
+            let name = entry.file_name();
+            let decoded = name.clone().into_string().unwrap_or_else(|_|"<unreadable>".to_string());
+            let meta = entry.metadata()?;
+            if meta.is_dir() {
+                dirs.push((name, format!("📁 {decoded}")));
+            } else if meta.is_file() {
+                files.push((name, format!("📄 {decoded}")));
+            }
+        }
+        Ok(Self {
+            cwd,
+            dirs,
+            files,
+            filter: "".to_string(),
+            index:  0,
+            scroll: 0,
+            size:   Measure::new(),
+        })
+    }
+    pub fn len (&self) -> usize {
+        self.dirs.len() + self.files.len()
+    }
+    pub fn is_dir (&self) -> bool {
+        self.index < self.dirs.len()
+    }
+    pub fn is_file (&self) -> bool {
+        self.index >= self.dirs.len()
+    }
+    pub fn path (&self) -> PathBuf {
+        self.cwd.join(if self.is_dir() {
+            &self.dirs[self.index].0
+        } else if self.is_file() {
+            &self.files[self.index - self.dirs.len()].0
+        } else {
+            unreachable!()
+        })
+    }
+    pub fn chdir (&self) -> Usually<Self> {
+        Self::new(Some(self.path()))
+    }
+}

tui/src/tui_focus.rs

@@ -0,0 +1,306 @@
+use crate::*;
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum FocusState<T: Copy + Debug + PartialEq> {
+    Focused(T),
+    Entered(T),
+}
+
+impl<T: Copy + Debug + PartialEq> FocusState<T> {
+    pub fn inner (&self) -> T {
+        match self {
+            Self::Focused(inner) => *inner,
+            Self::Entered(inner) => *inner,
+        }
+    }
+    pub fn set_inner (&mut self, inner: T) {
+        *self = match self {
+            Self::Focused(_) => Self::Focused(inner),
+            Self::Entered(_) => Self::Entered(inner),
+        }
+    }
+    pub fn is_focused (&self) -> bool { matches!(self, Self::Focused(_)) }
+    pub fn is_entered (&self) -> bool { matches!(self, Self::Entered(_)) }
+    pub fn focus (&mut self) { *self = Self::Focused(self.inner()) }
+    pub fn enter (&mut self) { *self = Self::Entered(self.inner()) }
+}
+
+#[derive(Copy, Clone, PartialEq, Debug)]
+pub enum FocusCommand<T: Send + Sync> {
+    Up,
+    Down,
+    Left,
+    Right,
+    Next,
+    Prev,
+    Enter,
+    Exit,
+    Set(T)
+}
+
+impl<F: HasFocus + HasEnter + FocusGrid + FocusOrder> Command<F> for FocusCommand<F::Item> {
+    fn execute (self, state: &mut F) -> Perhaps<FocusCommand<F::Item>> {
+        match self {
+            Self::Next  => { state.focus_next();  },
+            Self::Prev  => { state.focus_prev();  },
+            Self::Up    => { state.focus_up();    },
+            Self::Down  => { state.focus_down();  },
+            Self::Left  => { state.focus_left();  },
+            Self::Right => { state.focus_right(); },
+            Self::Enter => { state.focus_enter(); },
+            Self::Exit  => { state.focus_exit();  },
+            Self::Set(to) => { state.set_focused(to); },
+        }
+        Ok(None)
+    }
+}
+
+/// Trait for things that have focusable subparts.
+pub trait HasFocus {
+    type Item: Copy + PartialEq + Debug + Send + Sync;
+    /// Get the currently focused item.
+    fn focused (&self) -> Self::Item;
+    /// Get the currently focused item.
+    fn set_focused (&mut self, to: Self::Item);
+    /// Loop forward until a specific item is focused.
+    fn focus_to (&mut self, to: Self::Item) {
+        self.set_focused(to);
+        self.focus_updated();
+    }
+    /// Run this on focus update
+    fn focus_updated (&mut self) {}
+}
+
+/// Trait for things that have enterable subparts.
+pub trait HasEnter: HasFocus {
+    /// Get the currently focused item.
+    fn entered (&self) -> bool;
+    /// Get the currently focused item.
+    fn set_entered (&mut self, entered: bool);
+    /// Enter into the currently focused component
+    fn focus_enter (&mut self) {
+        self.set_entered(true);
+        self.focus_updated();
+    }
+    /// Exit the currently entered component
+    fn focus_exit (&mut self) {
+        self.set_entered(false);
+        self.focus_updated();
+    }
+}
+
+/// Trait for things that implement directional navigation between focusable elements.
+pub trait FocusGrid: HasFocus {
+    fn focus_layout (&self) -> &[&[Self::Item]];
+    fn focus_cursor (&self) -> (usize, usize);
+    fn focus_cursor_mut (&mut self) -> &mut (usize, usize);
+    fn focus_current (&self) -> Self::Item {
+        let (x, y) = self.focus_cursor();
+        self.focus_layout()[y][x]
+    }
+    fn focus_update (&mut self) {
+        self.focus_to(self.focus_current());
+        self.focus_updated()
+    }
+    fn focus_up (&mut self) {
+        let original_focused = self.focused();
+        let (_, original_y) = self.focus_cursor();
+        loop {
+            let (x, y) = self.focus_cursor();
+            let next_y = if y == 0 {
+                self.focus_layout().len().saturating_sub(1)
+            } else {
+                y - 1
+            };
+            if next_y == original_y {
+                break
+            }
+            let next_x = if self.focus_layout()[y].len() == self.focus_layout()[next_y].len() {
+                x
+            } else {
+                ((x as f32 / self.focus_layout()[original_y].len() as f32)
+                    * self.focus_layout()[next_y].len() as f32) as usize
+            };
+            *self.focus_cursor_mut() = (next_x, next_y);
+            if self.focus_current() != original_focused {
+                break
+            }
+        }
+        self.focus_update();
+    }
+    fn focus_down (&mut self) {
+        let original_focused = self.focused();
+        let (_, original_y) = self.focus_cursor();
+        loop {
+            let (x, y) = self.focus_cursor();
+            let next_y = if y >= self.focus_layout().len().saturating_sub(1) {
+                0
+            } else {
+                y + 1
+            };
+            if next_y == original_y {
+                break
+            }
+            let next_x = if self.focus_layout()[y].len() == self.focus_layout()[next_y].len() {
+                x
+            } else {
+                ((x as f32 / self.focus_layout()[original_y].len() as f32)
+                    * self.focus_layout()[next_y].len() as f32) as usize
+            };
+            *self.focus_cursor_mut() = (next_x, next_y);
+            if self.focus_current() != original_focused {
+                break
+            }
+        }
+        self.focus_update();
+    }
+    fn focus_left (&mut self) {
+        let original_focused = self.focused();
+        let (original_x, y) = self.focus_cursor();
+        loop {
+            let x = self.focus_cursor().0;
+            let next_x = if x == 0 {
+                self.focus_layout()[y].len().saturating_sub(1)
+            } else {
+                x - 1
+            };
+            if next_x == original_x {
+                break
+            }
+            *self.focus_cursor_mut() = (next_x, y);
+            if self.focus_current() != original_focused {
+                break
+            }
+        }
+        self.focus_update();
+    }
+    fn focus_right (&mut self) {
+        let original_focused = self.focused();
+        let (original_x, y) = self.focus_cursor();
+        loop {
+            let x = self.focus_cursor().0;
+            let next_x = if x >= self.focus_layout()[y].len().saturating_sub(1) {
+                0
+            } else {
+                x + 1
+            };
+            if next_x == original_x {
+                break
+            }
+            self.focus_cursor_mut().0 = next_x;
+            if self.focus_current() != original_focused {
+                break
+            }
+        }
+        self.focus_update();
+    }
+}
+
+/// Trait for things that implement next/prev navigation between focusable elements.
+pub trait FocusOrder {
+    /// Focus the next item.
+    fn focus_next (&mut self);
+    /// Focus the previous item.
+    fn focus_prev (&mut self);
+}
+
+/// Next/prev navigation for directional focusables works in the given way.
+impl<T: FocusGrid + HasEnter> FocusOrder for T {
+    /// Focus the next item.
+    fn focus_next (&mut self) {
+        let current = self.focused();
+        let (x, y) = self.focus_cursor();
+        if x < self.focus_layout()[y].len().saturating_sub(1) {
+            self.focus_right();
+        } else {
+            self.focus_down();
+            self.focus_cursor_mut().0 = 0;
+        }
+        if self.focused() == current { // FIXME: prevent infinite loop
+            self.focus_next()
+        }
+        self.focus_exit();
+        self.focus_update();
+    }
+    /// Focus the previous item.
+    fn focus_prev (&mut self) {
+        let current = self.focused();
+        let (x, _) = self.focus_cursor();
+        if x > 0 {
+            self.focus_left();
+        } else {
+            self.focus_up();
+            let (_, y) = self.focus_cursor();
+            let next_x = self.focus_layout()[y].len().saturating_sub(1);
+            self.focus_cursor_mut().0 = next_x;
+        }
+        if self.focused() == current { // FIXME: prevent infinite loop
+            self.focus_prev()
+        }
+        self.focus_exit();
+        self.focus_update();
+    }
+}
+
+pub trait FocusWrap<T> {
+    fn wrap <W: Content<TuiOut>> (self, focus: T, content: &'_ W) -> impl Content<TuiOut> + '_;
+}
+
+pub fn to_focus_command <T: Send + Sync> (input: &TuiIn) -> Option<FocusCommand<T>> {
+    Some(match input.event() {
+        kpat!(Tab)           => FocusCommand::Next,
+        kpat!(Shift-Tab)     => FocusCommand::Prev,
+        kpat!(BackTab)       => FocusCommand::Prev,
+        kpat!(Shift-BackTab) => FocusCommand::Prev,
+        kpat!(Up)            => FocusCommand::Up,
+        kpat!(Down)          => FocusCommand::Down,
+        kpat!(Left)          => FocusCommand::Left,
+        kpat!(Right)         => FocusCommand::Right,
+        kpat!(Enter)         => FocusCommand::Enter,
+        kpat!(Esc)           => FocusCommand::Exit,
+        _ => return None
+    })
+}
+
+#[macro_export] macro_rules! impl_focus {
+    ($Struct:ident $Focus:ident $Grid:expr $(=> [$self:ident : $update_focus:expr])?) => {
+        impl HasFocus for $Struct {
+            type Item = $Focus;
+            /// Get the currently focused item.
+            fn focused (&self) -> Self::Item {
+                self.focus.inner()
+            }
+            /// Get the currently focused item.
+            fn set_focused (&mut self, to: Self::Item) {
+                self.focus.set_inner(to)
+            }
+            $(fn focus_updated (&mut $self) { $update_focus })?
+        }
+        impl HasEnter for $Struct {
+            /// Get the currently focused item.
+            fn entered (&self) -> bool {
+                self.focus.is_entered()
+            }
+            /// Get the currently focused item.
+            fn set_entered (&mut self, entered: bool) {
+                if entered {
+                    self.focus.to_entered()
+                } else {
+                    self.focus.to_focused()
+                }
+            }
+        }
+        impl FocusGrid for $Struct {
+            fn focus_cursor (&self) -> (usize, usize) {
+                self.cursor
+            }
+            fn focus_cursor_mut (&mut self) -> &mut (usize, usize) {
+                &mut self.cursor
+            }
+            fn focus_layout (&self) -> &[&[$Focus]] {
+                use $Focus::*;
+                &$Grid
+            }
+        }
+    }
+}

tui/src/tui_menu.rs

@@ -0,0 +1,63 @@
+use crate::*;
+pub struct MenuBar<E: Engine, S, C: Command<S>> {
+    pub menus: Vec<Menu<E, S, C>>,
+    pub index: usize,
+}
+impl<E: Engine, S, C: Command<S>> MenuBar<E, S, C> {
+    pub fn new () -> Self { Self { menus: vec![], index: 0 } }
+    pub fn add (mut self, menu: Menu<E, S, C>) -> Self {
+        self.menus.push(menu);
+        self
+    }
+}
+pub struct Menu<E: Engine, S, C: Command<S>> {
+    pub title: Arc<str>,
+    pub items: Vec<MenuItem<E, S, C>>,
+    pub index: Option<usize>,
+}
+impl<E: Engine, S, C: Command<S>> Menu<E, S, C> {
+    pub fn new (title: impl AsRef<str>) -> Self {
+        Self {
+            title: title.as_ref().to_string(),
+            items: vec![],
+            index: None,
+        }
+    }
+    pub fn add (mut self, item: MenuItem<E, S, C>) -> Self {
+        self.items.push(item);
+        self
+    }
+    pub fn sep (mut self) -> Self {
+        self.items.push(MenuItem::sep());
+        self
+    }
+    pub fn cmd (mut self, hotkey: &'static str, text: &'static str, command: C) -> Self {
+     self.items.push(MenuItem::cmd(hotkey, text, command));
+        self
+    }
+    pub fn off (mut self, hotkey: &'static str, text: &'static str) -> Self {
+        self.items.push(MenuItem::off(hotkey, text));
+        self
+    }
+}
+pub enum MenuItem<E: Engine, S, C: Command<S>> {
+    /// Unused.
+    __(PhantomData<E>, PhantomData<S>),
+    /// A separator. Skip it.
+    Separator,
+    /// A menu item with command, description and hotkey.
+    Command(&'static str, &'static str, C),
+    /// A menu item that can't be activated but has description and hotkey
+    Disabled(&'static str, &'static str)
+}
+impl<E: Engine, S, C: Command<S>> MenuItem<E, S, C> {
+    pub fn sep () -> Self {
+        Self::Separator
+    }
+    pub fn cmd (hotkey: &'static str, text: &'static str, command: C) -> Self {
+        Self::Command(hotkey, text, command)
+    }
+    pub fn off (hotkey: &'static str, text: &'static str) -> Self {
+        Self::Disabled(hotkey, text)
+    }
+}