extract pool, scene, track

Cargo.toml

@@ -50,11 +50,11 @@ symphonia    = { version = "0.5.4", features = [ "all" ] }
 toml         = { version = "0.8.12" }
 uuid         = { version = "1.10.0", features = [ "v4" ] }
 wavers       = { version = "1.4.3" }
+winit        = { version = "0.30.4", features = [ "x11" ] }
 #once_cell = "1.19.0"
 #no_deadlocks = "1.3.2"
 #suil-rs = { path = "../suil" }
 #vst = "0.4.0"
 #vst3 = "0.1.0"
-#winit = { version = "0.30.4", features = [ "x11" ] }
 proptest        = { version = "^1" }
 proptest-derive = { version = "^0.5.1" }

config/config_arranger.edn

@@ -11,6 +11,7 @@
                               :arranger))))))
 
 (keys
+  (layer-if :mode-message     "./keys_message.edn")
   (layer-if :mode-device-add  "./keys_device_add.edn")
   (layer-if :mode-pool-import "./keys_pool_file.edn")
   (layer-if :mode-pool-export "./keys_pool_file.edn")

config/keys_message.edn

@@ -0,0 +1,2 @@
+(@esc   message dismiss)
+(@enter message dismiss)

crates/app/src/api.rs

@@ -20,7 +20,8 @@ handle!(TuiIn: |self: Tek, input|Ok(if let Some(command) = self.config.keys.comm
 expose!([self: Tek]
     ([bool]
         (":mode-editor" self.is_editing())
-        (":mode-device-add" matches!(self.modal, Some(Modal::Device(..))))
+        (":mode-message"    matches!(self.dialog, Some(Dialog::Message(..))))
+        (":mode-device-add" matches!(self.dialog, Some(Dialog::Device(..))))
         (":mode-clip"   !self.is_editing() && self.selected.is_clip())
         (":mode-track"  !self.is_editing() && self.selected.is_track())
         (":mode-scene"  !self.is_editing() && self.selected.is_scene())
@@ -47,17 +48,17 @@ expose!([self: Tek]
     ([usize]
         (":scene-last" self.scenes.len())
         (":track-last" self.tracks.len())
-        (":device-kind" if let Some(Modal::Device(index)) = self.modal {
+        (":device-kind" if let Some(Dialog::Device(index)) = self.dialog {
             index
         } else {
             0
         })
-        (":device-kind-prev" if let Some(Modal::Device(index)) = self.modal {
+        (":device-kind-prev" if let Some(Dialog::Device(index)) = self.dialog {
             index.overflowing_sub(1).0.min(self.device_kinds().len().saturating_sub(1))
         } else {
             0
         })
-        (":device-kind-next" if let Some(Modal::Device(index)) = self.modal {
+        (":device-kind-next" if let Some(Dialog::Device(index)) = self.dialog {
             (index + 1) % self.device_kinds().len()
         } else {
             0
@@ -130,13 +131,14 @@ impose!([app: Tek]
         ("enqueue" [c: Arc<RwLock<MidiClip>>] Some(Self::Enqueue(c)))
         ("launch"  [] Some(Self::Launch))
         ("select"  [t: Selection] Some(t.map(Self::Select).expect("no selection")))
-        ("clock"   [,..a] ns!(ClockCommand,  app.clock(), a, Self::Clock))
-        ("scene"   [,..a] ns!(SceneCommand,  app, a, Self::Scene))
-        ("track"   [,..a] ns!(TrackCommand,  app, a, Self::Track))
-        ("input"   [,..a] ns!(InputCommand,  app, a, Self::Input))
-        ("output"  [,..a] ns!(OutputCommand, app, a, Self::Output))
-        ("clip"    [,..a] ns!(ClipCommand,   app, a, Self::Clip))
-        ("device"  [,..a] ns!(DeviceCommand, app, a, Self::Device))
+        ("clock"   [,..a] ns!(ClockCommand,   app.clock(), a, Self::Clock))
+        ("scene"   [,..a] ns!(SceneCommand,   app, a, Self::Scene))
+        ("track"   [,..a] ns!(TrackCommand,   app, a, Self::Track))
+        ("input"   [,..a] ns!(InputCommand,   app, a, Self::Input))
+        ("output"  [,..a] ns!(OutputCommand,  app, a, Self::Output))
+        ("clip"    [,..a] ns!(ClipCommand,    app, a, Self::Clip))
+        ("device"  [,..a] ns!(DeviceCommand,  app, a, Self::Device))
+        ("message" [,..a] ns!(MessageCommand, app, a, Self::Message))
         ("pool"    [,..a] app.pool.as_ref().map(|p|ns!(PoolCommand, p, a, Self::Pool)).flatten())
         ("editor"  [,..a] app.editor().map(|e|ns!(MidiEditCommand, e, a, Self::Editor)).flatten())
         ("sampler" [,..a] app.sampler().map(|s|ns!(SamplerCommand, s, a, Self::Sampler)).flatten())
@@ -166,6 +168,9 @@ impose!([app: Tek]
         ("pick"   [index: usize] Some(Self::Pick(index.unwrap())))
         ("add"    [index: usize] Some(Self::Add(index.unwrap()))))
 
+    (MessageCommand:
+        ("dismiss" [] Some(Self::Dismiss)))
+
     (SceneCommand:
         ("add"     []                   Some(Self::Add))
         ("delete"  [a: Option<usize>]   Some(Self::Del(a.flatten().unwrap())))
@@ -187,6 +192,18 @@ impose!([app: Tek]
         ("rec"    []                   Some(Self::ToggleRec))
         ("mon"    []                   Some(Self::ToggleMon))));
 
+//#[tengri_proc::input(TuiIn)]
+//impl Tek {
+    //#[tengri::command("sampler", TekCommand::Sampler)]
+    //fn cmd_sampler (&mut self, cmd: SamplerCommand) -> Perhaps<TekCommand> {
+        //self.sampler_mut().map(|s|cmd.delegate(s, Self::Sampler)).transpose()?.flatten())
+    //}
+    //#[tengri::command("scene", TekCommand::Scene)]
+    //fn cmd_scene (&mut self, cmd: SceneCommand) -> Perhaps<TekCommand> {
+        //cmd.delegate(self, scene)
+    //}
+//}
+
 defcom!([self, app: Tek]
 
     (TekCommand
@@ -198,10 +215,11 @@ defcom!([self, app: Tek]
         (Clip       [cmd: ClipCommand]     cmd.delegate(app, Self::Clip)?)
         (Clock      [cmd: ClockCommand]    cmd.delegate(app, Self::Clock)?)
         (Device     [cmd: DeviceCommand]   cmd.delegate(app, Self::Device)?)
+        (Message    [cmd: MessageCommand]  cmd.delegate(app, Self::Message)?)
         (Editor     [cmd: MidiEditCommand] delegate_to_editor(app, cmd)?)
         (Pool       [cmd: PoolCommand]     delegate_to_pool(app, cmd)?)
-        (ToggleHelp []                     cmd!(app.toggle_modal(Some(Modal::Help))))
-        (ToggleMenu []                     cmd!(app.toggle_modal(Some(Modal::Menu))))
+        (ToggleHelp []                     cmd!(app.toggle_dialog(Some(Dialog::Help))))
+        (ToggleMenu []                     cmd!(app.toggle_dialog(Some(Dialog::Menu))))
         (Color      [p: ItemTheme]         app.set_color(Some(p)).map(Self::Color))
         (Enqueue    [c: MaybeClip]         cmd_todo!("\n\rtodo: enqueue {c:?}"))
         (History    [d: isize]             cmd_todo!("\n\rtodo: history {d:?}"))
@@ -222,6 +240,9 @@ defcom!([self, app: Tek]
         (Pick   [i: usize] cmd!(app.device_pick(i)))
         (Add    [i: usize] cmd!(app.device_add(i))))
 
+    (MessageCommand
+        (Dismiss [] cmd!(app.message_dismiss())))
+
     (TrackCommand
         (TogglePlay []                       Some(Self::TogglePlay))
         (ToggleSolo []                       Some(Self::ToggleSolo))

crates/app/src/model.rs

@@ -1,5 +1,12 @@
 use crate::*;
 
+mod dialog;    pub use self::dialog::*;
+mod editor;    pub use self::editor::*;
+mod pool;      pub use self::pool::*;
+mod selection; pub use self::selection::*;
+mod track;     pub use self::track::*;
+mod scene;     pub use self::scene::*;
+
 #[derive(Default, Debug)]
 pub struct Tek {
     /// Must not be dropped for the duration of the process
@@ -50,8 +57,8 @@ pub struct Tek {
     pub ports: std::collections::BTreeMap<u32, Port<Unowned>>,
     // Cache of formatted strings
     pub view_cache: Arc<RwLock<ViewCache>>,
-    // Modal overlay
-    pub modal: Option<Modal>,
+    // Dialog overlay
+    pub dialog: Option<Dialog>,
     // View and input definition
     pub config: Configuration
 }
@@ -204,14 +211,6 @@ impl Tek {
         }
     }
 
-    pub fn toggle_modal (&mut self, modal: Option<Modal>) {
-        self.modal = if self.modal == modal {
-            None
-        } else {
-            modal
-        }
-    }
-
     // Create new clip in pool when entering empty cell
     pub fn clip_auto_create (&mut self) {
         if let Some(ref pool) = self.pool
@@ -393,33 +392,6 @@ impl Tek {
         Ok(())
     }
 
-    pub(crate) fn device_picker_show (&mut self) {
-        self.modal = Some(Modal::Device(0));
-    }
-
-    pub(crate) fn device_pick (&mut self, index: usize) {
-        self.modal = Some(Modal::Device(index));
-    }
-
-    pub(crate) fn device_add (&mut self, index: usize) -> Usually<()> {
-        match index {
-            0 => {
-                let jack = self.jack.clone();
-                self.track_mut()
-                    .expect("no active track")
-                    .devices
-                    .push({
-                        let sampler = Sampler::new(&jack, &"sampler", &[], &[&[], &[]], &[&[], &[]])?;
-                        Device::Sampler(sampler)
-                    });
-                self.modal = None;
-                Ok(())
-            },
-            1 => todo!(),
-            _ => unreachable!(),
-        }
-    }
-
     pub(crate) fn device_kinds (&self) -> &'static [&'static str] {
         &[
             "Sampler",
@@ -427,6 +399,46 @@ impl Tek {
         ]
     }
 
+    pub(crate) fn device_picker_show (&mut self) {
+        self.dialog = Some(Dialog::Device(0));
+    }
+
+    pub(crate) fn device_pick (&mut self, index: usize) {
+        self.dialog = Some(Dialog::Device(index));
+    }
+
+    pub(crate) fn device_add (&mut self, index: usize) -> Usually<()> {
+        match index {
+            0 => self.device_add_sampler(),
+            1 => self.device_add_lv2(),
+            _ => unreachable!(),
+        }
+    }
+
+    fn device_add_sampler (&mut self) -> Usually<()> {
+        let name = self.jack.with_client(|c|c.name().to_string());
+        let midi = self.track().expect("no active track").player.midi_outs[0].name();
+        let sampler = if let Ok(sampler) = Sampler::new(
+            &self.jack,
+            &format!("{}/Sampler", &self.track().expect("no active track").name),
+            &[PortConnect::exact(format!("{name}:{midi}"))],
+            &[&[], &[]],
+            &[&[], &[]]
+        ) {
+            self.dialog = None;
+            Device::Sampler(sampler)
+        } else {
+            self.dialog = Some(Dialog::Message(Message::FailedToAddDevice));
+            return Err("failed to add device".into())
+        };
+        self.track_mut().expect("no active track").devices.push(sampler);
+        Ok(())
+    }
+
+    fn device_add_lv2 (&mut self) -> Usually<()> {
+        todo!();
+        Ok(())
+    }
 }
 
 has_size!(<TuiOut>|self: Tek|&self.size);
@@ -447,749 +459,3 @@ has_editor!(|self: Tek|{
     editor_h = 15;
     is_editing = self.editing.load(Relaxed);
 });
-
-pub trait HasSelection {
-    fn selected (&self) -> &Selection;
-    fn selected_mut (&mut self) -> &mut Selection;
-}
-
-/// Various possible modal overlays
-#[derive(PartialEq, Clone, Copy, Debug)]
-pub enum Modal {
-    Help,
-    Menu,
-    Device(usize)
-}
-
-/// Represents the current user selection in the arranger
-#[derive(PartialEq, Clone, Copy, Debug, Default)]
-pub enum Selection {
-    /// The whole mix is selected
-    #[default] Mix,
-    /// A MIDI input is selected.
-    Input(usize),
-    /// A MIDI output is selected.
-    Output(usize),
-    /// A scene is selected.
-    Scene(usize),
-    /// A track is selected.
-    Track(usize),
-    /// A clip (track × scene) is selected.
-    TrackClip   { track: usize, scene:  usize },
-    /// A track's MIDI input connection is selected.
-    TrackInput  { track: usize, port:   usize },
-    /// A track's MIDI output connection is selected.
-    TrackOutput { track: usize, port:   usize },
-    /// A track device slot is selected.
-    TrackDevice { track: usize, device: usize },
-}
-
-/// Focus identification methods
-impl Selection {
-    pub fn is_mix (&self) -> bool {
-        matches!(self, Self::Mix)
-    }
-    pub fn is_track (&self) -> bool {
-        matches!(self, Self::Track(_))
-    }
-    pub fn is_scene (&self) -> bool {
-        matches!(self, Self::Scene(_))
-    }
-    pub fn is_clip (&self) -> bool {
-        matches!(self, Self::TrackClip {..})
-    }
-    pub fn track (&self) -> Option<usize> {
-        use Selection::*;
-        match self {
-            Track(track)
-            | TrackClip   { track, .. }
-            | TrackInput  { track, .. }
-            | TrackOutput { track, .. }
-            | TrackDevice { track, .. } => Some(*track),
-            _ => None
-        }
-    }
-    pub fn track_next (&self, len: usize) -> Self {
-        use Selection::*;
-        match self {
-            Mix => Track(0),
-            Scene(s) => TrackClip { track: 0, scene: *s },
-            Track(t) => if t + 1 < len {
-                Track(t + 1)
-            } else {
-                Mix
-            },
-            TrackClip {track, scene} => if track + 1 < len {
-                TrackClip { track: track + 1, scene: *scene }
-            } else {
-                Scene(*scene)
-            },
-            _ => todo!()
-        }
-    }
-    pub fn track_prev (&self) -> Self {
-        use Selection::*;
-        match self {
-            Mix => Mix,
-            Scene(s) => Scene(*s),
-            Track(0) => Mix,
-            Track(t) => Track(t - 1),
-            TrackClip { track: 0, scene } => Scene(*scene),
-            TrackClip { track: t, scene } => TrackClip { track: t - 1, scene: *scene },
-            _ => todo!()
-        }
-    }
-    pub fn scene (&self) -> Option<usize> {
-        use Selection::*;
-        match self {
-            Scene(scene) | TrackClip { scene, .. } => Some(*scene),
-            _ => None
-        }
-    }
-    pub fn scene_next (&self, len: usize) -> Self {
-        use Selection::*;
-        match self {
-            Mix => Scene(0),
-            Track(t) => TrackClip { track: *t, scene: 0 },
-            Scene(s) => if s + 1 < len {
-                Scene(s + 1)
-            } else {
-                Mix
-            },
-            TrackClip { track, scene } => if scene + 1 < len {
-                TrackClip { track: *track, scene: scene + 1 }
-            } else {
-                Track(*track)
-            },
-            _ => todo!()
-        }
-    }
-    pub fn scene_prev (&self) -> Self {
-        use Selection::*;
-        match self {
-            Mix | Scene(0) => Mix,
-            Scene(s) => Scene(s - 1),
-            Track(t) => Track(*t),
-            TrackClip { track, scene: 0 } => Track(*track),
-            TrackClip { track, scene } => TrackClip { track: *track, scene: scene - 1 },
-            _ => todo!()
-        }
-    }
-    pub fn describe (&self, tracks: &[Track], scenes: &[Scene]) -> Arc<str> {
-        use Selection::*;
-        format!("{}", match self {
-            Mix => "Everything".to_string(),
-            Scene(s) => scenes.get(*s)
-                .map(|scene|format!("S{s}: {}", &scene.name))
-                .unwrap_or_else(||"S??".into()),
-            Track(t) => tracks.get(*t)
-                .map(|track|format!("T{t}: {}", &track.name))
-                .unwrap_or_else(||"T??".into()),
-            TrackClip { track, scene } => match (tracks.get(*track), scenes.get(*scene)) {
-                (Some(_), Some(s)) => match s.clip(*track) {
-                    Some(clip) => format!("T{track} S{scene} C{}", &clip.read().unwrap().name),
-                    None       => format!("T{track} S{scene}: Empty")
-                },
-                _ => format!("T{track} S{scene}: Empty"),
-            },
-            _ => todo!()
-        }).into()
-    }
-}
-
-impl HasSelection for Tek {
-    fn selected (&self) -> &Selection { &self.selected }
-    fn selected_mut (&mut self) -> &mut Selection { &mut self.selected }
-}
-
-pub trait HasScenes: HasSelection + HasEditor + Send + Sync {
-    fn scenes (&self) -> &Vec<Scene>;
-    fn scenes_mut (&mut self) -> &mut Vec<Scene>;
-    fn scene_longest (&self) -> usize {
-        self.scenes().iter().map(|s|s.name.len()).fold(0, usize::max)
-    }
-    fn scene (&self) -> Option<&Scene> {
-        self.selected().scene().and_then(|s|self.scenes().get(s))
-    }
-    fn scene_mut (&mut self) -> Option<&mut Scene> {
-        self.selected().scene().and_then(|s|self.scenes_mut().get_mut(s))
-    }
-    fn scene_del (&mut self, index: usize) {
-        self.selected().scene().and_then(|s|Some(self.scenes_mut().remove(index)));
-    }
-    /// Set the color of a scene, returning the previous one.
-    fn scene_set_color (&mut self, index: usize, color: ItemTheme) -> ItemTheme {
-        let scenes = self.scenes_mut();
-        let old = scenes[index].color;
-        scenes[index].color = color;
-        old
-    }
-    /// Generate the default name for a new scene
-    fn scene_default_name (&self) -> Arc<str> {
-        format!("Sc{:3>}", self.scenes().len() + 1).into()
-    }
-}
-
-#[derive(Debug, Default)] pub struct Scene {
-    /// Name of scene
-    pub name:  Arc<str>,
-    /// Clips in scene, one per track
-    pub clips: Vec<Option<Arc<RwLock<MidiClip>>>>,
-    /// Identifying color of scene
-    pub color: ItemTheme,
-}
-
-impl Scene {
-    /// Returns the pulse length of the longest clip in the scene
-    pub fn pulses (&self) -> usize {
-        self.clips.iter().fold(0, |a, p|{
-            a.max(p.as_ref().map(|q|q.read().unwrap().length).unwrap_or(0))
-        })
-    }
-    /// Returns true if all clips in the scene are
-    /// currently playing on the given collection of tracks.
-    pub fn is_playing (&self, tracks: &[Track]) -> bool {
-        self.clips.iter().any(|clip|clip.is_some()) && self.clips.iter().enumerate()
-            .all(|(track_index, clip)|match clip {
-                Some(c) => tracks
-                    .get(track_index)
-                    .map(|track|{
-                        if let Some((_, Some(clip))) = track.player().play_clip() {
-                            *clip.read().unwrap() == *c.read().unwrap()
-                        } else {
-                            false
-                        }
-                    })
-                    .unwrap_or(false),
-                None => true
-            })
-    }
-    pub fn clip (&self, index: usize) -> Option<&Arc<RwLock<MidiClip>>> {
-        match self.clips.get(index) { Some(Some(clip)) => Some(clip), _ => None }
-    }
-}
-
-impl HasScenes for Tek {
-    fn scenes (&self) -> &Vec<Scene> { &self.scenes }
-    fn scenes_mut (&mut self) -> &mut Vec<Scene> { &mut self.scenes }
-}
-
-pub trait HasTracks: HasSelection + HasClock + HasJack + HasEditor + Send + Sync {
-    fn midi_ins (&self) -> &Vec<JackMidiIn>;
-    fn midi_outs (&self) -> &Vec<JackMidiOut>;
-    fn tracks (&self) -> &Vec<Track>;
-    fn tracks_mut (&mut self) -> &mut Vec<Track>;
-    fn track_longest (&self) -> usize {
-        self.tracks().iter().map(|s|s.name.len()).fold(0, usize::max)
-    }
-    const WIDTH_OFFSET: usize = 1;
-    fn track (&self) -> Option<&Track> {
-        self.selected().track().and_then(|s|self.tracks().get(s))
-    }
-    fn track_mut (&mut self) -> Option<&mut Track> {
-        self.selected().track().and_then(|s|self.tracks_mut().get_mut(s))
-    }
-    /// Set the color of a track
-    fn track_set_color (&mut self, index: usize, color: ItemTheme) -> ItemTheme {
-        let tracks = self.tracks_mut();
-        let old = tracks[index].color;
-        tracks[index].color = color;
-        old
-    }
-    /// Toggle track recording
-    fn track_toggle_record (&mut self) {
-        if let Some(t) = self.selected().track() {
-            let tracks = self.tracks_mut();
-            tracks[t-1].player.recording = !tracks[t-1].player.recording;
-        }
-    }
-    /// Toggle track monitoring
-    fn track_toggle_monitor (&mut self) {
-        if let Some(t) = self.selected().track() {
-            let tracks = self.tracks_mut();
-            tracks[t-1].player.monitoring = !tracks[t-1].player.monitoring;
-        }
-    }
-}
-
-#[derive(Debug, Default)] pub struct Track {
-    /// Name of track
-    pub name:       Arc<str>,
-    /// Preferred width of track column
-    pub width:      usize,
-    /// Identifying color of track
-    pub color:      ItemTheme,
-    /// MIDI player state
-    pub player:     MidiPlayer,
-    /// Device chain
-    pub devices:    Vec<Device>,
-    /// Inputs of 1st device
-    pub audio_ins:  Vec<JackAudioIn>,
-    /// Outputs of last device
-    pub audio_outs: Vec<JackAudioOut>,
-}
-
-has_clock!(|self: Track|self.player.clock);
-
-has_player!(|self: Track|self.player);
-
-impl Track {
-    pub const MIN_WIDTH: usize = 9;
-    /// Create a new track containing a sequencer.
-    pub fn new_sequencer () -> Self {
-        let mut track = Self::default();
-        track.devices.push(Device::Sequencer(MidiPlayer::default()));
-        track
-    }
-    /// Create a new track containing a sequencer and sampler.
-    pub fn new_groovebox (
-        jack:       &Jack,
-        midi_from:  &[PortConnect],
-        audio_from: &[&[PortConnect];2],
-        audio_to:   &[&[PortConnect];2],
-    ) -> Usually<Self> {
-        let mut track = Self::new_sequencer();
-        track.devices.push(Device::Sampler(
-            Sampler::new(jack, &"sampler", midi_from, audio_from, audio_to)?
-        ));
-        Ok(track)
-    }
-    /// Create a new track containing a sampler.
-    pub fn new_sampler (
-        jack:       &Jack,
-        midi_from:  &[PortConnect],
-        audio_from: &[&[PortConnect];2],
-        audio_to:   &[&[PortConnect];2],
-    ) -> Usually<Self> {
-        let mut track = Self::default();
-        track.devices.push(Device::Sampler(
-            Sampler::new(jack, &"sampler", midi_from, audio_from, audio_to)?
-        ));
-        Ok(track)
-    }
-    pub fn width_inc (&mut self) {
-        self.width += 1;
-    }
-    pub fn width_dec (&mut self) {
-        if self.width > Track::MIN_WIDTH {
-            self.width -= 1;
-        }
-    }
-    pub fn sequencer (&self, mut nth: usize) -> Option<&MidiPlayer> {
-        for device in self.devices.iter() {
-            match device {
-                Device::Sequencer(s) => if nth == 0 {
-                    return Some(s);
-                } else {
-                    nth -= 1;
-                },
-                _ => {}
-            }
-        }
-        None
-    }
-    pub fn sampler (&self, mut nth: usize) -> Option<&Sampler> {
-        for device in self.devices.iter() {
-            match device {
-                Device::Sampler(s) => if nth == 0 {
-                    return Some(s);
-                } else {
-                    nth -= 1;
-                },
-                _ => {}
-            }
-        }
-        None
-    }
-    pub fn sampler_mut (&mut self, mut nth: usize) -> Option<&mut Sampler> {
-        for device in self.devices.iter_mut() {
-            match device {
-                Device::Sampler(s) => if nth == 0 {
-                    return Some(s);
-                } else {
-                    nth -= 1;
-                },
-                _ => {}
-            }
-        }
-        None
-    }
-}
-
-impl HasTracks for Tek {
-    fn midi_ins (&self) -> &Vec<JackMidiIn> { &self.midi_ins }
-    fn midi_outs (&self) -> &Vec<JackMidiOut> { &self.midi_outs }
-    fn tracks (&self) -> &Vec<Track> { &self.tracks }
-    fn tracks_mut (&mut self) -> &mut Vec<Track> { &mut self.tracks }
-}
-
-#[derive(Debug)]
-pub struct MidiPool {
-    pub visible: bool,
-    /// Collection of clips
-    pub clips: Arc<RwLock<Vec<Arc<RwLock<MidiClip>>>>>,
-    /// Selected clip
-    pub clip: AtomicUsize,
-    /// Mode switch
-    pub mode: Option<PoolMode>,
-}
-
-impl Default for MidiPool {
-    fn default () -> Self {
-        use PoolMode::*;
-        Self {
-            visible: true,
-            clips: Arc::from(RwLock::from(vec![])),
-            clip: 0.into(),
-            mode: None,
-        }
-    }
-}
-
-has_clips!(|self: MidiPool|self.clips);
-
-has_clip!(|self: MidiPool|self.clips().get(self.clip_index()).map(|c|c.clone()));
-
-from!(|clip:&Arc<RwLock<MidiClip>>|MidiPool = {
-    let model = Self::default();
-    model.clips.write().unwrap().push(clip.clone());
-    model.clip.store(1, Relaxed);
-    model
-});
-
-impl MidiPool {
-    pub fn clip_index (&self) -> usize {
-        self.clip.load(Relaxed)
-    }
-    pub fn set_clip_index (&self, value: usize) {
-        self.clip.store(value, Relaxed);
-    }
-    pub fn mode (&self) -> &Option<PoolMode> {
-        &self.mode
-    }
-    pub fn mode_mut (&mut self) -> &mut Option<PoolMode> {
-        &mut self.mode
-    }
-    pub fn begin_clip_length (&mut self) {
-        let length = self.clips()[self.clip_index()].read().unwrap().length;
-        *self.mode_mut() = Some(PoolMode::Length(
-            self.clip_index(),
-            length,
-            ClipLengthFocus::Bar
-        ));
-    }
-    pub fn begin_clip_rename (&mut self) {
-        let name = self.clips()[self.clip_index()].read().unwrap().name.clone();
-        *self.mode_mut() = Some(PoolMode::Rename(
-            self.clip_index(),
-            name
-        ));
-    }
-    pub fn begin_import (&mut self) -> Usually<()> {
-        *self.mode_mut() = Some(PoolMode::Import(
-            self.clip_index(),
-            FileBrowser::new(None)?
-        ));
-        Ok(())
-    }
-    pub fn begin_export (&mut self) -> Usually<()> {
-        *self.mode_mut() = Some(PoolMode::Export(
-            self.clip_index(),
-            FileBrowser::new(None)?
-        ));
-        Ok(())
-    }
-    pub fn new_clip (&self) -> MidiClip {
-        MidiClip::new("Clip", true, 4 * PPQ, None, Some(ItemTheme::random()))
-    }
-    pub fn cloned_clip (&self) -> MidiClip {
-        let index    = self.clip_index();
-        let mut clip = self.clips()[index].read().unwrap().duplicate();
-        clip.color   = ItemTheme::random_near(clip.color, 0.25);
-        clip
-    }
-    pub fn add_new_clip (&self) -> (usize, Arc<RwLock<MidiClip>>) {
-        let clip = Arc::new(RwLock::new(self.new_clip()));
-        let index = {
-            let mut clips = self.clips.write().unwrap();
-            clips.push(clip.clone());
-            clips.len().saturating_sub(1)
-        };
-        self.clip.store(index, Relaxed);
-        (index, clip)
-    }
-    pub fn delete_clip (&mut self, clip: &MidiClip) -> bool {
-        let index = self.clips.read().unwrap().iter().position(|x|*x.read().unwrap()==*clip);
-        if let Some(index) = index {
-            self.clips.write().unwrap().remove(index);
-            return true
-        }
-        false
-    }
-}
-
-/// Modes for clip pool
-#[derive(Debug, Clone)]
-pub enum PoolMode {
-    /// Renaming a pattern
-    Rename(usize, Arc<str>),
-    /// Editing the length of a pattern
-    Length(usize, usize, ClipLengthFocus),
-    /// Load clip from disk
-    Import(usize, FileBrowser),
-    /// Save clip to disk
-    Export(usize, FileBrowser),
-}
-
-/// Focused field of `ClipLength`
-#[derive(Copy, Clone, Debug)]
-pub enum ClipLengthFocus {
-    /// Editing the number of bars
-    Bar,
-    /// Editing the number of beats
-    Beat,
-    /// Editing the number of ticks
-    Tick,
-}
-
-impl ClipLengthFocus {
-    pub fn next (&mut self) {
-        use ClipLengthFocus::*;
-        *self = match self { Bar => Beat, Beat => Tick, Tick => Bar, }
-    }
-    pub fn prev (&mut self) {
-        use ClipLengthFocus::*;
-        *self = match self { Bar => Tick, Beat => Bar, Tick => Beat, }
-    }
-}
-
-/// Displays and edits clip length.
-#[derive(Clone)]
-pub struct ClipLength {
-    /// Pulses per beat (quaver)
-    ppq: usize,
-    /// Beats per bar
-    bpb: usize,
-    /// Length of clip in pulses
-    pulses: usize,
-    /// Selected subdivision
-    pub focus: Option<ClipLengthFocus>,
-}
-
-impl ClipLength {
-    pub fn _new (pulses: usize, focus: Option<ClipLengthFocus>) -> Self {
-        Self { ppq: PPQ, bpb: 4, pulses, focus }
-    }
-    pub fn bars  (&self) -> usize {
-        self.pulses / (self.bpb * self.ppq)
-    }
-    pub fn beats (&self) -> usize {
-        (self.pulses % (self.bpb * self.ppq)) / self.ppq
-    }
-    pub fn ticks (&self) -> usize {
-        self.pulses % self.ppq
-    }
-    pub fn bars_string  (&self) -> Arc<str> {
-        format!("{}", self.bars()).into()
-    }
-    pub fn beats_string (&self) -> Arc<str> {
-        format!("{}", self.beats()).into()
-    }
-    pub fn ticks_string (&self) -> Arc<str> {
-        format!("{:>02}", self.ticks()).into()
-    }
-}
-
-pub type ClipPool = Vec<Arc<RwLock<MidiClip>>>;
-
-pub trait HasClips {
-    fn clips <'a> (&'a self) -> std::sync::RwLockReadGuard<'a, ClipPool>;
-    fn clips_mut <'a> (&'a self) -> std::sync::RwLockWriteGuard<'a, ClipPool>;
-    fn add_clip (&self) -> (usize, Arc<RwLock<MidiClip>>) {
-        let clip = Arc::new(RwLock::new(MidiClip::new("Clip", true, 384, None, None)));
-        self.clips_mut().push(clip.clone());
-        (self.clips().len() - 1, clip)
-    }
-}
-
-#[macro_export] macro_rules! has_clips {
-    (|$self:ident:$Struct:ident$(<$($L:lifetime),*$($T:ident$(:$U:path)?),*>)?|$cb:expr) => {
-        impl $(<$($L),*$($T $(: $U)?),*>)? HasClips for $Struct $(<$($L),*$($T),*>)? {
-            fn clips <'a> (&'a $self) -> std::sync::RwLockReadGuard<'a, ClipPool>      {
-                $cb.read().unwrap()
-            }
-            fn clips_mut <'a> (&'a $self) -> std::sync::RwLockWriteGuard<'a, ClipPool> {
-                $cb.write().unwrap()
-            }
-        }
-    }
-}
-
-pub trait HasEditor {
-    fn editor (&self) -> &Option<MidiEditor>;
-    fn editor_mut (&mut self) -> &Option<MidiEditor>;
-    fn is_editing (&self) -> bool { true }
-    fn editor_w (&self) -> usize { 0 }
-    fn editor_h (&self) -> usize { 0 }
-}
-
-#[macro_export] macro_rules! has_editor {
-    (|$self:ident: $Struct:ident|{
-        editor     = $e0:expr;
-        editor_w   = $e1:expr;
-        editor_h   = $e2:expr;
-        is_editing = $e3:expr;
-    }) => {
-        impl HasEditor for $Struct {
-            fn editor (&$self) -> &Option<MidiEditor> { &$e0 }
-            fn editor_mut (&mut $self) -> &Option<MidiEditor> { &mut $e0 }
-            fn editor_w (&$self) -> usize { $e1 }
-            fn editor_h (&$self) -> usize { $e2 }
-            fn is_editing (&$self) -> bool { $e3 }
-        }
-    };
-    (|$self:ident:$Struct:ident$(<$($L:lifetime),*$($T:ident$(:$U:path)?),*>)?|$cb:expr) => {
-        impl $(<$($L),*$($T $(: $U)?),*>)? HasEditor for $Struct $(<$($L),*$($T),*>)? {
-            fn editor (&$self) -> &MidiEditor { &$cb }
-        }
-    };
-}
-
-/// Contains state for viewing and editing a clip
-pub struct MidiEditor {
-    /// Size of editor on screen
-    pub size: Measure<TuiOut>,
-    /// View mode and state of editor
-    pub mode: PianoHorizontal,
-}
-
-impl std::fmt::Debug for MidiEditor {
-    fn fmt (&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
-        f.debug_struct("MidiEditor")
-            .field("mode", &self.mode)
-            .finish()
-    }
-}
-
-impl Default for MidiEditor {
-    fn default () -> Self {
-        Self {
-            size: Measure::new(),
-            mode: PianoHorizontal::new(None),
-        }
-    }
-}
-
-
-has_size!(<TuiOut>|self: MidiEditor|&self.size);
-
-content!(TuiOut: |self: MidiEditor| {
-    self.autoscroll();
-    //self.autozoom();
-    self.size.of(&self.mode)
-});
-
-from!(|clip: &Arc<RwLock<MidiClip>>|MidiEditor = {
-    let model = Self::from(Some(clip.clone()));
-    model.redraw();
-    model
-});
-
-from!(|clip: Option<Arc<RwLock<MidiClip>>>|MidiEditor = {
-    let mut model = Self::default();
-    *model.clip_mut() = clip;
-    model.redraw();
-    model
-});
-
-impl MidiEditor {
-    /// Put note at current position
-    pub fn put_note (&mut self, advance: bool) {
-        let mut redraw = false;
-        if let Some(clip) = self.clip() {
-            let mut clip   = clip.write().unwrap();
-            let note_start = self.time_pos();
-            let note_pos   = self.note_pos();
-            let note_len   = self.note_len();
-            let note_end   = note_start + (note_len.saturating_sub(1));
-            let key: u7    = u7::from(note_pos as u8);
-            let vel: u7    = 100.into();
-            let length     = clip.length;
-            let note_end   = note_end % length;
-            let note_on = MidiMessage::NoteOn { key, vel };
-            if !clip.notes[note_start].iter().any(|msg|*msg == note_on) {
-                clip.notes[note_start].push(note_on);
-            }
-            let note_off = MidiMessage::NoteOff { key, vel };
-            if !clip.notes[note_end].iter().any(|msg|*msg == note_off) {
-                clip.notes[note_end].push(note_off);
-            }
-            if advance {
-                self.set_time_pos(note_end);
-            }
-            redraw = true;
-        }
-        if redraw {
-            self.mode.redraw();
-        }
-    }
-
-    pub fn clip_status (&self) -> impl Content<TuiOut> + '_ {
-        let (color, name, length, looped) = if let Some(clip) = self.clip().as_ref().map(|p|p.read().unwrap()) {
-            (clip.color, clip.name.clone(), clip.length, clip.looped)
-        } else { (ItemTheme::G[64], String::new().into(), 0, false) };
-        Bsp::e(
-            FieldH(color, "Edit", format!("{name} ({length})")),
-            FieldH(color, "Loop", looped.to_string())
-        )
-    }
-
-    pub fn edit_status (&self) -> impl Content<TuiOut> + '_ {
-        let (color, length) = if let Some(clip) = self.clip().as_ref().map(|p|p.read().unwrap()) {
-            (clip.color, clip.length)
-        } else { (ItemTheme::G[64], 0) };
-        let time_pos  = self.time_pos();
-        let time_zoom = self.time_zoom().get();
-        let time_lock = if self.time_lock().get() { "[lock]" } else { "      " };
-        let note_pos  = format!("{:>3}", self.note_pos());
-        let note_name = format!("{:4}",  Note::pitch_to_name(self.note_pos()));
-        let note_len  = format!("{:>4}", self.note_len());
-        Bsp::e(
-            FieldH(color, "Time", format!("{length}/{time_zoom}+{time_pos} {time_lock}")),
-            FieldH(color, "Note", format!("{note_name} {note_pos} {note_len}")),
-        )
-    }
-}
-
-impl TimeRange for MidiEditor {
-    fn time_len   (&self) -> &AtomicUsize { self.mode.time_len()   }
-    fn time_zoom  (&self) -> &AtomicUsize { self.mode.time_zoom()  }
-    fn time_lock  (&self) -> &AtomicBool  { self.mode.time_lock()  }
-    fn time_start (&self) -> &AtomicUsize { self.mode.time_start() }
-    fn time_axis  (&self) -> &AtomicUsize { self.mode.time_axis()  }
-}
-
-impl NoteRange for MidiEditor {
-    fn note_lo   (&self) -> &AtomicUsize { self.mode.note_lo()   }
-    fn note_axis (&self) -> &AtomicUsize { self.mode.note_axis() }
-}
-
-impl NotePoint for MidiEditor {
-    fn note_len     (&self)           -> usize { self.mode.note_len() }
-    fn set_note_len (&self, x: usize) -> usize { self.mode.set_note_len(x) }
-    fn note_pos     (&self)           -> usize { self.mode.note_pos() }
-    fn set_note_pos (&self, x: usize) -> usize { self.mode.set_note_pos(x) }
-}
-
-impl TimePoint for MidiEditor {
-    fn time_pos     (&self)           -> usize { self.mode.time_pos() }
-    fn set_time_pos (&self, x: usize) -> usize { self.mode.set_time_pos(x) }
-}
-
-impl MidiViewer for MidiEditor {
-    fn buffer_size (&self, clip: &MidiClip) -> (usize, usize) { self.mode.buffer_size(clip) }
-    fn redraw      (&self) { self.mode.redraw() }
-    fn clip        (&self) -> &Option<Arc<RwLock<MidiClip>>> { self.mode.clip() }
-    fn clip_mut    (&mut self) -> &mut Option<Arc<RwLock<MidiClip>>> { self.mode.clip_mut() }
-    fn set_clip    (&mut self, p: Option<&Arc<RwLock<MidiClip>>>) { self.mode.set_clip(p) }
-}

crates/app/src/model/dialog.rs

@@ -0,0 +1,33 @@
+use crate::*;
+
+impl Tek {
+    pub fn toggle_dialog (&mut self, dialog: Option<Dialog>) {
+        self.dialog = if self.dialog == dialog {
+            None
+        } else {
+            dialog
+        }
+    }
+    pub(crate) fn message_dismiss (&mut self) {
+        self.dialog = None;
+    }
+}
+
+/// Various possible dialog overlays
+#[derive(PartialEq, Clone, Copy, Debug)]
+pub enum Dialog {
+    Help,
+    Menu,
+    Device(usize),
+    Message(Message)
+}
+
+/// Various possible messages
+#[derive(PartialEq, Clone, Copy, Debug)]
+pub enum Message {
+    FailedToAddDevice,
+}
+
+content!(TuiOut: |self: Message| match self {
+    Self::FailedToAddDevice => "Failed to add device."
+});

crates/app/src/model/editor.rs

@@ -0,0 +1,170 @@
+use crate::*;
+
+/// Contains state for viewing and editing a clip
+pub struct MidiEditor {
+    /// Size of editor on screen
+    pub size: Measure<TuiOut>,
+    /// View mode and state of editor
+    pub mode: PianoHorizontal,
+}
+
+impl std::fmt::Debug for MidiEditor {
+    fn fmt (&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
+        f.debug_struct("MidiEditor")
+            .field("mode", &self.mode)
+            .finish()
+    }
+}
+
+impl Default for MidiEditor {
+    fn default () -> Self {
+        Self {
+            size: Measure::new(),
+            mode: PianoHorizontal::new(None),
+        }
+    }
+}
+
+
+has_size!(<TuiOut>|self: MidiEditor|&self.size);
+
+content!(TuiOut: |self: MidiEditor| {
+    self.autoscroll();
+    //self.autozoom();
+    self.size.of(&self.mode)
+});
+
+from!(|clip: &Arc<RwLock<MidiClip>>|MidiEditor = {
+    let model = Self::from(Some(clip.clone()));
+    model.redraw();
+    model
+});
+
+from!(|clip: Option<Arc<RwLock<MidiClip>>>|MidiEditor = {
+    let mut model = Self::default();
+    *model.clip_mut() = clip;
+    model.redraw();
+    model
+});
+
+impl MidiEditor {
+    /// Put note at current position
+    pub fn put_note (&mut self, advance: bool) {
+        let mut redraw = false;
+        if let Some(clip) = self.clip() {
+            let mut clip   = clip.write().unwrap();
+            let note_start = self.time_pos();
+            let note_pos   = self.note_pos();
+            let note_len   = self.note_len();
+            let note_end   = note_start + (note_len.saturating_sub(1));
+            let key: u7    = u7::from(note_pos as u8);
+            let vel: u7    = 100.into();
+            let length     = clip.length;
+            let note_end   = note_end % length;
+            let note_on = MidiMessage::NoteOn { key, vel };
+            if !clip.notes[note_start].iter().any(|msg|*msg == note_on) {
+                clip.notes[note_start].push(note_on);
+            }
+            let note_off = MidiMessage::NoteOff { key, vel };
+            if !clip.notes[note_end].iter().any(|msg|*msg == note_off) {
+                clip.notes[note_end].push(note_off);
+            }
+            if advance {
+                self.set_time_pos(note_end);
+            }
+            redraw = true;
+        }
+        if redraw {
+            self.mode.redraw();
+        }
+    }
+
+    pub fn clip_status (&self) -> impl Content<TuiOut> + '_ {
+        let (color, name, length, looped) = if let Some(clip) = self.clip().as_ref().map(|p|p.read().unwrap()) {
+            (clip.color, clip.name.clone(), clip.length, clip.looped)
+        } else { (ItemTheme::G[64], String::new().into(), 0, false) };
+        Bsp::e(
+            FieldH(color, "Edit", format!("{name} ({length})")),
+            FieldH(color, "Loop", looped.to_string())
+        )
+    }
+
+    pub fn edit_status (&self) -> impl Content<TuiOut> + '_ {
+        let (color, length) = if let Some(clip) = self.clip().as_ref().map(|p|p.read().unwrap()) {
+            (clip.color, clip.length)
+        } else { (ItemTheme::G[64], 0) };
+        let time_pos  = self.time_pos();
+        let time_zoom = self.time_zoom().get();
+        let time_lock = if self.time_lock().get() { "[lock]" } else { "      " };
+        let note_pos  = format!("{:>3}", self.note_pos());
+        let note_name = format!("{:4}",  Note::pitch_to_name(self.note_pos()));
+        let note_len  = format!("{:>4}", self.note_len());
+        Bsp::e(
+            FieldH(color, "Time", format!("{length}/{time_zoom}+{time_pos} {time_lock}")),
+            FieldH(color, "Note", format!("{note_name} {note_pos} {note_len}")),
+        )
+    }
+}
+
+impl TimeRange for MidiEditor {
+    fn time_len   (&self) -> &AtomicUsize { self.mode.time_len()   }
+    fn time_zoom  (&self) -> &AtomicUsize { self.mode.time_zoom()  }
+    fn time_lock  (&self) -> &AtomicBool  { self.mode.time_lock()  }
+    fn time_start (&self) -> &AtomicUsize { self.mode.time_start() }
+    fn time_axis  (&self) -> &AtomicUsize { self.mode.time_axis()  }
+}
+
+impl NoteRange for MidiEditor {
+    fn note_lo   (&self) -> &AtomicUsize { self.mode.note_lo()   }
+    fn note_axis (&self) -> &AtomicUsize { self.mode.note_axis() }
+}
+
+impl NotePoint for MidiEditor {
+    fn note_len     (&self)           -> usize { self.mode.note_len() }
+    fn set_note_len (&self, x: usize) -> usize { self.mode.set_note_len(x) }
+    fn note_pos     (&self)           -> usize { self.mode.note_pos() }
+    fn set_note_pos (&self, x: usize) -> usize { self.mode.set_note_pos(x) }
+}
+
+impl TimePoint for MidiEditor {
+    fn time_pos     (&self)           -> usize { self.mode.time_pos() }
+    fn set_time_pos (&self, x: usize) -> usize { self.mode.set_time_pos(x) }
+}
+
+impl MidiViewer for MidiEditor {
+    fn buffer_size (&self, clip: &MidiClip) -> (usize, usize) { self.mode.buffer_size(clip) }
+    fn redraw      (&self) { self.mode.redraw() }
+    fn clip        (&self) -> &Option<Arc<RwLock<MidiClip>>> { self.mode.clip() }
+    fn clip_mut    (&mut self) -> &mut Option<Arc<RwLock<MidiClip>>> { self.mode.clip_mut() }
+    fn set_clip    (&mut self, p: Option<&Arc<RwLock<MidiClip>>>) { self.mode.set_clip(p) }
+}
+
+pub trait HasEditor {
+    fn editor (&self) -> &Option<MidiEditor>;
+    fn editor_mut (&mut self) -> &Option<MidiEditor>;
+    fn is_editing (&self) -> bool { true }
+    fn editor_w (&self) -> usize { 0 }
+    fn editor_h (&self) -> usize { 0 }
+}
+
+#[macro_export] macro_rules! has_editor {
+    (|$self:ident: $Struct:ident|{
+        editor     = $e0:expr;
+        editor_w   = $e1:expr;
+        editor_h   = $e2:expr;
+        is_editing = $e3:expr;
+    }) => {
+        impl HasEditor for $Struct {
+            fn editor (&$self) -> &Option<MidiEditor> { &$e0 }
+            fn editor_mut (&mut $self) -> &Option<MidiEditor> { &mut $e0 }
+            fn editor_w (&$self) -> usize { $e1 }
+            fn editor_h (&$self) -> usize { $e2 }
+            fn is_editing (&$self) -> bool { $e3 }
+        }
+    };
+    (|$self:ident:$Struct:ident$(<$($L:lifetime),*$($T:ident$(:$U:path)?),*>)?|$cb:expr) => {
+        impl $(<$($L),*$($T $(: $U)?),*>)? HasEditor for $Struct $(<$($L),*$($T),*>)? {
+            fn editor (&$self) -> &MidiEditor { &$cb }
+        }
+    };
+}

crates/app/src/model/pool.rs

@@ -0,0 +1,203 @@
+use crate::*;
+
+#[derive(Debug)]
+pub struct MidiPool {
+    pub visible: bool,
+    /// Collection of clips
+    pub clips: Arc<RwLock<Vec<Arc<RwLock<MidiClip>>>>>,
+    /// Selected clip
+    pub clip: AtomicUsize,
+    /// Mode switch
+    pub mode: Option<PoolMode>,
+}
+
+impl Default for MidiPool {
+    fn default () -> Self {
+        use PoolMode::*;
+        Self {
+            visible: true,
+            clips: Arc::from(RwLock::from(vec![])),
+            clip: 0.into(),
+            mode: None,
+        }
+    }
+}
+
+has_clips!(|self: MidiPool|self.clips);
+
+has_clip!(|self: MidiPool|self.clips().get(self.clip_index()).map(|c|c.clone()));
+
+from!(|clip:&Arc<RwLock<MidiClip>>|MidiPool = {
+    let model = Self::default();
+    model.clips.write().unwrap().push(clip.clone());
+    model.clip.store(1, Relaxed);
+    model
+});
+
+impl MidiPool {
+    pub fn clip_index (&self) -> usize {
+        self.clip.load(Relaxed)
+    }
+    pub fn set_clip_index (&self, value: usize) {
+        self.clip.store(value, Relaxed);
+    }
+    pub fn mode (&self) -> &Option<PoolMode> {
+        &self.mode
+    }
+    pub fn mode_mut (&mut self) -> &mut Option<PoolMode> {
+        &mut self.mode
+    }
+    pub fn begin_clip_length (&mut self) {
+        let length = self.clips()[self.clip_index()].read().unwrap().length;
+        *self.mode_mut() = Some(PoolMode::Length(
+            self.clip_index(),
+            length,
+            ClipLengthFocus::Bar
+        ));
+    }
+    pub fn begin_clip_rename (&mut self) {
+        let name = self.clips()[self.clip_index()].read().unwrap().name.clone();
+        *self.mode_mut() = Some(PoolMode::Rename(
+            self.clip_index(),
+            name
+        ));
+    }
+    pub fn begin_import (&mut self) -> Usually<()> {
+        *self.mode_mut() = Some(PoolMode::Import(
+            self.clip_index(),
+            FileBrowser::new(None)?
+        ));
+        Ok(())
+    }
+    pub fn begin_export (&mut self) -> Usually<()> {
+        *self.mode_mut() = Some(PoolMode::Export(
+            self.clip_index(),
+            FileBrowser::new(None)?
+        ));
+        Ok(())
+    }
+    pub fn new_clip (&self) -> MidiClip {
+        MidiClip::new("Clip", true, 4 * PPQ, None, Some(ItemTheme::random()))
+    }
+    pub fn cloned_clip (&self) -> MidiClip {
+        let index    = self.clip_index();
+        let mut clip = self.clips()[index].read().unwrap().duplicate();
+        clip.color   = ItemTheme::random_near(clip.color, 0.25);
+        clip
+    }
+    pub fn add_new_clip (&self) -> (usize, Arc<RwLock<MidiClip>>) {
+        let clip = Arc::new(RwLock::new(self.new_clip()));
+        let index = {
+            let mut clips = self.clips.write().unwrap();
+            clips.push(clip.clone());
+            clips.len().saturating_sub(1)
+        };
+        self.clip.store(index, Relaxed);
+        (index, clip)
+    }
+    pub fn delete_clip (&mut self, clip: &MidiClip) -> bool {
+        let index = self.clips.read().unwrap().iter().position(|x|*x.read().unwrap()==*clip);
+        if let Some(index) = index {
+            self.clips.write().unwrap().remove(index);
+            return true
+        }
+        false
+    }
+}
+
+/// Modes for clip pool
+#[derive(Debug, Clone)]
+pub enum PoolMode {
+    /// Renaming a pattern
+    Rename(usize, Arc<str>),
+    /// Editing the length of a pattern
+    Length(usize, usize, ClipLengthFocus),
+    /// Load clip from disk
+    Import(usize, FileBrowser),
+    /// Save clip to disk
+    Export(usize, FileBrowser),
+}
+
+/// Focused field of `ClipLength`
+#[derive(Copy, Clone, Debug)]
+pub enum ClipLengthFocus {
+    /// Editing the number of bars
+    Bar,
+    /// Editing the number of beats
+    Beat,
+    /// Editing the number of ticks
+    Tick,
+}
+
+impl ClipLengthFocus {
+    pub fn next (&mut self) {
+        use ClipLengthFocus::*;
+        *self = match self { Bar => Beat, Beat => Tick, Tick => Bar, }
+    }
+    pub fn prev (&mut self) {
+        use ClipLengthFocus::*;
+        *self = match self { Bar => Tick, Beat => Bar, Tick => Beat, }
+    }
+}
+
+/// Displays and edits clip length.
+#[derive(Clone)]
+pub struct ClipLength {
+    /// Pulses per beat (quaver)
+    ppq: usize,
+    /// Beats per bar
+    bpb: usize,
+    /// Length of clip in pulses
+    pulses: usize,
+    /// Selected subdivision
+    pub focus: Option<ClipLengthFocus>,
+}
+
+impl ClipLength {
+    pub fn _new (pulses: usize, focus: Option<ClipLengthFocus>) -> Self {
+        Self { ppq: PPQ, bpb: 4, pulses, focus }
+    }
+    pub fn bars  (&self) -> usize {
+        self.pulses / (self.bpb * self.ppq)
+    }
+    pub fn beats (&self) -> usize {
+        (self.pulses % (self.bpb * self.ppq)) / self.ppq
+    }
+    pub fn ticks (&self) -> usize {
+        self.pulses % self.ppq
+    }
+    pub fn bars_string  (&self) -> Arc<str> {
+        format!("{}", self.bars()).into()
+    }
+    pub fn beats_string (&self) -> Arc<str> {
+        format!("{}", self.beats()).into()
+    }
+    pub fn ticks_string (&self) -> Arc<str> {
+        format!("{:>02}", self.ticks()).into()
+    }
+}
+
+pub type ClipPool = Vec<Arc<RwLock<MidiClip>>>;
+
+pub trait HasClips {
+    fn clips <'a> (&'a self) -> std::sync::RwLockReadGuard<'a, ClipPool>;
+    fn clips_mut <'a> (&'a self) -> std::sync::RwLockWriteGuard<'a, ClipPool>;
+    fn add_clip (&self) -> (usize, Arc<RwLock<MidiClip>>) {
+        let clip = Arc::new(RwLock::new(MidiClip::new("Clip", true, 384, None, None)));
+        self.clips_mut().push(clip.clone());
+        (self.clips().len() - 1, clip)
+    }
+}
+
+#[macro_export] macro_rules! has_clips {
+    (|$self:ident:$Struct:ident$(<$($L:lifetime),*$($T:ident$(:$U:path)?),*>)?|$cb:expr) => {
+        impl $(<$($L),*$($T $(: $U)?),*>)? HasClips for $Struct $(<$($L),*$($T),*>)? {
+            fn clips <'a> (&'a $self) -> std::sync::RwLockReadGuard<'a, ClipPool>      {
+                $cb.read().unwrap()
+            }
+            fn clips_mut <'a> (&'a $self) -> std::sync::RwLockWriteGuard<'a, ClipPool> {
+                $cb.write().unwrap()
+            }
+        }
+    }
+}

