refactor: jack proto-lib

src/core.rs

@@ -1,30 +1,27 @@
-pub use std::error::Error;
+/// Define and reexport submodules.
-pub use std::io::{stdout, Stdout, Write};
+#[macro_export] macro_rules! submod {
-pub use std::thread::{spawn, JoinHandle};
+    ($($name:ident)*) => { $(mod $name; pub use self::$name::*;)* };
-pub use std::time::Duration;
+}
-pub use std::collections::BTreeMap;
-pub use std::sync::{Arc, Mutex, MutexGuard};
-pub use std::sync::atomic::{Ordering, AtomicBool, AtomicUsize};
-pub use std::sync::mpsc::{channel, Sender, Receiver};
 
-pub use microxdg::XdgApp;
+submod!( handle keymap midi render run time );
-pub use ratatui::prelude::*;
-pub use midly::{MidiMessage, live::LiveEvent, num::u7};
-pub use crossterm::{ExecutableCommand, QueueableCommand};
-pub use crossterm::event::{Event, KeyEvent, KeyCode, KeyModifiers};
-
-macro_rules! submod { ($($name:ident)*) => { $(mod $name; pub use self::$name::*;)* }; }
-
-submod!( handle jack keymap midi port render run time );
 
+/// Standard result type.
 pub type Usually<T> = Result<T, Box<dyn Error>>;
 
-pub trait Component: Render + Handle {}
+/// A UI component.
+pub trait Component: Render + Handle {
+    /// Perform type erasure for collecting heterogeneous components.
+    fn boxed (self) -> Box<dyn Component> where Self: Sized + 'static {
+        Box::new(self)
+    }
+}
 
+/// Anything that implements `Render` + `Handle` can be used as a UI component.
 impl<T: Render + Handle> Component for T {}
 
-/// A UI component that may have presence on the JACK grap.
+/// A UI component that may be associated with a JACK client by the `Jack` factory.
 pub trait Device: Render + Handle + Process + Send + Sync {
+    /// Perform type erasure for collecting heterogeneous devices.
     fn boxed (self) -> Box<dyn Device> where Self: Sized + 'static {
         Box::new(self)
     }
