finally, handle jack events

jack/src/jack_client.rs

@@ -59,18 +59,17 @@ impl Jack {
                 // This is the misc notifications handler. It's a struct that wraps a [Box]
                 // which performs type erasure on a callback that takes [JackEvent], which is
                 // one of the available misc notifications.
-                Notifications(Box::new(move|_|{/*TODO*/}) as BoxedJackEventHandler),
+                Notifications(Box::new({
+                    let app = app.clone();
+                    move|event|app.write().unwrap().handle(event)
+                }) as BoxedJackEventHandler),
                 // This is the main processing handler. It's a struct that wraps a [Box]
                 // which performs type erasure on a callback that takes [Client] and [ProcessScope]
                 // and passes them down to the `app`'s `process` callback, which in turn
                 // implements audio and MIDI input and output on a realtime basis.
                 ClosureProcessHandler::new(Box::new({
                     let app = app.clone();
-                    move|c: &_, s: &_|if let Ok(mut app) = app.write() {
-                        app.process(c, s)
-                    } else {
-                        Control::Quit
-                    }
+                    move|c: &_, s: &_|app.write().unwrap().process(c, s)
                 }) as BoxedAudioHandler<'j>),
             )?;
             *self.state.write().unwrap() = Active(client);
@@ -122,14 +121,19 @@ pub type DynamicAsyncClient<'j>
     = AsyncClient<DynamicNotifications<'j>, DynamicAudioHandler<'j>>;
 /// Implement [Audio]: provide JACK callbacks.
 #[macro_export] macro_rules! audio {
-    (|$self:ident:$Struct:ident$(<$($L:lifetime),*$($T:ident$(:$U:path)?),*>)?,$c:ident,$s:ident|$cb:expr) => {
+    (|
+        $self1:ident:
+        $Struct:ident$(<$($L:lifetime),*$($T:ident$(:$U:path)?),*>)?,$c:ident,$s:ident
+    |$cb:expr$(;|$self2:ident,$e:ident|$cb2:expr)?) => {
         impl $(<$($L),*$($T $(: $U)?),*>)? Audio for $Struct $(<$($L),*$($T),*>)? {
-            #[inline] fn process (&mut $self, $c: &Client, $s: &ProcessScope) -> Control { $cb }
+            #[inline] fn process (&mut $self1, $c: &Client, $s: &ProcessScope) -> Control { $cb }
+            $(#[inline] fn handle (&mut $self2, $e: JackEvent) { $cb2 })?
         }
     }
 }
 /// Trait for thing that has a JACK process callback.
 pub trait Audio: Send + Sync {
+    fn handle (&mut self, _event: JackEvent) {}
     fn process (&mut self, _: &Client, _: &ProcessScope) -> Control {
         Control::Continue
     }

jack/src/jack_event.rs

@@ -1,7 +1,6 @@
 use crate::*;
-#[derive(Debug, Clone, PartialEq)]
 /// Event enum for JACK events.
-pub enum JackEvent {
+#[derive(Debug, Clone, PartialEq)] pub enum JackEvent {
     ThreadInit,
     Shutdown(ClientStatus, Arc<str>),
     Freewheel(bool),
@@ -19,42 +18,33 @@ impl<T: Fn(JackEvent) + Send> NotificationHandler for Notifications<T> {
     fn thread_init(&self, _: &Client) {
         self.0(JackEvent::ThreadInit);
     }
-
     unsafe fn shutdown(&mut self, status: ClientStatus, reason: &str) {
         self.0(JackEvent::Shutdown(status, reason.into()));
     }
-
     fn freewheel(&mut self, _: &Client, enabled: bool) {
         self.0(JackEvent::Freewheel(enabled));
     }
-
     fn sample_rate(&mut self, _: &Client, frames: Frames) -> Control {
         self.0(JackEvent::SampleRate(frames));
         Control::Quit
     }
-
     fn client_registration(&mut self, _: &Client, name: &str, reg: bool) {
         self.0(JackEvent::ClientRegistration(name.into(), reg));
     }
-
     fn port_registration(&mut self, _: &Client, id: PortId, reg: bool) {
         self.0(JackEvent::PortRegistration(id, reg));
     }
-
     fn port_rename(&mut self, _: &Client, id: PortId, old: &str, new: &str) -> Control {
         self.0(JackEvent::PortRename(id, old.into(), new.into()));
         Control::Continue
     }
-
     fn ports_connected(&mut self, _: &Client, a: PortId, b: PortId, are: bool) {
         self.0(JackEvent::PortsConnected(a, b, are));
     }
-
     fn graph_reorder(&mut self, _: &Client) -> Control {
         self.0(JackEvent::GraphReorder);
         Control::Continue
     }
-
     fn xrun(&mut self, _: &Client) -> Control {
         self.0(JackEvent::XRun);
         Control::Continue

jack/src/jack_port.rs

@@ -97,13 +97,15 @@ pub trait JackPortAutoconnect: JackPort + for<'a>JackPortConnect<&'a Port<Unowne
         for connect in self.conn().iter() {
             let status = match &connect.name {
                 Exact(name) => self.connect_exact(name),
-                RegExp(re)  => self.connect_regexp(re),
+                RegExp(re)  => self.connect_regexp(re, connect.scope),
             }?;
             *connect.status.write().unwrap() = status;
         }
         Ok(())
     }
-    fn connect_exact (&self, name: &str) -> Usually<Vec<(Port<Unowned>, Arc<str>, PortConnectStatus)>> {
+    fn connect_exact (
+        &self, name: &str
+    ) -> Usually<Vec<(Port<Unowned>, Arc<str>, PortConnectStatus)>> {
         self.with_client(|c|{
             let mut status = vec![];
             for port in c.ports(None, None, PortFlags::empty()).iter() {
@@ -121,18 +123,20 @@ pub trait JackPortAutoconnect: JackPort + for<'a>JackPortConnect<&'a Port<Unowne
             Ok(status)
         })
     }
-    fn connect_regexp (&self, re: &str) -> Usually<Vec<(Port<Unowned>, Arc<str>, PortConnectStatus)>> {
+    fn connect_regexp (
+        &self, re: &str, scope: PortConnectScope
+    ) -> Usually<Vec<(Port<Unowned>, Arc<str>, PortConnectStatus)>> {
         self.with_client(|c|{
             let mut status = vec![];
-            for port in c.ports(Some(&re), None, PortFlags::empty()).iter() {
+            let ports = c.ports(Some(&re), None, PortFlags::empty());
+            for port in ports.iter() {
                 if let Some(port) = c.port_by_name(port.as_str()) {
                     let port_status = self.connect_to(&port)?;
                     let name = port.name()?.into();
                     status.push((port, name, port_status));
-                    // TODO
-                    //if port_status == Connected && connect.scope == One {
-                        //break
-                    //}
+                    if port_status == Connected && scope == One {
+                        break
+                    }
                 }
             }
             Ok(status)
@@ -185,12 +189,22 @@ impl PortConnect {
         Self { name, scope: All, status: Arc::new(RwLock::new(vec![])) }
     }
     pub fn info (&self) -> Arc<str> {
-        format!("{} {} {}", match self.scope {
-            One => " ",
-            All => "*",
-        }, match &self.name {
-            Exact(name)  => format!("= {name}"),
-            RegExp(name) => format!("~ {name}"),
-        }, self.status.read().unwrap().len()).into()
+        let status = {
+            let status = self.status.read().unwrap();
+            let mut ok = 0;
+            for (_, _, state) in status.iter() {
+                if *state == Connected {
+                    ok += 1
+                }
+            }
+            format!("{ok}/{}", status.len())
+        };
+        let scope  = match self.scope {
+            One => " ", All => "*",
+        };
+        let name   = match &self.name {
+            Exact(name) => format!("= {name}"), RegExp(name) => format!("~ {name}"),
+        };
+        format!("({}) {} {}", status, scope, name).into()
     }
 }