but how to pass arbitrary chars to the config

midi/src/midi_pool.rs

@@ -1,7 +1,5 @@
 use crate::*;
-
 pub type ClipPool = Vec<Arc<RwLock<MidiClip>>>;
-
 pub trait HasClips {
     fn clips     <'a> (&'a self) -> std::sync::RwLockReadGuard<'a, ClipPool>;
     fn clips_mut <'a> (&'a self) -> std::sync::RwLockWriteGuard<'a, ClipPool>;
@@ -11,7 +9,6 @@ pub trait HasClips {
         (self.clips().len() - 1, clip)
     }
 }
-
 #[macro_export] macro_rules! has_clips {
     (|$self:ident:$Struct:ident$(<$($L:lifetime),*$($T:ident$(:$U:path)?),*>)?|$cb:expr) => {
         impl $(<$($L),*$($T $(: $U)?),*>)? HasClips for $Struct $(<$($L),*$($T),*>)? {
@@ -24,7 +21,6 @@ pub trait HasClips {
         }
     }
 }
-
 #[derive(Debug)]
 pub struct PoolModel {
     pub visible: bool,
@@ -35,6 +31,18 @@ pub struct PoolModel {
     /// Mode switch
     pub mode: Option<PoolMode>,
 }
+/// Modes for clip pool
+#[derive(Debug, Clone)]
+pub enum PoolMode {
+    /// Renaming a pattern
+    Rename(usize, Arc<str>),
+    /// Editing the length of a pattern
+    Length(usize, usize, ClipLengthFocus),
+    /// Load clip from disk
+    Import(usize, FileBrowser),
+    /// Save clip to disk
+    Export(usize, FileBrowser),
+}
 impl Default for PoolModel {
     fn default () -> Self {
         Self {
@@ -51,262 +59,6 @@ from!(|clip:&Arc<RwLock<MidiClip>>|PoolModel = {
     model.clip.store(1, Relaxed);
     model
 });
-
-#[derive(Clone, PartialEq, Debug)]
-pub enum PoolCommand {
-    Show(bool),
-    /// Update the contents of the clip pool
-    Clip(PoolClipCommand),
-    /// Select a clip from the clip pool
-    Select(usize),
-    /// Rename a clip
-    Rename(ClipRenameCommand),
-    /// Change the length of a clip
-    Length(ClipLengthCommand),
-    /// Import from file
-    Import(FileBrowserCommand),
-    /// Export to file
-    Export(FileBrowserCommand),
-}
-impl EdnCommand<PoolModel> for PoolCommand {
-    fn from_edn <'a> (state: &PoolModel, head: &EdnItem<&str>, tail: &'a [EdnItem<String>]) -> Self {
-        todo!()
-    }
-}
-#[derive(Clone, Debug, PartialEq)]
-pub enum PoolClipCommand {
-    Add(usize, MidiClip),
-    Delete(usize),
-    Swap(usize, usize),
-    Import(usize, PathBuf),
-    Export(usize, PathBuf),
-    SetName(usize, Arc<str>),
-    SetLength(usize, usize),
-    SetColor(usize, ItemColor),
-}
-impl PoolClipCommand {
-    pub fn from_edn <'a> (head: &EdnItem<&str>, tail: &'a [EdnItem<String>]) -> Self {
-        todo!()
-    }
-}
-
-/// Modes for clip pool
-#[derive(Debug, Clone)]
-pub enum PoolMode {
-    /// Renaming a pattern
-    Rename(usize, Arc<str>),
-    /// Editing the length of a pattern
-    Length(usize, usize, ClipLengthFocus),
-    /// Load clip from disk
-    Import(usize, FileBrowser),
-    /// Save clip to disk
-    Export(usize, FileBrowser),
-}
-
-
-impl<T: HasClips> Command<T> for PoolClipCommand {
-    fn execute (self, model: &mut T) -> Perhaps<Self> {
-        use PoolClipCommand::*;
-        Ok(match self {
-            Add(mut index, clip) => {
-                let clip  = Arc::new(RwLock::new(clip));
-                let mut clips = model.clips_mut();
-                if index >= clips.len() {
-                    index = clips.len();
-                    clips.push(clip)
-                } else {
-                    clips.insert(index, clip);
-                }
-                Some(Self::Delete(index))
-            },
-            Delete(index) => {
-                let clip = model.clips_mut().remove(index).read().unwrap().clone();
-                Some(Self::Add(index, clip))
-            },
-            Swap(index, other) => {
-                model.clips_mut().swap(index, other);
-                Some(Self::Swap(index, other))
-            },
-            Import(index, path) => {
-                let bytes = std::fs::read(&path)?;
-                let smf = Smf::parse(bytes.as_slice())?;
-                let mut t = 0u32;
-                let mut events = vec![];
-                for track in smf.tracks.iter() {
-                    for event in track.iter() {
-                        t += event.delta.as_int();
-                        if let TrackEventKind::Midi { channel, message } = event.kind {
-                            events.push((t, channel.as_int(), message));
-                        }
-                    }
-                }
-                let mut clip = MidiClip::new("imported", true, t as usize + 1, None, None);
-                for event in events.iter() {
-                    clip.notes[event.0 as usize].push(event.2);
-                }
-                Self::Add(index, clip).execute(model)?
-            },
-            Export(_index, _path) => {
-                todo!("export clip to midi file");
-            },
-            SetName(index, name) => {
-                let clip = &mut model.clips_mut()[index];
-                let old_name = clip.read().unwrap().name.clone();
-                clip.write().unwrap().name = name;
-                Some(Self::SetName(index, old_name))
-            },
-            SetLength(index, length) => {
-                let clip = &mut model.clips_mut()[index];
-                let old_len = clip.read().unwrap().length;
-                clip.write().unwrap().length = length;
-                Some(Self::SetLength(index, old_len))
-            },
-            SetColor(index, color) => {
-                let mut color = ItemPalette::from(color);
-                std::mem::swap(&mut color, &mut model.clips()[index].write().unwrap().color);
-                Some(Self::SetColor(index, color.base))
-            },
-        })
-    }
-}
-
-
-pub struct PoolView<'a>(pub bool, pub &'a PoolModel);
-render!(TuiOut: (self: PoolView<'a>) => {
-    let Self(compact, model) = self;
-    let PoolModel { clips, mode, .. } = self.1;
-    let color  = self.1.clip().map(|c|c.read().unwrap().color).unwrap_or_else(||TuiTheme::g(32).into());
-    let on_bg  = |x|x;//Bsp::b(Repeat(" "), Tui::bg(color.darkest.rgb, x));
-    let border = |x|x;//Outer(Style::default().fg(color.dark.rgb).bg(color.darkest.rgb)).enclose(x);
-    let iter   = | |model.clips().clone().into_iter();
-    Tui::bg(Color::Reset, Fixed::y(clips.read().unwrap().len() as u16, on_bg(border(Map::new(iter, move|clip, i|{
-        let item_height = 1;
-        let item_offset = i as u16 * item_height;
-        let selected    = i == model.clip_index();
-        let MidiClip { ref name, color, length, .. } = *clip.read().unwrap();
-        let bg     = if selected { color.light.rgb } else { color.base.rgb };
-        let fg     = color.lightest.rgb;
-        let name   = if *compact { format!(" {i:>3}") } else { format!(" {i:>3} {name}") };
-        let length = if *compact { String::default()  } else { format!("{length}  ") };
-        Fixed::y(1, map_south(item_offset, item_height, Tui::bg(bg, lay!(
-            Fill::x(Align::w(Tui::fg(fg, Tui::bold(selected, name)))),
-            Fill::x(Align::e(Tui::fg(fg, Tui::bold(selected, length)))),
-            Fill::x(Align::w(When(selected, Tui::bold(true, Tui::fg(TuiTheme::g(255), "▶"))))),
-            Fill::x(Align::e(When(selected, Tui::bold(true, Tui::fg(TuiTheme::g(255), "◀"))))),
-        ))))
-    })))))
-});
-
-command!(|self:PoolCommand, state: PoolModel|{
-    use PoolCommand::*;
-    match self {
-        Show(visible) => {
-            state.visible = visible;
-            Some(Self::Show(!visible))
-        }
-        Rename(command) => match command {
-            ClipRenameCommand::Begin => {
-                let length = state.clips()[state.clip_index()].read().unwrap().length;
-                *state.clips_mode_mut() = Some(
-                    PoolMode::Length(state.clip_index(), length, ClipLengthFocus::Bar)
-                );
-                None
-            },
-            _ => command.execute(state)?.map(Rename)
-        },
-        Length(command) => match command {
-            ClipLengthCommand::Begin => {
-                let name = state.clips()[state.clip_index()].read().unwrap().name.clone();
-                *state.clips_mode_mut() = Some(
-                    PoolMode::Rename(state.clip_index(), name)
-                );
-                None
-            },
-            _ => command.execute(state)?.map(Length)
-        },
-        Import(command) => match command {
-            FileBrowserCommand::Begin => {
-                *state.clips_mode_mut() = Some(
-                    PoolMode::Import(state.clip_index(), FileBrowser::new(None)?)
-                );
-                None
-            },
-            _ => command.execute(state)?.map(Import)
-        },
-        Export(command) => match command {
-            FileBrowserCommand::Begin => {
-                *state.clips_mode_mut() = Some(
-                    PoolMode::Export(state.clip_index(), FileBrowser::new(None)?)
-                );
-                None
-            },
-            _ => command.execute(state)?.map(Export)
-        },
-        Select(clip) => {
-            state.set_clip_index(clip);
-            None
-        },
-        Clip(command) => command.execute(state)?.map(Clip),
-    }
-});
-
-input_to_command!(PoolCommand: |state: PoolModel, input: Event|match state.clips_mode() {
-    Some(PoolMode::Rename(..)) => Self::Rename(ClipRenameCommand::input_to_command(state, input)?),
-    Some(PoolMode::Length(..)) => Self::Length(ClipLengthCommand::input_to_command(state, input)?),
-    Some(PoolMode::Import(..)) => Self::Import(FileBrowserCommand::input_to_command(state, input)?),
-    Some(PoolMode::Export(..)) => Self::Export(FileBrowserCommand::input_to_command(state, input)?),
-    _ => to_clips_command(state, input)?
-});
-
-fn to_clips_command (state: &PoolModel, input: &Event) -> Option<PoolCommand> {
-    use KeyCode::{Up, Down, Delete, Char};
-    use PoolCommand as Cmd;
-    let index = state.clip_index();
-    let count = state.clips().len();
-    Some(match input {
-        kpat!(Char('n')) => Cmd::Rename(ClipRenameCommand::Begin),
-        kpat!(Char('t')) => Cmd::Length(ClipLengthCommand::Begin),
-        kpat!(Char('m')) => Cmd::Import(FileBrowserCommand::Begin),
-        kpat!(Char('x')) => Cmd::Export(FileBrowserCommand::Begin),
-        kpat!(Char('c')) => Cmd::Clip(PoolClipCommand::SetColor(index, ItemColor::random())),
-        kpat!(Char('[')) | kpat!(Up) => Cmd::Select(
-            index.overflowing_sub(1).0.min(state.clips().len() - 1)
-        ),
-        kpat!(Char(']')) | kpat!(Down) => Cmd::Select(
-            index.saturating_add(1) % state.clips().len()
-        ),
-        kpat!(Char('<')) => if index > 1 {
-            state.set_clip_index(state.clip_index().saturating_sub(1));
-            Cmd::Clip(PoolClipCommand::Swap(index - 1, index))
-        } else {
-            return None
-        },
-        kpat!(Char('>')) => if index < count.saturating_sub(1) {
-            state.set_clip_index(state.clip_index() + 1);
-            Cmd::Clip(PoolClipCommand::Swap(index + 1, index))
-        } else {
-            return None
-        },
-        kpat!(Delete) => if index > 0 {
-            state.set_clip_index(index.min(count.saturating_sub(1)));
-            Cmd::Clip(PoolClipCommand::Delete(index))
-        } else {
-            return None
-        },
-        kpat!(Char('a')) | kpat!(Shift-Char('A')) => Cmd::Clip(PoolClipCommand::Add(count, MidiClip::new(
-            "Clip", true, 4 * PPQ, None, Some(ItemPalette::random())
-        ))),
-        kpat!(Char('i')) => Cmd::Clip(PoolClipCommand::Add(index + 1, MidiClip::new(
-            "Clip", true, 4 * PPQ, None, Some(ItemPalette::random())
-        ))),
-        kpat!(Char('d')) | kpat!(Shift-Char('D')) => {
-            let mut clip = state.clips()[index].read().unwrap().duplicate();
-            clip.color = ItemPalette::random_near(clip.color, 0.25);
-            Cmd::Clip(PoolClipCommand::Add(index + 1, clip))
-        },
-        _ => return None
-    })
-}
 has_clips!(|self: PoolModel|self.clips);
 has_clip!(|self: PoolModel|self.clips().get(self.clip_index()).map(|c|c.clone()));
 impl PoolModel {
@@ -330,71 +82,6 @@ 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;
-                PoolClipCommand::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!()
-    }
-});
-
 /// Displays and edits clip length.
 #[derive(Clone)]
 pub struct ClipLength {
@@ -407,7 +94,6 @@ pub struct ClipLength {
     /// Selected subdivision
     pub focus:  Option<ClipLengthFocus>,
 }
-
 impl ClipLength {
     pub fn new (pulses: usize, focus: Option<ClipLengthFocus>) -> Self {
         Self { ppq: PPQ, bpb: 4, pulses, focus }
@@ -431,7 +117,6 @@ impl ClipLength {
         format!("{:>02}", self.ticks()).into()
     }
 }
-
 /// Focused field of `ClipLength`
 #[derive(Copy, Clone, Debug)]
 pub enum ClipLengthFocus {
@@ -442,104 +127,14 @@ pub enum ClipLengthFocus {
     /// Editing the number of ticks
     Tick,
 }
-
 impl ClipLengthFocus {
     pub fn next (&mut self) {
-        *self = match self {
-            Self::Bar  => Self::Beat,
-            Self::Beat => Self::Tick,
-            Self::Tick => Self::Bar,
-        }
+        *self = match self { Self::Bar => Self::Beat, Self::Beat => Self::Tick, Self::Tick => Self::Bar, }
     }
     pub fn prev (&mut self) {
-        *self = match self {
-            Self::Bar  => Self::Tick,
-            Self::Beat => Self::Bar,
-            Self::Tick => Self::Beat,
-        }
+        *self = match self { Self::Bar => Self::Tick, Self::Beat => Self::Bar, Self::Tick => Self::Beat, }
     }
 }
-
-render!(TuiOut: (self: ClipLength) => {
-    let bars  = ||self.bars_string();
-    let beats = ||self.beats_string();
-    let ticks = ||self.ticks_string();
-    match self.focus {
-        None =>
-            row!(" ", bars(), ".", beats(), ".", ticks()),
-        Some(ClipLengthFocus::Bar) =>
-            row!("[", bars(), "]", beats(), ".", ticks()),
-        Some(ClipLengthFocus::Beat) =>
-            row!(" ", bars(), "[", beats(), "]", ticks()),
-        Some(ClipLengthFocus::Tick) =>
-            row!(" ", bars(), ".", beats(), "[", ticks()),
-    }
-});
-
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub enum ClipLengthCommand {
-    Begin,
-    Cancel,
-    Set(usize),
-    Next,
-    Prev,
-    Inc,
-    Dec,
-}
-
-command!(|self: ClipLengthCommand,state:PoolModel|{
-    use ClipLengthCommand::*;
-    use ClipLengthFocus::*;
-    match state.clips_mode_mut().clone() {
-        Some(PoolMode::Length(clip, ref mut length, ref mut focus)) => match self {
-            Cancel => { *state.clips_mode_mut() = None; },
-            Self::Prev => { focus.prev() },
-            Self::Next => { focus.next() },
-            Self::Inc => match focus {
-                Bar  => { *length += 4 * PPQ },
-                Beat => { *length += PPQ },
-                Tick => { *length += 1 },
-            },
-            Self::Dec => match focus {
-                Bar  => { *length = length.saturating_sub(4 * PPQ) },
-                Beat => { *length = length.saturating_sub(PPQ) },
-                Tick => { *length = length.saturating_sub(1) },
-            },
-            Self::Set(length) => {
-                let mut old_length = None;
-                {
-                    let mut clip = state.clips()[clip].clone();//.write().unwrap();
-                    old_length = Some(clip.read().unwrap().length);
-                    clip.write().unwrap().length = length;
-                }
-                *state.clips_mode_mut() = None;
-                return Ok(old_length.map(Self::Set))
-            },
-            _ => unreachable!()
-        },
-        _ => unreachable!()
-    };
-    None
-});
-
-input_to_command!(ClipLengthCommand: |state: PoolModel, input: Event|{
-    if let Some(PoolMode::Length(_, length, _)) = state.clips_mode() {
-        match input {
-            kpat!(Up)    => Self::Inc,
-            kpat!(Down)  => Self::Dec,
-            kpat!(Right) => Self::Next,
-            kpat!(Left)  => Self::Prev,
-            kpat!(Enter) => Self::Set(*length),
-            kpat!(Esc)   => Self::Cancel,
-            _ => return None
-        }
-    } else {
-        unreachable!()
-    }
-});
-use crate::*;
-use super::*;
-
 #[derive(Clone, Debug, PartialEq)]
 pub enum ClipRenameCommand {
     Begin,
@@ -547,7 +142,6 @@ pub enum ClipRenameCommand {
     Confirm,
     Set(Arc<str>),
 }
-
 impl Command<PoolModel> for ClipRenameCommand {
     fn execute (self, state: &mut PoolModel) -> Perhaps<Self> {
         use ClipRenameCommand::*;
@@ -572,28 +166,3 @@ impl Command<PoolModel> for ClipRenameCommand {
         Ok(None)
     }
 }
-
-impl InputToCommand<Event, PoolModel> for ClipRenameCommand {
-    fn input_to_command (state: &PoolModel, input: &Event) -> Option<Self> {
-        use KeyCode::{Char, Backspace, Enter, Esc};
-        if let Some(PoolMode::Rename(_, ref old_name)) = state.clips_mode() {
-            Some(match input {
-                kpat!(Char(c)) => {
-                    let mut new_name = old_name.clone().to_string();
-                    new_name.push(*c);
-                    Self::Set(new_name.into())
-                },
-                kpat!(Backspace) => {
-                    let mut new_name = old_name.clone().to_string();
-                    new_name.pop();
-                    Self::Set(new_name.into())
-                },
-                kpat!(Enter) => Self::Confirm,
-                kpat!(Esc) => Self::Cancel,
-                _ => return None
-            })
-        } else {
-            unreachable!()
-        }
-    }
-}