remodularize 3

src/arranger/arranger_command.rs

@@ -185,7 +185,7 @@ command!(|self: ArrangerCommand, state: Arranger|match self {
                 undo
             },
             // reload phrase in editor to update color
-            PoolCommand::Phrase(PhrasePoolCommand::SetColor(index, _)) => {
+            PoolCommand::Phrase(MidiPoolCommand::SetColor(index, _)) => {
                 let undo = cmd.delegate(&mut state.pool, Self::Phrases)?;
                 state.editor.set_phrase(Some(state.pool.phrase()));
                 undo

src/file.rs

@@ -1,151 +0,0 @@
-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()))
-    }
-}
-command!(|self: FileBrowserCommand, state: PoolModel|{
-    use PoolMode::*;
-    use FileBrowserCommand::*;
-    let mode = &mut state.mode;
-    match mode {
-        Some(Import(index, ref mut browser)) => match self {
-            Cancel => { *mode = None; },
-            Chdir(cwd) => { *mode = Some(Import(*index, FileBrowser::new(Some(cwd))?)); },
-            Select(index) => { browser.index = index; },
-            Confirm => if browser.is_file() {
-                let index = *index;
-                let path  = browser.path();
-                *mode = None;
-                PhrasePoolCommand::Import(index, path).execute(state)?;
-            } else if browser.is_dir() {
-                *mode = Some(Import(*index, browser.chdir()?));
-            },
-            _ => todo!(),
-        },
-        Some(Export(index, ref mut browser)) => match self {
-            Cancel => { *mode = None; },
-            Chdir(cwd) => { *mode = Some(Export(*index, FileBrowser::new(Some(cwd))?)); },
-            Select(index) => { browser.index = index; },
-            _ => unreachable!()
-        },
-        _ => unreachable!(),
-    };
-    None
-});
-input_to_command!(FileBrowserCommand: |state: PoolModel, input: Event|{
-    use FileBrowserCommand::*;
-    use KeyCode::{Up, Down, Left, Right, Enter, Esc, Backspace, Char};
-    if let Some(PoolMode::Import(_index, browser)) = &state.mode {
-        match input {
-            kpat!(Up)        => Select(browser.index.overflowing_sub(1).0
-                                    .min(browser.len().saturating_sub(1))),
-            kpat!(Down)      => Select(browser.index.saturating_add(1)
-                                    % browser.len()),
-            kpat!(Right)     => Chdir(browser.cwd.clone()),
-            kpat!(Left)      => Chdir(browser.cwd.clone()),
-            kpat!(Enter)     => Confirm,
-            kpat!(Char(_))   => { todo!() },
-            kpat!(Backspace) => { todo!() },
-            kpat!(Esc)       => Cancel,
-            _ => return None
-        }
-    } else if let Some(PoolMode::Export(_index, browser)) = &state.mode {
-        match input {
-            kpat!(Up)        => Select(browser.index.overflowing_sub(1).0
-                                    .min(browser.len())),
-            kpat!(Down)      => Select(browser.index.saturating_add(1)
-                                    % browser.len()),
-            kpat!(Right)     => Chdir(browser.cwd.clone()),
-            kpat!(Left)      => Chdir(browser.cwd.clone()),
-            kpat!(Enter)     => Confirm,
-            kpat!(Char(_))   => { todo!() },
-            kpat!(Backspace) => { todo!() },
-            kpat!(Esc)       => Cancel,
-            _ => return None
-        }
-    } else {
-        unreachable!()
-    }
-});

src/focus.rs

@@ -1,306 +0,0 @@
-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
-            }
-        }
-    }
-}

src/groovebox.rs

@@ -7,7 +7,7 @@ use KeyCode::{Char, Delete, Tab, Up, Down, Left, Right};
 use ClockCommand::{Play, Pause};
 use GrooveboxCommand as Cmd;
 use MidiEditCommand::*;
