wip: refactor into crates

crates/tek_sequencer/src/arranger.rs

@@ -0,0 +1,144 @@
+//! Clip launcher and arrangement editor.
+
+use crate::*;
+
+use self::arr_focus::ArrangerFocus;
+pub use self::arr_scene::Scene;
+
+submod! { arr_draw_h arr_draw_v arr_focus arr_phrase arr_scene arr_track }
+
+/// Key bindings for arranger section.
+pub const KEYMAP_ARRANGER: &'static [KeyBinding<Arranger>] = keymap!(Arranger {
+    [Char('`'), NONE, "arranger_mode_switch", "switch the display mode", |app: &mut Arranger| {
+        app.mode.to_next();
+        Ok(true)
+    }],
+    [Up,    NONE, "arranger_cursor_up",    "move cursor up",    |app: &mut Arranger| {
+        match app.mode {
+            ArrangerViewMode::Horizontal => app.track_prev(),
+            _ => app.scene_prev(),
+        };
+        app.show_phrase()?;
+        Ok(true)
+    }],
+    [Down,  NONE, "arranger_cursor_down",  "move cursor down",  |app: &mut Arranger| {
+        match app.mode {
+            ArrangerViewMode::Horizontal => app.track_next(),
+            _ => app.scene_next(),
+        };
+        app.show_phrase()?;
+        Ok(true)
+    }],
+    [Left,  NONE, "arranger_cursor_left",  "move cursor left",  |app: &mut Arranger| {
+        match app.mode {
+            ArrangerViewMode::Horizontal => app.scene_prev(),
+            _ => app.track_prev(),
+        };
+        app.show_phrase()?;
+        Ok(true)
+    }],
+    [Right, NONE, "arranger_cursor_right", "move cursor right", |app: &mut Arranger| {
+        match app.mode {
+            ArrangerViewMode::Horizontal => app.scene_next(),
+            _ => app.track_next(),
+        };
+        app.show_phrase()?;
+        Ok(true)
+    }],
+    [Char('.'), NONE, "arranger_increment", "set next clip at cursor", |app: &mut Arranger| {
+        app.phrase_next();
+        app.sequencer.phrase = app.phrase().map(Clone::clone);
+        Ok(true)
+    }],
+    [Char(','), NONE, "arranger_decrement", "set previous clip at cursor", |app: &mut Arranger| {
+        app.phrase_prev();
+        app.sequencer.phrase = app.phrase().map(Clone::clone);
+        Ok(true)
+    }],
+    [Enter, NONE, "arranger_activate", "activate item at cursor", |app: &mut Arranger| {
+        app.activate();
+        Ok(true)
+    }],
+});
+
+/// Represents the tracks and scenes of the composition.
+pub struct Arranger {
+    /// Display mode of arranger
+    pub mode: ArrangerViewMode,
+    /// Currently selected element.
+    pub selected: ArrangerFocus,
+    /// Collection of tracks.
+    pub tracks: Vec<Track>,
+    /// Collection of scenes.
+    pub scenes: Vec<Scene>,
+
+    pub focused: bool,
+    pub entered: bool,
+    pub fixed_height: bool,
+
+    pub sequencer: Sequencer,
+}
+
+/// Display mode of arranger
+pub 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:         ArrangerViewMode::Vertical,
+            selected:     ArrangerFocus::Clip(0, 0),
+            scenes:       vec![],
+            tracks:       vec![],
+            entered:      true,
+            focused:      true,
+            fixed_height: false,
+            sequencer:    Sequencer::new(),
+        }
+    }
+
+    pub fn activate (&mut self) {
+        match self.selected {
+            ArrangerFocus::Scene(s) => {
+                for (track_index, track) in self.tracks.iter_mut().enumerate() {
+                    track.sequence = self.scenes[s].clips[track_index];
+                    track.reset = true;
+                }
+            },
+            ArrangerFocus::Clip(t, s) => {
+                self.tracks[t].sequence = self.scenes[s].clips[t];
+                self.tracks[t].reset = true;
+            },
+            _ => {}
+        }
+    }
+
+    fn show_phrase (&mut self) -> Usually<()> {
+        let phrase = self.phrase();
+        self.sequencer.show(phrase)
+    }
+}
+
+render!(Arranger |self, buf, area| match self.mode {
+    ArrangerViewMode::Horizontal =>
+        self::arr_draw_h::draw(self, buf, area),
+    ArrangerViewMode::Vertical =>
+        self::arr_draw_v::draw_expanded(self, buf, area),
+    ArrangerViewMode::VerticalCompact =>
+        self::arr_draw_v::draw_compact(self, buf, area),
+});
+