midi: add pgup/pgdn; cleanup

crates/jack/src/jack_client.rs

@@ -1,6 +1,7 @@
 use crate::*;
 use ::jack::contrib::*;
 use self::JackState::*;
+
 /// Things that can provide a [jack::Client] reference.
 pub trait HasJack {
     /// Return the internal [jack::Client] handle
@@ -38,13 +39,25 @@ pub trait HasJack {
         Ok(())
     }
 }
-impl HasJack for Jack { fn jack (&self) -> &Jack { self } }
-impl HasJack for &Jack { fn jack (&self) -> &Jack { self } }
+
+impl HasJack for Jack {
+    fn jack (&self) -> &Jack {
+        self
+    }
+}
+
+impl HasJack for &Jack {
+    fn jack (&self) -> &Jack {
+        self
+    }
+}
+
 /// Wraps [JackState] and through it [jack::Client].
 #[derive(Clone, Debug, Default)]
 pub struct Jack {
     state: Arc<RwLock<JackState>>
 }
+
 impl Jack {
     pub fn new (name: &str) -> Usually<Self> {
         Ok(Self {
@@ -82,6 +95,7 @@ impl Jack {
         Ok(app)
     }
 }
+
 /// This is a connection which may be [Inactive], [Activating], or [Active].
 /// In the [Active] and [Inactive] states, [JackState::client] returns a
 /// [jack::Client], which you can use to talk to the JACK API.
@@ -95,33 +109,36 @@ impl Jack {
     /// After activation. Must not be dropped for JACK thread to persist.
     Active(DynamicAsyncClient<'static>),
 }
+
 impl JackState {
-    fn new (client: Client) -> Arc<RwLock<Self>> { Arc::new(RwLock::new(Self::Inactive(client))) }
+    fn new (client: Client) -> Arc<RwLock<Self>> {
+        Arc::new(RwLock::new(Self::Inactive(client)))
+    }
 }
-//has_jack_client!(|self: JackState|match self {
-    //Inert                => panic!("jack client not activated"),
-    //Inactive(ref client) => client,
-    //Activating           => panic!("jack client has not finished activation"),
-    //Active(ref client)   => client.as_client(),
-//});
+
 /// This is a boxed realtime callback.
 pub type BoxedAudioHandler<'j> =
     Box<dyn FnMut(&Client, &ProcessScope) -> Control + Send + 'j>;
+
 /// This is the notification handler wrapper for a boxed realtime callback.
 pub type DynamicAudioHandler<'j> =
     ClosureProcessHandler<(), BoxedAudioHandler<'j>>;
+
 /// This is a boxed [JackEvent] callback.
 pub type BoxedJackEventHandler<'j> =
     Box<dyn Fn(JackEvent) + Send + Sync + 'j>;
+
 /// This is the notification handler wrapper for a boxed [JackEvent] callback.
 pub type DynamicNotifications<'j> =
     Notifications<BoxedJackEventHandler<'j>>;
+
 /// This is a running JACK [AsyncClient] with maximum type erasure.
 /// It has one [Box] containing a function that handles [JackEvent]s,
 /// and another [Box] containing a function that handles realtime IO,
 /// and that's all it knows about them.
 pub type DynamicAsyncClient<'j>
     = AsyncClient<DynamicNotifications<'j>, DynamicAudioHandler<'j>>;
+
 /// Implement [Audio]: provide JACK callbacks.
 #[macro_export] macro_rules! audio {
     (|
@@ -134,6 +151,7 @@ pub type DynamicAsyncClient<'j>
         }
     }
 }
+
 /// Trait for thing that has a JACK process callback.
 pub trait Audio: Send + Sync {
     fn handle (&mut self, _event: JackEvent) {}