@@ -34,12 +31,24 @@ pub trait Device: Render + Handle + Process + Send + Sync {
 impl<T: Render + Handle + Process + Send + Sync> Device for T {}
 
 // Reexport macros:
-pub use crate::{
+pub use crate::{submod, render, handle, process, phrase, keymap, key, ports};
-    render,
+
-    handle,
+// Reexport JACK proto-lib:
-    process,
+pub use crate::jack::*;
-    phrase,
+
-    keymap, 
+// Various stdlib dependencies:
-    key,
+pub use std::error::Error;
-    ports
+pub use std::io::{stdout, Stdout, Write};
-};
+pub use std::thread::{spawn, JoinHandle};
+pub use std::time::Duration;
+pub use std::collections::BTreeMap;
+pub use std::sync::{Arc, Mutex, MutexGuard};
+pub use std::sync::atomic::{Ordering, AtomicBool, AtomicUsize};
+pub use std::sync::mpsc::{channel, Sender, Receiver};
+
+// Various non-stdlib dependencies:
+pub use microxdg::XdgApp;
+pub use ratatui::prelude::*;
+pub use midly::{MidiMessage, live::LiveEvent, num::u7};
+pub use crossterm::{ExecutableCommand, QueueableCommand};
+pub use crossterm::event::{Event, KeyEvent, KeyCode, KeyModifiers};

src/core/jack.rs

@@ -1,271 +0,0 @@
-use crate::core::*;
-
-pub struct Jack {
-    pub client: Client,
-    pub ports:  JackPorts,
-}
-
-pub struct JackDevice {
-    pub client: DynamicAsyncClient,
-    pub state:  Arc<Mutex<Box<dyn Device>>>,
-    pub ports:  UnownedJackPorts,
-}
-
-pub enum JackClient {
-    Active(DynamicAsyncClient),
-    Inactive(Client),
-}
-
-ports!(JackDevice {
-    audio: {
-        ins:  |s|Ok(s.ports.audio_ins.values().collect()),
-        outs: |s|Ok(s.ports.audio_outs.values().collect()),
-    }
-    midi: {
-        ins:  |s|Ok(s.ports.midi_ins.values().collect()),
-        outs: |s|Ok(s.ports.midi_outs.values().collect()),
-    }
-});
-
-impl Jack {
-    pub fn new (name: &str) -> Usually<Self> {
-        let (client, _) = Client::new(name, ClientOptions::NO_START_SERVER)?;
-        Ok(Self { client, ports: JackPorts::default() })
-    }
-    pub fn run <T: Device + Process + Sized + 'static> (
-        mut self, state: impl FnOnce(JackPorts)->Box<T>
-    )
-        -> Usually<JackDevice>
-    {
-        let mut owned_ports = JackPorts::default();
-        std::mem::swap(&mut self.ports, &mut owned_ports);
-        let unowned_ports = owned_ports.clone_unowned(&self.client);
-        let state = Arc::new(Mutex::new(state(owned_ports) as Box<dyn Device>));
-        let client = self.client.activate_async(
-            Notifications(Box::new({
-                let _state = state.clone();
-                move|_event|{
-                    // FIXME: this deadlocks
-                    //state.lock().unwrap().handle(&event).unwrap();
-                }
-            }) as Box<dyn Fn(AppEvent) + Send + Sync>),
-            ClosureProcessHandler::new(Box::new({
-                let state = state.clone();
-                move|c: &Client, s: &ProcessScope|{
-                    state.lock().unwrap().process(c, s)
-                }
-            }) as BoxedProcessHandler)
-        )?;
-        Ok(JackDevice { client, state, ports: unowned_ports })
-    }
-    pub fn ports_from_lv2 (self, plugin: &::livi::Plugin) -> Usually<Self> {
-        let counts = plugin.port_counts();
-        let mut jack = self;
-        for i in 0..counts.atom_sequence_inputs {
-            jack = jack.register_midi_in(&format!("midi-in-{i}"))?
-        }
-        for i in 0..counts.atom_sequence_outputs {
-            jack = jack.register_midi_out(&format!("midi-out-{i}"))?;
-        }
-        for i in 0..counts.audio_inputs {
-            jack = jack.register_audio_in(&format!("audio-in-{i}"))?
-        }
-        for i in 0..counts.audio_outputs {
-            jack = jack.register_audio_out(&format!("audio-out-{i}"))?;
-        }
-        Ok(jack)
-    }
-    pub fn register_midi_out (mut self, name: &str) -> Usually<Self> {
-        let port = self.client.register_port(name, MidiOut::default())?;
-        self.ports.midi_outs.insert(name.to_string(), port);
-        Ok(self)
-    }
-    pub fn register_midi_in (mut self, name: &str) -> Usually<Self> {
-        let port = self.client.register_port(name, MidiIn::default())?;
-        self.ports.midi_ins.insert(name.to_string(), port);
-        Ok(self)
-    }
-    pub fn register_audio_out (mut self, name: &str) -> Usually<Self> {
-        let port = self.client.register_port(name, AudioOut::default())?;
-        self.ports.audio_outs.insert(name.to_string(), port);
-        Ok(self)
-    }
-    pub fn register_audio_in (mut self, name: &str) -> Usually<Self> {
-        let port = self.client.register_port(name, AudioIn::default())?;
-        self.ports.audio_ins.insert(name.to_string(), port);
-        Ok(self)
-    }
-}
-
-pub fn jack_run <T> (name: &str, app: &Arc<Mutex<T>>) -> Usually<DynamicAsyncClient>
-    where T: Handle + Process + Send + 'static
-{
-    let options = ClientOptions::NO_START_SERVER;
-    let (client, _status) = Client::new(name, options)?;
-    Ok(client.activate_async(
-        Notifications(Box::new({
-            let _app = app.clone();
-            move|_event|{
-                // FIXME: this deadlocks
-                //app.lock().unwrap().handle(&event).unwrap();
-            }
-        }) as Box<dyn Fn(AppEvent) + Send + Sync>),
-        ClosureProcessHandler::new(Box::new({
-            let app = app.clone();
-            move|c: &Client, s: &ProcessScope|{
-                app.lock().unwrap().process(c, s)
-                //Control::Continue
-            }
-        }) as BoxedProcessHandler)
-    )?)
-}
-
-pub trait Process {
-    fn process (&mut self, _: &Client, _: &ProcessScope) -> Control {
-        Control::Continue
-    }
-}
-
-#[macro_export] macro_rules! process {
-    ($T:ty) => {
-        impl Process for $T {}
-    };
-    ($T:ty |$self:ident, $c:ident, $s:ident|$block:tt) => {
-        impl Process for $T {
-            fn process (&mut $self, $c: &Client, $s: &ProcessScope) -> Control {
-                $block
-            }
-        }
-    };
-    ($T:ty = $process:path) => {
-        impl Process for $T {
-            fn process (&mut self, c: &Client, s: &ProcessScope) -> Control {
-                $process(self, c, s)
-            }
-        }
-    }
-}
-
-pub type DynamicAsyncClient =
-    AsyncClient<DynamicNotifications, DynamicProcessHandler>;
-
-pub type DynamicNotifications =
-    Notifications<Box<dyn Fn(AppEvent) + Send + Sync>>;
-
-pub type DynamicProcessHandler =
-    ClosureProcessHandler<BoxedProcessHandler>;
-
-pub type BoxedProcessHandler =
-    Box<dyn FnMut(&Client, &ProcessScope)-> Control + Send>;
-
-pub use ::jack::{
-    AsyncClient,
-    AudioIn,
-    AudioOut,
-    Client,
-    ClientOptions,
-    ClientStatus,
-    ClosureProcessHandler,
-    Control,
-    Frames,
-    MidiIn,
-    MidiOut,
-    NotificationHandler,
-    Port,
-    PortFlags,
-    PortId,
-    PortSpec,
-    ProcessHandler,
-    ProcessScope,
-    RawMidi,
-    Transport,
-    TransportState,
-    TransportStatePosition,
-    Unowned
-};
-
-#[derive(Debug)]
-pub enum JackEvent {
-    ThreadInit,
-    Shutdown(ClientStatus, String),
-    Freewheel(bool),
-    SampleRate(Frames),
-    ClientRegistration(String, bool),
-    PortRegistration(PortId, bool),
-    PortRename(PortId, String, String),
-    PortsConnected(PortId, PortId, bool),
-    GraphReorder,
-    XRun,
-}
-
-pub struct Notifications<T: Fn(AppEvent) + Send>(pub T);
-
-impl<T: Fn(AppEvent) + Send> NotificationHandler for Notifications<T> {
-    fn thread_init (&self, _: &Client) {
-        self.0(AppEvent::Jack(JackEvent::ThreadInit));
-    }
-
-    fn shutdown (&mut self, status: ClientStatus, reason: &str) {
-        self.0(AppEvent::Jack(JackEvent::Shutdown(status, reason.into())));
-    }
-
-    fn freewheel (&mut self, _: &Client, enabled: bool) {
-        self.0(AppEvent::Jack(JackEvent::Freewheel(enabled)));
-    }
-
-    fn sample_rate (&mut self, _: &Client, frames: Frames) -> Control {
-        self.0(AppEvent::Jack(JackEvent::SampleRate(frames)));
-        Control::Quit
-    }
-
-    fn client_registration (&mut self, _: &Client, name: &str, reg: bool) {
-        self.0(AppEvent::Jack(JackEvent::ClientRegistration(name.into(), reg)));
-    }
-
-    fn port_registration (&mut self, _: &Client, id: PortId, reg: bool) {
-        self.0(AppEvent::Jack(JackEvent::PortRegistration(id, reg)));
-    }
-
-    fn port_rename (&mut self, _: &Client, id: PortId, old: &str, new: &str) -> Control {
-        self.0(AppEvent::Jack(JackEvent::PortRename(id, old.into(), new.into())));
-        Control::Continue
-    }
-
-    fn ports_connected (&mut self, _: &Client, a: PortId, b: PortId, are: bool) {
-        self.0(AppEvent::Jack(JackEvent::PortsConnected(a, b, are)));
-    }
-
-    fn graph_reorder (&mut self, _: &Client) -> Control {
-        self.0(AppEvent::Jack(JackEvent::GraphReorder));
-        Control::Continue
-    }
-
-    fn xrun (&mut self, _: &Client) -> Control {
-        self.0(AppEvent::Jack(JackEvent::XRun));
-        Control::Continue
-    }
-}
-
-/// Add "all notes off" to the start of a buffer.
-pub fn all_notes_off (output: &mut MIDIChunk) {
-    output[0] = Some(vec![]);
-    if let Some(Some(frame)) = output.get_mut(0) {
-        let mut buf = vec![];
-        let msg = MidiMessage::Controller { controller: 123.into(), value: 0.into() };
-        let evt = LiveEvent::Midi { channel: 0.into(), message: msg };
-        evt.write(&mut buf).unwrap();
-        frame.push(buf);
-    }
-}
-
-/// Write to JACK port from output buffer (containing notes from sequence and/or monitor)
-pub fn write_output (writer: &mut ::jack::MidiWriter, output: &mut MIDIChunk, frames: usize) {
-    for time in 0..frames {
-        if let Some(Some(frame)) = output.get_mut(time ) {
-            for event in frame.iter() {
-                writer.write(&::jack::RawMidi { time: time as u32, bytes: &event })
-                    .expect(&format!("{event:?}"));
-            }
-        }
-    }
-}

