wip: refactor pt.20: 44 errors

crates/tek_tui/src/tui_arranger.rs

@@ -1,31 +1,107 @@
 use crate::*;
 
+pub type ArrangerApp = AppContainer<
+    Tui,
+    ArrangerModel,
+    ArrangerView<Tui>,
+    ArrangerViewCommand,
+    ArrangerAudio,
+    ArrangerStatusBar
+>;
+
+impl ArrangerApp {
+    pub fn run <'a> (jack: &Arc<RwLock<JackClient>>) -> Usually<Self> {
+        let clock = Arc::new(Clock::from(Instant::default()));
+
+        let transport = Arc::new(RwLock::new(tek_api::Transport {
+            metronome: false,
+            transport: jack.read().unwrap().transport(),
+            jack:      jack.clone(),
+            clock:     clock.clone()
+        }));
+
+        let phrases = Arc::new(RwLock::new(PhrasePool {
+            phrases: vec![]
+        }));
+
+        let player = Arc::new(RwLock::new(MIDIPlayer::new(jack, &clock, "preview")?));
+
+        let arrangement = Arc::new(RwLock::new(Arrangement {
+            jack:      jack.clone(),
+            clock:     clock.clone(),
+            name:      Arc::new(RwLock::new(String::new())),
+            phrases:   phrases.read().unwrap().phrases.clone(), // FIXME
+            tracks:    vec![],
+            scenes:    vec![],
+        }));
+
+        let sequencer = Arc::new(RwLock::new(SequencerModel {
+            transport: transport.clone(),
+            phrases:   phrases.clone(),
+            player:    player.clone(),
+        }));
+
+        let model = Arc::new(RwLock::new(ArrangerModel {
+            arrangement: arrangement.clone(),
+            sequencer:   sequencer.clone(),
+            transport:   transport.clone(),
+            phrases:     phrases.clone(),
+        }));
+
+        Ok(Self::new(
+            &model,
+            ArrangerView::from(&model),
+            ArrangerAudio(arrangement.clone()),
+            None,
+            None
+        ))
+    }
+}
+
+pub struct ArrangerModel {
+    pub arrangement: Arc<RwLock<Arrangement>>,
+    pub sequencer:   Arc<RwLock<SequencerModel>>,
+    pub transport:   Arc<RwLock<tek_api::Transport>>,
+    pub phrases:     Arc<RwLock<PhrasePool>>,
+}
+
+impl<E: Engine> From<&Arc<RwLock<ArrangerModel>>> for ArrangerView<E> {
+    fn from (model: &Arc<RwLock<ArrangerModel>>) -> Self {
+        let mut view = Self {
+            model:     model.clone(),
+            sequencer: SequencerView::from(&model.read().unwrap().sequencer),
+            split:     20,
+            selected:  ArrangementEditorFocus::Clip(0, 0),
+            mode:      ArrangementEditorMode::Vertical(2),
+            color:     Color::Rgb(28, 35, 25).into(),
+            size:      Measure::new(),
+            focused:   false,
+            entered:   false,
+        };
+        view.update_focus();
+        view
+    }
+}
+
 /// Root level object for standalone `tek_arranger`
 pub struct ArrangerView<E: Engine> {
+    pub model:       Arc<RwLock<ArrangerModel>>,
     /// Sequencer component
     pub sequencer:   SequencerView<E>,
-    /// Contains all the sequencers.
-    pub arrangement: ArrangementEditor<E>,
     /// Height of arrangement
     pub split:       u16,
-    /// Width and height of app at last render
-    pub size:        Measure<E>,
-}
-
-pub struct ArrangementEditor<E: Engine> {
-    pub model:    Arrangement,
     /// Currently selected element.
-    pub selected: ArrangementEditorFocus,
+    pub selected:    ArrangementEditorFocus,
     /// Display mode of arranger
-    pub mode:     ArrangementEditorMode,
+    pub mode:        ArrangementEditorMode,
     /// Background color of arrangement
-    pub color:    ItemColor,
-    /// Width and height of arrangement area at last render
-    pub size:     Measure<E>,
+    pub color:       ItemColor,
     /// Whether the arranger is currently focused
-    pub focused:  bool,
+    pub focused:     bool,
     /// Whether this is currently in edit mode
-    pub entered:  bool,
+    pub entered:     bool,
+    /// Width and height of arrangement area at last render
+    pub size:        Measure<E>,
 }
 
 /// Display mode of arranger
