enum ArrangerViewMode instead of bool

src/devices/arranger.rs

@@ -7,37 +7,37 @@ pub use self::scene::Scene;
 /// Key bindings for arranger section.
 pub const KEYMAP_ARRANGER: &'static [KeyBinding<App>] = keymap!(App {
     [Char('`'), NONE, "arranger_mode_switch", "switch the display mode", |app: &mut App| {
-        app.arranger.mode = !app.arranger.mode;
+        app.arranger.mode.to_next();
         Ok(true)
     }],
     [Up,    NONE, "arranger_cursor_up",    "move cursor up",    |app: &mut App| {
         match app.arranger.mode {
-            false => app.arranger.scene_prev(),
-            true  => app.arranger.track_prev(),
+            ArrangerViewMode::Horizontal => app.arranger.track_prev(),
+            _ => app.arranger.scene_prev(),
         };
         app.sequencer.show(app.arranger.phrase())?;
         Ok(true)
     }],
     [Down,  NONE, "arranger_cursor_down",  "move cursor down",  |app: &mut App| {
         match app.arranger.mode {
-            false => app.arranger.scene_next(),
-            true  => app.arranger.track_next(),
+            ArrangerViewMode::Horizontal => app.arranger.track_next(),
+            _ => app.arranger.scene_next(),
         };
         app.sequencer.show(app.arranger.phrase())?;
         Ok(true)
     }],
     [Left,  NONE, "arranger_cursor_left",  "move cursor left",  |app: &mut App| {
         match app.arranger.mode {
-            false => app.arranger.track_prev(),
-            true  => app.arranger.scene_prev(),
+            ArrangerViewMode::Horizontal => app.arranger.scene_prev(),
+            _ => app.arranger.track_prev(),
         };
         app.sequencer.show(app.arranger.phrase())?;
         Ok(true)
     }],
     [Right, NONE, "arranger_cursor_right", "move cursor right", |app: &mut App| {
         match app.arranger.mode {
-            false => app.arranger.track_next(),
-            true  => app.arranger.scene_next()
+            ArrangerViewMode::Horizontal => app.arranger.scene_next(),
+            _ => app.arranger.track_next(),
         };
         app.sequencer.show(app.arranger.phrase())?;
         Ok(true)
@@ -61,7 +61,7 @@ pub const KEYMAP_ARRANGER: &'static [KeyBinding<App>] = keymap!(App {
 /// Represents the tracks and scenes of the composition.
 pub struct Arranger {
     /// Display mode of arranger
-    pub mode: bool,
+    pub mode: ArrangerViewMode,
     /// Currently selected element.
     pub selected: ArrangerFocus,
     /// Collection of tracks.
@@ -74,11 +74,28 @@ pub struct Arranger {
     pub fixed_height: bool,
 }
 
+/// Display mode of arranger
+enum ArrangerViewMode {
+    Vertical,
+    VerticalCompact,
+    Horizontal,
+}
+
+impl ArrangerViewMode {
+    fn to_next (&mut self) {
+        *self = match self {
+            Self::Vertical        => Self::VerticalCompact,
+            Self::VerticalCompact => Self::Horizontal,
+            Self::Horizontal      => Self::Vertical,
+        }
+    }
+}
+
 impl Arranger {
 
     pub fn new () -> Self {
         Self {
-            mode:         false,
+            mode:         ArrangerViewMode::Vertical,
             selected:     ArrangerFocus::Clip(0, 0),
             scenes:       vec![],
             tracks:       vec![],
@@ -105,19 +122,33 @@ impl Arranger {
     }
 }
 
-render!(Arranger |self, buf, area| if self.mode {
-    self::draw_horizontal::draw(self, buf, area)
-} else {
-    self::draw_vertical::draw(self, buf, area)
+render!(Arranger |self, buf, area| match self.mode {
+    ArrangerViewMode::Horizontal =>
+        self::draw_horizontal::draw(self, buf, area),
+    ArrangerViewMode::Vertical =>
+        self::draw_vertical::draw_expanded(self, buf, area),
+    ArrangerViewMode::VerticalCompact =>
+        self::draw_vertical::draw_compact(self, buf, area),
 });
 
 mod draw_vertical {
     use crate::{core::*, view::*, model::Track};
     use super::{Arranger, focus::ArrangerFocus, track::track_clip_name_lengths, scene::{Scene, scene_ppqs, scene_name_max_len}};
 
-    pub fn draw (state: &Arranger, buf: &mut Buffer, mut area: Rect) -> Usually<Rect> {
-        let track_cols = track_clip_name_lengths(state.tracks.as_slice());
+    pub fn draw_expanded (state: &Arranger, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
         let scene_rows = scene_ppqs(state.tracks.as_slice(), state.scenes.as_slice());
+        draw(state, buf, area, scene_rows.as_slice())
+    }
+
+    pub fn draw_compact (state: &Arranger, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
+        let scene_rows = (0..=state.scenes.len()).map(|i|(96, 96*(i+1))).collect::<Vec<_>>();
+        draw(state, buf, area, scene_rows.as_slice())
+    }
+
+    pub fn draw (
+        state: &Arranger, buf: &mut Buffer, mut area: Rect, scene_rows: &[(usize, usize)]
+    ) -> Usually<Rect> {
+        let track_cols = track_clip_name_lengths(state.tracks.as_slice());
         area.height = 2 + (scene_rows[scene_rows.len() - 1].1 / 96) as u16;
         let offset = 3 + scene_name_max_len(state.scenes.as_ref()) as u16;
         let style = Some(Style::default().fg(Color::Rgb(0,0,0)));
@@ -186,7 +217,7 @@ mod draw_vertical {
             &|buf: &mut Buffer, area: Rect|state.draw_tracks_header(
                 buf, area, track_cols.as_slice(), offset),
             &|buf: &mut Buffer, area: Rect|state.draw_scene_rows(
-                buf, area, track_cols.as_slice(), scene_rows.as_slice(), offset),
+                buf, area, track_cols.as_slice(), scene_rows, offset),
         ]).render(buf, area)?;
         for (_, y) in scene_rows.iter() {
             let y = area.y + (*y / 96) as u16 + 1;