diff options
| author | Brooks J Rady <b.j.rady@gmail.com> | 2021-02-09 22:19:34 +0000 |
|---|---|---|
| committer | Brooks J Rady <b.j.rady@gmail.com> | 2021-02-09 22:19:34 +0000 |
| commit | 979197085617a84992b38c7fd02098965e2479d5 (patch) | |
| tree | 4136a1d4f39254e72379d1204b62ce6b1e54d144 /src/common/input | |
| parent | Work towards a functional build (diff) | |
| download | sl0ppij-979197085617a84992b38c7fd02098965e2479d5.tar.gz sl0ppij-979197085617a84992b38c7fd02098965e2479d5.tar.xz sl0ppij-979197085617a84992b38c7fd02098965e2479d5.zip | |
Well, it turns out that I spent 4 hours on something impossible...
Diffstat (limited to 'src/common/input')
| -rw-r--r-- | src/common/input/actions.rs | 47 | ||||
| -rw-r--r-- | src/common/input/handler.rs | 349 | ||||
| -rw-r--r-- | src/common/input/keybinds.rs | 143 | ||||
| -rw-r--r-- | src/common/input/mod.rs | 3 |
4 files changed, 542 insertions, 0 deletions
diff --git a/src/common/input/actions.rs b/src/common/input/actions.rs new file mode 100644 index 00000000..6f4a4521 --- /dev/null +++ b/src/common/input/actions.rs @@ -0,0 +1,47 @@ +/// This module is for defining the set of actions that can be taken in response to a keybind +/// and also passing actions back to the handler for dispatch. +use super::handler; + +#[derive(Clone)] +pub enum Direction { + Left, + Right, + Up, + Down, +} + +#[derive(Clone)] +pub enum Action { + /// Quit mosaic + Quit, + /// Write to terminal + Write(Vec<u8>), + /// Switch to the specified input mode + SwitchToMode(handler::InputMode), + TogglePersistentMode, + /// Resize focus pane in specified direction + Resize(Direction), + /// Switch focus to next pane in specified direction + SwitchFocus(Direction), + /// Move the focus pane in specified direction + MoveFocus(Direction), + /// Scroll up in focus pane + ScrollUp, + /// Scroll down in focus pane + ScrollDown, + /// Toggle focus pane between fullscreen and normal layout + ToggleFocusFullscreen, + /// Open a new pane in specified direction (relative to focus) + /// If no direction is specified, will try to use the biggest available space + NewPane(Option<Direction>), + /// Close focus pane + CloseFocus, + // Create a new tab + NewTab, + // Go to next tab + GoToNextTab, + // Go to previous tab + GoToPreviousTab, + // Close the current tab + CloseTab, +} diff --git a/src/common/input/handler.rs b/src/common/input/handler.rs new file mode 100644 index 00000000..2a1c2c72 --- /dev/null +++ b/src/common/input/handler.rs @@ -0,0 +1,349 @@ +use super::actions::Action; +use super::keybinds::get_default_keybinds; +use crate::common::{update_state, AppInstruction, AppState, SenderWithContext, OPENCALLS}; +/// Module for handling input +use crate::errors::ContextType; +use crate::os_input_output::OsApi; +use crate::pty_bus::PtyInstruction; +use crate::screen::ScreenInstruction; +use crate::wasm_vm::PluginInstruction; +use crate::CommandIsExecuting; + +use serde::{Deserialize, Serialize}; +use strum_macros::EnumIter; +use termion::input::TermReadEventsAndRaw; + +use super::keybinds::key_to_action; + +struct InputHandler { + mode: InputMode, + mode_is_persistent: bool, + os_input: Box<dyn OsApi>, + command_is_executing: CommandIsExecuting, + send_screen_instructions: SenderWithContext<ScreenInstruction>, + send_pty_instructions: SenderWithContext<PtyInstruction>, + send_plugin_instructions: SenderWithContext<PluginInstruction>, + send_app_instructions: SenderWithContext<AppInstruction>, +} + +impl InputHandler { + fn new( + os_input: Box<dyn OsApi>, + command_is_executing: CommandIsExecuting, + send_screen_instructions: SenderWithContext<ScreenInstruction>, + send_pty_instructions: SenderWithContext<PtyInstruction>, + send_plugin_instructions: SenderWithContext<PluginInstruction>, + send_app_instructions: SenderWithContext<AppInstruction>, + ) -> Self { + InputHandler { + mode: InputMode::Normal, + mode_is_persistent: false, + os_input, + command_is_executing, + send_screen_instructions, + send_pty_instructions, + send_plugin_instructions, + send_app_instructions, + } + } + + /// Main event loop + fn get_input(&mut self) { + let mut err_ctx = OPENCALLS.with(|ctx| *ctx.borrow()); + err_ctx.add_call(ContextType::StdinHandler); + self.send_pty_instructions.update(err_ctx); + self.send_app_instructions.update(err_ctx); + self.send_screen_instructions.update(err_ctx); + if let Ok(keybinds) = get_default_keybinds() { + 'input_loop: loop { + let entry_mode = self.mode; + //@@@ I think this should actually just iterate over stdin directly + let stdin_buffer = self.os_input.read_from_stdin(); + drop( + self.send_plugin_instructions + .send(PluginInstruction::GlobalInput(stdin_buffer.clone())), + ); + for key_result in stdin_buffer.events_and_raw() { + match key_result { + Ok((event, raw_bytes)) => match event { + termion::event::Event::Key(key) => { + let should_break = self.dispatch_action(key_to_action( + &key, raw_bytes, &self.mode, &keybinds, + )); + //@@@ This is a hack until we dispatch more than one action per key stroke + if entry_mode == self.mode && !self.mode_is_persistent { + self.mode = InputMode::Normal; + update_state(&self.send_app_instructions, |_| AppState { + input_state: InputState { + mode: self.mode, + persistent: self.mode_is_persistent, + }, + }); + } + if should_break { + break 'input_loop; + } + } + termion::event::Event::Mouse(_) + | termion::event::Event::Unsupported(_) => { + unimplemented!("Mouse and unsupported events aren't supported!"); + } + }, + Err(err) => panic!("Encountered read error: {:?}", err), + } + } + } + } else { + //@@@ Error handling? + self.exit(); + } + } + + fn dispatch_action(&mut self, action: Action) -> bool { + let mut interrupt_loop = false; + + match action { + Action::Write(val) => { + self.send_screen_instructions + .send(ScreenInstruction::ClearScroll) + .unwrap(); + self.send_screen_instructions + .send(ScreenInstruction::WriteCharacter(val)) + .unwrap(); + } + Action::Quit => { + self.exit(); + interrupt_loop = true; + } + Action::SwitchToMode(mode) => { + self.mode = mode; + if mode == InputMode::Normal { + self.mode_is_persistent = false; + } + update_state(&self.send_app_instructions, |_| AppState { + input_state: InputState { + mode: self.mode, + persistent: self.mode_is_persistent, + }, + }); + self.send_screen_instructions + .send(ScreenInstruction::Render) + .unwrap(); + } + Action::TogglePersistentMode => { + self.mode_is_persistent = !self.mode_is_persistent; + update_state(&self.send_app_instructions, |_| AppState { + input_state: InputState { + mode: self.mode, + persistent: self.mode_is_persistent, + }, + }); + } + Action::Resize(direction) => { + let screen_instr = match direction { + super::actions::Direction::Left => ScreenInstruction::ResizeLeft, + super::actions::Direction::Right => ScreenInstruction::ResizeRight, + super::actions::Direction::Up => ScreenInstruction::ResizeUp, + super::actions::Direction::Down => ScreenInstruction::ResizeDown, + }; + self.send_screen_instructions.send(screen_instr).unwrap(); + } + Action::SwitchFocus(_) => { + self.send_screen_instructions + .send(ScreenInstruction::MoveFocus) + .unwrap(); + } + Action::MoveFocus(direction) => { + let screen_instr = match direction { + super::actions::Direction::Left => ScreenInstruction::MoveFocusLeft, + super::actions::Direction::Right => ScreenInstruction::MoveFocusRight, + super::actions::Direction::Up => ScreenInstruction::MoveFocusUp, + super::actions::Direction::Down => ScreenInstruction::MoveFocusDown, + }; + self.send_screen_instructions.send(screen_instr).unwrap(); + } + Action::ScrollUp => { + self.send_screen_instructions + .send(ScreenInstruction::ScrollUp) + .unwrap(); + } + Action::ScrollDown => { + self.send_screen_instructions + .send(ScreenInstruction::ScrollDown) + .unwrap(); + } + Action::ToggleFocusFullscreen => { + self.send_screen_instructions + .send(ScreenInstruction::ToggleActiveTerminalFullscreen) + .unwrap(); + } + Action::NewPane(direction) => { + let pty_instr = match direction { + Some(super::actions::Direction::Left) => { + PtyInstruction::SpawnTerminalVertically(None) + } + Some(super::actions::Direction::Right) => { + PtyInstruction::SpawnTerminalVertically(None) + } + Some(super::actions::Direction::Up) => { + PtyInstruction::SpawnTerminalHorizontally(None) + } + Some(super::actions::Direction::Down) => { + PtyInstruction::SpawnTerminalHorizontally(None) + } + // No direction specified - try to put it in the biggest available spot + None => PtyInstruction::SpawnTerminal(None), + }; + self.command_is_executing.opening_new_pane(); + self.send_pty_instructions.send(pty_instr).unwrap(); + self.command_is_executing.wait_until_new_pane_is_opened(); + } + Action::CloseFocus => { + self.command_is_executing.closing_pane(); + self.send_screen_instructions + .send(ScreenInstruction::CloseFocusedPane) + .unwrap(); + self.command_is_executing.wait_until_pane_is_closed(); + } + Action::NewTab => { + self.command_is_executing.opening_new_pane(); + self.send_pty_instructions + .send(PtyInstruction::NewTab) + .unwrap(); + self.command_is_executing.wait_until_new_pane_is_opened(); + } + Action::GoToNextTab => { + self.send_screen_instructions + .send(ScreenInstruction::SwitchTabNext) + .unwrap(); + } + Action::GoToPreviousTab => { + self.send_screen_instructions + .send(ScreenInstruction::SwitchTabPrev) + .unwrap(); + } + Action::CloseTab => { + self.command_is_executing.closing_pane(); + self.send_screen_instructions + .send(ScreenInstruction::CloseTab) + .unwrap(); + self.command_is_executing.wait_until_pane_is_closed(); + } + } + + interrupt_loop + } + + /// Routine to be called when the input handler exits (at the moment this is the + /// same as quitting mosaic) + fn exit(&mut self) { + self.send_app_instructions + .send(AppInstruction::Exit) + .unwrap(); + } +} + +#[derive(Debug, PartialEq, Eq, Hash, Copy, Clone, Serialize, Deserialize)] +pub struct InputState { + mode: InputMode, + persistent: bool, +} + +impl Default for InputState { + fn default() -> InputState { + InputState { + mode: InputMode::Normal, + persistent: false, + } + } +} + +/// Dictates whether we're in command mode, persistent command mode, normal mode or exiting: +/// - Normal mode either writes characters to the terminal, or switches to command mode +/// using a particular key control +/// - Command mode intercepts characters to control mosaic itself, before switching immediately +/// back to normal mode +/// - Persistent command mode is the same as command mode, but doesn't return automatically to +/// normal mode +#[derive(Debug, PartialEq, Eq, Hash, Copy, Clone, EnumIter, Serialize, Deserialize)] +pub enum InputMode { + Normal, + Command, + Resize, + Pane, + Tab, + Scroll, + Exiting, +} + +#[derive(Default, Debug, Clone, Serialize, Deserialize)] +pub struct Help { + pub mode: InputMode, + pub mode_is_persistent: bool, + pub keybinds: Vec<(String, String)>, // <shortcut> => <shortcut description> +} + +impl Default for InputMode { + fn default() -> InputMode { + InputMode::Normal + } +} + +pub fn get_help(input_state: &InputState) -> Help { + let mut keybinds: Vec<(String, String)> = vec![]; + match input_state.mode { + InputMode::Normal | InputMode::Command | InputMode::Exiting => { + keybinds.push((format!("p"), format!("Pane mode"))); + keybinds.push((format!("t"), format!("Tab mode"))); + keybinds.push((format!("r"), format!("Resize mode"))); + } + InputMode::Resize => { + keybinds.push((format!("←↓↑→"), format!("resize pane"))); + } + InputMode::Pane => { + keybinds.push((format!("←↓↑→"), format!("move focus"))); + keybinds.push((format!("p"), format!("next pane"))); + keybinds.push((format!("n"), format!("new pane"))); + keybinds.push((format!("d"), format!("down split"))); + keybinds.push((format!("r"), format!("right split"))); + keybinds.push((format!("x"), format!("exit pane"))); + keybinds.push((format!("f"), format!("fullscreen pane"))); + } + InputMode::Tab => { + keybinds.push((format!("←↓↑→"), format!("move tab focus"))); + keybinds.push((format!("n"), format!("new tab"))); + keybinds.push((format!("x"), format!("exit tab"))); + } + InputMode::Scroll => { + keybinds.push((format!("↓↑"), format!("scroll up/down"))); + } + } + keybinds.push((format!("ESC"), format!("Back"))); + keybinds.push((format!("q"), format!("Quit"))); + Help { + mode: input_state.mode, + mode_is_persistent: input_state.persistent, + keybinds, + } +} + +/// Entry point to the module that instantiates a new InputHandler and calls its +/// reading loop +pub fn input_loop( + os_input: Box<dyn OsApi>, + command_is_executing: CommandIsExecuting, + send_screen_instructions: SenderWithContext<ScreenInstruction>, + send_pty_instructions: SenderWithContext<PtyInstruction>, + send_plugin_instructions: SenderWithContext<PluginInstruction>, + send_app_instructions: SenderWithContext<AppInstruction>, +) { + let _handler = InputHandler::new( + os_input, + command_is_executing, + send_screen_instructions, + send_pty_instructions, + send_plugin_instructions, + send_app_instructions, + ) + .get_input(); +} diff --git a/src/common/input/keybinds.rs b/src/common/input/keybinds.rs new file mode 100644 index 00000000..d6ace68d --- /dev/null +++ b/src/common/input/keybinds.rs @@ -0,0 +1,143 @@ +// This module is for mapping particular input keys to their corresponding actions. + +use super::actions::{Action, Direction}; +use super::handler::InputMode; + +use std::collections::HashMap; + +use strum::IntoEnumIterator; +use termion::event::Key; + +type Keybinds = HashMap<InputMode, ModeKeybinds>; +type ModeKeybinds = HashMap<Key, Action>; + +/// Populate the default hashmap of keybinds +/// @@@khs26 What about an input config file? +pub fn get_default_keybinds() -> Result<Keybinds, String> { + let mut defaults = Keybinds::new(); + + for mode in InputMode::iter() { + defaults.insert(mode, get_defaults_for_mode(&mode)?); + } + + Ok(defaults) +} + +fn get_defaults_for_mode(mode: &InputMode) -> Result<ModeKeybinds, String> { + let mut defaults = ModeKeybinds::new(); + + match *mode { + InputMode::Normal => { + defaults.insert(Key::Ctrl('g'), Action::SwitchToMode(InputMode::Command)); + } + InputMode::Command => { + defaults.insert(Key::Char('r'), Action::SwitchToMode(InputMode::Resize)); + defaults.insert(Key::Char('p'), Action::SwitchToMode(InputMode::Pane)); + defaults.insert(Key::Char('t'), Action::SwitchToMode(InputMode::Tab)); + defaults.insert(Key::Char('s'), Action::SwitchToMode(InputMode::Scroll)); + defaults.insert(Key::Ctrl('g'), Action::TogglePersistentMode); + defaults.insert(Key::Esc, Action::SwitchToMode(InputMode::Normal)); + defaults.insert(Key::Char('q'), Action::Quit); + } + InputMode::Resize => { + defaults.insert(Key::Char('h'), Action::Resize(Direction::Left)); + defaults.insert(Key::Char('j'), Action::Resize(Direction::Down)); + defaults.insert(Key::Char('k'), Action::Resize(Direction::Up)); + defaults.insert(Key::Char('l'), Action::Resize(Direction::Right)); + + defaults.insert(Key::Left, Action::Resize(Direction::Left)); + defaults.insert(Key::Down, Action::Resize(Direction::Down)); + defaults.insert(Key::Up, Action::Resize(Direction::Up)); + defaults.insert(Key::Right, Action::Resize(Direction::Right)); + + defaults.insert(Key::Ctrl('b'), Action::Resize(Direction::Left)); + defaults.insert(Key::Ctrl('n'), Action::Resize(Direction::Down)); + defaults.insert(Key::Ctrl('p'), Action::Resize(Direction::Up)); + defaults.insert(Key::Ctrl('f'), Action::Resize(Direction::Right)); + + defaults.insert(Key::Char('q'), Action::Quit); + defaults.insert(Key::Ctrl('g'), Action::TogglePersistentMode); + defaults.insert(Key::Esc, Action::SwitchToMode(InputMode::Normal)); + } + InputMode::Pane => { + defaults.insert(Key::Char('h'), Action::MoveFocus(Direction::Left)); + defaults.insert(Key::Char('j'), Action::MoveFocus(Direction::Down)); + defaults.insert(Key::Char('k'), Action::MoveFocus(Direction::Up)); + defaults.insert(Key::Char('l'), Action::MoveFocus(Direction::Right)); + + defaults.insert(Key::Left, Action::MoveFocus(Direction::Left)); + defaults.insert(Key::Down, Action::MoveFocus(Direction::Down)); + defaults.insert(Key::Up, Action::MoveFocus(Direction::Up)); + defaults.insert(Key::Right, Action::MoveFocus(Direction::Right)); + + defaults.insert(Key::Ctrl('b'), Action::MoveFocus(Direction::Left)); + defaults.insert(Key::Ctrl('n'), Action::MoveFocus(Direction::Down)); + defaults.insert(Key::Ctrl('p'), Action::MoveFocus(Direction::Up)); + defaults.insert(Key::Ctrl('f'), Action::MoveFocus(Direction::Right)); + + defaults.insert(Key::Char('p'), Action::SwitchFocus(Direction::Right)); + defaults.insert(Key::Char('n'), Action::NewPane(None)); + defaults.insert(Key::Char('d'), Action::NewPane(Some(Direction::Down))); + defaults.insert(Key::Char('r'), Action::NewPane(Some(Direction::Right))); + defaults.insert(Key::Char('x'), Action::CloseFocus); + + defaults.insert(Key::Char('f'), Action::ToggleFocusFullscreen); + + defaults.insert(Key::Char('q'), Action::Quit); + defaults.insert(Key::Ctrl('g'), Action::TogglePersistentMode); + defaults.insert(Key::Esc, Action::SwitchToMode(InputMode::Normal)); + } + InputMode::Tab => { + defaults.insert(Key::Char('h'), Action::GoToPreviousTab); + defaults.insert(Key::Char('j'), Action::GoToNextTab); + defaults.insert(Key::Char('k'), Action::GoToPreviousTab); + defaults.insert(Key::Char('l'), Action::GoToNextTab); + + defaults.insert(Key::Left, Action::GoToPreviousTab); + defaults.insert(Key::Down, Action::GoToNextTab); + defaults.insert(Key::Up, Action::GoToPreviousTab); + defaults.insert(Key::Right, Action::GoToNextTab); + + defaults.insert(Key::Ctrl('b'), Action::GoToPreviousTab); + defaults.insert(Key::Ctrl('n'), Action::GoToNextTab); + defaults.insert(Key::Ctrl('p'), Action::GoToPreviousTab); + defaults.insert(Key::Ctrl('f'), Action::GoToNextTab); + + defaults.insert(Key::Char('n'), Action::NewTab); + defaults.insert(Key::Char('x'), Action::CloseTab); + + defaults.insert(Key::Char('q'), Action::Quit); + defaults.insert(Key::Ctrl('g'), Action::TogglePersistentMode); + defaults.insert(Key::Esc, Action::SwitchToMode(InputMode::Normal)); + } + InputMode::Scroll => { + defaults.insert(Key::Char('j'), Action::ScrollDown); + defaults.insert(Key::Char('k'), Action::ScrollUp); + + defaults.insert(Key::Down, Action::ScrollDown); + defaults.insert(Key::Up, Action::ScrollUp); + + defaults.insert(Key::Ctrl('n'), Action::ScrollDown); + defaults.insert(Key::Ctrl('p'), Action::ScrollUp); + + defaults.insert(Key::Char('q'), Action::Quit); + defaults.insert(Key::Ctrl('g'), Action::TogglePersistentMode); + defaults.insert(Key::Esc, Action::SwitchToMode(InputMode::Normal)); + } + InputMode::Exiting => {} + } + + Ok(defaults) +} + +pub fn key_to_action(key: &Key, input: Vec<u8>, mode: &InputMode, keybinds: &Keybinds) -> Action { + if let Some(mode_keybinds) = keybinds.get(mode) { + mode_keybinds + .get(key) + .cloned() + .unwrap_or(Action::Write(input)) + } else { + // Unrecognized mode - panic? + panic!("Unrecognized mode: {:?}", mode); + } +} diff --git a/src/common/input/mod.rs b/src/common/input/mod.rs new file mode 100644 index 00000000..094054e8 --- /dev/null +++ b/src/common/input/mod.rs @@ -0,0 +1,3 @@ +pub mod actions; +pub mod handler; +pub mod keybinds; |
