group modules and scripts

app/src/view/view_arranger.rs

@@ -0,0 +1,388 @@
+use crate::*;
+impl Tek {
+
+    // FIXME: The memoized arranger is too complex.
+    // Just render a slice of the arranger for now,
+    // starting from tracks[scroll_offset] and ending
+    // at the last track that fits fully.
+
+    /// Blit the currently visible section of the arranger view buffer to the output.
+    ///
+    /// If the arranger is larger than the available display area,
+    /// the scrollbars determine the portion that will be shown.
+    ///
+    /// This function is called on every frame, but is relatively cheap
+    /// as the rendering logic of [redraw_arranger] is only invoked on
+    /// changes to the content.
+    pub fn view_arranger (&self) -> impl Content<TuiOut> + use<'_> {
+        Fill::xy(ThunkRender::new(move|to: &mut TuiOut|{
+            let [x0, y0, w, h] = to.area().xywh();
+            let source = self.arranger.read().unwrap();
+            for (source_x, target_x) in (x0..x0+w).enumerate() {
+                for (source_y, target_y) in (y0..y0+h).enumerate() {
+                    let target_pos = Position::from((target_x, target_y));
+                    if let Some(target) = to.buffer.cell_mut(target_pos) {
+                        target.set_bg(Color::Rgb(128,0,0));
+                        let source_pos = Position::from((source_x as u16, source_y as u16));
+                        if let Some(source) = source.cell(source_pos) {
+                            *target = source.clone();
+                            target.set_bg(Color::Rgb(0,128,0));
+                        }
+                    }
+                }
+            }
+        }))
+    }
+
+    /// Draw the full arranger to the arranger view buffer.
+    ///
+    /// This should happen on changes to the arrangement contents,
+    /// i.e. not on scroll. Scrolling just determines which part
+    /// of the arranger buffer to blit in [view_arranger].
+    pub fn redraw_arranger (&self) {
+        let width  = self.w_tracks();
+        let height = self.h_scenes() + self.h_inputs() + self.h_outputs();
+        let buffer = Buffer::empty(ratatui::prelude::Rect { x: 0, y: 0, width, height });
+        let mut output = TuiOut { buffer, area: [0, 0, width, height] };
+        let layout = Bsp::s(self.view_inputs(),
+            Bsp::s(self.view_tracks(),
+                Bsp::n(self.view_outputs(),
+                    self.view_scenes())));
+        Content::render(&layout, &mut output);
+        *self.arranger.write().unwrap() = output.buffer;
+    }
+
+    /// Display the current scene scroll state.
+    fn scene_scrollbar (&self) -> impl Content<TuiOut> + use<'_> {
+        let offset = self.scene_scroll;
+        let length = self.h_tracks_area() as usize;
+        let total  = self.h_scenes() as usize;
+        Fill::y(Fixed::x(1, ScrollbarV { offset, length, total }))
+    }
+
+    /// Display the current track scroll state.
+    fn track_scrollbar (&self) -> impl Content<TuiOut> + use<'_> {
+        let offset = self.track_scroll;
+        let length = self.w_tracks_area() as usize;
+        let total  = self.w_tracks() as usize;
+        Fill::x(Fixed::y(1, ScrollbarH { offset, length, total }))
+    }
+
+    /// Render something centered for each track.
+    fn per_track <'a, T: Content<TuiOut> + 'a> (
+        &'a self, f: impl Fn(usize, &'a Track)->T + Send + Sync + 'a
+    ) -> impl Content<TuiOut> + 'a {
+        self.per_track_top(move|index, track|Fill::y(Align::y(f(index, track))))
+    }
+
+    /// Render something top-aligned for each track.
+    fn per_track_top <'a, T: Content<TuiOut> + 'a> (
+        &'a self, f: impl Fn(usize, &'a Track)->T + Send + Sync + 'a
+    ) -> impl Content<TuiOut> + 'a {
+        let width  = self.w_tracks_area();
+        let filter = move|(t, track, x1, x2)|if x2 as u16 >= width {
+            None
+        } else {
+            Some((t, track, x1, x2))
+        };
+        let tracks = move||self.tracks_sizes().map_while(filter);
+        Align::x(Tui::bg(Reset, Map::new(tracks, move|(index, track, x1, x2), _|{
+            let width = (x2 - x1) as u16;
+            map_east(x1 as u16, width, Fixed::x(width, Tui::fg_bg(
+                track.color.lightest.rgb,
+                track.color.base.rgb,
+                f(index, track))))
+        })))
+    }
+
+    pub fn view_tracks (&self) -> impl Content<TuiOut> + use<'_> {
+        let w = (self.size.w() as u16).saturating_sub(2 * self.w_sidebar());
+        let s = self.w_sidebar() as u16;
+        let data = (self.selected.track().unwrap_or(0), self.tracks().len());
+        let editing = self.is_editing();
+        self.fmtd.write().unwrap().trks.update(Some(data), rewrite!(buf, "{}/{}", data.0, data.1));
+        row(w, 1, s, button_3("t", "track", self.fmtd.read().unwrap().trks.view.clone(), editing),
+            self.per_track(|t, track|track_header(t, track, self.selected().track() == Some(t))),
+            button_2("T", "add track", editing))
+    }
+
+    pub fn view_scenes (&self) -> impl Content<TuiOut> + use<'_> {
+        let editing        = self.is_editing();
+        let s              = self.w_sidebar() as u16;
+        let w              = self.w_tracks_area();
+        let w_full         = self.w();
+        let h              = self.h_scenes();
+        let h_area         = self.h_tracks_area();
+        let selected_track = self.selected().track();
+        let selected_scene = self.selected().scene();
+        let track_scroll   = self.track_scrollbar();
+        let scene_scroll   = self.scene_scrollbar();
+        Tui::bg(Reset, Bsp::s(track_scroll, Bsp::e(scene_scroll, Fixed::y(h_area, row(w, h, s,
+            Map::new(
+                move||self.scenes_with_colors(editing, h_area),
+                move|(s, scene, y1, y2, prev): SceneWithColor, _|self.view_scene_name(
+                    w_full, (1 + y2 - y1) as u16, y1 as u16, s, scene, prev)),
+            self.per_track(move|t, track|Map::new(
+                move||self.scenes_with_track_colors(editing, h_area, t),
+                move|(s, scene, y1, y2, prev): SceneWithColor, _|self.view_scene_clip(
+                    w, (1 + y2 - y1) as u16, y1 as u16,
+                    scene, prev, s, t, editing, selected_track == Some(t), selected_scene))),
+            () )))))
+    }
+
+    fn view_scene_name (
+        &self,
+        width:  u16,
+        height: u16,
+        offset: u16,
+        index:  usize,
+        scene:  &Scene,
+        prev:   Option<ItemPalette>,
+    ) -> impl Content<TuiOut> + use<'_> {
+        Fill::x(map_south(offset, height, Fixed::y(height, scene_cell(
+            index == self.scenes.len().saturating_sub(1),
+            self.selected().scene(),
+            true,
+            index,
+            &scene.color,
+            prev,
+            Some(scene.name.clone()),
+            " ⯈ ",
+            scene.color.lightest.rgb
+        ))))
+    }
+
+    fn view_scene_clip (
+        &self,
+        width:          u16,
+        height:         u16,
+        offset:         u16,
+        scene:          &Scene,
+        prev:           Option<ItemPalette>,
+        scene_index:    usize,
+        track_index:    usize,
+        editing:        bool,
+        same_track:     bool,
+        selected_scene: Option<usize>
+    ) -> impl Content<TuiOut> + use<'_> {
+        let (name, fg, bg) = if let Some(clip) = &scene.clips[track_index] {
+            let clip = clip.read().unwrap();
+            (Some(clip.name.clone()), clip.color.lightest.rgb, clip.color)
+        } else {
+            (None, Tui::g(96), ItemPalette::G[32])
+        };
+        let active = editing && same_track && selected_scene == Some(scene_index);
+        let edit = |x|Bsp::b(x, When(active, &self.editor));
+        map_south(offset, height, edit(Fixed::y(height, scene_cell(
+            scene_index == self.scenes.len().saturating_sub(1),
+            self.selected().scene(),
+            same_track,
+            scene_index,
+            &bg,
+            prev,
+            name,
+            " ⏹ ",
+            fg
+        ))))
+    }
+
+    pub fn view_scene_add (&self) -> impl Content<TuiOut> + use<'_> {
+        let editing = self.is_editing();
+        let data = (self.selected().scene().unwrap_or(0), self.scenes().len());
+        self.fmtd.write().unwrap().scns.update(Some(data), rewrite!(buf, "({}/{})", data.0, data.1));
+        button_3("S", "add scene", self.fmtd.read().unwrap().scns.view.clone(), editing)
+    }
+
+    pub fn view_outputs (&self) -> impl Content<TuiOut> + use<'_> {
+        let editing = self.is_editing();
+        let w = self.w_tracks_area();
+        let s = self.w_sidebar() as u16;
+        let fg = Tui::g(224);
+        let nexts = self.per_track_top(|t, track|Either(
+            track.player.next_clip.is_some(),
+            Thunk::new(||Tui::bg(Reset, format!("{:?}",
+                track.player.next_clip.as_ref()
+                    .map(|(moment, clip)|clip.as_ref()
+                        .map(|clip|clip.read().unwrap().name.clone()))
+                    .flatten().as_ref()))),
+            Thunk::new(||Tui::bg(Reset, " ------ "))));
+        let nexts = row_top(w, 2, s, Align::ne("Next:"), nexts, ());
+        let froms = self.per_track_top(|_, _|Tui::bg(Reset, Align::c(Bsp::s(" ------ ", OctaveVertical::default(),))));
+        let froms = row_top(w, 2, s, Align::ne("From:"), froms, ());
+        let ports = row_top(w, 1, s,
+            button_3("o", "midi outs", format!("{}", self.midi_outs.len()), editing),
+            self.per_track_top(move|t, track|{
+                let mute = false;
+                let solo = false;
+                let mute = if mute { White } else { track.color.darkest.rgb };
+                let solo = if solo { White } else { track.color.darkest.rgb };
+                let bg = if self.selected().track() == Some(t) {
+                    track.color.light.rgb
+                } else {
+                    track.color.base.rgb
+                };
+                let bg2 = if t > 0 { self.tracks()[t].color.base.rgb } else { Reset };
+                wrap(bg, fg, Tui::bold(true, Fill::x(Bsp::e(
+                    Tui::fg_bg(mute, bg, "Play "),
+                    Tui::fg_bg(solo, bg, "Solo ")))))}),
+            button_2("O", "add midi out", editing));
+        let routes = row_top(w, self.h_outputs() - 1, s,
+            io_ports(fg, Tui::g(32), ||self.outputs_sizes()),
+            self.per_track_top(move|t, track|io_conns(
+                track.color.dark.rgb, track.color.darker.rgb, ||self.outputs_sizes())), ());
+        Align::n(Bsp::s(Bsp::s(nexts, froms), Bsp::s(ports, routes)))
+    }
+
+    pub fn view_inputs (&self) -> impl Content<TuiOut> + use<'_> {
+        let editing = self.is_editing();
+        let w = (self.size.w() as u16).saturating_sub(2 * self.w_sidebar());
+        let s = self.w_sidebar() as u16;
+        let fg = Tui::g(224);
+        let routes = row_top(w, self.h_inputs() - 1, s,
+            io_ports(fg, Tui::g(32), ||self.inputs_sizes()),
+            self.per_track_top(move|t, track|io_conns(
+                track.color.dark.rgb,
+                track.color.darker.rgb,
+                ||self.inputs_sizes()
+            )), ());
+        let ports = row_top(w, 1, s,
+            button_3("i", "midi ins", format!("{}", self.midi_ins.len()), editing),
+            self.per_track_top(move|t, track|{
+                let rec = track.player.recording;
+                let mon = track.player.monitoring;
+                let rec = if rec { White } else { track.color.darkest.rgb };
+                let mon = if mon { White } else { track.color.darkest.rgb };
+                let bg  = if self.selected().track() == Some(t) {
+                    track.color.light.rgb
+                } else {
+                    track.color.base.rgb
+                };
+                let bg2 = if t > 0 { self.tracks()[t - 1].color.base.rgb } else { Reset };
+                wrap(bg, fg, Tui::bold(true, Fill::x(Bsp::e(
+                    Tui::fg_bg(rec, bg, "Rec  "),
+                    Tui::fg_bg(mon, bg, "Mon  ")))))
+            }),
+            button_2("I", "add midi in", editing));
+        Bsp::s(
+            Bsp::s(routes, ports),
+            row_top(w, 2, s,
+                Bsp::s(Align::e("Input:"), Align::e("Into:")),
+                self.per_track_top(|_, _|Tui::bg(Reset, Align::c(Bsp::s(
+                    OctaveVertical::default(),
+                    " ------ ")))), ())
+        )
+    }
+
+}
+
+fn scene_cell <'a> (
+    is_last:        bool,
+    selected_scene: Option<usize>,
+    same_track:     bool,
+    scene:          usize,
+    color:          &ItemPalette,
+    prev:           Option<ItemPalette>,
+    name:           Option<Arc<str>>,
+    icon:           &'a str,
+    fg: Color,
+) -> impl Content<TuiOut> + use<'a> {
+    Phat {
+        width:   0,
+        height:  0,
+        content: Fill::x(Align::w(Tui::bold(true, Bsp::e(icon, name)))),
+        colors:  Tek::colors(
+            color,
+            prev,
+            same_track && selected_scene == Some(scene),
+            same_track && scene > 0 && selected_scene == Some(scene - 1),
+            is_last
+        )
+    }
+}
+
+fn track_header <'a> (t: usize, track: &'a Track, active: bool) -> impl Content<TuiOut> + use<'a> {
+    let name = &track.name;
+    let fg = track.color.lightest.rgb;
+    let bg = if active { track.color.light.rgb } else { track.color.base.rgb };
+    let bg2 = Reset;//if t > 0 { self.tracks()[t - 1].color.base.rgb } else { Reset };
+    let bfg = if active { Rgb(255,255,255) } else { Rgb(0,0,0) };
+    wrap(bg, fg, Tui::bold(true, Fill::x(Align::nw(name))))
+}
+
+fn io_ports <'a, T: PortsSizes<'a>> (
+    fg: Color,
+    bg: Color,
+    iter: impl Fn()->T + Send + Sync + 'a
+) -> impl Content<TuiOut> + 'a {
+    Map::new(iter,
+        move|(index, name, connections, y, y2), _|map_south(y as u16, (y2-y) as u16, Bsp::s(
+            Fill::x(Tui::bold(true, Tui::fg_bg(fg, bg, Align::w(Bsp::e(" 󰣲 ", name))))),
+            Map::new(||connections.iter(), move|connect, index|map_south(index as u16, 1,
+                Fill::x(Align::w(Tui::bold(false, Tui::fg_bg(fg, bg,
+                    &connect.info)))))))))
+}
+
+fn io_conns <'a, T: PortsSizes<'a>> (
+    fg: Color,
+    bg: Color,
+    iter: impl Fn()->T + Send + Sync + 'a
+) -> impl Content<TuiOut> + 'a {
+    Map::new(iter,
+        move|(index, name, connections, y, y2), _|map_south(y as u16, (y2-y) as u16, Bsp::s(
+            Fill::x(Tui::bold(true, wrap(bg, fg, Fill::x(Align::w("▞▞▞▞ ▞▞▞▞"))))),
+            Map::new(||connections.iter(), move|connect, index|map_south(index as u16, 1,
+                Fill::x(Align::w(Tui::bold(false, wrap(bg, fg, Fill::x(""))))))))))
+}
+
+#[cfg(test)] mod test {
+    use super::*;
+    #[test] fn test_view_arranger () {
+        let mut output = TuiOut::default();
+        output.area[2] = 9;
+        output.area[3] = 9;
+
+        let mut app = Tek::default();
+        app.editor = Some(Default::default());
+        app.scenes_add(5);
+        app.tracks_add(5, Some(5), &[], &[]);
+
+        Content::render(&io_ports(Reset, Reset, ||app.inputs_sizes()),  &mut output);
+        Content::render(&io_conns(Reset, Reset, ||app.outputs_sizes()), &mut output);
+        Content::render(&app.per_track(|_, _|()),     &mut output);
+        Content::render(&app.per_track_top(|_, _|()), &mut output);
+
+        app.redraw_arranger();
+        Content::render(&app.view_arranger(), &mut output);
+        Content::render(&app.view_inputs(),   &mut output);
+        Content::render(&app.view_outputs(),  &mut output);
+        Content::render(&app.view_scenes(),   &mut output);
+
+        Content::render(
+            &app.view_scene_name(0, 0, 0, 0, &Default::default(), None),
+            &mut output);
+
+        Content::render(
+            &app.view_scene_clip(0, 0, 0, &{
+                let mut scene: Scene = Default::default();
+                scene.clips.push(Some(Default::default()));
+                scene
+            }, None, 0, 0, false, false, None),
+            &mut output);
+
+        Content::render(
+            &track_header(0, &Default::default(), true),
+            &mut output);
+
+        Content::render(&scene_cell(
+            false,
+            None,
+            false,
+            0,
+            &Default::default(),
+            None,
+            None,
+            &"",
+            Default::default(),
+        ), &mut output);
+    }
+}