src/core/midi.rs

@@ -9,28 +9,26 @@ pub type MIDIMessage =
 pub type MIDIChunk =
     [Option<Vec<MIDIMessage>>];
 
-pub const KEY_WHITE: Style = Style {
+/// Add "all notes off" to the start of a buffer.
-    fg: Some(Color::Gray),
+pub fn all_notes_off (output: &mut MIDIChunk) {
-    bg: None,
+    output[0] = Some(vec![]);
-    underline_color: None,
+    if let Some(Some(frame)) = output.get_mut(0) {
-    add_modifier: ::ratatui::style::Modifier::empty(),
+        let mut buf = vec![];
-    sub_modifier: ::ratatui::style::Modifier::empty(),
+        let msg = MidiMessage::Controller { controller: 123.into(), value: 0.into() };
-};
+        let evt = LiveEvent::Midi { channel: 0.into(), message: msg };
-
+        evt.write(&mut buf).unwrap();
-pub const KEY_BLACK: Style = Style {
+        frame.push(buf);
-    fg: Some(Color::Black),
+    }
-    bg: None,
+}
-    underline_color: None,
-    add_modifier: ::ratatui::style::Modifier::empty(),
-    sub_modifier: ::ratatui::style::Modifier::empty(),
-};
-
-pub const KEY_STYLE: [Style;12] = [
-    KEY_WHITE, KEY_BLACK, KEY_WHITE, KEY_BLACK, KEY_WHITE,
-    KEY_WHITE, KEY_BLACK, KEY_WHITE, KEY_BLACK, KEY_WHITE, KEY_BLACK, KEY_WHITE,
-];
-
-pub const KEYS_VERTICAL: [&'static str; 6] = [
-    "▄", "▄", "█", "▀", "▀", "▀",
-];
 
+/// Write to JACK port from output buffer (containing notes from sequence and/or monitor)
+pub fn write_output (writer: &mut ::jack::MidiWriter, output: &mut MIDIChunk, frames: usize) {
+    for time in 0..frames {
+        if let Some(Some(frame)) = output.get_mut(time ) {
+            for event in frame.iter() {
+                writer.write(&::jack::RawMidi { time: time as u32, bytes: &event })
+                    .expect(&format!("{event:?}"));
+            }
+        }
+    }
+}

