/// <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);
}
}
}
