internal protected virtual void TriggerOnKeyReleased(Component sender, Keys key)
{
if (OnKeyReleased != null)
{
OnKeyReleased.Invoke(new KeyEventArgs(sender, key));
}
}
private void InvokeEvents()
{
foreach (var key in Enum.GetValues(typeof(Keys)).Cast <Keys>())
{
if (IsKeyDown(key))
{
OnKeyDown?.Invoke(key);
if (IsKeyPressed(key))
{
OnKeyPressed?.Invoke(key);
}
if (IsKeyClicked(key))
{
OnKeyClicked?.Invoke(key);
}
}
else
{
OnKeyUp?.Invoke(key);
if (IsKeyReleased(key))
{
OnKeyReleased?.Invoke(key);
}
}
}
}
public void Update()
{
Keys[] pressedKeys = Keyboard.GetState().GetPressedKeys();
foreach (Keys key in previousKeys)
{
if (!pressedKeys.Contains(key))
{
OnKeyReleased.Invoke(this, key);
}
}
foreach (Keys key in pressedKeys)
{
if (controllerMappings.ContainsKey(key))
{
if (key == Keys.Up || key == Keys.W || key == Keys.Down)
{
if (!previousKeys.Contains(key))
{
controllerMappings[key].Execute();
}
}
else
{
controllerMappings[key].Execute();
}
}
}
previousKeys = pressedKeys;
}
internal static void DoKeyReleased(Keys k)
{
if (OnKeyReleased != null)
{
Delegate[] dels = OnKeyReleased.GetInvocationList();
//ctrl+shift is considered a universal override.
//it will reverse the order of event handling to allow global-level UI to handle keys/mouse before others.
if (KeyboardHandler.ControlPressed && KeyboardHandler.ShiftPressed)
{
List <Delegate> temp = new List <Delegate>(dels);
temp.Reverse();
dels = temp.ToArray();
}
if (dels.Length == 0)
{
return;
}
for (int i = dels.Length - 1; i >= 0; i--)
{
KeyEventHandler d = dels[i] as KeyEventHandler;
if (d == null) // cast error. should never happen.
{
continue;
}
if ((bool)d.DynamicInvoke(null, k))
{
break;
}
}
}
}
private IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN || wParam == (IntPtr)WM_SYSKEYDOWN)
{
int vkCode = Marshal.ReadInt32(lParam);
Key keyPressed = KeyInterop.KeyFromVirtualKey(vkCode);
if (!AllKeyPressed.Contains(keyPressed))
{
AllKeyPressed.Add(keyPressed);
}
if (OnKeyPressed != null)
{
OnKeyPressed.Invoke(new KeyPressedArgs(keyPressed));
}
}
if (nCode >= 0 && wParam == (IntPtr)WM_KEYUP || wParam == (IntPtr)WM_SYSKEYUP)
{
int vkCode = Marshal.ReadInt32(lParam);
Key keyPressed = KeyInterop.KeyFromVirtualKey(vkCode);
if (AllKeyPressed.Contains(keyPressed))
{
AllKeyPressed.Remove(keyPressed);
}
if (OnKeyReleased != null)
{
OnKeyReleased.Invoke(new KeyReleasedArgs(keyPressed));
}
}
return(WinApi.CallNextHookEx(_hookID, nCode, wParam, lParam));
}
public override bool keyReleased(KeyboardEvent evt)
{
OnKeyReleased?.Invoke(this, new KeyboardEventArgs()
{
KeyboardEvent = evt
});
return(false); // propgate further;
}
private void OnKeyRelease(Keys key)
{
KeyEventArgs args = new KeyEventArgs(key);
Task.Run(() =>
{
OnKeyReleased?.Invoke(this, args);
});
}
internal void InitKeyboardHandlers()
{
_keyboardHandler = new KeyboardHandler();
_keyboardHandler.OnKeyDown += (key) => OnKeyDown?.Invoke(key);
_keyboardHandler.OnKeyUp += (key) => OnKeyUp?.Invoke(key);
_keyboardHandler.OnKeyPressed += (key) => OnKeyPressed?.Invoke(key);
_keyboardHandler.OnKeyClicked += (key) => OnKeyClicked?.Invoke(key);
_keyboardHandler.OnKeyReleased += (key) => OnKeyReleased?.Invoke(key);
}
private void CheckButton(BcmPin pin, Dictionary <BcmPin, bool> buttonState)
{
if (!Pi.Gpio[pin].Read() && !buttonState[pin])
{
buttonState[pin] = true;
OnKeyPressed.Invoke((int)pin);
}
if (Pi.Gpio[pin].Read() && buttonState[pin])
{
OnKeyReleased.Invoke((int)pin);
buttonState[pin] = false;
}
}
public static void InvokeEvents()
{
if (OnKeyDown != null && GetDownKeys().Count() > 0)
{
OnKeyDown.Invoke(currentState, GetDownKeys());
}
if (OnKeyPressed != null && GetPressedKeys().Count() > 0)
{
OnKeyPressed.Invoke(currentState, GetPressedKeys());
}
if (OnKeyReleased != null && GetReleasedKeys().Count() > 0)
{
OnKeyReleased.Invoke(currentState, GetReleasedKeys());
}
}
private void MessageLoop()
{
foreach (HookMessage message in hooker.MessageQueue.GetConsumingEnumerable())
{
/* ProcessNewTagReceivedLogic(tag);
* Console.WriteLine("Process Buffer #Tag {0}. Buffer Count #{1}", tag.NewLoopId, LogicBuffer.Count);*/
if (message.messageType == HookMessageType.KeyDown)
{
OnKeyReleased?.Invoke(this, new KeyEventArgs(message.key));
}
else if (message.messageType == HookMessageType.KeyUp)
{
OnKeyPressed?.Invoke(this, new KeyEventArgs(message.key));
}
else if (message.messageType == HookMessageType.MouseDown)
{
OnMouseClicked?.Invoke(this, new MouseEventArgs(message.mouseButton, 1, message.mouseX, message.mouseY, 0));
}
}
/* while (true)
* {
* if (cancelToken.IsCancellationRequested)
* return;
*
*
*
* /*if (hooker.HasMessageAvailable)
* {
* HookMessage message = hooker.NextMessage;
* if (message.messageType == HookMessageType.KeyDown)
* {
* OnKeyReleased?.Invoke(this, new KeyEventArgs(message.key));
* }
* else if (message.messageType == HookMessageType.KeyUp)
* {
* OnKeyPressed?.Invoke(this, new KeyEventArgs(message.key));
* }
* else if (message.messageType == HookMessageType.MouseDown)
* {
* OnMouseClicked?.Invoke(this, new MouseEventArgs(message.mouseButton, 1, message.mouseX, message.mouseY, 0));
* }
* }
* await Task.Delay(10);
* }*/
}
public void Update(GameTime gameTime)
{
CurrentKeyState.Clear();
_currentState = Keyboard.GetState();
_keysArray = _currentState.GetPressedKeys();
if (_keysArray != null)
{
for (int i = 0; i < _keysArray.Length; i++)
{
if (!CurrentKeyState.HeldKeys.Contains(_keysArray[i]))
{
CurrentKeyState.HeldKeys.Add(_keysArray[i]);
}
if (_previousState.IsKeyUp(_keysArray[i]))
{
OnKeyPressed?.Invoke(_keysArray[i], gameTime, CurrentKeyState);
}
else
{
OnKeyDown?.Invoke(_keysArray[i], gameTime, CurrentKeyState);
}
}
}
_keysArray = _previousState.GetPressedKeys();
if (_keysArray != null)
{
for (int i = 0; i < _keysArray.Length; i++)
{
if (_currentState.IsKeyUp(_keysArray[i]))
{
CurrentKeyState.HeldKeys.RemoveAll(k => { return(k == _keysArray[i]); });
OnKeyReleased?.Invoke(_keysArray[i], gameTime, CurrentKeyState);
}
}
}
_previousState = _currentState;
}
private IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode >= 0 && wParam == (IntPtr)WM_KEYUP || wParam == (IntPtr)WM_SYSKEYUP)
{
int vkCode = Marshal.ReadInt32(lParam);
if (OnKeyReleased != null)
{
OnKeyReleased.Invoke(this, new KeyReleasedArgs(KeyInterop.KeyFromVirtualKey(vkCode)));
}
}
if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN || wParam == (IntPtr)WM_SYSKEYDOWN)
{
int vkCode = Marshal.ReadInt32(lParam);
if (OnKeyPressed != null)
{
OnKeyPressed(this, new KeyPressedArgs(KeyInterop.KeyFromVirtualKey(vkCode)));
}
}
return(CallNextHookEx(_hookID, nCode, wParam, lParam));
}
public void AddMidiDevice(MidiIn midiInput, OnKeyPressed onKeyPressedListener = null, OnKeyReleased onKeyReleasedListener = null)
{
_midiDevice = new MidiDevice(midiInput, OnNoteOn, OnNoteOff);
if (onKeyPressedListener != null)
{
_onKeyPressedListeners.Add(onKeyPressedListener);
}
if (onKeyReleasedListener != null)
{
_onKeyReleasedListeners.Add(onKeyReleasedListener);
}
}
public void KeyReleased(Keys key)
{
_keyStates[key] = false;
OnKeyReleased?.Invoke(key);
}
private void OnKeyRelease(object sender, KeyEventArgs e)
{
OnKeyReleased?.Invoke(sender, e);
}
public void AddKeyReleasedListener(OnKeyReleased listener) => _onKeyReleasedListeners.Add(listener);
public void RemoveKeyReleasedListener(OnKeyReleased listener) => _onKeyReleasedListeners.Remove(listener);
internal void InvokeKeyReleased(KeyConstant key, Scancode scancode)
{
OnKeyReleased?.Invoke(key, scancode);
KeyReleased(key, scancode);
}
