private static void DoKeyboard(KEYEVENTF flags, KEYEVENTF dwflag)
{
INPUT[] inputs = new INPUT[]
{
new INPUT
{
type = INPUT_KEYBOARD,
u = new InputUnion
{
ki = new KEYBDINPUT
{
wVk = (short)flags,
wScan = 0,
dwFlags = dwflag,
time = 0,
dwExtraInfo = IntPtr.Zero,
}
}
}
};
int cbSize = Marshal.SizeOf(typeof(INPUT));
int result = SendInput(inputs.Length, inputs, cbSize);
if (result == 0)
{
Debug.WriteLine(Marshal.GetLastWin32Error());
}
}
private KEYBDINPUT(VK vk, ushort scan, KEYEVENTF flags)
{
_wVk = vk;
_wScan = scan;
_dwFlags = flags;
_time = 0;
_dwExtraInfo = IntPtr.Zero;
}
public KEYBDINPUT(ushort wVk, bool isUp)
{
this.wVk = wVk;
wScan = 0;
dwFlags = isUp ? KEYEVENTF.KEYUP : 0;
time = 0;
dwExtraInfo = UIntPtr.Zero;
}
public INPUT(uint type, ScanCodeShort scan, KEYEVENTF flags)
{
this.type = type;
this.U = new InputUnion {
ki = new KEYBDINPUT {
wScan = scan, dwFlags = flags
}
};
}
public static void InputKeyboardKey(ScanCodeShort scs, KEYEVENTF flags = KEYEVENTF.SCANCODE)
{
INPUT[] Inputs = new INPUT[1];
Inputs[0].type = 1; // 1 = Keyboard Input
Inputs[0].U.ki.wScan = scs;
Inputs[0].U.ki.dwFlags = flags;
SendInput(1, Inputs, INPUT.Size);
}
public void KeyUpOrDown(Key key)
{
bool down = (this.keyboard.GetKeyStates(key) & KeyStates.Down) > 0;
logger.Debug("Toggle the (modifier) key ({0}), currently pressed? {1}", key, down);
KEYEVENTF type = down ? KEYEVENTF.KEYUP : KEYEVENTF.KEYDOWN;
this.SendKeyboardInput(key, type);
}
private static INPUT[] GetKeyInput(KEYEVENTF keyEvent, ScanCodeShort scanCode = 0)
{
INPUT[] KeyInput = new INPUT[1];
KeyInput[0].type = 1;
KeyInput[0].U.ki.wVk = 0;
KeyInput[0].U.ki.dwFlags = keyEvent;
KeyInput[0].U.ki.wScan = scanCode;
return(KeyInput);
}
public void SendUp(ScanCodeShort a, KEYEVENTF keyType)
{
if (keyType == KEYEVENTF.SCANCODE)
{
_InputKeyLib.VSendUp(a);
}
else if (keyType == KEYEVENTF.EXTENDEDKEY)
{
_InputKeyLib.SendUp(a);
}
}
public static void SendInputWithAPI(ScanCodeShort keycode, KEYEVENTF ev)
{
MemLib.INPUT[] Inputs = new MemLib.INPUT[4];
MemLib.INPUT Input = new MemLib.INPUT();
Input.type = 1; // 1 = Keyboard Input
Input.U.ki.wScan = keycode;
Input.U.ki.dwFlags = ev;
Inputs[0] = Input;
SendInput(1, Inputs, MemLib.INPUT.Size);
}
private KEYEVENTF CheckGetExtendedKey(VirtualKeyCode virtualKey)
{
KEYEVENTF k = KEYEVENTF.KEYDOWN;
if (virtualKey == VirtualKeyCode.UP || virtualKey == VirtualKeyCode.DOWN || virtualKey == VirtualKeyCode.LEFT ||
virtualKey == VirtualKeyCode.RIGHT || virtualKey == VirtualKeyCode.HOME || virtualKey == VirtualKeyCode.END ||
virtualKey == VirtualKeyCode.PRIOR || virtualKey == VirtualKeyCode.NEXT ||
virtualKey == VirtualKeyCode.INSERT || virtualKey == VirtualKeyCode.DELETE)
{
k = KEYEVENTF.EXTENDEDKEY;
}
return(k);
}
private void Send(Input key, KEYEVENTF flag)
{
INPUT[] inputs = new INPUT[1];
INPUT input = new INPUT();
input.type = 1; // 1 = Keyboard Input
input.ki.wScan = 0;
input.ki.time = 0;
input.ki.dwExtraInfo = IntPtr.Zero;
input.ki.wVk = key;
input.ki.dwFlags = flag;
inputs[0] = input;
SendInput(1, inputs, INPUT.Size);
}
static INPUT GenerateKeystoke(VirtualKeyShort key, KEYEVENTF flags = 0)
{
return(new INPUT
{
type = 1,
U = new InputUnion
{
ki = new KEYBDINPUT
{
wVk = key,
dwFlags = flags,
wScan = 0
}
}
});
}
static INPUT GenerateKeystoke(VirtualKeyShort key, KEYEVENTF flags = 0)
{
return new INPUT()
{
type = 1,
U = new InputUnion()
{
ki = new KEYBDINPUT()
{
wVk = key,
dwFlags = flags,
wScan = 0
}
}
};
}
public static LPINPUT CreateKeyboardScancodeInput(short scancode, KEYEVENTF flags)
{
return(new LPINPUT
{
type = (int)InputType.KEYBOARD,
Data = new InputUnion
{
ki = new KEYBDINPUT
{
wVk = 0,
wScan = scancode,
dwFlags = flags | KEYEVENTF.SCANCODE,
dwExtraInfo = UIntPtr.Zero
}
}
});
}
private void SendKeyboardInput(int vkey, KEYEVENTF type)
{
INPUT input = new INPUT
{
type = (int)INPUTTYPE.KEYBOARD,
u = new InputUnion
{
ki = new KEYBDINPUT
{
wVk = (ushort)vkey,
wScan = 0,
dwFlags = (uint)type,
dwExtraInfo = this.winUser.GetMessageExtraInfo(),
}
}
};
this.winUser.SendInput(1, new INPUT[] { input }, Marshal.SizeOf(typeof(INPUT)));
}
public static extern unsafe void keybd_event(byte bVk, byte bScan, KEYEVENTF dwFlags, void* dwExtraInfo);
private static void SendKeyPress(VK vk, KEYEVENTF flags = 0)
{
SendKeyDown(vk, flags);
SendKeyUp(vk, flags);
}
private static void SendKeyUp(VK vk, KEYEVENTF flags = 0)
{
NativeMethods.keybd_event(vk, 0, KEYEVENTF.KEYUP | flags, 0);
}
private static void SendKeyDown(VK vk, KEYEVENTF flags = 0)
{
NativeMethods.keybd_event(vk, 0, flags, 0);
}
public static extern void keybd_event(VK vk, SC sc, KEYEVENTF flags,
int dwExtraInfo);
private static void SendKeyPress(VK vk, KEYEVENTF flags = 0)
{
SendKeyDown(vk, flags);
SendKeyUp(vk, flags);
}
private void SendKeyboardInput(int vkey, KEYEVENTF type)
{
INPUT input = new INPUT
{
type = (int)INPUTTYPE.KEYBOARD,
u = new InputUnion
{
ki = new KEYBDINPUT
{
wVk = (ushort)vkey,
wScan = 0,
dwFlags = (uint)type,
dwExtraInfo = this.winUser.GetMessageExtraInfo(),
}
}
};
this.winUser.SendInput(1, new INPUT[] { input }, Marshal.SizeOf(typeof(INPUT)));
}
private static void SendKeyDown(VK vk, KEYEVENTF flags = 0)
{
NativeMethods.keybd_event(vk, 0, flags, 0);
}
public static extern void keybd_event(
VK bVk,
Byte bScan,
KEYEVENTF dwFlags,
Int32 dwExtraInfo);
public static extern void keybd_event(
byte bVk,
byte bScan,
KEYEVENTF dwFlags,
uint dwExtraInfo);
public static void Event( VKeyCode vk, byte scan, KEYEVENTF flags, UIntPtr extra )
{
keybd_event( (byte)vk, scan, (byte)flags, extra );
}
private void SendKeyboardInput(Key key, KEYEVENTF type)
{
this.SendKeyboardInput(this.keyInterop.VirtualKeyFromKey(key), type);
}
public static extern void keybd_event(byte bVk, byte bScan, KEYEVENTF dwFlags, IntPtr dwExtraInfo);
public void CreateInput(uint key, bool isDown, bool isExtended = false)
{
KEYEVENTF up = 0;
if (isExtended)
{
up = KEYEVENTF.EXTENDEDKEY;
}
key = MapVirtualKey(key, 0);
if (!hasInitialized)
{
inputs[inputcount].type = INPUT_KEYBOARD;
inputs[inputcount].U.ki.wScan = (short)key;
if (isDown)
{
inputs[inputcount].U.ki.dwFlags = KEYEVENTF.SCANCODE | up;
}
else
{
inputs[inputcount].U.ki.dwFlags = KEYEVENTF.SCANCODE | KEYEVENTF.KEYUP | up;
}
inputs[inputcount].U.ki.time = 0;
inputs[inputcount].U.ki.dwExtraInfo = UIntPtr.Zero;
inputs[inputcount].U.ki.wVk = 0;
inputcount++;
}
else
{
if ((inputs[inputcount].U.ki.dwFlags == (KEYEVENTF.SCANCODE | up) && isDown == true) || (inputs[inputcount].U.ki.dwFlags == (KEYEVENTF.KEYUP | up) && isDown == false))
{
inputs[inputcount].type = INPUT_KEYBOARD;
inputs[inputcount].U.ki.wScan = (short)key;
if (isDown)
{
inputs[inputcount].U.ki.dwFlags = KEYEVENTF.SCANCODE | up;
}
else
{
inputs[inputcount].U.ki.dwFlags = KEYEVENTF.SCANCODE | KEYEVENTF.KEYUP | up;
}
inputs[inputcount].U.ki.time = 0;
inputs[inputcount].U.ki.dwExtraInfo = UIntPtr.Zero;
inputs[inputcount].U.ki.wVk = 0;
inputcount++;
return;
}
inputs_out[output].type = INPUT_KEYBOARD;
inputs_out[output].U.ki.wScan = (short)key;
if (isDown)
{
inputs_out[output].U.ki.dwFlags = KEYEVENTF.SCANCODE | up;
}
else
{
inputs_out[output].U.ki.dwFlags = KEYEVENTF.SCANCODE | KEYEVENTF.KEYUP | up;
}
inputs_out[output].U.ki.time = 0;
inputs_out[output].U.ki.dwExtraInfo = UIntPtr.Zero;
inputs_out[output].U.ki.wVk = 0;
inputs[inputcount].type = INPUT_KEYBOARD;
inputs[inputcount].U.ki.wScan = (short)key;
if (isDown)
{
inputs[inputcount].U.ki.dwFlags = KEYEVENTF.SCANCODE | up;
}
else
{
inputs[inputcount].U.ki.dwFlags = KEYEVENTF.SCANCODE | KEYEVENTF.KEYUP | up;
}
inputs[inputcount].U.ki.time = 0;
inputs[inputcount].U.ki.dwExtraInfo = UIntPtr.Zero;
inputs[inputcount].U.ki.wVk = 0;
inputcount++;
output++;
}
}
private static void SendKeyUp(VK vk, KEYEVENTF flags = 0)
{
NativeMethods.keybd_event(vk, 0, KEYEVENTF.KEYUP | flags, 0);
}
public static extern void keybd_event(VK vk, SC sc, KEYEVENTF flags,
int dwExtraInfo);
private void SendKeyboardInput(Key key, KEYEVENTF type)
{
this.SendKeyboardInput(this.keyInterop.VirtualKeyFromKey(key), type);
}