crates/app/src/model/scene.rs

@@ -0,0 +1,73 @@
+use crate::*;
+
+#[derive(Debug, Default)] pub struct Scene {
+    /// Name of scene
+    pub name:  Arc<str>,
+    /// Clips in scene, one per track
+    pub clips: Vec<Option<Arc<RwLock<MidiClip>>>>,
+    /// Identifying color of scene
+    pub color: ItemTheme,
+}
+
+impl Scene {
+    /// Returns the pulse length of the longest clip in the scene
+    pub fn pulses (&self) -> usize {
+        self.clips.iter().fold(0, |a, p|{
+            a.max(p.as_ref().map(|q|q.read().unwrap().length).unwrap_or(0))
+        })
+    }
+    /// Returns true if all clips in the scene are
+    /// currently playing on the given collection of tracks.
+    pub fn is_playing (&self, tracks: &[Track]) -> bool {
+        self.clips.iter().any(|clip|clip.is_some()) && self.clips.iter().enumerate()
+            .all(|(track_index, clip)|match clip {
+                Some(c) => tracks
+                    .get(track_index)
+                    .map(|track|{
+                        if let Some((_, Some(clip))) = track.player().play_clip() {
+                            *clip.read().unwrap() == *c.read().unwrap()
+                        } else {
+                            false
+                        }
+                    })
+                    .unwrap_or(false),
+                None => true
+            })
+    }
+    pub fn clip (&self, index: usize) -> Option<&Arc<RwLock<MidiClip>>> {
+        match self.clips.get(index) { Some(Some(clip)) => Some(clip), _ => None }
+    }
+}
+
+pub trait HasScenes: HasSelection + HasEditor + Send + Sync {
+    fn scenes (&self) -> &Vec<Scene>;
+    fn scenes_mut (&mut self) -> &mut Vec<Scene>;
+    fn scene_longest (&self) -> usize {
+        self.scenes().iter().map(|s|s.name.len()).fold(0, usize::max)
+    }
+    fn scene (&self) -> Option<&Scene> {
+        self.selected().scene().and_then(|s|self.scenes().get(s))
+    }
+    fn scene_mut (&mut self) -> Option<&mut Scene> {
+        self.selected().scene().and_then(|s|self.scenes_mut().get_mut(s))
+    }
+    fn scene_del (&mut self, index: usize) {
+        self.selected().scene().and_then(|s|Some(self.scenes_mut().remove(index)));
+    }
+    /// Set the color of a scene, returning the previous one.
+    fn scene_set_color (&mut self, index: usize, color: ItemTheme) -> ItemTheme {
+        let scenes = self.scenes_mut();
+        let old = scenes[index].color;
+        scenes[index].color = color;
+        old
+    }
+    /// Generate the default name for a new scene
+    fn scene_default_name (&self) -> Arc<str> {
+        format!("Sc{:3>}", self.scenes().len() + 1).into()
+    }
+}
+
+impl HasScenes for Tek {
+    fn scenes (&self) -> &Vec<Scene> { &self.scenes }
+    fn scenes_mut (&mut self) -> &mut Vec<Scene> { &mut self.scenes }
+}

