move pool to tek_midi; implement some Default

midi/src/lib.rs

@@ -20,7 +20,7 @@ pub(crate) use ::tek_tui::{
     *,
     tek_input::*,
     tek_output::*, 
-    crossterm::event::KeyCode,
+    crossterm::event::*,
     ratatui::style::{Style, Stylize, Color}
 };
 

midi/src/midi_player.rs

@@ -23,9 +23,9 @@ pub struct MidiPlayer {
     /// State of clock and playhead
     pub clock:       Clock,
     /// Start time and clip being played
-    pub play_clip: Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>,
+    pub play_clip:   Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>,
     /// Start time and next clip
-    pub next_clip: Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>,
+    pub next_clip:   Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>,
     /// Play input through output.
     pub monitoring:  bool,
     /// Write input to sequence.
@@ -45,6 +45,26 @@ pub struct MidiPlayer {
     /// MIDI output buffer
     pub note_buf:    Vec<u8>,
 }
+impl Default for MidiPlayer {
+    fn default () -> Self {
+        Self {
+            play_clip:  None,
+            next_clip:  None,
+            recording:  false,
+            monitoring: false,
+            overdub:    false,
+
+            notes_in:   RwLock::new([false;128]).into(),
+            notes_out:  RwLock::new([false;128]).into(),
+            note_buf:   vec![0;8],
+            reset:      true,
+
+            midi_ins:   vec![],
+            midi_outs:  vec![],
+            clock:      Clock::default(),
+        }
+    }
+}
 impl MidiPlayer {
     pub fn new (
         jack: &Arc<RwLock<JackConnection>>,
@@ -56,20 +76,11 @@ impl MidiPlayer {
         let name  = name.as_ref();
         let clock = Clock::from(jack);
         Ok(Self {
-            play_clip: Some((Moment::zero(&clock.timebase), clip.cloned())),
-            next_clip: None,
-            recording:   false,
-            monitoring:  false,
-            overdub:     false,
-
-            notes_in:  RwLock::new([false;128]).into(),
-            notes_out: RwLock::new([false;128]).into(),
-            note_buf:  vec![0;8],
-            reset:     true,
-
             midi_ins:  vec![JackPort::<MidiIn>::new(jack,  format!("M/{name}"), midi_from)?,],
             midi_outs: vec![JackPort::<MidiOut>::new(jack, format!("{name}/M"), midi_to)?,  ],
+            play_clip: Some((Moment::zero(&clock.timebase), clip.cloned())),
             clock,
+            ..Default::default()
         })
     }
     pub fn play_status (&self) -> impl Content<TuiOut> {

midi/src/midi_pool.rs

@@ -102,3 +102,493 @@ impl<T: HasClips> Command<T> for MidiPoolCommand {
         })
     }
 }
+
+#[derive(Debug)]
+pub struct PoolModel {
+    pub visible: bool,
+    /// Collection of clips
+    pub clips: Arc<RwLock<Vec<Arc<RwLock<MidiClip>>>>>,
+    /// Selected clip
+    pub clip: AtomicUsize,
+    /// Mode switch
+    pub mode: Option<PoolMode>,
+    /// Rendered size
+    size: Measure<TuiOut>,
+    /// Scroll offset
+    scroll: usize,
+}
+impl Default for PoolModel {
+    fn default () -> Self {
+        Self {
+            visible: true,
+            clips:   Arc::from(RwLock::from(vec![])),
+            clip:    0.into(),
+            scroll:  0,
+            mode:    None,
+            size:    Measure::new(),
+        }
+    }
+}
+from!(|clip:&Arc<RwLock<MidiClip>>|PoolModel = {
+    let mut model = Self::default();
+    model.clips.write().unwrap().push(clip.clone());
+    model.clip.store(1, Relaxed);
+    model
+});
+
+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), "◀"))))),
+        ))))
+    })))))
+});
+
+/// 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),
+}
+
+#[derive(Clone, PartialEq, Debug)]
+pub enum PoolCommand {
+    Show(bool),
+    /// Update the contents of the clip pool
+    Clip(MidiPoolCommand),
+    /// 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),
+}
+
+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(MidiPoolCommand::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(MidiPoolCommand::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(MidiPoolCommand::Swap(index + 1, index))
+        } else {
+            return None
+        },
+        kpat!(Delete) => if index > 0 {
+            state.set_clip_index(index.min(count.saturating_sub(1)));
+            Cmd::Clip(MidiPoolCommand::Delete(index))
+        } else {
+            return None
+        },
+        kpat!(Char('a')) | kpat!(Shift-Char('A')) => Cmd::Clip(MidiPoolCommand::Add(count, MidiClip::new(
+            "Clip", true, 4 * PPQ, None, Some(ItemPalette::random())
+        ))),
+        kpat!(Char('i')) => Cmd::Clip(MidiPoolCommand::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(MidiPoolCommand::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 {
+    pub(crate) fn clip_index (&self) -> usize {
+        self.clip.load(Relaxed)
+    }
+    pub(crate) fn set_clip_index (&self, value: usize) {
+        self.clip.store(value, Relaxed);
+    }
+    pub(crate) fn clips_mode (&self) -> &Option<PoolMode> {
+        &self.mode
+    }
+    pub(crate) fn clips_mode_mut (&mut self) -> &mut Option<PoolMode> {
+        &mut self.mode
+    }
+    pub fn file_picker (&self) -> Option<&FileBrowser> {
+        match self.mode {
+            Some(PoolMode::Import(_, ref file_picker)) => Some(file_picker),
+            Some(PoolMode::Export(_, ref file_picker)) => Some(file_picker),
+            _ => None
+        }
+    }
+}
+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!()
+    }
+});
+
+/// Displays and edits clip length.
+#[derive(Clone)]
+pub struct ClipLength {
+    /// Pulses per beat (quaver)
+    pub ppq:    usize,
+    /// Beats per bar
+    pub bpb:    usize,
+    /// Length of clip in pulses
+    pub pulses: usize,
+    /// Selected subdivision
+    pub focus:  Option<ClipLengthFocus>,
+}
+
+impl ClipLength {
+    pub fn new (pulses: usize, focus: Option<ClipLengthFocus>) -> Self {
+        Self { ppq: PPQ, bpb: 4, pulses, focus }
+    }
+    pub fn bars  (&self) -> usize {
+        self.pulses / (self.bpb * self.ppq)
+    }
+    pub fn beats (&self) -> usize {
+        (self.pulses % (self.bpb * self.ppq)) / self.ppq
+    }
+    pub fn ticks (&self) -> usize {
+        self.pulses % self.ppq
+    }
+    pub fn bars_string  (&self) -> Arc<str> {
+        format!("{}", self.bars()).into()
+    }
+    pub fn beats_string (&self) -> Arc<str> {
+        format!("{}", self.beats()).into()
+    }
+    pub fn ticks_string (&self) -> Arc<str> {
+        format!("{:>02}", self.ticks()).into()
+    }
+}
+
+/// Focused field of `ClipLength`
+#[derive(Copy, Clone, Debug)]
+pub enum ClipLengthFocus {
+    /// Editing the number of bars
+    Bar,
+    /// Editing the number of beats
+    Beat,
+    /// 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,
+        }
+    }
+    pub fn prev (&mut self) {
+        *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,
+    Cancel,
+    Confirm,
+    Set(Arc<str>),
+}
+
+impl Command<PoolModel> for ClipRenameCommand {
+    fn execute (self, state: &mut PoolModel) -> Perhaps<Self> {
+        use ClipRenameCommand::*;
+        match state.clips_mode_mut().clone() {
+            Some(PoolMode::Rename(clip, ref mut old_name)) => match self {
+                Set(s) => {
+                    state.clips()[clip].write().unwrap().name = s;
+                    return Ok(Some(Self::Set(old_name.clone().into())))
+                },
+                Confirm => {
+                    let old_name = old_name.clone();
+                    *state.clips_mode_mut() = None;
+                    return Ok(Some(Self::Set(old_name)))
+                },
+                Cancel => {
+                    state.clips()[clip].write().unwrap().name = old_name.clone().into();
+                },
+                _ => unreachable!()
+            },
+            _ => unreachable!()
+        };
+        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!()
+        }
+    }
+}