app/src/view/view_clock.rs

@@ -0,0 +1,84 @@
+use crate::*;
+impl Tek {
+    fn update_clock (&self) {
+        let compact = self.size.w() > 80;
+        let clock   = self.clock();
+        let rate    = clock.timebase.sr.get();
+        let chunk   = clock.chunk.load(Relaxed) as f64;
+        let lat     = chunk / rate * 1000.;
+        let delta   = |start: &Moment|clock.global.usec.get() - start.usec.get();
+        let mut fmtd = self.fmtd.write().unwrap();
+        fmtd.buf.update(Some(chunk), rewrite!(buf, "{chunk}"));
+        fmtd.lat.update(Some(lat),   rewrite!(buf, "{lat:.1}ms"));
+        fmtd.sr.update(Some((compact, rate)), |buf,_,_|if compact {
+            buf.clear(); write!(buf, "{:.1}kHz", rate / 1000.)
+        } else {
+            buf.clear(); write!(buf, "{:.0}Hz", rate)
+        });
+        if let Some(now) = clock.started.read().unwrap().as_ref().map(delta) {
+            let pulse = clock.timebase.usecs_to_pulse(now);
+            let time  = now/1000000.;
+            let bpm   = clock.timebase.bpm.get();
+            fmtd.beat.update(Some(pulse),
+                |buf, _, _|{buf.clear();clock.timebase.format_beats_1_to(buf, pulse)});
+            fmtd.time.update(Some(time), rewrite!(buf, "{:.3}s", time));
+            fmtd.bpm.update(Some(bpm), rewrite!(buf, "{:.3}",  bpm));
+        } else {
+            fmtd.beat.update(None, rewrite!(buf, "-.-.--"));
+            fmtd.time.update(None, rewrite!(buf, "-.---s"));
+            fmtd.bpm.update(None, rewrite!(buf, "---.---"));
+        }
+    }
+    pub(crate) fn view_status (&self) -> impl Content<TuiOut> + use<'_> {
+        self.update_clock();
+        let theme = ItemPalette::G[96];
+        let fmtd  = self.fmtd.read().unwrap();
+        Tui::bg(Black, row!(Bsp::a(
+            Fill::xy(Align::w(button_play_pause(self.clock.is_rolling()))),
+            Fill::xy(Align::e(row!(
+                FieldH(theme, "BPM",  fmtd.bpm.view.clone()),
+                FieldH(theme, "Beat", fmtd.beat.view.clone()),
+                FieldH(theme, "Time", fmtd.time.view.clone())
+            )))
+        )))
+    }
+    pub(crate) fn view_transport (&self) -> impl Content<TuiOut> + use<'_> {
+        self.update_clock();
+        let theme = ItemPalette::G[96];
+        let fmtd  = self.fmtd.read().unwrap();
+        Tui::bg(Black, row!(Bsp::a(
+            Fill::xy(Align::w(
+                FieldH(theme, "Selected", self.selected.describe(&self.tracks, &self.scenes))
+            )),
+            Fill::xy(Align::e(row!(
+                FieldH(theme, "SR",  fmtd.sr.view.clone()),
+                FieldH(theme, "Buf", fmtd.buf.view.clone()),
+                FieldH(theme, "Lat", fmtd.lat.view.clone()),
+            )))
+        )))
+    }
+}
+
+fn button_play_pause (playing: bool) -> impl Content<TuiOut> {
+    let compact = true;//self.is_editing();
+    Tui::bg(
+        if playing{Rgb(0,128,0)}else{Rgb(128,64,0)},
+        Either::new(compact,
+            Thunk::new(move||Fixed::x(9, Either::new(playing,
+                Tui::fg(Rgb(0, 255, 0),   " PLAYING "),
+                Tui::fg(Rgb(255, 128, 0), " STOPPED ")))),
+            Thunk::new(move||Fixed::x(5, Either::new(playing,
+                Tui::fg(Rgb(0, 255, 0),   Bsp::s(" 🭍🭑🬽 ", " 🭞🭜🭘 ",)),
+                Tui::fg(Rgb(255, 128, 0), Bsp::s(" ▗▄▖ ", " ▝▀▘ ",)))))))
+}
+
+#[cfg(test)] mod test {
+    use super::*;
+    #[test] fn test_view_clock () {
+        let _ = button_play_pause(true);
+        let mut app = Tek::default();
+        let _ = app.view_transport();
+        let _ = app.view_status();
+        let _ = app.update_clock();
+    }
+}

