last small wave of 15 errors?

crates/app/src/api.rs

@@ -30,9 +30,9 @@ handle!(TuiIn: |self: App, input|Ok(if let Some(command) = self.config.keys.comm
         app.toggle_editor(Some(value));
         Ok(None)
     }
-    fn color (app: &mut App, theme: ItemTheme) -> Perhaps<Self> {
+    //fn color (app: &mut App, theme: ItemTheme) -> Perhaps<Self> {
-        Ok(app.set_color(Some(theme)).map(|theme|Self::Color{theme}))
+        //Ok(app.set_color(Some(theme)).map(|theme|Self::Color{theme}))
-    }
+    //}
     fn enqueue (app: &mut App, clip: Option<Arc<RwLock<MidiClip>>>) -> Perhaps<Self> {
         todo!()
     }
@@ -42,49 +42,47 @@ handle!(TuiIn: |self: App, input|Ok(if let Some(command) = self.config.keys.comm
     fn zoom (app: &mut App, zoom: usize) -> Perhaps<Self> {
         todo!()
     }
-    fn launch (app: &mut App) -> Perhaps<Self> {
+    //fn launch (app: &mut App) -> Perhaps<Self> {
-        app.launch();
+        //app.project.launch();
-        Ok(None)
+        //Ok(None)
-    }
+    //}
     fn select (app: &mut App, selection: Selection) -> Perhaps<Self> {
-        app.select(selection);
+        *app.project.selection_mut() = selection;
+        if let Some(ref mut editor) = app.editor {
+            editor.set_clip(match app.project.selection() {
+                Selection::TrackClip { track, scene } if let Some(Some(Some(clip))) = app
+                    .project
+                    .scenes.get(*scene)
+                    .map(|s|s.clips.get(*track))
+                =>
+                    Some(clip),
+                _ =>
+                    None
+            });
+        }
         Ok(None)
         //("select"  [t: usize, s: usize] Some(match (t.expect("no track"), s.expect("no scene")) {
             //(0, 0) => Self::Select(Selection::Mix),
             //(t, 0) => Self::Select(Selection::Track(t)),
             //(0, s) => Self::Select(Selection::Scene(s)),
             //(t, s) => Self::Select(Selection::TrackClip { track: t, scene: s }) })))
+        // autoedit: load focused clip in editor.
     }
     fn stop_all (app: &mut App) -> Perhaps<Self> {
-        app.stop_all();
+        app.tracks_stop_all();
         Ok(None)
     }
     fn sampler (app: &mut App, command: SamplerCommand) -> Perhaps<Self> {
-        Ok(app.sampler_mut()
+        Ok(app.project.sampler_mut()
             .map(|s|command.delegate(s, |command|Self::Sampler{command}))
             .transpose()?
             .flatten())
     }
-    fn scene (app: &mut App, command: SceneCommand) -> Perhaps<Self> {
+    fn project (app: &mut App, command: ArrangementCommand) -> Perhaps<Self> {
-        Ok(command.delegate(app, |command|Self::Scene{command})?)
+        Ok(command.delegate(&mut app.project, |command|Self::Project{command})?)
-    }
-    fn track (app: &mut App, command: TrackCommand) -> Perhaps<Self> {
-        Ok(command.delegate(app, |command|Self::Track{command})?)
-    }
-    fn input (app: &mut App, command: InputCommand) -> Perhaps<Self> {
-        Ok(command.delegate(app, |command|Self::Input{command})?)
-    }
-    fn output (app: &mut App, command: OutputCommand) -> Perhaps<Self> {
-        Ok(command.delegate(app, |command|Self::Output{command})?)
-    }
-    fn clip (app: &mut App, command: ClipCommand) -> Perhaps<Self> {
-        Ok(command.delegate(app, |command|Self::Clip{command})?)
     }
     fn clock (app: &mut App, command: ClockCommand) -> Perhaps<Self> {
-        Ok(command.execute(&mut app.clock)?.map(|command|Self::Clock{command}))
+        Ok(command.execute(app.clock_mut())?.map(|command|Self::Clock{command}))
-    }
-    fn device (app: &mut App, command: DeviceCommand) -> Perhaps<Self> {
-        Ok(command.delegate(app, |command|Self::Device{command})?)
     }
     fn message (app: &mut App, command: MessageCommand) -> Perhaps<Self> {
         Ok(command.delegate(app, |command|Self::Message{command})?)
@@ -93,7 +91,7 @@ handle!(TuiIn: |self: App, input|Ok(if let Some(command) = self.config.keys.comm
         Ok(if let Some(editor) = app.editor.as_mut() {
             let undo = command.clone().delegate(editor, |command|AppCommand::Editor{command})?;
             // update linked sampler after editor action
-            app.sampler_mut().map(|sampler|match command {
+            app.project.sampler_mut().map(|sampler|match command {
                 // autoselect: automatically select sample in sampler
                 MidiEditCommand::SetNotePos { pos } => { sampler.set_note_pos(pos); },
                 _ => {}
@@ -104,27 +102,26 @@ handle!(TuiIn: |self: App, input|Ok(if let Some(command) = self.config.keys.comm
         })
     }
     fn pool (app: &mut App, command: PoolCommand) -> Perhaps<Self> {
-        Ok(if let Some(pool) = app.pool.as_mut() {
+        let undo = command.clone().delegate(
-            let undo = command.clone().delegate(pool, |command|AppCommand::Pool{command})?;
+            &mut app.project.pool,
+            |command|AppCommand::Pool{command}
+        )?;
         // update linked editor after pool action
         app.editor.as_mut().map(|editor|match command {
             // autoselect: automatically load selected clip in editor
             PoolCommand::Select { .. } |
             // autocolor: update color in all places simultaneously
             PoolCommand::Clip { command: PoolClipCommand::SetColor { .. } } =>
-                    editor.set_clip(pool.clip().as_ref()),
+                editor.set_clip(app.project.pool.clip().as_ref()),
             _ => {}
         });
-            undo
+        Ok(undo)
-        } else {
-            None
-        })
     }
 }
 
 impl<'state> Context<'state, ClockCommand> for App {
     fn get <'source> (&'state self, iter: &mut TokenIter<'source>) -> Option<ClockCommand> {
-        Context::get(&self.clock, iter)
+        Context::get(&self.clock(), iter)
     }
 }
 
@@ -136,19 +133,25 @@ impl<'state> Context<'state, MidiEditCommand> for App {
 
 impl<'state> Context<'state, PoolCommand> for App {
     fn get <'source> (&'state self, iter: &mut TokenIter<'source>) -> Option<PoolCommand> {
-        self.pool().map(|p|Context::get(p, iter)).flatten()
+        Context::get(&self.project.pool, iter)
     }
 }
 
 impl<'state> Context<'state, SamplerCommand> for App {
     fn get <'source> (&'state self, iter: &mut TokenIter<'source>) -> Option<SamplerCommand> {
-        self.sampler().map(|p|Context::get(p, iter)).flatten()
+        self.project.sampler().map(|p|Context::get(p, iter)).flatten()
+    }
+}
+
+impl<'state> Context<'state, ArrangementCommand> for App {
+    fn get <'source> (&'state self, iter: &mut TokenIter<'source>) -> Option<ArrangementCommand> {
+        Context::get(&self.project, iter)
     }
 }
 
 #[tengri_proc::command(App)] impl MessageCommand {
     fn dismiss (app: &mut App) -> Perhaps<Self> {
-        app.message_dismiss();
+        app.dialog = None;
         Ok(None)
     }
 }

crates/app/src/audio.rs

@@ -1,16 +1,10 @@
 use crate::*;
 
-impl HasJack for App {
-    fn jack (&self) -> &Jack {
-        &self.jack
-    }
-}
-
 audio!(
     |self: App, client, scope|{
         let t0 = self.perf.get_t0();
         self.clock().update_from_scope(scope).unwrap();
-        let midi_in = self.arranger.midi_input_collect(scope);
+        let midi_in = self.project.midi_input_collect(scope);
         if let Some(editor) = &self.editor {
             let mut pitch: Option<u7> = None;
             for port in midi_in.iter() {
@@ -26,14 +20,16 @@ audio!(
                 editor.set_note_pos(pitch.as_int() as usize);
             }
         }
-        let result = self.arranger.tracks_render(client, scope);
+        let result = self.project.process_tracks(client, scope);
         self.perf.update_from_jack_scope(t0, scope);
         result
     };
     |self, event|{
         use JackEvent::*;
         match event {
-            SampleRate(sr) => { self.clock.timebase.sr.set(sr as f64); },
+            SampleRate(sr) => {
+                self.clock().timebase.sr.set(sr as f64);
+            },
             PortRegistration(id, true) => {
                 //let port = self.jack().port_by_id(id);
                 //println!("\rport add: {id} {port:?}");

crates/app/src/model.rs

@@ -6,8 +6,6 @@ pub struct App {
     pub jack:  Jack,
     /// Port handles
     pub ports: std::collections::BTreeMap<u32, Port<Unowned>>,
-    /// Source of time
-    pub clock: Clock,
     /// Display size
     pub size: Measure<TuiOut>,
     /// Performance counter
@@ -15,18 +13,14 @@ pub struct App {
 
     // View and input definition
     pub config:  Configuration,
+    /// Contains the currently edited musical arrangement
+    pub project: Arrangement,
     /// Undo history
     pub history: Vec<AppCommand>,
     // Dialog overlay
     pub dialog:  Option<Dialog>,
-    /// Browses external resources, such as directories
-    pub browser:  Option<Browser>,
-    /// Contains all clips in the project
-    pub pool:     Option<Pool>,
     /// Contains the currently edited MIDI clip
     pub editor:  Option<MidiEditor>,
-    /// Contains the currently edited musical arrangement
-    pub arranger: Arrangement,
 
     // Cache of formatted strings
     pub view_cache: Arc<RwLock<ViewCache>>,
@@ -34,27 +28,48 @@ pub struct App {
     pub color: ItemTheme,
 }
 
-has!(Option<Selection>: |self: App|self.arrangement.selected);
+has!(Jack:             |self: App|self.jack);
-has!(Vec<JackMidiIn>:   |self: App|self.arrangement.midi_ins);
+has!(Clock:            |self: App|self.project.clock);
-has!(Vec<JackMidiOut>:  |self: App|self.arrangement.midi_outs);
+has!(Selection:        |self: App|self.project.selection);
-has!(Vec<Scene>:        |self: App|self.arrangement.scenes);
+has!(Vec<JackMidiIn>:  |self: App|self.project.midi_ins);
-has!(Vec<Track>:        |self: App|self.arrangement.tracks);
+has!(Vec<JackMidiOut>: |self: App|self.project.midi_outs);
+has!(Vec<Scene>:       |self: App|self.project.scenes);
+has!(Vec<Track>:       |self: App|self.project.tracks);
+
+has_size!(<TuiOut>|self: App|&self.size);
+has_clips!(|self: App|self.project.pool.clips);
+has_editor!(|self: App|{
+    editor = self.editor;
+    editor_w = {
+        let size      = self.size.w();
+        let editor    = self.editor.as_ref().expect("missing editor");
+        let time_len  = editor.time_len().get();
+        let time_zoom = editor.time_zoom().get().max(1);
+        (5 + (time_len / time_zoom)).min(size.saturating_sub(20)).max(16)
+    };
+    editor_h = 15;
+    is_editing = self.editor.is_some();
+});
 
 impl App {
-    pub fn toggle_dialog (&mut self, dialog: Option<Dialog>) {
+    pub fn toggle_dialog (&mut self, mut dialog: Option<Dialog>) -> Option<Dialog> {
-        self.dialog = if self.dialog == dialog {
+        std::mem::swap(&mut self.dialog, &mut dialog);
-            None
-        } else {
         dialog
     }
-    }
     pub fn toggle_editor (&mut self, value: Option<bool>) {
-        self.editing.store(value.unwrap_or_else(||!self.is_editing()), Relaxed);
+        //FIXME: self.editing.store(value.unwrap_or_else(||!self.is_editing()), Relaxed);
-        self.arranger.map(|arranger|if value {
+        let value = value.unwrap_or_else(||!self.editor.is_some());
-            arranger.clip_auto_create();
+        if value {
+            self.clip_auto_create();
         } else {
-            arranger.clip_auto_remove();
+            self.clip_auto_remove();
-        });
+        }
+    }
+    pub fn browser (&self) -> Option<&Browser> {
+        self.dialog.as_ref().and_then(|dialog|match dialog {
+            Dialog::Save(b) | Dialog::Load(b) => Some(b),
+            _ => None
+        })
     }
     pub(crate) fn device_pick (&mut self, index: usize) {
         self.dialog = Some(Dialog::Device(index));
@@ -67,22 +82,82 @@ impl App {
     }
     pub(crate) fn device_add (&mut self, index: usize) -> Usually<()> {
         match index {
-            0 => self.arrangement.device_add_sampler(),
+            0 => self.device_add_sampler(),
-            1 => self.arrangement.device_add_lv2(),
+            1 => self.device_add_lv2(),
             _ => unreachable!(),
         }
     }
+    fn device_add_lv2 (&mut self) -> Usually<()> {
+        todo!();
+        Ok(())
+    }
+    fn device_add_sampler (&mut self) -> Usually<()> {
+        let name    = self.jack.with_client(|c|c.name().to_string());
+        let midi    = self.project.track().expect("no active track").sequencer.midi_outs[0].name();
+        let track   = self.track().expect("no active track");
+        let port    = format!("{}/Sampler", &track.name);
+        let connect = PortConnect::exact(format!("{name}:{midi}")); 
+        let sampler = if let Ok(sampler) = Sampler::new(
+            &self.jack, &port, &[connect], &[&[], &[]], &[&[], &[]]
+        ) {
+            self.dialog = None;
+            Device::Sampler(sampler)
+        } else {
+            self.dialog = Some(Dialog::Message(Message::FailedToAddDevice));
+            return Err("failed to add device".into())
+        };
+        let track   = self.track_mut().expect("no active track");
+        track.devices.push(sampler);
+        Ok(())
+    }
+    // Create new clip in pool when entering empty cell
+    fn clip_auto_create (&mut self) -> Option<Arc<RwLock<MidiClip>>> {
+        if let Selection::TrackClip { track, scene } = *self.selection()
+        && let Some(scene) = self.project.scenes.get_mut(scene)
+        && let Some(slot)  = scene.clips.get_mut(track)
+        && slot.is_none()
+        && let Some(track) = self.project.tracks.get_mut(track)
+        {
+            let (index, mut clip) = self.project.pool.add_new_clip();
+            // autocolor: new clip colors from scene and track color
+            let color = track.color.base.mix(scene.color.base, 0.5);
+            clip.write().unwrap().color = ItemColor::random_near(color, 0.2).into();
+            if let Some(ref mut editor) = self.editor {
+                editor.set_clip(Some(&clip));
+            }
+            *slot = Some(clip.clone());
+            Some(clip)
+        } else {
+            None
+        }
+    }
+    // Remove clip from arrangement when exiting empty clip editor
+    fn clip_auto_remove (&mut self) {
+        if let Selection::TrackClip { track, scene } = *self.selection()
+        && let Some(scene) = self.project.scenes.get_mut(scene)
+        && let Some(slot) = scene.clips.get_mut(track)
+        && let Some(clip) = slot.as_mut()
+        {
+            let mut swapped = None;
+            if clip.read().unwrap().count_midi_messages() == 0 {
+                std::mem::swap(&mut swapped, slot);
+            }
+            if let Some(clip) = swapped {
+                self.project.pool.delete_clip(&clip.read().unwrap());
+            }
+        }
+    }
 }
 
 /// Various possible dialog overlays
-#[derive(PartialEq, Clone, Copy, Debug)]
+#[derive(Clone, Debug)]
 pub enum Dialog {
     Help,
     Menu,
     Device(usize),
     Message(Message),
-    Save,
+    Save(Browser),
-    Load,
+    Load(Browser),
     Options,
 }
 
@@ -93,24 +168,12 @@ pub enum Message {
 }
 
 content!(TuiOut: |self: Message| match self { Self::FailedToAddDevice => "Failed to add device." });
-has_size!(<TuiOut>|self: App|&self.size);
-has!(Clock: |self: App|self.clock);
-has_clips!(|self: App|self.pool.as_ref().expect("no clip pool").clips);
-has_editor!(|self: App|{
-    editor = self.editor;
-    editor_w = {
-        let size      = self.size.w();
-        let editor    = self.editor.as_ref().expect("missing editor");
-        let time_len  = editor.time_len().get();
-        let time_zoom = editor.time_zoom().get().max(1);
-        (5 + (time_len / time_zoom)).min(size.saturating_sub(20)).max(16)
-    };
-    editor_h = 15;
-    is_editing = self.editing.load(Relaxed);
-});
 
 #[tengri_proc::expose]
 impl App {
+    fn _todo_u16_stub (&self) -> u16 {
+        todo!()
+    }
     fn _todo_isize_stub (&self) -> isize {
         todo!()
     }
@@ -127,31 +190,31 @@ impl App {
         matches!(self.dialog, Some(Dialog::Device(..)))
     }
     fn focus_browser (&self) -> bool {
-        self.browser.is_visible
+        self.browser().is_some()
     }
     fn focus_clip (&self) -> bool {
-        !self.is_editing() && self.selected.is_clip()
+        !self.is_editing() && self.selection().is_clip()
     }
     fn focus_track (&self) -> bool {
-        !self.is_editing() && self.selected.is_track()
+        !self.is_editing() && self.selection().is_track()
     }
     fn focus_scene (&self) -> bool {
-        !self.is_editing() && self.selected.is_scene()
+        !self.is_editing() && self.selection().is_scene()
     }
     fn focus_mix (&self) -> bool {
-        !self.is_editing() && self.selected.is_mix()
+        !self.is_editing() && self.selection().is_mix()
     }
     fn focus_pool_import (&self) -> bool {
-        matches!(self.pool.as_ref().map(|p|p.mode.as_ref()).flatten(), Some(PoolMode::Import(..)))
+        matches!(self.project.pool.mode, Some(PoolMode::Import(..)))
     }
     fn focus_pool_export (&self) -> bool {
-        matches!(self.pool.as_ref().map(|p|p.mode.as_ref()).flatten(), Some(PoolMode::Export(..)))
+        matches!(self.project.pool.mode, Some(PoolMode::Export(..)))
     }
     fn focus_pool_rename (&self) -> bool {
-        matches!(self.pool.as_ref().map(|p|p.mode.as_ref()).flatten(), Some(PoolMode::Rename(..)))
+        matches!(self.project.pool.mode, Some(PoolMode::Rename(..)))
     }
     fn focus_pool_length (&self) -> bool {
-        matches!(self.pool.as_ref().map(|p|p.mode.as_ref()).flatten(), Some(PoolMode::Length(..)))
+        matches!(self.project.pool.mode, Some(PoolMode::Length(..)))
     }
     fn dialog_device (&self) -> Dialog {
         Dialog::Device(0) // TODO
@@ -169,47 +232,47 @@ impl App {
         Dialog::Menu
     }
     fn dialog_save (&self) -> Dialog {
-        Dialog::Save
+        Dialog::Save(Default::default())
     }
     fn dialog_load (&self) -> Dialog {
-        Dialog::Load
+        Dialog::Load(Default::default())
     }
     fn dialog_options (&self) -> Dialog {
         Dialog::Options
     }
     fn editor_pitch (&self) -> Option<u7> {
-        Some((self.editor().map(|e|e.get_note_pos()).unwrap() as u8).into())
+        Some((self.editor().as_ref().map(|e|e.get_note_pos()).unwrap() as u8).into())
     }
     fn scene_count (&self) -> usize {
-        self.scenes.len()
+        self.scenes().len()
     }
-    fn scene_selected (&self) -> Option<usize> {
+    fn scene_selection (&self) -> Option<usize> {
-        self.selected.scene()
+        self.selection().scene()
     }
     fn track_count (&self) -> usize {
-        self.tracks.len()
+        self.tracks().len()
     }
-    fn track_selected (&self) -> Option<usize> {
+    fn track_selection (&self) -> Option<usize> {
-        self.selected.track()
+        self.selection().track()
     }
     fn select_scene_next (&self) -> Selection {
-        self.selected.scene_next(self.scenes.len())
+        self.selection().scene_next(self.scenes().len())
     }
     fn select_scene_prev (&self) -> Selection {
-        self.selected.scene_prev()
+        self.selection().scene_prev()
     }
     fn select_track_header (&self) -> Selection {
-        self.selected.track_header(self.tracks.len())
+        self.selection().track_header(self.tracks().len())
     }
     fn select_track_next (&self) -> Selection {
-        self.selected.track_next(self.tracks.len())
+        self.selection().track_next(self.tracks().len())
     }
     fn select_track_prev (&self) -> Selection {
-        self.selected.track_prev()
+        self.selection().track_prev()
     }
-    fn clip_selected (&self) -> Option<Arc<RwLock<MidiClip>>> {
+    fn clip_selection (&self) -> Option<Arc<RwLock<MidiClip>>> {
-        match self.selected {
+        match self.selection() {
-            Selection::TrackClip { track, scene } => self.scenes[scene].clips[track].clone(),
+            Selection::TrackClip { track, scene } => self.scenes()[*scene].clips[*track].clone(),
             _ => None
         }
     }
@@ -234,27 +297,4 @@ impl App {
             0
         }
     }
-    fn device_add_lv2 (&mut self) -> Usually<()> {
-        todo!();
-        Ok(())
-    }
-    fn device_add_sampler (&mut self, jack: &Jack) -> Usually<usize> {
-        let name = jack.with_client(|c|c.name().to_string());
-        let midi = self.track().expect("no active track").sequencer.midi_outs[0].name();
-        let sampler = if let Ok(sampler) = Sampler::new(
-            jack,
-            &format!("{}/Sampler", Has::<Track>::get(self).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())
-        };
-        Has::<Track>::get_mut(self).expect("no active track").devices.push(sampler);
-        Ok(())
-    }
 }

crates/app/src/view.rs

@@ -17,65 +17,70 @@ impl App {
     pub fn view_status (&self) -> impl Content<TuiOut> + use<'_> {
         self.update_clock();
         let cache = self.view_cache.read().unwrap();
-        view_status(self.selected.describe(&self.tracks, &self.scenes),
+        view_status(Some(self.project.selection.describe(self.tracks(), self.scenes())),
             cache.sr.view.clone(), cache.buf.view.clone(), cache.lat.view.clone())
     }
     pub fn view_transport (&self) -> impl Content<TuiOut> + use<'_> {
         self.update_clock();
         let cache = self.view_cache.read().unwrap();
-        view_transport(self.clock.is_rolling(),
+        view_transport(self.project.clock.is_rolling(),
             cache.bpm.view.clone(), cache.beat.view.clone(), cache.time.view.clone())
     }
-    pub fn view_arranger (&self) -> impl Content<TuiOut> + use<'_> {
-        ArrangerView::new(self, self.editor.as_ref())
-    }
-    pub fn view_pool (&self) -> impl Content<TuiOut> + use<'_> {
-        self.pool().map(|p|Fixed::x(self.w_sidebar(), PoolView(self.is_editing(), p)))
-    }
     pub fn view_editor (&self) -> impl Content<TuiOut> + use<'_> {
         self.editor().map(|e|Bsp::n(Bsp::e(e.clip_status(), e.edit_status()), e))
     }
+    pub fn view_arranger (&self) -> impl Content<TuiOut> + use<'_> {
+        ArrangerView::new(&self.project, self.editor.as_ref())
+    }
+    pub fn view_pool (&self) -> impl Content<TuiOut> + use<'_> {
+        let is_editing = self.is_editing();
+        Fixed::x(self.project.w_sidebar(is_editing),
+            PoolView(is_editing, &self.project.pool))
+    }
     pub fn view_samples_keys (&self) -> impl Content<TuiOut> + use<'_> {
-        self.sampler().map(|s|s.view_list(false, self.editor().unwrap()))
+        self.project.sampler().map(|s|s.view_list(false, self.editor().unwrap()))
     }
     pub fn view_samples_grid (&self) -> impl Content<TuiOut> + use<'_> {
-        self.sampler().map(|s|s.view_grid())
+        self.project.sampler().map(|s|s.view_grid())
     }
     pub fn view_sample_viewer (&self) -> impl Content<TuiOut> + use<'_> {
-        self.sampler().map(|s|s.view_sample(self.editor().unwrap().get_note_pos()))
+        self.project.sampler().map(|s|s.view_sample(self.editor().unwrap().get_note_pos()))
     }
     pub fn view_sample_info (&self) -> impl Content<TuiOut> + use<'_> {
-        self.sampler().map(|s|s.view_sample_info(self.editor().unwrap().get_note_pos()))
+        self.project.sampler().map(|s|s.view_sample_info(self.editor().unwrap().get_note_pos()))
     }
     pub fn view_meters_input (&self) -> impl Content<TuiOut> + use<'_> {
-        self.sampler().map(|s|s.view_meters_input())
+        self.project.sampler().map(|s|s.view_meters_input())
     }
     pub fn view_meters_output (&self) -> impl Content<TuiOut> + use<'_> {
-        self.sampler().map(|s|s.view_meters_output())
+        self.project.sampler().map(|s|s.view_meters_output())
     }
     pub fn view_dialog (&self) -> impl Content<TuiOut> + use<'_> {
-        When(app.dialog.is_some(), Bsp::b( "",
+        When(self.dialog.is_some(), Bsp::b( "",
             Fixed::xy(70, 23, Tui::fg_bg(Rgb(255,255,255), Rgb(16,16,16), Bsp::b(
                 Repeat(" "), Outer(true, Style::default().fg(Tui::g(96)))
-                    .enclose(app.dialog.as_ref().map(|dialog|match dialog {
+                    .enclose(self.dialog.as_ref().map(|dialog|match dialog {
                         Dialog::Menu =>
-                            app.view_dialog_menu().boxed(),
+                            self.view_dialog_menu().boxed(),
                         Dialog::Help =>
-                            app.view_dialog_help().boxed(),
+                            self.view_dialog_help().boxed(),
-                        Dialog::Save =>
+                        Dialog::Save(browser) =>
-                            app.view_dialog_save().boxed(),
+                            self.view_dialog_save().boxed(),
-                        Dialog::Load =>
+                        Dialog::Load(browser) =>
-                            app.view_dialog_load().boxed(),
+                            self.view_dialog_load().boxed(),
                         Dialog::Options =>
-                            app.view_dialog_options().boxed(),
+                            self.view_dialog_options().boxed(),
                         Dialog::Device(index) =>
-                            app.view_dialog_device(*index).boxed(),
+                            self.view_dialog_device(*index).boxed(),
                         Dialog::Message(message) =>
-                            app.view_dialog_message(message).boxed(),
+                            self.view_dialog_message(message).boxed(),
                     }))
             )))
         ))
     }
+}
+
+impl App {
     pub 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));

crates/device/src/arranger/arranger_api.rs

@@ -6,36 +6,28 @@ impl Arrangement {
     fn _todo_arc_str_stub_ (&self) -> Arc<str> { todo!() }
     fn _todo_item_theme_stub (&self) -> ItemTheme { todo!() }
     fn _todo_opt_item_theme_stub (&self) -> Option<ItemTheme> { todo!() }
+    fn select_nothing (&self) -> Selection {
+        Selection::Nothing
+    }
 }
 
 #[tengri_proc::command(Arrangement)] 
 impl ArrangementCommand {
     /// Set the selection
-    fn select (arranger: &mut Arrangement, s: Option<Selection>) -> Perhaps<Self> {
+    fn select (arranger: &mut Arrangement, s: Selection) -> Perhaps<Self> {
-        arranger.selected = s;
+        *arranger.selection_mut() = s;
-        // autoedit: load focused clip in editor.
-        if let Some(ref mut editor) = arranger.editor {
-            editor.set_clip(match arranger.selected {
-                Some(Selection::TrackClip { track, scene })
-                if let Some(Some(Some(clip))) = arranger
-                    .scenes.get(scene)
-                    .map(|s|s.clips.get(track)) => Some(clip),
-                _ => None
-            });
-        }
         Ok(None)
     }
     /// Launch a clip or scene
     fn launch (arranger: &mut Arrangement) -> Perhaps<Self> {
-        use Selection::*;
+        match *arranger.selection() {
-        match arranger.selected {
+            Selection::Track(t) => {
-            Some(Track(t)) => {
                 arranger.tracks[t].sequencer.enqueue_next(None)
             },
-            Some(TrackClip { track, scene }) => {
+            Selection::TrackClip { track, scene } => {
                 arranger.tracks[track].sequencer.enqueue_next(arranger.scenes[scene].clips[track].as_ref())
             },
-            Some(Scene(s)) => {
+            Selection::Scene(s) => {
                 for t in 0..arranger.tracks.len() {
                     arranger.tracks[t].sequencer.enqueue_next(arranger.scenes[s].clips[t].as_ref())
                 }
@@ -45,50 +37,45 @@ impl ArrangementCommand {
         Ok(None)
     }
     /// Set the color of the selected entity
-    fn set_color (arranger: &mut Arrangement, palette: Option<ItemTheme>) -> Option<ItemTheme> {
+    fn set_color (arranger: &mut Arrangement, palette: Option<ItemTheme>) -> Perhaps<Self> {
-        use Selection::*;
+        let mut palette = palette.unwrap_or_else(||ItemTheme::random());
-        let palette = palette.unwrap_or_else(||ItemTheme::random());
+        let selection   = *arranger.selection();
-        Some(match arranger.selected {
+        Ok(Some(Self::SetColor { palette: Some(match selection {
-            Some(Mix) => {
+            Selection::Mix => {
-                let old = arranger.color;
+                std::mem::swap(&mut palette, &mut arranger.color);
-                arranger.color = palette;
+                palette
-                old
             },
-            Some(Scene(s)) => {
+            Selection::Scene(s) => {
-                let old = arranger.scenes[s].color;
+                std::mem::swap(&mut palette, &mut arranger.scenes[s].color);
-                arranger.scenes[s].color = palette;
+                palette
-                old
             }
-            Some(Track(t)) => {
+            Selection::Track(t) => {
-                let old = arranger.tracks[t].color;
+                std::mem::swap(&mut palette, &mut arranger.tracks[t].color);
-                arranger.tracks[t].color = palette;
+                palette
-                old
             }
-            Some(TrackClip { track, scene }) => {
+            Selection::TrackClip { track, scene } => {
                 if let Some(ref clip) = arranger.scenes[scene].clips[track] {
                     let mut clip = clip.write().unwrap();
-                    let old = clip.color;
+                    std::mem::swap(&mut palette, &mut clip.color);
-                    clip.color = palette;
+                    palette
-                    old
                 } else {
-                    return None
+                    return Ok(None)
                 }
             },
             _ => todo!()
-        })
+        }) }))
     }
-
     fn track (arranger: &mut Arrangement, track: TrackCommand) -> Perhaps<Self> {
         todo!("delegate")
     }
     fn track_add (arranger: &mut Arrangement) -> Perhaps<Self> {
         let index = arranger.track_add(None, None, &[], &[])?.0;
-        arranger.selected = match arranger.selected {
+        *arranger.selection_mut() = match arranger.selection() {
-            Some(Selection::Track(_)) =>
+            Selection::Track(_) => Selection::Track(index),
-                Some(Selection::Track(index)),
+            Selection::TrackClip { track, scene } => Selection::TrackClip {
-            Some(Selection::TrackClip { track, scene }) =>
+                track: index, scene: *scene
-                Some(Selection::TrackClip { track: index, scene }),
+            },
-            _ => arranger.selected
+            _ => *arranger.selection()
         };
         Ok(Some(Self::TrackDelete { index }))
     }
@@ -115,37 +102,42 @@ impl ArrangementCommand {
         //TODO:Ok(Some(Self::TrackAdd ( index, track: Some(deleted_track) })
     }
     fn midi_in (arranger: &mut Arrangement, input: MidiInputCommand) -> Perhaps<Self> {
-        todo!("delegate")
+        todo!("delegate");
+        Ok(None)
     }
     fn midi_in_add (arranger: &mut Arrangement) -> Perhaps<Self> {
         arranger.midi_in_add()?;
         Ok(None)
     }
     fn midi_out (arranger: &mut Arrangement, input: MidiOutputCommand) -> Perhaps<Self> {
-        todo!("delegate")
+        todo!("delegate");
+        Ok(None)
     }
     fn midi_out_add (arranger: &mut Arrangement) -> Perhaps<Self> {
         arranger.midi_out_add()?;
         Ok(None)
     }
     fn device (arranger: &mut Arrangement, input: DeviceCommand) -> Perhaps<Self> {
-        todo!("delegate")
+        todo!("delegate");
+        Ok(None)
     }
     fn device_add (arranger: &mut Arrangement, i: usize) -> Perhaps<Self> {
-        arranger.device_add(i);
+        todo!("delegate");
         Ok(None)
     }
     fn scene (arranger: &mut Arrangement, scene: SceneCommand) -> Perhaps<Self> {
-        todo!("delegate")
+        todo!("delegate");
+        Ok(None)
     }
     fn scene_add (arranger: &mut Arrangement) -> Perhaps<Self> {
         let index = arranger.scene_add(None, None)?.0;
-        arranger.selected = match arranger.selected {
+        *arranger.selection_mut() = match arranger.selection() {
-            Some(Selection::Scene(_)) =>
+            Selection::Scene(_) => Selection::Scene(index),
-                Some(Selection::Scene(index)),
+            Selection::TrackClip { track, scene } => Selection::TrackClip {
-            Some(Selection::TrackClip { track, scene }) =>
+                track: *track,
-                Some(Selection::TrackClip { track, scene: index }),
+                scene: index
-            _ => arranger.selected
+            },
+            _ => *arranger.selection()
         };
         Ok(None) // TODO
     }
@@ -200,117 +192,20 @@ impl ArrangementCommand {
     }
 }
 
-impl<'state> Context<'state, TrackCommand> for Arrangement {
+impl<'state> Context<'state, MidiInputCommand> for Arrangement {
-    fn get <'source> (&'state self, iter: &mut TokenIter<'source>) -> Option<TrackCommand> {
+    fn get <'source> (&'state self, iter: &mut TokenIter<'source>) -> Option<MidiInputCommand> {
         Context::get(&self, iter)
     }
 }
 
-#[tengri_proc::expose]
+impl<'state> Context<'state, MidiOutputCommand> for Arrangement {
-impl Track {
+    fn get <'source> (&'state self, iter: &mut TokenIter<'source>) -> Option<MidiOutputCommand> {
-    fn _todo_opt_bool_stub_ (&self) -> Option<bool> { todo!() }
-    fn _todo_usize_stub_ (&self) -> usize { todo!() }
-    fn _todo_arc_str_stub_ (&self) -> Arc<str> { todo!() }
-    fn _todo_item_theme_stub (&self) -> ItemTheme { todo!() }
-}
-
-#[tengri_proc::command(Track)]
-impl TrackCommand {
-    fn set_name (track: &mut Track, mut name: Arc<str>) -> Perhaps<Self> {
-        std::mem::swap(&mut name, &mut track.name);
-        Ok(Some(Self::SetName { name }))
-    }
-    fn set_color (track: &mut Track, mut color: ItemTheme) -> Perhaps<Self> {
-        std::mem::swap(&mut color, &mut track.color);
-        Ok(Some(Self::SetColor { color }))
-    }
-    fn set_mute (track: &mut Track, value: Option<bool>) -> Perhaps<Self> {
-        todo!()
-    }
-    fn set_solo (track: &mut Track, value: Option<bool>) -> Perhaps<Self> {
-        todo!()
-    }
-    fn set_rec (track: &mut Track, value: Option<bool>) -> Perhaps<Self> {
-        let current = track.sequencer.recording;
-        let value = value.unwrap_or(!current);
-        Ok((value != current).then_some(Self::SetRec { value: Some(current) }))
-    }
-    fn set_mon (track: &mut Track, value: Option<bool>) -> Perhaps<Self> {
-        let current = track.sequencer.monitoring;
-        let value = value.unwrap_or(!current);
-        Ok((value != current).then_some(Self::SetRec { value: Some(current) }))
-    }
-    fn set_size (track: &mut Track, size: usize) -> Perhaps<Self> {
-        todo!()
-    }
-    fn set_zoom (track: &mut Track, zoom: usize) -> Perhaps<Self> {
-        todo!()
-    }
-    fn stop (track: &mut Track) -> Perhaps<Self> {
-        track.sequencer.enqueue_next(None);
-        Ok(None)
-    }
-}
-
-impl<'state> Context<'state, SceneCommand> for Arrangement {
-    fn get <'source> (&'state self, iter: &mut TokenIter<'source>) -> Option<SceneCommand> {
         Context::get(&self, iter)
     }
 }
 
-impl<'state> Context<'state, ClipCommand> for Arrangement {
+impl<'state> Context<'state, DeviceCommand> for Arrangement {
-    fn get <'source> (&'state self, iter: &mut TokenIter<'source>) -> Option<ClipCommand> {
+    fn get <'source> (&'state self, iter: &mut TokenIter<'source>) -> Option<DeviceCommand> {
         Context::get(&self, iter)
     }
 }
-
-#[tengri_proc::expose]
-impl Scene {
-    fn _todo_opt_bool_stub_ (&self) -> Option<bool> { todo!() }
-    fn _todo_usize_stub_ (&self) -> usize { todo!() }
-    fn _todo_arc_str_stub_ (&self) -> Arc<str> { todo!() }
-    fn _todo_item_theme_stub (&self) -> ItemTheme { todo!() }
-}
-
-#[tengri_proc::command(Scene)]
-impl SceneCommand {
-    fn set_name (scene: &mut Scene, mut name: Arc<str>) -> Perhaps<Self> {
-        std::mem::swap(&mut scene.name, &mut name);
-        Ok(Some(Self::SetName { name }))
-    }
-    fn set_color (scene: &mut Scene, mut color: ItemTheme) -> Perhaps<Self> {
-        std::mem::swap(&mut scene.color, &mut color);
-        Ok(Some(Self::SetColor { color }))
-    }
-    fn set_size (scene: &mut Scene, size: usize) -> Perhaps<Self> {
-        todo!()
-    }
-    fn set_zoom (scene: &mut Scene, zoom: usize) -> Perhaps<Self> {
-        todo!()
-    }
-}
-
-#[tengri_proc::expose]
-impl MidiClip {
-    fn _todo_opt_bool_stub_ (&self) -> Option<bool> { todo!() }
-    fn _todo_bool_stub_ (&self) -> bool { todo!() }
-    fn _todo_usize_stub_ (&self) -> usize { todo!() }
-    fn _todo_arc_str_stub_ (&self) -> Arc<str> { todo!() }
-    fn _todo_item_theme_stub (&self) -> ItemTheme { todo!() }
-    fn _todo_opt_item_theme_stub (&self) -> Option<ItemTheme> { todo!() }
-}
-
-#[tengri_proc::command(MidiClip)]
-impl ClipCommand {
-    fn set_color (clip: &mut MidiClip, color: Option<ItemTheme>) -> Perhaps<Self> {
-        //(SetColor [t: usize, s: usize, c: ItemTheme]
-            //clip.clip_set_color(t, s, c).map(|o|Self::SetColor(t, s, o)))));
-            //("color"   [a: usize, b: usize] Some(Self::SetColor(a.unwrap(), b.unwrap(), ItemTheme::random())))
-        todo!()
-    }
-    fn set_loop (clip: &mut MidiClip, looping: Option<bool>) -> Perhaps<Self> {
-        //(SetLoop  [t: usize, s: usize, l: bool] cmd_todo!("\n\rtodo: {self:?}"))
-            //("loop"    [a: usize, b: usize, c: bool] Some(Self::SetLoop(a.unwrap(), b.unwrap(), c.unwrap())))
-        todo!()
-    }
-}

crates/device/src/arranger/arranger_clip.rs

@@ -1,100 +1,36 @@
 use crate::*;
 
+impl<'state> Context<'state, ClipCommand> for Arrangement {
+    fn get <'source> (&'state self, iter: &mut TokenIter<'source>) -> Option<ClipCommand> {
+        Context::get(&self, iter)
+    }
+}
+
+#[tengri_proc::expose]
+impl MidiClip {
+    fn _todo_opt_bool_stub_ (&self) -> Option<bool> { todo!() }
+    fn _todo_bool_stub_ (&self) -> bool { todo!() }
+    fn _todo_usize_stub_ (&self) -> usize { todo!() }
+    fn _todo_arc_str_stub_ (&self) -> Arc<str> { todo!() }
+    fn _todo_item_theme_stub (&self) -> ItemTheme { todo!() }
+    fn _todo_opt_item_theme_stub (&self) -> Option<ItemTheme> { todo!() }
+}
+
+#[tengri_proc::command(MidiClip)]
+impl ClipCommand {
+    fn set_color (clip: &mut MidiClip, color: Option<ItemTheme>) -> Perhaps<Self> {
+        //(SetColor [t: usize, s: usize, c: ItemTheme]
+            //clip.clip_set_color(t, s, c).map(|o|Self::SetColor(t, s, o)))));
+            //("color"   [a: usize, b: usize] Some(Self::SetColor(a.unwrap(), b.unwrap(), ItemTheme::random())))
+        todo!()
+    }
+    fn set_loop (clip: &mut MidiClip, looping: Option<bool>) -> Perhaps<Self> {
+        //(SetLoop  [t: usize, s: usize, l: bool] cmd_todo!("\n\rtodo: {self:?}"))
+            //("loop"    [a: usize, b: usize, c: bool] Some(Self::SetLoop(a.unwrap(), b.unwrap(), c.unwrap())))
+        todo!()
+    }
+}
+
 impl Arrangement {
 
-    /// Put a clip in a slot
-    pub(crate) fn clip_put (
-        &mut self, track: usize, scene: usize, clip: Option<Arc<RwLock<MidiClip>>>
-    ) -> Option<Arc<RwLock<MidiClip>>> {
-        let old = self.scenes[scene].clips[track].clone();
-        self.scenes[scene].clips[track] = clip;
-        old
-    }
-
-    /// Change the color of a clip, returning the previous one
-    pub(crate) fn clip_set_color (
-        &self, track: usize, scene: usize, color: ItemTheme
-    ) -> Option<ItemTheme> {
-        self.scenes[scene].clips[track].as_ref().map(|clip|{
-            let mut clip = clip.write().unwrap();
-            let old = clip.color.clone();
-            clip.color = color.clone();
-            panic!("{color:?} {old:?}");
-            old
-        })
-    }
-
-    /// Get the active clip
-    pub(crate) fn clip (&self) -> Option<Arc<RwLock<MidiClip>>> {
-        self.scene()?.clips.get(self.selected().track()?)?.clone()
-    }
-
-    /// Toggle looping for the active clip
-    pub(crate) fn toggle_loop (&mut self) {
-        if let Some(clip) = self.clip() {
-            clip.write().unwrap().toggle_loop()
-        }
-    }
-
-}
-
-#[cfg(all(feature = "pool", feature = "editor"))]
-pub trait AutoCreate:
-    Has<Vec<Scene>> +
-    Has<Vec<Track>> +
-    Has<Option<MidiEditor>> +
-    Has<Option<Selection>> +
-    Has<Option<Pool>> +
-    Send + Sync
-{
-    // Create new clip in pool when entering empty cell
-    fn clip_auto_create (&mut self) -> Option<Arc<RwLock<MidiClip>>> {
-        if let Some(pool) = Has::<Option<Pool>>::get(self)
-            && let Some(Selection::TrackClip { track, scene }) = self.get()
-            && let Some(scene) = Has::<Vec<Scene>>::get_mut(self).get_mut(scene)
-            && let Some(slot)  = scene.clips.get_mut(track)
-            && slot.is_none()
-            && let Some(track) = Has::<Vec<Track>>::get_mut(self).get_mut(track)
-        {
-            let (index, mut clip) = pool.add_new_clip();
-            // autocolor: new clip colors from scene and track color
-            let color = track.color.base.mix(scene.color.base, 0.5);
-            clip.write().unwrap().color = ItemColor::random_near(color, 0.2).into();
-            if let Some(ref mut editor) = Has::<Option<MidiEditor>>::get_mut(self) {
-                editor.set_clip(Some(&clip));
-            }
-            *slot = Some(clip.clone());
-            Some(clip)
-        } else {
-            None
-        }
-    }
-}
-
-#[cfg(all(feature = "pool", feature = "editor"))]
-pub trait AutoRemove:
-    Has<Vec<Scene>> +
-    Has<Vec<Track>> +
-    Has<Option<MidiEditor>> +
-    Has<Option<Selection>> +
-    Has<Option<Pool>> +
-    Send + Sync
-{
-    // Remove clip from arrangement when exiting empty clip editor
-    fn clip_auto_remove (&mut self) {
-        if let Some(ref mut pool) = Has::<Option<Pool>>::get(self)
-            && let Some(Selection::TrackClip { track, scene }) = self.get()
-            && let Some(scene) = Has::<Vec<Scene>>::get_mut(self).get_mut(scene)
-            && let Some(slot) = scene.clips.get_mut(track)
-            && let Some(clip) = slot.as_mut()
-        {
-            let mut swapped = None;
-            if clip.read().unwrap().count_midi_messages() == 0 {
-                std::mem::swap(&mut swapped, slot);
-            }
-            if let Some(clip) = swapped {
-                pool.delete_clip(&clip.read().unwrap());
-            }
-        }
-    }
 }

crates/device/src/arranger/arranger_model.rs

@@ -6,6 +6,10 @@ pub struct Arrangement {
     pub name:         Arc<str>,
     /// Base color.
     pub color:        ItemTheme,
+    /// Jack client handle
+    pub jack:         Jack,
+    /// Source of time
+    pub clock:        Clock,
     /// List of global midi inputs
     pub midi_ins:     Vec<JackMidiIn>,
     /// List of global midi outputs
@@ -29,51 +33,53 @@ pub struct Arrangement {
     /// Scroll offset of scenes
     pub scene_scroll: usize,
     /// Selected UI element
-    pub selected:     Option<Selection>,
+    pub selection:    Selection,
     /// Contains a render of the project arrangement, redrawn on update.
     /// TODO rename to "render_cache" or smth
     pub arranger:     Arc<RwLock<Buffer>>,
     /// Display size
     pub size:         Measure<TuiOut>,
-    /// Jack client handle
+    /// Contains all clips in arrangement
-    pub jack:         Jack,
+    pub pool:         Pool,
 }
 
-has!(Option<Selection>: |self: Arrangement|self.selected);
+has!(Jack:             |self: Arrangement|self.jack);
+has!(Clock:            |self: Arrangement|self.clock);
+has!(Selection:        |self: Arrangement|self.selection);
 has!(Vec<JackMidiIn>:  |self: Arrangement|self.midi_ins);
 has!(Vec<JackMidiOut>: |self: Arrangement|self.midi_outs);
 has!(Vec<Scene>:       |self: Arrangement|self.scenes);
 has!(Vec<Track>:       |self: Arrangement|self.tracks);
-has!(Jack:              |self: Arrangement|self.jack);
 
 impl Arrangement {
     /// Width of display
-    pub(crate) fn w (&self) -> u16 {
+    pub fn w (&self) -> u16 {
         self.size.w() as u16
     }
     /// Width allocated for sidebar.
-    pub(crate) fn w_sidebar (&self, is_editing: bool) -> u16 {
+    pub fn w_sidebar (&self, is_editing: bool) -> u16 {
         self.w() / if is_editing { 16 } else { 8 } as u16
     }
     /// Width taken by all tracks.
-    pub(crate) fn w_tracks (&self) -> u16 {
+    pub fn w_tracks (&self) -> u16 {
-        self.tracks_with_sizes().last().map(|(_, _, _, x)|x as u16).unwrap_or(0)
+        self.tracks_with_sizes(&self.selection(), None).last()
+            .map(|(_, _, _, x)|x as u16).unwrap_or(0)
     }
     /// Width available to display tracks.
-    pub(crate) fn w_tracks_area (&self, is_editing: bool) -> u16 {
+    pub fn w_tracks_area (&self, is_editing: bool) -> u16 {
         self.w().saturating_sub(2 * self.w_sidebar(is_editing))
     }
     /// Height of display
-    pub(crate) fn h (&self) -> u16 {
+    pub fn h (&self) -> u16 {
         self.size.h() as u16
     }
     /// Height available to display track headers.
-    pub(crate) fn h_tracks_area (&self) -> u16 {
+    pub fn h_tracks_area (&self) -> u16 {
         5 // FIXME
         //self.h().saturating_sub(self.h_inputs() + self.h_outputs())
     }
     /// Height available to display tracks.
-    pub(crate) fn h_scenes_area (&self) -> u16 {
+    pub fn h_scenes_area (&self) -> u16 {
         //15
         self.h().saturating_sub(
             self.h_inputs() +
@@ -83,34 +89,90 @@ impl Arrangement {
         )
     }
     /// Height taken by all scenes.
-    pub(crate) fn h_scenes (&self, is_editing: bool) -> u16 {
+    pub fn h_scenes (&self, is_editing: bool) -> u16 {
-        let (selected_track, selected_scene) = match Has::<Option<Selection>>::get(self) {
-            Some(Selection::Track(t)) => (Some(*t), None),
-            Some(Selection::Scene(s)) => (None, Some(*s)),
-            Some(Selection::TrackClip { track, scene }) => (Some(*track), Some(*scene)),
-            _ => (None, None)
-        };
         self.scenes_with_sizes(
             is_editing,
             ArrangerView::H_SCENE,
             ArrangerView::H_EDITOR,
-            selected_track,
+            self.selection().track(),
-            selected_scene
+            self.selection().scene(),
         )
             .last()
             .map(|(_, _, _, y)|y as u16).unwrap_or(0)
     }
     /// Height taken by all inputs.
-    pub(crate) fn h_inputs (&self) -> u16 {
+    pub fn h_inputs (&self) -> u16 {
         self.midi_ins_with_sizes().last().map(|(_, _, _, _, y)|y as u16).unwrap_or(0)
     }
     /// Height taken by all outputs.
-    pub(crate) fn h_outputs (&self) -> u16 {
+    pub fn h_outputs (&self) -> u16 {
         self.midi_outs_with_sizes().last().map(|(_, _, _, _, y)|y as u16).unwrap_or(0)
     }
     /// Height taken by visible device slots.
-    pub(crate) fn h_devices (&self) -> u16 {
+    pub fn h_devices (&self) -> u16 {
         2
         //1 + self.devices_with_sizes().last().map(|(_, _, _, _, y)|y as u16).unwrap_or(0)
     }
+    /// Get the active track
+    fn get_track (&self) -> Option<&Track> {
+        let index = self.selection().track()?;
+        Has::<Vec<Track>>::get(self).get(index)
+    }
+    /// Get a mutable reference to the active track
+    fn get_track_mut (&mut self) -> Option<&mut Track> {
+        let index = self.selection().track()?;
+        Has::<Vec<Track>>::get_mut(self).get_mut(index)
+    }
+    /// Get the active scene
+    fn get_scene (&self) -> Option<&Scene> {
+        let index = self.selection().scene()?;
+        Has::<Vec<Scene>>::get(self).get(index)
+    }
+    /// Get a mutable reference to the active scene
+    fn get_scene_mut (&mut self) -> Option<&mut Scene> {
+        let index = self.selection().scene()?;
+        Has::<Vec<Scene>>::get_mut(self).get_mut(index)
+    }
+    /// Get the active clip
+    fn get_clip (&self) -> Option<Arc<RwLock<MidiClip>>> {
+        self.get_scene()?.clips.get(self.selection().track()?)?.clone()
+    }
+    /// Put a clip in a slot
+    pub fn clip_put (
+        &mut self, track: usize, scene: usize, clip: Option<Arc<RwLock<MidiClip>>>
+    ) -> Option<Arc<RwLock<MidiClip>>> {
+        let old = self.scenes[scene].clips[track].clone();
+        self.scenes[scene].clips[track] = clip;
+        old
+    }
+    /// Change the color of a clip, returning the previous one
+    pub fn clip_set_color (&self, track: usize, scene: usize, color: ItemTheme)
+        -> Option<ItemTheme>
+    {
+        self.scenes[scene].clips[track].as_ref().map(|clip|{
+            let mut clip = clip.write().unwrap();
+            let old = clip.color.clone();
+            clip.color = color.clone();
+            panic!("{color:?} {old:?}");
+            old
+        })
+    }
+    /// Toggle looping for the active clip
+    pub fn toggle_loop (&mut self) {
+        if let Some(clip) = self.get_clip() {
+            clip.write().unwrap().toggle_loop()
+        }
+    }
+}
+
+#[cfg(feature = "sampler")]
+impl Arrangement {
+    /// Get the first sampler of the active track
+    pub fn sampler (&self) -> Option<&Sampler> {
+        self.get_track()?.sampler(0)
+    }
+    /// Get the first sampler of the active track
+    pub fn sampler_mut (&mut self) -> Option<&mut Sampler> {
+        self.get_track_mut()?.sampler_mut(0)
+    }
 }

crates/device/src/arranger/arranger_scene.rs

@@ -1,10 +1,42 @@
 use crate::*;
 
+impl<'state> Context<'state, SceneCommand> for Arrangement {
+    fn get <'source> (&'state self, iter: &mut TokenIter<'source>) -> Option<SceneCommand> {
+        Context::get(&self, iter)
+    }
+}
+
+#[tengri_proc::expose]
+impl Scene {
+    fn _todo_opt_bool_stub_ (&self) -> Option<bool> { todo!() }
+    fn _todo_usize_stub_ (&self) -> usize { todo!() }
+    fn _todo_arc_str_stub_ (&self) -> Arc<str> { todo!() }
+    fn _todo_item_theme_stub (&self) -> ItemTheme { todo!() }
+}
+
+#[tengri_proc::command(Scene)]
+impl SceneCommand {
+    fn set_name (scene: &mut Scene, mut name: Arc<str>) -> Perhaps<Self> {
+        std::mem::swap(&mut scene.name, &mut name);
+        Ok(Some(Self::SetName { name }))
+    }
+    fn set_color (scene: &mut Scene, mut color: ItemTheme) -> Perhaps<Self> {
+        std::mem::swap(&mut scene.color, &mut color);
+        Ok(Some(Self::SetColor { color }))
+    }
+    fn set_size (scene: &mut Scene, size: usize) -> Perhaps<Self> {
+        todo!()
+    }
+    fn set_zoom (scene: &mut Scene, zoom: usize) -> Perhaps<Self> {
+        todo!()
+    }
+}
+
 impl<T: Has<Option<Scene>> + Send + Sync> HasScene for T {}
 
 pub trait HasScene: Has<Option<Scene>> + Send + Sync {
-    fn scene (&self) -> &Option<Scene> {
+    fn scene (&self) -> Option<&Scene> {
-        Has::<Option<Scene>>::get(self)
+        Has::<Option<Scene>>::get(self).as_ref()
     }
     fn scene_mut (&mut self) -> &mut Option<Scene> {
         Has::<Option<Scene>>::get_mut(self)

crates/device/src/arranger/arranger_select.rs

@@ -11,37 +11,14 @@ pub trait HasSelection: Has<Selection> {
     }
 }
 
-impl Has<Option<Track>> for Arrangement {
-    fn get (&self) -> &Option<Track> {
-        Has::<Option<Selection>>::get(self)
-            .and_then(|selection|selection.track())
-            .and_then(|index|Has::<Vec<Track>>::get(self).get(index))
-    }
-    fn get_mut (&mut self) -> &mut Option<Track> {
-        Has::<Option<Selection>>::get(self)
-            .and_then(|selection|selection.track())
-            .and_then(|index|Has::<Vec<Track>>::get_mut(self).get_mut(index))
-    }
-}
-
-impl Has<Option<Scene>> for Arrangement {
-    fn get (&self) -> &Option<Scene> {
-        Has::<Option<Selection>>::get(self)
-            .and_then(|selection|selection.track())
-            .and_then(|index|Has::<Vec<Scene>>::get(self).get(index))
-    }
-    fn get_mut (&mut self) -> &mut Option<Scene> {
-        Has::<Option<Selection>>::get(self)
-            .and_then(|selection|selection.track())
-            .and_then(|index|Has::<Vec<Scene>>::get_mut(self).get_mut(index))
-    }
-}
-
 /// Represents the current user selection in the arranger
 #[derive(PartialEq, Clone, Copy, Debug, Default)]
 pub enum Selection {
+    #[default]
+    /// Nothing is selected
+    Nothing,
     /// The whole mix is selected
-    #[default] Mix,
+    Mix,
     /// A MIDI input is selected.
     Input(usize),
     /// A MIDI output is selected.

crates/device/src/arranger/arranger_track.rs

@@ -1,5 +1,57 @@
 use crate::*;
 
+impl<'state> Context<'state, TrackCommand> for Arrangement {
+    fn get <'source> (&'state self, iter: &mut TokenIter<'source>) -> Option<TrackCommand> {
+        Context::get(&self, iter)
+    }
+}
+
+#[tengri_proc::expose]
+impl Track {
+    fn _todo_opt_bool_stub_ (&self) -> Option<bool> { todo!() }
+    fn _todo_usize_stub_ (&self) -> usize { todo!() }
+    fn _todo_arc_str_stub_ (&self) -> Arc<str> { todo!() }
+    fn _todo_item_theme_stub (&self) -> ItemTheme { todo!() }
+}
+
+#[tengri_proc::command(Track)]
+impl TrackCommand {
+    fn set_name (track: &mut Track, mut name: Arc<str>) -> Perhaps<Self> {
+        std::mem::swap(&mut name, &mut track.name);
+        Ok(Some(Self::SetName { name }))
+    }
+    fn set_color (track: &mut Track, mut color: ItemTheme) -> Perhaps<Self> {
+        std::mem::swap(&mut color, &mut track.color);
+        Ok(Some(Self::SetColor { color }))
+    }
+    fn set_mute (track: &mut Track, value: Option<bool>) -> Perhaps<Self> {
+        todo!()
+    }
+    fn set_solo (track: &mut Track, value: Option<bool>) -> Perhaps<Self> {
+        todo!()
+    }
+    fn set_rec (track: &mut Track, value: Option<bool>) -> Perhaps<Self> {
+        let current = track.sequencer.recording;
+        let value = value.unwrap_or(!current);
+        Ok((value != current).then_some(Self::SetRec { value: Some(current) }))
+    }
+    fn set_mon (track: &mut Track, value: Option<bool>) -> Perhaps<Self> {
+        let current = track.sequencer.monitoring;
+        let value = value.unwrap_or(!current);
+        Ok((value != current).then_some(Self::SetRec { value: Some(current) }))
+    }
+    fn set_size (track: &mut Track, size: usize) -> Perhaps<Self> {
+        todo!()
+    }
+    fn set_zoom (track: &mut Track, zoom: usize) -> Perhaps<Self> {
+        todo!()
+    }
+    fn stop (track: &mut Track) -> Perhaps<Self> {
+        track.sequencer.enqueue_next(None);
+        Ok(None)
+    }
+}
+
 #[derive(Debug, Default)]
 pub struct Track {
     /// Name of track
@@ -97,197 +149,27 @@ impl Track {
     }
 }
 
-impl<T: Has<Vec<Track>> + Send + Sync> HasTracks for T {}
+pub trait HasTrack {
-
+    fn track (&self) -> Option<&Track>;
-pub trait HasTracks: Has<Vec<Track>> + Send + Sync {
+    fn track_mut (&mut self) -> Option<&mut Track>;
-    fn tracks (&self) -> &Vec<Track> {
-        Has::<Vec<Track>>::get(self)
-    }
-    fn tracks_mut (&mut self) -> &mut Vec<Track> {
-        Has::<Vec<Track>>::get_mut(self)
-    }
-    /// Run audio callbacks for every track and every device
-    fn tracks_render (&mut self, client: &Client, scope: &ProcessScope) -> Control {
-        for track in self.tracks_mut().iter_mut() {
-            if Control::Quit == PlayerAudio(
-                track.sequencer_mut(), &mut self.note_buf, &mut self.midi_buf
-            ).process(client, scope) {
-                return Control::Quit
-            }
-            for device in track.devices.iter_mut() {
-                if Control::Quit == DeviceAudio(device).process(client, scope) {
-                    return Control::Quit
-                }
-            }
-        }
-        Control::Continue
-    }
-    fn track_longest_name (&self) -> usize {
-        self.tracks().iter().map(|s|s.name.len()).fold(0, usize::max)
-    }
-    /// Stop all playing clips
-    fn tracks_stop_all (&mut self) {
-        for track in self.tracks_mut().iter_mut() {
-            track.sequencer.enqueue_next(None);
-        }
-    }
-    /// Stop all playing clips
-    fn tracks_launch (&mut self, clips: Option<Vec<Option<Arc<RwLock<MidiClip>>>>>) {
-        if let Some(clips) = clips {
-            for (clip, track) in clips.iter().zip(self.tracks_mut()) {
-                track.sequencer.enqueue_next(clip);
-            }
-        } else {
-            for track in self.tracks_mut().iter_mut() {
-                track.sequencer.enqueue_next(None);
-            }
-        }
-    }
-    /// Iterate over tracks with their corresponding sizes.
-    fn tracks_with_sizes (
-        &self,
-        selection:    &Option<Selection>,
-        editor_width: Option<usize>
-    ) -> impl TracksSizes<'_> {
-        let mut x = 0;
-        let active_track = if let Some(width) = editor_width && let Some(selection) = selection {
-            selection.track()
-        } else {
-            None
-        };
-        self.tracks().iter().enumerate().map(move |(index, track)|{
-            let width = active_track
-                .and_then(|_|editor_width)
-                .unwrap_or(track.width.max(8));
-            let data = (index, track, x, x + width);
-            x += width + Self::TRACK_SPACING;
-            data
-        })
-    }
-    /// Spacing between tracks.
-    const TRACK_SPACING: usize = 0;
 }
 
-impl<T: Has<Option<Track>> + Send + Sync> HasTrack for T {}
+//impl<T: Has<Option<Track>>> HasTrack for T {
+    //fn track (&self) -> Option<&Track> {
+        //self.get().as_ref()
+    //}
+    //fn track_mut (&mut self) -> Option<&mut Track> {
+        //self.get_mut().as_mut()
+    //}
+//}
 
-pub trait HasTrack: Has<Option<Track>> + Send + Sync {
+impl<T: Has<Vec<Track>> + Has<Selection>> HasTrack for T {
     fn track (&self) -> Option<&Track> {
-        Has::<Option<Track>>::get(self).as_ref()
+        let index = Has::<Selection>::get(self).track()?;
+        Has::<Vec<Track>>::get(self).get(index)
     }
     fn track_mut (&mut self) -> Option<&mut Track> {
-        Has::<Option<Track>>::get_mut(self).as_mut()
+        let index = Has::<Selection>::get(self).track()?;
-    }
+        Has::<Vec<Track>>::get_mut(self).get_mut(index)
-}
-
-impl<'a> ArrangerView<'a> {
-    pub(crate) fn tracks_with_sizes_scrolled (&'a self)
-        -> impl TracksSizes<'a>
-    {
-        self.arrangement
-            .tracks_with_sizes(&self.arrangement.selected, self.is_editing.then_some(20/*FIXME*/))
-            .map_while(move|(t, track, x1, x2)|{
-                (self.width_mid > x2 as u16).then_some((t, track, x1, x2))
-            })
-    }
-}
-
-pub(crate) fn per_track_top <'a, T: Content<TuiOut> + 'a, U: TracksSizes<'a>> (
-    width:    u16,
-    tracks:   impl Fn() -> U + Send + Sync + 'a,
-    callback: impl Fn(usize, &'a Track)->T + Send + Sync + 'a
-) -> impl Content<TuiOut> + 'a {
-    Align::x(Tui::bg(Reset, Map::new(tracks,
-        move|(index, track, x1, x2): (usize, &'a Track, usize, usize), _|{
-            let width = (x2 - x1) as u16;
-            map_east(x1 as u16, width, Fixed::x(width, Tui::fg_bg(
-                track.color.lightest.rgb,
-                track.color.base.rgb,
-                callback(index, track))))})))
-}
-
-pub(crate) fn per_track <'a, T: Content<TuiOut> + 'a, U: TracksSizes<'a>> (
-    width:    u16,
-    tracks:   impl Fn() -> U + Send + Sync + 'a,
-    callback: impl Fn(usize, &'a Track)->T + Send + Sync + 'a
-) -> impl Content<TuiOut> + 'a {
-    per_track_top(
-        width,
-        tracks,
-        move|index, track|Fill::y(Align::y(callback(index, track)))
-    )
-}
-
-impl<T: HasTracks + HasScenes + HasClock + HasJack> AddTrack for T {}
-
-pub trait AddTrack: HasTracks + HasScenes + HasClock + HasJack {
-    /// Add multiple tracks
-    fn tracks_add (
-        &mut self,
-        count: usize,
-        width: Option<usize>,
-        mins:  &[PortConnect],
-        mouts: &[PortConnect],
-    ) -> Usually<()> {
-        let jack = self.jack().clone();
-        let track_color_1 = ItemColor::random();
-        let track_color_2 = ItemColor::random();
-        for i in 0..count {
-            let color = track_color_1.mix(track_color_2, i as f32 / count as f32).into();
-            let mut track = self.track_add(None, Some(color), mins, mouts)?.1;
-            if let Some(width) = width {
-                track.width = width;
-            }
-        }
-        Ok(())
-    }
-
-    /// Add a track
-    fn track_add (
-        &mut self,
-        name:  Option<&str>,
-        color: Option<ItemTheme>,
-        mins:  &[PortConnect],
-        mouts: &[PortConnect],
-    ) -> Usually<(usize, &mut Track)> {
-        self.track_last += 1;
-        let name: Arc<str> = name.map_or_else(
-            ||format!("Track{:02}", self.track_last).into(),
-            |x|x.to_string().into()
-        );
-        let mut track = Track {
-            width:  (name.len() + 2).max(12),
-            color:  color.unwrap_or_else(ItemTheme::random),
-            sequencer: Sequencer::new(
-                &format!("{name}"),
-                self.jack(),
-                Some(self.clock()),
-                None,
-                mins,
-                mouts
-            )?,
-            name,
-            ..Default::default()
-        };
-        self.tracks_mut().push(track);
-        let len = self.tracks().len();
-        let index = len - 1;
-        for scene in self.scenes_mut().iter_mut() {
-            while scene.clips.len() < len {
-                scene.clips.push(None);
-            }
-        }
-        Ok((index, &mut self.tracks_mut()[index]))
-    }
-}
-
-#[cfg(feature = "sampler")]
-impl Arrangement {
-    /// Get the first sampler of the active track
-    pub fn sampler (&self) -> Option<&Sampler> {
-        self.track().map(|t|t.sampler(0)).flatten()
-    }
-    /// Get the first sampler of the active track
-    pub fn sampler_mut (&mut self) -> Option<&mut Sampler> {
-        self.track_mut().map(|t|t.sampler_mut(0)).flatten()
     }
 }

crates/device/src/arranger/arranger_tracks.rs

@@ -0,0 +1,146 @@
+use crate::*;
+
+impl<T: Has<Vec<Track>> + Send + Sync> HasTracks for T {}
+
+pub trait HasTracks: Has<Vec<Track>> + Send + Sync {
+    fn tracks (&self) -> &Vec<Track> {
+        Has::<Vec<Track>>::get(self)
+    }
+    fn tracks_mut (&mut self) -> &mut Vec<Track> {
+        Has::<Vec<Track>>::get_mut(self)
+    }
+    /// Run audio callbacks for every track and every device
+    fn process_tracks (&mut self, client: &Client, scope: &ProcessScope) -> Control {
+        for track in self.tracks_mut().iter_mut() {
+            if Control::Quit == Audio::process(&mut track.sequencer, client, scope) {
+                return Control::Quit
+            }
+            for device in track.devices.iter_mut() {
+                if Control::Quit == DeviceAudio(device).process(client, scope) {
+                    return Control::Quit
+                }
+            }
+        }
+        Control::Continue
+    }
+    fn track_longest_name (&self) -> usize {
+        self.tracks().iter().map(|s|s.name.len()).fold(0, usize::max)
+    }
+    /// Stop all playing clips
+    fn tracks_stop_all (&mut self) {
+        for track in self.tracks_mut().iter_mut() {
+            track.sequencer.enqueue_next(None);
+        }
+    }
+    /// Stop all playing clips
+    fn tracks_launch (&mut self, clips: Option<Vec<Option<Arc<RwLock<MidiClip>>>>>) {
+        if let Some(clips) = clips {
+            for (clip, track) in clips.iter().zip(self.tracks_mut()) {
+                track.sequencer.enqueue_next(clip.as_ref());
+            }
+        } else {
+            for track in self.tracks_mut().iter_mut() {
+                track.sequencer.enqueue_next(None);
+            }
+        }
+    }
+    /// Iterate over tracks with their corresponding sizes.
+    fn tracks_with_sizes (
+        &self,
+        selection:    &Selection,
+        editor_width: Option<usize>
+    ) -> impl TracksSizes<'_> {
+        let mut x = 0;
+        let active_track = if let Some(width) = editor_width {
+            selection.track()
+        } else {
+            None
+        };
+        self.tracks().iter().enumerate().map(move |(index, track)|{
+            let width = active_track
+                .and_then(|_|editor_width)
+                .unwrap_or(track.width.max(8));
+            let data = (index, track, x, x + width);
+            x += width + Self::TRACK_SPACING;
+            data
+        })
+    }
+    /// Spacing between tracks.
+    const TRACK_SPACING: usize = 0;
+}
+
+impl<'a> ArrangerView<'a> {
+    pub(crate) fn tracks_with_sizes_scrolled (&'a self)
+        -> impl TracksSizes<'a>
+    {
+        self.arrangement
+            .tracks_with_sizes(
+                &self.arrangement.selection(),
+                self.is_editing.then_some(20/*FIXME*/)
+            )
+            .map_while(move|(t, track, x1, x2)|{
+                (self.width_mid > x2 as u16).then_some((t, track, x1, x2))
+            })
+    }
+}
+
+impl Arrangement {
+    /// Add multiple tracks
+    pub fn tracks_add (
+        &mut self,
+        count: usize,
+        width: Option<usize>,
+        mins:  &[PortConnect],
+        mouts: &[PortConnect],
+    ) -> Usually<()> {
+        let jack = self.jack().clone();
+        let track_color_1 = ItemColor::random();
+        let track_color_2 = ItemColor::random();
+        for i in 0..count {
+            let color = track_color_1.mix(track_color_2, i as f32 / count as f32).into();
+            let mut track = self.track_add(None, Some(color), mins, mouts)?.1;
+            if let Some(width) = width {
+                track.width = width;
+            }
+        }
+        Ok(())
+    }
+
+    /// Add a track
+    pub fn track_add (
+        &mut self,
+        name:  Option<&str>,
+        color: Option<ItemTheme>,
+        mins:  &[PortConnect],
+        mouts: &[PortConnect],
+    ) -> Usually<(usize, &mut Track)> {
+        self.track_last += 1;
+        let name: Arc<str> = name.map_or_else(
+            ||format!("Track{:02}", self.track_last).into(),
+            |x|x.to_string().into()
+        );
+        let mut track = Track {
+            width:  (name.len() + 2).max(12),
+            color:  color.unwrap_or_else(ItemTheme::random),
+            sequencer: Sequencer::new(
+                &format!("{name}"),
+                self.jack(),
+                Some(self.clock()),
+                None,
+                mins,
+                mouts
+            )?,
+            name,
+            ..Default::default()
+        };
+        self.tracks_mut().push(track);
+        let len = self.tracks().len();
+        let index = len - 1;
+        for scene in self.scenes_mut().iter_mut() {
+            while scene.clips.len() < len {
+                scene.clips.push(None);
+            }
+        }
+        Ok((index, &mut self.tracks_mut()[index]))
+    }
+}

crates/device/src/arranger/arranger_view.rs

@@ -1,6 +1,6 @@
 use crate::*;
 
-pub(crate) struct ArrangerView<'a> {
+pub struct ArrangerView<'a> {
     pub arrangement:    &'a Arrangement,
 
     pub is_editing:     bool,
@@ -35,7 +35,6 @@ impl<'a> ArrangerView<'a> {
         editor: Option<&'a MidiEditor>
     ) -> Self {
         let is_editing    = editor.is_some();
-        let selected      = arrangement.selected;
         let h_tracks_area = arrangement.h_tracks_area();
         let h_scenes_area = arrangement.h_scenes_area();
         let h_scenes      = arrangement.h_scenes(is_editing);
@@ -54,7 +53,7 @@ impl<'a> ArrangerView<'a> {
             outputs_count:  arrangement.midi_outs.len(),
 
             scenes_height:  h_scenes_area,
-            scene_selected: selected.map(|s|s.scene()).flatten(),
+            scene_selected: arrangement.selection().scene(),
             scene_count:    arrangement.scenes.len(),
             scene_last:     arrangement.scenes.len().saturating_sub(1),
             scene_scroll:   Fill::y(Fixed::x(1, ScrollbarV {
@@ -65,7 +64,7 @@ impl<'a> ArrangerView<'a> {
 
             tracks_height:  h_tracks_area,
             track_count:    arrangement.tracks.len(),
-            track_selected: selected.map(|s|s.track()).flatten(),
+            track_selected: arrangement.selection().track(),
             track_scroll:   Fill::x(Fixed::y(1, ScrollbarH {
                 offset: arrangement.track_scroll,
                 length: h_tracks_area as usize,
@@ -86,7 +85,7 @@ impl<'a> Content<TuiOut> for ArrangerView<'a> {
         let bg      = |x|Tui::bg(Reset, x);
         //let track_scroll = |x|Bsp::s(&self.track_scroll, x);
         //let scene_scroll = |x|Bsp::e(&self.scene_scroll, x);
-        outs(tracks(devices(ins(bg(self.scenes(None))))))
+        outs(tracks(devices(ins(bg(self.scenes(&None))))))
     }
 }
 
@@ -150,7 +149,7 @@ impl<'a> ArrangerView<'a> {
     pub(crate) const H_EDITOR: usize = 15;
 
     /// Render scenes with clips
-    pub(crate) fn scenes (&'a self, editor: Option<MidiEditor>) -> impl Content<TuiOut> + 'a {
+    pub(crate) fn scenes (&'a self, editor: &'a Option<MidiEditor>) -> impl Content<TuiOut> + 'a {
         /// A scene with size and color.
         type SceneWithColor<'a> = (usize, &'a Scene, usize, usize, Option<ItemTheme>);
         let Self {
@@ -160,16 +159,14 @@ impl<'a> ArrangerView<'a> {
             track_selected, is_editing, ..
         } = self;
 
-        let selection = Has::<Option<Selection>>::get(self.arrangement);
+        let selection = Has::<Selection>::get(self.arrangement);
-        let selected_track = selection.map(|s|s.track()).flatten();
+        let selected_track = selection.track();
-        let selected_scene = selection.map(|s|s.scene()).flatten();
+        let selected_scene = selection.scene();
+        Tryptich::center(*scenes_height)
 
-        let scenes_with_scene_colors = ||HasScenes::scenes_with_sizes(self.arrangement,
+            .left(*width_side, Map::new(
-            *is_editing,
+                move||arrangement.scenes_with_sizes(
-            Self::H_SCENE,
+                    *is_editing, Self::H_SCENE, Self::H_EDITOR, selected_track, selected_scene,
-            Self::H_EDITOR,
-            selected_track,
-            selected_scene,
                 ).map_while(|(s, scene, y1, y2)|if y2 as u16 > *scenes_height {
                     None
                 } else {
@@ -178,9 +175,8 @@ impl<'a> ArrangerView<'a> {
                     } else {
                         Some(arrangement.scenes()[s-1].color)
                     }))
-        });
+                }),
-
+                move |(s, scene, y1, y2, previous): SceneWithColor, _|{
-        let scene_header = |(s, scene, y1, y2, previous): SceneWithColor, _|{
                     let height     = (1 + y2 - y1) as u16;
                     let name       = Some(scene.name.clone());
                     let content    = Fill::x(Align::w(Tui::bold(true, Bsp::e(" ⯈ ", name))));
@@ -210,38 +206,30 @@ impl<'a> ArrangerView<'a> {
                     Fill::x(map_south(y1 as u16, height, Fixed::y(height, Phat {
                         width: 0, height: 0, content, colors: [fg, bg, hi, lo]
                     })))
-        };
+                }))
 
-        let scenes_with_track_colors = |track: usize| arrangement.scenes_with_sizes(
+            .middle(*width_mid, per_track(
+                *width_mid,
+                ||self.tracks_with_sizes_scrolled(),
+                move|track_index, track|Map::new(
+                    move||arrangement.scenes_with_sizes(
                         self.is_editing,
                         Self::H_SCENE,
                         Self::H_EDITOR,
                         selected_track,
                         selected_scene,
-        ).map_while(|(s, scene, y1, y2)|if y2 as u16 > self.scenes_height {
+                    ).map_while(move|(s, scene, y1, y2)|if y2 as u16 > self.scenes_height {
                         None
                     } else {
                         Some((s, scene, y1, y2, if s == 0 {
                             None
                         } else {
-                Some(self.arrangement.scenes[s-1].clips[track].as_ref()
+                            Some(self.arrangement.scenes[s-1].clips[track_index].as_ref()
                                 .map(|c|c.read().unwrap().color)
                                 .unwrap_or(ItemTheme::G[32]))
                         }))
-        });
+                    }),
-
+                    move|(s, scene, y1, y2, previous): SceneWithColor<'a>, _|{
-        Tryptich::center(*scenes_height)
-
-            .left(*width_side, Map::new(
-                ||scenes_with_scene_colors(), 
-                scene_header))
-
-            .middle(*width_mid, per_track(
-                *width_mid,
-                ||self.tracks_with_sizes_scrolled(),
-                |track_index, track|Map::new(
-                    ||scenes_with_track_colors(track_index),
-                    |(s, scene, y1, y2, previous): SceneWithColor<'a>, _|{
                         let (name, theme) = if let Some(clip) = &scene.clips[track_index] {
                             let clip = clip.read().unwrap();
                             (Some(clip.name.clone()), clip.color)
@@ -283,3 +271,29 @@ impl<'a> ArrangerView<'a> {
     }
 
 }
+
+pub(crate) fn per_track_top <'a, T: Content<TuiOut> + 'a, U: TracksSizes<'a>> (
+    width:    u16,
+    tracks:   impl Fn() -> U + Send + Sync + 'a,
+    callback: impl Fn(usize, &'a Track)->T + Send + Sync + 'a
+) -> impl Content<TuiOut> + 'a {
+    Align::x(Tui::bg(Reset, Map::new(tracks,
+        move|(index, track, x1, x2): (usize, &'a Track, usize, usize), _|{
+            let width = (x2 - x1) as u16;
+            map_east(x1 as u16, width, Fixed::x(width, Tui::fg_bg(
+                track.color.lightest.rgb,
+                track.color.base.rgb,
+                callback(index, track))))})))
+}
+
+pub(crate) fn per_track <'a, T: Content<TuiOut> + 'a, U: TracksSizes<'a>> (
+    width:    u16,
+    tracks:   impl Fn() -> U + Send + Sync + 'a,
+    callback: impl Fn(usize, &'a Track)->T + Send + Sync + 'a
+) -> impl Content<TuiOut> + 'a {
+    per_track_top(
+        width,
+        tracks,
+        move|index, track|Fill::y(Align::y(callback(index, track)))
+    )
+}

crates/device/src/browser/browser_model.rs

@@ -3,7 +3,7 @@ use std::path::PathBuf;
 use std::ffi::OsString;
 
 /// Browses for phrase to import/export
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct Browser {
     pub cwd:    PathBuf,
     pub dirs:   Vec<(OsString, String)>,

crates/device/src/clock/clock_model.rs

@@ -177,4 +177,25 @@ impl Clock {
     pub fn next_launch_instant (&self) -> Moment {
         Moment::from_pulse(self.timebase(), self.next_launch_pulse() as f64)
     }
+
+    /// Get index of first sample to populate.
+    ///
+    /// Greater than 0 means that the first pulse of the clip
+    /// falls somewhere in the middle of the chunk.
+    pub fn get_sample_offset (&self, scope: &ProcessScope, started: &Moment) -> usize{
+        (scope.last_frame_time() as usize).saturating_sub(
+            started.sample.get() as usize +
+            self.started.read().unwrap().as_ref().unwrap().sample.get() as usize
+        )
+    }
+
+    // Get iterator that emits sample paired with pulse.
+    //
+    // * Sample: index into output buffer at which to write MIDI event
+    // * Pulse: index into clip from which to take the MIDI event
+    //
+    // Emitted for each sample of the output buffer that corresponds to a MIDI pulse.
+    pub fn get_pulses (&self, scope: &ProcessScope, offset: usize) -> TicksIterator {
+        self.timebase().pulses_between_samples(offset, offset + scope.n_frames() as usize)
+    }
 }

crates/device/src/clock/clock_view.rs

@@ -18,14 +18,14 @@ pub fn view_transport (
 }
 
 pub fn view_status (
-    sel: Arc<str>,
+    sel: Option<Arc<str>>,
     sr:  Arc<RwLock<String>>,
     buf: Arc<RwLock<String>>,
     lat: Arc<RwLock<String>>,
 ) -> impl Content<TuiOut> {
     let theme = ItemTheme::G[96];
     Tui::bg(Black, row!(Bsp::a(
-        Fill::xy(Align::w(FieldH(theme, "Selected", sel))),
+        Fill::xy(Align::w(sel.map(|sel|FieldH(theme, "Selected", sel)))),
         Fill::xy(Align::e(row!(
             FieldH(theme, "SR",  sr),
             FieldH(theme, "Buf", buf),

crates/device/src/editor/editor_model.rs

@@ -102,8 +102,8 @@ impl MidiViewer for MidiEditor {
 }
 
 pub trait HasEditor {
-    fn editor (&self) -> &Option<MidiEditor>;
+    fn editor (&self) -> Option<&MidiEditor>;
-    fn editor_mut (&mut self) -> &Option<MidiEditor>;
+    fn editor_mut (&mut self) -> Option<&mut MidiEditor>;
     fn is_editing (&self) -> bool { true }
     fn editor_w (&self) -> usize { 0 }
     fn editor_h (&self) -> usize { 0 }
@@ -117,17 +117,12 @@ pub trait HasEditor {
         is_editing = $e3:expr;
     }) => {
         impl HasEditor for $Struct {
-            fn editor (&$self) -> &Option<MidiEditor> { &$e0 }
+            fn editor (&$self) -> Option<&MidiEditor> { $e0.as_ref() }
-            fn editor_mut (&mut $self) -> &Option<MidiEditor> { &mut $e0 }
+            fn editor_mut (&mut $self) -> Option<&mut MidiEditor> { $e0.as_mut() }
             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/device/src/sequencer/seq_audio.rs

@@ -1,82 +1,45 @@
 use crate::*;
 
-/// Hosts the JACK callback for a single MIDI sequencer
-pub struct PlayerAudio<'a, T: MidiSequencer>(
-    /// Player
-    pub &'a mut T,
-    /// Note buffer
-    pub &'a mut Vec<u8>,
-    /// Note chunk buffer
-    pub &'a mut Vec<Vec<Vec<u8>>>,
-);
-
 /// JACK process callback for a sequencer's clip sequencer/recorder.
-impl<T: MidiSequencer> Audio for PlayerAudio<'_, T> {
+impl Audio for Sequencer {
     fn process (&mut self, _: &Client, scope: &ProcessScope) -> Control {
-        let model    = &mut self.0;
+        if self.clock().is_rolling() {
-        let note_buf = &mut self.1;
+            self.process_rolling(scope)
-        let midi_buf = &mut self.2;
+        } else {
-        // Clear output buffer(s)
+            self.process_stopped(scope)
-        model.clear(scope, midi_buf, false);
+        }
+    }
+}
+
+impl Sequencer {
+    fn process_rolling (&mut self, scope: &ProcessScope) -> Control {
+        self.process_clear(scope, false);
         // Write chunk of clip to output, handle switchover
-        if model.play(scope, note_buf, midi_buf) {
+        if self.process_playback(scope) {
-            model.switchover(scope, note_buf, midi_buf);
+            self.process_switchover(scope);
         }
-        if !model.midi_ins().is_empty() {
-            if model.recording() || model.monitoring() {
-                // Record and/or monitor input
-                model.record(scope, midi_buf)
-            } else if model.midi_outs().is_empty() && model.monitoring() {
         // Monitor input to output
-                model.monitor(scope, midi_buf)
+        self.process_monitoring(scope);
-            }
+        // Record and/or monitor input
-        }
+        self.process_recording(scope);
-        // Write to output port(s)
+        // Emit contents of MIDI buffers to JACK MIDI output ports.
-        model.write(scope, midi_buf);
+        self.midi_outs_emit(scope);
         Control::Continue
     }
+    fn process_stopped (&mut self, scope: &ProcessScope) -> Control {
+        if self.monitoring() && self.midi_ins().len() > 0 && self.midi_outs().len() > 0 {
+            self.process_monitoring(scope)
         }
-
+        Control::Continue
-pub trait MidiSequencer: MidiRecorder + MidiPlayer + Send + Sync {}
-
-impl MidiSequencer for Sequencer {}
-
-pub trait MidiRecorder: HasClock + HasPlayClip + HasMidiIns {
-    fn notes_in (&self) -> &Arc<RwLock<[bool;128]>>;
-
-    fn recording (&self) -> bool;
-
-    fn recording_mut (&mut self) -> &mut bool;
-
-    fn toggle_record (&mut self) {
-        *self.recording_mut() = !self.recording();
     }
-
+    fn process_monitoring (&mut self, scope: &ProcessScope) {
-    fn monitoring (&self) -> bool;
+        let notes_in = self.notes_in().clone(); // For highlighting keys and note repeat
-
-    fn monitoring_mut (&mut self) -> &mut bool;
-
-    fn toggle_monitor (&mut self) {
-        *self.monitoring_mut() = !self.monitoring();
-    }
-
-    fn overdub (&self) -> bool;
-
-    fn overdub_mut (&mut self) -> &mut bool;
-
-    fn toggle_overdub (&mut self) {
-        *self.overdub_mut() = !self.overdub();
-    }
-
-    fn monitor (&mut self, scope: &ProcessScope, midi_buf: &mut Vec<Vec<Vec<u8>>>) {
-        // For highlighting keys and note repeat
-        let notes_in = self.notes_in().clone();
         let monitoring = self.monitoring();
-        for input in self.midi_ins_mut().iter() {
+        for input in self.midi_ins.iter() {
-            for (sample, event, bytes) in parse_midi_input(input.port().iter(scope)) {
+            for (sample, event, bytes) in input.parsed(scope) {
                 if let LiveEvent::Midi { message, .. } = event {
                     if monitoring {
-                        midi_buf[sample].push(bytes.to_vec());
+                        self.midi_buf[sample].push(bytes.to_vec());
                     }
                     // FIXME: don't lock on every event!
                     update_keys(&mut notes_in.write().unwrap(), &message);
@@ -84,28 +47,143 @@ pub trait MidiRecorder: HasClock + HasPlayClip + HasMidiIns {
             }
         }
     }
-
+    /// Clear the section of the output buffer that we will be using,
-    fn record (&mut self, scope: &ProcessScope, midi_buf: &mut Vec<Vec<Vec<u8>>>) {
+    /// emitting "all notes off" at start of buffer if requested.
+    fn process_clear (&mut self, scope: &ProcessScope, reset: bool) {
+        let n_frames = (scope.n_frames() as usize).min(self.midi_buf_mut().len());
+        for frame in &mut self.midi_buf_mut()[0..n_frames] {
+            frame.clear();
+        }
+        if reset {
+            all_notes_off(self.midi_buf_mut());
+        }
+        for port in self.midi_outs_mut().iter_mut() {
+            // Clear output buffer(s)
+            port.buffer_clear(scope, false);
+        }
+    }
+    fn process_recording (&mut self, scope: &ProcessScope) {
         if self.monitoring() {
-            self.monitor(scope, midi_buf);
+            self.monitor(scope);
         }
-        if !self.clock().is_rolling() {
+        if let Some((started, ref clip)) = self.play_clip.clone() {
-            return
+            self.record_clip(scope, started, clip);
-        }
-        if let Some((started, ref clip)) = self.play_clip().clone() {
-            self.record_clip(scope, started, clip, midi_buf);
         }
         if let Some((_start_at, _clip)) = &self.next_clip() {
             self.record_next();
         }
     }
+    fn process_playback (&mut self, scope: &ProcessScope) -> bool {
+        // If a clip is playing, write a chunk of MIDI events from it to the output buffer.
+        // If no clip is playing, prepare for switchover immediately.
+        if let Some((started, clip)) = &self.play_clip {
+            // Length of clip, to repeat or stop on end.
+            let length = clip.as_ref().map_or(0, |p|p.read().unwrap().length);
+            // Index of first sample to populate.
+            let offset = self.clock().get_sample_offset(scope, &started);
+            // Write MIDI events from clip at sample offsets corresponding to pulses.
+            for (sample, pulse) in self.clock().get_pulses(scope, offset) {
+                // If a next clip is enqueued, and we're past the end of the current one,
+                // break the loop here (FIXME count pulse correctly)
+                let past_end = if clip.is_some() { pulse >= length } else { true };
+                // Is it time for switchover?
+                if self.next_clip().is_some() && past_end {
+                    return true
+                }
+                // If there's a currently playing clip, output notes from it to buffer:
+                if let Some(ref clip) = clip {
+                    // Source clip from which the MIDI events will be taken.
+                    let clip = clip.read().unwrap();
+                    // Clip with zero length is not processed
+                    if clip.length > 0 {
+                        // Current pulse index in source clip
+                        let pulse = pulse % clip.length;
+                        // Output each MIDI event from clip at appropriate frames of output buffer:
+                        for message in clip.notes[pulse].iter() {
+                            for port in self.midi_outs.iter_mut() {
+                                port.buffer_write(sample, LiveEvent::Midi {
+                                    channel: 0.into(), /* TODO */
+                                    message: *message
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+            false
+        } else {
+            true
+        }
+    }
+    /// Handle switchover from current to next playing clip.
+    fn process_switchover (&mut self, scope: &ProcessScope) {
+        let midi_buf = self.midi_buf_mut();
+        let sample0 = scope.last_frame_time() as usize;
+        //let samples = scope.n_frames() as usize;
+        if let Some((start_at, clip)) = &self.next_clip() {
+            let start  = start_at.sample.get() as usize;
+            let sample = self.clock().started.read().unwrap()
+                .as_ref().unwrap().sample.get() as usize;
+            // If it's time to switch to the next clip:
+            if start <= sample0.saturating_sub(sample) {
+                // Samples elapsed since clip was supposed to start
+                let _skipped = sample0 - start;
+                // Switch over to enqueued clip
+                let started = Moment::from_sample(self.clock().timebase(), start as f64);
+                // Launch enqueued clip
+                *self.play_clip_mut() = Some((started, clip.clone()));
+                // Unset enqueuement (TODO: where to implement looping?)
+                *self.next_clip_mut() = None;
+                // Fill in remaining ticks of chunk from next clip.
+                self.process_playback(scope);
+            }
+        }
+    }
+}
+
+pub trait HasMidiBuffers {
+    fn note_buf_mut (&mut self) -> &mut Vec<u8>;
+    fn midi_buf_mut (&mut self) -> &mut Vec<Vec<Vec<u8>>>;
+}
+
+impl HasMidiBuffers for Sequencer {
+    fn note_buf_mut (&mut self) -> &mut Vec<u8> {
+        &mut self.note_buf
+    }
+    fn midi_buf_mut (&mut self) -> &mut Vec<Vec<Vec<u8>>> {
+        &mut self.midi_buf
+    }
+}
+
+pub trait MidiMonitor: HasMidiIns + HasMidiBuffers {
+    fn notes_in (&self) -> &Arc<RwLock<[bool;128]>>;
+    fn monitoring (&self) -> bool;
+    fn monitoring_mut (&mut self) -> &mut bool;
+    fn toggle_monitor (&mut self) {
+        *self.monitoring_mut() = !self.monitoring();
+    }
+    fn monitor (&mut self, scope: &ProcessScope) {
+    }
+}
+
+pub trait MidiRecord: MidiMonitor + HasClock + HasPlayClip {
+    fn recording (&self) -> bool;
+    fn recording_mut (&mut self) -> &mut bool;
+    fn toggle_record (&mut self) {
+        *self.recording_mut() = !self.recording();
+    }
+
+    fn overdub (&self) -> bool;
+    fn overdub_mut (&mut self) -> &mut bool;
+    fn toggle_overdub (&mut self) {
+        *self.overdub_mut() = !self.overdub();
+    }
 
     fn record_clip (
         &mut self,
         scope:   &ProcessScope,
         started: Moment,
         clip:    &Option<Arc<RwLock<MidiClip>>>,
-        _midi_buf: &mut Vec<Vec<Vec<u8>>>
     ) {
         if let Some(clip) = clip {
             let sample0    = scope.last_frame_time() as usize;
@@ -133,173 +211,4 @@ pub trait MidiRecorder: HasClock + HasPlayClip + HasMidiIns {
     fn record_next (&mut self) {
         // TODO switch to next clip and record into it
     }
-
-}
-
-pub trait MidiPlayer: HasPlayClip + HasClock + HasMidiOuts {
-
-    fn notes_out (&self) -> &Arc<RwLock<[bool;128]>>;
-
-    /// Clear the section of the output buffer that we will be using,
-    /// emitting "all notes off" at start of buffer if requested.
-    fn clear (
-        &mut self, scope: &ProcessScope, out: &mut [Vec<Vec<u8>>], reset: bool
-    ) {
-        let n_frames = (scope.n_frames() as usize).min(out.len());
-        for frame in &mut out[0..n_frames] {
-            frame.clear();
-        }
-        if reset {
-            all_notes_off(out);
-        }
-    }
-
-    /// Output notes from clip to MIDI output ports.
-    fn play (
-        &mut self, scope: &ProcessScope, note_buf: &mut Vec<u8>, out: &mut [Vec<Vec<u8>>]
-    ) -> bool {
-        if !self.clock().is_rolling() {
-            return false
-        }
-        // If a clip is playing, write a chunk of MIDI events from it to the output buffer.
-        // If no clip is playing, prepare for switchover immediately.
-        if let Some((started, clip)) = self.play_clip() {
-            self.play_chunk(scope, note_buf, out, started, clip)
-        } else {
-            true
-        }
-    }
-
-    fn play_chunk (
-        &self,
-        scope:    &ProcessScope,
-        note_buf: &mut Vec<u8>,
-        out:      &mut [Vec<Vec<u8>>],
-        started:  &Moment,
-        clip:     &Option<Arc<RwLock<MidiClip>>>
-    ) -> bool {
-        // Index of first sample to populate.
-        let offset = self.get_sample_offset(scope, started);
-        // Notes active during current chunk.
-        let notes  = &mut self.notes_out().write().unwrap();
-        // Length of clip.
-        let length = clip.as_ref().map_or(0, |p|p.read().unwrap().length);
-        // Write MIDI events from clip at sample offsets corresponding to pulses.
-        for (sample, pulse) in self.get_pulses(scope, offset) {
-            // If a next clip is enqueued, and we're past the end of the current one,
-            // break the loop here (FIXME count pulse correctly)
-            let past_end = if clip.is_some() { pulse >= length } else { true };
-            // Is it time for switchover?
-            if self.next_clip().is_some() && past_end {
-                return true
-            }
-            // If there's a currently playing clip, output notes from it to buffer:
-            if let Some(ref clip) = clip {
-                Self::play_pulse(clip, pulse, sample, note_buf, out, notes)
-            }
-        }
-        false
-    }
-
-    /// Get index of first sample to populate.
-    ///
-    /// Greater than 0 means that the first pulse of the clip
-    /// falls somewhere in the middle of the chunk.
-    fn get_sample_offset (&self, scope: &ProcessScope, started: &Moment) -> usize{
-        (scope.last_frame_time() as usize).saturating_sub(
-            started.sample.get() as usize +
-            self.clock().started.read().unwrap().as_ref().unwrap().sample.get() as usize
-        )
-    }
-
-    // Get iterator that emits sample paired with pulse.
-    //
-    // * Sample: index into output buffer at which to write MIDI event
-    // * Pulse: index into clip from which to take the MIDI event
-    //
-    // Emitted for each sample of the output buffer that corresponds to a MIDI pulse.
-    fn get_pulses (&self, scope: &ProcessScope, offset: usize) -> TicksIterator {
-        self.clock().timebase().pulses_between_samples(
-            offset, offset + scope.n_frames() as usize)
-    }
-
-    /// Handle switchover from current to next playing clip.
-    fn switchover (
-        &mut self, scope: &ProcessScope, note_buf: &mut Vec<u8>, out: &mut [Vec<Vec<u8>>]
-    ) {
-        if !self.clock().is_rolling() {
-            return
-        }
-        let sample0 = scope.last_frame_time() as usize;
-        //let samples = scope.n_frames() as usize;
-        if let Some((start_at, clip)) = &self.next_clip() {
-            let start  = start_at.sample.get() as usize;
-            let sample = self.clock().started.read().unwrap()
-                .as_ref().unwrap().sample.get() as usize;
-            // If it's time to switch to the next clip:
-            if start <= sample0.saturating_sub(sample) {
-                // Samples elapsed since clip was supposed to start
-                let _skipped = sample0 - start;
-                // Switch over to enqueued clip
-                let started = Moment::from_sample(self.clock().timebase(), start as f64);
-                // Launch enqueued clip
-                *self.play_clip_mut() = Some((started, clip.clone()));
-                // Unset enqueuement (TODO: where to implement looping?)
-                *self.next_clip_mut() = None;
-                // Fill in remaining ticks of chunk from next clip.
-                self.play(scope, note_buf, out);
-            }
-        }
-    }
-
-    fn play_pulse (
-        clip:   &RwLock<MidiClip>,
-        pulse:    usize,
-        sample:   usize,
-        note_buf: &mut Vec<u8>,
-        out:      &mut [Vec<Vec<u8>>],
-        notes:    &mut [bool;128]
-    ) {
-        // Source clip from which the MIDI events will be taken.
-        let clip = clip.read().unwrap();
-        // Clip with zero length is not processed
-        if clip.length > 0 {
-            // Current pulse index in source clip
-            let pulse = pulse % clip.length;
-            // Output each MIDI event from clip at appropriate frames of output buffer:
-            for message in clip.notes[pulse].iter() {
-                // Clear output buffer for this MIDI event.
-                note_buf.clear();
-                // TODO: support MIDI channels other than CH1.
-                let channel = 0.into();
-                // Serialize MIDI event into message buffer.
-                LiveEvent::Midi { channel, message: *message }
-                    .write(note_buf)
-                    .unwrap();
-                // Append serialized message to output buffer.
-                out[sample].push(note_buf.clone());
-                // Update the list of currently held notes.
-                update_keys(&mut*notes, message);
-            }
-        }
-    }
-
-    /// Write a chunk of MIDI data from the output buffer to all assigned output ports.
-    fn write (&mut self, scope: &ProcessScope, out: &[Vec<Vec<u8>>]) {
-        let samples = scope.n_frames() as usize;
-        for port in self.midi_outs_mut().iter_mut() {
-            Self::write_port(&mut port.port_mut().writer(scope), samples, out)
-        }
-    }
-
-    /// Write a chunk of MIDI data from the output buffer to an output port.
-    fn write_port (writer: &mut MidiWriter, samples: usize, out: &[Vec<Vec<u8>>]) {
-        for (time, events) in out.iter().enumerate().take(samples) {
-            for bytes in events.iter() {
-                writer.write(&RawMidi { time: time as u32, bytes }).unwrap_or_else(|_|{
-                    panic!("Failed to write MIDI data: {bytes:?}");
-                });
-            }
-        }
-    }
 }

crates/device/src/sequencer/seq_model.rs

@@ -2,17 +2,17 @@
 use crate::*;
 
 impl<T: Has<Sequencer>> HasSequencer for T {
-    fn sequencer (&self) -> &impl MidiSequencer {
+    fn sequencer (&self) -> &Sequencer {
         self.get()
     }
-    fn sequencer_mut (&mut self) -> &mut impl MidiSequencer {
+    fn sequencer_mut (&mut self) -> &mut Sequencer {
         self.get_mut()
     }
 }
 
 pub trait HasSequencer {
-    fn sequencer (&self) -> &impl MidiSequencer;
+    fn sequencer (&self) -> &Sequencer;
-    fn sequencer_mut (&mut self) -> &mut impl MidiSequencer;
+    fn sequencer_mut (&mut self) -> &mut Sequencer;
 }
 
 /// Contains state for playing a clip
@@ -41,6 +41,8 @@ pub struct Sequencer {
     pub notes_out:  Arc<RwLock<[bool; 128]>>,
     /// MIDI output buffer
     pub note_buf:   Vec<u8>,
+    /// MIDI output buffer
+    pub midi_buf:   Vec<Vec<Vec<u8>>>,
 }
 
 impl Default for Sequencer {
@@ -55,6 +57,7 @@ impl Default for Sequencer {
             notes_in:   RwLock::new([false;128]).into(),
             notes_out:  RwLock::new([false;128]).into(),
             note_buf:   vec![0;8],
+            midi_buf:   vec![],
             reset:      true,
 
             midi_ins:   vec![],
@@ -80,14 +83,10 @@ impl Sequencer {
             midi_outs:  vec![JackMidiOut::new(jack, format!("{}/M", name.as_ref()), midi_to)?,  ],
             play_clip:  clip.map(|clip|(Moment::zero(&clock.timebase), Some(clip.clone()))),
             clock,
-            note_buf:   vec![0;8],
             reset:      true,
-            recording:  false,
-            monitoring: false,
-            overdub:    false,
-            next_clip:  None,
             notes_in:   RwLock::new([false;128]).into(),
             notes_out:  RwLock::new([false;128]).into(),
+            ..Default::default()
         })
     }
 }
@@ -106,12 +105,9 @@ has!(Clock:            |self: Sequencer|self.clock);
 has!(Vec<JackMidiIn>:  |self:Sequencer| self.midi_ins);
 has!(Vec<JackMidiOut>: |self:Sequencer| self.midi_outs);
 
-impl MidiRecorder for Sequencer {
+impl MidiMonitor for Sequencer {
-    fn recording (&self) -> bool {
+    fn notes_in (&self) -> &Arc<RwLock<[bool; 128]>> {
-        self.recording
+        &self.notes_in
-    }
-    fn recording_mut (&mut self) -> &mut bool {
-        &mut self.recording
     }
     fn monitoring (&self) -> bool {
         self.monitoring
@@ -119,21 +115,21 @@ impl MidiRecorder for Sequencer {
     fn monitoring_mut (&mut self) -> &mut bool {
         &mut self.monitoring
     }
+}
+
+impl MidiRecord for Sequencer {
+    fn recording (&self) -> bool {
+        self.recording
+    }
+    fn recording_mut (&mut self) -> &mut bool {
+        &mut self.recording
+    }
     fn overdub (&self) -> bool {
         self.overdub
     }
     fn overdub_mut (&mut self) -> &mut bool {
         &mut self.overdub
     }
-    fn notes_in (&self) -> &Arc<RwLock<[bool; 128]>> {
-        &self.notes_in
-    }
-}
-
-impl MidiPlayer for Sequencer {
-    fn notes_out (&self) -> &Arc<RwLock<[bool; 128]>> {
-        &self.notes_out
-    }
 }
 
 impl HasPlayClip for Sequencer {

crates/engine/src/jack/jack_port.rs

@@ -233,5 +233,3 @@ impl_port!(JackAudioIn:  AudioIn  -> AudioOut |j, n|j.register_port::<AudioIn>(n
 impl_port!(JackAudioOut: AudioOut -> AudioIn  |j, n|j.register_port::<AudioOut>(n));
 
 impl_port!(JackMidiIn:   MidiIn   -> MidiOut  |j, n|j.register_port::<MidiIn>(n));
-
-impl_port!(JackMidiOut:  MidiOut  -> MidiIn   |j, n|j.register_port::<MidiOut>(n));

crates/engine/src/lib.rs

@@ -18,6 +18,16 @@ pub trait Has<T>: Send + Sync {
     fn get_mut (&mut self) -> &mut T;
 }
 
+pub trait MaybeHas<T>: Send + Sync {
+    fn get (&self) -> Option<&T>;
+}
+
+impl<T, U: Has<Option<T>>> MaybeHas<T> for U {
+    fn get (&self) -> Option<&T> {
+        Has::<Option<T>>::get(self).as_ref()
+    }
+}
+
 #[macro_export] macro_rules! has {
     ($T:ty: |$self:ident : $S:ty| $x:expr) => {
         impl Has<$T> for $S {
@@ -27,6 +37,14 @@ pub trait Has<T>: Send + Sync {
     };
 }
 
+#[macro_export] macro_rules! as_ref {
+    ($T:ty: |$self:ident : $S:ty| $x:expr) => {
+        impl AsRef<$T> for $S {
+            fn as_ref (&$self) -> &$T { &$x }
+        }
+    };
+}
+
 pub trait HasN<T>: Send + Sync {
     fn get_nth     (&self,     key: usize) -> &T;
     fn get_nth_mut (&mut self, key: usize) -> &mut T;

crates/engine/src/midi.rs

@@ -11,15 +11,7 @@ pub use ::midly::{
 
 mod midi_in;   pub use self::midi_in::*;
 mod midi_out;  pub use self::midi_out::*;
-
+mod midi_hold; pub use self::midi_hold::*;
-/// Update notes_in array
-pub fn update_keys (keys: &mut[bool;128], message: &MidiMessage) {
-    match message {
-        MidiMessage::NoteOn  { key, .. } => { keys[key.as_int() as usize] = true; }
-        MidiMessage::NoteOff { key, .. } => { keys[key.as_int() as usize] = false; },
-        _ => {}
-    }
-}
 
 /// Return boxed iterator of MIDI events
 pub fn parse_midi_input <'a> (input: ::jack::MidiIter<'a>) -> Box<dyn Iterator<Item=(usize, LiveEvent<'a>, &'a [u8])> + 'a> {

crates/engine/src/midi/midi_hold.rs

@@ -0,0 +1,10 @@
+use crate::*;
+
+/// Update notes_in array
+pub fn update_keys (keys: &mut[bool;128], message: &MidiMessage) {
+    match message {
+        MidiMessage::NoteOn  { key, .. } => { keys[key.as_int() as usize] = true; }
+        MidiMessage::NoteOff { key, .. } => { keys[key.as_int() as usize] = false; },
+        _ => {}
+    }
+}

crates/engine/src/midi/midi_in.rs

@@ -1,5 +1,11 @@
 use crate::*;
 
+impl JackMidiIn {
+    pub fn parsed <'a> (&'a self, scope: &'a ProcessScope) -> impl Iterator<Item=(usize, LiveEvent<'a>, &'a [u8])> {
+        parse_midi_input(self.port().iter(scope))
+    }
+}
+
 #[tengri_proc::command(JackMidiIn)]
 impl MidiInputCommand {
 }

crates/engine/src/midi/midi_out.rs

@@ -1,5 +1,151 @@
 use crate::*;
 
+#[derive(Debug)] pub struct JackMidiOut {
+    /// Handle to JACK client, for receiving reconnect events.
+    jack: Jack,
+    /// Port name
+    name: Arc<str>,
+    /// Port handle.
+    port: Port<MidiOut>,
+    /// List of ports to connect to.
+    conn: Vec<PortConnect>,
+    /// List of currently held notes.
+    held: Arc<RwLock<[bool;128]>>,
+    /// Buffer
+    note_buffer: Vec<u8>,
+    /// Buffer
+    output_buffer: Vec<Vec<Vec<u8>>>,
+}
+
+has!(Jack: |self: JackMidiOut|self.jack);
+
+impl JackMidiOut {
+    pub fn new (jack: &Jack, name: impl AsRef<str>, connect: &[PortConnect])
+        -> Usually<Self>
+    {
+        let jack = jack.clone();
+        let port = jack.register_port::<MidiOut>(name.as_ref())?;
+        let name = name.as_ref().into();
+        let conn = connect.to_vec();
+        let port = Self {
+            jack,
+            port,
+            name,
+            conn,
+            held: Arc::new([false;128].into()),
+            note_buffer: vec![0;8],
+            output_buffer: vec![vec![];65536],
+        };
+        port.connect_to_matching()?;
+        Ok(port)
+    }
+    pub fn name (&self) -> &Arc<str> {
+        &self.name
+    }
+    pub fn port (&self) -> &Port<MidiOut> {
+        &self.port
+    }
+    pub fn port_mut (&mut self) -> &mut Port<MidiOut> {
+        &mut self.port
+    }
+    pub fn into_port (self) -> Port<MidiOut> {
+        self.port
+    }
+    pub fn close (self) -> Usually<()> {
+        let Self { jack, port, .. } = self;
+        Ok(jack.with_client(|client|client.unregister_port(port))?)
+    }
+    /// Clear the section of the output buffer that we will be using,
+    /// emitting "all notes off" at start of buffer if requested.
+    pub fn buffer_clear (&mut self, scope: &ProcessScope, reset: bool) {
+        let n_frames = (scope.n_frames() as usize).min(self.output_buffer.len());
+        for frame in &mut self.output_buffer[0..n_frames] {
+            frame.clear();
+        }
+        if reset {
+            all_notes_off(&mut self.output_buffer);
+        }
+    }
+    /// Write a note to the output buffer
+    pub fn buffer_write <'a> (
+        &'a mut self,
+        sample: usize,
+        event:  LiveEvent,
+    ) {
+        self.note_buffer.fill(0);
+        event.write(&mut self.note_buffer).expect("failed to serialize MIDI event");
+        self.output_buffer[sample].push(self.note_buffer.clone());
+        // Update the list of currently held notes.
+        if let LiveEvent::Midi { ref message, .. } = event {
+            update_keys(&mut*self.held.write().unwrap(), message);
+        }
+    }
+    /// Write a chunk of MIDI data from the output buffer to the output port.
+    pub fn buffer_emit (&mut self, scope: &ProcessScope) {
+        let samples = scope.n_frames() as usize;
+        let mut writer = self.port.writer(scope);
+        for (time, events) in self.output_buffer.iter().enumerate().take(samples) {
+            for bytes in events.iter() {
+                writer.write(&RawMidi { time: time as u32, bytes }).unwrap_or_else(|_|{
+                    panic!("Failed to write MIDI data: {bytes:?}");
+                });
+            }
+        }
+    }
+}
+
+impl AsRef<Port<MidiOut>> for JackMidiOut {
+    fn as_ref (&self) -> &Port<MidiOut> {
+        &self.port
+    }
+}
+
+impl JackPort for JackMidiOut {
+    type Port = MidiOut;
+    type Pair = MidiIn;
+    fn port (&self) -> &Port<MidiOut> { &self.port }
+}
+
+impl JackPortConnect<&str> for JackMidiOut {
+    fn connect_to (&self, to: &str) -> Usually<PortConnectStatus> {
+        self.with_client(|c|if let Some(ref port) = c.port_by_name(to.as_ref()) {
+            self.connect_to(port)
+        } else {
+            Ok(Missing)
+        })
+    }
+}
+
+impl JackPortConnect<&Port<Unowned>> for JackMidiOut {
+    fn connect_to (&self, port: &Port<Unowned>) -> Usually<PortConnectStatus> {
+        self.with_client(|c|Ok(if let Ok(_) = c.connect_ports(&self.port, port) {
+            Connected
+        } else if let Ok(_) = c.connect_ports(port, &self.port) {
+            Connected
+        } else {
+            Mismatch
+        }))
+    }
+}
+
+impl JackPortConnect<&Port<MidiIn>> for JackMidiOut {
+    fn connect_to (&self, port: &Port<MidiIn>) -> Usually<PortConnectStatus> {
+        self.with_client(|c|Ok(if let Ok(_) = c.connect_ports(&self.port, port) {
+            Connected
+        } else if let Ok(_) = c.connect_ports(port, &self.port) {
+            Connected
+        } else {
+            Mismatch
+        }))
+    }
+}
+
+impl JackPortAutoconnect for JackMidiOut {
+    fn conn (&self) -> &[PortConnect] {
+        &self.conn
+    }
+}
+
 #[tengri_proc::command(JackMidiOut)]
 impl MidiOutputCommand {
 }
@@ -29,6 +175,11 @@ pub trait HasMidiOuts {
             data
         })
     }
+    fn midi_outs_emit (&mut self, scope: &ProcessScope) {
+        for port in self.midi_outs_mut().iter_mut() {
+            port.buffer_emit(scope)
+        }
+    }
 }
 
 /// Trail for thing that may gain new MIDI ports.

deps/tengri

@@ -1 +1 @@
-Subproject commit bad20f5037dc22d572a8381840fab871ce65f565
+Subproject commit a9619ab9cea40aed3ec30483f4a7db03ca7fec9d