Mouse AnyEvent tracking (1003) -- work in progress

zellij-client/src/input_handler.rs

@@ -11,26 +11,13 @@ use zellij_utils::{
         actions::Action,
         cast_termwiz_key,
         config::Config,
-        mouse::{MouseButton, MouseEvent},
+        mouse::{MouseButtons, MouseEvent},
         options::Options,
     },
     ipc::{ClientToServerMsg, ExitReason},
     termwiz::input::InputEvent,
 };
 
-#[derive(Debug, Clone, Copy)]
-enum HeldMouseButton {
-    Left,
-    Right,
-    Middle,
-}
-
-impl Default for HeldMouseButton {
-    fn default() -> Self {
-        HeldMouseButton::Left
-    }
-}
-
 /// Handles the dispatching of [`Action`]s according to the current
 /// [`InputMode`], and keep tracks of the current [`InputMode`].
 struct InputHandler {
@@ -43,7 +30,7 @@ struct InputHandler {
     send_client_instructions: SenderWithContext<ClientInstruction>,
     should_exit: bool,
     receive_input_instructions: Receiver<(InputInstruction, ErrorContext)>,
-    holding_mouse: Option<HeldMouseButton>,
+    mouse_buttons: MouseButtons,
     mouse_mode_active: bool,
 }
 
@@ -67,7 +54,13 @@ impl InputHandler {
             send_client_instructions,
             should_exit: false,
             receive_input_instructions,
-            holding_mouse: None,
+            mouse_buttons: MouseButtons {
+                left: false,
+                right: false,
+                middle: false,
+                wheel_up: false,
+                wheel_down: false,
+            },
             mouse_mode_active: false,
         }
     }
