ignore modifier-only key presses

Author: rhysd

examples/winit.rs

@@ -3,15 +3,15 @@ use keybinds::{KeyBind, KeyBindMatcher, KeyBinds};
 use winit::application::ApplicationHandler;
 use winit::event::WindowEvent;
 use winit::event_loop::{ActiveEventLoop, EventLoop};
-use winit::window::{Window, WindowId};
+use winit::window::{Theme, Window, WindowId};
 
 // Actions triggered by key bindings
 #[derive(Debug)]
 enum Action {
     SayHi,
     ToggleMaximized,
-    ToggleVisible,
-    ExitApp,
+    ToggleTheme,
+    Exit,
 }
 
 struct App {
@@ -26,8 +26,8 @@ impl Default for App {
         let keybinds = KeyBinds::new(vec![
             KeyBind::multiple("h i".parse().unwrap(), Action::SayHi),
             KeyBind::single("Mod+m".parse().unwrap(), Action::ToggleMaximized),
-            KeyBind::single("Mod+Shift+v".parse().unwrap(), Action::ToggleVisible),
-            KeyBind::multiple("Mod+x Mod+c".parse().unwrap(), Action::ExitApp),
+            KeyBind::single("Mod+Shift+t".parse().unwrap(), Action::ToggleTheme),
+            KeyBind::multiple("Mod+x Mod+c".parse().unwrap(), Action::Exit),
         ]);
         Self {
             window: None,
@@ -39,31 +39,32 @@ impl Default for App {
 
 impl ApplicationHandler for App {
     fn resumed(&mut self, event_loop: &ActiveEventLoop) {
-        let window = event_loop
-            .create_window(Window::default_attributes())
-            .unwrap();
+        let attrs = Window::default_attributes().with_theme(Some(Theme::Dark));
+        let window = event_loop.create_window(attrs).unwrap();
         self.window = Some(window);
     }
 
     fn window_event(&mut self, event_loop: &ActiveEventLoop, _id: WindowId, event: WindowEvent) {
-        if let Some(input) = self.converter.convert(&event) {
-            println!("Key input: {input:?}");
+        let input = self.converter.convert(&event);
 
-            if let Some(action) = self.matcher.trigger(input) {
-                println!("Action: {action:?}");
+        if let Some(action) = self.matcher.trigger(input) {
+            println!("Action: {action:?}");
 
-                match action {
-                    Action::SayHi => println!("Hi!"),
-                    Action::ToggleMaximized => {
-                        let window = self.window.as_ref().unwrap();
-                        window.set_maximized(!window.is_maximized());
-                    }
-                    Action::ToggleVisible => {
-                        let window = self.window.as_ref().unwrap();
-                        window.set_visible(!window.is_visible().unwrap_or(false));
-                    }
-                    Action::ExitApp => event_loop.exit(),
+            match action {
+                Action::SayHi => println!("Hi!"),
+                Action::ToggleMaximized => {
+                    let window = self.window.as_ref().unwrap();
+                    window.set_maximized(!window.is_maximized());
                 }
+                Action::ToggleTheme => {
+                    let window = self.window.as_ref().unwrap();
+                    let theme = match window.theme() {
+                        Some(Theme::Dark) => Theme::Light,
+                        _ => Theme::Dark,
+                    };
+                    window.set_theme(Some(theme));
+                }
+                Action::Exit => event_loop.exit(),
             }
         }
 

src/crossterm.rs

@@ -35,6 +35,7 @@ impl From<KeyCode> for Key {
             KeyCode::Media(MediaKeyCode::LowerVolume) => Self::VolumeDown,
             KeyCode::Media(MediaKeyCode::RaiseVolume) => Self::VolumeUp,
             KeyCode::Media(MediaKeyCode::MuteVolume) => Self::Mute,
+            KeyCode::Modifier(_) | KeyCode::Null => Self::Ignored,
             _ => Self::Unidentified,
         }
     }
@@ -94,15 +95,19 @@ impl From<Event> for KeyInput {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crossterm::event::{KeyEventKind, KeyEventState};
+    use crossterm::event::{KeyEventKind, KeyEventState, ModifierKeyCode};
 
     #[test]
     fn convert_key_code() {
         assert_eq!(Key::from(KeyCode::Backspace), Key::Backspace);
         assert_eq!(Key::from(KeyCode::Char('a')), Key::Char('a'));
         assert_eq!(Key::from(KeyCode::Char('A')), Key::Char('a'));
         assert_eq!(Key::from(KeyCode::Char('A')), Key::Char('a'));
-        assert_eq!(Key::from(KeyCode::Null), Key::Unidentified);
+        assert_eq!(Key::from(KeyCode::Null), Key::Ignored);
+        assert_eq!(
+            Key::from(KeyCode::Modifier(ModifierKeyCode::LeftControl)),
+            Key::Ignored,
+        );
         assert_eq!(Key::from(KeyCode::Media(MediaKeyCode::Play)), Key::Play);
         assert_eq!(Key::from(KeyCode::F(12)), Key::F(12));
     }

src/lib.rs

@@ -59,6 +59,7 @@ pub enum Key {
     Mute,
     F(u8),
     Unidentified,
+    Ignored,
 }
 
 impl From<char> for Key {
@@ -182,6 +183,10 @@ impl KeyInput {
             mods,
         }
     }
+
+    fn is_ignored(&self) -> bool {
+        self.key == Key::Ignored
+    }
 }
 
 impl FromStr for KeyInput {
@@ -314,8 +319,12 @@ impl<A> KeyBindMatcher<A> {
     }
 
     pub fn trigger<I: Into<KeyInput>>(&mut self, input: I) -> Option<&A> {
+        let input = input.into();
+        if input.is_ignored() {
+            return None;
+        }
         self.handle_timeout();
-        self.ongoing.push(input.into());
+        self.ongoing.push(input);
 
         // TODO: When no keybind is prefix-matched, call `self.reset()`
         let action = self.binds.find(&self.ongoing).map(|b| &b.action)?;

src/winit.rs

@@ -61,6 +61,13 @@ impl From<&WinitKey> for Key {
                 NamedKey::F18 => Self::F(18),
                 NamedKey::F19 => Self::F(19),
                 NamedKey::F20 => Self::F(20),
+                NamedKey::Alt
+                | NamedKey::Control
+                | NamedKey::Shift
+                | NamedKey::Super
+                | NamedKey::Hyper
+                | NamedKey::Meta
+                | NamedKey::Symbol => Self::Ignored,
                 _ => Self::Unidentified,
             },
             WinitKey::Character(s) => {
@@ -108,33 +115,33 @@ impl From<ModifiersState> for Mods {
 }
 
 pub trait KeyInputConvertible {
-    fn convert_key_input(&self, conv: &mut KeyEventConverter) -> Option<KeyInput>;
+    fn convert_key_input(&self, conv: &mut KeyEventConverter) -> KeyInput;
 }
 
 impl KeyInputConvertible for WindowEvent {
-    fn convert_key_input(&self, conv: &mut KeyEventConverter) -> Option<KeyInput> {
+    fn convert_key_input(&self, conv: &mut KeyEventConverter) -> KeyInput {
         match self {
             WindowEvent::ModifiersChanged(mods) => {
                 conv.on_modifiers_changed(mods);
-                None
+                Key::Ignored.into()
             }
             WindowEvent::KeyboardInput { event, .. } if event.state == ElementState::Pressed => {
-                Some(KeyInput {
+                KeyInput {
                     key: Key::from(&event.logical_key),
                     mods: conv.mods,
-                })
+                }
             }
-            _ => None,
+            _ => Key::Ignored.into(),
         }
     }
 }
 
 impl<T> KeyInputConvertible for Event<T> {
-    fn convert_key_input(&self, conv: &mut KeyEventConverter) -> Option<KeyInput> {
+    fn convert_key_input(&self, conv: &mut KeyEventConverter) -> KeyInput {
         if let Event::WindowEvent { event, .. } = self {
             event.convert_key_input(conv)
         } else {
-            None
+            Key::Ignored.into()
         }
     }
 }
@@ -153,7 +160,7 @@ impl KeyEventConverter {
         self.mods = mods.state().into();
     }
 
-    pub fn convert<C: KeyInputConvertible>(&mut self, event: &C) -> Option<KeyInput> {
+    pub fn convert<C: KeyInputConvertible>(&mut self, event: &C) -> KeyInput {
         event.convert_key_input(self)
     }
 }