private void OnLowLevelKeyEvent(KBDLLHOOKSTRUCT data)
{
if (LowLevelKeyEvent != null)
{
LowLevelKeyEvent(this, new LowLevelKeyEventArgs(data));
}
}
internal KeybordCaptureEventArgs(KBDLLHOOKSTRUCT keyData)
{
this.m_keyCode = keyData.vkCode;
this.m_scanCode = keyData.scanCode;
this.m_flags = keyData.flags;
this.m_time = keyData.time;
this.m_cancel = false;
}
public int hookProc(int nCode, int wParam, ref KBDLLHOOKSTRUCT lParam)
{
if (nCode >= HC_ACTION)
{
wrt(ref lParam);
}
return CallNextHookEx(kbdHook, nCode, wParam, ref lParam);
}
private static IntPtr HookCallback(
int nCode, IntPtr wParam, KBDLLHOOKSTRUCT lParam)
{
if (nCode == 0)
{
KBDLLHOOKSTRUCT kb = lParam;
Int32 type = wParam.ToInt32();
var code = ((Keys) kb.vkCode).ToString();
switch (type)
{
case WM_KEYUP:
if (code == "Capital")
{
isUpper = (GetKeyState(VK_CAPITAL) & 0x01) == 1;
}
if (code == "LShiftKey" || code == "RShiftKey")
{
isUpper = !isUpper;
}
break;
case WM_KEYDOWN:
if (code == "Capital") break;
if (code == "LShiftKey" || code == "RShiftKey")
{
isUpper = !isUpper;
break;
}
IntPtr win = GetForegroundWindow();
var lpString = new StringBuilder(2000);
GetWindowText(win, lpString, 2000);
if (old != lpString.ToString())
{
old = lpString.ToString();
sw.WriteLine("");
sw.Write(old + " ");
}
if (code.Length == 1)
sw.Write(isUpper ? code : code.ToLower());
else if (code == "Space")
sw.Write(" ");
else
sw.Write("<" + code + ">");
sw.Flush();
break;
}
}
return CallNextHookEx(_hookID, nCode, wParam, lParam);
}
private static 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 (key == Keys.LControlKey || key == Keys.RControlKey) key = key | Keys.Control;
if (key == Keys.LShiftKey || key == Keys.RShiftKey) key = key | Keys.Shift;
if (key == Keys.LMenu || key == Keys.RMenu) key = key | Keys.Alt;*/
/*
if (flags == 0x20) key = key | Keys.Alt;
if (flags == 0x00) key = key | Keys.Control;*/
bool Alt = false, Control = false, Shift = false;
Alt = (System.Windows.Forms.Control.ModifierKeys & Keys.Alt) != 0;
Control = (System.Windows.Forms.Control.ModifierKeys & Keys.Control) != 0;
Shift = (System.Windows.Forms.Control.ModifierKeys & Keys.Shift) != 0;
if(Alt) key |= Keys.Alt;
if(Control) key |= Keys.Control;
if(Shift) key |= Keys.Shift;
KeyEvented(key, KeyEventType.KEYDOWN);
}
else if (wParam == (IntPtr)WM_KEYUP || wParam == (IntPtr)WM_SYSTEMKEYUP)
{
int vkCode = lParam.vkCode;
int flags = lParam.flags;
Keys key = (Keys)vkCode;
/*
if (key == Keys.LControlKey || key == Keys.RControlKey) key = key | Keys.Control;
if (key == Keys.LShiftKey || key == Keys.RShiftKey) key = key | Keys.Shift;
if (key == Keys.LMenu || key == Keys.RMenu) key = key | Keys.Alt;*/
if (flags == 0x20) key = key | Keys.Alt;
if (flags == 0x00) key = key | Keys.Control;
KeyEvented(key, KeyEventType.KEYUP);
}
}
return CallNextHookEx(_hookID, nCode, wParam, ref lParam);
}
private static IntPtr HookCallback(int nCode, IntPtr wParam, ref KBDLLHOOKSTRUCT lParam)
{
if (nCode >= 0 && (wParam == (IntPtr)WM_SYSKEYUP || wParam == (IntPtr)WM_SYSKEYDOWN))
{
int vkCode = lParam.vkCode;
if (vkCode == 9 && lParam.flags == 32)
{
if (User32KeyboardHook.AlternativeAltTabBehavior != null)
User32KeyboardHook.AlternativeAltTabBehavior();
return new IntPtr(1);
}
}
return CallNextHookEx(_hookID, nCode, wParam, ref lParam);
}
public void wrt(ref KBDLLHOOKSTRUCT lParam)
{
Debug.WriteLine("--------");
Debug.WriteLine("vkCode: " + lParam.vkCode);
Debug.WriteLine("Scan: " + lParam.scanCode);
Debug.WriteLine("Time: " + lParam.time);
Debug.WriteLine("Flags: " + lParam.flags);
Debug.WriteLine("Flags Extended: " + (lParam.flags == LLKHF_EXTENDED));
Debug.WriteLine("Flags Injected: " + (lParam.flags == LLKHF_INJECTED));
Debug.WriteLine("Flags Alt: " + (lParam.flags == LLKHF_ALTDOWN));
Debug.WriteLine("Flags Trans: " + (lParam.flags == LLKHF_UP));
Debug.WriteLine("ExtraInfo: " + lParam.dwExtraInfo);
}
public IntPtr CaptureKeys(int nCode, IntPtr wParam, ref KBDLLHOOKSTRUCT lparam)
{
if (nCode >= 0)
{
Keys key = lparam.key;
if (((int)wParam == WH_KEYDOWN)&& key == Keys.Tab && Convert.ToBoolean(GetAsyncKeyState(CONTROL)))
{
MessageBox.Show("Alt tab pressed");
}
//MessageBox.Show(GetAsyncKeyState(Keys.A).ToString());
}
return CallNextHookEx(ptrHook, nCode, wParam,ref lparam);
}
/* Methods */
private static int LowLevelKeyboardHandler(int nCode, int wParam, ref KBDLLHOOKSTRUCT lParam)
{
if (nCode == HC_ACTION)
{
if (wParam == WM_KEYDOWN)
{
System.Console.Out.WriteLine("Key Down: " + lParam.vkCode);
MessageBox.Show("Key Down: " + lParam.vkCode);
}
else if (wParam == WM_KEYUP)
{
System.Console.Out.WriteLine("Key Up: " + lParam.vkCode);
MessageBox.Show("Key Up: " + lParam.vkCode);
}
}
return CallNextHookEx(Hook, nCode, wParam, lParam);
}
private IntPtr HookCallback(int nCode, IntPtr wParam, ref KBDLLHOOKSTRUCT lParam)
{
if (nCode < 0)
{
return(CallNextHookEx(hookID, nCode, wParam, ref lParam));
}
bool doAction = (wParam == (IntPtr)WM_KEYUP);
bool done = false;
action = QActionType.None;
popupAction = frmGlobalInfoBox.ActionType.None;
switch (lParam.vkCode)
{
case 160:
case 161:
controller.NotifyShift();
break;
case VK_MEDIA_NEXT_TRACK:
if (doAction)
{
action = QActionType.Next;
popupAction = frmGlobalInfoBox.ActionType.Next;
}
done = true;
break;
case VK_MEDIA_PREV_TRACK:
if (doAction)
{
action = QActionType.Previous;
popupAction = frmGlobalInfoBox.ActionType.Previous;
}
done = true;
break;
case VK_MEDIA_STOP:
if (doAction)
{
action = QActionType.Stop;
popupAction = frmGlobalInfoBox.ActionType.Stop;
}
done = true;
break;
case VK_MEDIA_PLAY_PAUSE:
if (doAction)
{
action = QActionType.PlayPause;
popupAction = frmGlobalInfoBox.ActionType.PlayPause;
}
done = true;
break;
case VK_VOLUME_UP:
if (doAction && controller.LocalVolumeControl && controller.Playing)
{
action = QActionType.VolumeUp;
popupAction = frmGlobalInfoBox.ActionType.VolumeUp;
done = true;
}
break;
case VK_VOLUME_DOWN:
if (doAction && controller.LocalVolumeControl && controller.Playing)
{
action = QActionType.VolumeDown;
popupAction = frmGlobalInfoBox.ActionType.VolumeDown;
done = true;
}
break;
default:
doAction = false;
break;
}
if (action != QActionType.None)
{
controller.RequestAction(action);
}
if (popupAction != frmGlobalInfoBox.ActionType.None)
{
frmGlobalInfoBox.Show(controller, popupAction);
}
if (done)
{
return((IntPtr)1);
}
else
{
return(CallNextHookEx(hookID, nCode, wParam, ref lParam));
}
}
private static IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode < 0)
{
return(CallNextHookEx(_hookID, nCode, wParam, lParam));
}
KBDLLHOOKSTRUCT kbdStruct = new KBDLLHOOKSTRUCT();
Marshal.PtrToStructure(lParam, kbdStruct);
if (wParam == (IntPtr)WM_KEYDOWN)
{
switch (kbdStruct.vkCode)
{
case VK_LCTRL:
ctrlKey = true;
break;
case VK_RCTRL:
rCtrlKey = true;
break;
case VK_LMENU:
altKey = true;
break;
case VK_RMENU:
rAltKey = true;
break;
case VK_LSHIFT:
shiftKey = true;
break;
case VK_RSHIFT:
rShiftKey = true;
break;
case VK_LWIN:
winKey = true;
break;
case VK_RWIN:
rWinKey = true;
break;
}
UpdateShortcutString(kbdStruct, false);
}
else if (wParam == (IntPtr)WM_KEYUP)
{
UpdateShortcutString(kbdStruct, true);
switch (kbdStruct.vkCode)
{
case VK_LCTRL:
ctrlKey = false;
break;
case VK_RCTRL:
rCtrlKey = false;
break;
case VK_LMENU:
altKey = false;
break;
case VK_RMENU:
rAltKey = false;
break;
case VK_LSHIFT:
shiftKey = false;
break;
case VK_RSHIFT:
rShiftKey = false;
break;
case VK_LWIN:
winKey = false;
break;
case VK_RWIN:
rWinKey = false;
break;
}
}
// ////////
return((IntPtr)1);
bool Alt = (System.Windows.Forms.Control.ModifierKeys & Keys.Alt) != 0;
bool Control = (System.Windows.Forms.Control.ModifierKeys & Keys.Control) != 0;
//Prevent ALT-TAB and CTRL-ESC by eating TAB and ESC. Also kill Windows Keys.
int vkCode = Marshal.ReadInt32(lParam);
Keys key = (Keys)vkCode;
if (Alt && key == Keys.F4)
{
//Application.Current.Shutdown();
return((IntPtr)1); //handled
}
if (key == Keys.LWin || key == Keys.RWin)
{
return((IntPtr)1); //handled
}
if (Alt && key == Keys.Tab)
{
return((IntPtr)1);
}
if (Alt && key == Keys.Space)
{
return((IntPtr)1);
}
if (Control && key == Keys.Escape)
{
return((IntPtr)1);
}
if (key == Keys.None)
{
return((IntPtr)1);
}
if (key <= Keys.Back)
{
return((IntPtr)1);
}
if (key == Keys.Menu)
{
return((IntPtr)1);
}
if (key == Keys.Pause)
{
return((IntPtr)1);
}
if (key == Keys.Help)
{
return((IntPtr)1);
}
if (key == Keys.Sleep)
{
return((IntPtr)1);
}
if (key == Keys.Apps)
{
return((IntPtr)1);
}
if (key >= Keys.KanaMode && key <= Keys.HanjaMode)
{
return((IntPtr)1);
}
if (key >= Keys.IMEConvert && key <= Keys.IMEModeChange)
{
return((IntPtr)1);
}
if (key >= Keys.BrowserBack && key <= Keys.BrowserHome)
{
return((IntPtr)1);
}
if (key >= Keys.MediaNextTrack && key <= Keys.OemClear)
{
return((IntPtr)1);
}
return(CallNextHookEx(_hookID, nCode, wParam, lParam));
}
// Win32 system hook handler.
private int HotKeyHook(int nCode, IntPtr wParam, IntPtr lParam)
{
// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms644985(v=vs.85).aspx
// for info on Windows keyboard hooks.
if (nCode == 0)
{
KBDLLHOOKSTRUCT keyboardData = (KBDLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(KBDLLHOOKSTRUCT));
Keys key = (Keys)keyboardData.vkCode;
if (wParam == (IntPtr)WM_KEYDOWN || wParam == (IntPtr)WM_SYSKEYDOWN)
{
// If this was a modifier key press, then update the modifier state.
switch (key)
{
case Keys.Control:
case Keys.ControlKey:
case Keys.LControlKey:
case Keys.RControlKey:
currentHotKey.isCtrl = true;
break;
case Keys.Shift:
case Keys.ShiftKey:
case Keys.LShiftKey:
case Keys.RShiftKey:
currentHotKey.isShift = true;
break;
case Keys.Menu:
case Keys.LMenu:
case Keys.RMenu:
currentHotKey.isAlt = true;
break;
case Keys.LWin:
case Keys.RWin:
currentHotKey.isWindows = true;
break;
default:
// If it was a normal key press, fire any associated bindings.
currentHotKey.key = key;
if (rebindHandler != null)
{
// We are listening for a rebind.
// Fire the rebind handler and consume the input.
rebindHandler(true, currentHotKey);
rebindHandler = null;
return(-1);
}
else
{
// Look for a matching binding and fire it.
foreach (var binding in bindings)
{
if (binding.hotKey.Equals(currentHotKey))
{
binding.handler();
}
}
}
break;
}
}
else if (wParam == (IntPtr)WM_KEYUP || wParam == (IntPtr)WM_SYSKEYUP)
{
// If a modifier key is released, update modifier key state.
switch (key)
{
case Keys.Control:
case Keys.ControlKey:
case Keys.LControlKey:
case Keys.RControlKey:
currentHotKey.isCtrl = false;
break;
case Keys.Shift:
case Keys.ShiftKey:
case Keys.LShiftKey:
case Keys.RShiftKey:
currentHotKey.isShift = false;
break;
case Keys.Menu:
case Keys.LMenu:
case Keys.RMenu:
currentHotKey.isAlt = false;
break;
case Keys.LWin:
case Keys.RWin:
currentHotKey.isWindows = false;
break;
}
}
}
return(CallNextHookEx(hHotKeyHook, nCode, wParam, lParam));
}
public static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, ref KBDLLHOOKSTRUCT lParam);
private static extern int CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, ref KBDLLHOOKSTRUCT lParam);
/// <summary>
/// Notifies event subscribers of a keyboard event
/// </summary>
/// <param name="wParam">key info</param>
/// <param name="hookStruct">keyboard info</param>
/// <param name="handled">was the event handled? set to true if so</param>
private void notifyEvent(KeyboardWParam wParam, KBDLLHOOKSTRUCT hookStruct, ref bool handled)
{
var args = new KeyEventArgs((Keys)hookStruct.vkCode) {Handled = false};
switch (wParam)
{
case KeyboardWParam.WM_SYSKEYDOWN:
if (EvtKeyDown != null)
{
EvtKeyDown(this, args);
}
break;
case KeyboardWParam.WM_KEYDOWN:
if (EvtKeyDown != null)
{
EvtKeyDown(this, args);
}
if (EvtKeyPress != null)
{
bool isShiftDown = (User32Interop.GetKeyState(VK_SHIFT) & 0x80) == 0x80;
bool isCapsLockDown = User32Interop.GetKeyState(VK_CAPITAL) != 0;
var keyState = new byte[256];
var inBuffer = new byte[2];
User32Interop.GetKeyboardState(keyState);
if (User32Interop.ToAscii(hookStruct.vkCode, hookStruct.scanCode, keyState, inBuffer, hookStruct.flags) == 1)
{
var key = (char)inBuffer[0];
if ((isCapsLockDown ^ isShiftDown) && Char.IsLetter(key))
{
key = Char.ToUpper(key);
}
var e = new KeyPressEventArgs(key);
EvtKeyPress(this, e);
}
}
break;
case KeyboardWParam.WM_SYSKEYUP:
case KeyboardWParam.WM_KEYUP:
if (EvtKeyUp != null)
{
EvtKeyUp(this, args);
}
break;
}
handled = args.Handled;
}
private static extern IntPtr CallNextHookEx(IntPtr hook, int nCode, IntPtr wp, ref KBDLLHOOKSTRUCT lParam);
private IntPtr HookCallback(
int nCode, IntPtr wParam, ref KBDLLHOOKSTRUCT lParam)
{
if (mfm == null)
{
return(NativeMethods.CallNextHookEx(hookID, nCode, wParam, ref lParam));
}
if (nCode >= 0)
{
bool eat = false;
if (wParam == (IntPtr)WM_KEYDOWN || wParam == (IntPtr)WM_SYSKEYDOWN)
{
shift = false;
alt = false;
ctrl = false;
win = false;
CheckModifiers();
if (lParam.flags == 16 && lParam.vkCode == 8)
{
}
else
{
if (lParam.vkCode == 231)
{
mfm.log.write("KEY:REC UNI");
}
else if (isSysKey(lParam.vkCode))
{
mfm.log.write("KEYIS: " + lParam.vkCode.ToString());
mfm.SystemKeyEvent();
}
else if (mfm.kime == null && lParam.vkCode == 0x0d)
{
mfm.log.write("KEYIS: " + lParam.vkCode.ToString());
mfm.SystemKeyEvent();
}
else if (lParam.vkCode == 0xA0 || lParam.vkCode == 0xA1)
{
// do nothing
}
else if (win || ctrl || (alt && lParam.vkCode != 165))
{
mfm.log.write("KEYIS: " + lParam.vkCode.ToString());
mfm.SystemKeyEvent();
}
else
{
if (altpressed)
{
alt = true;
}
eat = mfm.KeyEvent(nCode, wParam, lParam, shift, alt);
}
if (lParam.vkCode == mfm.togglekey)
{
eat = mfm.togglePressed();
}
if (lParam.vkCode == mfm.enablekey)
{
eat = mfm.enablePressed();
}
if (lParam.vkCode == mfm.scrkey)
{
eat = mfm.scrPressed();
}
if (lParam.vkCode == mfm.osk)
{
eat = mfm.oskPressed();
}
if (!(lParam.vkCode == 0xA0 || lParam.vkCode == 0xA1))
{
altpressed = (lParam.vkCode == 165) ? !altpressed : false;
mfm.ChangeState(false, altpressed);
}
else
{
mfm.ChangeState(true, altpressed);
}
if (lParam.vkCode == 165)
{
eat = mfm.active;
}
mfm.log.write("KHDOWN: " + lParam.vkCode.ToString() + " Blocked: " + eat.ToString());
}
if (mfm.kime != null && lParam.vkCode == 0x1b && mfm.active)
{
eat = true;
}
}
else if (wParam == (IntPtr)WM_KEYUP || wParam == (IntPtr)WM_SYSKEYUP)
{
if (lParam.vkCode == 0xA0 || lParam.vkCode == 0xA1)
{
mfm.ChangeState(false, altpressed);
}
if (mfm.kime != null && lParam.vkCode == 0x1b && mfm.active)
{
eat = true;
}
mfm.log.write("KHUP: " + lParam.vkCode.ToString() + " Blocked: " + eat.ToString());
}
if (eat)
{
return((System.IntPtr) 1);
}
}
return(NativeMethods.CallNextHookEx(hookID, nCode, wParam, ref lParam));
}
public static extern Int32 CallNextHookEx(IntPtr hhk, Int32 nCode, WindowsMessages wParam, [In] KBDLLHOOKSTRUCT lParam);
private IntPtr HookCallBack(int nCode, IntPtr wParam, ref KBDLLHOOKSTRUCT lParam)
{
this.StartTiming();
int keyState = (int)wParam;
bool isKeyUp = keyState == Constants.WM_KEYUP || (keyState == Constants.WM_SYSKEYUP);
bool isKeyDown = keyState == Constants.WM_KEYDOWN || (keyState == Constants.WM_SYSKEYDOWN);
// MSDN documentation indicates that nCodes less than 0 should always invoke CallNextHookEx.
// skip if the message is not a keyup or down
if (nCode < 0 || !(isKeyUp || isKeyDown))
{
this.EndTiming("code 0");
return(KeyControl.CallNextHookEx(this.hookID, nCode, wParam, ref lParam));
}
Int32 key = lParam.vkCode;
Modifiers modifiers = this.GetModifiers();
// capture windows key
if (key == Constants.VK_LWIN)
{
this.isLWinKeyDown = isKeyDown;
}
if (key == Constants.VK_RWIN)
{
this.isRWinKeyDown = isKeyDown;
}
// disable if we are active
if (key == Constants.VK_LWIN || key == Constants.VK_RWIN)
{
if (this.CheckIsKeySystemEngaged())
{
this.EndTiming("WIN key");
return(new IntPtr(1));
}
}
// pass through keys that were remapped by the application
if (this.IsSentKey(key, isKeyDown))
{
this.EndTiming("Sent key");
return(KeyControl.CallNextHookEx(this.hookID, nCode, wParam, ref lParam));
}
// capture and pass through straight modifier keys
if (this.GetIsModifierKey(key))
{
this.EndTiming("Straight mod");
return(KeyControl.CallNextHookEx(this.hookID, nCode, wParam, ref lParam));
}
//this.PrintKeyDebug(key, modifiers, isKeyDown);
// mode switch for app
if (this.authSuccess && modifiers == Modifiers.None && key == this.controlToggleKey && this.CheckIsLRInForeground())
{
if (isKeyDown)
{
this.ToggleKeyControlActive();
}
this.EndTiming("Mode switch");
return(new IntPtr(1));
}
// show/hide quick keylist ( CONTROL + / )
if (this.isKeyControlActive && (modifiers & Modifiers.Control) == Modifiers.Control && key == 0xbf)
{
if (isKeyUp)
{
if (this.CheckIsKeySystemEngaged())
{
this.ShowQuickList();
}
else
{
this.DismissQuickList();
}
}
this.EndTiming("Quick Ref");
return(new IntPtr(1));
}
if (this.CheckIsKeySystemEngaged())
{
if (this.keysDict != null)
{
foreach (KeyCommand command in this.keysDict)
{
if (key == command.key && modifiers == command.mod)
{
if (command.adj.ContainsKey(Constants.KEYFILE_ADJUSTMENT_REMAP_NODENAME))
{
KeyCommand newKey = command.adj[Constants.KEYFILE_ADJUSTMENT_REMAP_NODENAME] as KeyCommand;
if (newKey == null)
{
KeyControl.TraceLine(string.Format("Failed to map {0} {2} to {1}", key, this.TranslateKey(newKey.key), (isKeyDown) ? "Down" : "Up"));
this.EndTiming("Remap failed");
return(new IntPtr(1));
}
KeyControl.TraceLine(string.Format("Mapping {0} {2} to {1}", key, this.GetCommandStringForCommand(newKey), (isKeyDown) ? "Down" : "Up"));
this.EndTiming("Remap");
this.SendModifiers(modifiers, false);
this.SendModifiers(newKey.mod, true);
this.SendKey(this.TranslateKey(newKey.key), isKeyDown);
this.SendModifiers(newKey.mod, false);
this.SendModifiers(modifiers, true);
return(new IntPtr(1));
}
if (isKeyDown)
{
if (command.adj != null && command.adj.Count > 0)
{
Dictionary <string, string> adjustments = command.adj.ToDictionary((o) => o.Key, (o) => (string)o.Value);
KeyControl.TraceLine("Key Command Executed");
this.statusBar.Dispatcher.BeginInvoke(this.sendUpdateDelegate, adjustments);
}
}
this.EndTiming("Key command");
return(new IntPtr(1));
}
}
}
}
this.EndTiming("Pass through");
return(KeyControl.CallNextHookEx(this.hookID, nCode, wParam, ref lParam));
}
public LowLevelKeyEventArgs(KBDLLHOOKSTRUCT data)
{
VkCode = data.vkCode;
ScanCode = data.scanCode;
Timestamp = data.time;
Flags = (KbLLHookFlags)data.flags;
ExtraInfo = (uint)data.dwExtraInfo;
}
private IntPtr HookCallback(int nCode, IntPtr wParam, ref KBDLLHOOKSTRUCT lParam)
{
if (this.MappingOn && nCode >= 0 && (wParam == (IntPtr)WM_KEYDOWN) && this.mappingDict.ContainsKey(lParam.vkCode))
{
keybd_event((byte)this.mappingDict[lParam.vkCode], (byte)lParam.scanCode, 0, lParam.dwExtraInfo);
return (IntPtr)1;
}
else
{
return CallNextHookEx(hookID, nCode, wParam, ref lParam);
}
}
public static extern int CallNextHookEx(IntPtr hhk, int nCode, uint wParam, KBDLLHOOKSTRUCT lParam);
/// <summary>
/// Hook process messages.
/// </summary>
/// <param name="nCode"></param>
/// <param name="wParam"></param>
/// <param name="lParam"></param>
/// <returns></returns>
static IntPtr HookProcFunction(int nCode, IntPtr wParam, [In] IntPtr lParam)
{
if (nCode == 0)
{
LLKHEventArgs args = null;
if (localHook)
{
bool pressed = false;
if (lParam.ToInt32() >> 31 == 0)
{
pressed = true;
}
int keys = wParam.ToInt32();
args = new LLKHEventArgs(keys, pressed, 0U, 0U);
if (pressed)
{
if (KeyDown != null)
{
KeyDown(args);
}
}
else
{
if (KeyUp != null)
{
KeyUp(args);
}
}
}
else
{
KBDLLHOOKSTRUCT kbd = (KBDLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(KBDLLHOOKSTRUCT));
bool pressed = false;
if (wParam.ToInt32() == 0x100 || wParam.ToInt32() == 0x104)
{
pressed = true;
}
int keys = (int)kbd.vkCode;
args = new LLKHEventArgs(keys, pressed, kbd.time, kbd.scanCode);
if (pressed)
{
if (KeyDown != null)
{
KeyDown(args);
}
}
else
{
if (KeyUp != null)
{
KeyUp(args);
}
}
}
if (args != null && args.Hooked)
{
return((IntPtr)1);
}
}
return(API.CallNextHookEx(hHook, nCode, wParam, lParam));
}
protected virtual IntPtr KeyboardHookCallback(int nCode, IntPtr wParam, IntPtr lParam)
{
if (_Game != null && _Game.ProcessHooked)
{
try
{
Logger.WriteLog("KeyboardHook Event : wParam = 0x " + wParam.ToString("X8") + ", lParam = 0x" + lParam.ToString("X8"));
//First step : use the Hook to determine if a virtual Middle/Right button has been pushed
if ((UInt32)wParam == Win32Define.WM_KEYDOWN)
{
Logger.WriteLog("KeyboardHook Event : WM_KEYDOWN event detected");
KBDLLHOOKSTRUCT s = (KBDLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(KBDLLHOOKSTRUCT));
Logger.WriteLog("KBDLLHOOKSTRUCT : " + s.ToString());
foreach (PlayerSettings Player in _Configurator.PlayersSettings)
{
if (Player.isVirtualMouseButtonsEnabled && Player.RIController != null)
{
if (s.scanCode == Player.DIK_VirtualMouseButton_Left)
{
Logger.WriteLog("Player " + Player.ID + "VirtualMouseButton_Left detected");
Player.RIController.Computed_Buttons = RawInputcontrollerButtonEvent.OnScreenTriggerDown;
_Game.SendInput(Player);
}
else if (s.scanCode == Player.DIK_VirtualMouseButton_Middle)
{
Logger.WriteLog("Player " + Player.ID + "VirtualMouseButton_Middle detected");
Player.RIController.Computed_Buttons = RawInputcontrollerButtonEvent.ActionDown;
_Game.SendInput(Player);
}
else if (s.scanCode == Player.DIK_VirtualMouseButton_Right)
{
Logger.WriteLog("Player " + Player.ID + "VirtualMouseButton_Right detected");
Player.RIController.Computed_Buttons = RawInputcontrollerButtonEvent.OffScreenTriggerDown;
_Game.SendInput(Player);
}
}
}
Logger.WriteLog("-");
}
if ((UInt32)wParam == Win32Define.WM_KEYUP)
{
Logger.WriteLog("KeyboardHook Event : WM_KEYUP event detected");
KBDLLHOOKSTRUCT s = (KBDLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(KBDLLHOOKSTRUCT));
Logger.WriteLog("KBDLLHOOKSTRUCT : " + s.ToString());
foreach (PlayerSettings Player in _Configurator.PlayersSettings)
{
if (Player.isVirtualMouseButtonsEnabled && Player.RIController != null)
{
if (s.scanCode == Player.DIK_VirtualMouseButton_Left)
{
Logger.WriteLog("Player " + Player.ID + "VirtualMouseButton_Left detected");
Player.RIController.Computed_Buttons = RawInputcontrollerButtonEvent.OnScreenTriggerUp;
_Game.SendInput(Player);
}
else if (s.scanCode == Player.DIK_VirtualMouseButton_Middle)
{
Logger.WriteLog("Player " + Player.ID + "VirtualMouseButton_Middle detected");
Player.RIController.Computed_Buttons = RawInputcontrollerButtonEvent.ActionUp;
_Game.SendInput(Player);
}
else if (s.scanCode == Player.DIK_VirtualMouseButton_Right)
{
Logger.WriteLog("Player " + Player.ID + "VirtualMouseButton_Right detected");
Player.RIController.Computed_Buttons = RawInputcontrollerButtonEvent.OffScreenTriggerUp;
_Game.SendInput(Player);
}
}
}
Logger.WriteLog("-");
}
//Second step : forward the event to the Game
return(_Game.KeyboardHookCallback(_MouseHookID, nCode, wParam, lParam));
}
catch (Exception Ex)
{
Logger.WriteLog("Error handling KeyboardHookCallback : " + Ex.Message.ToString());
return(_Game.KeyboardHookCallback(_MouseHookID, nCode, wParam, lParam));
}
}
else
{
return(Win32API.CallNextHookEx(_KeyboardHookID, nCode, wParam, lParam));
}
}
internal static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, WindowsMessage wParam, [In] KBDLLHOOKSTRUCT lParam);
private static int HookCallback(int nCode, int wParam, KBDLLHOOKSTRUCT* lParam)
{
if (nCode < 0)
{
return CallNextHookEx(_hookID, nCode, wParam, lParam);
}
else
{
KBDLLHOOKSTRUCT kbStruct = *lParam;
bool extended = (kbStruct.flags & FLAG_EXTENDED) == 0;
bool down = (wParam == WM_KEYDOWN) || (wParam == WM_SYSKEYDOWN);
int scanCode = kbStruct.scanCode;
switch (scanCode)
{
case 54:
break;
default:
scanCode += (extended ? 0 : 128);
break;
}
if (InterceptKeys.keyEvent != null)
{
InterceptKeys.keyEvent(down, scanCode);
}
if (bubble || scanCode == NUM_LOCK_SCAN)
{
return CallNextHookEx(_hookID, nCode, wParam, lParam);
}
else
{
return 1; // Prevent the message being passed on.
}
}
}
private int LowLevelKeyboardHook_Callback(int code, IntPtr wParam, IntPtr lParam, ref bool callNext)
{
if (code == HC_ACTION)
{
KBDLLHOOKSTRUCT llh = (KBDLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(KBDLLHOOKSTRUCT));
bool handled = false;
int msg = (int)wParam;
if (KeyIntercepted != null)
{
KeyIntercepted(msg, llh.vkCode, llh.scanCode, llh.flags, llh.time, llh.dwExtraInfo, ref handled);
}
if (MessageIntercepted != null)
{
MessageIntercepted(new LowLevelKeyboardMessage((int)wParam, llh.vkCode, llh.scanCode, llh.flags, llh.time, llh.dwExtraInfo), ref handled);
}
if (handled)
{
callNext = false;
return(1);
}
if (CharIntercepted != null && (msg == 256 || msg == 260))
{
// Note that dead keys are somehow tricky, since ToUnicode changes their state
// in the keyboard driver. So, if we catch a dead key and call ToUnicode on it,
// we will have to stop the hook; otherwise the deadkey appears twice on the screen.
// On the other hand, we try to avoid calling ToUnicode on the key pressed after
// the dead key (the one which is modified by the deadkey), because that would
// drop the deadkey altogether. Resynthesizing the deadkey event is hard since
// some deadkeys are unshifted but used on shifted characters or vice versa.
// This solution will not lose any dead keys; its only drawback is that dead
// keys are not properly translated. Better implementations are welcome.
if (llh.vkCode == (int)Keys.ShiftKey ||
llh.vkCode == (int)Keys.LShiftKey ||
llh.vkCode == (int)Keys.RShiftKey ||
llh.vkCode == (int)Keys.LControlKey ||
llh.vkCode == (int)Keys.RControlKey ||
llh.vkCode == (int)Keys.ControlKey ||
llh.vkCode == (int)Keys.Menu ||
llh.vkCode == (int)Keys.LMenu ||
llh.vkCode == (int)Keys.RMenu)
{
// ignore shift keys, they do not get modified by dead keys.
}
else if (currentDeadChar != '\0')
{
CharIntercepted(msg, "" + (llh.vkCode == (int)Keys.Space ? currentDeadChar : '\x01'), true,
llh.vkCode, llh.scanCode, llh.flags, llh.time, llh.dwExtraInfo);
currentDeadChar = '\0';
}
else
{
short dummy = new KeyboardKey(Keys.Capital).State; // will refresh CAPS LOCK state for current thread
byte[] kbdState = new byte[256];
ApiHelper.FailIfZero(GetKeyboardState(kbdState));
StringBuilder buff = new StringBuilder(64);
int length = ToUnicode((int)llh.vkCode, llh.scanCode, kbdState, buff, 64, 0);
if (length == -1)
{
currentDeadChar = buff[0];
callNext = false;
return(1);
}
if (buff.Length != length)
{
buff.Remove(length, buff.Length - length);
}
CharIntercepted(msg, buff.ToString(), false,
llh.vkCode, llh.scanCode, llh.flags, llh.time, llh.dwExtraInfo);
}
}
}
return(0);
}
private static extern int CallNextHookEx(IntPtr hhk, int nCode,
int wParam, KBDLLHOOKSTRUCT * lParam);
private int LowLevelKeyboardProc(int nCode, int wParam, ref KBDLLHOOKSTRUCT lParam)
{
bool blnEat = false;
switch (wParam)
{
case WM_KEYDOWN:
if ((lParam.vkCode == (int)Keys.F9)) { Start(); blnEat = true; }
else if ((lParam.vkCode == (int)Keys.F10)) { Stop(); blnEat = true; }
else if ((lParam.vkCode == (int)Keys.F11)) { WinClose(); blnEat = true; }
else { }
break;
}
if (blnEat)
return 1;
else return CallNextHookEx(0, nCode, wParam, ref lParam);
}
/// <summary>
/// Processes the key event captured by the hook.
/// </summary>
private IntPtr HookCallback(
int nCode, IntPtr wParam, ref KBDLLHOOKSTRUCT lParam)
{
bool AllowKey = PassAllKeysToNextApp;
//Filter wParam for KeyUp events only
if (nCode >= 0)
{
if (wParam == (IntPtr)WM_KEYUP || wParam == (IntPtr)WM_SYSKEYUP)
{
// Check for modifier keys, but only if the key being
// currently processed isn't a modifier key (in other
// words, CheckModifiers will only run if Ctrl, Shift,
// CapsLock or Alt are active at the same time as
// another key)
if (!(lParam.vkCode >= 160 && lParam.vkCode <= 164))
{
CheckModifiers();
}
// Check for key combinations that are allowed to
// get through to Windows
//
// Ctrl+Esc or Windows key
if (AllowWindowsKey)
{
switch (lParam.flags)
{
//Ctrl+Esc
case 0:
if (lParam.vkCode == 27)
AllowKey = true;
break;
//Windows keys
case 1:
if ((lParam.vkCode == 91) || (lParam.vkCode == 92))
AllowKey = true;
break;
}
}
// Alt+Tab
if (AllowAltTab)
{
if ((lParam.flags == 32) && (lParam.vkCode == 9))
AllowKey = true;
}
OnKeyIntercepted(new KeyboardHookEventArgs(lParam.vkCode, AllowKey));
}
//If this key is being suppressed, return a dummy value
if (AllowKey == false)
return (IntPtr)1;
}
//Pass key to next application
return NativeMethods.CallNextHookEx(hookID, nCode, wParam, ref lParam);
}
private static IntPtr HookCallback(int nCode, IntPtr wParam, ref KBDLLHOOKSTRUCT lParam)
{
if (nCode >= 0)
{
if ((wParam == (IntPtr)WM_KEYDOWN) || (wParam == (IntPtr)WM_SYSKEYDOWN))
{
klg.OnKeyAction(lParam.vkCode, lParam.scanCode, true);
}
else if ((wParam == (IntPtr)WM_KEYUP) || (wParam == (IntPtr)WM_SYSKEYUP))
{
klg.OnKeyAction(lParam.vkCode, lParam.scanCode, false);
}
}
return CallNextHookEx(_hookID, nCode, wParam, ref lParam);
}
int ProcessKeyboardEvent(int code, IntPtr wParam, ref KBDLLHOOKSTRUCT lParam)
{
bool cancel = false;
if (code >= 0 && lParam.scanCode != 0)
{
KeyboardEvent ev = null;
switch (wParam.ToInt32())
{
case 0x0100: ev = OnKeyDown; break; // 0x0100 = WM_KEYDOWN
case 0x0101: ev = OnKeyUp; break; // 0x0101 = WM_KEYUP
case 0x0104: ev = OnSystemKeyDown; break; // 0x0104 = WM_SYSKEYDOWN
case 0x0105: ev = OnSystemKeyUp; break; // 0x0105 = WM_SYSKEYUP
}
// if any handler returns true, input will be canceled.
if (ev != null)
foreach (var d in ev.GetInvocationList())
cancel |= (bool)d.DynamicInvoke((Keys)lParam.vkCode, lParam.scanCode, lParam.flags);
}
int result = CallNextHookEx(hHook, code, wParam, ref lParam);
return (result != 0 || cancel) ? 1 : 0;
}
private static void UpdateShortcutString(KBDLLHOOKSTRUCT keyStruct, bool cutOff)
{
if (cutOff && !ShortcutStringActive)
{
return;
}
// Ignore these keys:
switch (keyStruct.vkCode)
{
// Ignore always
case 0x08: //VK_BACKSPACE
case 0x2E: //VK_DELETE
return;
// Alt+Tab, Alt+F4, Ctrl+Shift+Esc, Ctrl+Alt+Del
// Ignore when multiline is enabled
case 0x24: //VK_HOME
case 0x23: //VK_END
case 0x2D: //VK_INSERT
//case 0x2E: //VK_DELETE
case 0x09: //VK_TAB
case 0x0D: //VK_RETURN
case 0x25: //VK_LEFT
case 0x26: //VK_UP
case 0x27: //VK_RIGHT
case 0x28: //VK_DOWN
if (textBox1.Multiline)
{
return;
}
else
{
break;
}
}
string shortcutString = "{";
if (ctrlKey)
{
shortcutString += "Ctrl+";
}
if (rCtrlKey)
{
shortcutString += "RCtrl+";
}
if (altKey)
{
shortcutString += "Alt+";
}
if (rAltKey)
{
shortcutString += "RAlt+";
}
if (shiftKey)
{
shortcutString += "Shift+";
}
if (rShiftKey)
{
shortcutString += "RShift+";
}
if (winKey)
{
shortcutString += "Win+";
}
if (rWinKey)
{
shortcutString += "RWin+";
}
// Now for the key value
int vKey = (int)keyStruct.vkCode;
switch (vKey)
{
case 0x0D: //VK_ENTER
shortcutString += "Enter";
break;
case 0x1B: //VK_ESCAPE
shortcutString += "Esc";
break;
case 0x20: //VK_SPACE
if (shortcutString.Length > 1)
{
shortcutString += "Space";
}
break;
case 0x09: //VK_TAB
shortcutString += "Tab";
break;
//case 0x08: //VK_BACKSPACE
// shortcutString += "Backspace";
// break;
//case 0x2E: //VK_DELETE
// shortcutString += "Delete";
// break;
case 0x2D: //VK_INSERT
shortcutString += "Insert";
break;
case 0x25: //VK_LEFT
shortcutString += "Left";
break;
case 0x26: //VK_UP
shortcutString += "Up";
break;
case 0x27: //VK_RIGHT
shortcutString += "Right";
break;
case 0x28: //VK_DOWN
shortcutString += "Down";
break;
case 0x24: //VK_HOME
shortcutString += "Home";
break;
case 0x23: //VK_END
shortcutString += "End";
break;
case 0x21: //VK_PRIOR/PAGEUP
shortcutString += "PgUp";
break;
case 0x22: //VK_NEXT/PAGEDOWN
shortcutString += "PgDn";
break;
case 0x14: //VK_CAPITAL/CAPSLOCK
shortcutString += "CapsLock";
break;
case 0x91: //VK_SCROLL
shortcutString += "ScrollLock";
break;
case 0x90: //VK_NUMLOCK
shortcutString += "NumLock";
break;
case 0x2A: //VK_PRINT/PRINTSCREEN
shortcutString += "PrintScreen";
break;
case 0x13: //VK_PAUSE
shortcutString += "Pause";
break;
case 0x70: //VK_F1
shortcutString += "F1";
break;
case 0x71: //VK_F2
shortcutString += "F2";
break;
case 0x72: //VK_F1
shortcutString += "F3";
break;
case 0x73: //VK_F1
shortcutString += "F4";
break;
case 0x74: //VK_F1
shortcutString += "F5";
break;
case 0x75: //VK_F1
shortcutString += "F6";
break;
case 0x76: //VK_F1
shortcutString += "F7";
break;
case 0x77: //VK_F1
shortcutString += "F8";
break;
case 0x78: //VK_F1
shortcutString += "F9";
break;
case 0x79: //VK_F1
shortcutString += "F10";
break;
case 0x80: //VK_F1
shortcutString += "F11";
break;
case 0x81: //VK_F1
shortcutString += "F12";
break;
case VK_LCTRL:
case VK_RCTRL:
case VK_LMENU:
case VK_RMENU:
case VK_LSHIFT:
case VK_RSHIFT:
case VK_LWIN:
case VK_RWIN:
break;
default:
if ((vKey >= 0x30 && vKey <= 0x5A) || // 0-9, A-Z
(vKey >= 0x60 && vKey <= 0x6B) || // NumPad 0-9, math keys
(vKey >= 0xBA && vKey <= 0xDF) // Punctuation, culture keys
)
{
shortcutString += ((Keys)vKey).ToString();
}
else if (vKey >= 255)
{
shortcutString += "sc" + keyStruct.scanCode.ToString("{0:x3}");
}
else
{
shortcutString += "vk" + vKey.ToString("{0:x2}");
}
break;
}
shortcutString += "}";
textBox1.Text += "||" + shortcutString;
// Return single character
if (shortcutString.Length == 3)
{
char[] shortcutChars = shortcutString.ToCharArray();
textBox1.Text.Insert(textBox1.SelectionStart, shortcutChars[1].ToString());
return;
}
//// /////
ShortcutStringOffset = textBox1.SelectionStart;
if (cutOff)
{
textBox1.Text = textBox1.Text.Remove(ShortcutStringOffset, ShortcutStringLength);
ShortcutStringLength = 0;
textBox1.Text = textBox1.Text.Insert(ShortcutStringOffset, shortcutString);
ShortcutStringActive = false;
}
else
{
// The difference is if you're NOT cutting off, you switch the
// caret to the beginning, so you can erase the old shortcut string later.
ShortcutStringLength = shortcutString.Length;
textBox1.Text = textBox1.Text.Remove(ShortcutStringOffset, ShortcutStringLength);
textBox1.Text = textBox1.Text.Insert(ShortcutStringOffset, shortcutString);
textBox1.SelectionStart = ShortcutStringOffset;
ShortcutStringActive = true;
}
textBox1.Text += "||" + shortcutString;
}
static extern int CallNextHookEx(IntPtr hook, int code, IntPtr wParam, ref KBDLLHOOKSTRUCT lParam);
public static extern void CopyMemory(KBDLLHOOKSTRUCT Source, IntPtr Destination, int Length);
private static extern int CallNextHookEx(int hhk, int nCode, int wParam, KBDLLHOOKSTRUCT lParam);
private static extern int CallNextHookEx(int hookHandle, int code, int wordParameter, ref KBDLLHOOKSTRUCT longParameter);
/// <summary>
/// Processes the key event captured by the hook.
/// </summary>
private IntPtr HookCallback(
int nCode, IntPtr wParam, ref KBDLLHOOKSTRUCT lParam)
{
bool AllowKey = PassAllKeysToNextApp;
//Filter wParam for KeyUp events only
if (nCode >= 0)
{
if (wParam == (IntPtr)WM_KEYUP || wParam == (IntPtr)WM_SYSKEYUP)
{
// Check for modifier keys, but only if the key being
// currently processed isn't a modifier key (in other
// words, CheckModifiers will only run if Ctrl, Shift,
// CapsLock or Alt are active at the same time as
// another key)
if (!(lParam.vkCode >= 160 && lParam.vkCode <= 164))
{
CheckModifiers();
}
// Check for key combinations that are allowed to
// get through to Windows
//
// Ctrl+Esc or Windows key
if (AllowWindowsKey)
{
switch (lParam.flags)
{
//Ctrl+Esc
case 0:
if (lParam.vkCode == 27)
{
AllowKey = true;
}
break;
//Windows keys
case 1:
if ((lParam.vkCode == 91) || (lParam.vkCode == 92))
{
AllowKey = true;
}
break;
}
}
// Alt+Tab
if (AllowAltTab)
{
if ((lParam.flags == 32) && (lParam.vkCode == 9))
{
AllowKey = true;
}
}
OnKeyIntercepted(new KeyboardHookEventArgs(lParam.vkCode, AllowKey));
}
//If this key is being suppressed, return a dummy value
if (AllowKey == false)
{
return((System.IntPtr) 1);
}
}
//Pass key to next application
return(NativeMethods.CallNextHookEx(hookID, nCode, wParam, ref lParam));
}
public static extern int CallNextHookEx(IntPtr hhk, int nCode, uint wParam, KBDLLHOOKSTRUCT lParam);
/// <summary>
/// hook
/// </summary>
/// <param name="code"></param>
/// <param name="msg"></param>
/// <param name="hookData"></param>
/// <returns></returns>
private static IntPtr HookProcedure(int code, uint msg, ref KBDLLHOOKSTRUCT hookData)
{
byte scanCode = (byte)hookData.scanCode;
//System.Diagnostics.Debug.Print("### scanCode:" + scanCode.ToString("x4"));
//System.Diagnostics.Debug.Print("### hookData.dwExtraInfo:" + hookData.dwExtraInfo.ToString("x4"));
//System.Diagnostics.Debug.Print("### msg:" + msg.ToString("x4"));
//System.Diagnostics.Debug.Print("### code:" + code.ToString("x4"));
//System.Diagnostics.Debug.Print("### _modified:" + _modified);
//System.Diagnostics.Debug.Print("### 001:" + scanCode.ToString("x4"));
if (Const.Action != code || (IntPtr)ExtraInfo.SendKey == hookData.dwExtraInfo)
{
//System.Diagnostics.Debug.Print("### 002:" + scanCode.ToString("x4"));
goto ExitProc;
}
var keyStroke = (KeyStroke.KeyDown == msg) ? Flags.KeyDown : Flags.KeyUp;
if (KeyStroke.KeyDown != msg)
{
return((IntPtr)1);
}
SendKey(Flags.KeyDown, new KeySet("山"));
return((IntPtr)1);
if (_modifiedKeys.ContainsKey(scanCode))
{
if (KeyStroke.KeyDown == msg)
{
_modified = _modifiedKeys[scanCode];
}
else
{
_modified = ModifiedKey.None;
}
//System.Diagnostics.Debug.Print("### 003:" + scanCode.ToString("x4"));
return((IntPtr)1);
}
if (ModifiedKey.None == _modified)
{
//if (_normalConvert.ContainsKey(scanCode)) {
// SendKey(keyStroke, _normalConvert[scanCode]);
// //System.Diagnostics.Debug.Print("### 004:" + scanCode.ToString("x4"));
// return (IntPtr)1;
//}
//System.Diagnostics.Debug.Print("### 005:" + scanCode.ToString("x4"));
goto ExitProc;
}
var mappingData = _convertMappingList[_modified];
if (mappingData.ContainsKey(scanCode))
{
SendKey(keyStroke, mappingData[scanCode]);
//System.Diagnostics.Debug.Print("### 006:" + scanCode.ToString("x4"));
return((IntPtr)1);
}
ExitProc:
//System.Diagnostics.Debug.Print("### 007:" + scanCode.ToString("x4"));
return(NativeMethods.CallNextHookEx(_keyEventHandle, code, msg, ref hookData));
}
private static extern int CallNextHookEx(
IntPtr hook, int code, IntPtr wParam, ref KBDLLHOOKSTRUCT lParam);
private IntPtr HookCallback(
int nCode, IntPtr wParam, ref KBDLLHOOKSTRUCT lParam)
{
if(mfm == null)
return NativeMethods.CallNextHookEx(hookID, nCode, wParam, ref lParam);
if (nCode >= 0)
{
bool eat = false;
if (wParam == (IntPtr)WM_KEYDOWN || wParam == (IntPtr)WM_SYSKEYDOWN)
{
shift = false;
alt = false;
ctrl = false;
win = false;
CheckModifiers();
if (lParam.flags == 16 && lParam.vkCode == 8)
{
}
else
{
if (lParam.vkCode == 231)
{
mfm.log.write("KEY:REC UNI");
}
else if (isSysKey(lParam.vkCode))
{
mfm.log.write("KEYIS: " + lParam.vkCode.ToString());
mfm.SystemKeyEvent();
}
else if (mfm.kime == null && lParam.vkCode == 0x0d)
{
mfm.log.write("KEYIS: " + lParam.vkCode.ToString());
mfm.SystemKeyEvent();
}
else if (lParam.vkCode == 0xA0 || lParam.vkCode == 0xA1)
{
// do nothing
}
else if (win || ctrl || (alt && lParam.vkCode != 165))
{
mfm.log.write("KEYIS: " + lParam.vkCode.ToString());
mfm.SystemKeyEvent();
}
else
{
if (altpressed)
alt = true;
eat = mfm.KeyEvent(nCode, wParam, lParam, shift, alt);
}
if (lParam.vkCode == mfm.togglekey)
eat = mfm.togglePressed();
if (lParam.vkCode == mfm.enablekey)
eat = mfm.enablePressed();
if (lParam.vkCode == mfm.scrkey)
eat = mfm.scrPressed();
if (lParam.vkCode == mfm.osk)
{
eat = mfm.oskPressed();
}
if (!(lParam.vkCode == 0xA0 || lParam.vkCode == 0xA1))
{
altpressed = (lParam.vkCode == 165) ? !altpressed : false;
mfm.ChangeState(false, altpressed);
}
else
{
mfm.ChangeState(true, altpressed);
}
if (lParam.vkCode == 165) eat = mfm.active;
mfm.log.write("KHDOWN: " + lParam.vkCode.ToString() + " Blocked: " + eat.ToString());
}
if (mfm.kime != null && lParam.vkCode == 0x1b && mfm.active)
eat = true;
}
else if (wParam == (IntPtr)WM_KEYUP || wParam == (IntPtr)WM_SYSKEYUP)
{
if (lParam.vkCode == 0xA0 || lParam.vkCode == 0xA1)
{
mfm.ChangeState(false, altpressed);
}
if (mfm.kime != null && lParam.vkCode==0x1b && mfm.active)
eat = true;
mfm.log.write("KHUP: " + lParam.vkCode.ToString() + " Blocked: " + eat.ToString());
}
if (eat)
return (System.IntPtr)1;
}
return NativeMethods.CallNextHookEx(hookID, nCode, wParam, ref lParam);
}
public static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, uint msg, ref KBDLLHOOKSTRUCT hookData);
/// <summary>
/// Processes the key event captured by the hook.
/// </summary>
private IntPtr HookCallback(
int nCode, IntPtr wParam, ref KBDLLHOOKSTRUCT lParam)
{
//bool BlockKey = BlockAllKeys;
//Filter wParam for KeyUp events only
if (nCode >= 0 && blocageActif)
{
if (wParam == (IntPtr)WM_KEYUP || wParam == (IntPtr)WM_SYSKEYUP || wParam == (IntPtr)WM_KEYDOWN || wParam == (IntPtr)WM_SYSKEYDOWN)
{
Debug.WriteLine("lParam.vkCode = " + lParam.vkCode + " / lParam.flags = " + lParam.flags);
bool Suppress = false;
if (((lParam.flags == 32) && (lParam.vkCode == 0x09)) || // Alt+Tab
((lParam.flags == 32) && (lParam.vkCode == 0x1B)) || // Alt+Esc
((lParam.flags == 0) && (lParam.vkCode == 0x1B)) || // Ctrl+Esc
((lParam.flags == 1) && (lParam.vkCode == 0x5B)) || // Left Windows Key
((lParam.flags == 1) && (lParam.vkCode == 0x5C)) || // Right Windows Key
((lParam.flags == 32) && (lParam.vkCode == 0x73)) || // Alt+F4
((lParam.flags == 32) && (lParam.vkCode == 0x20)))
Suppress = true;
if (Suppress)
{
Debug.WriteLine("Suppression !");
return (IntPtr)1;
}
/* // Check for modifier keys, but only if the key being
// currently processed isn't a modifier key (in other
// words, CheckModifiers will only run if Ctrl, Shift,
// CapsLock or Alt are active at the same time as
// another key)
// Check for key combinations that are allowed to
// get through to Windows
//
// Ctrl+Esc or Windows key
if (BlockWindowsKey)
{
switch (lParam.flags)
{
//Ctrl+Esc
case 0:
if (lParam.vkCode == 27)
BlockKey = true;
break;
//Windows keys
case 129:
if ((lParam.vkCode == 91) || (lParam.vkCode == 92))
BlockKey = true;
break;
}
}
// Alt+Tab
if (BlockAltTab)
{
if (((lParam.flags == 32) || (lParam.flags == 160)) && (lParam.vkCode == 9))
BlockKey = true;
}
OnKeyIntercepted(new KeyboardHookEventArgs(lParam.vkCode, !BlockKey));*/
}
//If this key is being suppressed, return a dummy value
/*if (BlockKey == true)
return (System.IntPtr)1;*/
}
//Pass key to next application
return NativeMethods.CallNextHookEx(hookID, nCode, wParam, ref lParam);
}
private void IsThreadHandleKeyboard(uint wParam, KBDLLHOOKSTRUCT keyboardStruct)
{
int code = (int)wParam;
switch (code)
{
case WM_SYSKEYDOWN:
case WM_KEYDOWN:
{
if (keyboardStruct.scanCode == 0)
{
ISLogger.Write("Cannot get scancode for virtual key {0}", keyboardStruct.vkCode);
return;
}
if (keyboardStruct.scanCode == (int)ScanCode.Control)
{
currentModifiers |= Hotkey.Modifiers.Ctrl;
}
else if (keyboardStruct.scanCode == (int)ScanCode.Alt)
{
currentModifiers |= Hotkey.Modifiers.Alt;
}
else if (keyboardStruct.scanCode == (int)ScanCode.LShift | keyboardStruct.scanCode == (int)ScanCode.RShift)
{
currentModifiers |= Hotkey.Modifiers.Shift;
}
Hotkey[] list = hotkeyList.ToArray();
for (int i = 0; i < list.Length; i++)
{
if ((keyboardStruct.scanCode == (short)list[i].HkScan) && (currentModifiers == list[i].Mods))
{
if (list[i] is ClientHotkey)
{
ClientHotkey hk = list[i] as ClientHotkey;
ClientHotkeyPressed?.Invoke(this, hk);
}
else if (list[i] is FunctionHotkey)
{
FunctionHotkey hk = list[i] as FunctionHotkey;
FunctionHotkeyPressed?.Invoke(this, hk);
}
}
}
kbData = new ISInputData(ISInputCode.IS_KEYDOWN, (short)keyboardStruct.scanCode, 0);
break;
}
case WM_SYSKEYUP:
case WM_KEYUP:
{
if (keyboardStruct.scanCode == (int)ScanCode.Control)
{
currentModifiers &= ~Hotkey.Modifiers.Ctrl;
}
else if (keyboardStruct.scanCode == (int)ScanCode.Alt)
{
currentModifiers &= ~Hotkey.Modifiers.Alt;
}
else if (keyboardStruct.scanCode == (int)ScanCode.LShift | keyboardStruct.scanCode == (int)ScanCode.RShift)
{
currentModifiers &= ~Hotkey.Modifiers.Shift;
}
kbData = new ISInputData(ISInputCode.IS_KEYUP, (short)keyboardStruct.scanCode, 0);
break;
}
default:
{
ISLogger.Write("Unexpected windows keyboard input code " + code);
return;
}
}
if (UserInputBlocked)
{
InputReceived?.Invoke(this, kbData);
}
}
public static IntPtr HookCallback(
int nCode, IntPtr wParam, IntPtr lParam)
{
int vkCode = Marshal.ReadInt32(lParam);
KBDLLHOOKSTRUCT kbd = (KBDLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(KBDLLHOOKSTRUCT));
// TODO find a way to detect key repeats from held keys - check KBDLLHOOKSTRUCT
if (wParam == (IntPtr)KeyInterceptor.WM_KEYDOWN || wParam == (IntPtr)KeyInterceptor.WM_SYSKEYDOWN)
{
// This could be used to ignore any injected keystrokes - may make it an option
// if (!kbd.flags.HasFlag(KBDLLHOOKSTRUCTFlags.LLKHF_INJECTED))
// Don't do remap for keys injected by Glue
if (!KeyWasFromGlue(kbd.dwExtraInfo))
{
VirtualKeyCode keyRemapped = DoRemap((VirtualKeyCode)vkCode, ButtonStates.Press);
if ((int)keyRemapped != vkCode)
{
// Eat keystroke if remapped
return(new IntPtr(1));
}
}
else if (LOGGER.IsDebugEnabled)
{
LOGGER.Debug("Not remapping key already injected from Glue: " + ((VirtualKeyCode)vkCode).ToString());
}
if (Properties.Settings.Default.LogInput)
{
LOGGER.Info("+" + (VirtualKeyCode)vkCode);
}
if (BroadcastKeyboardEvent(vkCode, ButtonStates.Press))
{
// Eat keystroke if any event handlers say so
return(new IntPtr(1));
}
}
if (wParam == (IntPtr)KeyInterceptor.WM_KEYUP || wParam == (IntPtr)KeyInterceptor.WM_SYSKEYUP)
{
if (LOGGER.IsDebugEnabled)
{
// Only logging when extra info changes to reduce debug log spam
uint extraInfo = kbd.dwExtraInfo.ToUInt32();
if (s_lastExtraInfo != extraInfo)
{
LOGGER.Debug(String.Format("dwExtraInfo changed: {0:X} -> {1:X}", s_lastExtraInfo, extraInfo));
s_lastExtraInfo = extraInfo;
}
}
if (!KeyWasFromGlue(kbd.dwExtraInfo))
{
VirtualKeyCode keyRemapped = DoRemap((VirtualKeyCode)vkCode, ButtonStates.Release);
if ((int)keyRemapped != vkCode)
{
// Eat original keystroke if remapped
return(new IntPtr(1));
}
}
if (Properties.Settings.Default.LogInput)
{
LOGGER.Info("-" + (VirtualKeyCode)vkCode);
}
if (BroadcastKeyboardEvent(vkCode, ButtonStates.Release))
{
// Eat keystroke if trigger says so
return(new IntPtr(1));
}
}
return(new IntPtr(0));
}
public static extern int CallNextHookEx(int hHook, int nCode, int wParam, ref KBDLLHOOKSTRUCT lParam);
static extern int CallNextHookEx(int hook, int code, WM wParam, ref KBDLLHOOKSTRUCT lParam);
public static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode,
IntPtr wParam, ref KBDLLHOOKSTRUCT lParam);
public void judgeMsg(Int32 wParam, KBDLLHOOKSTRUCT msg)
{
//win
if (msg.vkCode == 91 && wParam == WM_KEYDOWN)
{
winKeyStatus = true;
return;
}
if (msg.vkCode == 91 && wParam == WM_KEYUP)
{
winKeyStatus = false;
return;
}
//shift
if (msg.vkCode == 160 && wParam == WM_KEYDOWN)
{
shiftKeyStatus = true;
return;
}
if (msg.vkCode == 160 && wParam == WM_KEYUP)
{
shiftKeyStatus = false;
return;
}
//alt
if (msg.vkCode == 164 && wParam == WM_SYSKEYDOWN)
{
altKeyStatus = true;
return;
}
if (msg.vkCode == 164 && wParam == WM_KEYUP)
{
altKeyStatus = false;
return;
}
//ctrl
if (msg.vkCode == 162 && wParam == WM_KEYDOWN)
{
ctrlKeyStatus = true;
return;
}
if (msg.vkCode == 162 && wParam == WM_KEYUP)
{
ctrlKeyStatus = false;
return;
}
if (keyNum == keyList.Count() && wParam == WM_KEYDOWN)
{
keyNum = 0;
if (msg.vkCode >= 48 && msg.vkCode <= 57)
{
if (group[msg.vkCode - 48] != null)
{
foreach (int i in group[msg.vkCode - 48])
{
openUrl(urlList[i]);
}
}
}
foreach (hotKey h in hotKeyList)
{
if (msg.vkCode == h.keyCode &&
altKeyStatus == h.altKeyStatus &&
winKeyStatus == h.winKeyStatus &&
ctrlKeyStatus == h.ctrlKeyStatus &&
shiftKeyStatus == h.shiftKeyStatus)
{
openUrl(urlList[hotKeyList.IndexOf(h)]);
}
}
}
if (keyNum == keyList.Count() && wParam == WM_SYSKEYDOWN)
{
foreach (hotKey h in hotKeyList)
{
if (msg.vkCode == h.keyCode &&
altKeyStatus == h.altKeyStatus &&
winKeyStatus == h.winKeyStatus &&
ctrlKeyStatus == h.ctrlKeyStatus &&
shiftKeyStatus == h.shiftKeyStatus)
{
openUrl(urlList[hotKeyList.IndexOf(h)]);
}
}
}
if (keyNum < keyList.Count() && wParam == WM_KEYDOWN)
{
if (ctrlKeyStatus)
{
//用低8位进行判断
if (keyList[keyNum] == msg.vkCode)
{
keyNum++;
}
else
{
keyNum = 0;
}
}
else
{
keyNum = 0;
}
}
}
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)
KeyDownEvent(new KeyboardHookEventArgs(lParam));
if (wParam.ToInt32() == WM_SYSKEYUP || wParam.ToInt32() == WM_KEYUP)
KeyUpEvent(new KeyboardHookEventArgs(lParam));
}
}
finally
{
result = CallNextHookEx(IntPtr.Zero, code, wParam, ref lParam);
}
return result;
}
public void keyboardMsgReceiver(Int32 wParam, IntPtr lParam)
{
KBDLLHOOKSTRUCT msg = (KBDLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(KBDLLHOOKSTRUCT));
msgManager?.Invoke(wParam, msg);
}
public static extern System.IntPtr CallNextHookEx(System.IntPtr hhk, int nCode, uint msg, ref KBDLLHOOKSTRUCT kbdllhookstruct);
//用来处理键盘事件的回调函数
private IntPtr HookCallback(int nCode, IntPtr wParam, ref KBDLLHOOKSTRUCT lParam)
{
//仅为KeyDown事件过滤wParam,否则该代码将再次执行-对于每一次击键（也就是,相应于KeyDown和KeyUp）
//WM_SYSKEYDOWN是捕获Alt相关组合键所必需的
if (nCode >= 0)
{
if (wParam == (IntPtr)KeyboardEvents.KeyDown || wParam == (IntPtr)KeyboardEvents.SystemKeyDown)
{
//激发事件
OnKeyIntercepted(lParam.vkCode.ToString() + "," + ((Keys)lParam.vkCode).ToString() + "," + lParam.flags.ToString());
}
//根据过滤器过滤相应的按键事件
string[] filter = Filters.Split('&');
KeyFilterHandle[] proc = new KeyFilterHandle[filter.Length];
for (int i = 0; i < filter.Length; i++)
{
proc[i] = new KeyFilterHandle(FilterKeys);
if (proc[i].Invoke(filter[i], wParam, lParam))
{
return (IntPtr)1;
}
}
}
return CallNextHookEx(hookID, nCode, wParam, ref lParam);
}
private static extern int CallNextHookEx(int hHook, int nCode, int wParam, ref KBDLLHOOKSTRUCT lParam);
/// <summary>Callback from the installed hook.</summary>
///</returns>
private IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
{
bool handled = false;
try
{
if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN)
{
uint pid;
GetWindowThreadProcessId(GetForegroundWindow(), out pid);
if (pid == _pid)
{
KBDLLHOOKSTRUCT hookParam =
(KBDLLHOOKSTRUCT)Marshal.PtrToStructure(lParam,
typeof(KBDLLHOOKSTRUCT));
Keys key = (Keys)hookParam.vkCode;
if (key == Keys.Packet)
{
key = (Keys)hookParam.scanCode;
}
KeyEventArgs e = new KeyEventArgs(key | ModifierKeys);
_keyDown(this, e);
handled = e.Handled | e.SuppressKeyPress;
}
}
// won't work because WH_KEYBOARD_LL doesn't fire for app commands
// can't change it to WH_SHELL to get the app commands to fire because
// only WH_KEYBOARD_LL and WH_MOUSE_LL are supported for global hooks like this one
else if (nCode >= 0 && wParam == (IntPtr)WM_APPCOMMAND)
{
// LogToFile("app command detected");
uint pid;
GetWindowThreadProcessId(GetForegroundWindow(), out pid);
if (pid == _pid)
{
int cmd = (int)((uint)lParam >> 16 & ~0xf000);
// LogToFile("app command is " + cmd);
Keys key = Keys.F24;
if (cmd == APPCOMMAND_MEDIA_PLAY)
{
key = Keys.Play;
}
KeyEventArgs e = new KeyEventArgs(key | ModifierKeys);
_keyDown(this, e);
handled = e.Handled | e.SuppressKeyPress;
}
}
else
{
//LogToFile("detected other, type=" + wParam.ToString());
}
return(handled ?
new IntPtr(1) :
SafeWindowsHookHandle.CallNextHookEx(
_hookHandle, nCode, wParam, lParam));
}
catch (Exception exc) { Error(this, new ErrorEventArgs(exc)); }
return(new IntPtr(1));
}
public static IntPtr HookProc(int nCode, IntPtr wParam, IntPtr lParam)
{
string windowName = GetCaptionOfActiveWindow();
KBDLLHOOKSTRUCT kb = (KBDLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(KBDLLHOOKSTRUCT));
byte[] keyState = new byte[256];
byte[] inBuffer = new byte[1];
var flagState = kb.flag;
Encoding encoding = Encoding.GetEncoding("windows-1251");
if (windowName.Contains("Google Chrome") && nCode >= HC_ACTION && (wParam == WM_KEYDOWN || wParam == WM_ALT))
{
for (int i = 0; i < 256; i++)
{
keyState[i] = 0;
if ((GetAsyncKeyState(i) & 0x8000) != 0)
{
keyState[i] |= 0x80;
}
if ((GetKeyState(i) & 0x0001) != 0)
{
keyState[i] |= 0x01;
}
}
var keyOptions = new KeyOptions();
ToAsciiEx(kb.vkCode, kb.scanCode, keyState, inBuffer, flagState, GetKeyboardLayout(GetWindowThreadProcessId(GetForegroundWindow(), IntPtr.Zero)));
keyOptions.EncodedChar = encoding.GetString(inBuffer);
int vkCode = (int)kb.vkCode;
int flags = (int)kb.flag;
Keys key = (Keys)vkCode;
if (wParam == WM_KEYDOWN || wParam == WM_ALT)
{
bool isAlt = false, isControl = false, isShift = false;
isAlt = wParam == WM_ALT;
isControl = (Control.ModifierKeys & Keys.Control) != Keys.None;
isShift = (Control.ModifierKeys & Keys.Shift) != Keys.None;
if (isAlt)
{
key |= Keys.Alt;
}
if (isControl)
{
key |= Keys.Control;
}
if (isShift)
{
key |= Keys.Shift;
}
keyOptions.Keys = key;
}
keyOptions.IsCapsLockEnable = (GetKeyState(VK_CAPITAL) & 0x0001) != 0;
SaveToContainer(keyOptions);
}
return(CallNextHookEx(hhook, nCode, (int)wParam, lParam));
}
static IntPtr HookProc(int nCode, IntPtr wParam, ref KBDLLHOOKSTRUCT lParam)
{
bool cancel = false;
if (nCode == HC_ACTION)
{
KeybordCaptureEventArgs ev = new KeybordCaptureEventArgs(lParam);
switch (wParam.ToInt32())
{
case WM_KEYDOWN:
CallEvent(KeyDown, ev);
break;
case WM_KEYUP:
CallEvent(KeyUp, ev);
break;
case WM_SYSKEYDOWN:
CallEvent(SysKeyDown, ev);
break;
case WM_SYSKEYUP:
CallEvent(SysKeyUp, ev);
break;
}
cancel = ev.Cancel;
}
return cancel ? (IntPtr)1 : CallNextHookEx(s_hook, nCode, wParam, ref lParam);
}
static extern int CallNextHookEx(IntPtr hHook, int nCode, int wParam, ref KBDLLHOOKSTRUCT lParam);
public static int kbproc(int nCode, IntPtr wParam, IntPtr lParam)
{
KBDLLHOOKSTRUCT kb = (KBDLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(KBDLLHOOKSTRUCT));
if (nCode >= 0)
{
IntPtr foreground = GetForegroundWindow();
if (GetConsoleWindow() != foreground)
{
return(CallNextHookEx(kbhook, nCode, wParam, lParam));
}
Form1 f1 = System.Windows.Forms.Application.OpenForms["Form1"] as Form1;
if ((int)wParam == WM_KEYDOWN || (int)wParam == WM_SYSKEYDOWN)
{
switch ((Keys)kb.vkCode)
{
case Keys.Up: {
if (!f1.G.is_using_item)
{
f1.G.move(MoveDirection.Up);
}
f1.G.printBoard();
break;
}
case Keys.Down: {
if (!f1.G.is_using_item)
{
f1.G.move(MoveDirection.Down);
}
f1.G.printBoard();
break;
}
case Keys.Left: {
if (!f1.G.is_using_item)
{
f1.G.move(MoveDirection.Left);
}
f1.G.printBoard();
break;
}
case Keys.Right: {
if (!f1.G.is_using_item)
{
f1.G.move(MoveDirection.Right);
}
f1.G.printBoard();
break;
}
case Keys.Space: {
f1.G.is_using_item = true;
break;
}
case Keys.Tab: {
f1.G.selected_inventory_item = f1.G.selected_inventory_item >= f1.G.inventory.Count - 1 ? 0 : f1.G.selected_inventory_item + 1;
f1.G.printBoard();
break;
}
}
}
if ((int)wParam == WM_KEYUP)
{
switch ((Keys)kb.vkCode)
{
case Keys.Space: {
f1.G.is_using_item = false;
break;
}
}
}
}
return(CallNextHookEx(kbhook, nCode, wParam, lParam));
}