helix

diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs
index f879a717..cad94e97 100644
--- a/helix-term/src/application.rs
+++ b/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!(),

};

diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs
index 0f977737..115e04a1 100644
--- a/helix-term/src/commands.rs
+++ b/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);

}

}));

diff --git a/helix-term/src/compositor.rs b/helix-term/src/compositor.rs
index daeff898..12171d71 100644
--- a/helix-term/src/compositor.rs
+++ b/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> {

- pub editor: &'a Editor,

- pub surface: &'a mut Surface,

- pub scroll: Option<usize>,

+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();

diff --git a/helix-term/src/ui/completion.rs b/helix-term/src/ui/completion.rs
index ec1ca326..cf2644d2 100644
--- a/helix-term/src/ui/completion.rs
+++ b/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};

diff --git a/helix-term/src/ui/editor.rs b/helix-term/src/ui/editor.rs
index 6775b5b2..baa4bf56 100644
--- a/helix-term/src/ui/editor.rs
+++ b/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

diff --git a/helix-term/src/ui/menu.rs b/helix-term/src/ui/menu.rs
index 7d831e15..6c11618a 100644
--- a/helix-term/src/ui/menu.rs
+++ b/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);

diff --git a/helix-term/src/ui/overlay.rs b/helix-term/src/ui/overlay.rs
index b2ab0d49..3efacdc9 100644
--- a/helix-term/src/ui/overlay.rs
+++ b/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> {

diff --git a/helix-term/src/ui/picker.rs b/helix-term/src/ui/picker.rs
index 6012510b..67e780da 100644
--- a/helix-term/src/ui/picker.rs
+++ b/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);

}

diff --git a/helix-term/src/ui/popup.rs b/helix-term/src/ui/popup.rs
index 95d55d0a..873d8540 100644
--- a/helix-term/src/ui/popup.rs
+++ b/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);

diff --git a/helix-term/src/ui/prompt.rs b/helix-term/src/ui/prompt.rs
index a24ed36b..cb431806 100644
--- a/helix-term/src/ui/prompt.rs
+++ b/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;

diff --git a/helix-view/src/input.rs b/helix-view/src/input.rs
index 14dadc3b..28282475 100644
--- a/helix-view/src/input.rs
+++ b/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)]

@@ -215,6 +260,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 {

if code == crossterm::event::KeyCode::BackTab {

diff --git a/helix-view/src/keyboard.rs b/helix-view/src/keyboard.rs
index f1717209..fd1fe06f 100644
--- a/helix-view/src/keyboard.rs
+++ b/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,