/// <summary> /// Fire a key released event. /// </summary> internal void fireKeyReleased(KeyboardButtonCode keyCode) { if (keysDown[(int)keyCode]) { keysDown[(int)keyCode] = false; switch (keyCode) { case KeyboardButtonCode.KC_LSHIFT: shiftDown = false; break; case KeyboardButtonCode.KC_LMENU: altDown = false; break; case KeyboardButtonCode.KC_LCONTROL: ctrlDown = false; break; } if (KeyReleased != null) { KeyReleased.Invoke(keyCode); } } }
internal bool HandledKeyReleased(KeyEventArgs e) { if (!Visible || !enabled) { return(false); } bool handled = false; for (var index = children.Count - 1; index >= 0; --index) { if (children[index].HandledKeyReleased(e)) { handled = true; } } if (!RegisterEventTypes.HasFlag(EventType.KeyRelease) || !HasFocus) { return(handled); } OnKeyReleased(e.Key, e.ScanCode, e.Modifiers); KeyReleased?.Invoke(this, e); return(true); }
/// <summary> /// Handles the KeyReleased event of the <see cref="GameBase.RenderWindow"/>. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="SFML.Window.KeyEventArgs"/> instance containing the event data.</param> void rw_KeyReleased(object sender, KeyEventArgs e) { if (KeyReleased != null) { KeyReleased.Raise(this, e); } }
private void OnMouseUp(object sender, MouseButtonEventArgs e) { if (sender is UIElement uiElement) { uiElement.ReleaseMouseCapture(); } KeyReleased?.Invoke(this, e); }
protected void OnKeyReleased(Key key) { if (!_keys.TryAdd(key, KeyState.Released)) { _keys[key] = KeyState.Released; } _keysToUpdate.Add(key); KeyReleased?.Invoke(key); }
private void RaiseReleasedEvents(KeyboardState currentState) { var releasedKeys = Enum.GetValues(typeof(Key)) .Cast <Key>() .Where(key => currentState.IsKeyUp(key) && _previousState.IsKeyDown(key)); foreach (var key in releasedKeys) { KeyReleased?.Invoke(this, new KeyboardEventArgs(key, currentState)); } }
private void OnKeyboardHookCalled(KeyboardEventArgs e) { // dispatch corresponding event based on windows mouse message if (e.TransitionState == KeyboardTransitionState.KeyDown) { KeyPressed?.Invoke(this, e); } else { KeyReleased?.Invoke(this, e); } }
public void Update() { if (!_wasPressed && Keyboard.GetState().IsKeyDown(_key)) { _wasPressed = true; } else if (_wasPressed && Keyboard.GetState().IsKeyUp(_key)) { _wasPressed = false; KeyReleased?.Invoke(this, EventArgs.Empty); } }
void scrollView_KeyButtonReleased(Widget source, EventArgs e) { KeyEventArgs ke = e as KeyEventArgs; if (ke.Key == Engine.Platform.KeyboardButtonCode.KC_LCONTROL) { timelineScrollView.AllowMouseScroll = true; } if (KeyReleased != null) { KeyReleased.Invoke(this, ke); } }
private void handleKey(Keys key, int scancode, bool press) { var index = (int)key; var time = (float)AppTime.Elapsed.TotalSeconds; // Update modifier state switch (key) { case Keys.LeftShift: _modMask.LeftShift = press; break; case Keys.LeftControl: _modMask.LeftControl = press; break; case Keys.LeftAlt: _modMask.LeftAlt = press; break; case Keys.RightShift: _modMask.RightShift = press; break; case Keys.RightControl: _modMask.RightControl = press; break; case Keys.RightAlt: _modMask.RightAlt = press; break; } // Update key state if (press) { _currKeys[index] = true; _lastPress[index] = time; _pressed.Add(key); KeyPressed?.Invoke(this, new KeyEventData(KeyEventType.Pressed, key, ModifierMask, time - _lastRelease[index])); } else // release { _currKeys[index] = false; _lastRelease[index] = time; _pressed.Remove(key); float diff = time - _lastPress[index]; KeyReleased?.Invoke(this, new KeyEventData(KeyEventType.Released, key, ModifierMask, diff)); if (TapEventsEnabled && (diff <= TapTime)) { KeyTapped?.Invoke(this, new KeyEventData(KeyEventType.Tapped, key, ModifierMask, time - _lastTap[index])); _lastTap[index] = time; } } }
public static void ReleaseKey(char key) { if (Paused) { return; } if (key == 'k' && scale < 10) { scale += 0.5; } else if (key == '½' && scale > 1) { scale -= 0.5; } if (char.ToUpper(key) == '1') { new Dorf(Player.Player1.Reticle.GridX, Player.Player1.Reticle.GridY); } if (char.ToUpper(key) == '2') { new Predator(Player.Player1.Reticle.GridX, Player.Player1.Reticle.GridY); } if (char.ToUpper(key) == '3') { new Stump(Player.Player1.Reticle.GridX, Player.Player1.Reticle.GridY); } if (char.ToUpper(key) == '4') { new Tree(Player.Player1.Reticle.GridX, Player.Player1.Reticle.GridY); } if (char.ToUpper(key) == '5') { foreach (Dorf dorf in Character.Characters.FindAll(x => x is Dorf)) { new Egg(dorf); } } KeyReleased?.Invoke(key); }
private IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam) { if (nCode >= 0) { int vkCode = Marshal.ReadInt32(lParam); if (wParam == (IntPtr)WM_KEYDOWN && !isDown[vkCode]) { isDown[vkCode] = true; KeyPressed?.Invoke(this, new KeyboardKeyArgs(KeyInterop.KeyFromVirtualKey(vkCode))); } else if (wParam == (IntPtr)WM_KEYUP && isDown[vkCode]) { isDown[vkCode] = false; KeyReleased?.Invoke(this, new KeyboardKeyArgs(KeyInterop.KeyFromVirtualKey(vkCode))); } } return(CallNextHookEx(_hookID, nCode, wParam, lParam)); }
public InputEvents(CluwneWindow window) { // if dummy don't attach events if (window == null) { return; } SFML.Graphics.RenderWindow SWindow = window.SFMLWindow; SWindow.KeyPressed += (sender, args) => KeyPressed?.Invoke(sender, (KeyEventArgs)args); SWindow.KeyReleased += (sender, args) => KeyReleased?.Invoke(sender, (KeyEventArgs)args); SWindow.MouseButtonPressed += (sender, args) => MouseButtonPressed?.Invoke(sender, (MouseButtonEventArgs)args); SWindow.MouseButtonReleased += (sender, args) => MouseButtonReleased?.Invoke(sender, (MouseButtonEventArgs)args); SWindow.MouseMoved += (sender, args) => MouseMoved?.Invoke(sender, (MouseMoveEventArgs)args); SWindow.MouseWheelScrolled += (sender, args) => MouseWheelMoved?.Invoke(sender, (MouseWheelScrollEventArgs)args); SWindow.MouseEntered += (sender, args) => MouseEntered?.Invoke(sender, args); SWindow.MouseLeft += (sender, args) => MouseLeft?.Invoke(sender, args); SWindow.TextEntered += (sender, args) => TextEntered?.Invoke(sender, (TextEventArgs)args); }
public InputEvents(RenderWindow window) { // if dummy don't attach events if (window == null) { return; } _window = window; _window.KeyPressed += (sender, args) => KeyPressed?.Invoke(sender, args); _window.KeyReleased += (sender, args) => KeyReleased?.Invoke(sender, args); _window.MouseButtonPressed += (sender, args) => MouseButtonPressed?.Invoke(sender, args); _window.MouseButtonReleased += (sender, args) => MouseButtonReleased?.Invoke(sender, args); _window.MouseMoved += (sender, args) => MouseMoved?.Invoke(sender, args); _window.MouseWheelMoved += (sender, args) => MouseWheelMoved?.Invoke(sender, args); _window.MouseEntered += (sender, args) => MouseEntered?.Invoke(sender, args); _window.MouseLeft += (sender, args) => MouseLeft?.Invoke(sender, args); _window.TextEntered += (sender, args) => TextEntered?.Invoke(sender, args); }
internal static void OnKeyReleased(Key key) => KeyReleased?.Invoke(key);
public static void InputLoop() { uint toRead = 128; var records = new INPUT_RECORD[toRead]; int prevWidth = MyConsole.Width; int prevHeight = MyConsole.Height; MouseButton prevMouseState = MouseButton.None; COORD prevMouseLocation = new COORD(); while (!MyConsole.Exiting) { WinApi.ReadConsoleInput(inputHandle, records, toRead, out uint recordLen); for (int i = 0; i < recordLen; i++) { var record = records[i]; switch (record.EventType) { case EventType.Mouse: { var mouseEvent = record.Event.MouseEvent; var button = mouseEvent.ButtonState; var flags = mouseEvent.EventFlags; var location = mouseEvent.MousePosition; bool mousePressed = prevMouseState == MouseButton.None && button != MouseButton.None; bool mouseReleased = prevMouseState != MouseButton.None && button == MouseButton.None; bool mouseHeld = prevMouseState != MouseButton.None && button != MouseButton.None; var args = new MouseEventArgs { Button = button, Location = location, ControlKeyState = mouseEvent.ControlKeyState }; bool sameLocation = location.Equals(prevMouseLocation); if (mousePressed && flags.HasFlag(MouseState.DoubleClick)) { MouseDoubleClick?.Invoke(null, args); } else if (mousePressed) { MousePressed?.Invoke(null, args); } else if (mouseReleased) { MouseReleased?.Invoke(null, args); } else if (mouseHeld && flags.HasFlag(MouseState.Moved) && !sameLocation) { MouseDragged?.Invoke(null, args); } else if (flags.HasFlag(MouseState.Moved) && !sameLocation) { MouseMoved?.Invoke(null, args); } prevMouseState = button; prevMouseLocation = location; } break; case EventType.Key: { var keyEvent = record.Event.KeyEvent; var eventArgs = new KeyEventArgs { Key = (ConsoleKey)keyEvent.VirtualKeyCode, ControlKeyState = keyEvent.ControlKeyState }; bool currState = keyEvent.KeyDown; bool prevState = keyStates[keyEvent.VirtualKeyCode]; if (currState && !prevState) { KeyPressed?.Invoke(eventArgs); } else if (prevState && !currState) { KeyReleased?.Invoke(eventArgs); } else if (prevState && currState) { KeyHeld?.Invoke(eventArgs); } keyStates[keyEvent.VirtualKeyCode] = keyEvent.KeyDown; } break; case EventType.Resize: { var clientSize = MyConsole.GetClientSize(); var fontSize = MyConsole.GetFontSize(); int w = clientSize.X / fontSize.X; int h = clientSize.Y / fontSize.Y; if (prevWidth != w || prevHeight != h) { MyConsole.SetSize(w, h); MyConsole.HideCursor(); Drawing.ConsoleRenderer.Resize(w, h); Resized?.Invoke(new ResizedEventArgs { Width = w, Height = h }); prevWidth = w; prevHeight = h; } } break; case EventType.Menu: { var id = record.Event.MenuEvent.dwCommandId; Debug.WriteLine(id); } break; case EventType.Focus: { var focused = record.Event.FocusEvent.bSetFocus; } break; default: Debug.WriteLine("Unhandled event: " + record.EventType); break; } } } }
/// <summary> /// Raised by the KeyReleased event. /// </summary> /// <param name="sender">Sender object.</param> /// <param name="e">Event arguments.</param> protected virtual void OnKeyReleased(object sender, KeyboardKeyEventArgs e) { KeyReleased?.Invoke(sender, e); }
private KeyReleased KRValidator(KeyReleased r) { return(r ?? this.EmptyKeyreleaseHandler); }
public void Update(double delta) { // Truncate mouse position to screen dimensions Point position = _form.PointToClient(Cursor.Position); _mousePosition = new Vector2I(position.X, position.Y); MouseMoved.Raise(_mousePosition); MouseButtons buttons = Control.MouseButtons; bool leftMouseButtonPressed = (buttons == MouseButtons.Left); if (leftMouseButtonPressed && !_previousMouseButtons[0]) { MouseClicked.Raise(_mousePosition, 0); } else if (_previousMouseButtons[0] && !leftMouseButtonPressed) { MouseReleased.Raise(_mousePosition, 0); } _previousMouseButtons[0] = leftMouseButtonPressed; bool rightMouseButtonPressed = (buttons == MouseButtons.Right); if (rightMouseButtonPressed && !_previousMouseButtons[1]) { MouseClicked.Raise(_mousePosition, 1); } else if (_previousMouseButtons[1] && !rightMouseButtonPressed) { MouseReleased.Raise(_mousePosition, 1); } _previousMouseButtons[1] = rightMouseButtonPressed; foreach (Key key in _keys.Cast <Key>().Where(key => key != Key.None)) { if (Keyboard.IsKeyDown(key)) { if (_pressedKeys.ContainsKey(key)) { _pressedKeys[key] += delta; if (_pressedKeys[key] > 0.1) { _pressedKeys[key] = 0.0; KeyPressed.Raise(key, InputInterop.GetCharFromKey(key), true); } } else { _pressedKeys.Add(key, -0.9); KeyPressed.Raise(key, InputInterop.GetCharFromKey(key), false); } } else { if (_pressedKeys.ContainsKey(key)) { _pressedKeys.Remove(key); KeyReleased.Raise(key); } } } }
internal static void InvokeKeyReleased(Keys key) { KeyReleased.Invoke(null, new EventArgsKeyPressed(key)); }
private static void OnKeyReleased(Screen s, KeyEvent e) { KeyReleased?.Invoke(s, e); }
// If key is released through the app, call the KeyReleased event so that NoteOff is sent to the MIDI output // The key colour is also reset here instead of through the main ControlMessageHelper class // PointerCanceled, PointerCaptureLost and PointerExited also use this function to release the key when it should be released private void WKey_PointerReleased(object sender, PointerRoutedEventArgs e) { KeyReleased?.Invoke(KeyPitch, null); e.Handled = true; DepressKey(); }
/// <summary> /// Raises the <see cref="KeyReleased"/> event. /// </summary> /// <param name="window">The window that raised the event.</param> /// <param name="key">The <see cref="Key"/> that was released.</param> protected virtual void OnKeyReleased(IUltravioletWindow window, Key key) { KeyReleased?.Invoke(window, this, key); }
void OnKeyReleased(KeyReleased msg) { if (msg.Key == Keys.Space) { m_Controller.Constraint.TryJump = false; return; } Vector3 action; if (!m_ActionMap.TryGetValue(msg.Key, out action)) return; m_Controller.Constraint.TargetVelocity -= m_Speed * action; }
private void OnKeyReleased(object sender, KeyEventArgs e) { KeyReleased?.Invoke(this, e); }
protected virtual void OnKeyReleased(KeyEventArgs e) { KeyReleased?.Invoke(this, e); }
public override void Update(GameTime gameTime) { if (!Enabled) { return; } var keystate = Keyboard.GetState(); var mousestate = Mouse.GetState(); MousePosition = new Vector2(mousestate.X, mousestate.Y); if (IsLeftMouseDown && mousestate.LeftButton == ButtonState.Released) { IsLeftMouseDown = false; LeftMouseUp?.Invoke(mousestate); } else if (!IsLeftMouseDown && mousestate.LeftButton == ButtonState.Pressed) { IsLeftMouseDown = true; LeftMouseDown?.Invoke(mousestate); } if (IsRightMouseDown && mousestate.RightButton == ButtonState.Released) { IsRightMouseDown = false; RightMouseUp?.Invoke(mousestate); } else if (!IsRightMouseDown && mousestate.RightButton == ButtonState.Pressed) { IsRightMouseDown = true; RightMouseDown?.Invoke(mousestate); } if (IsMiddleMouseDown && mousestate.MiddleButton == ButtonState.Released) { IsMiddleMouseDown = false; MiddleMouseUp?.Invoke(mousestate); } else if (!IsMiddleMouseDown && mousestate.MiddleButton == ButtonState.Pressed) { IsMiddleMouseDown = true; MiddleMouseDown?.Invoke(mousestate); } ScrollWheel = mousestate.ScrollWheelValue; var releasedKeys = _keyStates.Where(k => k.Value && keystate.IsKeyUp(k.Key)).Select(k => k.Key).ToArray(); foreach (var releasedKey in releasedKeys) { _keyStates[releasedKey] = false; KeyReleased?.Invoke(releasedKey); } foreach (var pressedKey in keystate.GetPressedKeys()) { if (_keyStates.ContainsKey(pressedKey)) { if (_keyStates[pressedKey]) { continue; } _keyStates[pressedKey] = true; KeyPressed?.Invoke(pressedKey); } else { _keyStates.Add(pressedKey, true); } } }