tek/app/src/view/view_track.rs

use crate::*;

impl<'a> ArrangerView<'a> {

    /// Render track headers
    pub(crate) fn tracks (&'a self) -> impl Content<TuiOut> + 'a {
        Tryptich::center(3)
            .left(self.width_side,
                button_3("t", "track", format!("{}", self.track_count), self.is_editing))
            .right(self.width_side,
                button_2("T", "add track", self.is_editing))
            .middle(self.width_mid,
                per_track(
                    self.width_mid,
                    ||self.tracks_with_sizes_scrolled(),
                    |t, track|view_track_header(t, track, self.track_selected == Some(t))))
    }

    /// Render scenes with clips
    pub(crate) fn scenes (&'a self) -> impl Content<TuiOut> + 'a {
        Tryptich::center(self.scenes_height)
            .left(self.width_side, Map::new(
                ||self.scenes_with_scene_colors(),
                move|(index, scene, y1, y2, previous): SceneWithColor, _|{
                    let offset  = y1 as u16;
                    let height  = (1 + y2 - y1) as u16;
                    let is_last = self.scene_last == index;
                    view_scene_name(
                        self.width, height, offset,
                        index, scene, previous, is_last, self.scene_selected
                    )
                }))
            .middle(self.width_mid, per_track(
                self.width_mid,
                ||self.tracks_with_sizes_scrolled(),
                move|track_index, track|Map::new(
                    ||self.scenes_with_track_colors(),
                    move|(scene_index, scene, y1, y2, prev_scene): SceneWithColor, _|
                        view_scene_clip(
                            self.width_mid,
                            (1 + y2 - y1) as u16,
                            y1 as u16,
                            scene,
                            prev_scene,
                            scene_index,
                            track_index,
                            self.is_editing,
                            self.track_selected == Some(track_index),
                            self.scene_selected,
                            self.scene_last == scene_index,
                            &self.app.editor
                        ))))
    }

    fn scene_add (&'a self) -> impl Content<TuiOut> + 'a {
        let data = (self.scene_selected.unwrap_or(0), self.scene_count);
        self.app.fmtd.write().unwrap().scns.update(Some(data), rewrite!(buf, "({}/{})", data.0, data.1));
        button_3("S", "add scene", self.app.fmtd.read().unwrap().scns.view.clone(), self.is_editing)
    }

    fn track_counter (&'a self) -> Arc<RwLock<String>> {
        let track_counter_data = (self.track_selected.unwrap_or(0), self.track_count);
        self.app.fmtd.write().unwrap().trks.update(
            Some(track_counter_data),
            rewrite!(buf, "{}/{}", track_counter_data.0, track_counter_data.1)
        );
        self.app.fmtd.read().unwrap().trks.view.clone()
    }

}

fn view_track_header <'a> (
    index:  usize,
    track:  &'a Track,
    active: bool
) -> impl Content<TuiOut> + use<'a> {
    let fg  = track.color.lightest.rgb;
    let bg  = if active { track.color.light.rgb } else { track.color.base.rgb };
    let bg2 = Reset;//if index > 0 { self.tracks()[index - 1].color.base.rgb } else { Reset };
    wrap(bg, fg, Tui::bold(true, Fill::x(Align::nw(&track.name))))
}

pub(crate) fn view_scene_name (
    width:  u16,
    height: u16,
    offset: u16,
    index:  usize,
    scene:  &Scene,
    prev:   Option<ItemPalette>,
    last:   bool,
    select: Option<usize>,
) -> impl Content<TuiOut> {
    Fill::x(map_south(offset, height, Fixed::y(height, view_scene_cell(
        last,
        select,
        true,
        index,
        &scene.color,
        prev,
        Some(scene.name.clone()),
        " ⯈ ",
        scene.color.lightest.rgb
    ))))
}

pub(crate) fn view_scene_clip <'a> (
    width:          u16,
    height:         u16,
    offset:         u16,
    scene:          &'a Scene,
    prev:           Option<ItemPalette>,
    scene_index:    usize,
    track_index:    usize,
    editing:        bool,
    same_track:     bool,
    scene_selected: Option<usize>,
    scene_is_last:  bool,
    editor:         &'a Option<MidiEditor>,
) -> impl Content<TuiOut> + use<'a> {
    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 && scene_selected == Some(scene_index);
    let edit = |x|Bsp::b(x, When(active, editor));
    map_south(offset, height, edit(Fixed::y(height, view_scene_cell(
        scene_is_last,
        scene_selected,
        same_track,
        scene_index,
        &bg,
        prev,
        name,
        " ⏹ ",
        fg
    ))))
}

pub(crate) fn view_scene_cell <'a> (
    is_last:    bool,
    selected:   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 == Some(scene),
            same_track && scene > 0 && selected == Some(scene - 1),
            is_last
        )
    }
}