convert to workspace, add suil bindings crate

crates/tek/Cargo.toml

@@ -0,0 +1,39 @@
+[package]
+name = "tek"
+edition = "2021"
+version = "0.1.0"
+
+[dependencies]
+jack = "0.10"
+clap = { version = "4.5.4", features = [ "derive" ] }
+crossterm = "0.27"
+ratatui = { version = "0.26.3", features = [ "unstable-widget-ref", "underline-color" ] }
+backtrace = "0.3.72"
+microxdg = "0.1.2"
+toml = "0.8.12"
+better-panic = "0.3.0"
+midly = "0.5"
+
+vst = "0.4.0"
+#vst3 = "0.1.0"
+livi = "0.7.4"
+#atomic_enum = "0.3.0"
+wavers = "1.4.3"
+music-math = "0.1.1"
+atomic_float = "1.0.0"
+fraction = "0.15.3"
+rlsf = "0.2.1"
+r8brain-rs = "0.3.5"
+clojure-reader = "0.1.0"
+once_cell = "1.19.0"
+
+symphonia = { version = "0.5.4", features = [ "all" ] }
+
+dasp = { version = "0.11.0", features = [ "all" ] }
+
+rubato = "0.15.0"
+
+winit = { version = "0.30.4", features = [ "x11" ] }
+#winit = { path = "../winit" }
+
+suil = { path = "../suil" }

crates/tek/src/cli.rs

@@ -0,0 +1,29 @@
+//! Command line option parser.
+
+use clap::{Parser, Subcommand};
+
+#[derive(Debug, Parser)]
+#[command(version, about, long_about = None)]
+pub struct Cli {
+    #[command(subcommand)]
+    pub command: Option<Command>
+}
+
+#[derive(Debug, Clone, Subcommand)]
+pub enum Command {
+    /// Launch or control a master transport
+    Transport,
+    /// Launch or control a sequencer
+    Sequencer {
+        #[arg(long="input")]
+        inputs:  Vec<Option<String>>,
+        #[arg(long="output")]
+        outputs: Vec<Option<String>>,
+    },
+    /// Launch or control a sampler
+    Sampler,
+    /// Launch or control a mixer
+    Mixer,
+    /// Launch or control a looper
+    Looper,
+}

crates/tek/src/config.rs

@@ -0,0 +1,51 @@
+//! Global settings.
+
+use crate::core::*;
+use std::path::{Path, PathBuf};
+use std::fs::{File, create_dir_all};
+
+const CONFIG_FILE_NAME:  &'static str = "tek.toml";
+const PROJECT_FILE_NAME: &'static str = "project.toml";
+
+/// Filesystem locations of things.
+pub struct AppPaths {
+    config_dir:   PathBuf,
+    config_file:  PathBuf,
+    data_dir:     PathBuf,
+    project_file: PathBuf,
+}
+impl AppPaths {
+    pub fn new (xdg: &XdgApp) -> Usually<Self> {
+        let config_dir   = PathBuf::from(xdg.app_config()?);
+        let config_file  = PathBuf::from(config_dir.join(CONFIG_FILE_NAME));
+        let data_dir     = PathBuf::from(xdg.app_data()?);
+        let project_file = PathBuf::from(data_dir.join(PROJECT_FILE_NAME));
+        Ok(Self { config_dir, config_file, data_dir, project_file })
+    }
+    pub fn should_create (&self) -> bool {
+        for path in [
+            &self.config_dir,
+            &self.config_file,
+            &self.data_dir,
+            &self.project_file,
+        ].iter() {
+            if !Path::new(path).exists() {
+                return true
+            }
+        }
+        false
+    }
+    pub fn create (&self) -> Usually<()> {
+        for dir in [&self.config_dir, &self.data_dir].iter() {
+            if !Path::new(dir).exists() {
+                create_dir_all(&dir)?;
+            }
+        }
+        for file in [&self.config_file, &self.project_file].iter() {
+            if !Path::new(file).exists() {
+                File::create_new(&file)?;
+            }
+        }
+        Ok(())
+    }
+}

crates/tek/src/control.rs

@@ -0,0 +1,210 @@
+//! Handling of input events.
+
+use crate::{core::*, handle, App, AppFocus, model::MODAL};
+
+handle!{
+    App |self, e| {
+        if handle_modal(e)? {
+            return Ok(true)
+        }
+        Ok(if self.entered {
+            handle_focused(self, e)?
+                || handle_keymap(self, e, KEYMAP_GLOBAL)?
+                || handle_keymap(self, e, crate::control::KEYMAP_FOCUS)?
+        } else {
+            handle_keymap(self, e, KEYMAP_GLOBAL)?
+                || handle_keymap(self, e, crate::control::KEYMAP_FOCUS)?
+                || handle_focused(self, e)?
+        })
+    }
+}
+
+fn handle_modal (e: &AppEvent) -> Usually<bool> {
+    let mut handled = false;
+    let mut close = false;
+    if let Some(ref mut modal) = *MODAL.lock().unwrap() {
+        if modal.handle(e)? {
+            handled = true;
+            if modal.exited() {
+                close = true;
+            }
+        };
+    }
+    if close {
+        *MODAL.lock().unwrap() = None;
+    }
+    Ok(handled)
+}
+
+fn handle_focused (state: &mut App, e: &AppEvent) -> Usually<bool> {
+    match state.section {
+        AppFocus::Transport =>
+            handle_keymap(state, e, crate::devices::transport::KEYMAP_TRANSPORT),
+        AppFocus::Arranger =>
+            handle_keymap(state, e, crate::devices::arranger::KEYMAP_ARRANGER),
+        AppFocus::Sequencer =>
+            handle_keymap(state, e, crate::devices::sequencer::KEYMAP_SEQUENCER),
+        AppFocus::Chain => Ok(if state.entered {
+            handle_device(state, e)? ||
+            handle_keymap(state, e, crate::control::KEYMAP_CHAIN)?
+        } else {
+            handle_keymap(state, e, crate::control::KEYMAP_CHAIN)? || handle_device(state, e)?
+        })
+    }
+}
+
+fn handle_device (state: &mut App, e: &AppEvent) -> Usually<bool> {
+    state.arranger.track()
+        .and_then(|track|track.device_mut())
+        .map(|mut device|device.handle(e))
+        .transpose()
+        .map(|x|x.unwrap_or(false))
+}
+
+/// Global key bindings.
+pub const KEYMAP_GLOBAL: &'static [KeyBinding<App>] = keymap!(App {
+    [Char(' '), NONE, "play_toggle",    "play or pause",    |app: &mut App| {
+        app.transport.toggle_play()?;
+        Ok(true)
+    }],
+    [Char('r'), NONE, "record_toggle",  "toggle recording", |app: &mut App| {
+        app.arranger.track_mut().map(|t|t.toggle_record());
+        Ok(true)
+    }],
+    [Char('o'), NONE, "overdub_toggle", "toggle overdub",   |app: &mut App| {
+        app.arranger.track_mut().map(|t|t.toggle_overdub());
+        Ok(true)
+    }],
+    [Char('m'), NONE, "monitor_toggle", "toggle monitor",   |app: &mut App| {
+        app.arranger.track_mut().map(|t|t.toggle_monitor());
+        Ok(true)
+    }],
+    [Char('+'), NONE, "quant_inc", "quantize coarser", |app: &mut App| {
+        app.transport.quant = next_note_length(app.transport.quant);
+        Ok(true)
+    }],
+    [Char('_'), NONE, "quant_dec", "quantize finer",   |app: &mut App| {
+        app.transport.quant = prev_note_length(app.transport.quant);
+        Ok(true)
+    }],
+    [Char('='), NONE, "zoom_in",  "show fewer ticks per block",  |app: &mut App| {
+        app.sequencer.time_axis.scale_mut(&prev_note_length);
+        Ok(true)
+    }],
+    [Char('-'), NONE, "zoom_out", "show more ticks per block", |app: &mut App| {
+        app.sequencer.time_axis.scale_mut(&next_note_length);
+        Ok(true)
+    }],
+    [Char('x'), NONE, "extend", "double the current clip",   |app: &mut App| {
+        app.arranger.phrase().map(|x|x.write().unwrap()).map(|mut phrase|{
+            let mut notes = phrase.notes.clone();
+            notes.extend_from_slice(&mut phrase.notes);
+            phrase.notes = notes;
+            phrase.length = phrase.length * 2;
+        });
+        app.sequencer.show(app.arranger.phrase())?;
+        Ok(true)
+    }],
+    [Char('l'), NONE, "loop_toggle",       "toggle looping",            |_app: &mut App| {
+        // TODO: This toggles the loop flag for the clip under the cursor.
+        Ok(true)
+    }],
+    [Char('['), NONE, "loop_start_dec",    "move loop start back",      |_app: &mut App| {
+        // TODO: This moves the loop start to the previous quant.
+        Ok(true)
+    }],
+    [Char(']'), NONE, "loop_start_inc",    "move loop start forward",   |_app: &mut App| {
+        // TODO: This moves the loop start to the next quant.
+        Ok(true)
+    }],
+    [Char('{'), NONE, "loop_end_dec",      "move loop end back",        |_app: &mut App| {
+        // TODO: This moves the loop end to the previous quant.
+        Ok(true)
+    }],
+    [Char('}'), NONE, "loop_end_inc",      "move loop end forward",     |_app: &mut App| {
+        // TODO: This moves the loop end to the next quant.
+        Ok(true)
+    }],
+    [Char('a'), CONTROL, "scene_add",      "add a new scene",           |app: &mut App| {
+        app.arranger.scene_add(None)?;
+        Ok(true)
+    }],
+    [Char('t'), CONTROL, "track_add",      "add a new track",           |app: &mut App| {
+        app.arranger.track_add(None)?;
+        Ok(true)
+    }],
+});
+
+/// Key bindings for chain section.
+pub const KEYMAP_CHAIN: &'static [KeyBinding<App>] = keymap!(App {
+    [Up,    NONE, "chain_cursor_up",   "move cursor up", |_: &mut App| {
+        Ok(true)
+    }],
+    [Down,  NONE, "chain_cursor_down", "move cursor down", |_: &mut App| {
+        Ok(true)
+    }],
+    [Left,  NONE, "chain_cursor_left", "move cursor left", |app: &mut App| {
+        if let Some(track) = app.arranger.track_mut() {
+            track.device = track.device.saturating_sub(1);
+            return Ok(true)
+        }
+        Ok(false)
+    }],
+    [Right, NONE, "chain_cursor_right", "move cursor right", |app: &mut App| {
+        if let Some(track) = app.arranger.track_mut() {
+            track.device = (track.device + 1).min(track.devices.len().saturating_sub(1));
+            return Ok(true)
+        }
+        Ok(false)
+    }],
+    [Char('`'), NONE, "chain_mode_switch", "switch the display mode", |app: &mut App| {
+        app.chain_mode = !app.chain_mode;
+        Ok(true)
+    }],
+});
+
+/// Generic key bindings for views that support focus.
+pub const KEYMAP_FOCUS: &'static [KeyBinding<App>] = keymap!(App {
+    [Char(';'), NONE, "command", "open command palette", |_: &mut App| {
+        *MODAL.lock().unwrap() = Some(Box::new(crate::devices::help::HelpModal::new()));
+        Ok(true)
+    }],
+    [Tab, NONE,  "focus_next", "focus next area",     focus_next],
+    [Tab, SHIFT, "focus_prev", "focus previous area", focus_prev],
+    [Esc, NONE,  "focus_exit", "unfocus", |app: &mut App|{
+        app.entered = false;
+        app.transport.entered = app.entered;
+        app.arranger.entered  = app.entered;
+        app.sequencer.entered = app.entered;
+        Ok(true)
+    }],
+    [Enter, NONE, "focus_enter", "activate item at cursor", |app: &mut App|{
+        app.entered = true;
+        app.transport.entered = app.entered;
+        app.arranger.entered  = app.entered;
+        app.sequencer.entered = app.entered;
+        Ok(true)
+    }],
+});
+
+pub fn focus_next (app: &mut App) -> Usually<bool> {
+    app.section.next();
+    app.transport.focused = app.section == AppFocus::Transport;
+    app.transport.entered = app.entered;
+    app.arranger.focused  = app.section == AppFocus::Arranger;
+    app.arranger.entered  = app.entered;
+    app.sequencer.focused = app.section == AppFocus::Sequencer;
+    app.sequencer.entered = app.entered;
+    Ok(true)
+}
+
+pub fn focus_prev (app: &mut App) -> Usually<bool> {
+    app.section.prev();
+    app.transport.focused = app.section == AppFocus::Transport;
+    app.transport.entered = app.entered;
+    app.arranger.focused  = app.section == AppFocus::Arranger;
+    app.arranger.entered  = app.entered;
+    app.sequencer.focused = app.section == AppFocus::Sequencer;
+    app.sequencer.entered = app.entered;
+    Ok(true)
+}

crates/tek/src/core.rs

@@ -0,0 +1,185 @@
+//! Prelude.
+
+// Stdlib dependencies:
+pub(crate) use std::error::Error;
+pub(crate) use std::io::{stdout};
+pub(crate) use std::thread::{spawn, JoinHandle};
+pub(crate) use std::time::Duration;
+pub(crate) use std::collections::BTreeMap;
+pub(crate) use std::sync::atomic::{Ordering, AtomicBool};
+pub(crate) use std::sync::{Arc, Mutex, RwLock, LockResult, RwLockReadGuard, RwLockWriteGuard};
+pub(crate) use std::path::PathBuf;
+pub(crate) use std::fs::read_dir;
+pub(crate) use std::ffi::OsString;
+
+// Non-stdlib dependencies:
+pub(crate) use microxdg::XdgApp;
+pub(crate) use midly::{MidiMessage, live::LiveEvent, num::u7};
+pub(crate) use crossterm::{ExecutableCommand};
+pub(crate) use crossterm::event::{Event, KeyEvent, KeyCode, KeyModifiers};
+use better_panic::{Settings, Verbosity};
+use crossterm::terminal::{
+    EnterAlternateScreen, LeaveAlternateScreen,
+    enable_raw_mode, disable_raw_mode
+};
+
+/// Define and reexport submodules.
+#[macro_export] macro_rules! submod {
+    ($($name:ident)*) => { $(mod $name; pub use self::$name::*;)* };
+}
+
+/// Define and reexport public modules.
+#[macro_export] macro_rules! pubmod {
+    ($($name:ident)*) => { $(pub mod $name;)* };
+}
+
+submod!( handle midi render time );
+
+/// Standard result type.
+pub type Usually<T> = Result<T, Box<dyn Error>>;
+
+/// A UI component.
+pub trait Component: Render + Handle + Sync {
+    /// Perform type erasure for collecting heterogeneous components.
+    fn boxed (self) -> Box<dyn Component> where Self: Sized + 'static {
+        Box::new(self)
+    }
+}
+
+pub trait Exit: Component {
+    fn exited (&self) -> bool;
+    fn exit (&mut self);
+    fn boxed (self) -> Box<dyn Exit> where Self: Sized + 'static {
+        Box::new(self)
+    }
+}
+
+#[macro_export] macro_rules! exit {
+    ($T:ty) => {
+        impl Exit for $T {
+            fn exited (&self) -> bool {
+                self.exited
+            }
+            fn exit (&mut self) {
+                self.exited = true
+            }
+        }
+    }
+}
+
+/// Anything that implements `Render` + `Handle` can be used as a UI component.
+impl<T: Render + Handle + Sync> Component for T {}
+
+/// A UI component that may be associated with a JACK client by the `Jack` factory.
+pub trait Device: Render + Handle + Process + Send + Sync {
+    /// Perform type erasure for collecting heterogeneous devices.
+    fn boxed (self) -> Box<dyn Device> where Self: Sized + 'static {
+        Box::new(self)
+    }
+}
+
+/// All things that implement the required traits can be treated as `Device`.
+impl<T: Render + Handle + Process + Send + Sync> Device for T {}
+
+// Reexport macros:
+pub use crate::{
+    submod, pubmod, render, handle, process, phrase, keymap, ports, exit
+};
+
+// Reexport JACK proto-lib:
+pub use crate::jack::*;
+
+/// Run the main loop.
+pub fn run <T> (state: Arc<RwLock<T>>) -> Usually<Arc<RwLock<T>>>
+    where T: Render + Handle + Send + Sync + Sized + 'static
+{
+    let exited = Arc::new(AtomicBool::new(false));
+    let _input_thread = input_thread(&exited, &state);
+    terminal_setup()?;
+    panic_hook_setup();
+    let main_thread = main_thread(&exited, &state)?;
+    main_thread.join().expect("main thread failed");
+    terminal_teardown()?;
+    Ok(state)
+}
+
+/// Set up panic hook
+pub fn panic_hook_setup () {
+    let better_panic_handler = Settings::auto().verbosity(Verbosity::Full).create_panic_handler();
+    std::panic::set_hook(Box::new(move |info: &std::panic::PanicInfo|{
+        stdout().execute(LeaveAlternateScreen).unwrap();
+        disable_raw_mode().unwrap();
+        better_panic_handler(info);
+    }));
+}
+
+/// Set up terminal
+pub fn terminal_setup () -> Usually<()> {
+    stdout().execute(EnterAlternateScreen)?;
+    enable_raw_mode()?;
+    Ok(())
+}
+/// Cleanup
+pub fn terminal_teardown () -> Usually<()> {
+    stdout().execute(LeaveAlternateScreen)?;
+    disable_raw_mode()?;
+    Ok(())
+}
+
+/// Main thread render loop
+pub fn main_thread (
+    exited: &Arc<AtomicBool>,
+    device: &Arc<RwLock<impl Render + Send + Sync + 'static>>
+) -> Usually<JoinHandle<()>> {
+    let exited = exited.clone();
+    let device = device.clone();
+    let mut terminal = ratatui::Terminal::new(CrosstermBackend::new(stdout()))?;
+    let sleep = Duration::from_millis(20);
+    Ok(spawn(move || loop {
+
+        if let Ok(device) = device.try_read() {
+            terminal.draw(|frame|{
+                let area   = frame.size();
+                let buffer = frame.buffer_mut();
+                device
+                    .render(buffer, area)
+                    .expect("Failed to render content");
+            })
+                .expect("Failed to render frame");
+        }
+
+        if exited.fetch_and(true, Ordering::Relaxed) {
+            break
+        }
+
+        std::thread::sleep(sleep);
+
+    }))
+}
+
+/// Spawn thread that listens for user input
+pub fn input_thread (
+    exited: &Arc<AtomicBool>,
+    device: &Arc<RwLock<impl Handle + Send + Sync + 'static>>
+) -> JoinHandle<()> {
+    let poll = Duration::from_millis(100);
+    let exited = exited.clone();
+    let device = device.clone();
+    spawn(move || loop {
+        // Exit if flag is set
+        if exited.fetch_and(true, Ordering::Relaxed) {
+            break
+        }
+        // Listen for events and send them to the main thread
+        if ::crossterm::event::poll(poll).is_ok() {
+            let event = ::crossterm::event::read().unwrap();
+            if let Event::Key(KeyEvent {
+                code: KeyCode::Char('c'), modifiers: KeyModifiers::CONTROL, ..
+            }) = event {
+                exited.store(true, Ordering::Relaxed);
+            } else if let Err(e) = device.write().unwrap().handle(&AppEvent::Input(event)) {
+                panic!("{e}")
+            }
+        }
+    })
+}

crates/tek/src/core/handle.rs

@@ -0,0 +1,81 @@
+use crate::core::*;
+
+/// Trait for things that handle input events.
+pub trait Handle {
+    /// Handle an input event.
+    /// Returns Ok(true) if the device handled the event.
+    /// This is the mechanism which allows nesting of components;.
+    fn handle (&mut self, _e: &AppEvent) -> Usually<bool> {
+        Ok(false)
+    }
+}
+
+/// Implement the `Handle` trait.
+#[macro_export] macro_rules! handle {
+    ($T:ty) => {
+        impl Handle for $T {}
+    };
+    ($T:ty |$self:ident, $e:ident|$block:expr) => {
+        impl Handle for $T {
+            fn handle (&mut $self, $e: &AppEvent) -> Usually<bool> {
+                $block
+            }
+        }
+    };
+    ($T:ty = $handle:path) => {
+        impl Handle for $T {
+            fn handle (&mut self, e: &AppEvent) -> Usually<bool> {
+                $handle(self, e)
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum AppEvent {
+    /// Terminal input
+    Input(::crossterm::event::Event),
+    /// Update values but not the whole form.
+    Update,
+    /// Update the whole form.
+    Redraw,
+    /// Device gains focus
+    Focus,
+    /// Device loses focus
+    Blur,
+    /// JACK notification
+    Jack(JackEvent)
+}
+
+pub type KeyHandler<T> = &'static dyn Fn(&mut T)->Usually<bool>;
+
+pub type KeyBinding<T> = (
+    KeyCode, KeyModifiers, &'static str, &'static str, KeyHandler<T>
+);
+
+pub type KeyMap<T> = [KeyBinding<T>];
+
+pub fn handle_keymap <T> (
+    state: &mut T, event: &AppEvent, keymap: &KeyMap<T>,
+) -> Usually<bool> {
+    match event {
+        AppEvent::Input(Event::Key(event)) => {
+            for (code, modifiers, _, _, command) in keymap.iter() {
+                if *code == event.code && modifiers.bits() == event.modifiers.bits() {
+                    return command(state)
+                }
+            }
+        },
+        _ => {}
+    };
+    Ok(false)
+}
+
+/// Define a keymap
+#[macro_export] macro_rules! keymap {
+    ($T:ty { $([$k:ident $(($char:literal))?, $m:ident, $n: literal, $d: literal, $f: expr]),* $(,)? }) => {
+        &[
+            $((KeyCode::$k $(($char))?, KeyModifiers::$m, $n, $d, &$f as KeyHandler<$T>)),*
+        ] as &'static [KeyBinding<$T>]
+    }
+}

crates/tek/src/core/midi.rs

@@ -0,0 +1,92 @@
+use crate::core::*;
+
+pub type MIDIMessage =
+    Vec<u8>;
+
+pub type MIDIChunk =
+    [Vec<MIDIMessage>];
+
+/// Add "all notes off" to the start of a buffer.
+pub fn all_notes_off (output: &mut MIDIChunk) {
+    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);
+}
+
+pub fn parse_midi_input (input: MidiIter) -> Box<dyn Iterator<Item=(usize, LiveEvent, &[u8])> + '_> {
+    Box::new(input.map(|RawMidi { time, bytes }|(
+        time as usize,
+        LiveEvent::parse(bytes).unwrap(),
+        bytes
+    )))
+}
+
+/// Write to JACK port from output buffer (containing notes from sequence and/or monitor)
+pub fn write_midi_output (writer: &mut ::jack::MidiWriter, output: &MIDIChunk, frames: usize) {
+    for time in 0..frames {
+        for event in output[time].iter() {
+            writer.write(&::jack::RawMidi { time: time as u32, bytes: &event })
+                .expect(&format!("{event:?}"));
+        }
+    }
+}
+
+/// (pulses, name)
+pub const NOTE_DURATIONS: [(u16, &str);26] = [
+    (1,    "1/384"),
+    (2,    "1/192"),
+    (3,    "1/128"),
+    (4,    "1/96"),
+    (6,    "1/64"),
+    (8,    "1/48"),
+    (12,   "1/32"),
+    (16,   "1/24"),
+    (24,   "1/16"),
+    (32,   "1/12"),
+    (48,   "1/8"),
+    (64,   "1/6"),
+    (96,   "1/4"),
+    (128,  "1/3"),
+    (192,  "1/2"),
+    (256,  "2/3"),
+    (384,  "1/1"),
+    (512,  "4/3"),
+    (576,  "3/2"),
+    (768,  "2/1"),
+    (1152, "3/1"),
+    (1536, "4/1"),
+    (2304, "6/1"),
+    (3072, "8/1"),
+    (3456, "9/1"),
+    (6144, "16/1"),
+];
+
+pub fn prev_note_length (ppq: u16) -> u16 {
+    for i in 1..=16 {
+        let length = NOTE_DURATIONS[16-i].0;
+        if length < ppq {
+            return length
+        }
+    }
+    ppq
+}
+
+pub fn next_note_length (ppq: u16) -> u16 {
+    for (length, _) in &NOTE_DURATIONS {
+        if *length > ppq {
+            return *length
+        }
+    }
+    ppq
+}
+
+pub fn ppq_to_name (ppq: u16) -> &'static str {
+    for (length, name) in &NOTE_DURATIONS {
+        if *length == ppq {
+            return name
+        }
+    }
+    ""
+}

