Fix Peek Ctrl+W shortcut not working after clicking preview

When the user clicks inside a file preview in Peek (PDF, text/code files,
markdown, HTML), the WebView2 control or shell preview handler captures
keyboard focus. Since these controls handle input in their own process/
message loop, the Ctrl+W KeyboardAccelerator defined on the parent XAML
Grid never fires, making it impossible to close the Peek window with the
keyboard shortcut.

This fix adds a low-level keyboard hook (WH_KEYBOARD_LL) that intercepts
Ctrl+W, Escape, and arrow navigation keys at the OS level when the Peek
window is in the foreground. This works regardless of which child control
has focus (WebView2, native shell preview handlers, etc.).

Additionally, browser-level accelerator keys are disabled on the WebView2
control (AreBrowserAcceleratorKeysEnabled = false) as defense-in-depth,
preventing Chromium from consuming shortcuts like Ctrl+W internally.

Fixes #48274

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: MuyuanMS

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

@@ -199,6 +199,13 @@ 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.) so that
+                // the WinUI WebView2 control forwards them to the XAML input system, allowing
+                // KeyboardAccelerators on the parent window (e.g., Ctrl+W to close) to work
+                // even when WebView2 content has focus. Monaco editor shortcuts (Ctrl+F, etc.)
+                // still function because they are handled by JavaScript, not the browser.
+                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,33 @@ 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);
     }
 }

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;
@@ -42,6 +44,9 @@ public sealed partial class MainWindow : WindowEx, IDisposable
         private bool _isDeleteInProgress;
         private bool _exitAfterClose;
 
+        private IntPtr _keyboardHookHandle;
+        private NativeMethods.LowLevelKeyboardProc? _keyboardHookProc;
+
         public MainWindow()
         {
             InitializeComponent();
@@ -209,13 +214,17 @@ private void Initialize(SelectedItem selectedItem)
             ViewModel.ScalingFactor = this.GetMonitorScale();
             this.Content.KeyUp += Content_KeyUp;
 
+            InstallKeyboardHook();
+
             bootTime.Stop();
 
             PowerToysTelemetry.Log.WriteEvent(new OpenedEvent() { FileExtension = ViewModel.CurrentItem?.Extension ?? string.Empty, HotKeyToVisibleTimeMs = bootTime.ElapsedMilliseconds });
         }
 
         private void Uninitialize()
         {
+            UninstallKeyboardHook();
+
             this.Restore();
             this.Hide();
 
@@ -309,6 +318,96 @@ private bool IsNewSingleSelectedItem(SelectedItem selectedItem)
             return false;
         }
 
+        private void InstallKeyboardHook()
+        {
+            if (_keyboardHookHandle != IntPtr.Zero)
+            {
+                return;
+            }
+
+            _keyboardHookProc = LowLevelKeyboardHookCallback;
+            _keyboardHookHandle = NativeMethods.SetWindowsHookEx(
+                NativeMethods.WH_KEYBOARD_LL,
+                _keyboardHookProc,
+                IntPtr.Zero,
+                0);
+        }
+
+        private void UninstallKeyboardHook()
+        {
+            if (_keyboardHookHandle != IntPtr.Zero)
+            {
+                NativeMethods.UnhookWindowsHookEx(_keyboardHookHandle);
+                _keyboardHookHandle = IntPtr.Zero;
+                _keyboardHookProc = null;
+            }
+        }
+
+        private IntPtr LowLevelKeyboardHookCallback(int nCode, IntPtr wParam, IntPtr lParam)
+        {
+            const int WM_KEYDOWN = 0x0100;
+            const int WM_SYSKEYDOWN = 0x0104;
+            const int VK_W = 0x57;
+            const int VK_ESCAPE = 0x1B;
+            const int VK_LEFT = 0x25;
+            const int VK_UP = 0x26;
+            const int VK_RIGHT = 0x27;
+            const int VK_DOWN = 0x28;
+
+            if (nCode >= 0 && (wParam == (IntPtr)WM_KEYDOWN || wParam == (IntPtr)WM_SYSKEYDOWN))
+            {
+                var hookStruct = Marshal.PtrToStructure<NativeMethods.KBDLLHOOKSTRUCT>(lParam);
+                bool ctrlPressed = (NativeMethods.GetAsyncKeyState(0x11) & 0x8000) != 0;
+
+                // Only handle when our window is in the foreground
+                var foreground = Windows.Win32.PInvoke_PeekUI.GetForegroundWindow();
+                var ourWindow = new Windows.Win32.Foundation.HWND(this.GetWindowHandle());
+
+                if (foreground == ourWindow)
+                {
+                    bool handled = false;
+
+                    if (ctrlPressed && hookStruct.vkCode == VK_W)
+                    {
+                        DispatcherQueue.TryEnqueue(Uninitialize);
+                        handled = true;
+                    }
+                    else if (hookStruct.vkCode == VK_ESCAPE)
+                    {
+                        DispatcherQueue.TryEnqueue(Uninitialize);
+                        handled = true;
+                    }
+                    else if (!ctrlPressed && hookStruct.vkCode == VK_LEFT)
+                    {
+                        DispatcherQueue.TryEnqueue(() => ViewModel.AttemptPreviousNavigation());
+                        handled = true;
+                    }
+                    else if (!ctrlPressed && hookStruct.vkCode == VK_RIGHT)
+                    {
+                        DispatcherQueue.TryEnqueue(() => ViewModel.AttemptNextNavigation());
+                        handled = true;
+                    }
+                    else if (!ctrlPressed && hookStruct.vkCode == VK_UP)
+                    {
+                        DispatcherQueue.TryEnqueue(() => ViewModel.AttemptPreviousNavigation());
+                        handled = true;
+                    }
+                    else if (!ctrlPressed && hookStruct.vkCode == VK_DOWN)
+                    {
+                        DispatcherQueue.TryEnqueue(() => ViewModel.AttemptNextNavigation());
+                        handled = true;
+                    }
+
+                    if (handled)
+                    {
+                        return (IntPtr)1;
+                    }
+                }
+            }
+
+            return NativeMethods.CallNextHookEx(_keyboardHookHandle, nCode, wParam, lParam);
+        }
+
         public void Dispose()
         {
             themeListener?.Dispose();