move port and midi to tengri

src/device/arrange/scene.rs

@@ -1,174 +0,0 @@
-use crate::*;
-
-/// Default scene height.
-pub const H_SCENE: usize = 2;
-
-/// Default editor height.
-pub const H_EDITOR: usize = 15;
-
-/// A scene consists of a set of clips to play together.
-///
-/// ```
-/// let scene: tek::Scene = Default::default();
-/// let _ = scene.pulses();
-/// let _ = scene.is_playing(&[]);
-/// ```
-#[derive(Debug, Default)] pub struct Scene {
-    /// Name of scene
-    pub name:  Arc<str>,
-    /// Identifying color of scene
-    pub color: ItemTheme,
-    /// Clips in scene, one per track
-    pub clips: Vec<Option<Arc<RwLock<MidiClip>>>>,
-}
-
-impl Scene {
-    /// Returns the pulse length of the longest clip in the scene
-    pub fn pulses (&self) -> usize {
-        self.clips.iter().fold(0, |a, p|{
-            a.max(p.as_ref().map(|q|q.read().unwrap().length).unwrap_or(0))
-        })
-    }
-    /// Returns true if all clips in the scene are
-    /// currently playing on the given collection of tracks.
-    pub fn is_playing (&self, tracks: &[Track]) -> bool {
-        self.clips.iter().any(|clip|clip.is_some()) && self.clips.iter().enumerate()
-            .all(|(track_index, clip)|match clip {
-                Some(c) => tracks
-                    .get(track_index)
-                    .map(|track|{
-                        if let Some((_, Some(clip))) = track.sequencer().play_clip() {
-                            *clip.read().unwrap() == *c.read().unwrap()
-                        } else {
-                            false
-                        }
-                    })
-                    .unwrap_or(false),
-                None => true
-            })
-    }
-    pub fn clip (&self, index: usize) -> Option<&Arc<RwLock<MidiClip>>> {
-        match self.clips.get(index) { Some(Some(clip)) => Some(clip), _ => None }
-    }
-    fn _todo_opt_bool_stub_ (&self) -> Option<bool> { todo!() }
-    fn _todo_usize_stub_ (&self) -> usize { todo!() }
-    fn _todo_arc_str_stub_ (&self) -> Arc<str> { todo!() }
-    fn _todo_item_theme_stub (&self) -> ItemTheme { todo!() }
-}
-
-pub trait ScenesView: HasEditor + HasSelection + HasSceneScroll + HasClipsSize + Send + Sync {
-    fn h_scenes (&self) -> u16;
-    fn w_side   (&self) -> u16;
-    fn w_mid    (&self) -> u16;
-
-    fn view_scenes_names (&self) -> impl Draw<Tui> {
-        view_scenes_names(
-            self.scenes_with_sizes(), self.selection(), self.editor(), self.is_editing()
-        )
-    }
-    fn scenes_with_sizes (&self) -> impl ScenesSizes<'_> {
-        let mut y = 0;
-        self.scenes().iter().enumerate().skip(self.scene_scroll()).map_while(move|(s, scene)|{
-            let height = if self.selection().scene() == Some(s) && self.editor().is_some() {
-                8
-            } else {
-                H_SCENE
-            };
-            if y + height <= self.clips_size().h() as usize {
-                let data = (s, scene, y, y + height);
-                y += height;
-                Some(data)
-            } else {
-                None
-            }
-        })
-    }
-}
-
-pub trait HasSceneScroll: HasScenes {
-    fn scene_scroll (&self) -> usize;
-}
-
-pub trait HasScene: AsRefOpt<Scene> + AsMutOpt<Scene> {
-    fn scene_mut (&mut self) -> Option<&mut Scene> { self.as_mut_opt() }
-    fn scene     (&self)     -> Option<&Scene>     { self.as_ref_opt() }
-}
-
-pub trait HasScenes: AsRef<Vec<Scene>> + AsMut<Vec<Scene>> {
-    fn scenes (&self) -> &Vec<Scene> { self.as_ref()  }
-    fn scenes_mut (&mut self) -> &mut Vec<Scene> { self.as_mut() }
-    /// Generate the default name for a new scene
-    fn scene_default_name (&self) -> Arc<str> { format!("s{:3>}", self.scenes().len() + 1).into() }
-    fn scene_longest_name (&self) -> usize { self.scenes().iter().map(|s|s.name.len()).fold(0, usize::max) }
-    /// Add multiple scenes
-    fn scenes_add (&mut self, n: usize) -> Usually<()> where Self: HasTracks {
-        let scene_color_1 = ItemColor::random();
-        let scene_color_2 = ItemColor::random();
-        for i in 0..n {
-            let _ = self.scene_add(None, Some(
-                scene_color_1.mix(scene_color_2, i as f32 / n as f32).into()
-            ))?;
-        }
-        Ok(())
-    }
-    /// Add a scene
-    fn scene_add (&mut self, name: Option<&str>, color: Option<ItemTheme>)
-        -> Usually<(usize, &mut Scene)> where Self: HasTracks
-    {
-        let scene = Scene {
-            name:  name.map_or_else(||self.scene_default_name(), |x|x.to_string().into()),
-            clips: vec![None;self.tracks().len()],
-            color: color.unwrap_or_else(ItemTheme::random),
-        };
-        self.scenes_mut().push(scene);
-        let index = self.scenes().len() - 1;
-        Ok((index, &mut self.scenes_mut()[index]))
-    }
-}
-
-impl HasSceneScroll for Arrangement {
-    fn scene_scroll (&self) -> usize { self.scene_scroll }
-}
-
-impl HasSceneScroll for App {
-    fn scene_scroll (&self) -> usize { self.project.scene_scroll() }
-}
-
-impl ScenesView for Arrangement {
-    fn h_scenes (&self) -> u16 { (self.size.h() as u16).saturating_sub(20) }
-    fn w_side (&self) -> u16 { (self.size.w() as u16 * 2 / 10).max(20) }
-    fn w_mid (&self) -> u16 { (self.size.w() as u16).saturating_sub(2 * self.w_side()).max(40) }
-}
-
-pub type SceneWith<'a, T> =
-    (usize, &'a Scene, usize, usize, T);
-
-def_command!(SceneCommand: |scene: Scene| {
-    SetSize { size: usize } => { todo!() },
-    SetZoom { size: usize } => { todo!() },
-    SetName { name: Arc<str> } =>
-        swap_value(&mut scene.name, name, |name|Self::SetName{name}),
-    SetColor { color: ItemTheme } =>
-        swap_value(&mut scene.color, color, |color|Self::SetColor{color}),
-});
-
-#[cfg(all(feature = "select"))] impl_as_ref_opt!(Scene: |self: App| self.project.as_ref_opt());
-#[cfg(all(feature = "select"))] impl_as_mut_opt!(Scene: |self: App| self.project.as_mut_opt());
-#[cfg(all(feature = "select"))] impl_as_ref_opt!(Scene: |self: Arrangement| self.selected_scene());
-#[cfg(all(feature = "select"))] impl_as_mut_opt!(Scene: |self: Arrangement| self.selected_scene_mut());
-impl_has!(Vec<Scene>: |self: Arrangement| self.scenes);
-impl<T: TracksView+ScenesView+Send+Sync> ClipsView for T {}
-impl<T: AsRef<Vec<Scene>>+AsMut<Vec<Scene>>> HasScenes for T {}
-impl<T: AsRefOpt<Scene>+AsMutOpt<Scene>+Send+Sync> HasScene for T {}
-
-impl ScenesView for App {
-    fn w_mid (&self) -> u16 {
-        (self.size.w() as u16).saturating_sub(self.w_side())
-    }
-    fn w_side (&self) -> u16 {
-        20
-    }
-    fn h_scenes (&self) -> u16 {
-        (self.size.h() as u16).saturating_sub(20)
-    }
-}