app/src/view/view_color.rs

@@ -0,0 +1,22 @@
+use crate::*;
+impl Tek {
+    pub(crate) fn colors (
+        theme:    &ItemPalette,
+        prev:     Option<ItemPalette>,
+        selected: bool,
+        neighbor: bool,
+        is_last:  bool,
+    ) -> [Color;4] {
+        let fg = theme.lightest.rgb;
+        let bg = if selected { theme.light } else { theme.base }.rgb;
+        let hi = Self::color_hi(prev, neighbor);
+        let lo = Self::color_lo(theme, is_last, selected);
+        [fg, bg, hi, lo]
+    }
+    pub(crate) fn color_hi (prev: Option<ItemPalette>, neighbor: bool) -> Color {
+        prev.map(|prev|if neighbor { prev.light.rgb } else { prev.base.rgb }).unwrap_or(Reset)
+    }
+    pub(crate) fn color_lo (theme: &ItemPalette, is_last: bool, selected: bool) -> Color {
+        if is_last { Reset } else if selected { theme.light.rgb } else { theme.base.rgb }
+    }
+}

app/src/view/view_iter.rs

@@ -0,0 +1,88 @@
+use crate::*;
+impl Tek {
+    pub(crate) fn inputs_sizes (&self) -> impl PortsSizes<'_> {
+        let mut y = 0;
+        self.midi_ins.iter().enumerate().map(move|(i, input)|{
+            let height = 1 + input.conn().len();
+            let data   = (i, input.name(), input.conn(), y, y + height);
+            y += height;
+            data
+        })
+    }
+    pub(crate) fn outputs_sizes (&self) -> impl PortsSizes<'_> {
+        let mut y = 0;
+        self.midi_outs.iter().enumerate().map(move|(i, output)|{
+            let height = 1 + output.conn().len();
+            let data   = (i, output.name(), output.conn(), y, y + height);
+            y += height;
+            data
+        })
+    }
+    pub(crate) fn tracks_sizes <'a> (&'a self) -> impl TracksSizes<'a> {
+        let editing = self.is_editing();
+        let bigger  = self.editor_w();
+        let mut x = 0;
+        let active = match self.selected() {
+            Selection::Track(t)   if editing => Some(t),
+            Selection::Clip(t, _) if editing => Some(t),
+            _ => None
+        };
+        self.tracks().iter().enumerate().map(move |(index, track)|{
+            let width = if Some(index) == active.copied() { bigger } else { track.width.max(8) };
+            let data = (index, track, x, x + width);
+            x += width + Self::TRACK_SPACING;
+            data
+        })
+    }
+    pub(crate) fn scenes_sizes (&self, editing: bool, height: usize, larger: usize) -> impl ScenesSizes<'_> {
+        let (selected_track, selected_scene) = match self.selected() {
+            Selection::Track(t)   => (Some(*t), None),
+            Selection::Scene(s)   => (None,     Some(*s)),
+            Selection::Clip(t, s) => (Some(*t), Some(*s)),
+            _ => (None, None)
+        };
+        let mut y = 0;
+        self.scenes().iter().enumerate().map(move|(s, scene)|{
+            let active = editing && selected_track.is_some() && selected_scene == Some(s);
+            let height = if active { larger } else { height };
+            let data   = (s, scene, y, y + height);
+            y += height;
+            data
+        })
+    }
+    pub(crate) fn scenes_with_colors (&self, editing: bool, h: u16) -> impl ScenesColors<'_> {
+        self.scenes_sizes(editing, Self::H_SCENE, Self::H_EDITOR).map_while(
+            move|(s, scene, y1, y2)|if y2 as u16 > h {
+                None
+            } else { Some((s, scene, y1, y2, if s == 0 {
+                None
+            } else {
+                Some(self.scenes[s-1].color)
+            }))
+        })
+    }
+    pub(crate) fn scenes_with_track_colors (&self, editing: bool, h: u16, t: usize) -> impl ScenesColors<'_> {
+        self.scenes_sizes(editing, Self::H_SCENE, Self::H_EDITOR).map_while(
+            move|(s, scene, y1, y2)|if y2 as u16 > h {
+                None
+            } else { Some((s, scene, y1, y2, if s == 0 {
+                None
+            } else {
+                Some(self.scenes[s-1].clips[t].as_ref()
+                    .map(|c|c.read().unwrap().color)
+                    .unwrap_or(ItemPalette::G[32]))
+            }))
+        })
+    }
+}
+
+#[cfg(test)] #[test] fn test_view_iter () {
+    let mut tek = Tek::default();
+    tek.editor = Some(Default::default());
+    let _: Vec<_> = tek.inputs_sizes().collect();
+    let _: Vec<_> = tek.outputs_sizes().collect();
+    let _: Vec<_> = tek.tracks_sizes().collect();
+    let _: Vec<_> = tek.scenes_sizes(true, 10, 10).collect();
+    let _: Vec<_> = tek.scenes_with_colors(true, 10).collect();
+    let _: Vec<_> = tek.scenes_with_track_colors(true, 10, 10).collect();
+}

