tek/app/src/view/view_iter.rs

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 tracks_sizes_scrolled <'a> (&'a self) -> impl TracksSizes<'a> {
        let width = self.w_tracks_area();
        self.tracks_sizes().map_while(move|(t, track, x1, x2)|{
            (width > x2 as u16).then_some((t, track, x1, x2))
        })
    }
    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();
}