mouse configuration via mouseon mouseoff

src/bridge/events.rs

@@ -128,6 +128,8 @@ pub enum RedrawEvent {
     ModeChange {
         mode_index: u64,
     },
+    MouseOn,
+    MouseOff,
     BusyStart,
     BusyStop,
     Flush,
@@ -779,6 +781,8 @@ pub fn parse_redraw_event(event_value: Value) -> Result<Vec<RedrawEvent>> {
             "mode_info_set" => Some(parse_mode_info_set(event_parameters)?),
             "option_set" => Some(parse_option_set(event_parameters)?),
             "mode_change" => Some(parse_mode_change(event_parameters)?),
+            "mouse_on" => Some(RedrawEvent::MouseOn),
+            "mouse_off" => Some(RedrawEvent::MouseOff),
             "busy_start" => Some(RedrawEvent::BusyStart),
             "busy_stop" => Some(RedrawEvent::BusyStop),
             "flush" => Some(RedrawEvent::Flush),

src/bridge/handler.rs

@@ -25,10 +25,10 @@ impl Handler for NeovimHandler {
         task::spawn_blocking(move || match event_name.as_ref() {
             "redraw" => {
                 handle_redraw_event_group(arguments);
-            }
+            },
             "setting_changed" => {
                 SETTINGS.handle_changed_notification(arguments);
-            }
+            },
             _ => {}
         })
         .await

src/bridge/ui_commands.rs

@@ -3,6 +3,8 @@ use nvim_rs::compat::tokio::Compat;
 use nvim_rs::Neovim;
 use tokio::process::ChildStdin;
 
+use crate::editor::EDITOR;
+
 #[derive(Debug, Clone)]
 pub enum UiCommand {
     Resize {
@@ -38,21 +40,30 @@ impl UiCommand {
             UiCommand::MouseButton {
                 action,
                 position: (grid_x, grid_y),
-            } => nvim
+            } => {
-                .input_mouse("left", &action, "", 0, grid_y as i64, grid_x as i64)
+                if { EDITOR.lock().mouse_enabled } {
-                .await
+                    nvim.input_mouse("left", &action, "", 0, grid_y as i64, grid_x as i64)
-                .expect("Mouse Input Failed"),
+                        .await
+                        .expect("Mouse Input Failed");
+                }
+            },
             UiCommand::Scroll {
                 direction,
                 position: (grid_x, grid_y),
-            } => nvim
+            } => {
-                .input_mouse("wheel", &direction, "", 0, grid_y as i64, grid_x as i64)
+                if { EDITOR.lock().mouse_enabled } {
-                .await
+                    nvim.input_mouse("wheel", &direction, "", 0, grid_y as i64, grid_x as i64)
-                .expect("Mouse Scroll Failed"),
+                        .await
-            UiCommand::Drag(grid_x, grid_y) => nvim
+                        .expect("Mouse Scroll Failed");
-                .input_mouse("left", "drag", "", 0, grid_y as i64, grid_x as i64)
+                }
-                .await
+            },
-                .expect("Mouse Drag Failed"),
+            UiCommand::Drag(grid_x, grid_y) => {
+                if { EDITOR.lock().mouse_enabled } {
+                    nvim.input_mouse("left", "drag", "", 0, grid_y as i64, grid_x as i64)
+                        .await
+                        .expect("Mouse Drag Failed");
+                }
+            },
             UiCommand::FocusLost => nvim
                 .command("if exists('#FocusLost') | doautocmd <nomodeline> FocusLost | endif")
                 .await

src/editor/mod.rs

@@ -32,6 +32,7 @@ pub struct DrawCommand {
 pub struct Editor {
     pub grid: CharacterGrid,
     pub title: String,
+    pub mouse_enabled: bool,
     pub font_name: Option<String>,
     pub font_size: Option<f32>,
     pub cursor: Cursor,
@@ -45,6 +46,7 @@ impl Editor {
         let mut editor = Editor {
             grid: CharacterGrid::new(window_geometry_or_default()),
             title: "Neovide".to_string(),
+            mouse_enabled: true,
             font_name: None,
             font_size: None,
             cursor: Cursor::new(),
@@ -68,26 +70,32 @@ impl Editor {
             RedrawEvent::OptionSet { gui_option } => self.set_option(gui_option),
             RedrawEvent::ModeChange { mode_index } => {
                 self.cursor.change_mode(mode_index, &self.defined_styles)
-            }
+            },
+            RedrawEvent::MouseOn => {
+                self.mouse_enabled = true;
+            },
+            RedrawEvent::MouseOff => {
+                self.mouse_enabled = false;
+            },
             RedrawEvent::BusyStart => {
                 trace!("Cursor off");
                 self.cursor.enabled = false;
-            }
+            },
             RedrawEvent::BusyStop => {
                 trace!("Cursor on");
                 self.cursor.enabled = true;
-            }
+            },
             RedrawEvent::Flush => {
                 trace!("Image flushed");
                 REDRAW_SCHEDULER.queue_next_frame();
-            }
+            },
             RedrawEvent::Resize { width, height, .. } => self.grid.resize(width, height),
             RedrawEvent::DefaultColorsSet { colors } => {
                 self.default_style = Arc::new(Style::new(colors))
-            }
+            },
             RedrawEvent::HighlightAttributesDefine { id, style } => {
                 self.defined_styles.insert(id, Arc::new(style));
-            }
+            },
             RedrawEvent::GridLine {
                 row,
                 column_start,