refactor app/jack init

src/model.rs

@@ -15,12 +15,11 @@ pub use self::plugin::{Plugin, PluginKind, lv2::LV2Plugin};
 
 use crate::core::*;
 
-#[derive(Default)]
 pub struct App {
     /// Paths to user directories
     pub xdg:           Option<Arc<XdgApp>>,
     /// Main JACK client.
-    pub jack:          Option<DynamicAsyncClient>,
+    pub jack:          Option<JackClient>,
     /// Main MIDI controller.
     pub midi_in:       Option<Port<MidiIn>>,
     /// Main audio outputs.
@@ -77,15 +76,36 @@ impl App {
     pub fn new () -> Usually<Self> {
         let xdg = Arc::new(microxdg::XdgApp::new("tek")?);
         let first_run = crate::config::AppPaths::new(&xdg)?.should_create();
+        let jack = JackClient::Inactive(Client::new("tek", ClientOptions::NO_START_SERVER)?.0);
+        let transport = jack.transport();
         Ok(Self {
+            arranger_mode: false,
+            audio_outs: vec![],
+            chain_mode: false,
+            chunk_size: 0,
+            entered: true,
+            jack: Some(jack),
+            metronome: false,
+            midi_in: None,
             modal: first_run.then(||crate::config::SetupModal(Some(xdg.clone())).boxed()),
-            xdg:   Some(xdg),
-            track_cursor: 1,
+            note_cursor: 0,
+            note_start: 2,
+            play_started: None,
+            playhead: 0,
+            playing: None,
+            quant: 24,
             scene_cursor: 1,
-            note_start:   2,
-            time_zoom:    12,
-            quant:        24,
-            ..Self::default()
+            scenes: vec![],
+            section: AppSection::default(),
+            seq_mode: false,
+            time_cursor: 0,
+            time_start: 0,
+            time_zoom: 12,
+            timebase: Arc::new(Timebase::default()),
+            track_cursor: 1,
+            tracks: vec![],
+            transport: Some(transport),
+            xdg: Some(xdg),
         })
     }
 }
@@ -111,14 +131,23 @@ process!(App |self, _client, scope| {
     Control::Continue
 });
 impl App {
+    pub fn activate (mut self) -> Usually<Arc<RwLock<Self>>> {
+        let jack = self.jack.take().expect("no jack client");
+        let state = Arc::new(RwLock::new(self));
+        state.write().unwrap().jack = Some(jack.activate(&state, Self::process)?);
+        Ok(state)
+    }
+    pub fn process (state: &Arc<RwLock<Self>>, client: &Client, scope: &ProcessScope) -> Control {
+        state.write().unwrap().process(client, scope)
+    }
     pub fn process_update_time (&mut self, scope: &ProcessScope) -> (bool, usize, usize, usize, f64) {
-        self.chunk_size = scope.n_frames() as usize;
         let CycleTimes {
             current_frames,
             current_usecs,
             next_usecs,
             period_usecs
         } = scope.cycle_times().unwrap();
+        self.chunk_size = scope.n_frames() as usize;
         let transport = self.transport.as_ref().unwrap().query().unwrap();
         self.playhead = transport.pos.frame() as usize;
         let mut reset = false;
@@ -146,15 +175,10 @@ impl App {
         self.audio_outs.get(index).map(|x|x.clone())
     }
     pub fn client (&self) -> &Client {
-        self.jack.as_ref().unwrap().as_client()
-    }
-    pub fn connect_ports <A: ::_jack::PortSpec, B: ::_jack::PortSpec> (
-        &self, a: &Port<A>, b: &Port<B>
-    ) -> Usually<()> {
-        Ok(self.client().connect_ports(a, b)?)
+        self.jack.as_ref().unwrap().client()
     }
     pub fn toggle_play (&mut self) -> Usually<()> {
-        self.playing = match self.playing.expect("after jack init") {
+        self.playing = match self.playing.expect("1st frame has not been processed yet") {
             TransportState::Stopped => {
                 self.transport.as_ref().unwrap().start()?;
                 Some(TransportState::Starting)
@@ -308,6 +332,39 @@ impl App {
             //phrase
         //}
     //}
+    pub fn connect_to_midi_ins (&mut self, ports: &[&str]) -> Usually<&mut Self> {
+        let client = self.client();
+        let midi_in = client.register_port("midi-in", MidiIn)?;
+        ports
+            .iter()
+            .map(|name|client
+                .ports(Some(name), None, PortFlags::empty())
+                .iter()
+                .map(|name|{
+                    if let Some(port) = client.port_by_name(name) {
+                        client.connect_ports(&port, &midi_in)?;
+                    }
+                    Ok(())
+                })
+                .collect::<Usually<()>>())
+            .collect::<Usually<()>>()?;
+        self.midi_in = Some(midi_in);
+        Ok(self)
+    }
+    pub fn connect_to_audio_outs (&mut self, ports: &[&str]) -> Usually<&mut Self> {
+        let client = self.client();
+        self.audio_outs = ports
+            .iter()
+            .map(|name|client
+                .ports(Some(name), None, PortFlags::empty())
+                .get(0)
+                .map(|name|client.port_by_name(name)))
+            .flatten()
+            .filter_map(|x|x)
+            .map(Arc::new)
+            .collect();
+        Ok(self)
+    }
 }
 
 struct Selection<'a> {