crates/tek/src/core/render.rs

@@ -0,0 +1,166 @@
+use crate::core::*;
+pub(crate) use ratatui::prelude::CrosstermBackend;
+pub(crate) use ratatui::style::{Stylize, Style, Color, Modifier};
+pub(crate) use ratatui::layout::Rect;
+pub(crate) use ratatui::buffer::{Buffer, Cell};
+use ratatui::widgets::WidgetRef;
+
+pub fn make_dim (buf: &mut Buffer) {
+    for cell in buf.content.iter_mut() {
+        cell.bg = ratatui::style::Color::Rgb(30,30,30);
+        cell.fg = ratatui::style::Color::Rgb(100,100,100);
+        cell.modifier = ratatui::style::Modifier::DIM;
+    }
+}
+pub fn center_box (area: Rect, w: u16, h: u16) -> Rect {
+    let width  = w.min(area.width * 3 / 5);
+    let height = h.min(area.width * 3 / 5);
+    let x = area.x + (area.width  - width)  / 2;
+    let y = area.y + (area.height - height) / 2;
+    Rect { x, y, width, height }
+}
+pub fn buffer_update (
+    buf: &mut Buffer, area: Rect, callback: &impl Fn(&mut Cell, u16, u16)
+) {
+    for row in 0..area.height {
+        let y = area.y + row;
+        for col in 0..area.width {
+            let x = area.x + col;
+            if x < buf.area.width && y < buf.area.height {
+                callback(buf.get_mut(x, y), col, row);
+            }
+        }
+    }
+}
+pub fn fill_fg (buf: &mut Buffer, area: Rect, color: Color) {
+    buffer_update(buf, area, &|cell,_,_|{cell.set_fg(color);})
+}
+pub fn fill_bg (buf: &mut Buffer, area: Rect, color: Color) {
+    buffer_update(buf, area, &|cell,_,_|{cell.set_bg(color);})
+}
+pub fn to_fill_bg (color: Color) -> impl Render {
+    move |buf: &mut Buffer, area: Rect|{
+        fill_bg(buf, area, color);
+        Ok(area)
+    }
+}
+pub fn fill_char (buf: &mut Buffer, area: Rect, c: char) {
+    buffer_update(buf, area, &|cell,_,_|{cell.set_char(c);})
+}
+pub fn half_block (lower: bool, upper: bool) -> Option<char> {
+    match (lower, upper) {
+        (true, true)  => Some('█'),
+        (true, false) => Some('▄'),
+        (false, true) => Some('▀'),
+        _ => None
+    }
+}
+
+pub trait Blit {
+    // Render something to X, Y coordinates in a buffer, ignoring width/height.
+    fn blit (&self, buf: &mut Buffer, x: u16, y: u16, style: Option<Style>) -> Usually<Rect>;
+}
+
+impl<T: AsRef<str>> Blit for T {
+    fn blit (&self, buf: &mut Buffer, x: u16, y: u16, style: Option<Style>) -> Usually<Rect> {
+        if x < buf.area.width && y < buf.area.height {
+            buf.set_string(x, y, self.as_ref(), style.unwrap_or(Style::default()));
+        }
+        Ok(Rect { x, y, width: self.as_ref().len() as u16, height: 1 })
+    }
+}
+
+/// Trait for things that render to the display.
+pub trait Render: Send {
+    // Render something to an area of the buffer.
+    // Returns area used by component.
+    // This is insufficient but for the most basic dynamic layout algorithms.
+    fn render (&self, _b: &mut Buffer, _a: Rect) -> Usually<Rect> {
+        Ok(Rect { x: 0, y: 0, width: 0, height: 0 })
+    }
+}
+
+/// Implement the `Render` trait.
+#[macro_export] macro_rules! render {
+    ($T:ty) => {
+        impl Render for $T {}
+    };
+    ($T:ty |$self:ident, $buf:ident, $area:ident|$block:expr) => {
+        impl Render for $T {
+            fn render (&$self, $buf: &mut Buffer, $area: Rect) -> Usually<Rect> {
+                $block
+            }
+        }
+    };
+    ($T:ty = $render:path) => {
+        impl Render for $T {
+            fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
+                $render(self, buf, area)
+            }
+        }
+    }
+}
+
+impl Render for () {
+    fn render (&self, _: &mut Buffer, a: Rect) -> Usually<Rect> {
+        Ok(Rect { x: a.x, y: a.y, width: 0, height: 0 })
+    }
+}
+
+impl<T: Fn(&mut Buffer, Rect) -> Usually<Rect> + Send> Render for T {
+    fn render (&self, b: &mut Buffer, a: Rect) -> Usually<Rect> {
+        (*self)(b, a)
+    }
+}
+
+impl Render for Box<dyn Device> {
+    fn render (&self, b: &mut Buffer, a: Rect) -> Usually<Rect> {
+        (**self).render(b, a)
+    }
+}
+
+impl<T: Render> Render for Arc<Mutex<T>> {
+    fn render (&self, b: &mut Buffer, a: Rect) -> Usually<Rect> {
+        self.lock().unwrap().render(b, a)
+    }
+}
+
+impl<T: Render + Sync> Render for Arc<RwLock<T>> {
+    fn render (&self, b: &mut Buffer, a: Rect) -> Usually<Rect> {
+        self.read().unwrap().render(b, a)
+    }
+}
+
+impl WidgetRef for &dyn Render {
+    fn render_ref (&self, area: Rect, buf: &mut Buffer) {
+        Render::render(*self, buf, area).expect("Failed to render device.");
+    }
+}
+
+impl WidgetRef for dyn Render {
+    fn render_ref (&self, area: Rect, buf: &mut Buffer) {
+        Render::render(self, buf, area).expect("Failed to render device.");
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    #[test]
+    fn test_line_buffer () {
+        let mut buffer = LineBuffer::new(Cell::default(), 12, 0);
+        assert_eq!(buffer.cells.len(), 0);
+        buffer.put("FOO", 0, 0);
+        assert_eq!(buffer.cells.len(), 12);
+        buffer.put("FOO", 6, 0);
+        assert_eq!(buffer.cells.len(), 12);
+        buffer.put("FOO", 11, 0);
+        assert_eq!(buffer.cells.len(), 12);
+        buffer.put("FOO", 12, 0);
+        assert_eq!(buffer.cells.len(), 12);
+        buffer.put("FOO", 24, 0);
+        assert_eq!(buffer.cells.len(), 12);
+        buffer.put("FOO", 0, 1);
+        assert_eq!(buffer.cells.len(), 24);
+    }
+}

crates/tek/src/core/time.rs

@@ -0,0 +1,152 @@
+use crate::core::*;
+use atomic_float::AtomicF64;
+#[derive(Debug)]
+/// Keeps track of global time units.
+pub struct Timebase {
+    /// Frames per second
+    pub rate: AtomicF64,
+    /// Beats per minute
+    pub bpm:  AtomicF64,
+    /// Ticks per beat
+    pub ppq:  AtomicF64,
+}
+impl Default for Timebase {
+    fn default () -> Self {
+        Self {
+            rate: 48000f64.into(),
+            bpm:  150f64.into(),
+            ppq:  96f64.into(),
+        }
+    }
+}
+impl Timebase {
+    pub fn new (rate: f64, bpm: f64, ppq: f64) -> Self {
+        Self { rate: rate.into(), bpm: bpm.into(), ppq: ppq.into() }
+    }
+
+    /// Frames per second
+    #[inline] fn rate (&self) -> f64 {
+        self.rate.load(Ordering::Relaxed)
+    }
+    #[inline] fn usec_per_frame (&self) -> f64 {
+        1_000_000 as f64 / self.rate() as f64
+    }
+    #[inline] pub fn frame_to_usec (&self, frame: f64) -> f64 {
+        frame * self.usec_per_frame()
+    }
+
+    /// Beats per minute
+    #[inline] pub fn bpm (&self) -> f64 {
+        self.bpm.load(Ordering::Relaxed)
+    }
+    #[inline] pub fn set_bpm (&self, bpm: f64) {
+        self.bpm.store(bpm, Ordering::Relaxed)
+    }
+    #[inline] fn usec_per_beat (&self) -> f64 {
+        60_000_000f64 / self.bpm() as f64
+    }
+    #[inline] fn beat_per_second (&self) -> f64 {
+        self.bpm() as f64 / 60000000.0
+    }
+
+    /// Pulses per beat
+    #[inline] pub fn ppq (&self) -> f64 {
+        self.ppq.load(Ordering::Relaxed)
+    }
+    #[inline] pub fn pulse_per_frame (&self) -> f64 {
+        self.usec_per_pulse() / self.usec_per_frame() as f64
+    }
+    #[inline] pub fn usec_per_pulse (&self) -> f64 {
+        self.usec_per_beat() / self.ppq() as f64
+    }
+    #[inline] pub fn pulse_to_frame (&self, pulses: f64) -> f64 {
+        self.pulse_per_frame() * pulses
+    }
+    #[inline] pub fn frame_to_pulse (&self, frames: f64) -> f64 {
+        frames / self.pulse_per_frame()
+    }
+    #[inline] pub fn note_to_usec (&self, (num, den): (f64, f64)) -> f64 {
+        4.0 * self.usec_per_beat() * num / den
+    }
+    #[inline] pub fn frames_per_pulse (&self) -> f64 {
+        self.rate() as f64 / self.pulses_per_second()
+    }
+    #[inline] fn pulses_per_second (&self) -> f64 {
+        self.beat_per_second() * self.ppq() as f64
+    }
+
+    #[inline] pub fn note_to_frame (&self, note: (f64, f64)) -> f64 {
+        self.usec_to_frame(self.note_to_usec(note))
+    }
+    #[inline] fn usec_to_frame (&self, usec: f64) -> f64 {
+        usec * self.rate() / 1000.0
+    }
+
+    #[inline] pub fn quantize (
+        &self, step: (f64, f64), time: f64
+    ) -> (f64, f64) {
+        let step = self.note_to_usec(step);
+        (time / step, time % step)
+    }
+
+    #[inline] pub fn quantize_into <E, T> (
+        &self, step: (f64, f64), events: E
+    ) -> Vec<(f64, T)>
+        where E: std::iter::Iterator<Item=(f64, T)> + Sized
+    {
+        let step = (step.0.into(), step.1.into());
+        events
+            .map(|(time, event)|(self.quantize(step, time).0, event))
+            .collect()
+    }
+
+}
+
+/// Defines frames per tick.
+pub struct Ticks(pub f64);
+
+impl Ticks {
+    /// Iterate over ticks between start and end.
+    pub fn between_frames (&self, start: usize, end: usize) -> TicksIterator {
+        TicksIterator(self.0, start, start, end)
+    }
+}
+
+/// Iterator that emits subsequent ticks within a range.
+pub struct TicksIterator(f64, usize, usize, usize);
+
+impl Iterator for TicksIterator {
+    type Item = (usize, usize);
+    fn next (&mut self) -> Option<Self::Item> {
+        loop {
+            if self.1 > self.3 {
+                return None
+            }
+            let fpt   = self.0;
+            let frame = self.1 as f64;
+            let start = self.2;
+            let end   = self.3;
+            self.1 = self.1 + 1;
+            //println!("{fpt} {frame} {start} {end}");
+            let jitter = frame.rem_euclid(fpt); // ramps
+            let next_jitter = (frame + 1.0).rem_euclid(fpt);
+            if jitter > next_jitter { // at crossing:
+                let time = (frame as usize) % (end as usize-start as usize);
+                let tick = (frame / fpt) as usize;
+                return Some((time, tick))
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_frames_to_ticks () {
+        let ticks = Ticks(12.3).between_frames(0, 100).collect::<Vec<_>>();
+        println!("{ticks:?}");
+    }
+
+}

crates/tek/src/devices.rs

@@ -0,0 +1,2 @@
+//! Music-making apparatuses.
+crate::core::pubmod!{arranger chain help looper mixer plugin sampler setup sequencer transport}

crates/tek/src/devices/arranger.rs

@@ -0,0 +1,134 @@
+//! Clip launcher and arrangement editor.
+
+use crate::{core::*, model::*};
+use self::arr_focus::ArrangerFocus;
+pub use self::arr_scene::Scene;
+
+submod! { arr_draw_h arr_draw_v arr_focus arr_phrase arr_scene arr_track }
+
+/// Key bindings for arranger section.
+pub const KEYMAP_ARRANGER: &'static [KeyBinding<App>] = keymap!(App {
+    [Char('`'), NONE, "arranger_mode_switch", "switch the display mode", |app: &mut App| {
+        app.arranger.mode.to_next();
+        Ok(true)
+    }],
+    [Up,    NONE, "arranger_cursor_up",    "move cursor up",    |app: &mut App| {
+        match app.arranger.mode {
+            ArrangerViewMode::Horizontal => app.arranger.track_prev(),
+            _ => app.arranger.scene_prev(),
+        };
+        app.sequencer.show(app.arranger.phrase())?;
+        Ok(true)
+    }],
+    [Down,  NONE, "arranger_cursor_down",  "move cursor down",  |app: &mut App| {
+        match app.arranger.mode {
+            ArrangerViewMode::Horizontal => app.arranger.track_next(),
+            _ => app.arranger.scene_next(),
+        };
+        app.sequencer.show(app.arranger.phrase())?;
+        Ok(true)
+    }],
+    [Left,  NONE, "arranger_cursor_left",  "move cursor left",  |app: &mut App| {
+        match app.arranger.mode {
+            ArrangerViewMode::Horizontal => app.arranger.scene_prev(),
+            _ => app.arranger.track_prev(),
+        };
+        app.sequencer.show(app.arranger.phrase())?;
+        Ok(true)
+    }],
+    [Right, NONE, "arranger_cursor_right", "move cursor right", |app: &mut App| {
+        match app.arranger.mode {
+            ArrangerViewMode::Horizontal => app.arranger.scene_next(),
+            _ => app.arranger.track_next(),
+        };
+        app.sequencer.show(app.arranger.phrase())?;
+        Ok(true)
+    }],
+    [Char('.'), NONE, "arranger_increment", "set next clip at cursor", |app: &mut App| {
+        app.arranger.phrase_next();
+        app.sequencer.phrase = app.arranger.phrase().map(Clone::clone);
+        Ok(true)
+    }],
+    [Char(','), NONE, "arranger_decrement", "set previous clip at cursor", |app: &mut App| {
+        app.arranger.phrase_prev();
+        app.sequencer.phrase = app.arranger.phrase().map(Clone::clone);
+        Ok(true)
+    }],
+    [Enter, NONE, "arranger_activate", "activate item at cursor", |app: &mut App| {
+        app.arranger.activate();
+        Ok(true)
+    }],
+});
+
+/// Represents the tracks and scenes of the composition.
+pub struct Arranger {
+    /// Display mode of arranger
+    pub mode: ArrangerViewMode,
+    /// Currently selected element.
+    pub selected: ArrangerFocus,
+    /// Collection of tracks.
+    pub tracks: Vec<Track>,
+    /// Collection of scenes.
+    pub scenes: Vec<Scene>,
+
+    pub focused: bool,
+    pub entered: bool,
+    pub fixed_height: bool,
+}
+
+/// Display mode of arranger
+pub enum ArrangerViewMode {
+    Vertical,
+    VerticalCompact,
+    Horizontal,
+}
+
+impl ArrangerViewMode {
+    fn to_next (&mut self) {
+        *self = match self {
+            Self::Vertical        => Self::VerticalCompact,
+            Self::VerticalCompact => Self::Horizontal,
+            Self::Horizontal      => Self::Vertical,
+        }
+    }
+}
+
+impl Arranger {
+
+    pub fn new () -> Self {
+        Self {
+            mode:         ArrangerViewMode::Vertical,
+            selected:     ArrangerFocus::Clip(0, 0),
+            scenes:       vec![],
+            tracks:       vec![],
+            entered:      true,
+            focused:      true,
+            fixed_height: false,
+        }
+    }
+
+    pub fn activate (&mut self) {
+        match self.selected {
+            ArrangerFocus::Scene(s) => {
+                for (track_index, track) in self.tracks.iter_mut().enumerate() {
+                    track.sequence = self.scenes[s].clips[track_index];
+                    track.reset = true;
+                }
+            },
+            ArrangerFocus::Clip(t, s) => {
+                self.tracks[t].sequence = self.scenes[s].clips[t];
+                self.tracks[t].reset = true;
+            },
+            _ => {}
+        }
+    }
+}
+
+render!(Arranger |self, buf, area| match self.mode {
+    ArrangerViewMode::Horizontal =>
+        self::arr_draw_h::draw(self, buf, area),
+    ArrangerViewMode::Vertical =>
+        self::arr_draw_v::draw_expanded(self, buf, area),
+    ArrangerViewMode::VerticalCompact =>
+        self::arr_draw_v::draw_compact(self, buf, area),
+});

crates/tek/src/devices/arranger/arr_draw_h.rs

@@ -0,0 +1,199 @@
+use crate::{core::*, view::*};
+use super::{Arranger, arr_track::*};
+
+pub fn draw (state: &Arranger, buf: &mut Buffer, mut area: Rect) -> Usually<Rect> {
+    area.height = area.height.min((2 + state.tracks.len() * 2) as u16);
+    Layered([
+        &to_fill_bg(Nord::bg_lo(state.focused, state.entered)),
+        &Split::right([
+            &track_name_column(state),
+            &track_mon_column(state),
+            &track_rec_column(state),
+            &track_ovr_column(state),
+            &track_del_column(state),
+            &track_gain_column(state),
+            &track_scenes_column(state),
+        ]),
+    ]).render(buf, area)
+}
+
+fn track_name_column <'a> (state: &'a Arranger) -> impl Render + 'a {
+    let dim    = Some(Style::default().dim());
+    let yellow = Some(Style::default().yellow().bold().not_dim());
+    let white  = Some(Style::default().white().bold().not_dim());
+    move |buf: &mut Buffer, mut area: Rect| {
+        area.width = 3 + 5.max(track_name_max_len(state.tracks.as_slice())) as u16;
+        let offset = 0; // track scroll offset
+        for y in 0..area.height {
+            if y == 0 {
+                "Mixer".blit(buf, area.x + 1, area.y + y, dim)?;
+            } else if y % 2 == 0 {
+                let index = (y as usize - 2) / 2 + offset;
+                if let Some(track) = state.tracks.get(index) {
+                    let selected = state.selected.track() == Some(index);
+                    let style = if selected { yellow } else { white };
+                    format!(" {index:>02} ").blit(buf, area.x, area.y + y, style)?;
+                    track.name.blit(buf, area.x + 4, area.y + y, style)?;
+                }
+            }
+        }
+        Ok(area)
+    }
+}
+
+fn track_mon_column <'a> (state: &'a Arranger) -> impl Render + 'a {
+    let on  = Some(Style::default().not_dim().green().bold());
+    let off = Some(Style::default().dim());
+    move |buf: &mut Buffer, mut area: Rect| {
+        area.x = area.x + 1;
+        for y in 0..area.height {
+            if y == 0 {
+                //" MON ".blit(buf, area.x, area.y + y, style2)?;
+            } else if y % 2 == 0 {
+                let index = (y as usize - 2) / 2;
+                if let Some(track) = state.tracks.get(index) {
+                    let style = if track.monitoring { on } else { off };
+                    " MON ".blit(buf, area.x, area.y + y, style)?;
+                } else {
+                    area.height = y;
+                    break
+                }
+            }
+        }
+        area.width = 4;
+        Ok(area)
+    }
+}
+
+fn track_rec_column <'a> (state: &'a Arranger) -> impl Render + 'a {
+    let on  = Some(Style::default().not_dim().red().bold());
+    let off = Some(Style::default().dim());
+    move |buf: &mut Buffer, mut area: Rect| {
+        area.x = area.x + 1;
+        for y in 0..area.height {
+            if y == 0 {
+                //" REC ".blit(buf, area.x, area.y + y, style2)?;
+            } else if y % 2 == 0 {
+                let index = (y as usize - 2) / 2;
+                if let Some(track) = state.tracks.get(index) {
+                    let style = if track.recording { on } else { off };
+                    " REC ".blit(buf, area.x, area.y + y, style)?;
+                } else {
+                    area.height = y;
+                    break
+                }
+            }
+        }
+        area.width = 4;
+        Ok(area)
+    }
+}
+
+fn track_ovr_column <'a> (state: &'a Arranger) -> impl Render + 'a {
+    let on  = Some(Style::default().not_dim().yellow().bold());
+    let off = Some(Style::default().dim());
+    move |buf: &mut Buffer, mut area: Rect| {
+        area.x = area.x + 1;
+        for y in 0..area.height {
+            if y == 0 {
+                //" OVR ".blit(buf, area.x, area.y + y, style2)?;
+            } else if y % 2 == 0 {
+                let index = (y as usize - 2) / 2;
+                if let Some(track) = state.tracks.get(index) {
+                    " OVR ".blit(buf, area.x, area.y + y, if track.overdub {
+                        on
+                    } else {
+                        off
+                    })?;
+                } else {
+                    area.height = y;
+                    break
+                }
+            }
+        }
+        area.width = 4;
+        Ok(area)
+    }
+}
+
+fn track_del_column <'a> (state: &'a Arranger) -> impl Render + 'a {
+    let off = Some(Style::default().dim());
+    move |buf: &mut Buffer, mut area: Rect| {
+        area.x = area.x + 1;
+        for y in 0..area.height {
+            if y == 0 {
+                //" DEL ".blit(buf, area.x, area.y + y, style2)?;
+            } else if y % 2 == 0 {
+                let index = (y as usize - 2) / 2;
+                if let Some(_) = state.tracks.get(index) {
+                    " DEL ".blit(buf, area.x, area.y + y, off)?;
+                } else {
+                    area.height = y;
+                    break
+                }
+            }
+        }
+        area.width = 4;
+        Ok(area)
+    }
+}
+
+fn track_gain_column <'a> (state: &'a Arranger) -> impl Render + 'a {
+    let off = Some(Style::default().dim());
+    move |buf: &mut Buffer, mut area: Rect| {
+        area.x = area.x + 1;
+        for y in 0..area.height {
+            if y == 0 {
+                //" GAIN ".blit(buf, area.x, area.y + y, style2)?;
+            } else if y % 2 == 0 {
+                let index = (y as usize - 2) / 2;
+                if let Some(_) = state.tracks.get(index) {
+                    " +0.0 ".blit(buf, area.x, area.y + y, off)?;
+                } else {
+                    area.height = y;
+                    break
+                }
+            }
+        }
+        area.width = 7;
+        Ok(area)
+    }
+}
+
+fn track_scenes_column <'a> (state: &'a Arranger) -> impl Render + 'a {
+    |buf: &mut Buffer, area: Rect| {
+        let mut x2 = 0;
+        let Rect { x, y, height, .. } = area;
+        for (scene_index, scene) in state.scenes.iter().enumerate() {
+            let active_scene = state.selected.scene() == Some(scene_index);
+            let sep = Some(if active_scene {
+                Style::default().yellow().not_dim()
+            } else {
+                Style::default().dim()
+            });
+            for y in y+1..y+height {
+                "│".blit(buf, x + x2, y, sep)?;
+            }
+            let mut x3 = scene.name.len() as u16;
+            scene.name.blit(buf, x + x2, y, sep)?;
+            for (i, clip) in scene.clips.iter().enumerate() {
+                let active_track = state.selected.track() == Some(i);
+                if let Some(clip) = clip {
+                    let y2 = y + 2 + i as u16 * 2;
+                    let label = match state.tracks[i].phrases.get(*clip) {
+                        Some(phrase) => &format!("{}", phrase.read().unwrap().name),
+                        None => "...."
+                    };
+                    label.blit(buf, x + x2, y2, Some(if active_track && active_scene {
+                        Style::default().not_dim().yellow().bold()
+                    } else {
+                        Style::default().not_dim()
+                    }))?;
+                    x3 = x3.max(label.len() as u16)
+                }
+            }
+            x2 = x2 + x3 + 1;
+        }
+        Ok(Rect { x, y, height, width: x2 })
+    }
+}