crates/app/src/model/selection.rs

@@ -0,0 +1,147 @@
+use crate::*;
+
+pub trait HasSelection {
+    fn selected (&self) -> &Selection;
+    fn selected_mut (&mut self) -> &mut Selection;
+}
+
+/// Represents the current user selection in the arranger
+#[derive(PartialEq, Clone, Copy, Debug, Default)]
+pub enum Selection {
+    /// The whole mix is selected
+    #[default] Mix,
+    /// A MIDI input is selected.
+    Input(usize),
+    /// A MIDI output is selected.
+    Output(usize),
+    /// A scene is selected.
+    Scene(usize),
+    /// A track is selected.
+    Track(usize),
+    /// A clip (track × scene) is selected.
+    TrackClip   { track: usize, scene:  usize },
+    /// A track's MIDI input connection is selected.
+    TrackInput  { track: usize, port:   usize },
+    /// A track's MIDI output connection is selected.
+    TrackOutput { track: usize, port:   usize },
+    /// A track device slot is selected.
+    TrackDevice { track: usize, device: usize },
+}
+
+/// Focus identification methods
+impl Selection {
+    pub fn is_mix (&self) -> bool {
+        matches!(self, Self::Mix)
+    }
+    pub fn is_track (&self) -> bool {
+        matches!(self, Self::Track(_))
+    }
+    pub fn is_scene (&self) -> bool {
+        matches!(self, Self::Scene(_))
+    }
+    pub fn is_clip (&self) -> bool {
+        matches!(self, Self::TrackClip {..})
+    }
+    pub fn track (&self) -> Option<usize> {
+        use Selection::*;
+        match self {
+            Track(track)
+            | TrackClip   { track, .. }
+            | TrackInput  { track, .. }
+            | TrackOutput { track, .. }
+            | TrackDevice { track, .. } => Some(*track),
+            _ => None
+        }
+    }
+    pub fn track_next (&self, len: usize) -> Self {
+        use Selection::*;
+        match self {
+            Mix => Track(0),
+            Scene(s) => TrackClip { track: 0, scene: *s },
+            Track(t) => if t + 1 < len {
+                Track(t + 1)
+            } else {
+                Mix
+            },
+            TrackClip {track, scene} => if track + 1 < len {
+                TrackClip { track: track + 1, scene: *scene }
+            } else {
+                Scene(*scene)
+            },
+            _ => todo!()
+        }
+    }
+    pub fn track_prev (&self) -> Self {
+        use Selection::*;
+        match self {
+            Mix => Mix,
+            Scene(s) => Scene(*s),
+            Track(0) => Mix,
+            Track(t) => Track(t - 1),
+            TrackClip { track: 0, scene } => Scene(*scene),
+            TrackClip { track: t, scene } => TrackClip { track: t - 1, scene: *scene },
+            _ => todo!()
+        }
+    }
+    pub fn scene (&self) -> Option<usize> {
+        use Selection::*;
+        match self {
+            Scene(scene) | TrackClip { scene, .. } => Some(*scene),
+            _ => None
+        }
+    }
+    pub fn scene_next (&self, len: usize) -> Self {
+        use Selection::*;
+        match self {
+            Mix => Scene(0),
+            Track(t) => TrackClip { track: *t, scene: 0 },
+            Scene(s) => if s + 1 < len {
+                Scene(s + 1)
+            } else {
+                Mix
+            },
+            TrackClip { track, scene } => if scene + 1 < len {
+                TrackClip { track: *track, scene: scene + 1 }
+            } else {
+                Track(*track)
+            },
+            _ => todo!()
+        }
+    }
+    pub fn scene_prev (&self) -> Self {
+        use Selection::*;
+        match self {
+            Mix | Scene(0) => Mix,
+            Scene(s) => Scene(s - 1),
+            Track(t) => Track(*t),
+            TrackClip { track, scene: 0 } => Track(*track),
+            TrackClip { track, scene } => TrackClip { track: *track, scene: scene - 1 },
+            _ => todo!()
+        }
+    }
+    pub fn describe (&self, tracks: &[Track], scenes: &[Scene]) -> Arc<str> {
+        use Selection::*;
+        format!("{}", match self {
+            Mix => "Everything".to_string(),
+            Scene(s) => scenes.get(*s)
+                .map(|scene|format!("S{s}: {}", &scene.name))
+                .unwrap_or_else(||"S??".into()),
+            Track(t) => tracks.get(*t)
+                .map(|track|format!("T{t}: {}", &track.name))
+                .unwrap_or_else(||"T??".into()),
+            TrackClip { track, scene } => match (tracks.get(*track), scenes.get(*scene)) {
+                (Some(_), Some(s)) => match s.clip(*track) {
+                    Some(clip) => format!("T{track} S{scene} C{}", &clip.read().unwrap().name),
+                    None       => format!("T{track} S{scene}: Empty")
+                },
+                _ => format!("T{track} S{scene}: Empty"),
+            },
+            _ => todo!()
+        }).into()
+    }
+}
+
+impl HasSelection for Tek {
+    fn selected (&self) -> &Selection { &self.selected }
+    fn selected_mut (&mut self) -> &mut Selection { &mut self.selected }
+}

