static void Prefix() { //TODO: Maybe bring this back if I ever properly implement the config menu. //if (Input.GetKeyDown(KeyCode.F5)) //{ // ConfigMenu.Instance.Show = !ConfigMenu.Instance.Show; // UIManager.SomeOtherMenuIsOpen = ConfigMenu.Instance.Show; // if (ConfigMenu.Instance.Show) // { // UIManager.UnlockMouseAndDisableFirstPersonLooking(); // } // else // { // UIManager.LockMouseAndEnableFirstPersonLooking(); // } //} foreach (var key in KeyCodesToListenTo) { if ((Input.GetKeyDown(key.Key)) || (key.Repeat && Input.GetKey(key.Key) && Time.time - PressedTimes[key] >= key.RepeatInterval)) { PressedTimes[key] = Time.time; KeyDown?.Invoke(key.Key); } } ModInput.UpdateListeners(); }
public void Update(GameTime gt) { KeyboardState keyboardState = KeyboardState; Keys[] last = lastKeyboardState.GetPressedKeys(); Keys[] current = keyboardState.GetPressedKeys(); foreach (Keys key in current.Except(last)) { KeyDown?.Invoke(this, new KeyEventArgs(key, keyboardState)); } foreach (Keys key in last.Except(current)) { KeyUp?.Invoke(this, new KeyEventArgs(key, keyboardState)); } lastKeyboardState = KeyboardState; MouseState mouseState = MouseState; if (lastMouseState.LeftButton == ButtonState.Released && mouseState.LeftButton == ButtonState.Pressed) { MouseDown?.Invoke(this, new MouseEventArgs(MouseButtons.Left, mouseState)); } if (lastMouseState.LeftButton == ButtonState.Pressed && mouseState.LeftButton == ButtonState.Released) { MouseUp?.Invoke(this, new MouseEventArgs(MouseButtons.Left, mouseState)); } lastMouseState = mouseState; }
public static void OnKeyDown(Keys key) { KeyDown.Invoke(key); if (IsMenuBarActive) { MenuBar.OnKeyDown(key); } else { // Small workaround: if key is escape active widget is window // Send it there var topWidget = GetTopWidget(); var asWindow = topWidget as Window; if (asWindow != null) { if (key == Keys.Escape) { asWindow.OnKeyDown(key); } var asDialog = asWindow as Dialog; if (asDialog != null && key == Keys.Enter) { // Dialog also always receives Enter (Ok) asWindow.OnKeyDown(key); } } if (_focusedKeyboardWidget != null && _focusedKeyboardWidget.Active) { _focusedKeyboardWidget.OnKeyDown(key); #if XENKO var ch = key.ToChar(_downKeys.Contains(Keys.LeftShift) || _downKeys.Contains(Keys.RightShift)); if (ch != null) { _focusedKeyboardWidget.OnChar(ch.Value); } #endif } } if (key == Keys.Escape && ContextMenu != null) { HideContextMenu(); } #if MONOGAME if (!HasExternalTextInput && !IsControlDown && !IsAltDown) { var c = key.ToChar(IsShiftDown); if (c != null) { OnChar(c.Value); } } #endif }
public bool OnKeyDown(ModKeys modKeys, Keys keyCode, string srcElementTagName, string srcElementTypeName) { var args = new HotKeyDownEventArgs(modKeys, keyCode, srcElementTagName, srcElementTypeName); KeyDown?.Invoke(null, args); return(args.PreventDefault); }
private void FileStatusListView_KeyDown(object sender, KeyEventArgs e) { switch (e.KeyCode) { case Keys.A: { if (!e.Control) { break; } FileStatusListView.BeginUpdate(); try { for (var i = 0; i < FileStatusListView.Items.Count; i++) { FileStatusListView.Items[i].Selected = true; } e.Handled = true; } finally { FileStatusListView.EndUpdate(); } break; } default: KeyDown?.Invoke(sender, e); break; } }
private void KeyboardInputSource_KeyboardInput(object sender, RawKeyboardInputEventArgs e) { // only evaluate this event if it is actually intended for this device //TODO: add some sort of conditional event invocation before this if (e.Header.hDevice != DeviceHandle) { return; } VirtualKeys key = (VirtualKeys)e.Data.VirtualKey; switch ((WM)e.Data.Message) { case WM.KEYDOWN: { KeyDown?.Invoke(this, new KeyInputEventArgs(key)); break; } case WM.KEYUP: { KeyUp?.Invoke(this, new KeyInputEventArgs(key)); break; } case WM.SYSKEYDOWN: { //TODO: syskeydown break; } } }
private int HookCallback(int code, IntPtr wParam, ref KBDLLHOOKSTRUCT lParam) { int result = 0; try { if (!IsPaused && code >= 0) { if (wParam.ToInt32() == WM_SYSKEYDOWN || wParam.ToInt32() == WM_KEYDOWN) { KeyDown?.Invoke(this, new KeyboardHookEventArgs(lParam)); } if (wParam.ToInt32() == WM_SYSKEYUP || wParam.ToInt32() == WM_KEYUP) { KeyUp?.Invoke(this, new KeyboardHookEventArgs(lParam)); } } } finally { result = CallNextHookEx(IntPtr.Zero, code, wParam, ref lParam); } return(result); }
/// <summary> /// The callback for the keyboard hook /// </summary> /// <param name="code">The hook code, if it isn't >= 0, the function shouldn't do anyting</param> /// <param name="wParam">The event type</param> /// <param name="lParam">The keyhook event information</param> /// <returns></returns> private IntPtr hookProc(int code, IntPtr wParam, ref NativeMethods.keyboardHookStruct lParam) { if (code >= 0) { Key key = KeyInterop.KeyFromVirtualKey(lParam.vkCode); if (HookedKeys.Contains(key)) { var wparam = wParam.ToInt64(); var args = new KeyHookEventArgs(key); if ((wparam == NativeMethods.WM_KEYDOWN || wparam == NativeMethods.WM_SYSKEYDOWN) && (KeyDown != null)) { KeyDown.Invoke(this, args); } else if ((wparam == NativeMethods.WM_KEYUP || wparam == NativeMethods.WM_SYSKEYUP) && (KeyUp != null)) { KeyUp.Invoke(this, args); } if (args.Handled) { return(new IntPtr(1)); } } } return(NativeMethods.CallNextHookEx(hhook, code, wParam, ref lParam)); }
private int HookProc(int code, int wParam, ref User32.KeyboardHookStruct lParam) { if (code < 0) { return(User32.CallNextHookEx(_hhook, code, wParam, ref lParam)); } if (IsWindowsKeyPressed()) { return(User32.CallNextHookEx(_hhook, code, wParam, ref lParam)); } var key = (Keys)lParam.vkCode; key = AddModifiers(key); var kea = new KeyEventArgs(key); if (wParam == User32.WM_KEYDOWN || wParam == User32.WM_SYSKEYDOWN) { KeyDown?.Invoke(this, kea); } else if (wParam == User32.WM_KEYUP || wParam == User32.WM_SYSKEYUP) { KeyUp?.Invoke(this, kea); } return(kea.Handled ? 1 : User32.CallNextHookEx(_hhook, code, wParam, ref lParam)); }
private void CoreDispatcher_AcceleratorKeyActivated(CoreDispatcher sender, AcceleratorKeyEventArgs e) { if ((e.EventType == CoreAcceleratorKeyEventType.SystemKeyDown || e.EventType == CoreAcceleratorKeyEventType.KeyDown)) { var coreWindow = Windows.UI.Xaml.Window.Current.CoreWindow; var downState = CoreVirtualKeyStates.Down; var virtualKey = e.VirtualKey; bool winKey = ((coreWindow.GetKeyState(VirtualKey.LeftWindows) & downState) == downState || (coreWindow.GetKeyState(VirtualKey.RightWindows) & downState) == downState); bool altKey = (coreWindow.GetKeyState(VirtualKey.Menu) & downState) == downState; bool controlKey = (coreWindow.GetKeyState(VirtualKey.Control) & downState) == downState; bool shiftKey = (coreWindow.GetKeyState(VirtualKey.Shift) & downState) == downState; // raise keydown actions var keyDown = new KeyboardEventArgs { AltKey = altKey, Character = ToChar(virtualKey, shiftKey), ControlKey = controlKey, EventArgs = e, ShiftKey = shiftKey, VirtualKey = virtualKey }; try { KeyDown?.Invoke(keyDown); } catch { } // Handle F5 to refresh content if (virtualKey == VirtualKey.F5) { bool noModifiers = !altKey && !controlKey && !shiftKey; RefreshRequest?.Invoke(keyDown); } } }
/// <summary> /// The callback for the keyboard hook /// </summary> /// <param name="code">The hook code, if it isn't >= 0, the function shouldn't do anyting</param> /// <param name="wParam">The event type</param> /// <param name="lParam">The keyhook event information</param> /// <returns></returns> public int HookProc(int code, int wParam, ref KeyboardHookStruct lParam) { if (code >= 0) { try { bool isSysKey = (wParam == WM_SYSKEYDOWN || wParam == WM_SYSKEYUP); if (wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN) { bool isHeld = KeyPressStateArr[lParam.vkCode]; var keyArg = new RawKeyEventArgs(lParam.vkCode, isSysKey, isHeld); KeyPressStateArr[lParam.vkCode] = true; KeyDown?.Invoke(keyArg); } else if (wParam == WM_KEYUP || wParam == WM_SYSKEYUP) { var keyArg = new RawKeyEventArgs(lParam.vkCode, isSysKey, false); KeyPressStateArr[lParam.vkCode] = false; KeyUp?.Invoke(keyArg); } } catch { //noop } } return(CallNextHookEx(_hhook, code, wParam, ref lParam)); }
private int KeybHookProc(int code, int w, int l) { if (code < 0) { return(CallNextHookEx(hookId, code, w, l)); } try { var kEvent = (KeyEvents)w; var vkCode = Marshal.ReadInt32((IntPtr)l); switch (kEvent) { case KeyEvents.KeyDown: case KeyEvents.SKeyDown: KeyDown?.Invoke((Keys)vkCode, GetShiftPressed(), GetCtrlPressed(), GetAltPressed()); break; case KeyEvents.KeyUp: case KeyEvents.SKeyUp: KeyUp?.Invoke((Keys)vkCode, GetShiftPressed(), GetCtrlPressed(), GetAltPressed()); break; } } catch (Exception) { //Ignore all errors... } return(CallNextHookEx(hookId, code, w, l)); }
public void HandleKeyInputEvent(KeyEvent e) { if (e.Type == "keydown") { KeyDown?.Invoke(this, e); } }
private void OnKeyDown(object sender, KeyEventArgs e) { Keys key = e.KeyCode; if (key == Keys.LControlKey || key == Keys.RControlKey) { ctrl = true; } if (key == Keys.LMenu || key == Keys.RMenu) { alt = true; } if (key == Keys.LShiftKey || key == Keys.RShiftKey) { shift = true; } foreach (HotKeyToAction hotKeyToAction in HotKeys) { if (hotKeyToAction.HotKey.Match(key, ctrl, alt, shift)) { KeyDown?.Invoke(sender, e, hotKeyToAction); return; } } }
public override void ResponseReceived(byte[] parameter) { switch ((LiveKeyloggerCommunication)parameter[0]) { case LiveKeyloggerCommunication.StringDown: StringDown?.Invoke(this, Encoding.UTF8.GetString(parameter, 1, parameter.Length - 1)); break; case LiveKeyloggerCommunication.SpecialKeyDown: KeyDown?.Invoke(this, new Serializer(new[] { typeof(KeyLogEntry), typeof(SpecialKey), typeof(StandardKey) }) .Deserialize <KeyLogEntry>(parameter, 1)); break; case LiveKeyloggerCommunication.SpecialKeyUp: KeyUp?.Invoke(this, new Serializer(new[] { typeof(KeyLogEntry), typeof(SpecialKey), typeof(StandardKey) }) .Deserialize <KeyLogEntry>(parameter, 1)); break; case LiveKeyloggerCommunication.WindowChanged: WindowChanged?.Invoke(this, Encoding.UTF8.GetString(parameter, 1, parameter.Length - 1)); break; default: throw new ArgumentOutOfRangeException(); } }
public int HookProc(int code, int wParam, ref KeyBoardHookStruct lParam) { if (code >= 0) { var key = (Keys)lParam.VkCode; if (HookedKeys.Contains(key)) { var Arg = new KeyEventArgs(key); switch (wParam) { case WM_KEYDOWN: case WM_SYSKEYDOWN: KeyDown?.Invoke(this, Arg); break; case WM_KEYUP: case WM_SYSKEYUP: KeyUp?.Invoke(this, Arg); break; } if (Arg.Handled) { return(1); } } } return(CallNextHookEx(Hook, code, wParam, ref lParam)); }
private void OnKeyEvent(KeyActivityEvent ev) { switch (ev.Action) { case KeyEventActions.Down: { Noesis.Key key = _keyTable[(int)ev.KeyCode]; if (key != Noesis.Key.None) { KeyDown?.Invoke(this, key); } if (ev.Char != 0) { Char?.Invoke(this, ev.Char); } break; } case KeyEventActions.Up: { Noesis.Key key = _keyTable[(int)ev.KeyCode]; if (key != Noesis.Key.None) { KeyUp?.Invoke(this, key); } break; } } }
private IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam) { if (nCode >= 0) { int vkCode = Marshal.ReadInt32(lParam); Keys key = (Keys)vkCode; var eventArgs = new KeyEventArgs(key); if (wParam == (IntPtr)WM_KEYDOWN || wParam == (IntPtr)260) { DownKeys.Add(key); KeyDown?.Invoke(eventArgs); } else if (wParam == (IntPtr)WM_KEYUP) { DownKeys.Remove(key); KeyUp?.Invoke(eventArgs); } if (eventArgs.Cancel) { return(new IntPtr(1)); } } return(CallNextHookEx(HookID, nCode, wParam, lParam)); }
internal override IntPtr Callback(int nCode, IntPtr wParam, IntPtr lParam) { var data = (KBDLLHOOKSTRUCT)PtrToStructure(lParam, typeof(KBDLLHOOKSTRUCT)); var ea = new LowLevelKeyboardProcEventArgs(data); LowLevelKeyboardProc?.Invoke((WPARAM)wParam, ea); switch ((WPARAM)wParam) { case WPARAM.WM_KEYDOWN: KeyDown?.Invoke(ea); break; case WPARAM.WM_KEYUP: KeyUp?.Invoke(ea); break; case WPARAM.WM_SYSKEYDOWN: SysKeyDown?.Invoke(ea); break; case WPARAM.WM_SYSKEYUP: SysKeyUp?.Invoke(ea); break; } return(base.Callback(nCode, wParam, lParam)); }
protected virtual bool RaiseKeyDown(int virtualKeyCode) { var e = new KeyEventArgs((Keys)virtualKeyCode); KeyDown?.Invoke(this, e); return(e.Handled); }
/// <summary> /// Receives all KeyDown events, and checks if control is focused and /// should receive event. /// </summary> /// <param name="args">Key event arguments.</param> protected virtual void KeyDownIntercept(KeyEventArgs args) { if (this.guiManager.GetFocus() == this) { KeyDown.Invoke(args); } }
/// <summary> /// </summary> /// <param name="nCode"></param> /// <param name="wParam"></param> /// <param name="lParam"></param> /// <returns></returns> private static int KeyboardHookProc(int nCode, int wParam, IntPtr lParam) { var handled = false; s_isDownBothShiftAndCtrlKeys = false; if (0 <= nCode) { // read structure KeyboardHookStruct at lParam var myKeyboardHookStruct = (KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct)); // raise KeyPress if (KeyPress != null && wParam == WmKeydown) { bool isDownShift = (GetKeyState(VkShift) & 0x8000) == 0x8000 ? true : false; // bool isDownCapslock = (GetKeyState(VK_CAPITAL) != 0 ? true : false); bool isDownControl = (GetKeyState(VkControl) & 0x8000) == 0x8000 ? true : false; if (isDownControl && isDownShift) { s_isDownBothShiftAndCtrlKeys = true; } } if (KeyDown != null && (wParam == WmKeydown || wParam == WmSyskeydown)) { var keyData = (Keys)myKeyboardHookStruct.VirtualKeyCode; if (s_isDownBothShiftAndCtrlKeys) { if (Keys.V == keyData) { KeyDown.Invoke(null, null); } } } // raise KeyUp if (KeyUp != null && (wParam == WmKeyup || wParam == WmSyskeyup)) { s_isDownBothShiftAndCtrlKeys = false; var keyData = (Keys)myKeyboardHookStruct.VirtualKeyCode; var e = new KeyEventArgs(keyData); // s_KeyUp.Invoke(null, e); handled = e.Handled; } } // if event handled in application do not handoff to other listeners if (handled) { return(-1); } // forward to other application return(CallNextHookEx(s_KeyboardHookHandle, nCode, wParam, lParam)); }
private static int HookProc(int code, int wParam, ref KeyboardHookStruct lParam) { if (code >= 0) { if (wParam == WMKEYDOWN || wParam == WMKEYUP) { byte[] keyboardState = new byte[256]; int result = GetKeyboardState(keyboardState); var downKeys = (from virtualKey in DistinctVirtualKeys where (GetKeyState(virtualKey) & 0x80) != 0 select(Keys) KeyInterop.VirtualKeyFromKey(KeyInterop.KeyFromVirtualKey(virtualKey))).ToList(); foreach (var downKey in downKeys) { if (!LastKeysPressed.Contains(downKey)) { KeyDown?.Invoke(null, new KeyEventArgs(downKey)); LastKeysPressed.Add(downKey); } } List <Keys> keysToRemove = new List <Keys>(); foreach (var key in LastKeysPressed) { if (!downKeys.Contains(key)) { KeyUp?.Invoke(null, new KeyEventArgs(key)); keysToRemove.Add(key); } } LastKeysPressed.RemoveAll(k => keysToRemove.Contains(k)); } } return(CallNextHookEx(Hhook, code, wParam, ref lParam)); }
public void Update() { var keyboardState = _keyboard.GetState(); var pressedKeys = keyboardState.GetPressedKeys().ToHashSet(); var previousPressedKeys = _previousKeyboardState.GetPressedKeys().ToHashSet(); if (KeyUp != null) { foreach (var key in previousPressedKeys) { if (!pressedKeys.Contains(key)) { KeyUp.Invoke(this, new KeyEventArgs(key)); } } } if (KeyDown != null) { foreach (var key in pressedKeys) { if (!previousPressedKeys.Contains(key)) { KeyDown.Invoke(this, new KeyEventArgs(key)); } } } _previousKeyboardState = keyboardState; }
private void DeviceOnKeyboardInput(object sender, KeyboardInputEventArgs e) { if ((int)e.Key == 255) { // discard "fake keys" which are part of an escaped sequence return; } KeyUtils.CorrectRawInputData(e); //Debug.WriteLine($"RawInput {e.Key} {e.MakeCode} {e.ScanCodeFlags} {e.GetDeviceKey()}", "InputEvents"); if (e.ScanCodeFlags.HasFlag(ScanCodeFlags.Break)) { pressedKeySequence.RemoveAll(k => k == e.Key); KeyUp?.Invoke(sender, e); } else { if (!pressedKeySequence.Contains(e.Key)) { pressedKeySequence.Add(e.Key); } KeyDown?.Invoke(sender, e); } }
private static int KeyboardCallBack(int code, WinAPI.User32.WindowsMessage wParam, ref WinAPI.User32.KeyboardHookStruct lParam) { // Если code < 0, мы не должны обрабатывать это сообщение системы if (code >= 0) { var key = KeyInterop.KeyFromVirtualKey((int)lParam.VKCode); KeyEventArgsCustom eventArgs = new KeyEventArgsCustom(key); // В зависимости от типа пришедшего сообщения вызовем то или иное событие if (lParam.dwExtraInfo == IntPtr.Zero) { switch (wParam) { case WinAPI.User32.WindowsMessage.KeyDown: case WinAPI.User32.WindowsMessage.SysKeyDown: KeyDown?.Invoke(null, eventArgs); break; case WinAPI.User32.WindowsMessage.KeyUp: case WinAPI.User32.WindowsMessage.SysKeyUp: KeyUp?.Invoke(null, eventArgs); break; } } // Если событие помечено приложением как обработанное, // прервём дальнейшее распространение сообщения if (eventArgs.Handled) { return(1); } } // Вызовем следующий обработчик return(WinAPI.User32.CallNextHookEx(_keyboardHookHandle, code, wParam, ref lParam)); }
public void KeyCallback(int key, int action, int scancode) { Keys k = IntToKeys(key); //Console.WriteLine(k.ToString() + " " + (action == 1 ? "PRESSED" : "LIFTED")); if (key >= (int)SpecialKeys.D0 && key <= (int)SpecialKeys.D9) { LastNumberKey = key - (int)SpecialKeys.D0; } //ignores numlock else if (key >= (int)SpecialKeys.NP0 && key <= (int)SpecialKeys.NP9) { LastNumberKey = key - (int)SpecialKeys.NP0; } else if (key >= 65 && key <= 90) { LastLetterKey = char.ToLower((char)key); } else if (key >= 32 && key <= 127) { LastLetterKey = (char)key; } LastKey = (char)key; if (action == 1) { KeyDown.Invoke(k, this); } if (action == 0) { KeyUp.Invoke(k, this); } }
private void CoreDispatcher_AcceleratorKeyActivated(CoreDispatcher sender, AcceleratorKeyEventArgs args) { if (args.EventType.ToString().Contains("Down") && !args.Handled) { var alt = (Window.Current.CoreWindow.GetKeyState(VirtualKey.Menu) & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down; var shift = (Window.Current.CoreWindow.GetKeyState(VirtualKey.Shift) & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down; var control = (Window.Current.CoreWindow.GetKeyState(VirtualKey.Shift) & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down; var windows = ((Window.Current.CoreWindow.GetKeyState(VirtualKey.LeftWindows) & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down) || ((Window.Current.CoreWindow.GetKeyState(VirtualKey.RightWindows) & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down); var character = ToChar(args.VirtualKey, shift); var keyDown = new KeyboardEventArgs { AltKey = alt, Character = character, ControlKey = control, EventArgs = args, ShiftKey = shift, VirtualKey = args.VirtualKey }; try { KeyDown?.Invoke(keyDown); } finally { args.Handled = keyDown.Handled; } } }
public virtual void OnKeyDown(KeyEventArgs e) { if (!_enabled) { return; } if (Controls != null) { for (int i = Controls.Count - 1; i >= 0; i--) { if (e.Handled) { return; } else { Controls[i].OnKeyDown(e); } } } if (KeyDown == null) { return; } KeyDown.Invoke(this, e); }
public virtual void OnKeyDown(KeyEventArgs e) { if (!_Enabled) { return; } if (Controls != null) { for (int I = Controls.Count - 1; I >= 0; I--) { if (e.Handled) { return; } else { Controls[I].OnKeyDown(e); } } } if (KeyDown != null) { KeyDown.Invoke(this, e); return; } }