/// <summary>
/// Inject keyboard input into the system
/// </summary>
/// <param name="key">indicates the key pressed or released. Can be one of the constants defined in the Key enum</param>
/// <param name="press">true to inject a key press, false to inject a key release</param>
public static void SendKeyboardInput(Key key, bool press)
{
Win32.INPUT ki = new Win32.INPUT();
ki.type = Win32.INPUT_KEYBOARD;
ki.union.keyboardInput.wVk = (short)KeyInterop.VirtualKeyFromKey(key);
ki.union.keyboardInput.wScan = (short)Win32.MapVirtualKey(ki.union.keyboardInput.wVk, 0);
int dwFlags = 0;
if (ki.union.keyboardInput.wScan > 0)
{
dwFlags |= Win32.KEYEVENTF_SCANCODE;
}
if (false == press)
{
dwFlags |= Win32.KEYEVENTF_KEYUP;
}
ki.union.keyboardInput.dwFlags = dwFlags;
if (IsExtendedKey(key))
{
ki.union.keyboardInput.dwFlags |= Win32.KEYEVENTF_EXTENDEDKEY;
}
ki.union.keyboardInput.time = Environment.TickCount;
ki.union.keyboardInput.dwExtraInfo = new IntPtr(0);
if (0 == Win32.SendInput(1, ref ki, Marshal.SizeOf(ki)))
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
}
public static void SendMouseInput(double x, double y, int data, SendMouseInputFlags flags, int mouseData)
{
int intflags = (int)flags;
if ((intflags & (int)SendMouseInputFlags.Absolute) != 0)
{
int vscreenWidth = Win32.GetSystemMetrics(Win32.SM_CXVIRTUALSCREEN);
int vscreenHeight = Win32.GetSystemMetrics(Win32.SM_CYVIRTUALSCREEN);
int vscreenLeft = Win32.GetSystemMetrics(Win32.SM_XVIRTUALSCREEN);
int vscreenTop = Win32.GetSystemMetrics(Win32.SM_YVIRTUALSCREEN);
// Absolute input requires that input is in 'normalized' coords - with the entire
// desktop being (0,0)...(65535,65536). Need to convert input x,y coords to this
// first.
//
// In this normalized world, any pixel on the screen corresponds to a block of values
// of normalized coords - eg. on a 1024x768 screen,
// y pixel 0 corresponds to range 0 to 85.333,
// y pixel 1 corresponds to range 85.333 to 170.666,
// y pixel 2 correpsonds to range 170.666 to 256 - and so on.
// Doing basic scaling math - (x-top)*65536/Width - gets us the start of the range.
// However, because int math is used, this can end up being rounded into the wrong
// pixel. For example, if we wanted pixel 1, we'd get 85.333, but that comes out as
// 85 as an int, which falls into pixel 0's range - and that's where the pointer goes.
// To avoid this, we add on half-a-"screen pixel"'s worth of normalized coords - to
// push us into the middle of any given pixel's range - that's the 65536/(Width*2)
// part of the formula. So now pixel 1 maps to 85+42 = 127 - which is comfortably
// in the middle of that pixel's block.
// The key ting here is that unlike points in coordinate geometry, pixels take up
// space, so are often better treated like rectangles - and if you want to target
// a particular pixel, target its rectangle's midpoint, not its edge.
x = ((x - vscreenLeft) * 65536) / vscreenWidth + 65536 / (vscreenWidth * 2);
y = ((y - vscreenTop) * 65536) / vscreenHeight + 65536 / (vscreenHeight * 2);
intflags |= Win32.MOUSEEVENTF_VIRTUALDESK;
}
Win32.INPUT mi = new Win32.INPUT();
mi.type = Win32.INPUT_MOUSE;
mi.union.mouseInput.dx = (int)x;
mi.union.mouseInput.dy = (int)y;
mi.union.mouseInput.mouseData = data;
mi.union.mouseInput.dwFlags = intflags;
mi.union.mouseInput.time = 0;
mi.union.mouseInput.dwExtraInfo = new IntPtr(0);
mi.union.mouseInput.mouseData = mouseData;
if (Win32.SendInput(1, ref mi, Marshal.SizeOf(mi)) == 0)
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
}
// Used internally by the HWND SetFocus code - it sends a hotkey to
// itself - because it uses a VK that's not on the keyboard, it needs
// to send the VK directly, not the scan code, which regular
// SendKeyboardInput does.
// Note that this method is public, but this class is private, so
// this is not externally visible.
internal static void SendKeyboardInputVK(byte vk, bool press)
{
Win32.INPUT ki = new Win32.INPUT();
ki.type = Win32.INPUT_KEYBOARD;
ki.union.keyboardInput.wVk = vk;
ki.union.keyboardInput.wScan = 0;
ki.union.keyboardInput.dwFlags = press ? 0 : Win32.KEYEVENTF_KEYUP;
ki.union.keyboardInput.time = 0;
ki.union.keyboardInput.dwExtraInfo = new IntPtr(0);
if (0 == Win32.SendInput(1, ref ki, Marshal.SizeOf(ki)))
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
}
/// <summary>
/// Injects a unicode character as keyboard input into the system
/// </summary>
/// <param name="key">indicates the key to be pressed or released. Can be any unicode character</param>
/// <param name="press">true to inject a key press, false to inject a key release</param>
public static void SendUnicodeKeyboardInput(char key, bool press)
{
Win32.INPUT ki = new Win32.INPUT();
ki.type = Win32.INPUT_KEYBOARD;
ki.union.keyboardInput.wVk = (short)0;
ki.union.keyboardInput.wScan = (short)key;
ki.union.keyboardInput.dwFlags = Win32.KEYEVENTF_UNICODE | (press ? 0 : Win32.KEYEVENTF_KEYUP);
ki.union.keyboardInput.time = Environment.TickCount;
ki.union.keyboardInput.dwExtraInfo = new IntPtr(0);
if (0 == Win32.SendInput(1, ref ki, Marshal.SizeOf(ki)))
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
}