Add a custom event type that's shared across backends

helix-term/src/application.rs

@@ -15,7 +15,7 @@ use helix_view::{align_view, editor::ConfigEvent, graphics::Rect, theme, Align,
 
 use crate::{
     args::Args,
-    compositor::Compositor,
+    compositor::{Compositor, Event},
     config::Config,
     job::Jobs,
     keymap::Keymaps,
@@ -31,7 +31,7 @@ use std::{
 use anyhow::Error;
 
 use crossterm::{
-    event::{DisableMouseCapture, EnableMouseCapture, Event, EventStream},
+    event::{DisableMouseCapture, EnableMouseCapture, Event as CrosstermEvent, EventStream},
     execute, terminal,
     tty::IsTty,
 };
@@ -397,14 +397,17 @@ impl Application {
         }
     }
 
-    pub fn handle_terminal_events(&mut self, event: Option<Result<Event, crossterm::ErrorKind>>) {
+    pub fn handle_terminal_events(
+        &mut self,
+        event: Option<Result<CrosstermEvent, crossterm::ErrorKind>>,
+    ) {
         let mut cx = crate::compositor::Context {
             editor: &mut self.editor,
             jobs: &mut self.jobs,
         };
         // Handle key events
         let should_redraw = match event {
-            Some(Ok(Event::Resize(width, height))) => {
+            Some(Ok(CrosstermEvent::Resize(width, height))) => {
                 self.terminal
                     .resize(Rect::new(0, 0, width, height))
                     .expect("Unable to resize terminal");
@@ -416,7 +419,7 @@ impl Application {
                 self.compositor
                     .handle_event(Event::Resize(width, height), &mut cx)
             }
-            Some(Ok(event)) => self.compositor.handle_event(event, &mut cx),
+            Some(Ok(event)) => self.compositor.handle_event(event.into(), &mut cx),
             Some(Err(x)) => panic!("{}", x),
             None => panic!(),
         };

helix-term/src/commands.rs

@@ -4570,7 +4570,7 @@ fn replay_macro(cx: &mut Context) {
     cx.callback = Some(Box::new(move |compositor, cx| {
         for _ in 0..count {
             for &key in keys.iter() {
-                compositor.handle_event(crossterm::event::Event::Key(key.into()), cx);
+                compositor.handle_event(compositor::Event::Key(key), cx);
             }
         }
     }));

helix-term/src/compositor.rs

@@ -4,9 +4,6 @@
 use helix_core::Position;
 use helix_view::graphics::{CursorKind, Rect};
 
-use crossterm::event::Event;
-use tui::buffer::Buffer as Surface;
-
 pub type Callback = Box<dyn FnOnce(&mut Compositor, &mut Context)>;
 
 // Cursive-inspired
@@ -15,21 +12,29 @@ pub enum EventResult {
     Consumed(Option<Callback>),
 }
 
+use crate::job::Jobs;
 use helix_view::Editor;
 
-use crate::job::Jobs;
+pub use helix_view::input::Event;
 
 pub struct Context<'a> {
     pub editor: &'a mut Editor,
     pub jobs: &'a mut Jobs,
 }
 
-pub struct RenderContext<'a> {
+mod term {
+    use super::*;
+    pub use tui::buffer::Buffer as Surface;
+
+    pub struct RenderContext<'a> {
         pub editor: &'a Editor,
         pub surface: &'a mut Surface,
         pub scroll: Option<usize>,
+    }
 }
 
+pub use term::*;
+
 pub trait Component: Any + AnyComponent {
     /// Process input events, return true if handled.
     fn handle_event(&mut self, _event: Event, _ctx: &mut Context) -> EventResult {
@@ -115,7 +120,7 @@ impl Compositor {
     pub fn handle_event(&mut self, event: Event, cx: &mut Context) -> bool {
         // If it is a key event and a macro is being recorded, push the key event to the recording.
         if let (Event::Key(key), Some((_, keys))) = (event, &mut cx.editor.macro_recording) {
-            keys.push(key.into());
+            keys.push(key);
         }
 
         let mut callbacks = Vec::new();

helix-term/src/ui/completion.rs

@@ -1,11 +1,14 @@
-use crate::compositor::{Component, Context, EventResult, RenderContext};
-use crossterm::event::{Event, KeyCode, KeyEvent};
+use crate::compositor::{Component, Context, Event, EventResult, RenderContext};
 use helix_view::editor::CompleteAction;
 
 use std::borrow::Cow;
 
 use helix_core::{Change, Transaction};
-use helix_view::{graphics::Rect, Document, Editor};
+use helix_view::{
+    graphics::Rect,
+    input::{KeyCode, KeyEvent},
+    Document, Editor,
+};
 
 use crate::commands;
 use crate::ui::{menu, Markdown, Menu, Popup, PromptEvent};

helix-term/src/ui/editor.rs

@@ -1,6 +1,6 @@
 use crate::{
     commands,
-    compositor::{Component, Context, EventResult, RenderContext},
+    compositor::{Component, Context, Event, EventResult, RenderContext},
     key,
     keymap::{KeymapResult, Keymaps},
     ui::{Completion, ProgressSpinners},
@@ -21,13 +21,12 @@ use helix_view::{
     document::{Mode, SCRATCH_BUFFER_NAME},
     editor::{CompleteAction, CursorShapeConfig},
     graphics::{CursorKind, Modifier, Rect, Style},
-    input::KeyEvent,
+    input::{KeyEvent, MouseButton, MouseEvent, MouseEventKind},
     keyboard::{KeyCode, KeyModifiers},
     Document, Editor, Theme, View,
 };
 use std::borrow::Cow;
 
-use crossterm::event::{Event, MouseButton, MouseEvent, MouseEventKind};
 use tui::buffer::Buffer as Surface;
 
 pub struct EditorView {
@@ -977,7 +976,7 @@ impl EditorView {
                 if let Some((pos, view_id)) = result {
                     let doc = editor.document_mut(editor.tree.get(view_id).doc).unwrap();
 
-                    if modifiers == crossterm::event::KeyModifiers::ALT {
+                    if modifiers == KeyModifiers::ALT {
                         let selection = doc.selection(view_id).clone();
                         doc.set_selection(view_id, selection.push(Range::point(pos)));
                     } else {
@@ -1108,7 +1107,7 @@ impl EditorView {
                     let line = coords.row + view.offset.row;
                     if let Ok(pos) = doc.text().try_line_to_char(line) {
                         doc.set_selection(view_id, Selection::point(pos));
-                        if modifiers == crossterm::event::KeyModifiers::ALT {
+                        if modifiers == KeyModifiers::ALT {
                             commands::MappableCommand::dap_edit_log.execute(cxt);
                         } else {
                             commands::MappableCommand::dap_edit_condition.execute(cxt);
@@ -1132,7 +1131,7 @@ impl EditorView {
                     return EventResult::Ignored(None);
                 }
 
-                if modifiers == crossterm::event::KeyModifiers::ALT {
+                if modifiers == KeyModifiers::ALT {
                     commands::MappableCommand::replace_selections_with_primary_clipboard
                         .execute(cxt);
 
@@ -1181,9 +1180,8 @@ impl Component for EditorView {
                 // Handling it here but not re-rendering will cause flashing
                 EventResult::Consumed(None)
             }
-            Event::Key(key) => {
+            Event::Key(mut key) => {
                 cx.editor.reset_idle_timer();
-                let mut key = KeyEvent::from(key);
                 canonicalize_key(&mut key);
 
                 // clear status

helix-term/src/ui/menu.rs

@@ -1,8 +1,7 @@
 use crate::{
-    compositor::{Callback, Component, Compositor, Context, EventResult, RenderContext},
+    compositor::{Callback, Component, Compositor, Context, Event, EventResult, RenderContext},
     ctrl, key, shift,
 };
-use crossterm::event::Event;
 use tui::widgets::Table;
 
 pub use tui::widgets::{Cell, Row};
@@ -210,7 +209,7 @@ impl<T: Item + 'static> Component for Menu<T> {
             compositor.pop();
         }));
 
-        match event.into() {
+        match event {
             // esc or ctrl-c aborts the completion and closes the menu
             key!(Esc) | ctrl!('c') => {
                 (self.callback_fn)(cx.editor, self.selection(), MenuEvent::Abort);

helix-term/src/ui/overlay.rs

@@ -1,11 +1,10 @@
-use crossterm::event::Event;
 use helix_core::Position;
 use helix_view::{
     graphics::{CursorKind, Rect},
     Editor,
 };
 
-use crate::compositor::{Component, Context, EventResult, RenderContext};
+use crate::compositor::{Component, Context, Event, EventResult, RenderContext};
 
 /// Contains a component placed in the center of the parent component
 pub struct Overlay<T> {

helix-term/src/ui/picker.rs

@@ -1,9 +1,8 @@
 use crate::{
-    compositor::{Component, Compositor, Context, EventResult, RenderContext},
+    compositor::{Component, Compositor, Context, Event, EventResult, RenderContext},
     ctrl, key, shift,
     ui::{self, EditorView},
 };
-use crossterm::event::Event;
 use tui::widgets::{Block, BorderType, Borders};
 
 use fuzzy_matcher::skim::SkimMatcherV2 as Matcher;
@@ -496,7 +495,7 @@ impl<T: 'static> Component for Picker<T> {
             compositor.last_picker = compositor.pop();
         })));
 
-        match key_event.into() {
+        match key_event {
             shift!(Tab) | key!(Up) | ctrl!('p') => {
                 self.move_by(1, Direction::Backward);
             }

helix-term/src/ui/popup.rs

@@ -1,8 +1,7 @@
 use crate::{
-    compositor::{Callback, Component, Context, EventResult, RenderContext},
+    compositor::{Callback, Component, Context, Event, EventResult, RenderContext},
     ctrl, key,
 };
-use crossterm::event::Event;
 
 use helix_core::Position;
 use helix_view::{
@@ -124,7 +123,7 @@ impl<T: Component> Component for Popup<T> {
             compositor.pop();
         });
 
-        match key.into() {
+        match key {
             // esc or ctrl-c aborts the completion and closes the menu
             key!(Esc) | ctrl!('c') => {
                 let _ = self.contents.handle_event(event, cx);

helix-term/src/ui/prompt.rs

@@ -1,6 +1,5 @@
-use crate::compositor::{Component, Compositor, Context, EventResult, RenderContext};
+use crate::compositor::{Component, Compositor, Context, Event, EventResult, RenderContext};
 use crate::{alt, ctrl, key, shift, ui};
-use crossterm::event::Event;
 use helix_view::input::KeyEvent;
 use helix_view::keyboard::KeyCode;
 use std::{borrow::Cow, ops::RangeFrom};
@@ -454,7 +453,7 @@ impl Component for Prompt {
             compositor.pop();
         })));
 
-        match event.into() {
+        match event {
             ctrl!('c') | key!(Esc) => {
                 (self.callback_fn)(cx, &self.line, PromptEvent::Abort);
                 return close_fn;

helix-view/src/input.rs

@@ -4,8 +4,53 @@ use helix_core::unicode::width::UnicodeWidthStr;
 use serde::de::{self, Deserialize, Deserializer};
 use std::fmt;
 
-use crate::keyboard::{KeyCode, KeyModifiers};
+pub use crate::keyboard::{KeyCode, KeyModifiers};
 
+#[derive(Debug, PartialOrd, PartialEq, Eq, Clone, Copy, Hash)]
+pub enum Event {
+    Key(KeyEvent),
+    Mouse(MouseEvent),
+    Resize(u16, u16),
+}
+
+#[derive(Debug, PartialOrd, PartialEq, Eq, Clone, Copy, Hash)]
+pub struct MouseEvent {
+    /// The kind of mouse event that was caused.
+    pub kind: MouseEventKind,
+    /// The column that the event occurred on.
+    pub column: u16,
+    /// The row that the event occurred on.
+    pub row: u16,
+    /// The key modifiers active when the event occurred.
+    pub modifiers: KeyModifiers,
+}
+
+#[derive(Debug, PartialOrd, PartialEq, Eq, Clone, Copy, Hash)]
+pub enum MouseEventKind {
+    /// Pressed mouse button. Contains the button that was pressed.
+    Down(MouseButton),
+    /// Released mouse button. Contains the button that was released.
+    Up(MouseButton),
+    /// Moved the mouse cursor while pressing the contained mouse button.
+    Drag(MouseButton),
+    /// Moved the mouse cursor while not pressing a mouse button.
+    Moved,
+    /// Scrolled mouse wheel downwards (towards the user).
+    ScrollDown,
+    /// Scrolled mouse wheel upwards (away from the user).
+    ScrollUp,
+}
+
+/// Represents a mouse button.
+#[derive(Debug, PartialOrd, PartialEq, Eq, Clone, Copy, Hash)]
+pub enum MouseButton {
+    /// Left mouse button.
+    Left,
+    /// Right mouse button.
+    Right,
+    /// Middle mouse button.
+    Middle,
+}
 /// Represents a key event.
 // We use a newtype here because we want to customize Deserialize and Display.
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Hash)]
@@ -214,6 +259,61 @@ impl<'de> Deserialize<'de> for KeyEvent {
     }
 }
 
+#[cfg(feature = "term")]
+impl From<crossterm::event::Event> for Event {
+    fn from(event: crossterm::event::Event) -> Self {
+        match event {
+            crossterm::event::Event::Key(key) => Self::Key(key.into()),
+            crossterm::event::Event::Mouse(mouse) => Self::Mouse(mouse.into()),
+            crossterm::event::Event::Resize(w, h) => Self::Resize(w, h),
+        }
+    }
+}
+
+#[cfg(feature = "term")]
+impl From<crossterm::event::MouseEvent> for MouseEvent {
+    fn from(
+        crossterm::event::MouseEvent {
+            kind,
+            column,
+            row,
+            modifiers,
+        }: crossterm::event::MouseEvent,
+    ) -> Self {
+        Self {
+            kind: kind.into(),
+            column,
+            row,
+            modifiers: modifiers.into(),
+        }
+    }
+}
+
+#[cfg(feature = "term")]
+impl From<crossterm::event::MouseEventKind> for MouseEventKind {
+    fn from(kind: crossterm::event::MouseEventKind) -> Self {
+        match kind {
+            crossterm::event::MouseEventKind::Down(button) => Self::Down(button.into()),
+            crossterm::event::MouseEventKind::Up(button) => Self::Down(button.into()),
+            crossterm::event::MouseEventKind::Drag(button) => Self::Drag(button.into()),
+            crossterm::event::MouseEventKind::Moved => Self::Moved,
+            crossterm::event::MouseEventKind::ScrollDown => Self::ScrollDown,
+            crossterm::event::MouseEventKind::ScrollUp => Self::ScrollUp,
+        }
+    }
+}
+
+#[cfg(feature = "term")]
+impl From<crossterm::event::MouseButton> for MouseButton {
+    fn from(button: crossterm::event::MouseButton) -> Self {
+        match button {
+            crossterm::event::MouseButton::Left => MouseButton::Left,
+            crossterm::event::MouseButton::Right => MouseButton::Right,
+            crossterm::event::MouseButton::Middle => MouseButton::Middle,
+        }
+    }
+}
+
 #[cfg(feature = "term")]
 impl From<crossterm::event::KeyEvent> for KeyEvent {
     fn from(crossterm::event::KeyEvent { code, modifiers }: crossterm::event::KeyEvent) -> Self {

helix-view/src/keyboard.rs

@@ -55,7 +55,6 @@ impl From<crossterm::event::KeyModifiers> for KeyModifiers {
 
 /// Represents a key.
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Copy, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum KeyCode {
     /// Backspace key.
     Backspace,