@@ -37,13 +113,27 @@ pub enum ArrangementEditorMode {
     Vertical(usize),
 }
 
+/// Arranger display mode can be cycled
+impl ArrangementEditorMode {
+    /// 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),
+        }
+    }
+}
+
 impl<E: Engine> Audio for ArrangerView<E> {
     #[inline] fn process (&mut self, _: &Client, _: &ProcessScope) -> Control {
         // FIXME: one of these per playing track
-        if let ArrangementEditorFocus::Clip(t, s) = self.arrangement.selected {
-            let phrase = self.arrangement.model.scenes.get(s).map(|scene|scene.clips.get(t));
+        if let ArrangementEditorFocus::Clip(t, s) = self.selected {
+            let phrase = self.model.scenes.get(s).map(|scene|scene.clips.get(t));
             if let Some(Some(Some(phrase))) = phrase {
-                if let Some(track) = self.arrangement.model.tracks.get(t) {
+                if let Some(track) = self.model.tracks.get(t) {
                     if let Some((ref started_at, Some(ref playing))) = track.player.phrase {
                         let phrase = phrase.read().unwrap();
                         if *playing.read().unwrap() == *phrase {
@@ -72,18 +162,26 @@ impl Content for ArrangerView<Tui> {
             Split::down(
                 self.split,
                 lay!(
-                    widget(&self.arrangement)
+                    Layers::new(move |add|{
+                        match self.mode {
+                            ArrangementEditorMode::Horizontal =>
+                                add(&arranger_content_horizontal(self))?,
+                            ArrangementEditorMode::Vertical(factor) =>
+                                add(&arranger_content_vertical(self, factor))?
+                        };
+                        add(&self.size)
+                    })
                         .grow_y(1)
                         .border(Lozenge(Style::default()
                             .bg(TuiTheme::border_bg())
-                            .fg(TuiTheme::border_fg(self.arrangement.focused)))),
-                    widget(&self.arrangement.size),
-                    widget(&format!("[{}] Arrangement", if self.arrangement.entered {
+                            .fg(TuiTheme::border_fg(self.focused)))),
+                    widget(&self.size),
+                    widget(&format!("[{}] Arrangement", if self.entered {
                         "■"
                     } else {
                         " "
                     }))
-                        .fg(TuiTheme::title_fg(self.arrangement.focused))
+                        .fg(TuiTheme::title_fg(self.focused))
                         .push_x(1),
                 ),
                 Split::right(
@@ -99,52 +197,19 @@ impl Content for ArrangerView<Tui> {
 /// General methods for arranger
 impl<E: Engine> ArrangerView<E> {
 
-    pub fn new (
-        sequencer:   SequencerView<E>,
-        arrangement: ArrangementEditor<E>,
-    ) -> Self {
-        let mut app = Self { sequencer, arrangement, split: 15, size: Measure::new() };
-        app.update_focus();
-        app
-    }
-
-    /// Toggle global play/pause
-    pub fn toggle_play (&mut self) -> Usually<()> {
-        self.sequencer.transport.model.toggle_play()
-    }
-
-    pub fn next_color (&self) -> ItemColor {
-        if let ArrangementEditorFocus::Clip(track, scene) = self.arrangement.selected {
-            let track_color = self.arrangement.model.tracks[track].color;
-            let scene_color = self.arrangement.model.scenes[scene].color;
-            track_color.mix(scene_color, 0.5).mix(ItemColor::random(), 0.25)
-        } else {
-            panic!("could not compute next color")
-        }
-    }
-
     /// Focus the editor with the current phrase
     pub fn show_phrase (&mut self) {
-        self.sequencer.editor.show(self.arrangement.phrase().as_ref());
-    }
-
-    /// Focus the editor with the current phrase
-    pub fn edit_phrase (&mut self) {
-        if self.arrangement.selected.is_clip() && self.arrangement.phrase().is_none() {
-            self.sequencer.phrases.append_new(None, Some(self.next_color().into()));
-            self.arrangement.phrase_put();
-        }
-        self.show_phrase();
-        self.focus(ArrangerViewFocus::PhraseEditor);
-        self.sequencer.editor.entered = true;
+        let arrangement = self.model.read().unwrap().arrangement.read().unwrap();
+        self.sequencer.editor.show(self.selected_phrase().as_ref());
     }
 
     pub fn activate (&mut self) {
-        match self.arrangement.selected {
+        let arrangement = self.model.read().unwrap().arrangement.read().unwrap();
+        match self.selected {
             ArrangementEditorFocus::Scene(s) => {
-                for (t, track) in self.arrangement.model.tracks.iter_mut().enumerate() {
+                for (t, track) in self.model.tracks.iter_mut().enumerate() {
                     let player = &mut track.player;
-                    let clip = self.arrangement.model.scenes[s].clips[t].as_ref();
+                    let clip = self.model.scenes[s].clips[t].as_ref();
                     if player.phrase.is_some() || clip.is_some() {
                         player.enqueue_next(clip);
                     }
@@ -156,189 +221,61 @@ impl<E: Engine> ArrangerView<E> {
                 //}
             },
             ArrangementEditorFocus::Clip(t, s) => {
-                let clip = self.arrangement.model.scenes[s].clips[t].as_ref();
-                self.arrangement.model.tracks[t].player.enqueue_next(clip);
+                let clip = self.model.scenes[s].clips[t].as_ref();
+                self.model.tracks[t].player.enqueue_next(clip);
             },
             _ => {}
         }
     }
 
-    pub fn delete (&mut self) {
-        match self.arrangement.selected {
-            ArrangementEditorFocus::Track(_)   => self.arrangement.track_del(),
-            ArrangementEditorFocus::Scene(_)   => self.arrangement.scene_del(),
-            ArrangementEditorFocus::Clip(_, _) => self.arrangement.phrase_del(),
-            _ => {}
-        }
-    }
-
     pub fn is_first_row (&self) -> bool {
-        let selected = self.arrangement.selected;
+        let arrangement = self.model.read().unwrap().arrangement.read().unwrap();
+        let selected = self.selected;
         selected.is_mix() || selected.is_track()
     }
 
     pub fn is_last_row (&self) -> bool {
-        let selected = self.arrangement.selected;
-        (self.arrangement.model.scenes.len() == 0 && (selected.is_mix() || selected.is_track())) || match selected {
-            ArrangementEditorFocus::Scene(s)   => s == self.arrangement.model.scenes.len() - 1,
-            ArrangementEditorFocus::Clip(_, s) => s == self.arrangement.model.scenes.len() - 1,
+        let arrangement = self.model.read().unwrap().arrangement.read().unwrap();
+        let selected = self.selected;
+        (self.model.scenes.len() == 0 && (selected.is_mix() || selected.is_track())) || match selected {
+            ArrangementEditorFocus::Scene(s)   => s == self.model.scenes.len() - 1,
+            ArrangementEditorFocus::Clip(_, s) => s == self.model.scenes.len() - 1,
             _ => false
         }
     }
 
     pub fn toggle_loop (&mut self) {
-        if let Some(phrase) = self.arrangement.phrase() {
+        if let Some(phrase) = self.selected_phrase() {
             phrase.write().unwrap().toggle_loop()
         }
     }
 
     pub fn randomize_color (&mut self) {
-        match self.arrangement.selected {
+        let arrangement = self.model.read().unwrap().arrangement.read().unwrap();
+        match self.selected {
             ArrangementEditorFocus::Mix        => {
-                self.arrangement.color = ItemColor::random_dark()
+                self.color = ItemColor::random_dark()
             },
             ArrangementEditorFocus::Track(t)   => {
-                self.arrangement.model.tracks[t].color = ItemColor::random()
+                self.model.tracks[t].color = ItemColor::random()
             },
             ArrangementEditorFocus::Scene(s)   => {
-                self.arrangement.model.scenes[s].color = ItemColor::random()
+                self.model.scenes[s].color = ItemColor::random()
             },
             ArrangementEditorFocus::Clip(t, s) => {
-                if let Some(phrase) = &self.arrangement.model.scenes[s].clips[t] {
+                if let Some(phrase) = &self.model.scenes[s].clips[t] {
                     phrase.write().unwrap().color = ItemColorTriplet::random();
                 }
             }
         }
     }
-
-}
-
-/// Arranger display mode can be cycled
-impl ArrangementEditorMode {
-    /// 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),
-        }
-    }
-}
-
-impl Content for ArrangementEditor<Tui> {
-    type Engine = Tui;
-    fn content (&self) -> impl Widget<Engine = Tui> {
-        Layers::new(move |add|{
-            match self.mode {
-                ArrangementEditorMode::Horizontal =>
-                    add(&arranger_content_horizontal(self))?,
-                ArrangementEditorMode::Vertical(factor) =>
-                    add(&arranger_content_vertical(self, factor))?
-            };
-            add(&self.size)
-        })
-    }
-}
-
-impl<E: Engine> ArrangementEditor<E> {
-    pub fn new (model: Arrangement) -> Self {
-        Self {
-            model,
-            selected: ArrangementEditorFocus::Clip(0, 0),
-            mode:     ArrangementEditorMode::Vertical(2),
-            color:    Color::Rgb(28, 35, 25).into(),
-            size:     Measure::new(),
-            focused:  false,
-            entered:  false,
-        }
-    }
-}
-
-impl<E: Engine> ArrangementEditor<E> {
-    pub fn track (&self) -> Option<&ArrangementTrack> {
-        self.selected.track().map(|t|self.model.tracks.get(t)).flatten()
-    }
-    pub fn track_mut (&mut self) -> Option<&mut ArrangementTrack> {
-        self.selected.track().map(|t|self.model.tracks.get_mut(t)).flatten()
-    }
-    pub fn scene (&self) -> Option<&ArrangementScene> {
+    pub fn selected_scene (&self) -> Option<&ArrangementScene> {
         self.selected.scene().map(|s|self.model.scenes.get(s)).flatten()
     }
-    pub fn scene_mut (&mut self) -> Option<&mut ArrangementScene> {
+    pub fn selected_scene_mut (&mut self) -> Option<&mut ArrangementScene> {
         self.selected.scene().map(|s|self.model.scenes.get_mut(s)).flatten()
     }
-    pub fn phrase (&self) -> Option<Arc<RwLock<Phrase>>> {
-        self.scene()?.clips.get(self.selected.track()?)?.clone()
-    }
-    pub fn track_del (&mut self) {
-        if let Some(index) = self.selected.track() { self.model.track_del(index); }
-    }
-    pub fn scene_del (&mut self) {
-        if let Some(index) = self.selected.scene() { self.model.scene_del(index); }
-    }
-    pub fn track_widths (&self) -> Vec<(usize, usize)> {
-        let mut widths = vec![];
-        let mut total = 0;
-        for track in self.model.tracks.iter() {
-            let width = track.width;
-            widths.push((width, total));
-            total += width;
-        }
-        widths.push((0, total));
-        widths
-    }
-    pub fn phrase_del (&mut self) {
-        let track_index = self.selected.track();
-        let scene_index = self.selected.scene();
-        track_index
-            .and_then(|index|self.model.tracks.get_mut(index).map(|track|(index, track)))
-            .map(|(track_index, _)|scene_index
-                .and_then(|index|self.model.scenes.get_mut(index))
-                .map(|scene|scene.clips[track_index] = None));
-    }
-    pub fn phrase_put (&mut self) {
-        if let ArrangementEditorFocus::Clip(track, scene) = self.selected {
-            self.model.scenes[scene].clips[track] = Some(
-                self.model.phrase().clone()
-            );
-        }
-    }
-    pub fn phrase_get (&mut self) {
-        if let ArrangementEditorFocus::Clip(track, scene) = self.selected {
-            if let Some(phrase) = &self.model.scenes[scene].clips[track] {
-                let mut phrases = self.model.phrases.write().unwrap();
-                if let Some(index) = phrases.index_of(&*phrase.read().unwrap()) {
-                    phrases.phrase = index;
-                }
-            }
-        }
-    }
-    pub fn phrase_next (&mut self) {
-        if let ArrangementEditorFocus::Clip(track, scene) = self.selected {
-            if let Some(ref mut phrase) = self.model.scenes[scene].clips[track] {
-                let phrases = self.model.phrases.read().unwrap();
-                let index = phrases.index_of(&*phrase.read().unwrap());
-                if let Some(index) = index {
-                    if index < phrases.len().saturating_sub(1) {
-                        *phrase = phrases[index + 1].clone();
-                    }
-                }
-            }
-        }
-    }
-    pub fn phrase_prev (&mut self) {
-        if let ArrangementEditorFocus::Clip(track, scene) = self.selected {
-            if let Some(ref mut phrase) = self.model.scenes[scene].clips[track] {
-                let phrases = self.model.phrases.read().unwrap();
-                let index = phrases.index_of(&*phrase.read().unwrap());
-                if let Some(index) = index {
-                    if index > 0 {
-                        *phrase = phrases[index - 1].clone();
-                    }
-                }
-            }
-        }
+    pub fn selected_phrase (&self) -> Option<Arc<RwLock<Phrase>>> {
+        self.selected_scene()?.clips.get(self.selected.track()?)?.clone()
     }
 }