Improve Windows text input

reflectronic · reflectronic · commit f0065a36a2d9 · 2025-10-27T03:36:00.000-04:00
diff --git a/crates/gpui/src/platform/windows/events.rs b/crates/gpui/src/platform/windows/events.rs
@@ -26,6 +26,7 @@ pub(crate) const WM_GPUI_DOCK_MENU_ACTION: u32 = WM_USER + 4;
 pub(crate) const WM_GPUI_FORCE_UPDATE_WINDOW: u32 = WM_USER + 5;
 pub(crate) const WM_GPUI_KEYBOARD_LAYOUT_CHANGED: u32 = WM_USER + 6;
 pub(crate) const WM_GPUI_GPU_DEVICE_LOST: u32 = WM_USER + 7;
+pub(crate) const WM_GPUI_KEYDOWN: u32 = WM_USER + 8;
 
 const SIZE_MOVE_LOOP_TIMER_ID: usize = 1;
 const AUTO_HIDE_TASKBAR_THICKNESS_PX: i32 = 1;
@@ -92,13 +93,10 @@ impl WindowsWindowInner {
             }
             WM_MOUSEWHEEL => self.handle_mouse_wheel_msg(handle, wparam, lparam),
             WM_MOUSEHWHEEL => self.handle_mouse_horizontal_wheel_msg(handle, wparam, lparam),
-            WM_SYSKEYDOWN => self.handle_syskeydown_msg(handle, wparam, lparam),
-            WM_SYSKEYUP => self.handle_syskeyup_msg(handle, wparam, lparam),
-            WM_SYSCOMMAND => self.handle_system_command(wparam),
-            WM_KEYDOWN => self.handle_keydown_msg(handle, wparam, lparam),
-            WM_KEYUP => self.handle_keyup_msg(handle, wparam, lparam),
+            WM_SYSKEYUP => self.handle_syskeyup_msg(wparam, lparam),
+            WM_KEYUP => self.handle_keyup_msg(wparam, lparam),
+            WM_GPUI_KEYDOWN => self.handle_keydown_msg(wparam, lparam),
             WM_CHAR => self.handle_char_msg(wparam),
-            WM_DEADCHAR => self.handle_dead_char_msg(wparam),
             WM_IME_STARTCOMPOSITION => self.handle_ime_position(handle),
             WM_IME_COMPOSITION => self.handle_ime_composition(handle, lparam),
             WM_SETCURSOR => self.handle_set_cursor(handle, lparam),
@@ -327,35 +325,9 @@ impl WindowsWindowInner {
         Some(0)
     }
 
