Reset char suppression for every key binding

Previously the character suppression was only reset whenever a key was
released. However this did not take key repetition into account.

Now every key down also resets the character suppression. This should
work since the `ReceivedCharacter` is always received immediately after
the `KeyboardInput` without the chance of a racing condition where
another keyboard event interrupts the two.

1 files changed, 52 insertions, 2 deletions

diff --git a/alacritty/src/event.rs b/alacritty/src/event.rs
index 9a27963c..d4d0d968 100644
--- a/alacritty/src/event.rs
+++ b/alacritty/src/event.rs
@@ -218,6 +218,56 @@ impl<'a, N: Notify + 'a, T: EventListener> input::ActionContext<T> for ActionCon
         self.notifier.notify(val);
     }
 
+    fn received_char(&mut self, c: char) {
+        // Don't insert chars when we have IME running.
+        if self.display().ime.preedit().is_some() {
+            return;
+        }
+
+        // Handle hint selection over anything else.
+        if self.display().hint_state.active() && !*self.suppress_chars {
+            self.hint_input(c);
+            return;
+        }
+
+        // Pass keys to search and ignore them during `suppress_chars`.
+        let search_active = self.search_active();
+        if *self.suppress_chars || search_active || self.terminal().mode().contains(TermMode::VI) {
+            if search_active && !*self.suppress_chars {
+                self.search_input(c);
+            }
+
+            return;
+        }
+
+        self.on_typing_start();
+
+        if self.terminal().grid().display_offset() != 0 {
+            self.scroll(Scroll::Bottom);
+        }
+        self.clear_selection();
+
+        let utf8_len = c.len_utf8();
+        let mut bytes = vec![0; utf8_len];
+        c.encode_utf8(&mut bytes[..]);
+
+        #[cfg(not(target_os = "macos"))]
+        let alt_send_esc = true;
+
+        // Don't send ESC when `OptionAsAlt` is used. This doesn't handle
+        // `Only{Left,Right}` variants due to inability to distinguish them.
+        #[cfg(target_os = "macos")]
+        let alt_send_esc = self.config().window.option_as_alt != OptionAsAlt::None;
+
+        if alt_send_esc && *self.received_count() == 0 && self.modifiers().alt() && utf8_len == 1 {
+            bytes.insert(0, b'\x1b');
+        }
+
+        self.write_to_pty(bytes);
+
+        *self.received_count() += 1;
+    }
+
     /// Request a redraw.
     #[inline]
     fn mark_dirty(&mut self) {
@@ -1288,7 +1338,7 @@ impl input::Processor<EventProxy, ActionContext<'_, Notifier, EventProxy>> {
                         self.key_input(input);
                     },
                     WindowEvent::ModifiersChanged(modifiers) => self.modifiers_input(modifiers),
-                    WindowEvent::ReceivedCharacter(c) => self.received_char(c),
+                    WindowEvent::ReceivedCharacter(c) => self.ctx.received_char(c),
                     WindowEvent::MouseInput { state, button, .. } => {
                         self.ctx.window().set_mouse_visible(true);
                         self.mouse_input(state, button);
@@ -1336,7 +1386,7 @@ impl input::Processor<EventProxy, ActionContext<'_, Notifier, EventProxy>> {
                             *self.ctx.dirty = true;
 
                             for ch in text.chars() {
-                                self.received_char(ch);
+                                self.ctx.received_char(ch);
                             }
 
                             self.ctx.update_cursor_blinking();