cleanup ports; horizontal scenes

src/view/grid.rs

@@ -9,38 +9,105 @@ pub struct SceneGridView<'a> {
     pub scenes:  &'a[Scene],
     pub tracks:  &'a[Track],
     pub cursor:  &'a(usize, usize),
+    pub mode:    bool,
 }
 impl<'a> SceneGridView<'a> {
-    pub fn new (
-        buf:     &'a mut Buffer,
-        area:    Rect,
-        name:    &'a str,
-        focused: bool,
-        scenes:  &'a[Scene],
-        tracks:  &'a[Track],
-        cursor:  &'a(usize, usize),
-    ) -> Self {
-        Self {
-            buf,
-            area,
-            name,
-            focused,
-            scenes,
-            tracks,
-            cursor,
+    fn longest_scene_name (&self) -> u16 {
+        let mut w = 3u16;
+        for scene in self.scenes.iter() {
+            w = w.max(scene.name.len() as u16);
+        }
+        w
+    }
+
+    fn longest_track_name (&self) -> u16 {
+        let mut w = 3u16;
+        for track in self.tracks.iter() {
+            w = w.max(track.name.len() as u16);
+        }
+        w
+    }
+
+    pub fn size_horizontal (&mut self) -> (u16, u16) {
+        let (mut w, mut h) = (4, 2);
+        w = w + self.longest_track_name();
+        w = w + self.scenes.len() as u16 * 10;
+        h = h + self.tracks.len();
+        (w as u16, h as u16)
+    }
+
+    pub fn draw (&mut self) -> Usually<Rect> {
+        match self.mode {
+            true  => self.draw_horizontal(),
+            false => self.draw_vertical(),
         }
     }
-    pub fn draw (&mut self) -> Usually<Rect> {
-        self.area.height = self.scenes.len() as u16 + 2;
+
+    pub fn draw_horizontal (&mut self) -> Usually<Rect> {
+        let (w, h) = self.size_horizontal();
+        //self.area.x = self.area.x + self.area.width.saturating_sub(w) / 2;
+        self.area.height = self.tracks.len() as u16 + 2;
+        //self.area.width  = w;
         let style = Some(Style::default().green().dim());
         if self.focused {
             let Rect { x, y, width, height } = self.area;
             lozenge_left(self.buf, x, y, height, style);
             lozenge_right(self.buf, x + width - 1, y, height, style);
         }
-        let columns = self.column_names();
+        " Mix ".blit(self.buf,self.area.x+1,self.area.y,Some(Style::default().bold().not_dim().white()));
+        let mut x2 = 0;
+        for (i, track) in self.tracks.iter().enumerate() {
+            let label = format!(" {} ", &track.name);
+            label.blit(self.buf, self.area.x+1, self.area.y+1+i as u16, Some(Style::default().bold()));
+            x2 = x2.max(label.len() as u16 + 1);
+        }
+        "╷".blit(self.buf, self.area.x + x2, self.area.y, style);
+        for y in self.area.y+1..self.area.y+self.area.height-1 {
+            "│".blit(self.buf, self.area.x + x2, y, style);
+        }
+        //"╵".blit(self.buf, self.area.x + x2, self.area.y+self.area.height-1, style);
+        x2 = x2 + 1;
+        for scene in self.scenes.iter() {
+            let label = format!("{}", &scene.name);
+            let mut x3 = label.len() as u16;
+            label.blit(self.buf, self.area.x + x2, self.area.y, Some(Style::default().bold()));
+            for (i, clip) in scene.clips.iter().enumerate() {
+                if let Some(clip) = clip {
+                    if let Some(phrase) = self.tracks[i].sequencer.phrases.get(*clip) {
+                        let label = format!("{}", &phrase.name);
+                        label.blit(self.buf, self.area.x + x2, self.area.y + 1 + i as u16, None);
+                        x3 = x3.max(label.len() as u16)
+                    }
+                }
+            }
+            x2 = x2 + x3;
+
+            "╷".blit(self.buf, self.area.x + x2, self.area.y, style);
+            for y in self.area.y+1..self.area.y+self.area.height-1 {
+                "┊".blit(self.buf, self.area.x + x2, y, style);
+            }
+            //"╵".blit(self.buf, self.area.x + x2, self.area.y+self.area.height-1, style);
+            x2 = x2 + 1;
+        }
+        if self.focused {
+            HELP.blit(self.buf, self.area.x + 2, self.area.y + self.area.height - 1, Some(Style::default().dim()));
+        }
+        Ok(self.area)
+    }
+
+    pub fn draw_vertical (&mut self) -> Usually<Rect> {
+        let width        = self.area.width.min(4 + HELP.len() as u16);
+        self.area.height = self.scenes.len() as u16 + 2;
+        //self.area.x      = self.area.x + self.area.width.saturating_sub(width) / 2;
+        let style = Some(Style::default().green().dim());
+        if self.focused {
+            let Rect { x, y, width, height } = self.area;
+            lozenge_left(self.buf, x, y, height, style);
+            lozenge_right(self.buf, x + width - 1, y, height, style);
+        }
+        let columns = self.track_names();
         let mut x = self.area.x;
-        for (i, w) in self.column_widths().iter().enumerate() {
+        for (i, w) in self.track_widths().iter().enumerate() {
             if x >= self.area.x + self.area.width {
                 break
             }
@@ -64,20 +131,22 @@ impl<'a> SceneGridView<'a> {
             let w = (title.len() as u16).max(10) + 3;
             x = x + w;
         }
-        "[C-t] Add track…".blit(self.buf, x + 2, y + 1, Some(Style::default().dim()));
+        if self.focused {
+            HELP.blit(self.buf, self.area.x + 2, self.area.y + self.area.height - 1, Some(Style::default().dim()));
+        }
         Ok(self.area)
     }
 
-    fn column_names (&self) -> Vec<&'a str> {
-        let mut column_names = vec![self.name];
+    fn track_names (&self) -> Vec<&'a str> {
+        let mut track_names = vec!["Mix"];
         for track in self.tracks.iter() {
-            column_names.push(track.name.as_str());
+            track_names.push(track.name.as_str());
         }
-        column_names
+        track_names
     }
 
-    fn column_widths (&self) -> Vec<u16> {
-        self.column_names().iter().map(|name|(name.len() as u16).max(10) + 3).collect()
+    fn track_widths (&self) -> Vec<u16> {
+        self.track_names().iter().map(|name|(name.len() as u16).max(10) + 3).collect()
     }
 
     fn scenes (&mut self, x: u16, y: u16) -> u16 {
@@ -98,13 +167,6 @@ impl<'a> SceneGridView<'a> {
             }
             index = index + 1;
         }
-        let hi = (0 == self.cursor.0) &&
-                 (self.scenes.len() + 1 == self.cursor.1);
-        "[Add scene…]".blit(self.buf, x, y + index as u16, Some(if hi {
-            self.highlight(true)
-        } else {
-            Style::default().dim()
-        }));
         index as u16
     }
 
@@ -136,13 +198,13 @@ impl<'a> SceneGridView<'a> {
             }
             index = index + 1;
         }
-        let hi = (track + 1 == self.cursor.0) &&
-                 (self.scenes.len() + 1 == self.cursor.1);
-        "[Add clip…]".blit(self.buf, x, y + index as u16, Some(if hi {
-            self.highlight(true)
-        } else {
-            Style::default().dim()
-        }));
+        //let hi = (track + 1 == self.cursor.0) &&
+                 //(self.scenes.len() + 1 == self.cursor.1);
+        //"[Add clip…]".blit(self.buf, x, y + index as u16, Some(if hi {
+            //self.highlight(true)
+        //} else {
+            //Style::default().dim()
+        //}));
         index as u16
     }
 
@@ -166,3 +228,4 @@ impl<'a> SceneGridView<'a> {
     }
 }
 
+const HELP: &'static str = "[C-t] Add track  [C-a] Add scene  [v] Show/hide track";

src/view/launcher.rs

@@ -17,12 +17,13 @@ pub fn render (state: &Launcher, buf: &mut Buffer, mut area: Rect) -> Usually<Re
     y = y + SceneGridView {
         buf,
         area:    Rect { x, y, width, height },
+        mode:    false,
         name:    &state.name,
         focused: state.view.is_tracks(),
         scenes:  &state.scenes,
         tracks:  &state.tracks,
         cursor:  &state.cursor
-    }.draw()?.height;
+    }.draw_vertical()?.height;
 
     if let Some(chain) = state.chain() {
         y = y + ChainView {