crates/tek/src/devices/arranger/arr_draw_v.rs

@@ -0,0 +1,225 @@
+use crate::{core::*, view::*};
+use super::{
+    Arranger,
+    arr_focus::ArrangerFocus,
+    arr_track::track_clip_name_lengths,
+    arr_scene::{Scene, scene_ppqs, scene_name_max_len}
+};
+
+pub fn draw_expanded (state: &Arranger, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
+    let track_cols = track_clip_name_lengths(state.tracks.as_slice());
+    let scene_rows = scene_ppqs(state.tracks.as_slice(), state.scenes.as_slice());
+    draw(state, buf, area, track_cols.as_slice(), scene_rows.as_slice())
+}
+
+pub fn draw_compact (state: &Arranger, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
+    let track_cols = track_clip_name_lengths(state.tracks.as_slice());
+    let scene_rows = (0..=state.scenes.len()+3).map(|i|(96, 96*i)).collect::<Vec<_>>();
+    draw(state, buf, area, track_cols.as_slice(), scene_rows.as_slice())
+}
+
+pub fn draw (
+    state: &Arranger,
+    buf: &mut Buffer,
+    mut area: Rect,
+    cols: &[(usize, usize)],
+    rows: &[(usize, usize)],
+) -> Usually<Rect> {
+    area.height = 2 + (rows[rows.len() - 1].1 / 96) as u16;
+    let offset = 3 + scene_name_max_len(state.scenes.as_ref()) as u16;
+    Layered([
+        &to_fill_bg(Nord::bg_lo(state.focused, state.entered)),
+        &column_separators(offset, cols),
+        &cursor_focus(state, offset, cols, rows),
+        &Split::down([
+            &tracks_header(state, cols, offset),
+            &scene_rows(state, cols, rows, offset),
+        ]),
+        &row_separators(rows),
+    ]).render(buf, area)
+}
+
+fn column_separators <'a> (offset: u16, cols: &'a [(usize, usize)]) -> impl Render + 'a {
+    move |buf: &mut Buffer, area: Rect|{
+        let style = Some(Style::default().fg(Nord::SEPARATOR));
+        for (_, x) in cols.iter() {
+            let x = offset + area.x + *x as u16 - 1;
+            for y in area.y..area.height+area.y {
+                "▎".blit(buf, x, y, style)?;
+            }
+        }
+        Ok(area)
+    }
+}
+
+fn row_separators <'a> (rows: &'a [(usize, usize)]) -> impl Render + 'a {
+    move |buf: &mut Buffer, area: Rect| {
+        for (_, y) in rows.iter() {
+            let y = area.y + (*y / 96) as u16 + 1;
+            if y >= buf.area.height {
+                break
+            }
+            for x in area.x..area.width+area.y-2 {
+                let cell = buf.get_mut(x, y);
+                cell.modifier = Modifier::UNDERLINED;
+                cell.underline_color = Nord::SEPARATOR;
+            }
+        }
+        Ok(area)
+    }
+}
+
+fn cursor_focus <'a> (
+    state: &'a Arranger, offset: u16, cols: &'a [(usize, usize)], rows: &'a [(usize, usize)],
+) -> impl Render + 'a {
+    move |buf: &mut Buffer, area: Rect| {
+        match state.selected {
+            ArrangerFocus::Mix => if state.focused
+                && state.entered
+                && state.selected == ArrangerFocus::Mix
+            {
+                fill_bg(buf, area, Nord::bg_hi(state.focused, state.entered));
+                Corners(Style::default().green().not_dim()).draw(buf, area)
+            } else {
+                Ok(area)
+            },
+            ArrangerFocus::Track(t) => {
+                let area = Rect {
+                    x:      offset + area.x + cols[t].1 as u16 - 1,
+                    y:      area.y,
+                    width:  cols[t].0 as u16,
+                    height: area.height
+                };
+                fill_bg(buf, area, Nord::bg_hi(state.focused, state.entered));
+                Corners(Style::default().green().not_dim()).draw(buf, area)
+            },
+            ArrangerFocus::Scene(s) => {
+                let area = Rect {
+                    x:      area.x,
+                    y:      2 + area.y + (rows[s].1 / 96) as u16,
+                    width:  area.width,
+                    height: (rows[s].0 / 96) as u16
+                };
+                fill_bg(buf, area, Nord::bg_hi(state.focused, state.entered));
+                Corners(Style::default().green().not_dim()).draw(buf, area)
+            },
+            ArrangerFocus::Clip(t, s) => {
+                let track_area = Rect {
+                    x:      offset + area.x + cols[t].1 as u16 - 1,
+                    y:      area.y,
+                    width:  cols[t].0 as u16,
+                    height: area.height
+                };
+                let scene_area = Rect {
+                    x:      area.x,
+                    y:      2 + area.y + (rows[s].1 / 96) as u16,
+                    width:  area.width,
+                    height: (rows[s].0 / 96) as u16
+                };
+                let area = Rect {
+                    x:      offset + area.x + cols[t].1 as u16 - 1,
+                    y:      2 + area.y + (rows[s].1 / 96) as u16,
+                    width:  cols[t].0 as u16,
+                    height: (rows[s].0 / 96) as u16
+                };
+                let lo = Nord::bg_hi(state.focused, state.entered);
+                let hi = Nord::bg_hier(state.focused, state.entered);
+                fill_bg(buf, track_area, lo);
+                fill_bg(buf, scene_area, lo);
+                fill_bg(buf, area, hi);
+                Corners(Style::default().green().not_dim()).draw(buf, area)
+            },
+        }
+    }
+}
+
+pub fn tracks_header <'a> (
+    state:      &'a Arranger,
+    track_cols: &'a [(usize, usize)],
+    offset:     u16,
+) -> impl Render + 'a {
+    move |buf: &mut Buffer, area: Rect| {
+        let Rect { y, width, .. } = area;
+        for (track, (_, x)) in state.tracks.iter().zip(track_cols) {
+            let x = *x as u16;
+            if x > width {
+                break
+            }
+            track.name.blit(buf, offset + x, y, Some(Style::default()))?;
+        }
+        Ok(Rect { x: area.x, y, width, height: 2 })
+    }
+}
+
+pub fn scene_rows <'a> (
+    state:      &'a Arranger,
+    track_cols: &'a [(usize, usize)],
+    scene_rows: &'a [(usize, usize)],
+    offset:     u16,
+) -> impl Render + 'a {
+    move |buf: &mut Buffer, area: Rect| {
+        let black = Some(Style::default().fg(Nord::SEPARATOR));
+        let Rect { mut y, height, .. } = area;
+        for (_, x) in track_cols.iter() {
+            let x = *x as u16;
+            if x > 0 {
+                for y in area.y-2..y-2 {
+                    "▎".blit(buf, x - 1, y, black)?;
+                }
+            }
+        }
+        for (scene, (pulses, _)) in state.scenes.iter().zip(scene_rows) {
+            if y > height {
+                break
+            }
+            let h = 1.max((pulses / 96) as u16);
+            scene_row(state, buf, Rect {
+                x: area.x,
+                y,
+                width: area.width,
+                height: h,//.min(area.height - y)
+            }, scene, track_cols, offset)?;
+            y = y + h
+        }
+        Ok(area)
+    }
+}
+
+fn scene_row (
+    state:      &Arranger,
+    buf:        &mut Buffer,
+    area:       Rect,
+    scene:      &Scene,
+    track_cols: &[(usize, usize)],
+    offset:     u16
+) -> Usually<u16> {
+    let Rect { y, width, .. } = area;
+    let tracks = state.tracks.as_ref();
+    let playing = scene.is_playing(tracks);
+    (if playing { "▶" } else { " " }).blit(buf, area.x, y, None)?;
+    scene.name.blit(buf, area.x + 1, y, None)?;
+    let style = Some(Style::default().white());
+    for (track, (w, x)) in track_cols.iter().enumerate() {
+        let x = *x as u16 + offset;
+        if x > width {
+            break
+        }
+        if let (Some(track), Some(Some(clip))) = (
+            tracks.get(track), scene.clips.get(track)
+        ) {
+            if let Some(phrase) = track.phrases.get(*clip) {
+                let phrase = phrase.read().unwrap();
+                phrase.name.blit(buf, x, y, style)?;
+                if track.sequence == Some(*clip) {
+                    fill_bg(buf, Rect {
+                        x: x - 1,
+                        y,
+                        width:  *w as u16,
+                        height: area.height,
+                    }, Nord::PLAYING);
+                }
+            }
+        }
+    }
+    Ok((scene.pulses(tracks) / 96) as u16)
+}

crates/tek/src/devices/arranger/arr_focus.rs

@@ -0,0 +1,95 @@
+#[derive(PartialEq)]
+/// Represents the current user selection in the arranger
+pub enum ArrangerFocus {
+    /** The whole mix is selected */
+    Mix,
+    /// A track is selected.
+    Track(usize),
+    /// A scene is selected.
+    Scene(usize),
+    /// A clip (track × scene) is selected.
+    Clip(usize, usize),
+}
+
+/// Focus identification methods
+impl ArrangerFocus {
+    pub fn is_track (&self) -> bool {
+        match self { Self::Track(_) => true, _ => false }
+    }
+    pub fn is_scene (&self) -> bool {
+        match self { Self::Scene(_) => true, _ => false }
+    }
+    pub fn is_clip (&self) -> bool {
+        match self { Self::Clip(_, _) => true, _ => false }
+    }
+}
+
+/// Track focus methods
+impl ArrangerFocus {
+    pub fn track (&self) -> Option<usize> {
+        match self {
+            Self::Clip(t, _) => Some(*t),
+            Self::Track(t)   => Some(*t),
+            _ => None
+        }
+    }
+    pub fn track_next (&mut self, last_track: usize) {
+        *self = match self {
+            Self::Mix        => Self::Track(0),
+            Self::Track(t)   => Self::Track(last_track.min(*t + 1)),
+            Self::Scene(s)   => Self::Clip(0, *s),
+            Self::Clip(t, s) => Self::Clip(last_track.min(*t + 1), *s),
+        }
+    }
+    pub fn track_prev (&mut self) {
+        *self = match self {
+            Self::Mix      => Self::Mix,
+            Self::Scene(s) => Self::Scene(*s),
+            Self::Track(t) => if *t == 0 {
+                Self::Mix
+            } else {
+                Self::Track(*t - 1)
+            },
+            Self::Clip(t, s) => if *t == 0 {
+                Self::Scene(*s)
+            } else {
+                Self::Clip(t.saturating_sub(1), *s)
+            }
+        }
+    }
+}
+
+/// Scene focus methods
+impl ArrangerFocus {
+    pub fn scene (&self) -> Option<usize> {
+        match self {
+            Self::Clip(_, s) => Some(*s),
+            Self::Scene(s)   => Some(*s),
+            _ => None
+        }
+    }
+    pub fn scene_next (&mut self, last_scene: usize) {
+        *self = match self {
+            Self::Mix        => Self::Scene(0),
+            Self::Track(t)   => Self::Clip(*t, 0),
+            Self::Scene(s)   => Self::Scene(last_scene.min(*s + 1)),
+            Self::Clip(t, s) => Self::Clip(*t, last_scene.min(*s + 1)),
+        }
+    }
+    pub fn scene_prev (&mut self) {
+        *self = match self {
+            Self::Mix      => Self::Mix,
+            Self::Track(t) => Self::Track(*t),
+            Self::Scene(s) => if *s == 0 {
+                Self::Mix
+            } else {
+                Self::Scene(*s - 1)
+            },
+            Self::Clip(t, s) => if *s == 0 {
+                Self::Track(*t)
+            } else {
+                Self::Clip(*t, s.saturating_sub(1))
+            }
+        }
+    }
+}

crates/tek/src/devices/arranger/arr_phrase.rs

@@ -0,0 +1,56 @@
+use crate::{core::*, devices::sequencer::Phrase};
+use super::Arranger;
+
+/// Phrase management methods
+impl Arranger {
+    pub fn phrase (&self) -> Option<&Arc<RwLock<Phrase>>> {
+        let track_id = self.selected.track()?;
+        self.tracks.get(track_id)?.phrases.get((*self.scene()?.clips.get(track_id)?)?)
+    }
+    pub fn phrase_next (&mut self) {
+        let track_index = self.selected.track();
+        let scene_index = self.selected.scene();
+        track_index
+            .and_then(|index|self.tracks.get_mut(index).map(|track|(index, track)))
+            .and_then(|(track_index, track)|{
+                let phrases = track.phrases.len();
+                scene_index
+                    .and_then(|index|self.scenes.get_mut(index))
+                    .and_then(|scene|{
+                        if let Some(phrase_index) = scene.clips[track_index] {
+                            if phrase_index >= phrases - 1 {
+                                scene.clips[track_index] = None;
+                            } else {
+                                scene.clips[track_index] = Some(phrase_index + 1);
+                            }
+                        } else if phrases > 0 {
+                            scene.clips[track_index] = Some(0);
+                        }
+                        Some(())
+                    })
+            });
+    }
+    pub fn phrase_prev (&mut self) {
+        let track_index = self.selected.track();
+        let scene_index = self.selected.scene();
+        track_index
+            .and_then(|index|self.tracks.get_mut(index).map(|track|(index, track)))
+            .and_then(|(track_index, track)|{
+                let phrases = track.phrases.len();
+                scene_index
+                    .and_then(|index|self.scenes.get_mut(index))
+                    .and_then(|scene|{
+                        if let Some(phrase_index) = scene.clips[track_index] {
+                            scene.clips[track_index] = if phrase_index == 0 {
+                                None
+                            } else {
+                                Some(phrase_index - 1)
+                            };
+                        } else if phrases > 0 {
+                            scene.clips[track_index] = Some(phrases - 1);
+                        }
+                        Some(())
+                    })
+            });
+    }
+}

crates/tek/src/devices/arranger/arr_scene.rs

@@ -0,0 +1,79 @@
+use crate::{core::*, model::Track};
+use super::Arranger;
+
+/// A collection of phrases to play on each track.
+pub struct Scene {
+    pub name:  String,
+    pub clips: Vec<Option<usize>>,
+}
+
+impl Scene {
+    pub fn new (name: impl AsRef<str>, clips: impl AsRef<[Option<usize>]>) -> Self {
+        let name = name.as_ref().into();
+        let clips = clips.as_ref().iter().map(|x|x.clone()).collect();
+        Self { name, clips, }
+    }
+    /// Returns the pulse length of the longest phrase in the scene
+    pub fn pulses (&self, tracks: &[Track]) -> usize {
+        self.clips.iter().enumerate()
+            .filter_map(|(i, c)|c.map(|c|tracks[i].phrases.get(c)))
+            .filter_map(|p|p)
+            .fold(0, |a, p|a.max(p.read().unwrap().length))
+    }
+    /// Returns true if all phrases in the scene are currently playing
+    pub fn is_playing (&self, tracks: &[Track]) -> bool {
+        self.clips.iter().enumerate()
+            .all(|(track_index, phrase_index)|match phrase_index {
+                Some(i) => tracks[track_index].sequence == Some(*i),
+                None => true
+            })
+    }
+}
+
+pub fn scene_name_max_len (scenes: &[Scene]) -> usize {
+    scenes.iter()
+        .map(|s|s.name.len())
+        .fold(0, usize::max)
+}
+
+pub fn scene_ppqs (tracks: &[Track], scenes: &[Scene]) -> Vec<(usize, usize)> {
+    let mut total = 0;
+    let mut scenes: Vec<(usize, usize)> = scenes.iter().map(|scene|{
+        let pulses = scene.pulses(tracks);
+        total = total + pulses;
+        (pulses, total - pulses)
+    }).collect();
+    scenes.push((0, total));
+    scenes
+}
+
+/// Scene management methods
+impl Arranger {
+    pub fn scene (&self) -> Option<&Scene> {
+        self.selected.scene().map(|s|self.scenes.get(s)).flatten()
+    }
+    pub fn scene_mut (&mut self) -> Option<&mut Scene> {
+        self.selected.scene().map(|s|self.scenes.get_mut(s)).flatten()
+    }
+    pub fn scene_next (&mut self) {
+        self.selected.scene_next(self.scenes.len() - 1)
+    }
+    pub fn scene_prev (&mut self) {
+        self.selected.scene_prev()
+    }
+    pub fn scene_add (&mut self, name: Option<&str>) -> Usually<&mut Scene> {
+        let clips = vec![None;self.tracks.len()];
+        self.scenes.push(match name {
+            Some(name) => Scene::new(name, clips),
+            None       => Scene::new(&self.scene_default_name(), clips),
+        });
+        let index = self.scenes.len() - 1;
+        Ok(&mut self.scenes[index])
+    }
+    pub fn scene_del (&mut self) {
+        unimplemented!("Arranger::scene_del");
+    }
+    pub fn scene_default_name (&self) -> String {
+        format!("Scene {}", self.scenes.len() + 1)
+    }
+}

crates/tek/src/devices/arranger/arr_track.rs

@@ -0,0 +1,53 @@
+use crate::{core::*, model::Track};
+use super::Arranger;
+
+/// Track management methods
+impl Arranger {
+    pub fn track (&self) -> Option<&Track> {
+        self.selected.track().map(|t|self.tracks.get(t)).flatten()
+    }
+    pub fn track_mut (&mut self) -> Option<&mut Track> {
+        self.selected.track().map(|t|self.tracks.get_mut(t)).flatten()
+    }
+    pub fn track_next (&mut self) {
+        self.selected.track_next(self.tracks.len() - 1)
+    }
+    pub fn track_prev (&mut self) {
+        self.selected.track_prev()
+    }
+    pub fn track_add (&mut self, name: Option<&str>) -> Usually<&mut Track> {
+        self.tracks.push(name.map_or_else(
+            || Track::new(&self.track_default_name()),
+            |name| Track::new(name),
+        )?);
+        let index = self.tracks.len() - 1;
+        Ok(&mut self.tracks[index])
+    }
+    pub fn track_del (&mut self) {
+        unimplemented!("Arranger::track_del");
+    }
+    pub fn track_default_name (&self) -> String {
+        format!("Track {}", self.tracks.len() + 1)
+    }
+}
+
+pub fn track_name_max_len (tracks: &[Track]) -> usize {
+    tracks.iter()
+        .map(|s|s.name.len())
+        .fold(0, usize::max)
+}
+
+pub fn track_clip_name_lengths (tracks: &[Track]) -> Vec<(usize, usize)> {
+    let mut total = 0;
+    let mut lengths: Vec<(usize, usize)> = tracks.iter().map(|track|{
+        let len = 2 + track.phrases
+            .iter()
+            .fold(track.name.len(), |len, phrase|{
+                len.max(phrase.read().unwrap().name.len())
+            });
+        total = total + len;
+        (len, total - len)
+    }).collect();
+    lengths.push((0, total));
+    lengths
+}

crates/tek/src/devices/chain.rs

@@ -0,0 +1,55 @@
+use crate::{core::*, model::*, view::*};
+
+pub struct ChainView<'a> {
+    pub track:     Option<&'a Track>,
+    pub direction: Direction,
+    pub focused:   bool,
+    pub entered:   bool,
+}
+
+impl<'a> ChainView<'a> {
+    pub fn horizontal (app: &'a App) -> Self {
+        Self::new(app, Direction::Right)
+    }
+    pub fn vertical (app: &'a App) -> Self {
+        Self::new(app, Direction::Down)
+    }
+    pub fn new (app: &'a App, direction: Direction) -> Self {
+        Self {
+            direction,
+            entered:  app.entered,
+            focused:  app.section == AppFocus::Chain,
+            track:    app.arranger.track()
+        }
+    }
+}
+
+impl<'a> Render for ChainView<'a> {
+    fn render (&self, buf: &mut Buffer, mut area: Rect) -> Usually<Rect> {
+        if let Some(track) = self.track {
+            match self.direction {
+                Direction::Down  => area.width = area.width.min(40),
+                Direction::Right => area.width = area.width.min(10),
+            }
+            fill_bg(buf, area, Nord::bg_lo(self.focused, self.entered));
+            let (area, areas) = self.direction
+                .split_focus(0, track.devices.as_slice(), if self.focused {
+                    Style::default().green().dim()
+                } else {
+                    Style::default().dim()
+                })
+                .render_areas(buf, area)?;
+            if self.focused && self.entered {
+                Corners(Style::default().green().not_dim()).draw(buf, areas[0])?;
+            }
+            Ok(area)
+        } else {
+            let Rect { x, y, width, height } = area;
+            let label = "No track selected";
+            let x = x + (width - label.len() as u16) / 2;
+            let y = y + height / 2;
+            label.blit(buf, x, y, Some(Style::default().dim().bold()))?;
+            Ok(area)
+        }
+    }
+}

crates/tek/src/devices/help.rs

@@ -0,0 +1,88 @@
+//! Help modal / command palette.
+
+use crate::{core::*, view::*};
+
+/// Command palette.
+pub struct HelpModal {
+    cursor: usize,
+    search: Option<String>,
+    exited: bool,
+}
+impl HelpModal {
+    pub fn new () -> Self {
+        Self { cursor: 0, search: None, exited: false }
+    }
+}
+exit!(HelpModal);
+
+render!(HelpModal |self, buf, area|{
+    make_dim(buf);
+    let area = center_box(area, 64, 20);
+    fill_fg(buf, area, Color::Reset);
+    fill_bg(buf, area, Nord::bg_lo(true, true));
+    fill_char(buf, area, ' ');
+    let x = area.x + 2;
+    let y = area.y + 1;
+    "Command:"
+        .blit(buf, x,     y, Some(Style::default().bold()))?;
+    " ".repeat(area.width as usize - 13)
+        .blit(buf, x + 9, y, Some(Style::default().bg(Color::Reset)))?;
+    if let Some(search) = self.search.as_ref() {
+        search.blit(buf, x + 9, y, Some(Style::default().not_dim()))?;
+    }
+    let y = y + 1;
+    fill_char(buf, Rect { y, height: 1, ..area }, '-');
+    let y = y + 1;
+    for i in 0..area.height-3 {
+        let y = y + i;
+        if let Some(command) = crate::control::KEYMAP_FOCUS.get(i as usize) {
+            format!("{:?}", command.0).blit(buf, x, y, Some(Style::default().white().bold()))?;
+            command.2.blit(buf, x + 11, y, Some(Style::default().white().bold()))?;
+            command.3.blit(buf, x + 26, y, Some(Style::default().white().dim()))?;
+        } else if let Some(command) = crate::control::KEYMAP_GLOBAL.get((i as usize) - crate::control::KEYMAP_FOCUS.len()) {
+            format!("{:?}", command.0).blit(buf, x, y, Some(Style::default().white().bold()))?;
+            command.2.blit(buf, x + 11, y, Some(Style::default().white().bold()))?;
+            command.3.blit(buf, x + 26, y, Some(Style::default().white().dim()))?;
+        } else {
+            break
+        }
+    }
+    let hi_area = Rect { x: area.x + 1, width: area.width - 2, y: area.y + 3 + self.cursor as u16, height: 1 };
+    fill_bg(buf, hi_area, Nord::bg_hi(true, true));
+    fill_fg(buf, hi_area, Color::White);
+    Lozenge(Style::default()).draw(buf, area)
+});
+
+handle!(HelpModal |self, e| {
+    if handle_keymap(self, e, KEYMAP_HELP)? {
+        return Ok(true)
+    }
+    Ok(match e {
+        AppEvent::Input(Event::Key(KeyEvent {
+            code:      KeyCode::Char(c),
+            modifiers: KeyModifiers::NONE, ..
+        })) => {
+            if self.search.is_none() {
+                self.search = Some(String::new());
+            }
+            self.search.as_mut().unwrap().push(*c);
+            true
+        },
+        _ => true
+    })
+});
+
+pub const KEYMAP_HELP: &'static [KeyBinding<HelpModal>] = keymap!(HelpModal {
+    [Esc,  NONE, "help_close", "close help dialog",       |modal: &mut HelpModal|{
+        modal.exit();
+        Ok(true)
+    }],
+    [Up,   NONE, "help_prev",  "select previous command", |modal: &mut HelpModal|{
+        modal.cursor = modal.cursor.saturating_sub(1);
+        Ok(true)
+    }],
+    [Down, NONE, "help_next",  "select next command",     |modal: &mut HelpModal|{
+        modal.cursor = modal.cursor + 1;
+        Ok(true)
+    }],
+});

