public PencilKeyInfo(Pencil.Gaming.Key key, int scancode, KeyAction action, KeyModifiers modifiers)
 {
     Key = key;
     Scancode = scancode;
     Action = action;
     Modifiers = modifiers;
 }

 public HotKeyEventArgs(IntPtr hotKeyParam, IntPtr wParam)
 {
     uint param = (uint)hotKeyParam.ToInt64();
     Key = (Keys)((param & 0xffff0000) >> 16);
     Modifiers = (KeyModifiers)(param & 0x0000ffff);
     this.ID = (int)wParam;
 }

 public int RegisterHotkey(Keys key, KeyModifiers keyflags)
 {
     UInt32 hotkeyid = Win32.GlobalAddAtom(System.Guid.NewGuid().ToString());
     Win32.RegisterHotKey((IntPtr)hWnd, hotkeyid, (UInt32)keyflags, (UInt32)key);
     keyIDs.Add(hotkeyid, hotkeyid);
     return (int)hotkeyid;
 }

    public void RegisterHotKey(KeyModifiers keyModifiers, uint key)
    {
        if(hotKeySet)
            UnregisterHotKey();

        hotKeySet = User32_RegisterHotKey(Handle, 100, keyModifiers, key);
    }

 /// <summary>
 /// Initializes a new instance of the <see cref="FreezingArcher.Input.KeyboardInput"/> class.
 /// </summary>
 /// <param name="key">Key.</param>
 /// <param name="scancode">Scancode.</param>
 /// <param name="action">Action.</param>
 /// <param name="modifier">Modifier.</param>
 public KeyboardInput (Key key, int scancode, KeyAction action, KeyModifiers modifier)
 {
     Key = key;
     Scancode = scancode;
     Action = action;
     Modifier = modifier;
 }

 public static int RegisterHotKey(Keys key, KeyModifiers modifiers)
 {
     _windowReadyEvent.WaitOne();
     int id = System.Threading.Interlocked.Increment(ref _id);
     _wnd.Invoke(new RegisterHotKeyDelegate(RegisterHotKeyInternal), _hwnd, id, (uint)modifiers, (uint)key);
     return id;
 }

 public GlobalHotKey(KeyModifiers modifiers, Keys key)
 {
     if (!RegisterHotKey(this.Handle, ID, modifiers, key))
     {
         Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());
     }
 }

 private void AssertMapping(KeyState keyState, string text, KeyModifiers modifiers = KeyModifiers.None)
 {
     VimKeyData vimKeyData;
     Assert.True(_keyStateToVimKeyDataMap.TryGetValue(keyState, out vimKeyData));
     Assert.Equal(text, vimKeyData.TextOptional);
     Assert.Equal(modifiers, vimKeyData.KeyInputOptional.KeyModifiers);
 }

 private void VerifyConvert(VSConstants.VSStd2KCmdID cmd, KeyModifiers modifiers, KeyInput ki, EditCommandKind kind)
 {
     EditCommand command;
     Assert.True(OleCommandUtil.TryConvert(VSConstants.VSStd2K, (uint)cmd, IntPtr.Zero, modifiers, out command));
     Assert.Equal(ki, command.KeyInput);
     Assert.Equal(kind, command.EditCommandKind);
 }

 public HotKey(int id, KeyModifiers modifiers, Keys key, EventHandler<HotKeyEventArgs> genericHandler)
 {
     this.Id = id;
     this.Modifiers = modifiers;
     this.Keys = key;
     this.Handler = null;
     this.GenericHandler = genericHandler;
 }

		public HotKey(int _keyID, Keys _key, KeyModifiers _modifier, EventHandler hotKeyPressed)
		{
			keyID = _keyID;
			HotKeyPressed = hotKeyPressed;
			key = _key;
			modifier = _modifier;
			Start();
		}

        public static extern bool RegisterHotKey( 
            IntPtr hWnd, 
 
            int id, 
            KeyModifiers fsModifiers, 
 
            Keys vk 
 
            ); 

 public static extern bool RegisterHotKey(
     //要定义热键的窗口的句柄
     IntPtr hWnd,
     //定义热键ID（不能与其它ID重复）
     int id,
     //标识热键是否在按Alt、Ctrl、Shift、Windows等键时才会生效
     KeyModifiers fsModifiers,
     //定义热键的内容
     Keys vk
     );

 internal static KeyInput CreateKeyInput(
     VimKey key = VimKey.NotWellKnown,
     KeyModifiers mod = KeyModifiers.None,
     char? c = null)
 {
     return new KeyInput(
         key,
         mod,
         c.HasValue ? FSharpOption<char>.Some(c.Value) : FSharpOption<char>.None);
 }

        public Hotkey(IntPtr handle, int id, KeyModifiers modifiers, Keys key)
        {
            if (key == Keys.None || modifiers == KeyModifiers.None) throw new Exception();

            Handle = handle;
            ID = id;
            Modifiers = modifiers;
            Key = key;
            RegisterHotKey();
            Application.AddMessageFilter(this);
        }

        /// <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>
        /// <returns>Hot key ID</returns>
        public int RegisterHotKey(KeyModifiers modifier, Keys key)
        {
            // increment the counter.
            currentId = currentId + 1;

            // register the hot key.
            if (!RegisterHotKey(window.Handle, currentId, (uint)modifier, (uint)key))
            {
                throw new InvalidOperationException("Couldn’t register the hot key.");
            }

            return currentId;
        }

        internal static bool TryConvert(Guid commandGroup, uint commandId, IntPtr pVariableIn, KeyModifiers modifiers, out EditCommand command)
        {
            KeyInput keyInput;
            EditCommandKind kind;
            if (!TryConvert(commandGroup, commandId, pVariableIn, out keyInput, out kind))
            {
                command = null;
                return false;
            }

            keyInput = KeyInputUtil.ApplyModifiers(keyInput, modifiers);
            command = new EditCommand(keyInput, kind, commandGroup, commandId);
            return true;
        }

        /// Initializes a new instance of the <see cref="HotKey"/> by specific name, modifiers, and key.
        /// <param name="name">A <see cref="string"/> to identify the system hot key.</param>
        /// <param name="modifiers">Modify keys (Shift, Ctrl, Alt, and/or Windows Logo key).</param>
        /// <param name="key">Key code.</param>
        public HotKey(string name, KeyModifiers modifiers, Keys key)
        {
            if (name == null)
            {
                throw new ArgumentNullException("name");
            }

            if (key == Keys.None)
            {
                throw new ArgumentException("key cannot be Keys.None. Must specify a key for the hot key.", "key");
            }

            _name = name;
            _modifiers = modifiers;
            _key = key;
        }

 // TODO: UnsubscribeListener()
 //
 private void OnKeyDown(object sender, KeyboardKeyEventArgs keyboardKeyEventArgs)
 {
     List<KeyListener> listeners;
     //KeyModifiers mods = keyboardKeyEventArgs.Modifiers; // note that this always returns 0, probably a bug in openTK
     KeyModifiers mods = new KeyModifiers();
     mods = mods | (keyboard[Key.AltLeft] || keyboard[Key.AltRight] ? KeyModifiers.Alt : 0);
     mods = mods | (keyboard[Key.ShiftLeft] || keyboard[Key.ShiftRight] ? KeyModifiers.Shift : 0);
     mods = mods | (keyboard[Key.ControlLeft] || keyboard[Key.ControlRight] ? KeyModifiers.Control : 0);
     Listeners.TryGetValue(keyboardKeyEventArgs.Key, out listeners);
     if (listeners != null)
     {
         for (int i = 0; i < listeners.Count; i++)
         {
             listeners[i](mods);
         }
     }
 }

        public HotKeyRegister(IntPtr handle, int id, KeyModifiers modifiers, Keys key)
        {
            if (key == Keys.None || modifiers == KeyModifiers.None)
            {
                throw new ArgumentException("键或者编辑器不能为空。");
            }

            this.Handle = handle;
            this.ID = id;
            this.Modifiers = modifiers;
            this.Key = key;

            RegisterHotKey();

            // 添加一个消息过滤器来监督窗体信息，因为它们是由目标选择路径的。

            Application.AddMessageFilter(this);
        }