Moving the sync command to the Tab mode (#412)

* Moving the sync command to the Tab mode

* Fixing bug related to plugin panes and sync mode

When sync mode was enabled the input from a plugin pane was being
incorrectly ignored.

assets/config/default.yaml

@@ -97,8 +97,6 @@ keybinds:
           key: [Char: 'r',]
         - action: [CloseFocus,]
           key: [Char: 'x',]
-        - action: [ToggleActiveSyncPanes]
-          key: [Char: 's']
         - action: [ToggleFocusFullscreen,]
           key: [Char: 'f',]
         - action: [FocusPreviousPane,]
@@ -130,6 +128,8 @@ keybinds:
           key: [ Char: 'n',]
         - action: [CloseTab,]
           key: [ Char: 'x',]
+        - action: [ToggleActiveSyncTab]
+          key: [Char: 's']
         - action: [MoveFocus: Left,]
           key: [ Alt: 'h',]
         - action: [MoveFocus: Right,]

src/client/tab.rs

@@ -607,23 +607,17 @@ impl Tab {
     }
     pub fn write_to_terminals_on_current_tab(&mut self, input_bytes: Vec<u8>) {
         let pane_ids = self.get_pane_ids();
-        pane_ids.iter().for_each(|pane_id| match pane_id {
-            PaneId::Terminal(pid) => {
-                self.write_to_pane_id(input_bytes.clone(), *pid);
-            }
-            PaneId::Plugin(_) => {}
+        pane_ids.iter().for_each(|&pane_id| {
+            self.write_to_pane_id(input_bytes.clone(), pane_id);
         });
     }
-    pub fn write_to_pane_id(&mut self, mut input_bytes: Vec<u8>, pid: RawFd) {
-        self.os_api
-            .write_to_tty_stdin(pid, &mut input_bytes)
-            .expect("failed to write to terminal");
-        self.os_api.tcdrain(pid).expect("failed to drain terminal");
-    }
     pub fn write_to_active_terminal(&mut self, input_bytes: Vec<u8>) {
-        match self.get_active_pane_id() {
-            Some(PaneId::Terminal(active_terminal_id)) => {
-                let active_terminal = self.get_active_pane().unwrap();
+        self.write_to_pane_id(input_bytes, self.get_active_pane_id().unwrap());
+    }
+    pub fn write_to_pane_id(&mut self, input_bytes: Vec<u8>, pane_id: PaneId) {
+        match pane_id {
+            PaneId::Terminal(active_terminal_id) => {
+                let active_terminal = self.panes.get(&pane_id).unwrap();
                 let mut adjusted_input = active_terminal.adjust_input_to_terminal(input_bytes);
                 self.os_api
                     .write_to_tty_stdin(active_terminal_id, &mut adjusted_input)
@@ -632,14 +626,13 @@ impl Tab {
                     .tcdrain(active_terminal_id)
                     .expect("failed to drain terminal");
             }
-            Some(PaneId::Plugin(pid)) => {
+            PaneId::Plugin(pid) => {
                 for key in parse_keys(&input_bytes) {
                     self.send_plugin_instructions
                         .send(PluginInstruction::Update(Some(pid), Event::KeyPress(key)))
                         .unwrap()
                 }
             }
-            _ => {}
         }
     }
     pub fn get_active_terminal_cursor_position(&self) -> Option<(usize, usize)> {
@@ -713,7 +706,7 @@ impl Tab {
     pub fn is_sync_panes_active(&self) -> bool {
         self.synchronize_is_active
     }
-    pub fn toggle_sync_panes_is_active(&mut self) {
+    pub fn toggle_sync_tab_is_active(&mut self) {
         self.synchronize_is_active = !self.synchronize_is_active;
     }
     pub fn panes_contain_widechar(&self) -> bool {

src/common/errors.rs

@@ -200,7 +200,7 @@ pub enum ScreenContext {
     PageScrollDown,
     ClearScroll,
     CloseFocusedPane,
-    ToggleActiveSyncPanes,
+    ToggleActiveSyncTab,
     ToggleActiveTerminalFullscreen,
     SetSelectable,
     SetInvisibleBorders,
@@ -261,7 +261,7 @@ impl From<&ScreenInstruction> for ScreenContext {
             ScreenInstruction::UpdateTabName(_) => ScreenContext::UpdateTabName,
             ScreenInstruction::TerminalResize(_) => ScreenContext::TerminalResize,
             ScreenInstruction::ChangeMode(_) => ScreenContext::ChangeMode,
-            ScreenInstruction::ToggleActiveSyncPanes => ScreenContext::ToggleActiveSyncPanes,
+            ScreenInstruction::ToggleActiveSyncTab => ScreenContext::ToggleActiveSyncTab,
         }
     }
 }

src/common/input/actions.rs

@@ -39,8 +39,8 @@ pub enum Action {
     PageScrollDown,
     /// Toggle between fullscreen focus pane and normal layout.
     ToggleFocusFullscreen,
-    /// Toggle between sending text commands to all panes and normal mode.
-    ToggleActiveSyncPanes,
+    /// Toggle between sending text commands to all panes on the current tab and normal mode.
+    ToggleActiveSyncTab,
     /// Open a new pane in the specified direction (relative to focus).
     /// If no direction is specified, will try to use the biggest available space.
     NewPane(Option<Direction>),

src/common/input/handler.rs

@@ -160,14 +160,14 @@ pub fn get_mode_info(mode: InputMode, palette: Palette) -> ModeInfo {
             keybinds.push(("d".to_string(), "Down split".to_string()));
             keybinds.push(("r".to_string(), "Right split".to_string()));
             keybinds.push(("x".to_string(), "Close".to_string()));
-            keybinds.push(("s".to_string(), "Sync".to_string()));
             keybinds.push(("f".to_string(), "Fullscreen".to_string()));
         }
         InputMode::Tab => {
             keybinds.push(("←↓↑→".to_string(), "Move focus".to_string()));
             keybinds.push(("n".to_string(), "New".to_string()));
             keybinds.push(("x".to_string(), "Close".to_string()));
             keybinds.push(("r".to_string(), "Rename".to_string()));
+            keybinds.push(("s".to_string(), "Sync".to_string()));
         }
         InputMode::Scroll => {
             keybinds.push(("↓↑".to_string(), "Scroll".to_string()));

src/common/screen.rs

@@ -52,7 +52,7 @@ pub enum ScreenInstruction {
     NewTab(RawFd),
     SwitchTabNext,
     SwitchTabPrev,
-    ToggleActiveSyncPanes,
+    ToggleActiveSyncTab,
     CloseTab,
     GoToTab(u32),
     UpdateTabName(Vec<u8>),

src/server/mod.rs

@@ -528,11 +528,11 @@ fn init_session(
                         ScreenInstruction::ChangeMode(mode_info) => {
                             screen.change_mode(mode_info);
                         }
-                        ScreenInstruction::ToggleActiveSyncPanes => {
+                        ScreenInstruction::ToggleActiveSyncTab => {
                             screen
                                 .get_active_tab_mut()
                                 .unwrap()
-                                .toggle_sync_panes_is_active();
+                                .toggle_sync_tab_is_active();
                             screen.update_tabs();
                         }
                         ScreenInstruction::Exit => {
@@ -781,10 +781,10 @@ fn route_action(action: Action, session: &SessionMetaData, os_input: &dyn Server
                 .send(ScreenInstruction::SwitchTabPrev)
                 .unwrap();
         }
-        Action::ToggleActiveSyncPanes => {
+        Action::ToggleActiveSyncTab => {
             session
                 .send_screen_instructions
-                .send(ScreenInstruction::ToggleActiveSyncPanes)
+                .send(ScreenInstruction::ToggleActiveSyncTab)
                 .unwrap();
         }
         Action::CloseTab => {