crates/tek/src/devices/looper.rs

@@ -0,0 +1,12 @@
+//! TODO: audio looper (merge with [crate::devices::sampler::Sampler]?)
+
+use crate::core::*;
+
+pub struct Looper {
+    pub name: String
+}
+render!(Looper);
+handle!(Looper);
+process!(Looper);
+ports!(Looper);
+

crates/tek/src/devices/mixer.rs

@@ -0,0 +1,190 @@
+//! TODO: audio mixer (merge with [crate::devices::arranger::Arranger]?)
+
+use crate::core::*;
+
+// TODO:
+// - Meters: propagate clipping:
+//   - If one stage clips, all stages after it are marked red
+//   - If one track clips, all tracks that feed from it are marked red?
+
+//pub const ACTIONS: [(&'static str, &'static str);2] = [
+    //("+/-",     "Adjust"),
+    //("Ins/Del", "Add/remove track"),
+//];
+
+pub struct Mixer {
+    pub name:            String,
+    pub tracks:          Vec<MixerTrack>,
+    pub selected_track:  usize,
+    pub selected_column: usize,
+}
+//render!(Mixer = crate::view::mixer::render);
+handle!(Mixer = handle_mixer);
+process!(Mixer = process);
+
+impl Mixer {
+    pub fn new (name: &str) -> Usually<Self> {
+        let (client, _status) = Client::new(name, ClientOptions::NO_START_SERVER)?;
+        Ok(Self {
+            name: name.into(),
+            selected_column: 0,
+            selected_track:  1,
+            tracks: vec![
+                MixerTrack::new(&client, 1, "Mono 1")?,
+                MixerTrack::new(&client, 1, "Mono 2")?,
+                MixerTrack::new(&client, 2, "Stereo 1")?,
+                MixerTrack::new(&client, 2, "Stereo 2")?,
+                MixerTrack::new(&client, 2, "Stereo 3")?,
+                MixerTrack::new(&client, 2, "Bus 1")?,
+                MixerTrack::new(&client, 2, "Bus 2")?,
+                MixerTrack::new(&client, 2, "Mix")?,
+            ],
+        })
+    }
+}
+
+fn process (
+    _: &mut Mixer,
+    _: &Client,
+    _: &ProcessScope
+) -> Control {
+    Control::Continue
+}
+
+/// TODO: A track in the mixer. (Integrate with [crate::model::Track]?)
+pub struct MixerTrack {
+    pub name:              String,
+    pub channels:          u8,
+    pub input_ports:       Vec<Port<AudioIn>>,
+    pub pre_gain_meter:    f64,
+    pub gain:              f64,
+    pub insert_ports:      Vec<Port<AudioOut>>,
+    pub return_ports:      Vec<Port<AudioIn>>,
+    pub post_gain_meter:   f64,
+    pub post_insert_meter: f64,
+    pub level:             f64,
+    pub pan:               f64,
+    pub output_ports:      Vec<Port<AudioOut>>,
+    pub post_fader_meter:  f64,
+    pub route:             String,
+}
+
+impl MixerTrack {
+    pub fn new (jack: &Client, channels: u8, name: &str) -> Usually<Self> {
+        let mut input_ports  = vec![];
+        let mut insert_ports = vec![];
+        let mut return_ports = vec![];
+        let mut output_ports = vec![];
+        for channel in 1..=channels {
+            input_ports.push(jack.register_port(&format!("{name} [input {channel}]"),   AudioIn::default())?);
+            output_ports.push(jack.register_port(&format!("{name} [out {channel}]"),    AudioOut::default())?);
+            let insert_port = jack.register_port(&format!("{name} [pre {channel}]"),    AudioOut::default())?;
+            let return_port = jack.register_port(&format!("{name} [insert {channel}]"), AudioIn::default())?;
+            jack.connect_ports(&insert_port, &return_port)?;
+            insert_ports.push(insert_port);
+            return_ports.push(return_port);
+        }
+        Ok(Self {
+            name:              name.into(),
+            channels,
+            input_ports,
+            pre_gain_meter:    0.0,
+            gain:              0.0,
+            post_gain_meter:   0.0,
+            insert_ports,
+            return_ports,
+            post_insert_meter: 0.0,
+            level:             0.0,
+            pan:               0.0,
+            post_fader_meter:  0.0,
+            route:             "---".into(),
+            output_ports,
+        })
+    }
+}
+
+//impl<W: Write> Input<TUI<W>, bool> for Mixer {
+    //fn handle (&mut self, engine: &mut TUI<W>) -> Result<Option<bool>> {
+        //Ok(None)
+    //}
+//
+
+//impl<W: Write> Output<TUI<W>, [u16;2]> for Mixer {
+    //fn render (&self, envine: &mut TUI<W>) -> Result<Option<[u16;2]>> {
+
+        //let tracks_table = Columns::new()
+            //.add(titles)
+            //.add(input_meters)
+            //.add(gains)
+            //.add(gain_meters)
+            //.add(pres)
+            //.add(pre_meters)
+            //.add(levels)
+            //.add(pans)
+            //.add(pan_meters)
+            //.add(posts)
+            //.add(routes)
+
+        //Rows::new()
+            //.add(Columns::new()
+                //.add(Rows::new()
+                    //.add("[Arrows]".bold())
+                    //.add("Navigate"))
+                //.add(Rows::new()
+                    //.add("[+/-]".bold())
+                    //.add("Adjust"))
+                //.add(Rows::new()
+                    //.add("[Ins/Del]".bold())
+                    //.add("Add/remove track")))
+            //.add(tracks_table)
+            //.render(engine)
+    //}
+//}
+
+pub fn handle_mixer (state: &mut Mixer, event: &AppEvent) -> Usually<bool> {
+    if let AppEvent::Input(crossterm::event::Event::Key(event)) = event {
+
+        match event.code {
+            //KeyCode::Char('c') => {
+                //if event.modifiers == KeyModifiers::CONTROL {
+                    //state.exit();
+                //}
+            //},
+            KeyCode::Down => {
+                state.selected_track = (state.selected_track + 1) % state.tracks.len();
+                println!("{}", state.selected_track);
+                return Ok(true)
+            },
+            KeyCode::Up => {
+                if state.selected_track == 0 {
+                    state.selected_track = state.tracks.len() - 1;
+                } else {
+                    state.selected_track = state.selected_track - 1;
+                }
+                println!("{}", state.selected_track);
+                return Ok(true)
+            },
+            KeyCode::Left => {
+                if state.selected_column == 0 {
+                    state.selected_column = 6
+                } else {
+                    state.selected_column = state.selected_column - 1;
+                }
+                return Ok(true)
+            },
+            KeyCode::Right => {
+                if state.selected_column == 6 {
+                    state.selected_column = 0
+                } else {
+                    state.selected_column = state.selected_column + 1;
+                }
+                return Ok(true)
+            },
+            _ => {
+                println!("\n{event:?}");
+            }
+        }
+
+    }
+    Ok(false)
+}

crates/tek/src/devices/plugin.rs

@@ -0,0 +1,227 @@
+//! Plugin (currently LV2 only; TODO other formats)
+
+use crate::core::*;
+
+submod! { lv2 }
+
+pub fn handle_plugin (state: &mut Plugin, event: &AppEvent) -> Usually<bool> {
+    handle_keymap(state, event, KEYMAP_PLUGIN)
+}
+
+/// Key bindings for plugin device.
+pub const KEYMAP_PLUGIN: &'static [KeyBinding<Plugin>] = keymap!(Plugin {
+    [Up,        NONE, "/plugin/cursor_up",   "move cursor up",   |s: &mut Plugin|{
+        s.selected = s.selected.saturating_sub(1);
+        Ok(true)
+    }],
+    [Down,      NONE, "/plugin/cursor_down", "move cursor down", |s: &mut Plugin|{
+        s.selected = (s.selected + 1).min(match &s.plugin {
+            Some(PluginKind::LV2(LV2Plugin { port_list, .. })) => port_list.len() - 1,
+            _ => unimplemented!()
+        });
+        Ok(true)
+    }],
+    [PageUp,    NONE, "/plugin/cursor_page_up",   "move cursor up",   |s: &mut Plugin|{
+        s.selected = s.selected.saturating_sub(8);
+        Ok(true)
+    }],
+    [PageDown,  NONE, "/plugin/cursor_page_down", "move cursor down", |s: &mut Plugin|{
+        s.selected = (s.selected + 10).min(match &s.plugin {
+            Some(PluginKind::LV2(LV2Plugin { port_list, .. })) => port_list.len() - 1,
+            _ => unimplemented!()
+        });
+        Ok(true)
+    }],
+    [Char(','), NONE, "/plugin/decrement",   "decrement value",  |s: &mut Plugin|{
+        match s.plugin.as_mut() {
+            Some(PluginKind::LV2(LV2Plugin { port_list, ref mut instance, .. })) => {
+                let index = port_list[s.selected].index;
+                if let Some(value) = instance.control_input(index) {
+                    instance.set_control_input(index, value - 0.01);
+                }
+            },
+            _ => {}
+        }
+        Ok(true)
+    }],
+    [Char('.'), NONE, "/plugin/decrement",   "increment value",  |s: &mut Plugin|{
+        match s.plugin.as_mut() {
+            Some(PluginKind::LV2(LV2Plugin { port_list, ref mut instance, .. })) => {
+                let index = port_list[s.selected].index;
+                if let Some(value) = instance.control_input(index) {
+                    instance.set_control_input(index, value + 0.01);
+                }
+            },
+            _ => {}
+        }
+        Ok(true)
+    }],
+    [Char('g'), NONE, "/plugin/gui_toggle", "toggle plugin UI", |s: &mut Plugin|{
+        match s.plugin {
+            Some(PluginKind::LV2(ref mut plugin)) => {
+                plugin.ui_thread = Some(run_lv2_ui(LV2PluginUI::new()?)?);
+            },
+            Some(_) => unreachable!(),
+            None => {}
+        }
+        Ok(true)
+    }],
+});
+
+/// A plugin device.
+pub struct Plugin {
+    pub name:     String,
+    pub path:     Option<String>,
+    pub plugin:   Option<PluginKind>,
+    pub selected: usize,
+    pub mapping:  bool,
+    pub ports:    JackPorts,
+}
+render!(Plugin = render_plugin);
+handle!(Plugin = handle_plugin);
+process!(Plugin = Plugin::process);
+
+/// Supported plugin formats.
+pub enum PluginKind {
+    LV2(LV2Plugin),
+    VST2 {
+        instance: ::vst::host::PluginInstance
+    },
+    VST3,
+}
+
+impl Plugin {
+    /// Create a plugin host device.
+    pub fn new (name: &str) -> Usually<Self> {
+        Ok(Self {
+            name:       name.into(),
+            path:       None,
+            plugin:     None,
+            selected:   0,
+            mapping:    false,
+            ports:      JackPorts::default()
+        })
+    }
+    pub fn process (&mut self, _: &Client, scope: &ProcessScope) -> Control {
+        match self.plugin.as_mut() {
+            Some(PluginKind::LV2(LV2Plugin {
+                features,
+                ref mut instance,
+                ref mut input_buffer,
+                ..
+            })) => {
+                let urid = features.midi_urid();
+                input_buffer.clear();
+                for port in self.ports.midi_ins.values() {
+                    let mut atom = ::livi::event::LV2AtomSequence::new(
+                        &features,
+                        scope.n_frames() as usize
+                    );
+                    for event in port.iter(scope) {
+                        match event.bytes.len() {
+                            3 => atom.push_midi_event::<3>(
+                                event.time as i64,
+                                urid,
+                                &event.bytes[0..3]
+                            ).unwrap(),
+                            _ => {}
+                        }
+                    }
+                    input_buffer.push(atom);
+                }
+                let mut outputs = vec![];
+                for _ in self.ports.midi_outs.iter() {
+                    outputs.push(::livi::event::LV2AtomSequence::new(
+                        &features,
+                        scope.n_frames() as usize
+                    ));
+                }
+                let ports = ::livi::EmptyPortConnections::new()
+                    .with_atom_sequence_inputs(
+                        input_buffer.iter()
+                    )
+                    .with_atom_sequence_outputs(
+                        outputs.iter_mut()
+                    )
+                    .with_audio_inputs(
+                        self.ports.audio_ins.values().map(|o|o.as_slice(scope))
+                    )
+                    .with_audio_outputs(
+                        self.ports.audio_outs.values_mut().map(|o|o.as_mut_slice(scope))
+                    );
+                unsafe {
+                    instance.run(scope.n_frames() as usize, ports).unwrap()
+                };
+            },
+            _ => {}
+        }
+        Control::Continue
+    }
+}
+
+pub fn render_plugin (state: &Plugin, buf: &mut Buffer, area: Rect)
+    -> Usually<Rect>
+{
+    let Rect { x, y, height, .. } = area;
+    let mut width = 20u16;
+    match &state.plugin {
+        Some(PluginKind::LV2(LV2Plugin { port_list, instance, .. })) => {
+            let start = state.selected.saturating_sub((height as usize / 2).saturating_sub(1));
+            let end   = start + height as usize - 2;
+            //draw_box(buf, Rect { x, y, width, height });
+            for i in start..end {
+                if let Some(port) = port_list.get(i) {
+                    let value = if let Some(value) = instance.control_input(port.index) {
+                        value
+                    } else {
+                        port.default_value
+                    };
+                    //let label = &format!("C·· M·· {:25} = {value:.03}", port.name);
+                    let label = &format!("{:25} = {value:.03}", port.name);
+                    width = width.max(label.len() as u16 + 4);
+                    label.blit(buf, x + 2, y + 1 + i as u16 - start as u16, if i == state.selected {
+                        Some(Style::default().green())
+                    } else {
+                        None
+                    })?;
+                } else {
+                    break
+                }
+            }
+        },
+        _ => {}
+    };
+    draw_header(state, buf, area.x, area.y, width)?;
+    Ok(Rect { width, ..area })
+}
+
+fn draw_header (state: &Plugin, buf: &mut Buffer, x: u16, y: u16, w: u16) -> Usually<Rect> {
+    let style  = Style::default().gray();
+    let label1 = format!(" {}", state.name);
+    label1.blit(buf, x + 1, y, Some(style.white().bold()))?;
+    if let Some(ref path) = state.path {
+        let label2 = format!("{}…", &path[..((w as usize - 10).min(path.len()))]);
+        label2.blit(buf, x + 2 + label1.len() as u16, y, Some(style.not_dim()))?;
+    }
+    Ok(Rect { x, y, width: w, height: 1 })
+}
+
+impl ::vst::host::Host for Plugin {}
+
+fn set_vst_plugin (host: &Arc<Mutex<Plugin>>, _path: &str) -> Usually<PluginKind> {
+    let mut loader = ::vst::host::PluginLoader::load(
+        &std::path::Path::new("/nix/store/ij3sz7nqg5l7v2dygdvzy3w6cj62bd6r-helm-0.9.0/lib/lxvst/helm.so"),
+        host.clone()
+    )?;
+    Ok(PluginKind::VST2 {
+        instance: loader.instance()?
+    })
+}
+
+//pub struct LV2PluginUI {
+    //write:      (),
+    //controller: (),
+    //widget:     (),
+    //features:   (),
+    //transfer:   (),
+//}

crates/tek/src/devices/plugin/lv2.rs

@@ -0,0 +1,123 @@
+use super::*;
+use ::livi::{
+    World,
+    Instance,
+    Plugin as LiviPlugin,
+    Features,
+    FeaturesBuilder,
+    Port,
+    event::LV2AtomSequence,
+};
+use ::winit::{
+    application::ApplicationHandler,
+    event::WindowEvent,
+    event_loop::{ActiveEventLoop, ControlFlow, EventLoop},
+    window::{Window, WindowId},
+    platform::x11::EventLoopBuilderExtX11
+};
+use ::suil::{self};
+
+impl Plugin {
+    pub fn lv2 (name: &str, path: &str) -> Usually<JackDevice> {
+        let plugin = LV2Plugin::new(path)?;
+        Jack::new(name)?
+            .ports_from_lv2(&plugin.plugin)
+            .run(|ports|Box::new(Self {
+                name:       name.into(),
+                path:       Some(String::from(path)),
+                plugin:     Some(PluginKind::LV2(plugin)),
+                selected:   0,
+                mapping:    false,
+                ports
+            }))
+    }
+}
+
+/// A LV2 plugin.
+pub struct LV2Plugin {
+    pub world:        World,
+    pub instance:     Instance,
+    pub plugin:       LiviPlugin,
+    pub features:     Arc<Features>,
+    pub port_list:    Vec<Port>,
+    pub input_buffer: Vec<LV2AtomSequence>,
+    pub ui_thread:    Option<JoinHandle<()>>,
+}
+
+impl LV2Plugin {
+    pub fn new (uri: &str) -> Usually<Self> {
+        // Get 1st plugin at URI
+        let world    = World::with_load_bundle(&uri);
+        let features = FeaturesBuilder { min_block_length: 1, max_block_length: 65536 };
+        let features = world.build_features(features);
+        let mut plugin = None;
+        for p in world.iter_plugins() {
+            plugin = Some(p);
+            break
+        }
+        let plugin = plugin.unwrap();
+        let err = &format!("init {uri}");
+
+        // Instantiate
+        Ok(Self {
+            world,
+            instance: unsafe {
+                plugin
+                    .instantiate(features.clone(), 48000.0)
+                    .expect(&err)
+            },
+            port_list: {
+                let mut port_list = vec![];
+                for port in plugin.ports() {
+                    port_list.push(port);
+                }
+                port_list
+            },
+            plugin,
+            features,
+            input_buffer: Vec::with_capacity(1024),
+            ui_thread: None
+        })
+    }
+}
+
+pub fn run_lv2_ui (mut ui: LV2PluginUI) -> Usually<JoinHandle<()>> {
+    Ok(spawn(move||{
+        let event_loop = EventLoop::builder().with_x11().with_any_thread(true).build().unwrap();
+        event_loop.set_control_flow(ControlFlow::Wait);
+        event_loop.run_app(&mut ui).unwrap()
+    }))
+}
+
+/// A LV2 plugin's X11 UI.
+pub struct LV2PluginUI {
+    pub window: Option<Window>
+}
+
+impl LV2PluginUI {
+    pub fn new () -> Usually<Self> {
+        Ok(Self { window: None })
+    }
+}
+
+impl ApplicationHandler for LV2PluginUI {
+    fn resumed (&mut self, event_loop: &ActiveEventLoop) {
+        self.window = Some(event_loop.create_window(Window::default_attributes()).unwrap());
+    }
+    fn window_event (&mut self, event_loop: &ActiveEventLoop, id: WindowId, event: WindowEvent) {
+        match event {
+            WindowEvent::CloseRequested => {
+                self.window.as_ref().unwrap().set_visible(false);
+                event_loop.exit();
+            },
+            WindowEvent::RedrawRequested => {
+                self.window.as_ref().unwrap().request_redraw();
+            }
+            _ => (),
+        }
+    }
+}
+
+fn lv2_ui_instantiate (kind: &str) {
+    //let host = Suil
+}

crates/tek/src/devices/sampler.rs

@@ -0,0 +1,201 @@
+//! Sampler (currently 16bit WAVs at system rate; TODO convert/resample)
+
+use crate::{core::*, view::*, model::MODAL};
+
+submod! { add_sample sample voice }
+
+/// The sampler plugin plays sounds.
+pub struct Sampler {
+    pub name:        String,
+    pub cursor:      (usize, usize),
+    pub editing:     Option<Arc<RwLock<Sample>>>,
+    pub mapped:      BTreeMap<u7, Arc<RwLock<Sample>>>,
+    pub unmapped:    Vec<Arc<RwLock<Sample>>>,
+    pub voices:      Arc<RwLock<Vec<Voice>>>,
+    pub ports:       JackPorts,
+    pub buffer:      Vec<Vec<f32>>,
+    pub output_gain: f32
+}
+
+render!(Sampler |self, buf, area| {
+    let Rect { x, y, height, .. } = area;
+    let style = Style::default().gray();
+    let title = format!(" {} ({})", self.name, self.voices.read().unwrap().len());
+    title.blit(buf, x+1, y, Some(style.white().bold().not_dim()))?;
+    let mut width = title.len() + 2;
+    let mut y1 = 1;
+    let mut j = 0;
+    for (note, sample) in self.mapped.iter()
+        .map(|(note, sample)|(Some(note), sample))
+        .chain(self.unmapped.iter().map(|sample|(None, sample)))
+    {
+        if y1 >= height {
+            break
+        }
+        let active = j == self.cursor.0;
+        width = width.max(draw_sample(buf, x, y + y1, note, &*sample.read().unwrap(), active)?);
+        y1 = y1 + 1;
+        j = j + 1;
+    }
+    let height = ((2 + y1) as u16).min(height);
+    Ok(Rect { x, y, width: (width as u16).min(area.width), height })
+});
+
+fn draw_sample (
+    buf: &mut Buffer, x: u16, y: u16, note: Option<&u7>, sample: &Sample, focus: bool
+) -> Usually<usize> {
+    let style = if focus { Style::default().green() } else { Style::default() };
+    if focus {
+        "🬴".blit(buf, x+1, y, Some(style.bold()))?;
+    }
+    let label1 = format!("{:3} {:12}",
+        note.map(|n|n.to_string()).unwrap_or(String::default()),
+        sample.name);
+    let label2 = format!("{:>6} {:>6}  +0.0",
+        sample.start,
+        sample.end);
+    label1.blit(buf, x+2, y, Some(style.bold()))?;
+    label2.blit(buf, x+3+label1.len()as u16, y, Some(style))?;
+    Ok(label1.len() + label2.len() + 4)
+}
+
+handle!(Sampler |self, event| handle_keymap(self, event, KEYMAP_SAMPLER));
+
+/// Key bindings for sampler device.
+pub const KEYMAP_SAMPLER: &'static [KeyBinding<Sampler>] = keymap!(Sampler {
+    [Up, NONE, "/sampler/cursor/up", "move cursor up", |state: &mut Sampler| {
+        state.cursor.0 = if state.cursor.0 == 0 {
+            state.mapped.len() + state.unmapped.len() - 1
+        } else {
+            state.cursor.0 - 1
+        };
+        Ok(true)
+    }],
+    [Down, NONE, "/sampler/cursor/down", "move cursor down", |state: &mut Sampler| {
+        state.cursor.0 = (state.cursor.0 + 1) % (state.mapped.len() + state.unmapped.len());
+        Ok(true)
+    }],
+    [Char('p'), NONE, "/sampler/play", "play current sample",  |state: &mut Sampler| {
+        if let Some(sample) = state.sample() {
+            state.voices.write().unwrap().push(Sample::play(sample, 0, &100.into()));
+        }
+        Ok(true)
+    }],
+    [Char('a'), NONE, "/sampler/add", "add a new sample", |state: &mut Sampler| {
+        let sample = Arc::new(RwLock::new(Sample::new("", 0, 0, vec![])));
+        *MODAL.lock().unwrap() = Some(Exit::boxed(AddSampleModal::new(&sample, &state.voices)?));
+        state.unmapped.push(sample);
+        Ok(true)
+    }],
+    [Char('r'), NONE, "/sampler/replace", "replace selected sample", |state: &mut Sampler| {
+        if let Some(sample) = state.sample() {
+            *MODAL.lock().unwrap() = Some(Exit::boxed(AddSampleModal::new(&sample, &state.voices)?));
+        }
+        Ok(true)
+    }],
+    [Enter, NONE, "/sampler/edit", "edit selected sample", |state: &mut Sampler| {
+        if let Some(sample) = state.sample() {
+            state.editing = Some(sample.clone());
+        }
+        Ok(true)
+    }],
+});
+
+process!(Sampler = Sampler::process);
+
+impl Sampler {
+    pub fn new (name: &str, mapped: Option<BTreeMap<u7, Arc<RwLock<Sample>>>>) -> Usually<JackDevice> {
+        Jack::new(name)?
+            .midi_in("midi")
+            .audio_in("recL")
+            .audio_in("recR")
+            .audio_out("outL")
+            .audio_out("outR")
+            .run(|ports|Box::new(Self {
+                name:     name.into(),
+                cursor:   (0, 0),
+                editing:  None,
+                mapped:   mapped.unwrap_or_else(||BTreeMap::new()),
+                unmapped: vec![],
+                voices:   Arc::new(RwLock::new(vec![])),
+                ports,
+                buffer:   vec![vec![0.0;16384];2],
+                output_gain: 0.5,
+            }))
+    }
+
+    /// Immutable reference to sample at cursor.
+    pub fn sample (&self) -> Option<&Arc<RwLock<Sample>>> {
+        for (i, sample) in self.mapped.values().enumerate() {
+            if i == self.cursor.0 {
+                return Some(sample)
+            }
+        }
+        for (i, sample) in self.unmapped.iter().enumerate() {
+            if i + self.mapped.len() == self.cursor.0 {
+                return Some(sample)
+            }
+        }
+        None
+    }
+
+    pub fn process (&mut self, _: &Client, scope: &ProcessScope) -> Control {
+        self.process_midi_in(scope);
+        self.clear_output_buffer();
+        self.process_audio_out(scope);
+        self.write_output_buffer(scope);
+        Control::Continue
+    }
+
+    /// Create [Voice]s from [Sample]s in response to MIDI input.
+    fn process_midi_in (&mut self, scope: &ProcessScope) {
+        for RawMidi { time, bytes } in self.ports.midi_ins.get("midi").unwrap().iter(scope) {
+            if let LiveEvent::Midi { message, .. } = LiveEvent::parse(bytes).unwrap() {
+                if let MidiMessage::NoteOn { ref key, ref vel } = message {
+                    if let Some(sample) = self.mapped.get(key) {
+                        self.voices.write().unwrap().push(Sample::play(sample, time as usize, vel));
+                    }
+                }
+            }
+        }
+    }
+
+    /// Zero the output buffer.
+    fn clear_output_buffer (&mut self) {
+        for buffer in self.buffer.iter_mut() {
+            buffer.fill(0.0);
+        }
+    }
+
+    /// Mix all currently playing samples into the output.
+    fn process_audio_out (&mut self, scope: &ProcessScope) {
+        let channel_count = self.buffer.len();
+        self.voices.write().unwrap().retain_mut(|voice|{
+            for index in 0..scope.n_frames() as usize {
+                if let Some(frame) = voice.next() {
+                    for (channel, sample) in frame.iter().enumerate() {
+                        // Averaging mixer:
+                        //self.buffer[channel % channel_count][index] = (
+                            //(self.buffer[channel % channel_count][index] + sample * self.output_gain) / 2.0
+                        //);
+                        self.buffer[channel % channel_count][index] +=
+                            sample * self.output_gain;
+                    }
+                } else {
+                    return false
+                }
+            }
+            return true
+        });
+    }
+
+    /// Write output buffer to output ports.
+    fn write_output_buffer (&mut self, scope: &ProcessScope) {
+        for (i, port) in self.ports.audio_outs.values_mut().enumerate() {
+            let buffer = &self.buffer[i];
+            for (i, value) in port.as_mut_slice(scope).iter_mut().enumerate() {
+                *value = *buffer.get(i).unwrap_or(&0.0);
+            }
+        }
+    }
+}