src/jack.rs

@@ -0,0 +1,65 @@
+use crate::core::*;
+
+submod!( device event factory ports process );
+
+pub type DynamicAsyncClient =
+    AsyncClient<DynamicNotifications, DynamicProcessHandler>;
+
+pub type DynamicNotifications =
+    Notifications<Box<dyn Fn(AppEvent) + Send + Sync>>;
+
+pub type DynamicProcessHandler =
+    ClosureProcessHandler<BoxedProcessHandler>;
+
+pub type BoxedProcessHandler =
+    Box<dyn FnMut(&Client, &ProcessScope)-> Control + Send>;
+
+pub use ::_jack::{
+    AsyncClient,
+    AudioIn,
+    AudioOut,
+    Client,
+    ClientOptions,
+    ClientStatus,
+    ClosureProcessHandler,
+    Control,
+    Frames,
+    MidiIn,
+    MidiOut,
+    NotificationHandler,
+    Port,
+    PortFlags,
+    PortId,
+    PortSpec,
+    ProcessHandler,
+    ProcessScope,
+    RawMidi,
+    Transport,
+    TransportState,
+    TransportStatePosition,
+    Unowned
+};
+
+/// Just run thing with JACK. Returns the activated client.
+pub fn jack_run <T> (name: &str, app: &Arc<Mutex<T>>) -> Usually<DynamicAsyncClient>
+    where T: Handle + Process + Send + 'static
+{
+    let options = ClientOptions::NO_START_SERVER;
+    let (client, _status) = Client::new(name, options)?;
+    Ok(client.activate_async(
+        Notifications(Box::new({
+            let _app = app.clone();
+            move|_event|{
+                // FIXME: this deadlocks
+                //app.lock().unwrap().handle(&event).unwrap();
+            }
+        }) as Box<dyn Fn(AppEvent) + Send + Sync>),
+        ClosureProcessHandler::new(Box::new({
+            let app = app.clone();
+            move|c: &Client, s: &ProcessScope|{
+                app.lock().unwrap().process(c, s)
+                //Control::Continue
+            }
+        }) as BoxedProcessHandler)
+    )?)
+}

src/jack/device.rs

@@ -0,0 +1,29 @@
+use super::*;
+
+/// A Device bound to a JACK client and a set of ports.
+pub struct JackDevice {
+    /// The active JACK client of this device.
+    pub client: DynamicAsyncClient,
+    /// The device state, encapsulated for sharing between threads.
+    pub state:  Arc<Mutex<Box<dyn Device>>>,
+    /// Unowned copies of the device's JACK ports, for connecting to the device.
+    /// The "real" readable/writable `Port`s are owned by the `state`.
+    pub ports:  UnownedJackPorts,
+}
+ports!(JackDevice {
+    audio: {
+        ins:  |s|Ok(s.ports.audio_ins.values().collect()),
+        outs: |s|Ok(s.ports.audio_outs.values().collect()),
+    }
+    midi: {
+        ins:  |s|Ok(s.ports.midi_ins.values().collect()),
+        outs: |s|Ok(s.ports.midi_outs.values().collect()),
+    }
+});
+impl JackDevice {
+    /// Returns a locked mutex of the state's contents.
+    pub fn state (&self) -> MutexGuard<Box<dyn Device>> {
+        self.state.lock().unwrap()
+    }
+}
+

src/jack/event.rs

@@ -0,0 +1,64 @@
+use super::*;
+
+#[derive(Debug)]
+pub enum JackEvent {
+    ThreadInit,
+    Shutdown(ClientStatus, String),
+    Freewheel(bool),
+    SampleRate(Frames),
+    ClientRegistration(String, bool),
+    PortRegistration(PortId, bool),
+    PortRename(PortId, String, String),
+    PortsConnected(PortId, PortId, bool),
+    GraphReorder,
+    XRun,
+}
+
+pub struct Notifications<T: Fn(AppEvent) + Send>(pub T);
+
+impl<T: Fn(AppEvent) + Send> NotificationHandler for Notifications<T> {
+    fn thread_init (&self, _: &Client) {
+        self.0(AppEvent::Jack(JackEvent::ThreadInit));
+    }
+
+    fn shutdown (&mut self, status: ClientStatus, reason: &str) {
+        self.0(AppEvent::Jack(JackEvent::Shutdown(status, reason.into())));
+    }
+
+    fn freewheel (&mut self, _: &Client, enabled: bool) {
+        self.0(AppEvent::Jack(JackEvent::Freewheel(enabled)));
+    }
+
+    fn sample_rate (&mut self, _: &Client, frames: Frames) -> Control {
+        self.0(AppEvent::Jack(JackEvent::SampleRate(frames)));
+        Control::Quit
+    }
+
+    fn client_registration (&mut self, _: &Client, name: &str, reg: bool) {
+        self.0(AppEvent::Jack(JackEvent::ClientRegistration(name.into(), reg)));
+    }
+
+    fn port_registration (&mut self, _: &Client, id: PortId, reg: bool) {
+        self.0(AppEvent::Jack(JackEvent::PortRegistration(id, reg)));
+    }
+
+    fn port_rename (&mut self, _: &Client, id: PortId, old: &str, new: &str) -> Control {
+        self.0(AppEvent::Jack(JackEvent::PortRename(id, old.into(), new.into())));
+        Control::Continue
+    }
+
+    fn ports_connected (&mut self, _: &Client, a: PortId, b: PortId, are: bool) {
+        self.0(AppEvent::Jack(JackEvent::PortsConnected(a, b, are)));
+    }
+
+    fn graph_reorder (&mut self, _: &Client) -> Control {
+        self.0(AppEvent::Jack(JackEvent::GraphReorder));
+        Control::Continue
+    }
+
+    fn xrun (&mut self, _: &Client) -> Control {
+        self.0(AppEvent::Jack(JackEvent::XRun));
+        Control::Continue
+    }
+}
+

