flatten workspace into 1 crate

.old/src/app.rs

@@ -0,0 +1,151 @@
+use crate::*;
+use tek_core::Direction;
+use tek_mixer::Mixer;
+use tek_sequencer::{Arranger, TransportToolbar};
+
+/// 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 (contains sequencers)
+    pub arranger: Arranger,
+    /// Mixer (contains tracks)
+    pub mixer: Mixer,
+    /// Main JACK client.
+    pub jack: Option<JackClientt>,
+    /// 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,
+    /// Main audio outputs.
+    pub audio_outs: Vec<Arc<Port<Unowned>>>,
+    /// Number of frames requested by process callback
+    chunk_size: usize,
+    /// Paths to user directories
+    _xdg: Option<Arc<XdgApp>>,
+}
+
+impl App {
+    pub fn new() -> Usually<Self> {
+        let xdg = Arc::new(XdgApp::new("tek")?);
+        let first_run = AppPaths::new(&xdg)?.should_create();
+        let jack = JackClient::Inactive(Client::new("tek", ClientOptions::NO_START_SERVER)?.0);
+        *MODAL.lock().unwrap() =
+            first_run.then(|| ExitableComponent::boxed(SetupModal(Some(xdg.clone()), false)));
+        Ok(Self {
+            entered: true,
+            section: AppFocus::default(),
+            transport: TransportToolbar::new(Some(jack.transport())),
+            arranger: Arranger::new(""),
+            mixer: Mixer::new("")?,
+            jack: Some(jack),
+            audio_outs: vec![],
+            chain_mode: false,
+            chunk_size: 0,
+            midi_in: None,
+            midi_ins: vec![],
+            _xdg: Some(xdg),
+        })
+    }
+    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)
+    }
+}
+
+render!(
+    App | self,
+    buf,
+    area | {
+        Stack::down()
+            .add_ref(&self.transport)
+            .add_ref(&self.arranger)
+            .add(If(
+                self.arranger.selected.is_clip(),
+                &Stack::right()
+                    .add(tek_mixer::TrackView {
+                        direction: Direction::Down,
+                        entered: self.entered,
+                        focused: self.section == AppFocus::Chain,
+                        chain: self.mixer.track(),
+                    })
+                    .add_ref(&self.arranger.sequencer()),
+            ))
+            .render(buf, area)?;
+        if let Some(ref modal) = *MODAL.lock().unwrap() {
+            modal.render(buf, area)?;
+        }
+        Ok(area)
+    }
+);
+
+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
+    }
+);

.old/src/app_focus.rs

@@ -0,0 +1,37 @@
+use crate::*;
+
+/// 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,
+        }
+    }
+}

.old/src/app_paths.rs

@@ -0,0 +1,52 @@
+//! Global settings.
+
+use crate::*;
+use std::path::{Path, PathBuf};
+use std::fs::{File, create_dir_all};
+
+const CONFIG_FILE_NAME:  &str = "tek.toml";
+const PROJECT_FILE_NAME: &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(())
+    }
+}

.old/src/cli.rs

@@ -0,0 +1,29 @@
+//! Command line option parser.
+
+use tek_core::clap::{self, 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,
+}

.old/src/control.rs

@@ -0,0 +1,184 @@
+//! Handling of input events.
+
+use crate::*;
+
+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> {
+    unimplemented!()
+    //match state.section {
+        //AppFocus::Transport => state.transport.handle(e),
+        //AppFocus::Arranger  => state.arranger.sequencer_mut().map(|s|s.handle(e)),
+        //AppFocus::Sequencer => state.arranger.sequencer_mut().map(|s|s.handle(e)),
+        //AppFocus::Chain => Ok(false)[>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.mixer.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 = Note::next(app.transport.quant);
+        Ok(true)
+    }],
+    [Char('_'), NONE, "quant_dec", "quantize finer",   |app: &mut App| {
+        app.transport.quant = Note::prev(app.transport.quant);
+        Ok(true)
+    }],
+    [Char('='), NONE, "zoom_in",  "show fewer ticks per block",  |app: &mut App| {
+        app.arranger.sequencer_mut().map(|s|s.time_axis.scale_mut(&Note::prev));
+        Ok(true)
+    }],
+    [Char('-'), NONE, "zoom_out", "show more ticks per block", |app: &mut App| {
+        app.arranger.sequencer_mut().map(|s|s.time_axis.scale_mut(&Note::next));
+        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.arranger.show_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)
+    }],
+});
+
+/// 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(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.arranger.sequencer_mut().map(|s|s.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.arranger.sequencer_mut().map(|s|s.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.arranger.sequencer_mut().map(|s|{
+        s.focused = app.section == AppFocus::Sequencer;
+        s.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.arranger.sequencer_mut().map(|s|{
+        s.focused = app.section == AppFocus::Sequencer;
+        s.entered = app.entered;
+    });
+    Ok(true)
+}

.old/src/edn.rs

@@ -0,0 +1,99 @@
+//! 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::*;
+
+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")) => {
+                        tek_sequencer::Scene::from_edn(&items[1..])?;
+                    },
+                    Some(Edn::Symbol("track")) => {
+                        tek_mixer::Track::from_edn(&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(())
+    }
+
+}

.old/src/help.rs

@@ -0,0 +1,96 @@
+//! Help modal / command palette.
+
+use crate::*;
+
+/// 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 }
+    }
+}
+
+impl Exit for HelpModal {
+    fn exited (&self) -> bool {
+        self.exited
+    }
+    fn exit (&mut self) {
+        self.exited = true
+    }
+}
+
+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)
+    }],
+});

.old/src/main.rs

@@ -0,0 +1,65 @@
+//! ***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)]
+
+pub(crate) use tek_core::{*, jack::*};
+pub(crate) use tek_sequencer::*;
+pub(crate) use tek_mixer::*;
+pub(crate) use microxdg::XdgApp;
+
+submod! {
+    app
+    app_focus
+    app_paths
+    cli
+    control
+    edn
+    help
+    setup
+}
+
+/// Global modal dialog
+pub static MODAL: Lazy<Arc<Mutex<Option<Box<dyn ExitableComponent>>>>> =
+    Lazy::new(||Arc::new(Mutex::new(None)));
+
+/// Application entrypoint.
+pub fn main () -> Usually<()> {
+    run(App::from_edn(include_str!("../example.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.read().unwrap(), 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(())
+}

.old/src/setup.rs

@@ -0,0 +1,55 @@
+//! Inital setup dialog (TODO: make this the options dialog too?)
+
+use crate::*;
+
+/// 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(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
+    }
+}