implement controller traits

src/device/arrange/clip.rs

@@ -0,0 +1,165 @@
+use crate::*;
+
+/// TODO: Preserve the generic passthru syntax;
+/// remove this macro (only used twice) and potentially the trait.
+#[macro_export] macro_rules! impl_has_clips {
+    (|$self:ident:$Struct:ident$(<$($L:lifetime),*$($T:ident$(:$U:path)?),*>)?|$cb:expr) => {
+        impl $(<$($L),*$($T $(: $U)?),*>)? HasClips for $Struct $(<$($L),*$($T),*>)? {
+            fn clips <'a> (&'a $self) -> std::sync::RwLockReadGuard<'a, ClipPool>      {
+                $cb.read().unwrap()
+            }
+            fn clips_mut <'a> (&'a $self) -> std::sync::RwLockWriteGuard<'a, ClipPool> {
+                $cb.write().unwrap()
+            }
+        }
+    }
+}
+
+#[macro_export] macro_rules! has_clip {
+    (|$self:ident:$Struct:ident$(<$($L:lifetime),*$($T:ident$(:$U:path)?),*>)?|$cb:expr) => {
+        impl $(<$($L),*$($T $(: $U)?),*>)? HasMidiClip for $Struct $(<$($L),*$($T),*>)? {
+            fn clip (&$self) -> Option<Arc<RwLock<MidiClip>>> { $cb }
+        }
+    }
+}
+
+impl Arrangement {
+    /// Toggle looping for the active clip
+    pub fn toggle_loop (&mut self) {
+        if let Some(clip) = self.selected_clip() {
+            clip.write().unwrap().toggle_loop()
+        }
+    }
+
+    /// Put a clip in a slot
+    pub fn clip_put (
+        &mut self, track: usize, scene: usize, clip: Option<Arc<RwLock<MidiClip>>>
+    ) -> Option<Arc<RwLock<MidiClip>>> {
+        let old = self.scenes[scene].clips[track].clone();
+        self.scenes[scene].clips[track] = clip;
+        old
+    }
+
+    /// Change the color of a clip, returning the previous one
+    pub fn clip_set_color (
+        &self, track: usize, scene: usize, color: ItemTheme
+    ) -> Option<ItemTheme> {
+        self.scenes[scene].clips[track].as_ref().map(|clip|{
+            let mut clip = clip.write().unwrap();
+            let old = clip.color.clone();
+            clip.color = color.clone();
+            panic!("{color:?} {old:?}");
+            //old
+        })
+    }
+}
+
+impl<T: TracksView + ScenesView + Send + Sync> ClipsView for T {}
+
+pub trait HasClipsSize {
+    fn clips_size (&self) -> &Sizer;
+}
+
+impl HasClipsSize for App {
+    fn clips_size (&self) -> &Sizer { &self.project.size_inner }
+}
+
+impl HasClipsSize for Arrangement {
+    fn clips_size (&self) -> &Sizer { &self.size_inner }
+}
+
+pub trait ClipsView: TracksView + ScenesView {
+    /// Draw clips per scene
+    fn view_scenes_clips <'a> (&'a self) -> impl Draw<Tui> + 'a {
+        view_scenes_clips(
+            ||self.scenes_with_sizes(),
+            self.tracks_with_sizes(),
+            self.selection(),
+            self.editor(),
+            self.clips_size(),
+            self.is_editing(),
+        )
+    }
+}
+
+pub fn view_scenes_clips <'a, S: ScenesSizes<'a>> (
+    scenes:  impl Fn()->S,
+    tracks:  impl TracksSizes<'a>,
+    select:  &Selection,
+    editor:  Option<&MidiEditor>,
+    size:    &Sizer,
+    editing: bool,
+) -> impl Draw<Tui> {
+    let status = fg(Green, format!("{}x{}", size.w(), size.h())).align_se().full_wh();
+    let tracks = iter_once(tracks, move|(track_index, track, _, _), _| {
+        let scenes = iter_once(scenes(), move|(scene_index, scene, _, _), _| {
+            let (name, theme): (Arc<str>, ItemTheme) = scene_name_theme(scene, track_index);
+            let f = theme.lightest.term;
+            let (b, o) = scene_bg(theme, select, track_index, scene_index);
+            let w = scene_w(track, select, track_index, editor);
+            let y = scene_y(select, scene_index, editor);
+            let is_selected = scene_sel(select, track_index, scene_index, editing);
+            below(
+                Outer(true, Style::default().fg(o)).full_wh(),
+                below(
+                    below(
+                        fg_bg(o, b, "".full_wh()),
+                        fg_bg(f, b, bold(true, name)).align_nw().full_wh(),
+                    ),
+                    when(is_selected, editor.map(|e|e.view())).full_wh()
+                ).full_wh()
+            ).exact_wh(w, y)
+        });
+        scenes.full_h().exact_w(track.width as u16)
+    });
+
+    return size.of(above(status, tracks).full_wh());
+
+    fn scene_name_theme (scene: &Scene, track_index: usize) -> (Arc<str>, ItemTheme) {
+        if let Some(Some(clip)) = &scene.clips.get(track_index) {
+            let clip = clip.read().unwrap();
+            (format!(" ⏹ {}", &clip.name).into(), clip.color)
+        } else {
+            (" ⏹ -- ".into(), ItemTheme::G[32])
+        }
+    }
+
+    fn scene_bg (
+        theme: ItemTheme, select: &Selection, track_index: usize, scene_index: usize
+    ) -> (Color, Color) {
+        let mut outline = theme.base.term;
+        (if select.track() == Some(track_index) && select.scene() == Some(scene_index) {
+            outline = theme.lighter.term;
+            theme.light.term
+        } else if select.track() == Some(track_index) || select.scene() == Some(scene_index) {
+            outline = theme.darkest.term;
+            theme.base.term
+        } else {
+            theme.dark.term
+        }, outline)
+    }
+
+    fn scene_w (
+        track: &Track, select: &Selection, track_index: usize, editor: Option<&MidiEditor>
+    ) -> u16 {
+        if select.track() == Some(track_index) && let Some(editor) = editor {
+            (editor.size.w() as usize).max(24).max(track.width) as u16
+        } else {
+            track.width as u16
+        }
+    }
+
+    fn scene_y (
+        select: &Selection, scene_index: usize, editor: Option<&MidiEditor>
+    ) -> u16 {
+        if select.scene() == Some(scene_index) && let Some(editor) = editor {
+            editor.size.h().max(12)
+        } else {
+            Scene::DEFAULT_HEIGHT as u16
+        }
+    }
+
+    fn scene_sel (select: &Selection, track_index: usize, scene_index: usize, editing: bool) -> bool {
+        editing && select.track() == Some(track_index) && select.scene() == Some(scene_index)
+    }
+}