crates/app/src/model/track.rs

@@ -0,0 +1,150 @@
+use crate::*;
+
+#[derive(Debug, Default)] pub struct Track {
+    /// Name of track
+    pub name:       Arc<str>,
+    /// Preferred width of track column
+    pub width:      usize,
+    /// Identifying color of track
+    pub color:      ItemTheme,
+    /// MIDI player state
+    pub player:     MidiPlayer,
+    /// Device chain
+    pub devices:    Vec<Device>,
+    /// Inputs of 1st device
+    pub audio_ins:  Vec<JackAudioIn>,
+    /// Outputs of last device
+    pub audio_outs: Vec<JackAudioOut>,
+}
+
+has_clock!(|self: Track|self.player.clock);
+
+has_player!(|self: Track|self.player);
+
+impl Track {
+    pub const MIN_WIDTH: usize = 9;
+    /// Create a new track containing a sequencer.
+    pub fn new_sequencer () -> Self {
+        let mut track = Self::default();
+        track.devices.push(Device::Sequencer(MidiPlayer::default()));
+        track
+    }
+    /// Create a new track containing a sequencer and sampler.
+    pub fn new_groovebox (
+        jack:       &Jack,
+        midi_from:  &[PortConnect],
+        audio_from: &[&[PortConnect];2],
+        audio_to:   &[&[PortConnect];2],
+    ) -> Usually<Self> {
+        let mut track = Self::new_sequencer();
+        track.devices.push(Device::Sampler(
+            Sampler::new(jack, &"sampler", midi_from, audio_from, audio_to)?
+        ));
+        Ok(track)
+    }
+    /// Create a new track containing a sampler.
+    pub fn new_sampler (
+        jack:       &Jack,
+        midi_from:  &[PortConnect],
+        audio_from: &[&[PortConnect];2],
+        audio_to:   &[&[PortConnect];2],
+    ) -> Usually<Self> {
+        let mut track = Self::default();
+        track.devices.push(Device::Sampler(
+            Sampler::new(jack, &"sampler", midi_from, audio_from, audio_to)?
+        ));
+        Ok(track)
+    }
+    pub fn width_inc (&mut self) {
+        self.width += 1;
+    }
+    pub fn width_dec (&mut self) {
+        if self.width > Track::MIN_WIDTH {
+            self.width -= 1;
+        }
+    }
+    pub fn sequencer (&self, mut nth: usize) -> Option<&MidiPlayer> {
+        for device in self.devices.iter() {
+            match device {
+                Device::Sequencer(s) => if nth == 0 {
+                    return Some(s);
+                } else {
+                    nth -= 1;
+                },
+                _ => {}
+            }
+        }
+        None
+    }
+    pub fn sampler (&self, mut nth: usize) -> Option<&Sampler> {
+        for device in self.devices.iter() {
+            match device {
+                Device::Sampler(s) => if nth == 0 {
+                    return Some(s);
+                } else {
+                    nth -= 1;
+                },
+                _ => {}
+            }
+        }
+        None
+    }
+    pub fn sampler_mut (&mut self, mut nth: usize) -> Option<&mut Sampler> {
+        for device in self.devices.iter_mut() {
+            match device {
+                Device::Sampler(s) => if nth == 0 {
+                    return Some(s);
+                } else {
+                    nth -= 1;
+                },
+                _ => {}
+            }
+        }
+        None
+    }
+}
+
+pub trait HasTracks: HasSelection + HasClock + HasJack + HasEditor + Send + Sync {
+    fn midi_ins (&self) -> &Vec<JackMidiIn>;
+    fn midi_outs (&self) -> &Vec<JackMidiOut>;
+    fn tracks (&self) -> &Vec<Track>;
+    fn tracks_mut (&mut self) -> &mut Vec<Track>;
+    fn track_longest (&self) -> usize {
+        self.tracks().iter().map(|s|s.name.len()).fold(0, usize::max)
+    }
+    const WIDTH_OFFSET: usize = 1;
+    fn track (&self) -> Option<&Track> {
+        self.selected().track().and_then(|s|self.tracks().get(s))
+    }
+    fn track_mut (&mut self) -> Option<&mut Track> {
+        self.selected().track().and_then(|s|self.tracks_mut().get_mut(s))
+    }
+    /// Set the color of a track
+    fn track_set_color (&mut self, index: usize, color: ItemTheme) -> ItemTheme {
+        let tracks = self.tracks_mut();
+        let old = tracks[index].color;
+        tracks[index].color = color;
+        old
+    }
+    /// Toggle track recording
+    fn track_toggle_record (&mut self) {
+        if let Some(t) = self.selected().track() {
+            let tracks = self.tracks_mut();
+            tracks[t-1].player.recording = !tracks[t-1].player.recording;
+        }
+    }
+    /// Toggle track monitoring
+    fn track_toggle_monitor (&mut self) {
+        if let Some(t) = self.selected().track() {
+            let tracks = self.tracks_mut();
+            tracks[t-1].player.monitoring = !tracks[t-1].player.monitoring;
+        }
+    }
+}
+
+impl HasTracks for Tek {
+    fn midi_ins (&self) -> &Vec<JackMidiIn> { &self.midi_ins }
+    fn midi_outs (&self) -> &Vec<JackMidiOut> { &self.midi_outs }
+    fn tracks (&self) -> &Vec<Track> { &self.tracks }
+    fn tracks_mut (&mut self) -> &mut Vec<Track> { &mut self.tracks }
+}

