use ssh clone urls

.gitmodules

@@ -1,13 +1,13 @@
 [submodule "rust-jack"]
 	path = rust-jack
-	url = https://codeberg.org/unspeaker/rust-jack
+	url = ssh://git@codeberg.org:unspeaker/rust-jack.git
 	branch = timebase
 [submodule "tengri"]
 	path = tengri
-	url = https://codeberg.org/unspeaker/tengri
+	url = ssh://git@codeberg.org:unspeaker/tengri.git
 [submodule "deps/rust-jack"]
 	path = tengri/rust-jack
-	url = https://codeberg.org/unspeaker/rust-jack
+	url = ssh://git@codeberg.org:unspeaker/rust-jack.git
 [submodule "deps/dizzle"]
 	path = tengri/dizzle
 	url = ssh://git@codeberg.org/unspeaker/dizzle.git

src/app.rs

@@ -0,0 +1,363 @@
+use crate::*;
+pub mod audio;  #[allow(unused)] pub use self::audio::*;
+pub mod bind;   pub use self::bind::*;
+pub mod cli;    pub use self::cli::*;
+pub mod config; pub use self::config::*;
+pub mod draw;   pub use self::draw::*;
+pub mod size;   pub use self::size::*;
+
+/// Total application state.
+///
+/// ```
+/// use tek::{HasTracks, HasScenes, TracksView, ScenesView};
+/// let mut app = tek::App::default();
+/// let _ = app.scene_add(None, None).unwrap();
+/// let _ = app.update_clock();
+/// app.project.editor = Some(Default::default());
+/// //let _: Vec<_> = app.project.inputs_with_sizes().collect();
+/// //let _: Vec<_> = app.project.outputs_with_sizes().collect();
+/// let _: Vec<_> = app.project.tracks_with_sizes().collect();
+/// //let _: Vec<_> = app.project.scenes_with_sizes(true, 10, 10).collect();
+/// //let _: Vec<_> = app.scenes_with_colors(true, 10).collect();
+/// //let _: Vec<_> = app.scenes_with_track_colors(true, 10, 10).collect();
+/// let _ = app.project.w();
+/// //let _ = app.project.w_sidebar();
+/// //let _ = app.project.w_tracks_area();
+/// let _ = app.project.h();
+/// //let _ = app.project.h_tracks_area();
+/// //let _ = app.project.h_inputs();
+/// //let _ = app.project.h_outputs();
+/// let _ = app.project.h_scenes();
+/// ```
+#[derive(Default, Debug)] pub struct App {
+    /// Base color.
+    pub color:   ItemTheme,
+    /// Must not be dropped for the duration of the process
+    pub jack:    Jack<'static>,
+    /// Display size
+    pub size:    Sizer,
+    /// Performance counter
+    pub perf:    PerfModel,
+    /// Available view modes and input bindings
+    pub config:  Config,
+    /// Currently selected mode
+    pub mode:    Arc<Mode<Arc<str>>>,
+    /// Undo history
+    pub history: Vec<(AppCommand, Option<AppCommand>)>,
+    /// Dialog overlay
+    pub dialog:  Dialog,
+    /// Contains all recently created clips.
+    pub pool:    Pool,
+    /// Contains the currently edited musical arrangement
+    pub project: Arrangement,
+    /// Error, if any
+    pub error:   Arc<RwLock<Option<Arc<str>>>>
+}
+
+impl App {
+
+    /// Create a new application instance from a backend, project, config, and mode
+    ///
+    /// ```
+    /// let jack = tek::tengri::Jack::new(&"test_tek").expect("failed to connect to jack");
+    /// let proj = tek::Arrangement::default();
+    /// let mut conf = tek::Config::default();
+    /// conf.add("(mode hello)");
+    /// let tek = tek::App::new(&jack, proj, conf, "hello");
+    /// ```
+    pub fn new (
+        jack: &Jack<'static>, project: Arrangement, config: Config, mode: impl AsRef<str>
+    ) -> Self {
+        let mode: &str = mode.as_ref();
+        App {
+            color:  ItemTheme::random(),
+            dialog: Dialog::welcome(),
+            jack:   jack.clone(),
+            mode:   config.get_mode(mode).expect(&format!("failed to find mode '{mode}'")),
+            config,
+            project,
+            ..Default::default()
+        }
+    }
+
+    pub fn confirm (&mut self) -> Perhaps<AppCommand> {
+        Ok(match &self.dialog {
+            Dialog::Menu(index, items) => {
+                let callback = items.0[*index].1.clone();
+                callback(self)?;
+                None
+            },
+            _ => todo!(),
+        })
+    }
+
+    pub fn inc (&mut self, axis: &ControlAxis) -> Perhaps<AppCommand> {
+        Ok(match (&self.dialog, axis) {
+            (Dialog::None, _) => todo!(),
+            (Dialog::Menu(_, _), ControlAxis::Y) =>
+                AppCommand::SetDialog { dialog: self.dialog.menu_next() }.act(self)?,
+            _ => todo!()
+        })
+    }
+
+    pub fn dec (&mut self, axis: &ControlAxis) -> Perhaps<AppCommand> {
+        Ok(match (&self.dialog, axis) {
+            (Dialog::None, _) => None,
+            (Dialog::Menu(_, _), ControlAxis::Y) =>
+                AppCommand::SetDialog { dialog: self.dialog.menu_prev() }.act(self)?,
+            _ => todo!()
+        })
+    }
+
+    /// Update memoized render of clock values.
+    /// ```
+    /// tek::App::default().update_clock();
+    /// ```
+    pub fn update_clock (&self) {
+        ClockView::update_clock(&self.project.clock.view_cache, self.clock(), self.size.w() > 80)
+    }
+
+    /// Set modal dialog.
+    ///
+    /// ```
+    /// let previous: tek::Dialog = tek::App::default().set_dialog(tek::Dialog::welcome());
+    /// ```
+    pub fn set_dialog (&mut self, mut dialog: Dialog) -> Dialog {
+        std::mem::swap(&mut self.dialog, &mut dialog);
+        dialog
+    }
+
+    /// FIXME: generalize. Set picked device in device pick dialog.
+    ///
+    /// ```
+    /// tek::App::default().device_pick(0);
+    /// ```
+    pub fn device_pick (&mut self, index: usize) {
+        self.dialog = Dialog::Device(index);
+    }
+
+    /// FIXME: generalize. Add device to current track.
+    pub fn add_device (&mut self, index: usize) -> Usually<()> {
+        match index {
+            0 => {
+                let name    = self.jack.with_client(|c|c.name().to_string());
+                let midi    = self.project.track().expect("no active track").sequencer.midi_outs[0].port_name();
+                let track   = self.track().expect("no active track");
+                let port    = format!("{}/Sampler", &track.name);
+                let connect = Connect::exact(format!("{name}:{midi}"));
+                let sampler = if let Ok(sampler) = Sampler::new(
+                    &self.jack, &port, &[connect], &[&[], &[]], &[&[], &[]]
+                ) {
+                    self.dialog = Dialog::None;
+                    Device::Sampler(sampler)
+                } else {
+                    self.dialog = Dialog::Message("Failed to add device.".into());
+                    return Err("failed to add device".into())
+                };
+                let track   = self.track_mut().expect("no active track");
+                track.devices.push(sampler);
+                Ok(())
+            },
+            1 => {
+                todo!();
+                //Ok(())
+            },
+            _ => unreachable!(),
+        }
+    }
+
+    /// Return reference to content browser if open.
+    ///
+    /// ```
+    /// assert_eq!(tek::App::default().browser(), None);
+    /// ```
+    pub fn browser (&self) -> Option<&Browse> {
+        if let Dialog::Browse(_, ref b) = self.dialog { Some(b) } else { None }
+    }
+
+    /// Is a MIDI editor currently focused?
+    ///
+    /// ```
+    /// tek::App::default().editor_focused();
+    /// ```
+    pub fn editor_focused (&self) -> bool {
+        false
+    }
+
+    /// Toggle MIDI editor.
+    ///
+    /// ```
+    /// tek::App::default().toggle_editor(None);
+    /// ```
+    pub fn toggle_editor (&mut self, value: Option<bool>) {
+        //FIXME: self.editing.store(value.unwrap_or_else(||!self.is_editing()), Relaxed);
+        let value = value.unwrap_or_else(||!self.editor().is_some());
+        if value {
+            // Create new clip in pool when entering empty cell
+            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, clip) = self.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(editor) = &mut self.project.editor {
+                    editor.set_clip(Some(&clip));
+                }
+                *slot = Some(clip.clone());
+                //Some(clip)
+            } else {
+                //None
+            }
+        } else 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()
+        {
+            // Remove clip from arrangement when exiting empty clip editor
+            let mut swapped = None;
+            if clip.read().unwrap().count_midi_messages() == 0 {
+                std::mem::swap(&mut swapped, slot);
+            }
+            if let Some(clip) = swapped {
+                self.pool.delete_clip(&clip.read().unwrap());
+            }
+        }
+    }
+}
+
+impl_has!(Clock:             |self: App|self.project.clock);
+impl_has!(Vec<MidiInput>:    |self: App|self.project.midi_ins);
+impl_has!(Vec<MidiOutput>:   |self: App|self.project.midi_outs);
+impl_has!(Dialog:            |self: App|self.dialog);
+impl_has!(Jack<'static>:     |self: App|self.jack);
+impl_has!(Pool:              |self: App|self.pool);
+impl_has!(Selection:         |self: App|self.project.selection);
+impl_as_ref!(Vec<Scene>:     |self: App|self.project.as_ref());
+impl_as_mut!(Vec<Scene>:     |self: App|self.project.as_mut());
+impl_as_ref_opt!(MidiEditor: |self: App|self.project.as_ref_opt());
+impl_as_mut_opt!(MidiEditor: |self: App|self.project.as_mut_opt());
+impl_has_clips!(             |self: App|self.pool.clips);
+
+primitive!(u8:    try_to_u8);
+primitive!(u16:   try_to_u16);
+primitive!(usize: try_to_usize);
+primitive!(isize: try_to_isize);
+
+namespace!(App: Arc<str> { literal = |dsl|Ok(dsl.src()?.map(|x|x.into())); });
+
+namespace!(App: u8       { literal = |dsl|try_to_u8(dsl); });
+
+namespace!(App: u16      { literal = |dsl|try_to_u16(dsl); symbol = |app| {
+    ":w/sidebar"        => app.project.w_sidebar(app.editor().is_some()),
+    ":h/sample-detail"  => 6.max(app.size.h() as u16 * 3 / 9), }; });
+
+namespace!(App: isize    { literal = |dsl|try_to_isize(dsl); });
+
+namespace!(App: usize    { literal = |dsl|try_to_usize(dsl); symbol = |app| {
+    ":scene-count"      => app.scenes().len(),
+    ":track-count"      => app.tracks().len(),
+    ":device-kind"      => app.dialog.device_kind().unwrap_or(0),
+    ":device-kind/next" => app.dialog.device_kind_next().unwrap_or(0),
+    ":device-kind/prev" => app.dialog.device_kind_prev().unwrap_or(0), }; });
+
+namespace!(App: bool { symbol = |app| { // Provide boolean values.
+    ":mode/editor"         => app.project.editor.is_some(),
+    ":focused/dialog"      => !matches!(app.dialog, Dialog::None),
+    ":focused/message"     => matches!(app.dialog, Dialog::Message(..)),
+    ":focused/add_device"  => matches!(app.dialog, Dialog::Device(..)),
+    ":focused/browser"     => app.dialog.browser().is_some(),
+    ":focused/pool/import" => matches!(app.pool.mode, Some(PoolMode::Import(..))),
+    ":focused/pool/export" => matches!(app.pool.mode, Some(PoolMode::Export(..))),
+    ":focused/pool/rename" => matches!(app.pool.mode, Some(PoolMode::Rename(..))),
+    ":focused/pool/length" => matches!(app.pool.mode, Some(PoolMode::Length(..))),
+    ":focused/clip"        => !app.editor_focused() && matches!(app.selection(), Selection::TrackClip{..}),
+    ":focused/track"       => !app.editor_focused() && matches!(app.selection(), Selection::Track(..)),
+    ":focused/scene"       => !app.editor_focused() && matches!(app.selection(), Selection::Scene(..)),
+    ":focused/mix"         => !app.editor_focused() && matches!(app.selection(), Selection::Mix),
+}; });
+
+namespace!(App: ItemTheme {}); // TODO: provide colors here
+                               //
+namespace!(App: Selection { symbol = |app| {
+    ":select/scene"      => app.selection().select_scene(app.tracks().len()),
+    ":select/scene/next" => app.selection().select_scene_next(app.scenes().len()),
+    ":select/scene/prev" => app.selection().select_scene_prev(),
+    ":select/track"      => app.selection().select_track(app.tracks().len()),
+    ":select/track/next" => app.selection().select_track_next(app.tracks().len()),
+    ":select/track/prev" => app.selection().select_track_prev(),
+}; });
+
+namespace!(App: Color {
+    symbol     = |app| {
+        ":color/bg" => Color::Rgb(28, 32, 36),
+    };
+    expression = |app| {
+        "g"   (n: u8) => Color::Rgb(n, n, n),
+        "rgb" (r: u8, g: u8, b: u8) => Color::Rgb(r, g, b),
+    };
+});
+
+namespace!(App: Option<u7> { symbol = |app| {
+    ":editor/pitch" => Some((app.editor().as_ref().map(|e|e.get_note_pos()).unwrap() as u8).into())
+}; });
+
+namespace!(App: Option<u16> { symbol = |app| {}; });
+
+namespace!(App: Option<usize> { symbol = |app| {
+    ":selected/scene" => app.selection().scene(),
+    ":selected/track" => app.selection().track(),
+}; });
+
+namespace!(App: Option<Arc<RwLock<MidiClip>>> { symbol = |app| {
+    ":selected/clip" => if let Selection::TrackClip { track, scene } = app.selection() {
+        app.scenes()[*scene].clips[*track].clone()
+    } else {
+        None
+    }
+}; });
+
+pub fn swap_value <T: Clone + PartialEq, U> (
+    target: &mut T, value: &T, returned: impl Fn(T)->U
+) -> Perhaps<U> {
+    if *target == *value {
+        Ok(None)
+    } else {
+        let mut value = value.clone();
+        std::mem::swap(target, &mut value);
+        Ok(Some(returned(value)))
+    }
+}
+
+pub fn toggle_bool <U> (
+    target: &mut bool, value: &Option<bool>, returned: impl Fn(Option<bool>)->U
+) -> Perhaps<U> {
+    let mut value = value.unwrap_or(!*target);
+    if value == *target {
+        Ok(None)
+    } else {
+        std::mem::swap(target, &mut value);
+        Ok(Some(returned(Some(value))))
+    }
+}
+
+pub fn scan (dir: &PathBuf) -> Usually<(Vec<OsString>, Vec<OsString>)> {
+    let (mut subdirs, mut files) = std::fs::read_dir(dir)?
+        .fold((vec!["..".into()], vec![]), |(mut subdirs, mut files), entry|{
+            let entry = entry.expect("failed to read drectory entry");
+            let meta = entry.metadata().expect("failed to read entry metadata");
+            if meta.is_file() {
+                files.push(entry.file_name());
+            } else if meta.is_dir() {
+                subdirs.push(entry.file_name());
+            }
+            (subdirs, files)
+        });
+    subdirs.sort();
+    files.sort();
+    Ok((subdirs, files))
+}
+

src/app/audio.rs

@@ -0,0 +1,52 @@
+use crate::*;
+
+impl HasJack<'static> for App { fn jack (&self) -> &Jack<'static> { &self.jack } }
+
+impl_audio!(App: tek_jack_process, tek_jack_event);
+
+fn tek_jack_process (state: &mut App, client: &Client, scope: &ProcessScope) -> Control {
+    let t0 = state.perf.get_t0();
+    state.clock().update_from_scope(scope).unwrap();
+    let midi_in = state.project.midi_input_collect(scope);
+    if let Some(editor) = &state.editor() {
+        let mut pitch: Option<u7> = None;
+        for port in midi_in.iter() {
+            for event in port.iter() {
+                if let (_, Ok(LiveEvent::Midi {message: MidiMessage::NoteOn {key, ..}, ..}))
+                    = event
+                {
+                    pitch = Some(key.clone());
+                }
+            }
+        }
+        if let Some(pitch) = pitch {
+            editor.set_note_pos(pitch.as_int() as usize);
+        }
+    }
+    let result = state.project.process_tracks(client, scope);
+    state.perf.update_from_jack_scope(t0, scope);
+    result
+}
+
+fn tek_jack_event (state: &mut App, event: JackEvent) {
+    use JackEvent::*;
+    match event {
+        SampleRate(sr) => { state.clock().timebase.sr.set(sr as f64); },
+        PortRegistration(_id, true) => {
+            //let port = self.jack().port_by_id(id);
+            //println!("\rport add: {id} {port:?}");
+            //println!("\rport add: {id}");
+        },
+        PortRegistration(_id, false) => {
+            /*println!("\rport del: {id}")*/
+        },
+        PortsConnected(_a, _b, true) => { /*println!("\rport conn: {a} {b}")*/ },
+        PortsConnected(_a, _b, false) => { /*println!("\rport disc: {a} {b}")*/ },
+        ClientRegistration(_id, true) => {},
+        ClientRegistration(_id, false) => {},
+        ThreadInit => {},
+        XRun => {},
+        GraphReorder => {},
+        _ => { panic!("{event:?}"); }
+    }
+}

src/app/bind.rs

@@ -1,11 +1,41 @@
 use crate::*;
-/// A control axis.
-///
-/// ```
-/// let axis = tek::ControlAxis::X;
-/// ```
-#[derive(Debug, Copy, Clone)] pub enum ControlAxis {
-    X, Y, Z, I
+
+tui_keys!(|self: App, input| {
+    let commands = tek_commands_collect(self, input)?;
+    let results = tek_commands_execute(self, commands)?;
+    self.history.extend(results.into_iter());
+    Ok(())
+});
+
+fn tek_commands_collect (app: &App, input: &TuiEvent)
+    -> Usually<Vec<AppCommand>>
+{
+    let mut commands = vec![];
+    for id in app.mode.keys.iter() {
+        if let Some(event_map) = app.config.binds.clone().read().unwrap().get(id.as_ref())
+        && let Some(bindings) = event_map.query(input) {
+            for binding in bindings {
+                for command in binding.commands.iter() {
+                    if let Some(command) = app.namespace(command)? as Option<AppCommand> {
+                        commands.push(command)
+                    }
+                }
+            }
+        }
+    }
+    Ok(commands)
+}
+
+fn tek_commands_execute (app: &mut App, commands: Vec<AppCommand>)
+    -> Usually<Vec<(AppCommand, Option<AppCommand>)>>
+{
+    let mut history = vec![];
+    for command in commands.into_iter() {
+        let result = command.act(app);
+        match result { Err(err) => { history.push((command, None)); return Err(err)  }
+                       Ok(undo) => { history.push((command, undo)); } };
+    }
+    Ok(history)
 }
 
 /// Collection of input bindings.
@@ -56,13 +86,13 @@ pub(crate) fn load_bind (binds: &Binds, name: &impl AsRef<str>, body: &impl Lang
 
 impl Bind<TuiEvent, Arc<str>> {
     pub fn load (lang: &impl Language) -> Usually<Self> {
-        let mut map = Bind::new();
+        let mut map = Self::new();
         lang.each(|item|if item.expr().head() == Ok(Some("see")) {
             // TODO
             Ok(())
         } else if let Ok(Some(_word)) = item.expr().head().word() {
-            if let Some(key) = TuiEvent::from_dsl(item.expr()?.head()?)? {
-                map.add(key, Binding {
+            if let Some(event) = TuiKey::from_dsl(item.expr()?.head()?)?.to_crossterm() {
+                map.add(TuiEvent(event), Binding {
                     commands:    [item.expr()?.tail()?.unwrap_or_default().into()].into(),
                     condition:   None,
                     description: None,
@@ -86,6 +116,7 @@ impl Bind<TuiEvent, Arc<str>> {
 impl<E, C> Default for Bind<E, C> {
     fn default () -> Self { Self(Default::default()) }
 }
+
 impl<C: Default> Default for Binding<C> {
     fn default () -> Self {
         Self {
@@ -128,3 +159,39 @@ impl<E: Clone + Ord, C> Bind<E, C> {
 }
 
 impl_debug!(Condition |self, w| { write!(w, "*") });
+
+impl_default!(AppCommand: Self::Nop);
+
+def_command!(AppCommand: |app: App| {
+    Nop     => Ok(None),
+    Cancel  => todo!(),                                               // TODO delegate:
+    Confirm => app.confirm(),
+    Inc { axis: ControlAxis } => app.inc(axis),
+    Dec { axis: ControlAxis } => app.dec(axis),
+    SetDialog { dialog: Dialog } => {
+        swap_value(&mut app.dialog, dialog, |dialog|Self::SetDialog { dialog })
+    },
+});
+
+impl<'a> Namespace<'a, AppCommand> for App {
+    symbols!('a |app| -> AppCommand {
+        "x/inc"   => AppCommand::Inc { axis: ControlAxis::X },
+        "x/dec"   => AppCommand::Dec { axis: ControlAxis::X },
+        "y/inc"   => AppCommand::Inc { axis: ControlAxis::Y },
+        "y/dec"   => AppCommand::Dec { axis: ControlAxis::Y },
+        "confirm" => AppCommand::Confirm,
+        "cancel"  => AppCommand::Cancel,
+    });
+}
+
+/// A control axis.
+///
+/// ```
+/// let axis = tek::ControlAxis::X;
+/// ```
+#[derive(Debug, Copy, Clone)] pub enum ControlAxis {
+    X, Y, Z, I
+}
+
+//take!(DeviceCommand|state: Arrangement, iter|state.selected_device().as_ref()
+    //.map(|t|Take::take(t, iter)).transpose().map(|x|x.flatten()));

src/app/cli.rs

@@ -1,4 +1,4 @@
-use crate::{*, arrange::*, clock::*, config::*, device::*};
+use crate::*;
 
 /// The command-line interface descriptor.
 ///
@@ -61,7 +61,7 @@ use crate::{*, arrange::*, clock::*, config::*, device::*};
         #[arg(short='L', long)] left_to: Vec<String>,
         /// Audio ins to connect from right output
         #[arg(short='R', long)] right_to: Vec<String>,
-        /// Tracks to create
+        /// Tracks to creat
         #[arg(short='t', long)] tracks: Option<usize>,
         /// Scenes to create
         #[arg(short='s', long)] scenes: Option<usize>,
@@ -75,44 +75,95 @@ use crate::{*, arrange::*, clock::*, config::*, device::*};
 }
 
 /// Command-line configuration.
-#[cfg(feature = "cli")] impl Cli {
+#[cfg(feature = "cli")]
+impl Cli {
     pub fn run (&self) -> Usually<()> {
-        if let Action::Version = self.action {
-            return Ok(tek_show_version())
+        self.action.run(Config::init_new(None)?)
     }
+}
 
-        let mut config = Config::new(None);
-        config.init()?;
-
-        if let Action::Config = self.action {
-            tek_print_config(&config);
-        } else if let Action::List = self.action {
-            todo!("list sessions")
-        } else if let Action::Resume = self.action {
-            todo!("resume session")
-        } else if let Action::New {
+#[cfg(feature = "cli")]
+impl Action {
+    fn run (&self, config: Config) -> Usually<()> {
+        use Action::*;
+        match self {
+            Version => tek_show_version(),
+            Config  => tek_print_config(&config),
+            List    => todo!("list sessions"),
+            Resume  => todo!("resume session"),
+            New {
                 name, bpm, tracks, scenes, sync_lead, sync_follow,
-            midi_from, midi_from_re, midi_to, midi_to_re,
-            left_from, right_from, left_to, right_to, ..
-        } = &self.action {
-
-            // Connect to JACK
+                midi_from: mf, midi_from_re: mfr, midi_to: mt, midi_to_re: mtr,
+                left_from: lf, right_from: rf, left_to: lt, right_to: rt, ..
+            } => {
                 let name = name.as_ref().map_or("tek", |x|x.as_str());
                 let jack = Jack::new(&name)?;
+                let mut proj = tek_project_new(
+                    &jack, Clock::new(&jack, *bpm)?, &lf, &lt, &rf, &rt, &mf, &mt, &mfr, &mtr
+                )?;
+                proj.tracks_add(tracks.unwrap_or(0), None, &[], &[])?;
+                proj.scenes_add(scenes.unwrap_or(0))?;
+                //if matches!(self, Action::Status) {
+                    //// Show status and exit
+                    //tek_print_status(&proj);
+                    //return Ok(())
+                //}
+                // Initialize the app state
+                let app = Arc::new(RwLock::new(App::new(&jack, proj, config, ":menu")));
+                //if matches!(self, Action::Headless) {
+                    //// TODO: Headless mode (daemon + client over IPC, then over network...)
+                    //println!("todo headless");
+                    //return Ok(())
+                //}
+                let (_keyboard, _terminal) = Exit::run(|exited|tui_io(
+                    exited.as_ref(),
+                    &app,
+                    Duration::from_millis(100),
+                    Duration::from_millis(10),
+                    std::io::stdout()
+                ))?;
+                // Run the [Tui] and [Jack] threads with the [App] state.
+                //Tui::new(Box::new(std::io::stdout()))?.run(true, &jack.run(move|jack|{
+                    //// Between jack init and app's first cycle:
+                    //jack.sync_lead(*sync_lead, |mut state|{
+                        //let clock = app.clock();
+                        //clock.playhead.update_from_sample(state.position.frame() as f64);
+                        //state.position.bbt = Some(clock.bbt());
+                        //state.position
+                    //})?;
+                    //jack.sync_follow(*sync_follow)?;
+                    //// FIXME: They don't work properly.
+                    //Ok(app)
+                //})?)?;
+            },
+            _ => todo!()
+        }
+        Ok(())
+    }
+}
 
+pub fn tek_project_new (
+    jack:         &Jack<'static>,
+    clock:        Clock,
+    left_from:    &[impl AsRef<str>],
+    left_to:      &[impl AsRef<str>],
+    right_from:   &[impl AsRef<str>],
+    right_to:     &[impl AsRef<str>],
+    midi_from:    &[impl AsRef<str>],
+    midi_to:      &[impl AsRef<str>],
+    midi_from_re: &[impl AsRef<str>],
+    midi_to_re:   &[impl AsRef<str>],
+) -> Usually<Arrangement> {
     // TODO: Collect audio IO:
     let empty        = &[] as &[&str];
-            let left_froms   = Connect::collect(&left_from,  empty, empty);
-            let left_tos     = Connect::collect(&left_to,    empty, empty);
-            let right_froms  = Connect::collect(&right_from, empty, empty);
-            let right_tos    = Connect::collect(&right_to,   empty, empty);
+    let left_froms   = Connect::collect(left_from,  empty, empty);
+    let left_tos     = Connect::collect(left_to,    empty, empty);
+    let right_froms  = Connect::collect(right_from, empty, empty);
+    let right_tos    = Connect::collect(right_to,   empty, empty);
     let _audio_froms = &[left_froms.as_slice(), right_froms.as_slice()];
     let _audio_tos   = &[left_tos.as_slice(),   right_tos.as_slice()];
-
-            // Create initial project:
-            let clock = Clock::new(&jack, *bpm)?;
-            let mut project = Arrangement::new(
-                &jack,
+    Ok(Arrangement::new(
+        jack,
         None,
         clock,
         vec![],
@@ -123,46 +174,7 @@ use crate::{*, arrange::*, clock::*, config::*, device::*};
         Connect::collect(&midi_to, &[] as &[&str], &midi_to_re).iter().enumerate()
             .map(|(index, connect)|jack.midi_out(&format!("{index}/M"), &[connect.clone()]))
             .collect::<Result<Vec<_>, _>>()?
-            );
-            project.tracks_add(tracks.unwrap_or(0), None, &[], &[])?;
-            project.scenes_add(scenes.unwrap_or(0))?;
-
-            if matches!(self.action, Action::Status) {
-                // Show status and exit
-                tek_print_status(&project);
-                return Ok(())
-            }
-
-            // Initialize the app state
-            let app = tek(&jack, project, config, ":menu");
-            if matches!(self.action, Action::Headless) {
-                // TODO: Headless mode (daemon + client over IPC, then over network...)
-                println!("todo headless");
-                return Ok(())
-            }
-
-            // Run the [Tui] and [Jack] threads with the [App] state.
-            Tui::new(Box::new(std::io::stdout()))?.run(true, &jack.run(move|jack|{
-
-                // Between jack init and app's first cycle:
-
-                jack.sync_lead(*sync_lead, |mut state|{
-                    let clock = app.clock();
-                    clock.playhead.update_from_sample(state.position.frame() as f64);
-                    state.position.bbt = Some(clock.bbt());
-                    state.position
-                })?;
-
-                jack.sync_follow(*sync_follow)?;
-
-                // FIXME: They don't work properly.
-
-                Ok(app)
-
-            })?)?;
-        }
-        Ok(())
-    }
+    ))
 }
 
 pub fn tek_show_version () {
@@ -196,7 +208,7 @@ pub fn tek_print_config (config: &Config) {
             }
         }
     }
-    for (k, v) in config.modes.read().unwrap().iter() {
+    config.modes.for_each(|k, v|{
         println!();
         for v in v.name.iter() { print!("{}", Green.bold().paint(format!("{v} "))); }
         for v in v.info.iter() { print!("\n{}", Green.paint(format!("{v}"))); }
@@ -204,22 +216,16 @@ pub fn tek_print_config (config: &Config) {
         print!("\n{}", Blue.paint("KEYS"));
         for v in v.keys.iter() { print!("{}", Green.paint(format!(" {v}"))); }
         println!();
-        for (k, v) in v.modes.read().unwrap().iter() {
-            print!("{} {} {:?}",
-                Blue.paint("MODE"),
-                Green.bold().paint(format!("{k:<16}")),
-                v.name);
-            print!(" INFO={:?}",
-                v.info);
-            print!(" VIEW={:?}",
-                v.view);
-            println!(" KEYS={:?}",
-                v.keys);
-        }
+        v.modes.for_each(|k, v|{
+            print!("{} {} {:?}", Blue.paint("MODE"), Green.bold().paint(format!("{k:<16}")), v.name);
+            print!(  " INFO={:?}", v.info);
+            print!(  " VIEW={:?}", v.view);
+            println!(" KEYS={:?}", v.keys);
+        });
         print!("{}", Blue.paint("VIEW"));
         for v in v.view.iter() { print!("{}", Green.paint(format!(" {v}"))); }
         println!();
-    }
+    });
 }
 
 pub fn tek_print_status (project: &Arrangement) {

src/app/config.rs

@@ -1,4 +1,4 @@
-use crate::{*, bind::*, mode::*, view::*};
+use crate::*;
 
 /// Configuration: mode, view, and bind definitions.
 ///
@@ -30,17 +30,32 @@ use crate::{*, bind::*, mode::*, view::*};
     /// Active collection of view definitions.
     pub views: Views,
 }
+
 impl Config {
     const CONFIG_DIR: &'static str = "tek";
     const CONFIG_SUB: &'static str = "v0";
     const CONFIG:     &'static str = "tek.edn";
-    const DEFAULTS:   &'static str = include_str!("./tek.edn");
+    const DEFAULTS:   &'static str = include_str!("../tek.edn");
+
+    pub fn watch <T> (callback: impl FnOnce(Self)->T) -> Usually<T> {
+        let config = Self::init_new(None)?;
+        let result = callback(config);
+        Ok(result)
+    }
+
+    pub fn init_new (dirs: Option<BaseDirectories>) -> Usually<Self> {
+        let mut config = Self::new(None);
+        config.init()?;
+        Ok(config)
+    }
+
     /// Create a new app configuration from a set of XDG base directories,
     pub fn new (dirs: Option<BaseDirectories>) -> Self {
         let default = ||BaseDirectories::with_profile(Self::CONFIG_DIR, Self::CONFIG_SUB);
         let dirs = dirs.unwrap_or_else(default);
         Self { dirs, ..Default::default() }
     }
+
     /// Write initial contents of configuration.
     pub fn init (&mut self) -> Usually<()> {
         self.init_one(Self::CONFIG, Self::DEFAULTS, |cfgs, dsl|{
@@ -49,6 +64,7 @@ impl Config {
         })?;
         Ok(())
     }
+
     /// Write initial contents of a configuration file.
     pub fn init_one (
         &mut self, path: &str, defaults: &str, mut each: impl FnMut(&mut Self, &str)->Usually<()>
@@ -65,11 +81,13 @@ impl Config {
             return Err(format!("{path}: not found").into())
         })
     }
+
     /// Add statements to configuration from [Dsl] source.
     pub fn add (&mut self, dsl: impl Language) -> Usually<&mut Self> {
         dsl.each(|item|self.add_one(item))?;
         Ok(self)
     }
+
     fn add_one (&self, item: impl Language) -> Usually<()> {
         if let Some(expr) = item.expr()? {
             let head = expr.head()?;
@@ -78,7 +96,7 @@ impl Config {
             let body = tail.tail()?;
             //println!("Config::load: {} {} {}", head.unwrap_or_default(), name.unwrap_or_default(), body.unwrap_or_default());
             match head {
-                Some("mode") if let Some(name) = name => load_mode(&self.modes, &name, &body)?,
+                Some("mode") if let Some(name) = name => self.modes.add(&name, &body)?,
                 Some("keys") if let Some(name) = name => load_bind(&self.binds, &name, &body)?,
                 Some("view") if let Some(name) = name => load_view(&self.views, &name, &body)?,
                 _ => return Err(format!("Config::load: expected view/keys/mode, got: {item:?}").into())
@@ -88,5 +106,12 @@ impl Config {
             return Err(format!("Config::load: expected expr, got: {item:?}").into())
         }
     }
+
+    pub fn get_mode (&self, mode: impl AsRef<str>) -> Option<Arc<Mode<Arc<str>>>> {
+        self.modes.get(mode)
+    }
 }
 
+mod views; pub use self::views::*;
+mod modes; pub use self::modes::*;
+mod mode;  pub use self::mode::*;

src/app/config/mode.rs

@@ -1,21 +1,19 @@
-use crate::{*, config::*};
+use crate::*;
 
-impl Config {
-    pub fn get_mode (&self, mode: impl AsRef<str>) -> Option<Arc<Mode<Arc<str>>>> {
-        self.modes.clone().read().unwrap().get(mode.as_ref()).cloned()
-    }
+/// Group of view and keys definitions.
+///
+/// ```
+/// let mode = tek::Mode::<std::sync::Arc<str>>::default();
+/// ```
+#[derive(Default, Debug)] pub struct Mode<D: Language + Ord> {
+    pub path:  PathBuf,
+    pub name:  Vec<D>,
+    pub info:  Vec<D>,
+    pub view:  Vec<D>,
+    pub keys:  Vec<D>,
+    pub modes: Modes,
 }
 
-pub(crate) fn load_mode (modes: &Modes, name: &impl AsRef<str>, body: &impl Language) -> Usually<()> {
-    let mut mode = Mode::default();
-    body.each(|item|mode.add(item))?;
-    modes.write().unwrap().insert(name.as_ref().into(), Arc::new(mode));
-    Ok(())
-}
-
-/// Collection of interaction modes.
-pub type Modes = Arc<RwLock<BTreeMap<Arc<str>, Arc<Mode<Arc<str>>>>>>;
-
 impl Mode<Arc<str>> {
     /// Add a definition to the mode.
     ///
@@ -77,23 +75,9 @@ impl Mode<Arc<str>> {
     }
     fn add_mode (&mut self, dsl: impl Language) -> Perhaps<()> {
         Ok(Some(if let Some(id) = dsl.head()? {
-            load_mode(&self.modes, &id, &dsl.tail())?;
+            self.modes.add(&id, &dsl.tail())?;
         } else {
             return Err(format!("Mode::add: self: incomplete: {dsl:?}").into());
         }))
     }
 }
-/// Group of view and keys definitions.
-///
-/// ```
-/// let mode = tek::Mode::<std::sync::Arc<str>>::default();
-/// ```
-#[derive(Default, Debug)] pub struct Mode<D: Language + Ord> {
-    pub path:  PathBuf,
-    pub name:  Vec<D>,
-    pub info:  Vec<D>,
-    pub view:  Vec<D>,
-    pub keys:  Vec<D>,
-    pub modes: Modes,
-}
-

src/app/config/modes.rs

@@ -0,0 +1,27 @@
+use crate::*;
+
+/// Collection of UI modes.
+#[derive(Default, Debug, Clone)]
+pub struct Modes(
+    Arc<RwLock<BTreeMap<Arc<str>, Arc<Mode<Arc<str>>>>>>
+);
+
+impl Modes {
+    pub fn add (&self, name: &impl AsRef<str>, body: &impl Language) -> Usually<()> {
+        let mut mode = Mode::default();
+        body.each(|item|mode.add(item))?;
+        self.0.write().unwrap().insert(name.as_ref().into(), Arc::new(mode));
+        Ok(())
+    }
+    pub fn get (&self, name: impl AsRef<str>) -> Option<Arc<Mode<Arc<str>>>> {
+        self.0.read().unwrap().get(name.as_ref()).cloned()
+    }
+    pub fn for_each <T> (&self, mut ator: impl FnMut(&str, &Mode<Arc<str>>)->T) {
+        for (k, v) in self.0.read().unwrap().iter() {
+            let _ = ator(k.as_ref(), v.as_ref());
+        }
+    }
+    pub fn len (&self) -> usize {
+        self.0.read().unwrap().len()
+    }
+}

src/app/config/views.rs

@@ -1,10 +1,10 @@
 use crate::*;
 
-/// Collection of view definitions.
+/// Collection of custom view definitions.
 pub type Views = Arc<RwLock<BTreeMap<Arc<str>, Arc<str>>>>;
 
+/// Load custom view definition.
 pub(crate) fn load_view (views: &Views, name: &impl AsRef<str>, body: &impl Language) -> Usually<()> {
     views.write().unwrap().insert(name.as_ref().into(), body.src()?.unwrap_or_default().into());
     Ok(())
 }
-

src/app/draw.rs

@@ -0,0 +1,758 @@
+use crate::*;
+
+/// The [Draw] implementation for [App] handles the loaded view,
+/// which is defined in terms of [dizzle] DSL.
+///
+/// If there is an error, the error is displayed. FIXME: overlay it
+/// Then, every top-level form of the DSL description is rendered.
+impl View<Tui> for App {
+    fn view (&self) -> impl Draw<Tui> {
+        thunk(|to: &mut Tui|{
+            let xywh = to.area().into();
+            if let Some(e) = self.error.read().unwrap().as_ref() {
+                to.show(area(xywh, e.as_ref()))?;
+            }
+            for (index, dsl) in self.mode.view.iter().enumerate() {
+                if let Err(e) = self.interpret(to, dsl) {
+                    *self.error.write().unwrap() = Some(format!("view #{index}: {e}").into());
+                    break;
+                }
+            }
+            Ok(Some(xywh))
+        })
+    }
+}
+
+impl Interpret<Tui, Option<XYWH<u16>>> for App {
+    fn interpret_expr <'a> (&'a self, to: &mut Tui, lang: &'a impl Expression) -> Drawn<u16> {
+        tek_draw_expr(self, to, lang)
+    }
+    fn interpret_word <'a> (&'a self, to: &mut Tui, lang: &'a impl Expression) -> Drawn<u16> {
+        tek_draw_word(self, to, lang)
+    }
+}
+
+fn tek_draw_expr (state: &App, to: &mut Tui, lang: &impl Expression) -> Drawn<u16> {
+    Ok(Some(if let Some(area) = eval_view(state, to, lang)? {
+        area
+    } else if let Some(area) = eval_view_tui(state, to, lang)? {
+        area
+    } else {
+        return Err(format!("App::interpret_expr: unexpected: {lang:?}").into())
+    }))
+}
+
+fn tek_draw_word (state: &App, to: &mut Tui, dsl: &impl Expression) -> Drawn<u16> {
+    let mut frags = dsl.src()?.unwrap().split("/");
+    match frags.next() {
+        Some(":logo")         => view_logo().draw(to),
+        Some(":meters")       => draw_meter_section(to, frags),
+        Some(":tracks")       => draw_tracks(to, frags, state),
+        Some(":scenes")       => draw_scenes(to, frags),
+        Some(":dialog")       => draw_dialog(to, frags, state, dsl),
+        Some(":templates")    => draw_templates(to, frags, state),
+        Some(":sessions")     => view_sessions().draw(to),
+        Some(":browse/title") => view_browse_title(state).draw(to),
+        Some(":device")       => view_device(state).draw(to),
+        Some(":status")       => "TODO: Status Bar".exact_h(1).draw(to),
+        Some(":editor")       => "TODO Editor".draw(to),
+        Some(":debug")        => format!("[{:?}]", to.area()).exact_h(1).draw(to),
+        Some(_) => {
+            let views = state.config.views.read().unwrap();
+            if let Some(dsl) = views.get(dsl.src()?.unwrap()) {
+                let dsl = dsl.clone();
+                std::mem::drop(views);
+                state.interpret(to, &dsl)
+            } else {
+                unimplemented!("{dsl:?}");
+            }
+        },
+        _ => unreachable!()
+    }
+}
+
+pub fn draw_meter_section (to: &mut Tui, mut frags: std::str::Split<&str>) -> Drawn<u16> {
+    match frags.next() {
+        Some("input")  => bg(Rgb(30, 30, 30), "Input Meters".align_s().full_h()).draw(to),
+        Some("output") => bg(Rgb(30, 30, 30), "Output Meters".align_s().full_h()).draw(to),
+        _ => panic!()
+    }
+}
+
+pub fn draw_tracks (to: &mut Tui, mut frags: std::str::Split<&str>, state: &App) -> Drawn<u16> {
+    match frags.next() {
+        None            => "TODO tracks".draw(to),
+        Some("names")   => state.project.view_track_names(state.color.clone()).draw(to),//bg(Rgb(40, 40, 40), full_w(align_w("Track Names")))),
+        Some("inputs")  => bg(Rgb(40, 40, 40), "Track Inputs".align_w().full_w()).draw(to),
+        Some("devices") => bg(Rgb(40, 40, 40), "Track Devices".align_w().full_w()).draw(to),
+        Some("outputs") => bg(Rgb(40, 40, 40), "Track Outputs".align_w().full_w()).draw(to),
+        _ => panic!()
+    }
+}
+
+pub fn draw_scenes (to: &mut Tui, mut frags: std::str::Split<&str>) -> Drawn<u16> {
+    match frags.next() {
+        None                  => "TODO Scenes".draw(to),
+        Some(":scenes/names") => "TODO Scene Names".draw(to),
+        _ => panic!()
+    }
+}
+
+pub fn draw_dialog (
+    to: &mut Tui, mut frags: std::str::Split<&str>, state: &App, dsl: &impl Expression) -> Drawn<u16> {
+    match frags.next() {
+        Some("menu") => if let Dialog::Menu(selected, items) = &state.dialog {
+            let items = items.clone();
+            let selected = selected;
+            Some(thunk(move|to: &mut Tui|{
+                for (index, MenuItem(item, _)) in items.0.iter().enumerate() {
+                    let f = if *selected == index { Rgb(240,200,180) } else { Rgb(200, 200, 200) };
+                    let b = if *selected == index { Rgb(80, 80, 50)  } else { Rgb(30,  30,  30)  };
+                    fg_bg(f, b, item.full_w().align_w().exact_h(2))
+                        .push_y((2 * index) as u16).draw(to)?;
+                }
+                Ok(Some(to.area().into()))
+            }).full_wh())
+        } else {
+            None
+        }.draw(to),
+        _ => unimplemented!("App::interpret_word: {dsl:?} ({frags:?})"),
+    }
+}
+
+pub fn draw_templates (to: &mut Tui, frags: std::str::Split<&str>, state: &App) -> Drawn<u16> {
+    let height = (state.config.modes.len() * 2) as u16;
+    thunk(move |to: &mut Tui|{
+        let mut index = 0;
+        state.config.modes.for_each(|id, profile| {
+            let b          = if index == 0 { Rgb(70,70,70) } else { Rgb(50,50,50) };
+            let name       = profile.name.get(0).map(|x|x.as_ref()).unwrap_or("<no name>");
+            let info       = profile.info.get(0).map(|x|x.as_ref()).unwrap_or("<no info>");
+            let fg1        = Rgb(224, 192, 128);
+            let fg2        = Rgb(224, 128,  32);
+            let field_name = fg(fg1, name).align_w().full_w();
+            let field_id   = fg(fg2, id).align_e().full_w();
+            let field_info = info.align_w().full_w();
+            let _ = bg(b, south(above(field_name, field_id), field_info))
+                .full_w().exact_h(2).push_y((2 * index) as u16).draw(to);
+            index += 1;
+        });
+        Ok(Some(to.area().into()))
+    }).min_w(30).exact_h(height).draw(to)
+}
+
+/// ```
+/// let _ = tek::view_logo();
+/// ```
+pub fn view_logo () -> impl Draw<Tui> {
+    bold(true, fg(Rgb(240, 200, 180), south!{
+        "".exact_h(1),
+        "".exact_h(1),
+        "~~ ╓─╥─╖ ╓──╖ ╥  ╖ ~~~~~~~~~~~~".exact_h(1),
+        east("~~~~ ║ ~ ╟─╌ ~╟─<  ~~ ", east(fg(Rgb(230,100,40), "v0.3.0"), " ~~")).exact_h(1),
+        "~~~~ ╨ ~ ╙──╜ ╨  ╜ ~~~~~~~~~~~~".exact_h(1),
+    })).exact_wh(32, 7)
+}
+
+/// ```
+/// let x = "";
+/// let _ = tek::view_transport(true,  x.as_ref(), x.as_ref(), x.as_ref());
+/// let _ = tek::view_transport(false, x.as_ref(), x.as_ref(), x.as_ref());
+/// ```
+pub fn view_transport (play: bool, bpm: &str, beat: &str, time: &str) -> impl Draw<Tui> {
+    let theme = ItemTheme::G[96];
+    bg(Black, east!(above(
+        button_play_pause(play, false).align_w().full_wh(),
+        east!(
+            field_h(theme, "BPM",  bpm),
+            field_h(theme, "Beat", beat),
+            field_h(theme, "Time", time),
+        ).align_e().full_wh()
+    )))
+}
+
+/// ```
+/// let x = "";
+/// let _ = tek::view_status(None, x.as_ref(), x.as_ref(), x.as_ref());
+/// let _ = tek::view_status(Some("".into()), x.as_ref(), x.as_ref(), x.as_ref());
+/// ```
+pub fn view_status (sel: Option<&str>, sr: &str, buf: &str, lat: &str) -> impl Draw<Tui> {
+    let theme = ItemTheme::G[96];
+    let sr    = field_h(theme, "SR",  sr);
+    let buf   = field_h(theme, "Buf", buf);
+    let lat   = field_h(theme, "Lat", lat);
+    bg(Black, east!(above(
+        sel.map(|sel|field_h(theme, "Selected", sel)).align_w().full_wh(),
+        east!(sr, buf, lat).align_e().full_wh(),
+    )))
+}
+
+/// ```
+/// let _ = tek::button_play_pause(true, true);
+/// let _ = tek::button_play_pause(true, false);
+/// let _ = tek::button_play_pause(false, true);
+/// let _ = tek::button_play_pause(false, false);
+/// ```
+pub fn button_play_pause (playing: bool, compact: bool) -> impl Draw<Tui> {
+    bg(if playing { Rgb(0, 128, 0) } else { Rgb(128, 64, 0) },
+        either(compact,
+            thunk(move|to: &mut Tui|either(playing,
+                fg(Rgb(0, 255, 0),   " PLAYING "),
+                fg(Rgb(255, 128, 0), " STOPPED "),
+            ).exact_w(9).draw(to)),
+            thunk(move|to: &mut Tui|either(playing,
+                fg(Rgb(0, 255, 0),   south(" 🭍🭑🬽 ", " 🭞🭜🭘 ",)),
+                fg(Rgb(255, 128, 0), south(" ▗▄▖ ", " ▝▀▘ ",)),
+            ).exact_w(5).draw(to)),
+        )
+    )
+}
+
+#[cfg(feature = "track")] pub fn view_track_row_section (
+    _theme:     ItemTheme,
+    button:     impl Draw<Tui>,
+    button_add: impl Draw<Tui>,
+    content:    impl Draw<Tui>,
+) -> impl Draw<Tui> {
+    west(
+        button_add.align_nw().exact_w(4).full_h(),
+        east(
+            button.align_nw().full_h().exact_w(20),
+            content.align_c().full_wh()
+        )
+    )
+}
+
+/// ```
+/// let bg = tengri::ratatui::style::Color::Red;
+/// let fg = tengri::ratatui::style::Color::Green;
+/// let _  = tek::view_wrap(bg, fg, "and then blue, too!");
+/// ```
+pub fn view_wrap (bg: Color, fg: Color, content: impl Draw<Tui>) -> impl Draw<Tui> {
+    let left  = fg_bg(bg, Reset, y_repeat("▐").exact_w(1));
+    let right = fg_bg(bg, Reset, y_repeat("▌").exact_w(1));
+    east(left, west(right, fg_bg(fg, bg, content)))
+}
+
+/// ```
+/// let _ = tek::view_meter("", 0.0);
+/// let _ = tek::view_meters(&[0.0, 0.0]);
+/// ```
+pub fn view_meter <'a> (label: &'a str, value: f32) -> impl Draw<Tui> + 'a {
+    let f = field_h(ItemTheme::G[128], label, format!("{:>+9.3}", value));
+    let w =  if value >=   0.0 { 13 }
+        else if value >=  -1.0 { 12 }
+        else if value >=  -2.0 { 11 }
+        else if value >=  -3.0 { 10 }
+        else if value >=  -4.0 { 9  }
+        else if value >=  -6.0 { 8  }
+        else if value >=  -9.0 { 7  }
+        else if value >= -12.0 { 6  }
+        else if value >= -15.0 { 5  }
+        else if value >= -20.0 { 4  }
+        else if value >= -25.0 { 3  }
+        else if value >= -30.0 { 2  }
+        else if value >= -40.0 { 1  }
+        else { 0 };
+    let c = if value >= 0.0  { Red }
+        else if value >= -3.0 { Yellow }
+        else { Green };
+    south!(f, bg(c, ()).exact_wh(w, 1))
+}
+
+pub fn view_meters (values: &[f32;2]) -> impl Draw<Tui> + use<'_> {
+    let left  = format!("L/{:>+9.3}", values[0]);
+    let right = format!("R/{:>+9.3}", values[1]);
+    south(left, right)
+}
+
+pub fn view_sample_info (sample: Option<&Arc<RwLock<Sample>>>) -> impl Draw<Tui> + use<'_> {
+    when(sample.is_some(), thunk(move|to: &mut Tui|{
+        let sample = sample.unwrap().read().unwrap();
+        let theme  = sample.color;
+        east!(
+            field_h(theme, "Name",   format!("{:<10}", sample.name.clone())),
+            field_h(theme, "Length", format!("{:<8}",  sample.channels[0].len())),
+            field_h(theme, "Start",  format!("{:<8}",  sample.start)),
+            field_h(theme, "End",    format!("{:<8}",  sample.end)),
+            field_h(theme, "Trans",  "0"),
+            field_h(theme, "Gain",   format!("{}",     sample.gain)),
+        ).draw(to)
+    }))
+}
+
+pub fn view_sample_info_v (sample: Option<&Arc<RwLock<Sample>>>) -> impl Draw<Tui> + use<'_> {
+    let a = thunk(move|to: &mut Tui|{
+        let sample = sample.unwrap().read().unwrap();
+        let theme  = sample.color;
+        south!(
+            field_h(theme, "Name  ", format!("{:<10}", sample.name.clone()))     .align_w().full_w(),
+            field_h(theme, "Length", format!("{:<8}",  sample.channels[0].len())).align_w().full_w(),
+            field_h(theme, "Start ", format!("{:<8}",  sample.start))            .align_w().full_w(),
+            field_h(theme, "End   ", format!("{:<8}",  sample.end))              .align_w().full_w(),
+            field_h(theme, "Trans ", "0")                                        .align_w().full_w(),
+            field_h(theme, "Gain  ", format!("{}",     sample.gain))             .align_w().full_w(),
+        ).exact_w(20).draw(to)
+    });
+
+    let b = thunk(|to: &mut Tui|fg(Red, south!(
+        bold(true, "× No sample."),
+        "[r] record",
+        "[Shift-F9] import",
+    )).draw(to));
+
+    either(sample.is_some(), a, b)
+}
+
+pub fn view_sample_status (sample: Option<&Arc<RwLock<Sample>>>) -> impl Draw<Tui> {
+    bold(true, fg(g(224), sample
+        .map(|sample|{
+            let sample = sample.read().unwrap();
+            format!("Sample {}-{}", sample.start, sample.end)
+        })
+        .unwrap_or_else(||"No sample".to_string())))
+}
+
+pub  fn view_track_header (theme: ItemTheme, content: impl Draw<Tui>) -> impl Draw<Tui> {
+    bg(theme.darker.term, content.align_e().full_w()).exact_w(12)
+}
+
+pub fn view_ports_status <'a, T: JackPort> (theme: ItemTheme, title: &'a str, ports: &'a [T])
+    -> impl Draw<Tui> + use<'a, T>
+{
+    let ins   = ports.len() as u16;
+    let frame = Outer(true, Style::default().fg(g(96)));
+    let iter  = move||ports.iter();
+    let names = iter_south(iter, move|port, index|format!(" {index} {}", port.port_name()).align_w().full_h());
+    let field = field_v(theme, title, names);
+    border(true, frame, field.exact_wh(20, 1 + ins)).exact_wh(20, 1 + ins)
+}
+
+pub fn view_io_ports <'a, T: PortsSizes<'a>> (
+    fg: Color, bg: Color, items: impl Fn()->T + Send + Sync + 'a
+) -> impl Draw<Tui> + 'a {
+    type Item<'a> = (usize, &'a Arc<str>, &'a [Connect], usize, usize);
+    iter(items,
+        move|(_index, name, connections, y, y2): Item<'a>, _| south(
+            bold(true, fg_bg(fg, bg, east(" 󰣲 ", name).align_w())).full_h(),
+            iter(||connections.iter(), move|connect: &'a Connect, index|{
+                bold(false, fg_bg(fg, bg, &connect.info)).exact_h(1).align_w().push_y(index as u16)
+            })
+        ).exact_h((y2 - y) as u16).push_y(y as u16))
+}
+
+pub fn view_scenes_clips <'a, S: ScenesSizes<'a>> (
+    scenes:  impl Fn()->S,
+    tracks:  impl TracksSizes<'a>,
+    select:  &Selection,
+    editor:  Option<&MidiEditor>,
+    size:    &Sizer,
+    editing: bool,
+) -> impl Draw<Tui> {
+    let status = fg(Green, format!("{}x{}", size.w(), size.h())).align_se().full_wh();
+    let tracks = iter_once(tracks, move|(track_index, track, _, _), _| {
+        let scenes = iter_once(scenes(), move|(scene_index, scene, _, _), _| {
+            let (name, theme): (Arc<str>, ItemTheme) = scene_name_theme(scene, track_index);
+            let f = theme.lightest.term;
+            let (b, o) = scene_bg(theme, select, track_index, scene_index);
+            let w = scene_w(track, select, track_index, editor);
+            let y = scene_y(select, scene_index, editor);
+            let is_selected = scene_sel(select, track_index, scene_index, editing);
+            below(
+                Outer(true, Style::default().fg(o)).full_wh(),
+                below(
+                    below(
+                        fg_bg(o, b, "".full_wh()),
+                        fg_bg(f, b, bold(true, name)).align_nw().full_wh(),
+                    ),
+                    when(is_selected, editor.map(|e|e.view())).full_wh()
+                ).full_wh()
+            ).exact_wh(w, y)
+        });
+        scenes.full_h().exact_w(track.width as u16)
+    });
+
+    return size.of(above(status, tracks).full_wh());
+
+    fn scene_name_theme (scene: &Scene, track_index: usize) -> (Arc<str>, ItemTheme) {
+        if let Some(Some(clip)) = &scene.clips.get(track_index) {
+            let clip = clip.read().unwrap();
+            (format!(" ⏹ {}", &clip.name).into(), clip.color)
+        } else {
+            (" ⏹ -- ".into(), ItemTheme::G[32])
+        }
+    }
+
+    fn scene_bg (
+        theme: ItemTheme, select: &Selection, track_index: usize, scene_index: usize
+    ) -> (Color, Color) {
+        let mut outline = theme.base.term;
+        (if select.track() == Some(track_index) && select.scene() == Some(scene_index) {
+            outline = theme.lighter.term;
+            theme.light.term
+        } else if select.track() == Some(track_index) || select.scene() == Some(scene_index) {
+            outline = theme.darkest.term;
+            theme.base.term
+        } else {
+            theme.dark.term
+        }, outline)
+    }
+
+    fn scene_w (
+        track: &Track, select: &Selection, track_index: usize, editor: Option<&MidiEditor>
+    ) -> u16 {
+        if select.track() == Some(track_index) && let Some(editor) = editor {
+            (editor.size.w() as usize).max(24).max(track.width) as u16
+        } else {
+            track.width as u16
+        }
+    }
+
+    fn scene_y (
+        select: &Selection, scene_index: usize, editor: Option<&MidiEditor>
+    ) -> u16 {
+        if select.scene() == Some(scene_index) && let Some(editor) = editor {
+            editor.size.h().max(12)
+        } else {
+            H_SCENE as u16
+        }
+    }
+
+    fn scene_sel (select: &Selection, track_index: usize, scene_index: usize, editing: bool) -> bool {
+        editing && select.track() == Some(track_index) && select.scene() == Some(scene_index)
+    }
+}
+
+pub fn view_track_names (
+    theme:       ItemTheme,
+    tracks:      impl TracksSizes<'_>,
+    track_count: usize,
+    scene_count: usize,
+    selected:    &Selection,
+) -> impl Draw<Tui> {
+    let button = south(
+        button_3("t", "rack ", format!("{}{track_count}", selected.track()
+            .map(|track|format!("{track}/")).unwrap_or_default()), false),
+        button_3("s", "cene ", format!("{}{scene_count}", selected.scene()
+            .map(|scene|format!("{scene}/")).unwrap_or_default()), false));
+    let button_2 = south(
+        button_2("T", "+", false),
+        button_2("S", "+", false));
+    view_track_row_section(theme, button, button_2, bg(theme.darker.term,
+        thunk(|to: &mut Tui|{
+            for (index, track, x1, _x2) in tracks {
+                let b = if selected.track() == Some(index) {
+                    track.color.light.term
+                } else {
+                    track.color.base.term
+                };
+                bg(b, south(east(
+                    format!("·t{index:02} "),
+                    fg(Rgb(255, 255, 255), bold(true, &track.name))
+                ).align_nw().full_w(), ""))
+                    .exact_w(track_width(index, track))
+                    .push_x(x1 as u16)
+                    .draw(to)?;
+            }
+            Ok(Some(XYWH(0, 0, 0, 0)))
+        }).exact_h(2)))
+}
+
+pub fn view_track_outputs (
+    theme: ItemTheme, tracks: impl TracksSizes<'_>, midi_outs: impl Iterator<Item = &MidiOutput>,
+) -> impl Draw<Tui> {
+    view_track_row_section(theme,
+        south(button_2("o", "utput", false).align_w().full_w(),
+            thunk(|to: &mut Tui|{
+                for port in midi_outs {
+                    port.port_name().align_w().full_w().draw(to);
+                }
+                Ok(Some(XYWH(0, 0, 0, 0)))
+            })),
+        button_2("O", "+", false),
+        bg(theme.darker.term, thunk(|to: &mut Tui|{
+            for (index, track, _x1, _x2) in tracks {
+                let f = Rgb(255, 255, 255);
+                let b = track.color.dark.term;
+                let iter = ||track.sequencer.midi_outs.iter();
+                let draw = |port: &MidiOutput, _|fg(f, bg(b, 
+                    format!("·o{index:02} {}", port.port_name()).full_w().align_w()).exact_h(1));
+                iter_south(iter, draw).full_h().align_nw()
+                    .exact_w(track_width(index, track))
+                    .draw(to)?;
+            }
+            Ok(Some(XYWH(0, 0, 0, 0)))
+        }).align_w()))
+}
+
+pub fn view_track_inputs (
+    theme: ItemTheme, tracks: impl TracksSizes<'_>, height: u16,
+) -> impl Draw<Tui> {
+    view_track_row_section(theme, button_2("i", "nput", false), button_2("I", "+", false),
+        bg(theme.darker.term, thunk(move|to: &mut Tui|{
+            for (index, track, _x1, _x2) in tracks {
+                south(
+                    bg(track.color.base.term,
+                        east!(
+                            either(track.sequencer.monitoring, fg(Green,  "●mon "), "·mon "),
+                            either(track.sequencer.recording,  fg(Red,    "●rec "), "·rec "),
+                            either(track.sequencer.overdub,    fg(Yellow, "●dub "), "·dub "),
+                        ).align_w().full_w()),
+                    iter_south(||track.sequencer.midi_ins.iter(),
+                        |port, _|fg_bg(Rgb(255, 255, 255), track.color.dark.term,
+                            format!("·i{index:02} {}", port.port_name()).align_w().full_w()))
+                ).align_nw().exact_wh(track_width(index, track), height + 1).draw(to)?;
+            }
+            Ok(Some(XYWH(0, 0, 0, 0)))
+        }).align_w()))
+}
+
+pub fn view_scenes_names (
+    scenes:  impl ScenesSizes<'_>,
+    select:  &Selection,
+    editor:  Option<&MidiEditor>,
+    editing: bool,
+) -> impl Draw<Tui> {
+    thunk(move |to: &mut Tui|{
+        for (index, scene, ..) in scenes {
+            view_scene_name(select, editor, index, scene, editing).draw(to)?;
+        }
+        Ok(Some(XYWH(1, 1, 1, 1)))
+    }).exact_w(20)
+}
+
+pub fn view_scene_name (
+    select:  &Selection,
+    editor:  Option<&MidiEditor>,
+    index:   usize,
+    scene:   &Scene,
+    editing: bool
+) -> impl Draw<Tui> {
+    let h = if select.scene() == Some(index) && let Some(_editor) = editor {
+        7
+    } else {
+        H_SCENE as u16
+    };
+    let a = east(format!("·s{index:02} "),
+        fg(g(255), bold(true, &scene.name))).align_w().full_w();
+    let b = when(select.scene() == Some(index) && editing, south(
+        editor.as_ref().map(|e|e.clip_status()),
+        editor.as_ref().map(|e|e.edit_status())).align_nw().full_wh());
+    let c = if select.scene() == Some(index) {
+        scene.color.light.term
+    } else {
+        scene.color.base.term
+    };
+    bg(c, south(a, b).align_nw()).exact_wh(20, h)
+}
+
+pub fn view_midi_ins_status (theme: ItemTheme, track: Option<&Track>) -> impl Draw<Tui> {
+    track.map(move|track|view_ports_status(theme, "MIDI ins:  ", &track.sequencer.midi_ins))
+}
+
+pub fn view_midi_outs_status (theme: ItemTheme, track: Option<&Track>) -> impl Draw<Tui> {
+    track.map(move|track|view_ports_status(theme, "MIDI outs: ", &track.sequencer.midi_outs))
+}
+
+pub fn view_audio_ins_status (theme: ItemTheme, track: Option<&Track>) -> impl Draw<Tui> {
+    track.map(move|track|view_ports_status(theme, "Audio ins: ", &track.audio_ins()))
+}
+
+pub fn view_audio_outs_status (theme: ItemTheme, track: Option<&Track>) -> impl Draw<Tui> {
+    track.map(move|track|view_ports_status(theme, "Audio outs:", &track.audio_outs()))
+}
+
+pub fn view_track_per <'a, T: Draw<Tui> + 'a, U: TracksSizes<'a>> (
+    tracks:   impl Fn() -> U + Send + Sync + 'a,
+    callback: impl Fn(usize, &'a Track)->T + Send + Sync + 'a
+) -> impl Draw<Tui> {
+    iter_east(tracks, move|(index, track, x1, x2): (usize, &Track, usize, usize), _|{
+        fg_bg(
+            track.color.lightest.term,
+            track.color.base.term,
+            callback(index, track)
+        ).exact_w((x2 - x1) as u16)
+    })
+}
+
+pub fn view_per_track () -> impl Draw<Tui> {}
+
+pub fn view_per_track_top () -> impl Draw<Tui> {}
+
+pub fn view_inputs (tracks: impl TracksSizes<'_>, midi_ins: &[MidiInput]) -> impl Draw<Tui> {
+    let title_1 = button_3("i", "nput ", format!("{}", midi_ins.len()), false).align_w().exact_wh(20, 1);
+    let title_2 = button_2("I", "+", false).exact_wh(4, 1);
+    east(title_1, west(title_2, thunk(move|to: &mut Tui|{
+        for (_index, track, x1, _x2) in tracks {
+            south(
+                bg(track.color.dark.term, east!(
+                    either(track.sequencer.monitoring, fg(Green,  "mon "), "mon "),
+                    either(track.sequencer.recording,  fg(Red,    "rec "), "rec "),
+                    either(track.sequencer.overdub,    fg(Yellow, "dub "), "dub "),
+                ).exact_w(track.width as u16)).align_w().push_x(x1 as u16),
+                thunk(move |to: &mut Tui|{
+                    for (index, port) in midi_ins.iter().enumerate() {
+                        east(
+                            east(
+                                " ● ",
+                                bold(true, fg(Rgb(255,255,255), port.port_name()))
+                            ).align_w().exact_w(20),
+                            west(
+                                ().exact_w(4),
+                                thunk(move|to: &mut Tui|{
+                                    bg(track.color.darker.term, east!(
+                                        either(track.sequencer.monitoring, fg(Green,  " ●  "), " ·  "),
+                                        either(track.sequencer.recording,  fg(Red,    " ●  "), " ·  "),
+                                        either(track.sequencer.overdub,    fg(Yellow, " ●  "), " ·  "),
+                                    ).exact_w(track.width as u16).align_w()).draw(to);
+                                    todo!()
+                                }))
+                        ).push_x(index as u16 * 10).exact_h(1).draw(to);
+                    }
+                    todo!()
+                })
+            ).draw(to);
+        }
+        todo!()
+    })))
+}
+
+pub fn view_outputs (
+    theme:     ItemTheme,
+    tracks:    impl TracksSizes<'_>,
+    midi_outs: &[MidiOutput],
+    height:    u16,
+) -> impl Draw<Tui> {
+
+    let list = south(
+        button_3(
+            "o", "utput", format!("{}", midi_outs.len()), false
+        ).align_w().full_w().exact_h(1),
+        thunk(|to: &mut Tui|{
+            for (_index, port) in midi_outs.iter().enumerate() {
+                east(
+                    east(" ● ", fg(Rgb(255,255,255), bold(true, port.port_name()))).align_w(),
+                    format!("{}/{} ",
+                        port.port().get_connections().len(),
+                        port.connections.len()).align_e().full_w().exact_h(1)).full_w().draw(to)?;
+                for (index, conn) in port.connections.iter().enumerate() {
+                    format!("   c{index:02}{}", conn.info()).align_w().full_w().exact_h(1).draw(to)?;
+                }
+            }
+            todo!();
+        }).align_nw().full_wh().exact_h(height - 1)
+    );
+
+    view_track_row_section(theme, list, button_2("O", "+", false),
+        bg(theme.darker.term, thunk(|to: &mut Tui|{
+            for (index, track, _x1, _x2) in tracks {
+                thunk(|to: &mut Tui|{
+                    east(
+                        either(true,  fg(Green,  "play "), "play "),
+                        either(false, fg(Yellow, "solo "), "solo "),
+                    ).align_w().exact_h(1).draw(to)?;
+                    for (_index, port) in midi_outs.iter().enumerate() {
+                        east(
+                            either(true,  fg(Green,  " ●   "), " ·   "),
+                            either(false, fg(Yellow, " ●   "), " ·   "),
+                        ).align_w().exact_h(1).draw(to)?;
+                        for (_index, _conn) in port.connections.iter().enumerate() {
+                            "".full_w().exact_h(1).draw(to)?;
+                        }
+                    }
+                    todo!()
+                }).exact_w(track_width(index, track)).draw(to);
+            }
+            todo!()
+        }).align_w().full_w())).exact_h(height)
+}
+
+pub fn view_track_devices (
+    theme:  ItemTheme,
+    tracks: impl TracksSizes<'_>,
+    track:  Option<&Track>,
+    h:      u16,
+) -> impl Draw<Tui> {
+    view_track_row_section(theme,
+        button_3("d", "evice", format!("{}", track.map(|t|t.devices.len()).unwrap_or(0)), false),
+        button_2("D", "+", false),
+        iter_once(tracks, move|(_, track, _x1, _x2), index|bg(
+            track.color.dark.term,
+            iter_south(move||0..h,
+                |_, _index|fg_bg(
+                    ItemTheme::G[32].lightest.term,
+                    ItemTheme::G[32].dark.term,
+                    format!(" · {}", "--").align_nw()
+                ).exact_wh(track.width as u16, 2)
+            ).align_nw()).exact_wh(
+                Some(track_width(index, track)),
+                Some(h + 1),
+            )))
+}
+
+pub fn per_track <'a, T: Draw<Tui> + 'a, U: TracksSizes<'a>> (
+    tracks:   impl Fn() -> U + Send + Sync + 'a,
+    callback: impl Fn(usize, &'a Track)->T + Send + Sync + 'a
+) -> impl Draw<Tui> + 'a {
+    per_track_top(tracks, move|index, track|callback(index, track).full_h().align_y())
+}
+
+pub fn per_track_top <'a, T: Draw<Tui> + 'a, U: TracksSizes<'a>> (
+    tracks:   impl Fn() -> U + Send + Sync + 'a,
+    callback: impl Fn(usize, &'a Track)->T + Send + Sync + 'a
+) -> impl Draw<Tui> + 'a {
+    bg(Reset, iter_east(tracks,
+        move|(index, track, x1, x2): (usize, &'a Track, usize, usize), _|{
+            fg_bg(
+                track.color.lightest.term,
+                track.color.base.term,
+                callback(index, track)
+            ).exact_w((x2 - x1) as u16)
+        }).align_x())
+}
+
+pub fn field_h <T: Screen> (theme: ItemTheme, head: impl Draw<T>, body: impl Draw<T>) -> impl Draw<T> {
+}
+
+pub fn field_v <T: Screen> (theme: ItemTheme, head: impl Draw<T>, body: impl Draw<T>) -> impl Draw<T> {
+}
+
+pub fn view_sessions () -> impl Draw<Tui> {
+    let h = 6;
+    let w = Some(30);
+    let f = Rgb(224, 192, 128);
+    thunk(move |to: &mut Tui|{
+        for (index, name) in ["session1", "session2", "session3"].iter().enumerate() {
+            let b = if index == 0 { Rgb(50,50,50) } else { Rgb(40,40,40) };
+            let y = (2 * index) as u16;
+            let h = 2;
+            bg(b, fg(f, *name).align_w()).full_w().exact_h(h).push_y(y).draw(to)?;
+        }
+        Ok(Some(to.area().into()))
+    }).min_w(w).exact_h(h)
+}
+
+pub fn view_browse_title (state: &App) -> impl Draw<Tui> {
+    field_v(ItemTheme::default(),
+        match state.dialog.browser_target().unwrap() {
+               BrowseTarget::SaveProject     => "Save project:",
+               BrowseTarget::LoadProject     => "Load project:",
+               BrowseTarget::ImportSample(_) => "Import sample:",
+               BrowseTarget::ExportSample(_) => "Export sample:",
+               BrowseTarget::ImportClip(_)   => "Import clip:",
+               BrowseTarget::ExportClip(_)   => "Export clip:",
+            }, fg(g(96), x_repeat("🭻")).exact_h(1)
+        ).align_w().full_w()
+}
+
+pub fn view_device (state: &App) -> impl Draw<Tui> {
+    let selected = state.dialog.device_kind().unwrap();
+    south(bold(true, "Add device"), iter_south(
+        move||device_kinds().iter(),
+        move|_label: &&'static str, i|{
+            let b = if i == selected { Rgb(64,128,32) } else { Rgb(0,0,0) };
+            let l = if i == selected { "[ " } else { "  " };
+            let r = if i == selected { " ]" } else { "  " };
+            bg(b, east(l, west(r, "FIXME device name"))).full_w()
+        }))
+}

src/app/size.rs

@@ -0,0 +1,25 @@
+use crate::*;
+
+impl_has!(Sizer: |self: App|self.size);
+
+/// Define a type alias for iterators of sized items (columns).
+macro_rules! def_sizes_iter {
+    ($Type:ident => $($Item:ty),+) => {
+        pub trait $Type<'a> =
+            Iterator<Item=(usize, $(&'a $Item,)+ usize, usize)> + Send + Sync + 'a;
+    }
+}
+
+def_sizes_iter!(InputsSizes  => MidiInput);
+def_sizes_iter!(OutputsSizes => MidiOutput);
+def_sizes_iter!(PortsSizes   => Arc<str>, [Connect]);
+def_sizes_iter!(ScenesSizes  => Scene);
+def_sizes_iter!(TracksSizes  => Track);
+
+pub trait HasWidth {
+    const MIN_WIDTH: usize;
+    /// Increment track width.
+    fn width_inc (&mut self);
+    /// Decrement track width, down to a hardcoded minimum of [Self::MIN_WIDTH].
+    fn width_dec (&mut self);
+}

src/arrange.rs

@@ -1,836 +0,0 @@
-use ::std::sync::{Arc, RwLock};
-use ::tengri::{space::east, color::ItemTheme};
-use ::tengri::{draw::*, term::*};
-use crate::{*, device::*, sequence::*, clock::*, select::*, sample::*};
-impl HasJack<'static> for Arrangement { fn jack (&self) -> &Jack<'static> { &self.jack } }
-
-/// Arranger.
-///
-/// ```
-/// let arranger = tek::Arrangement::default();
-/// ```
-#[derive(Default, Debug)] pub struct Arrangement {
-    /// Project name.
-    pub name:       Arc<str>,
-    /// Base color.
-    pub color:      ItemTheme,
-    /// JACK client handle.
-    pub jack:       Jack<'static>,
-    /// FIXME 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:       [AtomicUsize; 2],
-    /// Display size of clips area
-    pub size_inner: [AtomicUsize; 2],
-    /// Source of time
-    #[cfg(feature = "clock")]  pub clock: Clock,
-    /// Allows one MIDI clip to be edited
-    #[cfg(feature = "editor")] pub editor: Option<MidiEditor>,
-    /// List of global midi inputs
-    #[cfg(feature = "port")]   pub midi_ins:   Vec<MidiInput>,
-    /// List of global midi outputs
-    #[cfg(feature = "port")]   pub midi_outs:  Vec<MidiOutput>,
-    /// List of global audio inputs
-    #[cfg(feature = "port")]   pub audio_ins:  Vec<AudioInput>,
-    /// List of global audio outputs
-    #[cfg(feature = "port")]   pub audio_outs: Vec<AudioOutput>,
-    /// Selected UI element
-    #[cfg(feature = "select")] pub selection: Selection,
-    /// Last track number (to avoid duplicate port names)
-    #[cfg(feature = "track")]  pub track_last:   usize,
-    /// List of tracks
-    #[cfg(feature = "track")]  pub tracks: Vec<Track>,
-    /// Scroll offset of tracks
-    #[cfg(feature = "track")]  pub track_scroll: usize,
-    /// List of scenes
-    #[cfg(feature = "scene")]  pub scenes: Vec<Scene>,
-    /// Scroll offset of scenes
-    #[cfg(feature = "scene")]  pub scene_scroll: usize,
-}
-
-/// A track consists of a sequencer and zero or more devices chained after it.
-///
-/// ```
-/// let track: tek::Track = Default::default();
-/// ```
-#[derive(Debug, Default)] pub struct Track {
-    /// Name of track
-    pub name:      Arc<str>,
-    /// Identifying color of track
-    pub color:     ItemTheme,
-    /// Preferred width of track column
-    pub width:     usize,
-    /// MIDI sequencer state
-    pub sequencer: Sequencer,
-    /// Device chain
-    pub devices:   Vec<Device>,
-}
-
-/// A scene consists of a set of clips to play together.
-///
-/// ```
-/// let scene: tek::Scene = Default::default();
-/// let _ = scene.pulses();
-/// let _ = scene.is_playing(&[]);
-/// ```
-#[derive(Debug, Default)] pub struct Scene {
-    /// Name of scene
-    pub name:  Arc<str>,
-    /// Identifying color of scene
-    pub color: ItemTheme,
-    /// Clips in scene, one per track
-    pub clips: Vec<Option<Arc<RwLock<MidiClip>>>>,
-}
-
-impl_has!(Jack<'static>:     |self: Arrangement| self.jack);
-impl_has!([AtomicUsize; 2]:   |self: Arrangement| self.size);
-impl_has!(Vec<Track>:        |self: Arrangement| self.tracks);
-impl_has!(Vec<Scene>:        |self: Arrangement| self.scenes);
-impl_has!(Vec<MidiInput>:    |self: Arrangement| self.midi_ins);
-impl_has!(Vec<MidiOutput>:   |self: Arrangement| self.midi_outs);
-impl_has!(Clock:             |self: Arrangement| self.clock);
-impl_has!(Selection:         |self: Arrangement| self.selection);
-impl_as_ref_opt!(MidiEditor: |self: Arrangement| self.editor.as_ref());
-impl_as_mut_opt!(MidiEditor: |self: Arrangement| self.editor.as_mut());
-impl_as_ref_opt!(Track:      |self: Arrangement| self.selected_track());
-impl_as_mut_opt!(Track:      |self: Arrangement| self.selected_track_mut());
-
-impl <T: AsRef<Vec<Scene>>+AsMut<Vec<Scene>>>              HasScenes    for T {}
-impl <T: AsRef<Vec<Track>>+AsMut<Vec<Track>>>              HasTracks    for T {}
-impl <T: AsRefOpt<Scene>+AsMutOpt<Scene>+Send+Sync>        HasScene     for T {}
-impl <T: AsRefOpt<Track>+AsMutOpt<Track>+Send+Sync>        HasTrack     for T {}
-impl <T: ScenesView+HasMidiIns+HasMidiOuts+HasTrackScroll> TracksView   for T {}
-impl <T: TracksView+ScenesView+Send+Sync>                  ClipsView    for T {}
-
-pub trait ClipsView: TracksView + ScenesView {
-
-    fn view_scenes_clips <'a> (&'a self)
-        -> impl Draw<Tui> + 'a
-    {
-        self.clips_size().of(wh_full(above(
-            wh_full(origin_se(fg(Green, format!("{}x{}", self.clips_size().w(), self.clips_size().h())))),
-            thunk(|to: &mut Tui|for (
-                track_index, track, _, _
-            ) in self.tracks_with_sizes() {
-                to.place(&w_exact(track.width as u16,
-                    h_full(self.view_track_clips(track_index, track))))
-            }))))
-    }
-
-    fn view_track_clips <'a> (&'a self, track_index: usize, track: &'a Track) -> impl Draw<Tui> + 'a {
-        thunk(move|to: &mut Tui|for (
-            scene_index, scene, ..
-        ) in self.scenes_with_sizes() {
-            let (name, theme): (Arc<str>, ItemTheme) = if let Some(Some(clip)) = &scene.clips.get(track_index) {
-                let clip = clip.read().unwrap();
-                (format!(" ⏹ {}", &clip.name).into(), clip.color)
-            } else {
-                (" ⏹ -- ".into(), ItemTheme::G[32])
-            };
-            let fg = theme.lightest.term;
-            let mut outline = theme.base.term;
-            let bg = if self.selection().track() == Some(track_index)
-                && self.selection().scene() == Some(scene_index)
-            {
-                outline = theme.lighter.term;
-                theme.light.term
-            } else if self.selection().track() == Some(track_index)
-                || self.selection().scene() == Some(scene_index)
-            {
-                outline = theme.darkest.term;
-                theme.base.term
-            } else {
-                theme.dark.term
-            };
-            let w = if self.selection().track() == Some(track_index)
-                && let Some(editor) = self.editor ()
-            {
-                (editor.measure_width() as usize).max(24).max(track.width)
-            } else {
-                track.width
-            } as u16;
-            let y = if self.selection().scene() == Some(scene_index)
-                && let Some(editor) = self.editor ()
-            {
-                (editor.measure_height() as usize).max(12)
-            } else {
-                Self::H_SCENE as usize
-            } as u16;
-
-            let is_selected =
-                self.selection().track() == Some(track_index) &&
-                self.selection().scene() == Some(scene_index) &&
-                self.is_editing();
-
-            to.place(&wh_exact(w, y, below(
-                wh_full(Outer(true, Style::default().fg(outline))),
-                wh_full(below(
-                    below(
-                        fg_bg(outline, bg, wh_full("")),
-                        wh_full(origin_nw(fg_bg(fg, bg, bold(true, name)))),
-                    ),
-                    wh_full(when(is_selected, self.editor().view())))))));
-        })
-    }
-
-}
-
-pub trait TracksView: ScenesView + HasMidiIns + HasMidiOuts + HasTrackScroll {
-
-    fn tracks_width_available (&self) -> u16 {
-        (self.measure_width() as u16).saturating_sub(40)
-    }
-
-    /// Iterate over tracks with their corresponding sizes.
-    fn tracks_with_sizes (&self) -> impl TracksSizes<'_> {
-        let _editor_width = self.editor().map(|e|e.measure_width());
-        let _active_track = self.selection().track();
-        let mut x = 0;
-        self.tracks().iter().enumerate().map_while(move |(index, track)|{
-            let width = track.width.max(8);
-            if x + width < self.clips_size().w() as usize {
-                let data = (index, track, x, x + width);
-                x += width + Self::TRACK_SPACING;
-                Some(data)
-            } else {
-                None
-            }
-        })
-    }
-
-    fn view_track_names (&self, theme: ItemTheme) -> impl Draw<Tui> {
-        let track_count = self.tracks().len();
-        let scene_count = self.scenes().len();
-        let selected = self.selection();
-        let button = south(
-            button_3("t", "rack ", format!("{}{track_count}", selected.track()
-                .map(|track|format!("{track}/")).unwrap_or_default()), false),
-            button_3("s", "cene ", format!("{}{scene_count}", selected.scene()
-                .map(|scene|format!("{scene}/")).unwrap_or_default()), false));
-        let button_2 = south(
-            button_2("T", "+", false),
-            button_2("S", "+", false));
-        view_track_row_section(theme, button, button_2, bg(theme.darker.term,
-            h_exact(2, thunk(|to: &mut Tui|{
-                for (index, track, x1, _x2) in self.tracks_with_sizes() {
-                    to.place(&x_push(x1 as u16, w_exact(track_width(index, track),
-                        bg(if selected.track() == Some(index) {
-                            track.color.light.term
-                        } else {
-                            track.color.base.term
-                        }, south(w_full(origin_nw(east(
-                            format!("·t{index:02} "),
-                            fg(Rgb(255, 255, 255), bold(true, &track.name))
-                        ))), "")))  ));}}))))
-    }
-
-    fn view_track_outputs <'a> (&'a self, theme: ItemTheme, _h: u16) -> impl Draw<Tui> {
-        view_track_row_section(theme,
-            south(w_full(origin_w(button_2("o", "utput", false))),
-                thunk(|to: &mut Tui|for port in self.midi_outs().iter() {
-                    to.place(&w_full(origin_w(port.port_name())));
-                })),
-            button_2("O", "+", false),
-            bg(theme.darker.term, origin_w(thunk(|to: &mut Tui|{
-                for (index, track, _x1, _x2) in self.tracks_with_sizes() {
-                    to.place(&w_exact(track_width(index, track),
-                        origin_nw(h_full(iter_south(1, ||track.sequencer.midi_outs.iter(),
-                            |port, index|fg(Rgb(255, 255, 255),
-                                h_exact(1, bg(track.color.dark.term, w_full(origin_w(
-                                    format!("·o{index:02} {}", port.port_name())))))))))));}}))))
-    }
-
-    fn view_track_inputs <'a> (&'a self, theme: ItemTheme) -> impl Draw<Tui> {
-        let mut h = 0u16;
-        for track in self.tracks().iter() {
-            h = h.max(track.sequencer.midi_ins.len() as u16);
-        }
-        let content = thunk(move|to: &mut Tui|for (index, track, _x1, _x2) in self.tracks_with_sizes() {
-            to.place(&wh_exact(track_width(index, track), h + 1,
-                origin_nw(south(
-                    bg(track.color.base.term,
-                        w_full(origin_w(east!(
-                            either(track.sequencer.monitoring, fg(Green, "●mon "), "·mon "),
-                            either(track.sequencer.recording,  fg(Red, "●rec "), "·rec "),
-                            either(track.sequencer.overdub,    fg(Yellow, "●dub "), "·dub "),
-                        )))),
-                    iter_south(1, ||track.sequencer.midi_ins.iter(),
-                        |port, index|fg_bg(Rgb(255, 255, 255), track.color.dark.term,
-                            w_full(origin_w(format!("·i{index:02} {}", port.port_name())))))))));
-        });
-        view_track_row_section(theme, button_2("i", "nput", false), button_2("I", "+", false),
-            bg(theme.darker.term, origin_w(content)))
-    }
-
-}
-
-pub trait ScenesView: HasEditor + HasSelection + HasSceneScroll + HasClipsSize + Send + Sync {
-    /// Default scene height.
-    const H_SCENE:  usize = 2;
-    /// Default editor height.
-    const H_EDITOR: usize = 15;
-    fn h_scenes (&self) -> u16;
-    fn w_side   (&self) -> u16;
-    fn w_mid    (&self) -> u16;
-    fn scenes_with_sizes (&self) -> impl ScenesSizes<'_> {
-        let mut y = 0;
-        self.scenes().iter().enumerate().skip(self.scene_scroll()).map_while(move|(s, scene)|{
-            let height = if self.selection().scene() == Some(s) && self.editor().is_some() {
-                8
-            } else {
-                Self::H_SCENE
-            };
-            if y + height <= self.clips_size().h() as usize {
-                let data = (s, scene, y, y + height);
-                y += height;
-                Some(data)
-            } else {
-                None
-            }
-        })
-    }
-
-    fn view_scenes_names (&self) -> impl Draw<Tui> {
-        w_exact(20, thunk(|to: &mut Tui|for (index, scene, ..) in self.scenes_with_sizes() {
-            to.place(&self.view_scene_name(index, scene));
-        }))
-    }
-
-    fn view_scene_name <'a> (&'a self, index: usize, scene: &'a Scene) -> impl Draw<Tui> + 'a {
-        let h = if self.selection().scene() == Some(index) && let Some(_editor) = self.editor() {
-            7
-        } else {
-            Self::H_SCENE as u16
-        };
-        let bg = if self.selection().scene() == Some(index) {
-            scene.color.light.term
-        } else {
-            scene.color.base.term
-        };
-        let a = w_full(origin_w(east(format!("·s{index:02} "),
-            fg(g(255), bold(true, &scene.name)))));
-        let b = when(self.selection().scene() == Some(index) && self.is_editing(),
-            wh_full(origin_nw(south(
-                self.editor().as_ref().map(|e|e.clip_status()),
-                self.editor().as_ref().map(|e|e.edit_status())))));
-        wh_exact(20, h, bg(bg, origin_nw(south(a, b))))
-    }
-
-}
-pub trait HasSceneScroll: HasScenes { fn scene_scroll (&self) -> usize; }
-pub trait HasTrackScroll: HasTracks { fn track_scroll (&self) -> usize; }
-pub trait HasScene: AsRefOpt<Scene> + AsMutOpt<Scene> {
-    fn scene_mut (&mut self) -> Option<&mut Scene> { self.as_mut_opt() }
-    fn scene     (&self)     -> Option<&Scene>     { self.as_ref_opt() }
-}
-pub trait HasScenes: AsRef<Vec<Scene>> + AsMut<Vec<Scene>> {
-    fn scenes (&self) -> &Vec<Scene> { self.as_ref()  }
-    fn scenes_mut (&mut self) -> &mut Vec<Scene> { self.as_mut() }
-    /// Generate the default name for a new scene
-    fn scene_default_name (&self) -> Arc<str> { format!("s{:3>}", self.scenes().len() + 1).into() }
-    fn scene_longest_name (&self) -> usize { self.scenes().iter().map(|s|s.name.len()).fold(0, usize::max) }
-    /// Add multiple scenes
-    fn scenes_add (&mut self, n: usize) -> Usually<()> where Self: HasTracks {
-        let scene_color_1 = ItemColor::random();
-        let scene_color_2 = ItemColor::random();
-        for i in 0..n {
-            let _ = self.scene_add(None, Some(
-                scene_color_1.mix(scene_color_2, i as f32 / n as f32).into()
-            ))?;
-        }
-        Ok(())
-    }
-    /// Add a scene
-    fn scene_add (&mut self, name: Option<&str>, color: Option<ItemTheme>)
-        -> Usually<(usize, &mut Scene)> where Self: HasTracks
-    {
-        let scene = Scene {
-            name:  name.map_or_else(||self.scene_default_name(), |x|x.to_string().into()),
-            clips: vec![None;self.tracks().len()],
-            color: color.unwrap_or_else(ItemTheme::random),
-        };
-        self.scenes_mut().push(scene);
-        let index = self.scenes().len() - 1;
-        Ok((index, &mut self.scenes_mut()[index]))
-    }
-}
-pub trait HasTracks: AsRef<Vec<Track>> + AsMut<Vec<Track>> {
-    fn tracks (&self) -> &Vec<Track> { self.as_ref() }
-    fn tracks_mut (&mut self) -> &mut Vec<Track> { self.as_mut() }
-    /// 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); }
-        }
-    }
-    /// Spacing between tracks.
-    const TRACK_SPACING: usize = 0;
-}
-pub trait HasTrack: AsRefOpt<Track> + AsMutOpt<Track> {
-    fn track (&self) -> Option<&Track> { self.as_ref_opt() }
-    fn track_mut (&mut self) -> Option<&mut Track> { self.as_mut_opt() }
-    #[cfg(feature = "port")] fn view_midi_ins_status <'a> (&'a self, theme: ItemTheme) -> impl Draw<Tui> + 'a {
-        self.track().map(move|track|view_ports_status(theme, "MIDI ins:  ", &track.sequencer.midi_ins))
-    }
-    #[cfg(feature = "port")] fn view_midi_outs_status (&self, theme: ItemTheme) -> impl Draw<Tui>  + '_ {
-        self.track().map(move|track|view_ports_status(theme, "MIDI outs: ", &track.sequencer.midi_outs))
-    }
-    #[cfg(feature = "port")] fn view_audio_ins_status (&self, theme: ItemTheme) -> impl Draw<Tui> {
-        self.track().map(move|track|view_ports_status(theme, "Audio ins: ", &track.audio_ins()))
-    }
-    #[cfg(feature = "port")] fn view_audio_outs_status (&self, theme: ItemTheme) -> impl Draw<Tui> {
-        self.track().map(move|track|view_ports_status(theme, "Audio outs:", &track.audio_outs()))
-    }
-}
-    impl_as_ref!(Vec<Track>: |self: App| self.project.as_ref());
-    impl_as_mut!(Vec<Track>: |self: App| self.project.as_mut());
-    #[cfg(feature = "select")] impl_as_ref_opt!(Track: |self: App| self.project.as_ref_opt());
-    #[cfg(feature = "select")] impl_as_mut_opt!(Track: |self: App| self.project.as_mut_opt());
-    impl HasTrackScroll for App { fn track_scroll (&self) -> usize { self.project.track_scroll() } }
-    impl HasTrackScroll for Arrangement { fn track_scroll (&self) -> usize { self.track_scroll } }
-
-    impl HasWidth for Track {
-        const MIN_WIDTH: usize = 9;
-        fn width_inc (&mut self) { self.width += 1; }
-        fn width_dec (&mut self) { if self.width > Track::MIN_WIDTH { self.width -= 1; } }
-    }
-
-    impl Track {
-        /// Create a new track with only the default [Sequencer].
-        pub fn new (
-            name:      &impl AsRef<str>,
-            color:     Option<ItemTheme>,
-            jack:      &Jack<'static>,
-            clock:     Option<&Clock>,
-            clip:      Option<&Arc<RwLock<MidiClip>>>,
-            midi_from: &[Connect],
-            midi_to:   &[Connect],
-        ) -> Usually<Self> {
-            Ok(Self {
-                name: name.as_ref().into(),
-                color: color.unwrap_or_default(),
-                sequencer: Sequencer::new(format!("{}/sequencer", name.as_ref()), jack, clock, clip, midi_from, midi_to)?,
-                ..Default::default()
-            })
-        }
-        pub fn audio_ins  (&self) -> &[AudioInput] {
-            self.devices.first().map(|x|x.audio_ins()).unwrap_or_default()
-        }
-        pub fn audio_outs (&self) -> &[AudioOutput] {
-            self.devices.last().map(|x|x.audio_outs()).unwrap_or_default()
-        }
-        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!() }
-        pub fn per <'a, T: Draw<Tui> + 'a, U: TracksSizes<'a>> (
-            tracks:   impl Fn() -> U + Send + Sync + 'a,
-            callback: impl Fn(usize, &'a Track)->T + Send + Sync + 'a
-        ) -> impl Draw<Tui> + 'a {
-            iter(tracks,
-                move|(index, track, x1, x2): (usize, &'a Track, usize, usize), _|{
-                    let width = (x2 - x1) as u16;
-                    iter_east(x1 as u16, width, w_exact(width, fg_bg(
-                        track.color.lightest.term,
-                        track.color.base.term,
-                        callback(index, track))))})
-        }
-        /// Create a new track connecting the [Sequencer] to a [Sampler].
-        #[cfg(feature = "sampler")] pub fn new_with_sampler (
-            name:       &impl AsRef<str>,
-            color:      Option<ItemTheme>,
-            jack:       &Jack<'static>,
-            clock:      Option<&Clock>,
-            clip:       Option<&Arc<RwLock<MidiClip>>>,
-            midi_from:  &[Connect],
-            midi_to:    &[Connect],
-            audio_from: &[&[Connect];2],
-            audio_to:   &[&[Connect];2],
-        ) -> Usually<Self> {
-            let mut track = Self::new(name, color, jack, clock, clip, midi_from, midi_to)?;
-            let client_name = jack.with_client(|c|c.name().to_string());
-            let port_name = track.sequencer.midi_outs[0].port_name();
-            let connect = [Connect::exact(format!("{client_name}:{}", port_name))];
-            track.devices.push(Device::Sampler(Sampler::new(
-                jack, &format!("{}/sampler", name.as_ref()), &connect, audio_from, audio_to
-            )?));
-            Ok(track)
-        }
-        #[cfg(feature = "sampler")] pub fn sampler (&self, mut nth: usize) -> Option<&Sampler> {
-            for device in self.devices.iter() {
-                match device {
-                    Device::Sampler(s) => if nth == 0 { return Some(s); } else { nth -= 1; },
-                    _ => {}
-                }
-            }
-            None
-        }
-        #[cfg(feature = "sampler")] pub fn sampler_mut (&mut self, mut nth: usize) -> Option<&mut Sampler> {
-            for device in self.devices.iter_mut() {
-                match device {
-                    Device::Sampler(s) => if nth == 0 { return Some(s); } else { nth -= 1; },
-                    _ => {}
-                }
-            }
-            None
-        }
-    }
-
-    pub fn per_track <'a, T: Draw<Tui> + 'a, U: TracksSizes<'a>> (
-        tracks:   impl Fn() -> U + Send + Sync + 'a,
-        callback: impl Fn(usize, &'a Track)->T + Send + Sync + 'a
-    ) -> impl Draw<Tui> + 'a {
-        per_track_top(tracks, move|index, track|h_full(origin_y(callback(index, track))))
-    }
-
-    pub fn per_track_top <'a, T: Draw<Tui> + 'a, U: TracksSizes<'a>> (
-        tracks:   impl Fn() -> U + Send + Sync + 'a,
-        callback: impl Fn(usize, &'a Track)->T + Send + Sync + 'a
-    ) -> impl Draw<Tui> + 'a {
-        origin_x(bg(Reset, iter(tracks,
-            move|(index, track, x1, x2): (usize, &'a Track, usize, usize), _|{
-                let width = (x2 - x1) as u16;
-                iter_east(x1 as u16, width, w_exact(width, fg_bg(
-                    track.color.lightest.term,
-                    track.color.base.term,
-                    callback(index, track))))})))
-    }
-    #[cfg(all(feature = "select"))] impl_as_ref_opt!(Scene: |self: App| self.project.as_ref_opt());
-    #[cfg(all(feature = "select"))] impl_as_mut_opt!(Scene: |self: App| self.project.as_mut_opt());
-    #[cfg(all(feature = "select"))] impl_as_ref_opt!(Scene: |self: Arrangement| self.selected_scene());
-    #[cfg(all(feature = "select"))] impl_as_mut_opt!(Scene: |self: Arrangement| self.selected_scene_mut());
-    impl HasSceneScroll for App { fn scene_scroll (&self) -> usize { self.project.scene_scroll() } }
-    impl HasSceneScroll for Arrangement { fn scene_scroll (&self) -> usize { self.scene_scroll } }
-    impl ScenesView for App {
-        fn w_mid    (&self) -> u16 { (self.measure_width() as u16).saturating_sub(self.w_side()) }
-        fn w_side   (&self) -> u16 { 20 }
-        fn h_scenes (&self) -> u16 { (self.measure_height() as u16).saturating_sub(20) }
-    }
-    impl Scene {
-        /// Returns the pulse length of the longest clip in the scene
-        pub fn pulses (&self) -> usize {
-            self.clips.iter().fold(0, |a, p|{
-                a.max(p.as_ref().map(|q|q.read().unwrap().length).unwrap_or(0))
-            })
-        }
-        /// Returns true if all clips in the scene are
-        /// currently playing on the given collection of tracks.
-        pub fn is_playing (&self, tracks: &[Track]) -> bool {
-            self.clips.iter().any(|clip|clip.is_some()) && self.clips.iter().enumerate()
-                .all(|(track_index, clip)|match clip {
-                    Some(c) => tracks
-                        .get(track_index)
-                        .map(|track|{
-                            if let Some((_, Some(clip))) = track.sequencer().play_clip() {
-                                *clip.read().unwrap() == *c.read().unwrap()
-                            } else {
-                                false
-                            }
-                        })
-                        .unwrap_or(false),
-                    None => true
-                })
-        }
-        pub fn clip (&self, index: usize) -> Option<&Arc<RwLock<MidiClip>>> {
-            match self.clips.get(index) { Some(Some(clip)) => Some(clip), _ => None }
-        }
-        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!() }
-    }
-
-impl Arrangement {
-    /// Create a new arrangement.
-    pub fn new (
-        jack:      &Jack<'static>,
-        name:      Option<Arc<str>>,
-        clock:     Clock,
-        tracks:    Vec<Track>,
-        scenes:    Vec<Scene>,
-        midi_ins:  Vec<MidiInput>,
-        midi_outs: Vec<MidiOutput>,
-    ) -> Self {
-        Self {
-            clock, tracks, scenes, midi_ins, midi_outs,
-            jack: jack.clone(),
-            name: name.unwrap_or_default(),
-            color: ItemTheme::random(),
-            selection: Selection::TrackClip { track: 0, scene: 0 },
-            ..Default::default()
-        }
-    }
-    /// Width of display
-    pub fn w (&self) -> u16 {
-        self.size.w() as u16
-    }
-    /// Width allocated for sidebar.
-    pub fn w_sidebar (&self, is_editing: bool) -> u16 {
-        self.w() / if is_editing { 16 } else { 8 } as u16
-    }
-    /// Width available to display tracks.
-    pub fn w_tracks_area (&self, is_editing: bool) -> u16 {
-        self.w().saturating_sub(self.w_sidebar(is_editing))
-    }
-    /// Height of display
-    pub fn h (&self) -> u16 {
-        self.size.h() as u16
-    }
-    /// Height taken by visible device slots.
-    pub fn h_devices (&self) -> u16 {
-        2
-        //1 + self.devices_with_sizes().last().map(|(_, _, _, _, y)|y as u16).unwrap_or(0)
-    }
-    /// Add multiple tracks
-    #[cfg(feature = "track")] pub fn tracks_add (
-        &mut self,
-        count: usize, width: Option<usize>,
-        mins: &[Connect], mouts: &[Connect],
-    ) -> Usually<()> {
-        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 track = self.track_add(None, Some(color), mins, mouts)?.1;
-            if let Some(width) = width {
-                track.width = width;
-            }
-        }
-        Ok(())
-    }
-    /// Add a track
-    #[cfg(feature = "track")] pub fn track_add (
-        &mut self,
-        name:  Option<&str>, color: Option<ItemTheme>,
-        mins:  &[Connect], mouts: &[Connect],
-    ) -> Usually<(usize, &mut Track)> {
-        let name: Arc<str> = name.map_or_else(
-            ||format!("trk{:02}", self.track_last).into(),
-            |x|x.to_string().into()
-        );
-        self.track_last += 1;
-        let 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 = "track")] pub fn view_inputs (&self, _theme: ItemTheme) -> impl Draw<Tui> + '_ {
-        south(
-            h_exact(1, self.view_inputs_header()),
-            thunk(|to: &mut Tui|{
-                for (index, port) in self.midi_ins().iter().enumerate() {
-                    to.place(&x_push(index as u16 * 10, h_exact(1, self.view_inputs_row(port))))
-                }
-            })
-        )
-    }
-    #[cfg(feature = "track")] fn view_inputs_header (&self) -> impl Draw<Tui> + '_ {
-        east(w_exact(20, origin_w(button_3("i", "nput ", format!("{}", self.midi_ins.len()), false))),
-            west(w_exact(4, button_2("I", "+", false)), thunk(move|to: &mut Tui|for (_index, track, x1, _x2) in self.tracks_with_sizes() {
-                #[cfg(feature = "track")]
-                to.place(&x_push(x1 as u16, bg(track.color.dark.term, origin_w(w_exact(track.width as u16, east!(
-                    either(track.sequencer.monitoring, fg(Green,  "mon "), "mon "),
-                    either(track.sequencer.recording,  fg(Red,    "rec "), "rec "),
-                    either(track.sequencer.overdub,    fg(Yellow, "dub "), "dub "),
-                ))))))
-            })))
-    }
-    #[cfg(feature = "track")] fn view_inputs_row (&self, port: &MidiInput) -> impl Draw<Tui> {
-        east(w_exact(20, origin_w(east(" ● ", bold(true, fg(Rgb(255,255,255), port.port_name()))))),
-            west(w_exact(4, ()), thunk(move|to: &mut Tui|for (_index, track, _x1, _x2) in self.tracks_with_sizes() {
-                #[cfg(feature = "track")]
-                to.place(&bg(track.color.darker.term, origin_w(w_exact(track.width as u16, east!(
-                    either(track.sequencer.monitoring, fg(Green,  " ●  "), " ·  "),
-                    either(track.sequencer.recording,  fg(Red,    " ●  "), " ·  "),
-                    either(track.sequencer.overdub,    fg(Yellow, " ●  "), " ·  "),
-                )))))
-            })))
-    }
-    #[cfg(feature = "track")] pub fn view_outputs (&self, theme: ItemTheme) -> impl Draw<Tui> {
-        let mut h = 1;
-        for output in self.midi_outs().iter() {
-            h += 1 + output.connections.len();
-        }
-        let h = h as u16;
-        let list = south(
-            h_exact(1, w_full(origin_w(button_3("o", "utput", format!("{}", self.midi_outs.len()), false)))),
-            h_exact(h - 1, wh_full(origin_nw(thunk(|to: &mut Tui|{
-                for (_index, port) in self.midi_outs().iter().enumerate() {
-                    to.place(&h_exact(1,w_full(east(
-                        origin_w(east(" ● ", fg(Rgb(255,255,255), bold(true, port.port_name())))),
-                        w_full(origin_e(format!("{}/{} ",
-                            port.port().get_connections().len(),
-                            port.connections.len())))))));
-                    for (index, conn) in port.connections.iter().enumerate() {
-                        to.place(&h_exact(1, w_full(origin_w(format!("   c{index:02}{}", conn.info())))));
-                    }
-                }
-            })))));
-        h_exact(h, view_track_row_section(theme, list, button_2("O", "+", false),
-            bg(theme.darker.term, origin_w(w_full(
-                thunk(|to: &mut Tui|{
-                    for (index, track, _x1, _x2) in self.tracks_with_sizes() {
-                        to.place(&w_exact(track_width(index, track),
-                            thunk(|to: &mut Tui|{
-                                to.place(&h_exact(1, origin_w(east(
-                                    either(true,  fg(Green,  "play "), "play "),
-                                    either(false, fg(Yellow, "solo "), "solo "),
-                                ))));
-                                for (_index, port) in self.midi_outs().iter().enumerate() {
-                                    to.place(&h_exact(1, origin_w(east(
-                                        either(true,  fg(Green,  " ●   "), " ·   "),
-                                        either(false, fg(Yellow, " ●   "), " ·   "),
-                                    ))));
-                                    for (_index, _conn) in port.connections.iter().enumerate() {
-                                        to.place(&h_exact(1, w_full("")));
-                                    }
-                                }})))}}))))))
-    }
-    #[cfg(feature = "track")] pub fn view_track_devices (&self, theme: ItemTheme) -> impl Draw<Tui> {
-        let mut h = 2u16;
-        for track in self.tracks().iter() {
-            h = h.max(track.devices.len() as u16 * 2);
-        }
-        view_track_row_section(theme,
-            button_3("d", "evice", format!("{}", self.track().map(|t|t.devices.len()).unwrap_or(0)), false),
-            button_2("D", "+", false),
-            thunk(move|to: &mut Tui|for (index, track, _x1, _x2) in self.tracks_with_sizes() {
-                to.place(&wh_exact(track_width(index, track), h + 1,
-                    bg(track.color.dark.term, origin_nw(iter_south(2, move||0..h,
-                        |_, _index|wh_exact(track.width as u16, 2,
-                            fg_bg(
-                                ItemTheme::G[32].lightest.term,
-                                ItemTheme::G[32].dark.term,
-                                origin_nw(format!(" · {}", "--")))))))));
-            }))
-    }
-    /// Put a clip in a slot
-    #[cfg(feature = "clip")] 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
-    #[cfg(feature = "clip")] 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
-    #[cfg(feature = "clip")] pub fn toggle_loop (&mut self) {
-        if let Some(clip) = self.selected_clip() {
-            clip.write().unwrap().toggle_loop()
-        }
-    }
-    /// Get the first sampler of the active track
-    #[cfg(feature = "sampler")] pub fn sampler (&self) -> Option<&Sampler> {
-        self.selected_track()?.sampler(0)
-    }
-    /// Get the first sampler of the active track
-    #[cfg(feature = "sampler")] pub fn sampler_mut (&mut self) -> Option<&mut Sampler> {
-        self.selected_track_mut()?.sampler_mut(0)
-    }
-}
-impl ScenesView for Arrangement {
-    fn h_scenes (&self) -> u16 {
-        (self.measure_height() as u16).saturating_sub(20)
-    }
-    fn w_side (&self) -> u16 {
-        (self.measure_width() as u16 * 2 / 10).max(20)
-    }
-    fn w_mid (&self) -> u16 {
-        (self.measure_width() as u16).saturating_sub(2 * self.w_side()).max(40)
-    }
-}
-impl HasClipsSize for Arrangement {
-    fn clips_size (&self) -> &[AtomicUsize; 2] { &self.size_inner }
-}
-
-pub type SceneWith<'a, T> =
-    (usize, &'a Scene, usize, usize, T);
-
-def_command!(SceneCommand: |scene: Scene| {
-    SetSize { size: usize } => { todo!() },
-    SetZoom { size: usize } => { todo!() },
-    SetName  { name:  Arc<str>  } =>
-        swap_value(&mut scene.name, name, |name|Self::SetName{name}),
-    SetColor { color: ItemTheme } =>
-        swap_value(&mut scene.color, color, |color|Self::SetColor{color}),
-});
-
-def_command!(TrackCommand: |track: Track| {
-    Stop => { track.sequencer.enqueue_next(None); Ok(None) },
-    SetMute { mute: Option<bool> } => todo!(),
-    SetSolo { solo: Option<bool> } => todo!(),
-    SetSize { size: usize } => todo!(),
-    SetZoom { zoom: usize } => todo!(),
-    SetName { name: Arc<str> } =>
-        swap_value(&mut track.name, name, |name|Self::SetName { name }),
-    SetColor { color: ItemTheme } =>
-        swap_value(&mut track.color, color, |color|Self::SetColor { color }),
-    SetRec { rec: Option<bool> } =>
-        toggle_bool(&mut track.sequencer.recording, rec, |rec|Self::SetRec { rec }),
-    SetMon { mon: Option<bool> } =>
-        toggle_bool(&mut track.sequencer.monitoring, mon, |mon|Self::SetMon { mon }),
-});
-
-def_command!(ClipCommand: |clip: MidiClip| {
-    SetColor { color: Option<ItemTheme> } => {
-        //(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!()
-    },
-    SetLoop { looping: Option<bool> } => {
-        //(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!()
-    }
-});

src/deps.rs

@@ -0,0 +1,33 @@
+#[cfg(feature = "cli")]
+pub(crate) use ::clap::{self, Parser, Subcommand};
+
+pub(crate) use ::xdg::BaseDirectories;
+
+pub(crate) use ::midly::{Smf, TrackEventKind, MidiMessage, Error as MidiError, num::*, live::*};
+
+pub(crate) use tengri::{
+    *, lang::*,
+    crossterm::event::{Event, KeyEvent},
+    ratatui::{
+        self,
+        prelude::{Rect, Style, Stylize, Buffer, Color::{self, *}},
+        widgets::{Widget, canvas::{Canvas, Line}},
+    },
+};
+
+#[allow(unused)]
+pub(crate) use ::{
+    std::{
+        cmp::Ord,
+        collections::BTreeMap,
+        error::Error,
+        ffi::OsString,
+        fmt::{Write, Debug, Formatter},
+        fs::File,
+        ops::{Add, Sub, Mul, Div, Rem},
+        path::{Path, PathBuf},
+        sync::{Arc, RwLock, atomic::{AtomicBool, AtomicUsize, Ordering::Relaxed}},
+        time::Duration,
+        thread::{spawn, JoinHandle},
+    },
+};

src/device.rs

@@ -1,30 +1,7 @@
 use crate::*;
-use ConnectName::*;
-use ConnectScope::*;
-use ConnectStatus::*;
 
 def_command!(DeviceCommand: |device: Device| {});
 
-def_command!(MidiInputCommand: |port: MidiInput| {
-    Close => todo!(),
-    Connect { midi_out: Arc<str> } => todo!(),
-});
-
-def_command!(MidiOutputCommand: |port: MidiOutput| {
-    Close => todo!(),
-    Connect { midi_in: Arc<str> } => todo!(),
-});
-
-def_command!(AudioInputCommand: |port: AudioInput| {
-    Close => todo!(),
-    Connect { audio_out: Arc<str> } => todo!(),
-});
-
-def_command!(AudioOutputCommand: |port: AudioOutput| {
-    Close => todo!(),
-    Connect { audio_in: Arc<str> } => todo!(),
-});
-
 impl Device {
     pub fn name (&self) -> &str {
         match self {
@@ -84,516 +61,6 @@ impl Device {
 /// Some sort of wrapper?
 pub struct DeviceAudio<'a>(pub &'a mut Device);
 
-/// Audio input port.
-#[derive(Debug)] pub struct AudioInput {
-    /// Handle to JACK client, for receiving reconnect events.
-    pub jack: Jack<'static>,
-    /// Port name
-    pub name: Arc<str>,
-    /// Port handle.
-    pub port: Port<AudioIn>,
-    /// List of ports to connect to.
-    pub connections: Vec<Connect>,
-}
-
-/// Audio output port.
-#[derive(Debug)] pub struct AudioOutput {
-    /// Handle to JACK client, for receiving reconnect events.
-    pub jack: Jack<'static>,
-    /// Port name
-    pub name: Arc<str>,
-    /// Port handle.
-    pub port: Port<AudioOut>,
-    /// List of ports to connect to.
-    pub connections: Vec<Connect>,
-}
-
-/// MIDI input port.
-#[derive(Debug)] pub struct MidiInput {
-    /// Handle to JACK client, for receiving reconnect events.
-    pub jack: Jack<'static>,
-    /// Port name
-    pub name: Arc<str>,
-    /// Port handle.
-    pub port: Port<MidiIn>,
-    /// List of currently held notes.
-    pub held: Arc<RwLock<[bool;128]>>,
-    /// List of ports to connect to.
-    pub connections: Vec<Connect>,
-}
-
-/// MIDI output port.
-#[derive(Debug)] pub struct MidiOutput {
-    /// Handle to JACK client, for receiving reconnect events.
-    pub jack: Jack<'static>,
-    /// Port name
-    pub name: Arc<str>,
-    /// Port handle.
-    pub port: Port<MidiOut>,
-    /// List of ports to connect to.
-    pub connections: Vec<Connect>,
-    /// List of currently held notes.
-    pub held: Arc<RwLock<[bool;128]>>,
-    /// Buffer
-    pub note_buffer: Vec<u8>,
-    /// Buffer
-    pub output_buffer: Vec<Vec<Vec<u8>>>,
-}
-
-#[derive(Clone, Debug, PartialEq)] pub enum ConnectName {
-    /** Exact match */
-    Exact(Arc<str>),
-    /** Match regular expression */
-    RegExp(Arc<str>),
-}
-
-#[derive(Clone, Copy, Debug, PartialEq)] pub enum ConnectScope {
-    One,
-    All
-}
-
-#[derive(Clone, Copy, Debug, PartialEq)] pub enum ConnectStatus {
-    Missing,
-    Disconnected,
-    Connected,
-    Mismatch,
-}
-
-/// Port connection manager.
-///
-/// ```
-/// let connect = tek::Connect::default();
-/// ```
-#[derive(Clone, Debug, Default)] pub struct Connect {
-    pub name:   Option<ConnectName>,
-    pub scope:  Option<ConnectScope>,
-    pub status: Arc<RwLock<Vec<(Port<Unowned>, Arc<str>, ConnectStatus)>>>,
-    pub info:   Arc<str>,
-}
-
-impl Connect {
-    pub fn collect (exact: &[impl AsRef<str>], re: &[impl AsRef<str>], re_all: &[impl AsRef<str>])
-        -> Vec<Self>
-    {
-        let mut connections = vec![];
-        for port in exact.iter()  { connections.push(Self::exact(port)) }
-        for port in re.iter()     { connections.push(Self::regexp(port)) }
-        for port in re_all.iter() { connections.push(Self::regexp_all(port)) }
-        connections
-    }
-    /// Connect to this exact port
-    pub fn exact (name: impl AsRef<str>) -> Self {
-        let info = format!("=:{}", name.as_ref()).into();
-        let name = Some(Exact(name.as_ref().into()));
-        Self { name, scope: Some(One), status: Arc::new(RwLock::new(vec![])), info }
-    }
-    pub fn regexp (name: impl AsRef<str>) -> Self {
-        let info = format!("~:{}", name.as_ref()).into();
-        let name = Some(RegExp(name.as_ref().into()));
-        Self { name, scope: Some(One), status: Arc::new(RwLock::new(vec![])), info }
-    }
-    pub fn regexp_all (name: impl AsRef<str>) -> Self {
-        let info = format!("+:{}", name.as_ref()).into();
-        let name = Some(RegExp(name.as_ref().into()));
-        Self { name, scope: Some(All), status: Arc::new(RwLock::new(vec![])), info }
-    }
-    pub fn info (&self) -> Arc<str> {
-        format!(" ({}) {} {}", {
-            let status = self.status.read().unwrap();
-            let mut ok = 0;
-            for (_, _, state) in status.iter() {
-                if *state == Connected {
-                    ok += 1
-                }
-            }
-            format!("{ok}/{}", status.len())
-        }, match self.scope {
-            None      => "x",
-            Some(One) => " ",
-            Some(All) => "*",
-        }, match &self.name {
-            None               => format!("x"),
-            Some(Exact(name))  => format!("= {name}"),
-            Some(RegExp(name)) => format!("~ {name}"),
-        }).into()
-    }
-}
-
-impl HasJack<'static> for MidiInput { fn jack (&self) -> &Jack<'static> { &self.jack } }
-impl HasJack<'static> for MidiOutput { fn jack (&self) -> &Jack<'static> { &self.jack } }
-impl HasJack<'static> for AudioInput { fn jack (&self) -> &Jack<'static> { &self.jack } }
-impl HasJack<'static> for AudioOutput { fn jack (&self) -> &Jack<'static> { &self.jack } }
-impl<J: HasJack<'static>> RegisterPorts for J {
-    fn midi_in (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<MidiInput> {
-        MidiInput::new(self.jack(), name, connect)
-    }
-    fn midi_out (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<MidiOutput> {
-        MidiOutput::new(self.jack(), name, connect)
-    }
-    fn audio_in (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<AudioInput> {
-        AudioInput::new(self.jack(), name, connect)
-    }
-    fn audio_out (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<AudioOutput> {
-        AudioOutput::new(self.jack(), name, connect)
-    }
-}
-
-/// May create new MIDI input ports.
-pub trait AddMidiIn {
-    fn midi_in_add (&mut self) -> Usually<()>;
-}
-
-/// May create new MIDI output ports.
-pub trait AddMidiOut {
-    fn midi_out_add (&mut self) -> Usually<()>;
-}
-
-pub trait RegisterPorts: HasJack<'static> {
-    /// Register a MIDI input port.
-    fn midi_in (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<MidiInput>;
-    /// Register a MIDI output port.
-    fn midi_out (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<MidiOutput>;
-    /// Register an audio input port.
-    fn audio_in (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<AudioInput>;
-    /// Register an audio output port.
-    fn audio_out (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<AudioOutput>;
-}
-
-pub trait JackPort: HasJack<'static> {
-
-    type Port: PortSpec + Default;
-
-    type Pair: PortSpec + Default;
-
-    fn new (jack: &Jack<'static>, name: &impl AsRef<str>, connect: &[Connect])
-        -> Usually<Self> where Self: Sized;
-
-    fn register (jack: &Jack<'static>, name: &impl AsRef<str>) -> Usually<Port<Self::Port>> {
-        jack.with_client(|c|c.register_port::<Self::Port>(name.as_ref(), Default::default()))
-            .map_err(|e|e.into())
-    }
-
-    fn port_name (&self) -> &Arc<str>;
-
-    fn connections (&self) -> &[Connect];
-
-    fn port (&self) -> &Port<Self::Port>;
-
-    fn port_mut (&mut self) -> &mut Port<Self::Port>;
-
-    fn into_port (self) -> Port<Self::Port> where Self: Sized;
-
-    fn close (self) -> Usually<()> where Self: Sized {
-        let jack = self.jack().clone();
-        Ok(jack.with_client(|c|c.unregister_port(self.into_port()))?)
-    }
-
-    fn ports (&self, re_name: Option<&str>, re_type: Option<&str>, flags: PortFlags) -> Vec<String> {
-        self.with_client(|c|c.ports(re_name, re_type, flags))
-    }
-
-    fn port_by_id (&self, id: u32) -> Option<Port<Unowned>> {
-        self.with_client(|c|c.port_by_id(id))
-    }
-
-    fn port_by_name (&self, name: impl AsRef<str>) -> Option<Port<Unowned>> {
-        self.with_client(|c|c.port_by_name(name.as_ref()))
-    }
-
-    fn connect_to_matching <'k> (&'k self) -> Usually<()> {
-        for connect in self.connections().iter() {
-            match &connect.name {
-                Some(Exact(name)) => {
-                    *connect.status.write().unwrap() = self.connect_exact(name)?;
-                },
-                Some(RegExp(re))  => {
-                    *connect.status.write().unwrap() = self.connect_regexp(re, connect.scope)?;
-                },
-                _ => {},
-            };
-        }
-        Ok(())
-    }
-
-    fn connect_exact <'k> (&'k self, name: &str) ->
-        Usually<Vec<(Port<Unowned>, Arc<str>, ConnectStatus)>>
-    {
-        self.with_client(move|c|{
-            let mut status = vec![];
-            for port in c.ports(None, None, PortFlags::empty()).iter() {
-                if port.as_str() == &*name {
-                    if let Some(port) = c.port_by_name(port.as_str()) {
-                        let port_status = self.connect_to_unowned(&port)?;
-                        let name = port.name()?.into();
-                        status.push((port, name, port_status));
-                        if port_status == Connected {
-                            break
-                        }
-                    }
-                }
-            }
-            Ok(status)
-        })
-    }
-
-    fn connect_regexp <'k> (
-        &'k self, re: &str, scope: Option<ConnectScope>
-    ) -> Usually<Vec<(Port<Unowned>, Arc<str>, ConnectStatus)>> {
-        self.with_client(move|c|{
-            let mut status = vec![];
-            let ports = c.ports(Some(&re), None, PortFlags::empty());
-            for port in ports.iter() {
-                if let Some(port) = c.port_by_name(port.as_str()) {
-                    let port_status = self.connect_to_unowned(&port)?;
-                    let name = port.name()?.into();
-                    status.push((port, name, port_status));
-                    if port_status == Connected && scope == Some(One) {
-                        break
-                    }
-                }
-            }
-            Ok(status)
-        })
-    }
-
-    /** Connect to a matching port by name. */
-    fn connect_to_name (&self, name: impl AsRef<str>) -> Usually<ConnectStatus> {
-        self.with_client(|c|if let Some(ref port) = c.port_by_name(name.as_ref()) {
-            self.connect_to_unowned(port)
-        } else {
-            Ok(Missing)
-        })
-    }
-
-    /** Connect to a matching port by reference. */
-    fn connect_to_unowned (&self, port: &Port<Unowned>) -> Usually<ConnectStatus> {
-        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
-        }))
-    }
-
-    /** Connect to an owned matching port by reference. */
-    fn connect_to_owned (&self, port: &Port<Self::Pair>) -> Usually<ConnectStatus> {
-        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 JackPort for MidiInput {
-    type Port = MidiIn;
-    type Pair = MidiOut;
-    fn port_name (&self) -> &Arc<str> {
-        &self.name
-    }
-    fn port (&self) -> &Port<Self::Port> {
-        &self.port
-    }
-    fn port_mut (&mut self) -> &mut Port<Self::Port> {
-        &mut self.port
-    }
-    fn into_port (self) -> Port<Self::Port> {
-        self.port
-    }
-    fn connections (&self) -> &[Connect] {
-        self.connections.as_slice()
-    }
-    fn new (jack: &Jack<'static>, name: &impl AsRef<str>, connect: &[Connect])
-        -> Usually<Self> where Self: Sized
-    {
-        let port = Self {
-            port: Self::register(jack, name)?,
-            jack: jack.clone(),
-            name: name.as_ref().into(),
-            connections: connect.to_vec(),
-            held: Arc::new(RwLock::new([false;128]))
-        };
-        port.connect_to_matching()?;
-        Ok(port)
-    }
-}
-
-impl JackPort for MidiOutput {
-    type Port = MidiOut;
-    type Pair = MidiIn;
-    fn port_name (&self) -> &Arc<str> {
-        &self.name
-    }
-    fn port (&self) -> &Port<Self::Port> {
-        &self.port
-    }
-    fn port_mut (&mut self) -> &mut Port<Self::Port> {
-        &mut self.port
-    }
-    fn into_port (self) -> Port<Self::Port> {
-        self.port
-    }
-    fn connections (&self) -> &[Connect] {
-        self.connections.as_slice()
-    }
-    fn new (jack: &Jack<'static>, name: &impl AsRef<str>, connect: &[Connect])
-        -> Usually<Self> where Self: Sized
-    {
-        let port = Self::register(jack, name)?;
-        let jack = jack.clone();
-        let name = name.as_ref().into();
-        let connections = connect.to_vec();
-        let port = Self {
-            jack,
-            port,
-            name,
-            connections,
-            held: Arc::new([false;128].into()),
-            note_buffer: vec![0;8],
-            output_buffer: vec![vec![];65536],
-        };
-        port.connect_to_matching()?;
-        Ok(port)
-    }
-}
-
-impl MidiOutput {
-    /// 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 MidiInput {
-    pub fn parsed <'a> (&'a self, scope: &'a ProcessScope) -> impl Iterator<Item=(usize, LiveEvent<'a>, &'a [u8])> {
-        parse_midi_input(self.port().iter(scope))
-    }
-}
-impl<T: AsRef<Vec<MidiInput>> + AsMut<Vec<MidiInput>>> HasMidiIns for T {
-    fn midi_ins (&self) -> &Vec<MidiInput> { self.as_ref() }
-    fn midi_ins_mut (&mut self) -> &mut Vec<MidiInput> { self.as_mut() }
-}
-impl<T: AsRef<Vec<MidiOutput>> + AsMut<Vec<MidiOutput>>> HasMidiOuts for T {
-    fn midi_outs (&self) -> &Vec<MidiOutput> { self.as_ref() }
-    fn midi_outs_mut (&mut self) -> &mut Vec<MidiOutput> { self.as_mut() }
-}
-impl<T: HasMidiIns + HasJack<'static>> AddMidiIn for T {
-    fn midi_in_add (&mut self) -> Usually<()> {
-        let index = self.midi_ins().len();
-        let port  = MidiInput::new(self.jack(), &format!("M/{index}"), &[])?;
-        self.midi_ins_mut().push(port);
-        Ok(())
-    }
-}
-/// Trail for thing that may gain new MIDI ports.
-impl<T: HasMidiOuts + HasJack<'static>> AddMidiOut for T {
-    fn midi_out_add (&mut self) -> Usually<()> {
-        let index = self.midi_outs().len();
-        let port  = MidiOutput::new(self.jack(), &format!("{index}/M"), &[])?;
-        self.midi_outs_mut().push(port);
-        Ok(())
-    }
-}
-
-impl JackPort for AudioInput {
-    type Port = AudioIn;
-    type Pair = AudioOut;
-    fn port_name (&self) -> &Arc<str> {
-        &self.name
-    }
-    fn port (&self) -> &Port<Self::Port> {
-        &self.port
-    }
-    fn port_mut (&mut self) -> &mut Port<Self::Port> {
-        &mut self.port
-    }
-    fn into_port (self) -> Port<Self::Port> {
-        self.port
-    }
-    fn connections (&self) -> &[Connect] {
-        self.connections.as_slice()
-    }
-    fn new (jack: &Jack<'static>, name: &impl AsRef<str>, connect: &[Connect])
-        -> Usually<Self> where Self: Sized
-    {
-        let port = Self {
-            port: Self::register(jack, name)?,
-            jack: jack.clone(),
-            name: name.as_ref().into(),
-            connections: connect.to_vec()
-        };
-        port.connect_to_matching()?;
-        Ok(port)
-    }
-}
-
-impl JackPort for AudioOutput {
-    type Port = AudioOut;
-    type Pair = AudioIn;
-    fn port_name (&self) -> &Arc<str> {
-        &self.name
-    }
-    fn port (&self) -> &Port<Self::Port> {
-        &self.port
-    }
-    fn port_mut (&mut self) -> &mut Port<Self::Port> {
-        &mut self.port
-    }
-    fn into_port (self) -> Port<Self::Port> {
-        self.port
-    }
-    fn connections (&self) -> &[Connect] {
-        self.connections.as_slice()
-    }
-    fn new (jack: &Jack<'static>, name: &impl AsRef<str>, connect: &[Connect])
-        -> Usually<Self> where Self: Sized
-    {
-        let port = Self {
-            port: Self::register(jack, name)?,
-            jack: jack.clone(),
-            name: name.as_ref().into(),
-            connections: connect.to_vec()
-        };
-        port.connect_to_matching()?;
-        Ok(port)
-    }
-}
-
 impl_audio!(|self: DeviceAudio<'a>, client, scope|{
     use Device::*;
     match self.0 {
@@ -623,48 +90,27 @@ impl<T: AsRef<Vec<Device>> + AsMut<Vec<Device>>> HasDevices for T {
         self.as_mut()
     }
 }
-/// Trait for thing that may receive MIDI.
-pub trait HasMidiIns {
-    fn midi_ins (&self) -> &Vec<MidiInput>;
-    fn midi_ins_mut (&mut self) -> &mut Vec<MidiInput>;
-    /// Collect MIDI input from app ports (TODO preallocate large buffers)
-    fn midi_input_collect <'a> (&'a self, scope: &'a ProcessScope) -> CollectedMidiInput<'a> {
-        self.midi_ins().iter()
-            .map(|port|port.port().iter(scope)
-                .map(|RawMidi { time, bytes }|(time, LiveEvent::parse(bytes)))
-                .collect::<Vec<_>>())
-            .collect::<Vec<_>>()
-    }
-    fn midi_ins_with_sizes <'a> (&'a self) ->
-        impl Iterator<Item=(usize, &'a Arc<str>, &'a [Connect], usize, usize)> + Send + Sync + 'a
-    {
-        let mut y = 0;
-        self.midi_ins().iter().enumerate().map(move|(i, input)|{
-            let height = 1 + input.connections().len();
-            let data   = (i, input.port_name(), input.connections(), y, y + height);
-            y += height;
-            data
-        })
-    }
-}
-/// Trait for thing that may output MIDI.
-pub trait HasMidiOuts {
-    fn midi_outs (&self) -> &Vec<MidiOutput>;
-    fn midi_outs_mut (&mut self) -> &mut Vec<MidiOutput>;
-    fn midi_outs_with_sizes <'a> (&'a self) ->
-        impl Iterator<Item=(usize, &'a Arc<str>, &'a [Connect], usize, usize)> + Send + Sync + 'a
-    {
-        let mut y = 0;
-        self.midi_outs().iter().enumerate().map(move|(i, output)|{
-            let height = 1 + output.connections().len();
-            let data   = (i, output.port_name(), output.connections(), y, y + height);
-            y += height;
-            data
-        })
-    }
-    fn midi_outs_emit (&mut self, scope: &ProcessScope) {
-        for port in self.midi_outs_mut().iter_mut() {
-            port.buffer_emit(scope)
+
+pub trait HasDevices: AsRef<Vec<Device>> + AsMut<Vec<Device>> {
+    fn devices (&self) -> &Vec<Device> {
+        self.as_ref()
     }
+    fn devices_mut (&mut self) -> &mut Vec<Device> {
+        self.as_mut()
     }
 }
+
+pub mod arrange;  pub use self::arrange::*;
+pub mod browse;   pub use self::browse::*;
+pub mod clock;    pub use self::clock::*;
+pub mod dialog;   pub use self::dialog::*;
+pub mod editor;   pub use self::editor::*;
+pub mod menu;     pub use self::menu::*;
+pub mod meter;    pub use self::meter::*;
+pub mod mix;      pub use self::mix::*;
+pub mod port;     pub use self::port::*;
+pub mod sampler;  pub use self::sampler::*;
+pub mod sequence; pub use self::sequence::*;
+
+#[cfg(feature = "plugin")] pub mod plugin;
+#[cfg(feature = "plugin")] pub use self::plugin::*;

src/device/arrange.rs

@@ -0,0 +1,123 @@
+use crate::*;
+
+/// Arranger.
+///
+/// ```
+/// let arranger = tek::Arrangement::default();
+/// ```
+#[derive(Default, Debug)] pub struct Arrangement {
+    /// Project name.
+    pub name:       Arc<str>,
+    /// Base color.
+    pub color:      ItemTheme,
+    /// JACK client handle.
+    pub jack:       Jack<'static>,
+    /// FIXME 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:       Sizer,
+    /// Display size of clips area
+    pub size_inner: Sizer,
+    /// Source of time
+    #[cfg(feature = "clock")]  pub clock: Clock,
+    /// Allows one MIDI clip to be edited
+    #[cfg(feature = "editor")] pub editor: Option<MidiEditor>,
+    /// List of global midi inputs
+    #[cfg(feature = "port")]   pub midi_ins:   Vec<MidiInput>,
+    /// List of global midi outputs
+    #[cfg(feature = "port")]   pub midi_outs:  Vec<MidiOutput>,
+    /// List of global audio inputs
+    #[cfg(feature = "port")]   pub audio_ins:  Vec<AudioInput>,
+    /// List of global audio outputs
+    #[cfg(feature = "port")]   pub audio_outs: Vec<AudioOutput>,
+    /// Selected UI element
+    #[cfg(feature = "select")] pub selection: Selection,
+    /// Last track number (to avoid duplicate port names)
+    #[cfg(feature = "track")]  pub track_last:   usize,
+    /// List of tracks
+    #[cfg(feature = "track")]  pub tracks: Vec<Track>,
+    /// Scroll offset of tracks
+    #[cfg(feature = "track")]  pub track_scroll: usize,
+    /// List of scenes
+    #[cfg(feature = "scene")]  pub scenes: Vec<Scene>,
+    /// Scroll offset of scenes
+    #[cfg(feature = "scene")]  pub scene_scroll: usize,
+}
+
+impl HasJack<'static> for Arrangement { fn jack (&self) -> &Jack<'static> { &self.jack } }
+impl_has!(Jack<'static>:     |self: Arrangement| self.jack);
+impl_has!(Sizer:             |self: Arrangement| self.size);
+impl_has!(Vec<MidiInput>:    |self: Arrangement| self.midi_ins);
+impl_has!(Vec<MidiOutput>:   |self: Arrangement| self.midi_outs);
+impl_has!(Clock:             |self: Arrangement| self.clock);
+impl_has!(Selection:         |self: Arrangement| self.selection);
+impl_as_ref_opt!(MidiEditor: |self: Arrangement| self.editor.as_ref());
+impl_as_mut_opt!(MidiEditor: |self: Arrangement| self.editor.as_mut());
+
+impl Arrangement {
+
+    /// Create a new arrangement.
+    pub fn new (
+        jack:      &Jack<'static>,
+        name:      Option<Arc<str>>,
+        clock:     Clock,
+        tracks:    Vec<Track>,
+        scenes:    Vec<Scene>,
+        midi_ins:  Vec<MidiInput>,
+        midi_outs: Vec<MidiOutput>,
+    ) -> Self {
+        Self {
+            clock, tracks, scenes, midi_ins, midi_outs,
+            jack: jack.clone(),
+            name: name.unwrap_or_default(),
+            color: ItemTheme::random(),
+            selection: Selection::TrackClip { track: 0, scene: 0 },
+            ..Default::default()
+        }
+    }
+
+    /// Width of display
+    pub fn w (&self) -> u16 {
+        self.size.w() as u16
+    }
+
+    /// Width allocated for sidebar.
+    pub fn w_sidebar (&self, is_editing: bool) -> u16 {
+        self.w() / if is_editing { 16 } else { 8 } as u16
+    }
+
+    /// Width available to display tracks.
+    pub fn w_tracks_area (&self, is_editing: bool) -> u16 {
+        self.w().saturating_sub(self.w_sidebar(is_editing))
+    }
+
+    /// Height of display
+    pub fn h (&self) -> u16 {
+        self.size.h() as u16
+    }
+
+    /// Height taken by visible device slots.
+    pub fn h_devices (&self) -> u16 {
+        2
+        //1 + self.devices_with_sizes().last().map(|(_, _, _, _, y)|y as u16).unwrap_or(0)
+    }
+
+    /// Get the first sampler of the active track
+    #[cfg(feature = "sampler")]
+    pub fn sampler (&self) -> Option<&Sampler> {
+        self.selected_track()?.sampler(0)
+    }
+
+    /// Get the first sampler of the active track
+    #[cfg(feature = "sampler")]
+    pub fn sampler_mut (&mut self) -> Option<&mut Sampler> {
+        self.selected_track_mut()?.sampler_mut(0)
+    }
+
+}
+
+#[cfg(feature = "clip")] mod clip; #[cfg(feature = "clip")] pub use self::clip::*;
+#[cfg(feature = "scene")] mod scene; #[cfg(feature = "scene")] pub use self::scene::*;
+#[cfg(feature = "track")] mod track; #[cfg(feature = "track")] pub use self::track::*;
+#[cfg(feature = "select")] mod select; #[cfg(feature = "select")] pub use self::select::*;

src/device/arrange/clip.rs

@@ -0,0 +1,95 @@
+use crate::*;
+
+/// TODO: Preserve the generic passthru syntax;
+/// remove this macro (only used twice) and potentially the trait.
+#[macro_export] macro_rules! impl_has_clips {
+    (|$self:ident:$Struct:ident$(<$($L:lifetime),*$($T:ident$(:$U:path)?),*>)?|$cb:expr) => {
+        impl $(<$($L),*$($T $(: $U)?),*>)? HasClips for $Struct $(<$($L),*$($T),*>)? {
+            fn clips <'a> (&'a $self) -> std::sync::RwLockReadGuard<'a, ClipPool>      {
+                $cb.read().unwrap()
+            }
+            fn clips_mut <'a> (&'a $self) -> std::sync::RwLockWriteGuard<'a, ClipPool> {
+                $cb.write().unwrap()
+            }
+        }
+    }
+}
+
+#[macro_export] macro_rules! has_clip {
+    (|$self:ident:$Struct:ident$(<$($L:lifetime),*$($T:ident$(:$U:path)?),*>)?|$cb:expr) => {
+        impl $(<$($L),*$($T $(: $U)?),*>)? HasMidiClip for $Struct $(<$($L),*$($T),*>)? {
+            fn clip (&$self) -> Option<Arc<RwLock<MidiClip>>> { $cb }
+        }
+    }
+}
+
+pub trait ClipsView: TracksView + ScenesView {
+    /// Draw clips per scene
+    fn view_scenes_clips <'a> (&'a self) -> impl Draw<Tui> + 'a {
+        view_scenes_clips(
+            ||self.scenes_with_sizes(),
+            self.tracks_with_sizes(),
+            self.selection(),
+            self.editor(),
+            self.clips_size(),
+            self.is_editing(),
+        )
+    }
+}
+
+def_command!(ClipCommand: |clip: MidiClip| {
+    SetColor { color: Option<ItemTheme> } => {
+        //(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!()
+    },
+    SetLoop { looping: Option<bool> } => {
+        //(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 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.selected_clip() {
+            clip.write().unwrap().toggle_loop()
+        }
+    }
+}
+
+pub trait HasClipsSize {
+    fn clips_size (&self) -> &Sizer;
+}
+
+impl HasClipsSize for App {
+    fn clips_size (&self) -> &Sizer { &self.project.size_inner }
+}
+
+impl HasClipsSize for Arrangement {
+    fn clips_size (&self) -> &Sizer { &self.size_inner }
+}

src/device/arrange/scene.rs

@@ -0,0 +1,174 @@
+use crate::*;
+
+/// Default scene height.
+pub const H_SCENE: usize = 2;
+
+/// Default editor height.
+pub const H_EDITOR: usize = 15;
+
+/// A scene consists of a set of clips to play together.
+///
+/// ```
+/// let scene: tek::Scene = Default::default();
+/// let _ = scene.pulses();
+/// let _ = scene.is_playing(&[]);
+/// ```
+#[derive(Debug, Default)] pub struct Scene {
+    /// Name of scene
+    pub name:  Arc<str>,
+    /// Identifying color of scene
+    pub color: ItemTheme,
+    /// Clips in scene, one per track
+    pub clips: Vec<Option<Arc<RwLock<MidiClip>>>>,
+}
+
+impl Scene {
+    /// Returns the pulse length of the longest clip in the scene
+    pub fn pulses (&self) -> usize {
+        self.clips.iter().fold(0, |a, p|{
+            a.max(p.as_ref().map(|q|q.read().unwrap().length).unwrap_or(0))
+        })
+    }
+    /// Returns true if all clips in the scene are
+    /// currently playing on the given collection of tracks.
+    pub fn is_playing (&self, tracks: &[Track]) -> bool {
+        self.clips.iter().any(|clip|clip.is_some()) && self.clips.iter().enumerate()
+            .all(|(track_index, clip)|match clip {
+                Some(c) => tracks
+                    .get(track_index)
+                    .map(|track|{
+                        if let Some((_, Some(clip))) = track.sequencer().play_clip() {
+                            *clip.read().unwrap() == *c.read().unwrap()
+                        } else {
+                            false
+                        }
+                    })
+                    .unwrap_or(false),
+                None => true
+            })
+    }
+    pub fn clip (&self, index: usize) -> Option<&Arc<RwLock<MidiClip>>> {
+        match self.clips.get(index) { Some(Some(clip)) => Some(clip), _ => None }
+    }
+    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!() }
+}
+
+pub trait ScenesView: HasEditor + HasSelection + HasSceneScroll + HasClipsSize + Send + Sync {
+    fn h_scenes (&self) -> u16;
+    fn w_side   (&self) -> u16;
+    fn w_mid    (&self) -> u16;
+
+    fn view_scenes_names (&self) -> impl Draw<Tui> {
+        view_scenes_names(
+            self.scenes_with_sizes(), self.selection(), self.editor(), self.is_editing()
+        )
+    }
+    fn scenes_with_sizes (&self) -> impl ScenesSizes<'_> {
+        let mut y = 0;
+        self.scenes().iter().enumerate().skip(self.scene_scroll()).map_while(move|(s, scene)|{
+            let height = if self.selection().scene() == Some(s) && self.editor().is_some() {
+                8
+            } else {
+                H_SCENE
+            };
+            if y + height <= self.clips_size().h() as usize {
+                let data = (s, scene, y, y + height);
+                y += height;
+                Some(data)
+            } else {
+                None
+            }
+        })
+    }
+}
+
+pub trait HasSceneScroll: HasScenes {
+    fn scene_scroll (&self) -> usize;
+}
+
+pub trait HasScene: AsRefOpt<Scene> + AsMutOpt<Scene> {
+    fn scene_mut (&mut self) -> Option<&mut Scene> { self.as_mut_opt() }
+    fn scene     (&self)     -> Option<&Scene>     { self.as_ref_opt() }
+}
+
+pub trait HasScenes: AsRef<Vec<Scene>> + AsMut<Vec<Scene>> {
+    fn scenes (&self) -> &Vec<Scene> { self.as_ref()  }
+    fn scenes_mut (&mut self) -> &mut Vec<Scene> { self.as_mut() }
+    /// Generate the default name for a new scene
+    fn scene_default_name (&self) -> Arc<str> { format!("s{:3>}", self.scenes().len() + 1).into() }
+    fn scene_longest_name (&self) -> usize { self.scenes().iter().map(|s|s.name.len()).fold(0, usize::max) }
+    /// Add multiple scenes
+    fn scenes_add (&mut self, n: usize) -> Usually<()> where Self: HasTracks {
+        let scene_color_1 = ItemColor::random();
+        let scene_color_2 = ItemColor::random();
+        for i in 0..n {
+            let _ = self.scene_add(None, Some(
+                scene_color_1.mix(scene_color_2, i as f32 / n as f32).into()
+            ))?;
+        }
+        Ok(())
+    }
+    /// Add a scene
+    fn scene_add (&mut self, name: Option<&str>, color: Option<ItemTheme>)
+        -> Usually<(usize, &mut Scene)> where Self: HasTracks
+    {
+        let scene = Scene {
+            name:  name.map_or_else(||self.scene_default_name(), |x|x.to_string().into()),
+            clips: vec![None;self.tracks().len()],
+            color: color.unwrap_or_else(ItemTheme::random),
+        };
+        self.scenes_mut().push(scene);
+        let index = self.scenes().len() - 1;
+        Ok((index, &mut self.scenes_mut()[index]))
+    }
+}
+
+impl HasSceneScroll for Arrangement {
+    fn scene_scroll (&self) -> usize { self.scene_scroll }
+}
+
+impl HasSceneScroll for App {
+    fn scene_scroll (&self) -> usize { self.project.scene_scroll() }
+}
+
+impl ScenesView for Arrangement {
+    fn h_scenes (&self) -> u16 { (self.size.h() as u16).saturating_sub(20) }
+    fn w_side (&self) -> u16 { (self.size.w() as u16 * 2 / 10).max(20) }
+    fn w_mid (&self) -> u16 { (self.size.w() as u16).saturating_sub(2 * self.w_side()).max(40) }
+}
+
+pub type SceneWith<'a, T> =
+    (usize, &'a Scene, usize, usize, T);
+
+def_command!(SceneCommand: |scene: Scene| {
+    SetSize { size: usize } => { todo!() },
+    SetZoom { size: usize } => { todo!() },
+    SetName { name: Arc<str> } =>
+        swap_value(&mut scene.name, name, |name|Self::SetName{name}),
+    SetColor { color: ItemTheme } =>
+        swap_value(&mut scene.color, color, |color|Self::SetColor{color}),
+});
+
+#[cfg(all(feature = "select"))] impl_as_ref_opt!(Scene: |self: App| self.project.as_ref_opt());
+#[cfg(all(feature = "select"))] impl_as_mut_opt!(Scene: |self: App| self.project.as_mut_opt());
+#[cfg(all(feature = "select"))] impl_as_ref_opt!(Scene: |self: Arrangement| self.selected_scene());
+#[cfg(all(feature = "select"))] impl_as_mut_opt!(Scene: |self: Arrangement| self.selected_scene_mut());
+impl_has!(Vec<Scene>: |self: Arrangement| self.scenes);
+impl<T: TracksView+ScenesView+Send+Sync> ClipsView for T {}
+impl<T: AsRef<Vec<Scene>>+AsMut<Vec<Scene>>> HasScenes for T {}
+impl<T: AsRefOpt<Scene>+AsMutOpt<Scene>+Send+Sync> HasScene for T {}
+
+impl ScenesView for App {
+    fn w_mid (&self) -> u16 {
+        (self.size.w() as u16).saturating_sub(self.w_side())
+    }
+    fn w_side (&self) -> u16 {
+        20
+    }
+    fn h_scenes (&self) -> u16 {
+        (self.size.h() as u16).saturating_sub(20)
+    }
+}

src/device/arrange/track.rs

@@ -0,0 +1,350 @@
+use crate::*;
+
+/// A track consists of a sequencer and zero or more devices chained after it.
+///
+/// ```
+/// let track: tek::Track = Default::default();
+/// ```
+#[derive(Debug, Default)] pub struct Track {
+    /// Name of track
+    pub name:      Arc<str>,
+    /// Identifying color of track
+    pub color:     ItemTheme,
+    /// Preferred width of track column
+    pub width:     usize,
+    /// MIDI sequencer state
+    pub sequencer: Sequencer,
+    /// Device chain
+    pub devices:   Vec<Device>,
+}
+
+impl Track {
+    /// Create a new track with only the default [Sequencer].
+    pub fn new (
+        name:      &impl AsRef<str>,
+        color:     Option<ItemTheme>,
+        jack:      &Jack<'static>,
+        clock:     Option<&Clock>,
+        clip:      Option<&Arc<RwLock<MidiClip>>>,
+        midi_from: &[Connect],
+        midi_to:   &[Connect],
+    ) -> Usually<Self> {
+        Ok(Self {
+            name: name.as_ref().into(),
+            color: color.unwrap_or_default(),
+            sequencer: Sequencer::new(
+                format!("{}/sequencer", name.as_ref()), jack, clock, clip, midi_from, midi_to
+            )?,
+            ..Default::default()
+        })
+    }
+    pub fn audio_ins  (&self) -> &[AudioInput] {
+        self.devices.first().map(|x|x.audio_ins()).unwrap_or_default()
+    }
+    pub fn audio_outs (&self) -> &[AudioOutput] {
+        self.devices.last().map(|x|x.audio_outs()).unwrap_or_default()
+    }
+    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!() }
+
+    pub fn per <'a, T: Draw<Tui> + 'a, U: TracksSizes<'a>> (
+        tracks:   impl Fn() -> U + Send + Sync + 'a,
+        callback: impl Fn(usize, &'a Track)->T + Send + Sync + 'a
+    ) -> impl Draw<Tui> + 'a {
+        view_track_per(tracks, callback)
+    }
+}
+
+#[cfg(feature = "sampler")]
+impl Track {
+
+    /// Create a new track connecting the [Sequencer] to a [Sampler].
+    pub fn new_with_sampler (
+        name:       &impl AsRef<str>,
+        color:      Option<ItemTheme>,
+        jack:       &Jack<'static>,
+        clock:      Option<&Clock>,
+        clip:       Option<&Arc<RwLock<MidiClip>>>,
+        midi_from:  &[Connect],
+        midi_to:    &[Connect],
+        audio_from: &[&[Connect];2],
+        audio_to:   &[&[Connect];2],
+    ) -> Usually<Self> {
+        let mut track = Self::new(name, color, jack, clock, clip, midi_from, midi_to)?;
+        let client_name = jack.with_client(|c|c.name().to_string());
+        let port_name = track.sequencer.midi_outs[0].port_name();
+        let connect = [Connect::exact(format!("{client_name}:{}", port_name))];
+        track.devices.push(Device::Sampler(Sampler::new(
+            jack, &format!("{}/sampler", name.as_ref()), &connect, audio_from, audio_to
+        )?));
+        Ok(track)
+    }
+
+    pub fn sampler (&self, mut nth: usize) -> Option<&Sampler> {
+        for device in self.devices.iter() {
+            match device {
+                Device::Sampler(s) => if nth == 0 { return Some(s); } else { nth -= 1; },
+                _ => {}
+            }
+        }
+        None
+    }
+
+    pub fn sampler_mut (&mut self, mut nth: usize) -> Option<&mut Sampler> {
+        for device in self.devices.iter_mut() {
+            match device {
+                Device::Sampler(s) => if nth == 0 { return Some(s); } else { nth -= 1; },
+                _ => {}
+            }
+        }
+        None
+    }
+}
+
+impl HasWidth for Track {
+    const MIN_WIDTH: usize = 9;
+    fn width_inc (&mut self) { self.width += 1; }
+    fn width_dec (&mut self) { if self.width > Track::MIN_WIDTH { self.width -= 1; } }
+}
+
+pub trait HasTracks: AsRef<Vec<Track>> + AsMut<Vec<Track>> {
+    fn tracks (&self) -> &Vec<Track> { self.as_ref() }
+    fn tracks_mut (&mut self) -> &mut Vec<Track> { self.as_mut() }
+    /// 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);
+            }
+        }
+    }
+    /// Spacing between tracks.
+    const TRACK_SPACING: usize = 0;
+}
+
+pub trait HasTrack: AsRefOpt<Track> + AsMutOpt<Track> {
+    fn track (&self) -> Option<&Track> { self.as_ref_opt() }
+    fn track_mut (&mut self) -> Option<&mut Track> { self.as_mut_opt() }
+
+    #[cfg(feature = "port")]
+    fn view_midi_ins_status <'a> (&'a self, theme: ItemTheme) -> impl Draw<Tui> + 'a {
+        view_midi_ins_status(theme, self.track())
+    }
+
+    #[cfg(feature = "port")]
+    fn view_midi_outs_status (&self, theme: ItemTheme) -> impl Draw<Tui>  + '_ {
+        view_midi_outs_status(theme, self.track())
+    }
+
+    #[cfg(feature = "port")]
+    fn view_audio_ins_status (&self, theme: ItemTheme) -> impl Draw<Tui> {
+        view_audio_ins_status(theme, self.track())
+    }
+
+    #[cfg(feature = "port")]
+    fn view_audio_outs_status (&self, theme: ItemTheme) -> impl Draw<Tui> {
+        view_audio_outs_status(theme, self.track())
+    }
+}
+
+pub trait HasTrackScroll: HasTracks {
+    fn track_scroll (&self) -> usize;
+}
+
+pub trait TracksView: ScenesView + HasMidiIns + HasMidiOuts + HasTrackScroll {
+    /// Draw name of each track
+    fn view_track_names (&self, theme: ItemTheme) -> impl Draw<Tui> {
+        view_track_names(
+            theme, self.tracks_with_sizes(), self.tracks().len(), self.scenes().len(), self.selection()
+        )
+    }
+    /// Draw outputs per track
+    fn view_track_outputs <'a> (&'a self, theme: ItemTheme, _h: u16) -> impl Draw<Tui> {
+        view_track_outputs(
+            theme, self.tracks_with_sizes(), self.midi_outs().iter()
+        )
+    }
+    /// Draw inputs per track
+    fn view_track_inputs <'a> (&'a self, theme: ItemTheme) -> impl Draw<Tui> {
+        let mut h = 0u16;
+        for track in self.tracks().iter() {
+            h = h.max(track.sequencer.midi_ins.len() as u16);
+        }
+        view_track_inputs(theme, self.tracks_with_sizes(), h)
+    }
+    /// Iterate over tracks with their corresponding sizes.
+    fn tracks_with_sizes (&self) -> impl TracksSizes<'_> {
+        let _editor_width = self.editor().map(|e|e.size.w());
+        let _active_track = self.selection().track();
+        let mut x = 0;
+        let w = self.clips_size().w() as usize;
+        self.tracks().iter().enumerate().map_while(move |(index, track)|{
+            let width = track.width.max(8);
+            if x + width < w {
+                let data = (index, track, x, x + width);
+                x += width + Self::TRACK_SPACING;
+                Some(data)
+            } else {
+                None
+            }
+        })
+    }
+
+}
+
+impl HasTrackScroll for Arrangement {
+    fn track_scroll (&self) -> usize { self.track_scroll }
+}
+
+def_command!(TrackCommand: |track: Track| {
+    Stop => { track.sequencer.enqueue_next(None); Ok(None) },
+    SetRec   { rec: Option<bool> } => toggle_bool(&mut track.sequencer.recording,  rec, |rec|Self::SetRec { rec }),
+    SetMon   { mon: Option<bool> } => toggle_bool(&mut track.sequencer.monitoring, mon, |mon|Self::SetMon { mon }),
+    SetMute  { mute: Option<bool> } => todo!(),
+    SetSolo  { solo: Option<bool> } => todo!(),
+    SetSize  { size: usize } => todo!(),
+    SetZoom  { zoom: usize } => todo!(),
+    SetName  { name: Arc<str> } => swap_value(&mut track.name, name, |name|Self::SetName { name }),
+    SetColor { color: ItemTheme } => swap_value(&mut track.color, color, |color|Self::SetColor { color }),
+});
+
+impl<T: AsRef<Vec<Track>>+AsMut<Vec<Track>>> HasTracks for T {}
+impl<T: AsRefOpt<Track>+AsMutOpt<Track>+Send+Sync> HasTrack for T {}
+impl<T: ScenesView+HasMidiIns+HasMidiOuts+HasTrackScroll> TracksView for T {}
+impl_has!(Vec<Track>: |self: Arrangement| self.tracks);
+impl_as_ref_opt!(Track: |self: Arrangement| self.selected_track());
+impl_as_mut_opt!(Track: |self: Arrangement| self.selected_track_mut());
+impl_as_ref!(Vec<Track>: |self: App| self.project.as_ref());
+impl_as_mut!(Vec<Track>: |self: App| self.project.as_mut());
+#[cfg(feature = "select")] impl_as_ref_opt!(Track: |self: App| self.project.as_ref_opt());
+#[cfg(feature = "select")] impl_as_mut_opt!(Track: |self: App| self.project.as_mut_opt());
+
+impl Arrangement {
+
+    pub fn view_inputs (&self, _theme: ItemTheme) -> impl Draw<Tui> + '_ {
+        view_inputs(
+            self.tracks_with_sizes(), self.midi_ins().as_slice()
+        )
+    }
+
+    pub fn view_outputs (&self, theme: ItemTheme) -> impl Draw<Tui> {
+        view_outputs(
+            theme, self.tracks_with_sizes(), self.midi_outs(), self.outputs_height()
+        )
+    }
+
+    pub fn view_track_devices (&self, theme: ItemTheme) -> impl Draw<Tui> {
+        view_track_devices(
+            theme, self.tracks_with_sizes(), self.track(), self.devices_height()
+        )
+    }
+
+    fn devices_height (&self) -> u16 {
+        let mut h = 2;
+        for track in self.tracks().iter() {
+            h = h.max(track.devices.len() * 2);
+        }
+        h as u16
+    }
+
+    fn outputs_height (&self) -> u16 {
+        let mut h = 1;
+        for output in self.midi_outs().iter() {
+            h += 1 + output.connections.len();
+        }
+        h as u16
+    }
+
+    /// Add multiple tracks
+    pub fn tracks_add (
+        &mut self, count: usize, width: Option<usize>, mins: &[Connect], mouts: &[Connect],
+    ) -> Usually<()> {
+        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 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: &[Connect],
+        mouts: &[Connect],
+    ) -> Usually<(usize, &mut Track)> {
+        let name: Arc<str> = name.map_or_else(
+            ||format!("trk{:02}", self.track_last).into(),
+            |x|x.to_string().into()
+        );
+        self.track_last += 1;
+        let 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]))
+    }
+}
+
+impl HasTrackScroll for App {
+    fn track_scroll (&self) -> usize {
+        self.project.track_scroll()
+    }
+}
+
+pub(crate) fn track_width (_index: usize, track: &Track) -> u16 {
+    track.width as u16
+}

src/device/browse.rs

@@ -1,4 +1,4 @@
-use crate::{*, clock::*, sequence::*, sample::*};
+use crate::{*, clock::*, sequence::*, sampler::*};
 
 def_command!(FileBrowserCommand: |sampler: Sampler|{
     //("begin"   []            Some(Self::Begin))
@@ -21,14 +21,15 @@ def_command!(FileBrowserCommand: |sampler: Sampler|{
     pub filter: String,
     pub index:  usize,
     pub scroll: usize,
-    pub size:   [AtomicUsize; 2],
+    pub size:   Sizer,
 }
 
-pub(crate) struct EntriesIterator<'a> {
+pub(crate) struct EntriesIterator<'a, S: Screen> {
     pub browser: &'a Browse,
     pub offset:  usize,
     pub length:  usize,
     pub index:   usize,
+    _screen: std::marker::PhantomData<S>
 }
 
 #[derive(Clone, Debug)] pub enum BrowseTarget {
@@ -215,15 +216,6 @@ impl ClipLength {
     pub fn ticks (&self) -> usize {
         self.pulses % self.ppq
     }
-    pub fn bars_string  (&self) -> Arc<str> {
-        format!("{}", self.bars()).into()
-    }
-    pub fn beats_string (&self) -> Arc<str> {
-        format!("{}", self.beats()).into()
-    }
-    pub fn ticks_string (&self) -> Arc<str> {
-        format!("{:>02}", self.ticks()).into()
-    }
 }
 
 impl Pool {
@@ -245,41 +237,42 @@ impl Pool {
 impl<'a> PoolView<'a> {
     fn tui (&self) -> impl Draw<Tui> {
         let Self(pool) = self;
-        //let color  = self.1.clip().map(|c|c.read().unwrap().color).unwrap_or_else(||Tui::g(32).into());
-        //let on_bg  = |x|x;//below(Repeat(" "), Tui::bg(color.darkest.term, x));
+        //let color  = self.1.clip().map(|c|c.read().unwrap().color).unwrap_or_else(||g(32).into());
+        //let on_bg  = |x|x;//below(Repeat(" "), bg(color.darkest.term, x));
         //let border = |x|x;//Outer(Style::default().fg(color.dark.term).bg(color.darkest.term)).enclose(x);
         //let height = pool.clips.read().unwrap().len() as u16;
-        w_exact(20, h_full(origin_n(iter(
+        iter(
             ||pool.clips().clone().into_iter(),
             move|clip: Arc<RwLock<MidiClip>>, i: usize|{
+                let MidiClip { ref name, color, length, .. } = *clip.read().unwrap();
                 let item_height = 1;
                 let item_offset = i as u16 * item_height;
                 let selected    = i == pool.clip_index();
-            let MidiClip { ref name, color, length, .. } = *clip.read().unwrap();
-            let bg     = if selected { color.light.term } else { color.base.term };
-            let fg     = color.lightest.term;
+                let b           = if selected { color.light.term } else { color.base.term };
+                let f           = color.lightest.term;
                 let name        = if false { format!(" {i:>3}") } else { format!(" {i:>3} {name}") };
                 let length      = if false { String::default()  } else { format!("{length}  ") };
-            h_exact(1, iter_south(item_offset, item_height, Tui::bg(bg, below!(
-                w_full(origin_w(Tui::fg(fg, Tui::bold(selected, name)))),
-                w_full(origin_e(Tui::fg(fg, Tui::bold(selected, length)))),
-                w_full(origin_w(When::new(selected, Tui::bold(true, Tui::fg(Tui::g(255), "▶"))))),
-                w_full(origin_e(When::new(selected, Tui::bold(true, Tui::fg(Tui::g(255), "◀"))))),
-            ))))
-        }))))
+                bg(b, below!(
+                    fg(f, bold(selected, name)).origin_w().full_w(),
+                    fg(f, bold(selected, length)).origin_e().full_w(),
+                    when(selected, bold(true, fg(g(255), "▶"))).origin_w().full_w(),
+                    when(selected, bold(true, fg(g(255), "◀"))).origin_e().full_w(),
+                )).exact_h(1)
+            }).origin_n().full_h().exact_w(20)
     }
 }
+
 impl ClipLength {
     fn tui (&self) -> impl Draw<Tui> {
         use ClipLengthFocus::*;
-        let bars  = ||self.bars_string();
-        let beats = ||self.beats_string();
-        let ticks = ||self.ticks_string();
+        let bars  = format!("{}", self.bars());
+        let beats = format!("{}", self.beats());
+        let ticks = format!("{:>02}", self.ticks());
         match self.focus {
-            None       => east!(" ", bars(), ".", beats(), ".", ticks()),
-            Some(Bar)  => east!("[", bars(), "]", beats(), ".", ticks()),
-            Some(Beat) => east!(" ", bars(), "[", beats(), "]", ticks()),
-            Some(Tick) => east!(" ", bars(), ".", beats(), "[", ticks()),
+            None       => east!(" ", bars, ".", beats, ".", ticks),
+            Some(Bar)  => east!("[", bars, "]", beats, ".", ticks),
+            Some(Beat) => east!(" ", bars, "[", beats, "]", ticks),
+            Some(Tick) => east!(" ", bars, ".", beats, "[", ticks),
         }
     }
 }
@@ -319,33 +312,40 @@ impl Browse {
     fn _todo_stub_usize (&self) -> usize { todo!() }
     fn _todo_stub_arc_str (&self) -> Arc<str> { todo!() }
 }
+
 impl Browse {
     fn tui (&self) -> impl Draw<Tui> {
-        iter_south(1, ||EntriesIterator {
+        iter_south_fixed(1, ||self.tui_entries(), |entry, _index|entry.origin_w().full_w())
+    }
+    fn tui_entries (&self) -> EntriesIterator<Tui> {
+        EntriesIterator {
             offset:  0,
             index:   0,
             length:  self.dirs.len() + self.files.len(),
             browser: self,
-        }, |entry, _index|w_full(origin_w(entry)))
+            _screen: Default::default(),
+        }
     }
 }
-impl<'a> Iterator for EntriesIterator<'a> {
-    type Item = Modify<&'a str>;
+
+impl<'a> Iterator for EntriesIterator<'a, Tui> {
+    type Item = impl Draw<Tui>;
     fn next (&mut self) -> Option<Self::Item> {
         let dirs  = self.browser.dirs.len();
         let files = self.browser.files.len();
         let index = self.index;
         if self.index < dirs {
             self.index += 1;
-            Some(Tui::bold(true, self.browser.dirs[index].1.as_str()))
+            Some(bold(true, self.browser.dirs[index].1.as_str()))
         } else if self.index < dirs + files {
             self.index += 1;
-            Some(Tui::bold(false, self.browser.files[index - dirs].1.as_str()))
+            Some(bold(false, self.browser.files[index - dirs].1.as_str()))
         } else {
             None
         }
     }
 }
+
 impl PartialEq for BrowseTarget {
     fn eq (&self, other: &Self) -> bool {
         match self {
@@ -367,24 +367,36 @@ def_command!(BrowseCommand: |browse: Browse| {
 
 def_command!(PoolCommand: |pool: Pool| {
     // Toggle visibility of pool
-    Show { visible: bool } => { pool.visible = *visible; Ok(Some(Self::Show { visible: !visible })) },
+    Show { visible: bool } => {
+        pool.visible = *visible;
+        Ok(Some(Self::Show { visible: !visible }))
+    },
     // Select a clip from the clip pool
-    Select { index: usize } => { pool.set_clip_index(*index); Ok(None) },
+    Select { index: usize } => {
+        pool.set_clip_index(*index);
+        Ok(None)
+    },
     // Update the contents of the clip pool
-    Clip { command: PoolClipCommand } => Ok(command.execute(pool)?.map(|command|Self::Clip{command})),
+    Clip { command: PoolClipCommand } => Ok(
+        command.act(pool)?.map(|command|Self::Clip{command})
+    ),
     // Rename a clip
-    Rename { command: RenameCommand } => Ok(command.delegate(pool, |command|Self::Rename{command})?),
+    Rename { command: RenameCommand } => Ok(
+        command.act(pool)?.map(|command|Self::Rename{command})
+    ),
     // Change the length of a clip
-    Length { command: CropCommand } => Ok(command.delegate(pool, |command|Self::Length{command})?),
+    Length { command: CropCommand } => Ok(
+        command.act(pool)?.map(|command|Self::Length{command})
+    ),
     // Import from file
     Import { command: BrowseCommand } => Ok(if let Some(browse) = pool.browse.as_mut() {
-        command.delegate(browse, |command|Self::Import{command})?
+        command.act(browse)?.map(|command|Self::Import{command})
     } else {
         None
     }),
     // Export to file
     Export { command: BrowseCommand } => Ok(if let Some(browse) = pool.browse.as_mut() {
-        command.delegate(browse, |command|Self::Export{command})?
+        command.act(browse)?.map(|command|Self::Export{command})
     } else {
         None
     }),
@@ -436,7 +448,7 @@ def_command!(PoolClipCommand: |pool: Pool| {
         for event in events.iter() {
             clip.notes[event.0 as usize].push(event.2);
         }
-        Ok(Self::Add { index, clip }.execute(pool)?)
+        Ok(Self::Add { index, clip }.act(pool)?)
     },
     SetName { index: usize, name: Arc<str> } => {
         let index = *index;

src/device/clock.rs

@@ -1,7 +1,12 @@
 use crate::*;
-use ::std::sync::{Arc, RwLock, atomic::{AtomicUsize, Ordering::*}};
+use ::std::sync::{Arc, RwLock, atomic::AtomicUsize};
 use ::atomic_float::AtomicF64;
-use ::tengri::{draw::*, term::*};
+
+mod memo; pub use self::memo::*;
+mod moment; pub use self::moment::*;
+mod ticker; pub use self::ticker::*;
+mod timebase; pub use self::timebase::*;
+mod clock_view; pub use self::clock_view::*;
 
 impl <T: AsRef<Clock>+AsMut<Clock>>                 HasClock     for T {}
 pub trait HasClock: AsRef<Clock> + AsMut<Clock> {
@@ -43,80 +48,6 @@ pub trait HasClock: AsRef<Clock> + AsMut<Clock> {
     #[cfg(feature = "port")] pub click_out: Arc<RwLock<Option<AudioOutput>>>,
 }
 
-/// Temporal resolutions: sample rate, tempo, MIDI pulses per quaver (beat)
-///
-/// ```
-/// let _ = tek::Timebase::default();
-/// ```
-#[derive(Debug, Clone)] pub struct Timebase {
-    /// Audio samples per second
-    pub sr:  SampleRate,
-    /// MIDI beats per minute
-    pub bpm: Bpm,
-    /// MIDI ticks per beat
-    pub ppq: Ppq,
-}
-
-/// Iterator that emits subsequent ticks within a range.
-///
-/// ```
-/// let iter = tek::Ticker::default();
-/// ```
-#[derive(Debug, Default)] pub struct Ticker {
-    pub spp:    f64,
-    pub sample: usize,
-    pub start:  usize,
-    pub end:    usize,
-}
-
-/// A point in time in all time scales (microsecond, sample, MIDI pulse)
-///
-/// ```
-/// let _ = tek::Moment::default();
-/// ```
-#[derive(Debug, Default, Clone)] pub struct Moment {
-    pub timebase: Arc<Timebase>,
-    /// Current time in microseconds
-    pub usec:   Microsecond,
-    /// Current time in audio samples
-    pub sample: SampleCount,
-    /// Current time in MIDI pulses
-    pub pulse:  Pulse,
-}
-
-///
-/// ```
-/// let _ = tek::Moment2::default();
-/// ```
-#[derive(Debug, Clone, Default)] pub enum Moment2 {
-    #[default] None,
-    Zero,
-    Usec(Microsecond),
-    Sample(SampleCount),
-    Pulse(Pulse),
-}
-
-/// MIDI resolution in PPQ (pulses per quarter note)
-///
-/// ```
-///
-/// ```
-#[derive(Debug, Default)] pub struct Ppq (pub(crate) AtomicF64);
-
-/// Timestamp in MIDI pulses
-///
-/// ```
-///
-/// ```
-#[derive(Debug, Default)] pub struct Pulse (pub(crate) AtomicF64);
-
-/// Tempo in beats per minute
-///
-/// ```
-///
-/// ```
-#[derive(Debug, Default)] pub struct Bpm (pub(crate) AtomicF64);
-
 /// Quantization setting for launching clips
 ///
 /// ```
@@ -131,27 +62,6 @@ pub trait HasClock: AsRef<Clock> + AsMut<Clock> {
 /// ```
 #[derive(Debug, Default)] pub struct Quantize (pub(crate) AtomicF64);
 
-/// Timestamp in audio samples
-///
-/// ```
-///
-/// ```
-#[derive(Debug, Default)] pub struct SampleCount (pub(crate) AtomicF64);
-
-/// Audio sample rate in Hz (samples per second)
-///
-/// ```
-///
-/// ```
-#[derive(Debug, Default)] pub struct SampleRate (pub(crate) AtomicF64);
-
-/// Timestamp in microseconds
-///
-/// ```
-///
-/// ```
-#[derive(Debug, Default)] pub struct Microsecond (pub(crate) AtomicF64);
-
 /// A unit of time, represented as an atomic 64-bit float.
 ///
 /// According to https://stackoverflow.com/a/873367, as per IEEE754,
@@ -160,17 +70,7 @@ pub trait HasClock: AsRef<Clock> + AsMut<Clock> {
 /// can be clocked in microseconds with f64 without losing precision.
 pub trait TimeUnit: InteriorMutable<f64> {}
 
-/// Contains memoized renders of clock values.
-///
-/// Performance optimization.
-#[derive(Debug)] pub struct ClockView {
-    pub sr:   Memo<Option<(bool, f64)>, String>,
-    pub buf:  Memo<Option<f64>, String>,
-    pub lat:  Memo<Option<f64>, String>,
-    pub bpm:  Memo<Option<f64>, String>,
-    pub beat: Memo<Option<f64>, String>,
-    pub time: Memo<Option<f64>, String>,
-}
+pub const DEFAULT_PPQ: f64 = 96.0;
 
 /// FIXME: remove this and use PPQ from timebase everywhere:
 pub const PPQ: usize = 96;
@@ -206,8 +106,6 @@ pub const NOTE_NAMES: [&str; 128] = [
     "C10", "C#10", "D10", "D#10", "E10", "F10", "F#10", "G10",
 ];
 
-pub const DEFAULT_PPQ: f64 = 96.0;
-
 def_command!(ClockCommand: |clock: Clock| {
     SeekUsec   { usec:   f64 } => {
         clock.playhead.update_from_usec(*usec); Ok(None) },
@@ -234,53 +132,6 @@ def_command!(ClockCommand: |clock: Clock| {
     }),
 });
 
-impl Moment {
-    pub fn zero (timebase: &Arc<Timebase>) -> Self {
-        Self { usec: 0.into(), sample: 0.into(), pulse: 0.into(), timebase: timebase.clone() }
-    }
-    pub fn from_usec (timebase: &Arc<Timebase>, usec: f64) -> Self {
-        Self {
-            usec:     usec.into(),
-            sample:   timebase.sr.usecs_to_sample(usec).into(),
-            pulse:    timebase.usecs_to_pulse(usec).into(),
-            timebase: timebase.clone(),
-        }
-    }
-    pub fn from_sample (timebase: &Arc<Timebase>, sample: f64) -> Self {
-        Self {
-            sample:   sample.into(),
-            usec:     timebase.sr.samples_to_usec(sample).into(),
-            pulse:    timebase.samples_to_pulse(sample).into(),
-            timebase: timebase.clone(),
-        }
-    }
-    pub fn from_pulse (timebase: &Arc<Timebase>, pulse: f64) -> Self {
-        Self {
-            pulse:    pulse.into(),
-            sample:   timebase.pulses_to_sample(pulse).into(),
-            usec:     timebase.pulses_to_usec(pulse).into(),
-            timebase: timebase.clone(),
-        }
-    }
-    #[inline] pub fn update_from_usec (&self, usec: f64) {
-        self.usec.set(usec);
-        self.pulse.set(self.timebase.usecs_to_pulse(usec));
-        self.sample.set(self.timebase.sr.usecs_to_sample(usec));
-    }
-    #[inline] pub fn update_from_sample (&self, sample: f64) {
-        self.usec.set(self.timebase.sr.samples_to_usec(sample));
-        self.pulse.set(self.timebase.samples_to_pulse(sample));
-        self.sample.set(sample);
-    }
-    #[inline] pub fn update_from_pulse (&self, pulse: f64) {
-        self.usec.set(self.timebase.pulses_to_usec(pulse));
-        self.pulse.set(pulse);
-        self.sample.set(self.timebase.pulses_to_sample(pulse));
-    }
-    #[inline] pub fn format_beat (&self) -> Arc<str> {
-        self.timebase.format_beats_1(self.pulse.get()).into()
-    }
-}
 impl LaunchSync {
     pub fn next (&self) -> f64 {
         note_duration_next(self.get() as usize) as f64
@@ -289,6 +140,7 @@ impl LaunchSync {
         note_duration_prev(self.get() as usize) as f64
     }
 }
+
 impl Quantize {
     pub fn next (&self) -> f64 {
         note_duration_next(self.get() as usize) as f64
@@ -297,131 +149,25 @@ impl Quantize {
         note_duration_prev(self.get() as usize) as f64
     }
 }
-impl Timebase {
-    /// Specify sample rate, BPM and PPQ
-    pub fn new (
-        s: impl Into<SampleRate>,
-        b: impl Into<Bpm>,
-        p: impl Into<Ppq>
-    ) -> Self {
-        Self { sr: s.into(), bpm: b.into(), ppq: p.into() }
+
+/// Implement an arithmetic operation for a unit of time
+#[macro_export] macro_rules! impl_op {
+    ($T:ident, $Op:ident, $method:ident, |$a:ident,$b:ident|{$impl:expr}) => {
+        impl $Op<Self> for $T {
+            type Output = Self; #[inline] fn $method (self, other: Self) -> Self::Output {
+                let $a = self.get(); let $b = other.get(); Self($impl.into())
             }
-    /// Iterate over ticks between start and end.
-    #[inline] pub fn pulses_between_samples (&self, start: usize, end: usize) -> Ticker {
-        Ticker { spp: self.samples_per_pulse(), sample: start, start, end }
         }
-    /// Return the duration fo a beat in microseconds
-    #[inline] pub fn usec_per_beat (&self) -> f64 { 60_000_000f64 / self.bpm.get() }
-    /// Return the number of beats in a second
-    #[inline] pub fn beat_per_second (&self) -> f64 { self.bpm.get() / 60f64 }
-    /// Return the number of microseconds corresponding to a note of the given duration
-    #[inline] pub fn note_to_usec (&self, (num, den): (f64, f64)) -> f64 {
-        4.0 * self.usec_per_beat() * num / den
+        impl $Op<usize> for $T {
+            type Output = Self; #[inline] fn $method (self, other: usize) -> Self::Output {
+                let $a = self.get(); let $b = other as f64; Self($impl.into())
             }
-    /// Return duration of a pulse in microseconds (BPM-dependent)
-    #[inline] pub fn pulse_per_usec (&self) -> f64 { self.ppq.get() / self.usec_per_beat() }
-    /// Return duration of a pulse in microseconds (BPM-dependent)
-    #[inline] pub fn usec_per_pulse (&self) -> f64 { self.usec_per_beat() / self.ppq.get() }
-    /// Return number of pulses to which a number of microseconds corresponds (BPM-dependent)
-    #[inline] pub fn usecs_to_pulse (&self, usec: f64) -> f64 { usec * self.pulse_per_usec() }
-    /// Convert a number of pulses to a sample number (SR- and BPM-dependent)
-    #[inline] pub fn pulses_to_usec (&self, pulse: f64) -> f64 { pulse / self.usec_per_pulse() }
-    /// Return number of pulses in a second (BPM-dependent)
-    #[inline] pub fn pulses_per_second (&self) -> f64 { self.beat_per_second() * self.ppq.get() }
-    /// Return fraction of a pulse to which a sample corresponds (SR- and BPM-dependent)
-    #[inline] pub fn pulses_per_sample (&self) -> f64 {
-        self.usec_per_pulse() / self.sr.usec_per_sample()
         }
-    /// Return number of samples in a pulse (SR- and BPM-dependent)
-    #[inline] pub fn samples_per_pulse (&self) -> f64 {
-        self.sr.get() / self.pulses_per_second()
+        impl $Op<f64> for $T {
+            type Output = Self; #[inline] fn $method (self, other: f64) -> Self::Output {
+                let $a = self.get(); let $b = other; Self($impl.into())
             }
-    /// Convert a number of pulses to a sample number (SR- and BPM-dependent)
-    #[inline] pub fn pulses_to_sample (&self, p: f64) -> f64 {
-        self.pulses_per_sample() * p
         }
-    /// Convert a number of samples to a pulse number (SR- and BPM-dependent)
-    #[inline] pub fn samples_to_pulse (&self, s: f64) -> f64 {
-        s / self.pulses_per_sample()
-    }
-    /// Return the number of samples corresponding to a note of the given duration
-    #[inline] pub fn note_to_samples (&self, note: (f64, f64)) -> f64 {
-        self.usec_to_sample(self.note_to_usec(note))
-    }
-    /// Return the number of samples corresponding to the given number of microseconds
-    #[inline] pub fn usec_to_sample (&self, usec: f64) -> f64 {
-        usec * self.sr.get() / 1000f64
-    }
-    /// Return the quantized position of a moment in time given a step
-    #[inline] pub fn quantize (&self, step: (f64, f64), time: f64) -> (f64, f64) {
-        let step = self.note_to_usec(step);
-        (time / step, time % step)
-    }
-    /// Quantize a collection of events
-    #[inline] pub fn quantize_into <E: Iterator<Item=(f64, f64)> + Sized, T> (
-        &self, step: (f64, f64), events: E
-    ) -> Vec<(f64, f64)> {
-        events.map(|(time, event)|(self.quantize(step, time).0, event)).collect()
-    }
-    /// Format a number of pulses into Beat.Bar.Pulse starting from 0
-    #[inline] pub fn format_beats_0 (&self, pulse: f64) -> Arc<str> {
-        let pulse = pulse as usize;
-        let ppq   = self.ppq.get() as usize;
-        let (beats, pulses) = if ppq > 0 { (pulse / ppq, pulse % ppq) } else { (0, 0) };
-        format!("{}.{}.{pulses:02}", beats / 4, beats % 4).into()
-    }
-    /// Format a number of pulses into Beat.Bar starting from 0
-    #[inline] pub fn format_beats_0_short (&self, pulse: f64) -> Arc<str> {
-        let pulse = pulse as usize;
-        let ppq   = self.ppq.get() as usize;
-        let beats = if ppq > 0 { pulse / ppq } else { 0 };
-        format!("{}.{}", beats / 4, beats % 4).into()
-    }
-    /// Format a number of pulses into Beat.Bar.Pulse starting from 1
-    #[inline] pub fn format_beats_1 (&self, pulse: f64) -> Arc<str> {
-        let mut string = String::with_capacity(16);
-        self.format_beats_1_to(&mut string, pulse).expect("failed to format {pulse} into beat");
-        string.into()
-    }
-    /// Format a number of pulses into Beat.Bar.Pulse starting from 1
-    #[inline] pub fn format_beats_1_to (&self, w: &mut impl std::fmt::Write, pulse: f64) -> Result<(), std::fmt::Error> {
-        let pulse = pulse as usize;
-        let ppq   = self.ppq.get() as usize;
-        let (beats, pulses) = if ppq > 0 { (pulse / ppq, pulse % ppq) } else { (0, 0) };
-        write!(w, "{}.{}.{pulses:02}", beats / 4 + 1, beats % 4 + 1)
-    }
-    /// Format a number of pulses into Beat.Bar.Pulse starting from 1
-    #[inline] pub fn format_beats_1_short (&self, pulse: f64) -> Arc<str> {
-        let pulse = pulse as usize;
-        let ppq   = self.ppq.get() as usize;
-        let beats = if ppq > 0 { pulse / ppq } else { 0 };
-        format!("{}.{}", beats / 4 + 1, beats % 4 + 1).into()
-    }
-}
-impl SampleRate {
-    /// Return the duration of a sample in microseconds (floating)
-    #[inline] pub fn usec_per_sample (&self) -> f64 {
-        1_000_000f64 / self.get()
-    }
-    /// Return the duration of a sample in microseconds (floating)
-    #[inline] pub fn sample_per_usec (&self) -> f64 {
-        self.get() / 1_000_000f64
-    }
-    /// Convert a number of samples to microseconds (floating)
-    #[inline] pub fn samples_to_usec (&self, samples: f64) -> f64 {
-        self.usec_per_sample() * samples
-    }
-    /// Convert a number of microseconds to samples (floating)
-    #[inline] pub fn usecs_to_sample (&self, usecs:   f64) -> f64 {
-        self.sample_per_usec() * usecs
-    }
-}
-impl Microsecond {
-    #[inline] pub fn format_msu (&self) -> Arc<str> {
-        let usecs              = self.get() as usize;
-        let (seconds, msecs)   = (usecs / 1000000, usecs / 1000 % 1000);
-        let (minutes, seconds) = (seconds / 60, seconds % 60);
-        format!("{minutes}:{seconds:02}:{msecs:03}").into()
     }
 }
 
@@ -467,6 +213,7 @@ impl std::fmt::Debug for Clock {
             .finish()
     }
 }
+
 impl Clock {
     pub fn new (jack: &Jack<'static>, bpm: Option<f64>) -> Usually<Self> {
         let (chunk, transport) = jack.with_client(|c|(c.buffer_size(), c.transport()));
@@ -625,6 +372,7 @@ impl Clock {
         self.timebase().pulses_between_samples(offset, offset + scope.n_frames() as usize)
     }
 }
+
 impl Clock {
     fn _todo_provide_u32 (&self) -> u32 {
         todo!()
@@ -636,64 +384,12 @@ impl Clock {
         todo!()
     }
 }
+
 impl<T: HasClock> Act<T> for ClockCommand {
     fn act (&self, state: &mut T) -> Perhaps<Self> {
         self.act(state.clock_mut()) // awesome
     }
 }
-impl ClockView {
-    pub const BEAT_EMPTY: &'static str = "-.-.--";
-    pub const TIME_EMPTY: &'static str = "-.---s";
-    pub const BPM_EMPTY:  &'static str = "---.---";
-    pub fn update_clock (cache: &Arc<RwLock<Self>>, clock: &Clock, compact: bool) {
-        let rate  = clock.timebase.sr.get();
-        let chunk = clock.chunk.load(Relaxed) as f64;
-        let lat   = chunk / rate * 1000.;
-        let delta = |start: &Moment|clock.global.usec.get() - start.usec.get();
-        let mut cache = cache.write().unwrap();
-        cache.buf.update(Some(chunk), rewrite!(buf, "{chunk}"));
-        cache.lat.update(Some(lat),   rewrite!(buf, "{lat:.1}ms"));
-        cache.sr.update(Some((compact, rate)), |buf,_,_|{
-            buf.clear();
-            if compact {
-                write!(buf, "{:.1}kHz", rate / 1000.)
-            } else {
-                write!(buf, "{:.0}Hz", rate)
-            }
-        });
-        if let Some(now) = clock.started.read().unwrap().as_ref().map(delta) {
-            let pulse = clock.timebase.usecs_to_pulse(now);
-            let time  = now/1000000.;
-            let bpm   = clock.timebase.bpm.get();
-            cache.beat.update(Some(pulse), |buf, _, _|{
-                buf.clear();
-                clock.timebase.format_beats_1_to(buf, pulse)
-            });
-            cache.time.update(Some(time), rewrite!(buf, "{:.3}s", time));
-            cache.bpm.update(Some(bpm),   rewrite!(buf, "{:.3}",  bpm));
-        } else {
-            cache.beat.update(None, rewrite!(buf, "{}", ClockView::BEAT_EMPTY));
-            cache.time.update(None, rewrite!(buf, "{}", ClockView::TIME_EMPTY));
-            cache.bpm.update(None,  rewrite!(buf, "{}", ClockView::BPM_EMPTY));
-        }
-    }
-}
-impl_default!(ClockView: {
-    let mut beat = String::with_capacity(16);
-    let _ = write!(beat, "{}", Self::BEAT_EMPTY);
-    let mut time = String::with_capacity(16);
-    let _ = write!(time, "{}", Self::TIME_EMPTY);
-    let mut bpm  = String::with_capacity(16);
-    let _ = write!(bpm,  "{}", Self::BPM_EMPTY);
-    Self {
-        beat: Memo::new(None, beat),
-        time: Memo::new(None, time),
-        bpm:  Memo::new(None, bpm),
-        sr:   Memo::new(None, String::with_capacity(16)),
-        buf:  Memo::new(None, String::with_capacity(16)),
-        lat:  Memo::new(None, String::with_capacity(16)),
-    }
-});
 
 #[cfg(feature = "clock")] impl_has!(Clock: |self: Track|self.sequencer.clock);
 impl_default!(Timebase: Self::new(48000f64, 150f64, DEFAULT_PPQ));

src/device/clock/clock_view.rs

@@ -0,0 +1,78 @@
+use crate::*;
+
+/// Contains memoized renders of clock values.
+///
+/// Performance optimization.
+#[derive(Debug)] pub struct ClockView {
+    pub sr:   Memo<Option<(bool, f64)>, String>,
+    pub buf:  Memo<Option<f64>, String>,
+    pub lat:  Memo<Option<f64>, String>,
+    pub bpm:  Memo<Option<f64>, String>,
+    pub beat: Memo<Option<f64>, String>,
+    pub time: Memo<Option<f64>, String>,
+}
+
+impl_default!(ClockView: {
+    let mut beat = String::with_capacity(16);
+    let _ = write!(beat, "{}", Self::BEAT_EMPTY);
+    let mut time = String::with_capacity(16);
+    let _ = write!(time, "{}", Self::TIME_EMPTY);
+    let mut bpm  = String::with_capacity(16);
+    let _ = write!(bpm,  "{}", Self::BPM_EMPTY);
+    Self {
+        beat: Memo::new(None, beat),
+        time: Memo::new(None, time),
+        bpm:  Memo::new(None, bpm),
+        sr:   Memo::new(None, String::with_capacity(16)),
+        buf:  Memo::new(None, String::with_capacity(16)),
+        lat:  Memo::new(None, String::with_capacity(16)),
+    }
+});
+
+impl ClockView {
+    pub const BEAT_EMPTY: &'static str = "-.-.--";
+    pub const TIME_EMPTY: &'static str = "-.---s";
+    pub const BPM_EMPTY:  &'static str = "---.---";
+    pub fn update_clock (cache: &Arc<RwLock<Self>>, clock: &Clock, compact: bool) {
+        let rate  = clock.timebase.sr.get();
+        let chunk = clock.chunk.load(Relaxed) as f64;
+        let lat   = chunk / rate * 1000.;
+        let delta = |start: &Moment|clock.global.usec.get() - start.usec.get();
+        let mut cache = cache.write().unwrap();
+
+        cache.buf.update(
+            Some(chunk), rewrite!(buf, "{chunk}")
+        );
+
+        cache.lat.update(
+            Some(lat), rewrite!(buf, "{lat:.1}ms")
+        );
+
+        cache.sr.update(
+            Some((compact, rate)), |buf: &mut String,_,_|{
+                buf.clear();
+                if compact {
+                    write!(buf, "{:.1}kHz", rate / 1000.)
+                } else {
+                    write!(buf, "{:.0}Hz", rate)
+                }
+            }
+        );
+
+        if let Some(now) = clock.started.read().unwrap().as_ref().map(delta) {
+            let pulse = clock.timebase.usecs_to_pulse(now);
+            let time  = now/1000000.;
+            let bpm   = clock.timebase.bpm.get();
+            cache.beat.update(Some(pulse), |buf, _, _|{
+                buf.clear();
+                clock.timebase.format_beats_1_to(buf, pulse)
+            });
+            cache.time.update(Some(time), rewrite!(buf, "{:.3}s", time));
+            cache.bpm.update(Some(bpm),   rewrite!(buf, "{:.3}",  bpm));
+        } else {
+            cache.beat.update(None, rewrite!(buf, "{}", ClockView::BEAT_EMPTY));
+            cache.time.update(None, rewrite!(buf, "{}", ClockView::TIME_EMPTY));
+            cache.bpm.update(None,  rewrite!(buf, "{}", ClockView::BPM_EMPTY));
+        }
+    }
+}

src/device/clock/memo.rs

@@ -0,0 +1,53 @@
+use crate::*;
+
+#[macro_export] macro_rules! rewrite {
+    ($buf:ident, $($rest:tt)*) => {
+        |$buf,_,_|{
+            $buf.clear();
+            write!($buf, $($rest)*)
+        }
+    };
+}
+
+pub struct Memo<T, U> {
+    value: T,
+    view:  U,
+}
+
+impl<T, U> Memo<T, U> {
+    pub fn new (value: T, view: U) -> Self {
+        Self { value, view }
+    }
+}
+
+impl<T: PartialEq + Debug, U: Debug> Debug for Memo<T, U> {
+    fn fmt (&self, _: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+        todo!()
+    }
+}
+
+impl<T: PartialEq, U> Memo<T, U> {
+    pub fn update <R> (&mut self, newval: T, render: impl Fn(&mut U, &T, &T)->R) -> Option<R> {
+        if newval != self.value {
+            let result = render(&mut self.view, &newval, &self.value);
+            self.value = newval;
+            return Some(result);
+        }
+        None
+    }
+}
+
+pub trait Gettable<T> {
+    /// Returns current value
+    fn get (&self) -> T;
+}
+
+pub trait Mutable<T>: Gettable<T> {
+    /// Sets new value, returns old
+    fn set (&mut self, value: T) -> T;
+}
+
+pub trait InteriorMutable<T>: Gettable<T> {
+    /// Sets new value, returns old
+    fn set (&self, value: T) -> T;
+}

src/device/clock/moment.rs

@@ -0,0 +1,108 @@
+use crate::*;
+use ::std::sync::{Arc, RwLock, atomic::{AtomicUsize, Ordering::*}};
+use ::atomic_float::AtomicF64;
+
+/// A point in time in all time scales (microsecond, sample, MIDI pulse)
+///
+/// ```
+/// let _ = tek::Moment::default();
+/// ```
+#[derive(Debug, Default, Clone)] pub struct Moment {
+    pub timebase: Arc<Timebase>,
+    /// Current time in microseconds
+    pub usec:   Microsecond,
+    /// Current time in audio samples
+    pub sample: SampleCount,
+    /// Current time in MIDI pulses
+    pub pulse:  Pulse,
+}
+
+///
+/// ```
+/// let _ = tek::Moment2::default();
+/// ```
+#[derive(Debug, Clone, Default)] pub enum Moment2 {
+    #[default] None,
+    Zero,
+    Usec(Microsecond),
+    Sample(SampleCount),
+    Pulse(Pulse),
+}
+
+/// Timestamp in microseconds
+///
+/// ```
+///
+/// ```
+#[derive(Debug, Default)] pub struct Microsecond (pub(crate) AtomicF64);
+
+/// Timestamp in audio samples
+///
+/// ```
+///
+/// ```
+#[derive(Debug, Default)] pub struct SampleCount (pub(crate) AtomicF64);
+
+/// Timestamp in MIDI pulses
+///
+/// ```
+///
+/// ```
+#[derive(Debug, Default)] pub struct Pulse (pub(crate) AtomicF64);
+
+impl Moment {
+    pub fn zero (timebase: &Arc<Timebase>) -> Self {
+        Self { usec: 0.into(), sample: 0.into(), pulse: 0.into(), timebase: timebase.clone() }
+    }
+    pub fn from_usec (timebase: &Arc<Timebase>, usec: f64) -> Self {
+        Self {
+            usec:     usec.into(),
+            sample:   timebase.sr.usecs_to_sample(usec).into(),
+            pulse:    timebase.usecs_to_pulse(usec).into(),
+            timebase: timebase.clone(),
+        }
+    }
+    pub fn from_sample (timebase: &Arc<Timebase>, sample: f64) -> Self {
+        Self {
+            sample:   sample.into(),
+            usec:     timebase.sr.samples_to_usec(sample).into(),
+            pulse:    timebase.samples_to_pulse(sample).into(),
+            timebase: timebase.clone(),
+        }
+    }
+    pub fn from_pulse (timebase: &Arc<Timebase>, pulse: f64) -> Self {
+        Self {
+            pulse:    pulse.into(),
+            sample:   timebase.pulses_to_sample(pulse).into(),
+            usec:     timebase.pulses_to_usec(pulse).into(),
+            timebase: timebase.clone(),
+        }
+    }
+    #[inline] pub fn update_from_usec (&self, usec: f64) {
+        self.usec.set(usec);
+        self.pulse.set(self.timebase.usecs_to_pulse(usec));
+        self.sample.set(self.timebase.sr.usecs_to_sample(usec));
+    }
+    #[inline] pub fn update_from_sample (&self, sample: f64) {
+        self.usec.set(self.timebase.sr.samples_to_usec(sample));
+        self.pulse.set(self.timebase.samples_to_pulse(sample));
+        self.sample.set(sample);
+    }
+    #[inline] pub fn update_from_pulse (&self, pulse: f64) {
+        self.usec.set(self.timebase.pulses_to_usec(pulse));
+        self.pulse.set(pulse);
+        self.sample.set(self.timebase.pulses_to_sample(pulse));
+    }
+    #[inline] pub fn format_beat (&self) -> Arc<str> {
+        self.timebase.format_beats_1(self.pulse.get()).into()
+    }
+}
+
+impl Microsecond {
+    #[inline] pub fn format_msu (&self) -> Arc<str> {
+        let usecs              = self.get() as usize;
+        let (seconds, msecs)   = (usecs / 1000000, usecs / 1000 % 1000);
+        let (minutes, seconds) = (seconds / 60, seconds % 60);
+        format!("{minutes}:{seconds:02}:{msecs:03}").into()
+    }
+}

src/device/clock/ticker.rs

@@ -0,0 +1,15 @@
+use crate::*;
+use ::std::sync::{Arc, RwLock, atomic::{AtomicUsize, Ordering::*}};
+use ::atomic_float::AtomicF64;
+
+/// Iterator that emits subsequent ticks within a range.
+///
+/// ```
+/// let iter = tek::Ticker::default();
+/// ```
+#[derive(Debug, Default)] pub struct Ticker {
+    pub spp:    f64,
+    pub sample: usize,
+    pub start:  usize,
+    pub end:    usize,
+}

src/device/clock/timebase.rs

@@ -0,0 +1,159 @@
+use crate::*;
+use ::std::sync::{Arc, RwLock, atomic::{AtomicUsize, Ordering::*}};
+use ::atomic_float::AtomicF64;
+
+/// Temporal resolutions: sample rate, tempo, MIDI pulses per quaver (beat)
+///
+/// ```
+/// let _ = tek::Timebase::default();
+/// ```
+#[derive(Debug, Clone)] pub struct Timebase {
+    /// Audio samples per second
+    pub sr:  SampleRate,
+    /// MIDI beats per minute
+    pub bpm: Bpm,
+    /// MIDI ticks per beat
+    pub ppq: Ppq,
+}
+
+/// Audio sample rate in Hz (samples per second)
+///
+/// ```
+///
+/// ```
+#[derive(Debug, Default)] pub struct SampleRate (pub(crate) AtomicF64);
+
+/// Tempo in beats per minute
+///
+/// ```
+///
+/// ```
+#[derive(Debug, Default)] pub struct Bpm (pub(crate) AtomicF64);
+
+/// MIDI resolution in PPQ (pulses per quarter note)
+///
+/// ```
+///
+/// ```
+#[derive(Debug, Default)] pub struct Ppq (pub(crate) AtomicF64);
+
+impl Timebase {
+    /// Specify sample rate, BPM and PPQ
+    pub fn new (
+        s: impl Into<SampleRate>,
+        b: impl Into<Bpm>,
+        p: impl Into<Ppq>
+    ) -> Self {
+        Self { sr: s.into(), bpm: b.into(), ppq: p.into() }
+    }
+    /// Iterate over ticks between start and end.
+    #[inline] pub fn pulses_between_samples (&self, start: usize, end: usize) -> Ticker {
+        Ticker { spp: self.samples_per_pulse(), sample: start, start, end }
+    }
+    /// Return the duration fo a beat in microseconds
+    #[inline] pub fn usec_per_beat (&self) -> f64 { 60_000_000f64 / self.bpm.get() }
+    /// Return the number of beats in a second
+    #[inline] pub fn beat_per_second (&self) -> f64 { self.bpm.get() / 60f64 }
+    /// Return the number of microseconds corresponding to a note of the given duration
+    #[inline] pub fn note_to_usec (&self, (num, den): (f64, f64)) -> f64 {
+        4.0 * self.usec_per_beat() * num / den
+    }
+    /// Return duration of a pulse in microseconds (BPM-dependent)
+    #[inline] pub fn pulse_per_usec (&self) -> f64 { self.ppq.get() / self.usec_per_beat() }
+    /// Return duration of a pulse in microseconds (BPM-dependent)
+    #[inline] pub fn usec_per_pulse (&self) -> f64 { self.usec_per_beat() / self.ppq.get() }
+    /// Return number of pulses to which a number of microseconds corresponds (BPM-dependent)
+    #[inline] pub fn usecs_to_pulse (&self, usec: f64) -> f64 { usec * self.pulse_per_usec() }
+    /// Convert a number of pulses to a sample number (SR- and BPM-dependent)
+    #[inline] pub fn pulses_to_usec (&self, pulse: f64) -> f64 { pulse / self.usec_per_pulse() }
+    /// Return number of pulses in a second (BPM-dependent)
+    #[inline] pub fn pulses_per_second (&self) -> f64 { self.beat_per_second() * self.ppq.get() }
+    /// Return fraction of a pulse to which a sample corresponds (SR- and BPM-dependent)
+    #[inline] pub fn pulses_per_sample (&self) -> f64 {
+        self.usec_per_pulse() / self.sr.usec_per_sample()
+    }
+    /// Return number of samples in a pulse (SR- and BPM-dependent)
+    #[inline] pub fn samples_per_pulse (&self) -> f64 {
+        self.sr.get() / self.pulses_per_second()
+    }
+    /// Convert a number of pulses to a sample number (SR- and BPM-dependent)
+    #[inline] pub fn pulses_to_sample (&self, p: f64) -> f64 {
+        self.pulses_per_sample() * p
+    }
+    /// Convert a number of samples to a pulse number (SR- and BPM-dependent)
+    #[inline] pub fn samples_to_pulse (&self, s: f64) -> f64 {
+        s / self.pulses_per_sample()
+    }
+    /// Return the number of samples corresponding to a note of the given duration
+    #[inline] pub fn note_to_samples (&self, note: (f64, f64)) -> f64 {
+        self.usec_to_sample(self.note_to_usec(note))
+    }
+    /// Return the number of samples corresponding to the given number of microseconds
+    #[inline] pub fn usec_to_sample (&self, usec: f64) -> f64 {
+        usec * self.sr.get() / 1000f64
+    }
+    /// Return the quantized position of a moment in time given a step
+    #[inline] pub fn quantize (&self, step: (f64, f64), time: f64) -> (f64, f64) {
+        let step = self.note_to_usec(step);
+        (time / step, time % step)
+    }
+    /// Quantize a collection of events
+    #[inline] pub fn quantize_into <E: Iterator<Item=(f64, f64)> + Sized, T> (
+        &self, step: (f64, f64), events: E
+    ) -> Vec<(f64, f64)> {
+        events.map(|(time, event)|(self.quantize(step, time).0, event)).collect()
+    }
+    /// Format a number of pulses into Beat.Bar.Pulse starting from 0
+    #[inline] pub fn format_beats_0 (&self, pulse: f64) -> Arc<str> {
+        let pulse = pulse as usize;
+        let ppq   = self.ppq.get() as usize;
+        let (beats, pulses) = if ppq > 0 { (pulse / ppq, pulse % ppq) } else { (0, 0) };
+        format!("{}.{}.{pulses:02}", beats / 4, beats % 4).into()
+    }
+    /// Format a number of pulses into Beat.Bar starting from 0
+    #[inline] pub fn format_beats_0_short (&self, pulse: f64) -> Arc<str> {
+        let pulse = pulse as usize;
+        let ppq   = self.ppq.get() as usize;
+        let beats = if ppq > 0 { pulse / ppq } else { 0 };
+        format!("{}.{}", beats / 4, beats % 4).into()
+    }
+    /// Format a number of pulses into Beat.Bar.Pulse starting from 1
+    #[inline] pub fn format_beats_1 (&self, pulse: f64) -> Arc<str> {
+        let mut string = String::with_capacity(16);
+        self.format_beats_1_to(&mut string, pulse).expect("failed to format {pulse} into beat");
+        string.into()
+    }
+    /// Format a number of pulses into Beat.Bar.Pulse starting from 1
+    #[inline] pub fn format_beats_1_to (&self, w: &mut impl std::fmt::Write, pulse: f64) -> Result<(), std::fmt::Error> {
+        let pulse = pulse as usize;
+        let ppq   = self.ppq.get() as usize;
+        let (beats, pulses) = if ppq > 0 { (pulse / ppq, pulse % ppq) } else { (0, 0) };
+        write!(w, "{}.{}.{pulses:02}", beats / 4 + 1, beats % 4 + 1)
+    }
+    /// Format a number of pulses into Beat.Bar.Pulse starting from 1
+    #[inline] pub fn format_beats_1_short (&self, pulse: f64) -> Arc<str> {
+        let pulse = pulse as usize;
+        let ppq   = self.ppq.get() as usize;
+        let beats = if ppq > 0 { pulse / ppq } else { 0 };
+        format!("{}.{}", beats / 4 + 1, beats % 4 + 1).into()
+    }
+}
+
+impl SampleRate {
+    /// Return the duration of a sample in microseconds (floating)
+    #[inline] pub fn usec_per_sample (&self) -> f64 {
+        1_000_000f64 / self.get()
+    }
+    /// Return the duration of a sample in microseconds (floating)
+    #[inline] pub fn sample_per_usec (&self) -> f64 {
+        self.get() / 1_000_000f64
+    }
+    /// Convert a number of samples to microseconds (floating)
+    #[inline] pub fn samples_to_usec (&self, samples: f64) -> f64 {
+        self.usec_per_sample() * samples
+    }
+    /// Convert a number of microseconds to samples (floating)
+    #[inline] pub fn usecs_to_sample (&self, usecs:   f64) -> f64 {
+        self.sample_per_usec() * usecs
+    }
+}

src/device/dialog.rs

@@ -43,7 +43,7 @@ impl Dialog {
             MenuItem("Resume session".into(),     Arc::new(Box::new(|_|Ok(())))),
             MenuItem("Create new session".into(), Arc::new(Box::new(|app|Ok({
                 app.dialog = Dialog::None;
-                app.mode = app.config.modes.clone().read().unwrap().get(":arranger").cloned().unwrap();
+                app.mode = app.config.modes.get(":arranger").unwrap();
             })))),
             MenuItem("Load old session".into(),   Arc::new(Box::new(|_|Ok(())))),
         ].into()))
@@ -103,4 +103,3 @@ impl Dialog {
     /// FIXME: implement
     pub fn browser_target (&self) -> Option<&BrowseTarget> { todo!() }
 }
-

src/device/editor.rs

@@ -0,0 +1,298 @@
+use crate::*;
+
+/// Contains state for viewing and editing a clip.
+///
+/// ```
+/// use std::sync::{Arc, RwLock};
+/// let clip = tek::MidiClip::stop_all();
+/// let mut editor = tek::MidiEditor {
+///     mode: tek::PianoHorizontal::new(Some(&Arc::new(RwLock::new(clip)))),
+///     size: Default::default(),
+///     //keys: Default::default(),
+/// };
+/// let _ = editor.put_note(true);
+/// let _ = editor.put_note(false);
+/// let _ = editor.clip_status();
+/// let _ = editor.edit_status();
+/// ```
+pub struct MidiEditor {
+    /// View mode and state of editor
+    pub mode: PianoHorizontal,
+    /// Size of editor on screen
+    pub size: Sizer,
+}
+
+impl_default!(MidiEditor: Self {
+    mode: PianoHorizontal::new(None),
+    size: Sizer(
+        Arc::new(0usize.into()),
+        Arc::new(0usize.into()),
+    ),
+});
+
+impl MidiEditor {
+    /// Put note at current position
+    pub fn put_note (&mut self, advance: bool) {
+        let mut redraw = false;
+        if let Some(clip) = self.clip() {
+            let mut clip   = clip.write().unwrap();
+            let note_start = self.get_time_pos();
+            let note_pos   = self.get_note_pos();
+            let note_len   = self.get_note_len();
+            let note_end   = note_start + (note_len.saturating_sub(1));
+            let key: u7    = u7::from(note_pos as u8);
+            let vel: u7    = 100.into();
+            let length     = clip.length;
+            let note_end   = note_end % length;
+            let note_on = MidiMessage::NoteOn { key, vel };
+            if !clip.notes[note_start].iter().any(|msg|*msg == note_on) {
+                clip.notes[note_start].push(note_on);
+            }
+            let note_off = MidiMessage::NoteOff { key, vel };
+            if !clip.notes[note_end].iter().any(|msg|*msg == note_off) {
+                clip.notes[note_end].push(note_off);
+            }
+            if advance {
+                self.set_time_pos((note_end + 1) % clip.length);
+            }
+            redraw = true;
+        }
+        if redraw {
+            self.mode.redraw();
+        }
+    }
+    fn _todo_opt_clip_stub (&self) -> Option<Arc<RwLock<MidiClip>>> { todo!() }
+    fn clip_length (&self) -> usize { self.clip().as_ref().map(|p|p.read().unwrap().length).unwrap_or(1) }
+    fn note_length (&self) -> usize { self.get_note_len() }
+    fn note_pos (&self) -> usize { self.get_note_pos() }
+    fn note_pos_next (&self) -> usize { self.get_note_pos() + 1 }
+    fn note_pos_next_octave (&self) -> usize { self.get_note_pos() + 12 }
+    fn note_pos_prev (&self) -> usize { self.get_note_pos().saturating_sub(1) }
+    fn note_pos_prev_octave (&self) -> usize { self.get_note_pos().saturating_sub(12) }
+    fn note_len (&self) -> usize { self.get_note_len() }
+    fn note_len_next (&self) -> usize { self.get_note_len() + 1 }
+    fn note_len_prev (&self) -> usize { self.get_note_len().saturating_sub(1) }
+    fn note_range (&self) -> usize { self.get_note_axis() }
+    fn note_range_next (&self) -> usize { self.get_note_axis() + 1 }
+    fn note_range_prev (&self) -> usize { self.get_note_axis().saturating_sub(1) }
+    fn time_zoom (&self) -> usize { self.get_time_zoom() }
+    fn time_zoom_next (&self) -> usize { self.get_time_zoom() + 1 }
+    fn time_zoom_next_fine (&self) -> usize { self.get_time_zoom() + 1 }
+    fn time_zoom_prev (&self) -> usize { self.get_time_zoom().saturating_sub(1).max(1) }
+    fn time_zoom_prev_fine (&self) -> usize { self.get_time_zoom().saturating_sub(1).max(1) }
+    fn time_lock (&self) -> bool { self.get_time_lock() }
+    fn time_lock_toggled (&self) -> bool { !self.get_time_lock() }
+    fn time_pos (&self) -> usize { self.get_time_pos() }
+    fn time_pos_next (&self) -> usize { (self.get_time_pos() + self.get_note_len()) % self.clip_length() }
+    fn time_pos_next_fine (&self) -> usize { (self.get_time_pos() + 1) % self.clip_length() }
+    fn time_pos_prev (&self) -> usize {
+        let step = self.get_note_len();
+        self.get_time_pos().overflowing_sub(step)
+            .0.min(self.clip_length().saturating_sub(step))
+    }
+    fn time_pos_prev_fine (&self) -> usize {
+        self.get_time_pos().overflowing_sub(1)
+            .0.min(self.clip_length().saturating_sub(1))
+    }
+    pub fn clip_status (&self) -> impl Draw<Tui> + '_ {
+        let (_color, name, length, looped) = if let Some(clip) = self.clip().as_ref().map(|p|p.read().unwrap()) {
+            (clip.color, clip.name.clone(), clip.length, clip.looped)
+        } else { (ItemTheme::G[64], String::new().into(), 0, false) };
+        south!(
+            east(button_2("f2", "name ", false), fg(Rgb(255, 255, 255), format!("{name} "))
+                .origin_e().full_w()).origin_w().full_w(),
+            east(button_2("l", "ength ", false), fg(Rgb(255, 255, 255), format!("{length} ")).origin_e().full_w())
+                .origin_w().full_w(),
+            east(button_2("r", "epeat ", false), fg(Rgb(255, 255, 255), format!("{looped} ")).origin_e().full_w())
+                .origin_w().full_w(),
+        ).exact_w(20)
+    }
+    pub fn edit_status (&self) -> impl Draw<Tui> + '_ {
+        let (_color, length) = if let Some(clip) = self.clip().as_ref().map(|p|p.read().unwrap()) {
+            (clip.color, clip.length)
+        } else { (ItemTheme::G[64], 0) };
+        let time_pos  = self.get_time_pos();
+        let time_zoom = self.get_time_zoom();
+        let time_lock = if self.get_time_lock() { "[lock]" } else { "      " };
+        let note_pos  = self.get_note_pos();
+        let note_name = format!("{:4}",  note_pitch_to_name(note_pos));
+        let note_pos  = format!("{:>3}", note_pos);
+        let note_len  = format!("{:>4}", self.get_note_len());
+        south!(
+            east(button_2("t", "ime  ", false),
+                fg(Rgb(255, 255, 255), format!("{length} /{time_zoom} +{time_pos} ")).origin_e().full_w()).origin_w().full_w(),
+            east(button_2("z", "lock ", false),
+                fg(Rgb(255, 255, 255), format!("{time_lock}")).origin_e().full_w()).origin_w().full_w(),
+            east(button_2("x", "note ", false),
+                fg(Rgb(255, 255, 255), format!("{note_name} {note_pos} {note_len}")).origin_e().full_w()).origin_w().full_w(),
+        ).exact_w(20)
+    }
+}
+
+/// ```
+/// use tek::{*, tengri::{*, lang::*}};
+///
+/// struct Test(Option<MidiEditor>);
+/// impl_as_ref_opt!(MidiEditor: |self: Test|self.0.as_ref());
+/// impl_as_mut_opt!(MidiEditor: |self: Test|self.0.as_mut());
+///
+/// let mut host = Test(Some(MidiEditor::default()));
+/// let _ = host.editor();
+/// let _ = host.editor_mut();
+/// let _ = host.is_editing();
+/// let _ = host.editor_w();
+/// let _ = host.editor_h();
+/// ```
+pub trait HasEditor: AsRefOpt<MidiEditor> + AsMutOpt<MidiEditor> {
+    fn editor (&self) -> Option<&MidiEditor> { self.as_ref_opt() }
+    fn editor_mut (&mut self) -> Option<&mut MidiEditor> { self.as_mut_opt() }
+    fn is_editing (&self) -> bool { self.editor().is_some() }
+    fn editor_w (&self) -> usize { self.editor().map(|e|e.size.w()).unwrap_or(0) as usize }
+    fn editor_h (&self) -> usize { self.editor().map(|e|e.size.h()).unwrap_or(0) as usize }
+}
+
+impl <T: NotePoint+TimePoint> MidiPoint for T {}
+
+impl <T: TimeRange+NoteRange> MidiRange for T {}
+
+impl <T: AsRefOpt<MidiEditor>+AsMutOpt<MidiEditor>> HasEditor for T {}
+
+def_command!(MidiEditCommand: |editor: MidiEditor| {
+    Show { clip: Option<Arc<RwLock<MidiClip>>> } => {
+        editor.set_clip(clip.as_ref()); editor.redraw(); Ok(None) },
+    DeleteNote => {
+        editor.redraw(); todo!() },
+    AppendNote    { advance: bool } => {
+        editor.put_note(*advance); editor.redraw(); Ok(None) },
+    SetNotePos    { pos:    usize } => {
+        editor.set_note_pos((*pos).min(127)); editor.redraw(); Ok(None) },
+    SetNoteLen    { len:    usize } => {
+        editor.set_note_len(*len); editor.redraw(); Ok(None) },
+    SetNoteScroll { scroll: usize } => {
+        editor.set_note_lo((*scroll).min(127)); editor.redraw(); Ok(None) },
+    SetTimePos    { pos:    usize } => {
+        editor.set_time_pos(*pos); editor.redraw(); Ok(None) },
+    SetTimeScroll { scroll: usize } => {
+        editor.set_time_start(*scroll); editor.redraw(); Ok(None) },
+    SetTimeZoom   { zoom:   usize } => {
+        editor.set_time_zoom(*zoom); editor.redraw(); Ok(None) },
+    SetTimeLock   { lock:   bool  } => {
+        editor.set_time_lock(*lock); editor.redraw(); Ok(None) },
+    // TODO: 1-9 seek markers that by default start every 8th of the clip
+});
+
+pub trait MidiViewer: MidiRange + MidiPoint + Debug + Send + Sync {
+    fn buffer_size (&self, clip: &MidiClip) -> (usize, usize);
+    fn redraw (&self);
+    fn clip (&self) -> &Option<Arc<RwLock<MidiClip>>>;
+    fn clip_mut (&mut self) -> &mut Option<Arc<RwLock<MidiClip>>>;
+    fn set_clip (&mut self, clip: Option<&Arc<RwLock<MidiClip>>>) {
+        *self.clip_mut() = clip.cloned();
+        self.redraw();
+    }
+    /// Make sure cursor is within note range
+    fn autoscroll (&self) {
+        let note_pos = self.get_note_pos().min(127);
+        let note_lo  = self.get_note_lo();
+        let note_hi  = self.get_note_hi();
+        if note_pos < note_lo {
+            self.note_lo().store(note_pos, Relaxed);
+        } else if note_pos > note_hi {
+            self.note_lo().store((note_lo + note_pos).saturating_sub(note_hi), Relaxed);
+        }
+    }
+    /// Make sure time range is within display
+    fn autozoom (&self) {
+        if self.time_lock().load(Relaxed) {
+            let time_len  = self.get_time_len();
+            let time_axis = self.get_time_axis();
+            let time_zoom = self.get_time_zoom();
+            loop {
+                let time_zoom = self.time_zoom().load(Relaxed);
+                let time_area = time_axis * time_zoom;
+                if time_area > time_len {
+                    let next_time_zoom = note_duration_prev(time_zoom);
+                    if next_time_zoom <= 1 {
+                        break
+                    }
+                    let next_time_area = time_axis * next_time_zoom;
+                    if next_time_area >= time_len {
+                        self.time_zoom().store(next_time_zoom, Relaxed);
+                    } else {
+                        break
+                    }
+                } else if time_area < time_len {
+                    let prev_time_zoom = note_duration_next(time_zoom);
+                    if prev_time_zoom > 384 {
+                        break
+                    }
+                    let prev_time_area = time_axis * prev_time_zoom;
+                    if prev_time_area <= time_len {
+                        self.time_zoom().store(prev_time_zoom, Relaxed);
+                    } else {
+                        break
+                    }
+                }
+            }
+            if time_zoom != self.time_zoom().load(Relaxed) {
+                self.redraw()
+            }
+        }
+        //while time_len.div_ceil(time_zoom) > time_axis {
+            //println!("\r{time_len} {time_zoom} {time_axis}");
+            //time_zoom = Note::next(time_zoom);
+        //}
+        //self.time_zoom().set(time_zoom);
+    }
+}
+
+impl_has!(Sizer: |self: MidiEditor| self.size);
+
+impl std::fmt::Debug for MidiEditor {
+    fn fmt (&self, f: &mut Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
+        f.debug_struct("MidiEditor").field("mode", &self.mode).finish()
+    }
+}
+
+impl_from!(MidiEditor: |clip: &Arc<RwLock<MidiClip>>| {
+    let model = Self::from(Some(clip.clone()));
+    model.redraw();
+    model
+});
+
+impl_from!(MidiEditor: |clip: Option<Arc<RwLock<MidiClip>>>| {
+    let mut model = Self::default();
+    *model.clip_mut() = clip;
+    model.redraw();
+    model
+});
+
+impl NotePoint for MidiEditor {
+    fn note_len (&self) -> &AtomicUsize { self.mode.note_len() }
+    fn note_pos (&self) -> &AtomicUsize { self.mode.note_pos() }
+}
+
+impl TimePoint for MidiEditor {
+    fn time_pos (&self) -> &AtomicUsize { self.mode.time_pos() }
+}
+
+impl MidiViewer for MidiEditor {
+    fn buffer_size (&self, clip: &MidiClip) -> (usize, usize) { self.mode.buffer_size(clip) }
+    fn redraw      (&self) { self.mode.redraw() }
+    fn clip        (&self) -> &Option<Arc<RwLock<MidiClip>>> { self.mode.clip() }
+    fn clip_mut    (&mut self) -> &mut Option<Arc<RwLock<MidiClip>>> { self.mode.clip_mut() }
+    fn set_clip    (&mut self, p: Option<&Arc<RwLock<MidiClip>>>) { self.mode.set_clip(p) }
+}
+
+impl View<Tui> for MidiEditor {
+    fn view (&self) -> impl Draw<Tui> {
+        self.autoscroll();
+        /*self.autozoom();*/
+        self.size.of(self.mode.view())
+    }
+}
+
+mod octave; pub use self::octave::*;
+mod piano; pub use self::piano::*;
+mod point; pub use self::point::*;
+mod range; pub use self::range::*;

src/device/editor/octave.rs

@@ -0,0 +1,36 @@
+use crate::*;
+
+/// 12 piano keys, some highlighted.
+///
+/// ```
+/// let keys = tek::OctaveVertical::default();
+/// ```
+#[derive(Copy, Clone)]
+pub struct OctaveVertical {
+    pub on:     [bool; 12],
+    pub colors: [Color; 3]
+}
+
+impl OctaveVertical {
+    fn color (&self, pitch: usize) -> Color {
+        let pitch = pitch % 12;
+        self.colors[if self.on[pitch] { 2 } else { match pitch { 0 | 2 | 4 | 5 | 6 | 8 | 10 => 0, _ => 1 } }]
+    }
+}
+
+impl OctaveVertical {
+    pub fn tui (&self) -> impl Draw<Tui> {
+        east!(
+            fg_bg(self.color(0),  self.color(1),  "▙"),
+            fg_bg(self.color(2),  self.color(3),  "▙"),
+            fg_bg(self.color(4),  self.color(5),  "▌"),
+            fg_bg(self.color(6),  self.color(7),  "▟"),
+            fg_bg(self.color(8),  self.color(9),  "▟"),
+            fg_bg(self.color(10), self.color(11), "▟"),
+        )
+    }
+}
+
+impl_default!(OctaveVertical: Self {
+    on: [false; 12], colors: [Rgb(255,255,255), Rgb(0,0,0), Rgb(255,0,0)]
+});

src/device/editor/piano.rs

@@ -0,0 +1,305 @@
+use crate::*;
+
+/// A clip, rendered as a horizontal piano roll.
+///
+/// ```
+/// let piano = tek::PianoHorizontal::default();
+/// ```
+#[derive(Clone, Default)]
+pub struct PianoHorizontal {
+    pub clip: Option<Arc<RwLock<MidiClip>>>,
+    /// Buffer where the whole clip is rerendered on change
+    pub buffer: Arc<RwLock<BigBuffer>>,
+    /// Size of actual notes area
+    pub size: Sizer,
+    /// The display window
+    pub range: MidiSelection,
+    /// The note cursor
+    pub point: MidiCursor,
+    /// The highlight color palette
+    pub color: ItemTheme,
+    /// Width of the keyboard
+    pub keys_width: u16,
+}
+
+impl_has!(Sizer: |self: PianoHorizontal| self.size);
+
+impl View<Tui> for PianoHorizontal {
+    fn view (&self) -> impl Draw<Tui> {
+        south(
+            east(
+                format!("{}x{}", self.size.w(), self.size.h()).exact_w(5),
+                self.timeline()
+            ),
+            east(
+                self.keys(),
+                self.size.of(below(self.notes().full_wh(), self.cursor().full_wh()))
+            ),
+        )
+    }
+}
+
+impl PianoHorizontal {
+
+    pub fn new (clip: Option<&Arc<RwLock<MidiClip>>>) -> Self {
+        let size = Sizer::default();
+        let mut range = MidiSelection::from((12, true));
+        range.time_axis = size.0.clone();
+        range.note_axis = size.1.clone();
+        let piano = Self {
+            keys_width: 5,
+            size,
+            range,
+            buffer: RwLock::new(Default::default()).into(),
+            point:  MidiCursor::default(),
+            clip: clip.cloned(),
+            color: clip.as_ref().map(|p|p.read().unwrap().color).unwrap_or(ItemTheme::G[64]),
+        };
+        piano.redraw();
+        piano
+    }
+
+    /// Draw the piano roll background.
+    ///
+    /// This mode uses full blocks on note on and half blocks on legato: █▄ █▄ █▄
+    fn draw_bg (buf: &mut BigBuffer, clip: &MidiClip, zoom: usize, note_len: usize, note_point: usize, time_point: usize) {
+        for (y, note) in (0..=127).rev().enumerate() {
+            for (x, time) in (0..buf.width).map(|x|(x, x*zoom)) {
+                let cell = buf.get_mut(x, y).unwrap();
+                if note == (127-note_point) || time == time_point {
+                    cell.set_bg(Rgb(0,0,0));
+                } else {
+                    cell.set_bg(clip.color.darkest.term);
+                }
+                if time % 384 == 0 {
+                    cell.set_fg(clip.color.darker.term);
+                    cell.set_char('│');
+                } else if time % 96 == 0 {
+                    cell.set_fg(clip.color.dark.term);
+                    cell.set_char('╎');
+                } else if time % note_len == 0 {
+                    cell.set_fg(clip.color.darker.term);
+                    cell.set_char('┊');
+                } else if (127 - note) % 12 == 0 {
+                    cell.set_fg(clip.color.darker.term);
+                    cell.set_char('=');
+                } else if (127 - note) % 6 == 0 {
+                    cell.set_fg(clip.color.darker.term);
+                    cell.set_char('—');
+                } else {
+                    cell.set_fg(clip.color.darker.term);
+                    cell.set_char('·');
+                }
+            }
+        }
+    }
+
+    /// Draw the piano roll foreground.
+    ///
+    /// This mode uses full blocks on note on and half blocks on legato: █▄ █▄ █▄
+    fn draw_fg (buf: &mut BigBuffer, clip: &MidiClip, zoom: usize) {
+        let style = Style::default().fg(clip.color.base.term);//.bg(Rgb(0, 0, 0));
+        let mut notes_on = [false;128];
+        for (x, time_start) in (0..clip.length).step_by(zoom).enumerate() {
+            for (_y, note) in (0..=127).rev().enumerate() {
+                if let Some(cell) = buf.get_mut(x, note) {
+                    if notes_on[note] {
+                        cell.set_char('▂');
+                        cell.set_style(style);
+                    }
+                }
+            }
+            let time_end = time_start + zoom;
+            for time in time_start..time_end.min(clip.length) {
+                for event in clip.notes[time].iter() {
+                    match event {
+                        MidiMessage::NoteOn { key, .. } => {
+                            let note = key.as_int() as usize;
+                            if let Some(cell) = buf.get_mut(x, note) {
+                                cell.set_char('█');
+                                cell.set_style(style);
+                            }
+                            notes_on[note] = true
+                        },
+                        MidiMessage::NoteOff { key, .. } => {
+                            notes_on[key.as_int() as usize] = false
+                        },
+                        _ => {}
+                    }
+                }
+            }
+
+        }
+    }
+
+    fn notes (&self) -> impl Draw<Tui> {
+        let time_start = self.get_time_start();
+        let note_lo    = self.get_note_lo();
+        let note_hi    = self.get_note_hi();
+        let buffer     = self.buffer.clone();
+        thunk(move|to: &mut Tui|{
+            let xywh = to.area().into();
+            let XYWH(x0, y0, w, _h) = xywh;
+            let source = buffer.read().unwrap();
+            //if h as usize != note_axis {
+                //panic!("area height mismatch: {h} <> {note_axis}");
+            //}
+            for (area_x, screen_x) in (x0..x0+w).enumerate() {
+                for (area_y, screen_y, _note) in note_y_iter(note_lo, note_hi, y0) {
+                    let source_x = time_start + area_x;
+                    let source_y = note_hi    - area_y;
+                    // TODO: enable loop rollover:
+                    //let source_x = (time_start + area_x) % source.width.max(1);
+                    //let source_y = (note_hi    - area_y) % source.height.max(1);
+                    let is_in_x = source_x < source.width;
+                    let is_in_y = source_y < source.height;
+                    if is_in_x && is_in_y {
+                        if let Some(source_cell) = source.get(source_x, source_y) {
+                            if let Some(cell) = to.0.cell_mut(ratatui::prelude::Position::from((screen_x, screen_y))) {
+                                *cell = source_cell.clone();
+                            }
+                        }
+                    }
+                }
+            }
+            Ok(Some(xywh))
+        })
+    }
+
+    fn cursor (&self) -> impl Draw<Tui> {
+        let note_hi    = self.get_note_hi();
+        let note_lo    = self.get_note_lo();
+        let note_pos   = self.get_note_pos();
+        let note_len   = self.get_note_len();
+        let time_pos   = self.get_time_pos();
+        let time_start = self.get_time_start();
+        let time_zoom  = self.get_time_zoom();
+        let style      = Some(Style::default().fg(self.color.lightest.term));
+        thunk(move|to: &mut Tui|{
+            let xywh = to.area().into();
+            let XYWH(x0, y0, w, _h) = xywh;
+            for (_area_y, screen_y, note) in note_y_iter(note_lo, note_hi, y0) {
+                if note == note_pos {
+                    for x in 0..w {
+                        let screen_x = x0 + x;
+                        let time_1 = time_start + x as usize * time_zoom;
+                        let time_2 = time_1 + time_zoom;
+                        if time_1 <= time_pos && time_pos < time_2 {
+                            to.blit(&"█", screen_x, screen_y, style);
+                            let tail = note_len as u16 / time_zoom as u16;
+                            for x_tail in (screen_x + 1)..(screen_x + tail) {
+                                to.blit(&"▂", x_tail, screen_y, style);
+                            }
+                            break
+                        }
+                    }
+                    break
+                }
+            }
+            Ok(Some(xywh))
+        })
+    }
+
+    fn keys (&self) -> impl Draw<Tui> {
+        let state      = self;
+        let color      = state.color;
+        let note_lo    = state.get_note_lo();
+        let note_hi    = state.get_note_hi();
+        let note_pos   = state.get_note_pos();
+        let key_style  = Some(Style::default().fg(Rgb(192, 192, 192)).bg(Rgb(0, 0, 0)));
+        let off_style  = Some(Style::default().fg(g(255)));
+        let on_style   = Some(Style::default().fg(Rgb(255,0,0)).bg(color.base.term).bold());
+        thunk(move|to: &mut Tui|{
+            let xywh = to.area().into();
+            let XYWH(x, y0, _w, _h) = xywh;
+            for (_area_y, screen_y, note) in note_y_iter(note_lo, note_hi, y0) {
+                to.blit(&to_key(note), x, screen_y, key_style);
+                if note > 127 {
+                    continue
+                }
+                if note == note_pos {
+                    to.blit(&format!("{:<5}", note_pitch_to_name(note)), x, screen_y, on_style)
+                } else {
+                    to.blit(&note_pitch_to_name(note), x, screen_y, off_style)
+                };
+            }
+            Ok(Some(xywh))
+        }).exact_w(self.keys_width).full_h()
+    }
+
+    fn timeline (&self) -> impl Draw<Tui> + '_ {
+        thunk(move|to: &mut Tui|{
+            let xywh = to.area().into();
+            let XYWH(x, y, w, _h) = xywh;
+            let style = Some(Style::default().dim());
+            let length = self.clip.as_ref().map(|p|p.read().unwrap().length).unwrap_or(1);
+            for (area_x, screen_x) in (0..w).map(|d|(d, d+x)) {
+                let t = area_x as usize * self.time_zoom().load(Relaxed);
+                if t < length {
+                    to.blit(&"|", screen_x, y, style);
+                }
+            }
+            Ok(Some(xywh))
+        }).exact_h(1).full_w()
+    }
+}
+
+impl TimeRange for PianoHorizontal {
+    fn time_len   (&self) -> &AtomicUsize { self.range.time_len()   }
+    fn time_zoom  (&self) -> &AtomicUsize { self.range.time_zoom()  }
+    fn time_lock  (&self) -> &AtomicBool  { self.range.time_lock()  }
+    fn time_start (&self) -> &AtomicUsize { self.range.time_start() }
+    fn time_axis  (&self) -> &AtomicUsize { self.range.time_axis()  }
+}
+
+impl NoteRange for PianoHorizontal {
+    fn note_lo    (&self) -> &AtomicUsize { self.range.note_lo()    }
+    fn note_axis  (&self) -> &AtomicUsize { self.range.note_axis()  }
+}
+
+impl NotePoint for PianoHorizontal {
+    fn note_len (&self) -> &AtomicUsize { self.point.note_len() }
+    fn note_pos (&self) -> &AtomicUsize { self.point.note_pos() }
+}
+
+impl TimePoint for PianoHorizontal {
+    fn time_pos (&self) -> &AtomicUsize { self.point.time_pos() }
+}
+
+impl MidiViewer for PianoHorizontal {
+    fn clip (&self) -> &Option<Arc<RwLock<MidiClip>>> { &self.clip }
+    fn clip_mut (&mut self) -> &mut Option<Arc<RwLock<MidiClip>>> { &mut self.clip }
+    /// Determine the required space to render the clip.
+    fn buffer_size (&self, clip: &MidiClip) -> (usize, usize) {
+        (clip.length / self.range.time_zoom().load(Relaxed), 128)
+    }
+    fn redraw (&self) {
+        *self.buffer.write().unwrap() = if let Some(clip) = self.clip.as_ref() {
+            let clip       = clip.read().unwrap();
+            let buf_size   = self.buffer_size(&clip);
+            let mut buffer = BigBuffer::from(buf_size);
+            let time_zoom  = self.get_time_zoom();
+            self.time_len().store(clip.length, Relaxed);
+            PianoHorizontal::draw_bg(&mut buffer, &clip, time_zoom,self.get_note_len(), self.get_note_pos(), self.get_time_pos());
+            PianoHorizontal::draw_fg(&mut buffer, &clip, time_zoom);
+            buffer
+        } else {
+            Default::default()
+        }
+    }
+    fn set_clip (&mut self, clip: Option<&Arc<RwLock<MidiClip>>>) {
+        *self.clip_mut() = clip.cloned();
+        self.color = clip.map(|p|p.read().unwrap().color).unwrap_or(ItemTheme::G[64]);
+        self.redraw();
+    }
+}
+
+impl std::fmt::Debug for PianoHorizontal {
+    fn fmt (&self, f: &mut Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
+        let buffer = self.buffer.read().unwrap();
+        f.debug_struct("PianoHorizontal")
+            .field("time_zoom", &self.range.time_zoom)
+            .field("buffer", &format!("{}x{}", buffer.width, buffer.height))
+            .finish()
+    }
+}

src/device/editor/point.rs

@@ -0,0 +1,76 @@
+use crate::*;
+
+///
+/// ```
+/// let _ = tek::MidiCursor::default();
+/// ```
+#[derive(Debug, Clone)] pub struct MidiCursor {
+    /// Time coordinate of cursor
+    pub time_pos: Arc<AtomicUsize>,
+    /// Note coordinate of cursor
+    pub note_pos: Arc<AtomicUsize>,
+    /// Length of note that will be inserted, in pulses
+    pub note_len: Arc<AtomicUsize>,
+}
+
+impl_default!(MidiCursor:     Self {
+    time_pos: Arc::new(0.into()),
+    note_pos: Arc::new(36.into()),
+    note_len: Arc::new(24.into()),
+});
+
+impl NotePoint for MidiCursor {
+    fn note_len (&self) -> &AtomicUsize {
+        &self.note_len
+    }
+    fn note_pos (&self) -> &AtomicUsize {
+        &self.note_pos
+    }
+}
+
+impl TimePoint for MidiCursor {
+    fn time_pos (&self) -> &AtomicUsize {
+        self.time_pos.as_ref()
+    }
+}
+
+pub trait NotePoint {
+    fn note_len (&self) -> &AtomicUsize;
+    /// Get the current length of the note cursor.
+    fn get_note_len (&self) -> usize {
+        self.note_len().load(Relaxed)
+    }
+    /// Set the length of the note cursor, returning the previous value.
+    fn set_note_len (&self, x: usize) -> usize {
+        self.note_len().swap(x, Relaxed)
+    }
+
+    fn note_pos (&self) -> &AtomicUsize;
+    /// Get the current pitch of the note cursor.
+    fn get_note_pos (&self) -> usize {
+        self.note_pos().load(Relaxed).min(127)
+    }
+    /// Set the current pitch fo the note cursor, returning the previous value.
+    fn set_note_pos (&self, x: usize) -> usize {
+        self.note_pos().swap(x.min(127), Relaxed)
+    }
+}
+
+pub trait TimePoint {
+    fn time_pos (&self) -> &AtomicUsize;
+    /// Get the current time position of the note cursor.
+    fn get_time_pos (&self) -> usize {
+        self.time_pos().load(Relaxed)
+    }
+    /// Set the current time position of the note cursor, returning the previous value.
+    fn set_time_pos (&self, x: usize) -> usize {
+        self.time_pos().swap(x, Relaxed)
+    }
+}
+
+pub trait MidiPoint: NotePoint + TimePoint {
+    /// Get the current end of the note cursor.
+    fn get_note_end (&self) -> usize {
+        self.get_time_pos() + self.get_note_len()
+    }
+}

src/device/editor/range.rs

@@ -0,0 +1,124 @@
+use crate::*;
+
+///
+/// ```
+/// use tek::{TimeRange, NoteRange};
+/// let model = tek::MidiSelection::from((1, false));
+///
+/// let _ = model.get_time_len();
+/// let _ = model.get_time_zoom();
+/// let _ = model.get_time_lock();
+/// let _ = model.get_time_start();
+/// let _ = model.get_time_axis();
+/// let _ = model.get_time_end();
+///
+/// let _ = model.get_note_lo();
+/// let _ = model.get_note_axis();
+/// let _ = model.get_note_hi();
+/// ```
+#[derive(Debug, Clone, Default)] pub struct MidiSelection {
+    pub time_len:   Arc<AtomicUsize>,
+    /// Length of visible time axis
+    pub time_axis:  Arc<AtomicUsize>,
+    /// Earliest time displayed
+    pub time_start: Arc<AtomicUsize>,
+    /// Time step
+    pub time_zoom:  Arc<AtomicUsize>,
+    /// Auto rezoom to fit in time axis
+    pub time_lock:  Arc<AtomicBool>,
+    /// Length of visible note axis
+    pub note_axis:  Arc<AtomicUsize>,
+    // Lowest note displayed
+    pub note_lo:    Arc<AtomicUsize>,
+}
+
+pub trait MidiRange: TimeRange + NoteRange {}
+
+impl TimeRange for MidiEditor {
+    fn time_len   (&self) -> &AtomicUsize { self.mode.time_len()   }
+    fn time_zoom  (&self) -> &AtomicUsize { self.mode.time_zoom()  }
+    fn time_lock  (&self) -> &AtomicBool  { self.mode.time_lock()  }
+    fn time_start (&self) -> &AtomicUsize { self.mode.time_start() }
+    fn time_axis  (&self) -> &AtomicUsize { self.mode.time_axis()  }
+}
+
+impl NoteRange for MidiEditor {
+    fn note_lo   (&self) -> &AtomicUsize { self.mode.note_lo()   }
+    fn note_axis (&self) -> &AtomicUsize { self.mode.note_axis() }
+}
+
+impl_from!(MidiSelection: |data:(usize, bool)| Self {
+    time_len:   Arc::new(0.into()),
+    note_axis:  Arc::new(0.into()),
+    note_lo:    Arc::new(0.into()),
+    time_axis:  Arc::new(0.into()),
+    time_start: Arc::new(0.into()),
+    time_zoom:  Arc::new(data.0.into()),
+    time_lock:  Arc::new(data.1.into()),
+});
+
+impl TimeRange for MidiSelection {
+    fn time_len   (&self) -> &AtomicUsize { &self.time_len   }
+    fn time_zoom  (&self) -> &AtomicUsize { &self.time_zoom  }
+    fn time_lock  (&self) -> &AtomicBool  { &self.time_lock  }
+    fn time_start (&self) -> &AtomicUsize { &self.time_start }
+    fn time_axis  (&self) -> &AtomicUsize { &self.time_axis  }
+}
+
+impl NoteRange for MidiSelection {
+    fn note_lo    (&self) -> &AtomicUsize { &self.note_lo    }
+    fn note_axis  (&self) -> &AtomicUsize { &self.note_axis  }
+}
+
+pub trait TimeRange {
+    fn time_len (&self) -> &AtomicUsize;
+    fn get_time_len (&self) -> usize {
+        self.time_len().load(Relaxed)
+    }
+    fn time_zoom (&self) -> &AtomicUsize;
+    fn get_time_zoom (&self) -> usize {
+        self.time_zoom().load(Relaxed)
+    }
+    fn set_time_zoom (&self, value: usize) -> usize {
+        self.time_zoom().swap(value, Relaxed)
+    }
+    fn time_lock (&self) -> &AtomicBool;
+    fn get_time_lock (&self) -> bool {
+        self.time_lock().load(Relaxed)
+    }
+    fn set_time_lock (&self, value: bool) -> bool {
+        self.time_lock().swap(value, Relaxed)
+    }
+    fn time_start (&self) -> &AtomicUsize;
+    fn get_time_start (&self) -> usize {
+        self.time_start().load(Relaxed)
+    }
+    fn set_time_start (&self, value: usize) -> usize {
+        self.time_start().swap(value, Relaxed)
+    }
+    fn time_axis (&self) -> &AtomicUsize;
+    fn get_time_axis (&self) -> usize {
+        self.time_axis().load(Relaxed)
+    }
+    fn get_time_end (&self) -> usize {
+        self.time_start().load(Relaxed) + self.time_axis().load(Relaxed) * self.time_zoom().load(Relaxed)
+    }
+}
+
+pub trait NoteRange {
+    fn note_lo   (&self) -> &AtomicUsize;
+    fn note_axis (&self) -> &AtomicUsize;
+
+    fn get_note_lo (&self) -> usize {
+        self.note_lo().load(Relaxed)
+    }
+    fn set_note_lo (&self, x: usize) -> usize {
+        self.note_lo().swap(x, Relaxed)
+    }
+    fn get_note_axis (&self) -> usize {
+        self.note_axis().load(Relaxed)
+    }
+    fn get_note_hi (&self) -> usize {
+        (self.get_note_lo() + self.get_note_axis().saturating_sub(1)).min(127)
+    }
+}

src/device/meter.rs

@@ -0,0 +1,80 @@
+use crate::*;
+
+#[derive(Debug, Default)] pub enum MeteringMode {
+    #[default] Rms,
+    Log10,
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct Log10Meter(pub f32);
+
+#[derive(Debug, Default, Clone)]
+pub struct RmsMeter(pub f32);
+
+impl_draw!(|self: RmsMeter, to: Tui|{
+    let XYWH(x, y, w, h) = to.area().into();
+    let signal = f32::max(0.0, f32::min(100.0, self.0.abs()));
+    let v = (signal * h as f32).ceil() as u16;
+    let y2 = y + h;
+    //to.blit(&format!("\r{v} {} {signal}", self.0), x * 30, y, Some(Style::default()));
+    for y in y..(y + v) {
+        for x in x..(x + w) {
+            to.blit(&"▌", x, y2.saturating_sub(y), Some(Style::default().green()));
+        }
+    }
+    Ok(Some(to.area().into()))
+});
+
+impl_draw!(|self: Log10Meter, to: Tui| {
+    let XYWH(x, y, w, h) = to.area().into();
+    let signal = 100.0 - f32::max(0.0, f32::min(100.0, self.0.abs()));
+    let v = (signal * h as f32 / 100.0).ceil() as u16;
+    let y2 = y + h;
+    //to.blit(&format!("\r{v} {} {signal}", self.0), x * 20, y, None);
+    for y in y..(y + v) {
+        for x in x..(x + w) {
+            to.blit(&"▌", x, y2 - y, Some(Style::default().green()));
+        }
+    }
+    Ok(Some(to.area().into()))
+});
+
+fn draw_meters (meters: &[f32]) -> impl Draw<Tui> + use<'_> {
+    bg(Black, iter_east_fixed(1, ||meters.iter(), |value, _index|{
+        RmsMeter(*value).full_h()
+    }).exact_w(2))
+}
+
+pub fn to_log10 (samples: &[f32]) -> f32 {
+    let total: f32 = samples.iter().map(|x|x.abs()).sum();
+    let count = samples.len() as f32;
+    10. * (total / count).log10()
+}
+
+pub fn to_rms (samples: &[f32]) -> f32 {
+    let sum = samples.iter()
+        .map(|s|*s)
+        .reduce(|sum, sample|sum + sample.abs())
+        .unwrap_or(0.0);
+    (sum / samples.len() as f32).sqrt()
+}
+
+#[cfg(test)] mod test_view_meter {
+    use super::*;
+    use proptest::prelude::*;
+    proptest! {
+
+        #[test] fn proptest_view_meter (
+            label in "\\PC*", value in f32::MIN..f32::MAX
+        ) {
+            let _ = view_meter(&label, value);
+        }
+
+        #[test] fn proptest_view_meters (
+            value1 in f32::MIN..f32::MAX,
+            value2 in f32::MIN..f32::MAX
+        ) {
+            let _ = view_meters(&[value1, value2]);
+        }
+    }
+}

src/device/mix.rs

@@ -0,0 +1,42 @@
+use crate::*;
+
+#[derive(Debug, Default)]
+pub enum MixingMode {
+    #[default] Summing,
+    Average,
+}
+
+pub fn mix_summing <const N: usize> (
+    buffer: &mut [Vec<f32>], gain: f32, frames: usize, mut next: impl FnMut()->Option<[f32;N]>,
+) -> bool {
+    let channels = buffer.len();
+    for index in 0..frames {
+        if let Some(frame) = next() {
+            for (channel, sample) in frame.iter().enumerate() {
+                let channel = channel % channels;
+                buffer[channel][index] += sample * gain;
+            }
+        } else {
+            return false
+        }
+    }
+    true
+}
+
+pub fn mix_average <const N: usize> (
+    buffer: &mut [Vec<f32>], gain: f32, frames: usize, mut next: impl FnMut()->Option<[f32;N]>,
+) -> bool {
+    let channels = buffer.len();
+    for index in 0..frames {
+        if let Some(frame) = next() {
+            for (channel, sample) in frame.iter().enumerate() {
+                let channel = channel % channels;
+                let value = buffer[channel][index];
+                buffer[channel][index] = (value + sample * gain) / 2.0;
+            }
+        } else {
+            return false
+        }
+    }
+    true
+}

src/device/plugin.rs

@@ -1,5 +1,13 @@
 use crate::*;
 
+#[cfg(feature = "lv2_gui")] use ::winit::{
+    application::ApplicationHandler,
+    event::WindowEvent,
+    event_loop::{ActiveEventLoop, ControlFlow, EventLoop},
+    window::{Window, WindowId},
+    platform::x11::EventLoopBuilderExtX11
+};
+
 /// A LV2 plugin.
 #[derive(Debug)] #[cfg(feature = "lv2")] pub struct Lv2 {
     /// JACK client handle (needs to not be dropped for standalone mode to work).

src/device/port.rs

@@ -0,0 +1,136 @@
+use crate::*;
+use ConnectName::*;
+use ConnectScope::*;
+use ConnectStatus::*;
+
+mod audio;    pub use self::audio::*;
+mod midi;     pub use self::midi::*;
+mod connect;  pub use self::connect::*;
+mod register; pub use self::register::*;
+
+pub trait JackPort: HasJack<'static> {
+    type Port: PortSpec + Default;
+    type Pair: PortSpec + Default;
+
+    fn new (jack: &Jack<'static>, name: &impl AsRef<str>, connect: &[Connect])
+        -> Usually<Self> where Self: Sized;
+
+    fn register (jack: &Jack<'static>, name: &impl AsRef<str>) -> Usually<Port<Self::Port>> {
+        jack.with_client(|c|c.register_port::<Self::Port>(name.as_ref(), Default::default()))
+            .map_err(|e|e.into())
+    }
+
+    fn port_name (&self) -> &Arc<str>;
+
+    fn connections (&self) -> &[Connect];
+
+    fn port (&self) -> &Port<Self::Port>;
+
+    fn port_mut (&mut self) -> &mut Port<Self::Port>;
+
+    fn into_port (self) -> Port<Self::Port> where Self: Sized;
+
+    fn close (self) -> Usually<()> where Self: Sized {
+        let jack = self.jack().clone();
+        Ok(jack.with_client(|c|c.unregister_port(self.into_port()))?)
+    }
+
+    fn ports (&self, re_name: Option<&str>, re_type: Option<&str>, flags: PortFlags) -> Vec<String> {
+        self.with_client(|c|c.ports(re_name, re_type, flags))
+    }
+
+    fn port_by_id (&self, id: u32) -> Option<Port<Unowned>> {
+        self.with_client(|c|c.port_by_id(id))
+    }
+
+    fn port_by_name (&self, name: impl AsRef<str>) -> Option<Port<Unowned>> {
+        self.with_client(|c|c.port_by_name(name.as_ref()))
+    }
+
+    fn connect_to_matching <'k> (&'k self) -> Usually<()> {
+        for connect in self.connections().iter() {
+            match &connect.name {
+                Some(Exact(name)) => {
+                    *connect.status.write().unwrap() = self.connect_exact(name)?;
+                },
+                Some(RegExp(re))  => {
+                    *connect.status.write().unwrap() = self.connect_regexp(re, connect.scope)?;
+                },
+                _ => {},
+            };
+        }
+        Ok(())
+    }
+
+    fn connect_exact <'k> (&'k self, name: &str) ->
+        Usually<Vec<(Port<Unowned>, Arc<str>, ConnectStatus)>>
+    {
+        self.with_client(move|c|{
+            let mut status = vec![];
+            for port in c.ports(None, None, PortFlags::empty()).iter() {
+                if port.as_str() == &*name {
+                    if let Some(port) = c.port_by_name(port.as_str()) {
+                        let port_status = self.connect_to_unowned(&port)?;
+                        let name = port.name()?.into();
+                        status.push((port, name, port_status));
+                        if port_status == Connected {
+                            break
+                        }
+                    }
+                }
+            }
+            Ok(status)
+        })
+    }
+
+    fn connect_regexp <'k> (
+        &'k self, re: &str, scope: Option<ConnectScope>
+    ) -> Usually<Vec<(Port<Unowned>, Arc<str>, ConnectStatus)>> {
+        self.with_client(move|c|{
+            let mut status = vec![];
+            let ports = c.ports(Some(&re), None, PortFlags::empty());
+            for port in ports.iter() {
+                if let Some(port) = c.port_by_name(port.as_str()) {
+                    let port_status = self.connect_to_unowned(&port)?;
+                    let name = port.name()?.into();
+                    status.push((port, name, port_status));
+                    if port_status == Connected && scope == Some(One) {
+                        break
+                    }
+                }
+            }
+            Ok(status)
+        })
+    }
+
+    /** Connect to a matching port by name. */
+    fn connect_to_name (&self, name: impl AsRef<str>) -> Usually<ConnectStatus> {
+        self.with_client(|c|if let Some(ref port) = c.port_by_name(name.as_ref()) {
+            self.connect_to_unowned(port)
+        } else {
+            Ok(Missing)
+        })
+    }
+
+    /** Connect to a matching port by reference. */
+    fn connect_to_unowned (&self, port: &Port<Unowned>) -> Usually<ConnectStatus> {
+        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
+        }))
+    }
+
+    /** Connect to an owned matching port by reference. */
+    fn connect_to_owned (&self, port: &Port<Self::Pair>) -> Usually<ConnectStatus> {
+        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
+        }))
+    }
+}

src/device/port/audio.rs

@@ -0,0 +1,103 @@
+use crate::*;
+
+def_command!(AudioInputCommand: |port: AudioInput| {
+    Close => todo!(),
+    Connect { audio_out: Arc<str> } => todo!(),
+});
+
+def_command!(AudioOutputCommand: |port: AudioOutput| {
+    Close => todo!(),
+    Connect { audio_in: Arc<str> } => todo!(),
+});
+
+impl HasJack<'static> for AudioInput { fn jack (&self) -> &Jack<'static> { &self.jack } }
+impl HasJack<'static> for AudioOutput { fn jack (&self) -> &Jack<'static> { &self.jack } }
+
+/// Audio input port.
+#[derive(Debug)] pub struct AudioInput {
+    /// Handle to JACK client, for receiving reconnect events.
+    pub jack: Jack<'static>,
+    /// Port name
+    pub name: Arc<str>,
+    /// Port handle.
+    pub port: Port<AudioIn>,
+    /// List of ports to connect to.
+    pub connections: Vec<Connect>,
+}
+
+/// Audio output port.
+#[derive(Debug)] pub struct AudioOutput {
+    /// Handle to JACK client, for receiving reconnect events.
+    pub jack: Jack<'static>,
+    /// Port name
+    pub name: Arc<str>,
+    /// Port handle.
+    pub port: Port<AudioOut>,
+    /// List of ports to connect to.
+    pub connections: Vec<Connect>,
+}
+
+
+impl JackPort for AudioInput {
+    type Port = AudioIn;
+    type Pair = AudioOut;
+    fn port_name (&self) -> &Arc<str> {
+        &self.name
+    }
+    fn port (&self) -> &Port<Self::Port> {
+        &self.port
+    }
+    fn port_mut (&mut self) -> &mut Port<Self::Port> {
+        &mut self.port
+    }
+    fn into_port (self) -> Port<Self::Port> {
+        self.port
+    }
+    fn connections (&self) -> &[Connect] {
+        self.connections.as_slice()
+    }
+    fn new (jack: &Jack<'static>, name: &impl AsRef<str>, connect: &[Connect])
+        -> Usually<Self> where Self: Sized
+    {
+        let port = Self {
+            port: Self::register(jack, name)?,
+            jack: jack.clone(),
+            name: name.as_ref().into(),
+            connections: connect.to_vec()
+        };
+        port.connect_to_matching()?;
+        Ok(port)
+    }
+}
+
+impl JackPort for AudioOutput {
+    type Port = AudioOut;
+    type Pair = AudioIn;
+    fn port_name (&self) -> &Arc<str> {
+        &self.name
+    }
+    fn port (&self) -> &Port<Self::Port> {
+        &self.port
+    }
+    fn port_mut (&mut self) -> &mut Port<Self::Port> {
+        &mut self.port
+    }
+    fn into_port (self) -> Port<Self::Port> {
+        self.port
+    }
+    fn connections (&self) -> &[Connect] {
+        self.connections.as_slice()
+    }
+    fn new (jack: &Jack<'static>, name: &impl AsRef<str>, connect: &[Connect])
+        -> Usually<Self> where Self: Sized
+    {
+        let port = Self {
+            port: Self::register(jack, name)?,
+            jack: jack.clone(),
+            name: name.as_ref().into(),
+            connections: connect.to_vec()
+        };
+        port.connect_to_matching()?;
+        Ok(port)
+    }
+}

src/device/port/connect.rs

@@ -0,0 +1,83 @@
+use crate::*;
+use ConnectName::*;
+use ConnectScope::*;
+use ConnectStatus::*;
+
+#[derive(Clone, Debug, PartialEq)] pub enum ConnectName {
+    /** Exact match */
+    Exact(Arc<str>),
+    /** Match regular expression */
+    RegExp(Arc<str>),
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)] pub enum ConnectScope {
+    One,
+    All
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)] pub enum ConnectStatus {
+    Missing,
+    Disconnected,
+    Connected,
+    Mismatch,
+}
+
+/// Port connection manager.
+///
+/// ```
+/// let connect = tek::Connect::default();
+/// ```
+#[derive(Clone, Debug, Default)] pub struct Connect {
+    pub name:   Option<ConnectName>,
+    pub scope:  Option<ConnectScope>,
+    pub status: Arc<RwLock<Vec<(Port<Unowned>, Arc<str>, ConnectStatus)>>>,
+    pub info:   Arc<str>,
+}
+
+impl Connect {
+    pub fn collect (exact: &[impl AsRef<str>], re: &[impl AsRef<str>], re_all: &[impl AsRef<str>])
+        -> Vec<Self>
+    {
+        let mut connections = vec![];
+        for port in exact.iter()  { connections.push(Self::exact(port)) }
+        for port in re.iter()     { connections.push(Self::regexp(port)) }
+        for port in re_all.iter() { connections.push(Self::regexp_all(port)) }
+        connections
+    }
+    /// Connect to this exact port
+    pub fn exact (name: impl AsRef<str>) -> Self {
+        let info = format!("=:{}", name.as_ref()).into();
+        let name = Some(Exact(name.as_ref().into()));
+        Self { name, scope: Some(One), status: Arc::new(RwLock::new(vec![])), info }
+    }
+    pub fn regexp (name: impl AsRef<str>) -> Self {
+        let info = format!("~:{}", name.as_ref()).into();
+        let name = Some(RegExp(name.as_ref().into()));
+        Self { name, scope: Some(One), status: Arc::new(RwLock::new(vec![])), info }
+    }
+    pub fn regexp_all (name: impl AsRef<str>) -> Self {
+        let info = format!("+:{}", name.as_ref()).into();
+        let name = Some(RegExp(name.as_ref().into()));
+        Self { name, scope: Some(All), status: Arc::new(RwLock::new(vec![])), info }
+    }
+    pub fn info (&self) -> Arc<str> {
+        format!(" ({}) {} {}", {
+            let status = self.status.read().unwrap();
+            let mut ok = 0;
+            for (_, _, state) in status.iter() {
+                if *state == Connected {
+                    ok += 1
+                }
+            }
+            format!("{ok}/{}", status.len())
+        }, match self.scope {
+            None      => "x",
+            Some(One) => " ",
+            Some(All) => "*",
+        }, match &self.name {
+            None               => format!("x"),
+            Some(Exact(name))  => format!("= {name}"),
+            Some(RegExp(name)) => format!("~ {name}"),
+        }).into()
+    }
+}

src/device/port/midi.rs

@@ -0,0 +1,256 @@
+use crate::*;
+
+impl HasJack<'static> for MidiInput { fn jack (&self) -> &Jack<'static> { &self.jack } }
+
+impl HasJack<'static> for MidiOutput { fn jack (&self) -> &Jack<'static> { &self.jack } }
+
+/// MIDI input port.
+#[derive(Debug)] pub struct MidiInput {
+    /// Handle to JACK client, for receiving reconnect events.
+    pub jack: Jack<'static>,
+    /// Port name
+    pub name: Arc<str>,
+    /// Port handle.
+    pub port: Port<MidiIn>,
+    /// List of currently held notes.
+    pub held: Arc<RwLock<[bool;128]>>,
+    /// List of ports to connect to.
+    pub connections: Vec<Connect>,
+}
+
+/// MIDI output port.
+#[derive(Debug)] pub struct MidiOutput {
+    /// Handle to JACK client, for receiving reconnect events.
+    pub jack: Jack<'static>,
+    /// Port name
+    pub name: Arc<str>,
+    /// Port handle.
+    pub port: Port<MidiOut>,
+    /// List of ports to connect to.
+    pub connections: Vec<Connect>,
+    /// List of currently held notes.
+    pub held: Arc<RwLock<[bool;128]>>,
+    /// Buffer
+    pub note_buffer: Vec<u8>,
+    /// Buffer
+    pub output_buffer: Vec<Vec<Vec<u8>>>,
+}
+
+def_command!(MidiInputCommand: |port: MidiInput| {
+    Close => todo!(),
+    Connect { midi_out: Arc<str> } => todo!(),
+});
+
+def_command!(MidiOutputCommand: |port: MidiOutput| {
+    Close => todo!(),
+    Connect { midi_in: Arc<str> } => todo!(),
+});
+/// Trait for thing that may receive MIDI.
+pub trait HasMidiIns {
+    fn midi_ins (&self) -> &Vec<MidiInput>;
+    fn midi_ins_mut (&mut self) -> &mut Vec<MidiInput>;
+    /// Collect MIDI input from app ports (TODO preallocate large buffers)
+    fn midi_input_collect <'a> (&'a self, scope: &'a ProcessScope) -> CollectedMidiInput<'a> {
+        self.midi_ins().iter()
+            .map(|port|port.port().iter(scope)
+                .map(|RawMidi { time, bytes }|(time, LiveEvent::parse(bytes)))
+                .collect::<Vec<_>>())
+            .collect::<Vec<_>>()
+    }
+    fn midi_ins_with_sizes <'a> (&'a self) ->
+        impl Iterator<Item=(usize, &'a Arc<str>, &'a [Connect], usize, usize)> + Send + Sync + 'a
+    {
+        let mut y = 0;
+        self.midi_ins().iter().enumerate().map(move|(i, input)|{
+            let height = 1 + input.connections().len();
+            let data   = (i, input.port_name(), input.connections(), y, y + height);
+            y += height;
+            data
+        })
+    }
+}
+/// Trait for thing that may output MIDI.
+pub trait HasMidiOuts {
+    fn midi_outs (&self) -> &Vec<MidiOutput>;
+    fn midi_outs_mut (&mut self) -> &mut Vec<MidiOutput>;
+    fn midi_outs_with_sizes <'a> (&'a self) ->
+        impl Iterator<Item=(usize, &'a Arc<str>, &'a [Connect], usize, usize)> + Send + Sync + 'a
+    {
+        let mut y = 0;
+        self.midi_outs().iter().enumerate().map(move|(i, output)|{
+            let height = 1 + output.connections().len();
+            let data   = (i, output.port_name(), output.connections(), y, y + height);
+            y += height;
+            data
+        })
+    }
+    fn midi_outs_emit (&mut self, scope: &ProcessScope) {
+        for port in self.midi_outs_mut().iter_mut() {
+            port.buffer_emit(scope)
+        }
+    }
+}
+
+impl JackPort for MidiInput {
+    type Port = MidiIn;
+    type Pair = MidiOut;
+    fn port_name (&self) -> &Arc<str> {
+        &self.name
+    }
+    fn port (&self) -> &Port<Self::Port> {
+        &self.port
+    }
+    fn port_mut (&mut self) -> &mut Port<Self::Port> {
+        &mut self.port
+    }
+    fn into_port (self) -> Port<Self::Port> {
+        self.port
+    }
+    fn connections (&self) -> &[Connect] {
+        self.connections.as_slice()
+    }
+    fn new (jack: &Jack<'static>, name: &impl AsRef<str>, connect: &[Connect])
+        -> Usually<Self> where Self: Sized
+    {
+        let port = Self {
+            port: Self::register(jack, name)?,
+            jack: jack.clone(),
+            name: name.as_ref().into(),
+            connections: connect.to_vec(),
+            held: Arc::new(RwLock::new([false;128]))
+        };
+        port.connect_to_matching()?;
+        Ok(port)
+    }
+}
+
+impl JackPort for MidiOutput {
+    type Port = MidiOut;
+    type Pair = MidiIn;
+    fn port_name (&self) -> &Arc<str> {
+        &self.name
+    }
+    fn port (&self) -> &Port<Self::Port> {
+        &self.port
+    }
+    fn port_mut (&mut self) -> &mut Port<Self::Port> {
+        &mut self.port
+    }
+    fn into_port (self) -> Port<Self::Port> {
+        self.port
+    }
+    fn connections (&self) -> &[Connect] {
+        self.connections.as_slice()
+    }
+    fn new (jack: &Jack<'static>, name: &impl AsRef<str>, connect: &[Connect])
+        -> Usually<Self> where Self: Sized
+    {
+        let port = Self::register(jack, name)?;
+        let jack = jack.clone();
+        let name = name.as_ref().into();
+        let connections = connect.to_vec();
+        let port = Self {
+            jack,
+            port,
+            name,
+            connections,
+            held: Arc::new([false;128].into()),
+            note_buffer: vec![0;8],
+            output_buffer: vec![vec![];65536],
+        };
+        port.connect_to_matching()?;
+        Ok(port)
+    }
+}
+
+impl View<Tui> for MidiInput {
+    fn view (&self) -> impl Draw<Tui> {
+        "TODO: MIDI IN"
+    }
+}
+
+impl View<Tui> for MidiOutput {
+    fn view (&self) -> impl Draw<Tui> {
+        "TODO: MIDI OUT"
+    }
+}
+
+impl MidiOutput {
+    /// 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 MidiInput {
+    pub fn parsed <'a> (&'a self, scope: &'a ProcessScope) -> impl Iterator<Item=(usize, LiveEvent<'a>, &'a [u8])> {
+        parse_midi_input(self.port().iter(scope))
+    }
+}
+impl<T: AsRef<Vec<MidiInput>> + AsMut<Vec<MidiInput>>> HasMidiIns for T {
+    fn midi_ins (&self) -> &Vec<MidiInput> { self.as_ref() }
+    fn midi_ins_mut (&mut self) -> &mut Vec<MidiInput> { self.as_mut() }
+}
+impl<T: AsRef<Vec<MidiOutput>> + AsMut<Vec<MidiOutput>>> HasMidiOuts for T {
+    fn midi_outs (&self) -> &Vec<MidiOutput> { self.as_ref() }
+    fn midi_outs_mut (&mut self) -> &mut Vec<MidiOutput> { self.as_mut() }
+}
+impl<T: HasMidiIns + HasJack<'static>> AddMidiIn for T {
+    fn midi_in_add (&mut self) -> Usually<()> {
+        let index = self.midi_ins().len();
+        let port  = MidiInput::new(self.jack(), &format!("M/{index}"), &[])?;
+        self.midi_ins_mut().push(port);
+        Ok(())
+    }
+}
+/// Trail for thing that may gain new MIDI ports.
+impl<T: HasMidiOuts + HasJack<'static>> AddMidiOut for T {
+    fn midi_out_add (&mut self) -> Usually<()> {
+        let index = self.midi_outs().len();
+        let port  = MidiOutput::new(self.jack(), &format!("{index}/M"), &[])?;
+        self.midi_outs_mut().push(port);
+        Ok(())
+    }
+}
+
+/// May create new MIDI input ports.
+pub trait AddMidiIn {
+    fn midi_in_add (&mut self) -> Usually<()>;
+}
+
+/// May create new MIDI output ports.
+pub trait AddMidiOut {
+    fn midi_out_add (&mut self) -> Usually<()>;
+}

src/device/port/register.rs

@@ -0,0 +1,27 @@
+use crate::*;
+
+pub trait RegisterPorts: HasJack<'static> {
+    /// Register a MIDI input port.
+    fn midi_in (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<MidiInput>;
+    /// Register a MIDI output port.
+    fn midi_out (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<MidiOutput>;
+    /// Register an audio input port.
+    fn audio_in (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<AudioInput>;
+    /// Register an audio output port.
+    fn audio_out (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<AudioOutput>;
+}
+
+impl<J: HasJack<'static>> RegisterPorts for J {
+    fn midi_in (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<MidiInput> {
+        MidiInput::new(self.jack(), name, connect)
+    }
+    fn midi_out (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<MidiOutput> {
+        MidiOutput::new(self.jack(), name, connect)
+    }
+    fn audio_in (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<AudioInput> {
+        AudioInput::new(self.jack(), name, connect)
+    }
+    fn audio_out (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<AudioOutput> {
+        AudioOutput::new(self.jack(), name, connect)
+    }
+}

src/device/sampler.rs

@@ -1,51 +1,17 @@
 use crate::{*, device::*, browse::*, mix::*};
 
-def_command!(SamplerCommand: |sampler: Sampler| {
-    RecordToggle { slot: usize } => {
-        let slot = *slot;
-        let recording = sampler.recording.as_ref().map(|x|x.0);
-        let _ = Self::RecordFinish.execute(sampler)?;
-        // autoslice: continue recording at next slot
-        if recording != Some(slot) {
-            Self::RecordBegin { slot }.execute(sampler)
-        } else {
-            Ok(None)
-        }
+pub(crate) use symphonia::{
+    default::get_codecs,
+    core::{//errors::Error as SymphoniaError,
+        audio::SampleBuffer, formats::Packet, io::MediaSourceStream, probe::Hint,
+        codecs::{Decoder, CODEC_TYPE_NULL},
     },
-    RecordBegin { slot: usize } => {
-        let slot = *slot;
-        sampler.recording = Some((
-            slot,
-            Some(Arc::new(RwLock::new(Sample::new(
-                "Sample", 0, 0, vec![vec![];sampler.audio_ins.len()]
-            ))))
-        ));
-        Ok(None)
-    },
-    RecordFinish => {
-        let _prev_sample = sampler.recording.as_mut().map(|(index, sample)|{
-            std::mem::swap(sample, &mut sampler.samples.0[*index]);
-            sample
-        }); // TODO: undo
-        Ok(None)
-    },
-    RecordCancel => {
-        sampler.recording = None;
-        Ok(None)
-    },
-    PlaySample { slot: usize } => {
-        let slot = *slot;
-        if let Some(ref sample) = sampler.samples.0[slot] {
-            sampler.voices.write().unwrap().push(Sample::play(sample, 0, &u7::from(128)));
-        }
-        Ok(None)
-    },
-    StopSample { slot: usize } => {
-        let _slot = *slot;
-        todo!();
-        //Ok(None)
-    },
-});
+};
+
+mod voice;      pub use self::voice::*;
+mod sample;     pub use self::sample::*;
+mod sample_add; pub use self::sample_add::*;
+mod sample_kit; pub use self::sample_kit::*;
 
 /// Plays [Voice]s from [Sample]s.
 /// 
@@ -78,7 +44,7 @@ def_command!(SamplerCommand: |sampler: Sampler| {
     /// Currently active modal, if any.
     pub mode: Option<SamplerMode>,
     /// Size of rendered sampler.
-    pub size: [AtomicUsize;2],
+    pub size: Sizer,
     /// Lowest note displayed.
     pub note_lo: AtomicUsize,
     /// Currently selected note.
@@ -97,51 +63,17 @@ def_command!(SamplerCommand: |sampler: Sampler| {
     #[cfg(feature = "meter")] pub output_meters: Vec<f32>,
 }
 
-/// Collection of samples, one per slot, fixed number of slots.
-///
-/// History: Separated to cleanly implement [Default].
-///
-/// ```
-/// let samples = tek::SampleKit([None, None, None, None]);
-/// ```
-#[derive(Debug)] pub struct SampleKit<const N: usize>(
-    pub [Option<Arc<RwLock<Sample>>>;N]
-);
+impl_audio!(Sampler: sampler_jack_process);
 
-/// A sound cut.
-///
-/// ```
-/// let sample = tek::Sample::default();
-/// let sample = tek::Sample::new("test", 0, 0, vec![]);
-/// ```
-#[derive(Default, Debug)] pub struct Sample {
-    pub name:     Arc<str>,
-    pub start:    usize,
-    pub end:      usize,
-    pub channels: Vec<Vec<f32>>,
-    pub rate:     Option<usize>,
-    pub gain:     f32,
-    pub color:    ItemTheme,
-}
-
-/// A currently playing instance of a sample.
-#[derive(Default, Debug, Clone)] pub struct Voice {
-    pub sample:   Arc<RwLock<Sample>>,
-    pub after:    usize,
-    pub position: usize,
-    pub velocity: f32,
-}
-
-#[derive(Default, Debug)] pub struct SampleAdd {
-    pub exited:  bool,
-    pub dir:     PathBuf,
-    pub subdirs: Vec<OsString>,
-    pub files:   Vec<OsString>,
-    pub cursor:  usize,
-    pub offset:  usize,
-    pub sample:  Arc<RwLock<Sample>>,
-    pub voices:  Arc<RwLock<Vec<Voice>>>,
-    pub _search: Option<String>,
+pub(crate) fn sampler_jack_process (state: &mut Sampler, _: &Client, scope: &ProcessScope) -> Control {
+    if let Some(midi_in) = &state.midi_in {
+        for midi in midi_in.port().iter(scope) {
+            sampler_midi_in(&state.samples, &state.voices, midi)
+        }
+    }
+    state.process_audio_out(scope);
+    state.process_audio_in(scope);
+    Control::Continue
 }
 
 #[derive(Debug)] pub enum SamplerMode {
@@ -152,36 +84,15 @@ def_command!(SamplerCommand: |sampler: Sampler| {
 pub type MidiSample =
     (Option<u7>, Arc<RwLock<crate::Sample>>);
 
-impl<const N: usize> Default for SampleKit<N> {
-    fn default () -> Self { Self([const { None }; N]) }
-}
-impl Iterator for Voice {
-    type Item = [f32;2];
-    fn next (&mut self) -> Option<Self::Item> {
-        if self.after > 0 {
-            self.after -= 1;
-            return Some([0.0, 0.0])
-        }
-        let sample = self.sample.read().unwrap();
-        if self.position < sample.end {
-            let position = self.position;
-            self.position += 1;
-            return sample.channels[0].get(position).map(|_amplitude|[
-                sample.channels[0][position] * self.velocity * sample.gain,
-                sample.channels[0][position] * self.velocity * sample.gain,
-            ])
-        }
-        None
-    }
-}
 impl NoteRange for Sampler {
     fn note_lo (&self) -> &AtomicUsize {
         &self.note_lo
     }
     fn note_axis (&self) -> &AtomicUsize {
-        &self.size.y
+        &self.size.1
     }
 }
+
 impl NotePoint for Sampler {
     fn note_len (&self) -> &AtomicUsize {
         unreachable!();
@@ -205,6 +116,7 @@ impl NotePoint for Sampler {
         old
     }
 }
+
 impl Sampler {
     pub fn new (
         jack: &Jack<'static>,
@@ -331,252 +243,6 @@ impl Sampler {
         }
     }
 }
-impl SampleAdd {
-    fn exited (&self) -> bool {
-        self.exited
-    }
-    fn exit (&mut self) {
-        self.exited = true
-    }
-    pub fn new (
-        sample: &Arc<RwLock<Sample>>,
-        voices: &Arc<RwLock<Vec<Voice>>>
-    ) -> Usually<Self> {
-        let dir = std::env::current_dir()?;
-        let (subdirs, files) = scan(&dir)?;
-        Ok(Self {
-            exited: false,
-            dir,
-            subdirs,
-            files,
-            cursor: 0,
-            offset: 0,
-            sample: sample.clone(),
-            voices: voices.clone(),
-            _search: None
-        })
-    }
-    fn rescan (&mut self) -> Usually<()> {
-        scan(&self.dir).map(|(subdirs, files)|{
-            self.subdirs = subdirs;
-            self.files = files;
-        })
-    }
-    fn prev (&mut self) {
-        self.cursor = self.cursor.saturating_sub(1);
-    }
-    fn next (&mut self) {
-        self.cursor = self.cursor + 1;
-    }
-    fn try_preview (&mut self) -> Usually<()> {
-        if let Some(path) = self.cursor_file() {
-            if let Ok(sample) = Sample::from_file(&path) {
-                *self.sample.write().unwrap() = sample;
-                self.voices.write().unwrap().push(
-                    Sample::play(&self.sample, 0, &u7::from(100u8))
-                );
-            }
-            //load_sample(&path)?;
-            //let src = std::fs::File::open(&path)?;
-            //let mss = MediaSourceStream::new(Box::new(src), Default::default());
-            //let mut hint = Hint::new();
-            //if let Some(ext) = path.extension() {
-                //hint.with_extension(&ext.to_string_lossy());
-            //}
-            //let meta_opts: MetadataOptions = Default::default();
-            //let fmt_opts: FormatOptions = Default::default();
-            //if let Ok(mut probed) =  symphonia::default::get_probe()
-                //.format(&hint, mss, &fmt_opts, &meta_opts)
-            //{
-                //panic!("{:?}", probed.format.metadata());
-            //};
-        }
-        Ok(())
-    }
-    fn cursor_dir (&self) -> Option<PathBuf> {
-        if self.cursor < self.subdirs.len() {
-            Some(self.dir.join(&self.subdirs[self.cursor]))
-        } else {
-            None
-        }
-    }
-    fn cursor_file (&self) -> Option<PathBuf> {
-        if self.cursor < self.subdirs.len() {
-            return None
-        }
-        let index = self.cursor.saturating_sub(self.subdirs.len());
-        if index < self.files.len() {
-            Some(self.dir.join(&self.files[index]))
-        } else {
-            None
-        }
-    }
-    fn pick (&mut self) -> Usually<bool> {
-        if self.cursor == 0 {
-            if let Some(parent) = self.dir.parent() {
-                self.dir = parent.into();
-                self.rescan()?;
-                self.cursor = 0;
-                return Ok(false)
-            }
-        }
-        if let Some(dir) = self.cursor_dir() {
-            self.dir = dir;
-            self.rescan()?;
-            self.cursor = 0;
-            return Ok(false)
-        }
-        if let Some(path) = self.cursor_file() {
-            let (end, channels) = read_sample_data(&path.to_string_lossy())?;
-            let mut sample = self.sample.write().unwrap();
-            sample.name = path.file_name().unwrap().to_string_lossy().into();
-            sample.end = end;
-            sample.channels = channels;
-            return Ok(true)
-        }
-        return Ok(false)
-    }
-}
-impl<const N: usize> SampleKit<N> {
-    pub fn get (&self, index: usize) -> &Option<Arc<RwLock<Sample>>> {
-        if index < self.0.len() {
-            &self.0[index]
-        } else {
-            &None
-        }
-    }
-}
-impl Sample {
-    pub fn new (name: impl AsRef<str>, start: usize, end: usize, channels: Vec<Vec<f32>>) -> Self {
-        Self {
-            name: name.as_ref().into(),
-            start,
-            end,
-            channels,
-            rate: None,
-            gain: 1.0,
-            color: ItemTheme::random(),
-        }
-    }
-    pub fn play (sample: &Arc<RwLock<Self>>, after: usize, velocity: &u7) -> Voice {
-        Voice {
-            sample: sample.clone(),
-            after,
-            position: sample.read().unwrap().start,
-            velocity: velocity.as_int() as f32 / 127.0,
-        }
-    }
-    pub fn handle_cc (&mut self, controller: u7, value: u7) {
-        let percentage = value.as_int() as f64 / 127.;
-        match controller.as_int() {
-            20 => {
-                self.start = (percentage * self.end as f64) as usize;
-            },
-            21 => {
-                let length = self.channels[0].len();
-                self.end = length.min(
-                    self.start + (percentage * (length as f64 - self.start as f64)) as usize
-                );
-            },
-            22 => { /*attack*/ },
-            23 => { /*decay*/  },
-            24 => {
-                self.gain = percentage as f32 * 2.0;
-            },
-            26 => { /* pan */ }
-            25 => { /* pitch */ }
-            _ => {}
-        }
-    }
-    /// Read WAV from file
-    pub fn read_data (src: &str) -> Usually<(usize, Vec<Vec<f32>>)> {
-        let mut channels: Vec<wavers::Samples<f32>> = vec![];
-        for channel in wavers::Wav::from_path(src)?.channels() {
-            channels.push(channel);
-        }
-        let mut end = 0;
-        let mut data: Vec<Vec<f32>> = vec![];
-        for samples in channels.iter() {
-            let channel = Vec::from(samples.as_ref());
-            end = end.max(channel.len());
-            data.push(channel);
-        }
-        Ok((end, data))
-    }
-    pub fn from_file (path: &PathBuf) -> Usually<Self> {
-        let name = path.file_name().unwrap().to_string_lossy().into();
-        let mut sample = Self { name, ..Default::default() };
-        // Use file extension if present
-        let mut hint = Hint::new();
-        if let Some(ext) = path.extension() {
-            hint.with_extension(&ext.to_string_lossy());
-        }
-        let probed = symphonia::default::get_probe().format(
-            &hint,
-            MediaSourceStream::new(
-                Box::new(File::open(path)?),
-                Default::default(),
-            ),
-            &Default::default(),
-            &Default::default()
-        )?;
-        let mut format = probed.format;
-        let params = &format.tracks().iter()
-            .find(|t| t.codec_params.codec != CODEC_TYPE_NULL)
-            .expect("no tracks found")
-            .codec_params;
-        let mut decoder = get_codecs().make(params, &Default::default())?;
-        loop {
-            match format.next_packet() {
-                Ok(packet) => sample.decode_packet(&mut decoder, packet)?,
-                Err(symphonia::core::errors::Error::IoError(_)) => break decoder.last_decoded(),
-                Err(err) => return Err(err.into()),
-            };
-        };
-        sample.end = sample.channels.iter().fold(0, |l, c|l + c.len());
-        Ok(sample)
-    }
-    fn decode_packet (
-        &mut self, decoder: &mut Box<dyn Decoder>, packet: Packet
-    ) -> Usually<()> {
-        // Decode a packet
-        let decoded = decoder
-            .decode(&packet)
-            .map_err(|e|Box::<dyn std::error::Error>::from(e))?;
-        // Determine sample rate
-        let spec = *decoded.spec();
-        if let Some(rate) = self.rate {
-            if rate != spec.rate as usize {
-                panic!("sample rate changed");
-            }
-        } else {
-            self.rate = Some(spec.rate as usize);
-        }
-        // Determine channel count
-        while self.channels.len() < spec.channels.count() {
-            self.channels.push(vec![]);
-        }
-        // Load sample
-        let mut samples = SampleBuffer::new(
-            decoded.frames() as u64,
-            spec
-        );
-        if samples.capacity() > 0 {
-            samples.copy_interleaved_ref(decoded);
-            for frame in samples.samples().chunks(spec.channels.count()) {
-                for (chan, frame) in frame.iter().enumerate() {
-                    self.channels[chan].push(*frame)
-                }
-            }
-        }
-        Ok(())
-    }
-}
-impl Draw<Tui> for SampleAdd {
-    fn draw (self, _to: &mut Tui) -> Usually<XYWH<u16>> {
-        todo!()
-    }
-}
 
 fn draw_list_item (sample: &Option<Arc<RwLock<Sample>>>) -> String {
     if let Some(sample) = sample {
@@ -596,8 +262,9 @@ fn draw_list_item (sample: &Option<Arc<RwLock<Sample>>>) -> String {
 
 fn draw_viewer (sample: Option<&Arc<RwLock<Sample>>>) -> impl Draw<Tui> + use<'_> {
     let min_db = -64.0;
-    Thunk::new(move|to: &mut Tui|{
-        let XYWH(x, y, width, height) = to.area();
+    thunk(move|to: &mut Tui|{
+        let xywh = to.area().into();
+        let XYWH(x, y, width, height) = xywh;
         let area = Rect { x, y, width, height };
         if let Some(sample) = &sample {
             let sample = sample.read().unwrap();
@@ -631,7 +298,8 @@ fn draw_viewer (sample: Option<&Arc<RwLock<Sample>>>) -> impl Draw<Tui> + use<'_
                         //height as f64 / 2.0,
                         //text.red()
                     //);
-                }).render(area, &mut to.buffer);
+                })
+                .render(area, to.as_mut());
         } else {
             Canvas::default()
                 .x_bounds([0.0, width  as f64])
@@ -644,23 +312,12 @@ fn draw_viewer (sample: Option<&Arc<RwLock<Sample>>>) -> impl Draw<Tui> + use<'_
                         //text.red()
                     //);
                 })
-                .render(area, &mut to.buffer);
+                .render(area, to.as_mut());
         }
+        Ok(Some(xywh))
     })
 }
 
-impl_audio!(Sampler: sampler_jack_process);
-pub(crate) fn sampler_jack_process (state: &mut Sampler, _: &Client, scope: &ProcessScope) -> Control {
-    if let Some(midi_in) = &state.midi_in {
-        for midi in midi_in.port().iter(scope) {
-            sampler_midi_in(&state.samples, &state.voices, midi)
-        }
-    }
-    state.process_audio_out(scope);
-    state.process_audio_in(scope);
-    Control::Continue
-}
-
 /// Create [Voice]s from [Sample]s in response to MIDI input.
 fn sampler_midi_in (
     samples: &SampleKit<128>, voices: &Arc<RwLock<Vec<Voice>>>, RawMidi { time, bytes }: RawMidi
@@ -701,3 +358,50 @@ fn draw_sample (
 fn read_sample_data (_: &str) -> Usually<(usize, Vec<Vec<f32>>)> {
     todo!();
 }
+
+def_command!(SamplerCommand: |sampler: Sampler| {
+    RecordToggle { slot: usize } => {
+        let slot = *slot;
+        let recording = sampler.recording.as_ref().map(|x|x.0);
+        let _ = Self::RecordFinish.act(sampler)?;
+        // autoslice: continue recording at next slot
+        if recording != Some(slot) {
+            Self::RecordBegin { slot }.act(sampler)
+        } else {
+            Ok(None)
+        }
+    },
+    RecordBegin { slot: usize } => {
+        let slot = *slot;
+        sampler.recording = Some((
+            slot,
+            Some(Arc::new(RwLock::new(Sample::new(
+                "Sample", 0, 0, vec![vec![];sampler.audio_ins.len()]
+            ))))
+        ));
+        Ok(None)
+    },
+    RecordFinish => {
+        let _prev_sample = sampler.recording.as_mut().map(|(index, sample)|{
+            std::mem::swap(sample, &mut sampler.samples.0[*index]);
+            sample
+        }); // TODO: undo
+        Ok(None)
+    },
+    RecordCancel => {
+        sampler.recording = None;
+        Ok(None)
+    },
+    PlaySample { slot: usize } => {
+        let slot = *slot;
+        if let Some(ref sample) = sampler.samples.0[slot] {
+            sampler.voices.write().unwrap().push(Sample::play(sample, 0, &u7::from(128)));
+        }
+        Ok(None)
+    },
+    StopSample { slot: usize } => {
+        let _slot = *slot;
+        todo!();
+        //Ok(None)
+    },
+});

src/device/sampler/sample.rs

@@ -0,0 +1,144 @@
+use crate::*;
+
+/// A sound cut.
+///
+/// ```
+/// let sample = tek::Sample::default();
+/// let sample = tek::Sample::new("test", 0, 0, vec![]);
+/// ```
+#[derive(Default, Debug)] pub struct Sample {
+    pub name:     Arc<str>,
+    pub start:    usize,
+    pub end:      usize,
+    pub channels: Vec<Vec<f32>>,
+    pub rate:     Option<usize>,
+    pub gain:     f32,
+    pub color:    ItemTheme,
+}
+
+impl Sample {
+    pub fn new (name: impl AsRef<str>, start: usize, end: usize, channels: Vec<Vec<f32>>) -> Self {
+        Self {
+            name: name.as_ref().into(),
+            start,
+            end,
+            channels,
+            rate: None,
+            gain: 1.0,
+            color: ItemTheme::random(),
+        }
+    }
+    pub fn play (sample: &Arc<RwLock<Self>>, after: usize, velocity: &u7) -> Voice {
+        Voice {
+            sample: sample.clone(),
+            after,
+            position: sample.read().unwrap().start,
+            velocity: velocity.as_int() as f32 / 127.0,
+        }
+    }
+    pub fn handle_cc (&mut self, controller: u7, value: u7) {
+        let percentage = value.as_int() as f64 / 127.;
+        match controller.as_int() {
+            20 => {
+                self.start = (percentage * self.end as f64) as usize;
+            },
+            21 => {
+                let length = self.channels[0].len();
+                self.end = length.min(
+                    self.start + (percentage * (length as f64 - self.start as f64)) as usize
+                );
+            },
+            22 => { /*attack*/ },
+            23 => { /*decay*/  },
+            24 => {
+                self.gain = percentage as f32 * 2.0;
+            },
+            26 => { /* pan */ }
+            25 => { /* pitch */ }
+            _ => {}
+        }
+    }
+    /// Read WAV from file
+    pub fn read_data (src: &str) -> Usually<(usize, Vec<Vec<f32>>)> {
+        let mut channels: Vec<wavers::Samples<f32>> = vec![];
+        for channel in wavers::Wav::from_path(src)?.channels() {
+            channels.push(channel);
+        }
+        let mut end = 0;
+        let mut data: Vec<Vec<f32>> = vec![];
+        for samples in channels.iter() {
+            let channel = Vec::from(samples.as_ref());
+            end = end.max(channel.len());
+            data.push(channel);
+        }
+        Ok((end, data))
+    }
+    pub fn from_file (path: &PathBuf) -> Usually<Self> {
+        let name = path.file_name().unwrap().to_string_lossy().into();
+        let mut sample = Self { name, ..Default::default() };
+        // Use file extension if present
+        let mut hint = Hint::new();
+        if let Some(ext) = path.extension() {
+            hint.with_extension(&ext.to_string_lossy());
+        }
+        let probed = symphonia::default::get_probe().format(
+            &hint,
+            MediaSourceStream::new(
+                Box::new(File::open(path)?),
+                Default::default(),
+            ),
+            &Default::default(),
+            &Default::default()
+        )?;
+        let mut format = probed.format;
+        let params = &format.tracks().iter()
+            .find(|t| t.codec_params.codec != CODEC_TYPE_NULL)
+            .expect("no tracks found")
+            .codec_params;
+        let mut decoder = get_codecs().make(params, &Default::default())?;
+        loop {
+            match format.next_packet() {
+                Ok(packet) => sample.decode_packet(&mut decoder, packet)?,
+                Err(symphonia::core::errors::Error::IoError(_)) => break decoder.last_decoded(),
+                Err(err) => return Err(err.into()),
+            };
+        };
+        sample.end = sample.channels.iter().fold(0, |l, c|l + c.len());
+        Ok(sample)
+    }
+    fn decode_packet (
+        &mut self, decoder: &mut Box<dyn Decoder>, packet: Packet
+    ) -> Usually<()> {
+        // Decode a packet
+        let decoded = decoder
+            .decode(&packet)
+            .map_err(|e|Box::<dyn std::error::Error>::from(e))?;
+        // Determine sample rate
+        let spec = *decoded.spec();
+        if let Some(rate) = self.rate {
+            if rate != spec.rate as usize {
+                panic!("sample rate changed");
+            }
+        } else {
+            self.rate = Some(spec.rate as usize);
+        }
+        // Determine channel count
+        while self.channels.len() < spec.channels.count() {
+            self.channels.push(vec![]);
+        }
+        // Load sample
+        let mut samples = SampleBuffer::new(
+            decoded.frames() as u64,
+            spec
+        );
+        if samples.capacity() > 0 {
+            samples.copy_interleaved_ref(decoded);
+            for frame in samples.samples().chunks(spec.channels.count()) {
+                for (chan, frame) in frame.iter().enumerate() {
+                    self.channels[chan].push(*frame)
+                }
+            }
+        }
+        Ok(())
+    }
+}

src/device/sampler/sample_add.rs

@@ -0,0 +1,122 @@
+use crate::{*, device::sampler::*};
+
+#[derive(Default, Debug)] pub struct SampleAdd {
+    pub exited:  bool,
+    pub dir:     PathBuf,
+    pub subdirs: Vec<OsString>,
+    pub files:   Vec<OsString>,
+    pub cursor:  usize,
+    pub offset:  usize,
+    pub sample:  Arc<RwLock<Sample>>,
+    pub voices:  Arc<RwLock<Vec<Voice>>>,
+    pub _search: Option<String>,
+}
+
+impl_draw!(|self: SampleAdd, to: Tui|{ todo!() });
+
+impl SampleAdd {
+    fn exited (&self) -> bool {
+        self.exited
+    }
+    fn exit (&mut self) {
+        self.exited = true
+    }
+    pub fn new (
+        sample: &Arc<RwLock<Sample>>,
+        voices: &Arc<RwLock<Vec<Voice>>>
+    ) -> Usually<Self> {
+        let dir = std::env::current_dir()?;
+        let (subdirs, files) = scan(&dir)?;
+        Ok(Self {
+            exited: false,
+            dir,
+            subdirs,
+            files,
+            cursor: 0,
+            offset: 0,
+            sample: sample.clone(),
+            voices: voices.clone(),
+            _search: None
+        })
+    }
+    fn rescan (&mut self) -> Usually<()> {
+        scan(&self.dir).map(|(subdirs, files)|{
+            self.subdirs = subdirs;
+            self.files = files;
+        })
+    }
+    fn prev (&mut self) {
+        self.cursor = self.cursor.saturating_sub(1);
+    }
+    fn next (&mut self) {
+        self.cursor = self.cursor + 1;
+    }
+    fn try_preview (&mut self) -> Usually<()> {
+        if let Some(path) = self.cursor_file() {
+            if let Ok(sample) = Sample::from_file(&path) {
+                *self.sample.write().unwrap() = sample;
+                self.voices.write().unwrap().push(
+                    Sample::play(&self.sample, 0, &u7::from(100u8))
+                );
+            }
+            //load_sample(&path)?;
+            //let src = std::fs::File::open(&path)?;
+            //let mss = MediaSourceStream::new(Box::new(src), Default::default());
+            //let mut hint = Hint::new();
+            //if let Some(ext) = path.extension() {
+                //hint.with_extension(&ext.to_string_lossy());
+            //}
+            //let meta_opts: MetadataOptions = Default::default();
+            //let fmt_opts: FormatOptions = Default::default();
+            //if let Ok(mut probed) =  symphonia::default::get_probe()
+                //.format(&hint, mss, &fmt_opts, &meta_opts)
+            //{
+                //panic!("{:?}", probed.format.metadata());
+            //};
+        }
+        Ok(())
+    }
+    fn cursor_dir (&self) -> Option<PathBuf> {
+        if self.cursor < self.subdirs.len() {
+            Some(self.dir.join(&self.subdirs[self.cursor]))
+        } else {
+            None
+        }
+    }
+    fn cursor_file (&self) -> Option<PathBuf> {
+        if self.cursor < self.subdirs.len() {
+            return None
+        }
+        let index = self.cursor.saturating_sub(self.subdirs.len());
+        if index < self.files.len() {
+            Some(self.dir.join(&self.files[index]))
+        } else {
+            None
+        }
+    }
+    fn pick (&mut self) -> Usually<bool> {
+        if self.cursor == 0 {
+            if let Some(parent) = self.dir.parent() {
+                self.dir = parent.into();
+                self.rescan()?;
+                self.cursor = 0;
+                return Ok(false)
+            }
+        }
+        if let Some(dir) = self.cursor_dir() {
+            self.dir = dir;
+            self.rescan()?;
+            self.cursor = 0;
+            return Ok(false)
+        }
+        if let Some(path) = self.cursor_file() {
+            let (end, channels) = read_sample_data(&path.to_string_lossy())?;
+            let mut sample = self.sample.write().unwrap();
+            sample.name = path.file_name().unwrap().to_string_lossy().into();
+            sample.end = end;
+            sample.channels = channels;
+            return Ok(true)
+        }
+        return Ok(false)
+    }
+}

src/device/sampler/sample_kit.rs

@@ -0,0 +1,26 @@
+use crate::*;
+
+/// Collection of samples, one per slot, fixed number of slots.
+///
+/// History: Separated to cleanly implement [Default].
+///
+/// ```
+/// let samples = tek::SampleKit([None, None, None, None]);
+/// ```
+#[derive(Debug)] pub struct SampleKit <const N: usize> (
+    pub [Option<Arc<RwLock<Sample>>>;N]
+);
+
+impl<const N: usize> Default for SampleKit<N> {
+    fn default () -> Self { Self([const { None }; N]) }
+}
+
+impl<const N: usize> SampleKit<N> {
+    pub fn get (&self, index: usize) -> &Option<Arc<RwLock<Sample>>> {
+        if index < self.0.len() {
+            &self.0[index]
+        } else {
+            &None
+        }
+    }
+}

src/device/sampler/voice.rs

@@ -0,0 +1,29 @@
+use crate::*;
+
+/// A currently playing instance of a sample.
+#[derive(Default, Debug, Clone)] pub struct Voice {
+    pub sample:   Arc<RwLock<Sample>>,
+    pub after:    usize,
+    pub position: usize,
+    pub velocity: f32,
+}
+
+impl Iterator for Voice {
+    type Item = [f32;2];
+    fn next (&mut self) -> Option<Self::Item> {
+        if self.after > 0 {
+            self.after -= 1;
+            return Some([0.0, 0.0])
+        }
+        let sample = self.sample.read().unwrap();
+        if self.position < sample.end {
+            let position = self.position;
+            self.position += 1;
+            return sample.channels[0].get(position).map(|_amplitude|[
+                sample.channels[0][position] * self.velocity * sample.gain,
+                sample.channels[0][position] * self.velocity * sample.gain,
+            ])
+        }
+        None
+    }
+}

src/device/sequence.rs

@@ -0,0 +1,646 @@
+use crate::{*, clock::*, device::*};
+
+impl <T: AsRef<Sequencer>+AsMut<Sequencer>> HasSequencer for T {}
+
+/// A MIDI sequence.
+///
+/// ```
+/// let clip = tek::MidiClip::default();
+/// ```
+#[derive(Debug, Clone, Default)] pub struct MidiClip {
+    pub uuid:        uuid::Uuid,
+    /// Name of clip
+    pub name:        Arc<str>,
+    /// Temporal resolution in pulses per quarter note
+    pub ppq:         usize,
+    /// Length of clip in pulses
+    pub length:      usize,
+    /// Notes in clip
+    pub notes:       MidiData,
+    /// Whether to loop the clip or play it once
+    pub looped:      bool,
+    /// Start of loop
+    pub loop_start:  usize,
+    /// Length of loop
+    pub loop_length: usize,
+    /// All notes are displayed with minimum length
+    pub percussive:  bool,
+    /// Identifying color of clip
+    pub color:       ItemTheme,
+}
+
+/// Contains state for playing a clip
+///
+/// ```
+/// let clip = tek::MidiClip::default();
+/// println!("Empty clip: {clip:?}");
+///
+/// let clip = tek::MidiClip::stop_all();
+/// println!("Panic clip: {clip:?}");
+///
+/// let mut clip = tek::MidiClip::new("clip", true, 1, None, None);
+/// clip.set_length(96);
+/// clip.toggle_loop();
+/// clip.record_event(12, midly::MidiMessage::NoteOn { key: 36.into(), vel: 100.into() });
+/// assert!(clip.contains_note_on(36.into(), 6, 18));
+/// assert_eq!(&clip.notes, &clip.duplicate().notes);
+///
+/// let clip = std::sync::Arc::new(clip);
+/// assert_eq!(clip.clone(), clip);
+///
+/// let sequencer = tek::Sequencer::default();
+/// println!("{sequencer:?}");
+/// ```
+pub struct Sequencer {
+    /// State of clock and playhead
+    #[cfg(feature = "clock")] pub clock: Clock,
+    /// Start time and clip being played
+    #[cfg(feature = "clip")] pub play_clip: Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>,
+    /// Start time and next clip
+    #[cfg(feature = "clip")] pub next_clip: Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>,
+    /// Record from MIDI ports to current sequence.
+    #[cfg(feature = "port")] pub midi_ins: Vec<MidiInput>,
+    /// Play from current sequence to MIDI ports
+    #[cfg(feature = "port")] pub midi_outs: Vec<MidiOutput>,
+    /// Play input through output.
+    pub monitoring: bool,
+    /// Write input to sequence.
+    pub recording:  bool,
+    /// Overdub input to sequence.
+    pub overdub:    bool,
+    /// Send all notes off
+    pub reset:      bool, // TODO?: after Some(nframes)
+    /// Notes currently held at input
+    pub notes_in:   Arc<RwLock<[bool; 128]>>,
+    /// Notes currently held at output
+    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>>>,
+}
+
+
+pub trait HasPlayClip: HasClock {
+    fn reset (&self) -> bool;
+    fn reset_mut (&mut self) -> &mut bool;
+    fn play_clip (&self) -> &Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>;
+    fn play_clip_mut (&mut self) -> &mut Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>;
+    fn next_clip (&self) -> &Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>;
+    fn next_clip_mut (&mut self) -> &mut Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>;
+
+    fn pulses_since_start (&self) -> Option<f64> {
+        if let Some((started, Some(_))) = self.play_clip().as_ref() {
+            let elapsed = self.clock().playhead.pulse.get() - started.pulse.get();
+            return Some(elapsed)
+        }
+        None
+    }
+
+    fn pulses_since_start_looped (&self) -> Option<(f64, f64)> {
+        if let Some((started, Some(clip))) = self.play_clip().as_ref() {
+            let elapsed = self.clock().playhead.pulse.get() - started.pulse.get();
+            let length  = clip.read().unwrap().length.max(1); // prevent div0 on empty clip
+            let times   = (elapsed as usize / length) as f64;
+            let elapsed = (elapsed as usize % length) as f64;
+            return Some((times, elapsed))
+        }
+        None
+    }
+
+    fn enqueue_next (&mut self, clip: Option<&Arc<RwLock<MidiClip>>>) {
+        *self.next_clip_mut() = Some((self.clock().next_launch_instant(), clip.cloned()));
+        *self.reset_mut() = true;
+    }
+
+    fn play_status (&self) -> impl Draw<Tui> {
+        let (name, color): (Arc<str>, ItemTheme) = if let Some((_, Some(clip))) = self.play_clip() {
+            let MidiClip { ref name, color, .. } = *clip.read().unwrap();
+            (name.clone(), color)
+        } else {
+            ("".into(), ItemTheme::G[64].into())
+        };
+        field_v(color, "Now:", format!("{} {}", self.play_status_time(), name))
+    }
+
+    fn play_status_time (&self) -> String {
+        self.pulses_since_start_looped()
+            .map(|(times, time)|format!("{:>3}x {:>}", times+1.0, self.clock().timebase.format_beats_1(time)))
+            .unwrap_or_else(||String::from("        "))
+            .into()
+    }
+
+    fn next_status (&self) -> impl Draw<Tui> {
+        let mut time: Arc<str> = String::from("--.-.--").into();
+        let mut name: Arc<str> = String::from("").into();
+        let mut color = ItemTheme::G[64];
+        let clock = self.clock();
+        if let Some((t, Some(clip))) = self.next_clip() {
+            let clip = clip.read().unwrap();
+            name  = clip.name.clone();
+            color = clip.color.clone();
+            time  = {
+                let target  = t.pulse.get();
+                let current = clock.playhead.pulse.get();
+                if target > current {
+                    let remaining = target - current;
+                    format!("-{:>}", clock.timebase.format_beats_1(remaining))
+                } else {
+                    String::new()
+                }
+            }.into()
+        } else if let Some((t, Some(clip))) = self.play_clip() {
+            let clip = clip.read().unwrap();
+            if clip.looped {
+                name  = clip.name.clone();
+                color = clip.color.clone();
+                let target  = t.pulse.get() + clip.length as f64;
+                let current = clock.playhead.pulse.get();
+                if target > current {
+                    time = format!("-{:>}", clock.timebase.format_beats_0(target - current)).into()
+                }
+            } else {
+                name  = "Stop".to_string().into();
+            }
+        };
+        field_v(color, "Next:", format!("{} {}", time, name))
+    }
+}
+
+pub trait MidiMonitor: HasMidiIns + HasMidiBuffers {
+    /// Input note flags.
+    fn notes_in (&self) -> &Arc<RwLock<[bool;128]>>;
+    /// Current monitoring status.
+    fn monitoring (&self) -> bool;
+    /// Mutable monitoring status.
+    fn monitoring_mut (&mut self) -> &mut bool;
+    /// Enable or disable monitoring.
+    fn toggle_monitor (&mut self) { *self.monitoring_mut() = !self.monitoring(); }
+    /// Perform monitoring.
+    fn monitor (&mut self, _scope: &ProcessScope) { /* do nothing by default */ }
+}
+
+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>>>,
+    ) {
+        if let Some(clip) = clip {
+            let sample0    = scope.last_frame_time() as usize;
+            let start      = started.sample.get() as usize;
+            let _recording = self.recording();
+            let timebase   = self.clock().timebase().clone();
+            let quant      = self.clock().quant.get();
+            let mut clip   = clip.write().unwrap();
+            let length     = clip.length;
+            for input in self.midi_ins_mut().iter() {
+                for (sample, event, _bytes) in parse_midi_input(input.port().iter(scope)) {
+                    if let LiveEvent::Midi { message, .. } = event {
+                        clip.record_event({
+                            let sample    = (sample0 + sample - start) as f64;
+                            let pulse     = timebase.samples_to_pulse(sample);
+                            let quantized = (pulse / quant).round() * quant;
+                            quantized as usize % length
+                        }, message);
+                    }
+                }
+            }
+        }
+    }
+
+    fn record_next (&mut self) {
+        // TODO switch to next clip and record into it
+    }
+}
+
+pub type MidiData = Vec<Vec<MidiMessage>>;
+pub type ClipPool = Vec<Arc<RwLock<MidiClip>>>;
+pub type CollectedMidiInput<'a> = Vec<Vec<(u32, Result<LiveEvent<'a>, MidiError>)>>;
+
+pub trait HasClips {
+    fn clips <'a> (&'a self) -> std::sync::RwLockReadGuard<'a, ClipPool>;
+    fn clips_mut <'a> (&'a self) -> std::sync::RwLockWriteGuard<'a, ClipPool>;
+    fn add_clip (&self) -> (usize, Arc<RwLock<MidiClip>>) {
+        let clip = Arc::new(RwLock::new(MidiClip::new("Clip", true, 384, None, None)));
+        self.clips_mut().push(clip.clone());
+        (self.clips().len() - 1, clip)
+    }
+}
+
+pub trait HasMidiClip {
+    fn clip (&self) -> Option<Arc<RwLock<MidiClip>>>;
+}
+
+pub trait HasSequencer: AsRef<Sequencer> + AsMut<Sequencer> {
+    fn sequencer_mut (&mut self) -> &mut Sequencer { self.as_mut() }
+    fn sequencer     (&self)     -> &Sequencer     { self.as_ref() }
+}
+
+pub trait HasMidiBuffers {
+    fn note_buf_mut (&mut self) -> &mut Vec<u8>;
+    fn midi_buf_mut (&mut self) -> &mut Vec<Vec<Vec<u8>>>;
+}
+
+impl MidiClip {
+    pub fn new (
+        name:    impl AsRef<str>,
+        looped:  bool,
+        length:  usize,
+        notes:   Option<MidiData>,
+        color:   Option<ItemTheme>,
+    ) -> Self {
+        Self {
+            uuid:        uuid::Uuid::new_v4(),
+            name:        name.as_ref().into(),
+            ppq:         PPQ,
+            length,
+            notes:       notes.unwrap_or(vec![Vec::with_capacity(16);length]),
+            looped,
+            loop_start:  0,
+            loop_length: length,
+            percussive:  true,
+            color:       color.unwrap_or_else(ItemTheme::random)
+        }
+    }
+    pub fn count_midi_messages (&self) -> usize {
+        let mut count = 0;
+        for tick in self.notes.iter() {
+            count += tick.len();
+        }
+        count
+    }
+    pub fn set_length (&mut self, length: usize) {
+        self.length = length;
+        self.notes  = vec![Vec::with_capacity(16);length];
+    }
+    pub fn duplicate (&self) -> Self {
+        let mut clone = self.clone();
+        clone.uuid = uuid::Uuid::new_v4();
+        clone
+    }
+    pub fn toggle_loop (&mut self) { self.looped = !self.looped; }
+    pub fn record_event (&mut self, pulse: usize, message: MidiMessage) {
+        if pulse >= self.length { panic!("extend clip first") }
+        self.notes[pulse].push(message);
+    }
+    /// Check if a range `start..end` contains MIDI Note On `k`
+    pub fn contains_note_on (&self, k: u7, start: usize, end: usize) -> bool {
+        for events in self.notes[start.max(0)..end.min(self.notes.len())].iter() {
+            for event in events.iter() {
+                if let MidiMessage::NoteOn {key,..} = event { if *key == k { return true } }
+            }
+        }
+        false
+    }
+    pub fn stop_all () -> Self {
+        Self::new(
+            "Stop",
+            false,
+            1,
+            Some(vec![vec![MidiMessage::Controller {
+                controller: 123.into(),
+                value: 0.into()
+            }]]),
+            Some(ItemColor::from_tui(Color::Rgb(32, 32, 32)).into())
+        )
+    }
+}
+
+impl PartialEq for MidiClip {
+    fn eq (&self, other: &Self) -> bool {
+        self.uuid == other.uuid
+    }
+}
+
+impl Eq for MidiClip {}
+
+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!() }
+}
+impl_has!(Sequencer:       |self: Track|           self.sequencer);
+impl_has!(Clock:           |self: Sequencer|       self.clock);
+impl_has!(Vec<MidiInput>:  |self: Sequencer|       self.midi_ins);
+impl_has!(Vec<MidiOutput>: |self: Sequencer|       self.midi_outs);
+impl_default!(Sequencer: Self {
+    clock:      Clock::default(),
+    play_clip:  None,
+    next_clip:  None,
+    midi_ins:   vec![],
+    midi_outs:  vec![],
+    recording:  false,
+    monitoring: true,
+    overdub:    false,
+    notes_in:   RwLock::new([false;128]).into(),
+    notes_out:  RwLock::new([false;128]).into(),
+    note_buf:   vec![0;8],
+    midi_buf:   vec![],
+    reset:      true,
+});
+impl Sequencer {
+    pub fn new (
+        name:      impl AsRef<str>,
+        jack:      &Jack<'static>,
+        #[cfg(feature = "clock")] clock:     Option<&Clock>,
+        #[cfg(feature = "clip")] clip:      Option<&Arc<RwLock<MidiClip>>>,
+        #[cfg(feature = "port")] midi_from: &[Connect],
+        #[cfg(feature = "port")] midi_to:   &[Connect],
+    ) -> Usually<Self> {
+        let _name = name.as_ref();
+        #[cfg(feature = "clock")] let clock = clock.cloned().unwrap_or_default();
+        Ok(Self {
+            reset:     true,
+            notes_in:  RwLock::new([false;128]).into(),
+            notes_out: RwLock::new([false;128]).into(),
+            #[cfg(feature = "port")] midi_ins:  vec![MidiInput::new(jack,  &format!("M/{}", name.as_ref()), midi_from)?,],
+            #[cfg(feature = "port")] midi_outs: vec![MidiOutput::new(jack, &format!("{}/M", name.as_ref()), midi_to)?,  ],
+            #[cfg(feature = "clip")] play_clip: clip.map(|clip|(Moment::zero(&clock.timebase), Some(clip.clone()))),
+            #[cfg(feature = "clock")] clock,
+            ..Default::default()
+        })
+    }
+    fn process_rolling (&mut self, scope: &ProcessScope) -> Control {
+        self.process_clear(scope, false);
+        // Write chunk of clip to output, handle switchover
+        if self.process_playback(scope) {
+            self.process_switchover(scope);
+        }
+        // Monitor input to output
+        self.process_monitoring(scope);
+        // Record and/or monitor input
+        self.process_recording(scope);
+        // Emit contents of MIDI buffers to JACK MIDI output ports.
+        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
+    }
+    fn process_monitoring (&mut self, scope: &ProcessScope) {
+        let notes_in = self.notes_in().clone(); // For highlighting keys and note repeat
+        let monitoring = self.monitoring();
+        for input in self.midi_ins.iter() {
+            for (sample, event, bytes) in input.parsed(scope) {
+                if let LiveEvent::Midi { message, .. } = event {
+                    if monitoring {
+                        self.midi_buf[sample].push(bytes.to_vec());
+                    }
+                    // FIXME: don't lock on every event!
+                    update_keys(&mut notes_in.write().unwrap(), &message);
+                }
+            }
+        }
+    }
+    /// Clear the section of the output buffer that we will be using,
+    /// 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);
+        }
+        if let Some((started, ref clip)) = self.play_clip.clone() {
+            self.record_clip(scope, started, clip);
+        }
+        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(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);
+            }
+        }
+    }
+}
+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 }
+}
+impl std::fmt::Debug for Sequencer {
+    fn fmt (&self, f: &mut Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
+        f.debug_struct("Sequencer")
+            .field("clock",     &self.clock)
+            .field("play_clip", &self.play_clip)
+            .field("next_clip", &self.next_clip)
+            .finish()
+    }
+}
+impl MidiMonitor for Sequencer {
+    fn monitoring     (&self)     -> bool      { self.monitoring }
+    fn monitoring_mut (&mut self) -> &mut bool { &mut self.monitoring }
+    fn notes_in       (&self)     -> &Arc<RwLock<[bool; 128]>> { &self.notes_in }
+}
+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 }
+}
+#[cfg(feature="clip")] impl HasPlayClip for Sequencer {
+    fn reset (&self) -> bool { self.reset }
+    fn reset_mut (&mut self) -> &mut bool { &mut self.reset }
+    fn play_clip (&self) -> &Option<(Moment, Option<Arc<RwLock<MidiClip>>>)> {
+        &self.play_clip
+    }
+    fn play_clip_mut (&mut self) -> &mut Option<(Moment, Option<Arc<RwLock<MidiClip>>>)> {
+        &mut self.play_clip
+    }
+    fn next_clip (&self) -> &Option<(Moment, Option<Arc<RwLock<MidiClip>>>)> {
+        &self.next_clip
+    }
+    fn next_clip_mut (&mut self) -> &mut Option<(Moment, Option<Arc<RwLock<MidiClip>>>)> {
+        &mut self.next_clip
+    }
+}
+/// JACK process callback for a sequencer's clip sequencer/recorder.
+impl Audio for Sequencer {
+    fn process (&mut self, _: &Client, scope: &ProcessScope) -> Control {
+        if self.clock().is_rolling() {
+            self.process_rolling(scope)
+        } else {
+            self.process_stopped(scope)
+        }
+    }
+}
+
+impl Iterator for Ticker {
+    type Item = (usize, usize);
+    fn next (&mut self) -> Option<Self::Item> {
+        loop {
+            if self.sample > self.end { return None }
+            let spp    = self.spp;
+            let sample = self.sample as f64;
+            let start  = self.start;
+            let end    = self.end;
+            self.sample += 1;
+            //println!("{spp} {sample} {start} {end}");
+            let jitter = sample.rem_euclid(spp); // ramps
+            let next_jitter = (sample + 1.0).rem_euclid(spp);
+            if jitter > next_jitter { // at crossing:
+                let time = (sample as usize) % (end as usize-start as usize);
+                let tick = (sample / spp) as usize;
+                return Some((time, tick))
+            }
+        }
+    }
+}
+
+pub fn to_key (note: usize) -> &'static str {
+    match note % 12 {
+        11 | 9 | 7 | 5 | 4 | 2 | 0 => "████▌",
+        10 | 8 | 6 | 3 | 1         => "     ",
+        _  => unreachable!(),
+    }
+}
+
+pub(crate) fn note_y_iter (note_lo: usize, note_hi: usize, y0: u16)
+    -> impl Iterator<Item=(usize, u16, usize)>
+{
+    (note_lo..=note_hi).rev().enumerate().map(move|(y, n)|(y, y0 + y as u16, n))
+}
+
+/// Return boxed iterator of MIDI events
+pub fn parse_midi_input <'a> (input: ::tengri::jack::MidiIter<'a>)
+    -> Box<dyn Iterator<Item=(usize, LiveEvent<'a>, &'a [u8])> + 'a>
+{
+    Box::new(input.map(|::tengri::jack::RawMidi { time, bytes }|(
+        time as usize,
+        LiveEvent::parse(bytes).unwrap(),
+        bytes
+    )))
+}
+
+/// Add "all notes off" to the start of a buffer.
+pub fn all_notes_off (output: &mut [Vec<Vec<u8>>]) {
+    let mut buf = vec![];
+    let msg = MidiMessage::Controller { controller: 123.into(), value: 0.into() };
+    let evt = LiveEvent::Midi { channel: 0.into(), message: msg };
+    evt.write(&mut buf).unwrap();
+    output[0].push(buf);
+}
+
+/// 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; },
+        _ => {}
+    }
+}
+
+/// Returns the next shorter length
+pub fn note_duration_prev (pulses: usize) -> usize {
+    for (length, _) in NOTE_DURATIONS.iter().rev() { if *length < pulses { return *length } }
+    pulses
+}
+
+/// Returns the next longer length
+pub fn note_duration_next (pulses: usize) -> usize {
+    for (length, _) in NOTE_DURATIONS.iter() { if *length > pulses { return *length } }
+    pulses
+}
+
+pub fn note_duration_to_name (pulses: usize) -> &'static str {
+    for (length, name) in NOTE_DURATIONS.iter() { if *length == pulses { return name } }
+    ""
+}
+
+pub fn note_pitch_to_name (n: usize) -> &'static str {
+    if n > 127 {
+        panic!("to_note_name({n}): must be 0-127");
+    }
+    NOTE_NAMES[n]
+}

src/mix.rs

@@ -1,123 +0,0 @@
-use crate::*;
-#[derive(Debug, Default)] pub enum MeteringMode {
-    #[default] Rms,
-    Log10,
-}
-
-#[derive(Debug, Default, Clone)]
-pub struct Log10Meter(pub f32);
-
-#[derive(Debug, Default, Clone)]
-pub struct RmsMeter(pub f32);
-
-#[derive(Debug, Default)]
-pub enum MixingMode {
-    #[default] Summing,
-    Average,
-}
-
-#[cfg(test)] mod test_view_meter {
-    use super::*;
-    use proptest::prelude::*;
-    proptest! {
-
-        #[test] fn proptest_view_meter (
-            label in "\\PC*", value in f32::MIN..f32::MAX
-        ) {
-            let _ = view_meter(&label, value);
-        }
-
-        #[test] fn proptest_view_meters (
-            value1 in f32::MIN..f32::MAX,
-            value2 in f32::MIN..f32::MAX
-        ) {
-            let _ = view_meters(&[value1, value2]);
-        }
-    }
-}
-
-        impl Draw<Tui> for RmsMeter {
-            fn draw(self, to: &mut Tui) -> Usually<XYWH<u16>> {
-                let XYWH(x, y, w, h) = to.area();
-                let signal = f32::max(0.0, f32::min(100.0, self.0.abs()));
-                let v = (signal * h as f32).ceil() as u16;
-                let y2 = y + h;
-                //to.blit(&format!("\r{v} {} {signal}", self.0), x * 30, y, Some(Style::default()));
-                for y in y..(y + v) {
-                    for x in x..(x + w) {
-                        to.blit(&"▌", x, y2.saturating_sub(y), Some(Style::default().green()));
-                    }
-                }
-            }
-        }
-
-        impl Draw<Tui> for Log10Meter {
-            fn draw(self, to: &mut Tui) -> Usually<XYWH<u16>> {
-                let XYWH(x, y, w, h) = to.area();
-                let signal = 100.0 - f32::max(0.0, f32::min(100.0, self.0.abs()));
-                let v = (signal * h as f32 / 100.0).ceil() as u16;
-                let y2 = y + h;
-                //to.blit(&format!("\r{v} {} {signal}", self.0), x * 20, y, None);
-                for y in y..(y + v) {
-                    for x in x..(x + w) {
-                        to.blit(&"▌", x, y2 - y, Some(Style::default().green()));
-                    }
-                }
-            }
-        }
-
-        fn draw_meters (meters: &[f32]) -> impl Draw<Tui> + use<'_> {
-            Tui::bg(Black, w_exact(2, iter_east(1, ||meters.iter(), |value, _index|{
-                h_full(RmsMeter(*value))
-            })))
-        }
-
-pub fn mix_summing <const N: usize> (
-    buffer: &mut [Vec<f32>], gain: f32, frames: usize, mut next: impl FnMut()->Option<[f32;N]>,
-) -> bool {
-    let channels = buffer.len();
-    for index in 0..frames {
-        if let Some(frame) = next() {
-            for (channel, sample) in frame.iter().enumerate() {
-                let channel = channel % channels;
-                buffer[channel][index] += sample * gain;
-            }
-        } else {
-            return false
-        }
-    }
-    true
-}
-
-pub fn mix_average <const N: usize> (
-    buffer: &mut [Vec<f32>], gain: f32, frames: usize, mut next: impl FnMut()->Option<[f32;N]>,
-) -> bool {
-    let channels = buffer.len();
-    for index in 0..frames {
-        if let Some(frame) = next() {
-            for (channel, sample) in frame.iter().enumerate() {
-                let channel = channel % channels;
-                let value = buffer[channel][index];
-                buffer[channel][index] = (value + sample * gain) / 2.0;
-            }
-        } else {
-            return false
-        }
-    }
-    true
-}
-
-pub fn to_log10 (samples: &[f32]) -> f32 {
-    let total: f32 = samples.iter().map(|x|x.abs()).sum();
-    let count = samples.len() as f32;
-    10. * (total / count).log10()
-}
-
-
-pub fn to_rms (samples: &[f32]) -> f32 {
-    let sum = samples.iter()
-        .map(|s|*s)
-        .reduce(|sum, sample|sum + sample.abs())
-        .unwrap_or(0.0);
-    (sum / samples.len() as f32).sqrt()
-}

src/tek.rs

@@ -1,975 +1,38 @@
 #![allow(clippy::unit_arg)]
 #![feature(
-    adt_const_params, associated_type_defaults, closure_lifetime_binder,
-    impl_trait_in_assoc_type, trait_alias, type_alias_impl_trait, type_changing_struct_update
+    adt_const_params,
+    anonymous_lifetime_in_impl_trait,
+    impl_trait_in_assoc_type,
+    trait_alias,
+    type_changing_struct_update
 )]
 
-/// Implement an arithmetic operation for a unit of time
-#[macro_export] macro_rules! impl_op {
-    ($T:ident, $Op:ident, $method:ident, |$a:ident,$b:ident|{$impl:expr}) => {
-        impl $Op<Self> for $T {
-            type Output = Self; #[inline] fn $method (self, other: Self) -> Self::Output {
-                let $a = self.get(); let $b = other.get(); Self($impl.into())
-            }
-        }
-        impl $Op<usize> for $T {
-            type Output = Self; #[inline] fn $method (self, other: usize) -> Self::Output {
-                let $a = self.get(); let $b = other as f64; Self($impl.into())
-            }
-        }
-        impl $Op<f64> for $T {
-            type Output = Self; #[inline] fn $method (self, other: f64) -> Self::Output {
-                let $a = self.get(); let $b = other; Self($impl.into())
-            }
-        }
-    }
-}
-
-#[macro_export] macro_rules! impl_has_clips {
-    (|$self:ident:$Struct:ident$(<$($L:lifetime),*$($T:ident$(:$U:path)?),*>)?|$cb:expr) => {
-        impl $(<$($L),*$($T $(: $U)?),*>)? HasClips for $Struct $(<$($L),*$($T),*>)? {
-            fn clips <'a> (&'a $self) -> std::sync::RwLockReadGuard<'a, ClipPool>      {
-                $cb.read().unwrap()
-            }
-            fn clips_mut <'a> (&'a $self) -> std::sync::RwLockWriteGuard<'a, ClipPool> {
-                $cb.write().unwrap()
-            }
-        }
-    }
-}
-
-pub mod arrange;
-pub mod bind;
-pub mod browse;
-pub mod cli;
-pub mod clock;
-pub mod config;
-pub mod device;
-pub mod dialog;
-pub mod menu;
-pub mod mix;
-pub mod mode;
-pub mod sample;
-pub mod sequence;
-pub mod select;
-pub mod view;
-
-#[cfg(feature = "plugin")] pub mod plugin;
-
-use clap::{self, Parser, Subcommand};
-use builder_pattern::Builder;
-use self::{
-    arrange::*, clock::*, dialog::*, browse::*, select::*, sequence::*, device::*,
-    config::*, mode::*, view::*, bind::*, sample::*, menu::*
-};
-
-extern crate xdg;
-pub(crate) use ::xdg::BaseDirectories;
 pub extern crate atomic_float;
-pub(crate) use atomic_float::AtomicF64;
-//pub extern crate jack;
-//pub(crate) use ::jack::{*, contrib::{*, ClosureProcessHandler}};
+pub extern crate xdg;
 pub extern crate midly;
-pub(crate) use ::midly::{Smf, TrackEventKind, MidiMessage, Error as MidiError, num::*, live::*};
 pub extern crate tengri;
-pub(crate) use tengri::{
-    *,
-    lang::*,
-    exit::*,
-    eval::*,
-    keys::*,
-    sing::*,
-    time::*,
-    draw::*,
-    term::*,
-    color::*,
-    space::*,
-    crossterm::event::{Event, KeyEvent},
-    ratatui::{
-        self,
-        prelude::{Rect, Style, Stylize, Buffer, Color::{self, *}},
-        widgets::{Widget, canvas::{Canvas, Line}},
-    },
-};
-#[cfg(feature = "sampler")] pub(crate) use symphonia::{
-    default::get_codecs,
-    core::{//errors::Error as SymphoniaError,
-        audio::SampleBuffer, formats::Packet, io::MediaSourceStream, probe::Hint,
-        codecs::{Decoder, CODEC_TYPE_NULL},
-    },
-};
-#[cfg(feature = "lv2_gui")] use ::winit::{
-    application::ApplicationHandler,
-    event::WindowEvent,
-    event_loop::{ActiveEventLoop, ControlFlow, EventLoop},
-    window::{Window, WindowId},
-    platform::x11::EventLoopBuilderExtX11
-};
-#[allow(unused)] pub(crate) use ::{
-    std::{
-        cmp::Ord,
-        collections::BTreeMap,
-        error::Error,
-        ffi::OsString,
-        fmt::{Write, Debug, Formatter},
-        fs::File,
-        ops::{Add, Sub, Mul, Div, Rem},
-        path::{Path, PathBuf},
-        sync::{Arc, RwLock, atomic::{AtomicBool, AtomicUsize, Ordering::Relaxed}},
-        time::Duration,
-        thread::{spawn, JoinHandle},
-    },
-};
 
 /// Command-line entrypoint.
 #[cfg(feature = "cli")] pub fn main () -> Usually<()> {
+    tui_setup_panic();
     Config::watch(|config|{
-        Exit::enter(|exit|{
-            Jack::connect("tek", |jack|{
-                let state  = Arc::new(RwLock::new(App {
-                    color:   ItemTheme::random(),
-                    config:  Config::init(),
-                    dialog:  Dialog::welcome(),
-                    jack:    jack.clone(),
-                    mode:    ":menu",
-                    project: Arrangement::new(&jack, &Clock::new(&jack, 51)),
-                    ..Default::default()
-                }));
-                // TODO: Sync these timings with main clock, so that things
-                // "accidentally" fall on the beat in overload conditions.
-                let keyboard = run_tui_in(&exit, &state, Duration::from_millis(100))?;
-                let terminal = run_tui_out(&exit, &state, Duration::from_millis(10))?;
-                (keyboard, terminal)
-            })
-        })
-    })
+        tui_run_main(Jack::new_run("tek", move|jack|{
+            let clock   = Clock::new(&jack, Some(51.))?;
+            let project = Arrangement::new(&jack, None, clock, vec![], vec![], vec![], vec![]);
+            let app     = App::new(&jack, project, config, ":menu");
+            Ok(app)
+        })?)
+    }).map(|_|())
 }
 
-/// Create a new application from a backend, project, config, and mode
-///
-/// ```
-/// let jack = tek::tengri::Jack::new(&"test_tek").expect("failed to connect to jack");
-/// let proj = tek::Arrangement::default();
-/// let mut conf = tek::Config::default();
-/// conf.add("(mode hello)");
-/// let tek = tek::tek(&jack, proj, conf, "hello");
-/// ```
-pub fn tek (
-    jack: &Jack<'static>, project: Arrangement, config: Config, mode: impl AsRef<str>
-) -> App {
-    let mode: &str = mode.as_ref();
-    App {
-        color:  ItemTheme::random(),
-        dialog: Dialog::welcome(),
-        jack:   jack.clone(),
-        mode:   config.get_mode(mode).expect(&format!("failed to find mode '{mode}'")),
-        config,
-        project,
-        ..Default::default()
-    }
-}
+pub mod deps;   pub use self::deps::*;
+pub mod device; pub use self::device::*;
+pub mod app;    pub use self::app::*;
 
-fn tek_confirm (state: &mut App) -> Perhaps<AppCommand> {
-    Ok(match &state.dialog {
-        Dialog::Menu(index, items) => {
-            let callback = items.0[*index].1.clone();
-            callback(state)?;
-            None
-        },
-        _ => todo!(),
-    })
-}
-
-fn tek_inc (state: &mut App, axis: &ControlAxis) -> Perhaps<AppCommand> {
-    Ok(match (&state.dialog, axis) {
-        (Dialog::None, _) => todo!(),
-        (Dialog::Menu(_, _), ControlAxis::Y) => AppCommand::SetDialog { dialog: state.dialog.menu_next() }
-            .act(state)?,
-        _ => todo!()
-    })
-}
-
-fn tek_dec (state: &mut App, axis: &ControlAxis) -> Perhaps<AppCommand> {
-    Ok(match (&state.dialog, axis) {
-        (Dialog::None, _) => None,
-        (Dialog::Menu(_, _), ControlAxis::Y) => AppCommand::SetDialog { dialog: state.dialog.menu_prev() }
-            .act(state)?,
-        _ => todo!()
-    })
-}
-
-fn collect_commands (app: &App, input: &TuiIn) -> Usually<Vec<AppCommand>> {
-    let mut commands = vec![];
-    for id in app.mode.keys.iter() {
-        if let Some(event_map) = app.config.binds.clone().read().unwrap().get(id.as_ref())
-        && let Some(bindings)  = event_map.query(input.event()) {
-            for binding in bindings {
-                for command in binding.commands.iter() {
-                    if let Some(command) = app.namespace(command)? as Option<AppCommand> {
-                        commands.push(command)
-                    }
-                }
-            }
-        }
-    }
-    Ok(commands)
-}
-
-fn execute_commands (
-    app: &mut App, commands: Vec<AppCommand>
-) -> Usually<Vec<(AppCommand, Option<AppCommand>)>> {
-    let mut history = vec![];
-    for command in commands.into_iter() {
-        let result = command.act(app);
-        match result { Err(err) => { history.push((command, None)); return Err(err)  }
-                       Ok(undo) => { history.push((command, undo)); } };
-    }
-    Ok(history)
-}
-
-pub fn tek_jack_process (app: &mut App, client: &Client, scope: &ProcessScope) -> Control {
-    let t0 = app.perf.get_t0();
-    app.clock().update_from_scope(scope).unwrap();
-    let midi_in = app.project.midi_input_collect(scope);
-    if let Some(editor) = &app.editor() {
-        let mut pitch: Option<u7> = None;
-        for port in midi_in.iter() {
-            for event in port.iter() {
-                if let (_, Ok(LiveEvent::Midi {message: MidiMessage::NoteOn {key, ..}, ..}))
-                    = event
-                {
-                    pitch = Some(key.clone());
-                }
-            }
-        }
-        if let Some(pitch) = pitch {
-            editor.set_note_pos(pitch.as_int() as usize);
-        }
-    }
-    let result = app.project.process_tracks(client, scope);
-    app.perf.update_from_jack_scope(t0, scope);
-    result
-}
-
-pub fn tek_jack_event (app: &mut App, event: JackEvent) {
-    use JackEvent::*;
-    match event {
-        SampleRate(sr) => { app.clock().timebase.sr.set(sr as f64); },
-        PortRegistration(_id, true) => {
-            //let port = app.jack().port_by_id(id);
-            //println!("\rport add: {id} {port:?}");
-            //println!("\rport add: {id}");
-        },
-        PortRegistration(_id, false) => {
-            /*println!("\rport del: {id}")*/
-        },
-        PortsConnected(_a, _b, true) => { /*println!("\rport conn: {a} {b}")*/ },
-        PortsConnected(_a, _b, false) => { /*println!("\rport disc: {a} {b}")*/ },
-        ClientRegistration(_id, true) => {},
-        ClientRegistration(_id, false) => {},
-        ThreadInit => {},
-        XRun => {},
-        GraphReorder => {},
-        _ => { panic!("{event:?}"); }
-    }
-}
-
-pub fn swap_value <T: Clone + PartialEq, U> (
-    target: &mut T, value: &T, returned: impl Fn(T)->U
-) -> Perhaps<U> {
-    if *target == *value {
-        Ok(None)
-    } else {
-        let mut value = value.clone();
-        std::mem::swap(target, &mut value);
-        Ok(Some(returned(value)))
-    }
-}
-
-pub fn toggle_bool <U> (
-    target: &mut bool, value: &Option<bool>, returned: impl Fn(Option<bool>)->U
-) -> Perhaps<U> {
-    let mut value = value.unwrap_or(!*target);
-    if value == *target {
-        Ok(None)
-    } else {
-        std::mem::swap(target, &mut value);
-        Ok(Some(returned(Some(value))))
-    }
-}
-
-
-//take!(DeviceCommand|state: Arrangement, iter|state.selected_device().as_ref()
-    //.map(|t|Take::take(t, iter)).transpose().map(|x|x.flatten()));
-
-#[macro_export] macro_rules! has_clip {
-    (|$self:ident:$Struct:ident$(<$($L:lifetime),*$($T:ident$(:$U:path)?),*>)?|$cb:expr) => {
-        impl $(<$($L),*$($T $(: $U)?),*>)? HasMidiClip for $Struct $(<$($L),*$($T),*>)? {
-            fn clip (&$self) -> Option<Arc<RwLock<MidiClip>>> { $cb }
-        }
-    }
-}
-
-fn scan (dir: &PathBuf) -> Usually<(Vec<OsString>, Vec<OsString>)> {
-    let (mut subdirs, mut files) = std::fs::read_dir(dir)?
-        .fold((vec!["..".into()], vec![]), |(mut subdirs, mut files), entry|{
-            let entry = entry.expect("failed to read drectory entry");
-            let meta = entry.metadata().expect("failed to read entry metadata");
-            if meta.is_file() {
-                files.push(entry.file_name());
-            } else if meta.is_dir() {
-                subdirs.push(entry.file_name());
-            }
-            (subdirs, files)
-        });
-    subdirs.sort();
-    files.sort();
-    Ok((subdirs, files))
-}
-
-pub(crate) fn track_width (_index: usize, track: &Track) -> u16 {
-    track.width as u16
-}
-
-def_command!(AppCommand: |app: App| {
-    Nop     => Ok(None),
-    Confirm => tek_confirm(app),
-    Cancel  => todo!(),                                               // TODO delegate:
-    Inc { axis: ControlAxis } => tek_inc(app, axis),
-    Dec { axis: ControlAxis } => tek_dec(app, axis),
-    SetDialog { dialog: Dialog } => {
-        swap_value(&mut app.dialog, dialog, |dialog|Self::SetDialog { dialog })
-    },
-});
-
-/// Define a type alias for iterators of sized items (columns).
-macro_rules! def_sizes_iter {
-    ($Type:ident => $($Item:ty),+) => {
-        pub trait $Type<'a> =
-            Iterator<Item=(usize, $(&'a $Item,)+ usize, usize)> + Send + Sync + 'a;
-    }
-}
-def_sizes_iter!(InputsSizes  => MidiInput);
-def_sizes_iter!(OutputsSizes => MidiOutput);
-def_sizes_iter!(PortsSizes   => Arc<str>, [Connect]);
-def_sizes_iter!(ScenesSizes  => Scene);
-def_sizes_iter!(TracksSizes  => Track);
-
-/// ```
-/// let _ = tek::view_logo();
-/// ```
-pub fn view_logo () -> impl Draw<Tui> {
-    wh_exact(32, 7, bold(true, fg(Rgb(240,200,180), south!{
-        h_exact(1, ""),
-        h_exact(1, ""),
-        h_exact(1, "~~ ╓─╥─╖ ╓──╖ ╥  ╖ ~~~~~~~~~~~~"),
-        h_exact(1, east("~~~~ ║ ~ ╟─╌ ~╟─<  ~~ ", east(fg(Rgb(230,100,40), "v0.3.0"), " ~~"))),
-        h_exact(1, "~~~~ ╨ ~ ╙──╜ ╨  ╜ ~~~~~~~~~~~~"),
-    })))
-}
-
-/// ```
-/// let x = std::sync::Arc::<std::sync::RwLock<String>>::default();
-/// let _ = tek::view_transport(true,  x.clone(), x.clone(), x.clone());
-/// let _ = tek::view_transport(false, x.clone(), x.clone(), x.clone());
-/// ```
-pub fn view_transport (
-    play: bool,
-    bpm:  Arc<RwLock<String>>,
-    beat: Arc<RwLock<String>>,
-    time: Arc<RwLock<String>>,
-) -> impl Draw<Tui> {
-    let theme = ItemTheme::G[96];
-    bg(Black, east!(above(
-        wh_full(origin_w(button_play_pause(play))),
-        wh_full(origin_e(east!(
-            field_h(theme, "BPM",  bpm),
-            field_h(theme, "Beat", beat),
-            field_h(theme, "Time", time),
-        )))
-    )))
-}
-
-/// ```
-/// let x = std::sync::Arc::<std::sync::RwLock<String>>::default();
-/// let _ = tek::view_status(None, x.clone(), x.clone(), x.clone());
-/// let _ = tek::view_status(Some("".into()), x.clone(), x.clone(), x.clone());
-/// ```
-pub fn view_status (
-    sel: Option<Arc<str>>,
-    sr:  Arc<RwLock<String>>,
-    buf: Arc<RwLock<String>>,
-    lat: Arc<RwLock<String>>,
-) -> impl Draw<Tui> {
-    let theme = ItemTheme::G[96];
-    bg(Black, east!(above(
-        wh_full(origin_w(sel.map(|sel|field_h(theme, "Selected", sel)))),
-        wh_full(origin_e(east!(
-            field_h(theme, "SR",  sr),
-            field_h(theme, "Buf", buf),
-            field_h(theme, "Lat", lat),
-        )))
-    )))
-}
-
-/// ```
-/// let _ = tek::button_play_pause(true);
-/// ```
-pub fn button_play_pause (playing: bool) -> impl Draw<Tui> {
-    let compact = true;//self.is_editing();
-    bg(if playing { Rgb(0, 128, 0) } else { Rgb(128, 64, 0) },
-        either(compact,
-            Thunk::new(move|to: &mut Tui|to.place(&w_exact(9, either(playing,
-                fg(Rgb(0, 255, 0),   " PLAYING "),
-                fg(Rgb(255, 128, 0), " STOPPED ")))
-            )),
-            Thunk::new(move|to: &mut Tui|to.place(&w_exact(5, either(playing,
-                fg(Rgb(0, 255, 0),   south(" 🭍🭑🬽 ", " 🭞🭜🭘 ",)),
-                fg(Rgb(255, 128, 0), south(" ▗▄▖ ", " ▝▀▘ ",))))
-            ))
-        )
-    )
-}
-
-#[cfg(feature = "track")] pub fn view_track_row_section (
-    _theme:     ItemTheme,
-    button:     impl Draw<Tui>,
-    button_add: impl Draw<Tui>,
-    content:    impl Draw<Tui>,
-) -> impl Draw<Tui> {
-    west(h_full(w_exact(4, origin_nw(button_add))),
-        east(w_exact(20, h_full(origin_nw(button))), wh_full(origin_c(content))))
-}
-
-/// ```
-/// let bg = tengri::ratatui::style::Color::Red;
-/// let fg = tengri::ratatui::style::Color::Green;
-/// let _  = tek::view_wrap(bg, fg, "and then blue, too!");
-/// ```
-pub fn view_wrap (bg: Color, fg: Color, content: impl Draw<Tui>) -> impl Draw<Tui> {
-    let left  = fg_bg(bg, Reset, w_exact(1, y_repeat("▐")));
-    let right = fg_bg(bg, Reset, w_exact(1, y_repeat("▌")));
-    east(left, west(right, fg_bg(fg, bg, content)))
-}
-
-/// ```
-/// let _ = tek::view_meter("", 0.0);
-/// let _ = tek::view_meters(&[0.0, 0.0]);
-/// ```
-pub fn view_meter <'a> (label: &'a str, value: f32) -> impl Draw<Tui> + 'a {
-    south!(
-        field_h(ItemTheme::G[128], label, format!("{:>+9.3}", value)),
-        wh_exact(if value >= 0.0 { 13 }
-            else if value >= -1.0 { 12 }
-            else if value >= -2.0 { 11 }
-            else if value >= -3.0 { 10 }
-            else if value >= -4.0 { 9  }
-            else if value >= -6.0 { 8  }
-            else if value >= -9.0 { 7  }
-            else if value >= -12.0 { 6 }
-            else if value >= -15.0 { 5 }
-            else if value >= -20.0 { 4 }
-            else if value >= -25.0 { 3 }
-            else if value >= -30.0 { 2 }
-            else if value >= -40.0 { 1 }
-            else { 0 }, 1, bg(if value >= 0.0  { Red }
-                else if value >= -3.0 { Yellow }
-                else { Green }, ())))
-}
-
-pub fn view_meters (values: &[f32;2]) -> impl Draw<Tui> + use<'_> {
-    let left  = format!("L/{:>+9.3}", values[0]);
-    let right = format!("R/{:>+9.3}", values[1]);
-    south(left, right)
-}
-
-pub fn draw_info (sample: Option<&Arc<RwLock<Sample>>>) -> impl Draw<Tui> + use<'_> {
-    when(sample.is_some(), Thunk::new(move|to: &mut Tui|{
-        let sample = sample.unwrap().read().unwrap();
-        let theme  = sample.color;
-        to.place(&east!(
-            field_h(theme, "Name",   format!("{:<10}", sample.name.clone())),
-            field_h(theme, "Length", format!("{:<8}",  sample.channels[0].len())),
-            field_h(theme, "Start",  format!("{:<8}",  sample.start)),
-            field_h(theme, "End",    format!("{:<8}",  sample.end)),
-            field_h(theme, "Trans",  "0"),
-            field_h(theme, "Gain",   format!("{}",     sample.gain)),
-        ))
-    }))
-}
-
-pub fn draw_info_v (sample: Option<&Arc<RwLock<Sample>>>) -> impl Draw<Tui> + use<'_> {
-    either(sample.is_some(), Thunk::new(move|to: &mut Tui|{
-        let sample = sample.unwrap().read().unwrap();
-        let theme  = sample.color;
-        to.place(&w_exact(20, south!(
-            w_full(origin_w(field_h(theme, "Name  ", format!("{:<10}", sample.name.clone())))),
-            w_full(origin_w(field_h(theme, "Length", format!("{:<8}",  sample.channels[0].len())))),
-            w_full(origin_w(field_h(theme, "Start ", format!("{:<8}",  sample.start)))),
-            w_full(origin_w(field_h(theme, "End   ", format!("{:<8}",  sample.end)))),
-            w_full(origin_w(field_h(theme, "Trans ", "0"))),
-            w_full(origin_w(field_h(theme, "Gain  ", format!("{}",     sample.gain)))),
-        )))
-    }), Thunk::new(|to: &mut Tui|to.place(&fg(Red, south!(
-        bold(true, "× No sample."),
-        "[r] record",
-        "[Shift-F9] import",
-    )))))
-}
-
-pub fn draw_status (sample: Option<&Arc<RwLock<Sample>>>) -> impl Draw<Tui> {
-    bold(true, fg(g(224), sample
-        .map(|sample|{
-            let sample = sample.read().unwrap();
-            format!("Sample {}-{}", sample.start, sample.end)
-        })
-        .unwrap_or_else(||"No sample".to_string())))
-}
-
-pub fn view_track_header (theme: ItemTheme, content: impl Draw<Tui>) -> impl Draw<Tui> {
-    w_exact(12, bg(theme.darker.term, w_full(origin_e(content))))
-}
-
-pub fn view_ports_status <'a, T: JackPort> (theme: ItemTheme, title: &'a str, ports: &'a [T])
-    -> impl Draw<Tui> + use<'a, T>
-{
-    let ins   = ports.len() as u16;
-    let frame = Outer(true, Style::default().fg(g(96)));
-    let iter  = move||ports.iter();
-    let names = iter_south(1, iter, move|port, index|h_full(origin_w(format!(" {index} {}", port.port_name()))));
-    let field = field_v(theme, title, names);
-    wh_exact(20, 1 + ins, frame.enclose(wh_exact(20, 1 + ins, field)))
-}
-
-pub fn io_ports <'a, T: PortsSizes<'a>> (
-    fg: Color, bg: Color, items: impl Fn()->T + Send + Sync + 'a
-) -> impl Draw<Tui> + 'a {
-    iter(items, move|(
-        _index, name, connections, y, y2
-    ): (usize, &'a Arc<str>, &'a [Connect], usize, usize), _|
-        iter_south(y as u16, (y2-y) as u16, south(
-            h_full(bold(true, fg_bg(fg, bg, origin_w(east(&" 󰣲 ", name))))),
-            iter(||connections.iter(), move|connect: &'a Connect, index|iter_south(index as u16, 1,
-                h_full(origin_w(bold(false, fg_bg(fg, bg,
-                    &connect.info)))))))))
-}
 
 /// CLI banner.
 pub(crate) const HEADER: &'static str = r#"
 
 ~ █▀█▀█ █▀▀█ █  █  ~~~  ~  ~ ~~  ~  ~  ~ ~~ ~ ~  ~  ~
-    █   term█▀   █▀▀▄  ~ v0.4.0, 2026 winter (or is it) ~
+    █   █▀   █▀▀▄  ~ v0.4.0, 2026 heatwave edition ~
  ~  ▀   █▀▀█ ▀  ▀ ~  ~~~  ~ ~  ~   ~ ~~~ ~~~ ~   ~~ "#;
-
-/// Total state
-///
-/// ```
-/// use tek::{HasTracks, HasScenes, TracksView, ScenesView};
-/// let mut app = tek::App::default();
-/// let _ = app.scene_add(None, None).unwrap();
-/// let _ = app.update_clock();
-/// app.project.editor = Some(Default::default());
-/// //let _: Vec<_> = app.project.inputs_with_sizes().collect();
-/// //let _: Vec<_> = app.project.outputs_with_sizes().collect();
-/// let _: Vec<_> = app.project.tracks_with_sizes().collect();
-/// //let _: Vec<_> = app.project.scenes_with_sizes(true, 10, 10).collect();
-/// //let _: Vec<_> = app.scenes_with_colors(true, 10).collect();
-/// //let _: Vec<_> = app.scenes_with_track_colors(true, 10, 10).collect();
-/// let _ = app.project.w();
-/// //let _ = app.project.w_sidebar();
-/// //let _ = app.project.w_tracks_area();
-/// let _ = app.project.h();
-/// //let _ = app.project.h_tracks_area();
-/// //let _ = app.project.h_inputs();
-/// //let _ = app.project.h_outputs();
-/// let _ = app.project.h_scenes();
-/// ```
-#[derive(Default, Debug)] pub struct App {
-    /// Base color.
-    pub color:   ItemTheme,
-    /// Must not be dropped for the duration of the process
-    pub jack:    Jack<'static>,
-    /// Display size
-    pub size:    [AtomicUsize;2],
-    /// Performance counter
-    pub perf:    PerfModel,
-    /// Available view modes and input bindings
-    pub config:  Config,
-    /// Currently selected mode
-    pub mode:    Arc<Mode<Arc<str>>>,
-    /// Undo history
-    pub history: Vec<(AppCommand, Option<AppCommand>)>,
-    /// Dialog overlay
-    pub dialog:  Dialog,
-    /// Contains all recently created clips.
-    pub pool:    Pool,
-    /// Contains the currently edited musical arrangement
-    pub project: Arrangement,
-    /// Error, if any
-    pub error:   Arc<RwLock<Option<Arc<str>>>>
-}
-impl_has!(Clock:             |self: App|self.project.clock);
-impl_has!(Vec<MidiInput>:    |self: App|self.project.midi_ins);
-impl_has!(Vec<MidiOutput>:   |self: App|self.project.midi_outs);
-impl_has!(Dialog:            |self: App|self.dialog);
-impl_has!(Jack<'static>:     |self: App|self.jack);
-impl_has!([AtomicUsize;2]:      |self: App|self.size);
-impl_has!(Pool:              |self: App|self.pool);
-impl_has!(Selection:         |self: App|self.project.selection);
-impl_as_ref!(Vec<Scene>:     |self: App|self.project.as_ref());
-impl_as_mut!(Vec<Scene>:     |self: App|self.project.as_mut());
-impl_as_ref_opt!(MidiEditor: |self: App|self.project.as_ref_opt());
-impl_as_mut_opt!(MidiEditor: |self: App|self.project.as_mut_opt());
-impl_has_clips!(             |self: App|self.pool.clips);
-impl_audio!(App: tek_jack_process, tek_jack_event);
-impl_handle!(TuiIn: |self: App, input|{
-    let commands = collect_commands(self, input)?;
-    let history  = execute_commands(self, commands)?;
-    self.history.extend(history.into_iter());
-    Ok(None)
-});
-namespace!(App: Arc<str> { literal = |dsl|Ok(dsl.src()?.map(|x|x.into())); });
-namespace!(App: u8       { literal = |dsl|try_to_u8(dsl); });
-namespace!(App: u16      { literal = |dsl|try_to_u16(dsl); symbol = |app| {
-    ":w/sidebar"        => app.project.w_sidebar(app.editor().is_some()),
-    ":h/sample-detail"  => 6.max(app.measure_height() as u16 * 3 / 9), }; });
-namespace!(App: isize    { literal = |dsl|try_to_isize(dsl); });
-namespace!(App: usize    { literal = |dsl|try_to_usize(dsl); symbol = |app| {
-    ":scene-count"      => app.scenes().len(),
-    ":track-count"      => app.tracks().len(),
-    ":device-kind"      => app.dialog.device_kind().unwrap_or(0),
-    ":device-kind/next" => app.dialog.device_kind_next().unwrap_or(0),
-    ":device-kind/prev" => app.dialog.device_kind_prev().unwrap_or(0), }; });
-namespace!(App: bool { symbol = |app| { // Provide boolean values.
-    ":mode/editor"         => app.project.editor.is_some(),
-    ":focused/dialog"      => !matches!(app.dialog, Dialog::None),
-    ":focused/message"     => matches!(app.dialog, Dialog::Message(..)),
-    ":focused/add_device"  => matches!(app.dialog, Dialog::Device(..)),
-    ":focused/browser"     => app.dialog.browser().is_some(),
-    ":focused/pool/import" => matches!(app.pool.mode, Some(PoolMode::Import(..))),
-    ":focused/pool/export" => matches!(app.pool.mode, Some(PoolMode::Export(..))),
-    ":focused/pool/rename" => matches!(app.pool.mode, Some(PoolMode::Rename(..))),
-    ":focused/pool/length" => matches!(app.pool.mode, Some(PoolMode::Length(..))),
-    ":focused/clip"        => !app.editor_focused() && matches!(app.selection(), Selection::TrackClip{..}),
-    ":focused/track"       => !app.editor_focused() && matches!(app.selection(), Selection::Track(..)),
-    ":focused/scene"       => !app.editor_focused() && matches!(app.selection(), Selection::Scene(..)),
-    ":focused/mix"         => !app.editor_focused() && matches!(app.selection(), Selection::Mix),
-}; });
-namespace!(App: ItemTheme {}); // TODO: provide colors here
-namespace!(App: Selection { symbol = |app| {
-    ":select/scene"      => app.selection().select_scene(app.tracks().len()),
-    ":select/scene/next" => app.selection().select_scene_next(app.scenes().len()),
-    ":select/scene/prev" => app.selection().select_scene_prev(),
-    ":select/track"      => app.selection().select_track(app.tracks().len()),
-    ":select/track/next" => app.selection().select_track_next(app.tracks().len()),
-    ":select/track/prev" => app.selection().select_track_prev(),
-}; });
-namespace!(App: Color {
-    symbol     = |app| {
-        ":color/bg" => Color::Rgb(28, 32, 36),
-    };
-    expression = |app| {
-        "g"   (n: u8) => Color::Rgb(n, n, n),
-        "rgb" (r: u8, g: u8, b: u8) => Color::Rgb(r, g, b),
-    };
-});
-namespace!(App: Option<u7> { symbol = |app| {
-    ":editor/pitch" => Some((app.editor().as_ref().map(|e|e.get_note_pos()).unwrap() as u8).into())
-}; });
-namespace!(App: Option<usize> { symbol = |app| {
-    ":selected/scene" => app.selection().scene(),
-    ":selected/track" => app.selection().track(),
-}; });
-namespace!(App: Option<Arc<RwLock<MidiClip>>> {
-    symbol = |app| {
-        ":selected/clip" => if let Selection::TrackClip { track, scene } = app.selection() {
-            app.scenes()[*scene].clips[*track].clone()
-        } else {
-            None
-        }
-    };
-});
-
-pub trait HasClipsSize { fn clips_size (&self) -> &[AtomicUsize;2]; }
-
-pub trait HasDevices: AsRef<Vec<Device>> + AsMut<Vec<Device>> {
-    fn devices     (&self)     -> &Vec<Device>     { self.as_ref() }
-    fn devices_mut (&mut self) -> &mut Vec<Device> { self.as_mut() }
-}
-pub trait HasWidth {
-    const MIN_WIDTH: usize;
-    /// Increment track width.
-    fn width_inc (&mut self);
-    /// Decrement track width, down to a hardcoded minimum of [Self::MIN_WIDTH].
-    fn width_dec (&mut self);
-}
-
-impl<'a> Namespace<'a, AppCommand> for App {
-    symbols!('a |app| -> AppCommand {
-        "x/inc"   => AppCommand::Inc { axis: ControlAxis::X },
-        "x/dec"   => AppCommand::Dec { axis: ControlAxis::X },
-        "y/inc"   => AppCommand::Inc { axis: ControlAxis::Y },
-        "y/dec"   => AppCommand::Dec { axis: ControlAxis::Y },
-        "confirm" => AppCommand::Confirm,
-        "cancel"  => AppCommand::Cancel,
-    });
-}
-impl Understand<Tui, ()> for App {
-    fn understand_expr <'a> (&'a self, to: &mut Tui, lang: &'a impl Expression) -> Usually<()> {
-        app_understand_expr(self, to, lang)
-    }
-    fn understand_word <'a> (&'a self, to: &mut Tui, lang: &'a impl Expression) -> Usually<()> {
-        app_understand_word(self, to, lang)
-    }
-}
-fn app_understand_expr (state: &App, to: &mut Tui, lang: &impl Expression) -> Usually<()> {
-    if eval_view(state, to, lang)? || eval_view_tui(state, to, lang)? {
-        Ok(())
-    } else {
-        Err(format!("App::understand_expr: unexpected: {lang:?}").into())
-    }
-}
-fn app_understand_word (state: &App, to: &mut Tui, dsl: &impl Expression) -> Usually<()> {
-    let mut frags = dsl.src()?.unwrap().split("/");
-    match frags.next() {
-        Some(":logo")   => to.place(&view_logo()),
-        Some(":status") => to.place(&h_exact(1, "TODO: Status Bar")),
-        Some(":meters") => match frags.next() {
-            Some("input")  => to.place(&bg(Rgb(30, 30, 30), h_full(origin_s("Input Meters")))),
-            Some("output") => to.place(&bg(Rgb(30, 30, 30), h_full(origin_s("Output Meters")))),
-            _ => panic!()
-        },
-        Some(":tracks") => match frags.next() {
-            None            => to.place(&"TODO tracks"),
-            Some("names")   => to.place(&state.project.view_track_names(state.color.clone())),//bg(Rgb(40, 40, 40), w_full(origin_w("Track Names")))),
-            Some("inputs")  => to.place(&bg(Rgb(40, 40, 40), w_full(origin_w("Track Inputs")))),
-            Some("devices") => to.place(&bg(Rgb(40, 40, 40), w_full(origin_w("Track Devices")))),
-            Some("outputs") => to.place(&bg(Rgb(40, 40, 40), w_full(origin_w("Track Outputs")))),
-            _ => panic!()
-        },
-        Some(":scenes") => match frags.next() {
-            None                  => to.place(&"TODO scenes"),
-            Some(":scenes/names") => to.place(&"TODO Scene Names"),
-            _ => panic!()
-        },
-        Some(":editor") => to.place(&"TODO Editor"),
-        Some(":dialog") => match frags.next() {
-            Some("menu") => to.place(&if let Dialog::Menu(selected, items) = &state.dialog {
-                let items = items.clone();
-                let selected = selected;
-                Some(wh_full(Thunk::new(move|to: &mut Tui|{
-                    for (index, MenuItem(item, _)) in items.0.iter().enumerate() {
-                        to.place(&y_push((2 * index) as u16,
-                            fg_bg(
-                                if *selected == index { Rgb(240,200,180) } else { Rgb(200, 200, 200) },
-                                if *selected == index { Rgb(80, 80, 50)  } else { Rgb(30,  30,  30)  },
-                                h_exact(2, origin_n(w_full(item)))
-                            )));
-                    }
-                })))
-            } else {
-                None
-            }),
-            _ => unimplemented!("App::understand_word: {dsl:?} ({frags:?})"),
-        },
-        Some(":templates") => to.place(&{
-            let modes  = state.config.modes.clone();
-            let height = (modes.read().unwrap().len() * 2) as u16;
-            h_exact(height, w_min(30, Thunk::new(move |to: &mut Tui|{
-                for (index, (id, profile)) in modes.read().unwrap().iter().enumerate() {
-                    let bg         = if index == 0 { Rgb(70,70,70) } else { Rgb(50,50,50) };
-                    let name       = profile.name.get(0).map(|x|x.as_ref()).unwrap_or("<no name>");
-                    let info       = profile.info.get(0).map(|x|x.as_ref()).unwrap_or("<no info>");
-                    let fg1        = Rgb(224, 192, 128);
-                    let fg2        = Rgb(224, 128,  32);
-                    let field_name = w_full(origin_w(fg(fg1, name)));
-                    let field_id   = w_full(origin_e(fg(fg2, id)));
-                    let field_info = w_full(origin_w(info));
-                    to.place(&y_push((2 * index) as u16,
-                        h_exact(2, w_full(bg(bg, south(
-                            above(field_name, field_id), field_info))))));
-                }
-            })))
-        }),
-        Some(":sessions") => to.place(&h_exact(6, w_min(30, Thunk::new(|to: &mut Tui|{
-            let fg = Rgb(224, 192, 128);
-            for (index, name) in ["session1", "session2", "session3"].iter().enumerate() {
-                let bg = if index == 0 { Rgb(50,50,50) } else { Rgb(40,40,40) };
-                to.place(&y_push((2 * index) as u16,
-                    &h_exact(2, w_full(bg(bg, origin_w(fg(fg, name)))))));
-            }
-        })))),
-        Some(":browse/title") => to.place(&w_full(origin_w(field_v(ItemColor::default(),
-            match state.dialog.browser_target().unwrap() {
-               BrowseTarget::SaveProject     => "Save project:",
-               BrowseTarget::LoadProject     => "Load project:",
-               BrowseTarget::ImportSample(_) => "Import sample:",
-               BrowseTarget::ExportSample(_) => "Export sample:",
-               BrowseTarget::ImportClip(_)   => "Import clip:",
-               BrowseTarget::ExportClip(_)   => "Export clip:",
-            }, w_shrink(3, h_exact(1, fg(g(96), x_repeat("🭻")))))))),
-        Some(":device") => {
-            let selected = state.dialog.device_kind().unwrap();
-            to.place(&south(bold(true, "Add device"), iter_south(1,
-                move||device_kinds().iter(),
-                move|_label: &&'static str, i|{
-                    let bg = if i == selected { Rgb(64,128,32) } else { Rgb(0,0,0) };
-                    let lb = if i == selected { "[ " } else { "  " };
-                    let rb = if i == selected { " ]" } else { "  " };
-                    w_full(bg(bg, east(lb, west(rb, "FIXME device name")))) })))
-        },
-        Some(":debug") => to.place(&h_exact(1, format!("[{:?}]", to.area()))),
-        Some(_) => {
-            let views = state.config.views.read().unwrap();
-            if let Some(dsl) = views.get(dsl.src()?.unwrap()) {
-                let dsl = dsl.clone();
-                std::mem::drop(views);
-                state.understand(to, &dsl)?
-            } else {
-                unimplemented!("{dsl:?}");
-            }
-        },
-        _ => unreachable!()
-    }
-    Ok(())
-}
-impl App {
-    /// Update memoized render of clock values.
-    /// ```
-    /// tek::App::default().update_clock();
-    /// ```
-    pub fn update_clock (&self) {
-        ClockView::update_clock(&self.project.clock.view_cache, self.clock(), self.size.w() > 80)
-    }
-
-    /// Set modal dialog.
-    ///
-    /// ```
-    /// let previous: tek::Dialog = tek::App::default().set_dialog(tek::Dialog::welcome());
-    /// ```
-    pub fn set_dialog (&mut self, mut dialog: Dialog) -> Dialog {
-        std::mem::swap(&mut self.dialog, &mut dialog);
-        dialog
-    }
-
-    /// FIXME: generalize. Set picked device in device pick dialog.
-    ///
-    /// ```
-    /// tek::App::default().device_pick(0);
-    /// ```
-    pub fn device_pick (&mut self, index: usize) {
-        self.dialog = Dialog::Device(index);
-    }
-
-    /// FIXME: generalize. Add device to current track.
-    pub fn add_device (&mut self, index: usize) -> Usually<()> {
-        match index {
-            0 => {
-                let name    = self.jack.with_client(|c|c.name().to_string());
-                let midi    = self.project.track().expect("no active track").sequencer.midi_outs[0].port_name();
-                let track   = self.track().expect("no active track");
-                let port    = format!("{}/Sampler", &track.name);
-                let connect = Connect::exact(format!("{name}:{midi}"));
-                let sampler = if let Ok(sampler) = Sampler::new(
-                    &self.jack, &port, &[connect], &[&[], &[]], &[&[], &[]]
-                ) {
-                    self.dialog = Dialog::None;
-                    Device::Sampler(sampler)
-                } else {
-                    self.dialog = Dialog::Message("Failed to add device.".into());
-                    return Err("failed to add device".into())
-                };
-                let track   = self.track_mut().expect("no active track");
-                track.devices.push(sampler);
-                Ok(())
-            },
-            1 => {
-                todo!();
-                //Ok(())
-            },
-            _ => unreachable!(),
-        }
-    }
-
-    /// Return reference to content browser if open.
-    ///
-    /// ```
-    /// assert_eq!(tek::App::default().browser(), None);
-    /// ```
-    pub fn browser (&self) -> Option<&Browse> {
-        if let Dialog::Browse(_, ref b) = self.dialog { Some(b) } else { None }
-    }
-
-    /// Is a MIDI editor currently focused?
-    ///
-    /// ```
-    /// tek::App::default().editor_focused();
-    /// ```
-    pub fn editor_focused (&self) -> bool {
-        false
-    }
-
-    /// Toggle MIDI editor.
-    ///
-    /// ```
-    /// tek::App::default().toggle_editor(None);
-    /// ```
-    pub fn toggle_editor (&mut self, value: Option<bool>) {
-        //FIXME: self.editing.store(value.unwrap_or_else(||!self.is_editing()), Relaxed);
-        let value = value.unwrap_or_else(||!self.editor().is_some());
-        if value {
-            // Create new clip in pool when entering empty cell
-            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, clip) = self.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(editor) = &mut self.project.editor {
-                    editor.set_clip(Some(&clip));
-                }
-                *slot = Some(clip.clone());
-                //Some(clip)
-            } else {
-                //None
-            }
-        } else 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()
-        {
-            // Remove clip from arrangement when exiting empty clip editor
-            let mut swapped = None;
-            if clip.read().unwrap().count_midi_messages() == 0 {
-                std::mem::swap(&mut swapped, slot);
-            }
-            if let Some(clip) = swapped {
-                self.pool.delete_clip(&clip.read().unwrap());
-            }
-        }
-    }
-}
-impl Draw<Tui> for App {
-    fn draw (self, to: &mut Tui) -> Usually<XYWH<u16>> {
-        if let Some(e) = self.error.read().unwrap().as_ref() {
-            to.place_at(to.area(), e);
-        }
-        for (index, dsl) in self.mode.view.iter().enumerate() {
-            if let Err(e) = self.understand(to, dsl) {
-                *self.error.write().unwrap() = Some(format!("view #{index}: {e}").into());
-                break;
-            }
-        }
-    }
-}
-impl HasClipsSize for App { fn clips_size (&self) -> &[AtomicUsize;2] { &self.project.size_inner } }
-impl HasJack<'static> for App { fn jack (&self) -> &Jack<'static> { &self.jack } }
-impl_default!(AppCommand: Self::Nop);
-primitive!(u8:    try_to_u8);
-primitive!(u16:   try_to_u16);
-primitive!(usize: try_to_usize);
-primitive!(isize: try_to_isize);

tengri

@@ -1 +1 @@
-Subproject commit a06ea2ac139d09ab9eba5931455c43a3a75f4151
+Subproject commit 13c886d9e05a8df712461d44025196ae9be51b78