src/jack/factory.rs

@@ -0,0 +1,78 @@
+use super::*;
+
+/// `JackDevice` factory. Creates JACK `Client`s, performs port registration
+/// and activation, and encapsulates a `Device` into a `JackDevice`.
+pub struct Jack {
+    pub client: Client,
+    pub ports:  JackPorts,
+}
+impl Jack {
+    pub fn new (name: &str) -> Usually<Self> {
+        let (client, _) = Client::new(name, ClientOptions::NO_START_SERVER)?;
+        Ok(Self { client, ports: JackPorts::default() })
+    }
+    pub fn run <T: Device + Process + Sized + 'static> (
+        mut self, state: impl FnOnce(JackPorts)->Box<T>
+    )
+        -> Usually<JackDevice>
+    {
+        let mut owned_ports = JackPorts::default();
+        std::mem::swap(&mut self.ports, &mut owned_ports);
+        let unowned_ports = owned_ports.clone_unowned(&self.client);
+        let state = Arc::new(Mutex::new(state(owned_ports) as Box<dyn Device>));
+        let client = self.client.activate_async(
+            Notifications(Box::new({
+                let _state = state.clone();
+                move|_event|{
+                    // FIXME: this deadlocks
+                    //state.lock().unwrap().handle(&event).unwrap();
+                }
+            }) as Box<dyn Fn(AppEvent) + Send + Sync>),
+            ClosureProcessHandler::new(Box::new({
+                let state = state.clone();
+                move|c: &Client, s: &ProcessScope|{
+                    state.lock().unwrap().process(c, s)
+                }
+            }) as BoxedProcessHandler)
+        )?;
+        Ok(JackDevice { client, state, ports: unowned_ports })
+    }
+    pub fn ports_from_lv2 (self, plugin: &::livi::Plugin) -> Usually<Self> {
+        let counts = plugin.port_counts();
+        let mut jack = self;
+        for i in 0..counts.atom_sequence_inputs {
+            jack = jack.register_midi_in(&format!("midi-in-{i}"))?
+        }
+        for i in 0..counts.atom_sequence_outputs {
+            jack = jack.register_midi_out(&format!("midi-out-{i}"))?;
+        }
+        for i in 0..counts.audio_inputs {
+            jack = jack.register_audio_in(&format!("audio-in-{i}"))?
+        }
+        for i in 0..counts.audio_outputs {
+            jack = jack.register_audio_out(&format!("audio-out-{i}"))?;
+        }
+        Ok(jack)
+    }
+    pub fn register_midi_out (mut self, name: &str) -> Usually<Self> {
+        let port = self.client.register_port(name, MidiOut::default())?;
+        self.ports.midi_outs.insert(name.to_string(), port);
+        Ok(self)
+    }
+    pub fn register_midi_in (mut self, name: &str) -> Usually<Self> {
+        let port = self.client.register_port(name, MidiIn::default())?;
+        self.ports.midi_ins.insert(name.to_string(), port);
+        Ok(self)
+    }
+    pub fn register_audio_out (mut self, name: &str) -> Usually<Self> {
+        let port = self.client.register_port(name, AudioOut::default())?;
+        self.ports.audio_outs.insert(name.to_string(), port);
+        Ok(self)
+    }
+    pub fn register_audio_in (mut self, name: &str) -> Usually<Self> {
+        let port = self.client.register_port(name, AudioIn::default())?;
+        self.ports.audio_ins.insert(name.to_string(), port);
+        Ok(self)
+    }
+}
+

src/jack/ports.rs

@@ -1,4 +1,4 @@
-use crate::core::*;
+use super::*;
 
 #[derive(Default)]
 pub struct JackPorts {
@@ -95,25 +95,4 @@ pub trait Ports {
             )?
         )?}
     };
-
-}
-
-pub struct DevicePort<T: PortSpec> {
-    pub name:    String,
-    pub port:    Port<T>,
-    pub connect: Vec<String>,
-}
-
-impl<T: PortSpec + Default> DevicePort<T> {
-    pub fn new (client: &Client, name: &str, connect: &[&str]) -> Usually<Self> {
-        let mut connects = vec![];
-        for port in connect.iter() {
-            connects.push(port.to_string());
-        }
-        Ok(Self {
-            name: name.to_string(),
-            port: client.register_port(name, T::default())?,
-            connect: connects,
-        })
-    }
 }

src/jack/process.rs

