Fix Peek Ctrl+W shortcut not working after clicking preview (#48293)

## Summary

Fixes #48274

When previewing a file with Peek, clicking inside the preview content
(PDF, text/code, markdown, HTML) makes **Ctrl+W unable to close the
window**. This happens because the preview controls (WebView2 for most
file types, native shell handlers for others) capture keyboard focus in
their own message loop, bypassing the XAML keyboard accelerator system
entirely.

## Problem

Peek defines keyboard shortcuts (Ctrl+W to close, Escape to close, arrow
keys to navigate) as `KeyboardAccelerator` elements on the main XAML
Grid. These only fire when keyboard input flows through the XAML input
system. However:

- **WebView2** (used for PDF, text/code via Monaco, markdown, HTML):
Runs Chromium in a separate process that consumes all keyboard input
when focused. Ctrl+W is particularly problematic because Chromium treats
it as "close tab."
- **Shell Preview Handlers** (native HWND): Run in a child Win32 window
that handles keyboard messages independently.

Once either of these controls gets focus via a mouse click, keyboard
shortcuts stop working.

## Solution

Added a **low-level keyboard hook** (`WH_KEYBOARD_LL`) that intercepts
key events at the OS level, regardless of which control has focus:

- **Ctrl+W** and **Escape** → close the Peek window
- **Arrow keys** (Left/Right/Up/Down without Ctrl) → navigate between
files

The hook is installed only while the Peek window is visible and only
acts when Peek is the foreground window, so it has no impact on other
applications.

As additional defense-in-depth, `AreBrowserAcceleratorKeysEnabled` is
set to `false` on the WebView2 control, preventing Chromium from
consuming browser-specific shortcuts like Ctrl+W.

## Changes

| File | Change |
|------|--------|
| `Peek.UI/PeekXAML/MainWindow.xaml.cs` | Install/uninstall keyboard
hook in Initialize/Uninitialize; hook callback handles Ctrl+W, Escape,
and arrow keys |
| `Peek.UI/Native/NativeMethods.cs` | P/Invoke declarations for
`SetWindowsHookEx`, `UnhookWindowsHookEx`, `CallNextHookEx`,
`GetAsyncKeyState` |
| `Peek.FilePreviewer/Controls/BrowserControl.xaml.cs` | Disable browser
accelerator keys on WebView2 |

## Validation

- [x] Ctrl+W closes Peek after clicking inside PDF preview
- [x] Ctrl+W closes Peek after clicking inside text/code preview
(Monaco)
- [x] Escape closes Peek after clicking inside preview
- [x] Arrow keys navigate between files after clicking inside preview
- [x] Normal typing/interaction inside previews still works (Ctrl+C,
scrolling, etc.)
- [x] Shortcuts still work without clicking (existing behavior
preserved)

---------

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>

Author: 3 people

src/modules/peek/Peek.FilePreviewer/Controls/BrowserControl.xaml.cs

@@ -199,6 +199,12 @@ private async void PreviewWV2_Loaded(object sender, RoutedEventArgs e)
                 PreviewBrowser.CoreWebView2.Settings.IsScriptEnabled = IsDevFilePreview;
                 PreviewBrowser.CoreWebView2.Settings.IsWebMessageEnabled = false;
 
+                // Disable browser-level accelerator keys (Ctrl+W, Ctrl+T, F5, etc.) as a
+                // defense-in-depth measure. This alone does not guarantee XAML KeyboardAccelerators
+                // work when WebView2 has focus (a low-level keyboard hook in MainWindow handles
+                // that), but it prevents WebView2 from consuming shortcuts like Ctrl+W internally.
+                PreviewBrowser.CoreWebView2.Settings.AreBrowserAcceleratorKeysEnabled = false;
+
                 if (IsDevFilePreview)
                 {
                     PreviewBrowser.CoreWebView2.SetVirtualHostNameToFolderMapping(Microsoft.PowerToys.FilePreviewCommon.MonacoHelper.VirtualHostName, Microsoft.PowerToys.FilePreviewCommon.MonacoHelper.MonacoDirectory, CoreWebView2HostResourceAccessKind.Allow);

src/modules/peek/Peek.UI/Native/NativeMethods.cs

@@ -131,5 +131,36 @@ internal struct SHFILEOPSTRUCT
         /// contain string paths.
         /// </summary>
         internal const uint SHCNF_PATH = 0x0001;
+
+        // Low-level keyboard hook support
+        internal const int WH_KEYBOARD_LL = 13;
+
+        internal delegate IntPtr LowLevelKeyboardProc(int nCode, IntPtr wParam, IntPtr lParam);
+
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct KBDLLHOOKSTRUCT
+        {
+            public uint vkCode;
+            public uint scanCode;
+            public uint flags;
+            public uint time;
+            public IntPtr dwExtraInfo;
+        }
+
+        [DllImport("user32.dll", SetLastError = true)]
+        internal static extern IntPtr SetWindowsHookEx(int idHook, LowLevelKeyboardProc lpfn, IntPtr hMod, uint dwThreadId);
+
+        [DllImport("user32.dll", SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static extern bool UnhookWindowsHookEx(IntPtr hhk);
+
+        [DllImport("user32.dll")]
+        internal static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam);
+
+        [DllImport("user32.dll")]
+        internal static extern short GetAsyncKeyState(int vKey);
+
+        [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+        internal static extern IntPtr GetModuleHandle(string? lpModuleName);
     }
 }

src/modules/peek/Peek.UI/PeekXAML/MainWindow.xaml.cs

@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Runtime.InteropServices;
 using System.Threading.Tasks;
 
 using ManagedCommon;
@@ -20,6 +21,7 @@
 using Peek.UI.Extensions;
 using Peek.UI.Helpers;
 using Peek.UI.Models;
+using Peek.UI.Native;
 using Peek.UI.Telemetry.Events;
 using Windows.Foundation;
 using WinUIEx;
@@ -43,6 +45,10 @@ public sealed partial class MainWindow : WindowEx, IDisposable
         private bool _isDeleteInProgress;
         private bool _exitAfterClose;
 
+        private IntPtr _keyboardHookHandle;
+        private NativeMethods.LowLevelKeyboardProc? _keyboardHookProc;
+        private Windows.Win32.Foundation.HWND _cachedWindowHandle;
+
         public MainWindow()
         {
             InitializeComponent();
@@ -221,8 +227,12 @@ private void Initialize(SelectedItem selectedItem)
             }
 
             ViewModel.ScalingFactor = this.GetMonitorScale();
+            this.Content.KeyUp -= Content_KeyUp;
             this.Content.KeyUp += Content_KeyUp;
 
+            _cachedWindowHandle = new Windows.Win32.Foundation.HWND(this.GetWindowHandle());
+            InstallKeyboardHook();
+
             bootTime.Stop();
 
             PowerToysTelemetry.Log.WriteEvent(new OpenedEvent() { FileExtension = ViewModel.CurrentItem?.Extension ?? string.Empty, HotKeyToVisibleTimeMs = bootTime.ElapsedMilliseconds });
@@ -234,6 +244,7 @@ private void Uninitialize()
             {
                 // Keep teardown best-effort: one failure must not skip later cleanup
                 // or prevent the CLI/-FilePath exit-after-close contract.
+                TryRunUninitializeStep(UninstallKeyboardHook, nameof(UninstallKeyboardHook));
                 TryRunUninitializeStep(this.Restore, "Restore");
                 TryRunUninitializeStep(() => this.Hide(), "Hide");
                 TryRunUninitializeStep(ViewModel.Uninitialize, nameof(ViewModel.Uninitialize));
@@ -352,8 +363,164 @@ private bool IsNewSingleSelectedItem(SelectedItem selectedItem)
             return false;
         }
 
+        private void InstallKeyboardHook()
+        {
+            if (_keyboardHookHandle != IntPtr.Zero)
+            {
+                return;
+            }
+
+            _keyboardHookProc = LowLevelKeyboardHookCallback;
+            using var process = System.Diagnostics.Process.GetCurrentProcess();
+            var moduleHandle = NativeMethods.GetModuleHandle(process.MainModule?.ModuleName);
+
+            _keyboardHookHandle = NativeMethods.SetWindowsHookEx(
+                NativeMethods.WH_KEYBOARD_LL,
+                _keyboardHookProc!,
+                moduleHandle,
+                0);
+
+            if (_keyboardHookHandle == IntPtr.Zero)
+            {
+                var error = Marshal.GetLastWin32Error();
+                _keyboardHookProc = null;
+                Logger.LogError($"Failed to install keyboard hook for Peek window. Win32 error: {error}");
+            }
+        }
+
+        private void UninstallKeyboardHook()
+        {
+            if (_keyboardHookHandle != IntPtr.Zero)
+            {
+                if (NativeMethods.UnhookWindowsHookEx(_keyboardHookHandle))
+                {
+                    _keyboardHookHandle = IntPtr.Zero;
+                    _keyboardHookProc = null;
+                }
+                else
+                {
+                    var error = Marshal.GetLastWin32Error();
+                    Logger.LogError($"Failed to uninstall keyboard hook for Peek window. Win32 error: {error}");
+                }
+            }
+        }
+
+        private IntPtr LowLevelKeyboardHookCallback(int nCode, IntPtr wParam, IntPtr lParam)
+        {
+            const int WM_KEYDOWN = 0x0100;
+            const uint VK_W = 0x57;
+            const uint VK_ESCAPE = 0x1B;
+            const uint VK_LEFT = 0x25;
+            const uint VK_UP = 0x26;
+            const uint VK_RIGHT = 0x27;
+            const uint VK_DOWN = 0x28;
+            const int VK_CONTROL = 0x11;
+            const int VK_ALT = 0x12;
+            const int VK_SHIFT = 0x10;
+            const int VK_LWIN = 0x5B;
+            const int VK_RWIN = 0x5C;
+            const int KEY_PRESSED_MASK = 0x8000;
+
+            try
+            {
+                if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN && lParam != IntPtr.Zero)
+                {
+                    // Only handle when our window is in the foreground (cheap check before marshaling)
+                    var foreground = Windows.Win32.PInvoke_PeekUI.GetForegroundWindow();
+                    if (foreground != _cachedWindowHandle)
+                    {
+                        return NativeMethods.CallNextHookEx(_keyboardHookHandle, nCode, wParam, lParam);
+                    }
+
+                    var hookStruct = Marshal.PtrToStructure<NativeMethods.KBDLLHOOKSTRUCT>(lParam);
+
+                    // Fast-path: skip keys we never handle
+                    if (hookStruct.vkCode != VK_W && hookStruct.vkCode != VK_ESCAPE &&
+                        hookStruct.vkCode != VK_LEFT && hookStruct.vkCode != VK_RIGHT &&
+                        hookStruct.vkCode != VK_UP && hookStruct.vkCode != VK_DOWN)
+                    {
+                        return NativeMethods.CallNextHookEx(_keyboardHookHandle, nCode, wParam, lParam);
+                    }
+
+                    bool ctrlPressed = (NativeMethods.GetAsyncKeyState(VK_CONTROL) & KEY_PRESSED_MASK) != 0;
+                    bool altPressed = (NativeMethods.GetAsyncKeyState(VK_ALT) & KEY_PRESSED_MASK) != 0;
+                    bool shiftPressed = (NativeMethods.GetAsyncKeyState(VK_SHIFT) & KEY_PRESSED_MASK) != 0;
+                    bool winPressed = (NativeMethods.GetAsyncKeyState(VK_LWIN) & KEY_PRESSED_MASK) != 0 ||
+                                      (NativeMethods.GetAsyncKeyState(VK_RWIN) & KEY_PRESSED_MASK) != 0;
+                    bool handled = false;
+
+                    // Pass keys through while delete confirmation dialog is showing
+                    if (_isDeleteInProgress)
+                    {
+                        return NativeMethods.CallNextHookEx(_keyboardHookHandle, nCode, wParam, lParam);
+                    }
+
+                    if (ctrlPressed && !altPressed && !shiftPressed && !winPressed && hookStruct.vkCode == VK_W)
+                    {
+                        handled = DispatcherQueue.TryEnqueue(() =>
+                        {
+                            if (!_isDeleteInProgress)
+                            {
+                                Uninitialize();
+                            }
+                        });
+                    }
+                    else if (!ctrlPressed && !altPressed && !shiftPressed && !winPressed && hookStruct.vkCode == VK_ESCAPE)
+                    {
+                        handled = DispatcherQueue.TryEnqueue(() =>
+                        {
+                            if (!_isDeleteInProgress)
+                            {
+                                Uninitialize();
+                            }
+                        });
+                    }
+                    else if (!ctrlPressed && !altPressed && !shiftPressed && !winPressed && hookStruct.vkCode == VK_LEFT)
+                    {
+                        if (ViewModel.DisplayItemCount > 1)
+                        {
+                            handled = DispatcherQueue.TryEnqueue(() => ViewModel.AttemptPreviousNavigation());
+                        }
+                    }
+                    else if (!ctrlPressed && !altPressed && !shiftPressed && !winPressed && hookStruct.vkCode == VK_RIGHT)
+                    {
+                        if (ViewModel.DisplayItemCount > 1)
+                        {
+                            handled = DispatcherQueue.TryEnqueue(() => ViewModel.AttemptNextNavigation());
+                        }
+                    }
+                    else if (!ctrlPressed && !altPressed && !shiftPressed && !winPressed && hookStruct.vkCode == VK_UP)
+                    {
+                        if (ViewModel.DisplayItemCount > 1)
+                        {
+                            handled = DispatcherQueue.TryEnqueue(() => ViewModel.AttemptPreviousNavigation());
+                        }
+                    }
+                    else if (!ctrlPressed && !altPressed && !shiftPressed && !winPressed && hookStruct.vkCode == VK_DOWN)
+                    {
+                        if (ViewModel.DisplayItemCount > 1)
+                        {
+                            handled = DispatcherQueue.TryEnqueue(() => ViewModel.AttemptNextNavigation());
+                        }
+                    }
+
+                    if (handled)
+                    {
+                        return (IntPtr)1;
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Logger.LogError("Unhandled exception in Peek keyboard hook.", ex);
+            }
+
+            return NativeMethods.CallNextHookEx(_keyboardHookHandle, nCode, wParam, lParam);
+        }
+
         public void Dispose()
         {
+            UninstallKeyboardHook();
             themeListener?.Dispose();
             userSettings.Changed -= UpdateWindowBySettings;
         }