src/device/arrange/port.rs

@@ -0,0 +1,87 @@
+use crate::*;
+def_sizes_iter!(PortsSizes  => Arc<str>, [Connect]);
+impl_has!(Vec<MidiInput>:  |self: Arrangement| self.midi_ins);
+impl_has!(Vec<MidiOutput>: |self: Arrangement| self.midi_outs);
+impl_has!(Vec<MidiInput>:  |self: App|self.project.midi_ins);
+impl_has!(Vec<MidiOutput>: |self: App|self.project.midi_outs);
+
+pub fn view_midi_ins_status (theme: ItemTheme, track: Option<&Track>) -> impl Draw<Tui> {
+    track.map(move|track|view_ports_status(theme, "MIDI ins:  ", &track.sequencer.midi_ins))
+}
+
+pub fn view_midi_outs_status (theme: ItemTheme, track: Option<&Track>) -> impl Draw<Tui> {
+    track.map(move|track|view_ports_status(theme, "MIDI outs: ", &track.sequencer.midi_outs))
+}
+
+pub fn view_audio_ins_status (theme: ItemTheme, track: Option<&Track>) -> impl Draw<Tui> {
+    track.map(move|track|view_ports_status(theme, "Audio ins: ", &track.audio_ins()))
+}
+
+pub fn view_audio_outs_status (theme: ItemTheme, track: Option<&Track>) -> impl Draw<Tui> {
+    track.map(move|track|view_ports_status(theme, "Audio outs:", &track.audio_outs()))
+}
+
+pub fn view_ports_status <'a, T: JackPort> (theme: ItemTheme, title: &'a str, ports: &'a [T])
+    -> impl Draw<Tui> + use<'a, T>
+{
+    let ins   = ports.len() as u16;
+    let frame = Outer(true, Style::default().fg(g(96)));
+    let names = iter_south(move||ports.iter().enumerate().map(|(index, port)|format!(
+        " {index} {}", port.port_name()
+    ).align_w().full_h()));
+    let field = field_v(theme, title, names);
+    border(true, frame, field.exact_wh(20, 1 + ins)).exact_wh(20, 1 + ins)
+}
+
+pub fn view_io_ports <'a, T: PortsSizes<'a>> (
+    fg: Color, bg: Color, items: impl Fn()->T + Send + Sync + 'a
+) -> impl Draw<Tui> + 'a {
+    type Item<'a> = (usize, &'a Arc<str>, &'a [Connect], usize, usize);
+    iter(items,
+        move|(_index, name, connections, y, y2): Item<'a>, _| south(
+            bold(true, fg_bg(fg, bg, east(" 󰣲 ", name).align_w())).full_h(),
+            iter(||connections.iter(), move|connect: &'a Connect, index|{
+                bold(false, fg_bg(fg, bg, &connect.info)).exact_h(1).align_w().push_y(index as u16)
+            })
+        ).exact_h((y2 - y) as u16).push_y(y as u16))
+}
+
+pub struct Junction<T: JackPort>(T);
+
+impl<T: JackPort> View<Tui> for Junction<T> {
+    fn view (&self) -> impl Draw<Tui> {
+        T::KIND
+    }
+}
+
+#[tek_proc::command(AudioInput)]
+#[tek_proc::keyword(AudioInput)]
+#[derive(Debug)]
+pub enum AudioInputCommand {
+    Close,
+    Connect(Arc<str>),
+}
+
+#[tek_proc::command(AudioOutput)]
+#[tek_proc::keyword(AudioOutput)]
+#[derive(Debug)]
+pub enum AudioOutputCommand {
+    Close,
+    Connect(Arc<str>),
+}
+
+#[tek_proc::command(MidiInput)]
+#[tek_proc::keyword(MidiInput)]
+#[derive(Debug)]
+pub enum MidiInputCommand {
+    Close,
+    Connect(Arc<str>),
+}
+
+#[tek_proc::command(MidiOutput)]
+#[tek_proc::keyword(MidiOutput)]
+#[derive(Debug)]
+pub enum MidiOutputCommand {
+    Close,
+    Connect(Arc<str>),
+}

src/device/arrange/scene.rs