@@ -0,0 +1,30 @@
+use super::*;
+
+/// Trait for things that have a JACK process callback.
+pub trait Process {
+    fn process (&mut self, _: &Client, _: &ProcessScope) -> Control {
+        Control::Continue
+    }
+}
+
+/// Define the JACK process callback associated with a struct.
+#[macro_export] macro_rules! process {
+    ($T:ty) => {
+        impl Process for $T {}
+    };
+    ($T:ty |$self:ident, $c:ident, $s:ident|$block:tt) => {
+        impl Process for $T {
+            fn process (&mut $self, $c: &Client, $s: &ProcessScope) -> Control {
+                $block
+            }
+        }
+    };
+    ($T:ty = $process:path) => {
+        impl Process for $T {
+            fn process (&mut self, c: &Client, s: &ProcessScope) -> Control {
+                $process(self, c, s)
+            }
+        }
+    }
+}
+

src/main.rs

@@ -3,7 +3,7 @@
 #![allow(macro_expanded_macro_exports_accessed_by_absolute_paths)]
 
 extern crate clap;
-extern crate jack;
+extern crate jack as _jack;
 extern crate crossterm;
 
 pub mod cli;
@@ -12,6 +12,7 @@ pub mod control;
 pub mod core;
 pub mod model;
 pub mod view;
+pub mod jack;
 
 use crate::{core::*, model::*};
 
@@ -35,48 +36,6 @@ pub fn main () -> Usually<()> {
         let client   = jack.as_client();
         let timebase = &state.timebase;
         let ppq      = timebase.ppq() as usize;
-        state.tracks = vec![
-
-            Track::new("Drums", &jack.as_client(), Some(vec![
-                Phrase::new("4 kicks", ppq * 4, Some(phrase! {
-                    00 * ppq/4 => MidiMessage::NoteOn { key: 36.into(), vel: 100.into() },
-                    04 * ppq/4 => MidiMessage::NoteOn { key: 36.into(), vel: 100.into() },
-                    08 * ppq/4 => MidiMessage::NoteOn { key: 36.into(), vel: 100.into() },
-                    12 * ppq/4 => MidiMessage::NoteOn { key: 36.into(), vel: 100.into() },
-                })),
-            ]), Some(vec![
-                Sampler::new("Sampler", Some(BTreeMap::from([
-                    sample!(36, "Kick",  "/home/user/Lab/Music/pak/kik.wav"),
-                    sample!(40, "Snare", "/home/user/Lab/Music/pak/sna.wav"),
-                    sample!(44, "Hihat", "/home/user/Lab/Music/pak/chh.wav"),
-                ])))?,
-                Plugin::lv2(
-                    "Panagement",
-                    "file:///home/user/.lv2/Auburn Sounds Panagement 2.lv2"
-                )?,
-            ]),)?,
-
-            Track::new("Bass", &jack.as_client(), Some(vec![
-                Phrase::new("Offbeat", ppq * 4, Some(phrase! {
-                    00 * ppq/4 => MidiMessage::NoteOff { key: 40.into(), vel: 100.into() },
-                    02 * ppq/4 => MidiMessage::NoteOn  { key: 40.into(), vel: 100.into() },
-                    04 * ppq/4 => MidiMessage::NoteOff { key: 40.into(), vel: 100.into() },
-                    06 * ppq/4 => MidiMessage::NoteOn  { key: 40.into(), vel: 100.into() },
-                    08 * ppq/4 => MidiMessage::NoteOff { key: 40.into(), vel: 100.into() },
-                    10 * ppq/4 => MidiMessage::NoteOn  { key: 40.into(), vel: 100.into() },
-                    12 * ppq/4 => MidiMessage::NoteOff { key: 40.into(), vel: 100.into() },
-                    14 * ppq/4 => MidiMessage::NoteOn  { key: 40.into(), vel: 100.into() },
-                })),
-            ]), Some(vec![
-                Plugin::lv2("Odin2", "file:///home/user/.lv2/Odin2.lv2")?,
-            ]))?,
-
-        ];
-        //for track in state.tracks.iter() {
-            //if let Some(port) = track.midi_ins()?.get(0) {
-                //client.connect_ports(&track.midi_out, port)?;
-            //}
-        //}
         state.tracks[0].sequence = Some(0);
         state.tracks[1].sequence = Some(0);
         state.track_cursor = 1;
@@ -87,6 +46,51 @@ pub fn main () -> Usually<()> {
         state.transport = Some(client.transport());
         state.playing   = Some(TransportState::Stopped);
         state.jack      = Some(jack);
+
+        let drums = state.add_track(Some("Drums"))?;
+        drums.add_device(Sampler::new("Sampler", Some(BTreeMap::from([
+            sample!(36, "Kick",  "/home/user/Lab/Music/pak/kik.wav"),
+            sample!(40, "Snare", "/home/user/Lab/Music/pak/sna.wav"),
+            sample!(44, "Hihat", "/home/user/Lab/Music/pak/chh.wav"),
+        ])))?);
+        drums.add_device(Plugin::lv2(
+            "Panagement",
+            "file:///home/user/.lv2/Auburn Sounds Panagement 2.lv2"
+        )?);
+
+        drums.add_phrase("4 kicks", ppq * 4, Some(phrase! {
+            00 * ppq/4 => MidiMessage::NoteOn { key: 36.into(), vel: 100.into() },
+            04 * ppq/4 => MidiMessage::NoteOn { key: 36.into(), vel: 100.into() },
+            08 * ppq/4 => MidiMessage::NoteOn { key: 36.into(), vel: 100.into() },
+            12 * ppq/4 => MidiMessage::NoteOn { key: 36.into(), vel: 100.into() },
+        }));
+        drums.add_phrase("D-Beat", ppq * 4, Some(phrase! {
+            00 * ppq/4 => MidiMessage::NoteOn { key: 36.into(), vel: 100.into() },
+            04 * ppq/4 => MidiMessage::NoteOn { key: 40.into(), vel: 100.into() },
+            08 * ppq/4 => MidiMessage::NoteOn { key: 36.into(), vel: 100.into() },
+            10 * ppq/4 => MidiMessage::NoteOn { key: 36.into(), vel: 100.into() },
+            12 * ppq/4 => MidiMessage::NoteOn { key: 40.into(), vel: 100.into() },
+        }));
+        drums.add_phrase("Garage", ppq * 4, Some(phrase! {
+            00 * ppq/4 => MidiMessage::NoteOn { key: 36.into(), vel: 100.into() },
+            04 * ppq/4 => MidiMessage::NoteOn { key: 40.into(), vel: 100.into() },
+            11 * ppq/4 => MidiMessage::NoteOn { key: 36.into(), vel: 100.into() },
+            12 * ppq/4 => MidiMessage::NoteOn { key: 40.into(), vel: 100.into() },
+        }));
+
+        let bass = state.add_track(Some("Bass"))?;
+        bass.add_device(Plugin::lv2("Odin2", "file:///home/user/.lv2/Odin2.lv2")?);
+        bass.add_phrase("Offbeat", ppq * 4, Some(phrase! {
+            00 * ppq/4 => MidiMessage::NoteOff { key: 40.into(), vel: 100.into() },
+            02 * ppq/4 => MidiMessage::NoteOn  { key: 40.into(), vel: 100.into() },
+            04 * ppq/4 => MidiMessage::NoteOff { key: 40.into(), vel: 100.into() },
+            06 * ppq/4 => MidiMessage::NoteOn  { key: 40.into(), vel: 100.into() },
+            08 * ppq/4 => MidiMessage::NoteOff { key: 40.into(), vel: 100.into() },
+            10 * ppq/4 => MidiMessage::NoteOn  { key: 40.into(), vel: 100.into() },
+            12 * ppq/4 => MidiMessage::NoteOff { key: 40.into(), vel: 100.into() },
+            14 * ppq/4 => MidiMessage::NoteOn  { key: 40.into(), vel: 100.into() },
+        }));
+
         Ok(())
     }))
 }
