Indicate to the user when text is copied to the clipboard

default-plugins/status-bar/src/main.rs

@@ -8,7 +8,7 @@ use zellij_tile::prelude::*;
 use zellij_tile_utils::style;
 
 use first_line::{ctrl_keys, superkey};
-use second_line::keybinds;
+use second_line::{keybinds, text_copied_hint};
 
 // for more of these, copy paste from: https://en.wikipedia.org/wiki/Box-drawing_character
 static ARROW_SEPARATOR: &str = "";
@@ -17,6 +17,7 @@ static MORE_MSG: &str = " ... ";
 #[derive(Default)]
 struct State {
     mode_info: ModeInfo,
+    diplay_text_copied_hint: bool,
 }
 
 register_plugin!(State);
@@ -136,12 +137,26 @@ impl ZellijPlugin for State {
         set_selectable(false);
         set_invisible_borders(true);
         set_fixed_height(2);
-        subscribe(&[EventType::ModeUpdate]);
+        subscribe(&[
+            EventType::ModeUpdate,
+            EventType::CopyToClipboard,
+            EventType::InputReceived,
+        ]);
     }
 
     fn update(&mut self, event: Event) {
-        if let Event::ModeUpdate(mode_info) = event {
-            self.mode_info = mode_info;
+        dbg!("got event {:?}", &event);
+        match event {
+            Event::ModeUpdate(mode_info) => {
+                self.mode_info = mode_info;
+            }
+            Event::CopyToClipboard => {
+                self.diplay_text_copied_hint = true;
+            }
+            Event::InputReceived => {
+                self.diplay_text_copied_hint = false;
+            }
+            _ => {}
         }
     }
 
@@ -157,7 +172,11 @@ impl ZellijPlugin for State {
         let ctrl_keys = ctrl_keys(&self.mode_info, cols - superkey.len, separator);
 
         let first_line = format!("{}{}", superkey, ctrl_keys);
-        let second_line = keybinds(&self.mode_info, cols);
+        let second_line = if self.diplay_text_copied_hint {
+            text_copied_hint()
+        } else {
+            keybinds(&self.mode_info, cols)
+        };
 
         // [48;5;238m is gray background, [0K is so that it fills the rest of the line
         // [m is background reset, [0K is so that it clears the rest of the line

default-plugins/status-bar/src/second_line.rs

@@ -375,3 +375,11 @@ pub fn keybinds(help: &ModeInfo, max_width: usize) -> LinePart {
     }
     best_effort_shortcut_list(help, max_width)
 }
+
+pub fn text_copied_hint() -> LinePart {
+    let hint = " Text copied to clipboard";
+    LinePart {
+        part: hint.into(),
+        len: hint.len(),
+    }
+}

zellij-client/src/input_handler.rs

@@ -74,32 +74,36 @@ impl InputHandler {
             let stdin_buffer = self.os_input.read_from_stdin();
             for key_result in stdin_buffer.events_and_raw() {
                 match key_result {
-                    Ok((event, raw_bytes)) => match event {
-                        termion::event::Event::Key(key) => {
-                            let key = cast_termion_key(key);
-                            self.handle_key(&key, raw_bytes);
-                        }
-                        termion::event::Event::Mouse(me) => {
-                            let mouse_event = zellij_utils::input::mouse::MouseEvent::from(me);
-                            self.handle_mouse_event(&mouse_event);
-                        }
-                        termion::event::Event::Unsupported(unsupported_key) => {
-                            // we have to do this because of a bug in termion
-                            // this should be a key event and not an unsupported event
-                            if unsupported_key == alt_left_bracket {
-                                let key = Key::Alt('[');
+                    Ok((event, raw_bytes)) => {
+                        self.os_input
+                            .send_to_server(ClientToServerMsg::InputReceived);
+                        match event {
+                            termion::event::Event::Key(key) => {
+                                let key = cast_termion_key(key);
                                 self.handle_key(&key, raw_bytes);
-                            } else if unsupported_key == bracketed_paste_start {
-                                self.pasting = true;
-                            } else if unsupported_key == bracketed_paste_end {
-                                self.pasting = false;
-                            } else {
-                                // this is a hack because termion doesn't recognize certain keys
-                                // in this case we just forward it to the terminal
-                                self.handle_unknown_key(raw_bytes);
                             }
-                        }
-                    },
+                            termion::event::Event::Mouse(me) => {
+                                let mouse_event = zellij_utils::input::mouse::MouseEvent::from(me);
+                                self.handle_mouse_event(&mouse_event);
+                            }
+                            termion::event::Event::Unsupported(unsupported_key) => {
+                                // we have to do this because of a bug in termion
+                                // this should be a key event and not an unsupported event
+                                if unsupported_key == alt_left_bracket {
+                                    let key = Key::Alt('[');
+                                    self.handle_key(&key, raw_bytes);
+                                } else if unsupported_key == bracketed_paste_start {
+                                    self.pasting = true;
+                                } else if unsupported_key == bracketed_paste_end {
+                                    self.pasting = false;
+                                } else {
+                                    // this is a hack because termion doesn't recognize certain keys
+                                    // in this case we just forward it to the terminal
+                                    self.handle_unknown_key(raw_bytes);
+                                }
+                            }
+                        };
+                    }
                     Err(err) => panic!("Encountered read error: {:?}", err),
                 }
             }

zellij-server/src/route.rs

@@ -307,6 +307,14 @@ pub(crate) fn route_thread_main(
                 }
             }
             ClientToServerMsg::ClientExited => break,
+            ClientToServerMsg::InputReceived => {
+                if let Some(rlocked_sessions) = rlocked_sessions.as_ref() {
+                    rlocked_sessions
+                        .senders
+                        .send_to_plugin(PluginInstruction::Update(None, Event::InputReceived))
+                        .unwrap();
+                }
+            }
         }
     }
 }

zellij-server/src/tab.rs

@@ -2381,6 +2381,9 @@ impl Tab {
         let selected_text = self.get_active_pane().and_then(|p| p.get_selected_text());
         if let Some(selected_text) = selected_text {
             self.write_selection_to_clipboard(&selected_text);
+            self.senders
+                .send_to_plugin(PluginInstruction::Update(None, Event::CopyToClipboard))
+                .unwrap();
         }
     }
 
@@ -2389,6 +2392,9 @@ impl Tab {
         self.senders
             .send_to_server(ServerInstruction::Render(Some(output)))
             .unwrap();
+        self.senders
+            .send_to_plugin(PluginInstruction::Update(None, Event::CopyToClipboard))
+            .unwrap();
     }
 }
 

zellij-tile/src/data.rs

@@ -33,6 +33,8 @@ pub enum Event {
     TabUpdate(Vec<TabInfo>),
     KeyPress(Key),
     Timer(f64),
+    CopyToClipboard,
+    InputReceived,
 }
 
 /// Describes the different input modes, which change the way that keystrokes will be interpreted.

zellij-utils/src/ipc.rs

@@ -60,6 +60,7 @@ pub enum ClientToServerMsg {
     AttachClient(ClientAttributes, bool, Options),
     Action(Action),
     ClientExited,
+    InputReceived,
 }
 
 // Types of messages sent from the server to the client