@@ -0,0 +1,289 @@
+use crate::*;
+use super::*;
+
+/// A scene consists of a set of clips to play together.
+///
+/// ```
+/// let scene: tek::Scene = Default::default();
+/// let _ = scene.pulses();
+/// let _ = scene.is_playing(&[]);
+/// ```
+#[derive(Debug, Default)] pub struct Scene {
+    /// Name of scene
+    pub name:  Arc<str>,
+    /// Identifying color of scene
+    pub color: ItemTheme,
+    /// Clips in scene, one per track
+    pub clips: Vec<Option<Arc<RwLock<MidiClip>>>>,
+}
+
+impl Scene {
+    pub const DEFAULT_HEIGHT: usize = 2;
+
+    /// Get currently playing clip, if any
+    pub fn clip (&self, index: usize) -> Option<&Arc<RwLock<MidiClip>>> {
+        if let Some(Some(clip)) = self.clips.get(index) {
+            Some(clip)
+        } else {
+            None
+        }
+    }
+
+    /// Get pulse length of the longest clip in the scene
+    pub fn pulses (&self) -> usize {
+        self.clips.iter().fold(0, |a, p|{
+            a.max(p.as_ref().map(|q|q.read().unwrap().length).unwrap_or(0))
+        })
+    }
+
+    /// True if all clips in scene are currently playing on given tracks.
+    pub fn is_playing (&self, tracks: &[Track]) -> bool {
+        self.clips.iter().any(|clip|clip.is_some()) && self.clips.iter().enumerate()
+            .all(|(track_index, clip)|match clip {
+                Some(c) => tracks
+                    .get(track_index)
+                    .map(|track|{
+                        if let Some((_, Some(clip))) = track.sequencer().play_clip() {
+                            *clip.read().unwrap() == *c.read().unwrap()
+                        } else {
+                            false
+                        }
+                    })
+                    .unwrap_or(false),
+                None => true
+            })
+    }
+
+}
+
+#[cfg(all(feature = "select"))] impl_as_ref_opt!(Scene: |self: App| self.project.as_ref_opt());
+#[cfg(all(feature = "select"))] impl_as_mut_opt!(Scene: |self: App| self.project.as_mut_opt());
+#[cfg(all(feature = "select"))] impl_as_ref_opt!(Scene: |self: Arrangement| self.selected_scene());
+#[cfg(all(feature = "select"))] impl_as_mut_opt!(Scene: |self: Arrangement| self.selected_scene_mut());
+
+impl<T: AsRefOpt<Scene> + AsMutOpt<Scene> + Send + Sync> HasScene for T {}
+
+pub trait HasScene: AsRefOpt<Scene> + AsMutOpt<Scene> {
+    fn scene (&self) -> Option<&Scene> {
+        self.as_ref_opt()
+    }
+    fn scene_mut (&mut self) -> Option<&mut Scene> {
+        self.as_mut_opt()
+    }
+}
+
+impl<T: HasScene
+    + for<'a> Namespace<'a, usize>
+    + for<'a> Namespace<'a, Arc<str>>
+    + for<'a> Namespace<'a, ItemTheme>
+> SceneController for T {}
+
+#[tek_proc::commands(SceneCommand)]
+pub trait SceneController: HasScene
+    + for<'a> Namespace<'a, usize>
+    + for<'a> Namespace<'a, Arc<str>>
+    + for<'a> Namespace<'a, ItemTheme>
+{
+    #[command(SetSize = "scene/size")]
+    fn scene_set_size (&mut self, size: usize) -> Perhaps<SceneCommand>
+        where Self: for<'a> Namespace<'a, usize>
+    {
+        todo!()
+    }
+    #[command(SetZoom = "scene/zoom")]
+    fn scene_set_zoom (&mut self, size: usize) -> Perhaps<SceneCommand>
+        where Self: for<'a> Namespace<'a, usize>
+    {
+        todo!()
+    }
+    #[command(SetName = "scene/name")]
+    fn scene_set_name (&mut self, name: Arc<str>) -> Perhaps<SceneCommand>
+        where Self: for<'a> Namespace<'a, Arc<str>>
+    {
+        Ok(self.scene_mut().map(|scene|swap_value(
+            &mut scene.name,
+            &name,
+            |name|SceneCommand::SetName { name }
+        )).transpose()?.flatten())
+    }
+    #[command(SetColor = "scene/color")]
+    fn scene_set_color (&mut self, color: ItemTheme) -> Perhaps<SceneCommand>
+        where Self: for<'a> Namespace<'a, ItemTheme>
+    {
+        Ok(self.scene_mut().map(|scene|swap_value(
+            &mut scene.color,
+            &color,
+            |color|SceneCommand::SetColor { color }
+        )).transpose()?.flatten())
+    }
+}
+
+pub type SceneWith<'a, T> = (usize, &'a Scene, usize, usize, T);
+
+def_sizes_iter!(ScenesSizes => Scene);
+impl_has!(Vec<Scene>: |self: Arrangement| self.scenes);
+impl_as_ref!(Vec<Scene>: |self: App| self.project.as_ref());
+impl_as_mut!(Vec<Scene>: |self: App| self.project.as_mut());
+
+impl<T: AsRef<Vec<Scene>> + AsMut<Vec<Scene>>> HasScenes for T {}
+
+pub trait HasScenes: AsRef<Vec<Scene>> + AsMut<Vec<Scene>> {
+    fn scenes (&self) -> &Vec<Scene> {
+        self.as_ref()
+    }
+    fn scenes_mut (&mut self) -> &mut Vec<Scene> {
+        self.as_mut()
+    }
+    /// Generate the default name for a new scene
+    fn scenes_default_name (&self) -> Arc<str> {
+        format!("s{:3>}", self.scenes().len() + 1).into()
+    }
+    fn scenes_longest_name (&self) -> usize {
+        self.scenes().iter().map(|s|s.name.len()).fold(0, usize::max)
+    }
+    /// Add multiple scenes
+    fn scenes_add_many (&mut self, n: usize)
+        -> Usually<()> where Self: HasTracks
+    {
+        let scene_color_1 = ItemColor::random();
+        let scene_color_2 = ItemColor::random();
+        for i in 0..n {
+            let _ = self.scenes_add_one(None, Some(
+                scene_color_1.mix(scene_color_2, i as f32 / n as f32).into()
+            ))?;
+        }
+        Ok(())
+    }
+    /// Add a scene
+    fn scenes_add_one (&mut self, name: Option<Arc<str>>, color: Option<ItemTheme>)
+        -> Usually<(usize, &mut Scene)>
+    where
+        Self: HasTracks
+    {
+        let scene = Scene {
+            name:  name.map_or_else(||self.scenes_default_name(), |x|x.to_string().into()),
+            clips: vec![None;self.tracks().len()],
+            color: color.unwrap_or_else(ItemTheme::random),
+        };
+        self.scenes_mut().push(scene);
+        let index = self.scenes().len() - 1;
+        Ok((index, &mut self.scenes_mut()[index]))
+    }
+}
+
+impl<T: HasScenes
+    + for<'a> Namespace<'a, usize>
+    + for<'a> Namespace<'a, Option<ItemTheme>>
+    + for<'a> Namespace<'a, Option<Arc<str>>>
+> ScenesController for T {}
+
+#[tek_proc::commands(ScenesCommand)]
+pub trait ScenesController: HasScenes
+    + for<'a> Namespace<'a, usize>
+    + for<'a> Namespace<'a, Option<ItemTheme>>
+    + for<'a> Namespace<'a, Option<Arc<str>>>
+{
+    // TODO
+}
+
+pub trait ScenesView: HasEditor + HasSelection + HasSceneScroll + HasClipsSize + Send + Sync {
+    fn h_scenes (&self) -> u16;
+    fn w_side   (&self) -> u16;
+    fn w_mid    (&self) -> u16;
+
+    fn view_scenes_names (&self) -> impl Draw<Tui> {
+        let select  = self.selection();
+        let editor  = self.editor();
+        let editing = self.is_editing();
+        draw(move |to: &mut Tui|{
+            for (index, scene, ..) in self.scenes_with_sizes() {
+                view_scene_name(select, editor, index, scene, editing).draw(to)?;
+            }
+            Ok(Some(XYWH(1, 1, 1, 1)))
+        })
+            .exact_w(20)
+    }
+
+    fn scenes_with_sizes (&self) -> impl ScenesSizes<'_> {
+        let mut y = 0;
+        self.scenes().iter().enumerate().skip(self.scene_scroll()).map_while(move|(s, scene)|{
+            let height = if self.selection().scene() == Some(s) && self.editor().is_some() {
+                8
+            } else {
+                Scene::DEFAULT_HEIGHT
+            };
+            if y + height <= self.clips_size().h() as usize {
+                let data = (s, scene, y, y + height);
+                y += height;
+                Some(data)
+            } else {
+                None
+            }
+        })
+    }
+}
+
+impl ScenesView for App {
+    fn w_mid (&self) -> u16 {
+        (self.size.w() as u16).saturating_sub(self.w_side())
+    }
+    fn w_side (&self) -> u16 {
+        20
+    }
+    fn h_scenes (&self) -> u16 {
+        (self.size.h() as u16).saturating_sub(20)
+    }
+}
+
+impl ScenesView for Arrangement {
+    fn h_scenes (&self) -> u16 {
+        (self.size.h() as u16).saturating_sub(20)
+    }
+    fn w_side (&self) -> u16 {
+        (self.size.w() as u16 * 2 / 10).max(20)
+    }
+    fn w_mid (&self) -> u16 {
+        (self.size.w() as u16).saturating_sub(2 * self.w_side()).max(40)
+    }
+}
+
+pub trait HasSceneScroll: HasScenes {
+    fn scene_scroll (&self) -> usize;
+}
+
+impl HasSceneScroll for Arrangement {
+    fn scene_scroll (&self) -> usize {
+        self.scene_scroll
+    }
+}
+
+impl HasSceneScroll for App {
+    fn scene_scroll (&self) -> usize {
+        self.project.scene_scroll()
+    }
+}
+
+    pub fn view_scene_name (
+        select:  &Selection,
+        editor:  Option<&MidiEditor>,
+        index:   usize,
+        scene:   &Scene,
+        editing: bool
+    ) -> impl Draw<Tui> {
+        let h = if select.scene() == Some(index) && let Some(_editor) = editor {
+            7
+        } else {
+            Scene::DEFAULT_HEIGHT as u16
+        };
+        let a = east(format!("·s{index:02} "),
+            fg(g(255), bold(true, &scene.name))).align_w().full_w();
+        let b = when(select.scene() == Some(index) && editing, south(
+            editor.as_ref().map(|e|e.clip_status()),
+            editor.as_ref().map(|e|e.edit_status())).align_nw().full_wh());
+        let c = if select.scene() == Some(index) {
+            scene.color.light.term
+        } else {
+            scene.color.base.term
+        };
+        bg(c, south(a, b).align_nw()).exact_wh(20, h)
+    }

