flatten workspace into 1 crate

src/arranger/arranger_scene.rs

@@ -0,0 +1,91 @@
+use crate::*;
+impl ArrangerTui {
+    pub fn scene_add (&mut self, name: Option<&str>, color: Option<ItemPalette>)
+        -> Usually<&mut ArrangerScene>
+    {
+        let name = name.map_or_else(||self.scene_default_name(), |x|x.to_string());
+        let scene = ArrangerScene {
+            name:  Arc::new(name.into()),
+            clips: vec![None;self.tracks.len()],
+            color: color.unwrap_or_else(ItemPalette::random),
+        };
+        self.scenes.push(scene);
+        let index = self.scenes.len() - 1;
+        Ok(&mut self.scenes[index])
+    }
+    pub fn scene_del (&mut self, index: usize) {
+        todo!("delete scene");
+    }
+    fn scene_default_name (&self) -> String {
+        format!("S{:3>}", self.scenes.len() + 1)
+    }
+    pub fn selected_scene (&self) -> Option<&ArrangerScene> {
+        self.selected.scene().and_then(|s|self.scenes.get(s))
+    }
+    pub fn selected_scene_mut (&mut self) -> Option<&mut ArrangerScene> {
+        self.selected.scene().and_then(|s|self.scenes.get_mut(s))
+    }
+}
+#[derive(Default, Debug, Clone)] pub struct ArrangerScene {
+    /// Name of scene
+    pub(crate) name:  Arc<RwLock<String>>,
+    /// Clips in scene, one per track
+    pub(crate) clips: Vec<Option<Arc<RwLock<MidiClip>>>>,
+    /// Identifying color of scene
+    pub(crate) color: ItemPalette,
+}
+impl ArrangerScene {
+    pub fn name (&self) -> &Arc<RwLock<String>> {
+        &self.name
+    }
+    pub fn clips (&self) -> &Vec<Option<Arc<RwLock<MidiClip>>>> {
+        &self.clips
+    }
+    pub fn color (&self) -> ItemPalette {
+        self.color
+    }
+    pub fn ppqs (scenes: &[Self], factor: usize) -> Vec<(usize, usize)> {
+        let mut total = 0;
+        if factor == 0 {
+            scenes.iter().map(|scene|{
+                let pulses = scene.pulses().max(PPQ);
+                total += pulses;
+                (pulses, total - pulses)
+            }).collect()
+        } else {
+            (0..=scenes.len()).map(|i|{
+                (factor*PPQ, factor*PPQ*i)
+            }).collect()
+        }
+    }
+    pub fn longest_name (scenes: &[Self]) -> usize {
+        scenes.iter().map(|s|s.name().read().unwrap().len()).fold(0, usize::max)
+    }
+    /// Returns the pulse length of the longest phrase 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 phrases in the scene are
+    /// currently playing on the given collection of tracks.
+    pub fn is_playing (&self, tracks: &[ArrangerTrack]) -> bool {
+        self.clips().iter().any(|clip|clip.is_some()) && self.clips().iter().enumerate()
+            .all(|(track_index, clip)|match clip {
+                Some(clip) => tracks
+                    .get(track_index)
+                    .map(|track|{
+                        if let Some((_, Some(phrase))) = track.player().play_phrase() {
+                            *phrase.read().unwrap() == *clip.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 }
+    }
+}