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));
}
internal protected virtual void TriggerOnKeyPressed(Component sender, Keys key)
{
if (OnKeyPressed != null)
{
OnKeyPressed.Invoke(new KeyEventArgs(sender, key));
}
}
public void GetKey()
{
if (Input.GetKeyDown(_keyCode))
{
OnKeyPressed.Invoke(true);
}
}
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);
}
}
}
}
private void ConsoleWindow_KeyPress(object sender, KeyPressEventArgs e)
{
if (OnKeyPressed != null)
{
OnKeyPressed.Invoke(e);
}
}
public static void Update()
{
if (OnKeyPressed == null && OnKeyDown == null)
{
return;
}
KeyboardState state = Keyboard.GetState();
var keys = state.GetPressedKeys();
foreach (var pressedKey in PressedKeys.ToArray())
{
if (keys.Contains(pressedKey) == false)
{
PressedKeys.Remove(pressedKey);
OnKeyPressed?.Invoke(pressedKey);
}
}
foreach (var key in keys)
{
if (PressedKeys.Contains(key) == false)
{
OnKeyDown?.Invoke(key);
PressedKeys.Add(key);
}
}
}
private void FireKeyboardEvents()
{
// Check through each key in the key list
foreach (Keys key in KeyList)
{
// Is the key currently down?
if (CurrentKeyboardState.IsKeyDown(key))
{
// Fire the OnKeyDown event
OnKeyDown?.Invoke(this, new KeyboardEventArgs(key, CurrentKeyboardState, PrevKeyboardState));
}
// Has the key been released? (Was down and is now up)
if (PrevKeyboardState.IsKeyDown(key) && CurrentKeyboardState.IsKeyUp(key))
{
OnKeyUp?.Invoke(this, new KeyboardEventArgs(key, CurrentKeyboardState, PrevKeyboardState));
}
// Has the key been pressed? (Was up and is now down)
if (PrevKeyboardState.IsKeyUp(key) && CurrentKeyboardState.IsKeyDown(key))
{
OnKeyPressed?.Invoke(this, new KeyboardEventArgs(key, CurrentKeyboardState, PrevKeyboardState));
}
}
}
public override bool keyPressed(KeyboardEvent evt)
{
OnKeyPressed?.Invoke(this, new KeyboardEventArgs()
{
KeyboardEvent = evt
});
return(false); // propgate further;
}
private void KeyCallback(GlfwWindowPtr wnd, Key key, int scanCode, KeyAction action, KeyModifiers mods)
{
if (key == Key.Escape && action == KeyAction.Press)
{
SetWindowShouldClose(window, true);
}
OnKeyPressed?.Invoke(key, scanCode, action, mods);
}
private void RunKey(KeyCode code)
{
if (CheckKeySingle(code))
{
KeyEventArgs args = new KeyEventArgs(code);
OnKeyPressed?.Invoke(this, args);
}
}
public IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN || wParam == (IntPtr)WM_SYSKEYDOWN)
{
int vkCode = Marshal.ReadInt32(lParam);
OnKeyPressed?.Invoke(this, new KeyPressedArgs(KeyInterop.KeyFromVirtualKey(vkCode)));
}
return(CallNextHookEx(_hookID, nCode, wParam, lParam));
}
private static IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode >= 0 && wParam == (IntPtr)WmKeydown)
{
OnKeyPressed?.Invoke(Marshal.ReadInt32(lParam));
}
return(CallNextHookEx(_hookId, nCode, wParam, lParam));
}
/// <summary>
/// Updates our input.
/// </summary>
/// <returns>
/// Currently pressed button.
/// </returns>
public ConsoleKey Update()
{
ConsoleKey key = Console.ReadKey().Key;
//if (OnKeyPressed != null)
// OnKeyPressed.Invoke(key);
OnKeyPressed?.Invoke(key);
return(key);
}
private IntPtr hookCallback(int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN || wParam == (IntPtr)WM_SYSKEYDOWN)
{
OnKeyPressed?.Invoke(KeyInterop.KeyFromVirtualKey(Marshal.ReadInt32(lParam)));
}
return(CallNextHookEx(hookId, nCode, wParam, lParam));
}
private void OnKeyPress(Keys key)
{
KeyEventArgs args = new KeyEventArgs(key);
Task.Run(() =>
{
OnKeyPressed?.Invoke(this, args);
});
}
private void Update(float time)
{
var m = _keyboard.GetCurrentState();
if (m.PressedKeys.Count > 0)
{
OnKeyPressed?.Invoke(time, m);
}
OnUpdate?.Invoke(time);
}
private void Listening()
{
while (true)
{
using (var g = Console.In)
{
OnKeyPressed?.Invoke(this, Console.ReadKey(true).Key);
}
}
}
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);
}
public void OnChangeKeyClick(int key)
{
changePretenderKey = (InputKey)key;
waitingForKey = true;
/* Delegate */
onKeyPressed = null; //Clear delegate
onKeyPressed += OnChangeKeyPressed;
inputKeysTexts[changePretenderKey].text = SET_KEY;
}
private IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode >= 0 && wParam == (IntPtr)WmKeydown || wParam == (IntPtr)WmSyskeydown)
{
int vkCode = Marshal.ReadInt32(lParam);
OnKeyPressed?.Invoke(this, new KeyPressedArgs(KeyInterop.KeyFromVirtualKey(vkCode)));
}
return(CallNextHookEx(_hookId, nCode, wParam, lParam));
}
/// <summary> 0бновление. </summary>
public static void Update()
{
blockNextInput = false;
if (!DisableMouse)
{
oldMouse = newMouse;
newMouse = Mouse.GetState();
rect.X = newMouse.X;
rect.Y = newMouse.Y;
rectf.X = newMouse.X;
rectf.Y = newMouse.Y;
currentScrollWheel = newMouse.ScrollWheelValue;
IsScrollWheelUp = false;
IsScrollWheelDown = false;
if (currentScrollWheel > oldMouse.ScrollWheelValue)
{
IsScrollWheelUp = true;
}
else if (currentScrollWheel < oldMouse.ScrollWheelValue)
{
IsScrollWheelDown = true;
}
}
oldKeyboard = newKeyboard;
newKeyboard = Keyboard.GetState();
presseds = newKeyboard.GetPressedKeys();
oldPresseds = oldKeyboard.GetPressedKeys();
anyKeyDown = presseds.Length > 0;
shiftDown = presseds.Contains(Keys.LeftShift);
pressedKeysList.Clear();
for (int i = 0; i < presseds.Length; i++)
{
if (!oldPresseds.Contains(presseds[i]))
{
// БЕЗУМИЕ!!!
if (presseds[i] != Keys.LeftShift && presseds[i] != Keys.RightShift &&
presseds[i] != Keys.LeftAlt &&
presseds[i] != Keys.RightAlt && presseds[i] != Keys.LeftControl &&
presseds[i] != Keys.RightControl && presseds[i] != Keys.Up && presseds[i] != Keys.Down &&
presseds[i] != Keys.Left && presseds[i] != Keys.Right && presseds[i] != Keys.Tab &&
presseds[i] != Keys.CapsLock && presseds[i] != Keys.NumLock && presseds[i] != Keys.Delete)
{
OnKeyPressed?.Invoke(presseds[i]);
}
}
}
}
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);
OnKeyPressed?.Invoke(this, new KeyEventArgs((Keys)vkCode));
}
return(CallNextHookEx(_hookID, nCode, wParam, lParam));
}
private void HandleIRQ(ref INTs.IRQContext aContext)
{
byte xScanCode = IO.Port60.Byte;
bool xReleased = (xScanCode & 0x80) == 0x80;
if (xReleased)
{
xScanCode = (byte)(xScanCode ^ 0x80);
}
OnKeyPressed?.Invoke(xScanCode, xReleased);
}
internal static void Init(IntPtr windowHandle)
{
_keyCallback = (IntPtr window, int key, int scancode, int action, int mods) =>
{
if (action == GLFW.PRESS)
{
OnKeyPressed?.Invoke((Keys)key);
}
};
GLFW.SetKeyCallback(windowHandle, Marshal.GetFunctionPointerForDelegate(_keyCallback));
}
private void TextBox_OnKeyUp(object sender, KeyEventArgs e)
{
OnKeyPressed?.Invoke(this, e);
if (e.Key == Key.Escape)
{
TextBox.Clear();
}
if (e.Key == Key.Enter)
{
EnterKeyPressed?.Invoke(null, null);
}
}
/// <summary>
/// Checks pressed keys.
/// </summary>
public void CheckInput()
{
if (Input.GetKey(Condition))
{
OnKeyPressed?.Invoke();
}
if (Input.GetKeyDown(Condition))
{
OnKeyDown?.Invoke();
}
}
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 listenForAnyPress()
{
Keys pressedKey;
while (true)
{
pressedKey = getPressedKey();
if (pressedKey != Keys.None)
{
OnKeyPressed?.Invoke(pressedKey);
}
}
}
public void QueryInput()
{
m_KeyBuffer = new List <ConsoleKeyInfo>();
while (Console.KeyAvailable)
{
m_KeyBuffer.Add(Console.ReadKey(true));
}
foreach (var keyInfo in m_KeyBuffer)
{
OnKeyPressed.Invoke(keyInfo);
}
}
public void ListenToUser()
{
var k = new ConsoleKeyInfo();
while (k.Key != stopKey)
{
k = Console.ReadKey();
CommandEventArgs commandEventArgs = new CommandEventArgs()
{
PressedKey = k
};
OnKeyPressed?.Invoke(this, commandEventArgs);
}
}