@@ -99,8 +92,10 @@ impl InputHandler {
                             self.handle_key(&key, raw_bytes, false);
                         },
                         InputEvent::Mouse(mouse_event) => {
-                            let mouse_event =
-                                zellij_utils::input::mouse::MouseEvent::from(mouse_event);
+                            let mouse_event = zellij_utils::input::mouse::MouseEvent::from_termwiz(
+                                self.mouse_buttons,
+                                mouse_event,
+                            );
                             self.handle_mouse_event(&mouse_event);
                         },
                         InputEvent::Paste(pasted_text) => {
@@ -216,67 +211,30 @@ impl InputHandler {
     }
     fn handle_mouse_event(&mut self, mouse_event: &MouseEvent) {
         match *mouse_event {
-            MouseEvent::Press(button, point) => match button {
-                MouseButton::WheelUp => {
+            MouseEvent::Press(buttons, point) => {
+                if buttons.wheel_up {
                     self.dispatch_action(Action::ScrollUpAt(point), None);
-                },
-                MouseButton::WheelDown => {
+                } else if buttons.wheel_down {
                     self.dispatch_action(Action::ScrollDownAt(point), None);
-                },
-                MouseButton::Left => {
-                    if self.holding_mouse.is_some() {
-                        self.dispatch_action(Action::MouseHoldLeft(point), None);
-                    } else {
-                        self.dispatch_action(Action::LeftClick(point), None);
-                    }
-                    self.holding_mouse = Some(HeldMouseButton::Left);
-                },
-                MouseButton::Right => {
-                    if self.holding_mouse.is_some() {
-                        self.dispatch_action(Action::MouseHoldRight(point), None);
-                    } else {
-                        self.dispatch_action(Action::RightClick(point), None);
-                    }
-                    self.holding_mouse = Some(HeldMouseButton::Right);
-                },
-                MouseButton::Middle => {
-                    if self.holding_mouse.is_some() {
-                        self.dispatch_action(Action::MouseHoldMiddle(point), None);
-                    } else {
-                        self.dispatch_action(Action::MiddleClick(point), None);
-                    }
-                    self.holding_mouse = Some(HeldMouseButton::Middle);
-                },
+                } else if buttons.left {
+                    self.dispatch_action(Action::LeftClick(point), None);
+                } else if buttons.right {
+                    self.dispatch_action(Action::RightClick(point), None);
+                } else if buttons.middle {
+                    self.dispatch_action(Action::MiddleClick(point), None);
+                }
             },
-            MouseEvent::Release(point) => {
-                let button_released = self.holding_mouse.unwrap_or_default();
-                match button_released {
-                    HeldMouseButton::Left => {
-                        self.dispatch_action(Action::LeftMouseRelease(point), None)
-                    },
-                    HeldMouseButton::Right => {
-                        self.dispatch_action(Action::RightMouseRelease(point), None)
-                    },
-                    HeldMouseButton::Middle => {
-                        self.dispatch_action(Action::MiddleMouseRelease(point), None)
-                    },
-                };
-                self.holding_mouse = None;
+            MouseEvent::Release(buttons, point) => {
+                if buttons.left {
+                    self.dispatch_action(Action::LeftMouseRelease(point), None);
+                } else if buttons.right {
+                    self.dispatch_action(Action::RightMouseRelease(point), None);
+                } else if buttons.middle {
+                    self.dispatch_action(Action::MiddleMouseRelease(point), None);
+                }
             },
-            MouseEvent::Hold(point) => {
-                let button_held = self.holding_mouse.unwrap_or_default();
-                match button_held {
-                    HeldMouseButton::Left => {
-                        self.dispatch_action(Action::MouseHoldLeft(point), None)
-                    },
-                    HeldMouseButton::Right => {
-                        self.dispatch_action(Action::MouseHoldRight(point), None)
-                    },
-                    HeldMouseButton::Middle => {
-                        self.dispatch_action(Action::MouseHoldMiddle(point), None)
-                    },
-                };
-                self.holding_mouse = Some(button_held);
+            MouseEvent::Motion(buttons, point) => {
+                // AZL TODO
             },
         }
     }

zellij-utils/src/input/mouse.rs

@@ -2,102 +2,135 @@ use serde::{Deserialize, Serialize};
 
 use crate::position::Position;
 
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
+/// A mouse event can have any number of buttons (including no
+/// buttons) pressed or released.
+pub struct MouseButtons {
+    pub left: bool,
+    pub right: bool,
+    pub middle: bool,
+    pub wheel_up: bool,
+    pub wheel_down: bool,
+}
+
 /// A mouse related event
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Deserialize, Serialize)]
 pub enum MouseEvent {
     /// A mouse button was pressed.
     ///
     /// The coordinates are zero-based.
-    Press(MouseButton, Position),
+    Press(MouseButtons, Position),
     /// A mouse button was released.
     ///
     /// The coordinates are zero-based.
-    Release(Position),
+    Release(MouseButtons, Position),
     /// A mouse button is held over the given coordinates.
     ///
     /// The coordinates are zero-based.
-    Hold(Position),
+    Motion(MouseButtons, Position),
 }
 
-impl From<termwiz::input::MouseEvent> for MouseEvent {
-    fn from(event: termwiz::input::MouseEvent) -> Self {
-        #[allow(clippy::if_same_then_else)]
-        if event
-            .mouse_buttons
-            .contains(termwiz::input::MouseButtons::LEFT)
+impl MouseButtons {
+    fn termwiz_mouse_buttons(mut self, button_bits: &termwiz::input::MouseButtons) -> MouseButtons {
+        self.left = button_bits.contains(termwiz::input::MouseButtons::LEFT);
+        self.right = button_bits.contains(termwiz::input::MouseButtons::RIGHT);
+        self.middle = button_bits.contains(termwiz::input::MouseButtons::MIDDLE);
+        self.wheel_up = button_bits.contains(termwiz::input::MouseButtons::VERT_WHEEL)
+            && button_bits.contains(termwiz::input::MouseButtons::WHEEL_POSITIVE);
+        self.wheel_down = button_bits.contains(termwiz::input::MouseButtons::VERT_WHEEL)
+            && !button_bits.contains(termwiz::input::MouseButtons::WHEEL_POSITIVE);
+
+        self
+    }
+}
+
+impl MouseEvent {
+    #[allow(unused)]
+    pub fn from_termwiz(mut old_buttons: MouseButtons, event: termwiz::input::MouseEvent) -> Self {
+        // We use the state of old_buttons vs new_buttons to determine
+        // if this event is a Press, Release, or Motion.  This is an
+        // unfortunate side effect of the pre-SGR-encoded X10 mouse
+        // protocol design in which release events don't carry
+        // information about WHICH button(s) were released, so we have
+        // to maintain a wee bit of state in between events.
+        //
+        // Note that only Left, Right, and Middle are saved in between
+        // calls.  WheelUp/WheelDown typically do not generate Release
+        // events.
+        let mut new_buttons = MouseButtons::termwiz_mouse_buttons(
+            MouseButtons {
+                left: false,
+                right: false,
+                middle: false,
+                wheel_up: false,
+                wheel_down: false,
+            },
+            &event.mouse_buttons,
+        );
+
+        if (new_buttons.left && !old_buttons.left)
+            || (new_buttons.right && !old_buttons.right)
+            || (new_buttons.middle && !old_buttons.middle)
+            || new_buttons.wheel_up
+            || new_buttons.wheel_down
         {
+            // This is a mouse Press event.  Hang onto the button state.
+            old_buttons = new_buttons;
             MouseEvent::Press(
-                MouseButton::Left,
+                new_buttons,
                 Position::new(event.y.saturating_sub(1) as i32, event.x.saturating_sub(1)),
             )
         } else if event
             .mouse_buttons
-            .contains(termwiz::input::MouseButtons::RIGHT)
+            .contains(termwiz::input::MouseButtons::NONE)
+            && !old_buttons.left
+            && !old_buttons.right
+            && !old_buttons.middle
         {
-            MouseEvent::Press(
-                MouseButton::Right,
+            // This is a mouse Motion event (no buttons are down).
+            old_buttons = new_buttons;
+            MouseEvent::Motion(
+                new_buttons,
                 Position::new(event.y.saturating_sub(1) as i32, event.x.saturating_sub(1)),
             )
         } else if event
             .mouse_buttons
-            .contains(termwiz::input::MouseButtons::MIDDLE)
+            .contains(termwiz::input::MouseButtons::NONE)
+            && (old_buttons.left || old_buttons.right || old_buttons.middle)
         {
-            MouseEvent::Press(
-                MouseButton::Middle,
+            // This is a mouse Release event.  Note that we set
+            // old_buttons to false (to release), but set ONLY the
+            // new_buttons that were released to true before sending
+            // the event up.
+            if old_buttons.left {
+                old_buttons.left = false;
+                new_buttons.left = true;
+            }
+            if old_buttons.right {
+                old_buttons.right = false;
+                new_buttons.right = true;
+            }
+            if old_buttons.middle {
+                old_buttons.middle = false;
+                new_buttons.middle = true;
+            }
+
+            MouseEvent::Release(
+                new_buttons,
                 Position::new(event.y.saturating_sub(1) as i32, event.x.saturating_sub(1)),
             )
-        } else if event
-            .mouse_buttons
-            .contains(termwiz::input::MouseButtons::VERT_WHEEL)
-        {
-            if event
-                .mouse_buttons
-                .contains(termwiz::input::MouseButtons::WHEEL_POSITIVE)
-            {
-                MouseEvent::Press(
-                    MouseButton::WheelUp,
-                    Position::new(event.y.saturating_sub(1) as i32, event.x.saturating_sub(1)),
-                )
-            } else {
-                MouseEvent::Press(
-                    MouseButton::WheelDown,
-                    Position::new(event.y.saturating_sub(1) as i32, event.x.saturating_sub(1)),
-                )
-            }
-        } else if event
-            .mouse_buttons
-            .contains(termwiz::input::MouseButtons::NONE)
-        {
-            // release
-            MouseEvent::Release(Position::new(
-                event.y.saturating_sub(1) as i32,
-                event.x.saturating_sub(1),
-            ))
         } else {
-            // this is an unsupported event, we just do this in order to send "something", but if
-            // something happens here, we might want to add more specific support
-            MouseEvent::Release(Position::new(
-                event.y.saturating_sub(1) as i32,
-                event.x.saturating_sub(1),
-            ))
+            // Unrecognized mouse state.  Return it as a blank Motion event.
+            MouseEvent::Motion(
+                MouseButtons {
+                    left: false,
+                    right: false,
+                    middle: false,
+                    wheel_up: false,
+                    wheel_down: false,
+                },
+                Position::new(event.y.saturating_sub(1) as i32, event.x.saturating_sub(1)),
+            )
         }
     }
 }
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
-pub enum MouseButton {
-    /// The left mouse button.
-    Left,
-    /// The right mouse button.
-    Right,
-    /// The middle mouse button.
-    Middle,
-    /// Mouse wheel is going up.
-    ///
-    /// This event is typically only used with Mouse::Press.
-    WheelUp,
-    /// Mouse wheel is going down.
-    ///
-    /// This event is typically only used with Mouse::Press.
-    WheelDown,
-}