-use PhrasePoolCommand::*;
+use MidiPoolCommand::*;
 
 pub struct Groovebox {
     _jack: Arc<RwLock<JackConnection>>,

src/lib.rs

@@ -6,8 +6,6 @@
 #![feature(associated_type_defaults)]
 
 pub mod arranger;  pub use self::arranger::*;
-pub mod file;      pub use self::file::*;
-pub mod focus;     pub use self::focus::*;
 pub mod groovebox; pub use self::groovebox::*;
 pub mod meter;     pub use self::meter::*;
 pub mod mixer;     pub use self::mixer::*;
@@ -42,16 +40,16 @@ pub(crate) use ::tek_tui::{
 pub(crate) use std::cmp::{Ord, Eq, PartialEq};
 pub(crate) use std::collections::BTreeMap;
 pub(crate) use std::error::Error;
-pub(crate) use std::ffi::OsString;
 pub(crate) use std::fmt::{Debug, Display, Formatter};
 pub(crate) use std::io::{Stdout, stdout};
 pub(crate) use std::marker::PhantomData;
 pub(crate) use std::ops::{Add, Sub, Mul, Div, Rem};
-pub(crate) use std::path::PathBuf;
 pub(crate) use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering::{self, *}};
 pub(crate) use std::sync::{Arc, Mutex, RwLock};
 pub(crate) use std::thread::{spawn, JoinHandle};
 pub(crate) use std::time::Duration;
+pub(crate) use std::path::PathBuf;
+pub(crate) use std::ffi::OsString;
 
 //#[cfg(test)] mod test_focus {
     //use super::focus::*;

src/menu.rs

@@ -1,63 +0,0 @@
-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)
-    }
-}

src/pool.rs

