implement controller traits

src/device/arrange/clip.rs

@@ -0,0 +1,165 @@
+use crate::*;
+
+/// TODO: Preserve the generic passthru syntax;
+/// remove this macro (only used twice) and potentially the trait.
+#[macro_export] macro_rules! impl_has_clips {
+    (|$self:ident:$Struct:ident$(<$($L:lifetime),*$($T:ident$(:$U:path)?),*>)?|$cb:expr) => {
+        impl $(<$($L),*$($T $(: $U)?),*>)? HasClips for $Struct $(<$($L),*$($T),*>)? {
+            fn clips <'a> (&'a $self) -> std::sync::RwLockReadGuard<'a, ClipPool>      {
+                $cb.read().unwrap()
+            }
+            fn clips_mut <'a> (&'a $self) -> std::sync::RwLockWriteGuard<'a, ClipPool> {
+                $cb.write().unwrap()
+            }
+        }
+    }
+}
+
+#[macro_export] macro_rules! has_clip {
+    (|$self:ident:$Struct:ident$(<$($L:lifetime),*$($T:ident$(:$U:path)?),*>)?|$cb:expr) => {
+        impl $(<$($L),*$($T $(: $U)?),*>)? HasMidiClip for $Struct $(<$($L),*$($T),*>)? {
+            fn clip (&$self) -> Option<Arc<RwLock<MidiClip>>> { $cb }
+        }
+    }
+}
+
+impl Arrangement {
+    /// Toggle looping for the active clip
+    pub fn toggle_loop (&mut self) {
+        if let Some(clip) = self.selected_clip() {
+            clip.write().unwrap().toggle_loop()
+        }
+    }
+
+    /// Put a clip in a slot
+    pub fn clip_put (
+        &mut self, track: usize, scene: usize, clip: Option<Arc<RwLock<MidiClip>>>
+    ) -> Option<Arc<RwLock<MidiClip>>> {
+        let old = self.scenes[scene].clips[track].clone();
+        self.scenes[scene].clips[track] = clip;
+        old
+    }
+
+    /// Change the color of a clip, returning the previous one
+    pub fn clip_set_color (
+        &self, track: usize, scene: usize, color: ItemTheme
+    ) -> Option<ItemTheme> {
+        self.scenes[scene].clips[track].as_ref().map(|clip|{
+            let mut clip = clip.write().unwrap();
+            let old = clip.color.clone();
+            clip.color = color.clone();
+            panic!("{color:?} {old:?}");
+            //old
+        })
+    }
+}
+
+impl<T: TracksView + ScenesView + Send + Sync> ClipsView for T {}
+
+pub trait HasClipsSize {
+    fn clips_size (&self) -> &Sizer;
+}
+
+impl HasClipsSize for App {
+    fn clips_size (&self) -> &Sizer { &self.project.size_inner }
+}
+
+impl HasClipsSize for Arrangement {
+    fn clips_size (&self) -> &Sizer { &self.size_inner }
+}
+
+pub trait ClipsView: TracksView + ScenesView {
+    /// Draw clips per scene
+    fn view_scenes_clips <'a> (&'a self) -> impl Draw<Tui> + 'a {
+        view_scenes_clips(
+            ||self.scenes_with_sizes(),
+            self.tracks_with_sizes(),
+            self.selection(),
+            self.editor(),
+            self.clips_size(),
+            self.is_editing(),
+        )
+    }
+}
+
+pub fn view_scenes_clips <'a, S: ScenesSizes<'a>> (
+    scenes:  impl Fn()->S,
+    tracks:  impl TracksSizes<'a>,
+    select:  &Selection,
+    editor:  Option<&MidiEditor>,
+    size:    &Sizer,
+    editing: bool,
+) -> impl Draw<Tui> {
+    let status = fg(Green, format!("{}x{}", size.w(), size.h())).align_se().full_wh();
+    let tracks = iter_once(tracks, move|(track_index, track, _, _), _| {
+        let scenes = iter_once(scenes(), move|(scene_index, scene, _, _), _| {
+            let (name, theme): (Arc<str>, ItemTheme) = scene_name_theme(scene, track_index);
+            let f = theme.lightest.term;
+            let (b, o) = scene_bg(theme, select, track_index, scene_index);
+            let w = scene_w(track, select, track_index, editor);
+            let y = scene_y(select, scene_index, editor);
+            let is_selected = scene_sel(select, track_index, scene_index, editing);
+            below(
+                Outer(true, Style::default().fg(o)).full_wh(),
+                below(
+                    below(
+                        fg_bg(o, b, "".full_wh()),
+                        fg_bg(f, b, bold(true, name)).align_nw().full_wh(),
+                    ),
+                    when(is_selected, editor.map(|e|e.view())).full_wh()
+                ).full_wh()
+            ).exact_wh(w, y)
+        });
+        scenes.full_h().exact_w(track.width as u16)
+    });
+
+    return size.of(above(status, tracks).full_wh());
+
+    fn scene_name_theme (scene: &Scene, track_index: usize) -> (Arc<str>, ItemTheme) {
+        if let Some(Some(clip)) = &scene.clips.get(track_index) {
+            let clip = clip.read().unwrap();
+            (format!(" ⏹ {}", &clip.name).into(), clip.color)
+        } else {
+            (" ⏹ -- ".into(), ItemTheme::G[32])
+        }
+    }
+
+    fn scene_bg (
+        theme: ItemTheme, select: &Selection, track_index: usize, scene_index: usize
+    ) -> (Color, Color) {
+        let mut outline = theme.base.term;
+        (if select.track() == Some(track_index) && select.scene() == Some(scene_index) {
+            outline = theme.lighter.term;
+            theme.light.term
+        } else if select.track() == Some(track_index) || select.scene() == Some(scene_index) {
+            outline = theme.darkest.term;
+            theme.base.term
+        } else {
+            theme.dark.term
+        }, outline)
+    }
+
+    fn scene_w (
+        track: &Track, select: &Selection, track_index: usize, editor: Option<&MidiEditor>
+    ) -> u16 {
+        if select.track() == Some(track_index) && let Some(editor) = editor {
+            (editor.size.w() as usize).max(24).max(track.width) as u16
+        } else {
+            track.width as u16
+        }
+    }
+
+    fn scene_y (
+        select: &Selection, scene_index: usize, editor: Option<&MidiEditor>
+    ) -> u16 {
+        if select.scene() == Some(scene_index) && let Some(editor) = editor {
+            editor.size.h().max(12)
+        } else {
+            Scene::DEFAULT_HEIGHT as u16
+        }
+    }
+
+    fn scene_sel (select: &Selection, track_index: usize, scene_index: usize, editing: bool) -> bool {
+        editing && select.track() == Some(track_index) && select.scene() == Some(scene_index)
+    }
+}