big flat

src/pool.rs

@@ -0,0 +1,482 @@
+use crate::*;
+
+/// A clip pool.
+///
+/// ```
+/// let pool = tek::Pool::default();
+/// ```
+#[derive(Debug)] pub struct Pool {
+    pub visible: bool,
+    /// Selected clip
+    pub clip: AtomicUsize,
+    /// Mode switch
+    pub mode: Option<PoolMode>,
+    /// Embedded file browse
+    #[cfg(feature = "browse")]  pub browse:  Option<Browse>,
+    /// Collection of MIDI clips.
+    #[cfg(feature = "clip")]    pub clips:   Arc<RwLock<Vec<Arc<RwLock<MidiClip>>>>>,
+    /// Collection of sound samples.
+    #[cfg(feature = "sampler")] pub samples: Arc<RwLock<Vec<Arc<RwLock<Sample>>>>>,
+}
+
+/// Displays and edits clip length.
+#[derive(Clone, Debug, Default)] 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>,
+}
+
+/// Some sort of wrapper again?
+pub struct PoolView<'a>(pub &'a Pool);
+
+/// 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, Browse),
+    /// Save clip to disk
+    Export(usize, Browse),
+}
+
+/// 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<T: AsRef<Pool> + AsMut<Pool>> HasPool for T {}
+
+pub trait HasPool: AsRef<Pool> + AsMut<Pool> {
+    fn pool (&self) -> &Pool {
+        self.as_ref()
+    }
+    fn pool_mut (&mut self) -> &mut Pool {
+        self.as_mut()
+    }
+}
+
+impl<T: HasPool
+    + Namespace<bool>
+    + Namespace<usize>
+    + Namespace<Arc<str>>
+    + Namespace<PathBuf>
+    + Namespace<MidiClip>
+    + Namespace<ItemColor>
+    + Namespace<BrowseCommand>
+> PoolController for T {}
+
+#[tek_proc::commands(PoolCommand = "pool")]
+pub trait PoolController: HasPool
+    + Namespace<bool>
+    + Namespace<usize>
+    + Namespace<Arc<str>>
+    + Namespace<PathBuf>
+    + Namespace<MidiClip>
+    + Namespace<ItemColor>
+    + Namespace<BrowseCommand>
+{
+
+    #[command(Show = "show")]
+    /// Toggle visibility of pool
+    fn show (&mut self, visible: bool) -> Perhaps<PoolCommand> {
+        self.pool_mut().visible = visible;
+        Ok(Some(PoolCommand::Show { visible: !visible }))
+    }
+
+    /// Set selected clip
+    #[command(Select = "select")]
+    fn select (&mut self, index: usize) -> Perhaps<PoolCommand> {
+        self.pool_mut().set_clip_index(index);
+        Ok(None)
+    }
+
+    ///// Import from file
+    //#[command(Browse = "browse")]
+    //fn browse (&mut self, command: BrowseCommand) -> Perhaps<PoolCommand> {
+        //Ok(if let Some(browse) = self.pool_mut().browse.as_mut() {
+            //command.act(browse)?.map(|command|PoolCommand::Browse{command})
+        //} else {
+            //None
+        //})
+    //}
+
+    /// Import clip to pool from file
+    #[command(Import = "import")]
+    fn clip_import (&mut self, index: usize, path: PathBuf) -> Perhaps<PoolCommand>
+        where Self: Sized
+    {
+        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);
+        }
+        Ok(PoolCommand::Add { index, clip }.dispatch(self)?)
+    }
+
+    ///// Export to file
+    //#[command(Export = "export")]
+    //fn export (&mut self, command: BrowseCommand) -> Perhaps<PoolCommand> {
+        //Ok(if let Some(browse) = self.pool_mut().browse.as_mut() {
+            //command.act(browse)?.map(|command|PoolCommand::Export{command})
+        //} else {
+            //None
+        //})
+    //}
+
+    /// Delete a clip from the pool
+    #[command(Delete = "delete")]
+    fn delete (&mut self, index: usize) -> Perhaps<PoolCommand> {
+        let clip = self.pool_mut().clips_mut().remove(index).try_read().unwrap().clone();
+        Ok(Some(PoolCommand::Add { index, clip }))
+    }
+
+    /// Switch places of two clips in pool
+    #[command(Swap = "swap")]
+    fn swap (&mut self, index: usize, other: usize) -> Perhaps<PoolCommand> {
+        self.pool_mut().clips_mut().swap(index, other);
+        Ok(Some(PoolCommand::Swap { index, other }))
+    }
+
+    /// Add clip to pool
+    #[command(Add = "add")]
+    fn clip_add (&mut self, index: usize, clip: MidiClip) -> Perhaps<PoolCommand> {
+        let mut index = index;
+        let clip = Arc::new(RwLock::new(clip.clone()));
+        let mut clips = self.pool_mut().clips_mut();
+        if index >= clips.len() {
+            index = clips.len();
+            clips.push(clip)
+        } else {
+            clips.insert(index, clip);
+        }
+        Ok(Some(PoolCommand::Delete { index }))
+    }
+
+    /// Set name of clip
+    #[command(SetName = "set-name")]
+    fn clip_set_name (&mut self, index: usize, name: Arc<str>) -> Perhaps<PoolCommand> {
+        let clip = &mut self.pool_mut().clips_mut()[index];
+        let old_name = clip.try_read().unwrap().name.clone();
+        clip.try_write().unwrap().name = name.clone();
+        Ok(Some(PoolCommand::SetName { index, name: old_name }))
+    }
+
+    /// Set length of clip
+    #[command(SetLength = "set-length")]
+    fn clip_set_length (&mut self, index: usize, length: usize) -> Perhaps<PoolCommand> {
+        let clip = &mut self.pool_mut().clips_mut()[index];
+        let old_len = clip.try_read().unwrap().length;
+        clip.try_write().unwrap().length = length;
+        Ok(Some(PoolCommand::SetLength { index, length: old_len }))
+    }
+
+    /// Set color of clip
+    #[command(SetColor = "set-color")]
+    fn clip_set_color (&mut self, index: usize, color: ItemColor) -> Perhaps<PoolCommand> {
+        let mut color = ItemTheme::from(color);
+        std::mem::swap(&mut color, &mut self.pool().clips()[index].try_write().unwrap().color);
+        Ok(Some(PoolCommand::SetColor { index, color: color.base }))
+    }
+
+    /// Enter crop mode
+    #[command(CropBegin = "crop/begin")]
+    fn crop_begin (&mut self) -> Perhaps<PoolCommand> {
+        let index  = self.pool().clip_index();
+        let length = self.pool().clips()[index].try_read().unwrap().length;
+        *self.pool_mut().mode_mut() = Some(PoolMode::Length(index, length, ClipLengthFocus::Bar));
+        Ok(None)
+    }
+
+    /// Exit crop mode, discard
+    #[command(CropCancel = "crop/cancel")]
+    fn crop_cancel (&mut self) -> Perhaps<PoolCommand> {
+        if let Some(PoolMode::Length(..)) = self.pool_mut().mode_mut().clone() {
+            *self.pool_mut().mode_mut() = None;
+        }
+        Ok(None)
+    }
+
+    #[command(CropSet = "crop/set")]
+    fn crop_set (&mut self, _length: usize) -> Perhaps<PoolCommand> {
+        if let Some(PoolMode::Length(clip, ref mut length, ref mut _focus))
+            = self.pool_mut().mode_mut().clone()
+        {
+            let old_length;
+            {
+                let clip = self.pool().clips()[clip].clone();//.try_write().unwrap();
+                old_length = Some(clip.try_read().unwrap().length);
+                clip.try_write().unwrap().length = *length;
+            }
+            *self.pool_mut().mode_mut() = None;
+            return Ok(old_length.map(|l|PoolCommand::CropSet { _length: l }))
+        }
+        Ok(None)
+    }
+
+    #[command(CropNext = "crop/next")]
+    fn crop_next (&mut self) -> Perhaps<PoolCommand> {
+        if let Some(PoolMode::Length(
+            _clip, ref mut _length, ref mut focus
+        )) = self.pool_mut().mode_mut().clone() {
+            focus.next()
+        };
+        Ok(None)
+    }
+
+    #[command(CropPrev = "crop/prev")]
+    fn crop_prev (&mut self) -> Perhaps<PoolCommand> {
+        if let Some(PoolMode::Length(
+            _clip, ref mut _length, ref mut focus
+        )) = self.pool_mut().mode_mut().clone() {
+            focus.prev()
+        };
+        Ok(None)
+    }
+
+    #[command(CropInc = "crop/inc")]
+    fn crop_inc (&mut self) -> Perhaps<PoolCommand> {
+        if let Some(PoolMode::Length(
+            _clip, ref mut length, ref mut focus
+        )) = self.pool_mut().mode_mut().clone() {
+            match focus {
+                ClipLengthFocus::Bar  => { *length += 4 * PPQ },
+                ClipLengthFocus::Beat => { *length += PPQ     },
+                ClipLengthFocus::Tick => { *length += 1       },
+            }
+        }
+        Ok(None)
+    }
+
+    #[command(CropDec = "crop/dec")]
+    fn crop_dec (&mut self) -> Perhaps<PoolCommand> {
+        if let Some(PoolMode::Length(
+            _clip, ref mut length, ref mut focus
+        )) = self.pool_mut().mode_mut().clone() {
+            match focus {
+                ClipLengthFocus::Bar  => { *length = length.saturating_sub(4 * PPQ) },
+                ClipLengthFocus::Beat => { *length = length.saturating_sub(PPQ)     },
+                ClipLengthFocus::Tick => { *length = length.saturating_sub(1)       },
+            }
+        }
+        Ok(None)
+    }
+
+    /// Enter rename mode
+    #[command(RenameBegin = "rename/begin")]
+    fn rename_begin (&mut self) -> Perhaps<PoolCommand> {
+        let index = self.pool().clip_index();
+        let name = self.pool().clips()[index].try_read().unwrap().name.clone();
+        *self.pool_mut().mode_mut() = Some(PoolMode::Rename(index, name));
+        Ok(None)
+    }
+
+    /// Exit rename mode, discard
+    #[command(RenameCancel = "rename/cancel")]
+    fn rename_cancel (&mut self) -> Perhaps<PoolCommand> {
+        if let Some(PoolMode::Rename(clip, ref mut old_name)) = self.pool_mut().mode_mut().clone() {
+            self.pool().clips()[clip].try_write().unwrap().name = old_name.clone().into();
+        }
+        Ok(None)
+    }
+
+    /// Exit rename mode, update name
+    #[command(RenameConfirm = "rename/confirm")]
+    fn rename_confirm (&mut self) -> Perhaps<PoolCommand> {
+        Ok(if let Some(PoolMode::Rename(_clip, ref mut old_name)) = self.pool_mut().mode_mut().clone() {
+            let old_name = old_name.clone();
+            *self.pool_mut().mode_mut() = None;
+            Some(PoolCommand::RenameSet { value: old_name })
+        } else {
+            None
+        })
+    }
+
+    #[command(RenameSet = "rename/set")]
+    fn rename_set (&mut self, value: Arc<str>) -> Perhaps<PoolCommand> {
+        if let Some(PoolMode::Rename(clip, ref mut _old_name)) = self.pool_mut().mode_mut().clone() {
+            self.pool().clips()[clip].try_write().unwrap().name = value.clone();
+        }
+        Ok(None)
+    }
+
+}
+
+has_clip!(|self: Pool|self.clips().get(self.clip_index()).map(|c|c.clone()));
+
+impl_has_clips!(|self: Pool|self.clips);
+
+impl_from!(Pool: |clip:&Arc<RwLock<MidiClip>>|{
+    let model = Self::default();
+    model.clips.try_write().unwrap().push(clip.clone());
+    model.clip.store(1, Relaxed);
+    model
+});
+
+impl_default!(Pool: Self {
+    browse:  None,
+    clip:    0.into(),
+    clips:   Arc::from(RwLock::from(vec![])),
+    mode:    None,
+    samples: Arc::from(RwLock::from(vec![])),
+    visible: true,
+});
+
+impl Pool {
+    pub fn clip_index (&self) -> usize {
+        self.clip.load(Relaxed)
+    }
+    pub fn set_clip_index (&self, value: usize) {
+        self.clip.store(value, Relaxed);
+    }
+    pub fn mode (&self) -> &Option<PoolMode> {
+        &self.mode
+    }
+    pub fn mode_mut (&mut self) -> &mut Option<PoolMode> {
+        &mut self.mode
+    }
+    pub fn begin_import (&mut self) -> Usually<()> {
+        *self.mode_mut() = Some(PoolMode::Import(
+            self.clip_index(),
+            Browse::new(None)?
+        ));
+        Ok(())
+    }
+    pub fn begin_export (&mut self) -> Usually<()> {
+        *self.mode_mut() = Some(PoolMode::Export(
+            self.clip_index(),
+            Browse::new(None)?
+        ));
+        Ok(())
+    }
+    pub fn new_clip (&self) -> MidiClip {
+        MidiClip::new("Clip", true, 4 * PPQ, None, Some(ItemTheme::random()))
+    }
+    pub fn cloned_clip (&self) -> MidiClip {
+        let index    = self.clip_index();
+        let mut clip = self.clips()[index].try_read().unwrap().duplicate();
+        clip.color   = ItemTheme::random_near(clip.color, 0.25);
+        clip
+    }
+    pub fn add_new_clip (&self) -> (usize, Arc<RwLock<MidiClip>>) {
+        let clip = Arc::new(RwLock::new(self.new_clip()));
+        let index = {
+            let mut clips = self.clips.try_write().unwrap();
+            clips.push(clip.clone());
+            clips.len().saturating_sub(1)
+        };
+        self.clip.store(index, Relaxed);
+        (index, clip)
+    }
+    pub fn delete_clip (&mut self, clip: &MidiClip) -> bool {
+        let index = self.clips.try_read().unwrap().iter().position(|x|*x.try_read().unwrap()==*clip);
+        if let Some(index) = index {
+            self.clips.try_write().unwrap().remove(index);
+            return true
+        }
+        false
+    }
+}
+
+impl ClipLengthFocus {
+    pub fn next (&mut self) {
+        use ClipLengthFocus::*;
+        *self = match self { Bar => Beat, Beat => Tick, Tick => Bar, }
+    }
+    pub fn prev (&mut self) {
+        use ClipLengthFocus::*;
+        *self = match self { Bar => Tick, Beat => Bar, Tick => Beat, }
+    }
+}
+
+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
+    }
+}
+
+impl Pool {
+    fn _clip_new (&self) -> MidiClip { self.new_clip() }
+    fn _clip_cloned (&self) -> MidiClip { self.cloned_clip() }
+    fn _clip_index_current (&self) -> usize { 0 }
+    fn _clip_index_after (&self) -> usize { 0 }
+    fn _clip_index_previous (&self) -> usize { 0 }
+    fn _clip_index_next (&self) -> usize { 0 }
+    fn _color_random (&self) -> ItemColor { ItemColor::random() }
+}
+
+impl<'a> PoolView<'a> {
+    //fn tui (&self) -> impl Draw<'_, Tui> {
+        //let Self(pool) = self;
+        ////let color  = self.1.clip().map(|c|c.try_read().unwrap().color).unwrap_or_else(||g(32).into());
+        ////let on_bg  = |x|x;//below(Repeat(" "), bg(color.darkest.term, x));
+        ////let border = |x|x;//Outer(Style::default().fg(color.dark.term).bg(color.darkest.term)).enclose(x);
+        ////let height = pool.clips.try_read().unwrap().len() as u16;
+        //iter(
+            //||pool.clips().clone().into_iter(),
+            //move|clip: Arc<RwLock<MidiClip>>, i: usize|{
+                //let MidiClip { ref name, color, length, .. } = *clip.try_read().unwrap();
+                //let item_height = 1;
+                //let _item_offset = i as u16 * item_height;
+                //let selected    = i == pool.clip_index();
+                //let b           = if selected { color.light.term } else { color.base.term };
+                //let f           = color.lightest.term;
+                //let name        = if false { format!(" {i:>3}") } else { format!(" {i:>3} {name}") };
+                //let length      = if false { String::default()  } else { format!("{length}  ") };
+                //bg(b, below!(
+                    //fg(f, bold(selected, name)).origin_w().full_w(),
+                    //fg(f, bold(selected, length)).origin_e().full_w(),
+                    //when(selected, bold(true, fg(g(255), "▶"))).origin_w().full_w(),
+                    //when(selected, bold(true, fg(g(255), "◀"))).origin_e().full_w(),
+                //)).exact_h(1)
+            //}).origin_n().full_h().exact_w(20)
+    //}
+}
+
+impl ClipLength {
+    //fn tui (&self) -> impl Draw<'_, Tui> {
+        //use ClipLengthFocus::*;
+        //let bars  = format!("{}", self.bars());
+        //let beats = format!("{}", self.beats());
+        //let ticks = format!("{:>02}", self.ticks());
+        //match self.focus {
+            //None       => east!(" ", bars, ".", beats, ".", ticks),
+            //Some(Bar)  => east!("[", bars, "]", beats, ".", ticks),
+            //Some(Beat) => east!(" ", bars, "[", beats, "]", ticks),
+            //Some(Tick) => east!(" ", bars, ".", beats, "[", ticks),
+        //}
+    //}
+}