crates/tek/src/devices/sampler/add_sample.rs

@@ -0,0 +1,279 @@
+use crate::{core::*, view::*};
+use super::*;
+
+use std::fs::File;
+use symphonia::core::codecs::CODEC_TYPE_NULL;
+use symphonia::core::errors::Error;
+use symphonia::core::io::MediaSourceStream;
+use symphonia::core::probe::Hint;
+use symphonia::core::audio::SampleBuffer;
+use symphonia::default::get_codecs;
+
+pub struct AddSampleModal {
+    exited:  bool,
+    dir:     PathBuf,
+    subdirs: Vec<OsString>,
+    files:   Vec<OsString>,
+    cursor:  usize,
+    offset:  usize,
+    sample:  Arc<RwLock<Sample>>,
+    voices:  Arc<RwLock<Vec<Voice>>>,
+    _search: Option<String>,
+}
+
+exit!(AddSampleModal);
+
+render!(AddSampleModal |self,buf,area|{
+    make_dim(buf);
+    let area = center_box(
+        area,
+        64.max(area.width.saturating_sub(8)),
+        20.max(area.width.saturating_sub(8)),
+    );
+    fill_fg(buf, area, Color::Reset);
+    fill_bg(buf, area, Nord::bg_lo(true, true));
+    fill_char(buf, area, ' ');
+    format!("{}", &self.dir.to_string_lossy())
+        .blit(buf, area.x+2, area.y+1, Some(Style::default().bold()))?;
+    "Select sample:"
+        .blit(buf, area.x+2, area.y+2, Some(Style::default().bold()))?;
+    for (i, (is_dir, name)) in self.subdirs.iter()
+        .map(|path|(true, path))
+        .chain(self.files.iter().map(|path|(false, path)))
+        .enumerate()
+        .skip(self.offset)
+    {
+        if i >= area.height as usize - 4 {
+            break
+        }
+        let t = if is_dir { "" } else { "" };
+        let line = format!("{t} {}", name.to_string_lossy());
+        let line = &line[..line.len().min(area.width as usize - 4)];
+        line.blit(buf, area.x + 2, area.y + 3 + i as u16, Some(if i == self.cursor {
+            Style::default().green()
+        } else {
+            Style::default().white()
+        }))?;
+    }
+    Lozenge(Style::default()).draw(buf, area)
+});
+
+handle!(AddSampleModal |self,e|{
+    if handle_keymap(self, e, KEYMAP_ADD_SAMPLE)? {
+        return Ok(true)
+    }
+    Ok(true)
+});
+
+impl AddSampleModal {
+    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)
+    }
+}
+
+pub const KEYMAP_ADD_SAMPLE: &'static [KeyBinding<AddSampleModal>] = keymap!(AddSampleModal {
+    [Esc,   NONE, "sampler/add/close", "close help dialog",       |modal: &mut AddSampleModal|{
+        modal.exit();
+        Ok(true)
+    }],
+    [Up,    NONE, "sampler/add/prev",  "select previous entry",   |modal: &mut AddSampleModal|{
+        modal.prev();
+        Ok(true)
+    }],
+    [Down,  NONE, "sampler/add/next",  "select next entry",       |modal: &mut AddSampleModal|{
+        modal.next();
+        Ok(true)
+    }],
+    [Enter, NONE, "sampler/add/enter", "activate selected entry", |modal: &mut AddSampleModal|{
+        if modal.pick()? {
+            modal.exit();
+        }
+        Ok(true)
+    }],
+    [Char('p'), NONE, "sampler/add/preview", "preview selected entry", |modal: &mut AddSampleModal|{
+        modal.try_preview()?;
+        Ok(true)
+    }]
+});
+
+fn scan (dir: &PathBuf) -> Usually<(Vec<OsString>, Vec<OsString>)> {
+    let (mut subdirs, mut files) = 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))
+}
+
+impl Sample {
+    fn from_file (path: &PathBuf) -> Usually<Self> {
+        let mut sample = Self::default();
+        sample.name = path.file_name().unwrap().to_string_lossy().into();
+        // 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 mut decoder = get_codecs().make(
+            &format.tracks().iter()
+                .find(|t| t.codec_params.codec != CODEC_TYPE_NULL)
+                .expect("no tracks found")
+                .codec_params,
+            &Default::default()
+        )?;
+        loop {
+            match format.next_packet() {
+                Ok(packet) => {
+                    // Decode a packet
+                    let decoded = match decoder.decode(&packet) {
+                        Ok(decoded) => decoded,
+                        Err(err) => { return Err(err.into()); }
+                    };
+                    // Determine sample rate
+                    let spec = *decoded.spec();
+                    if let Some(rate) = sample.rate {
+                        if rate != spec.rate as usize {
+                            panic!("sample rate changed");
+                        }
+                    } else {
+                        sample.rate = Some(spec.rate as usize);
+                    }
+                    // Determine channel count
+                    while sample.channels.len() < spec.channels.count() {
+                        sample.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() {
+                                sample.channels[chan].push(*frame)
+                            }
+                        }
+                    }
+                },
+                Err(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)
+    }
+}

crates/tek/src/devices/sampler/sample.rs

@@ -0,0 +1,54 @@
+use crate::core::*;
+use super::*;
+
+/// A sound sample.
+#[derive(Default, Debug)]
+pub struct Sample {
+    pub name:     String,
+    pub start:    usize,
+    pub end:      usize,
+    pub channels: Vec<Vec<f32>>,
+    pub rate:     Option<usize>,
+}
+
+impl Sample {
+    pub fn new (name: &str, start: usize, end: usize, channels: Vec<Vec<f32>>) -> Self {
+        Self { name: name.to_string(), start, end, channels, rate: None }
+    }
+    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,
+        }
+    }
+}
+
+
+/// Load sample from WAV and assign to MIDI note.
+#[macro_export] macro_rules! sample {
+    ($note:expr, $name:expr, $src:expr) => {{
+        let (end, data) = read_sample_data($src)?;
+        (
+            u7::from_int_lossy($note).into(),
+            Sample::new($name, 0, end, data).into()
+        )
+    }};
+}
+
+/// Read WAV from file
+pub fn read_sample_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))
+}

crates/tek/src/devices/sampler/voice.rs

@@ -0,0 +1,30 @@
+use crate::core::*;
+use super::*;
+
+/// A currently playing instance of a sample.
+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 = 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 = self.position + 1;
+            return sample.channels[0].get(position).map(|amplitude|[
+                sample.channels[0][position] * self.velocity,
+                sample.channels[0][position] * self.velocity,
+            ])
+        }
+        None
+    }
+}

crates/tek/src/devices/sequencer.rs

@@ -0,0 +1,448 @@
+//! Phrase editor.
+
+use crate::{core::*, model::*, view::*};
+
+/// Key bindings for phrase editor.
+pub const KEYMAP_SEQUENCER: &'static [KeyBinding<App>] = keymap!(App {
+    [Up,    NONE, "seq_cursor_up",    "move cursor up", |app: &mut App| {
+        match app.sequencer.entered {
+            true  => { app.sequencer.note_axis.point_dec(); },
+            false => { app.sequencer.note_axis.start_dec(); },
+        }
+        Ok(true)
+    }],
+    [Down,  NONE, "seq_cursor_down",  "move cursor down", |app: &mut App| {
+        match app.sequencer.entered {
+            true  => { app.sequencer.note_axis.point_inc(); },
+            false => { app.sequencer.note_axis.start_inc(); },
+        }
+        Ok(true)
+    }],
+    [Left,  NONE, "seq_cursor_left",  "move cursor up", |app: &mut App| {
+        match app.sequencer.entered {
+            true  => { app.sequencer.time_axis.point_dec(); },
+            false => { app.sequencer.time_axis.start_dec(); },
+        }
+        Ok(true)
+    }],
+    [Right, NONE, "seq_cursor_right", "move cursor up", |app: &mut App| {
+        match app.sequencer.entered {
+            true  => { app.sequencer.time_axis.point_inc(); },
+            false => { app.sequencer.time_axis.start_inc(); },
+        }
+        Ok(true)
+    }],
+    [Char('`'), NONE, "seq_mode_switch", "switch the display mode", |app: &mut App| {
+        app.sequencer.mode   = !app.sequencer.mode;
+        Ok(true)
+    }],
+    /*
+    [Char('a'), NONE,  "note_add",        "Add note",                 note_add],
+    [Char('z'), NONE,  "note_del",        "Delete note",              note_del],
+    [CapsLock,  NONE,  "advance",         "Toggle auto advance",      nop],
+    [Char('w'), NONE,  "rest",            "Advance by note duration", nop],
+    */
+});
+
+pub type PhraseData = Vec<Vec<MidiMessage>>;
+
+#[derive(Debug)]
+/// A MIDI sequence.
+pub struct Phrase {
+    pub name:   String,
+    pub length: usize,
+    pub notes:  PhraseData,
+    pub looped: Option<(usize, usize)>,
+    /// Immediate note-offs in view
+    pub percussive: bool
+}
+
+impl Default for Phrase {
+    fn default () -> Self {
+        Self::new("", 0, None)
+    }
+}
+
+impl Phrase {
+    pub fn new (name: &str, length: usize, notes: Option<PhraseData>) -> Self {
+        Self {
+            name:   name.to_string(),
+            length,
+            notes:  notes.unwrap_or(vec![Vec::with_capacity(16);length]),
+            looped: Some((0, length)),
+            percussive: true,
+        }
+    }
+    pub fn record_event (&mut self, pulse: usize, message: MidiMessage) {
+        if pulse >= self.length {
+            panic!("extend phrase 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 {
+        //panic!("{:?} {start} {end}", &self);
+        for events in self.notes[start.max(0)..end.min(self.notes.len())].iter() {
+            for event in events.iter() {
+                match event {
+                    MidiMessage::NoteOn {key,..} => {
+                        if *key == k {
+                            return true
+                        }
+                    }
+                    _ => {}
+                }
+            }
+        }
+        return false
+    }
+    /// Write a chunk of MIDI events to an output port.
+    pub fn process_out (
+        &self,
+        output:   &mut MIDIChunk,
+        notes_on: &mut [bool;128],
+        timebase: &Arc<Timebase>,
+        (frame0, frames, _): (usize, usize, f64),
+    ) {
+        let mut buf = Vec::with_capacity(8);
+        for (time, tick) in Ticks(timebase.pulse_per_frame()).between_frames(
+            frame0, frame0 + frames
+        ) {
+            let tick = tick % self.length;
+            for message in self.notes[tick].iter() {
+                buf.clear();
+                let channel = 0.into();
+                let message = *message;
+                LiveEvent::Midi { channel, message }.write(&mut buf).unwrap();
+                output[time as usize].push(buf.clone());
+                match message {
+                    MidiMessage::NoteOn  { key, .. } => notes_on[key.as_int() as usize] = true,
+                    MidiMessage::NoteOff { key, .. } => notes_on[key.as_int() as usize] = false,
+                    _ => {}
+                }
+            }
+        }
+    }
+}
+
+/// Phrase editor.
+pub struct Sequencer {
+    pub mode:      bool,
+    pub focused:   bool,
+    pub entered:   bool,
+
+    pub phrase:    Option<Arc<RwLock<Phrase>>>,
+    pub buffer:    Buffer,
+    pub keys:      Buffer,
+    /// Highlight input keys
+    pub keys_in:  [bool; 128],
+    /// Highlight output keys
+    pub keys_out: [bool; 128],
+
+    pub now:       usize,
+    pub ppq:       usize,
+    pub note_axis: FixedAxis<u16>,
+    pub time_axis: ScaledAxis<u16>,
+
+}
+
+render!(Sequencer |self, buf, area| {
+    fill_bg(buf, area, Nord::bg_lo(self.focused, self.entered));
+    self.horizontal_draw(buf, area)?;
+    if self.focused && self.entered {
+        Corners(Style::default().green().not_dim()).draw(buf, area)?;
+    }
+    Ok(area)
+});
+
+impl Sequencer {
+    pub fn new () -> Self {
+        Self {
+            buffer:    Buffer::empty(Rect::default()),
+            keys:      keys_vert(),
+            entered:   false,
+            focused:   false,
+            mode:      false,
+            keys_in:  [false;128],
+            keys_out: [false;128],
+            phrase:    None,
+            now:       0,
+            ppq:       96,
+            note_axis: FixedAxis {
+                start: 12,
+                point: Some(36)
+            },
+            time_axis: ScaledAxis {
+                start: 0,
+                scale: 24,
+                point: Some(0)
+            },
+        }
+    }
+    /// Select which pattern to display. This pre-renders it to the buffer at full resolution.
+    /// FIXME: Support phrases longer that 65536 ticks
+    pub fn show (&mut self, phrase: Option<&Arc<RwLock<Phrase>>>) -> Usually<()> {
+        self.phrase = phrase.map(Clone::clone);
+        if let Some(ref phrase) = self.phrase {
+            let width = u16::MAX.min(phrase.read().unwrap().length as u16);
+            let mut buffer = Buffer::empty(Rect { x: 0, y: 0, width, height: 64 });
+            let phrase = phrase.read().unwrap();
+            fill_seq_bg(&mut buffer, phrase.length, self.ppq)?;
+            fill_seq_fg(&mut buffer, &phrase)?;
+            self.buffer = buffer;
+        } else {
+            self.buffer = Buffer::empty(Rect::default())
+        }
+        Ok(())
+    }
+
+    fn style_focus (&self) -> Option<Style> {
+        Some(if self.focused {
+            Style::default().green().not_dim()
+        } else {
+            Style::default().green().dim()
+        })
+    }
+
+    fn style_timer_step (now: usize, step: usize, next_step: usize) -> Style {
+        if step <= now && now < next_step {
+            Style::default().yellow().bold().not_dim()
+        } else {
+            Style::default()
+        }
+    }
+
+    fn index_to_color (&self, index: u16, default: Color) -> Color {
+        let index = index as usize;
+        if self.keys_in[index] && self.keys_out[index] {
+            Color::Yellow
+        } else if self.keys_in[index] {
+            Color::Red
+        } else if self.keys_out[index] {
+            Color::Green
+        } else {
+            default
+        }
+    }
+
+    const H_KEYS_OFFSET: u16 = 5;
+
+    fn horizontal_draw (&self, buf: &mut Buffer, area: Rect) -> Usually<()> {
+        self.horizontal_keys(buf, area)?;
+        if let Some(ref phrase) = self.phrase {
+            self.horizontal_timer(buf, area, phrase)?;
+        }
+        self.horizontal_notes(buf, area)?;
+        self.horizontal_cursor(buf, area)?;
+        self.horizontal_quant(buf, area)?;
+        Ok(())
+    }
+
+    fn horizontal_notes (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
+        if area.height < 2 {
+            return Ok(area)
+        }
+        let area = Rect {
+            x:      area.x + Self::H_KEYS_OFFSET,
+            y:      area.y + 1,
+            width:  area.width - Self::H_KEYS_OFFSET,
+            height: area.height - 2
+        };
+        buffer_update(buf, area, &|cell, x, y|{
+            let src_x = (x + self.time_axis.start) * self.time_axis.scale;
+            let src_y = y + self.note_axis.start;
+            if src_x < self.buffer.area.width && src_y < self.buffer.area.height - 1 {
+                let src = self.buffer.get(src_x, self.buffer.area.height - src_y);
+                cell.set_symbol(src.symbol());
+                cell.set_fg(src.fg);
+            }
+        });
+        Ok(area)
+    }
+
+    fn horizontal_keys (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
+        if area.height < 2 {
+            return Ok(area)
+        }
+        let area = Rect {
+            x: area.x,
+            y: area.y + 1,
+            width: 5,
+            height: area.height - 2
+        };
+        buffer_update(buf, area, &|cell, x, y|{
+            let y = y + self.note_axis.start;
+            if x < self.keys.area.width && y < self.keys.area.height {
+                *cell = self.keys.get(x, y).clone()
+            }
+        });
+        Ok(area)
+    }
+
+    fn horizontal_quant (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
+        let quant = ppq_to_name(self.time_axis.scale);
+        let quant_x = area.x + area.width - 1 - quant.len() as u16;
+        let quant_y = area.y + area.height - 2;
+        quant.blit(buf, quant_x, quant_y, self.style_focus())
+    }
+
+    fn horizontal_cursor (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
+        if let (Some(time), Some(note)) = (self.time_axis.point, self.note_axis.point) {
+            let x = area.x + Self::H_KEYS_OFFSET + time as u16;
+            let y = area.y + 1 + note as u16 / 2;
+            let c = if note % 2 == 0 { "▀" } else { "▄" };
+            c.blit(buf, x, y, self.style_focus())
+        } else {
+            Ok(Rect::default())
+        }
+    }
+
+    fn horizontal_timer (
+        &self, buf: &mut Buffer, area: Rect, phrase: &RwLock<Phrase>
+    ) -> Usually<Rect> {
+        let phrase = phrase.read().unwrap();
+        let (time0, time_z, now) = (self.time_axis.start, self.time_axis.scale, self.now % phrase.length);
+        let Rect { x, width, .. } = area;
+        for x in x+Self::H_KEYS_OFFSET..x+width {
+            let step = (time0 + (x-Self::H_KEYS_OFFSET)) * time_z;
+            let next_step = (time0 + (x-Self::H_KEYS_OFFSET) + 1) * time_z;
+            let style = Self::style_timer_step(now, step as usize, next_step as usize);
+            "-".blit(buf, x, area.y, Some(style))?;
+        }
+        return Ok(Rect { x: area.x, y: area.y, width: area.width, height: 1 })
+    }
+}
+
+fn keys_vert () -> Buffer {
+    let area = Rect { x: 0, y: 0, width: 5, height: 64 };
+    let mut buffer = Buffer::empty(area);
+    buffer_update(&mut buffer, area, &|cell, x, y| {
+        let y = 63 - y;
+        match x {
+            0 => {
+                cell.set_char('▀');
+                let (fg, bg) = key_colors(6 - y % 6);
+                cell.set_fg(fg);
+                cell.set_bg(bg);
+            },
+            1 => {
+                cell.set_char('▀');
+                cell.set_fg(Color::White);
+                cell.set_bg(Color::White);
+            },
+            2 => if y % 6 == 0 {
+                cell.set_char('C');
+            },
+            3 => if y % 6 == 0 {
+                cell.set_symbol(nth_octave(y / 6));
+            },
+            _ => {}
+        }
+    });
+    buffer
+}
+
+fn nth_octave (index: u16) -> &'static str {
+    match index {
+        0  =>  "-1",
+        1  =>  "0",
+        2  =>  "1",
+        3  =>  "2",
+        4  =>  "3",
+        5  =>  "4",
+        6  =>  "5",
+        7  =>  "6",
+        8  =>  "7",
+        9  =>  "8",
+        10 =>  "9",
+        _  => unreachable!()
+    }
+}
+
+fn key_colors (index: u16) -> (Color, Color) {
+    match index % 6 {
+        0 => (Color::White, Color::Black),
+        1 => (Color::White, Color::Black),
+        2 => (Color::White, Color::White),
+        3 => (Color::Black, Color::White),
+        4 => (Color::Black, Color::White),
+        5 => (Color::Black, Color::White),
+        _ => unreachable!()
+    }
+}
+
+fn fill_seq_bg (buf: &mut Buffer, length: usize, ppq: usize) -> Usually<()> {
+    for x in 0 .. buf.area.width - buf.area.x {
+        if x as usize >= length {
+            break
+        }
+        let style = Style::default();
+        let cell = buf.get_mut(x, buf.area.y);
+        cell.set_char('-');
+        cell.set_style(style);
+        for y in 0 .. buf.area.height - buf.area.y {
+            let cell = buf.get_mut(x, y);
+            cell.set_char(char_seq_bg(ppq, x));
+            cell.set_fg(Color::Gray);
+            cell.modifier = Modifier::DIM;
+        }
+    }
+    Ok(())
+}
+
+fn char_seq_bg (ppq: usize, x: u16) -> char {
+    if ppq == 0 {
+        '·'
+    } else if x % (4 * ppq as u16) == 0 {
+        '│'
+    } else if x % ppq as u16 == 0 {
+        '╎'
+    } else {
+        '·'
+    }
+}
+
+fn fill_seq_fg (buf: &mut Buffer, phrase: &Phrase) -> Usually<()> {
+    let mut notes_on = [false;128];
+    for x in 0 .. buf.area.width - buf.area.x {
+        if x as usize >= phrase.length {
+            break
+        }
+        if let Some(notes) = phrase.notes.get(x as usize) {
+            for note in notes {
+                if phrase.percussive {
+                    match note {
+                        MidiMessage::NoteOn { key, .. } =>
+                            notes_on[key.as_int() as usize] = true,
+                        _ => {}
+                    }
+                } else {
+                    match note {
+                        MidiMessage::NoteOn { key, .. } =>
+                            notes_on[key.as_int() as usize] = true,
+                        MidiMessage::NoteOff { key, .. } =>
+                            notes_on[key.as_int() as usize] = false,
+                        _ => {}
+                    }
+                }
+            }
+            for y in 0 .. (buf.area.height - buf.area.y) / 2 {
+                if y >= 64 {
+                    break
+                }
+                if let Some(block) = half_block(
+                    notes_on[y as usize * 2],
+                    notes_on[y as usize * 2 + 1],
+                ) {
+                    let cell = buf.get_mut(x, y);
+                    cell.set_char(block);
+                    cell.set_fg(Color::White);
+                }
+            }
+            if phrase.percussive {
+                notes_on.fill(false);
+            }
+        }
+    }
+    Ok(())
+}

crates/tek/src/devices/setup.rs

@@ -0,0 +1,55 @@
+//! Inital setup dialog (TODO: make this the options dialog too?)
+
+use crate::{core::*, config::AppPaths};
+
+/// Appears on first run (i.e. if state dir is missing).
+pub struct SetupModal(pub Option<Arc<XdgApp>>, pub bool);
+
+render!(SetupModal |self, buf, area| {
+    for cell in buf.content.iter_mut() {
+        cell.fg = ratatui::style::Color::Gray;
+        cell.modifier = ratatui::style::Modifier::DIM;
+    }
+    let lines = [
+        ("                           ", Style::default().white().on_black().not_dim().bold()),
+        (" Welcome to TEK!           ", Style::default().white().on_black().not_dim().bold()),
+        ("                           ", Style::default().white().on_black().not_dim().bold()),
+        (" Press ENTER to create the ", Style::default().white().on_black().not_dim()),
+        (" following directories:    ", Style::default().white().on_black().not_dim()),
+        ("                           ", Style::default().white().on_black().not_dim().bold()),
+        (" Configuration directory:  ", Style::default().white().on_black().not_dim()),
+        ("   ~/.config/tek           ", Style::default().white().on_black().not_dim().bold()),
+        ("                           ", Style::default().white().on_black().not_dim()),
+        (" Data directory:           ", Style::default().white().on_black().not_dim()),
+        ("   ~/.local/share/tek      ", Style::default().white().on_black().not_dim().bold()),
+        ("                           ", Style::default().white().on_black().not_dim().bold()),
+        (" Or press CTRL-C to exit.  ", Style::default().white().on_black().not_dim()),
+        ("                           ", Style::default().white().on_black().not_dim()),
+    ];
+    let width = lines[0].0.len() as u16;
+    let x = area.x + (area.width - width) / 2;
+    for (i, (line, style)) in lines.iter().enumerate() {
+        line.blit(buf, x, area.y + area.height / 2 - (lines.len() / 2) as u16 + i as u16, Some(*style))?;
+    }
+    Ok(area)
+});
+handle!(SetupModal |self, e| {
+    if let AppEvent::Input(::crossterm::event::Event::Key(KeyEvent {
+        code: KeyCode::Enter,
+        ..
+    })) = e {
+        AppPaths::new(&self.0.as_ref().unwrap())?.create()?;
+        self.exit();
+        Ok(true)
+    } else {
+        Ok(false)
+    }
+});
+impl Exit for SetupModal {
+    fn exited (&self) -> bool {
+        self.1
+    }
+    fn exit (&mut self) {
+        self.1 = true
+    }
+}

crates/tek/src/devices/transport.rs

@@ -0,0 +1,248 @@
+//! Transport controller.
+
+use crate::{core::*, view::*, model::App};
+
+/// Key bindings for transport toolbar.
+pub const KEYMAP_TRANSPORT: &'static [KeyBinding<App>] = keymap!(App {
+    [Left,  NONE, "transport_prev", "select previous control",  |app: &mut App| Ok({
+        app.transport.selected.prev();
+        true
+    })],
+    [Right, NONE, "transport_next", "select next control",      |app: &mut App| Ok({
+        app.transport.selected.next();
+        true
+    })],
+    [Char('.'), NONE, "transport_increment", "increment value at cursor", |app: &mut App| {
+        match app.transport.selected {
+            TransportFocus::BPM   => {
+                app.transport.timebase.bpm.fetch_add(1.0, Ordering::Relaxed);
+            },
+            TransportFocus::Quant => {
+                app.transport.quant = next_note_length(app.transport.quant)
+            },
+            TransportFocus::Sync  => {
+                app.transport.sync = next_note_length(app.transport.sync)
+            },
+        };
+        Ok(true)
+    }],
+    [Char(','), NONE, "transport_decrement", "decrement value at cursor", |app: &mut App| {
+        match app.transport.selected {
+            TransportFocus::BPM   => {
+                app.transport.timebase.bpm.fetch_sub(1.0, Ordering::Relaxed);
+            },
+            TransportFocus::Quant => {
+                app.transport.quant = prev_note_length(app.transport.quant);
+            },
+            TransportFocus::Sync  => {
+                app.transport.sync = prev_note_length(app.transport.sync);
+            },
+        };
+        Ok(true)
+    }],
+});
+
+#[derive(PartialEq)]
+/// Which section of the transport is focused
+pub enum TransportFocus { BPM, Quant, Sync }
+
+impl TransportFocus {
+    pub fn prev (&mut self) {
+        *self = match self {
+            Self::BPM   => Self::Sync,
+            Self::Quant => Self::BPM,
+            Self::Sync  => Self::Quant,
+        }
+    }
+    pub fn next (&mut self) {
+        *self = match self {
+            Self::BPM   => Self::Quant,
+            Self::Quant => Self::Sync,
+            Self::Sync  => Self::BPM,
+        }
+    }
+}
+
+/// Stores and displays time-related state.
+pub struct TransportToolbar {
+    /// Enable metronome?
+    pub metronome: bool,
+    pub focused:   bool,
+    pub entered:   bool,
+    pub selected:  TransportFocus,
+    /// Current sample rate, tempo, and PPQ.
+    pub timebase:  Arc<Timebase>,
+    /// JACK transport handle.
+    transport:     Option<Transport>,
+    /// Quantization factor
+    pub quant:     u16,
+    /// Global sync quant
+    pub sync:      u16,
+    /// Current transport state
+    pub playing:   Option<TransportState>,
+    /// Current position according to transport
+    playhead:      usize,
+    /// Global frame and usec at which playback started
+    pub started:   Option<(usize, usize)>,
+}
+
+impl TransportToolbar {
+    pub fn new (transport: Option<Transport>) -> Self {
+        let timebase = Arc::new(Timebase::default());
+        Self {
+            selected:  TransportFocus::BPM,
+            metronome: false,
+            focused:   false,
+            entered:   false,
+            playhead:  0,
+            playing:   Some(TransportState::Stopped),
+            started:   None,
+            quant:     24,
+            sync:      timebase.ppq() as u16 * 4,
+            transport,
+            timebase,
+        }
+    }
+    pub fn toggle_play (&mut self) -> Usually<()> {
+        self.playing = match self.playing.expect("1st frame has not been processed yet") {
+            TransportState::Stopped => {
+                self.transport.as_ref().unwrap().start()?;
+                Some(TransportState::Starting)
+            },
+            _ => {
+                self.transport.as_ref().unwrap().stop()?;
+                self.transport.as_ref().unwrap().locate(0)?;
+                Some(TransportState::Stopped)
+            },
+        };
+        Ok(())
+    }
+    pub fn update (&mut self, scope: &ProcessScope) -> (bool, usize, usize, usize, usize, f64) {
+        let CycleTimes {
+            current_frames,
+            current_usecs,
+            next_usecs,
+            period_usecs
+        } = scope.cycle_times().unwrap();
+        let chunk_size = scope.n_frames() as usize;
+        let transport = self.transport.as_ref().unwrap().query().unwrap();
+        self.playhead = transport.pos.frame() as usize;
+        let mut reset = false;
+        if self.playing != Some(transport.state) {
+            match transport.state {
+                TransportState::Rolling => {
+                    self.started = Some((
+                        current_frames as usize,
+                        current_usecs  as usize,
+                    ));
+                },
+                TransportState::Stopped => {
+                    self.started = None;
+                    reset = true;
+                },
+                _ => {}
+            }
+        }
+        self.playing = Some(transport.state);
+        (
+            reset,
+            current_frames as usize,
+            chunk_size as usize,
+            current_usecs as usize,
+            next_usecs as usize,
+            period_usecs as f64
+        )
+    }
+    pub fn bpm (&self) -> usize {
+        self.timebase.bpm() as usize
+    }
+    pub fn ppq (&self) -> usize {
+        self.timebase.ppq() as usize
+    }
+    pub fn pulse (&self) -> usize {
+        self.timebase.frame_to_pulse(self.playhead as f64) as usize
+    }
+    pub fn usecs (&self) -> usize {
+        self.timebase.frame_to_usec(self.playhead as f64) as usize
+    }
+}
+
+render!(TransportToolbar |self, buf, area| {
+    let mut area     = area;
+    area.height      = 2;
+    let gray         = Style::default().gray();
+    let not_dim      = Style::default().not_dim();
+    let not_dim_bold = not_dim.bold();
+    let corners      = Corners(Style::default().green().not_dim());
+    let ppq          = self.ppq();
+    let bpm          = self.bpm();
+    let pulse        = self.pulse();
+    let usecs        = self.usecs();
+    let Self { quant, sync, focused, entered, .. } = self;
+    fill_bg(buf, area, Nord::bg_lo(*focused, *entered));
+    Split::right([
+
+        // Play/Pause button
+        &|buf: &mut Buffer, Rect { x, y, .. }: Rect|{
+            let style = Some(match self.playing {
+                Some(TransportState::Stopped)  => gray.dim().bold(),
+                Some(TransportState::Starting) => gray.not_dim().bold(),
+                Some(TransportState::Rolling)  => gray.not_dim().white().bold(),
+                _ => unreachable!(),
+            });
+            let label = match self.playing {
+                Some(TransportState::Rolling)  => "▶ PLAYING",
+                Some(TransportState::Starting) => "READY ...",
+                Some(TransportState::Stopped)  => "⏹ STOPPED",
+                _ => unreachable!(),
+            };
+            let mut result = label.blit(buf, x + 1, y, style)?;
+            result.width = result.width + 1;
+            Ok(result)
+        },
+
+        // Beats per minute
+        &|buf: &mut Buffer, Rect { x, y, .. }: Rect|{
+            "BPM".blit(buf, x, y, Some(not_dim))?;
+            let width = format!("{}.{:03}", bpm, bpm % 1).blit(buf, x, y + 1, Some(not_dim_bold))?.width;
+            let area  = Rect { x, y, width: (width + 2).max(10), height: 2 };
+            if self.focused && self.entered && self.selected == TransportFocus::BPM {
+                corners.draw(buf, Rect { x: area.x - 1, ..area })?;
+            }
+            Ok(area)
+        },
+
+        // Quantization
+        &|buf: &mut Buffer, Rect { x, y, .. }: Rect|{
+            "QUANT".blit(buf, x, y, Some(not_dim))?;
+            let width = ppq_to_name(*quant as u16).blit(buf, x, y + 1, Some(not_dim_bold))?.width;
+            let area  = Rect { x, y, width: (width + 2).max(10), height: 2 };
+            if self.focused && self.entered && self.selected == TransportFocus::Quant {
+                corners.draw(buf, Rect { x: area.x - 1, ..area })?;
+            }
+            Ok(area)
+        },
+
+        // Clip launch sync
+        &|buf: &mut Buffer, Rect { x, y, .. }: Rect|{
+            "SYNC".blit(buf, x, y, Some(not_dim))?;
+            let width = ppq_to_name(*sync as u16).blit(buf, x, y + 1, Some(not_dim_bold))?.width;
+            let area  = Rect { x, y, width: (width + 2).max(10), height: 2 };
+            if self.focused && self.entered && self.selected == TransportFocus::Sync {
+                corners.draw(buf, Rect { x: area.x - 1, ..area })?;
+            }
+            Ok(area)
+        },
+
+        // Clock
+        &|buf: &mut Buffer, Rect { x, y, width, .. }: Rect|{
+            let (beats, pulses)    = (pulse / ppq, pulse % ppq);
+            let (bars, beats)      = ((beats / 4) + 1, (beats % 4) + 1);
+            let (seconds, msecs)   = (usecs / 1000000, usecs / 1000 % 1000);
+            let (minutes, seconds) = (seconds / 60, seconds % 60);
+            let timer = format!("{minutes}:{seconds:02}:{msecs:03}  {bars}.{beats}.{pulses:02}");
+            timer.blit(buf, x + width - timer.len() as u16 - 1, y, Some(not_dim))
+        }
+
+    ]).render(buf, area)
+});

