wip: refactor pt.16: 58 errors

crates/tek_tui/src/tui_pool_length.rs

@@ -1,5 +1,82 @@
 use crate::*;
 
+#[derive(Clone, PartialEq)]
+pub enum PhraseLengthCommand {
+    Begin,
+    Next,
+    Prev,
+    Inc,
+    Dec,
+    Set(usize),
+    Cancel,
+}
+
+impl InputToCommand<Tui, PhrasePoolView<Tui>> for PhraseLengthCommand {
+    fn input_to_command (view: &PhrasePoolView<Tui>, from: &TuiInput) -> Option<Self> {
+        if let Some(PhrasePoolMode::Length(_, length, _)) = view.mode {
+            Some(match from.event() {
+                key!(KeyCode::Up)    => Self::Inc,
+                key!(KeyCode::Down)  => Self::Dec,
+                key!(KeyCode::Right) => Self::Next,
+                key!(KeyCode::Left)  => Self::Prev,
+                key!(KeyCode::Enter) => Self::Set(length),
+                key!(KeyCode::Esc)   => Self::Cancel,
+                _ => return None
+            })
+        } else {
+            unreachable!()
+        }
+    }
+}
+
+impl<E: Engine> Command<PhrasePoolView<E>> for PhraseLengthCommand {
+    fn execute (self, view: &mut PhrasePoolView<E>) -> Perhaps<Self> {
+        use PhraseLengthFocus::*;
+        use PhraseLengthCommand::*;
+        if let Some(PhrasePoolMode::Length(phrase, ref mut length, ref mut focus)) = view.mode {
+            match self {
+                Self::Cancel => {
+                    view.mode = None;
+                },
+                Self::Prev => {
+                    focus.prev()
+                },
+                Self::Next => {
+                    focus.next()
+                },
+                Self::Inc => match focus {
+                    Bar  => { *length += 4 * PPQ },
+                    Beat => { *length += PPQ },
+                    Tick => { *length += 1 },
+                },
+                Self::Dec => match focus {
+                    Bar  => { *length = length.saturating_sub(4 * PPQ) },
+                    Beat => { *length = length.saturating_sub(PPQ) },
+                    Tick => { *length = length.saturating_sub(1) },
+                },
+                Self::Set(length) => {
+                    let mut phrase = view.model.phrases[phrase].write().unwrap();
+                    let old_length = phrase.length;
+                    phrase.length = length;
+                    view.mode = None;
+                    return Ok(Some(Self::Set(old_length)))
+                },
+                _ => unreachable!()
+            }
+            Ok(None)
+        } else if self == Begin {
+            view.mode = Some(PhrasePoolMode::Length(
+                view.phrase,
+                view.model.phrases[view.phrase].read().unwrap().length,
+                PhraseLengthFocus::Bar
+            ));
+            Ok(None)
+        } else {
+            unreachable!()
+        }
+    }
+}
+
 /// Displays and edits phrase length.
 pub struct PhraseLength<E: Engine> {
     _engine: PhantomData<E>,
@@ -98,79 +175,3 @@ impl PhraseLengthFocus {
         }
     }
 }
-
-#[derive(Clone, PartialEq)]
-pub enum PhraseLengthCommand {
-    Begin,
-    Next,
-    Prev,
-    Inc,
-    Dec,
-    Set(usize),
-    Confirm,
-    Cancel,
-}
-
-impl InputToCommand<Tui, PhrasePoolView<Tui>> for PhraseLengthCommand {
-    fn input_to_command (_: &PhrasePoolView<Tui>, from: &TuiInput) -> Option<Self> {
-        match from.event() {
-            key!(KeyCode::Up)    => Some(Self::Inc),
-            key!(KeyCode::Down)  => Some(Self::Dec),
-            key!(KeyCode::Right) => Some(Self::Next),
-            key!(KeyCode::Left)  => Some(Self::Prev),
-            key!(KeyCode::Enter) => Some(Self::Confirm),
-            key!(KeyCode::Esc)   => Some(Self::Cancel),
-            _ => None
-        }
-    }
-}
-
-impl<E: Engine> Command<PhrasePoolView<E>> for PhraseLengthCommand {
-    fn translate (self, state: &PhrasePoolView<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 PhrasePoolView<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!()
-        }
-    }
-}

crates/tek_tui/src/tui_pool_rename.rs

@@ -3,53 +3,42 @@ use crate::*;
 #[derive(Clone, PartialEq)]
 pub enum PhraseRenameCommand {
     Begin,
-    Backspace,
-    Append(char),
     Set(String),
     Confirm,
     Cancel,
 }
 
 impl InputToCommand<Tui, PhrasePoolView<Tui>> for PhraseRenameCommand {
-    fn input_to_command (_: &PhrasePoolView<Tui>, from: &TuiInput) -> Option<Self> {
-        match from.event() {
-            key!(KeyCode::Backspace) => Some(Self::Backspace),
-            key!(KeyCode::Enter)     => Some(Self::Confirm),
-            key!(KeyCode::Esc)       => Some(Self::Cancel),
-            key!(KeyCode::Char(c))   => Some(Self::Append(*c)),
-            _ => None
+    fn input_to_command (view: &PhrasePoolView<Tui>, from: &TuiInput) -> Option<Self> {
+        if let Some(PhrasePoolMode::Rename(_, ref old_name)) = view.mode {
+            Some(match from.event() {
+                key!(KeyCode::Char(c))   => {
+                    let mut new_name = old_name.clone();
+                    new_name.push(*c);
+                    Self::Set(new_name)
+                },
+                key!(KeyCode::Backspace) => {
+                    let mut new_name = old_name.clone();
+                    new_name.pop();
+                    Self::Set(new_name)
+                },
+                key!(KeyCode::Enter)     => Self::Confirm,
+                key!(KeyCode::Esc)       => Self::Cancel,
+                _ => return None
+            })
+        } else {
+            unreachable!()
         }
     }
 }
 
 impl<E: Engine> Command<PhrasePoolView<E>> for PhraseRenameCommand {
-    fn translate (self, state: &PhrasePoolView<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 PhrasePoolView<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();
+                    state.model.phrases[phrase].write().unwrap().name = s.into();
                     return Ok(Some(Self::Set(old_name.clone())))
                 },
                 Confirm => {
@@ -58,14 +47,18 @@ impl<E: Engine> Command<PhrasePoolView<E>> for PhraseRenameCommand {
                     return Ok(Some(Self::Set(old_name)))
                 },
                 Cancel => {
-                    let mut phrase = state.phrases[phrase].write().unwrap();
+                    let mut phrase = state.model.phrases[phrase].write().unwrap();
                     phrase.name = old_name.clone();
                 },
                 _ => unreachable!()
             };
             Ok(None)
         } else if self == Begin {
-            todo!()
+            state.mode = Some(PhrasePoolMode::Rename(
+                state.phrase,
+                state.model.phrases[state.phrase].read().unwrap().name.clone()
+            ));
+            Ok(None)
         } else {
             unreachable!()
         }