-    fn handle_syskeydown_msg(&self, handle: HWND, wparam: WPARAM, lparam: LPARAM) -> Option<isize> {
+    fn handle_syskeyup_msg(&self, wparam: WPARAM, lparam: LPARAM) -> Option<isize> {
         let mut lock = self.state.borrow_mut();
-        let input = handle_key_event(handle, wparam, lparam, &mut lock, |keystroke| {
-            PlatformInput::KeyDown(KeyDownEvent {
-                keystroke,
-                is_held: lparam.0 & (0x1 << 30) > 0,
-            })
-        })?;
-        let mut func = lock.callbacks.input.take()?;
-        drop(lock);
-
-        let handled = !func(input).propagate;
-
-        let mut lock = self.state.borrow_mut();
-        lock.callbacks.input = Some(func);
-
-        if handled {
-            lock.system_key_handled = true;
-            Some(0)
-        } else {
-            // we need to call `DefWindowProcW`, or we will lose the system-wide `Alt+F4`, `Alt+{other keys}`
-            // shortcuts.
-            None
-        }
-    }
-
-    fn handle_syskeyup_msg(&self, handle: HWND, wparam: WPARAM, lparam: LPARAM) -> Option<isize> {
-        let mut lock = self.state.borrow_mut();
-        let input = handle_key_event(handle, wparam, lparam, &mut lock, |keystroke| {
+        let input = handle_key_event(wparam, lparam, &mut lock, |keystroke| {
             PlatformInput::KeyUp(KeyUpEvent { keystroke })
         })?;
         let mut func = lock.callbacks.input.take()?;
@@ -369,9 +341,9 @@ impl WindowsWindowInner {
 
     // It's a known bug that you can't trigger `ctrl-shift-0`. See:
     // https://superuser.com/questions/1455762/ctrl-shift-number-key-combination-has-stopped-working-for-a-few-numbers
-    fn handle_keydown_msg(&self, handle: HWND, wparam: WPARAM, lparam: LPARAM) -> Option<isize> {
+    fn handle_keydown_msg(&self, wparam: WPARAM, lparam: LPARAM) -> Option<isize> {
         let mut lock = self.state.borrow_mut();
-        let Some(input) = handle_key_event(handle, wparam, lparam, &mut lock, |keystroke| {
+        let Some(input) = handle_key_event(wparam, lparam, &mut lock, |keystroke| {
             PlatformInput::KeyDown(KeyDownEvent {
                 keystroke,
                 is_held: lparam.0 & (0x1 << 30) > 0,
@@ -381,15 +353,6 @@ impl WindowsWindowInner {
         };
         drop(lock);
 
-        let is_composing = self
-            .with_input_handler(|input_handler| input_handler.marked_text_range())
-            .flatten()
-            .is_some();
-        if is_composing {
-            translate_message(handle, wparam, lparam);
-            return Some(0);
-        }
-
         let Some(mut func) = self.state.borrow_mut().callbacks.input.take() else {
             return Some(1);
         };
@@ -398,17 +361,12 @@ impl WindowsWindowInner {
 
         self.state.borrow_mut().callbacks.input = Some(func);
 
-        if handled {
-            Some(0)
-        } else {
-            translate_message(handle, wparam, lparam);
-            Some(1)
-        }
+        if handled { Some(0) } else { Some(1) }
     }
 
-    fn handle_keyup_msg(&self, handle: HWND, wparam: WPARAM, lparam: LPARAM) -> Option<isize> {
+    fn handle_keyup_msg(&self, wparam: WPARAM, lparam: LPARAM) -> Option<isize> {
         let mut lock = self.state.borrow_mut();
-        let Some(input) = handle_key_event(handle, wparam, lparam, &mut lock, |keystroke| {
+        let Some(input) = handle_key_event(wparam, lparam, &mut lock, |keystroke| {
             PlatformInput::KeyUp(KeyUpEvent { keystroke })
         }) else {
             return Some(1);
@@ -434,14 +392,6 @@ impl WindowsWindowInner {
         Some(0)
     }
 
-    fn handle_dead_char_msg(&self, wparam: WPARAM) -> Option<isize> {
-        let ch = char::from_u32(wparam.0 as u32)?.to_string();
-        self.with_input_handler(|input_handler| {
-            input_handler.replace_and_mark_text_in_range(None, &ch, None);
-        });
-        None
-    }
-
     fn handle_mouse_down_msg(
         &self,
         handle: HWND,
@@ -1127,17 +1077,6 @@ impl WindowsWindowInner {
         Some(0)
     }
 
-    fn handle_system_command(&self, wparam: WPARAM) -> Option<isize> {
-        if wparam.0 == SC_KEYMENU as usize {
-            let mut lock = self.state.borrow_mut();
-            if lock.system_key_handled {
-                lock.system_key_handled = false;
-                return Some(0);
-            }
-        }
-        None
-    }
-
     fn handle_system_theme_changed(&self, handle: HWND, lparam: LPARAM) -> Option<isize> {
         // lParam is a pointer to a string that indicates the area containing the system parameter
         // that was changed.
@@ -1281,23 +1220,7 @@ impl WindowsWindowInner {
     }
 }
 
-#[inline]
-fn translate_message(handle: HWND, wparam: WPARAM, lparam: LPARAM) {
-    let msg = MSG {
-        hwnd: handle,
-        message: WM_KEYDOWN,
-        wParam: wparam,
-        lParam: lparam,
-        // It seems like leaving the following two parameters empty doesn't break key events, they still work as expected.
-        // But if any bugs pop up after this PR, this is probably the place to look first.
-        time: 0,
-        pt: POINT::default(),
-    };
-    unsafe { TranslateMessage(&msg).ok().log_err() };
-}
-
 fn handle_key_event<F>(
-    handle: HWND,
     wparam: WPARAM,
     lparam: LPARAM,
     state: &mut WindowsWindowState,
@@ -1323,10 +1246,7 @@ where
                 capslock: current_capslock(),
             }))
         }
-        VK_PACKET => {
-            translate_message(handle, wparam, lparam);
-            None
-        }
+        VK_PACKET => None,
         VK_CAPITAL => {
             let capslock = current_capslock();
             if state
@@ -1342,11 +1262,6 @@ where
             }))
         }
         vkey => {
-            let vkey = if vkey == VK_PROCESSKEY {
-                VIRTUAL_KEY(unsafe { ImmGetVirtualKey(handle) } as u16)
-            } else {
-                vkey
-            };
             let keystroke = parse_normal_key(vkey, lparam, modifiers)?;
             Some(f(keystroke))
         }
@@ -1460,25 +1375,11 @@ fn is_virtual_key_pressed(vkey: VIRTUAL_KEY) -> bool {
     unsafe { GetKeyState(vkey.0 as i32) < 0 }
 }
 
-fn keyboard_uses_altgr() -> bool {
-    use crate::platform::windows::keyboard::WindowsKeyboardLayout;
-    WindowsKeyboardLayout::new()
-        .map(|layout| layout.uses_altgr())
-        .unwrap_or(false)
-}
-
 #[inline]
 pub(crate) fn current_modifiers() -> Modifiers {
-    let lmenu_pressed = is_virtual_key_pressed(VK_LMENU);
-    let rmenu_pressed = is_virtual_key_pressed(VK_RMENU);
-    let lcontrol_pressed = is_virtual_key_pressed(VK_LCONTROL);
-
-    // Only treat right Alt + left Ctrl as AltGr on keyboards that actually use it
-    let altgr = keyboard_uses_altgr() && rmenu_pressed && lcontrol_pressed;
-
     Modifiers {
-        control: is_virtual_key_pressed(VK_CONTROL) && !altgr,
-        alt: (lmenu_pressed || rmenu_pressed) && !altgr,
+        control: is_virtual_key_pressed(VK_CONTROL),
+        alt: is_virtual_key_pressed(VK_MENU),
         shift: is_virtual_key_pressed(VK_SHIFT),
         platform: is_virtual_key_pressed(VK_LWIN) || is_virtual_key_pressed(VK_RWIN),
         function: false,
diff --git a/crates/gpui/src/platform/windows/keyboard.rs b/crates/gpui/src/platform/windows/keyboard.rs
@@ -110,38 +110,6 @@ impl WindowsKeyboardLayout {
             name: "unknown".to_string(),
         }
     }
-
-    pub(crate) fn uses_altgr(&self) -> bool {
-        // Check if this is a known AltGr layout by examining the layout ID
-        // The layout ID is a hex string like "00000409" (US) or "00000407" (German)
-        // Extract the language ID (last 4 bytes)
-        let id_bytes = self.id.as_bytes();
-        if id_bytes.len() >= 4 {
-            let lang_id = &id_bytes[id_bytes.len() - 4..];
-            // List of keyboard layouts that use AltGr (non-exhaustive)
-            matches!(
-                lang_id,
-                b"0407" | // German
-                b"040C" | // French
-                b"040A" | // Spanish
-                b"0415" | // Polish
-                b"0413" | // Dutch
-                b"0816" | // Portuguese
-                b"041D" | // Swedish
-                b"0414" | // Norwegian
-                b"040B" | // Finnish
-                b"041F" | // Turkish
-                b"0419" | // Russian
-                b"0405" | // Czech
-                b"040E" | // Hungarian
-                b"0424" | // Slovenian
-                b"041B" | // Slovak
-                b"0418" // Romanian
-            )
-        } else {
-            false
-        }
-    }
 }
 
 impl WindowsKeyboardMapper {
@@ -259,7 +227,7 @@ pub(crate) fn generate_key_char(
     }
 
     let mut buffer = [0; 8];
-    let len = unsafe { ToUnicode(vkey.0 as u32, scan_code, Some(&state), &mut buffer, 1 << 2) };
+    let len = unsafe { ToUnicode(vkey.0 as u32, scan_code, Some(&state), &mut buffer, 0x5) };
 
     match len {
         len if len > 0 => String::from_utf16(&buffer[..len as usize])
diff --git a/crates/gpui/src/platform/windows/platform.rs b/crates/gpui/src/platform/windows/platform.rs
@@ -272,6 +272,98 @@ impl WindowsPlatform {
     }
 }
 
+fn translate_accelerator(msg: &MSG) -> Option<()> {
+    if msg.message != WM_KEYDOWN && msg.message != WM_SYSKEYDOWN {
+        return None;
+    }
+
+    let vkey = VIRTUAL_KEY(msg.wParam.0 as u16);
+    let scan_code = ((msg.lParam.0 >> 16) & 0xFF) as u32;
+
+    let mut keyboard_state = [0u8; 256];
+    unsafe {
+        GetKeyboardState(&mut keyboard_state).ok()?;
+    }
+
+    let mut buffer_c = [0u16; 8];
+    let result_c = unsafe {
+        ToUnicode(
+            vkey.0 as u32,
+            scan_code,
+            Some(&keyboard_state),
+            &mut buffer_c,
+            0x4,
+        )
+    };
+
+    if result_c < 0 {
+        return None;
+    }
+
+    let c = String::from_utf16_lossy(&buffer_c[..result_c as usize]);
+
+    let ctrl_down = (keyboard_state[VK_CONTROL.0 as usize] & 0x80) != 0;
+    let alt_down = (keyboard_state[VK_MENU.0 as usize] & 0x80) != 0;
+    let win_down = (keyboard_state[VK_LWIN.0 as usize] & 0x80) != 0
+        || (keyboard_state[VK_RWIN.0 as usize] & 0x80) != 0;
+
+    let has_modifiers = ctrl_down || alt_down || win_down;
+
+    if !has_modifiers {
+        return dispatch_accelerator(msg);
+    }
+
+    if c.chars().next().map_or(true, |ch| ch.is_control()) {
+        return dispatch_accelerator(msg);
+    }
+
+    let mut state_no_modifiers = keyboard_state;
+    state_no_modifiers[VK_CONTROL.0 as usize] = 0;
+    state_no_modifiers[VK_LCONTROL.0 as usize] = 0;
+    state_no_modifiers[VK_RCONTROL.0 as usize] = 0;
+    state_no_modifiers[VK_MENU.0 as usize] = 0;
+    state_no_modifiers[VK_LMENU.0 as usize] = 0;
+    state_no_modifiers[VK_RMENU.0 as usize] = 0;
+    state_no_modifiers[VK_LWIN.0 as usize] = 0;
+    state_no_modifiers[VK_RWIN.0 as usize] = 0;
+
+    let mut buffer_c_no_modifiers = [0u16; 8];
+    let result_c_no_modifers = unsafe {
+        ToUnicode(
+            vkey.0 as u32,
+            scan_code,
+            Some(&state_no_modifiers),
+            &mut buffer_c_no_modifiers,
+            0x4,
+        )
+    };
+
+    if result_c_no_modifers <= 0 {
+        return dispatch_accelerator(msg);
+    }
+
+    let c_no_modifiers =
+        String::from_utf16_lossy(&buffer_c_no_modifiers[..result_c_no_modifers as usize]);
+
+    if c != c_no_modifiers {
+        return None;
+    }
+
+    dispatch_accelerator(msg)
+}
+
+fn dispatch_accelerator(msg: &MSG) -> Option<()> {
+    let result = unsafe {
+        SendMessageW(
+            msg.hwnd,
+            WM_GPUI_KEYDOWN,
+            Some(msg.wParam),
+            Some(msg.lParam),
+        )
+    };
+    (result == LRESULT(0)).then_some(())
+}
+
 impl Platform for WindowsPlatform {
     fn background_executor(&self) -> BackgroundExecutor {
         self.background_executor.clone()
@@ -312,7 +404,10 @@ impl Platform for WindowsPlatform {
         let mut msg = MSG::default();
         unsafe {
             while GetMessageW(&mut msg, None, 0, 0).as_bool() {
-                DispatchMessageW(&msg);
+                if translate_accelerator(&msg).is_none() {
+                    _ = TranslateMessage(&msg);
+                    DispatchMessageW(&msg);
+                }
             }
         }
 
diff --git a/crates/gpui/src/platform/windows/window.rs b/crates/gpui/src/platform/windows/window.rs