src/device/arrange/select.rs

@@ -0,0 +1,195 @@
+use crate::*;
+
+impl_as_ref_opt!(Track: |self: Arrangement| self.selected_track());
+impl_as_mut_opt!(Track: |self: Arrangement| self.selected_track_mut());
+impl_as_ref_opt!(Track: |self: App| self.project.as_ref_opt());
+impl_as_mut_opt!(Track: |self: App| self.project.as_mut_opt());
+impl <T: AsRef<Selection>+AsMut<Selection>> HasSelection for T {}
+
+pub trait HasSelection: AsRef<Selection> + AsMut<Selection> {
+    fn selection (&self) -> &Selection {
+        self.as_ref()
+    }
+    fn selection_mut (&mut self) -> &mut Selection {
+        self.as_mut()
+    }
+
+    /// Get the active track
+    #[cfg(feature = "track")]
+    fn selected_track (&self) -> Option<&Track> where Self: HasTracks {
+        let index = self.selection().track()?;
+        self.tracks().get(index)
+    }
+
+    /// Get a mutable reference to the active track
+    #[cfg(feature = "track")]
+    fn selected_track_mut (&mut self) -> Option<&mut Track> where Self: HasTracks {
+        let index = self.selection().track()?;
+        self.tracks_mut().get_mut(index)
+    }
+
+    /// Get the active scene
+    #[cfg(feature = "scene")]
+    fn selected_scene (&self) -> Option<&Scene> where Self: HasScenes {
+        let index = self.selection().scene()?;
+        self.scenes().get(index)
+    }
+
+    /// Get a mutable reference to the active scene
+    #[cfg(feature = "scene")]
+    fn selected_scene_mut (&mut self) -> Option<&mut Scene> where Self: HasScenes {
+        let index = self.selection().scene()?;
+        self.scenes_mut().get_mut(index)
+    }
+
+    /// Get the active clip
+    #[cfg(feature = "clip")]
+    fn selected_clip (&self) -> Option<Arc<RwLock<MidiClip>>> where Self: HasScenes + HasTracks {
+        self.selected_scene()?.clips.get(self.selection().track()?)?.clone()
+    }
+}
+
+/// Represents the current user selection in the arranger
+#[derive(PartialEq, Clone, Copy, Debug, Default)]
+pub enum Selection {
+    #[default]
+    /// Nothing is selected
+    Nothing,
+    /// The whole mix is selected
+    Mix,
+    /// A MIDI input is selected.
+    Input(usize),
+    /// A MIDI output is selected.
+    Output(usize),
+    /// A scene is selected.
+    #[cfg(feature = "scene")] Scene(usize),
+    /// A track is selected.
+    #[cfg(feature = "track")] Track(usize),
+    /// A clip (track × scene) is selected.
+    #[cfg(feature = "track")] TrackClip   { track: usize, scene:  usize },
+    /// A track's MIDI input connection is selected.
+    #[cfg(feature = "track")] TrackInput  { track: usize, port:   usize },
+    /// A track's MIDI output connection is selected.
+    #[cfg(feature = "track")] TrackOutput { track: usize, port:   usize },
+    /// A track device slot is selected.
+    #[cfg(feature = "track")] TrackDevice { track: usize, device: usize },
+}
+
+impl Selection {
+
+    pub fn describe (
+        &self,
+        #[cfg(feature = "track")] tracks: &[Track],
+        #[cfg(feature = "scene")] scenes: &[Scene],
+    ) -> Arc<str> {
+        use Selection::*;
+        format!("{}", match self {
+            Mix => "Everything".to_string(),
+            #[cfg(feature = "scene")] Scene(s) =>
+                scenes.get(*s).map(|scene|format!("S{s}: {}", &scene.name)).unwrap_or_else(||"S??".into()),
+            #[cfg(feature = "track")] Track(t) =>
+                tracks.get(*t).map(|track|format!("T{t}: {}", &track.name)).unwrap_or_else(||"T??".into()),
+            TrackClip { track, scene } => match (tracks.get(*track), scenes.get(*scene)) {
+                (Some(_), Some(s)) => match s.clip(*track) {
+                    Some(clip) => format!("T{track} S{scene} C{}", &clip.read().unwrap().name),
+                    None       => format!("T{track} S{scene}: Empty")
+                },
+                _ => format!("T{track} S{scene}: Empty"),
+            },
+            _ => todo!()
+        }).into()
+    }
+
+}
+
+#[cfg(feature = "scene")]
+impl Selection {
+
+    pub fn scene (&self) -> Option<usize> {
+        use Selection::*;
+        match self { Scene(scene) | TrackClip { scene, .. } => Some(*scene), _ => None }
+    }
+
+    pub fn select_scene (&self, scene_count: usize) -> Self {
+        use Selection::*;
+        match self {
+            Mix | Track(_) => Scene(0),
+            Scene(s) => Scene((s + 1) % scene_count),
+            TrackClip { scene, .. } => Track(*scene),
+            _ => todo!(),
+        }
+    }
+
+    pub fn select_scene_next (&self, len: usize) -> Self {
+        use Selection::*;
+        match self {
+            Mix => Scene(0),
+            Track(t) => TrackClip { track: *t, scene: 0 },
+            Scene(s) => if s + 1 < len { Scene(s + 1) } else { Mix },
+            TrackClip { track, scene } => if scene + 1 < len { TrackClip { track: *track, scene: scene + 1 } } else { Track(*track) },
+            _ => todo!()
+        }
+    }
+
+    pub fn select_scene_prev (&self) -> Self {
+        use Selection::*;
+        match self {
+            Mix | Scene(0) => Mix,
+            Scene(s) => Scene(s - 1),
+            Track(t) => Track(*t),
+            TrackClip { track, scene: 0 } => Track(*track),
+            TrackClip { track, scene } => TrackClip { track: *track, scene: scene - 1 },
+            _ => todo!()
+        }
+    }
+
+}
+
+#[cfg(feature = "track")]
+impl Selection {
+
+    pub fn track (&self) -> Option<usize> {
+        use Selection::*;
+        if let Track(track)|TrackClip{track,..}|TrackInput{track,..}|TrackOutput{track,..}|TrackDevice{track,..} = self {
+            Some(*track)
+        } else {
+            None
+        }
+    }
+
+    pub fn select_track (&self, track_count: usize) -> Self {
+        use Selection::*;
+        match self {
+            Mix => Track(0),
+            Scene(_) => Mix,
+            Track(t) => Track((t + 1) % track_count),
+            TrackClip { track, .. } => Track(*track),
+            _ => todo!(),
+        }
+    }
+
+    pub fn select_track_next (&self, len: usize) -> Self {
+        use Selection::*;
+        match self {
+            Mix => Track(0),
+            Scene(s) => TrackClip { track: 0, scene: *s },
+            Track(t) => if t + 1 < len { Track(t + 1) } else { Mix },
+            TrackClip {track, scene} => if track + 1 < len { TrackClip { track: track + 1, scene: *scene } } else { Scene(*scene) },
+            _ => todo!()
+        }
+    }
+
+    pub fn select_track_prev (&self) -> Self {
+        use Selection::*;
+        match self {
+            Mix => Mix,
+            Scene(s) => Scene(*s),
+            Track(0) => Mix,
+            Track(t) => Track(t - 1),
+            TrackClip { track: 0, scene } => Scene(*scene),
+            TrackClip { track: t, scene } => TrackClip { track: t - 1, scene: *scene },
+            _ => todo!()
+        }
+    }
+
+}

