public virtual void OnKeyDown(KeyEventArgs e) { KeyDown?.Invoke(this, e); }
static KeyboardInputManager() { InputHooks.KeyDown += (o, e) => KeyDown?.Invoke(new KeyboardHookEventArgs((int)e.KeyData)); InputHooks.KeyUp += (o, e) => KeyUp?.Invoke(new KeyboardHookEventArgs((int)e.KeyData)); InputHooks.KeyPress += (o, e) => KeyPress?.Invoke(new KeyPressHookEventArgs(e.KeyChar)); }
public void OnKeyDown(KeyEventArgs keyEventArgs) { KeyDown?.Invoke(this, keyEventArgs); }
/// <summary> /// Raise the event <see cref="KeyDown"/>. /// </summary> protected virtual void OnKeyDown(KeyCode key) { _KeysPressed[(int)key] = true; KeyDown?.Invoke(this, new NativeWindowKeyEventArgs(DeviceContext, GLContext, key)); }
public Node <INode> GetNode(string nodeName) { switch (nodeName) { case DeltaTime.NAME: INode nodeDeltaTime = new DeltaTime() as INode; return(new Node <INode> (nodeDeltaTime)); case KeyDown.NAME: INode nodeKeyDown = new KeyDown() as INode; return(new Node <INode> (nodeKeyDown)); case Transform.NAME: INode nodeTransform = new Transform() as INode; return(new Node <INode> (nodeTransform)); case Vec3.NAME: INode nodeVec3 = new Vec3() as INode; return(new Node <INode> (nodeVec3)); case Key.NAME: INode nodeKey = new Key() as INode; return(new Node <INode> (nodeKey)); case FindByName.NAME: INode nodeFindByName = new FindByName() as INode; return(new Node <INode> (nodeFindByName)); case ObjectAttribute.NAME: INode nodeObjectAttribute = new ObjectAttribute() as INode; return(new Node <INode> (nodeObjectAttribute)); case SplitVec3.NAME: INode nodeSplitVec3 = new SplitVec3() as INode; return(new Node <INode> (nodeSplitVec3)); case Update.NAME: INode nodeUpdate = new Update() as INode; return(new Node <INode> (nodeUpdate)); case LateUpdate.NAME: INode nodeLateUpdate = new LateUpdate() as INode; return(new Node <INode> (nodeLateUpdate)); case MouseButtonDown.NAME: INode nodeMouseButtonDown = new MouseButtonDown() as INode; return(new Node <INode> (nodeMouseButtonDown)); case PlayerPreferences.NAME: INode nodePlayerPref = new PlayerPreferences() as INode; return(new Node <INode> (nodePlayerPref)); case SetActive.NAME: INode nodeSetActive = new SetActive() as INode; return(new Node <INode> (nodeSetActive)); case LoadScene.NAME: INode nodeLoadScene = new LoadScene() as INode; return(new Node <INode> (nodeLoadScene)); case MousePosition.NAME: INode nodeMousePosition = new MousePosition() as INode; return(new Node <INode> (nodeMousePosition)); case ScreenToWorld.NAME: INode nodeScreenToWorld = new ScreenToWorld() as INode; return(new Node <INode> (nodeScreenToWorld)); case LookAtPosition.NAME: INode nodeLookAt = new LookAtPosition() as INode; return(new Node <INode> (nodeLookAt)); case GetComponent.NAME: INode nodeGetComponent = new GetComponent() as INode; return(new Node <INode> (nodeGetComponent)); case Color.NAME: INode nodeColor = new Color() as INode; return(new Node <INode> (nodeColor)); default: return(null); } }
private IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam) { if (nCode < 0) { return(CallNextHookEx(hookId, nCode, wParam, lParam)); } if (wParam == (IntPtr)WM_KEYDOWN) { var vkCode = Marshal.ReadInt32(lParam); var k = KeyShortcut.FromVirtualKey(vkCode); var m = Keyboard.Modifiers; // if (!KeyShortcut.IsModifier(k.Key)) // { // // } KeyDown?.Invoke(new KeyShortcut { Key = k, Modifiers = m }); // if (oneTimeKeys != null) // { // if (!KeyShortcut.IsModifier(k)) // { // oneTimeKeys.Invoke(new KeyShortcut() {Key = k, Modifiers = m}); // oneTimeKeys = null; // Close(); // } // return CallNextHookEx(hookId, nCode, wParam, lParam); // } foreach (var rec in records) { if (rec.shortcut.Key == k && rec.shortcut.Modifiers == m) { rec.action.Invoke(); } } Console.WriteLine($"{vkCode}[{m}]: {k}|{Thread.CurrentThread.ManagedThreadId}"); } // if ((MainWindow.StartStopKey == (Keys) vkCode) && (MainWindow.Paused == false) && // (wParam == (IntPtr) WM_KEYDOWN)) // { // MainWindow.Paused = true; // Debug.WriteLine("Paused"); // return CallNextHookEx(hookId, nCode, wParam, lParam); // } // if (MainWindow.StartStopKey == (Keys) vkCode && MainWindow.Paused && (wParam == (IntPtr) WM_KEYDOWN)) // { // MainWindow.Paused = false; // // return CallNextHookEx(hookId, nCode, wParam, lParam); // } // if (wParam == (IntPtr) WM_KEYDOWN && MainWindow.Paused == false) // { // string s = ((Keys) vkCode) + ", "; // //konsola(s); // // KeyDown(this, kea); // // } // else if (wParam == (IntPtr) WM_KEYUP && MainWindow.Paused == false) // { // if ((Keys) vkCode == Keys.LMenu || (Keys) vkCode == Keys.RMenu) // { // if (MainWindow.consoleEnabled) // Console.Write(((Keys) vkCode).ToString() + " "); // KeyDown(this, kea); // } // } return(CallNextHookEx(hookId, nCode, wParam, lParam)); }
private void OnKeyDown(Key key) { KeyDown?.Invoke(this, key); }
/// <inheritdoc cref="KeyDown" /> private void ControlOnKeyDown(object sender, System.Windows.Input.KeyEventArgs args) => KeyDown?.Invoke(sender, new KeyEventArgs(args));
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 { } // Only investigate further when Left, Right, or the dedicated Previous or Next keys // are pressed if (virtualKey == VirtualKey.Left || virtualKey == VirtualKey.Right || (int)virtualKey == 166 || (int)virtualKey == 167 || (int)virtualKey == 69) { bool noModifiers = !altKey && !controlKey && !shiftKey; bool onlyAlt = altKey && !controlKey && !shiftKey; if (((int)virtualKey == 166 && noModifiers) || (virtualKey == VirtualKey.Left && onlyAlt)) { // When the previous key or Alt+Left are pressed navigate back e.Handled = true; RaiseGoBackGestured(); } else if (virtualKey == VirtualKey.Back && winKey) { // When the next key or Win+Backspace are pressed navigate backward e.Handled = true; RaiseGoBackGestured(); } else if (((int)virtualKey == 167 && noModifiers) || (virtualKey == VirtualKey.Right && onlyAlt)) { // When the next key or Alt+Right are pressed navigate forward e.Handled = true; RaiseGoForwardGestured(); } else if (((int)virtualKey == 69 && controlKey)) { // when control-E e.Handled = true; RaiseControlEGestured(); } } } }
private void FireKeyDown(Keys key) { KeyDown?.Invoke(this, new KeyDownEventArgs(key)); }
/// <summary> /// A callback function which will be called every time a keyboard activity detected. /// </summary> /// <param name="nCode"> /// [in] Specifies whether the hook procedure must process the message. /// If nCode is HC_ACTION, the hook procedure must process the message. /// If nCode is less than zero, the hook procedure must pass the message to the /// CallNextHookEx function without further processing and must return the /// value returned by CallNextHookEx. /// </param> /// <param name="wParam"> /// [in] Specifies whether the message was sent by the current thread. /// If the message was sent by the current thread, it is nonzero; otherwise, it is zero. /// </param> /// <param name="lParam"> /// [in] Pointer to a CWPSTRUCT structure that contains details about the message. /// </param> /// <returns> /// If nCode is less than zero, the hook procedure must return the value returned by CallNextHookEx. /// If nCode is greater than or equal to zero, it is highly recommended that you call CallNextHookEx /// and return the value it returns; otherwise, other applications that have installed WH_CALLWNDPROC /// hooks will not receive hook notifications and may behave incorrectly as a result. If the hook /// procedure does not call CallNextHookEx, the return value should be zero. /// </returns> private int KeyboardHookProc(int nCode, Int32 wParam, IntPtr lParam) { //Indicates if any of underlaing events set e.Handled flag bool handled = false; //If was Ok and someone listens to events if ((nCode >= 0) && (KeyDown != null || KeyUp != null || KeyPress != null)) { //Read structure KeyboardHookStruct at lParam var myKeyboardHookStruct = (KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct)); if (KeyDown != null && (wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN)) { #region Raise KeyDown var keyData = (Keys)myKeyboardHookStruct.vkCode; var e = new CustomKeyEventArgs(keyData); KeyDown?.Invoke(this, e); handled = handled || e.Handled; #endregion } if (KeyPress != null && wParam == WM_KEYDOWN) { #region Raise KeyPress bool isDownShift = ((GetKeyState(VK_SHIFT) & 0x80) == 0x80); bool isDownCapslock = (GetKeyState(VK_CAPITAL) != 0); var keyState = new byte[256]; GetKeyboardState(keyState); var inBuffer = new byte[2]; if (ToAscii(myKeyboardHookStruct.vkCode, myKeyboardHookStruct.scanCode, keyState, inBuffer, myKeyboardHookStruct.flags) == 1) { var key = (char)inBuffer[0]; if ((isDownCapslock ^ isDownShift) && Char.IsLetter(key)) { key = Char.ToUpper(key); } var e = new CustomKeyPressEventArgs(key); KeyPress?.Invoke(this, e); handled = handled || e.Handled; } #endregion } if (KeyUp != null && (wParam == WM_KEYUP || wParam == WM_SYSKEYUP)) { #region Raise KeyUp var keyData = (Keys)myKeyboardHookStruct.vkCode; var e = new CustomKeyEventArgs(keyData); KeyUp?.Invoke(this, e); handled = handled || e.Handled; #endregion } } //If event handled in application do not handoff to other listeners if (handled) { return(1); } return(CallNextHookEx(hKeyboardHook, nCode, wParam, lParam)); }
private void KD(InputControl c) => KeyDown?.Invoke(this, new InputEventArgs(c));
/// <summary> /// Analizes hot key message. /// Understands what keys have been pressed or released /// </summary> /// <param name="msg"></param> public void AnalyzeKeys(ZeemoteMessage msg) { // If there are buttons touched in message if (msg.ButtonsTouched) { if (!msg.ButtonA && curZeemoteKeys.A) { curZeemoteKeys.A = msg.ButtonA; if (KeyUp != null) { KeyUp.Invoke(this, new ZeemoteKeysArgs(ZeemoteKeys.KeyCodeA)); } } else if (msg.ButtonA && !curZeemoteKeys.A) { curZeemoteKeys.A = msg.ButtonA; if (KeyDown != null) { KeyDown.Invoke(this, new ZeemoteKeysArgs(ZeemoteKeys.KeyCodeA)); } } if (!msg.ButtonB && curZeemoteKeys.B) { curZeemoteKeys.B = msg.ButtonB; if (KeyUp != null) { KeyUp.Invoke(this, new ZeemoteKeysArgs(ZeemoteKeys.KeyCodeB)); } } else if (msg.ButtonB && !curZeemoteKeys.B) { curZeemoteKeys.B = msg.ButtonB; if (KeyDown != null) { KeyDown.Invoke(this, new ZeemoteKeysArgs(ZeemoteKeys.KeyCodeB)); } } if (!msg.ButtonC && curZeemoteKeys.C) { curZeemoteKeys.C = msg.ButtonC; if (KeyUp != null) { KeyUp.Invoke(this, new ZeemoteKeysArgs(ZeemoteKeys.KeyCodeC)); } } else if (msg.ButtonC && !curZeemoteKeys.C) { curZeemoteKeys.C = msg.ButtonC; if (KeyDown != null) { KeyDown.Invoke(this, new ZeemoteKeysArgs(ZeemoteKeys.KeyCodeC)); } } if (!msg.ButtonD && curZeemoteKeys.D) { curZeemoteKeys.D = msg.ButtonD; if (KeyUp != null) { KeyUp.Invoke(this, new ZeemoteKeysArgs(ZeemoteKeys.KeyCodeD)); } } else if (msg.ButtonD && !curZeemoteKeys.D) { curZeemoteKeys.D = msg.ButtonD; if (KeyDown != null) { KeyDown.Invoke(this, new ZeemoteKeysArgs(ZeemoteKeys.KeyCodeD)); } } } else // Joystick was touched { int direction = FindJoystickDirection(msg); // 0 - no; 1 - left; 2 - right; 3 - up; 4 - down. if (direction != 1 && curZeemoteKeys.JoyLeft) { curZeemoteKeys.JoyLeft = false; if (KeyUp != null) { KeyUp.Invoke(this, new ZeemoteKeysArgs(ZeemoteKeys.KeyCodeJoyLeft)); } } else if (direction == 1 && !curZeemoteKeys.JoyLeft) { curZeemoteKeys.JoyLeft = true; if (KeyDown != null) { KeyDown.Invoke(this, new ZeemoteKeysArgs(ZeemoteKeys.KeyCodeJoyLeft)); } } if (direction != 2 && curZeemoteKeys.JoyRight) { curZeemoteKeys.JoyRight = false; if (KeyUp != null) { KeyUp.Invoke(this, new ZeemoteKeysArgs(ZeemoteKeys.KeyCodeJoyRight)); } } else if (direction == 2 && !curZeemoteKeys.JoyRight) { curZeemoteKeys.JoyRight = true; if (KeyDown != null) { KeyDown.Invoke(this, new ZeemoteKeysArgs(ZeemoteKeys.KeyCodeJoyRight)); } } if (direction != 3 && curZeemoteKeys.JoyUp) { curZeemoteKeys.JoyUp = false; if (KeyUp != null) { KeyUp.Invoke(this, new ZeemoteKeysArgs(ZeemoteKeys.KeyCodeJoyUp)); } } else if (direction == 3 && !curZeemoteKeys.JoyUp) { curZeemoteKeys.JoyUp = true; if (KeyDown != null) { KeyDown.Invoke(this, new ZeemoteKeysArgs(ZeemoteKeys.KeyCodeJoyUp)); } } if (direction != 4 && curZeemoteKeys.JoyDown) { curZeemoteKeys.JoyDown = false; if (KeyUp != null) { KeyUp.Invoke(this, new ZeemoteKeysArgs(ZeemoteKeys.KeyCodeJoyDown)); } } else if (direction == 4 && !curZeemoteKeys.JoyDown) { curZeemoteKeys.JoyDown = true; if (KeyDown != null) { KeyDown.Invoke(this, new ZeemoteKeysArgs(ZeemoteKeys.KeyCodeJoyDown)); } } } }
protected virtual void OnKeyDown(Key key) => KeyDown?.Invoke(key);
/// <summary> /// A callback function which will be called every time a keyboard activity detected. /// https://docs.microsoft.com/en-us/windows/win32/winmsg/lowlevelkeyboardproc /// </summary> /// <param name="code"> /// Specifies whether the hook procedure must process the message. /// If code is HC_ACTION, the hook procedure must process the message. /// If code is less than zero, the hook procedure must pass the message to the /// CallNextHookEx function without further processing and must return the /// value returned by CallNextHookEx. /// </param> /// <param name="wParam"> /// Specifies whether the message was sent by the current thread. /// If the message was sent by the current thread, it is nonzero; otherwise, it is zero. /// </param> /// <param name="lParam"> /// Pointer to a CWPSTRUCT structure that contains details about the message. /// </param> /// <returns> /// If code is less than zero, the hook procedure must return the value returned by CallNextHookEx. /// If code is greater than or equal to zero, it is highly recommended that you call CallNextHookEx /// and return the value it returns; otherwise, other applications that have installed WH_CALLWNDPROC /// hooks will not receive hook notifications and may behave incorrectly as a result. If the hook /// procedure does not call CallNextHookEx, the return value should be zero. /// </returns> private IntPtr KeyboardHookProc(int code, uint wParam, IntPtr lParam) { //Indicates if any of the underlaying events set the e.Handled flag. var handled = false; //If it was Ok and there are no listeners. if (code < 0 || KeyDown == null && KeyUp == null && KeyPress == null) { return(CallNextHookEx(_keyboardHookHandle, code, wParam, lParam)); } //Read structure KeyboardHookStruct at lParam var keyboard = (KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct)); if (KeyDown != null && (wParam == MessageKeydown || wParam == MessageSystemKeyDown)) { #region Raise KeyDown var isDownShift = (GetKeyState(KeyShift) & 0x80) == 0x80; var isDownCapslock = GetKeyState(KeyCapital) != 0; var e = new CustomKeyEventArgs(KeyInterop.KeyFromVirtualKey(keyboard.KeyCode), isDownCapslock ^ isDownShift); KeyDown?.Invoke(this, e); handled = e.Handled; #endregion } if (KeyPress != null && wParam == MessageKeydown) { #region Raise KeyPress var isDownShift = (GetKeyState(KeyShift) & 0x80) == 0x80; var isDownCapslock = GetKeyState(KeyCapital) != 0; var keyState = new byte[256]; GetKeyboardState(keyState); var inBuffer = new byte[2]; if (ToAscii(keyboard.KeyCode, keyboard.ScanCode, keyState, inBuffer, keyboard.Flags) == 1) { var key = (char)inBuffer[0]; if (isDownCapslock ^ isDownShift && char.IsLetter(key)) { key = char.ToUpper(key); } var e = new CustomKeyPressEventArgs(key); KeyPress?.Invoke(this, e); handled = handled || e.Handled; } #endregion } if (KeyUp != null && (wParam == MessageKeyUp || wParam == MessageSystemKeyUp)) { #region Raise KeyUp var e = new CustomKeyEventArgs(KeyInterop.KeyFromVirtualKey(keyboard.KeyCode)); KeyUp?.Invoke(this, e); handled = handled || e.Handled; #endregion } //If event handled in application do not handoff to other listeners. return(handled ? new IntPtr(1) : CallNextHookEx(_keyboardHookHandle, code, wParam, lParam)); }
private void CanExecute(object sender, CanExecuteRoutedEventArgs e) { e.Handled = true; if (!(e.Command is RoutedUICommand command)) { return; } switch (command.Text) { case "Copy": KeyDown?.Invoke(this, GetKeyEventArgs(Key.C)); break; case "Cut": KeyDown?.Invoke(this, GetKeyEventArgs(Key.X)); break; case "Paste": KeyDown?.Invoke(this, GetKeyEventArgs(Key.V)); break; case "Select All": KeyDown?.Invoke(this, GetKeyEventArgs(Key.A)); break; case "Undo": KeyDown?.Invoke(this, GetKeyEventArgs(Key.Z)); break; case "Redo": KeyDown?.Invoke(this, GetKeyEventArgs(Key.Y)); break; case "Backspace": case "DeletePreviousWord": KeyDown?.Invoke(this, GetKeyEventArgs(Key.Back)); break; case "Delete": case "DeleteNextWord": KeyDown?.Invoke(this, GetKeyEventArgs(Key.Delete)); break; case "MoveToLineStart": KeyDown?.Invoke(this, GetKeyEventArgs(Key.Home)); break; case "MoveToLineEnd": KeyDown?.Invoke(this, GetKeyEventArgs(Key.End)); break; case "ToggleInsert": KeyDown?.Invoke(this, GetKeyEventArgs(Key.Insert)); break; case "MoveUpByPage": KeyDown?.Invoke(this, GetKeyEventArgs(Key.PageUp)); break; case "MoveDownByPage": KeyDown?.Invoke(this, GetKeyEventArgs(Key.PageDown)); break; case "MoveLeftByCharacter": case "MoveLeftByWord": case "SelectLeftByWord": KeyDown?.Invoke(this, GetKeyEventArgs(Key.Left)); break; case "MoveRightByCharacter": case "MoveRightByWord": case "SelectRightByWord": KeyDown?.Invoke(this, GetKeyEventArgs(Key.Right)); break; case "MoveDownByLine": case "MoveDownByParagraph": case "SelectDownByParagraph": KeyDown?.Invoke(this, GetKeyEventArgs(Key.Down)); break; case "MoveUpByLine": case "MoveUpByParagraph": case "SelectUpByParagraph": KeyDown?.Invoke(this, GetKeyEventArgs(Key.Up)); break; } }
/// <summary> /// Goes through each key checking it's state compared to the last /// frame, triggering events if necessary. Updates the current mouse /// state and triggers events if necessary. /// </summary> /// <param name="gameTime">Provides a snapshot of timing values.</param> public override void Update(GameTime gameTime) { #region Update Keyboard // Create the Arguments class and fill in with the modifier data KeyEventArgs keyEvent = new KeyEventArgs(); foreach (Keys key in Keyboard.GetState().GetPressedKeys()) { if (key == Keys.LeftAlt || key == Keys.RightAlt) { keyEvent.Alt = true; } else if (key == Keys.LeftShift || key == Keys.RightShift) { keyEvent.Shift = true; } else if (key == Keys.LeftControl || key == Keys.RightControl) { keyEvent.Control = true; } } // Loop through our keys foreach (InputKey key in this.keys) { // If they are any of the modifier keys, skip them if (key.Key == Keys.LeftAlt || key.Key == Keys.RightAlt || key.Key == Keys.LeftShift || key.Key == Keys.RightShift || key.Key == Keys.LeftControl || key.Key == Keys.RightControl ) { continue; } // Check if the key was pressed bool pressed = Keyboard.GetState().IsKeyDown(key.Key); // If it was, decrement the countdown for that key if (pressed) { key.Countdown -= gameTime.ElapsedRealTime.Milliseconds; } if ((pressed) && (!key.Pressed)) // If it is pressed, but wasn't before... { // Set some flags and invoke the KeyDown event key.Pressed = true; keyEvent.Key = key.Key; if (KeyDown != null) { KeyDown.Invoke(keyEvent); } } else if ((!pressed) && (key.Pressed)) // If it isn't pressed, but was before... { // Set some flags, reset the countdown key.Pressed = false; key.Countdown = RepeatDelay; keyEvent.Key = key.Key; // Invoke the Key Up event if (KeyUp != null) { KeyUp.Invoke(keyEvent); } } // If the Key's Countdown has zeroed out, reset it, and make // sure that KeyDown fires again if (key.Countdown < 0) { keyEvent.Key = key.Key; if (KeyDown != null) { KeyDown.Invoke(keyEvent); } key.Countdown = RepeatRate; } } #endregion #region Update Mouse MouseState mouseState = Mouse.GetState(); // Check for mouse move event if ((mouseState.X != this.currentMouseState.X) || (mouseState.Y != this.currentMouseState.Y)) { if (MouseMove != null) { MouseEventArgs mouseEvent = new MouseEventArgs(); mouseEvent.State = mouseState; mouseEvent.Button = MouseButtons.None; // Cap mouse position to the window boundaries mouseEvent.Position = new Point(mouseState.X, mouseState.Y); if (mouseEvent.Position.X < 0) { mouseEvent.Position.X = 0; } if (mouseEvent.Position.Y < 0) { mouseEvent.Position.Y = 0; } Rectangle bounds = this.Game.Window.ClientBounds; if (mouseEvent.Position.X > bounds.Width) { mouseEvent.Position.X = bounds.Width; } if (mouseEvent.Position.Y > bounds.Height) { mouseEvent.Position.Y = bounds.Height; } MouseMove.Invoke(mouseEvent); } } if (mouseState.LeftButton != currentMouseState.LeftButton) { if ((MouseUp != null) || (MouseDown != null)) { MouseEventArgs mouseEvent = new MouseEventArgs(); mouseEvent.State = mouseState; mouseEvent.Position = new Point(mouseState.X, mouseState.Y); mouseEvent.Button = MouseButtons.Left; if (mouseState.LeftButton == ButtonState.Released) { if (MouseUp != null) { MouseUp.Invoke(mouseEvent); } } else { if (MouseDown != null) { // Must request focus first, to prevent mousedown // event from being swallowed up if (RequestingFocus != null) { RequestingFocus.Invoke(mouseEvent); } MouseDown.Invoke(mouseEvent); } } } } if (mouseState.RightButton != currentMouseState.RightButton) { if ((MouseUp != null) || (MouseDown != null)) { MouseEventArgs mouseEvent = new MouseEventArgs(); mouseEvent.State = mouseState; mouseEvent.Position = new Point(mouseState.X, mouseState.Y); mouseEvent.Button = MouseButtons.Right; if (mouseState.RightButton == ButtonState.Released) { if (MouseUp != null) { MouseUp.Invoke(mouseEvent); } } else { if (MouseDown != null) { MouseDown.Invoke(mouseEvent); } } } } // Update mouse state this.currentMouseState = mouseState; #endregion base.Update(gameTime); }
protected void FireKeyDown(Keys k) { KeyDown.Invoke(this, k); }
public void KeyReleased(object sender, KeyEventArgs e) { KeyDown?.Invoke(sender, e); }
private static IntPtr HookProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam) { IntPtr returnCode = KeyboardInput.CallWindowProc(KeyboardInput.prevWndProc, hWnd, msg, wParam, lParam);; switch (msg) { case WM_GETDLGCODE: returnCode = (IntPtr)DLGC_WANTALLKEYS; break; case WM_CHAR: CharEntered?.Invoke(null, new CharacterEventArgs((char)wParam, (int)lParam)); break; case WM_KEYDOWN: KeyDown?.Invoke(null, new KeyEventArgs((Keys)wParam)); break; case WM_KEYUP: KeyUp?.Invoke(null, new KeyEventArgs((Keys)wParam)); break; case WM_LBUTTONDOWN: MouseSelection.left = (int)lParam & 0xffff; MouseSelection.top = (int)lParam >> 16; MouseSelection.right = MouseSelection.left; MouseSelection.bottom = MouseSelection.top; if (Game1.keyboardDispatcher.Subscriber is ITextBox) { ITextBox textBox = Game1.keyboardDispatcher.Subscriber as ITextBox; Acp acp = textBox.GetAcpByRange(MouseSelection); if (acp.Start >= 0) { textBox.SetSelection(acp.Start, acp.End); Console.WriteLine("ACPStart:{0},ACPEnd:{1}", acp.Start, acp.End); Console.WriteLine("MouseDown:Left:{0},TOP:{1}RIGHT:{2}BOTTOM:{3}", MouseSelection.left, MouseSelection.top, MouseSelection.right, MouseSelection.bottom); Selecting = true; } } break; case WM_MOUSEMOVE: MouseSelection.right = (int)lParam & 0xffff; MouseSelection.bottom = (int)lParam >> 16; if (Selecting && Game1.keyboardDispatcher.Subscriber is ITextBox) { RECT range = new RECT(); range.left = Math.Min(MouseSelection.left, MouseSelection.right); range.top = Math.Max(MouseSelection.top, MouseSelection.bottom); range.right = Math.Max(MouseSelection.left, MouseSelection.right); range.bottom = Math.Min(MouseSelection.top, MouseSelection.bottom); ITextBox textBox = Game1.keyboardDispatcher.Subscriber as ITextBox; Acp acp = textBox.GetAcpByRange(range); if (acp.Start >= 0) { textBox.SetSelection(acp.Start, acp.End); textBox.SetSelState(MouseSelection.left > MouseSelection.right ? SelState.SEL_AE_END : SelState.SEL_AE_START); Console.WriteLine("ACPStart:{0},ACPEnd:{1}", acp.Start, acp.End); Console.WriteLine("MouseMove:Left:{0},TOP:{1}RIGHT:{2}BOTTOM:{3}", MouseSelection.left, MouseSelection.top, MouseSelection.right, MouseSelection.bottom); } } //handle IsMouseVisable returnCode = KeyboardInput.CallWindowProc(KeyboardInput.prevWndProc, hWnd, msg, wParam, lParam); break; case WM_LBUTTONUP: Selecting = false; break; #if TSF case EM_GETSEL: if (Game1.keyboardDispatcher.Subscriber is ITextBox) { ITextBox textBox = Game1.keyboardDispatcher.Subscriber as ITextBox; Acp acp = textBox.GetSelection(); Marshal.WriteInt32(wParam, acp.Start); Marshal.WriteInt32(lParam, acp.End); } break; case EM_SETSEL: if (Game1.keyboardDispatcher.Subscriber is ITextBox) { ITextBox textBox = Game1.keyboardDispatcher.Subscriber as ITextBox; textBox.SetSelection((int)wParam, (int)lParam); } break; case EM_REPLACESEL: if (Game1.keyboardDispatcher.Subscriber is ITextBox) { ITextBox textBox = Game1.keyboardDispatcher.Subscriber as ITextBox; textBox.ReplaceSelection(Marshal.PtrToStringAuto(lParam)); } break; case TF_GETSELSTATE: if (Game1.keyboardDispatcher.Subscriber is ITextBox) { ITextBox textBox = Game1.keyboardDispatcher.Subscriber as ITextBox; returnCode = (IntPtr)textBox.GetSelState(); } break; case TF_GETTEXT: if (Game1.keyboardDispatcher.Subscriber is ITextBox) { ITextBox textBox = Game1.keyboardDispatcher.Subscriber as ITextBox; var text = textBox.GetText(); Marshal.Copy(text.ToCharArray(), 0, wParam, Math.Min(text.Length, (int)lParam)); } break; case TF_GETTEXTLENGTH: if (Game1.keyboardDispatcher.Subscriber is ITextBox) { ITextBox textBox = Game1.keyboardDispatcher.Subscriber as ITextBox; returnCode = (IntPtr)textBox.GetTextLength(); } break; case TF_GETTEXTEXT: if (Game1.keyboardDispatcher.Subscriber is ITextBox) { ITextBox textBox = Game1.keyboardDispatcher.Subscriber as ITextBox; Acp acp = (Acp)Marshal.PtrToStructure(lParam, typeof(Acp)); RECT rect = textBox.GetTextExt(acp); MapWindowPoints(Game1.game1.Window.Handle, (IntPtr)0, ref rect, 2); //to screen coord Marshal.StructureToPtr(rect, wParam, false); //text ext returnCode = (IntPtr)0; //if the rect clipped } break; case TF_QUERYINSERT: if (Game1.keyboardDispatcher.Subscriber is ITextBox) { ITextBox textBox = Game1.keyboardDispatcher.Subscriber as ITextBox; Acp acp = (Acp)Marshal.PtrToStructure(wParam, typeof(Acp)); textBox.QueryInsert(acp, (uint)lParam); Marshal.StructureToPtr(acp, wParam, false); } break; case WM_KILLFOCUS: Game1.tsf.TerminateComposition(); break; #endif default: break; } return(returnCode); }
private void FormOnKeyDown(object sender, KeyEventArgs e) { KeyDown?.Invoke(this, e); if (e.Handled) { return; } if (_capture.CaptureState != CAPTURESTATE.CAPTURING) { return; } switch (e.KeyCode) { case Keys.Down: { if (_capture.VerticalPosition > _capture.VerticalPositionMinimum) { _capture.VerticalPosition--; } break; } case Keys.Up: { if (_capture.VerticalPosition < _capture.VerticalPositionMaximum) { _capture.VerticalPosition++; } break; } case Keys.Right: { if (e.Shift && !e.Control) { if (_capture.HorizontalScale < _capture.HorizontalScaleMaximum) { _capture.HorizontalScale++; } } else if (!e.Shift && e.Control) { if (_capture.Phase < _capture.PhaseMaximum) { _capture.Phase++; } } else if (!e.Shift && !e.Control) { if (_capture.HorizontalPosition > _capture.HorizontalPositionMinimum) { _capture.HorizontalPosition--; } } break; } case Keys.Left: { if (e.Shift && !e.Control) { if (_capture.HorizontalScale > _capture.HorizontalScaleMinimum) { _capture.HorizontalScale--; } } else if (!e.Shift && e.Control) { if (_capture.Phase > _capture.PhaseMinimum) { _capture.Phase--; } } else if (!e.Shift && !e.Control) { if (_capture.HorizontalPosition < _capture.HorizontalPositionMaximum) { _capture.HorizontalPosition++; } } break; } case Keys.Oemplus: { _scale++; UpdateFormGeometry(false); break; } case Keys.OemMinus: { if (_scale > 1) { _scale--; } UpdateFormGeometry(false); break; } } }
protected virtual void OnKeyDown(KeyEventArgs e) { KeyDown?.Invoke(this, e); }
//////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// private void UpdateKeys(KeyboardState state, GameTime gameTime) { #if (!XBOX && !XBOX_FAKE) KeyEventArgs e = new KeyEventArgs(); //e.Caps = (((ushort)NativeMethods.GetKeyState(0x14)) & 0xffff) != 0; foreach (Keys key in state.GetPressedKeys()) { if (key == Keys.LeftAlt || key == Keys.RightAlt) { e.Alt = true; } else if (key == Keys.LeftShift || key == Keys.RightShift) { e.Shift = true; } else if (key == Keys.LeftControl || key == Keys.RightControl) { e.Control = true; } } foreach (InputKey key in keys) { if (key.Key == Keys.LeftAlt || key.Key == Keys.RightAlt || key.Key == Keys.LeftShift || key.Key == Keys.RightShift || key.Key == Keys.LeftControl || key.Key == Keys.RightControl) { continue; } bool pressed = state.IsKeyDown(key.Key); double ms = gameTime.ElapsedGameTime.TotalMilliseconds; if (pressed) { key.Countdown -= ms; } if ((pressed) && (!key.Pressed)) { key.Pressed = true; e.Key = key.Key; if (KeyDown != null) { KeyDown.Invoke(this, e); } if (KeyPress != null) { KeyPress.Invoke(this, e); } } else if ((!pressed) && (key.Pressed)) { key.Pressed = false; key.Countdown = RepeatDelay; e.Key = key.Key; if (KeyUp != null) { KeyUp.Invoke(this, e); } } else if (key.Pressed && key.Countdown < 0) { key.Countdown = RepeatRate; e.Key = key.Key; if (KeyPress != null) { KeyPress.Invoke(this, e); } } } #endif }
public void onKeyDown(KeyDown kd) { EKeyDown = kd; }
/// <summary> /// Вызывает событие нажатия клавиши /// </summary> /// <param name="parE">Параметры события</param> protected virtual void CallKeyDown(KeyDownEventArgs parE) { KeyDown?.Invoke(this, parE); }
protected virtual void OnKeyDownPressed(object sender, Key args) { KeyDown?.Invoke(this, args); }
private void RegisterWindowCallbacks() { if (_callbackRegistered) { return; } _callbackRegistered = true; // [NOTE] // Do not register callback to GLFW as lambda or method. (That cannot work) // Put delegate on a field and register it to GLFW. _posCallback = (wnd, x, y) => { if (wnd != _window) { return; } _location = new Vector2i(x, y); Move?.Invoke(this, new WindowPositionEventArgs(x, y)); }; GLFW.SetWindowPosCallback(_window, _posCallback); _sizeCallback = (wnd, width, height) => { if (wnd != _window) { return; } GLFW.GetWindowFrameSize(_window, out var left, out var top, out var right, out var bottom); _clientSize = new Vector2i(width, height); _size = new Vector2i(_clientSize.X + left + right, _clientSize.Y + top + bottom); Resize?.Invoke(this, new ResizeEventArgs(width, height)); }; GLFW.SetWindowSizeCallback(_window, _sizeCallback); _frameBufferSizeCallback = (wnd, width, height) => { if (wnd != _window) { return; } _frameBufferSize = new Vector2i(width, height); FrameBufferSizeChanged?.Invoke(this, _frameBufferSize); }; GLFW.SetFramebufferSizeCallback(_window, _frameBufferSizeCallback); _closeCallback = wnd => { if (wnd != _window) { return; } var cancel = false; var e = new CancelEventArgs(&cancel); Closing?.Invoke(this, e); if (e.Cancel) { GLFW.SetWindowShouldClose(_window, false); } }; GLFW.SetWindowCloseCallback(_window, _closeCallback); _iconifyCallback = (wnd, minimized) => { if (wnd != _window) { return; } Minimized?.Invoke(this, new MinimizedEventArgs(minimized)); }; GLFW.SetWindowIconifyCallback(_window, _iconifyCallback); _focusCallback = (wnd, focused) => { if (wnd != _window) { return; } FocusedChanged?.Invoke(this, new FocusedChangedEventArgs(focused)); }; GLFW.SetWindowFocusCallback(_window, _focusCallback); _charCallback = (wnd, unicode) => { if (wnd != _window) { return; } CharInput?.Invoke(this, new CharInputEventArgs(unicode)); }; GLFW.SetCharCallback(_window, _charCallback); _keyCallback = (wnd, glfwKey, scanCode, action, glfwMods) => { if (wnd != _window) { return; } var e = new KeyboardKeyEventArgs(glfwKey, scanCode, glfwMods, action == GlfwInputAction.Repeat); if (action == GlfwInputAction.Release) { KeyUp?.Invoke(this, e); } else { KeyDown?.Invoke(this, e); } }; GLFW.SetKeyCallback(_window, _keyCallback); _cursorEnterCallback = (wnd, entered) => { if (wnd != _window) { return; } if (entered) { MouseEnter?.Invoke(this); } else { MouseLeave?.Invoke(this); } }; GLFW.SetCursorEnterCallback(_window, _cursorEnterCallback); _mouseButtonCallback = (wnd, button, action, mods) => { if (wnd != _window) { return; } var e = new MouseButtonEventArgs(button, action, mods); if (action == GlfwInputAction.Release) { MouseUp?.Invoke(this, e); } else { MouseDown?.Invoke(this, e); } }; GLFW.SetMouseButtonCallback(_window, _mouseButtonCallback); _cursorPosCallback = (wnd, posX, posY) => { if (wnd != _window) { return; } var e = new MouseMoveEventArgs(new Vector2((int)posX, (int)posY)); MouseMove?.Invoke(this, e); }; GLFW.SetCursorPosCallback(_window, _cursorPosCallback); _scrollCallback = (wnd, offsetX, offsetY) => { if (wnd != _window) { return; } var e = new MouseWheelEventArgs((float)offsetX, (float)offsetY); MouseWheel?.Invoke(this, e); }; GLFW.SetScrollCallback(_window, _scrollCallback); _dropCallback = (wnd, count, paths) => { if (wnd != _window) { return; } var e = new FileDropEventArgs(count, paths); FileDrop?.Invoke(this, e); }; GLFW.SetDropCallback(_window, _dropCallback); _joystickCallback = (joystick, state) => { var e = new JoystickConnectionEventArgs(joystick, state == GlfwConnectedState.Connected); JoystickConnectionChanged?.Invoke(this, e); }; GLFW.SetJoystickCallback(_joystickCallback); _monitorCallback = (monitor, state) => { var e = new MonitorConnectionEventArgs(monitor, state == GlfwConnectedState.Connected); MonitorConnectionChanged?.Invoke(this, e); }; GLFW.SetMonitorCallback(_monitorCallback); _refreshCallback = wnd => { if (wnd != _window) { return; } Refresh?.Invoke(this); }; GLFW.SetWindowRefreshCallback(_window, _refreshCallback); }
private void Button_KeyDown(object sender, KeyEventArgs e) { blnPressed = (e.KeyCode == Keys.Enter || e.KeyCode == Keys.Space); Invalidate(); KeyDown?.Invoke(this, e); }
/// <summary> /// A callback function which will be called every time a keyboard activity detected. /// </summary> /// <param name="nCode"> /// [in] Specifies whether the hook procedure must process the message. /// If nCode is HC_ACTION, the hook procedure must process the message. /// If nCode is less than zero, the hook procedure must pass the message to the /// CallNextHookEx function without further processing and must return the /// value returned by CallNextHookEx. /// </param> /// <param name="wParam"> /// [in] Specifies whether the message was sent by the current thread. /// If the message was sent by the current thread, it is nonzero; otherwise, it is zero. /// </param> /// <param name="lParam"> /// [in] Pointer to a CWPSTRUCT structure that contains details about the message. /// </param> /// <returns> /// If nCode is less than zero, the hook procedure must return the value returned by CallNextHookEx. /// If nCode is greater than or equal to zero, it is highly recommended that you call CallNextHookEx /// and return the value it returns; otherwise, other applications that have installed WH_CALLWNDPROC /// hooks will not receive hook notifications and may behave incorrectly as a result. If the hook /// procedure does not call CallNextHookEx, the return value should be zero. /// </returns> private int KeyboardHookProc(int nCode, int wParam, IntPtr lParam) { //Indicates if any of underlaing events set e.Handled flag var handled = false; //If was Ok and someone listens to events if (nCode < 0 || KeyDown == null && KeyUp == null && KeyPress == null) { return(CallNextHookEx(_hKeyboardHook, nCode, wParam, lParam)); } //Read structure KeyboardHookStruct at lParam var myKeyboardHookStruct = (KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct)); if (KeyDown != null && (wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN)) { #region Raise KeyDown var isDownShift = (GetKeyState(VK_SHIFT) & 0x80) == 0x80; var isDownCapslock = GetKeyState(VK_CAPITAL) != 0; var e = new CustomKeyEventArgs(KeyInterop.KeyFromVirtualKey(myKeyboardHookStruct.vkCode), isDownCapslock ^ isDownShift); KeyDown?.Invoke(this, e); handled = e.Handled; #endregion } if (KeyPress != null && wParam == WM_KEYDOWN) { #region Raise KeyPress var isDownShift = (GetKeyState(VK_SHIFT) & 0x80) == 0x80; var isDownCapslock = GetKeyState(VK_CAPITAL) != 0; var keyState = new byte[256]; GetKeyboardState(keyState); var inBuffer = new byte[2]; if (ToAscii(myKeyboardHookStruct.vkCode, myKeyboardHookStruct.scanCode, keyState, inBuffer, myKeyboardHookStruct.flags) == 1) { var key = (char)inBuffer[0]; if (isDownCapslock ^ isDownShift && char.IsLetter(key)) { key = char.ToUpper(key); } var e = new CustomKeyPressEventArgs(key); KeyPress?.Invoke(this, e); handled = handled || e.Handled; } #endregion } if (KeyUp != null && (wParam == WM_KEYUP || wParam == WM_SYSKEYUP)) { #region Raise KeyUp var e = new CustomKeyEventArgs(KeyInterop.KeyFromVirtualKey(myKeyboardHookStruct.vkCode)); KeyUp?.Invoke(this, e); handled = handled || e.Handled; #endregion } //If event handled in application do not handoff to other listeners return(handled ? 1 : CallNextHookEx(_hKeyboardHook, nCode, wParam, lParam)); }
internal void OnKeyDown(KeyboardEventArgs e) => KeyDown?.Invoke(e);
/// <summary> /// Raises the KeyDown event. Override this method to add code to handle when a key is pressed /// </summary> /// <param name="e">InputEventCKB for the KeyDown event</param> private void invokeKeyDown(InputEventKeyboard e) { KeyDown?.Invoke(e); }