private KEYBDINPUT CreateKeyboardInput(short wVK, uint flag)
{
KEYBDINPUT i = new KEYBDINPUT();
i.wVk = (ushort)wVK;
i.wScan = (ushort)MapVirtualKey((uint)wVK, 0);
i.time = 0;
i.dwExtraInfo = IntPtr.Zero;
i.dwFlags = flag;
return i;
}
public INPUT(UInt32 _type, UInt16 _wVk, UInt16 _wScan, UInt32 _dwFlags, UInt32 _time)
{
type = _type;
mi = new MOUSEINPUT();
hi = new HARDWAREINPUT();
ki = new KEYBDINPUT(_wVk, _wScan, _dwFlags, _time);
}
static void SendKey(short keycode)
{
KEYBDINPUT ki = new KEYBDINPUT()
{
time = 0,
wScan = 0,
dwExtraInfo = (IntPtr)0,
wVk = keycode,
dwFlags = 0
};
if (IntPtr.Size > 4)
{
// 64-bit environment
INPUT64 ip = new INPUT64();
ip.type = 1; // Indicates a keyboard event
ip.ki = ki;
SendInput(1, new INPUT64[] { ip }, Marshal.SizeOf(ip));
ip.ki.dwFlags = 2;
SendInput(1, new INPUT64[] { ip }, Marshal.SizeOf(ip));
}
else
{
// 32-bit environment
INPUT ip = new INPUT();
ip.type = 1; // Indicates a keyboard event
ip.ki = ki;
// Press..
SendInput(1, new INPUT[] { ip }, Marshal.SizeOf(ip));
ip.ki.dwFlags = 2;
// And let go.
SendInput(1, new INPUT[] { ip }, Marshal.SizeOf(ip));
}
}
static void SendKey(short keycode)
{
KEYBDINPUT ki = new KEYBDINPUT()
{
time = 0,
wScan = 0,
dwExtraInfo = (IntPtr)0,
wVk = keycode,
dwFlags = 0
};
if (IntPtr.Size > 4)
{
// 64-bit environment
INPUT64 ip = new INPUT64();
ip.type = 1; // Indicates a keyboard event
ip.ki = ki;
SendInput(1, new INPUT64[] { ip }, Marshal.SizeOf(ip));
ip.ki.dwFlags = 2;
SendInput(1, new INPUT64[] { ip }, Marshal.SizeOf(ip));
}
else
{
// 32-bit environment
INPUT ip = new INPUT();
ip.type = 1; // Indicates a keyboard event
ip.ki = ki;
// Press..
SendInput(1, new INPUT[] { ip }, Marshal.SizeOf(ip));
ip.ki.dwFlags = 2;
// And let go.
SendInput(1, new INPUT[] { ip }, Marshal.SizeOf(ip));
}
}
/// <summary>
/// Effectively sends the keyboard input command.
/// </summary>
/// <param name="keyCode">The key code to send. Can be the scan code or the virtual key code.</param>
/// <param name="keyFlags">Flag if the key should be pressed or released.</param>
private static void SendInput(ushort keyCode, KeyEventFlags keyFlags)
{
// Add the extended flag if the flag is set or the keycode is prefixed with the byte 0xE0
// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms646267(v=vs.85).aspx
if ((keyCode & 0xFF00) == 0xE0)
{
keyFlags |= KeyEventFlags.KEYEVENTF_EXTENDEDKEY;
}
// Prepare the basic object
var keyboardInput = new KEYBDINPUT
{
dwExtraInfo = User32.GetMessageExtraInfo(),
dwFlags = keyFlags,
};
if (keyFlags.HasFlag(KeyEventFlags.KEYEVENTF_SCANCODE) ||
keyFlags.HasFlag(KeyEventFlags.KEYEVENTF_UNICODE))
{
keyboardInput.wScan = keyCode;
}
else
{
keyboardInput.wVk = keyCode;
}
SendInput(keyboardInput);
Wait.For(TimeSpan.FromMilliseconds(10));
}
public static void GenerateKeySendInput(ScanCodeShort vk, bool bExtended)
{
INPUT[] inputs = new INPUT[1];
inputs[0].type = 1;
KEYBDINPUT kb = new KEYBDINPUT(); //{0};
// generate down
if (bExtended)
{
kb.dwFlags = KEYEVENTF.EXTENDEDKEY;
}
//kb.wVk = vk;
kb.wScan = vk;
inputs[0].U.ki = kb;
SendInput(1, inputs, System.Runtime.InteropServices.Marshal.SizeOf(inputs[0]));
// generate up
kb.dwFlags = KEYEVENTF.KEYUP;
if (bExtended)
{
kb.dwFlags |= KEYEVENTF.EXTENDEDKEY;
}
//kb.wVk = vk;
kb.wScan = vk;
inputs[0].type = 1;
inputs[0].U.ki = kb;
SendInput(1, inputs, System.Runtime.InteropServices.Marshal.SizeOf(inputs[0]));
}
public static int SendInput(KEYBDINPUT ki)
{
INPUT[] inputs = new INPUT[1];
inputs[0].type = 1 /*INPUT_KEYBOARD*/;
inputs[0].union.ki = ki;
return(SendInput(1, inputs, Marshal.SizeOf(inputs[0])));
}
/// <summary>
/// If the program is started with capslock already enabled, we'll always have capslock enabled.
/// This isn't what we want (probably).
/// </summary>
public static void ValidateCAPSLOCKState()
{
var buffer = new Byte[256];
if (GetKeyboardState(buffer))
{
if (buffer[(Int32)VirtualKeyShort.CAPITAL] == 1) // capslock is active
{
// Note: SetKeyboardState apparently only works for win95, so let's synthesize the key instead.
var keyboardInput = new KEYBDINPUT();
keyboardInput.wVk = VirtualKeyShort.CAPITAL;
keyboardInput.dwExtraInfo = GetMessageExtraInfo();
var keyDown = new INPUT();
keyDown.type = INPUT_KEYBOARD;
keyDown.U.ki = keyboardInput;
var keyUp = keyDown;
keyUp.U.ki.dwFlags |= KEYEVENTF.KEYUP;
// Attempt to disable capslock, tough if this fails.
SendInput(1, new[] { keyDown }, Marshal.SizeOf(keyDown));
// Do not send the keyUp as part of the above array, it is ignored.
SendInput(1, new[] { keyUp }, Marshal.SizeOf(keyDown));
}
}
}
private KEYBDINPUT KeyEvent(ushort keyCode)
{
var keyboardInput = new KEYBDINPUT();
keyboardInput.wVk = keyCode;
return(keyboardInput);
}
protected INPUT ToInput(KEYBDINPUT keyboardInput)
{
var input = new INPUT();
input.type = (int)InputType.INPUT_KEYBOARD;
input.data.asKeyboardInput = keyboardInput;
return(input);
}
private KEYBDINPUT UnicodeKeyEvent(char c)
{
var keyboardInput = new KEYBDINPUT();
keyboardInput.wScan = c;
keyboardInput.dwFlags = (int)KeyboardEventType.KEYEVENTF_UNICODE;
return(keyboardInput);
}
//Send keyboard based input, use PressKey for a simpler handler.
public static bool SendInput(KEYBDINPUT keyboardInput)
{
INPUT[] inputs = new INPUT[1];
inputs[0].type = INPUT_KEYBOARD;
inputs[0].ki.dwFlags = keyboardInput.dwFlags;
inputs[0].ki.wScan = keyboardInput.wScan;
return(SendInput(inputs));
}
public static KEYBDINPUT GetKeyInputFromChar(char ch)
{
KEYBDINPUT keyboard = new KEYBDINPUT();
keyboard.KeyCode = 0;
keyboard.Scan = ch;
keyboard.ExtraInfo = IntPtr.Zero;
keyboard.Flags = KeyboardFlag.Unicode;
return(keyboard);
}
public static KEYBDINPUT CreateKeybdInput(ushort wVK, uint flag)
{
KEYBDINPUT i = new KEYBDINPUT();
i.wVk = wVK;
i.wScan = 0;
i.time = 0;
i.dwExtraInfo = IntPtr.Zero;
i.dwFlags = flag;
return(i);
}
private KEYBDINPUT createKeybdInput(short wVK, uint flag)
{
KEYBDINPUT i = new KEYBDINPUT();
i.wVk = (ushort)wVK;
i.wScan = 0;
i.time = 0;
i.dwExtraInfo = IntPtr.Zero;
i.dwFlags = flag;
return(i);
}
public static void SendInput(KEYBDINPUT keyboardInput)
{
// Demand the correct permissions
var permissions = new PermissionSet(PermissionState.Unrestricted);
permissions.Demand();
if (User32.SendInput(1, new[] { INPUT.KeyboardInput(keyboardInput) }, INPUT.Size) == 0)
{
throw new Win32Exception();
}
}
/// <summary>
/// Effectively sends the keyboard input command.
/// </summary>
/// <param name="keyCode">The key code to send. Can be the scan code or the virtual key code.</param>
/// <param name="isKeyDown">Flag if the key should be pressed or released.</param>
/// <param name="isScanCode">Flag if the code is the scan code or the virtual key code.</param>
/// <param name="isExtended">Flag if the key is an extended key.</param>
/// <param name="isUnicode">Flag if the key is unicode.</param>
private static void SendInput(ushort keyCode, bool isKeyDown, bool isScanCode, bool isExtended, bool isUnicode)
{
// Prepare the basic object
var keyboardInput = new KEYBDINPUT
{
time = 0,
dwExtraInfo = User32.GetMessageExtraInfo(),
};
// Add the "key-up" flag if needed. By default it is "key-down"
if (!isKeyDown)
{
keyboardInput.dwFlags |= KeyEventFlags.KEYEVENTF_KEYUP;
}
if (isScanCode)
{
keyboardInput.wScan = keyCode;
keyboardInput.dwFlags |= KeyEventFlags.KEYEVENTF_SCANCODE;
// Add the extended flag if the flag is set or the keycode is prefixed with the byte 0xE0
// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms646267(v=vs.85).aspx
if (isExtended || (keyCode & 0xFF00) == 0xE0)
{
keyboardInput.dwFlags |= KeyEventFlags.KEYEVENTF_EXTENDEDKEY;
}
}
else if (isUnicode)
{
keyboardInput.dwFlags |= KeyEventFlags.KEYEVENTF_UNICODE;
keyboardInput.wScan = keyCode;
}
else
{
keyboardInput.wVk = keyCode;
}
// Build the input object
var input = INPUT.KeyboardInput(keyboardInput);
// Send the command
if (User32.SendInput(1, new[] { input }, INPUT.Size) == 0)
{
// An error occured
var errorCode = Marshal.GetLastWin32Error();
Logger.Default.Warn("Could not send keyboard input. ErrorCode: {0}", errorCode);
}
if (WindowsVersion.IsWindows10())
{
Wait.For(TimeSpan.FromMilliseconds(10));
}
}
//Press the given keycode for delayMilliseconds duration, then release.
public static bool PressKey(UInt16 keyCode, int delayMilliseconds)
{
KEYBDINPUT keyboardInput = new KEYBDINPUT();
keyboardInput.wScan = keyCode;
keyboardInput.dwFlags = 0x0008; //Press hold key
keyboardInput.time = 0;
var keyState = SendInput(keyboardInput);
if (!keyState) return false;
//time.sleep(delayMilliseconds);
keyboardInput.dwFlags = 0x0002 | 0x0008; //release hold key
return SendInput(keyboardInput);
}
public RawInput(KEYBDINPUT Data)
{
this.Data = new[] {
new INPUT()
{
Type = INPUTTYPE.Keyboard,
Data = new INPUTUNION()
{
Keyboard = Data
}
}
};
}
/*
* Function that creates an INPUT structure to inject a keyboard button press event in the system queue.
*/
public static INPUT keyboardPress(short keyCode)
{
KEYBDINPUT ki = new KEYBDINPUT();
ki.wVk = (VirtualKeyShort)keyCode;
ki.dwFlags = 0x0000;
INPUT inp = new INPUT();
inp.type = INPUTYPE.INPUT_KEYBOARD;
inp.U.ki = ki;
return(inp);
}
/*
* Function that creates an INPUT structure to inject a keyboard button release event in the system queue.
*/
public static INPUT keyboardRelease(short keyCode)
{
KEYBDINPUT ki = new KEYBDINPUT();
ki.wVk = (VirtualKeyShort)keyCode;
ki.dwFlags = KEYEVENTF.KEYUP;
INPUT inp = new INPUT();
inp.type = INPUTYPE.INPUT_KEYBOARD;
inp.U.ki = ki;
return(inp);
}
public void releaseKey(ushort key)
{
INPUT[] inp = new INPUT[1];
inp[0].type = SendInputEventType.InputKeyboard;
KEYBDINPUT kin = new KEYBDINPUT();
kin.wVk = key;
inp[0].mkhi.ki = kin;
unsafe
{
inp[0].mkhi.ki.dwFlags = 2;
SendInput((uint)1, ref inp[0], sizeof(INPUT));
}
}
public void TestInput()
{
ActivateProcessWindow("notepad");
System.Threading.Thread.Sleep(200);
Win32.SendInput(_testInputsI);
System.Threading.Thread.Sleep(500);
Win32.SendInput(new[] { INPUT.From(KEYBDINPUT.Char('\n')), });
System.Threading.Thread.Sleep(200);
Win32.SendInput(_testInputsI);
}
//Press the given keycode for delayMilliseconds duration, then release.
public static bool PressKey(UInt16 keyCode, int delayMilliseconds)
{
KEYBDINPUT keyboardInput = new KEYBDINPUT();
keyboardInput.wScan = keyCode;
keyboardInput.dwFlags = 0x0008; //Press hold key
keyboardInput.time = 0;
var keyState = SendInput(keyboardInput);
if (!keyState)
{
return(false);
}
//time.sleep(delayMilliseconds);
keyboardInput.dwFlags = 0x0002 | 0x0008; //release hold key
return(SendInput(keyboardInput));
}
/// <summary>
/// Sends a key down signal to the OS.
/// </summary>
/// <param name="virtualKey">The virtual key.</param>
public void SendKeyDown(ushort virtualKey)
{
var scan = (ushort)MapVirtualKey(virtualKey, 0);
var keyboardFlags = KEYEVENTF.SCANCODE;
var keyboardInput = new KEYBDINPUT()
{
virtualKey = 0, scanCode = scan, dwFlags = keyboardFlags, time = 0, dwExtraInfo = IntPtr.Zero
};
var wrapper = new InputUnion()
{
ki = keyboardInput
};
var down = new INPUT()
{
type = InputType.KEYBOARD, U = wrapper
};
SendInput(1, new INPUT[] { down }, INPUT.Size);
}
/// <summary>
/// Synthesizes keystrokes, mouse motions, and button clicks.
/// </summary>
/// <param name="keyCode">Key code</param>
/// <param name="isKeyDown">Whether the button is pressed</param>
public static void SendInput(ushort keyCode, bool isKeyDown)
{
KEYBDINPUT keyboardInput = new KEYBDINPUT
{
time = 0,
dwExtraInfo = User32.GetMessageExtraInfo()
};
if (isKeyDown == false)
{
keyboardInput.dwFlags |= KeyEventFlags.KEYEVENTF_KEYUP;
}
keyboardInput.wVk = keyCode;
var input = INPUT.KeyboardInput(keyboardInput);
User32.SendInput(1, new[] { input }, INPUT.Size);
}
private static INPUT BuildInput(uint scanCodeEx, bool keyDown)
{
var keyDownOrUp = keyDown ? 0 : KEYEVENTF_KEYUP;
var keyIsExtended = (scanCodeEx & 0x80000000) == 0 ? 0 : KEYEVENTF_EXTENDEDKEY;
var keybdInput = new KEYBDINPUT
{
wVk = 0,
wScan = (ushort)(scanCodeEx & 0x000000FF),
dwFlags = KEYEVENTF_SCANCODE | keyDownOrUp | keyIsExtended,
dwExtraInfo = GetMessageExtraInfo()
};
var inputUnion = new INPUT_UNION {
ki = keybdInput
};
return(new INPUT {
type = INPUT_KEYBOARD, u = inputUnion
});
}
public static void Keys(VK[] keys, bool up)
{
INPUT[] inputs = new INPUT[keys.Length];
for (int i = 0; i < keys.Length; i++)
{
INPUT input = new INPUT();
KEYBDINPUT keyInput = new KEYBDINPUT();
input.type = SendInputEventType.InputKeyboard;
input.mkhi.ki = keyInput;
input.mkhi.ki.wVk = (ushort)keys[i];
input.mkhi.ki.wScan = 0;
input.mkhi.ki.time = 0;
input.mkhi.ki.dwFlags = up ? KEYEVENTF_KEYUP : 0;
input.mkhi.ki.dwExtraInfo = IntPtr.Zero;
inputs[i] = input;
}
int size = Marshal.SizeOf(typeof(INPUT));
SendInput((uint)keys.Length, inputs, size);
}
private void DoKeyAction(KEYBDINPUT ki, KeyActions ka)
{
uint test1 = 1;
uint test2 = 1;
if (IntPtr.Size > 4)
{
INPUT64 input = new INPUT64();
input.type = INPUT_KEYBOARD;
input.ki = ki;
if (ka == KeyActions.Hold || ka == KeyActions.Press)
{
test1 = SendInput(1, new INPUT64[] { input }, Marshal.SizeOf(input));
}
input.ki.dwFlags |= (uint)KEYEVENTF.KEYUP;
if (ka == KeyActions.Release || ka == KeyActions.Press)
{
test2 = SendInput(1, new INPUT64[] { input }, Marshal.SizeOf(input));
}
}
else
{
INPUT input = new INPUT();
input.type = INPUT_KEYBOARD;
input.ki = ki;
if (ka == KeyActions.Hold || ka == KeyActions.Press)
{
test1 = SendInput(1, new INPUT[] { input }, Marshal.SizeOf(input));
}
input.ki.dwFlags |= (uint)KEYEVENTF.KEYUP;
if (ka == KeyActions.Release || ka == KeyActions.Press)
{
test2 = SendInput(1, new INPUT[] { input }, Marshal.SizeOf(input));
}
}
if (test1 == 0 || test2 == 0)
{
string key = ki.wVk != 0 ? Enum.GetName(typeof(VirtualKeyCode), ki.wVk) : Enum.GetName(typeof(ScanCodeShort), ki.wScan);
SendInputKeyFailedCall?.Invoke(Marshal.GetLastWin32Error().ToString(), key, ka);
}
}
public MacroEvent_Keyboard(eKeyboardEvent _eType, KeyboardEvent _event)
{
EventType = _eType;
Event = _event;
uint keyState = Convert.ToUInt32(EventType == eKeyboardEvent.KeyDown ? 0 : 0x2);
INPUT keyInput = new INPUT();
keyInput.type = 1;
KEYBDINPUT kbInput = new KEYBDINPUT();
kbInput.wVk = Convert.ToUInt16(Event.vKeyCode);
kbInput.wScan = Convert.ToUInt16(Event.scanCode);
kbInput.dwFlags = keyState;
kbInput.time = 0;
kbInput.dwExtraInfo = Event.dwExtraInfo;
keyInput.iUinion.ki = kbInput;
InputList[0] = keyInput;
inputSize = Marshal.SizeOf(InputList[0]);
}
public static KeyEventInformation Get(HookData hookData)
{
WindowMessage message = (WindowMessage)hookData.wParam;
KEYBDINPUT keyboardStruct = Marshal.PtrToStructure <KEYBDINPUT>(hookData.lParam);
int scanCode = (int)keyboardStruct.wScan;
int timestamp = (int)keyboardStruct.time;
bool isKeyDown = message == WindowMessage.WM_KEYDOWN || message == WindowMessage.WM_KEYDOWN;
bool isKeyUp = message == WindowMessage.WM_KEYUP || message == WindowMessage.WM_KEYUP;
// If specified, the scan code was preceded by a prefix byte that has the value
// 0xE0 (224).
const uint maskExtendedKey = 0x1;
bool isKeyExtended = ((uint)keyboardStruct.dwFlags & maskExtendedKey) > 0;
Keys keyData = AppendModifierStates((Keys)keyboardStruct.wVk);
return(new KeyEventInformation(keyData, scanCode, timestamp, isKeyDown, isKeyUp, isKeyExtended));
}
/// <summary>
/// Sends a key up signal to the OS.
/// </summary>
/// <param name="virtualKey">The virtual key.</param>
public void SendKeyUp(ushort virtualLKey, ushort modifierKey)
{
// Send modifier key
var scan2 = (ushort)MapVirtualKey(modifierKey, 0);
var keyboardFlags2 = KEYEVENTF.KEYUP | KEYEVENTF.SCANCODE;
var keyboardInput2 = new KEYBDINPUT()
{
virtualKey = 0, scanCode = scan2, dwFlags = keyboardFlags2, time = 0, dwExtraInfo = IntPtr.Zero
};
var wrapper2 = new InputUnion()
{
ki = keyboardInput2
};
var up2 = new INPUT()
{
type = InputType.KEYBOARD, U = wrapper2
};
SendInput(1, new INPUT[] { up2 }, INPUT.Size);
// Send actual key
var scan = (ushort)MapVirtualKey(virtualLKey, 0);
var keyboardFlags = KEYEVENTF.KEYUP | KEYEVENTF.SCANCODE;
var keyboardInput = new KEYBDINPUT()
{
virtualKey = 0, scanCode = scan, dwFlags = keyboardFlags, time = 0, dwExtraInfo = IntPtr.Zero
};
var wrapper = new InputUnion()
{
ki = keyboardInput
};
var up = new INPUT()
{
type = InputType.KEYBOARD, U = wrapper
};
SendInput(1, new INPUT[] { up }, INPUT.Size);
}
// Token: 0x06000043 RID: 67 RVA: 0x000034B0 File Offset: 0x000016B0
public static void SendInputKeyPress(VirtualKeyCode vkCode)
{
INPUT input = default;
input.Type = 1U;
var keyboard = new KEYBDINPUT
{
KeyCode = (ushort)vkCode,
Scan = (ushort)User32.MapVirtualKey((uint)vkCode, 0),
Flags = (IsExtendedKey(vkCode) ? 1U : 0U),
Time = 0U,
ExtraInfo = IntPtr.Zero
};
input.Data.Keyboard = keyboard;
INPUT input2 = input;
input = default;
input.Type = 1U;
keyboard = new KEYBDINPUT
{
KeyCode = (ushort)vkCode,
Scan = (ushort)User32.MapVirtualKey((uint)vkCode, 0),
Flags = (IsExtendedKey(vkCode) ? 3U : 2U),
Time = 0U,
ExtraInfo = IntPtr.Zero
};
input.Data.Keyboard = keyboard;
INPUT input3 = input;
SendInput(new INPUT[]
{
input2,
input3
});
}
public void SendKey(uint in_wScanCode, bool in_bPress)
{
KEYBDINPUT k = new KEYBDINPUT();
k.wVk = 0;
k.dwFlags = KEYEVENTF_SCANCODE;
k.time = 0;
k.dwExtraInfo = IntPtr.Zero;
if ((in_wScanCode & 0xFF00) == 0xE000)
{ // extended key?
k.dwFlags |= KEYEVENTF_EXTENDEDKEY;
}
if (in_bPress)
{ // press?
k.wScan = (ushort)(in_wScanCode & 0xFF);
}
else
{ // release?
k.wScan = (ushort) in_wScanCode;
k.dwFlags |= KEYEVENTF_KEYUP;
}
INPUT input = new INPUT();
input.type = INPUT_KEYBOARD;
input.ki = k;
INPUT[] lstInput = new INPUT[] { input };
int iSize = Marshal.SizeOf(input);
uint result = SendInput(1, lstInput, iSize);
if (result != 1) throw new Exception("Could not send key: " + in_wScanCode);
}
//Send keyboard based input, use PressKey for a simpler handler.
public static bool SendInput(KEYBDINPUT keyboardInput)
{
INPUT[] inputs = new INPUT[1];
inputs[0].type = INPUT_KEYBOARD;
inputs[0].ki.dwFlags = keyboardInput.dwFlags;
inputs[0].ki.wScan = keyboardInput.wScan;
return SendInput(inputs);
}
public static uint sendInput(KEYBDINPUT[] inputs)
{
INPUT[] pInputs = new INPUT[inputs.Length];
for (int i = 0; i < inputs.Length; i++)
{
pInputs[i] = new INPUT()
{
type = INPUT_KEYBOARD,
inputunion = new InputUnion()
{
keyboardinput = inputs[i]
}
};
}
return sendInput(pInputs);
}
public void Zoom(int val)
{
INPUT inputs = new INPUT();
inputs.type = SendInputEventType.InputKeyboard;
KEYBDINPUT kb = new KEYBDINPUT(); //{0};
// generate down
/* if (bExtended)
kb.dwFlags = KEYEVENTF_EXTENDEDKEY;*/
kb.wVk = (ushort)0x11;
kb.time = 0;
inputs.mkhi.ki = kb;
SendInput(1, ref inputs, System.Runtime.InteropServices.Marshal.SizeOf(inputs));
this.Scroll(val);
// generate up
//ZeroMemory(&kb, sizeof(KEYBDINPUT));
//ZeroMemory(&inputs,sizeof(inputs));
kb.dwFlags = 0x0002;
/* if (bExtended)
kb.dwFlags |= KEYEVENTF_EXTENDEDKEY;*/
kb.wVk = (ushort)0x11;
kb.time = 0;
inputs.type = SendInputEventType.InputKeyboard;
inputs.mkhi.ki = kb;
SendInput(1, ref inputs, System.Runtime.InteropServices.Marshal.SizeOf(inputs));
}
private static void SendKeyboardInput(KEYBDINPUT keybInput)
{
INPUT input = new INPUT
{
Type = 1
};
input.Data.Keyboard = keybInput;
if (SendInput(1, new[] { input }, Marshal.SizeOf(typeof(INPUT))) == 0)
{
throw new Exception();
}
}
private static void SendKeyDown(KeyCode keyCode)
{
var input = new KEYBDINPUT
{
Vk = (ushort)keyCode
};
SendKeyboardInput(input);
}
private static void SendKeyUp(KeyCode keyCode)
{
var input = new KEYBDINPUT
{
Vk = (ushort)keyCode,
Flags = 2
};
SendKeyboardInput(input);
}
/// <summary>
/// If the program is started with capslock already enabled, we'll always have capslock enabled.
/// This isn't what we want (probably).
/// </summary>
public static void ValidateCAPSLOCKState()
{
var buffer = new Byte[256];
if (GetKeyboardState(buffer))
{
if (buffer[(Int32)VirtualKeyShort.CAPITAL] == 1) // capslock is active
{
// Note: SetKeyboardState apparently only works for win95, so let's synthesize the key instead.
var keyboardInput = new KEYBDINPUT();
keyboardInput.wVk = VirtualKeyShort.CAPITAL;
keyboardInput.dwExtraInfo = GetMessageExtraInfo();
var keyDown = new INPUT();
keyDown.type = INPUT_KEYBOARD;
keyDown.U.ki = keyboardInput;
var keyUp = keyDown;
keyUp.U.ki.dwFlags |= KEYEVENTF.KEYUP;
// Attempt to disable capslock, tough if this fails.
SendInput(1, new[] { keyDown }, Marshal.SizeOf(keyDown));
// Do not send the keyUp as part of the above array, it is ignored.
SendInput(1, new[] { keyUp }, Marshal.SizeOf(keyDown));
}
}
}
public static uint sendInput(KEYBDINPUT input)
{
var pInputs = new[] {
new INPUT()
{
type=INPUT_KEYBOARD,
inputunion=new InputUnion()
{
keyboardinput=input
}
}
};
return sendInput(pInputs);
}
private static void _SendSelectedLetterAsKeyPress(Boolean delayInput = false)
{
var pos = Caret.GetPosition(_sActiveKeyboardWindow);
var letter = _sActiveSelectorWindow.SelectedLetter;
_HidePopup();
try
{
if (!SetForegroundWindow(_sActiveKeyboardWindow))
// Something went wrong, ignore.
return;
}
catch (Win32Exception e)
{
// For reasons not yet understood we sometimes get a 0 error code turned into an exception (operation succeeded).
if (e.NativeErrorCode != 0)
return;
}
var keyboardInput = new KEYBDINPUT();
keyboardInput.wVk = 0; // required by unicode event
keyboardInput.wScan = (Int16)letter;
keyboardInput.dwFlags = KEYEVENTF.UNICODE;
keyboardInput.dwExtraInfo = GetMessageExtraInfo();
keyboardInput.time = 0;
var keyDown = new INPUT();
keyDown.type = INPUT_KEYBOARD;
keyDown.U.ki = keyboardInput;
var keyUp = keyDown;
keyUp.U.ki.dwFlags |= KEYEVENTF.KEYUP;
// If an error happens here it's probably due to UIPI, i.e. the target application is of higher integrity.
// We ignore the error.
if (delayInput)
ThreadPool.QueueUserWorkItem(context =>
{
// Just block for a bit.
Thread.Sleep(_kReleaseErrorMargin);
((SynchronizationContext)context).Post(_ =>
{
SendInput(1, new[] { keyDown }, Marshal.SizeOf(keyDown));
SendInput(1, new[] { keyUp }, Marshal.SizeOf(keyDown));
}, null);
}, SynchronizationContext.Current);
else
{
SendInput(1, new[] { keyDown, keyUp }, Marshal.SizeOf(keyDown));
SendInput(1, new[] { keyUp }, Marshal.SizeOf(keyDown));
}
}
private KEYBDINPUT createKeybdInput(short wVK, short wScan, uint flag)
{
KEYBDINPUT ki = new KEYBDINPUT();
ki.wVk = (ushort)wVK;
ki.wScan = (ushort)wScan;
ki.time = 0;
ki.dwExtraInfo = IntPtr.Zero;
ki.dwFlags = flag;
return ki;
}
public void releaseKey(ushort key)
{
INPUT[] inp = new INPUT[1];
inp[0].type = SendInputEventType.InputKeyboard;
KEYBDINPUT kin = new KEYBDINPUT();
kin.wVk = key;
inp[0].mkhi.ki = kin;
unsafe
{
inp[0].mkhi.ki.dwFlags = 2;
SendInput((uint)1, ref inp[0], sizeof(INPUT));
}
}
/// <summary>
/// Sends a key up signal to the OS.
/// </summary>
/// <param name="virtualKey">The virtual key.</param>
public void SendKeyUp(ushort virtualLKey)
{
var scan = (ushort)MapVirtualKey(virtualLKey, 0);
var keyboardFlags = KEYEVENTF.KEYUP | KEYEVENTF.SCANCODE;
var keyboardInput = new KEYBDINPUT() { virtualKey = 0, scanCode = scan, dwFlags = keyboardFlags, time = 0, dwExtraInfo = IntPtr.Zero };
var wrapper = new InputUnion() { ki = keyboardInput };
var up = new INPUT() { type = InputType.KEYBOARD, U = wrapper };
SendInput(1, new INPUT[] { up }, INPUT.Size);
}
internal static extern int SendKeyboardInput(int cInputs, ref KEYBDINPUT pInputs, int cbSize);
public static KEYBDINPUT CreateKeybdInput(ushort wVK, uint flag)
{
KEYBDINPUT i = new KEYBDINPUT();
i.wVk = wVK;
i.wScan = 0;
i.time = 0;
i.dwExtraInfo = IntPtr.Zero;
i.dwFlags = flag;
return i;
}
