AudioEngine pt.3: arranger init with jack

crates/tek_core/src/audio.rs

@@ -36,12 +36,12 @@ impl JackClient {
     }
     pub fn activate_with <T: Audio + 'static> (
         self,
-        init: impl FnOnce(&Arc<RwLock<JackClient>>)->T
+        init: impl FnOnce(&Arc<RwLock<JackClient>>)->Usually<T>
     )
         -> Usually<Arc<RwLock<T>>>
     {
         let client = Arc::new(RwLock::new(self));
-        let target = Arc::new(RwLock::new(init(&client)));
+        let target = Arc::new(RwLock::new(init(&client)?));
         let event  = Box::new(move|_|{/*TODO*/}) as Box<dyn Fn(JackEvent) + Send + Sync>;
         let events = Notifications(event);
         let frame  = Box::new({

crates/tek_sequencer/src/arranger_cli.rs

@@ -19,43 +19,37 @@ pub struct ArrangerCli {
 impl ArrangerCli {
     /// Run the arranger TUI from CLI arguments.
     fn run (&self) -> Usually<()> {
-        let jack            = Client::new("tek_arranger", ClientOptions::NO_START_SERVER)?.0;
+        Tui::run(JackClient::new("tek_arranger")?.activate_with(|jack|{
-        let jack            = JackClient::Inactive(jack);
+            let transport       = TransportToolbar::new(jack, None);
-        let transport       = TransportToolbar::new(None, Some(jack.transport()));
+            let phrases         = Arc::new(RwLock::new(PhrasePool::new()));
-        let phrases         = Arc::new(RwLock::new(PhrasePool::new()));
+            let mut arrangement = Arrangement::new(&jack, &transport.clock, "", &phrases);
-        let mut arrangement = Arrangement::new(&jack, &transport.clock, "", &phrases);
+            let transport       = Arc::new(RwLock::new(transport));
-        let transport       = Arc::new(RwLock::new(transport));
+            if let Some(name) = self.name.as_ref() {
-        if let Some(name) = self.name.as_ref() {
+                *arrangement.name.write().unwrap() = name.clone();
-            *arrangement.name.write().unwrap() = name.clone();
+            }
-        }
+            let track_color_1 = ItemColor::random();
-        let track_color_1 = ItemColor::random();
+            let track_color_2 = ItemColor::random();
-        let track_color_2 = ItemColor::random();
+            for i in 0..self.tracks {
-        for i in 0..self.tracks {
+                let _track = arrangement.track_add(
-            let _track = arrangement.track_add(
+                    None,
-                None,
+                    Some(track_color_1.mix(track_color_2, i as f32 / self.tracks as f32))
-                Some(track_color_1.mix(track_color_2, i as f32 / self.tracks as f32))
+                )?;
-            )?;
+            }
-        }
+            let scene_color_1 = ItemColor::random();
-        let scene_color_1 = ItemColor::random();
+            let scene_color_2 = ItemColor::random();
-        let scene_color_2 = ItemColor::random();
+            for i in 0..self.scenes {
-        for i in 0..self.scenes {
+                let _scene = arrangement.scene_add(
-            let _scene = arrangement.scene_add(
+                    None,
-                None,
+                    Some(scene_color_1.mix(scene_color_2, i as f32 / self.scenes as f32))
-                Some(scene_color_1.mix(scene_color_2, i as f32 / self.scenes as f32))
+                )?;
-            )?;
+            }
-        }
+            Ok(Arranger::new(
-        let arranger = Arc::new(RwLock::new(Arranger::new(
+                jack,
-            self.transport.then_some(transport),
+                self.transport.then_some(transport),
-            arrangement,
+                arrangement,
-            phrases,
+                phrases,
-        )));
+            ))
-        let jack = jack.activate(&arranger.clone(), Arranger::callback)?;
+        })?)?;
-        let jack = Some(jack.into());
-        if let Some(ref transport) = arranger.read().unwrap().transport {
-            transport.write().unwrap().jack = jack.clone();
-        }
-        arranger.write().unwrap().jack = jack.clone();
-        Tui::run(arranger)?;
         Ok(())
     }
 }

crates/tek_sequencer/src/sequencer_cli.rs

@@ -18,16 +18,15 @@ pub struct SequencerCli {
 
 impl SequencerCli {
     fn run (&self) -> Usually<()> {
-        let name = self.name.map(|name|name.as_str()).unwrap_or("tek_arranger");
+        Tui::run(JackClient::new("tek_sequencer")?.activate_with(|jack|{
-        Tui::run(JackClient::new(name)?.activate_with(|jack|{
+            let transport = TransportToolbar::new(jack, None);
-            let mut transport = TransportToolbar::new(jack, None);
             let sequencer = Sequencer {
                 jack:         jack.clone(),
                 focus_cursor: (1, 1),
                 phrases:      Arc::new(RwLock::new(PhrasePool::new())),
                 editor:       PhraseEditor::new(),
                 clock:        transport.clock.clone(),
-                player:       Some(PhrasePlayer::new(jack, &transport.clock)),
+                player:       PhrasePlayer::new(jack, &transport.clock),
                 transport:    self.transport.then_some(Arc::new(RwLock::new(transport))),
             };
             if let Some(_) = self.name.as_ref() {
@@ -41,8 +40,8 @@ impl SequencerCli {
                     //phrase.write().unwrap().length = length;
                 //}
             }
-            sequencer
+            Ok(sequencer)
-        }))?;
+        })?)?;
         Ok(())
     }
 }

crates/tek_sequencer/src/transport_cli.rs

@@ -4,7 +4,7 @@ pub fn main () -> Usually<()> {
     Tui::run(JackClient::new("tek_transport")?.activate_with(|jack|{
         let mut transport = TransportToolbar::new(jack, None);
         transport.focused = true;
-        transport
+        Ok(transport)
-    }))?;
+    })?)?;
     Ok(())
 }