v1.2

FSI.BT.Tools/RadialMenu/Helpers/KeyPressedEventArgs.cs

@@ -0,0 +1,27 @@
+// <copyright file="KeyPressedEventArgs.cs" company="PlaceholderCompany">
+// Copyright (c) PlaceholderCompany. All rights reserved.
+// </copyright>
+
+namespace FSI.BT.Tools.RadialMenu.Helper
+{
+    using System;
+    using System.Windows.Forms;
+
+    /// <summary>
+    /// Event Args for the event that is fired after the hot key has been pressed.
+    /// </summary>
+    internal class KeyPressedEventArgs : EventArgs
+    {
+        private readonly Keys key;
+
+        internal KeyPressedEventArgs(KeyboardHookModifierKeys modifier, Keys key)
+        {
+            Modifier = modifier;
+            this.key = key;
+        }
+
+        internal KeyboardHookModifierKeys Modifier { get; }
+
+        internal Keys Key => key;
+    }
+}

FSI.BT.Tools/RadialMenu/Helpers/KeyboardHook.cs

@@ -0,0 +1,166 @@
+// <copyright file="KeyboardHook.cs" company="PlaceholderCompany">
+// Copyright (c) PlaceholderCompany. All rights reserved.
+// </copyright>
+
+namespace FSI.BT.Tools.RadialMenu.Helper
+{
+    using System;
+    using System.Windows.Forms;
+    using FSI.BT.Tools.Global.DllImports;
+    using FSI.BT.Tools.Global.UserInterface.HotkeyTextboxControl;
+
+    /// <summary>
+    /// The enumeration of possible modifiers.
+    /// </summary>
+    [Flags]
+    public enum KeyboardHookModifierKeys : uint
+    {
+        None = 0,
+        Alt = 1,
+        Control = 2,
+        Shift = 4,
+        Win = 8,
+    }
+
+    public sealed class KeyboardHook : IDisposable
+    {
+        private readonly Window window = new();
+        private int currentId;
+
+        public KeyboardHook()
+        {
+            // register the event of the inner native window.
+            window.KeyPressed += Window_KeyPressed;
+        }
+
+        /// <summary>
+        /// A hot key has been pressed.
+        /// </summary>
+        internal event EventHandler<KeyPressedEventArgs> KeyPressed;
+
+        public void Dispose()
+        {
+            // unregister all the registered hot keys.
+            for (int i = currentId; i > 0; i--)
+            {
+                NativeMethods.User32UnregisterHotKey(window.Handle, i);
+            }
+
+            // dispose the inner native window.
+            window.KeyPressed -= Window_KeyPressed;
+            window.Dispose();
+        }
+
+        /// <summary>
+        /// Registers a hot key in the system.
+        /// </summary>
+        /// <param name="key">The key itself that is associated with the hot key.</param>
+        internal void RegisterHotKey(Keys key)
+        {
+            uint keyModifiersNone = 0;
+            RegisterHotKey(keyModifiersNone, key);
+        }
+
+        internal void RegisterHotKey()
+        {
+            KeyboardHookModifierKeys modifiers = KeyboardHookModifierKeys.None;
+            string modifiersString = Global.Vars.RadialMenuSettings.HotKey;
+            if (!string.IsNullOrEmpty(modifiersString))
+            {
+                if (modifiersString.ToUpperInvariant().Contains("ALT", StringComparison.InvariantCulture))
+                {
+                    modifiers |= KeyboardHookModifierKeys.Alt;
+                }
+
+                if (modifiersString.ToUpperInvariant().Contains("CTRL", StringComparison.InvariantCulture) ||
+                    modifiersString.ToUpperInvariant().Contains("STRG", StringComparison.InvariantCulture))
+                {
+                    modifiers |= KeyboardHookModifierKeys.Control;
+                }
+
+                if (modifiersString.ToUpperInvariant().Contains("SHIFT", StringComparison.InvariantCulture))
+                {
+                    modifiers |= KeyboardHookModifierKeys.Shift;
+                }
+
+                if (modifiersString.ToUpperInvariant().Contains("WIN", StringComparison.InvariantCulture))
+                {
+                    modifiers |= KeyboardHookModifierKeys.Win;
+                }
+            }
+
+            RegisterHotKey(
+                modifiers,
+                HotkeyControl.HotkeyFromString(
+                    Global.Vars.RadialMenuSettings.HotKey));
+        }
+
+        /// <summary>
+        /// Registers a hot key in the system.
+        /// </summary>
+        /// <param name="modifier">The modifiers that are associated with the hot key.</param>
+        /// <param name="key">The key itself that is associated with the hot key.</param>
+        internal void RegisterHotKey(KeyboardHookModifierKeys modifier, Keys key)
+        {
+            RegisterHotKey((uint)modifier, key);
+        }
+
+        private void Window_KeyPressed(object sender, KeyPressedEventArgs e)
+        {
+            KeyPressed?.Invoke(this, e);
+        }
+
+        private void RegisterHotKey(uint modifier, Keys key)
+        {
+            currentId += 1;
+
+            if (!NativeMethods.User32RegisterHotKey(
+                window.Handle, currentId, modifier, (uint)key))
+            {
+                throw new InvalidOperationException(
+                    Global.Utilities.Translator.GetText("Could not register the hot key."));
+            }
+        }
+
+        /// <summary>
+        /// Represents the window that is used internally to get the messages.
+        /// </summary>
+        private class Window : NativeWindow, IDisposable
+        {
+            private const int WmHotkey = 0x0312;
+
+            public Window()
+            {
+                // create the handle for the window.
+                CreateHandle(new CreateParams());
+            }
+
+            public event EventHandler<KeyPressedEventArgs> KeyPressed;
+
+            public void Dispose()
+            {
+                DestroyHandle();
+            }
+
+            /// <summary>
+            /// Overridden to get the notifications.
+            /// </summary>
+            /// <param name="m">m.</param>
+            protected override void WndProc(ref Message m)
+            {
+                base.WndProc(ref m);
+
+                // check if we got a hot key pressed.
+                if (m.Msg == WmHotkey)
+                {
+                    // get the keys.
+                    Keys key = (Keys)(((int)m.LParam >> 16) & 0xFFFF);
+                    KeyboardHookModifierKeys modifier = (KeyboardHookModifierKeys)((int)m.LParam & 0xFFFF);
+
+                    // invoke the event to notify the parent.
+                    KeyPressed?.Invoke(this, new KeyPressedEventArgs(modifier, key));
+                }
+            }
+        }
+    }
+}