@@ -205,34 +209,6 @@ impl App {
         };
         Ok(())
     }
-    pub fn connect_tracks (&self) -> Usually<()> {
-        //let (client, _status) = Client::new(
-            //&format!("{}-init", &self.name), ClientOptions::NO_START_SERVER
-        //)?;
-        //let midi_ins = client.ports(Some(midi_in), None, PortFlags::IS_OUTPUT);
-        //let audio_outs: Vec<Vec<String>> = audio_outs.iter()
-            //.map(|pattern|client.ports(Some(pattern), None, PortFlags::IS_INPUT))
-            //.collect();
-        //for (i, sequencer) in self.tracks.iter().enumerate() {
-            //for sequencer_midi_in in sequencer.midi_ins()?.iter() {
-                //for midi_in in midi_ins.iter() {
-                    //client.connect_ports_by_name(&midi_in, &sequencer_midi_in)?;
-                //}
-            //}
-            //let chain: &Chain = &self.tracks[i].chain;
-            //for port in sequencer.midi_outs()?.iter() {
-                //for midi_in in chain.midi_ins()?.iter() {
-                    //client.connect_ports_by_name(&port, &midi_in)?;
-                //}
-            //}
-            //for (j, port) in chain.audio_outs()?.iter().enumerate() {
-                //for audio_out in audio_outs[j % audio_outs.len()].iter() {
-                    //client.connect_ports_by_name(&port, &audio_out)?;
-                //}
-            //}
-        //}
-        Ok(())
-    }
     pub fn add_scene (&mut self, name: Option<&str>) -> Usually<&mut Scene> {
         let name = name.ok_or_else(||format!("Scene {}", self.scenes.len() + 1))?;
         self.scenes.push(Scene::new(&name, vec![]));
@@ -274,4 +250,32 @@ impl App {
         let (_, scene) = self.scene()?;
         *scene.clips.get(track_id)?
     }
+    pub fn connect_tracks (&self) -> Usually<()> {
+        //let (client, _status) = Client::new(
+            //&format!("{}-init", &self.name), ClientOptions::NO_START_SERVER
+        //)?;
+        //let midi_ins = client.ports(Some(midi_in), None, PortFlags::IS_OUTPUT);
+        //let audio_outs: Vec<Vec<String>> = audio_outs.iter()
+            //.map(|pattern|client.ports(Some(pattern), None, PortFlags::IS_INPUT))
+            //.collect();
+        //for (i, sequencer) in self.tracks.iter().enumerate() {
+            //for sequencer_midi_in in sequencer.midi_ins()?.iter() {
+                //for midi_in in midi_ins.iter() {
+                    //client.connect_ports_by_name(&midi_in, &sequencer_midi_in)?;
+                //}
+            //}
+            //let chain: &Chain = &self.tracks[i].chain;
+            //for port in sequencer.midi_outs()?.iter() {
+                //for midi_in in chain.midi_ins()?.iter() {
+                    //client.connect_ports_by_name(&port, &midi_in)?;
+                //}
+            //}
+            //for (j, port) in chain.audio_outs()?.iter().enumerate() {
+                //for audio_out in audio_outs[j % audio_outs.len()].iter() {
+                    //client.connect_ports_by_name(&port, &audio_out)?;
+                //}
+            //}
+        //}
+        Ok(())
+    }
 }