src/device/arrange/track.rs

@@ -0,0 +1,588 @@
+use crate::{*, arrange::*};
+
+/// A track consists of a sequencer and zero or more devices chained after it.
+///
+/// ```
+/// let track: tek::Track = Default::default();
+/// ```
+#[derive(Debug, Default)]
+pub struct Track {
+    /// Name of track
+    pub name:      Arc<str>,
+    /// Identifying color of track
+    pub color:     ItemTheme,
+    /// Preferred width of track column
+    pub width:     usize,
+    /// MIDI sequencer state
+    pub sequencer: Sequencer,
+    /// Device chain
+    pub devices:   Vec<Device>,
+}
+
+impl Track {
+    /// Create a new track with only the default [Sequencer].
+    pub fn new (
+        name:      &impl AsRef<str>,
+        color:     Option<ItemTheme>,
+        jack:      &Jack<'static>,
+        clock:     Option<&Clock>,
+        clip:      Option<&Arc<RwLock<MidiClip>>>,
+        midi_from: &[Connect],
+        midi_to:   &[Connect],
+    ) -> Usually<Self> {
+        Ok(Self {
+            name: name.as_ref().into(),
+            color: color.unwrap_or_default(),
+            sequencer: Sequencer::new(
+                format!("{}/sequencer", name.as_ref()), jack, clock, clip, midi_from, midi_to
+            )?,
+            ..Default::default()
+        })
+    }
+    pub fn audio_ins  (&self) -> &[AudioInput] {
+        self.devices.first().map(|x|x.audio_ins()).unwrap_or_default()
+    }
+    pub fn audio_outs (&self) -> &[AudioOutput] {
+        self.devices.last().map(|x|x.audio_outs()).unwrap_or_default()
+    }
+    pub fn per <'a, T: Draw<Tui> + 'a, U: TracksSizes<'a>> (
+        tracks:   impl Fn() -> U + Send + Sync + 'a,
+        callback: &'a (impl Fn(usize, &'a Track)->T + Send + Sync + 'a)
+    ) -> impl Draw<Tui> + 'a {
+        iter_east(move||tracks().map(|(index, track, x1, x2): (usize, &Track, usize, usize)|{
+            fg_bg(
+                track.color.lightest.term,
+                track.color.base.term,
+                callback(index, track)
+            ).exact_w((x2 - x1) as u16)
+        }))
+    }
+    pub fn stop (&mut self) -> Perhaps<TrackCommand> {
+        self.sequencer.enqueue_next(None);
+        Ok(None)
+    }
+}
+
+impl HasWidth for Track {
+    const MIN_WIDTH: usize = 9;
+    fn width_inc (&mut self) {
+        self.width += 1;
+    }
+    fn width_dec (&mut self) {
+        if self.width > Track::MIN_WIDTH { self.width -= 1; }
+    }
+}
+
+impl<T: AsRefOpt<Track> + AsMutOpt<Track>> HasTrack for T {}
+
+pub trait HasTrack: AsRefOpt<Track> + AsMutOpt<Track> {
+    fn track (&self) -> Option<&Track> {
+        self.as_ref_opt()
+    }
+    fn track_mut (&mut self) -> Option<&mut Track> {
+        self.as_mut_opt()
+    }
+}
+
+impl<T: HasTrack
+    + for<'a> Namespace<'a, usize>
+    + for<'a> Namespace<'a, Arc<str>>
+    + for<'a> Namespace<'a, ItemTheme>
+    + for<'a> Namespace<'a, Option<bool>>
+> TrackController for T {}
+
+#[tek_proc::commands(TrackCommand)]
+pub trait TrackController: HasTrack
+    + for<'a> Namespace<'a, usize>
+    + for<'a> Namespace<'a, Arc<str>>
+    + for<'a> Namespace<'a, ItemTheme>
+    + for<'a> Namespace<'a, Option<bool>>
+{
+    #[command(Stop = "track/stop")]
+    fn track_stop (&mut self) -> Perhaps<TrackCommand> {
+        self.track_mut().map(|track|track.sequencer.enqueue_next(None));
+        Ok(None)
+    }
+    #[command(SetMute = "track/mute")]
+    fn track_set_mute (&mut self, mute: Option<bool>) -> Perhaps<TrackCommand> {
+        todo!()
+    }
+    #[command(SetSolo = "track/solo")]
+    fn track_set_solo (&mut self, solo: Option<bool>) -> Perhaps<TrackCommand> {
+        todo!()
+    }
+    #[command(SetSize = "track/size")]
+    fn track_set_size (&mut self, size: usize) -> Perhaps<TrackCommand> {
+        todo!()
+    }
+    #[command(SetZoom = "track/zoom")]
+    fn track_set_zoom (&mut self, zoom: usize) -> Perhaps<TrackCommand> {
+        todo!()
+    }
+    #[command(SetName = "track/name")]
+    fn track_set_name (&mut self, name: Arc<str>) -> Perhaps<TrackCommand> {
+        self.track_mut()
+            .map(|track|swap_value(&mut track.name, &name, |name|TrackCommand::SetName { name }))
+            .transpose()
+            .map(Option::flatten)
+    }
+    #[command(SetColor = "track/color")]
+    fn track_set_color (&mut self, color: ItemTheme) -> Perhaps<TrackCommand> {
+        self.track_mut()
+            .map(|track|swap_value(&mut track.color, &color, |color|TrackCommand::SetColor { color }))
+            .transpose()
+            .map(Option::flatten)
+    }
+    #[command(SetRec = "track/rec")]
+    fn track_set_rec (&mut self, rec: Option<bool>) -> Perhaps<TrackCommand> {
+        self.track_mut()
+            .map(|track|toggle_bool(&mut track.sequencer.recording, &rec, |rec|TrackCommand::SetRec { rec }))
+            .transpose()
+            .map(Option::flatten)
+    }
+    #[command(SetMon = "track/mon")]
+    fn track_set_mon (&mut self, mon: Option<bool>) -> Perhaps<TrackCommand> {
+        self.track_mut()
+            .map(|track|toggle_bool(&mut track.sequencer.monitoring, &mon, |mon|TrackCommand::SetMon { mon }))
+            .transpose()
+            .map(Option::flatten)
+    }
+}
+
+pub(crate) fn track_width (_index: usize, track: &Track) -> u16 {
+    track.width as u16
+}
+
+def_sizes_iter!(TracksSizes => Track);
+impl_has!(Vec<Track>: |self: Arrangement| self.tracks);
+impl_as_ref!(Vec<Track>: |self: App| self.project.as_ref());
+impl_as_mut!(Vec<Track>: |self: App| self.project.as_mut());
+
+impl<T: AsRef<Vec<Track>> + AsMut<Vec<Track>> + HasClock + HasTrackScroll> HasTracks for T {}
+
+pub trait HasTracks: AsRef<Vec<Track>> + AsMut<Vec<Track>> + HasClock + HasTrackScroll {
+    /// Spacing between tracks.
+    const TRACK_SPACING: usize = 0;
+
+    /// Read-only reference to collection of [Track]s.
+    fn tracks (&self) -> &Vec<Track> {
+        self.as_ref()
+    }
+
+    /// Mutable reference to collection of [Track]s.
+    fn tracks_mut (&mut self) -> &mut Vec<Track> {
+        self.as_mut()
+    }
+
+    /// Run audio callbacks for every track and every device
+    fn tracks_jack_process (&mut self, client: &Client, scope: &ProcessScope) -> Control
+        where Self: HasJack<'static>
+    {
+        for track in self.tracks_mut().iter_mut() {
+            if Control::Quit == Audio::process(&mut track.sequencer, client, scope) {
+                return Control::Quit
+            }
+            for device in track.devices.iter_mut() {
+                if Control::Quit == DeviceAudio(device).process(client, scope) {
+                    return Control::Quit
+                }
+            }
+        }
+        Control::Continue
+    }
+
+    /// Add multiple tracks
+    fn tracks_add_many (
+        &mut self,
+        count: usize,
+        width: Option<usize>,
+        mins:  Arc<[Connect]>,
+        mouts: Arc<[Connect]>,
+    ) -> Usually<()>
+        where Self: HasJack<'static> + HasScenes
+    {
+        let track_color_1 = ItemColor::random();
+        let track_color_2 = ItemColor::random();
+        for i in 0..count {
+            let color = track_color_1.mix(track_color_2, i as f32 / count as f32).into();
+            let track = self.tracks_add_one(None, Some(color), mins.clone(), mouts.clone())?.1;
+            if let Some(width) = width {
+                track.width = width;
+            }
+        }
+        Ok(())
+    }
+
+    /// Add a track
+    fn tracks_add_one (
+        &mut self,
+        name:  Option<Arc<str>>,
+        color: Option<ItemTheme>,
+        mins:  Arc<[Connect]>,
+        mouts: Arc<[Connect]>,
+    ) -> Usually<(usize, &mut Track)>
+        where Self: HasJack<'static> + HasScenes
+    {
+        let name: Arc<str> = name.map_or_else(
+            ||format!("trk{:02}", self.tracks_last()).into(),
+            |x|x.to_string().into()
+        );
+        *self.tracks_last_mut() += 1;
+        let track = Track {
+            width:  (name.len() + 2).max(12),
+            color:  color.unwrap_or_else(ItemTheme::random),
+            sequencer: Sequencer::new(
+                &format!("{name}"),
+                self.jack(),
+                Some(self.clock()),
+                None,
+                mins.as_ref(),
+                mouts.as_ref()
+            )?,
+            name,
+            ..Default::default()
+        };
+        self.tracks_mut().push(track);
+        let len = self.tracks().len();
+        let index = len - 1;
+        for scene in self.scenes_mut().iter_mut() {
+            while scene.clips.len() < len {
+                scene.clips.push(None);
+            }
+        }
+        Ok((index, &mut self.tracks_mut()[index]))
+    }
+
+    fn track_longest_name (&self) -> usize {
+        self.tracks().iter().map(|s|s.name.len()).fold(0, usize::max)
+    }
+}
+
+impl<T: HasTracks
+    + for<'a> Namespace<'a, usize>
+    + for<'a> Namespace<'a, Arc<[Connect]>>
+    + for<'a> Namespace<'a, Option<usize>>
+    + for<'a> Namespace<'a, Option<Arc<str>>>
+    + for<'a> Namespace<'a, Option<ItemTheme>>
+    + for<'a> Namespace<'a, Option<Arc<[Connect]>>>
+    + for<'a> Namespace<'a, Option<Vec<Option<Arc<RwLock<MidiClip>>>>>>
+> TracksController for T {}
+
+#[tek_proc::commands(TracksCommand)]
+pub trait TracksController: HasTracks
+    + for<'a> Namespace<'a, usize>
+    + for<'a> Namespace<'a, Arc<[Connect]>>
+    + for<'a> Namespace<'a, Option<usize>>
+    + for<'a> Namespace<'a, Option<Arc<str>>>
+    + for<'a> Namespace<'a, Option<ItemTheme>>
+    + for<'a> Namespace<'a, Option<Arc<[Connect]>>>
+    + for<'a> Namespace<'a, Option<Vec<Option<Arc<RwLock<MidiClip>>>>>>
+{
+
+    #[command(Stop = "tracks/stop")]
+    /// Stop all playing clips
+    fn tracks_stop_all (&mut self) -> Perhaps<TracksCommand> {
+        for track in self.tracks_mut().iter_mut() {
+            track.sequencer.enqueue_next(None);
+        }
+        Ok(None)
+    }
+
+    #[command(Launch = "tracks/launch")]
+    /// Launch multiple clips
+    fn tracks_launch (
+        &mut self, clips: Option<Vec<Option<Arc<RwLock<MidiClip>>>>>
+    ) -> Perhaps<TracksCommand> {
+        if let Some(clips) = clips {
+            for (clip, track) in clips.iter().zip(self.tracks_mut()) {
+                track.sequencer.enqueue_next(clip.as_ref());
+            }
+        } else {
+            for track in self.tracks_mut().iter_mut() {
+                track.sequencer.enqueue_next(None);
+            }
+        }
+        Ok(None)
+    }
+}
+
+impl<
+    T: HasTracks + ScenesView + HasMidiIns + HasMidiOuts + HasTrack
+> TracksView for T {}
+
+pub trait TracksView: HasTracks + ScenesView + HasMidiIns + HasMidiOuts + HasTrack {
+
+    /// Iterate over tracks with their corresponding sizes.
+    fn tracks_with_sizes (&self) -> impl TracksSizes<'_> {
+        let _editor_width = self.editor().map(|e|e.size.w());
+        let _active_track = self.selection().track();
+        let mut x = 0;
+        let w = self.clips_size().w() as usize;
+        self.tracks().iter().enumerate().map_while(move |(index, track)|{
+            let width = track.width.max(8);
+            if x + width < w {
+                let data = (index, track, x, x + width);
+                x += width + Self::TRACK_SPACING;
+                Some(data)
+            } else {
+                None
+            }
+        })
+    }
+
+    /// Draw name of each track
+    fn view_track_names (&self, theme: ItemTheme) -> impl Draw<Tui> {
+        let track_count = self.tracks().len();
+        let scene_count = self.scenes().len();
+        let selected = self.selection();
+        let button = south(
+            button_3("t", "rack ", format!("{}{track_count}", selected.track()
+                .map(|track|format!("{track}/")).unwrap_or_default()), false),
+            button_3("s", "cene ", format!("{}{scene_count}", selected.scene()
+                .map(|scene|format!("{scene}/")).unwrap_or_default()), false));
+        let button_2 = south(
+            button_2("T", "+", false),
+            button_2("S", "+", false));
+        view_track_row_section(theme, button, button_2, bg(theme.darker.term,
+            draw(|to: &mut Tui|{
+                for (index, track, x1, _x2) in self.tracks_with_sizes() {
+                    let b = if selected.track() == Some(index) {
+                        track.color.light.term
+                    } else {
+                        track.color.base.term
+                    };
+                    bg(b, south(east(
+                        format!("·t{index:02} "),
+                        fg(Rgb(255, 255, 255), bold(true, &track.name))
+                    ).align_nw().full_w(), ""))
+                        .exact_w(track_width(index, track))
+                        .push_x(x1 as u16)
+                        .draw(to)?;
+                }
+                Ok(Some(XYWH(0, 0, 0, 0)))
+            }).exact_h(2)))
+    }
+
+    /// Draw outputs per track
+    fn view_track_outputs <'a> (&'a self, theme: ItemTheme, _h: u16) -> impl Draw<Tui> {
+        view_track_row_section(theme,
+            south(button_2("o", "utput", false).align_w().full_w(),
+                draw(|to: &mut Tui|{
+                    for port in self.midi_outs().iter() {
+                        let _ = port.port_name().align_w().full_w().draw(to)?;
+                    }
+                    Ok(Some(XYWH(0, 0, 0, 0)))
+                })),
+            button_2("O", "+", false),
+            bg(theme.darker.term, draw(|to: &mut Tui|{
+                for (index, track, _x1, _x2) in self.tracks_with_sizes() {
+                    let f = Rgb(255, 255, 255);
+                    let b = track.color.dark.term;
+                    iter_south(||track.sequencer.midi_outs.iter().map(|port: &MidiOutput|{
+                        fg(f, bg(b, format!("·o{index:02} {}", port.port_name()).full_w().align_w()).exact_h(1))
+                    }))
+                        .full_h().align_nw().exact_w(track_width(index, track)).draw(to)?;
+                }
+                Ok(Some(XYWH(0, 0, 0, 0)))
+            }).align_w()))
+    }
+
+    /// Draw inputs per track
+    fn view_track_inputs <'a> (&'a self, theme: ItemTheme) -> impl Draw<Tui> {
+        let mut height = 0u16;
+        for track in self.tracks().iter() {
+            height = height.max(track.sequencer.midi_ins.len() as u16);
+        }
+        view_track_row_section(theme, button_2("i", "nput", false), button_2("I", "+", false),
+            bg(theme.darker.term, draw(move|to: &mut Tui|{
+                for (index, track, _x1, _x2) in self.tracks_with_sizes() {
+                    south(
+                        bg(track.color.base.term,
+                            east!(
+                                either(track.sequencer.monitoring, fg(Green,  "●mon "), "·mon "),
+                                either(track.sequencer.recording,  fg(Red,    "●rec "), "·rec "),
+                                either(track.sequencer.overdub,    fg(Yellow, "●dub "), "·dub "),
+                            ).align_w().full_w()),
+                        iter_south(||track.sequencer.midi_ins.iter().map(|port|fg_bg(Rgb(255, 255, 255), track.color.dark.term,
+                            format!("·i{index:02} {}", port.port_name()).align_w().full_w())))
+                    ).align_nw().exact_wh(track_width(index, track), height + 1).draw(to)?;
+                }
+                Ok(Some(XYWH(0, 0, 0, 0)))
+            }).align_w()))
+    }
+
+    fn view_track_devices (&self, theme: ItemTheme) -> impl Draw<Tui> {
+        let height = self.tracks_devices_height();
+        let btn1 = button_3("d", "evice", format!("{}", self.track().map(|t|t.devices.len()).unwrap_or(0)), false);
+        let btn2 = button_2("D", "+", false);
+        view_track_row_section(theme, btn1, btn2, iter_east(move||self.tracks_with_sizes()
+            .enumerate()
+            .map(move|(index, (_, track, _x1, _x2))|bg(
+                track.color.dark.term,
+                iter_south(move||(0..height).map(|_|fg_bg(
+                    ItemTheme::G[32].lightest.term,
+                    ItemTheme::G[32].dark.term,
+                    format!(" · {}", "--").align_nw()
+                ).exact_wh(track.width as u16, 2)))
+                    .align_nw()
+            )
+                .exact_wh(
+                    Some(track_width(index, track)),
+                    Some(height + 1),
+                ))))
+    }
+
+    fn tracks_devices_height (&self) -> u16 {
+        let mut h = 2;
+        for track in self.tracks().iter() {
+            h = h.max(track.devices.len() * 2);
+        }
+        h as u16
+    }
+
+    fn view_inputs (&self, _theme: ItemTheme) -> impl Draw<Tui> + '_ {
+        let title_1 = button_3("i", "nput ", format!("{}", self.midi_ins().len()), false).align_w().exact_wh(20, 1);
+        let title_2 = button_2("I", "+", false).exact_wh(4, 1);
+        east(title_1, west(title_2, draw(move|to: &mut Tui|{
+            for (_index, track, x1, _x2) in self.tracks_with_sizes() {
+                let _ = south(
+                    bg(track.color.dark.term, east!(
+                        either(track.sequencer.monitoring, fg(Green,  "mon "), "mon "),
+                        either(track.sequencer.recording,  fg(Red,    "rec "), "rec "),
+                        either(track.sequencer.overdub,    fg(Yellow, "dub "), "dub "),
+                    ).exact_w(track.width as u16)).align_w().push_x(x1 as u16),
+                    draw(move |to: &mut Tui|{
+                        for (index, port) in self.midi_ins().as_slice().iter().enumerate() {
+                            let _ = east(
+                                east(
+                                    " ● ",
+                                    bold(true, fg(Rgb(255,255,255), port.port_name()))
+                                ).align_w().exact_w(20),
+                                west(
+                                    ().exact_w(4),
+                                    bg(track.color.darker.term, east!(
+                                        either(track.sequencer.monitoring, fg(Green,  " ●  "), " ·  "),
+                                        either(track.sequencer.recording,  fg(Red,    " ●  "), " ·  "),
+                                        either(track.sequencer.overdub,    fg(Yellow, " ●  "), " ·  "),
+                                    ).exact_w(track.width as u16).align_w())
+                                )
+                            ).push_x(index as u16 * 10).exact_h(1).draw(to)?;
+                        }
+                        todo!()
+                    })
+                ).draw(to)?;
+            }
+            Ok(Some(to.area()))
+        })))
+    }
+
+    fn outputs_height (&self) -> u16 {
+        let mut h = 1;
+        for output in self.midi_outs().iter() {
+            h += 1 + output.connections.len();
+        }
+        h as u16
+    }
+
+    fn view_outputs (&self, theme: ItemTheme) -> impl Draw<Tui> {
+        let height = self.outputs_height();
+        let list = south(
+            button_3(
+                "o", "utput", format!("{}", self.midi_outs().len()), false
+            ).align_w().full_w().exact_h(1),
+            draw(|to: &mut Tui|{
+                for (_index, port) in self.midi_outs().iter().enumerate() {
+                    east(
+                        east(" ● ", fg(Rgb(255,255,255), bold(true, port.port_name()))).align_w(),
+                        format!("{}/{} ",
+                            port.port().get_connections().len(),
+                            port.connections.len()).align_e().full_w().exact_h(1)).full_w().draw(to)?;
+                    for (index, conn) in port.connections.iter().enumerate() {
+                        format!("   c{index:02}{}", conn.info()).align_w().full_w().exact_h(1).draw(to)?;
+                    }
+                }
+                todo!();
+            }).align_nw().full_wh().exact_h(height - 1)
+        );
+        view_track_row_section(theme, list, button_2("O", "+", false),
+            bg(theme.darker.term, draw(|to: &mut Tui|{
+                for (index, track, _x1, _x2) in self.tracks_with_sizes() {
+                    let _ = draw(|to: &mut Tui|{
+                        east(
+                            either(true,  fg(Green,  "play "), "play "),
+                            either(false, fg(Yellow, "solo "), "solo "),
+                        ).align_w().exact_h(1).draw(to)?;
+                        for (_index, port) in self.midi_outs().iter().enumerate() {
+                            east(
+                                either(true,  fg(Green,  " ●   "), " ·   "),
+                                either(false, fg(Yellow, " ●   "), " ·   "),
+                            ).align_w().exact_h(1).draw(to)?;
+                            for (_index, _conn) in port.connections.iter().enumerate() {
+                                "".full_w().exact_h(1).draw(to)?;
+                            }
+                        }
+                        todo!()
+                    }).exact_w(track_width(index, track)).draw(to)?;
+                }
+                todo!()
+            }).align_w().full_w())).exact_h(height)
+    }
+
+}
+
+pub trait HasTrackScroll {
+    fn track_scroll (&self) -> usize;
+    fn tracks_last (&self) -> usize;
+    fn tracks_last_mut (&mut self) -> &mut usize;
+}
+
+impl HasTrackScroll for &mut Arrangement {
+    fn track_scroll (&self) -> usize {
+        self.track_scroll
+    }
+    fn tracks_last (&self) -> usize {
+        self.track_last
+    }
+    fn tracks_last_mut (&mut self) -> &mut usize {
+        &mut self.track_last
+    }
+}
+
+impl HasTrackScroll for Arrangement {
+    fn track_scroll (&self) -> usize {
+        self.track_scroll
+    }
+    fn tracks_last (&self) -> usize {
+        self.track_last
+    }
+    fn tracks_last_mut (&mut self) -> &mut usize {
+        &mut self.track_last
+    }
+}
+
+impl HasTrackScroll for App {
+    fn track_scroll (&self) -> usize {
+        self.project.track_scroll()
+    }
+    fn tracks_last (&self) -> usize {
+        self.project.track_last
+    }
+    fn tracks_last_mut (&mut self) -> &mut usize {
+        &mut self.project.track_last
+    }
+}
+
+fn view_track_row_section (
+    _theme:     ItemTheme,
+    button:     impl Draw<Tui>,
+    button_add: impl Draw<Tui>,
+    content:    impl Draw<Tui>,
+) -> impl Draw<Tui> {
+    west(
+        button_add.align_nw().exact_w(4).full_h(),
+        east(
+            button.align_nw().full_h().exact_w(20),
+            content.align_c().full_wh()
+        )
+    )
+}