wip: p.57, e=81

crates/tek_tui/src/tui_control.rs

@@ -14,33 +14,109 @@ impl SequencerControl for SequencerTui {}
 
 pub trait ArrangerControl {
     fn selected (&self) -> ArrangerSelection;
+    fn show_phrase (&mut self);
+    fn activate (&mut self);
+    fn selected_phrase (&self) -> Option<Arc<RwLock<Phrase>>>;
+    fn toggle_loop (&mut self);
+    fn randomize_color (&mut self);
 }
 
 impl ArrangerControl for ArrangerTui {
     fn selected (&self) -> ArrangerSelection {
         self.selected
     }
+    fn show_phrase (&mut self) {
+        self.editor.show(self.selected_phrase().as_ref());
+    }
+    fn activate (&mut self) {
+        if let ArrangerSelection::Scene(s) = self.selected {
+            for (t, track) in self.tracks_mut().iter_mut().enumerate() {
+                let clip = self.scenes()[s].clips[t].as_ref();
+                if track.play_phrase.is_some() || clip.is_some() {
+                    track.enqueue_next(clip);
+                }
+            }
+            // TODO make transport available here, so that
+            // activating a scene when stopped starts playback
+            //if self.is_stopped() {
+                //self.transport.toggle_play()
+            //}
+        } else if let ArrangerSelection::Clip(t, s) = self.selected {
+            self.tracks_mut()[t].enqueue_next(self.scenes()[s].clips[t].as_ref());
+        };
+    }
+    fn selected_phrase (&self) -> Option<Arc<RwLock<Phrase>>> {
+        self.selected_scene()?.clips.get(self.selected.track()?)?.clone()
+    }
+    fn toggle_loop (&mut self) {
+        if let Some(phrase) = self.selected_phrase() {
+            phrase.write().unwrap().toggle_loop()
+        }
+    }
+    fn randomize_color (&mut self) {
+        match self.selected {
+            ArrangerSelection::Mix        => {
+                self.color = ItemColor::random_dark()
+            },
+            ArrangerSelection::Track(t)   => {
+                self.tracks_mut()[t].color = ItemColor::random()
+            },
+            ArrangerSelection::Scene(s)   => {
+                self.scenes_mut()[s].color = ItemColor::random()
+            },
+            ArrangerSelection::Clip(t, s) => {
+                if let Some(phrase) = &self.scenes_mut()[s].clips[t] {
+                    phrase.write().unwrap().color = ItemColorTriplet::random();
+                }
+            }
+        }
+    }
 }
 
-pub trait PhrasesControl {
+pub trait PhrasesControl: HasPhrases {
+    fn phrase_index (&self) -> usize;
+    fn phrase_index_mut (&mut self) -> &mut usize;
     fn phrases_mode (&self) -> &Option<PhrasesMode>;
     fn phrases_mode_mut (&mut self) -> &mut Option<PhrasesMode>;
     fn phrase_rename_begin (&mut self) {
-        *self.phrases_mode_mut() = Some(PhrasesMode::Rename(
-            self.phrase,
-            self.phrases[self.phrase].read().unwrap().name.clone()
-        ))
+        let name = self.phrases()[self.phrase_index()].read().unwrap().name.clone();
+        *self.phrases_mode_mut() = Some(
+            PhrasesMode::Rename(self.phrase_index(), name)
+        )
     }
     fn phrase_length_begin (&mut self) {
-        *self.phrases_mode_mut() = Some(PhrasesMode::Length(
-            self.phrase,
-            self.phrases[self.phrase].read().unwrap().length,
-            PhraseLengthFocus::Bar
-        ))
+        let length = self.phrases()[self.phrase_index()].read().unwrap().length;
+        *self.phrases_mode_mut() = Some(
+            PhrasesMode::Length(self.phrase_index(), length, PhraseLengthFocus::Bar)
+        )
+    }
+    fn new_phrase (name: Option<&str>, color: Option<ItemColorTriplet>) -> Arc<RwLock<Phrase>> {
+        Arc::new(RwLock::new(Phrase::new(
+            String::from(name.unwrap_or("(new)")), true, 4 * PPQ, None, color
+        )))
+    }
+    fn index_of (&self, phrase: &Phrase) -> Option<usize> {
+        for i in 0..self.phrases().len() {
+            if *self.phrases()[i].read().unwrap() == *phrase { return Some(i) }
+        }
+        return None
+    }
+    fn insert_dup (&mut self) {
+        let mut phrase = self.phrases()[self.phrase_index()].read().unwrap().duplicate();
+        phrase.color = ItemColorTriplet::random_near(phrase.color, 0.25);
+        let index = self.phrase_index() + 1;
+        self.phrases_mut().insert(index, Arc::new(RwLock::new(phrase)));
+        *self.phrase_index_mut() += 1;
     }
 }
 
 impl PhrasesControl for SequencerTui {
+    fn phrase_index (&self) -> usize {
+        self.view_phrase
+    }
+    fn phrase_index_mut (&mut self) -> &mut usize {
+        &mut self.view_phrase
+    }
     fn phrases_mode (&self) -> &Option<PhrasesMode> {
         &self.phrases_mode
     }
@@ -50,6 +126,12 @@ impl PhrasesControl for SequencerTui {
 }
 
 impl PhrasesControl for ArrangerTui {
+    fn phrase_index (&self) -> usize {
+        self.phrase
+    }
+    fn phrase_index_mut (&mut self) -> &mut usize {
+        &mut self.phrase
+    }
     fn phrases_mode (&self) -> &Option<PhrasesMode> {
         &self.phrases_mode
     }
@@ -59,6 +141,12 @@ impl PhrasesControl for ArrangerTui {
 }
 
 impl PhrasesControl for PhrasesTui {
+    fn phrase_index (&self) -> usize {
+        self.phrase
+    }
+    fn phrase_index_mut (&mut self) -> &mut usize {
+        &mut self.phrase
+    }
     fn phrases_mode (&self) -> &Option<PhrasesMode> {
         &self.mode
     }
@@ -73,6 +161,12 @@ pub trait PhraseControl {
     fn note_axis (&self) -> &RwLock<FixedAxis<usize>>;
     fn note_len (&self) -> usize;
     fn note_len_mut (&mut self) -> &mut usize;
+    fn time_cursor_advance (&self) {
+        let point   = self.time_axis().read().unwrap().point;
+        let length  = self.phrase.as_ref().map(|p|p.read().unwrap().length).unwrap_or(1);
+        let forward = |time|(time + self.note_len()) % length;
+        self.time_axis().write().unwrap().point = point.map(forward);
+    }
 }
 
 impl PhraseControl for SequencerTui {