RegisterHotKey OHNE KeysModifier ?



  • Hi,
    ich hab nen Codeschnipsel gefunden um globale Hotkeys zu implementieren. Klappt wunderbar, ich frag mich nur:

    Wie kann ich auf den Modifier verzichten, dass der Hotkey beispielsweise nicht mehr CTRL+F12 wäre sondern nur noch F12?

    Es gibt diverse Meinungen, man könnte 0 als Modifier verwenden, was aber nichts bringt, da dann die Funktion "RegisterHotKey" nicht funktioniert.

    Jemand ne Idee?

    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Windows.Forms;
    using System.Runtime.InteropServices;
    
    namespace global_hotkeys
    {
        public partial class Form1 : Form
        {
            KeyboardHook hook = new KeyboardHook();
    
            public Form1()
            {
                InitializeComponent();
    
                hook.KeyPressed +=  new EventHandler<KeyPressedEventArgs>(hook_KeyPressed);
    
                hook.RegisterHotKey(fsModifier.Control, Keys.F12);
            }
    
            void hook_KeyPressed(object sender, KeyPressedEventArgs e)
            {
                label1.Text = e.Modifier.ToString() + " + " + e.Key.ToString();        
            }
        }
    
        public sealed class KeyboardHook : IDisposable
        {
            [DllImport("user32.dll")]
            private static extern bool RegisterHotKey(IntPtr hWnd, int id, uint fsModifiers, uint vk);
    
            [DllImport("user32.dll")]
            private static extern bool UnregisterHotKey(IntPtr hWnd, int id);
    
            private class Window : NativeWindow, IDisposable
            {
                public Window()
                {
                    this.CreateHandle(new CreateParams());
                }
    
                protected override void WndProc(ref Message m)
                {
                    base.WndProc(ref m);
    
                    if (m.Msg == 0x0312)
                    {
                        Keys key = (Keys)(((int)m.LParam >> 16) & 0xFFFF);
                        fsModifier modifier = (fsModifier)((int)m.LParam & 0xFFFF);
    
                        if (KeyPressed != null)
                        {
                            KeyPressed(this, new KeyPressedEventArgs(modifier, key));
                        }
                    }
                }
    
                public event EventHandler<KeyPressedEventArgs> KeyPressed;
    
                #region IDisposable Members
    
                public void Dispose()
                {
                    this.DestroyHandle();
                }
    
                #endregion
            }
    
            private Window _window = new Window();
            private int _currentId;
    
            public KeyboardHook()
            {
                _window.KeyPressed += delegate(object sender, KeyPressedEventArgs args)
                {
                    if (KeyPressed != null)
                        KeyPressed(this, args);
                };
            }
    
            public void RegisterHotKey(fsModifier modifier, Keys key)
            {
                _currentId = _currentId + 1;
    
                if(!RegisterHotKey(_window.Handle, _currentId, (uint)modifier, (uint)key))
                  throw new InvalidOperationException("Couldn’t register the hot key.");
            }
    
            public event EventHandler<KeyPressedEventArgs> KeyPressed;
    
            #region IDisposable Members
    
            public void Dispose()
            {
                for (int i = _currentId; i > 0; i--)
                {
                    UnregisterHotKey(_window.Handle, i);
                }
    
                _window.Dispose();
            }
    
            #endregion
        }
    
        public class KeyPressedEventArgs : EventArgs
        {
            private fsModifier _modifier;
            private Keys _key;
    
            internal KeyPressedEventArgs(fsModifier modifier, Keys key)
            {
                _modifier = modifier;
                _key = key;
            }
    
            public fsModifier Modifier
            {
                get { return _modifier; }
            }
    
            public Keys Key
            {
                get { return _key; }
            }
        }
    
        [Flags]
        public enum fsModifier : uint
        {
            Alt = 1,
            Control = 2,
            Shift = 4,
            Win = 8,
        }
    }
    


  • Probiere es doch mal mit einer anderen F-Taste. Denn:

    The F12 key is reserved for use by the debugger at all times, so it should not be registered as a hot key. Even when you are not debugging an application, F12 is reserved in case a kernel-mode debugger or a just-in-time debugger is resident.



  • Eh brudaaaaaal 😃
    An sowas hätt ich nicht gedacht, Respekt. Funzt!
    Merci



  • Hat es eigentlich einen tieferen Sinn, dass du mit Hooks arbeitest statt mit Events der Form?



  • inflames2k schrieb:

    Hat es eigentlich einen tieferen Sinn, dass du mit Hooks arbeitest statt mit Events der Form?

    Die Frage kann ich nicht beantworten. Ich hab eine fertige Klasse gesucht und diese gefunden, quasi um das Rad nicht neu erfinden zu müssen, ich verstehe auch halbwegs was in dem Code passiert, da ich aber nur 2-3 mal im Jahr was programmiere ist mein Stand eher dürftig.

    Was mir jetzt noch aufgefallen ist, ist dass permanent reagiert wird, solange eine Taste gedrückt ist. Wie ich da aber nur einmalig auf ein KeyDown reagiere, erschließt sich mir aktuell noch nicht...



  • Such mal bitte nach "NOREPEAT" meine etwas in der Richtung gelesen zu haben.


Log in to reply