crates/app/src/view.rs

@@ -60,29 +60,30 @@ impl Tek {
         self.sampler().map(|s|s.view_sample(self.editor().unwrap().note_pos()))
     }
 
-    #[tengri::view(":modal")]
-    fn view_modal (&self) -> impl Content<TuiOut> + use<'_> {
-        When::new(self.modal.is_some(), Bsp::b(
+    #[tengri::view(":dialog")]
+    fn view_dialog (&self) -> impl Content<TuiOut> + use<'_> {
+        When::new(self.dialog.is_some(), Bsp::b(
             Fill::xy(Tui::fg_bg(Rgb(64,64,64), Rgb(32,32,32), "")),
             Fixed::xy(30, 15, Tui::fg_bg(Rgb(255,255,255), Rgb(16,16,16), Bsp::b(
                 Repeat(" "),
                 Outer(true, Style::default().fg(Tui::g(96)))
-                    .enclose(self.modal.map(|modal|match modal {
-                        Modal::Menu => self.view_modal_menu().boxed(),
-                        Modal::Help => self.view_modal_help().boxed(),
-                        Modal::Device(index) => self.view_modal_device(index).boxed(),
+                    .enclose(self.dialog.as_ref().map(|dialog|match dialog {
+                        Dialog::Menu => self.view_dialog_menu().boxed(),
+                        Dialog::Help => self.view_dialog_help().boxed(),
+                        Dialog::Device(index) => self.view_dialog_device(*index).boxed(),
+                        Dialog::Message(message) => self.view_dialog_message(message).boxed(),
                     }))
             )))
         ))
     }
 
-    fn view_modal_menu (&self) -> impl Content<TuiOut> {
+    fn view_dialog_menu (&self) -> impl Content<TuiOut> {
         let options = ||["Projects", "Settings", "Help", "Quit"].iter();
         let option  = |a,i|Tui::fg(Rgb(255,255,255), format!("{}", a));
         Bsp::s(Tui::bold(true, "tek!"), Bsp::s("", Map::south(1, options, option)))
     }
 
-    fn view_modal_help (&self) -> impl Content<TuiOut> + use<'_> {
+    fn view_dialog_help (&self) -> impl Content<TuiOut> + use<'_> {
         let bindings = ||self.config.keys.layers.iter()
             .filter_map(|a|(a.0)(self).then_some(a.1))
             .flat_map(|a|a)
@@ -110,7 +111,7 @@ impl Tek {
         Bsp::s(Tui::bold(true, "Help"), Bsp::s("",  Map::south(1, bindings, binding)))
     }
 
-    fn view_modal_device (&self, index: usize) -> impl Content<TuiOut> + use<'_> {
+    fn view_dialog_device (&self, index: usize) -> impl Content<TuiOut> + use<'_> {
         let choices = ||self.device_kinds().iter();
         let choice = move|label, i|
             Fill::x(Tui::bg(if i == index { Rgb(64,128,32) } else { Rgb(0,0,0) },
@@ -120,6 +121,10 @@ impl Tek {
         Bsp::s(Tui::bold(true, "Add device"), Map::south(1, choices, choice))
     }
 
+    fn view_dialog_message <'a> (&'a self, message: &'a Message) -> impl Content<TuiOut> + use<'a> {
+        Bsp::s(message, Bsp::s("", "[ OK ]"))
+    }
+
     /// Spacing between tracks.
     pub(crate) const TRACK_SPACING: usize = 0;
 
@@ -361,14 +366,13 @@ impl<'a> ArrangerView<'a> {
             .right(*width_side, button_2("Z", "add device", *is_editing))
             .middle(*width_mid, per_track_top(*width_mid, ||self.tracks_with_sizes_scrolled(),
                 move|index, track|{
-                    wrap(if *track_selected == Some(index) {
+                    let bg = if *track_selected == Some(index) {
                         track.color.light
                     } else {
                         track.color.base
-                    }.rgb, Tui::g(224), Tui::bold(true, Fill::x(Bsp::e(
-                        Tui::fg_bg(Reset, Reset, "[    "),
-                        Tui::fg_bg(Reset, Reset, "    ]"),
-                    ))))
+                    };
+                    let fg = Tui::g(224);
+                    track.devices.get(0).map(|device|wrap(bg.rgb, fg, device.name()))
                 }))
     }
 

crates/device/Cargo.toml

@@ -10,14 +10,14 @@ uuid       = { workspace = true, optional = true }
 livi       = { workspace = true, optional = true }
 symphonia  = { workspace = true, optional = true }
 wavers     = { workspace = true, optional = true }
+winit      = { workspace = true, optional = true }
 
 [features]
-default   = [ "clock", "sequencer", "sampler" ]
+default   = [ "clock", "sequencer", "sampler", "lv2" ]
 clock     = []
 sampler   = [ "symphonia", "wavers" ]
 sequencer = [ "clock", "uuid" ]
-plugin    = [] # temporary
-lv2       = [ "livi" ]
+lv2       = [ "livi", "winit" ]
 vst2      = []
 vst3      = []
 clap      = []

crates/device/src/lib.rs

@@ -24,8 +24,20 @@ pub(crate) use ratatui::{prelude::Rect, widgets::{Widget, canvas::{Canvas, Line}
 #[cfg(feature = "sampler")] mod sampler;
 #[cfg(feature = "sampler")] pub use self::sampler::*;
 
-#[cfg(feature = "plugin")] mod plugin;
-#[cfg(feature = "plugin")] pub use self::plugin::*;
+#[cfg(feature = "lv2")] mod lv2;
+#[cfg(feature = "lv2")] pub use self::lv2::*;
+
+#[cfg(feature = "sf2")] mod sf2;
+#[cfg(feature = "sf2")] pub use self::sf2::*;
+
+#[cfg(feature = "vst2")] mod vst2;
+#[cfg(feature = "vst2")] pub use self::vst2::*;
+
+#[cfg(feature = "vst3")] mod vst3;
+#[cfg(feature = "vst3")] pub use self::vst3::*;
+
+#[cfg(feature = "clap")] mod clap;
+#[cfg(feature = "clap")] pub use self::clap::*;
 
 #[derive(Debug)]
 pub enum Device {
@@ -38,3 +50,12 @@ pub enum Device {
     #[cfg(feature = "clap")]      Clap, // TODO
     #[cfg(feature = "sf2")]       Sf2,  // TODO
 }
+
+impl Device {
+    pub fn name (&self) -> &str {
+        match self {
+            Self::Sampler(sampler) => sampler.name.as_ref(),
+            _ => todo!(),
+        }
+    }
+}

crates/device/src/lv2.rs

@@ -0,0 +1,16 @@
+mod lv2_model; pub use self::lv2_model::*;
+mod lv2_audio; pub use self::lv2_audio::*;
+mod lv2_gui; pub use self::lv2_gui::*;
+mod lv2_tui; pub use self::lv2_tui::*;
+
+pub(self) use std::thread::JoinHandle;
+
+pub(self) use ::livi::{
+    World,
+    Instance,
+    Plugin as LiviPlugin,
+    Features,
+    FeaturesBuilder,
+    Port as LiviPort,
+    event::LV2AtomSequence,
+};

crates/device/src/lv2/lv2_audio.rs

@@ -0,0 +1,50 @@
+use crate::*;
+use super::*;
+
+audio!(|self: Lv2, _client, scope|{
+    let Self {
+        midi_ins,
+        midi_outs,
+        audio_ins,
+        audio_outs,
+        lv2_features,
+        ref mut lv2_instance,
+        ref mut lv2_input_buffer,
+        ..
+    } = self;
+    let urid = lv2_features.midi_urid();
+    lv2_input_buffer.clear();
+    for port in midi_ins.iter() {
+        let mut atom = ::livi::event::LV2AtomSequence::new(
+            &lv2_features,
+            scope.n_frames() as usize
+        );
+        for event in port.iter(scope) {
+            match event.bytes.len() {
+                3 => atom.push_midi_event::<3>(
+                    event.time as i64,
+                    urid,
+                    &event.bytes[0..3]
+                ).unwrap(),
+                _ => {}
+            }
+        }
+        lv2_input_buffer.push(atom);
+    }
+    let mut outputs = vec![];
+    for _ in midi_outs.iter() {
+        outputs.push(::livi::event::LV2AtomSequence::new(
+            lv2_features,
+            scope.n_frames() as usize
+        ));
+    }
+    let ports = ::livi::EmptyPortConnections::new()
+        .with_atom_sequence_inputs(lv2_input_buffer.iter())
+        .with_atom_sequence_outputs(outputs.iter_mut())
+        .with_audio_inputs(audio_ins.iter().map(|o|o.as_slice(scope)))
+        .with_audio_outputs(audio_outs.iter_mut().map(|o|o.as_mut_slice(scope)));
+    unsafe {
+        lv2_instance.run(scope.n_frames() as usize, ports).unwrap()
+    };
+    Control::Continue
+});

crates/device/src/lv2/lv2_gui.rs

@@ -56,4 +56,3 @@ impl ApplicationHandler for LV2PluginUI {
 fn lv2_ui_instantiate (kind: &str) {
     //let host = Suil
 }
-

crates/device/src/lv2/lv2_model.rs

@@ -0,0 +1,86 @@
+use crate::*;
+use super::*;
+
+/// A LV2 plugin.
+#[derive(Debug)]
+pub struct Lv2 {
+    /// JACK client handle (needs to not be dropped for standalone mode to work).
+    pub jack:       Jack,
+    pub name:       Arc<str>,
+    pub path:       Option<Arc<str>>,
+    pub selected:   usize,
+    pub mapping:    bool,
+    pub midi_ins:   Vec<Port<MidiIn>>,
+    pub midi_outs:  Vec<Port<MidiOut>>,
+    pub audio_ins:  Vec<Port<AudioIn>>,
+    pub audio_outs: Vec<Port<AudioOut>>,
+
+    pub lv2_world:        livi::World,
+    pub lv2_instance:     livi::Instance,
+    pub lv2_plugin:       livi::Plugin,
+    pub lv2_features:     Arc<livi::Features>,
+    pub lv2_port_list:    Vec<livi::Port>,
+    pub lv2_input_buffer: Vec<livi::event::LV2AtomSequence>,
+    pub lv2_ui_thread:    Option<JoinHandle<()>>,
+}
+
+impl Lv2 {
+
+    pub fn new (
+        jack: &Jack,
+        name: &str,
+        uri:  &str,
+    ) -> Usually<Self> {
+        let lv2_world = livi::World::with_load_bundle(&uri);
+        let lv2_features = lv2_world.build_features(livi::FeaturesBuilder {
+            min_block_length: 1,
+            max_block_length: 65536,
+        });
+        let lv2_plugin = lv2_world.iter_plugins().nth(0)
+            .unwrap_or_else(||panic!("plugin not found: {uri}"));
+        Ok(Self {
+            jack:       jack.clone(),
+            name:       name.into(),
+            path:       Some(String::from(uri).into()),
+            selected:   0,
+            mapping:    false,
+            midi_ins:   vec![],
+            midi_outs:  vec![],
+            audio_ins:  vec![],
+            audio_outs: vec![],
+            lv2_instance: unsafe {
+                lv2_plugin
+                    .instantiate(lv2_features.clone(), 48000.0)
+                    .expect(&format!("instantiate failed: {uri}"))
+            },
+            lv2_port_list: lv2_plugin.ports().collect::<Vec<_>>(),
+            lv2_input_buffer: Vec::with_capacity(Self::INPUT_BUFFER),
+            lv2_ui_thread: None,
+            lv2_world,
+            lv2_features,
+            lv2_plugin,
+        })
+    }
+
+    const INPUT_BUFFER: usize = 1024;
+
+}
+
+
+    //fn jack_from_lv2 (name: &str, plugin: &::livi::Plugin) -> Usually<Jack> {
+        //let counts = plugin.port_counts();
+        //let mut jack = Jack::new(name)?;
+        //for i in 0..counts.atom_sequence_inputs {
+            //jack = jack.midi_in(&format!("midi-in-{i}"))
+        //}
+        //for i in 0..counts.atom_sequence_outputs {
+            //jack = jack.midi_out(&format!("midi-out-{i}"));
+        //}
+        //for i in 0..counts.audio_inputs {
+            //jack = jack.audio_in(&format!("audio-in-{i}"));
+        //}
+        //for i in 0..counts.audio_outputs {
+            //jack = jack.audio_out(&format!("audio-out-{i}"));
+        //}
+        //Ok(jack)
+    //}

crates/device/src/lv2/lv2_tui.rs

@@ -0,0 +1,124 @@
+use crate::*;
+use super::*;
+
+impl Content<TuiOut> for Lv2 {
+    fn render (&self, to: &mut TuiOut) {
+        let area = to.area();
+        let [x, y, _, height] = area;
+        let mut width = 20u16;
+        let start = self.selected.saturating_sub((height as usize / 2).saturating_sub(1));
+        let end   = start + height as usize - 2;
+        //draw_box(buf, Rect { x, y, width, height });
+        for i in start..end {
+            if let Some(port) = self.lv2_port_list.get(i) {
+                let value = if let Some(value) = self.lv2_instance.control_input(port.index) {
+                    value
+                } else {
+                    port.default_value
+                };
+                //let label = &format!("C·· M·· {:25} = {value:.03}", port.name);
+                let label = &format!("{:25} = {value:.03}", port.name);
+                width = width.max(label.len() as u16 + 4);
+                let style = if i == self.selected {
+                    Some(Style::default().green())
+                } else {
+                    None
+                } ;
+                to.blit(&label, x + 2, y + 1 + i as u16 - start as u16, style);
+            } else {
+                break
+            }
+        }
+        draw_header(self, to, x, y, width);
+    }
+}
+
+fn draw_header (state: &Lv2, to: &mut TuiOut, x: u16, y: u16, w: u16) {
+    let style  = Style::default().gray();
+    let label1 = format!(" {}", state.name);
+    to.blit(&label1, x + 1, y, Some(style.white().bold()));
+    if let Some(ref path) = state.path {
+        let label2 = format!("{}…", &path[..((w as usize - 10).min(path.len()))]);
+        to.blit(&label2, x + 2 + label1.len() as u16, y, Some(style.not_dim()));
+    }
+    //Ok(Rect { x, y, width: w, height: 1 })
+}
+
+//handle!(TuiIn: |self:Plugin, from|{
+    //match from.event() {
+        //kpat!(KeyCode::Up) => {
+            //self.selected = self.selected.saturating_sub(1);
+            //Ok(Some(true))
+        //},
+        //kpat!(KeyCode::Down) => {
+            //self.selected = (self.selected + 1).min(match &self.plugin {
+                //Some(PluginKind::LV2(LV2Plugin { port_list, .. })) => port_list.len() - 1,
+                //_ => unimplemented!()
+            //});
+            //Ok(Some(true))
+        //},
+        //kpat!(KeyCode::PageUp) => {
+            //self.selected = self.selected.saturating_sub(8);
+            //Ok(Some(true))
+        //},
+        //kpat!(KeyCode::PageDown) => {
+            //self.selected = (self.selected + 10).min(match &self.plugin {
+                //Some(PluginKind::LV2(LV2Plugin { port_list, .. })) => port_list.len() - 1,
+                //_ => unimplemented!()
+            //});
+            //Ok(Some(true))
+        //},
+        //kpat!(KeyCode::Char(',')) => {
+            //match self.plugin.as_mut() {
+                //Some(PluginKind::LV2(LV2Plugin { port_list, ref mut instance, .. })) => {
+                    //let index = port_list[self.selected].index;
+                    //if let Some(value) = instance.control_input(index) {
+                        //instance.set_control_input(index, value - 0.01);
+                    //}
+                //},
+                //_ => {}
+            //}
+            //Ok(Some(true))
+        //},
+        //kpat!(KeyCode::Char('.')) => {
+            //match self.plugin.as_mut() {
+                //Some(PluginKind::LV2(LV2Plugin { port_list, ref mut instance, .. })) => {
+                    //let index = port_list[self.selected].index;
+                    //if let Some(value) = instance.control_input(index) {
+                        //instance.set_control_input(index, value + 0.01);
+                    //}
+                //},
+                //_ => {}
+            //}
+            //Ok(Some(true))
+        //},
+        //kpat!(KeyCode::Char('g')) => {
+            //match self.plugin {
+                ////Some(PluginKind::LV2(ref mut plugin)) => {
+                    ////plugin.ui_thread = Some(run_lv2_ui(LV2PluginUI::new()?)?);
+                ////},
+                //Some(_) => unreachable!(),
+                //None => {}
+            //}
+            //Ok(Some(true))
+        //},
+        //_ => Ok(None)
+    //}
+//});
+
+//from_atom!("plugin/lv2" => |jack: &Jack, args| -> Plugin {
+    //let mut name = String::new();
+    //let mut path = String::new();
+    //atom!(atom in args {
+        //Atom::Map(map) => {
+            //if let Some(Atom::Str(n)) = map.get(&Atom::Key(":name")) {
+                //name = String::from(*n);
+            //}
+            //if let Some(Atom::Str(p)) = map.get(&Atom::Key(":path")) {
+                //path = String::from(*p);
+            //}
+        //},
+        //_ => panic!("unexpected in lv2 '{name}'"),
+    //});
+    //Plugin::new_lv2(jack, &name, &path)
+//});

crates/device/src/plugin.rs

@@ -1,281 +0,0 @@
-use crate::*;
-
-mod lv2;
-mod lv2_gui;
-mod lv2_tui;
-mod vst2_tui;
-mod vst3_tui;
-
-/// A plugin device.
-#[derive(Debug)]
-pub struct Plugin {
-    /// JACK client handle (needs to not be dropped for standalone mode to work).
-    pub jack:       Jack,
-    pub name:       Arc<str>,
-    pub path:       Option<Arc<str>>,
-    pub plugin:     Option<PluginKind>,
-    pub selected:   usize,
-    pub mapping:    bool,
-    pub midi_ins:   Vec<Port<MidiIn>>,
-    pub midi_outs:  Vec<Port<MidiOut>>,
-    pub audio_ins:  Vec<Port<AudioIn>>,
-    pub audio_outs: Vec<Port<AudioOut>>,
-}
-
-/// Supported plugin formats.
-#[derive(Default)]
-pub enum PluginKind {
-    #[default] None,
-    LV2(LV2Plugin),
-    VST2 { instance: () /*::vst::host::PluginInstance*/ },
-    VST3,
-}
-
-impl Debug for PluginKind {
-    fn fmt (&self, f: &mut Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
-        write!(f, "{}", match self {
-            Self::None     => "(none)",
-            Self::LV2(_)   => "LV2",
-            Self::VST2{..} => "VST2",
-            Self::VST3     => "VST3",
-        })
-    }
-}
-impl Plugin {
-    pub fn new_lv2 (
-        jack: &Jack,
-        name: &str,
-        path: &str,
-    ) -> Usually<Self> {
-        Ok(Self {
-            jack:       jack.clone(),
-            name:       name.into(),
-            path:       Some(String::from(path).into()),
-            plugin:     Some(PluginKind::LV2(LV2Plugin::new(path)?)),
-            selected:   0,
-            mapping:    false,
-            midi_ins:   vec![],
-            midi_outs:  vec![],
-            audio_ins:  vec![],
-            audio_outs: vec![],
-        })
-    }
-}
-
-pub struct PluginAudio(Arc<RwLock<Plugin>>);
-from!(|model: &Arc<RwLock<Plugin>>| PluginAudio = Self(model.clone()));
-audio!(|self: PluginAudio, _client, scope|{
-    let state = &mut*self.0.write().unwrap();
-    match state.plugin.as_mut() {
-        Some(PluginKind::LV2(LV2Plugin {
-            features,
-            ref mut instance,
-            ref mut input_buffer,
-            ..
-        })) => {
-            let urid = features.midi_urid();
-            input_buffer.clear();
-            for port in state.midi_ins.iter() {
-                let mut atom = ::livi::event::LV2AtomSequence::new(
-                    &features,
-                    scope.n_frames() as usize
-                );
-                for event in port.iter(scope) {
-                    match event.bytes.len() {
-                        3 => atom.push_midi_event::<3>(
-                            event.time as i64,
-                            urid,
-                            &event.bytes[0..3]
-                        ).unwrap(),
-                        _ => {}
-                    }
-                }
-                input_buffer.push(atom);
-            }
-            let mut outputs = vec![];
-            for _ in state.midi_outs.iter() {
-                outputs.push(::livi::event::LV2AtomSequence::new(
-                    features,
-                    scope.n_frames() as usize
-                ));
-            }
-            let ports = ::livi::EmptyPortConnections::new()
-                .with_atom_sequence_inputs(input_buffer.iter())
-                .with_atom_sequence_outputs(outputs.iter_mut())
-                .with_audio_inputs(state.audio_ins.iter().map(|o|o.as_slice(scope)))
-                .with_audio_outputs(state.audio_outs.iter_mut().map(|o|o.as_mut_slice(scope)));
-            unsafe {
-                instance.run(scope.n_frames() as usize, ports).unwrap()
-            };
-        },
-        _ => todo!("only lv2 is supported")
-    }
-    Control::Continue
-});
-
-    //fn jack_from_lv2 (name: &str, plugin: &::livi::Plugin) -> Usually<Jack> {
-        //let counts = plugin.port_counts();
-        //let mut jack = Jack::new(name)?;
-        //for i in 0..counts.atom_sequence_inputs {
-            //jack = jack.midi_in(&format!("midi-in-{i}"))
-        //}
-        //for i in 0..counts.atom_sequence_outputs {
-            //jack = jack.midi_out(&format!("midi-out-{i}"));
-        //}
-        //for i in 0..counts.audio_inputs {
-            //jack = jack.audio_in(&format!("audio-in-{i}"));
-        //}
-        //for i in 0..counts.audio_outputs {
-            //jack = jack.audio_out(&format!("audio-out-{i}"));
-        //}
-        //Ok(jack)
-    //}
-
-impl Plugin {
-    /// Create a plugin host device.
-    pub fn new (
-        jack: &Jack,
-        name: &str,
-    ) -> Usually<Self> {
-        Ok(Self {
-            //_engine:    Default::default(),
-            jack:       jack.clone(),
-            name:       name.into(),
-            path:       None,
-            plugin:     None,
-            selected:   0,
-            mapping:    false,
-            audio_ins:  vec![],
-            audio_outs: vec![],
-            midi_ins:   vec![],
-            midi_outs:  vec![],
-            //ports:      JackPorts::default()
-        })
-    }
-}
-impl Content<TuiOut> for Plugin {
-    fn render (&self, to: &mut TuiOut) {
-        let area = to.area();
-        let [x, y, _, height] = area;
-        let mut width = 20u16;
-        match &self.plugin {
-            Some(PluginKind::LV2(LV2Plugin { port_list, instance, .. })) => {
-                let start = self.selected.saturating_sub((height as usize / 2).saturating_sub(1));
-                let end   = start + height as usize - 2;
-                //draw_box(buf, Rect { x, y, width, height });
-                for i in start..end {
-                    if let Some(port) = port_list.get(i) {
-                        let value = if let Some(value) = instance.control_input(port.index) {
-                            value
-                        } else {
-                            port.default_value
-                        };
-                        //let label = &format!("C·· M·· {:25} = {value:.03}", port.name);
-                        let label = &format!("{:25} = {value:.03}", port.name);
-                        width = width.max(label.len() as u16 + 4);
-                        let style = if i == self.selected {
-                            Some(Style::default().green())
-                        } else {
-                            None
-                        } ;
-                        to.blit(&label, x + 2, y + 1 + i as u16 - start as u16, style);
-                    } else {
-                        break
-                    }
-                }
-            },
-            _ => {}
-        };
-        draw_header(self, to, x, y, width);
-    }
-}
-
-fn draw_header (state: &Plugin, to: &mut TuiOut, x: u16, y: u16, w: u16) {
-    let style  = Style::default().gray();
-    let label1 = format!(" {}", state.name);
-    to.blit(&label1, x + 1, y, Some(style.white().bold()));
-    if let Some(ref path) = state.path {
-        let label2 = format!("{}…", &path[..((w as usize - 10).min(path.len()))]);
-        to.blit(&label2, x + 2 + label1.len() as u16, y, Some(style.not_dim()));
-    }
-    //Ok(Rect { x, y, width: w, height: 1 })
-}
-
-//handle!(TuiIn: |self:Plugin, from|{
-    //match from.event() {
-        //kpat!(KeyCode::Up) => {
-            //self.selected = self.selected.saturating_sub(1);
-            //Ok(Some(true))
-        //},
-        //kpat!(KeyCode::Down) => {
-            //self.selected = (self.selected + 1).min(match &self.plugin {
-                //Some(PluginKind::LV2(LV2Plugin { port_list, .. })) => port_list.len() - 1,
-                //_ => unimplemented!()
-            //});
-            //Ok(Some(true))
-        //},
-        //kpat!(KeyCode::PageUp) => {
-            //self.selected = self.selected.saturating_sub(8);
-            //Ok(Some(true))
-        //},
-        //kpat!(KeyCode::PageDown) => {
-            //self.selected = (self.selected + 10).min(match &self.plugin {
-                //Some(PluginKind::LV2(LV2Plugin { port_list, .. })) => port_list.len() - 1,
-                //_ => unimplemented!()
-            //});
-            //Ok(Some(true))
-        //},
-        //kpat!(KeyCode::Char(',')) => {
-            //match self.plugin.as_mut() {
-                //Some(PluginKind::LV2(LV2Plugin { port_list, ref mut instance, .. })) => {
-                    //let index = port_list[self.selected].index;
-                    //if let Some(value) = instance.control_input(index) {
-                        //instance.set_control_input(index, value - 0.01);
-                    //}
-                //},
-                //_ => {}
-            //}
-            //Ok(Some(true))
-        //},
-        //kpat!(KeyCode::Char('.')) => {
-            //match self.plugin.as_mut() {
-                //Some(PluginKind::LV2(LV2Plugin { port_list, ref mut instance, .. })) => {
-                    //let index = port_list[self.selected].index;
-                    //if let Some(value) = instance.control_input(index) {
-                        //instance.set_control_input(index, value + 0.01);
-                    //}
-                //},
-                //_ => {}
-            //}
-            //Ok(Some(true))
-        //},
-        //kpat!(KeyCode::Char('g')) => {
-            //match self.plugin {
-                ////Some(PluginKind::LV2(ref mut plugin)) => {
-                    ////plugin.ui_thread = Some(run_lv2_ui(LV2PluginUI::new()?)?);
-                ////},
-                //Some(_) => unreachable!(),
-                //None => {}
-            //}
-            //Ok(Some(true))
-        //},
-        //_ => Ok(None)
-    //}
-//});
-
-//from_atom!("plugin/lv2" => |jack: &Jack, args| -> Plugin {
-    //let mut name = String::new();
-    //let mut path = String::new();
-    //atom!(atom in args {
-        //Atom::Map(map) => {
-            //if let Some(Atom::Str(n)) = map.get(&Atom::Key(":name")) {
-                //name = String::from(*n);
-            //}
-            //if let Some(Atom::Str(p)) = map.get(&Atom::Key(":path")) {
-                //path = String::from(*p);
-            //}
-        //},
-        //_ => panic!("unexpected in lv2 '{name}'"),
-    //});
-    //Plugin::new_lv2(jack, &name, &path)
-//});

crates/device/src/plugin/lv2.rs

@@ -1,40 +0,0 @@
-use crate::*;
-
-/// A LV2 plugin.
-#[derive(Debug)]
-pub struct LV2Plugin {
-    pub world:        livi::World,
-    pub instance:     livi::Instance,
-    pub plugin:       livi::Plugin,
-    pub features:     Arc<livi::Features>,
-    pub port_list:    Vec<livi::Port>,
-    pub input_buffer: Vec<livi::event::LV2AtomSequence>,
-    pub ui_thread:    Option<JoinHandle<()>>,
-}
-
-impl LV2Plugin {
-    const INPUT_BUFFER: usize = 1024;
-    pub fn new (uri: &str) -> Usually<Self> {
-        let world = livi::World::with_load_bundle(&uri);
-        let features = world
-            .build_features(livi::FeaturesBuilder {
-                min_block_length: 1,
-                max_block_length: 65536,
-            });
-        let plugin = world.iter_plugins().nth(0)
-            .unwrap_or_else(||panic!("plugin not found: {uri}"));
-        Ok(Self {
-            instance: unsafe {
-                plugin
-                    .instantiate(features.clone(), 48000.0)
-                    .expect(&format!("instantiate failed: {uri}"))
-            },
-            port_list: plugin.ports().collect::<Vec<_>>(),
-            input_buffer: Vec::with_capacity(Self::INPUT_BUFFER),
-            ui_thread: None,
-            world,
-            features,
-            plugin,
-        })
-    }
-}

crates/device/src/plugin/lv2_tui.rs

@@ -1,47 +0,0 @@
-
-use super::*;
-use ::livi::{
-    World,
-    Instance,
-    Plugin as LiviPlugin,
-    Features,
-    FeaturesBuilder,
-    Port,
-    event::LV2AtomSequence,
-};
-use std::thread::JoinHandle;
-
-/// A LV2 plugin.
-pub struct LV2Plugin {
-    pub world:        World,
-    pub instance:     Instance,
-    pub plugin:       LiviPlugin,
-    pub features:     Arc<Features>,
-    pub port_list:    Vec<Port>,
-    pub input_buffer: Vec<LV2AtomSequence>,
-    pub ui_thread:    Option<JoinHandle<()>>,
-}
-
-impl LV2Plugin {
-    const INPUT_BUFFER: usize = 1024;
-    pub fn new (uri: &str) -> Usually<Self> {
-        // Get 1st plugin at URI
-        let world    = World::with_load_bundle(&uri);
-        let features = FeaturesBuilder { min_block_length: 1, max_block_length: 65536 };
-        let features = world.build_features(features);
-        let mut plugin = None;
-        if let Some(p) = world.iter_plugins().next() { plugin = Some(p); }
-        let plugin   = plugin.expect("plugin not found");
-        let err      = &format!("init {uri}");
-        let instance = unsafe { plugin.instantiate(features.clone(), 48000.0).expect(&err) };
-        let mut port_list = vec![];
-        for port in plugin.ports() {
-            port_list.push(port);
-        }
-        let input_buffer = Vec::with_capacity(Self::INPUT_BUFFER);
-        // Instantiate
-        Ok(Self {
-            world, instance, port_list, plugin, features, input_buffer, ui_thread: None
-        })
-    }
-}

crates/device/src/plugin/vst3_tui.rs

@@ -1,2 +0,0 @@
-//! TODO
-

crates/device/src/sampler/sampler_model.rs

@@ -64,6 +64,7 @@ impl Sampler {
     ) -> Usually<Self> {
         let name = name.as_ref();
         Ok(Self {
+            name: name.into(),
             midi_in: Some(JackMidiIn::new(jack, format!("M/{name}"), midi_from)?),
             audio_ins: vec![
                 JackAudioIn::new(jack, &format!("L/{name}"), audio_from[0])?,

crates/engine/src/jack/jack_port.rs

@@ -112,6 +112,7 @@ pub trait JackPortAutoconnect: JackPort + for<'a>JackPortConnect<&'a Port<Unowne
     }
     fn connect_to_matching (&self) -> Usually<()> {
         for connect in self.conn().iter() {
+            //panic!("{connect:?}");
             let status = match &connect.name {
                 Exact(name) => self.connect_exact(name),
                 RegExp(re)  => self.connect_regexp(re, connect.scope),