app/src/view/view_memo.rs

@@ -0,0 +1,51 @@
+use crate::*;
+
+/// Clear a pre-allocated buffer, then write into it.
+#[macro_export] macro_rules! rewrite {
+    ($buf:ident, $($rest:tt)*) => { |$buf,_,_|{$buf.clear();write!($buf, $($rest)*)} } }
+
+#[derive(Debug, Default)] pub(crate) struct ViewMemo<T, U> {
+    pub(crate) value: T,
+    pub(crate) view: Arc<RwLock<U>>
+}
+impl<T: PartialEq, U> ViewMemo<T, U> {
+    fn new (value: T, view: U) -> Self {
+        Self { value, view: Arc::new(view.into()) }
+    }
+    pub(crate) fn update <R> (&mut self, newval: T, render: impl Fn(&mut U, &T, &T)->R) -> Option<R> {
+        if newval != self.value {
+            let result = render(&mut*self.view.write().unwrap(), &newval, &self.value);
+            self.value = newval;
+            return Some(result);
+        }
+        None
+    }
+}
+#[derive(Debug)] pub(crate) struct ViewCache {
+    pub(crate) sr:   ViewMemo<Option<(bool, f64)>, String>,
+    pub(crate) buf:  ViewMemo<Option<f64>, String>,
+    pub(crate) lat:  ViewMemo<Option<f64>, String>,
+    pub(crate) bpm:  ViewMemo<Option<f64>, String>,
+    pub(crate) beat: ViewMemo<Option<f64>, String>,
+    pub(crate) time: ViewMemo<Option<f64>, String>,
+    pub(crate) scns: ViewMemo<Option<(usize, usize)>, String>,
+    pub(crate) trks: ViewMemo<Option<(usize, usize)>, String>,
+    pub(crate) stop: Arc<str>,
+    pub(crate) edit: Arc<str>,
+}
+impl Default for ViewCache {
+    fn default () -> Self {
+        Self {
+            beat: ViewMemo::new(None, String::with_capacity(16)),
+            time: ViewMemo::new(None, String::with_capacity(16)),
+            bpm:  ViewMemo::new(None, String::with_capacity(16)),
+            sr:   ViewMemo::new(None, String::with_capacity(16)),
+            buf:  ViewMemo::new(None, String::with_capacity(16)),
+            lat:  ViewMemo::new(None, String::with_capacity(16)),
+            scns: ViewMemo::new(None, String::with_capacity(16)),
+            trks: ViewMemo::new(None, String::with_capacity(16)),
+            stop: "⏹".into(),
+            edit: "edit".into(),
+        }
+    }
+}

