Add the Command Palette module (#37908)

Windows Command Palette ("CmdPal") is the next iteration of PowerToys Run. With extensibility at its core, the Command Palette is your one-stop launcher to start _anything_.

By default, CmdPal is bound to <kbd>Win+Alt+Space</kbd>.

![cmdpal-pr-002](https://github.com/user-attachments/assets/5077ec04-1009-478a-92d6-0a30989d44ac)
![cmdpal-pr-003](https://github.com/user-attachments/assets/63b4762a-9c19-48eb-9242-18ea48240ba0)

----

This brings the current preview version of CmdPal into the upstream PowerToys repo. There are still lots of bugs to work out, but it's reached the state we're ready to start sharing it with the world. From here, we can further collaborate with the community on the features that are important, and ensuring that we've got a most robust API to enable developers to build whatever extensions they want. 

Most of the built-in PT Run modules have already been ported to CmdPal's extension API. Those include:
* Installed apps
* Shell commands
* File search (powered by the indexer)
* Windows Registry search
* Web search
* Windows Terminal Profiles
* Windows Services
* Windows settings


There are a couple new extensions built-in
* You can now search for packages on `winget` and install them right from the palette. This also powers searching for extensions for the palette
* The calculator has an entirely new implementation. This is currently less feature complete than the original PT Run one - we're looking forward to updating it to be more complete for future ingestion in Windows
* "Bookmarks" allow you to save shortcuts to files, folders, and webpages as top-level commands in the palette. 

We've got a bunch of other samples too, in this repo and elsewhere

### PowerToys specific notes

CmdPal will eventually graduate out of PowerToys to live as its own application, which is why it's implemented just a little differently than most other modules. Enabling CmdPal will install its `msix` package. 

The CI was minorly changed to support CmdPal version numbers independent of PowerToys itself. It doesn't make sense for us to start CmdPal at v0.90, and in the future, we want to be able to rev CmdPal independently of PT itself. 


Closes #3200, closes #3600, closes #7770, closes #34273, closes #36471, closes #20976, closes #14495
  
  
-----

TODOs et al


**Blocking:**
- [ ] Images and descriptions in Settings and OOBE need to be properly defined, as mentioned before
  - [ ] Niels is on it
- [x] Doesn't start properly from PowerToys unless the fix PR is merged.
  - https://github.com/zadjii-msft/PowerToys/pull/556 merged
- [x] I seem to lose focus a lot when I press on some limits, like between the search bar and the results.
  - This is https://github.com/zadjii-msft/PowerToys/issues/427
- [x] Turned off an extension like Calculator and it was still working.
  - Need to get rid of that toggle, it doesn't do anything currently
- [x] `ListViewModel.<FetchItems>` crash
  - Pretty confident that was fixed in https://github.com/zadjii-msft/PowerToys/pull/553

**Not blocking / improvements:**
- Show the shortcut through settings, as mentioned before, or create a button that would open CmdPalette settings.
- When PowerToys starts, CmdPalette is always shown if enabled. That's weird when just starting PowerToys/ logging in to the computer with PowerToys auto-start activated. I think this should at least be a setting.
- Needing to double press a result for it to do the default action seems quirky. If one is already selected, I think just pressing should be enough for it to do the action.
  - This is currently a setting, though we're thinking of changing the setting even more: https://github.com/zadjii-msft/PowerToys/issues/392
- There's no URI extension. Was surprised when typing a URL that it only proposed a web search.
- [x] There's no System commands extension. Was expecting to be able to quickly restart the computer by typing restart but it wasn't there.
  - This is in PR https://github.com/zadjii-msft/PowerToys/pull/452  
  
---------

Co-authored-by: joadoumie <98557455+joadoumie@users.noreply.github.com>
Co-authored-by: Jordi Adoumie <jordiadoumie@microsoft.com>
Co-authored-by: Mike Griese <zadjii@gmail.com>
Co-authored-by: Niels Laute <niels.laute@live.nl>
Co-authored-by: Michael Hawker <24302614+michael-hawker@users.noreply.github.com>
Co-authored-by: Stefan Markovic <57057282+stefansjfw@users.noreply.github.com>
Co-authored-by: Seraphima <zykovas91@gmail.com>
Co-authored-by: Jaime Bernardo <jaime@janeasystems.com>
Co-authored-by: Kristen Schau <47155823+krschau@users.noreply.github.com>
Co-authored-by: Eric Johnson <ericjohnson327@gmail.com>
Co-authored-by: Ethan Fang <ethanfang@microsoft.com>
Co-authored-by: Yu Leng (from Dev Box) <yuleng@microsoft.com>
Co-authored-by: Clint Rutkas <clint@rutkas.com>

src/modules/cmdpal/Microsoft.CmdPal.UI/Controls/ShortcutControl/HotkeySettingsControlHook.cs

@@ -0,0 +1,89 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using PowerToys.Interop;
+
+namespace Microsoft.CmdPal.UI.Library;
+
+public delegate void KeyEvent(int key);
+
+public delegate bool IsActive();
+
+public delegate bool FilterAccessibleKeyboardEvents(int key, UIntPtr extraInfo);
+
+public class HotkeySettingsControlHook : IDisposable
+{
+    private const int WmKeyDown = 0x100;
+    private const int WmKeyUp = 0x101;
+    private const int WmSysKeyDown = 0x0104;
+    private const int WmSysKeyUp = 0x0105;
+
+    private readonly KeyboardHook _hook;
+    private readonly KeyEvent _keyDown;
+    private readonly KeyEvent _keyUp;
+    private readonly IsActive _isActive;
+
+    private readonly FilterAccessibleKeyboardEvents _filterKeyboardEvent;
+
+    private bool disposedValue;
+
+    public HotkeySettingsControlHook(KeyEvent keyDown, KeyEvent keyUp, IsActive isActive, FilterAccessibleKeyboardEvents filterAccessibleKeyboardEvents)
+    {
+        _keyDown = keyDown;
+        _keyUp = keyUp;
+        _isActive = isActive;
+        _filterKeyboardEvent = filterAccessibleKeyboardEvents;
+        _hook = new KeyboardHook(HotkeySettingsHookCallback, IsActive, FilterKeyboardEvents);
+        _hook.Start();
+    }
+
+    private bool IsActive()
+    {
+        return _isActive();
+    }
+
+    private void HotkeySettingsHookCallback(KeyboardEvent ev)
+    {
+        switch (ev.message)
+        {
+            case WmKeyDown:
+            case WmSysKeyDown:
+                _keyDown(ev.key);
+                break;
+            case WmKeyUp:
+            case WmSysKeyUp:
+                _keyUp(ev.key);
+                break;
+        }
+    }
+
+    private bool FilterKeyboardEvents(KeyboardEvent ev)
+    {
+#pragma warning disable CA2020 // Prevent from behavioral change
+        return _filterKeyboardEvent(ev.key, (UIntPtr)ev.dwExtraInfo);
+#pragma warning restore CA2020 // Prevent from behavioral change
+    }
+
+    protected virtual void Dispose(bool disposing)
+    {
+        if (!disposedValue)
+        {
+            if (disposing)
+            {
+                // Dispose the KeyboardHook object to terminate the hook threads
+                _hook.Dispose();
+            }
+
+            disposedValue = true;
+        }
+    }
+
+    public bool GetDisposedState() => disposedValue;
+
+    public void Dispose()
+    {
+        Dispose(disposing: true);
+        GC.SuppressFinalize(this);
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI/Controls/ShortcutControl/NativeKeyboardHelper.cs

@@ -0,0 +1,86 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.PowerToys.Settings.UI.Helpers
+{
+    internal static class NativeKeyboardHelper
+    {
+        [StructLayout(LayoutKind.Sequential)]
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("StyleCop.CSharp.NamingRules", "SA1307:Accessible fields should begin with upper-case letter", Justification = "Matching Native Structure")]
+        internal struct INPUT
+        {
+            internal INPUTTYPE type;
+            internal InputUnion data;
+
+            internal static int Size
+            {
+                get { return Marshal.SizeOf(typeof(INPUT)); }
+            }
+        }
+
+        [StructLayout(LayoutKind.Explicit)]
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("StyleCop.CSharp.NamingRules", "SA1307:Accessible fields should begin with upper-case letter", Justification = "Matching Native Structure")]
+        internal struct InputUnion
+        {
+            [FieldOffset(0)]
+            internal MOUSEINPUT mi;
+            [FieldOffset(0)]
+            internal KEYBDINPUT ki;
+            [FieldOffset(0)]
+            internal HARDWAREINPUT hi;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("StyleCop.CSharp.NamingRules", "SA1307:Accessible fields should begin with upper-case letter", Justification = "Matching Native Structure")]
+        internal struct MOUSEINPUT
+        {
+            internal int dx;
+            internal int dy;
+            internal int mouseData;
+            internal uint dwFlags;
+            internal uint time;
+            internal UIntPtr dwExtraInfo;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("StyleCop.CSharp.NamingRules", "SA1307:Accessible fields should begin with upper-case letter", Justification = "Matching Native Structure")]
+        internal struct KEYBDINPUT
+        {
+            internal short wVk;
+            internal short wScan;
+            internal uint dwFlags;
+            internal int time;
+            internal UIntPtr dwExtraInfo;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("StyleCop.CSharp.NamingRules", "SA1307:Accessible fields should begin with upper-case letter", Justification = "Matching Native Structure")]
+        internal struct HARDWAREINPUT
+        {
+            internal int uMsg;
+            internal short wParamL;
+            internal short wParamH;
+        }
+
+        internal enum INPUTTYPE : uint
+        {
+            INPUT_MOUSE = 0,
+            INPUT_KEYBOARD = 1,
+            INPUT_HARDWARE = 2,
+        }
+
+        [Flags]
+        internal enum KeyEventF
+        {
+            KeyDown = 0x0000,
+            ExtendedKey = 0x0001,
+            KeyUp = 0x0002,
+            Unicode = 0x0004,
+            Scancode = 0x0008,
+        }
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI/Controls/ShortcutControl/NativeMethods.cs

@@ -0,0 +1,81 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Microsoft.PowerToys.Settings.UI.Helpers;
+
+public static class NativeMethods
+{
+    private const int WS_POPUP = 1 << 31; // 0x80000000
+    internal const int GWL_STYLE = -16;
+    internal const int WS_CAPTION = 0x00C00000;
+    internal const int SPI_GETDESKWALLPAPER = 0x0073;
+    internal const int SW_SHOWNORMAL = 1;
+    internal const int SW_SHOWMAXIMIZED = 3;
+    internal const int SW_HIDE = 0;
+
+    [DllImport("user32.dll")]
+    internal static extern IntPtr GetActiveWindow();
+
+    [DllImport("user32.dll")]
+    internal static extern bool SetWindowPlacement(IntPtr hWnd, ref WINDOWPLACEMENT lpwndpl);
+
+    [DllImport("user32.dll")]
+    internal static extern bool GetWindowPlacement(IntPtr hWnd, out WINDOWPLACEMENT lpwndpl);
+
+    [DllImport("user32.dll")]
+    internal static extern uint SendInput(uint nInputs, NativeKeyboardHelper.INPUT[] pInputs, int cbSize);
+
+    [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall, SetLastError = true)]
+    internal static extern short GetAsyncKeyState(int vKey);
+
+    [DllImport("user32.dll", SetLastError = true)]
+    internal static extern int GetWindowLong(IntPtr hWnd, int nIndex);
+
+    [DllImport("user32.dll")]
+    internal static extern int SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong);
+
+    // [DllImport("shell32.dll")]
+    // internal static extern IntPtr SHBrowseForFolderW(ref ShellGetFolder.BrowseInformation browseInfo);
+    [DllImport("shell32.dll")]
+    internal static extern int SHGetPathFromIDListW(IntPtr pidl, IntPtr pszPath);
+
+    // [DllImport("Comdlg32.dll", CharSet = CharSet.Unicode)]
+    // internal static extern bool GetOpenFileName([In, Out] OpenFileName openFileName);
+#pragma warning disable CA1401 // P/Invokes should not be visible
+    [DllImport("user32.dll")]
+    public static extern bool ShowWindow(System.IntPtr hWnd, int nCmdShow);
+
+    [DllImport("user32.dll")]
+    public static extern int GetDpiForWindow(System.IntPtr hWnd);
+
+    [DllImport("user32.dll")]
+    public static extern bool IsWindowVisible(IntPtr hWnd);
+
+    [DllImport("user32.dll")]
+    public static extern bool AllowSetForegroundWindow(int dwProcessId);
+
+    [System.Runtime.InteropServices.DllImport("User32.dll")]
+    public static extern bool SetForegroundWindow(IntPtr handle);
+
+    [DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
+    public static extern IntPtr LoadLibrary(string dllToLoad);
+
+    [DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
+    public static extern bool FreeLibrary(IntPtr hModule);
+
+#pragma warning restore CA1401 // P/Invokes should not be visible
+
+    [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+
+    internal static extern bool SystemParametersInfo(int uiAction, int uiParam, StringBuilder pvParam, int fWinIni);
+
+    public static void SetPopupStyle(IntPtr hwnd)
+    {
+        _ = SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) | WS_POPUP);
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI/Controls/ShortcutControl/POINT.cs

@@ -0,0 +1,24 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.PowerToys.Settings.UI.Helpers
+{
+    [Serializable]
+    [StructLayout(LayoutKind.Sequential)]
+    public struct POINT
+    {
+        public int X { get; set; }
+
+        public int Y { get; set; }
+
+        public POINT(int x, int y)
+        {
+            X = x;
+            Y = y;
+        }
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI/Controls/ShortcutControl/RECT.cs

@@ -0,0 +1,30 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.PowerToys.Settings.UI.Helpers
+{
+    [Serializable]
+    [StructLayout(LayoutKind.Sequential)]
+    public struct RECT
+    {
+        public int Left { get; set; }
+
+        public int Top { get; set; }
+
+        public int Right { get; set; }
+
+        public int Bottom { get; set; }
+
+        public RECT(int left, int top, int right, int bottom)
+        {
+            Left = left;
+            Top = top;
+            Right = right;
+            Bottom = bottom;
+        }
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI/Controls/ShortcutControl/ShortcutControl.xaml

@@ -0,0 +1,53 @@
+<UserControl
+    x:Class="Microsoft.CmdPal.UI.Controls.ShortcutControl"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:controls="using:Microsoft.CmdPal.UI.Controls"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    x:Name="LayoutRoot"
+    d:DesignHeight="300"
+    d:DesignWidth="400"
+    mc:Ignorable="d">
+
+    <Grid HorizontalAlignment="Right">
+        <StackPanel Orientation="Horizontal">
+            <Button
+                x:Name="EditButton"
+                Padding="0"
+                Click="OpenDialogButton_Click"
+                CornerRadius="8">
+                <StackPanel
+                    Margin="12,6,12,6"
+                    Orientation="Horizontal"
+                    Spacing="16">
+                    <ItemsControl
+                        x:Name="PreviewKeysControl"
+                        VerticalAlignment="Center"
+                        IsEnabled="{Binding ElementName=EditButton, Path=IsEnabled}"
+                        IsTabStop="False">
+                        <ItemsControl.ItemsPanel>
+                            <ItemsPanelTemplate>
+                                <StackPanel Orientation="Horizontal" Spacing="4" />
+                            </ItemsPanelTemplate>
+                        </ItemsControl.ItemsPanel>
+                        <ItemsControl.ItemTemplate>
+                            <DataTemplate>
+                                <controls:KeyVisual
+                                    VerticalAlignment="Center"
+                                    AutomationProperties.AccessibilityView="Raw"
+                                    Content="{Binding}"
+                                    IsTabStop="False"
+                                    VisualType="Small" />
+                            </DataTemplate>
+                        </ItemsControl.ItemTemplate>
+                    </ItemsControl>
+                    <FontIcon
+                        FontFamily="{ThemeResource SymbolThemeFontFamily}"
+                        FontSize="16"
+                        Glyph="&#xE70F;" />
+                </StackPanel>
+            </Button>
+        </StackPanel>
+    </Grid>
+</UserControl>

src/modules/cmdpal/Microsoft.CmdPal.UI/Controls/ShortcutControl/ShortcutControl.xaml.cs

@@ -0,0 +1,511 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using CommunityToolkit.Mvvm.Messaging;
+using CommunityToolkit.WinUI;
+using Microsoft.CmdPal.UI.Library;
+using Microsoft.CmdPal.UI.ViewModels.Settings;
+using Microsoft.PowerToys.Settings.UI.Helpers;
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Automation;
+using Microsoft.UI.Xaml.Controls;
+using Microsoft.UI.Xaml.Input;
+using Windows.System;
+
+namespace Microsoft.CmdPal.UI.Controls;
+
+public sealed partial class ShortcutControl : UserControl, IDisposable, IRecipient<WindowActivatedEventArgs>
+{
+    private readonly UIntPtr ignoreKeyEventFlag = 0x5555;
+    private readonly System.Collections.Generic.HashSet<VirtualKey> _modifierKeysOnEntering = new();
+    private bool _enabled;
+    private HotkeySettings? hotkeySettings;
+    private HotkeySettings internalSettings;
+    private HotkeySettings? lastValidSettings;
+    private HotkeySettingsControlHook? hook;
+    private bool _isActive;
+    private bool disposedValue;
+
+    public string Header { get; set; } = string.Empty;
+
+    public string Keys { get; set; } = string.Empty;
+
+    public static readonly DependencyProperty IsActiveProperty = DependencyProperty.Register("Enabled", typeof(bool), typeof(ShortcutControl), null);
+    public static readonly DependencyProperty HotkeySettingsProperty = DependencyProperty.Register("HotkeySettings", typeof(HotkeySettings), typeof(ShortcutControl), null);
+
+    public static readonly DependencyProperty AllowDisableProperty = DependencyProperty.Register("AllowDisable", typeof(bool), typeof(ShortcutControl), new PropertyMetadata(false, OnAllowDisableChanged));
+
+    private static void OnAllowDisableChanged(DependencyObject d, DependencyPropertyChangedEventArgs? e)
+    {
+        var me = d as ShortcutControl;
+        if (me == null)
+        {
+            return;
+        }
+
+        var description = me.c?.FindDescendant<TextBlock>();
+        if (description == null)
+        {
+            return;
+        }
+
+        var resourceLoader = Microsoft.CmdPal.UI.Helpers.ResourceLoaderInstance.ResourceLoader;
+        var newValue = (bool)(e?.NewValue ?? false);
+        var text = newValue ?
+            resourceLoader.GetString("Activation_Shortcut_With_Disable_Description") :
+            resourceLoader.GetString("Activation_Shortcut_Description");
+        description.Text = text;
+    }
+
+    private readonly ShortcutDialogContentControl c = new();
+    private readonly ContentDialog shortcutDialog;
+
+    public bool AllowDisable
+    {
+        get => (bool)GetValue(AllowDisableProperty);
+        set => SetValue(AllowDisableProperty, value);
+    }
+
+    public bool Enabled
+    {
+        get
+        {
+            return _enabled;
+        }
+
+        set
+        {
+            SetValue(IsActiveProperty, value);
+            _enabled = value;
+
+            EditButton.IsEnabled = value;
+        }
+    }
+
+    public HotkeySettings? HotkeySettings
+    {
+        get
+        {
+            return hotkeySettings;
+        }
+
+        set
+        {
+            if (hotkeySettings != value)
+            {
+                hotkeySettings = value;
+                SetValue(HotkeySettingsProperty, value);
+                PreviewKeysControl.ItemsSource = HotkeySettings?.GetKeysList() ?? new List<object>();
+                AutomationProperties.SetHelpText(EditButton, HotkeySettings?.ToString() ?? string.Empty);
+                c.Keys = HotkeySettings?.GetKeysList() ?? new List<object>();
+            }
+        }
+    }
+
+    public ShortcutControl()
+    {
+        InitializeComponent();
+        internalSettings = new HotkeySettings();
+
+        var resourceLoader = Microsoft.CmdPal.UI.Helpers.ResourceLoaderInstance.ResourceLoader;
+
+        // We create the Dialog in C# because doing it in XAML is giving WinUI/XAML Island bugs when using dark theme.
+        shortcutDialog = new ContentDialog
+        {
+            XamlRoot = this.XamlRoot,
+            Title = resourceLoader.GetString("Activation_Shortcut_Title"),
+            Content = c,
+            PrimaryButtonText = resourceLoader.GetString("Activation_Shortcut_Save"),
+            SecondaryButtonText = resourceLoader.GetString("Activation_Shortcut_Reset"),
+            CloseButtonText = resourceLoader.GetString("Activation_Shortcut_Cancel"),
+            DefaultButton = ContentDialogButton.Primary,
+        };
+        shortcutDialog.SecondaryButtonClick += ShortcutDialog_Reset;
+        shortcutDialog.RightTapped += ShortcutDialog_Disable;
+
+        // The original ShortcutControl from PowerToys would hook up the bodies
+        // of DoLoad and DoUnload as `Loaded` and `Unloaded` handlers for `this`.
+        // We can't do that - since we might be virtualized in a list /
+        // ItemsRepeater, where those events are weirdly busted. We'd get both
+        // a Loaded and Unloaded as soon as we're displayed, which won't do.
+        //
+        // Instead, we'll do the work they used to do on Load/Unload when the
+        // dialog for this control is Opened/Close, respectively.
+        shortcutDialog.Opened += (s, e) => DoLoad();
+        shortcutDialog.Closed += (s, e) => DoUnload();
+        shortcutDialog.Opened += ShortcutDialog_Opened;
+        shortcutDialog.Closing += ShortcutDialog_Closing;
+
+        AutomationProperties.SetName(EditButton, resourceLoader.GetString("Activation_Shortcut_Title"));
+
+        WeakReferenceMessenger.Default.Register<WindowActivatedEventArgs>(this);
+
+        OnAllowDisableChanged(this, null);
+    }
+
+    private void DoUnload()
+    {
+        shortcutDialog.PrimaryButtonClick -= ShortcutDialog_PrimaryButtonClick;
+
+        // The original version of this control in PowerToys would add an event
+        // handler to the AppWindow here, to track if the window was active or
+        // inactive.
+        //
+        // That doesn't really work in our setup, as we might have multiple
+        // AppWindows per instance. Instead, we're having the SettingsWindow
+        // send us the WindowActivatedEventArgs, so that we can know when to
+        // stop our hook thread
+
+        // Dispose the HotkeySettingsControlHook object to terminate the hook threads when the textbox is unloaded
+        hook?.Dispose();
+
+        hook = null;
+    }
+
+    private void DoLoad()
+    {
+        // These all belong here; because of virtualization in e.g. a ListView, the control can go through several Loaded / Unloaded cycles.
+        hook?.Dispose();
+
+        hook = new HotkeySettingsControlHook(Hotkey_KeyDown, Hotkey_KeyUp, Hotkey_IsActive, FilterAccessibleKeyboardEvents);
+
+        shortcutDialog.PrimaryButtonClick += ShortcutDialog_PrimaryButtonClick;
+    }
+
+    private void KeyEventHandler(int key, bool matchValue, int matchValueCode)
+    {
+        var virtualKey = (VirtualKey)key;
+        switch (virtualKey)
+        {
+            case VirtualKey.LeftWindows:
+            case VirtualKey.RightWindows:
+                if (!matchValue && _modifierKeysOnEntering.Contains(virtualKey))
+                {
+                    SendSingleKeyboardInput((short)virtualKey, (uint)NativeKeyboardHelper.KeyEventF.KeyUp);
+                    _ = _modifierKeysOnEntering.Remove(virtualKey);
+                }
+
+                internalSettings.Win = matchValue;
+                break;
+            case VirtualKey.Control:
+            case VirtualKey.LeftControl:
+            case VirtualKey.RightControl:
+                if (!matchValue && _modifierKeysOnEntering.Contains(VirtualKey.Control))
+                {
+                    SendSingleKeyboardInput((short)virtualKey, (uint)NativeKeyboardHelper.KeyEventF.KeyUp);
+                    _ = _modifierKeysOnEntering.Remove(VirtualKey.Control);
+                }
+
+                internalSettings.Ctrl = matchValue;
+                break;
+            case VirtualKey.Menu:
+            case VirtualKey.LeftMenu:
+            case VirtualKey.RightMenu:
+                if (!matchValue && _modifierKeysOnEntering.Contains(VirtualKey.Menu))
+                {
+                    SendSingleKeyboardInput((short)virtualKey, (uint)NativeKeyboardHelper.KeyEventF.KeyUp);
+                    _ = _modifierKeysOnEntering.Remove(VirtualKey.Menu);
+                }
+
+                internalSettings.Alt = matchValue;
+                break;
+            case VirtualKey.Shift:
+            case VirtualKey.LeftShift:
+            case VirtualKey.RightShift:
+                if (!matchValue && _modifierKeysOnEntering.Contains(VirtualKey.Shift))
+                {
+                    SendSingleKeyboardInput((short)virtualKey, (uint)NativeKeyboardHelper.KeyEventF.KeyUp);
+                    _ = _modifierKeysOnEntering.Remove(VirtualKey.Shift);
+                }
+
+                internalSettings.Shift = matchValue;
+                break;
+            case VirtualKey.Escape:
+                internalSettings = new HotkeySettings();
+                shortcutDialog.IsPrimaryButtonEnabled = false;
+                return;
+            default:
+                internalSettings.Code = matchValueCode;
+                break;
+        }
+    }
+
+    // Function to send a single key event to the system which would be ignored by the hotkey control.
+    private void SendSingleKeyboardInput(short keyCode, uint keyStatus)
+    {
+        var inputShift = new NativeKeyboardHelper.INPUT
+        {
+            type = NativeKeyboardHelper.INPUTTYPE.INPUT_KEYBOARD,
+            data = new NativeKeyboardHelper.InputUnion
+            {
+                ki = new NativeKeyboardHelper.KEYBDINPUT
+                {
+                    wVk = keyCode,
+                    dwFlags = keyStatus,
+
+                    // Any keyevent with the extraInfo set to this value will be ignored by the keyboard hook and sent to the system instead.
+                    dwExtraInfo = ignoreKeyEventFlag,
+                },
+            },
+        };
+
+        NativeKeyboardHelper.INPUT[] inputs = [inputShift];
+
+        _ = NativeMethods.SendInput(1, inputs, NativeKeyboardHelper.INPUT.Size);
+    }
+
+    private bool FilterAccessibleKeyboardEvents(int key, UIntPtr extraInfo)
+    {
+        // A keyboard event sent with this value in the extra Information field should be ignored by the hook so that it can be captured by the system instead.
+        if (extraInfo == ignoreKeyEventFlag)
+        {
+            return false;
+        }
+
+        // If the current key press is tab, based on the other keys ignore the key press so as to shift focus out of the hotkey control.
+        if ((VirtualKey)key == VirtualKey.Tab)
+        {
+            // Shift was not pressed while entering and Shift is not pressed while leaving the hotkey control, treat it as a normal tab key press.
+            if (!internalSettings.Shift && !_modifierKeysOnEntering.Contains(VirtualKey.Shift) && !internalSettings.Win && !internalSettings.Alt && !internalSettings.Ctrl)
+            {
+                return false;
+            }
+
+            // Shift was not pressed while entering but it was pressed while leaving the hotkey, therefore simulate a shift key press as the system does not know about shift being pressed in the hotkey.
+            else if (internalSettings.Shift && !_modifierKeysOnEntering.Contains(VirtualKey.Shift) && !internalSettings.Win && !internalSettings.Alt && !internalSettings.Ctrl)
+            {
+                // This is to reset the shift key press within the control as it was not used within the control but rather was used to leave the hotkey.
+                internalSettings.Shift = false;
+
+                SendSingleKeyboardInput((short)VirtualKey.Shift, (uint)NativeKeyboardHelper.KeyEventF.KeyDown);
+
+                return false;
+            }
+
+            // Shift was pressed on entering and remained pressed, therefore only ignore the tab key so that it can be passed to the system.
+            // As the shift key is already assumed to be pressed by the system while it entered the hotkey control, shift would still remain pressed, hence ignoring the tab input would simulate a Shift+Tab key press.
+            else if (!internalSettings.Shift && _modifierKeysOnEntering.Contains(VirtualKey.Shift) && !internalSettings.Win && !internalSettings.Alt && !internalSettings.Ctrl)
+            {
+                return false;
+            }
+        }
+
+        // Either the cancel or save button has keyboard focus.
+        return FocusManager.GetFocusedElement(LayoutRoot.XamlRoot).GetType() != typeof(Button);
+    }
+
+    private void Hotkey_KeyDown(int key)
+    {
+        KeyEventHandler(key, true, key);
+
+        c.Keys = internalSettings.GetKeysList();
+
+        if (internalSettings.GetKeysList().Count == 0)
+        {
+            // Empty, disable save button
+            shortcutDialog.IsPrimaryButtonEnabled = false;
+        }
+        else if (internalSettings.GetKeysList().Count == 1)
+        {
+            // 1 key, disable save button
+            shortcutDialog.IsPrimaryButtonEnabled = false;
+
+            // Check if the one key is a hotkey
+            c.IsError = !internalSettings.Shift && !internalSettings.Win && !internalSettings.Alt && !internalSettings.Ctrl;
+        }
+
+        // Tab and Shift+Tab are accessible keys and should not be displayed in the hotkey control.
+        if (internalSettings.Code > 0 && !internalSettings.IsAccessibleShortcut())
+        {
+            lastValidSettings = internalSettings with { };
+
+            if (!ComboIsValid(lastValidSettings))
+            {
+                DisableKeys();
+            }
+            else
+            {
+                EnableKeys();
+            }
+        }
+
+        c.IsWarningAltGr = internalSettings.Ctrl && internalSettings.Alt && !internalSettings.Win && (internalSettings.Code > 0);
+    }
+
+    private void EnableKeys()
+    {
+        shortcutDialog.IsPrimaryButtonEnabled = true;
+        c.IsError = false;
+
+        // WarningLabel.Style = (Style)App.Current.Resources["SecondaryTextStyle"];
+    }
+
+    private void DisableKeys()
+    {
+        shortcutDialog.IsPrimaryButtonEnabled = false;
+        c.IsError = true;
+
+        // WarningLabel.Style = (Style)App.Current.Resources["SecondaryWarningTextStyle"];
+    }
+
+    private void Hotkey_KeyUp(int key)
+    {
+        KeyEventHandler(key, false, 0);
+    }
+
+    private bool Hotkey_IsActive()
+    {
+        return _isActive;
+    }
+
+    private void ShortcutDialog_Opened(ContentDialog sender, ContentDialogOpenedEventArgs args)
+    {
+        if (!ComboIsValid(hotkeySettings))
+        {
+            DisableKeys();
+        }
+        else
+        {
+            EnableKeys();
+        }
+
+        // Reset the status on entering the hotkey each time.
+        _modifierKeysOnEntering.Clear();
+
+        // To keep track of the modifier keys, whether it was pressed on entering.
+        if ((NativeMethods.GetAsyncKeyState((int)VirtualKey.Shift) & 0x8000) != 0)
+        {
+            _modifierKeysOnEntering.Add(VirtualKey.Shift);
+        }
+
+        if ((NativeMethods.GetAsyncKeyState((int)VirtualKey.Control) & 0x8000) != 0)
+        {
+            _modifierKeysOnEntering.Add(VirtualKey.Control);
+        }
+
+        if ((NativeMethods.GetAsyncKeyState((int)VirtualKey.Menu) & 0x8000) != 0)
+        {
+            _modifierKeysOnEntering.Add(VirtualKey.Menu);
+        }
+
+        if ((NativeMethods.GetAsyncKeyState((int)VirtualKey.LeftWindows) & 0x8000) != 0)
+        {
+            _modifierKeysOnEntering.Add(VirtualKey.LeftWindows);
+        }
+
+        if ((NativeMethods.GetAsyncKeyState((int)VirtualKey.RightWindows) & 0x8000) != 0)
+        {
+            _modifierKeysOnEntering.Add(VirtualKey.RightWindows);
+        }
+
+        _isActive = true;
+    }
+
+    private async void OpenDialogButton_Click(object sender, RoutedEventArgs e)
+    {
+        // c.Keys = null;
+        c.Keys = HotkeySettings?.GetKeysList() ?? new List<object>();
+
+        // 92 means the Win key. The logic is: warning should be visible if the shortcut contains Alt AND contains Ctrl AND NOT contains Win.
+        // Additional key must be present, as this is a valid, previously used shortcut shown at dialog open. Check for presence of non-modifier-key is not necessary therefore
+        c.IsWarningAltGr = c.Keys.Contains("Ctrl") && c.Keys.Contains("Alt") && !c.Keys.Contains(92);
+
+        shortcutDialog.XamlRoot = this.XamlRoot;
+        shortcutDialog.RequestedTheme = this.ActualTheme;
+        await shortcutDialog.ShowAsync();
+    }
+
+    private void ShortcutDialog_Reset(ContentDialog sender, ContentDialogButtonClickEventArgs args)
+    {
+        hotkeySettings = null;
+
+        SetValue(HotkeySettingsProperty, hotkeySettings);
+        PreviewKeysControl.ItemsSource = HotkeySettings?.GetKeysList() ?? new List<object>();
+
+        lastValidSettings = hotkeySettings;
+
+        AutomationProperties.SetHelpText(EditButton, HotkeySettings?.ToString() ?? string.Empty);
+        shortcutDialog.Hide();
+    }
+
+    private void ShortcutDialog_PrimaryButtonClick(ContentDialog sender, ContentDialogButtonClickEventArgs args)
+    {
+        if (lastValidSettings != null && ComboIsValid(lastValidSettings))
+        {
+            HotkeySettings = lastValidSettings with { };
+        }
+
+        PreviewKeysControl.ItemsSource = hotkeySettings?.GetKeysList() ?? new List<object>();
+        AutomationProperties.SetHelpText(EditButton, HotkeySettings?.ToString() ?? string.Empty);
+        shortcutDialog.Hide();
+    }
+
+    private void ShortcutDialog_Disable(object sender, RightTappedRoutedEventArgs e)
+    {
+        if (!AllowDisable)
+        {
+            return;
+        }
+
+        var empty = new HotkeySettings();
+        HotkeySettings = empty;
+
+        PreviewKeysControl.ItemsSource = HotkeySettings.GetKeysList();
+        AutomationProperties.SetHelpText(EditButton, HotkeySettings.ToString());
+        shortcutDialog.Hide();
+    }
+
+    private static bool ComboIsValid(HotkeySettings? settings)
+    {
+        return settings != null && (settings.IsValid() || settings.IsEmpty());
+    }
+
+    public void Receive(WindowActivatedEventArgs message) => DoWindowActivated(message);
+
+    private void DoWindowActivated(WindowActivatedEventArgs args)
+    {
+        args.Handled = true;
+        if (args.WindowActivationState != WindowActivationState.Deactivated && (hook == null || hook.GetDisposedState() == true))
+        {
+            // If the PT settings window gets focussed/activated again, we enable the keyboard hook to catch the keyboard input.
+            hook = new HotkeySettingsControlHook(Hotkey_KeyDown, Hotkey_KeyUp, Hotkey_IsActive, FilterAccessibleKeyboardEvents);
+        }
+        else if (args.WindowActivationState == WindowActivationState.Deactivated && hook != null && hook.GetDisposedState() == false)
+        {
+            // If the PT settings window lost focus/activation, we disable the keyboard hook to allow keyboard input on other windows.
+            hook.Dispose();
+            hook = null;
+        }
+    }
+
+    private void ShortcutDialog_Closing(ContentDialog sender, ContentDialogClosingEventArgs args)
+    {
+        _isActive = false;
+    }
+
+    private void Dispose(bool disposing)
+    {
+        if (!disposedValue)
+        {
+            if (disposing)
+            {
+                if (hook != null)
+                {
+                    hook.Dispose();
+                }
+
+                hook = null;
+            }
+
+            disposedValue = true;
+        }
+    }
+
+    public void Dispose()
+    {
+        // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
+        Dispose(disposing: true);
+        GC.SuppressFinalize(this);
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI/Controls/ShortcutControl/ShortcutDialogContentControl.xaml

@@ -0,0 +1,76 @@
+<UserControl
+    x:Class="Microsoft.CmdPal.UI.Controls.ShortcutDialogContentControl"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:controls="using:Microsoft.CmdPal.UI.Controls"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    xmlns:tk7controls="using:CommunityToolkit.WinUI.UI.Controls"
+    x:Name="ShortcutContentControl"
+    mc:Ignorable="d">
+    <Grid MinWidth="498" MinHeight="220">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto" />
+            <RowDefinition MinHeight="110" />
+            <RowDefinition Height="Auto" />
+        </Grid.RowDefinitions>
+
+        <TextBlock Grid.Row="0" />
+
+        <ItemsControl
+            x:Name="KeysControl"
+            Grid.Row="1"
+            Height="56"
+            Margin="0,64,0,0"
+            HorizontalAlignment="Center"
+            VerticalAlignment="Top"
+            HorizontalContentAlignment="Center"
+            ItemsSource="{x:Bind Keys, Mode=OneWay}">
+            <ItemsControl.ItemsPanel>
+                <ItemsPanelTemplate>
+                    <StackPanel Orientation="Horizontal" Spacing="8" />
+                </ItemsPanelTemplate>
+            </ItemsControl.ItemsPanel>
+            <ItemsControl.ItemTemplate>
+                <DataTemplate>
+                    <controls:KeyVisual
+                        Height="56"
+                        AutomationProperties.AccessibilityView="Raw"
+                        Content="{Binding}"
+                        IsError="{Binding ElementName=ShortcutContentControl, Path=IsError, Mode=OneWay}"
+                        IsTabStop="False"
+                        VisualType="Large" />
+                </DataTemplate>
+            </ItemsControl.ItemTemplate>
+        </ItemsControl>
+
+        <StackPanel
+            Grid.Row="2"
+            Margin="0,24,0,0"
+            VerticalAlignment="Top"
+            Orientation="Vertical"
+            Spacing="8">
+            <Grid Height="62">
+
+                <InfoBar
+                    x:Uid="InvalidShortcut"
+                    IsClosable="False"
+                    IsOpen="{Binding ElementName=ShortcutContentControl, Path=IsError, Mode=OneWay}"
+                    IsTabStop="{Binding ElementName=ShortcutContentControl, Path=IsError, Mode=OneWay}"
+                    Severity="Error" />
+
+                <InfoBar
+                    x:Uid="WarningShortcutAltGr"
+                    IsClosable="False"
+                    IsOpen="{Binding ElementName=ShortcutContentControl, Path=IsWarningAltGr, Mode=OneWay}"
+                    IsTabStop="{Binding ElementName=ShortcutContentControl, Path=IsWarningAltGr, Mode=OneWay}"
+                    Severity="Warning" />
+            </Grid>
+            <tk7controls:MarkdownTextBlock
+                x:Uid="InvalidShortcutWarningLabel"
+                Background="Transparent"
+                FontSize="12"
+                Foreground="{ThemeResource TextFillColorSecondaryBrush}" />
+        </StackPanel>
+    </Grid>
+</UserControl>

src/modules/cmdpal/Microsoft.CmdPal.UI/Controls/ShortcutControl/ShortcutDialogContentControl.xaml.cs

@@ -0,0 +1,41 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CmdPal.UI;
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Controls;
+
+namespace Microsoft.CmdPal.UI.Controls;
+
+public sealed partial class ShortcutDialogContentControl : UserControl
+{
+    public ShortcutDialogContentControl()
+    {
+        this.InitializeComponent();
+    }
+
+    public List<object> Keys
+    {
+        get { return (List<object>)GetValue(KeysProperty); }
+        set { SetValue(KeysProperty, value); }
+    }
+
+    public static readonly DependencyProperty KeysProperty = DependencyProperty.Register("Keys", typeof(List<object>), typeof(ShortcutDialogContentControl), new PropertyMetadata(default(string)));
+
+    public bool IsError
+    {
+        get => (bool)GetValue(IsErrorProperty);
+        set => SetValue(IsErrorProperty, value);
+    }
+
+    public static readonly DependencyProperty IsErrorProperty = DependencyProperty.Register("IsError", typeof(bool), typeof(ShortcutDialogContentControl), new PropertyMetadata(false));
+
+    public bool IsWarningAltGr
+    {
+        get => (bool)GetValue(IsWarningAltGrProperty);
+        set => SetValue(IsWarningAltGrProperty, value);
+    }
+
+    public static readonly DependencyProperty IsWarningAltGrProperty = DependencyProperty.Register("IsWarningAltGr", typeof(bool), typeof(ShortcutDialogContentControl), new PropertyMetadata(false));
+}

src/modules/cmdpal/Microsoft.CmdPal.UI/Controls/ShortcutControl/ShortcutWithTextLabelControl.xaml

@@ -0,0 +1,45 @@
+<UserControl
+    x:Class="Microsoft.CmdPal.UI.Controls.ShortcutWithTextLabelControl"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:controls="using:Microsoft.CmdPal.UI.Controls"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    xmlns:tk7controls="using:CommunityToolkit.WinUI.UI.Controls"
+    d:DesignHeight="300"
+    d:DesignWidth="400"
+    mc:Ignorable="d">
+
+    <Grid ColumnSpacing="8">
+        <Grid.ColumnDefinitions>
+            <ColumnDefinition Width="Auto" />
+            <ColumnDefinition Width="*" />
+        </Grid.ColumnDefinitions>
+        <ItemsControl
+            VerticalAlignment="Center"
+            AutomationProperties.AccessibilityView="Raw"
+            IsTabStop="False"
+            ItemsSource="{x:Bind Keys}">
+            <ItemsControl.ItemsPanel>
+                <ItemsPanelTemplate>
+                    <StackPanel Orientation="Horizontal" Spacing="4" />
+                </ItemsPanelTemplate>
+            </ItemsControl.ItemsPanel>
+            <ItemsControl.ItemTemplate>
+                <DataTemplate>
+                    <controls:KeyVisual
+                        VerticalAlignment="Center"
+                        AutomationProperties.AccessibilityView="Raw"
+                        Content="{Binding}"
+                        IsTabStop="False"
+                        VisualType="SmallOutline" />
+                </DataTemplate>
+            </ItemsControl.ItemTemplate>
+        </ItemsControl>
+        <tk7controls:MarkdownTextBlock
+            Grid.Column="1"
+            VerticalAlignment="Center"
+            Background="Transparent"
+            Text="{x:Bind Text}" />
+    </Grid>
+</UserControl>

src/modules/cmdpal/Microsoft.CmdPal.UI/Controls/ShortcutControl/ShortcutWithTextLabelControl.xaml.cs

@@ -0,0 +1,35 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Controls;
+
+namespace Microsoft.CmdPal.UI.Controls
+{
+    public sealed partial class ShortcutWithTextLabelControl : UserControl
+    {
+        public string Text
+        {
+            get { return (string)GetValue(TextProperty); }
+            set { SetValue(TextProperty, value); }
+        }
+
+        public static readonly DependencyProperty TextProperty = DependencyProperty.Register("Text", typeof(string), typeof(ShortcutWithTextLabelControl), new PropertyMetadata(default(string)));
+
+        public List<object> Keys
+        {
+            get { return (List<object>)GetValue(KeysProperty); }
+            set { SetValue(KeysProperty, value); }
+        }
+
+        public static readonly DependencyProperty KeysProperty = DependencyProperty.Register("Keys", typeof(List<object>), typeof(ShortcutWithTextLabelControl), new PropertyMetadata(default(string)));
+
+        public ShortcutWithTextLabelControl()
+        {
+            this.InitializeComponent();
+        }
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI/Controls/ShortcutControl/WINDOWPLACEMENT.cs

@@ -0,0 +1,26 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.PowerToys.Settings.UI.Helpers
+{
+    [Serializable]
+    [StructLayout(LayoutKind.Sequential)]
+    public struct WINDOWPLACEMENT
+    {
+        public int Length { get; set; }
+
+        public int Flags { get; set; }
+
+        public int ShowCmd { get; set; }
+
+        public POINT MinPosition { get; set; }
+
+        public POINT MaxPosition { get; set; }
+
+        public RECT NormalPosition { get; set; }
+    }
+}