crates/tek/src/edn.rs

@@ -0,0 +1,319 @@
+//! Project file format.
+//!
+//! This module `impl`s the `from_edn`, `load_edn`, etc. methods
+//! of structs that are defined in other modules. See:
+//!
+//! * [App::from_edn]
+//! * [App::load_edn]
+//! * [App::load_edn_one]
+//! * [Scene::load_edn]
+//! * [Track::load_edn]
+//! * [Phrase::load_edn]
+//! * [Sampler::load_edn]
+//! * [Sample::load_edn]
+//! * [LV2Plugin::load_edn]
+
+use crate::{core::*, model::*, App};
+use crate::devices::{
+    arranger::Scene,
+    sequencer::Phrase,
+    sampler::{Sampler, Sample, read_sample_data}
+};
+use crate::devices::plugin::{Plugin, LV2Plugin};
+use clojure_reader::{edn::{read, Edn}, error::Error as EdnError};
+
+/// EDN parsing helper.
+macro_rules! edn {
+    ($edn:ident { $($pat:pat => $expr:expr),* $(,)? }) => {
+        match $edn { $($pat => $expr),* }
+    };
+    ($edn:ident in $args:ident { $($pat:pat => $expr:expr),* $(,)? }) => {
+        for $edn in $args {
+            edn!($edn { $($pat => $expr),* })
+        }
+    };
+}
+
+impl App {
+    pub fn from_edn (src: &str) -> Usually<Self> {
+        let mut app = Self::new()?;
+        app.load_edn(src)?;
+        Ok(app)
+    }
+    pub fn load_edn (&mut self, mut src: &str) -> Usually<&mut Self> {
+        loop {
+            match read(src) {
+                Ok((edn, rest)) => {
+                    self.load_edn_one(edn)?;
+                    if rest.len() > 0 {
+                        src = rest;
+                    } else {
+                        break
+                    }
+                },
+                Err(EdnError { ptr: None, .. }) => {
+                    break
+                },
+                Err(e) => {
+                    panic!("{e:?}");
+                },
+            }
+        }
+        Ok(self)
+    }
+    fn load_edn_one <'e> (&mut self, edn: Edn<'e>) -> Usually<()> {
+        match edn {
+            Edn::List(items) => {
+                match items.get(0) {
+                    Some(Edn::Symbol("bpm")) => {
+                        match items.get(1) {
+                            Some(Edn::Int(b)) =>
+                                self.transport.timebase.set_bpm(*b as f64),
+                            Some(Edn::Double(b)) =>
+                                self.transport.timebase.set_bpm(f64::from(*b)),
+                            _ => panic!("unspecified bpm")
+                        }
+                    },
+                    Some(Edn::Symbol("scene")) => {
+                        Scene::load_edn(self, &items[1..])?;
+                    },
+                    Some(Edn::Symbol("track")) => {
+                        Track::load_edn(self, &items[1..])?;
+                    },
+                    Some(Edn::Symbol("midi-in")) => {
+                        self.midi_ins = items[1..].iter().map(|x|match x {
+                            Edn::Str(n) => n.to_string(),
+                            _ => panic!("unexpected midi-in")
+                        }).collect::<Vec<_>>();
+                    },
+                    Some(Edn::Symbol("audio-out")) => {
+                        let client = self.client();
+                        self.audio_outs = items[1..].iter().map(|x|match x {
+                            Edn::Str(n) => n.to_string(),
+                            _ => panic!("unexpected midi-in")
+                        }).collect::<Vec<_>>()
+                            .iter()
+                            .map(|name|client
+                                .ports(Some(name), None, PortFlags::empty())
+                                .get(0)
+                                .map(|name|client.port_by_name(name)))
+                            .flatten()
+                            .filter_map(|x|x)
+                            .map(Arc::new)
+                            .collect();
+                    },
+                    _ => panic!("unexpected edn: {:?}", items.get(0))
+                }
+            },
+            _ => {
+                panic!("unexpected edn: {edn:?}");
+            }
+        }
+        Ok(())
+    }
+}
+
+impl Scene {
+    fn load_edn <'a, 'e> (app: &'a mut App, args: &[Edn<'e>]) -> Usually<&'a mut Self> {
+        let mut name  = None;
+        let mut clips = vec![];
+        edn!(edn in args {
+            Edn::Map(map) => {
+                let key = map.get(&Edn::Key(":name"));
+                if let Some(Edn::Str(n)) = key {
+                    name = Some(*n);
+                } else {
+                    panic!("unexpected key in scene '{name:?}': {key:?}")
+                }
+            },
+            Edn::Symbol("_") => {
+                clips.push(None);
+            },
+            Edn::Int(i) => {
+                clips.push(Some(*i as usize));
+            },
+            _ => panic!("unexpected in scene '{name:?}': {edn:?}")
+        });
+        let scene = app.arranger.scene_add(name)?;
+        scene.clips = clips;
+        Ok(scene)
+    }
+}
+
+impl Track {
+    fn load_edn <'a, 'e> (app: &'a mut App, args: &[Edn<'e>]) -> Usually<&'a mut Self> {
+        let ppq = app.transport.ppq();
+        let mut name = None;
+        let mut _gain = 0.0f64;
+        let mut devices: Vec<JackDevice> = vec![];
+        let mut phrases: Vec<Phrase> = vec![];
+        edn!(edn in args {
+            Edn::Map(map) => {
+                if let Some(Edn::Str(n)) = map.get(&Edn::Key(":name")) {
+                    name = Some(*n);
+                }
+                if let Some(Edn::Double(g)) = map.get(&Edn::Key(":gain")) {
+                    _gain = f64::from(*g)
+                }
+            },
+            Edn::List(args) => match args.get(0) {
+                Some(Edn::Symbol("phrase")) => {
+                    phrases.push(Phrase::load_edn(ppq, &args[1..])?)
+                },
+                Some(Edn::Symbol("sampler")) => {
+                    devices.push(Sampler::load_edn(&args[1..])?)
+                },
+                Some(Edn::Symbol("lv2")) => {
+                    devices.push(LV2Plugin::load_edn(&args[1..])?)
+                },
+                None => panic!("empty list track {}",
+                    name.unwrap_or("")
+                ),
+                _ => panic!("unexpected in track {}: {:?}",
+                    name.unwrap_or(""),
+                    args.get(0).unwrap()
+                )
+            },
+            _ => {}
+        });
+        let track = app.arranger.track_add(name)?;
+        for phrase in phrases { track.phrases.push(Arc::new(RwLock::new(phrase))); }
+        for device in devices { track.add_device(device)?; }
+        Ok(track)
+    }
+}
+
+impl Phrase {
+    fn load_edn <'e> (ppq: usize, args: &[Edn<'e>]) -> Usually<Self> {
+        let mut phrase = Self::default();
+        let mut name   = String::new();
+        let mut beats  = 0usize;
+        let mut steps  = 0usize;
+        edn!(edn in args {
+            Edn::Map(map) => {
+                if let Some(Edn::Str(n)) = map.get(&Edn::Key(":name")) {
+                    name = String::from(*n);
+                }
+                if let Some(Edn::Int(b)) = map.get(&Edn::Key(":beats")) {
+                    beats = *b as usize;
+                    phrase.length = ppq * beats;
+                    for _ in phrase.notes.len()..phrase.length {
+                        phrase.notes.push(Vec::with_capacity(16))
+                    }
+                }
+                if let Some(Edn::Int(s)) = map.get(&Edn::Key(":steps")) {
+                    steps = *s as usize;
+                }
+            },
+            Edn::List(args) => {
+                let time = (match args.get(0) {
+                    Some(Edn::Key(text)) => text[1..].parse::<f64>()?,
+                    Some(Edn::Int(i))       => *i as f64,
+                    Some(Edn::Double(f))    => f64::from(*f),
+                    _ => panic!("unexpected in phrase '{name}': {:?}", args.get(0)),
+                } * beats as f64 * ppq as f64 / steps as f64) as usize;
+                for edn in args[1..].iter() {
+                    match edn {
+                        Edn::List(args) => if let (
+                            Some(Edn::Int(key)),
+                            Some(Edn::Int(vel)),
+                        ) = (
+                            args.get(0),
+                            args.get(1),
+                        ) {
+                            let (key, vel) = (
+                                u7::from((*key as u8).min(127)),
+                                u7::from((*vel as u8).min(127)),
+                            );
+                            phrase.notes[time].push(MidiMessage::NoteOn { key, vel })
+                        } else {
+                            panic!("unexpected list in phrase '{name}'")
+                        },
+                        _ => panic!("unexpected in phrase '{name}': {edn:?}")
+                    }
+                }
+            },
+            _ => panic!("unexpected in phrase '{name}': {edn:?}"),
+        });
+        phrase.name = name;
+        Ok(phrase)
+    }
+}
+
+impl Sampler {
+    fn load_edn <'e> (args: &[Edn<'e>]) -> Usually<JackDevice> {
+        let mut name = String::new();
+        let mut dir  = String::new();
+        let mut samples = BTreeMap::new();
+        edn!(edn in args {
+            Edn::Map(map) => {
+                if let Some(Edn::Str(n)) = map.get(&Edn::Key(":name")) {
+                    name = String::from(*n);
+                }
+                if let Some(Edn::Str(n)) = map.get(&Edn::Key(":dir")) {
+                    dir = String::from(*n);
+                }
+            },
+            Edn::List(args) => match args.get(0) {
+                Some(Edn::Symbol("sample")) => {
+                    let (midi, sample) = Sample::load_edn(&dir, &args[1..])?;
+                    if let Some(midi) = midi {
+                        samples.insert(midi, sample);
+                    } else {
+                        panic!("sample without midi binding: {}", sample.read().unwrap().name);
+                    }
+                },
+                _ => panic!("unexpected in sampler {name}: {args:?}")
+            },
+            _ => panic!("unexpected in sampler {name}: {edn:?}")
+        });
+        Self::new(&name, Some(samples))
+    }
+}
+
+impl Sample {
+    fn load_edn <'e> (dir: &str, args: &[Edn<'e>]) -> Usually<(Option<u7>, Arc<RwLock<Self>>)> {
+        let mut name = String::new();
+        let mut file = String::new();
+        let mut midi = None;
+        let mut start = 0usize;
+        edn!(edn in args {
+            Edn::Map(map) => {
+                if let Some(Edn::Str(n)) = map.get(&Edn::Key(":name")) {
+                    name = String::from(*n);
+                }
+                if let Some(Edn::Str(f)) = map.get(&Edn::Key(":file")) {
+                    file = String::from(*f);
+                }
+                if let Some(Edn::Int(i)) = map.get(&Edn::Key(":start")) {
+                    start = *i as usize;
+                }
+                if let Some(Edn::Int(m)) = map.get(&Edn::Key(":midi")) {
+                    midi = Some(u7::from(*m as u8));
+                }
+            },
+            _ => panic!("unexpected in sample {name}"),
+        });
+        let (end, data) = read_sample_data(&format!("{dir}/{file}"))?;
+        Ok((midi, Arc::new(RwLock::new(Self::new(&name, start, end, data)))))
+    }
+}
+
+impl LV2Plugin {
+    fn load_edn <'e> (args: &[Edn<'e>]) -> Usually<JackDevice> {
+        let mut name = String::new();
+        let mut path = String::new();
+        edn!(edn in args {
+            Edn::Map(map) => {
+                if let Some(Edn::Str(n)) = map.get(&Edn::Key(":name")) {
+                    name = String::from(*n);
+                }
+                if let Some(Edn::Str(p)) = map.get(&Edn::Key(":path")) {
+                    path = String::from(*p);
+                }
+            },
+            _ => panic!("unexpected in lv2 '{name}'"),
+        });
+        Plugin::lv2(&name, &path)
+    }
+}

