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();
+}

app/src/view/view_iter.rs

@@ -1,94 +0,0 @@
-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();
-}

app/src/view/view_ports.rs

@@ -8,13 +8,16 @@ impl<'a> ArrangerView<'a> {
 
     fn input_routes (&'a self) -> impl Content<TuiOut> + 'a {
         Tryptich::top(self.inputs_height)
-            .left(self.width_side, io_ports(Tui::g(224), Tui::g(32), ||self.inputs_with_sizes()))
+            .left(self.width_side,
-            .middle(self.width_mid, per_track_top(
+                io_ports(Tui::g(224), Tui::g(32), ||self.app.inputs_with_sizes()))
+            .middle(self.width_mid,
+                per_track_top(
                     self.width_mid,
-                ||self.tracks_with_sizes(),
+                    ||self.app.tracks_with_sizes(),
                     move|_, &Track { color, .. }|{
-                    io_conns(color.dark.rgb, color.darker.rgb, ||self.inputs_with_sizes())
+                        io_conns(color.dark.rgb, color.darker.rgb, ||self.app.inputs_with_sizes())
-                }))
+                    }
+                ))
     }
 
     fn input_ports (&'a self) -> impl Content<TuiOut> + 'a {
@@ -26,7 +29,7 @@ impl<'a> ArrangerView<'a> {
             .middle(self.width_mid,
                 per_track_top(
                     self.width_mid,
-                    ||self.tracks_with_sizes(),
+                    ||self.app.tracks_with_sizes(),
                     move|t, track|{
                         let rec = track.player.recording;
                         let mon = track.player.monitoring;
@@ -52,7 +55,7 @@ impl<'a> ArrangerView<'a> {
             .middle(self.width_mid,
                 per_track_top(
                     self.width_mid,
-                    ||self.tracks_with_sizes(),
+                    ||self.app.tracks_with_sizes(),
                     |_, _|{
                         Tui::bg(Reset, Align::c(Bsp::s(OctaveVertical::default(), " ------ ")))
                     }))
@@ -77,7 +80,7 @@ impl<'a> ArrangerView<'a> {
             .left(self.width_side, Align::ne("From:"))
             .middle(self.width_mid, per_track_top(
                 self.width_mid,
-                ||self.tracks_with_sizes(),
+                ||self.tracks_with_sizes_scrolled(),
                 |_, _|{
                     Tui::bg(Reset, Align::c(Bsp::s(" ------ ", OctaveVertical::default())))
                 }))
@@ -87,7 +90,7 @@ impl<'a> ArrangerView<'a> {
             .left(self.width_side, Align::ne("Next:"))
             .middle(self.width_mid, per_track_top(
                 self.width_mid,
-                ||self.tracks_with_sizes(),
+                ||self.tracks_with_sizes_scrolled(),
                 |t, track|Either(
                     track.player.next_clip.is_some(),
                     Thunk::new(||Tui::bg(Reset, format!("{:?}",
@@ -107,7 +110,7 @@ impl<'a> ArrangerView<'a> {
             .middle(self.width_mid,
                 per_track_top(
                     self.width_mid,
-                    ||self.tracks_with_sizes(),
+                    ||self.tracks_with_sizes_scrolled(),
                     move|i, t|{
                         let mute = false;
                         let solo = false;
@@ -123,12 +126,14 @@ impl<'a> ArrangerView<'a> {
     fn output_conns (&'a self) -> impl Content<TuiOut> + 'a {
         Tryptich::top(self.outputs_height)
             .left(self.width_side,
-                io_ports(Tui::g(224), Tui::g(32), ||self.outputs_with_sizes()))
+                io_ports(Tui::g(224), Tui::g(32), ||self.app.outputs_with_sizes()))
             .middle(self.width_mid, per_track_top(
                 self.width_mid,
-                ||self.tracks_with_sizes(),
+                ||self.tracks_with_sizes_scrolled(),
-                |_, t|{
+                |_, t|io_conns(
-                    io_conns(t.color.dark.rgb, t.color.darker.rgb, ||self.outputs_with_sizes())
+                    t.color.dark.rgb,
-                }))
+                    t.color.darker.rgb,
+                    ||self.app.outputs_with_sizes()
+                )))
     }
 }

app/src/view/view_sizes.rs

@@ -29,7 +29,7 @@ impl Tek {
     }
     /// Width taken by all tracks.
     pub(crate) fn w_tracks (&self) -> u16 {
-        self.tracks_sizes().last().map(|(_, _, _, x)|x as u16).unwrap_or(0)
+        self.tracks_with_sizes().last().map(|(_, _, _, x)|x as u16).unwrap_or(0)
     }
     /// Width available to display tracks.
     pub(crate) fn w_tracks_area (&self) -> u16 {
@@ -45,15 +45,15 @@ impl Tek {
     }
     /// 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)
+        1 + self.inputs_with_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)
+        1 + self.outputs_with_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()
+        self.scenes_with_sizes(self.is_editing(), Self::H_SCENE, Self::H_EDITOR).last()
             .map(|(_, _, _, y)|y as u16).unwrap_or(0)
     }
 }

app/src/view/view_track.rs

@@ -12,7 +12,7 @@ impl<'a> ArrangerView<'a> {
             .middle(self.width_mid,
                 per_track(
                     self.width_mid,
-                    ||self.tracks_with_sizes(),
+                    ||self.tracks_with_sizes_scrolled(),
                     |t, track|view_track_header(t, track, self.track_selected == Some(t))))
     }
 
@@ -32,7 +32,7 @@ impl<'a> ArrangerView<'a> {
                 }))
             .middle(self.width_mid, per_track(
                 self.width_mid,
-                ||self.tracks_with_sizes(),
+                ||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, _|
@@ -58,21 +58,6 @@ impl<'a> ArrangerView<'a> {
         button_3("S", "add scene", self.app.fmtd.read().unwrap().scns.view.clone(), self.is_editing)
     }
 
-    fn scenes_with_scene_colors (&'a self) -> impl ScenesColors<'a> {
-        self.app.scenes_with_colors(
-            self.is_editing,
-            self.tracks_height
-        )
-    }
-
-    fn scenes_with_track_colors (&'a self) -> impl ScenesColors<'a> {
-        self.app.scenes_with_track_colors(
-            self.is_editing,
-            self.tracks_height,
-            self.track_selected.unwrap_or(0)
-        )
-    }
-
     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(