app/src/view/view_meter.rs

@@ -0,0 +1,48 @@
+use crate::*;
+fn view_meter <'a> (label: &'a str, value: f32) -> impl Content<TuiOut> + 'a {
+    col!(
+        FieldH(ItemPalette::G[128], label, format!("{:>+9.3}", value)),
+        Fixed::xy(if value >= 0.0 { 13 }
+            else if value >= -1.0 { 12 }
+            else if value >= -2.0 { 11 }
+            else if value >= -3.0 { 10 }
+            else if value >= -4.0 { 9  }
+            else if value >= -6.0 { 8  }
+            else if value >= -9.0 { 7  }
+            else if value >= -12.0 { 6 }
+            else if value >= -15.0 { 5 }
+            else if value >= -20.0 { 4 }
+            else if value >= -25.0 { 3 }
+            else if value >= -30.0 { 2 }
+            else if value >= -40.0 { 1 }
+            else { 0 }, 1, Tui::bg(if value >= 0.0  { Red }
+                else if value >= -3.0 { Yellow }
+                else { Green }, ())))
+}
+fn view_meters (values: &[f32;2]) -> impl Content<TuiOut> + use<'_> {
+    Bsp::s(
+        format!("L/{:>+9.3}", values[0]),
+        format!("R/{:>+9.3}", values[1]),
+    )
+}
+#[cfg(test)] mod test_view_meter {
+    use super::*;
+    use proptest::prelude::*;
+    #[test] fn test_view_meter () {
+        let _ = view_meter("", 0.0);
+        let _ = view_meters(&[0.0, 0.0]);
+    }
+    proptest! {
+        #[test] fn proptest_view_meter (
+            label in "\\PC*", value in f32::MIN..f32::MAX
+        ) {
+            let _ = view_meter(&label, value);
+        }
+        #[test] fn proptest_view_meters (
+            value1 in f32::MIN..f32::MAX,
+            value2 in f32::MIN..f32::MAX
+        ) {
+            let _ = view_meters(&[value1, value2]);
+        }
+    }
+}

