Implement kitty's keyboard protocol

The protocol enables robust key reporting for the applications, so
they could bind more keys and the user won't have collisions with
the normal control keys.

Links: https://sw.kovidgoyal.net/kitty/keyboard-protocol
Fixes #6378.

2 files changed, 2087 insertions, 0 deletions

diff --git a/alacritty/src/input/keyboard.rs b/alacritty/src/input/keyboard.rs
new file mode 100644
index 00000000..94633cb1
--- /dev/null
+++ b/alacritty/src/input/keyboard.rs
@@ -0,0 +1,584 @@
+use std::borrow::Cow;
+use std::mem;
+
+use winit::event::{ElementState, KeyEvent};
+#[cfg(target_os = "macos")]
+use winit::keyboard::ModifiersKeyState;
+use winit::keyboard::{Key, KeyLocation, ModifiersState, NamedKey};
+#[cfg(target_os = "macos")]
+use winit::platform::macos::OptionAsAlt;
+
+use alacritty_terminal::event::EventListener;
+use alacritty_terminal::term::TermMode;
+use winit::platform::modifier_supplement::KeyEventExtModifierSupplement;
+
+use crate::config::{Action, BindingKey, BindingMode};
+use crate::event::TYPING_SEARCH_DELAY;
+use crate::input::{ActionContext, Execute, Processor};
+use crate::scheduler::{TimerId, Topic};
+
+impl<T: EventListener, A: ActionContext<T>> Processor<T, A> {
+    /// Process key input.
+    pub fn key_input(&mut self, key: KeyEvent) {
+        // IME input will be applied on commit and shouldn't trigger key bindings.
+        if self.ctx.display().ime.preedit().is_some() {
+            return;
+        }
+
+        let mode = *self.ctx.terminal().mode();
+        let mods = self.ctx.modifiers().state();
+
+        if key.state == ElementState::Released {
+            self.key_release(key, mode, mods);
+            return;
+        }
+
+        let text = key.text_with_all_modifiers().unwrap_or_default();
+
+        // All key bindings are disabled while a hint is being selected.
+        if self.ctx.display().hint_state.active() {
+            for character in text.chars() {
+                self.ctx.hint_input(character);
+            }
+            return;
+        }
+
+        // First key after inline search is captured.
+        let inline_state = self.ctx.inline_search_state();
+        if mem::take(&mut inline_state.char_pending) {
+            if let Some(c) = text.chars().next() {
+                inline_state.character = Some(c);
+
+                // Immediately move to the captured character.
+                self.ctx.inline_search_next();
+            }
+
+            // Ignore all other characters in `text`.
+            return;
+        }
+
+        // Reset search delay when the user is still typing.
+        self.reset_search_delay();
+
+        // Key bindings suppress the character input.
+        if self.process_key_bindings(&key) {
+            return;
+        }
+
+        if self.ctx.search_active() {
+            for character in text.chars() {
+                self.ctx.search_input(character);
+            }
+
+            return;
+        }
+
+        // Vi mode on its own doesn't have any input, the search input was done before.
+        if mode.contains(TermMode::VI) {
+            return;
+        }
+
+        let build_key_sequence = Self::should_build_sequence(&key, text, mode, mods);
+
+        let bytes = if build_key_sequence {
+            build_sequence(key, mods, mode)
+        } else {
+            let mut bytes = Vec::with_capacity(text.len() + 1);
+            if self.alt_send_esc() && text.len() == 1 {
+                bytes.push(b'\x1b');
+            }
+
+            bytes.extend_from_slice(text.as_bytes());
+            bytes
+        };
+
+        // Write only if we have something to write.
+        if !bytes.is_empty() {
+            self.ctx.on_terminal_input_start();
+            self.ctx.write_to_pty(bytes);
+        }
+    }
+
+    /// Check whether we should try to build escape sequence for the [`KeyEvent`].
+    fn should_build_sequence(
+        key: &KeyEvent,
+        text: &str,
+        mode: TermMode,
+        mods: ModifiersState,
+    ) -> bool {
+        if mode.contains(TermMode::REPORT_ALL_KEYS_AS_ESC) {
+            true
+        } else if mode.contains(TermMode::DISAMBIGUATE_ESC_CODES) {
+            let on_numpad = key.location == KeyLocation::Numpad;
+            let is_escape = key.logical_key == Key::Named(NamedKey::Escape);
+            is_escape || (!mods.is_empty() && mods != ModifiersState::SHIFT) || on_numpad
+        } else {
+            // `Delete` key always has text attached to it, but it's a named key, thus needs to be
+            // excluded here as well.
+            text.is_empty() || key.logical_key == Key::Named(NamedKey::Delete)
+        }
+    }
+
+    /// Whether we should send `ESC` due to `Alt` being pressed.
+    #[cfg(not(target_os = "macos"))]
+    fn alt_send_esc(&mut self) -> bool {
+        self.ctx.modifiers().state().alt_key()
+    }
+
+    #[cfg(target_os = "macos")]
+    fn alt_send_esc(&mut self) -> bool {
+        let option_as_alt = self.ctx.config().window.option_as_alt();
+        self.ctx.modifiers().state().alt_key()
+            && (option_as_alt == OptionAsAlt::Both
+                || (option_as_alt == OptionAsAlt::OnlyLeft
+                    && self.ctx.modifiers().lalt_state() == ModifiersKeyState::Pressed)
+                || (option_as_alt == OptionAsAlt::OnlyRight
+                    && self.ctx.modifiers().ralt_state() == ModifiersKeyState::Pressed))
+    }
+
+    /// Attempt to find a binding and execute its action.
+    ///
+    /// The provided mode, mods, and key must match what is allowed by a binding
+    /// for its action to be executed.
+    fn process_key_bindings(&mut self, key: &KeyEvent) -> bool {
+        let mode = BindingMode::new(self.ctx.terminal().mode(), self.ctx.search_active());
+        let mods = self.ctx.modifiers().state();
+
+        // Don't suppress char if no bindings were triggered.
+        let mut suppress_chars = None;
+
+        for i in 0..self.ctx.config().key_bindings().len() {
+            let binding = &self.ctx.config().key_bindings()[i];
+
+            // We don't want the key without modifier, because it means something else most of
+            // the time. However what we want is to manually lowercase the character to account
+            // for both small and capital letters on regular characters at the same time.
+            let logical_key = if let Key::Character(ch) = key.logical_key.as_ref() {
+                Key::Character(ch.to_lowercase().into())
+            } else {
+                key.logical_key.clone()
+            };
+
+            let key = match (&binding.trigger, logical_key) {
+                (BindingKey::Scancode(_), _) => BindingKey::Scancode(key.physical_key),
+                (_, code) => BindingKey::Keycode { key: code, location: key.location.into() },
+            };
+
+            if binding.is_triggered_by(mode, mods, &key) {
+                // Pass through the key if any of the bindings has the `ReceiveChar` action.
+                *suppress_chars.get_or_insert(true) &= binding.action != Action::ReceiveChar;
+
+                // Binding was triggered; run the action.
+                binding.action.clone().execute(&mut self.ctx);
+            }
+        }
+
+        suppress_chars.unwrap_or(false)
+    }
+
+    /// Handle key release.
+    fn key_release(&mut self, key: KeyEvent, mode: TermMode, mods: ModifiersState) {
+        if !mode.contains(TermMode::REPORT_EVENT_TYPES)
+            || mode.contains(TermMode::VI)
+            || self.ctx.search_active()
+            || self.ctx.display().hint_state.active()
+        {
+            return;
+        }
+
+        let bytes: Cow<'static, [u8]> = match key.logical_key.as_ref() {
+            // NOTE: Echo the key back on release to follow kitty/foot behavior. When
+            // KEYBOARD_REPORT_ALL_KEYS_AS_ESC is used, we build proper escapes for
+            // the keys below.
+            _ if mode.contains(TermMode::REPORT_ALL_KEYS_AS_ESC) => {
+                build_sequence(key, mods, mode).into()
+            },
+            // Winit uses different keys for `Backspace` so we expliictly specify the
+            // values, instead of using what was passed to us from it.
+            Key::Named(NamedKey::Tab) => [b'\t'].as_slice().into(),
+            Key::Named(NamedKey::Enter) => [b'\r'].as_slice().into(),
+            Key::Named(NamedKey::Backspace) => [b'\x7f'].as_slice().into(),
+            Key::Named(NamedKey::Escape) => [b'\x1b'].as_slice().into(),
+            _ => build_sequence(key, mods, mode).into(),
+        };
+
+        self.ctx.write_to_pty(bytes);
+    }
+
+    /// Reset search delay.
+    fn reset_search_delay(&mut self) {
+        if self.ctx.search_active() {
+            let timer_id = TimerId::new(Topic::DelayedSearch, self.ctx.window().id());
+            let scheduler = self.ctx.scheduler_mut();
+            if let Some(timer) = scheduler.unschedule(timer_id) {
+                scheduler.schedule(timer.event, TYPING_SEARCH_DELAY, false, timer.id);
+            }
+        }
+    }
+}
+
+/// Build a key's keyboard escape sequence based on the given `key`, `mods`, and `mode`.
+///
+/// The key sequences for `APP_KEYPAD` and alike are handled inside the bindings.
+#[inline(never)]
+fn build_sequence(key: KeyEvent, mods: ModifiersState, mode: TermMode) -> Vec<u8> {
+    let modifiers = mods.into();
+
+    let kitty_seq = mode.intersects(
+        TermMode::REPORT_ALL_KEYS_AS_ESC
+            | TermMode::DISAMBIGUATE_ESC_CODES
+            | TermMode::REPORT_EVENT_TYPES,
+    );
+
+    let kitty_encode_all = mode.contains(TermMode::REPORT_ALL_KEYS_AS_ESC);
+    // The default parameter is 1, so we can omit it.
+    let kitty_event_type = mode.contains(TermMode::REPORT_EVENT_TYPES)
+        && (key.repeat || key.state == ElementState::Released);
+
+    let context =
+        SequenceBuilder { mode, modifiers, kitty_seq, kitty_encode_all, kitty_event_type };
+
+    let sequence_base = context
+        .try_build_numpad(&key)
+        .or_else(|| context.try_build_named(&key))
+        .or_else(|| context.try_build_control_char_or_mod(&key))
+        .or_else(|| context.try_build_textual(&key));
+
+    let (payload, terminator) = match sequence_base {
+        Some(SequenceBase { payload, terminator }) => (payload, terminator),
+        _ => return Vec::new(),
+    };
+
+    let mut payload = format!("\x1b[{}", payload);
+
+    // Add modifiers information.
+    if kitty_event_type
+        || !modifiers.is_empty()
+        || (mode.contains(TermMode::REPORT_ASSOCIATED_TEXT) && key.text.is_some())
+    {
+        payload.push_str(&format!(";{}", modifiers.encode_esc_sequence()));
+    }
+
+    // Push event type.
+    if kitty_event_type {
+        payload.push(':');
+        let event_type = match key.state {
+            _ if key.repeat => '2',
+            ElementState::Pressed => '1',
+            ElementState::Released => '3',
+        };
+        payload.push(event_type);
+    }
+
+    // Associated text is not reported when the control/alt/logo is pressesed.
+    if mode.contains(TermMode::REPORT_ASSOCIATED_TEXT)
+        && key.state != ElementState::Released
+        && (modifiers.is_empty() || modifiers == SequenceModifiers::SHIFT)
+    {
+        if let Some(text) = key.text {
+            let mut codepoints = text.chars().map(u32::from);
+            if let Some(codepoint) = codepoints.next() {
+                payload.push_str(&format!(";{codepoint}"));
+            }
+            for codepoint in codepoints {
+                payload.push_str(&format!(":{codepoint}"));
+            }
+        }
+    }
+
+    payload.push(terminator.encode_esc_sequence());
+
+    payload.into_bytes()
+}
+
+/// Helper to build escape sequence payloads from [`KeyEvent`].
+pub struct SequenceBuilder {
+    mode: TermMode,
+    /// The emitted sequence should follow the kitty keyboard protocol.
+    kitty_seq: bool,
+    /// Encode all the keys according to the protocol.
+    kitty_encode_all: bool,
+    /// Report event types.
+    kitty_event_type: bool,
+    modifiers: SequenceModifiers,
+}
+
+impl SequenceBuilder {
+    /// Try building sequence from the event's emitting text.
+    fn try_build_textual(&self, key: &KeyEvent) -> Option<SequenceBase> {
+        let character = match key.logical_key.as_ref() {
+            Key::Character(character) => character,
+            _ => return None,
+        };
+
+        if character.chars().count() == 1 {
+            let character = character.chars().next().unwrap();
+            let base_character = character.to_lowercase().next().unwrap();
+
+            let codepoint = u32::from(character);
+            let base_codepoint = u32::from(base_character);
+
+            // NOTE: Base layouts are ignored, since winit doesn't expose this information
+            // yet.
+            let payload = if self.mode.contains(TermMode::REPORT_ALTERNATE_KEYS)
+                && codepoint != base_codepoint
+            {
+                format!("{codepoint}:{base_codepoint}")
+            } else {
+                codepoint.to_string()
+            };
+
+            Some(SequenceBase::new(payload.into(), SequenceTerminator::Kitty))
+        } else if self.kitty_encode_all
+            && self.mode.contains(TermMode::REPORT_ASSOCIATED_TEXT)
+            && key.text.is_some()
+        {
+            // Fallback when need to report text, but we don't have any key associated with this
+            // text.
+            Some(SequenceBase::new("0".into(), SequenceTerminator::Kitty))
+        } else {
+            None
+        }
+    }
+
+    /// Try building from numpad key.
+    ///
+    /// `None` is returned when the key is neither known nor numpad.
+    fn try_build_numpad(&self, key: &KeyEvent) -> Option<SequenceBase> {
+        if !self.kitty_seq || key.location != KeyLocation::Numpad {
+            return None;
+        }
+
+        let base = match key.logical_key.as_ref() {
+            Key::Character("0") => "57399",
+            Key::Character("1") => "57400",
+            Key::Character("2") => "57401",
+            Key::Character("3") => "57402",
+            Key::Character("4") => "57403",
+            Key::Character("5") => "57404",
+            Key::Character("6") => "57405",
+            Key::Character("7") => "57406",
+            Key::Character("8") => "57407",
+            Key::Character("9") => "57408",
+            Key::Character(".") => "57409",
+            Key::Character("/") => "57410",
+            Key::Character("*") => "57411",
+            Key::Character("-") => "57412",
+            Key::Character("+") => "57413",
+            Key::Character("=") => "57415",
+            Key::Named(named) => match named {
+                NamedKey::Enter => "57414",
+                NamedKey::ArrowLeft => "57417",
+                NamedKey::ArrowRight => "57418",
+                NamedKey::ArrowUp => "57419",
+                NamedKey::ArrowDown => "57420",
+                NamedKey::PageUp => "57421",
+                NamedKey::PageDown => "57422",
+                NamedKey::Home => "57423",
+                NamedKey::End => "57424",
+                NamedKey::Insert => "57425",
+                NamedKey::Delete => "57426",
+                _ => return None,
+            },
+            _ => return None,
+        };
+
+        Some(SequenceBase::new(base.into(), SequenceTerminator::Kitty))
+    }
+
+    /// Try building from [`NamedKey`].
+    fn try_build_named(&self, key: &KeyEvent) -> Option<SequenceBase> {
+        let named = match key.logical_key {
+            Key::Named(named) => named,
+            _ => return None,
+        };
+
+        // The default parameter is 1, so we can omit it.
+        let one_based = if self.modifiers.is_empty() && !self.kitty_event_type { "" } else { "1" };
+        let (base, terminator) = match named {
+            NamedKey::PageUp => ("5", SequenceTerminator::Normal('~')),
+            NamedKey::PageDown => ("6", SequenceTerminator::Normal('~')),
+            NamedKey::Insert => ("2", SequenceTerminator::Normal('~')),
+            NamedKey::Delete => ("3", SequenceTerminator::Normal('~')),
+            NamedKey::Home => (one_based, SequenceTerminator::Normal('H')),
+            NamedKey::End => (one_based, SequenceTerminator::Normal('F')),
+            NamedKey::ArrowLeft => (one_based, SequenceTerminator::Normal('D')),
+            NamedKey::ArrowRight => (one_based, SequenceTerminator::Normal('C')),
+            NamedKey::ArrowUp => (one_based, SequenceTerminator::Normal('A')),
+            NamedKey::ArrowDown => (one_based, SequenceTerminator::Normal('B')),
+            NamedKey::F1 => (one_based, SequenceTerminator::Normal('P')),
+            NamedKey::F2 => (one_based, SequenceTerminator::Normal('Q')),
+            NamedKey::F3 => {
+                // F3 in kitty protocol diverges from alacritty's terminfo.
+                if self.kitty_seq {
+                    ("13", SequenceTerminator::Normal('~'))
+                } else {
+                    (one_based, SequenceTerminator::Normal('R'))
+                }
+            },
+            NamedKey::F4 => (one_based, SequenceTerminator::Normal('S')),
+            NamedKey::F5 => ("15", SequenceTerminator::Normal('~')),
+            NamedKey::F6 => ("17", SequenceTerminator::Normal('~')),
+            NamedKey::F7 => ("18", SequenceTerminator::Normal('~')),
+            NamedKey::F8 => ("19", SequenceTerminator::Normal('~')),
+            NamedKey::F9 => ("20", SequenceTerminator::Normal('~')),
+            NamedKey::F10 => ("21", SequenceTerminator::Normal('~')),
+            NamedKey::F11 => ("23", SequenceTerminator::Normal('~')),
+            NamedKey::F12 => ("24", SequenceTerminator::Normal('~')),
+            NamedKey::F13 => ("57376", SequenceTerminator::Kitty),
+            NamedKey::F14 => ("57377", SequenceTerminator::Kitty),
+            NamedKey::F15 => ("57378", SequenceTerminator::Kitty),
+            NamedKey::F16 => ("57379", SequenceTerminator::Kitty),
+            NamedKey::F17 => ("57380", SequenceTerminator::Kitty),
+            NamedKey::F18 => ("57381", SequenceTerminator::Kitty),
+            NamedKey::F19 => ("57382", SequenceTerminator::Kitty),
+            NamedKey::F20 => ("57383", SequenceTerminator::Kitty),
+            NamedKey::F21 => ("57384", SequenceTerminator::Kitty),
+            NamedKey::F22 => ("57385", SequenceTerminator::Kitty),
+            NamedKey::F23 => ("57386", SequenceTerminator::Kitty),
+            NamedKey::F24 => ("57387", SequenceTerminator::Kitty),
+            NamedKey::F25 => ("57388", SequenceTerminator::Kitty),
+            NamedKey::F26 => ("57389", SequenceTerminator::Kitty),
+            NamedKey::F27 => ("57390", SequenceTerminator::Kitty),
+            NamedKey::F28 => ("57391", SequenceTerminator::Kitty),
+            NamedKey::F29 => ("57392", SequenceTerminator::Kitty),
+            NamedKey::F30 => ("57393", SequenceTerminator::Kitty),
+            NamedKey::F31 => ("57394", SequenceTerminator::Kitty),
+            NamedKey::F32 => ("57395", SequenceTerminator::Kitty),
+            NamedKey::F33 => ("57396", SequenceTerminator::Kitty),
+            NamedKey::F34 => ("57397", SequenceTerminator::Kitty),
+            NamedKey::F35 => ("57398", SequenceTerminator::Kitty),
+            NamedKey::ScrollLock => ("57359", SequenceTerminator::Kitty),
+            NamedKey::PrintScreen => ("57361", SequenceTerminator::Kitty),
+            NamedKey::Pause => ("57362", SequenceTerminator::Kitty),
+            NamedKey::ContextMenu => ("57363", SequenceTerminator::Kitty),
+            NamedKey::MediaPlay => ("57428", SequenceTerminator::Kitty),
+            NamedKey::MediaPause => ("57429", SequenceTerminator::Kitty),
+            NamedKey::MediaPlayPause => ("57430", SequenceTerminator::Kitty),
+            NamedKey::MediaStop => ("57432", SequenceTerminator::Kitty),
+            NamedKey::MediaFastForward => ("57433", SequenceTerminator::Kitty),
+            NamedKey::MediaRewind => ("57434", SequenceTerminator::Kitty),
+            NamedKey::MediaTrackNext => ("57435", SequenceTerminator::Kitty),
+            NamedKey::MediaTrackPrevious => ("57436", SequenceTerminator::Kitty),
+            NamedKey::MediaRecord => ("57437", SequenceTerminator::Kitty),
+            NamedKey::AudioVolumeDown => ("57438", SequenceTerminator::Kitty),
+            NamedKey::AudioVolumeUp => ("57439", SequenceTerminator::Kitty),
+            NamedKey::AudioVolumeMute => ("57440", SequenceTerminator::Kitty),
+            _ => return None,
+        };
+
+        Some(SequenceBase::new(base.into(), terminator))
+    }
+
+    /// Try building escape from control characters (e.g. Enter) and modifiers.
+    fn try_build_control_char_or_mod(&self, key: &KeyEvent) -> Option<SequenceBase> {
+        if !self.kitty_encode_all && !self.kitty_seq {
+            return None;
+        }
+
+        let named = match key.logical_key {
+            Key::Named(named) => named,
+            _ => return None,
+        };
+
+        let base = match named {
+            NamedKey::Tab => "9",
+            NamedKey::Enter => "13",
+            NamedKey::Escape => "27",
+            NamedKey::Space => "32",
+            NamedKey::Backspace => "127",
+            _ => "",
+        };
+
+        // Fail when the key is not a named control character and the active mode prohibits us
+        // from encoding modifier keys.
+        if !self.kitty_encode_all && base.is_empty() {
+            return None;
+        }
+
+        let base = match (named, key.location) {
+            (NamedKey::Shift, KeyLocation::Left) => "57441",
+            (NamedKey::Control, KeyLocation::Left) => "57442",
+            (NamedKey::Alt, KeyLocation::Left) => "57443",
+            (NamedKey::Super, KeyLocation::Left) => "57444",
+            (NamedKey::Hyper, KeyLocation::Left) => "57445",
+            (NamedKey::Meta, KeyLocation::Left) => "57446",
+            (NamedKey::Shift, _) => "57447",
+            (NamedKey::Control, _) => "57448",
+            (NamedKey::Alt, _) => "57449",
+            (NamedKey::Super, _) => "57450",
+            (NamedKey::Hyper, _) => "57451",
+            (NamedKey::Meta, _) => "57452",
+            (NamedKey::CapsLock, _) => "57358",
+            (NamedKey::NumLock, _) => "57360",
+            _ => base,
+        };
+
+        if base.is_empty() {
+            None
+        } else {
+            Some(SequenceBase::new(base.into(), SequenceTerminator::Kitty))
+        }
+    }
+}
+
+pub struct SequenceBase {
+    /// The base of the payload, which is the `number` and optionally an alt base from the kitty
+    /// spec.
+    payload: Cow<'static, str>,
+    terminator: SequenceTerminator,
+}
+
+impl SequenceBase {
+    fn new(payload: Cow<'static, str>, terminator: SequenceTerminator) -> Self {
+        Self { payload, terminator }
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum SequenceTerminator {
+    /// The normal key esc sequence terminator defined by xterm/dec.
+    Normal(char),
+    /// The terminator is for kitty escape sequence.
+    Kitty,
+}
+
+impl SequenceTerminator {
+    fn encode_esc_sequence(self) -> char {
+        match self {
+            SequenceTerminator::Normal(char) => char,
+            SequenceTerminator::Kitty => 'u',
+        }
+    }
+}
+
+bitflags::bitflags! {
+    /// The modifiers encoding for escape sequence.
+    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+    struct SequenceModifiers : u8 {
+        const SHIFT   = 0b0000_0001;
+        const ALT     = 0b0000_0010;
+        const CONTROL = 0b0000_0100;
+        const SUPER   = 0b0000_1000;
+        // NOTE: Kitty protocol defines additional modifiers to what is present here, like
+        // Capslock, but it's not a modifier as per winit.
+    }
+}
+
+impl SequenceModifiers {
+    /// Get the value which should be passed to escape sequence.
+    pub fn encode_esc_sequence(self) -> u8 {
+        self.bits() + 1
+    }
+}
+
+impl From<ModifiersState> for SequenceModifiers {
+    fn from(mods: ModifiersState) -> Self {
+        let mut modifiers = Self::empty();
+        modifiers.set(Self::SHIFT, mods.shift_key());
+        modifiers.set(Self::ALT, mods.alt_key());
+        modifiers.set(Self::CONTROL, mods.control_key());
+        modifiers.set(Self::SUPER, mods.super_key());
+        modifiers
+    }
+}
diff --git a/alacritty/src/input/mod.rs b/alacritty/src/input/mod.rs
new file mode 100644
index 00000000..584b8240
--- /dev/null
+++ b/alacritty/src/input/mod.rs
@@ -0,0 +1,1503 @@
+//! Handle input from winit.
+//!
+//! Certain key combinations should send some escape sequence back to the PTY.
+//! In order to figure that out, state about which modifier keys are pressed
+//! needs to be tracked. Additionally, we need a bit of a state machine to
+//! determine what to do when a non-modifier key is pressed.
+
+use std::borrow::Cow;
+use std::cmp::{max, min, Ordering};
+use std::collections::HashSet;
+use std::ffi::OsStr;
+use std::fmt::Debug;
+use std::marker::PhantomData;
+use std::mem;
+use std::time::{Duration, Instant};
+
+use log::debug;
+use winit::dpi::PhysicalPosition;
+use winit::event::{
+    ElementState, Modifiers, MouseButton, MouseScrollDelta, Touch as TouchEvent, TouchPhase,
+};
+use winit::event_loop::EventLoopWindowTarget;
+use winit::keyboard::ModifiersState;
+#[cfg(target_os = "macos")]
+use winit::platform::macos::EventLoopWindowTargetExtMacOS;
+use winit::window::CursorIcon;
+
+use alacritty_terminal::event::EventListener;
+use alacritty_terminal::grid::{Dimensions, Scroll};
+use alacritty_terminal::index::{Boundary, Column, Direction, Point, Side};
+use alacritty_terminal::selection::SelectionType;
+use alacritty_terminal::term::search::Match;
+use alacritty_terminal::term::{ClipboardType, Term, TermMode};
+use alacritty_terminal::vi_mode::ViMotion;
+use alacritty_terminal::vte::ansi::{ClearMode, Handler};
+
+use crate::clipboard::Clipboard;
+use crate::config::{Action, BindingMode, MouseAction, SearchAction, UiConfig, ViAction};
+use crate::display::hint::HintMatch;
+use crate::display::window::Window;
+use crate::display::{Display, SizeInfo};
+use crate::event::{
+    ClickState, Event, EventType, InlineSearchState, Mouse, TouchPurpose, TouchZoom,
+};
+use crate::message_bar::{self, Message};
+use crate::scheduler::{Scheduler, TimerId, Topic};
+
+pub mod keyboard;
+
+/// Font size change interval.
+pub const FONT_SIZE_STEP: f32 = 0.5;
+
+/// Interval for mouse scrolling during selection outside of the boundaries.
+const SELECTION_SCROLLING_INTERVAL: Duration = Duration::from_millis(15);
+
+/// Minimum number of pixels at the bottom/top where selection scrolling is performed.
+const MIN_SELECTION_SCROLLING_HEIGHT: f64 = 5.;
+
+/// Number of pixels for increasing the selection scrolling speed factor by one.
+const SELECTION_SCROLLING_STEP: f64 = 20.;
+
+/// Distance before a touch input is considered a drag.
+const MAX_TAP_DISTANCE: f64 = 20.;
+
+/// Threshold used for double_click/triple_click.
+const CLICK_THRESHOLD: Duration = Duration::from_millis(400);
+
+/// Processes input from winit.
+///
+/// An escape sequence may be emitted in case specific keys or key combinations
+/// are activated.
+pub struct Processor<T: EventListener, A: ActionContext<T>> {
+    pub ctx: A,
+    _phantom: PhantomData<T>,
+}
+
+pub trait ActionContext<T: EventListener> {
+    fn write_to_pty<B: Into<Cow<'static, [u8]>>>(&self, _data: B) {}
+    fn mark_dirty(&mut self) {}
+    fn size_info(&self) -> SizeInfo;
+    fn copy_selection(&mut self, _ty: ClipboardType) {}
+    fn start_selection(&mut self, _ty: SelectionType, _point: Point, _side: Side) {}
+    fn toggle_selection(&mut self, _ty: SelectionType, _point: Point, _side: Side) {}
+    fn update_selection(&mut self, _point: Point, _side: Side) {}
+    fn clear_selection(&mut self) {}
+    fn selection_is_empty(&self) -> bool;
+    fn mouse_mut(&mut self) -> &mut Mouse;
+    fn mouse(&self) -> &Mouse;
+    fn touch_purpose(&mut self) -> &mut TouchPurpose;
+    fn modifiers(&mut self) -> &mut Modifiers;
+    fn scroll(&mut self, _scroll: Scroll) {}
+    fn window(&mut self) -> &mut Window;
+    fn display(&mut self) -> &mut Display;
+    fn terminal(&self) -> &Term<T>;
+    fn terminal_mut(&mut self) -> &mut Term<T>;
+    fn spawn_new_instance(&mut self) {}
+    #[cfg(target_os = "macos")]
+    fn create_new_window(&mut self, _tabbing_id: Option<String>) {}
+    #[cfg(not(target_os = "macos"))]
+    fn create_new_window(&mut self) {}
+    fn change_font_size(&mut self, _delta: f32) {}
+    fn reset_font_size(&mut self) {}
+    fn pop_message(&mut self) {}
+    fn message(&self) -> Option<&Message>;
+    fn config(&self) -> &UiConfig;
+    fn event_loop(&self) -> &EventLoopWindowTarget<Event>;
+    fn mouse_mode(&self) -> bool;
+    fn clipboard_mut(&mut self) -> &mut Clipboard;
+    fn scheduler_mut(&mut self) -> &mut Scheduler;
+    fn start_search(&mut self, _direction: Direction) {}
+    fn confirm_search(&mut self) {}
+    fn cancel_search(&mut self) {}
+    fn search_input(&mut self, _c: char) {}
+    fn search_pop_word(&mut self) {}
+    fn search_history_previous(&mut self) {}
+    fn search_history_next(&mut self) {}
+    fn search_next(&mut self, origin: Point, direction: Direction, side: Side) -> Option<Match>;
+    fn advance_search_origin(&mut self, _direction: Direction) {}
+    fn search_direction(&self) -> Direction;
+    fn search_active(&self) -> bool;
+    fn on_typing_start(&mut self) {}
+    fn toggle_vi_mode(&mut self) {}
+    fn inline_search_state(&mut self) -> &mut InlineSearchState;
+    fn start_inline_search(&mut self, _direction: Direction, _stop_short: bool) {}
+    fn inline_search_next(&mut self) {}
+    fn inline_search_previous(&mut self) {}
+    fn hint_input(&mut self, _character: char) {}
+    fn trigger_hint(&mut self, _hint: &HintMatch) {}
+    fn expand_selection(&mut self) {}
+    fn on_terminal_input_start(&mut self) {}
+    fn paste(&mut self, _text: &str, _bracketed: bool) {}
+    fn spawn_daemon<I, S>(&self, _program: &str, _args: I)
+    where
+        I: IntoIterator<Item = S> + Debug + Copy,
+        S: AsRef<OsStr>,
+    {
+    }
+}
+
+impl Action {
+    fn toggle_selection<T, A>(ctx: &mut A, ty: SelectionType)
+    where
+        A: ActionContext<T>,
+        T: EventListener,
+    {
+        ctx.toggle_selection(ty, ctx.terminal().vi_mode_cursor.point, Side::Left);
+
+        // Make sure initial selection is not empty.
+        if let Some(selection) = &mut ctx.terminal_mut().selection {
+            selection.include_all();
+        }
+    }
+}
+
+trait Execute<T: EventListener> {
+    fn execute<A: ActionContext<T>>(&self, ctx: &mut A);
+}
+
+impl<T: EventListener> Execute<T> for Action {
+    #[inline]
+    fn execute<A: ActionContext<T>>(&self, ctx: &mut A) {
+        match self {
+            Action::Esc(s) => ctx.paste(s, false),
+            Action::Command(program) => ctx.spawn_daemon(program.program(), program.args()),
+            Action::Hint(hint) => {
+                ctx.display().hint_state.start(hint.clone());
+                ctx.mark_dirty();
+            },
+            Action::ToggleViMode => {
+                ctx.on_typing_start();
+                ctx.toggle_vi_mode()
+            },
+            action @ (Action::ViMotion(_) | Action::Vi(_))
+                if !ctx.terminal().mode().contains(TermMode::VI) =>
+            {
+                debug!("Ignoring {action:?}: Vi mode inactive");
+            },
+            Action::ViMotion(motion) => {
+                ctx.on_typing_start();
+                ctx.terminal_mut().vi_motion(*motion);
+                ctx.mark_dirty();
+            },
+            Action::Vi(ViAction::ToggleNormalSelection) => {
+                Self::toggle_selection(ctx, SelectionType::Simple);
+            },
+            Action::Vi(ViAction::ToggleLineSelection) => {
+                Self::toggle_selection(ctx, SelectionType::Lines);
+            },
+            Action::Vi(ViAction::ToggleBlockSelection) => {
+                Self::toggle_selection(ctx, SelectionType::Block);
+            },
+            Action::Vi(ViAction::ToggleSemanticSelection) => {
+                Self::toggle_selection(ctx, SelectionType::Semantic);
+            },
+            Action::Vi(ViAction::Open) => {
+                let hint = ctx.display().vi_highlighted_hint.take();
+                if let Some(hint) = &hint {
+                    ctx.mouse_mut().block_hint_launcher = false;
+                    ctx.trigger_hint(hint);
+                }
+                ctx.display().vi_highlighted_hint = hint;
+            },
+            Action::Vi(ViAction::SearchNext) => {
+                ctx.on_typing_start();
+
+                let terminal = ctx.terminal();
+                let direction = ctx.search_direction();
+                let vi_point = terminal.vi_mode_cursor.point;
+                let origin = match direction {
+                    Direction::Right => vi_point.add(terminal, Boundary::None, 1),
+                    Direction::Left => vi_point.sub(terminal, Boundary::None, 1),
+                };
+
+                if let Some(regex_match) = ctx.search_next(origin, direction, Side::Left) {
+                    ctx.terminal_mut().vi_goto_point(*regex_match.start());
+                    ctx.mark_dirty();
+                }
+            },
+            Action::Vi(ViAction::SearchPrevious) => {
+                ctx.on_typing_start();
+
+                let terminal = ctx.terminal();
+                let direction = ctx.search_direction().opposite();
+                let vi_point = terminal.vi_mode_cursor.point;
+                let origin = match direction {
+                    Direction::Right => vi_point.add(terminal, Boundary::None, 1),
+                    Direction::Left => vi_point.sub(terminal, Boundary::None, 1),
+                };
+
+                if let Some(regex_match) = ctx.search_next(origin, direction, Side::Left) {
+                    ctx.terminal_mut().vi_goto_point(*regex_match.start());
+                    ctx.mark_dirty();
+                }
+            },
+            Action::Vi(ViAction::SearchStart) => {
+                let terminal = ctx.terminal();
+                let origin = terminal.vi_mode_cursor.point.sub(terminal, Boundary::None, 1);
+
+                if let Some(regex_match) = ctx.search_next(origin, Direction::Left, Side::Left) {
+                    ctx.terminal_mut().vi_goto_point(*regex_match.start());
+                    ctx.mark_dirty();
+                }
+            },
+            Action::Vi(ViAction::SearchEnd) => {
+                let terminal = ctx.terminal();
+                let origin = terminal.vi_mode_cursor.point.add(terminal, Boundary::None, 1);
+
+                if let Some(regex_match) = ctx.search_next(origin, Direction::Right, Side::Right) {
+                    ctx.terminal_mut().vi_goto_point(*regex_match.end());
+                    ctx.mark_dirty();
+                }
+            },
+            Action::Vi(ViAction::CenterAroundViCursor) => {
+                let term = ctx.terminal();
+                let display_offset = term.grid().display_offset() as i32;
+                let target = -display_offset + term.screen_lines() as i32 / 2 - 1;
+                let line = term.vi_mode_cursor.point.line;
+                let scroll_lines = target - line.0;
+
+                ctx.scroll(Scroll::Delta(scroll_lines));
+            },
+            Action::Vi(ViAction::InlineSearchForward) => {
+                ctx.start_inline_search(Direction::Right, false)
+            },
+            Action::Vi(ViAction::InlineSearchBackward) => {
+                ctx.start_inline_search(Direction::Left, false)
+            },
+            Action::Vi(ViAction::InlineSearchForwardShort) => {
+                ctx.start_inline_search(Direction::Right, true)
+            },
+            Action::Vi(ViAction::InlineSearchBackwardShort) => {
+                ctx.start_inline_search(Direction::Left, true)
+            },
+            Action::Vi(ViAction::InlineSearchNext) => ctx.inline_search_next(),
+            Action::Vi(ViAction::InlineSearchPrevious) => ctx.inline_search_previous(),
+            action @ Action::Search(_) if !ctx.search_active() => {
+                debug!("Ignoring {action:?}: Search mode inactive");
+            },
+            Action::Search(SearchAction::SearchFocusNext) => {
+                ctx.advance_search_origin(ctx.search_direction());
+            },
+            Action::Search(SearchAction::SearchFocusPrevious) => {
+                let direction = ctx.search_direction().opposite();
+                ctx.advance_search_origin(direction);
+            },
+            Action::Search(SearchAction::SearchConfirm) => ctx.confirm_search(),
+            Action::Search(SearchAction::SearchCancel) => ctx.cancel_search(),
+            Action::Search(SearchAction::SearchClear) => {
+                let direction = ctx.search_direction();
+                ctx.cancel_search();
+                ctx.start_search(direction);
+            },
+            Action::Search(SearchAction::SearchDeleteWord) => ctx.search_pop_word(),
+            Action::Search(SearchAction::SearchHistoryPrevious) => ctx.search_history_previous(),
+            Action::Search(SearchAction::SearchHistoryNext) => ctx.search_history_next(),
+            Action::Mouse(MouseAction::ExpandSelection) => ctx.expand_selection(),
+            Action::SearchForward => ctx.start_search(Direction::Right),
+            Action::SearchBackward => ctx.start_search(Direction::Left),
+            Action::Copy => ctx.copy_selection(ClipboardType::Clipboard),
+            #[cfg(not(any(target_os = "macos", windows)))]
+            Action::CopySelection => ctx.copy_selection(ClipboardType::Selection),
+            Action::ClearSelection => ctx.clear_selection(),
+            Action::Paste => {
+                let text = ctx.clipboard_mut().load(ClipboardType::Clipboard);
+                ctx.paste(&text, true);
+            },
+            Action::PasteSelection => {
+                let text = ctx.clipboard_mut().load(ClipboardType::Selection);
+                ctx.paste(&text, true);
+            },
+            Action::ToggleFullscreen => ctx.window().toggle_fullscreen(),
+            Action::ToggleMaximized => ctx.window().toggle_maximized(),
+            #[cfg(target_os = "macos")]
+            Action::ToggleSimpleFullscreen => ctx.window().toggle_simple_fullscreen(),
+            #[cfg(target_os = "macos")]
+            Action::Hide => ctx.event_loop().hide_application(),
+            #[cfg(target_os = "macos")]
+            Action::HideOtherApplications => ctx.event_loop().hide_other_applications(),
+            #[cfg(not(target_os = "macos"))]
+            Action::Hide => ctx.window().set_visible(false),
+            Action::Minimize => ctx.window().set_minimized(true),
+            Action::Quit => ctx.terminal_mut().exit(),
+            Action::IncreaseFontSize => ctx.change_font_size(FONT_SIZE_STEP),
+            Action::DecreaseFontSize => ctx.change_font_size(FONT_SIZE_STEP * -1.),
+            Action::ResetFontSize => ctx.reset_font_size(),
+            Action::ScrollPageUp
+            | Action::ScrollPageDown
+            | Action::ScrollHalfPageUp
+            | Action::ScrollHalfPageDown => {
+                // Move vi mode cursor.
+                let term = ctx.terminal_mut();
+                let (scroll, amount) = match self {
+                    Action::ScrollPageUp => (Scroll::PageUp, term.screen_lines() as i32),
+                    Action::ScrollPageDown => (Scroll::PageDown, -(term.screen_lines() as i32)),
+                    Action::ScrollHalfPageUp => {
+                        let amount = term.screen_lines() as i32 / 2;
+                        (Scroll::Delta(amount), amount)
+                    },
+                    Action::ScrollHalfPageDown => {
+                        let amount = -(term.screen_lines() as i32 / 2);
+                        (Scroll::Delta(amount), amount)
+                    },
+                    _ => unreachable!(),
+                };
+
+                let old_vi_cursor = term.vi_mode_cursor;
+                term.vi_mode_cursor = term.vi_mode_cursor.scroll(term, amount);
+                if old_vi_cursor != term.vi_mode_cursor {
+                    ctx.mark_dirty();
+                }
+
+                ctx.scroll(scroll);
+            },
+            Action::ScrollLineUp => ctx.scroll(Scroll::Delta(1)),
+            Action::ScrollLineDown => ctx.scroll(Scroll::Delta(-1)),
+            Action::ScrollToTop => {
+                ctx.scroll(Scroll::Top);
+
+                // Move vi mode cursor.
+                let topmost_line = ctx.terminal().topmost_line();
+                ctx.terminal_mut().vi_mode_cursor.point.line = topmost_line;
+                ctx.terminal_mut().vi_motion(ViMotion::FirstOccupied);
+                ctx.mark_dirty();
+            },
+            Action::ScrollToBottom => {
+                ctx.scroll(Scroll::Bottom);
+
+                // Move vi mode cursor.
+                let term = ctx.terminal_mut();
+                term.vi_mode_cursor.point.line = term.bottommost_line();
+
+                // Move to beginning twice, to always jump across linewraps.
+                term.vi_motion(ViMotion::FirstOccupied);
+                term.vi_motion(ViMotion::FirstOccupied);
+                ctx.mark_dirty();
+            },
+            Action::ClearHistory => ctx.terminal_mut().clear_screen(ClearMode::Saved),
+            Action::ClearLogNotice => ctx.pop_message(),
+            #[cfg(not(target_os = "macos"))]
+            Action::CreateNewWindow => ctx.create_new_window(),
+            Action::SpawnNewInstance => ctx.spawn_new_instance(),
+            #[cfg(target_os = "macos")]
+            Action::CreateNewWindow => ctx.create_new_window(None),
+            #[cfg(target_os = "macos")]
+            Action::CreateNewTab => {
+                let tabbing_id = Some(ctx.window().tabbing_id());
+                ctx.create_new_window(tabbing_id);
+            },
+            #[cfg(target_os = "macos")]
+            Action::SelectNextTab => ctx.window().select_next_tab(),
+            #[cfg(target_os = "macos")]
+            Action::SelectPreviousTab => ctx.window().select_previous_tab(),
+            #[cfg(target_os = "macos")]
+            Action::SelectTab1 => ctx.window().select_tab_at_index(0),
+            #[cfg(target_os = "macos")]
+            Action::SelectTab2 => ctx.window().select_tab_at_index(1),
+            #[cfg(target_os = "macos")]
+            Action::SelectTab3 => ctx.window().select_tab_at_index(2),
+            #[cfg(target_os = "macos")]
+            Action::SelectTab4 => ctx.window().select_tab_at_index(3),
+            #[cfg(target_os = "macos")]
+            Action::SelectTab5 => ctx.window().select_tab_at_index(4),
+            #[cfg(target_os = "macos")]
+            Action::SelectTab6 => ctx.window().select_tab_at_index(5),
+            #[cfg(target_os = "macos")]
+            Action::SelectTab7 => ctx.window().select_tab_at_index(6),
+            #[cfg(target_os = "macos")]
+            Action::SelectTab8 => ctx.window().select_tab_at_index(7),
+            #[cfg(target_os = "macos")]
+            Action::SelectTab9 => ctx.window().select_tab_at_index(8),
+            #[cfg(target_os = "macos")]
+            Action::SelectLastTab => ctx.window().select_last_tab(),
+            Action::ReceiveChar | Action::None => (),
+        }
+    }
+}
+
+impl<T: EventListener, A: ActionContext<T>> Processor<T, A> {
+    pub fn new(ctx: A) -> Self {
+        Self { ctx, _phantom: Default::default() }
+    }
+
+    #[inline]
+    pub fn mouse_moved(&mut self, position: PhysicalPosition<f64>) {
+        let size_info = self.ctx.size_info();
+
+        let (x, y) = position.into();
+
+        let lmb_pressed = self.ctx.mouse().left_button_state == ElementState::Pressed;
+        let rmb_pressed = self.ctx.mouse().right_button_state == ElementState::Pressed;
+        if !self.ctx.selection_is_empty() && (lmb_pressed || rmb_pressed) {
+            self.update_selection_scrolling(y);
+        }
+
+        let display_offset = self.ctx.terminal().grid().display_offset();
+        let old_point = self.ctx.mouse().point(&size_info, display_offset);
+
+        let x = x.clamp(0, size_info.width() as i32 - 1) as usize;
+        let y = y.clamp(0, size_info.height() as i32 - 1) as usize;
+        self.ctx.mouse_mut().x = x;
+        self.ctx.mouse_mut().y = y;
+
+        let inside_text_area = size_info.contains_point(x, y);
+        let cell_side = self.cell_side(x);
+
+        let point = self.ctx.mouse().point(&size_info, display_offset);
+        let cell_changed = old_point != point;
+
+        // If the mouse hasn't changed cells, do nothing.
+        if !cell_changed
+            && self.ctx.mouse().cell_side == cell_side
+            && self.ctx.mouse().inside_text_area == inside_text_area
+        {
+            return;
+        }
+
+        self.ctx.mouse_mut().inside_text_area = inside_text_area;
+        self.ctx.mouse_mut().cell_side = cell_side;
+
+        // Update mouse state and check for URL change.
+        let mouse_state = self.cursor_state();
+        self.ctx.window().set_mouse_cursor(mouse_state);
+
+        // Prompt hint highlight update.
+        self.ctx.mouse_mut().hint_highlight_dirty = true;
+
+        // Don't launch URLs if mouse has moved.
+        self.ctx.mouse_mut().block_hint_launcher = true;
+
+        if (lmb_pressed || rmb_pressed)
+            && (self.ctx.modifiers().state().shift_key() || !self.ctx.mouse_mode())
+        {
+            self.ctx.update_selection(point, cell_side);
+        } else if cell_changed
+            && self.ctx.terminal().mode().intersects(TermMode::MOUSE_MOTION | TermMode::MOUSE_DRAG)
+        {
+            if lmb_pressed {
+                self.mouse_report(32, ElementState::Pressed);
+            } else if self.ctx.mouse().middle_button_state == ElementState::Pressed {
+                self.mouse_report(33, ElementState::Pressed);
+            } else if self.ctx.mouse().right_button_state == ElementState::Pressed {
+                self.mouse_report(34, ElementState::Pressed);
+            } else if self.ctx.terminal().mode().contains(TermMode::MOUSE_MOTION) {
+                self.mouse_report(35, ElementState::Pressed);
+            }
+        }
+    }
+
+    /// Check which side of a cell an X coordinate lies on.
+    fn cell_side(&self, x: usize) -> Side {
+        let size_info = self.ctx.size_info();
+
+        let cell_x =
+            x.saturating_sub(size_info.padding_x() as usize) % size_info.cell_width() as usize;
+        let half_cell_width = (size_info.cell_width() / 2.0) as usize;
+
+        let additional_padding =
+            (size_info.width() - size_info.padding_x() * 2.) % size_info.cell_width();
+        let end_of_grid = size_info.width() - size_info.padding_x() - additional_padding;
+
+        if cell_x > half_cell_width
+            // Edge case when mouse leaves the window.
+            || x as f32 >= end_of_grid
+        {
+            Side::Right
+        } else {
+            Side::Left
+        }
+    }
+
+    fn mouse_report(&mut self, button: u8, state: ElementState) {
+        let display_offset = self.ctx.terminal().grid().display_offset();
+        let point = self.ctx.mouse().point(&self.ctx.size_info(), display_offset);
+
+        // Assure the mouse point is not in the scrollback.
+        if point.line < 0 {
+            return;
+        }
+
+        // Calculate modifiers value.
+        let mut mods = 0;
+        let modifiers = self.ctx.modifiers().state();
+        if modifiers.shift_key() {
+            mods += 4;
+        }
+        if modifiers.alt_key() {
+            mods += 8;
+        }
+        if modifiers.control_key() {
+            mods += 16;
+        }
+
+        // Report mouse events.
+        if self.ctx.terminal().mode().contains(TermMode::SGR_MOUSE) {
+            self.sgr_mouse_report(point, button + mods, state);
+        } else if let ElementState::Released = state {
+            self.normal_mouse_report(point, 3 + mods);
+        } else {
+            self.normal_mouse_report(point, button + mods);
+        }
+    }
+
+    fn normal_mouse_report(&mut self, point: Point, button: u8) {
+        let Point { line, column } = point;
+        let utf8 = self.ctx.terminal().mode().contains(TermMode::UTF8_MOUSE);
+
+        let max_point = if utf8 { 2015 } else { 223 };
+
+        if line >= max_point || column >= max_point {
+            return;
+        }
+
+        let mut msg = vec![b'\x1b', b'[', b'M', 32 + button];
+
+        let mouse_pos_encode = |pos: usize| -> Vec<u8> {
+            let pos = 32 + 1 + pos;
+            let first = 0xC0 + pos / 64;
+            let second = 0x80 + (pos & 63);
+            vec![first as u8, second as u8]
+        };
+
+        if utf8 && column >= Column(95) {
+            msg.append(&mut mouse_pos_encode(column.0));
+        } else {
+            msg.push(32 + 1 + column.0 as u8);
+        }
+
+        if utf8 && line >= 95 {
+            msg.append(&mut mouse_pos_encode(line.0 as usize));
+        } else {
+            msg.push(32 + 1 + line.0 as u8);
+        }
+
+        self.ctx.write_to_pty(msg);
+    }
+
+    fn sgr_mouse_report(&mut self, point: Point, button: u8, state: ElementState) {
+        let c = match state {
+            ElementState::Pressed => 'M',
+            ElementState::Released => 'm',
+        };
+
+        let msg = format!("\x1b[<{};{};{}{}", button, point.column + 1, point.line + 1, c);
+        self.ctx.write_to_pty(msg.into_bytes());
+    }
+
+    fn on_mouse_press(&mut self, button: MouseButton) {
+        // Handle mouse mode.
+        if !self.ctx.modifiers().state().shift_key() && self.ctx.mouse_mode() {
+            self.ctx.mouse_mut().click_state = ClickState::None;
+
+            let code = match button {
+                MouseButton::Left => 0,
+                MouseButton::Middle => 1,
+                MouseButton::Right => 2,
+                // Can't properly report more than three buttons..
+                MouseButton::Back | MouseButton::Forward | MouseButton::Other(_) => return,
+            };
+
+            self.mouse_report(code, ElementState::Pressed);
+        } else {
+            // Calculate time since the last click to handle double/triple clicks.
+            let now = Instant::now();
+            let elapsed = now - self.ctx.mouse().last_click_timestamp;
+            self.ctx.mouse_mut().last_click_timestamp = now;
+
+            // Update multi-click state.
+            self.ctx.mouse_mut().click_state = match self.ctx.mouse().click_state {
+                // Reset click state if button has changed.
+                _ if button != self.ctx.mouse().last_click_button => {
+                    self.ctx.mouse_mut().last_click_button = button;
+                    ClickState::Click
+                },
+                ClickState::Click if elapsed < CLICK_THRESHOLD => ClickState::DoubleClick,
+                ClickState::DoubleClick if elapsed < CLICK_THRESHOLD => ClickState::TripleClick,
+                _ => ClickState::Click,
+            };
+
+            // Load mouse point, treating message bar and padding as the closest cell.
+            let display_offset = self.ctx.terminal().grid().display_offset();
+            let point = self.ctx.mouse().point(&self.ctx.size_info(), display_offset);
+
+            if let MouseButton::Left = button {
+                self.on_left_click(point)
+            }
+        }
+    }
+
+    /// Handle left click selection and vi mode cursor movement.
+    fn on_left_click(&mut self, point: Point) {
+        let side = self.ctx.mouse().cell_side;
+
+        match self.ctx.mouse().click_state {
+            ClickState::Click => {
+                // Don't launch URLs if this click cleared the selection.
+                self.ctx.mouse_mut().block_hint_launcher = !self.ctx.selection_is_empty();
+
+                self.ctx.clear_selection();
+
+                // Start new empty selection.
+                if self.ctx.modifiers().state().control_key() {
+                    self.ctx.start_selection(SelectionType::Block, point, side);
+                } else {
+                    self.ctx.start_selection(SelectionType::Simple, point, side);
+                }
+            },
+            ClickState::DoubleClick => {
+                self.ctx.mouse_mut().block_hint_launcher = true;
+                self.ctx.start_selection(SelectionType::Semantic, point, side);
+            },
+            ClickState::TripleClick => {
+                self.ctx.mouse_mut().block_hint_launcher = true;
+                self.ctx.start_selection(SelectionType::Lines, point, side);
+            },
+            ClickState::None => (),
+        };
+
+        // Move vi mode cursor to mouse click position.
+        if self.ctx.terminal().mode().contains(TermMode::VI) && !self.ctx.search_active() {
+            self.ctx.terminal_mut().vi_mode_cursor.point = point;
+            self.ctx.mark_dirty();
+        }
+    }
+
+    fn on_mouse_release(&mut self, button: MouseButton) {
+        if !self.ctx.modifiers().state().shift_key() && self.ctx.mouse_mode() {
+            let code = match button {
+                MouseButton::Left => 0,
+                MouseButton::Middle => 1,
+                MouseButton::Right => 2,
+                // Can't properly report more than three buttons.
+                MouseButton::Back | MouseButton::Forward | MouseButton::Other(_) => return,
+            };
+            self.mouse_report(code, ElementState::Released);
+            return;
+        }
+
+        // Trigger hints highlighted by the mouse.
+        let hint = self.ctx.display().highlighted_hint.take();
+        if let Some(hint) = hint.as_ref().filter(|_| button == MouseButton::Left) {
+            self.ctx.trigger_hint(hint);
+        }
+        self.ctx.display().highlighted_hint = hint;
+
+        let timer_id = TimerId::new(Topic::SelectionScrolling, self.ctx.window().id());
+        self.ctx.scheduler_mut().unschedule(timer_id);
+
+        if let MouseButton::Left | MouseButton::Right = button {
+            // Copy selection on release, to prevent flooding the display server.
+            self.ctx.copy_selection(ClipboardType::Selection);
+        }
+    }
+
+    pub fn mouse_wheel_input(&mut self, delta: MouseScrollDelta, phase: TouchPhase) {
+        let multiplier = self.ctx.config().scrolling.multiplier;
+        match delta {
+            MouseScrollDelta::LineDelta(columns, lines) => {
+                let new_scroll_px_x = columns * self.ctx.size_info().cell_width();
+                let new_scroll_px_y = lines * self.ctx.size_info().cell_height();
+                self.scroll_terminal(
+                    new_scroll_px_x as f64,
+                    new_scroll_px_y as f64,
+                    multiplier as f64,
+                );
+            },
+            MouseScrollDelta::PixelDelta(mut lpos) => {
+                match phase {
+                    TouchPhase::Started => {
+                        // Reset offset to zero.
+                        self.ctx.mouse_mut().accumulated_scroll = Default::default();
+                    },
+                    TouchPhase::Moved => {
+                        // When the angle between (x, 0) and (x, y) is lower than ~25 degrees
+                        // (cosine is larger that 0.9) we consider this scrolling as horizontal.
+                        if lpos.x.abs() / lpos.x.hypot(lpos.y) > 0.9 {
+                            lpos.y = 0.;
+                        } else {
+                            lpos.x = 0.;
+                        }
+
+                        self.scroll_terminal(lpos.x, lpos.y, multiplier as f64);
+                    },
+                    _ => (),
+                }
+            },
+        }
+    }
+
+    fn scroll_terminal(&mut self, new_scroll_x_px: f64, new_scroll_y_px: f64, multiplier: f64) {
+        const MOUSE_WHEEL_UP: u8 = 64;
+        const MOUSE_WHEEL_DOWN: u8 = 65;
+        const MOUSE_WHEEL_LEFT: u8 = 66;
+        const MOUSE_WHEEL_RIGHT: u8 = 67;
+
+        let width = f64::from(self.ctx.size_info().cell_width());
+        let height = f64::from(self.ctx.size_info().cell_height());
+
+        if self.ctx.mouse_mode() {
+            self.ctx.mouse_mut().accumulated_scroll.x += new_scroll_x_px;
+            self.ctx.mouse_mut().accumulated_scroll.y += new_scroll_y_px;
+
+            let code = if new_scroll_y_px > 0. { MOUSE_WHEEL_UP } else { MOUSE_WHEEL_DOWN };
+            let lines = (self.ctx.mouse().accumulated_scroll.y / height).abs() as i32;
+
+            for _ in 0..lines {
+                self.mouse_report(code, ElementState::Pressed);
+            }
+
+            let code = if new_scroll_x_px > 0. { MOUSE_WHEEL_LEFT } else { MOUSE_WHEEL_RIGHT };
+            let columns = (self.ctx.mouse().accumulated_scroll.x / width).abs() as i32;
+
+            for _ in 0..columns {
+                self.mouse_report(code, ElementState::Pressed);
+            }
+        } else if self
+            .ctx
+            .terminal()
+            .mode()
+            .contains(TermMode::ALT_SCREEN | TermMode::ALTERNATE_SCROLL)
+            && !self.ctx.modifiers().state().shift_key()
+        {
+            self.ctx.mouse_mut().accumulated_scroll.x += new_scroll_x_px * multiplier;
+            self.ctx.mouse_mut().accumulated_scroll.y += new_scroll_y_px * multiplier;
+
+            // The chars here are the same as for the respective arrow keys.
+            let line_cmd = if new_scroll_y_px > 0. { b'A' } else { b'B' };
+            let column_cmd = if new_scroll_x_px > 0. { b'D' } else { b'C' };
+
+            let lines = (self.ctx.mouse().accumulated_scroll.y / height).abs() as usize;
+            let columns = (self.ctx.mouse().accumulated_scroll.x / width).abs() as usize;
+
+            let mut content = Vec::with_capacity(3 * (lines + columns));
+
+            for _ in 0..lines {
+                content.push(0x1b);
+                content.push(b'O');
+                content.push(line_cmd);
+            }
+
+            for _ in 0..columns {
+                content.push(0x1b);
+                content.push(b'O');
+                content.push(column_cmd);
+            }
+
+            self.ctx.write_to_pty(content);
+        } else {
+            self.ctx.mouse_mut().accumulated_scroll.y += new_scroll_y_px * multiplier;
+
+            let lines = (self.ctx.mouse().accumulated_scroll.y / height) as i32;
+
+            if lines != 0 {
+                self.ctx.scroll(Scroll::Delta(lines));
+            }
+        }
+
+        self.ctx.mouse_mut().accumulated_scroll.x %= width;
+        self.ctx.mouse_mut().accumulated_scroll.y %= height;
+    }
+
+    pub fn on_focus_change(&mut self, is_focused: bool) {
+        if self.ctx.terminal().mode().contains(TermMode::FOCUS_IN_OUT) {
+            let chr = if is_focused { "I" } else { "O" };
+
+            let msg = format!("\x1b[{}", chr);
+            self.ctx.write_to_pty(msg.into_bytes());
+        }
+    }
+
+    /// Handle touch input.
+    pub fn touch(&mut self, touch: TouchEvent) {
+        match touch.phase {
+            TouchPhase::Started => self.on_touch_start(touch),
+            TouchPhase::Moved => self.on_touch_motion(touch),
+            TouchPhase::Ended | TouchPhase::Cancelled => self.on_touch_end(touch),
+        }
+    }
+
+    /// Handle beginning of touch input.
+    pub fn on_touch_start(&mut self, touch: TouchEvent) {
+        let touch_purpose = self.ctx.touch_purpose();
+        *touch_purpose = match mem::take(touch_purpose) {
+            TouchPurpose::None => TouchPurpose::Tap(touch),
+            TouchPurpose::Tap(start) => TouchPurpose::Zoom(TouchZoom::new((start, touch))),
+            TouchPurpose::Zoom(zoom) => TouchPurpose::Invalid(zoom.slots()),
+            TouchPurpose::Scroll(event) | TouchPurpose::Select(event) => {
+                let mut set = HashSet::default();
+                set.insert(event.id);
+                TouchPurpose::Invalid(set)
+            },
+            TouchPurpose::Invalid(mut slots) => {
+                slots.insert(touch.id);
+                TouchPurpose::Invalid(slots)
+            },
+        };
+    }
+
+    /// Handle touch input movement.
+    pub fn on_touch_motion(&mut self, touch: TouchEvent) {
+        let touch_purpose = self.ctx.touch_purpose();
+        match touch_purpose {
+            TouchPurpose::None => (),
+            // Handle transition from tap to scroll/select.
+            TouchPurpose::Tap(start) => {
+                let delta_x = touch.location.x - start.location.x;
+                let delta_y = touch.location.y - start.location.y;
+                if delta_x.abs() > MAX_TAP_DISTANCE {
+                    // Update gesture state.
+                    let start_location = start.location;
+                    *touch_purpose = TouchPurpose::Select(*start);
+
+                    // Start simulated mouse input.
+                    self.mouse_moved(start_location);
+                    self.mouse_input(ElementState::Pressed, MouseButton::Left);
+
+                    // Apply motion since touch start.
+                    self.on_touch_motion(touch);
+                } else if delta_y.abs() > MAX_TAP_DISTANCE {
+                    // Update gesture state.
+                    *touch_purpose = TouchPurpose::Scroll(*start);
+
+                    // Apply motion since touch start.
+                    self.on_touch_motion(touch);
+                }
+            },
+            TouchPurpose::Zoom(zoom) => {
+                let font_delta = zoom.font_delta(touch);
+                self.ctx.change_font_size(font_delta);
+            },
+            TouchPurpose::Scroll(last_touch) => {
+                // Calculate delta and update last touch position.
+                let delta_y = touch.location.y - last_touch.location.y;
+                *touch_purpose = TouchPurpose::Scroll(touch);
+
+                // Use a fixed scroll factor for touchscreens, to accurately track finger motion.
+                self.scroll_terminal(0., delta_y, 1.0);
+            },
+            TouchPurpose::Select(_) => self.mouse_moved(touch.location),
+            TouchPurpose::Invalid(_) => (),
+        }
+    }
+
+    /// Handle end of touch input.
+    pub fn on_touch_end(&mut self, touch: TouchEvent) {
+        // Finalize the touch motion up to the release point.
+        self.on_touch_motion(touch);
+
+        let touch_purpose = self.ctx.touch_purpose();
+        match touch_purpose {
+            // Simulate LMB clicks.
+            TouchPurpose::Tap(start) => {
+                let start_location = start.location;
+                *touch_purpose = Default::default();
+
+                self.mouse_moved(start_location);
+                self.mouse_input(ElementState::Pressed, MouseButton::Left);
+                self.mouse_input(ElementState::Released, MouseButton::Left);
+            },
+            // Invalidate zoom once a finger was released.
+            TouchPurpose::Zoom(zoom) => {
+                let mut slots = zoom.slots();
+                slots.remove(&touch.id);
+                *touch_purpose = TouchPurpose::Invalid(slots);
+            },
+            // Reset touch state once all slots were released.
+            TouchPurpose::Invalid(slots) => {
+                slots.remove(&touch.id);
+                if slots.is_empty() {
+                    *touch_purpose = Default::default();
+                }
+            },
+            // Release simulated LMB.
+            TouchPurpose::Select(_) => {
+                *touch_purpose = Default::default();
+                self.mouse_input(ElementState::Released, MouseButton::Left);
+            },
+            // Reset touch state on scroll finish.
+            TouchPurpose::Scroll(_) => *touch_purpose = Default::default(),
+            TouchPurpose::None => (),
+        }
+    }
+
+    /// Reset mouse cursor based on modifier and terminal state.
+    #[inline]
+    pub fn reset_mouse_cursor(&mut self) {
+        let mouse_state = self.cursor_state();
+        self.ctx.window().set_mouse_cursor(mouse_state);
+    }
+
+    /// Modifier state change.
+    pub fn modifiers_input(&mut self, modifiers: Modifiers) {
+        *self.ctx.modifiers() = modifiers;
+
+        // Prompt hint highlight update.
+        self.ctx.mouse_mut().hint_highlight_dirty = true;
+
+        // Update mouse state and check for URL change.
+        let mouse_state = self.cursor_state();
+        self.ctx.window().set_mouse_cursor(mouse_state);
+    }
+
+    pub fn mouse_input(&mut self, state: ElementState, button: MouseButton) {
+        match button {
+            MouseButton::Left => self.ctx.mouse_mut().left_button_state = state,
+            MouseButton::Middle => self.ctx.mouse_mut().middle_button_state = state,
+            MouseButton::Right => self.ctx.mouse_mut().right_button_state = state,
+            _ => (),
+        }
+
+        // Skip normal mouse events if the message bar has been clicked.
+        if self.message_bar_cursor_state() == Some(CursorIcon::Pointer)
+            && state == ElementState::Pressed
+        {
+            let size = self.ctx.size_info();
+
+            let current_lines = self.ctx.message().map_or(0, |m| m.text(&size).len());
+
+            self.ctx.clear_selection();
+            self.ctx.pop_message();
+
+            // Reset cursor when message bar height changed or all messages are gone.
+            let new_lines = self.ctx.message().map_or(0, |m| m.text(&size).len());
+
+            let new_icon = match current_lines.cmp(&new_lines) {
+                Ordering::Less => CursorIcon::Default,
+                Ordering::Equal => CursorIcon::Pointer,
+                Ordering::Greater => {
+                    if self.ctx.mouse_mode() {
+                        CursorIcon::Default
+                    } else {
+                        CursorIcon::Text
+                    }
+                },
+            };
+
+            self.ctx.window().set_mouse_cursor(new_icon);
+        } else {
+            match state {
+                ElementState::Pressed => {
+                    // Process mouse press before bindings to update the `click_state`.
+                    self.on_mouse_press(button);
+                    self.process_mouse_bindings(button);
+                },
+                ElementState::Released => self.on_mouse_release(button),
+            }
+        }
+    }
+
+    /// Attempt to find a binding and execute its action.
+    ///
+    /// The provided mode, mods, and key must match what is allowed by a binding
+    /// for its action to be executed.
+    fn process_mouse_bindings(&mut self, button: MouseButton) {
+        let mode = BindingMode::new(self.ctx.terminal().mode(), self.ctx.search_active());
+        let mouse_mode = self.ctx.mouse_mode();
+        let mods = self.ctx.modifiers().state();
+        let mouse_bindings = self.ctx.config().mouse_bindings().to_owned();
+
+        // If mouse mode is active, also look for bindings without shift.
+        let mut check_fallback = mouse_mode && mods.contains(ModifiersState::SHIFT);
+
+        for binding in &mouse_bindings {
+            if binding.is_triggered_by(mode, mods, &button) {
+                binding.action.execute(&mut self.ctx);
+                check_fallback = false;
+            }
+        }
+
+        if check_fallback {
+            let fallback_mods = mods & !ModifiersState::SHIFT;
+            for binding in &mouse_bindings {
+                if binding.is_triggered_by(mode, fallback_mods, &button) {
+                    binding.action.execute(&mut self.ctx);
+                }
+            }
+        }
+    }
+
+    /// Check mouse icon state in relation to the message bar.
+    fn message_bar_cursor_state(&self) -> Option<CursorIcon> {
+        // Since search is above the message bar, the button is offset by search's height.
+        let search_height = usize::from(self.ctx.search_active());
+
+        // Calculate Y position of the end of the last terminal line.
+        let size = self.ctx.size_info();
+        let terminal_end = size.padding_y() as usize
+            + size.cell_height() as usize * (size.screen_lines() + search_height);
+
+        let mouse = self.ctx.mouse();
+        let display_offset = self.ctx.terminal().grid().display_offset();
+        let point = self.ctx.mouse().point(&self.ctx.size_info(), display_offset);
+
+        if self.ctx.message().is_none() || (mouse.y <= terminal_end) {
+            None
+        } else if mouse.y <= terminal_end + size.cell_height() as usize
+            && point.column + message_bar::CLOSE_BUTTON_TEXT.len() >= size.columns()
+        {
+            Some(CursorIcon::Pointer)
+        } else {
+            Some(CursorIcon::Default)
+        }
+    }
+
+    /// Icon state of the cursor.
+    fn cursor_state(&mut self) -> CursorIcon {
+        let display_offset = self.ctx.terminal().grid().display_offset();
+        let point = self.ctx.mouse().point(&self.ctx.size_info(), display_offset);
+        let hyperlink = self.ctx.terminal().grid()[point].hyperlink();
+
+        // Function to check if mouse is on top of a hint.
+        let hint_highlighted = |hint: &HintMatch| hint.should_highlight(point, hyperlink.as_ref());
+
+        if let Some(mouse_state) = self.message_bar_cursor_state() {
+            mouse_state
+        } else if self.ctx.display().highlighted_hint.as_ref().map_or(false, hint_highlighted) {
+            CursorIcon::Pointer
+        } else if !self.ctx.modifiers().state().shift_key() && self.ctx.mouse_mode() {
+            CursorIcon::Default
+        } else {
+            CursorIcon::Text
+        }
+    }
+
+    /// Handle automatic scrolling when selecting above/below the window.
+    fn update_selection_scrolling(&mut self, mouse_y: i32) {
+        let scale_factor = self.ctx.window().scale_factor;
+        let size = self.ctx.size_info();
+        let window_id = self.ctx.window().id();
+        let scheduler = self.ctx.scheduler_mut();
+
+        // Scale constants by DPI.
+        let min_height = (MIN_SELECTION_SCROLLING_HEIGHT * scale_factor) as i32;
+        let step = (SELECTION_SCROLLING_STEP * scale_factor) as i32;
+
+        // Compute the height of the scrolling areas.
+        let end_top = max(min_height, size.padding_y() as i32);
+        let text_area_bottom = size.padding_y() + size.screen_lines() as f32 * size.cell_height();
+        let start_bottom = min(size.height() as i32 - min_height, text_area_bottom as i32);
+
+        // Get distance from closest window boundary.
+        let delta = if mouse_y < end_top {
+            end_top - mouse_y + step
+        } else if mouse_y >= start_bottom {
+            start_bottom - mouse_y - step
+        } else {
+            scheduler.unschedule(TimerId::new(Topic::SelectionScrolling, window_id));
+            return;
+        };
+
+        // Scale number of lines scrolled based on distance to boundary.
+        let event = Event::new(EventType::Scroll(Scroll::Delta(delta / step)), Some(window_id));
+
+        // Schedule event.
+        let timer_id = TimerId::new(Topic::SelectionScrolling, window_id);
+        scheduler.unschedule(timer_id);
+        scheduler.schedule(event, SELECTION_SCROLLING_INTERVAL, true, timer_id);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use winit::event::{DeviceId, Event as WinitEvent, WindowEvent};
+    use winit::keyboard::Key;
+    use winit::window::WindowId;
+
+    use alacritty_terminal::event::Event as TerminalEvent;
+
+    use crate::config::Binding;
+    use crate::message_bar::MessageBuffer;
+
+    const KEY: Key<&'static str> = Key::Character("0");
+
+    struct MockEventProxy;
+    impl EventListener for MockEventProxy {}
+
+    struct ActionContext<'a, T> {
+        pub terminal: &'a mut Term<T>,
+        pub size_info: &'a SizeInfo,
+        pub mouse: &'a mut Mouse,
+        pub clipboard: &'a mut Clipboard,
+        pub message_buffer: &'a mut MessageBuffer,
+        pub modifiers: Modifiers,
+        config: &'a UiConfig,
+        inline_search_state: &'a mut InlineSearchState,
+    }
+
+    impl<'a, T: EventListener> super::ActionContext<T> for ActionContext<'a, T> {
+        fn search_next(
+            &mut self,
+            _origin: Point,
+            _direction: Direction,
+            _side: Side,
+        ) -> Option<Match> {
+            None
+        }
+
+        fn search_direction(&self) -> Direction {
+            Direction::Right
+        }
+
+        fn inline_search_state(&mut self) -> &mut InlineSearchState {
+            self.inline_search_state
+        }
+
+        fn search_active(&self) -> bool {
+            false
+        }
+
+        fn terminal(&self) -> &Term<T> {
+            self.terminal
+        }
+
+        fn terminal_mut(&mut self) -> &mut Term<T> {
+            self.terminal
+        }
+
+        fn size_info(&self) -> SizeInfo {
+            *self.size_info
+        }
+
+        fn selection_is_empty(&self) -> bool {
+            true
+        }
+
+        fn scroll(&mut self, scroll: Scroll) {
+            self.terminal.scroll_display(scroll);
+        }
+
+        fn mouse_mode(&self) -> bool {
+            false
+        }
+
+        #[inline]
+        fn mouse_mut(&mut self) -> &mut Mouse {
+            self.mouse
+        }
+
+        #[inline]
+        fn mouse(&self) -> &Mouse {
+            self.mouse
+        }
+
+        #[inline]
+        fn touch_purpose(&mut self) -> &mut TouchPurpose {
+            unimplemented!();
+        }
+
+        fn modifiers(&mut self) -> &mut Modifiers {
+            &mut self.modifiers
+        }
+
+        fn window(&mut self) -> &mut Window {
+            unimplemented!();
+        }
+
+        fn display(&mut self) -> &mut Display {
+            unimplemented!();
+        }
+
+        fn pop_message(&mut self) {
+            self.message_buffer.pop();
+        }
+
+        fn message(&self) -> Option<&Message> {
+            self.message_buffer.message()
+        }
+
+        fn config(&self) -> &UiConfig {
+            self.config
+        }
+
+        fn clipboard_mut(&mut self) -> &mut Clipboard {
+            self.clipboard
+        }
+
+        fn event_loop(&self) -> &EventLoopWindowTarget<Event> {
+            unimplemented!();
+        }
+
+        fn scheduler_mut(&mut self) -> &mut Scheduler {
+            unimplemented!();
+        }
+    }
+
+    macro_rules! test_clickstate {
+        {
+            name: $name:ident,
+            initial_state: $initial_state:expr,
+            initial_button: $initial_button:expr,
+            input: $input:expr,
+            end_state: $end_state:expr,
+            input_delay: $input_delay:expr,
+        } => {
+            #[test]
+            fn $name() {
+                let mut clipboard = Clipboard::new_nop();
+                let cfg = UiConfig::default();
+                let size = SizeInfo::new(
+                    21.0,
+                    51.0,
+                    3.0,
+                    3.0,
+                    0.,
+                    0.,
+                    false,
+                );
+
+                let mut terminal = Term::new(cfg.term_options(), &size, MockEventProxy);
+
+                let mut mouse = Mouse {
+                    click_state: $initial_state,
+                    last_click_button: $initial_button,
+                    last_click_timestamp: Instant::now() - $input_delay,
+                    ..Mouse::default()
+                };
+
+                let mut inline_search_state = InlineSearchState::default();
+                let mut message_buffer = MessageBuffer::default();
+
+                let context = ActionContext {
+                    terminal: &mut terminal,
+                    mouse: &mut mouse,
+                    size_info: &size,
+                    clipboard: &mut clipboard,
+                    modifiers: Default::default(),
+                    message_buffer: &mut message_buffer,
+                    inline_search_state: &mut inline_search_state,
+                    config: &cfg,
+                };
+
+                let mut processor = Processor::new(context);
+
+                let event: WinitEvent::<TerminalEvent> = $input;
+                if let WinitEvent::WindowEvent {
+                    event: WindowEvent::MouseInput {
+                        state,
+                        button,
+                        ..
+                    },
+                    ..
+                } = event
+                {
+                    processor.mouse_input(state, button);
+                };
+
+                assert_eq!(processor.ctx.mouse.click_state, $end_state);
+            }
+        }
+    }
+
+    macro_rules! test_process_binding {
+        {
+            name: $name:ident,
+            binding: $binding:expr,
+            triggers: $triggers:expr,
+            mode: $mode:expr,
+            mods: $mods:expr,
+        } => {
+            #[test]
+            fn $name() {
+                if $triggers {
+                    assert!($binding.is_triggered_by($mode, $mods, &KEY));
+                } else {
+                    assert!(!$binding.is_triggered_by($mode, $mods, &KEY));
+                }
+            }
+        }
+    }
+
+    test_clickstate! {
+        name: single_click,
+        initial_state: ClickState::None,
+        initial_button: MouseButton::Other(0),
+        input: WinitEvent::WindowEvent {
+            event: WindowEvent::MouseInput {
+                state: ElementState::Pressed,
+                button: MouseButton::Left,
+                device_id: unsafe { DeviceId::dummy() },
+            },
+            window_id: unsafe { WindowId::dummy() },
+        },
+        end_state: ClickState::Click,
+        input_delay: Duration::ZERO,
+    }
+
+    test_clickstate! {
+        name: single_right_click,
+        initial_state: ClickState::None,
+        initial_button: MouseButton::Other(0),
+        input: WinitEvent::WindowEvent {
+            event: WindowEvent::MouseInput {
+                state: ElementState::Pressed,
+                button: MouseButton::Right,
+                device_id: unsafe { DeviceId::dummy() },
+            },
+            window_id: unsafe { WindowId::dummy() },
+        },
+        end_state: ClickState::Click,
+        input_delay: Duration::ZERO,
+    }
+
+    test_clickstate! {
+        name: single_middle_click,
+        initial_state: ClickState::None,
+        initial_button: MouseButton::Other(0),
+        input: WinitEvent::WindowEvent {
+            event: WindowEvent::MouseInput {
+                state: ElementState::Pressed,
+                button: MouseButton::Middle,
+                device_id: unsafe { DeviceId::dummy() },
+            },
+            window_id: unsafe { WindowId::dummy() },
+        },
+        end_state: ClickState::Click,
+        input_delay: Duration::ZERO,
+    }
+
+    test_clickstate! {
+        name: double_click,
+        initial_state: ClickState::Click,
+        initial_button: MouseButton::Left,
+        input: WinitEvent::WindowEvent {
+            event: WindowEvent::MouseInput {
+                state: ElementState::Pressed,
+                button: MouseButton::Left,
+                device_id: unsafe { DeviceId::dummy() },
+            },
+            window_id: unsafe { WindowId::dummy() },
+        },
+        end_state: ClickState::DoubleClick,
+        input_delay: Duration::ZERO,
+    }
+
+    test_clickstate! {
+        name: double_click_failed,
+        initial_state: ClickState::Click,
+        initial_button: MouseButton::Left,
+        input: WinitEvent::WindowEvent {
+            event: WindowEvent::MouseInput {
+                state: ElementState::Pressed,
+                button: MouseButton::Left,
+                device_id: unsafe { DeviceId::dummy() },
+            },
+            window_id: unsafe { WindowId::dummy() },
+        },
+        end_state: ClickState::Click,
+        input_delay: CLICK_THRESHOLD,
+    }
+
+    test_clickstate! {
+        name: triple_click,
+        initial_state: ClickState::DoubleClick,
+        initial_button: MouseButton::Left,
+        input: WinitEvent::WindowEvent {
+            event: WindowEvent::MouseInput {
+                state: ElementState::Pressed,
+                button: MouseButton::Left,
+                device_id: unsafe { DeviceId::dummy() },
+            },
+            window_id: unsafe { WindowId::dummy() },
+        },
+        end_state: ClickState::TripleClick,
+        input_delay: Duration::ZERO,
+    }
+
+    test_clickstate! {
+        name: triple_click_failed,
+        initial_state: ClickState::DoubleClick,
+        initial_button: MouseButton::Left,
+        input: WinitEvent::WindowEvent {
+            event: WindowEvent::MouseInput {
+                state: ElementState::Pressed,
+                button: MouseButton::Left,
+                device_id: unsafe { DeviceId::dummy() },
+            },
+            window_id: unsafe { WindowId::dummy() },
+        },
+        end_state: ClickState::Click,
+        input_delay: CLICK_THRESHOLD,
+    }
+
+    test_clickstate! {
+        name: multi_click_separate_buttons,
+        initial_state: ClickState::DoubleClick,
+        initial_button: MouseButton::Left,
+        input: WinitEvent::WindowEvent {
+            event: WindowEvent::MouseInput {
+                state: ElementState::Pressed,
+                button: MouseButton::Right,
+                device_id: unsafe { DeviceId::dummy() },
+            },
+            window_id: unsafe { WindowId::dummy() },
+        },
+        end_state: ClickState::Click,
+        input_delay: Duration::ZERO,
+    }
+
+    test_process_binding! {
+        name: process_binding_nomode_shiftmod_require_shift,
+        binding: Binding { trigger: KEY, mods: ModifiersState::SHIFT, action: Action::from("\x1b[1;2D"), mode: BindingMode::empty(), notmode: BindingMode::empty() },
+        triggers: true,
+        mode: BindingMode::empty(),
+        mods: ModifiersState::SHIFT,
+    }
+
+    test_process_binding! {
+        name: process_binding_nomode_nomod_require_shift,
+        binding: Binding { trigger: KEY, mods: ModifiersState::SHIFT, action: Action::from("\x1b[1;2D"), mode: BindingMode::empty(), notmode: BindingMode::empty() },
+        triggers: false,
+        mode: BindingMode::empty(),
+        mods: ModifiersState::empty(),
+    }
+
+    test_process_binding! {
+        name: process_binding_nomode_controlmod,
+        binding: Binding { trigger: KEY, mods: ModifiersState::CONTROL, action: Action::from("\x1b[1;5D"), mode: BindingMode::empty(), notmode: BindingMode::empty() },
+        triggers: true,
+        mode: BindingMode::empty(),
+        mods: ModifiersState::CONTROL,
+    }
+
+    test_process_binding! {
+        name: process_binding_nomode_nomod_require_not_appcursor,
+        binding: Binding { trigger: KEY, mods: ModifiersState::empty(), action: Action::from("\x1b[D"), mode: BindingMode::empty(), notmode: BindingMode::APP_CURSOR },
+        triggers: true,
+        mode: BindingMode::empty(),
+        mods: ModifiersState::empty(),
+    }
+
+    test_process_binding! {
+        name: process_binding_appcursormode_nomod_require_appcursor,
+        binding: Binding { trigger: KEY, mods: ModifiersState::empty(), action: Action::from("\x1bOD"), mode: BindingMode::APP_CURSOR, notmode: BindingMode::empty() },
+        triggers: true,
+        mode: BindingMode::APP_CURSOR,
+        mods: ModifiersState::empty(),
+    }
+
+    test_process_binding! {
+        name: process_binding_nomode_nomod_require_appcursor,
+        binding: Binding { trigger: KEY, mods: ModifiersState::empty(), action: Action::from("\x1bOD"), mode: BindingMode::APP_CURSOR, notmode: BindingMode::empty() },
+        triggers: false,
+        mode: BindingMode::empty(),
+        mods: ModifiersState::empty(),
+    }
+
+    test_process_binding! {
+        name: process_binding_appcursormode_appkeypadmode_nomod_require_appcursor,
+        binding: Binding { trigger: KEY, mods: ModifiersState::empty(), action: Action::from("\x1bOD"), mode: BindingMode::APP_CURSOR, notmode: BindingMode::empty() },
+        triggers: true,
+        mode: BindingMode::APP_CURSOR | BindingMode::APP_KEYPAD,
+        mods: ModifiersState::empty(),
+    }
+
+    test_process_binding! {
+        name: process_binding_fail_with_extra_mods,
+        binding: Binding { trigger: KEY, mods: ModifiersState::SUPER, action: Action::from("arst"), mode: BindingMode::empty(), notmode: BindingMode::empty() },
+        triggers: false,
+        mode: BindingMode::empty(),
+        mods: ModifiersState::ALT | ModifiersState::SUPER,
+    }
+}