private int KeyboardProc(int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode == HC_ACTION)
{
if (wParam == (IntPtr)WM_KEYDOWN || wParam == (IntPtr)WM_SYSKEYDOWN)
{
var vkcode = (int)((KBDLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(KBDLLHOOKSTRUCT))).vkCode;
var key = KeyInterop.KeyFromVirtualKey(vkcode);
CurrentKey = key;
KeyDown?.Invoke(key, vkcode);
}
if (wParam == (IntPtr)WM_KEYUP || wParam == (IntPtr)WM_SYSKEYUP)
{
var vkcode = (int)((KBDLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(KBDLLHOOKSTRUCT))).vkCode;
var key = KeyInterop.KeyFromVirtualKey(vkcode);
CurrentKey = null;
KeyUp?.Invoke(key, vkcode);
}
}
return(CallNextHookEx((int)IntPtr.Zero, nCode, wParam, lParam));
}
/// <summary>
/// 获取键盘消息
/// </summary>
/// <param name="nCode"></param>
/// <param name="wParam"></param>
/// <param name="lParam"></param>
/// <returns></returns>
private int KeyboardHookProc(int nCode, Int32 wParam, IntPtr lParam)
{
// 如果该消息被丢弃（nCode<0
if (nCode >= 0)
{
KeyboardHookStruct KeyDataFromHook = (KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct));
int keyData = KeyDataFromHook.VkCode;
//WM_KEYDOWN和WM_SYSKEYDOWN消息，将会引发OnKeyDownEvent事件
if ((wParam == NativeMethods.WMKEYDOWN || wParam == NativeMethods.WMSYSKEYDOWN))
{
Key key = KeyInterop.KeyFromVirtualKey(keyData);
KeyDown?.Invoke(this, new KeyboardHookEventArgs(key, CapsLockStatus));
}
//WM_KEYUP和WM_SYSKEYUP消息，将引发OnKeyUpEvent事件
if ((wParam == NativeMethods.WMKEYUP || wParam == NativeMethods.WMSYSKEYUP))
{
Key key = KeyInterop.KeyFromVirtualKey(keyData);
KeyUp?.Invoke(this, new KeyboardHookEventArgs(key, CapsLockStatus));
}
}
return(IsHoldKey ? -1 : NativeMethods.CallNextHookEx(hHook, nCode, wParam, lParam));
}
public static Task <bool> JsKeyUp(int e)
{
var found = false;
var consoleKey = default(ConsoleKey);
try
{
consoleKey = (ConsoleKey)e;
found = true;
}
catch
{
Console.WriteLine($"Cound not find {nameof(ConsoleKey)} for JS key value {e})");
}
if (found)
{
KeyUp?.Invoke(null, consoleKey);
}
return(Task.FromResult(found));
}
public FileViewerInternal()
{
InitializeComponent();
InitializeComplete();
_currentViewPositionCache = new CurrentViewPositionCache(this);
TextEditor.ActiveTextAreaControl.TextArea.PreviewKeyDown += (s, e) =>
{
if (e.KeyCode == Keys.Escape && !TextEditor.ActiveTextAreaControl.SelectionManager.HasSomethingSelected)
{
EscapePressed?.Invoke();
}
};
TextEditor.TextChanged += (s, e) => TextChanged?.Invoke(s, e);
TextEditor.ActiveTextAreaControl.HScrollBar.ValueChanged += (s, e) => OnHScrollPositionChanged(EventArgs.Empty);
TextEditor.ActiveTextAreaControl.VScrollBar.ValueChanged += (s, e) => OnVScrollPositionChanged(EventArgs.Empty);
TextEditor.ActiveTextAreaControl.TextArea.KeyUp += (s, e) => KeyUp?.Invoke(s, e);
TextEditor.ActiveTextAreaControl.TextArea.DoubleClick += (s, e) => DoubleClick?.Invoke(s, e);
TextEditor.ActiveTextAreaControl.TextArea.MouseMove += (s, e) => MouseMove?.Invoke(s, e);
TextEditor.ActiveTextAreaControl.TextArea.MouseEnter += (s, e) => MouseEnter?.Invoke(s, e);
TextEditor.ActiveTextAreaControl.TextArea.MouseLeave += (s, e) => MouseLeave?.Invoke(s, e);
TextEditor.ActiveTextAreaControl.TextArea.MouseDown += (s, e) =>
{
SelectedLineChanged?.Invoke(
this,
new SelectedLineEventArgs(
TextEditor.ActiveTextAreaControl.TextArea.TextView.GetLogicalLine(e.Y)));
};
HighlightingManager.Manager.DefaultHighlighting.SetColorFor("LineNumbers", new HighlightColor(Color.FromArgb(80, 0, 0, 0), Color.White, false, false));
TextEditor.ActiveTextAreaControl.TextEditorProperties.EnableFolding = false;
_lineNumbersControl = new DiffViewerLineNumberControl(TextEditor.ActiveTextAreaControl.TextArea);
VRulerPosition = AppSettings.DiffVerticalRulerPosition;
}
protected virtual HookResult HookProc(int code, int wParam, ref KeyboardHookData lParam)
{
Keys k = (Keys)lParam.vkCode;
//Check for shift(s), alt, and ctrl.
//Shift
if (k == Keys.LShiftKey)
{
bLeftShiftHeld = bShiftHeld = (wParam == WM_KEYDOWN);
}
else if (k == Keys.RShiftKey)
{
bRightShiftHeld = bShiftHeld = (wParam == WM_KEYDOWN);
}
//Control
if ((lParam.vkCode & 0xA2) == 0xA2 || (lParam.vkCode & 0xA3) == 0xA3)
{
bCtrlHeld = (wParam == WM_KEYDOWN);
return(HookResult.NoRelease);
}
//Alt
if ((lParam.vkCode & 0xA4) == 0xA4 || (lParam.vkCode & 0xA5) == 0xA5)
{
bAltHeld = (wParam == WM_KEYDOWN);
return(HookResult.NoRelease);
}
if (wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN)
{
KeyDown?.Invoke(wParam, lParam);
}
else if (wParam == WM_KEYUP || wParam == WM_SYSKEYUP)
{
KeyUp?.Invoke(wParam, lParam);
}
return(HookResult.Release);
}
/// <summary>
/// Default hook call, which analyses pressed keys
/// </summary>
private IntPtr HookFunc(int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode < 0)
{
return(CallNextHookEx(hookID, nCode, wParam, lParam));
}
var iwParam = wParam.ToInt32();
switch (iwParam)
{
case WM_KEYDOWN:
case WM_SYSKEYDOWN:
KeyDown?.Invoke((VKeys)Marshal.ReadInt32(lParam));
break;
case WM_KEYUP:
case WM_SYSKEYUP:
KeyUp?.Invoke((VKeys)Marshal.ReadInt32(lParam));
break;
}
return(CallNextHookEx(hookID, nCode, wParam, lParam));
}
//The listener that will trigger events
private int KeybHookProc(int Code, int W, int L)
{
if (Code < 0)
{
return(CallNextHookEx(HookID, Code, W, L));
}
try
{
KeyEvents kEvent = (KeyEvents)W;
Int32 vkCode = Marshal.ReadInt32((IntPtr)L);
if (kEvent == KeyEvents.KeyDown || kEvent == KeyEvents.SKeyDown)
{
KeyDown?.Invoke((Keys)vkCode);
}
if (kEvent == KeyEvents.KeyUp || kEvent == KeyEvents.SKeyUp)
{
KeyUp?.Invoke((Keys)vkCode);
}
}
catch { }
return(CallNextHookEx(HookID, Code, W, L));
}
private static IntPtr HookProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
{
var returnCode = CallWindowProc(prevWndProc, hWnd, msg, wParam, lParam);
switch (msg)
{
case WM_GETDLGCODE:
returnCode = (IntPtr)(returnCode.ToInt32() | DLGC_WANTALLKEYS);
break;
case WM_KEYDOWN:
KeyDown?.Invoke(null, new KeyEventArgs((Keys)wParam));
break;
case WM_KEYUP:
KeyUp?.Invoke(null, new KeyEventArgs((Keys)wParam));
break;
case WM_CHAR:
CharEntered?.Invoke(null, new CharacterEventArgs((char)wParam, lParam.ToInt32()));
break;
case WM_IME_SETCONTEXT:
if (wParam.ToInt32() == 1)
{
ImmAssociateContext(hWnd, hIMC);
}
break;
case WM_INPUTLANGCHANGE:
ImmAssociateContext(hWnd, hIMC);
returnCode = (IntPtr)1;
break;
}
return(returnCode);
}
private int HookProc(int code, int wParam, ref KeyboardHookStruct lParam)
{
try
{
if (code < 0)
{
return(CallNextHookEx(hhook, code, wParam, ref lParam));
}
var key = (Keys)lParam.vkCode;
if (!catchAllKeyDowns && !hookedKeys.Contains(key))
{
return(CallNextHookEx(hhook, code, wParam, ref lParam));
}
var kea = new KeyEventArgs(key);
if ((wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN) && KeyDown != null)
{
KeyDown(this, kea);
}
else if (wParam == WM_KEYUP || wParam == WM_SYSKEYUP)
{
KeyUp?.Invoke(this, kea);
}
if (kea.Handled)
{
return(1);
}
return(CallNextHookEx(hhook, code, wParam, ref lParam));
}
catch
{
return(0);
}
}
private static IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode >= 0)
{
if (wParam == KeyDownIntPtr)
{
var virtualKey = Marshal.ReadInt32(lParam);
if (VirtualKey != virtualKey)
{
VirtualKey = virtualKey;
KeyDown?.Invoke(null, new KeyboardHookEventArgs(virtualKey, false));
}
}
else if (wParam == SyskeyDownIntPtr)
{
var virtualKey = Marshal.ReadInt32(lParam);
if (VirtualKey != virtualKey)
{
VirtualKey = virtualKey;
KeyDown?.Invoke(null, new KeyboardHookEventArgs(virtualKey, true));
}
}
else if (wParam == KeyUpIntPtr)
{
var virtualKey = Marshal.ReadInt32(lParam);
VirtualKey = -1;
KeyUp?.Invoke(null, new KeyboardHookEventArgs(virtualKey, false));
}
else if (wParam == SyskeyUpIntPtr)
{
var virtualKey = Marshal.ReadInt32(lParam);
VirtualKey = -1;
KeyUp?.Invoke(null, new KeyboardHookEventArgs(virtualKey, true));
}
}
return(InteropMethods.CallNextHookEx(HookId, nCode, wParam, lParam));
}
// The method responsible for handling the update
static private void Update(object s, EventArgs e)
{
KeyboardState New = Keyboard.GetState();
Keys[] OldDown = Old.GetPressedKeys();
Keys[] Down = New.GetPressedKeys().Where(a => !Old.IsKeyDown(a)).ToArray();
Keys[] Up = OldDown.Where(a => !New.IsKeyDown(a)).ToArray();
Keys[] Held = OldDown.Where(a => New.IsKeyDown(a)).ToArray();
foreach (Keys key in Down)
{
KeyDown?.Invoke(key);
// int[]{ticks,tickRate}
Counter.Add(key, new int[2] {
30, 30
});
}
foreach (Keys key in Up)
{
Counter.Remove(key);
KeyUp?.Invoke(key);
}
foreach (Keys key in Held)
{
Counter[key][0]--;
if (Counter[key][0] > 0)
{
continue;
}
Counter[key][0] = Counter[key][1];
if (Counter[key][1] > 15)
{
Counter[key][1]--;
}
KeyHeld?.Invoke(key);
}
Old = New;
}
static IntPtr HookProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
{
IntPtr returnCode = CallWindowProc(_prevWndProc, hWnd, msg, wParam, lParam);
switch (msg)
{
case WmGetdlgcode:
returnCode = (IntPtr)(returnCode.ToInt32() | DlgcWantallkeys);
break;
case WmKeydown:
KeyDown?.Invoke(null, new KeyEventArgs((Keys)wParam));
break;
case WmKeyup:
KeyUp?.Invoke(null, new KeyEventArgs((Keys)wParam));
break;
case WmChar:
CharEntered?.Invoke(null, new CharacterEventArgs((char)wParam, lParam.ToInt32()));
break;
case WmImeSetcontext:
if (wParam.ToInt32() == 1)
{
ImmAssociateContext(hWnd, _hImc);
}
break;
case WmInputlangchange:
ImmAssociateContext(hWnd, _hImc);
returnCode = (IntPtr)1;
break;
}
return(returnCode);
}
/// <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)
{
Keys key = (Keys)lParam.vkCode;
if (HookedKeys.Contains(key))
{
KeyEventArgs kea = new KeyEventArgs(key);
if ((wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN) && (KeyDown != null))
{
KeyDown.Invoke(this, kea);
}
else if ((wParam == WM_KEYUP || wParam == WM_SYSKEYUP) && (KeyUp != null))
{
KeyUp.Invoke(this, kea);
}
if (kea.Handled)
{
return(1);
}
}
}
return(CallNextHookEx(hhook, code, wParam, ref lParam));
}
public override void Update(GameTime gameTime)
{
base.Update(gameTime);
if (!Enabled)
{
return;
}
var state = Keyboard.GetState();
var oldPressed = _previousState.GetPressedKeys();
var newPressed = state.GetPressedKeys();
for (var i = 0; i < oldPressed.Length; ++i)
{
if (Array.IndexOf(newPressed, oldPressed[i]) < 0)
{
var e = new KeyEventArgs(oldPressed[i], KeyState.Down, KeyState.Up);
KeyUp?.Invoke(this, e);
}
}
for (var i = 0; i < newPressed.Length; ++i)
{
if (Array.IndexOf(oldPressed, newPressed[i]) < 0)
{
var e = new KeyEventArgs(newPressed[i], KeyState.Up, KeyState.Down);
KeyDown?.Invoke(this, e);
}
}
_previousState = state;
}
IntPtr KeyBoardHookFunc(int nCode, IntPtr wParam, IntPtr lParam)
{
// parse system messages
if (nCode >= 0)
{
if (KeyBoardMessages.WM_KEYDOWN == (KeyBoardMessages)wParam)
{
KeyDown?.Invoke((Keys)Marshal.ReadInt32(lParam));
}
//Need to catch SYSKEYDOWN for alt key
if (KeyBoardMessages.WM_SYSKEYDOWN == (KeyBoardMessages)wParam)
{
KeyDown?.Invoke((Keys)Marshal.ReadInt32(lParam));
}
if (KeyBoardMessages.WM_KEYUP == (KeyBoardMessages)wParam)
{
KeyUp?.Invoke((Keys)Marshal.ReadInt32(lParam));
}
}
return(NativeMethods.CallNextHookEx(keyBoardHookID, nCode, wParam, lParam));
}
private IntPtr HookCallback(int nCode, IntPtr wParam, ref KBDLLHOOKSTRUCT lParam)
{
if (nCode >= 0)
{
if (wParam == (IntPtr)WM_KEYDOWN || wParam == (IntPtr)WM_SYSKEYDOWN)
{
int vkCode = lParam.vkCode;
int flags = lParam.flags;
Keys key = (Keys)vkCode;
if (KeyEvented?.Invoke(key, KeyboardEventType.KEYDOWN) == false)
{
return((IntPtr)1);
}
if (KeyDown?.Invoke(key) == false)
{
return((IntPtr)1);
}
}
else if (wParam == (IntPtr)WM_KEYUP || wParam == (IntPtr)WM_SYSTEMKEYUP)
{
int vkCode = lParam.vkCode;
int flags = lParam.flags;
Keys key = (Keys)vkCode;
if (KeyEvented?.Invoke(key, KeyboardEventType.KEYUP) == false)
{
return((IntPtr)1);
}
if (KeyUp?.Invoke(key) == false)
{
return((IntPtr)1);
}
}
}
return(API.CallNextHookEx(_hookID, nCode, wParam, ref lParam));
}
private int HookProc(int code, int wParam, ref User32.KeyboardHookStruct lParam)
{
if (code >= 0)
{
var key = (Keys)lParam.vkCode;
if (HookedKeys.Contains(key))
{
var kea = new KeyEventArgs(key);
if (wParam == User32.WM_KEYDOWN || wParam == User32.WM_SYSKEYDOWN)
{
KeyDown?.Invoke(this, kea);
}
if (wParam == User32.WM_KEYUP || wParam == User32.WM_SYSKEYUP)
{
KeyUp?.Invoke(this, kea);
}
if (kea.Handled)
{
return(1);
}
}
}
return(User32.CallNextHookEx(_hhook, code, wParam, ref lParam));
}
public void OnKeyUp(SkiVirtualKey key)
{
lock (_downKeys)
{
if (!_downKeys.Remove(key))
{
return;
}
}
lock (_keyBindingsMap)
{
if (_keyBindingsMap.TryGetValue(key, out var keyBindings))
{
var matchedKeyBindings = keyBindings.Where(b => b.IsPressed);
foreach (var matchedKeyBinding in matchedKeyBindings)
{
matchedKeyBinding.OnReleased();
}
}
}
KeyUp.Invoke(key);
}
/// <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 IntPtr HookCallback(int code, IntPtr wParam, ref WinAPI.KeyboardHookStruct lParam)
{
if (code >= 0)
{
var key = (System.Windows.Forms.Keys)lParam.vkCode;
if (_hookedKeys.Contains(key))
{
var wpfKey = InputUtil.WinformsToWPFKey(key);
var eventArgs = new GlobalKeyEventArgs(wpfKey, IsShiftPressed(), IsCtrlPressed(), IsAltPressed());
if (wParam == (IntPtr)WM_KEYDOWN || wParam == (IntPtr)WM_SYSKEYDOWN)
{
KeyDown?.Invoke(this, eventArgs);
}
else if (wParam == (IntPtr)WM_KEYUP || wParam == (IntPtr)WM_SYSKEYUP)
{
KeyUp?.Invoke(this, eventArgs);
}
}
}
return(WinAPI.CallNextHookEx(hookID, code, wParam, ref lParam));
}
internal virtual void InvokeKeyUp(DisplayObject target, DisplayObject currentTarget)
{
KeyUp?.Invoke(target, currentTarget);
}
private unsafe int HookFunc(IntPtr userdata, IntPtr ev)
{
SDL_Event *e = (SDL_Event *)ev;
switch (e->type)
{
case SDL_EventType.SDL_WINDOWEVENT:
switch (e->window.windowEvent)
{
case SDL_WindowEventID.SDL_WINDOWEVENT_ENTER:
Mouse.MouseInWindow = true;
break;
case SDL_WindowEventID.SDL_WINDOWEVENT_LEAVE:
Mouse.MouseInWindow = false;
break;
case SDL_WindowEventID.SDL_WINDOWEVENT_FOCUS_GAINED:
// SDL_CaptureMouse(SDL_bool.SDL_TRUE);
//Log.Message(LogTypes.Debug, "FOCUS");
break;
case SDL_WindowEventID.SDL_WINDOWEVENT_FOCUS_LOST:
//Log.Message(LogTypes.Debug, "NO FOCUS");
//SDL_CaptureMouse(SDL_bool.SDL_FALSE);
break;
case SDL_WindowEventID.SDL_WINDOWEVENT_TAKE_FOCUS:
//Log.Message(LogTypes.Debug, "TAKE FOCUS");
break;
case SDL_WindowEventID.SDL_WINDOWEVENT_HIT_TEST:
break;
}
break;
case SDL_EventType.SDL_SYSWMEVENT:
break;
case SDL_EventType.SDL_KEYDOWN:
KeyDown?.Raise(e->key);
break;
case SDL_EventType.SDL_KEYUP:
KeyUp.Raise(e->key);
break;
case SDL_EventType.SDL_TEXTINPUT:
string s = StringHelper.ReadUTF8(e->text.text);
if (!string.IsNullOrEmpty(s))
{
TextInput.Raise(s);
}
break;
case SDL_EventType.SDL_MOUSEMOTION:
Mouse.Update();
if (Mouse.IsDragging)
{
MouseDragging.Raise();
}
if (Mouse.IsDragging && !_dragStarted)
{
DragBegin.Raise();
_dragStarted = true;
}
break;
case SDL_EventType.SDL_MOUSEWHEEL:
Mouse.Update();
bool isup = e->wheel.y > 0;
MouseWheel.Raise(isup);
break;
case SDL_EventType.SDL_MOUSEBUTTONUP:
case SDL_EventType.SDL_MOUSEBUTTONDOWN:
Mouse.Update();
bool isDown = e->type == SDL_EventType.SDL_MOUSEBUTTONDOWN;
if (_dragStarted && !isDown)
{
DragEnd.Raise();
_dragStarted = false;
}
SDL_MouseButtonEvent mouse = e->button;
switch ((uint)mouse.button)
{
case SDL_BUTTON_LEFT:
Mouse.LButtonPressed = isDown;
if (isDown)
{
Mouse.Begin();
Mouse.LDropPosition = Mouse.Position;
Mouse.CancelDoubleClick = false;
uint ticks = SDL_GetTicks();
if (Mouse.LastLeftButtonClickTime + Mouse.MOUSE_DELAY_DOUBLE_CLICK >= ticks)
{
Mouse.LastLeftButtonClickTime = 0;
if (LeftMouseDoubleClick != null && !LeftMouseDoubleClick.Invoke())
{
LeftMouseButtonDown.Raise();
}
else
{
Mouse.LastLeftButtonClickTime = 0xFFFF_FFFF;
}
break;
}
LeftMouseButtonDown.Raise();
Mouse.LastLeftButtonClickTime = Mouse.CancelDoubleClick ? 0 : ticks;
}
else
{
if (Mouse.LastLeftButtonClickTime != 0xFFFF_FFFF)
{
LeftMouseButtonUp.Raise();
}
Mouse.End();
}
break;
case SDL_BUTTON_MIDDLE:
Mouse.MButtonPressed = isDown;
if (isDown)
{
Mouse.Begin();
Mouse.MDropPosition = Mouse.Position;
Mouse.CancelDoubleClick = false;
uint ticks = SDL_GetTicks();
if (Mouse.LastMidButtonClickTime + Mouse.MOUSE_DELAY_DOUBLE_CLICK >= ticks)
{
if (MidMouseDoubleClick != null && !MidMouseDoubleClick.Invoke())
{
MidMouseButtonDown.Raise();
}
Mouse.LastMidButtonClickTime = 0;
break;
}
MidMouseButtonDown.Raise();
Mouse.LastMidButtonClickTime = Mouse.CancelDoubleClick ? 0 : ticks;
}
else
{
MidMouseButtonUp.Raise();
Mouse.End();
}
break;
case SDL_BUTTON_RIGHT:
Mouse.RButtonPressed = isDown;
if (isDown)
{
Mouse.Begin();
Mouse.RDropPosition = Mouse.Position;
Mouse.CancelDoubleClick = false;
uint ticks = SDL_GetTicks();
if (Mouse.LastRightButtonClickTime + Mouse.MOUSE_DELAY_DOUBLE_CLICK >= ticks)
{
Mouse.LastRightButtonClickTime = 0;
if (RightMouseDoubleClick != null && !RightMouseDoubleClick.Invoke())
{
RightMouseButtonDown.Raise();
}
else
{
Mouse.LastRightButtonClickTime = 0xFFFF_FFFF;
}
break;
}
RightMouseButtonDown.Raise();
Mouse.LastRightButtonClickTime = Mouse.CancelDoubleClick ? 0 : ticks;
}
else
{
if (Mouse.LastRightButtonClickTime != 0xFFFF_FFFF)
{
RightMouseButtonUp.Raise();
}
Mouse.End();
}
break;
case SDL_BUTTON_X1:
break;
case SDL_BUTTON_X2:
break;
}
break;
}
//switch (e->type)
//{
// // KEYBOARD
// case SDL_EventType.SDL_KEYDOWN:
// OnKeyDown(new InputKeyboardEvent(KeyboardEvent.Down, e->key.keysym.sym, 0, e->key.keysym.mod));
// break;
// case SDL_EventType.SDL_KEYUP:
// OnKeyUp(new InputKeyboardEvent(KeyboardEvent.Up, e->key.keysym.sym, 0, e->key.keysym.mod));
// break;
// case SDL_EventType.SDL_TEXTINPUT:
// string s = StringHelper.ReadUTF8(e->text.text);
// if (!string.IsNullOrEmpty(s))
// OnTextInput(new InputKeyboardEvent(KeyboardEvent.TextInput, SDL_Keycode.SDLK_UNKNOWN, 0, SDL_Keymod.KMOD_NONE) {KeyChar = s});
// break;
// // MOUSE
// case SDL_EventType.SDL_MOUSEBUTTONDOWN:
// MouseDown.Raise();
// OnMouseDown(new InputMouseEvent(MouseEvent.Down, CovertMouseButton(e->button.button), e->button.clicks, e->button.x, e->button.y, 0, SDL_Keymod.KMOD_NONE));
// break;
// case SDL_EventType.SDL_MOUSEBUTTONUP:
// MouseUp.Raise();
// OnMouseUp(new InputMouseEvent(MouseEvent.Up, CovertMouseButton(e->button.button), e->button.clicks, e->button.x, e->button.y, 0, SDL_Keymod.KMOD_NONE));
// switch (e->button.clicks)
// {
// case 1:
// MouseClick.Raise();
// break;
// case 2:
// MouseDoubleClick.Raise();
// break;
// }
// break;
// case SDL_EventType.SDL_MOUSEMOTION:
// MouseMove.Raise();
// OnMouseMove(new InputMouseEvent(MouseEvent.Move, CovertMouseButton(e->button.button), 0, e->motion.x, e->motion.y, 0, SDL_Keymod.KMOD_NONE));
// break;
// case SDL_EventType.SDL_MOUSEWHEEL:
// OnMouseWheel(new InputMouseEvent(MouseEvent.WheelScroll, MouseButton.Middle, 0, e->wheel.x, e->wheel.y, 0, SDL_Keymod.KMOD_NONE));
// break;
//}
return(1);
}
private void OnKeyUp(Keys key)
{
modifiers.KeyUp(key);
KeyUp?.Invoke(this, new KeyEventArgs(key));
}
public void onKeyUp(KeyUp ku)
{
EKeyUp = ku;
}
/// <summary> /// Function to fire the key up event. /// </summary> /// <param name="key">Key that's pressed.</param> /// <param name="scan">Scan code data.</param> private void OnKeyUp(Keys key, int scan) => KeyUp?.Invoke(this, new GorgonKeyboardEventArgs(key, GetModifiers(), scan));
/// <summary>
/// A callback function which will be called every time a keyboard activity detected.
/// https://docs.microsoft.com/en-us/windows/win32/winmsg/lowlevelkeyboardproc
/// </summary>
/// <param name="code">
/// Specifies whether the hook procedure must process the message.
/// If code is HC_ACTION, the hook procedure must process the message.
/// If code is less than zero, the hook procedure must pass the message to the
/// CallNextHookEx function without further processing and must return the
/// value returned by CallNextHookEx.
/// </param>
/// <param name="wParam">
/// Specifies whether the message was sent by the current thread.
/// If the message was sent by the current thread, it is nonzero; otherwise, it is zero.
/// </param>
/// <param name="lParam">
/// Pointer to a CWPSTRUCT structure that contains details about the message.
/// </param>
/// <returns>
/// If code is less than zero, the hook procedure must return the value returned by CallNextHookEx.
/// If code is greater than or equal to zero, it is highly recommended that you call CallNextHookEx
/// and return the value it returns; otherwise, other applications that have installed WH_CALLWNDPROC
/// hooks will not receive hook notifications and may behave incorrectly as a result. If the hook
/// procedure does not call CallNextHookEx, the return value should be zero.
/// </returns>
private IntPtr KeyboardHookProc(int code, uint wParam, IntPtr lParam)
{
//Indicates if any of the underlaying events set the e.Handled flag.
var handled = false;
//If it was Ok and there are no listeners.
if (code < 0 || KeyDown == null && KeyUp == null && KeyPress == null)
{
return(CallNextHookEx(_keyboardHookHandle, code, wParam, lParam));
}
//Read structure KeyboardHookStruct at lParam
var keyboard = (KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct));
var isInjected = (keyboard.Flags & 0x10) != 0;
if (KeyDown != null && (wParam == MessageKeydown || wParam == MessageSystemKeyDown))
{
#region Raise KeyDown
var isDownShift = (GetKeyState(KeyShift) & 0x80) == 0x80;
var isDownCapslock = GetKeyState(KeyCapital) != 0;
var e = new CustomKeyEventArgs(KeyInterop.KeyFromVirtualKey(keyboard.KeyCode), isDownCapslock ^ isDownShift, isInjected);
KeyDown?.Invoke(this, e);
handled = e.Handled;
#endregion
}
if (KeyPress != null && wParam == MessageKeydown)
{
#region Raise KeyPress
var isDownShift = (GetKeyState(KeyShift) & 0x80) == 0x80;
var isDownCapslock = GetKeyState(KeyCapital) != 0;
var keyState = new byte[256];
GetKeyboardState(keyState);
var inBuffer = new byte[2];
if (ToAscii(keyboard.KeyCode, keyboard.ScanCode, keyState, inBuffer, keyboard.Flags) == 1)
{
var key = (char)inBuffer[0];
if (isDownCapslock ^ isDownShift && char.IsLetter(key))
{
key = char.ToUpper(key);
}
var e = new CustomKeyPressEventArgs(key);
KeyPress?.Invoke(this, e);
handled = handled || e.Handled;
}
#endregion
}
if (KeyUp != null && (wParam == MessageKeyUp || wParam == MessageSystemKeyUp))
{
#region Raise KeyUp
var e = new CustomKeyEventArgs(KeyInterop.KeyFromVirtualKey(keyboard.KeyCode), false, isInjected);
KeyUp?.Invoke(this, e);
handled = handled || e.Handled;
#endregion
}
//If event handled in application do not handoff to other listeners.
return(handled ? new IntPtr(1) : CallNextHookEx(_keyboardHookHandle, code, wParam, lParam));
}
public void PerformKeyUp(KeyboardKeyEventArgs e)
{
KeyUp?.Invoke(e);
FocusedControl?.PerformKeyUp(e);
}
/// <summary>
/// Queues a <see cref="KeyUp"/> event for the passed <see cref="KeyCode"/>.
/// </summary>
/// <param name="key"><see cref="KeyCode"/> of the key that was released.</param>
private void TriggerKeyUp(KeyCode key)
{
KeyUp e = new KeyUp();
e.Key = key.ToString();
QueueEvent(e);
}
private void init(GameWindow game)
{
if (_game != null)
{
return;
}
_game = game;
_originalOSCursor = game.Cursor;
_cursor.PropertyChanged += (sender, e) =>
{
if (_cursor.Cursor != null)
{
_game.Cursor = MouseCursor.Empty;
}
};
game.MouseDown += (sender, e) =>
{
if (isInputBlocked())
{
return;
}
var button = convert(e.Button);
_actions.Enqueue(() => MouseDown.InvokeAsync(new API.MouseButtonEventArgs(_hitTest.ObjectAtMousePosition, button, MousePosition)));
};
game.MouseUp += (sender, e) =>
{
if (isInputBlocked())
{
return;
}
var button = convert(e.Button);
_actions.Enqueue(() => MouseUp.InvokeAsync(new API.MouseButtonEventArgs(_hitTest.ObjectAtMousePosition, button, MousePosition)));
};
game.MouseMove += (sender, e) =>
{
_mouseX = e.Mouse.X;
_mouseY = e.Mouse.Y;
_actions.Enqueue(() => MouseMove.InvokeAsync(new MousePositionEventArgs(MousePosition)));
};
game.KeyDown += (sender, e) =>
{
API.Key key = convert(e.Key);
_keysDown.Add(key);
if (isInputBlocked())
{
return;
}
_actions.Enqueue(() => KeyDown.InvokeAsync(new KeyboardEventArgs(key)));
};
game.KeyUp += (sender, e) =>
{
API.Key key = convert(e.Key);
_keysDown.Remove(key);
if (isInputBlocked())
{
return;
}
_actions.Enqueue(() => KeyUp.InvokeAsync(new KeyboardEventArgs(key)));
};
_events.OnRepeatedlyExecuteAlways.Subscribe(onRepeatedlyExecute);
}
private void KeyboardDevice_KeyUp(object sender, OpenTK.Input.KeyboardKeyEventArgs e)
{
KeyUp?.Invoke(this, new KeyEventArgs(KeyboardState.Empty, Keys.A, ' '));
}
private static IntPtr HookProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
{
IntPtr returnCode = CallWindowProc(prevWndProc, hWnd, msg, wParam, lParam);
switch (msg)
{
case WM_GETDLGCODE:
returnCode = (IntPtr)DLGC_WANTALLKEYS;
break;
case WM_CHAR:
CharEntered?.Invoke(null, new CharacterEventArgs((char)wParam, (int)lParam));
break;
case WM_KEYDOWN:
KeyDown?.Invoke(null, new KeyEventArgs((Keys)wParam));
break;
case WM_KEYUP:
KeyUp?.Invoke(null, new KeyEventArgs((Keys)wParam));
break;
case WM_LBUTTONDOWN:
MouseSelection.left = (int)lParam & 0xffff;
MouseSelection.top = (int)lParam >> 16;
MouseSelection.right = MouseSelection.left;
MouseSelection.bottom = MouseSelection.top;
if (Game1.keyboardDispatcher.Subscriber is ITextBox)
{
ITextBox textBox = Game1.keyboardDispatcher.Subscriber as ITextBox;
Acp acp = textBox.GetAcpByRange(MouseSelection);
if (acp.Start >= 0)
{
textBox.SetSelection(acp.Start, acp.End);
Selecting = true;
}
}
break;
case WM_MOUSEMOVE:
MouseSelection.right = (int)lParam & 0xffff;
MouseSelection.bottom = (int)lParam >> 16;
if (Selecting && Game1.keyboardDispatcher.Subscriber is ITextBox)
{
RECT range = new RECT
{
left = Math.Min(MouseSelection.left, MouseSelection.right),
top = Math.Max(MouseSelection.top, MouseSelection.bottom),
right = Math.Max(MouseSelection.left, MouseSelection.right),
bottom = Math.Min(MouseSelection.top, MouseSelection.bottom)
};
ITextBox textBox = Game1.keyboardDispatcher.Subscriber as ITextBox;
Acp acp = textBox.GetAcpByRange(range);
if (acp.Start >= 0)
{
textBox.SetSelection(acp.Start, acp.End);
textBox.SetSelState(MouseSelection.left > MouseSelection.right ? SelState.SEL_AE_END : SelState.SEL_AE_START);
}
}
break;
case WM_LBUTTONUP:
Selecting = false;
break;
default:
break;
}
return(returnCode);
}
/// <inheritdoc cref="KeyUp" /> private void ControlOnKeyUp(object sender, System.Windows.Forms.KeyEventArgs args) => KeyUp?.Invoke(sender, new KeyEventArgs(args));
private void EditOnKeyUp(object sender, KeyEventArgs e)
{
KeyUp?.Invoke(sender, e);
}