@@ -37,7 +37,7 @@ pub enum PoolMode {
 pub enum PoolCommand {
     Show(bool),
     /// Update the contents of the phrase pool
-    Phrase(PhrasePoolCommand),
+    Phrase(MidiPoolCommand),
     /// Select a phrase from the phrase pool
     Select(usize),
     /// Rename a phrase
@@ -121,7 +121,7 @@ fn to_phrases_command (state: &PoolModel, input: &Event) -> Option<PoolCommand>
         kpat!(Char('t')) => Cmd::Length(PhraseLengthCommand::Begin),
         kpat!(Char('m')) => Cmd::Import(FileBrowserCommand::Begin),
         kpat!(Char('x')) => Cmd::Export(FileBrowserCommand::Begin),
-        kpat!(Char('c')) => Cmd::Phrase(PhrasePoolCommand::SetColor(index, ItemColor::random())),
+        kpat!(Char('c')) => Cmd::Phrase(MidiPoolCommand::SetColor(index, ItemColor::random())),
         kpat!(Char('[')) | kpat!(Up) => Cmd::Select(
             index.overflowing_sub(1).0.min(state.phrases().len() - 1)
         ),
@@ -130,32 +130,32 @@ fn to_phrases_command (state: &PoolModel, input: &Event) -> Option<PoolCommand>
         ),
         kpat!(Char('<')) => if index > 1 {
             state.set_phrase_index(state.phrase_index().saturating_sub(1));
-            Cmd::Phrase(PhrasePoolCommand::Swap(index - 1, index))
+            Cmd::Phrase(MidiPoolCommand::Swap(index - 1, index))
         } else {
             return None
         },
         kpat!(Char('>')) => if index < count.saturating_sub(1) {
             state.set_phrase_index(state.phrase_index() + 1);
-            Cmd::Phrase(PhrasePoolCommand::Swap(index + 1, index))
+            Cmd::Phrase(MidiPoolCommand::Swap(index + 1, index))
         } else {
             return None
         },
         kpat!(Delete) => if index > 0 {
             state.set_phrase_index(index.min(count.saturating_sub(1)));
-            Cmd::Phrase(PhrasePoolCommand::Delete(index))
+            Cmd::Phrase(MidiPoolCommand::Delete(index))
         } else {
             return None
         },
-        kpat!(Char('a')) | kpat!(Shift-Char('A')) => Cmd::Phrase(PhrasePoolCommand::Add(count, MidiClip::new(
+        kpat!(Char('a')) | kpat!(Shift-Char('A')) => Cmd::Phrase(MidiPoolCommand::Add(count, MidiClip::new(
             "Clip", true, 4 * PPQ, None, Some(ItemPalette::random())
         ))),
-        kpat!(Char('i')) => Cmd::Phrase(PhrasePoolCommand::Add(index + 1, MidiClip::new(
+        kpat!(Char('i')) => Cmd::Phrase(MidiPoolCommand::Add(index + 1, MidiClip::new(
             "Clip", true, 4 * PPQ, None, Some(ItemPalette::random())
         ))),
         kpat!(Char('d')) | kpat!(Shift-Char('D')) => {
             let mut phrase = state.phrases()[index].read().unwrap().duplicate();
             phrase.color = ItemPalette::random_near(phrase.color, 0.25);
-            Cmd::Phrase(PhrasePoolCommand::Add(index + 1, phrase))
+            Cmd::Phrase(MidiPoolCommand::Add(index + 1, phrase))
         },
         _ => return None
     })
@@ -201,3 +201,67 @@ impl PoolModel {
         }
     }
 }
+command!(|self: FileBrowserCommand, state: PoolModel|{
+    use PoolMode::*;
+    use FileBrowserCommand::*;
+    let mode = &mut state.mode;
+    match mode {
+        Some(Import(index, ref mut browser)) => match self {
+            Cancel => { *mode = None; },
+            Chdir(cwd) => { *mode = Some(Import(*index, FileBrowser::new(Some(cwd))?)); },
+            Select(index) => { browser.index = index; },
+            Confirm => if browser.is_file() {
+                let index = *index;
+                let path  = browser.path();
+                *mode = None;
+                MidiPoolCommand::Import(index, path).execute(state)?;
+            } else if browser.is_dir() {
+                *mode = Some(Import(*index, browser.chdir()?));
+            },
+            _ => todo!(),
+        },
+        Some(Export(index, ref mut browser)) => match self {
+            Cancel => { *mode = None; },
+            Chdir(cwd) => { *mode = Some(Export(*index, FileBrowser::new(Some(cwd))?)); },
+            Select(index) => { browser.index = index; },
+            _ => unreachable!()
+        },
+        _ => unreachable!(),
+    };
+    None
+});
+input_to_command!(FileBrowserCommand: |state: PoolModel, input: Event|{
+    use FileBrowserCommand::*;
+    use KeyCode::{Up, Down, Left, Right, Enter, Esc, Backspace, Char};
+    if let Some(PoolMode::Import(_index, browser)) = &state.mode {
+        match input {
+            kpat!(Up)        => Select(browser.index.overflowing_sub(1).0
+                                    .min(browser.len().saturating_sub(1))),
+            kpat!(Down)      => Select(browser.index.saturating_add(1)
+                                    % browser.len()),
+            kpat!(Right)     => Chdir(browser.cwd.clone()),
+            kpat!(Left)      => Chdir(browser.cwd.clone()),
+            kpat!(Enter)     => Confirm,
+            kpat!(Char(_))   => { todo!() },
+            kpat!(Backspace) => { todo!() },
+            kpat!(Esc)       => Cancel,
+            _ => return None
+        }
+    } else if let Some(PoolMode::Export(_index, browser)) = &state.mode {
+        match input {
+            kpat!(Up)        => Select(browser.index.overflowing_sub(1).0
+                                    .min(browser.len())),
+            kpat!(Down)      => Select(browser.index.saturating_add(1)
+                                    % browser.len()),
+            kpat!(Right)     => Chdir(browser.cwd.clone()),
+            kpat!(Left)      => Chdir(browser.cwd.clone()),
+            kpat!(Enter)     => Confirm,
+            kpat!(Char(_))   => { todo!() },
+            kpat!(Backspace) => { todo!() },
+            kpat!(Esc)       => Cancel,
+            _ => return None
+        }
+    } else {
+        unreachable!()
+    }
+});

src/sequencer.rs

@@ -3,7 +3,7 @@ use ClockCommand::{Play, Pause};
 use KeyCode::{Tab, Char};
 use SequencerCommand as Cmd;
 use MidiEditCommand::*;
-use PhrasePoolCommand::*;
+use MidiPoolCommand::*;
 /// Root view for standalone `tek_sequencer`.
 pub struct Sequencer {
     pub _jack: Arc<RwLock<JackConnection>>,
@@ -57,6 +57,25 @@ impl Sequencer {
         let pool = Pull::y(1, Fill::y(Align::e(PoolView(self.pool.visible, &self.pool))));
         Fixed::x(pool_w, Align::e(Fill::y(PoolView(self.compact, &self.pool))))
     }
+    fn help () -> impl Content<TuiOut> {
+        let single = |binding, command|row!(" ", col!(
+            Tui::fg(TuiTheme::yellow(), binding),
+            command
+        ));
+        let double = |(b1, c1), (b2, c2)|col!(
+            row!("  ", Tui::fg(TuiTheme::yellow(), b1), " ", c1,),
+            row!("  ", Tui::fg(TuiTheme::yellow(), b2), " ", c2,),
+        );
+        Tui::fg_bg(TuiTheme::g(255), TuiTheme::g(50), row!(
+            single("SPACE", "play/pause"),
+            double(("▲▼▶◀", "cursor"),  ("Ctrl", "scroll"),  ),
+            double(("a",    "append"),  ("s",    "set note"),),
+            double((",.",   "length"),  ("<>",   "triplet"), ),
+            double(("[]",   "phrase"),  ("{}",   "order"),   ),
+            double(("q",    "enqueue"), ("e",    "edit"),    ),
+            double(("c",    "color"),   ("",     ""),),
+        ))
+    }
 }
 audio!(|self:Sequencer, client, scope|{
     // Start profiling cycle
@@ -178,29 +197,10 @@ from!(|state:&Sequencer|SequencerStatus = {
     }
 });
 render!(TuiOut: (self: SequencerStatus) => Fixed::y(2, lay!(
-    Self::help(),
+    Sequencer::help(),
     Fill::xy(Align::se(Tui::fg_bg(TuiTheme::orange(), TuiTheme::g(25), self.stats()))),
 )));
 impl SequencerStatus {
-    fn help () -> impl Content<TuiOut> {
-        let single = |binding, command|row!(" ", col!(
-            Tui::fg(TuiTheme::yellow(), binding),
-            command
-        ));
-        let double = |(b1, c1), (b2, c2)|col!(
-            row!("  ", Tui::fg(TuiTheme::yellow(), b1), " ", c1,),
-            row!("  ", Tui::fg(TuiTheme::yellow(), b2), " ", c2,),
-        );
-        Tui::fg_bg(TuiTheme::g(255), TuiTheme::g(50), row!(
-            single("SPACE", "play/pause"),
-            double(("▲▼▶◀", "cursor"),  ("Ctrl", "scroll"),  ),
-            double(("a",    "append"),  ("s",    "set note"),),
-            double((",.",   "length"),  ("<>",   "triplet"), ),
-            double(("[]",   "phrase"),  ("{}",   "order"),   ),
-            double(("q",    "enqueue"), ("e",    "edit"),    ),
-            double(("c",    "color"),   ("",     ""),),
-        ))
-    }
     fn stats (&self) -> impl Content<TuiOut> + use<'_> {
         row!(&self.cpu, &self.size)
     }