wip: scaffold PhrasePool, PhraseEditor

crates/tek_sequencer/src/arranger.rs

@@ -0,0 +1,455 @@
+use crate::*;
+
+/// Represents the tracks and scenes of the composition.
+pub struct Arranger<E: Engine> {
+    /// Name of arranger
+    pub name:     Arc<RwLock<String>>,
+    /// Collection of tracks.
+    pub tracks:   Vec<Sequencer<E>>,
+    /// Collection of scenes.
+    pub scenes:   Vec<Scene>,
+    /// Currently selected element.
+    pub selected: ArrangerFocus,
+    /// Display mode of arranger
+    pub mode:     ArrangerViewMode,
+    /// Slot for modal dialog displayed on top of app.
+    pub modal:    Option<Box<dyn ContentComponent<E>>>,
+    /// Whether the arranger is currently focused
+    pub focused:  bool
+}
+
+impl<E: Engine> Arranger<E> {
+    pub fn new (name: &str) -> Self {
+        Self {
+            name:     Arc::new(RwLock::new(name.into())),
+            mode:     ArrangerViewMode::Vertical(2),
+            selected: ArrangerFocus::Clip(0, 0),
+            scenes:   vec![],
+            tracks:   vec![],
+            modal:    None,
+            focused:  false
+        }
+    }
+    pub fn activate (&mut self) {
+        match self.selected {
+            ArrangerFocus::Scene(s) => {
+                for (track_index, track) in self.tracks.iter_mut().enumerate() {
+                    track.playing_phrase = self.scenes[s].clips[track_index];
+                    track.reset = true;
+                }
+            },
+            ArrangerFocus::Clip(t, s) => {
+                self.tracks[t].playing_phrase = self.scenes[s].clips[t];
+                self.tracks[t].reset = true;
+            },
+            _ => {}
+        }
+    }
+    pub fn sequencer (&self) -> Option<&Sequencer<E>> {
+        self.selected.track()
+            .map(|track|self.tracks.get(track))
+            .flatten()
+    }
+    pub fn sequencer_mut (&mut self) -> Option<&mut Sequencer<E>> {
+        self.selected.track()
+            .map(|track|self.tracks.get_mut(track))
+            .flatten()
+    }
+    pub fn show_phrase (&mut self) {
+        let (scene, track) = (self.selected.scene(), self.selected.track());
+        if let (Some(scene_index), Some(track_index)) = (scene, track) {
+            let scene = self.scenes.get(scene_index);
+            let track = self.tracks.get_mut(track_index);
+            if let (Some(scene), Some(track)) = (scene, track) {
+                track.viewing_phrase = scene.clips[track_index]
+            }
+        }
+    }
+    pub fn is_first_row (&self) -> bool {
+        let selected = self.selected;
+        selected.is_mix() || selected.is_track()
+    }
+    pub fn is_last_row (&self) -> bool {
+        let selected = self.selected;
+        (self.scenes.len() == 0 && (selected.is_mix() || selected.is_track())) || match selected {
+            ArrangerFocus::Scene(s) =>
+                s == self.scenes.len() - 1,
+            ArrangerFocus::Clip(_, s) =>
+                s == self.scenes.len() - 1,
+            _ => false
+        }
+    }
+    pub fn track (&self) -> Option<&Sequencer<E>> {
+        self.selected.track().map(|t|self.tracks.get(t)).flatten()
+    }
+    pub fn track_mut (&mut self) -> Option<&mut Sequencer<E>> {
+        self.selected.track().map(|t|self.tracks.get_mut(t)).flatten()
+    }
+    pub fn track_next (&mut self) {
+        self.selected.track_next(self.tracks.len() - 1)
+    }
+    pub fn track_prev (&mut self) {
+        self.selected.track_prev()
+    }
+    pub fn track_add (&mut self, name: Option<&str>) -> Usually<&mut Sequencer<E>> {
+        self.tracks.push(name.map_or_else(
+            || Sequencer::new(&self.track_default_name()),
+            |name| Sequencer::new(name),
+        ));
+        let index = self.tracks.len() - 1;
+        Ok(&mut self.tracks[index])
+    }
+    pub fn track_del (&mut self) {
+        unimplemented!("Arranger::track_del");
+    }
+    pub fn track_default_name (&self) -> String {
+        format!("Track {}", self.tracks.len() + 1)
+    }
+    pub fn scene (&self) -> Option<&Scene> {
+        self.selected.scene().map(|s|self.scenes.get(s)).flatten()
+    }
+    pub fn scene_mut (&mut self) -> Option<&mut Scene> {
+        self.selected.scene().map(|s|self.scenes.get_mut(s)).flatten()
+    }
+    pub fn scene_next (&mut self) {
+        self.selected.scene_next(self.scenes.len() - 1)
+    }
+    pub fn scene_prev (&mut self) {
+        self.selected.scene_prev()
+    }
+    pub fn scene_add (&mut self, name: Option<&str>) -> Usually<&mut Scene> {
+        let clips = vec![None;self.tracks.len()];
+        self.scenes.push(match name {
+            Some(name) => Scene::new(name, clips),
+            None       => Scene::new(&self.scene_default_name(), clips),
+        });
+        let index = self.scenes.len() - 1;
+        Ok(&mut self.scenes[index])
+    }
+    pub fn scene_del (&mut self) {
+        unimplemented!("Arranger::scene_del");
+    }
+    pub fn scene_default_name (&self) -> String {
+        format!("Scene {}", self.scenes.len() + 1)
+    }
+    pub fn phrase (&self) -> Option<&Arc<RwLock<Phrase>>> {
+        let track_id = self.selected.track()?;
+        self.tracks.get(track_id)?.phrases.get((*self.scene()?.clips.get(track_id)?)?)
+    }
+    pub fn phrase_del (&mut self) {
+        let track_index = self.selected.track();
+        let scene_index = self.selected.scene();
+        track_index
+            .and_then(|index|self.tracks.get_mut(index).map(|track|(index, track)))
+            .map(|(track_index, _)|{
+                scene_index
+                    .and_then(|index|self.scenes.get_mut(index))
+                    .map(|scene|scene.clips[track_index] = None);
+            });
+    }
+    pub fn phrase_next (&mut self) {
+        let track_index = self.selected.track();
+        let scene_index = self.selected.scene();
+        track_index
+            .and_then(|index|self.tracks.get_mut(index).map(|track|(index, track)))
+            .and_then(|(track_index, track)|{
+                let phrases = track.phrases.len();
+                scene_index
+                    .and_then(|index|self.scenes.get_mut(index))
+                    .and_then(|scene|{
+                        if let Some(phrase_index) = scene.clips[track_index] {
+                            if phrase_index >= phrases - 1 {
+                                scene.clips[track_index] = None;
+                            } else {
+                                scene.clips[track_index] = Some(phrase_index + 1);
+                            }
+                        } else if phrases > 0 {
+                            scene.clips[track_index] = Some(0);
+                        }
+                        Some(())
+                    })
+            });
+    }
+    pub fn phrase_prev (&mut self) {
+        let track_index = self.selected.track();
+        let scene_index = self.selected.scene();
+        track_index
+            .and_then(|index|self.tracks.get_mut(index).map(|track|(index, track)))
+            .and_then(|(track_index, track)|{
+                let phrases = track.phrases.len();
+                scene_index
+                    .and_then(|index|self.scenes.get_mut(index))
+                    .and_then(|scene|{
+                        if let Some(phrase_index) = scene.clips[track_index] {
+                            scene.clips[track_index] = if phrase_index == 0 {
+                                None
+                            } else {
+                                Some(phrase_index - 1)
+                            };
+                        } else if phrases > 0 {
+                            scene.clips[track_index] = Some(phrases - 1);
+                        }
+                        Some(())
+                    })
+            });
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#[derive(PartialEq, Clone, Copy)]
+/// Represents the current user selection in the arranger
+pub enum ArrangerFocus {
+    /** The whole mix is selected */
+    Mix,
+    /// A track is selected.
+    Track(usize),
+    /// A scene is selected.
+    Scene(usize),
+    /// A clip (track × scene) is selected.
+    Clip(usize, usize),
+}
+
+/// Focus identification methods
+impl ArrangerFocus {
+    pub fn description <E: Engine> (
+        &self,
+        tracks: &Vec<Sequencer<E>>,
+        scenes: &Vec<Scene>,
+    ) -> String {
+        format!("Selected: {}", match self {
+            Self::Mix => format!("Everything"),
+            Self::Track(t) => if let Some(track) = tracks.get(*t) {
+                format!("T{t}: {}", &track.name.read().unwrap())
+            } else {
+                format!("T??")
+            },
+            Self::Scene(s) => if let Some(scene) = scenes.get(*s) {
+                format!("S{s}: {}", &scene.name.read().unwrap())
+            } else {
+                format!("S??")
+            },
+            Self::Clip(t, s) => if let (Some(track), Some(scene)) = (
+                tracks.get(*t),
+                scenes.get(*s),
+            ) {
+                if let Some(Some(slot)) = scene.clips.get(*t) {
+                    if let Some(clip) = track.phrases.get(*slot) {
+                        format!("T{t} S{s} C{slot} ({})", &clip.read().unwrap().name.read().unwrap())
+                    } else {
+                        format!("T{t} S{s}: Empty")
+                    }
+                } else {
+                    format!("T{t} S{s}: Empty")
+                }
+            } else {
+                format!("T{t} S{s}: Empty")
+            }
+        })
+    }
+    pub fn is_mix (&self) -> bool {
+        match self { Self::Mix => true, _ => false }
+    }
+    pub fn is_track (&self) -> bool {
+        match self { Self::Track(_) => true, _ => false }
+    }
+    pub fn is_scene (&self) -> bool {
+        match self { Self::Scene(_) => true, _ => false }
+    }
+    pub fn is_clip (&self) -> bool {
+        match self { Self::Clip(_, _) => true, _ => false }
+    }
+    pub fn track (&self) -> Option<usize> {
+        match self {
+            Self::Clip(t, _) => Some(*t),
+            Self::Track(t)   => Some(*t),
+            _ => None
+        }
+    }
+    pub fn track_next (&mut self, last_track: usize) {
+        *self = match self {
+            Self::Mix        => Self::Track(0),
+            Self::Track(t)   => Self::Track(last_track.min(*t + 1)),
+            Self::Scene(s)   => Self::Clip(0, *s),
+            Self::Clip(t, s) => Self::Clip(last_track.min(*t + 1), *s),
+        }
+    }
+    pub fn track_prev (&mut self) {
+        *self = match self {
+            Self::Mix      => Self::Mix,
+            Self::Scene(s) => Self::Scene(*s),
+            Self::Track(t) => if *t == 0 {
+                Self::Mix
+            } else {
+                Self::Track(*t - 1)
+            },
+            Self::Clip(t, s) => if *t == 0 {
+                Self::Scene(*s)
+            } else {
+                Self::Clip(t.saturating_sub(1), *s)
+            }
+        }
+    }
+    pub fn scene (&self) -> Option<usize> {
+        match self {
+            Self::Clip(_, s) => Some(*s),
+            Self::Scene(s)   => Some(*s),
+            _ => None
+        }
+    }
+    pub fn scene_next (&mut self, last_scene: usize) {
+        *self = match self {
+            Self::Mix        => Self::Scene(0),
+            Self::Track(t)   => Self::Clip(*t, 0),
+            Self::Scene(s)   => Self::Scene(last_scene.min(*s + 1)),
+            Self::Clip(t, s) => Self::Clip(*t, last_scene.min(*s + 1)),
+        }
+    }
+    pub fn scene_prev (&mut self) {
+        *self = match self {
+            Self::Mix      => Self::Mix,
+            Self::Track(t) => Self::Track(*t),
+            Self::Scene(s) => if *s == 0 {
+                Self::Mix
+            } else {
+                Self::Scene(*s - 1)
+            },
+            Self::Clip(t, s) => if *s == 0 {
+                Self::Track(*t)
+            } else {
+                Self::Clip(*t, s.saturating_sub(1))
+            }
+        }
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Display mode of arranger
+#[derive(PartialEq)]
+pub enum ArrangerViewMode { Horizontal, Vertical(usize) }
+/// Arranger display mode can be cycled
+impl ArrangerViewMode {
+    /// Cycle arranger display mode
+    pub fn to_next (&mut self) {
+        *self = match self {
+            Self::Horizontal  => Self::Vertical(1),
+            Self::Vertical(1) => Self::Vertical(2),
+            Self::Vertical(2) => Self::Vertical(2),
+            Self::Vertical(0) => Self::Horizontal,
+            Self::Vertical(_) => Self::Vertical(0),
+        }
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+pub struct VerticalArranger<'a, E: Engine>(
+    pub &'a Arranger<E>, pub usize
+);
+pub struct VerticalArrangerGrid<'a>(
+    pub u16, pub &'a [(usize, usize)], pub &'a [(usize, usize)]
+);
+pub struct VerticalArrangerCursor<'a>(
+    pub bool, pub ArrangerFocus, pub u16, pub &'a [(usize, usize)], pub &'a [(usize, usize)],
+);
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+pub struct HorizontalArranger<'a, E: Engine>(
+    pub &'a Arranger<E>
+);
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Appears on first run (i.e. if state dir is missing).
+pub struct ArrangerRenameModal<E: Engine> {
+    _engine:    std::marker::PhantomData<E>,
+    pub done:   bool,
+    pub target: ArrangerFocus,
+    pub value:  String,
+    pub result: Arc<RwLock<String>>,
+    pub cursor: usize
+}
+
+impl<E: Engine> ArrangerRenameModal<E> {
+    pub fn new (target: ArrangerFocus, value: &Arc<RwLock<String>>) -> Self {
+        Self {
+            _engine: Default::default(),
+            done:    false,
+            value:   value.read().unwrap().clone(),
+            cursor:  value.read().unwrap().len(),
+            result:  value.clone(),
+            target,
+        }
+    }
+}
+
+impl<E: Engine + Send> Exit for ArrangerRenameModal<E> {
+    fn exited (&self) -> bool { self.done }
+    fn exit (&mut self) { self.done = true }
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// A collection of phrases to play on each track.
+#[derive(Default)]
+pub struct Scene {
+    pub name:  Arc<RwLock<String>>,
+    pub clips: Vec<Option<usize>>,
+}
+
+impl Scene {
+    pub fn from_edn <'a, 'e> (args: &[Edn<'e>]) -> Usually<Self> {
+        let mut name  = None;
+        let mut clips = vec![];
+        edn!(edn in args {
+            Edn::Map(map) => {
+                let key = map.get(&Edn::Key(":name"));
+                if let Some(Edn::Str(n)) = key {
+                    name = Some(*n);
+                } else {
+                    panic!("unexpected key in scene '{name:?}': {key:?}")
+                }
+            },
+            Edn::Symbol("_") => {
+                clips.push(None);
+            },
+            Edn::Int(i) => {
+                clips.push(Some(*i as usize));
+            },
+            _ => panic!("unexpected in scene '{name:?}': {edn:?}")
+        });
+        let scene = Self::new(name.unwrap_or(""), clips);
+        Ok(scene)
+    }
+    pub fn new (name: impl AsRef<str>, clips: impl AsRef<[Option<usize>]>) -> Self {
+        let name = Arc::new(RwLock::new(name.as_ref().into()));
+        let clips = clips.as_ref().iter().map(|x|x.clone()).collect();
+        Self { name, clips, }
+    }
+    /// Returns the pulse length of the longest phrase in the scene
+    pub fn pulses <E: Engine> (&self, tracks: &[Sequencer<E>]) -> usize {
+        self.clips.iter().enumerate()
+            .filter_map(|(i, c)|c
+                .map(|c|tracks
+                    .get(i)
+                    .map(|track|track
+                        .phrases
+                        .get(c))))
+            .filter_map(|p|p)
+            .filter_map(|p|p)
+            .fold(0, |a, p|a.max(p.read().unwrap().length))
+    }
+    /// Returns true if all phrases in the scene are currently playing
+    pub fn is_playing <E: Engine> (&self, tracks: &[Sequencer<E>]) -> bool {
+        self.clips.iter().enumerate()
+            .all(|(track_index, phrase_index)|match phrase_index {
+                Some(i) => tracks
+                    .get(track_index)
+                    .map(|track|track.playing_phrase == Some(*i))
+                    .unwrap_or(false),
+                None => true
+            })
+    }
+}