crates/tek/src/jack.rs

@@ -0,0 +1,135 @@
+//! Audio engine.
+
+use crate::core::*;
+
+submod!( device event factory ports );
+
+pub(crate) use ::_jack::{
+    AsyncClient,
+    AudioIn,
+    AudioOut,
+    Client,
+    ClientOptions,
+    ClientStatus,
+    ClosureProcessHandler,
+    Control,
+    CycleTimes,
+    Frames,
+    MidiIn,
+    MidiIter,
+    MidiOut,
+    NotificationHandler,
+    Port,
+    PortFlags,
+    PortId,
+    PortSpec,
+    ProcessScope,
+    RawMidi,
+    Transport,
+    TransportState,
+    Unowned
+};
+
+/// Wraps [Client] or [DynamicAsyncClient] in place.
+pub enum JackClient {
+    Inactive(Client),
+    Active(DynamicAsyncClient),
+}
+
+impl JackClient {
+    pub fn client (&self) -> &Client {
+        match self {
+            Self::Inactive(ref client) =>
+                client,
+            Self::Active(ref client) =>
+                client.as_client(),
+        }
+    }
+    pub fn transport (&self) -> Transport {
+        self.client().transport()
+    }
+    pub fn port_by_name (&self, name: &str) -> Option<Port<Unowned>> {
+        self.client().port_by_name(name)
+    }
+    pub fn register_port <PS: PortSpec> (&self, name: &str, spec: PS) -> Usually<Port<PS>> {
+        Ok(self.client().register_port(name, spec)?)
+    }
+    pub fn activate <T: Send + Sync + 'static> (
+        self,
+        state: &Arc<RwLock<T>>,
+        mut process: impl FnMut(&Arc<RwLock<T>>, &Client, &ProcessScope)->Control + Send + 'static
+    ) -> Usually<Self> {
+        Ok(match self {
+            Self::Active(_) => self,
+            Self::Inactive(client) => Self::Active(client.activate_async(
+                Notifications(Box::new(move|_|{/*TODO*/})
+                    as Box<dyn Fn(AppEvent) + Send + Sync>),
+                ClosureProcessHandler::new(Box::new({
+                    let state = state.clone();
+                    move|c: &Client, s: &ProcessScope|process(&state, c, s)
+                }) as BoxedProcessHandler)
+            )?)
+        })
+    }
+}
+
+pub type DynamicAsyncClient =
+    AsyncClient<DynamicNotifications, DynamicProcessHandler>;
+
+type DynamicProcessHandler =
+    ClosureProcessHandler<BoxedProcessHandler>;
+
+pub type BoxedProcessHandler =
+    Box<dyn FnMut(&Client, &ProcessScope)-> Control + Send>;
+
+/// Trait for things that have a JACK process callback.
+pub trait Process {
+    fn process (&mut self, _: &Client, _: &ProcessScope) -> Control {
+        Control::Continue
+    }
+}
+
+/// Define the JACK process callback associated with a struct.
+#[macro_export] macro_rules! process {
+    ($T:ty) => {
+        impl Process for $T {}
+    };
+    ($T:ty |$self:ident, $c:ident, $s:ident|$block:tt) => {
+        impl Process for $T {
+            fn process (&mut $self, $c: &Client, $s: &ProcessScope) -> Control {
+                $block
+            }
+        }
+    };
+    ($T:ty = $process:path) => {
+        impl Process for $T {
+            fn process (&mut self, c: &Client, s: &ProcessScope) -> Control {
+                $process(self, c, s)
+            }
+        }
+    }
+}
+
+/// Just run thing with JACK. Returns the activated client.
+pub fn jack_run <T: Sync> (name: &str, app: &Arc<RwLock<T>>) -> Usually<DynamicAsyncClient>
+    where T: Handle + Process + Send + 'static
+{
+    let options = ClientOptions::NO_START_SERVER;
+    let (client, _status) = Client::new(name, options)?;
+    Ok(client.activate_async(
+        Notifications(Box::new({
+            let _app = app.clone();
+            move|_event|{
+                // FIXME: this deadlocks
+                //app.lock().unwrap().handle(&event).unwrap();
+            }
+        }) as Box<dyn Fn(AppEvent) + Send + Sync>),
+        ClosureProcessHandler::new(Box::new({
+            let app = app.clone();
+            move|c: &Client, s: &ProcessScope|{
+                app.write().unwrap().process(c, s)
+                //Control::Continue
+            }
+        }) as BoxedProcessHandler)
+    )?)
+}

crates/tek/src/jack/device.rs

@@ -0,0 +1,54 @@
+//! Wrap JACK-enabled [Device]s.
+
+use super::*;
+
+/// A [Device] bound to a JACK client and a set of ports.
+pub struct JackDevice {
+    /// The active JACK client of this device.
+    pub client: DynamicAsyncClient,
+    /// The device state, encapsulated for sharing between threads.
+    pub state:  Arc<RwLock<Box<dyn Device>>>,
+    /// Unowned copies of the device's JACK ports, for connecting to the device.
+    /// The "real" readable/writable `Port`s are owned by the `state`.
+    pub ports:  UnownedJackPorts,
+}
+impl std::fmt::Debug for JackDevice {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("JackDevice").field("ports", &self.ports).finish()
+    }
+}
+render!(JackDevice |self, buf, area| {
+    self.state.read().unwrap().render(buf, area)
+});
+ports!(JackDevice {
+    audio: {
+        ins:  |s|Ok(s.ports.audio_ins.values().collect()),
+        outs: |s|Ok(s.ports.audio_outs.values().collect()),
+    }
+    midi: {
+        ins:  |s|Ok(s.ports.midi_ins.values().collect()),
+        outs: |s|Ok(s.ports.midi_outs.values().collect()),
+    }
+});
+impl JackDevice {
+    /// Returns a locked mutex of the state's contents.
+    pub fn state (&self) -> LockResult<RwLockReadGuard<Box<dyn Device>>> {
+        self.state.read()
+    }
+    /// Returns a locked mutex of the state's contents.
+    pub fn state_mut (&self) -> LockResult<RwLockWriteGuard<Box<dyn Device>>> {
+        self.state.write()
+    }
+    pub fn connect_midi_in (&self, index: usize, port: &Port<Unowned>) -> Usually<()> {
+        Ok(self.client.as_client().connect_ports(port, self.midi_ins()?[index])?)
+    }
+    pub fn connect_midi_out (&self, index: usize, port: &Port<Unowned>) -> Usually<()> {
+        Ok(self.client.as_client().connect_ports(self.midi_outs()?[index], port)?)
+    }
+    pub fn connect_audio_in (&self, index: usize, port: &Port<Unowned>) -> Usually<()> {
+        Ok(self.client.as_client().connect_ports(port, self.audio_ins()?[index])?)
+    }
+    pub fn connect_audio_out (&self, index: usize, port: &Port<Unowned>) -> Usually<()> {
+        Ok(self.client.as_client().connect_ports(self.audio_outs()?[index], port)?)
+    }
+}

crates/tek/src/jack/event.rs

@@ -0,0 +1,73 @@
+//! JACK event handling.
+
+use super::*;
+
+/// Notification handler used by the [Jack] factory
+/// when constructing [JackDevice]s.
+pub type DynamicNotifications =
+    Notifications<Box<dyn Fn(AppEvent) + Send + Sync>>;
+
+#[derive(Debug)]
+/// Event enum for JACK events in [AppEvent].
+pub enum JackEvent {
+    ThreadInit,
+    Shutdown(ClientStatus, String),
+    Freewheel(bool),
+    SampleRate(Frames),
+    ClientRegistration(String, bool),
+    PortRegistration(PortId, bool),
+    PortRename(PortId, String, String),
+    PortsConnected(PortId, PortId, bool),
+    GraphReorder,
+    XRun,
+}
+
+/// Generic notification handler that emits [AppEvent]::Jack([JackEvent])s.
+pub struct Notifications<T: Fn(AppEvent) + Send>(pub T);
+
+impl<T: Fn(AppEvent) + Send> NotificationHandler for Notifications<T> {
+    fn thread_init (&self, _: &Client) {
+        self.0(AppEvent::Jack(JackEvent::ThreadInit));
+    }
+
+    fn shutdown (&mut self, status: ClientStatus, reason: &str) {
+        self.0(AppEvent::Jack(JackEvent::Shutdown(status, reason.into())));
+    }
+
+    fn freewheel (&mut self, _: &Client, enabled: bool) {
+        self.0(AppEvent::Jack(JackEvent::Freewheel(enabled)));
+    }
+
+    fn sample_rate (&mut self, _: &Client, frames: Frames) -> Control {
+        self.0(AppEvent::Jack(JackEvent::SampleRate(frames)));
+        Control::Quit
+    }
+
+    fn client_registration (&mut self, _: &Client, name: &str, reg: bool) {
+        self.0(AppEvent::Jack(JackEvent::ClientRegistration(name.into(), reg)));
+    }
+
+    fn port_registration (&mut self, _: &Client, id: PortId, reg: bool) {
+        self.0(AppEvent::Jack(JackEvent::PortRegistration(id, reg)));
+    }
+
+    fn port_rename (&mut self, _: &Client, id: PortId, old: &str, new: &str) -> Control {
+        self.0(AppEvent::Jack(JackEvent::PortRename(id, old.into(), new.into())));
+        Control::Continue
+    }
+
+    fn ports_connected (&mut self, _: &Client, a: PortId, b: PortId, are: bool) {
+        self.0(AppEvent::Jack(JackEvent::PortsConnected(a, b, are)));
+    }
+
+    fn graph_reorder (&mut self, _: &Client) -> Control {
+        self.0(AppEvent::Jack(JackEvent::GraphReorder));
+        Control::Continue
+    }
+
+    fn xrun (&mut self, _: &Client) -> Control {
+        self.0(AppEvent::Jack(JackEvent::XRun));
+        Control::Continue
+    }
+}
+

crates/tek/src/jack/factory.rs

@@ -0,0 +1,125 @@
+//! Encapsulate and run [Device]s as [JackDevice]s.
+use super::*;
+
+/// `JackDevice` factory. Creates JACK `Client`s, performs port registration
+/// and activation, and encapsulates a `Device` into a `JackDevice`.
+pub struct Jack {
+    pub client:     Client,
+    pub midi_ins:   Vec<String>,
+    pub audio_ins:  Vec<String>,
+    pub midi_outs:  Vec<String>,
+    pub audio_outs: Vec<String>,
+}
+impl Jack {
+    pub fn new (name: &str) -> Usually<Self> {
+        Ok(Self {
+            midi_ins:   vec![],
+            audio_ins:  vec![],
+            midi_outs:  vec![],
+            audio_outs: vec![],
+            client:     Client::new(
+                name,
+                ClientOptions::NO_START_SERVER
+            )?.0,
+        })
+    }
+    pub fn run <T: Device + Process + Sized + 'static> (
+        self, state: impl FnOnce(JackPorts)->Box<T>
+    )
+        -> Usually<JackDevice>
+    {
+        let owned_ports = JackPorts {
+            audio_ins:  register_ports(&self.client, self.audio_ins,  AudioIn)?,
+            audio_outs: register_ports(&self.client, self.audio_outs, AudioOut)?,
+            midi_ins:   register_ports(&self.client, self.midi_ins,   MidiIn)?,
+            midi_outs:  register_ports(&self.client, self.midi_outs,  MidiOut)?,
+        };
+        let midi_outs = owned_ports.midi_outs.values()
+            .map(|p|Ok(p.name()?)).collect::<Usually<Vec<_>>>()?;
+        let midi_ins = owned_ports.midi_ins.values()
+            .map(|p|Ok(p.name()?)).collect::<Usually<Vec<_>>>()?;
+        let audio_outs = owned_ports.audio_outs.values()
+            .map(|p|Ok(p.name()?)).collect::<Usually<Vec<_>>>()?;
+        let audio_ins = owned_ports.audio_ins.values()
+            .map(|p|Ok(p.name()?)).collect::<Usually<Vec<_>>>()?;
+        let state = Arc::new(RwLock::new(state(owned_ports) as Box<dyn Device>));
+        let client = self.client.activate_async(
+            Notifications(Box::new({
+                let _state = state.clone();
+                move|_event|{
+                    // FIXME: this deadlocks
+                    //state.lock().unwrap().handle(&event).unwrap();
+                }
+            }) as Box<dyn Fn(AppEvent) + Send + Sync>),
+            ClosureProcessHandler::new(Box::new({
+                let state = state.clone();
+                move|c: &Client, s: &ProcessScope|{
+                    state.write().unwrap().process(c, s)
+                }
+            }) as BoxedProcessHandler)
+        )?;
+        Ok(JackDevice {
+            ports: UnownedJackPorts {
+                audio_ins:  query_ports(&client.as_client(), audio_ins),
+                audio_outs: query_ports(&client.as_client(), audio_outs),
+                midi_ins:   query_ports(&client.as_client(), midi_ins),
+                midi_outs:  query_ports(&client.as_client(), midi_outs),
+            },
+            client,
+            state,
+        })
+    }
+    pub fn ports_from_lv2 (self, plugin: &::livi::Plugin) -> Self {
+        let counts = plugin.port_counts();
+        let mut jack = self;
+        for i in 0..counts.atom_sequence_inputs {
+            jack = jack.midi_in(&format!("midi-in-{i}"))
+        }
+        for i in 0..counts.atom_sequence_outputs {
+            jack = jack.midi_out(&format!("midi-out-{i}"));
+        }
+        for i in 0..counts.audio_inputs {
+            jack = jack.audio_in(&format!("audio-in-{i}"));
+        }
+        for i in 0..counts.audio_outputs {
+            jack = jack.audio_out(&format!("audio-out-{i}"));
+        }
+        jack
+    }
+    pub fn audio_in (mut self, name: &str) -> Self {
+        self.audio_ins.push(name.to_string());
+        self
+    }
+    pub fn audio_out (mut self, name: &str) -> Self {
+        self.audio_outs.push(name.to_string());
+        self
+    }
+    pub fn midi_in (mut self, name: &str) -> Self {
+        self.midi_ins.push(name.to_string());
+        self
+    }
+    pub fn midi_out (mut self, name: &str) -> Self {
+        self.midi_outs.push(name.to_string());
+        self
+    }
+}
+
+fn register_ports <T: PortSpec + Copy> (
+    client: &Client, names: Vec<String>, spec: T
+) -> Usually<BTreeMap<String, Port<T>>> {
+    names.into_iter().try_fold(BTreeMap::new(), |mut ports, name|{
+        let port = client.register_port(&name, spec)?;
+        ports.insert(name, port);
+        Ok(ports)
+    })
+}
+
+fn query_ports (
+    client: &Client, names: Vec<String>
+) -> BTreeMap<String, Port<Unowned>> {
+    names.into_iter().fold(BTreeMap::new(), |mut ports, name|{
+        let port = client.port_by_name(&name).unwrap();
+        ports.insert(name, port);
+        ports
+    })
+}

crates/tek/src/jack/ports.rs

@@ -0,0 +1,95 @@
+//! Handling JACK ports.
+use super::*;
+
+#[derive(Default)]
+/// Collection of JACK ports as [AudioIn]/[AudioOut]/[MidiIn]/[MidiOut].
+pub struct JackPorts {
+    pub audio_ins:  BTreeMap<String, Port<AudioIn>>,
+    pub midi_ins:   BTreeMap<String, Port<MidiIn>>,
+    pub audio_outs: BTreeMap<String, Port<AudioOut>>,
+    pub midi_outs:  BTreeMap<String, Port<MidiOut>>,
+}
+
+#[derive(Default)]
+/// Collection of JACK ports as [Unowned].
+#[derive(Debug)]
+pub struct UnownedJackPorts {
+    pub audio_ins:  BTreeMap<String, Port<Unowned>>,
+    pub midi_ins:   BTreeMap<String, Port<Unowned>>,
+    pub audio_outs: BTreeMap<String, Port<Unowned>>,
+    pub midi_outs:  BTreeMap<String, Port<Unowned>>,
+}
+
+impl JackPorts {
+    pub fn clone_unowned (&self) -> UnownedJackPorts {
+        let mut unowned = UnownedJackPorts::default();
+        for (name, port) in self.midi_ins.iter() {
+            unowned.midi_ins.insert(name.clone(), port.clone_unowned());
+        }
+        for (name, port) in self.midi_outs.iter() {
+            unowned.midi_outs.insert(name.clone(), port.clone_unowned());
+        }
+        for (name, port) in self.audio_ins.iter() {
+            unowned.audio_ins.insert(name.clone(), port.clone_unowned());
+        }
+        for (name, port) in self.audio_outs.iter() {
+            unowned.audio_outs.insert(name.clone(), port.clone_unowned());
+        }
+        unowned
+    }
+}
+
+/// Trait for things that may expose JACK ports.
+pub trait Ports {
+    fn audio_ins  <'a> (&'a self) -> Usually<Vec<&'a Port<Unowned>>> {
+        Ok(vec![])
+    }
+    fn audio_outs <'a> (&'a self) -> Usually<Vec<&'a Port<Unowned>>> {
+        Ok(vec![])
+    }
+    fn midi_ins  <'a> (&'a self) -> Usually<Vec<&'a Port<Unowned>>> {
+        Ok(vec![])
+    }
+    fn midi_outs <'a> (&'a self) -> Usually<Vec<&'a Port<Unowned>>> {
+        Ok(vec![])
+    }
+}
+
+/// Implement the `Ports` trait.
+#[macro_export] macro_rules! ports {
+    ($T:ty $({ $(audio: {
+        $(ins:  |$ai_arg:ident|$ai_impl:expr,)?
+        $(outs: |$ao_arg:ident|$ao_impl:expr,)?
+    })? $(midi: {
+        $(ins:  |$mi_arg:ident|$mi_impl:expr,)?
+        $(outs: |$mo_arg:ident|$mo_impl:expr,)?
+    })?})?) => {
+        impl Ports for $T {$(
+            $(
+                $(fn audio_ins <'a> (&'a self) -> Usually<Vec<&'a Port<Unowned>>> {
+                    let cb = |$ai_arg:&'a Self|$ai_impl;
+                    cb(self)
+                })?
+            )?
+            $(
+                $(fn audio_outs <'a> (&'a self) -> Usually<Vec<&'a Port<Unowned>>> {
+                    let cb = (|$ao_arg:&'a Self|$ao_impl);
+                    cb(self)
+                })?
+            )?
+        )? $(
+            $(
+                $(fn midi_ins <'a> (&'a self) -> Usually<Vec<&'a Port<Unowned>>> {
+                    let cb = (|$mi_arg:&'a Self|$mi_impl);
+                    cb(self)
+                })?
+            )?
+            $(
+                $(fn midi_outs <'a> (&'a self) -> Usually<Vec<&'a Port<Unowned>>> {
+                    let cb = (|$mo_arg:&'a Self|$mo_impl);
+                    cb(self)
+                })?
+            )?
+        )?}
+    };
+}

crates/tek/src/main.rs

@@ -0,0 +1,53 @@
+//! ***Tek*** is a MIDI sequencer, sampler, and audio plugin host for the Linux terminal.
+
+//#[global_allocator]
+//static A: rlsf::SmallGlobalTlsf = rlsf::SmallGlobalTlsf::new();
+//#![feature(fn_traits)]
+//#![feature(unboxed_closures)]
+#![allow(macro_expanded_macro_exports_accessed_by_absolute_paths)]
+#![allow(ambiguous_glob_reexports)]
+
+extern crate clap;
+extern crate jack as _jack;
+extern crate crossterm;
+
+mod core; crate::core::pubmod! { cli config control devices model view jack edn }
+
+use crate::{core::*, model::*};
+
+/// Application entrypoint.
+pub fn main () -> Usually<()> {
+    run(App::from_edn(include_str!("../../../demos/project.edn"))?
+        .activate(Some(|app: &Arc<RwLock<App>>|Ok({
+            let (midi_in, mut midi_outs) = {
+                let app = app.read().unwrap();
+                let jack = app.jack.as_ref().unwrap();
+                let midi_in = jack.register_port("midi-in", MidiIn)?;
+                let midi_outs = app.arranger.tracks.iter()
+                    .map(|t|Some(jack.register_port(&t.name, MidiOut).unwrap()))
+                    .collect::<Vec<_>>();
+                (midi_in, midi_outs)
+            };
+            {
+                let mut app = app.write().unwrap();
+                let jack = app.jack.as_ref().unwrap();
+                for name in app.midi_ins.iter() {
+                    let ports = jack.client().ports(Some(name), None, PortFlags::empty());
+                    for port in ports.iter() {
+                        if let Some(port) = jack.client().port_by_name(port) {
+                            jack.client().connect_ports(&port, &midi_in)?;
+                        }
+                    }
+                }
+                app.midi_in = Some(Arc::new(midi_in));
+                for (index, track) in app.arranger.tracks.iter_mut().enumerate() {
+                    track.midi_out = midi_outs[index].take();
+                }
+                for track in app.arranger.tracks.iter() {
+                    track.connect_first_device()?;
+                    track.connect_last_device(&app)?;
+                }
+            };
+        })))?)?;
+    Ok(())
+}

crates/tek/src/model.rs