app/src/view/view_sizes.rs

@@ -0,0 +1,73 @@
+use crate::*;
+
+/// Define a type alias for iterators of sized items (columns).
+macro_rules! def_sizes_iter {
+    ($Type:ident => $($Item:ty),+) => {
+        pub(crate) trait $Type<'a> =
+            Iterator<Item=(usize, $(&'a $Item,)+ usize, usize)> + Send + Sync + 'a;}}
+
+def_sizes_iter!(ScenesSizes  => Scene);
+def_sizes_iter!(TracksSizes  => Track);
+def_sizes_iter!(InputsSizes  => JackMidiIn);
+def_sizes_iter!(OutputsSizes => JackMidiOut);
+def_sizes_iter!(PortsSizes   => Arc<str>, [PortConnect]);
+
+impl Tek {
+    /// Spacing between tracks.
+    pub(crate) const TRACK_SPACING: usize = 0;
+    /// Default scene height.
+    pub(crate) const H_SCENE: usize = 2;
+    /// Default editor height.
+    pub(crate) const H_EDITOR: usize = 15;
+
+    /// Width of display
+    pub(crate) fn w (&self) -> u16 {
+        self.size.w() as u16
+    }
+    pub(crate) fn w_sidebar (&self) -> u16 {
+        self.w() / if self.is_editing() { 16 } else { 8 } as u16
+    }
+    /// Width taken by all tracks.
+    pub(crate) fn w_tracks (&self) -> u16 {
+        self.tracks_sizes().last().map(|(_, _, _, x)|x as u16).unwrap_or(0)
+    }
+    /// Width available to display tracks.
+    pub(crate) fn w_tracks_area (&self) -> u16 {
+        self.w().saturating_sub(2 * self.w_sidebar())
+    }
+    /// Height of display
+    pub(crate) fn h (&self) -> u16 {
+        self.size.h() as u16
+    }
+    /// Height available to display tracks.
+    pub(crate) fn h_tracks_area (&self) -> u16 {
+        self.h().saturating_sub(self.h_inputs() + self.h_outputs() + 10)
+    }
+    /// Height taken by all inputs.
+    pub(crate) fn h_inputs (&self) -> u16 {
+        1 + self.inputs_sizes().last().map(|(_, _, _, _, y)|y as u16).unwrap_or(0)
+    }
+    /// Height taken by all outputs.
+    pub(crate) fn h_outputs (&self) -> u16 {
+        1 + self.outputs_sizes().last().map(|(_, _, _, _, y)|y as u16).unwrap_or(0)
+    }
+    /// Height taken by all scenes.
+    pub(crate) fn h_scenes (&self) -> u16 {
+        self.scenes_sizes(self.is_editing(), Self::H_SCENE, Self::H_EDITOR).last()
+            .map(|(_, _, _, y)|y as u16).unwrap_or(0)
+    }
+}
+#[cfg(test)] mod test {
+    use super::*;
+    #[test] fn test_view_size () {
+        let app = Tek::default();
+        let _ = app.w();
+        let _ = app.w_sidebar();
+        let _ = app.w_tracks_area();
+        let _ = app.h();
+        let _ = app.h_tracks_area();
+        let _ = app.h_inputs();
+        let _ = app.h_outputs();
+        let _ = app.h_scenes();
+    }
+}