src/model/track.rs

@@ -38,22 +38,29 @@ impl Track {
             recording:  false,
             overdub:    true,
             sequence:   None,
-            phrases:    phrases.unwrap_or_else(||vec![]),
+            phrases:    phrases.unwrap_or_else(||Vec::with_capacity(16)),
-            devices:    devices.unwrap_or_else(||vec![]),
+            devices:    devices.unwrap_or_else(||Vec::with_capacity(16)),
             device:     0,
         })
     }
-    pub fn device (&self, i: usize) -> Option<MutexGuard<Box<dyn Device>>> {
+    pub fn add_device (
+        &mut self, device: JackDevice
+    ) -> &mut JackDevice {
+        self.devices.push(device);
+        let index = self.devices.len() - 1;
+        &mut self.devices[index]
+    }
+    pub fn get_device (&self, i: usize) -> Option<MutexGuard<Box<dyn Device>>> {
         self.devices.get(i).map(|d|d.state.lock().unwrap())
     }
-    pub fn active_device (&self) -> Option<MutexGuard<Box<dyn Device>>> {
+    pub fn device (&self) -> Option<MutexGuard<Box<dyn Device>>> {
-        self.device(self.device)
+        self.get_device(self.device)
     }
     pub fn first_device (&self) -> Option<MutexGuard<Box<dyn Device>>> {
-        self.device(0)
+        self.get_device(0)
     }
     pub fn last_device (&self) -> Option<MutexGuard<Box<dyn Device>>> {
-        self.device(self.devices.len().saturating_sub(1))
+        self.get_device(self.devices.len().saturating_sub(1))
     }
     pub fn phrase (&self) -> Option<&Phrase> {
         if let Some(phrase) = self.sequence {
@@ -69,6 +76,13 @@ impl Track {
             None
         }
     }
+    pub fn add_phrase (
+        &mut self, name: &str, length: usize, data: Option<PhraseData>
+    ) -> &mut Phrase {
+        self.phrases.push(Phrase::new(name, length, data));
+        let index = self.phrases.len() - 1;
+        &mut self.phrases[index]
+    }
 }
 
 ports!(Track {

src/view/sequencer.rs

@@ -5,7 +5,9 @@ pub enum SequencerMode { Tiny, Compact, Horizontal, Vertical, }
 
 pub struct SequencerView<'a> {
     pub focused:     bool,
+    /// Displayed phrase
     pub phrase:      Option<&'a Phrase>,
+    /// Resolution of MIDI sequence
     pub ppq:         usize,
     /// Range of notes to display
     pub note_start:  usize,
@@ -17,7 +19,6 @@ pub struct SequencerView<'a> {
     pub time_start:  usize,
     /// Position of cursor within time range
     pub time_cursor: usize,
-
     /// Current time
     pub now:         usize
 }
@@ -97,6 +98,10 @@ mod horizontal {
         }
     }
 
+    pub const KEYS_VERTICAL: [&'static str; 6] = [
+        "▄", "▄", "█", "▀", "▀", "▀",
+    ];
+
     pub fn keys (buf: &mut Buffer, area: Rect, note0: usize, _notes: &[bool])
         -> Usually<Rect>
     {
@@ -187,6 +192,7 @@ mod horizontal {
     }
 }
 
+
     //pub fn footer (
         //buf:    &mut Buffer,
         //area:   Rect,
@@ -293,6 +299,27 @@ mod horizontal {
         //buf.set_string(x, y, c, Style::default());
     //}
 
+//pub const KEY_WHITE: Style = Style {
+    //fg: Some(Color::Gray),
+    //bg: None,
+    //underline_color: None,
+    //add_modifier: ::ratatui::style::Modifier::empty(),
+    //sub_modifier: ::ratatui::style::Modifier::empty(),
+//};
+
+//pub const KEY_BLACK: Style = Style {
+    //fg: Some(Color::Black),
+    //bg: None,
+    //underline_color: None,
+    //add_modifier: ::ratatui::style::Modifier::empty(),
+    //sub_modifier: ::ratatui::style::Modifier::empty(),
+//};
+
+//pub const KEY_STYLE: [Style;12] = [
+    //KEY_WHITE, KEY_BLACK, KEY_WHITE, KEY_BLACK, KEY_WHITE,
+    //KEY_WHITE, KEY_BLACK, KEY_WHITE, KEY_BLACK, KEY_WHITE, KEY_BLACK, KEY_WHITE,
+//];
+
     //pub fn keys (s: &Sequencer, buf: &mut Buffer, area: Rect, beat: usize) {
         //let ppq = s.timebase.ppq() as usize;
         //let Rect { x, y, .. } = area;