@@ -0,0 +1,406 @@
+//! Application state.
+
+use crate::{core::*, devices::{arranger::*, sequencer::*, transport::*}};
+use once_cell::sync::Lazy;
+
+/// Global modal dialog
+pub static MODAL: Lazy<Arc<Mutex<Option<Box<dyn Exit>>>>> =
+    Lazy::new(||Arc::new(Mutex::new(None)));
+
+/// Root of application state.
+pub struct App {
+    /// Whether the currently focused section has input priority
+    pub entered:    bool,
+    /// Currently focused section
+    pub section:    AppFocus,
+    /// Transport model and view.
+    pub transport:  TransportToolbar,
+    /// Arranger model and view.
+    pub arranger:   Arranger,
+    /// Phrase editor
+    pub sequencer:  Sequencer,
+    /// Main JACK client.
+    pub jack:       Option<JackClient>,
+    /// Map of external MIDI outs in the jack graph
+    /// to internal MIDI ins of this app.
+    pub midi_in:    Option<Arc<Port<MidiIn>>>,
+    /// Names of ports to connect to main MIDI IN.
+    pub midi_ins:   Vec<String>,
+    /// Display mode of chain section
+    pub chain_mode: bool,
+    /// Paths to user directories
+    _xdg:           Option<Arc<XdgApp>>,
+    /// Main audio outputs.
+    pub audio_outs: Vec<Arc<Port<Unowned>>>,
+    /// Number of frames requested by process callback
+    chunk_size:     usize,
+}
+
+impl App {
+    pub fn new () -> Usually<Self> {
+        let xdg = Arc::new(microxdg::XdgApp::new("tek")?);
+        let first_run = crate::config::AppPaths::new(&xdg)?.should_create();
+        let jack = JackClient::Inactive(Client::new("tek", ClientOptions::NO_START_SERVER)?.0);
+        *MODAL.lock().unwrap() = first_run.then(||{
+            Exit::boxed(crate::devices::setup::SetupModal(Some(xdg.clone()), false))
+        });
+        Ok(Self {
+            entered:    true,
+            section:    AppFocus::default(),
+            transport:  TransportToolbar::new(Some(jack.transport())),
+            arranger:   Arranger::new(),
+            sequencer:  Sequencer::new(),
+            jack:       Some(jack),
+            audio_outs: vec![],
+            chain_mode: false,
+            chunk_size: 0,
+            midi_in:    None,
+            midi_ins:   vec![],
+            _xdg:       Some(xdg),
+        })
+    }
+}
+
+process!(App |self, _client, scope| {
+    let (
+        reset, current_frames, chunk_size, current_usecs, next_usecs, period_usecs
+    ) = self.transport.update(&scope);
+    self.chunk_size = chunk_size;
+    for track in self.arranger.tracks.iter_mut() {
+        track.process(
+            self.midi_in.as_ref().map(|p|p.iter(&scope)),
+            &self.transport.timebase,
+            self.transport.playing,
+            self.transport.started,
+            self.transport.quant as usize,
+            reset,
+            &scope,
+            (current_frames as usize, self.chunk_size),
+            (current_usecs as usize, next_usecs.saturating_sub(current_usecs) as usize),
+            period_usecs as f64
+        );
+    }
+    Control::Continue
+});
+
+impl App {
+    pub fn client (&self) -> &Client {
+        self.jack.as_ref().unwrap().client()
+    }
+    pub fn audio_out (&self, index: usize) -> Option<Arc<Port<Unowned>>> {
+        self.audio_outs.get(index).map(|x|x.clone())
+    }
+    pub fn with_midi_ins (mut self, names: &[&str]) -> Usually<Self> {
+        self.midi_ins = names.iter().map(|x|x.to_string()).collect();
+        Ok(self)
+    }
+    pub fn with_audio_outs (mut self, names: &[&str]) -> Usually<Self> {
+        let client = self.client();
+        self.audio_outs = names
+            .iter()
+            .map(|name|client
+                .ports(Some(name), None, PortFlags::empty())
+                .get(0)
+                .map(|name|client.port_by_name(name)))
+            .flatten()
+            .filter_map(|x|x)
+            .map(Arc::new)
+            .collect();
+        Ok(self)
+    }
+    pub fn activate (
+        mut self, init: Option<impl FnOnce(&Arc<RwLock<Self>>)->Usually<()>>
+    ) -> Usually<Arc<RwLock<Self>>> {
+        let jack = self.jack.take().expect("no jack client");
+        let app = Arc::new(RwLock::new(self));
+        app.write().unwrap().jack = Some(jack.activate(&app.clone(), |state, client, scope|{
+            state.write().unwrap().process(client, scope)
+        })?);
+        if let Some(init) = init {
+            init(&app)?;
+        }
+        Ok(app)
+    }
+}
+
+/// Different sections of the UI that may be focused.
+#[derive(PartialEq, Clone, Copy)]
+pub enum AppFocus {
+    /// The transport is selected.
+    Transport,
+    /// The arranger is selected.
+    Arranger,
+    /// The sequencer is selected.
+    Sequencer,
+    /// The device chain is selected.
+    Chain,
+}
+
+impl Default for AppFocus {
+    fn default () -> Self { Self::Arranger }
+}
+
+impl AppFocus {
+    pub fn prev (&mut self) {
+        *self = match self {
+            Self::Transport => Self::Chain,
+            Self::Arranger  => Self::Transport,
+            Self::Sequencer => Self::Arranger,
+            Self::Chain     => Self::Sequencer,
+        }
+    }
+    pub fn next (&mut self) {
+        *self = match self {
+            Self::Transport => Self::Arranger,
+            Self::Arranger  => Self::Sequencer,
+            Self::Sequencer => Self::Chain,
+            Self::Chain     => Self::Transport,
+        }
+    }
+}
+
+/// A sequencer track.
+#[derive(Debug)]
+pub struct Track {
+    pub name:       String,
+    /// Play input through output.
+    pub monitoring: bool,
+    /// Write input to sequence.
+    pub recording:  bool,
+    /// Overdub input to sequence.
+    pub overdub:    bool,
+    /// Map: tick -> MIDI events at tick
+    pub phrases:    Vec<Arc<RwLock<Phrase>>>,
+    /// Phrase selector
+    pub sequence:   Option<usize>,
+    /// Output from current sequence.
+    pub midi_out:   Option<Port<MidiOut>>,
+    /// MIDI output buffer
+    midi_out_buf:   Vec<Vec<Vec<u8>>>,
+    /// Device chain
+    pub devices:    Vec<JackDevice>,
+    /// Device selector
+    pub device:     usize,
+    /// Send all notes off
+    pub reset:      bool, // TODO?: after Some(nframes)
+    /// Highlight keys on piano roll.
+    pub notes_in:   [bool;128],
+    /// Highlight keys on piano roll.
+    pub notes_out:  [bool;128],
+}
+
+impl Track {
+    pub fn new (name: &str) -> Usually<Self> {
+        Ok(Self {
+            name:         name.to_string(),
+            midi_out:     None,
+            midi_out_buf: vec![Vec::with_capacity(16);16384],
+            notes_in:     [false;128],
+            notes_out:    [false;128],
+            monitoring:   false,
+            recording:    false,
+            overdub:      true,
+            sequence:     None,
+            phrases:      vec![],
+            devices:      vec![],
+            device:       0,
+            reset:        true,
+        })
+    }
+    fn get_device_mut (&self, i: usize) -> Option<RwLockWriteGuard<Box<dyn Device>>> {
+        self.devices.get(i).map(|d|d.state.write().unwrap())
+    }
+    pub fn device_mut (&self) -> Option<RwLockWriteGuard<Box<dyn Device>>> {
+        self.get_device_mut(self.device)
+    }
+    pub fn connect_first_device (&self) -> Usually<()> {
+        if let (Some(port), Some(device)) = (&self.midi_out, self.devices.get(0)) {
+            device.client.as_client().connect_ports(&port, &device.midi_ins()?[0])?;
+        }
+        Ok(())
+    }
+    pub fn connect_last_device (&self, app: &App) -> Usually<()> {
+        Ok(match self.devices.get(self.devices.len().saturating_sub(1)) {
+            Some(device) => {
+                app.audio_out(0).map(|left|device.connect_audio_out(0, &left)).transpose()?;
+                app.audio_out(1).map(|right|device.connect_audio_out(1, &right)).transpose()?;
+                ()
+            },
+            None => ()
+        })
+    }
+    pub fn add_device (&mut self, device: JackDevice) -> Usually<&mut JackDevice> {
+        self.devices.push(device);
+        let index = self.devices.len() - 1;
+        Ok(&mut self.devices[index])
+    }
+    pub fn toggle_monitor (&mut self) {
+        self.monitoring = !self.monitoring;
+    }
+    pub fn toggle_record (&mut self) {
+        self.recording = !self.recording;
+    }
+    pub fn toggle_overdub (&mut self) {
+        self.overdub = !self.overdub;
+    }
+    pub fn process (
+        &mut self,
+        input:    Option<MidiIter>,
+        timebase: &Arc<Timebase>,
+        playing:  Option<TransportState>,
+        started:  Option<(usize, usize)>,
+        quant:    usize,
+        reset:    bool,
+        scope:    &ProcessScope,
+        (frame0, frames): (usize, usize),
+        (_usec0,  _usecs):  (usize, usize),
+        period:   f64,
+    ) {
+        if self.midi_out.is_some() {
+            // Clear the section of the output buffer that we will be using
+            for frame in &mut self.midi_out_buf[0..frames] {
+                frame.clear();
+            }
+            // Emit "all notes off" at start of buffer if requested
+            if self.reset {
+                all_notes_off(&mut self.midi_out_buf);
+                self.reset = false;
+            } else if reset {
+                all_notes_off(&mut self.midi_out_buf);
+            }
+        }
+        if let (
+            Some(TransportState::Rolling), Some((start_frame, _)), Some(phrase)
+        ) = (
+            playing, started, self.sequence.and_then(|id|self.phrases.get_mut(id))
+        ) {
+            phrase.read().map(|phrase|{
+                if self.midi_out.is_some() {
+                    phrase.process_out(
+                        &mut self.midi_out_buf,
+                        &mut self.notes_out,
+                        timebase,
+                        (frame0.saturating_sub(start_frame), frames, period)
+                    );
+                }
+            }).unwrap();
+            let mut phrase = phrase.write().unwrap();
+            let length = phrase.length;
+            // Monitor and record input
+            if input.is_some() && (self.recording || self.monitoring) {
+                // For highlighting keys and note repeat
+                for (frame, event, bytes) in parse_midi_input(input.unwrap()) {
+                    match event {
+                        LiveEvent::Midi { message, .. } => {
+                            if self.monitoring {
+                                self.midi_out_buf[frame].push(bytes.to_vec())
+                            }
+                            if self.recording {
+                                phrase.record_event({
+                                    let pulse = timebase.frame_to_pulse(
+                                        (frame0 + frame - start_frame) as f64
+                                    );
+                                    let quantized = (
+                                        pulse / quant as f64
+                                    ).round() as usize * quant;
+                                    let looped = quantized % length;
+                                    looped
+                                }, message);
+                            }
+                            match message {
+                                MidiMessage::NoteOn { key, .. } => {
+                                    self.notes_in[key.as_int() as usize] = true;
+                                }
+                                MidiMessage::NoteOff { key, .. } => {
+                                    self.notes_in[key.as_int() as usize] = false;
+                                },
+                                _ => {}
+                            }
+                        },
+                        _ => {}
+                    }
+                }
+            }
+        } else if input.is_some() && self.midi_out.is_some() && self.monitoring {
+            for (frame, event, bytes) in parse_midi_input(input.unwrap()) {
+                self.process_monitor_event(frame, &event, bytes)
+            }
+        }
+        if let Some(out) = &mut self.midi_out {
+            write_midi_output(&mut out.writer(scope), &self.midi_out_buf, frames);
+        }
+    }
+
+    #[inline]
+    fn process_monitor_event (&mut self, frame: usize, event: &LiveEvent, bytes: &[u8]) {
+        match event {
+            LiveEvent::Midi { message, .. } => {
+                self.write_to_output_buffer(frame, bytes);
+                self.process_monitor_message(&message);
+            },
+            _ => {}
+        }
+    }
+
+    #[inline] fn write_to_output_buffer (&mut self, frame: usize, bytes: &[u8]) {
+        self.midi_out_buf[frame].push(bytes.to_vec());
+    }
+
+    #[inline]
+    fn process_monitor_message (&mut self, message: &MidiMessage) {
+        match message {
+            MidiMessage::NoteOn { key, .. } => {
+                self.notes_in[key.as_int() as usize] = true;
+            }
+            MidiMessage::NoteOff { key, .. } => {
+                self.notes_in[key.as_int() as usize] = false;
+            },
+            _ => {}
+        }
+    }
+}
+
+/// Define a MIDI phrase.
+#[macro_export] macro_rules! phrase {
+    ($($t:expr => $msg:expr),* $(,)?) => {{
+        #[allow(unused_mut)]
+        let mut phrase = BTreeMap::new();
+        $(phrase.insert($t, vec![]);)*
+        $(phrase.get_mut(&$t).unwrap().push($msg);)*
+        phrase
+    }}
+}
+
+macro_rules! impl_axis_common { ($A:ident $T:ty) => {
+    impl $A<$T> {
+        pub fn start_inc (&mut self) -> $T {
+            self.start = self.start + 1;
+            self.start
+        }
+        pub fn start_dec (&mut self) -> $T {
+            self.start = self.start.saturating_sub(1);
+            self.start
+        }
+        pub fn point_inc (&mut self) -> Option<$T> {
+            self.point = self.point.map(|p|p + 1);
+            self.point
+        }
+        pub fn point_dec (&mut self) -> Option<$T> {
+            self.point = self.point.map(|p|p.saturating_sub(1));
+            self.point
+        }
+    }
+} }
+
+pub struct FixedAxis<T> { pub start: T, pub point: Option<T> }
+impl_axis_common!(FixedAxis u16);
+impl_axis_common!(FixedAxis usize);
+
+pub struct ScaledAxis<T> { pub start: T, pub scale: T, pub point: Option<T> }
+impl_axis_common!(ScaledAxis u16);
+impl_axis_common!(ScaledAxis usize);
+impl<T: Copy> ScaledAxis<T> {
+    pub fn scale_mut (&mut self, cb: &impl Fn(T)->T) {
+        self.scale = cb(self.scale)
+    }
+}

crates/tek/src/view.rs

@@ -0,0 +1,20 @@
+//! Rendering of application to display.
+
+use crate::{render, App, core::*, devices::chain::ChainView, model::MODAL};
+
+submod! { border split theme }
+
+render!(App |self, buf, area| {
+    Split::down([
+        &self.transport,
+        &self.arranger,
+        &If(self.arranger.selected.is_clip(), &Split::right([
+            &ChainView::vertical(&self),
+            &self.sequencer,
+        ]))
+    ]).render(buf, area)?;
+    if let Some(ref modal) = *MODAL.lock().unwrap() {
+        modal.render(buf, area)?;
+    }
+    Ok(area)
+});

crates/tek/src/view/border.rs

@@ -0,0 +1,161 @@
+use crate::core::*;
+
+pub trait BorderStyle {
+    const NW: &'static str = "";
+    const N:  &'static str = "";
+    const NE: &'static str = "";
+    const E:  &'static str = "";
+    const SE: &'static str = "";
+    const S:  &'static str = "";
+    const SW: &'static str = "";
+    const W:  &'static str = "";
+
+    #[inline]
+    fn draw (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
+        self.draw_horizontal(buf, area, None)?;
+        self.draw_vertical(buf, area, None)?;
+        self.draw_corners(buf, area, None)?;
+        Ok(area)
+    }
+
+    #[inline]
+    fn draw_horizontal (&self, buf: &mut Buffer, area: Rect, style: Option<Style>) -> Usually<Rect> {
+        let style = style.or_else(||self.style_horizontal());
+        for x in area.x..(area.x+area.width).saturating_sub(1) {
+            self.draw_north(buf, x, area.y, style)?;
+            self.draw_south(buf, x, (area.y + area.height).saturating_sub(1), style)?;
+        }
+        Ok(area)
+    }
+    #[inline]
+    fn draw_north (&self, buf: &mut Buffer, x: u16, y: u16, style: Option<Style>) -> Usually<Rect> {
+        Self::N.blit(buf, x, y, style)
+    }
+    #[inline]
+    fn draw_south (&self, buf: &mut Buffer, x: u16, y: u16, style: Option<Style>) -> Usually<Rect> {
+        Self::S.blit(buf, x, y, style)
+    }
+
+    #[inline]
+    fn draw_vertical (&self, buf: &mut Buffer, area: Rect, style: Option<Style>) -> Usually<Rect> {
+        let style = style.or_else(||self.style_vertical());
+        for y in area.y..(area.y+area.height).saturating_sub(1) {
+            Self::W.blit(buf, area.x, y, style)?;
+            Self::E.blit(buf, area.x + area.width - 1, y, style)?;
+        }
+        Ok(area)
+    }
+
+    #[inline]
+    fn draw_corners (&self, buf: &mut Buffer, area: Rect, style: Option<Style>) -> Usually<Rect> {
+        let style = style.or_else(||self.style_corners());
+        Self::NW.blit(buf, area.x, area.y, style)?;
+        Self::NE.blit(buf, area.x + area.width - 1, area.y, style)?;
+        Self::SW.blit(buf, area.x, area.y + area.height - 1, style)?;
+        Self::SE.blit(buf, area.x + area.width - 1, area.y + area.height - 1, style)?;
+        Ok(area)
+    }
+
+    #[inline]
+    fn style (&self) -> Option<Style> {
+        None
+    }
+    #[inline]
+    fn style_horizontal (&self) -> Option<Style> {
+        self.style()
+    }
+    #[inline]
+    fn style_vertical (&self) -> Option<Style> {
+        self.style()
+    }
+    #[inline]
+    fn style_corners (&self) -> Option<Style> {
+        self.style()
+    }
+}
+
+macro_rules! border {
+    ($($T:ty {
+        $nw:literal $n:literal $ne:literal $w:literal $e:literal $sw:literal $s:literal $se:literal
+        $($x:tt)*
+    }),+) => {
+        $(impl BorderStyle for $T {
+            const NW: &'static str = $nw;
+            const N:  &'static str = $n;
+            const NE: &'static str = $ne;
+            const W:  &'static str = $w;
+            const E:  &'static str = $e;
+            const SW: &'static str = $sw;
+            const S:  &'static str = $s;
+            const SE: &'static str = $se;
+            $($x)*
+        })+
+    }
+}
+
+pub struct Lozenge(pub Style);
+pub struct LozengeV(pub Style);
+pub struct LozengeDotted(pub Style);
+pub struct Quarter(pub Style);
+pub struct QuarterV(pub Style);
+pub struct Chamfer(pub Style);
+pub struct Corners(pub Style);
+
+border! {
+    Lozenge {
+        "╭" "─" "╮"
+        "│"     "│"
+        "╰" "─" "╯"
+        fn style (&self) -> Option<Style> {
+            Some(self.0)
+        }
+    },
+    LozengeV {
+        "╭" "" "╮"
+        "│"    "│"
+        "╰" "" "╯"
+        fn style (&self) -> Option<Style> {
+            Some(self.0)
+        }
+    },
+    LozengeDotted {
+        "╭" "┅" "╮"
+        "┇"     "┇"
+        "╰" "┅" "╯"
+        fn style (&self) -> Option<Style> {
+            Some(self.0)
+        }
+    },
+    Quarter {
+        "▎" "▔" "🮇"
+        "▎"     "🮇"
+        "▎" "▁" "🮇"
+        fn style (&self) -> Option<Style> {
+            Some(self.0)
+        }
+    },
+    QuarterV {
+        "▎" "" "🮇"
+        "▎"    "🮇"
+        "▎" "" "🮇"
+        fn style (&self) -> Option<Style> {
+            Some(self.0)
+        }
+    },
+    Chamfer {
+        "🭂" "▔" "🭍"
+        "▎"     "🮇"
+        "🭓" "▁" "🭞"
+        fn style (&self) -> Option<Style> {
+            Some(self.0)
+        }
+    },
+    Corners {
+        "🬆" "" "🬊" // 🬴 🬸
+        ""     ""
+        "🬱" "" "🬵"
+        fn style (&self) -> Option<Style> {
+            Some(self.0)
+        }
+    }
+}

crates/tek/src/view/split.rs

@@ -0,0 +1,129 @@
+use crate::{core::*, view::*};
+
+pub struct Layered<'a, const N: usize>(pub [&'a (dyn Render + Sync); N]);
+
+impl<'a, const N: usize> Render for Layered<'a, N> {
+    fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
+        for layer in self.0.iter() {
+            layer.render(buf, area)?;
+        }
+        Ok(area)
+    }
+}
+
+pub struct If<'a>(pub bool, pub &'a (dyn Render + Sync));
+
+impl<'a> Render for If<'a> {
+    fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
+        match self.0 {
+            true  => self.1 as &dyn Render,
+            false => &() as &dyn Render
+        }.render(buf, area)
+    }
+}
+
+pub struct IfElse<'a>(pub bool, pub &'a (dyn Render + Sync), pub &'a (dyn Render + Sync));
+
+impl<'a> Render for IfElse<'a> {
+    fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
+        match self.0 {
+            true  => self.1 as &dyn Render,
+            false => &() as &dyn Render
+        }.render(buf, area)
+    }
+}
+
+#[derive(Copy, Clone)]
+pub enum Direction { Down, Right }
+
+impl Direction {
+    pub fn split <'a, const N: usize> (&self, items: [&'a (dyn Render + Sync);N]) -> Split<'a, N> {
+        Split(*self, items)
+    }
+    pub fn split_focus <'a> (&self, index: usize, items: Renderables<'a>, style: Style) -> SplitFocus<'a> {
+        SplitFocus(*self, index, items, style)
+    }
+    pub fn is_down (&self) -> bool {
+        match self { Self::Down => true, _ => false }
+    }
+    pub fn is_right (&self) -> bool {
+        match self { Self::Right => true, _ => false }
+    }
+}
+
+pub struct Split<'a, const N: usize>(
+    pub Direction, pub [&'a (dyn Render + Sync);N]
+);
+
+impl<'a, const N: usize> Split<'a, N> {
+    pub fn down (items: [&'a (dyn Render + Sync);N]) -> Self {
+        Self(Direction::Down, items)
+    }
+    pub fn right (items: [&'a (dyn Render + Sync);N]) -> Self {
+        Self(Direction::Right, items)
+    }
+    pub fn render_areas (&self, buf: &mut Buffer, area: Rect) -> Usually<(Rect, Vec<Rect>)> {
+        let Rect { mut x, mut y, mut width, mut height } = area;
+        let mut areas = vec![];
+        for item in self.1 {
+            if width == 0 || height == 0 {
+                break
+            }
+            let result = item.render(buf, Rect { x, y, width, height })?;
+            match self.0 {
+                Direction::Down => {
+                    y = y + result.height;
+                    height = height.saturating_sub(result.height);
+                },
+                Direction::Right => {
+                    x = x + result.width;
+                    width = width.saturating_sub(result.width);
+                },
+            };
+            areas.push(area);
+        }
+        Ok((area, areas))
+    }
+}
+
+impl<'a, const N: usize> Render for Split<'a, N> {
+    fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
+        Ok(self.render_areas(buf, area)?.0)
+    }
+}
+
+type Renderables<'a> = &'a [JackDevice];
+
+pub struct SplitFocus<'a>(pub Direction, pub usize, pub Renderables<'a>, pub Style);
+
+impl<'a> SplitFocus<'a> {
+    pub fn render_areas (&self, buf: &mut Buffer, area: Rect) -> Usually<(Rect, Vec<Rect>)> {
+        let Rect { mut x, mut y, mut width, mut height } = area;
+        let mut areas = vec![];
+        for item in self.2.iter() {
+            if width == 0 || height == 0 {
+                break
+            }
+            let result = item.render(buf, Rect { x, y, width, height })?;
+            areas.push(result);
+            match self.0 {
+                Direction::Down => {
+                    y = y + result.height;
+                    height = height.saturating_sub(result.height);
+                },
+                Direction::Right => {
+                    x = x + result.width;
+                    width = width.saturating_sub(result.width);
+                },
+            }
+            Lozenge(self.3).draw(buf, result)?;
+        }
+        Ok((area, areas))
+    }
+}
+
+impl<'a> Render for SplitFocus<'a> {
+    fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
+        Ok(self.render_areas(buf, area)?.0)
+    }
+}

crates/tek/src/view/theme.rs

@@ -0,0 +1,71 @@
+use crate::core::*;
+
+pub trait Theme {
+    const BG0:    Color;
+    const BG1:    Color;
+    const BG2:    Color;
+    const BG3:    Color;
+    const BG4:    Color;
+    const RED:    Color;
+    const YELLOW: Color;
+    const GREEN:  Color;
+
+    const PLAYING: Color;
+    const SEPARATOR: Color;
+
+    fn bg_hier (focused: bool, entered: bool) -> Color {
+        if focused && entered {
+            Self::BG3
+        } else if focused {
+            Self::BG2
+        } else {
+            Self::BG1
+        }
+    }
+
+    fn bg_hi (focused: bool, entered: bool) -> Color {
+        if focused && entered {
+            Self::BG2
+        } else if focused {
+            Self::BG1
+        } else {
+            Self::BG0
+        }
+    }
+
+    fn bg_lo (focused: bool, entered: bool) -> Color {
+        if focused && entered {
+            Self::BG1
+        } else if focused {
+            Self::BG0
+        } else {
+            Color::Reset
+        }
+    }
+
+    fn style_hi (focused: bool, highlight: bool) -> Style {
+        if highlight && focused {
+            Style::default().yellow().not_dim()
+        }  else if highlight {
+            Style::default().yellow().dim()
+        } else {
+            Style::default()
+        }
+    }
+}
+
+pub struct Nord;
+
+impl Theme for Nord {
+    const BG0:    Color = Color::Rgb(41, 46, 57);
+    const BG1:    Color = Color::Rgb(46, 52, 64);
+    const BG2:    Color = Color::Rgb(59, 66, 82);
+    const BG3:    Color = Color::Rgb(67, 76, 94);
+    const BG4:    Color = Color::Rgb(76, 86, 106);
+    const RED:    Color = Color::Rgb(191, 97, 106);
+    const YELLOW: Color = Color::Rgb(235, 203, 139);
+    const GREEN:  Color = Color::Rgb(163, 190, 140);
+
+    const PLAYING:   Color = Color::Rgb(60, 100, 50);
+    const SEPARATOR: Color = Color::Rgb(0, 0, 0);
+}