fold view_iter

app/src/view.rs

@@ -1,7 +1,6 @@
 use crate::*;
 mod view_clock;  pub use self::view_clock::*;
 mod view_color;  pub use self::view_color::*;
-mod view_iter;   pub use self::view_iter::*;
 mod view_memo;   pub use self::view_memo::*;
 mod view_meter;  pub use self::view_meter::*;
 mod view_sizes;  pub use self::view_sizes::*;
@@ -64,6 +63,8 @@ pub(crate) struct ArrangerView<'a> {
     track_count:    usize,
     track_selected: Option<usize>,
     tracks_height:  u16,
+
+    show_debug_info: bool,
 }
 
 impl<'a> Content<TuiOut> for ArrangerView<'a> {
@@ -113,15 +114,122 @@ impl<'a> ArrangerView<'a> {
                 total:  app.h_scenes() as usize,
             })),
 
+            show_debug_info: false
         }
     }
-    pub(crate) fn inputs_with_sizes (&'a self) -> impl PortsSizes<'a> {
-        self.app.inputs_sizes()
+
+    pub(crate) fn tracks_with_sizes_scrolled (&'a self)
+        -> impl TracksSizes<'a>
+    {
+        let width = self.width_mid;
+        self.app.tracks_with_sizes().map_while(move|(t, track, x1, x2)|{
+            (width > x2 as u16).then_some((t, track, x1, x2))
+        })
     }
-    pub(crate) fn outputs_with_sizes (&'a self) -> impl PortsSizes<'a> {
-        self.app.outputs_sizes()
+
+    pub(crate) fn scenes_with_scene_colors (&self)
+        -> impl ScenesColors<'_>
+    {
+        self.app.scenes_with_sizes(self.is_editing, Tek::H_SCENE, Tek::H_EDITOR).map_while(
+            move|(s, scene, y1, y2)|if y2 as u16 > self.tracks_height {
+                None
+            } else { Some((s, scene, y1, y2, if s == 0 {
+                None
+            } else {
+                Some(self.app.scenes()[s-1].color)
+            }))
+        })
     }
-    pub(crate) fn tracks_with_sizes (&'a self) -> impl TracksSizes<'a> {
-        self.app.tracks_sizes_scrolled()
+
+    pub(crate) fn scenes_with_track_colors (&self)
+        -> impl ScenesColors<'_>
+    {
+        self.app.scenes_with_sizes(self.is_editing, Tek::H_SCENE, Tek::H_EDITOR).map_while(
+            move|(s, scene, y1, y2)|if y2 as u16 > self.tracks_height {
+                None
+            } else { Some((s, scene, y1, y2, if s == 0 {
+                None
+            } else {
+                Some(self.app.scenes[s-1].clips[self.track_selected.unwrap_or(0)].as_ref()
+                    .map(|c|c.read().unwrap().color)
+                    .unwrap_or(ItemPalette::G[32]))
+            }))
+        })
     }
 }
+
+impl Tek {
+
+    pub(crate) fn inputs_with_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_with_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_with_sizes (&self)
+        -> impl TracksSizes<'_>
+    {
+        let mut x = 0;
+        let editing = self.is_editing();
+        let active = match self.selected() {
+            Selection::Track(t)   if editing => Some(t),
+            Selection::Clip(t, _) if editing => Some(t),
+            _ => None
+        };
+        let bigger  = self.editor_w();
+        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 + Tek::TRACK_SPACING;
+            data
+        })
+    }
+
+    pub(crate) fn scenes_with_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
+        })
+    }
+}
+
+#[cfg(test)] #[test] fn test_view_iter () {
+    let mut tek = Tek::default();
+    tek.editor = Some(Default::default());
+    let _: Vec<_> = tek.inputs_with_sizes().collect();
+    let _: Vec<_> = tek.outputs_with_sizes().collect();
+    let _: Vec<_> = tek.tracks_with_sizes().collect();
+    let _: Vec<_> = tek.scenes_with_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();
+}