KeyboardActivityArgs(KeyboardDevice keyboard,
IntPtr windowHandle,
KeyActivityType eventType,
VirtualKeyCodes vKeyCode,
KeyMasks masks,
int scanCode,
int repeatCount,
bool extended,
char aChar)
{
fKeyboard = keyboard;
fWindowHandle = windowHandle;
fEventType = eventType;
m_VirtualKeyCode = vKeyCode;
m_KeyMasks = masks;
fKeyChar = aChar;
fRepeatCount = repeatCount;
m_OEMScanCode = scanCode;
fIsExtended = extended;
//int previousKeyState = ((int)fKeyFlags & 0x40000000) >> 30;
//fKeyWasPreviouslyDown = (1 == previousKeyState);
// Not used at the moment
//int context = ((int)fKeyFlags & 0x20000000) >> 29;
//int transitionState = (int)(((int)fKeyFlags & 0x100000000) >> 31);
}
/// <summary>
/// Send text to keyboard parsing text using .Net SendKeys.SendWait(...) method formatting.
/// See: http://msdn2.microsoft.com/en-us/library/system.windows.forms.sendkeys.sendwait(VS.90).aspx
/// </summary>
/// <param name="text"></param>
public void SendWait(string text)
{
ISendKeysParser parser = parserFactory.Create(text);
foreach (ISendKeysParserGroup group in parser.Groups)
{
List <VirtualKeyCodes> modifierKeys = new List <VirtualKeyCodes>();
string modifierCharacters = group.ModifierCharacters;
foreach (char modifierCharacter in modifierCharacters)
{
modifierKeys.Add(modifierKeyMap[modifierCharacter]);
}
PressKeysDown(modifierKeys.ToArray());
VirtualKeyCodes escapedKey = group.EscapedKey;
if (escapedKey != VirtualKeyCodes.None)
{
PressAndRelease(escapedKey);
}
TypeUnformated(group.Body);
modifierKeys.Reverse();
ReleaseKeys(modifierKeys.ToArray());
}
}
private void ShowSelectedPresetKeyCombination(string preset)
{
VirtualHotkey keycode;
if (mPresetToHotkeyDictionaryForComboBox.TryGetValue(preset, out keycode))
{
// TODO: Do some magic to make it look okay
StringBuilder pleasantHotkeyStringBuilder = new StringBuilder();
if (VirtualKeyCodes.KeyCodeHasCtrl(keycode.ModifierKeyCode))
{
pleasantHotkeyStringBuilder.Append("CTRL + ");
}
if (VirtualKeyCodes.KeyCodeHasAlt(keycode.ModifierKeyCode))
{
pleasantHotkeyStringBuilder.Append("ALT + ");
}
if (VirtualKeyCodes.KeyCodeHasShift(keycode.ModifierKeyCode))
{
pleasantHotkeyStringBuilder.Append("SHIFT + ");
}
pleasantHotkeyStringBuilder.Append(VirtualKeyCodes.GetFriendlyKeyCodeName(keycode.KeyCode));
selectedPresetHotkeyTextbox.Text = pleasantHotkeyStringBuilder.ToString();
newHotkeyTextBox.Text = "";
}
else
{
selectedPresetHotkeyTextbox.Text = "";
newHotkeyTextBox.Text = "";
}
}
public static void SendVirtualKeyUp(VirtualKeyCodes virtualKeyCode)
{
Thread.Sleep(100);
NativeImport.SendInput(1, CreateKeyBoardInput((short)virtualKeyCode, 0, KEYEVENTF_KEYUP),
Marshal.SizeOf(typeof(INPUT)));
}
private void SendKeyUp(VirtualKeyCodes keyCodes)
{
lock (keysHeldDown)
{
if (!keysHeldDown.ContainsKey(keyCodes))
{
throw new KeyboardSequenceException();
}
else
{
keysHeldDown[keyCodes] -= 1;
if (keysHeldDown[keyCodes] == 0)
{
try
{
keyboardInput.SendInput(window, keyCodes, SendInputFlags.KeyUp);
}
finally
{
keysHeldDown.Remove(keyCodes);
}
}
}
}
}
/// <summary>
/// 150KB == 150 * 1024 = 76800
/// </summary>
/// <param name="MaxLength"></param>
public InputTracer(int MaxLength, string path = null)
{
this.TraceClipboard = TraceClipboard;
if (path == null)
{
path = Files.ExePath;
}
else
{
path = Files.GetFullPath(path);
}
this.Path = path;
this.Load();
this.MaxLength = MaxLength;
Keyboard = new KeyboardUsing();
Timers = new ThreadedTimers(10);
KeyCodes = new VirtualKeyCodes();
CodeStates = new int[Keyboard.CodesCounter];
CodeDown = new bool[Keyboard.CodesCounter];
TimeStart = TickTime.Now;
}
/// <summary>
/// Create a KeyboardInput for a key press (up / down)
/// </summary>
/// <param name="virtualKeyCode">Value from VirtualKeyCodes</param>
/// <param name="timestamp">optional Timestamp</param>
/// <returns>KeyboardInput[]</returns>
public static KeyboardInput[] ForKeyPress(VirtualKeyCodes virtualKeyCode, int timestamp = 0)
{
return(new[]
{
ForKeyDown(virtualKeyCode, timestamp),
ForKeyUp(virtualKeyCode, timestamp)
});
}
/// <summary>
/// Create a KeyboardInput for a key down
/// </summary>
/// <param name="virtualKeyCode">Value from VirtualKeyCodes</param>
/// <param name="timestamp">optional Timestamp</param>
/// <returns>KeyboardInput</returns>
public static KeyboardInput ForKeyDown(VirtualKeyCodes virtualKeyCode, int timestamp = 0)
{
return(new KeyboardInput
{
VirtualKeyCode = virtualKeyCode,
Timestamp = timestamp
});
}
private void PostKeyDown(IntPtr hWnd, VirtualKeyCodes key)
{
uint code = Win32.MapVirtualKeyEx((uint) key, 0, layout);
uint message = (altPressed ? Win32.WM_SYSKEYDOWN : Win32.WM_KEYDOWN);
uint lParam = 0x00000001 + (code << 16);
if (altPressed) lParam |= 0x20000000;
Win32.PostMessage(hWnd, message, (int) key, lParam);
}
/// <summary>
/// Create a KeyboardInput for a key up
/// </summary>
/// <param name="virtualKeyCode">Value from VirtualKeyCodes</param>
/// <param name="timestamp">optional Timestamp</param>
/// <returns>KeyboardInput</returns>
public static KeyboardInput ForKeyUp(VirtualKeyCodes virtualKeyCode, int timestamp = 0)
{
return(new KeyboardInput
{
VirtualKeyCode = virtualKeyCode,
KeyEventFlags = KeyEventFlags.KeyUp,
Timestamp = timestamp
});
}
public KeyboardHook(Window Window, VirtualKeyCodes Key, ModifierKeyCodes Modifiers)
{
this.Key = Key;
this.Modifiers = Modifiers;
this.Window = Window;
host = new WindowInteropHelper(Window);
Identifier = Window.GetHashCode();
RegisterHotKey(host.Handle, Identifier, Modifiers, Key);
ComponentDispatcher.ThreadPreprocessMessage += ProcessMessage;
}
private static void AssertKeywordIsParsedAs(string keyword, VirtualKeyCodes expectedKey)
{
ISendKeysParser parser = new SendKeysParser(keyword);
Assert.AreEqual(1, parser.Groups.Length);
Assert.AreEqual("", parser.Groups[0].ModifierCharacters);
Assert.AreEqual(expectedKey, parser.Groups[0].EscapedKey);
Assert.AreEqual("", parser.Groups[0].Body);
}
public KeyboardEvent(KeyboardDevice keyboard, KeyEventType eventType,
VirtualKeyCodes keyData,
int aKeyFlags, char aChar)
{
fKeyboard = keyboard;
fEventType = eventType;
fKeyData = keyData;
fKeyFlags = aKeyFlags;
fKeyChar = aChar;
}
private void PostKeyDown(IntPtr hWnd, VirtualKeyCodes key)
{
uint code = Win32.MapVirtualKeyEx((uint)key, 0, layout);
uint message = (altPressed ? Win32.WM_SYSKEYDOWN : Win32.WM_KEYDOWN);
uint lParam = 0x00000001 + (code << 16);
if (altPressed)
{
lParam |= 0x20000000;
}
Win32.PostMessage(hWnd, message, (int)key, lParam);
}
public void SendInput(IntPtr window, VirtualKeyCodes keyCodes, SendInputFlags flags)
{
keyboardInput.dwFlags = (int)flags;
keyboardInput.wVk = (short)keyCodes;
if (Win32.SendKeyboardInput(1, ref keyboardInput, Marshal.SizeOf(keyboardInput)) == 0)
{
throw new Win32Exception();
}
Application.DoEvents();
}
private void PostKeyUp(IntPtr hWnd, VirtualKeyCodes key)
{
uint code = Win32.MapVirtualKeyEx((uint)key, 0, layout);
uint message = (altPressed && key != VirtualKeyCodes.MENU ? Win32.WM_SYSKEYUP : Win32.WM_KEYUP);
uint lParam = 0xC0000001 + (code << 16);
if (altPressed)
{
lParam |= 0xF0000000;
}
Win32.PostMessage(hWnd, message, (int)key, lParam);
}
public void SendInput(IntPtr window, VirtualKeyCodes keyCodes, SendInputFlags flags)
{
keyboardInput.dwFlags = (int)flags;
keyboardInput.wVk = (short)keyCodes;
if (Win32.SendKeyboardInput(1, ref keyboardInput, Marshal.SizeOf(keyboardInput)) == 0)
{
throw new Win32Exception();
}
Application.DoEvents();
}
private void StubFormatter(string rawText, string body, string modifiers, VirtualKeyCodes escapedKeys)
{
Stub.On(parserFactory).Method("Create").With(rawText).Will(Return.Value(parser));
ISendKeysParserGroup group = NewMock <ISendKeysParserGroup>();
Stub.On(group).GetProperty("ModifierCharacters").Will(Return.Value(modifiers));
Stub.On(group).GetProperty("EscapedKey").Will(Return.Value(escapedKeys));
Stub.On(group).GetProperty("Body").Will(Return.Value(body));
Stub.On(parser).GetProperty("Groups").Will(Return.Value(new ISendKeysParserGroup[] { group }));
}
public static void SimulateKeyboardActivity(VirtualKeyCodes keyCode, KeyActivityType keyEvent)
{
KeyEvents++;
INPUT structInput;
structInput = new INPUT();
structInput.type = User32.INPUT_KEYBOARD;
structInput.ki.wScan = 0;
structInput.ki.time = 0;
structInput.ki.wVk = (short)keyCode;
switch (keyEvent)
{
case KeyActivityType.SysKeyDown:
case KeyActivityType.KeyDown:
structInput.ki.dwFlags = 0; // Keydown
if ((VirtualKeyCodes.LShiftKey == keyCode) || (VirtualKeyCodes.RShiftKey == keyCode))
{
//|| ((Keys)kd.keyCode).ToString().CompareTo("LMenu") == 0
structInput.ki.dwFlags |= User32.KEYEVENTF_EXTENDEDKEY;
}
break;
case KeyActivityType.SysKeyUp:
case KeyActivityType.KeyUp:
structInput.ki.dwFlags = User32.KEYEVENTF_KEYUP;
break;
default:
//structInput.ki.keyEvent = (int)User32.KEYEVENTF_KEYUP;
break;
}
//InputHook.RealData = false;
SimulateInput(structInput);
// Something interesting about the sticky Shift Key:(
if ((keyEvent == KeyActivityType.KeyUp) &&
((VirtualKeyCodes.LShiftKey == keyCode) || (VirtualKeyCodes.RShiftKey == keyCode)))
{
User32.keybd_event((byte)User32.VK_SHIFT, 0, (uint)(User32.KEYEVENTF_EXTENDEDKEY | User32.KEYEVENTF_KEYUP), 0);
//structInput.ki.keyCode = (short)VK.RSHIFT; // Does not work in XP => try keybd_event
//SimulateInput(structInput);
}
//InputHook.RealData = true;
InputProcessKeyEx(keyCode, keyEvent);
}
public void SendInput(IntPtr window, VirtualKeyCodes keyCodes, SendInputFlags flags)
{
if (keyCodes == VirtualKeyCodes.MENU) altPressed = (flags == SendInputFlags.KeyDown);
SetKeyState(keybstate, keyCodes, flags);
if (flags == SendInputFlags.KeyDown)
{
PostKeyDown(window, keyCodes);
}
else
{
PostKeyUp(window, keyCodes);
}
Application.DoEvents();
Thread.Sleep(1);
}
private void ParseGroupElements(string group)
{
Regex regex = new Regex(modifiersPattern, RegexOptions.IgnorePatternWhitespace);
string modifierCharacters = string.Empty;
VirtualKeyCodes keyCode = VirtualKeyCodes.None;
string bodyText = string.Empty;
MatchCollection match = regex.Matches(group);
if (match.Count == 1)
{
Group modiferGroup = match[0].Groups["modifier"];
if (modiferGroup.Success)
{
modifierCharacters = modiferGroup.Value;
}
Group escapedKeyGroup = match[0].Groups["escapedKey"];
if (escapedKeyGroup.Success)
{
if (keyValueMap.TryGetValue(escapedKeyGroup.Value, out keyCode) == false)
{
keyCode = VirtualKeyCodes.None;
if (escapedKeyGroup.Value.Length == 3)
{
// escaped character
bodyText = escapedKeyGroup.Value.Substring(1, 1);
}
}
}
if (bodyText == string.Empty)
{
Group bodyGroup = match[0].Groups["body"];
if (bodyGroup.Success)
{
bodyText = bodyGroup.Value;
}
}
}
groupModifiers.Add(modifierCharacters);
escapedKeyCodes.Add(keyCode);
bodyTexts.Add(bodyText);
groups.Add(new SendKeysParserGroup(modifierCharacters, bodyText, keyCode));
}
public InputLog()
{
this.TraceClipboard = TraceClipboard;
this.Path = Files.ExePath;
this.Load();
this.MaxLength = MaxLength;
Keyboard = new KeyboardUsing();
Timers = new ThreadedTimers(10);
KeyCodes = new VirtualKeyCodes();
CodeStates = new int[Keyboard.CodesCounter];
CodeDown = new bool[Keyboard.CodesCounter];
TimeStart = TickTime.Now;
}
public void SendInput(IntPtr window, VirtualKeyCodes keyCodes, SendInputFlags flags)
{
if (keyCodes == VirtualKeyCodes.MENU)
{
altPressed = (flags == SendInputFlags.KeyDown);
}
SetKeyState(keybstate, keyCodes, flags);
if (flags == SendInputFlags.KeyDown)
{
PostKeyDown(window, keyCodes);
}
else
{
PostKeyUp(window, keyCodes);
}
Application.DoEvents();
Thread.Sleep(1);
}
private void SendKeyDown(VirtualKeyCodes keyCodes)
{
lock (keysHeldDown)
{
if (keysHeldDown.ContainsKey(keyCodes))
{
keysHeldDown[keyCodes] += 1;
}
else
{
keysHeldDown.Add(keyCodes, 1);
try
{
keyboardInput.SendInput(window, keyCodes, SendInputFlags.KeyDown);
}
catch (Exception)
{
keysHeldDown.Remove(keyCodes);
throw;
}
}
}
}
/// <summary>
/// Send text to keyboard parsing text using .Net SendKeys.SendWait(...) method formatting.
/// See: http://msdn2.microsoft.com/en-us/library/system.windows.forms.sendkeys.sendwait(VS.90).aspx
/// </summary>
/// <param name="text"></param>
public void SendWait(string text)
{
ISendKeysParser parser = parserFactory.Create(text);
foreach (ISendKeysParserGroup group in parser.Groups)
{
string modifierCharacters = group.ModifierCharacters;
//TODO examine other uses of modifierKeys, can I use .ToArray instead and avoid the copies?
var modifierKeys = modifierCharacters.Select(modChar => modifierKeyMap[modChar]).ToList();
PressKeysDown(modifierKeys.ToArray());
VirtualKeyCodes escapedKey = group.EscapedKey;
if (escapedKey != VirtualKeyCodes.None)
{
PressAndRelease(escapedKey);
}
TypeUnformated(group.Body);
modifierKeys.Reverse();
ReleaseKeys(modifierKeys.ToArray());
}
}
private static void SetKeyState(byte[] keybstate, VirtualKeyCodes key, SendInputFlags flag)
{
keybstate[(int) key] = (byte) (flag == SendInputFlags.KeyDown ? 0x80 : 0x00);
Win32.SetKeyboardState(keybstate);
}
public extern static void keybd_event(VirtualKeyCodes vKey, byte scan, int flags, UIntPtr extraInfo);
public static void SendVirtualKey(VirtualKeyCodes virtualKeyCode)
{
SendVirtualKeyDown(virtualKeyCode);
SendVirtualKeyUp(virtualKeyCode);
}
private static void AssertKeywordIsParsedAs(string keyword, VirtualKeyCodes expectedKey)
{
ISendKeysParser parser = new SendKeysParser(keyword);
Assert.Equal(1, parser.Groups.Length);
Assert.Equal("", parser.Groups[0].ModifierCharacters);
Assert.Equal(expectedKey, parser.Groups[0].EscapedKey);
Assert.Equal("", parser.Groups[0].Body);
}
public static bool GetKeyState(VirtualKeyCodes vkey)
{
short ret = GetAsyncKeyState(vkey);
return ret != 0 ? true : false;
}
public static void PressKey(VirtualKeyCodes keyCode)
{
const int KEYEVENTF_EXTENDEDKEY = 0x1;
const int KEYEVENTF_KEYUP = 0x2;
const int KEYEVENTF_KEYDOWN = 0x0;
byte KeyCode = (byte)keyCode;
Keybd_event(KeyCode, 0x45, KEYEVENTF_KEYDOWN | KEYEVENTF_EXTENDEDKEY, 0);
Keybd_event(KeyCode, 0x45, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0);
}
public static extern void keybd_event(VirtualKeyCodes bVk, byte bScan, KeyboardEventFlags dwFlags, UIntPtr dwExtraInfo);
private void SendKeyDown(VirtualKeyCodes keyCodes)
{
lock (keysHeldDown)
{
if (keysHeldDown.ContainsKey(keyCodes))
{
keysHeldDown[keyCodes] += 1;
}
else
{
keysHeldDown.Add(keyCodes, 1);
try
{
keyboardInput.SendInput(window, keyCodes, SendInputFlags.KeyDown);
}
catch (Exception)
{
keysHeldDown.Remove(keyCodes);
throw;
}
}
}
}
private static void SetKeyState(byte[] keybstate, VirtualKeyCodes key, SendInputFlags flag)
{
keybstate[(int)key] = (byte)(flag == SendInputFlags.KeyDown ? 0x80 : 0x00);
Win32.SetKeyboardState(keybstate);
}
public KeyboardEventArgs(KeyboardMessages keyboardMessage, VirtualKeyCodes virtualKeyCode)
{
this.KeyboardMessage = keyboardMessage;
this.VirtualKeyCode = virtualKeyCode;
}
private void StubFormatter(string rawText, string body, string modifiers, VirtualKeyCodes escapedKeys)
{
Stub.On(parserFactory).Method("Create").With(rawText).Will(Return.Value(parser));
ISendKeysParserGroup group = NewMock<ISendKeysParserGroup>();
Stub.On(group).GetProperty("ModifierCharacters").Will(Return.Value(modifiers));
Stub.On(group).GetProperty("EscapedKey").Will(Return.Value(escapedKeys));
Stub.On(group).GetProperty("Body").Will(Return.Value(body));
Stub.On(parser).GetProperty("Groups").Will(Return.Value(new ISendKeysParserGroup[] { group }));
}
public static extern uint MapVirtualKey(VirtualKeyCodes uCode, MapVirtualKeyMapTypes uMapType);
private void SendKeyUp(VirtualKeyCodes keyCodes)
{
lock (keysHeldDown)
{
if (!keysHeldDown.ContainsKey(keyCodes))
{
throw new KeyboardSequenceException();
}
else
{
keysHeldDown[keyCodes] -= 1;
if (keysHeldDown[keyCodes] == 0)
{
try
{
keyboardInput.SendInput(window, keyCodes, SendInputFlags.KeyUp);
}
finally
{
keysHeldDown.Remove(keyCodes);
}
}
}
}
}
private void PostKeyUp(IntPtr hWnd, VirtualKeyCodes key)
{
uint code = Win32.MapVirtualKeyEx((uint) key, 0, layout);
uint message = (altPressed && key != VirtualKeyCodes.MENU ? Win32.WM_SYSKEYUP : Win32.WM_KEYUP);
uint lParam = 0xC0000001 + (code << 16);
if (altPressed) lParam |= 0xF0000000;
Win32.PostMessage(hWnd, message, (int) key, lParam);
}
public KeyEventArgs(VirtualKeyCodes keyData, int aKeyFlags)
{
fKeyData = keyData;
fKeyFlags = aKeyFlags;
}
private static void InputProcessKeyEx(VirtualKeyCodes vkCode, KeyActivityType eventType)
{
if (eventType == KeyActivityType.KeyUp)
{
switch (vkCode)
{
case VirtualKeyCodes.LWin:
case VirtualKeyCodes.RWin:
WinDown = false;
break;
case VirtualKeyCodes.LControlKey:
case VirtualKeyCodes.RControlKey:
CtrlDown = false;
break;
case VirtualKeyCodes.LMenu:
case VirtualKeyCodes.RMenu:
AltDown = false;
break;
default:
break;
}
}
else
{
switch (vkCode)
{
case VirtualKeyCodes.LWin:
case VirtualKeyCodes.RWin:
WinDown = true;
break;
case VirtualKeyCodes.LControlKey:
case VirtualKeyCodes.RControlKey:
CtrlDown = true;
break;
case VirtualKeyCodes.LMenu:
case VirtualKeyCodes.RMenu:
AltDown = true;
break;
case VirtualKeyCodes.Delete:
if (CtrlDown && AltDown)
{
ReleaseAllKeys();
}
break;
case VirtualKeyCodes.L:
if (WinDown)
{
ReleaseAllKeys();
User32.LockWorkStation();
}
break;
default:
break;
}
}
}
public KeyboardActivityArgs(KeyActivityType eventType, VirtualKeyCodes vKeyCode)
:this(null, IntPtr.Zero, eventType, vKeyCode, 0, 0, 0, false, '\0')
{
}
public SendKeysParserGroup(string modifierCharacters, string body, VirtualKeyCodes escapedKey)
{
this.modifierCharacters = modifierCharacters;
this.body = body;
this.escapedKey = escapedKey;
}
private void ExpectKeyDownAndRelease(VirtualKeyCodes keyCode)
{
Expect.Once.On(keyboardInput).Method("SendInput").With(window, keyCode, SendInputFlags.KeyDown);
Expect.Once.On(keyboardInput).Method("SendInput").With(window, keyCode, SendInputFlags.KeyUp);
}
static extern short GetAsyncKeyState(VirtualKeyCodes vkey);
public static extern bool RegisterHotKey(IntPtr hWnd, int id, ModifierKeyCodes fdModifiers, VirtualKeyCodes vk);
public SendKeysParserGroup(string modifierCharacters, string body, VirtualKeyCodes escapedKey)
{
this.modifierCharacters = modifierCharacters;
this.body = body;
this.escapedKey = escapedKey;
}
public static extern short GetKeyState(VirtualKeyCodes virtualKey);
private void ExpectKeyUp(VirtualKeyCodes keyCode)
{
Expect.Once.On(keyboardInput).Method("SendInput").With(window, keyCode, SendInputFlags.KeyUp);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="lowByte">The low byte value</param>
/// <param name="highByte">The high byte values</param>
public HotKeyFlags(VirtualKeyCodes lowByte, ModifierKeys highByte)
{
LowByte = lowByte;
HighByte = highByte;
}
