tek/crates/tek_sequencer/src/sequencer_cmd.rs

use crate::*;
/// Handle top-level events in standalone sequencer.
impl Handle<Tui> for Sequencer<Tui> {
    fn handle (&mut self, from: &TuiInput) -> Perhaps<bool> {
        if !match self.focused() {
            SequencerFocus::Transport    => self.transport.handle(from)?,
            SequencerFocus::PhrasePool   => self.phrases.handle(from)?,
            SequencerFocus::PhraseEditor => self.editor.handle(from)?
        }.unwrap_or(false) {
            match from.event() {
                // Tab navigation
                key!(KeyCode::Tab)           => { self.focus_next();  },
                key!(Shift-KeyCode::Tab)     => { self.focus_prev();  },
                key!(KeyCode::BackTab)       => { self.focus_prev();  },
                key!(Shift-KeyCode::BackTab) => { self.focus_prev();  },
                // Directional navigation
                key!(KeyCode::Up)            => { self.focus_up();    },
                key!(KeyCode::Down)          => { self.focus_down();  },
                key!(KeyCode::Left)          => { self.focus_left();  },
                key!(KeyCode::Right)         => { self.focus_right(); },
                // Global play/pause binding
                key!(KeyCode::Char(' ')) => match self.transport {
                    Some(ref mut transport) => { transport.write().unwrap().toggle_play()?; },
                    None => { return Ok(None) }
                },
                _ => {}
            }
        };
        Ok(Some(true))
    }
}
impl Handle<Tui> for PhrasePool<Tui> {
    fn handle (&mut self, from: &TuiInput) -> Perhaps<bool> {
        match self.mode {
            Some(PhrasePoolMode::Rename(phrase, ref mut old_name)) => {
                let mut phrase = self.phrases[phrase].write().unwrap();
                match from.event() {
                    key!(KeyCode::Backspace)     => { phrase.name.pop(); },
                    key!(KeyCode::Char(c))       => { phrase.name.push(*c); },
                    key!(Shift-KeyCode::Char(c)) => { phrase.name.push(*c); },
                    key!(KeyCode::Esc)   => { phrase.name = old_name.clone(); self.mode = None; },
                    key!(KeyCode::Enter) => { self.mode = None; },
                    _ => return Ok(Some(true))
                }
            },
            Some(PhrasePoolMode::Length(phrase, ref mut length, ref mut focus)) => {
                match from.event() {
                    key!(KeyCode::Left)  => { focus.prev() },
                    key!(KeyCode::Right) => { focus.next() },
                    key!(KeyCode::Esc)   => { self.mode = None; },
                    key!(KeyCode::Enter) => {
                        self.phrases[phrase].write().unwrap().length = *length;
                        self.mode = None;
                    },
                    key!(KeyCode::Up)    => match focus {
                        PhraseLengthFocus::Bar  => { *length += 4 * PPQ },
                        PhraseLengthFocus::Beat => { *length += PPQ },
                        PhraseLengthFocus::Tick => { *length += 1 },
                    },
                    key!(KeyCode::Down)  => match focus {
                        PhraseLengthFocus::Bar  => { *length = length.saturating_sub(4 * PPQ) },
                        PhraseLengthFocus::Beat => { *length = length.saturating_sub(PPQ) },
                        PhraseLengthFocus::Tick => { *length = length.saturating_sub(1) },
                    },
                    _ => return Ok(Some(true))
                }
            },
            None => match from.event() {
                key!(KeyCode::Up)        => { self.select_prev() },
                key!(KeyCode::Down)      => { self.select_next() },
                key!(KeyCode::Char('a')) => { self.append_new(None, None) },
                key!(KeyCode::Char('i')) => { self.insert_new(None, None) },
                key!(KeyCode::Char('d')) => { self.insert_dup() },
                key!(KeyCode::Char('c')) => { self.randomize_color() },
                key!(KeyCode::Char('n')) => { self.begin_rename() },
                key!(KeyCode::Char('t')) => { self.begin_length() },
                key!(KeyCode::Char(',')) => { self.move_up() },
                key!(KeyCode::Char('.')) => { self.move_down() },
                _ => return Ok(None),
            }
        }

        return Ok(Some(true))
    }
}
impl Handle<Tui> for PhraseEditor<Tui> {
    fn handle (&mut self, from: &TuiInput) -> Perhaps<bool> {
        match from.event() {
            key!(KeyCode::Char('`')) => { self.mode = !self.mode; },
            key!(KeyCode::Enter)     => { self.entered = true;    },
            key!(KeyCode::Esc)       => { self.entered = false;   },

            key!(KeyCode::Up) => match self.entered {
                true  => { self.note_axis.point_dec(); },
                false => { self.note_axis.start_dec(); },
            },
            key!(KeyCode::Down) => match self.entered {
                true  => { self.note_axis.point_inc(); },
                false => { self.note_axis.start_inc(); },
            },
            key!(KeyCode::Left) => match self.entered {
                true  => { self.time_axis.point_dec(); },
                false => { self.time_axis.start_dec(); },
            },
            key!(KeyCode::Right) => match self.entered {
                true  => { self.time_axis.point_inc(); },
                false => { self.time_axis.start_inc(); },
            },
            key!(KeyCode::Char(',')) => match self.entered {
                true  => {},
                false => {},
            },
            key!(KeyCode::Char('.')) => match self.entered {
                true  => {},
                false => {},
            },
            key!(KeyCode::Char('a')) => if self.entered {
                self.put();
                self.time_axis.point = self.time_axis.point.map(|time|time + self.note_len);
            },
            key!(KeyCode::Char('s')) => if self.entered {
                self.put();
            },

            _ => { return Ok(None) }
        }
        return Ok(Some(true))
    }
}