wip: refactor pt.4, reduce number of files

crates/tek_tui/src/tui_sequencer_cmd.rs

@@ -0,0 +1,257 @@
+use crate::*;
+
+#[derive(Clone, PartialEq)]
+pub enum SequencerCommand {
+    Focus(FocusCommand),
+    Transport(TransportCommand),
+    Phrases(PhrasePoolCommand),
+    Editor(PhraseEditorCommand),
+}
+#[derive(Clone, PartialEq)]
+pub enum PhrasePoolCommand {
+    Prev,
+    Next,
+    MoveUp,
+    MoveDown,
+    Delete,
+    Append,
+    Insert,
+    Duplicate,
+    RandomColor,
+    Edit,
+    Import,
+    Export,
+    Rename(PhraseRenameCommand),
+    Length(PhraseLengthCommand),
+}
+#[derive(Clone, PartialEq)]
+pub enum PhraseRenameCommand {
+    Begin,
+    Backspace,
+    Append(char),
+    Set(String),
+    Confirm,
+    Cancel,
+}
+#[derive(Clone, PartialEq)]
+pub enum PhraseLengthCommand {
+    Begin,
+    Next,
+    Prev,
+    Inc,
+    Dec,
+    Set(usize),
+    Confirm,
+    Cancel,
+}
+#[derive(Clone, PartialEq)]
+pub enum PhraseEditorCommand {
+    // TODO: 1-9 seek markers that by default start every 8th of the phrase
+    ToggleDirection,
+    EnterEditMode,
+    ExitEditMode,
+    NoteAppend,
+    NoteCursorDec,
+    NoteCursorInc,
+    NoteLengthDec,
+    NoteLengthInc,
+    NotePageDown,
+    NotePageUp,
+    NoteScrollDec,
+    NoteScrollInc,
+    NoteSet,
+    TimeCursorDec,
+    TimeCursorInc,
+    TimeScrollDec,
+    TimeScrollInc,
+    TimeZoomIn,
+    TimeZoomOut,
+    GoUp,
+    GoDown,
+    GoLeft,
+    GoRight,
+}
+impl<E: Engine> Command<Sequencer<E>> for SequencerCommand {
+    fn execute (self, state: &mut Sequencer<E>) -> Perhaps<Self> {
+        match self {
+            Self::Focus(cmd) => {
+                return delegate(cmd, Self::Focus,     state)
+            },
+            Self::Phrases(cmd) => {
+                return delegate(cmd, Self::Phrases,   &mut*state.phrases.write().unwrap())
+            },
+            Self::Editor(cmd) => {
+                return delegate(cmd, Self::Editor,    &mut state.editor)
+            },
+            Self::Transport(cmd) => if let Some(ref transport) = state.transport {
+                return delegate(cmd, Self::Transport, &mut*transport.write().unwrap())
+            },
+        }
+        Ok(None)
+    }
+}
+impl<E: Engine> Command<PhrasePool<E>> for PhrasePoolCommand {
+    fn execute (self, state: &mut PhrasePool<E>) -> Perhaps<Self> {
+        use PhrasePoolCommand::*;
+        use PhraseRenameCommand as Rename;
+        use PhraseLengthCommand as Length;
+        match self {
+            Rename(Rename::Begin) => { state.begin_rename() },
+            Length(Length::Begin) => { state.begin_length() },
+            Prev        => { state.select_prev() },
+            Next        => { state.select_next() },
+            Delete      => { state.delete_selected() },
+            Append      => { state.append_new(None, None) },
+            Insert      => { state.insert_new(None, None) },
+            Duplicate   => { state.insert_dup() },
+            RandomColor => { state.randomize_color() },
+            MoveUp      => { state.move_up() },
+            MoveDown    => { state.move_down() },
+            _           => unreachable!(),
+        }
+        Ok(None)
+    }
+}
+impl<E: Engine> Command<PhrasePool<E>> for PhraseRenameCommand {
+    fn translate (self, state: &PhrasePool<E>) -> Self {
+        use PhraseRenameCommand::*;
+        if let Some(PhrasePoolMode::Rename(_, ref old_name)) = state.mode {
+            match self {
+                Backspace => {
+                    let mut new_name = old_name.clone();
+                    new_name.pop();
+                    return Self::Set(new_name)
+                },
+                Append(c) => {
+                    let mut new_name = old_name.clone();
+                    new_name.push(c);
+                    return Self::Set(new_name)
+                },
+                _ => {}
+            }
+        } else if self != Begin {
+            unreachable!()
+        }
+        self
+    }
+    fn execute (self, state: &mut PhrasePool<E>) -> Perhaps<Self> {
+        use PhraseRenameCommand::*;
+        if let Some(PhrasePoolMode::Rename(phrase, ref mut old_name)) = state.mode {
+            match self {
+                Set(s) => {
+                    state.phrases[phrase].write().unwrap().name = s.into();
+                    return Ok(Some(Self::Set(old_name.clone())))
+                },
+                Confirm => {
+                    let old_name = old_name.clone();
+                    state.mode = None;
+                    return Ok(Some(Self::Set(old_name)))
+                },
+                Cancel => {
+                    let mut phrase = state.phrases[phrase].write().unwrap();
+                    phrase.name = old_name.clone();
+                },
+                _ => unreachable!()
+            };
+            Ok(None)
+        } else if self == Begin {
+            todo!()
+        } else {
+            unreachable!()
+        }
+    }
+}
+impl<E: Engine> Command<PhrasePool<E>> for PhraseLengthCommand {
+    fn translate (self, state: &PhrasePool<E>) -> Self {
+        use PhraseLengthCommand::*;
+        if let Some(PhrasePoolMode::Length(_, length, _)) = state.mode {
+            match self {
+                Confirm => { return Self::Set(length) },
+                _ => self
+            }
+        } else if self == Begin {
+            todo!()
+        } else {
+            unreachable!()
+        }
+    }
+    fn execute (self, state: &mut PhrasePool<E>) -> Perhaps<Self> {
+        use PhraseLengthFocus::*;
+        use PhraseLengthCommand::*;
+        if let Some(PhrasePoolMode::Length(phrase, ref mut length, ref mut focus)) = state.mode {
+            match self {
+                Cancel => { state.mode = None; },
+                Prev => { focus.prev() },
+                Next => { focus.next() },
+                Inc => match focus {
+                    Bar  => { *length += 4 * PPQ },
+                    Beat => { *length += PPQ },
+                    Tick => { *length += 1 },
+                },
+                Dec => match focus {
+                    Bar  => { *length = length.saturating_sub(4 * PPQ) },
+                    Beat => { *length = length.saturating_sub(PPQ) },
+                    Tick => { *length = length.saturating_sub(1) },
+                },
+                Set(length) => {
+                    let mut phrase = state.phrases[phrase].write().unwrap();
+                    let old_length = phrase.length;
+                    phrase.length = length;
+                    state.mode = None;
+                    return Ok(Some(Self::Set(old_length)))
+                },
+                _ => unreachable!()
+            }
+            Ok(None)
+        } else if self == Begin {
+            todo!()
+        } else {
+            unreachable!()
+        }
+    }
+}
+impl<E: Engine> Command<PhraseEditor<E>> for PhraseEditorCommand {
+    fn translate (self, state: &PhraseEditor<E>) -> Self {
+        use PhraseEditorCommand::*;
+        match self {
+            GoUp    => match state.entered { true => NoteCursorInc, false => NoteScrollInc, },
+            GoDown  => match state.entered { true => NoteCursorDec, false => NoteScrollDec, },
+            GoLeft  => match state.entered { true => TimeCursorDec, false => TimeScrollDec, },
+            GoRight => match state.entered { true => TimeCursorInc, false => TimeScrollInc, },
+            _ => self
+        }
+    }
+    fn execute (self, state: &mut PhraseEditor<E>) -> Perhaps<Self> {
+        use PhraseEditorCommand::*;
+        match self.translate(state) {
+            ToggleDirection => { state.mode = !state.mode; },
+            EnterEditMode => { state.entered = true;   },
+            ExitEditMode  => { state.entered = false;  },
+            TimeZoomOut   => { state.time_zoom_out()   },
+            TimeZoomIn    => { state.time_zoom_in()    },
+            TimeCursorDec => { state.time_cursor_dec() },
+            TimeCursorInc => { state.time_cursor_inc() },
+            TimeScrollDec => { state.time_scroll_dec() },
+            TimeScrollInc => { state.time_scroll_inc() },
+            NoteCursorDec => { state.note_cursor_dec() },
+            NoteCursorInc => { state.note_cursor_inc() },
+            NoteScrollDec => { state.note_scroll_dec() },
+            NoteScrollInc => { state.note_scroll_inc() },
+            NoteLengthDec => { state.note_length_dec() },
+            NoteLengthInc => { state.note_length_inc() },
+            NotePageUp    => { state.note_page_up()    },
+            NotePageDown  => { state.note_page_down()  },
+            NoteAppend    => {
+                if state.entered {
+                    state.put();
+                    state.time_cursor_advance();
+                }
+            },
+            NoteSet       => {
+                if state.entered { state.put(); }
+            },
+            _ => unreachable!()
+        }
+        Ok(None)
+    }
+}