/// <summary> /// Jiggle the mouse; i.e., fake a mouse movement event. /// </summary> /// <param name="delta">The mouse will be moved by delta pixels along both X and Y.</param> internal static void Jiggle(int delta) { var inp = new User32.INPUT { type = User32.InputType.INPUT_MOUSE, Inputs = new User32.INPUT.InputUnion { mi = new User32.MOUSEINPUT { dx = delta, dy = delta, mouseData = 0, dwFlags = User32.MOUSEEVENTF.MOUSEEVENTF_MOVE, time = 0, dwExtraInfo_IntPtr = IntPtr.Zero, }, }, }; uint returnValue = User32.SendInput(nInputs: 1, pInputs: new[] { inp, }, cbSize: Marshal.SizeOf <User32.INPUT> ()); if (returnValue != 1) { int errorCode = Marshal.GetLastWin32Error(); Debugger.Log(level: 1, category: "Jiggle", message: $"failed to insert event to input stream; retval={returnValue}, errcode=0x{errorCode:x8}\n"); } }
private void SendCharacter(char character) { var input = new User32.INPUT[] { new User32.INPUT() { Type = User32.INPUT_KEYBOARD, ki = new User32.KEYBDINPUT() { wVk = 0, wScan = character, dwFlags = User32.KEYEVENTF_UNICODE, time = 0, dwExtraInfo = IntPtr.Zero } }, new User32.INPUT() { Type = User32.INPUT_KEYBOARD, ki = new User32.KEYBDINPUT() { wVk = 0, wScan = character, dwFlags = User32.KEYEVENTF_UNICODE | User32.KEYEVENTF_KEYUP, time = 0, dwExtraInfo = IntPtr.Zero } } }; IntegrationHelper.SendInput(input); }
public uint SendMouseWheel(int deltaY, Viewer viewer) { Win32Interop.SwitchToInputDesktop(); if (deltaY < 0) { deltaY = -120; } else if (deltaY > 0) { deltaY = 120; } var union = new User32.InputUnion() { mi = new User32.MOUSEINPUT() { dwFlags = MOUSEEVENTF.WHEEL, dx = 0, dy = 0, time = 0, mouseData = deltaY, dwExtraInfo = GetMessageExtraInfo() } }; var input = new User32.INPUT() { type = InputType.MOUSE, U = union }; return(SendInput(1, new User32.INPUT[] { input }, INPUT.Size)); }
public void SendMouseWheel(int deltaY, Viewer viewer) { TryOnInputDesktop(() => { if (deltaY < 0) { deltaY = -120; } else if (deltaY > 0) { deltaY = 120; } var union = new User32.InputUnion() { mi = new User32.MOUSEINPUT() { dwFlags = MOUSEEVENTF.WHEEL, dx = 0, dy = 0, time = 0, mouseData = deltaY, dwExtraInfo = GetMessageExtraInfo() } }; var input = new User32.INPUT() { type = InputType.MOUSE, U = union }; SendInput(1, new User32.INPUT[] { input }, INPUT.Size); }); }
void SendMouseInput(Point point, User32.MOUSEEVENTF flags, long timestamp) { User32.INPUT[] input = new User32.INPUT[1]; input[0].type = User32.SendInputType.Mouse; input[0].U.mi.dx = (int)(point.X * 65535.0); input[0].U.mi.dy = (int)(point.Y * 65535.0); input[0].U.mi.dwFlags = flags; input[0].U.mi.time = 0; //(uint)timestamp / 1000; User32.SendInput(1, input, Marshal.SizeOf(typeof(User32.INPUT))); }
public static void SendMouseMove(int x, int y) { var inputs = new User32.INPUT[1]; inputs[0].type = User32.InputType.INPUT_MOUSE; inputs[0].Inputs.mi.dx = x; inputs[0].Inputs.mi.dy = y; inputs[0].Inputs.mi.dwFlags = User32.MOUSEEVENTF.MOUSEEVENTF_MOVE | User32.MOUSEEVENTF.MOUSEEVENTF_ABSOLUTE; SendInput(1, inputs); }
static void SendCharacter(char ch) { var inputs = new User32.INPUT[2]; inputs[0].type = User32.InputType.INPUT_KEYBOARD; inputs[0].Inputs.ki.wVk = (User32.VirtualKey)ch; inputs[1].type = User32.InputType.INPUT_KEYBOARD; inputs[1].Inputs.ki.wVk = (User32.VirtualKey)ch; inputs[1].Inputs.ki.dwFlags = User32.KEYEVENTF.KEYEVENTF_KEYUP; SendInput(inputs.Length, inputs); }
public static void SendUnicodeChar(char input) { var inputStruct = new User32.INPUT(); inputStruct.type = User32.INPUTTYPE.Keyboard; inputStruct.u.ki.virtualKey = 0; inputStruct.u.ki.scanCode = input; inputStruct.u.ki.time = 0; inputStruct.u.ki.flags = User32.KEYEVENTF.UNICODE; inputStruct.u.ki.extraInfo = User32.GetMessageExtraInfo(); User32.INPUT[] ip = { inputStruct }; User32.SendInput(1, ip, Marshal.SizeOf(inputStruct)); }
private unsafe static void SendMouseInput(int x, int y, User32.MOUSEEVENTF flags) { if ((flags & User32.MOUSEEVENTF.ABSOLUTE) != 0) { int vscreenWidth = User32.GetSystemMetrics(User32.SystemMetric.SM_CXVIRTUALSCREEN); int vscreenHeight = User32.GetSystemMetrics(User32.SystemMetric.SM_CYVIRTUALSCREEN); int vscreenLeft = User32.GetSystemMetrics(User32.SystemMetric.SM_XVIRTUALSCREEN); int vscreenTop = User32.GetSystemMetrics(User32.SystemMetric.SM_YVIRTUALSCREEN); const int DesktopNormilizedMax = 65536; // 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) * DesktopNormilizedMax) / vscreenWidth + DesktopNormilizedMax / (vscreenWidth * 2); y = ((y - vscreenTop) * DesktopNormilizedMax) / vscreenHeight + DesktopNormilizedMax / (vscreenHeight * 2); flags |= User32.MOUSEEVENTF.VIRTUALDESK; } var mouseInput = new User32.INPUT(); mouseInput.type = User32.INPUTENUM.MOUSE; mouseInput.inputUnion.mi.dx = x; mouseInput.inputUnion.mi.dy = y; mouseInput.inputUnion.mi.mouseData = 0; mouseInput.inputUnion.mi.dwFlags = flags; mouseInput.inputUnion.mi.time = 0; mouseInput.inputUnion.mi.dwExtraInfo = IntPtr.Zero; User32.SendInput(1, &mouseInput, Marshal.SizeOf(mouseInput)); }
public static void SendMouseClick(int x, int y) { var inputs = new User32.INPUT[3]; inputs[0].type = User32.InputType.INPUT_MOUSE; inputs[0].Inputs.mi.dx = x; inputs[0].Inputs.mi.dy = y; inputs[0].Inputs.mi.dwFlags = User32.MOUSEEVENTF.MOUSEEVENTF_MOVE | User32.MOUSEEVENTF.MOUSEEVENTF_ABSOLUTE; inputs[1].type = User32.InputType.INPUT_MOUSE; inputs[1].Inputs.mi.dwFlags = User32.MOUSEEVENTF.MOUSEEVENTF_LEFTDOWN; inputs[2].type = User32.InputType.INPUT_MOUSE; inputs[2].Inputs.mi.dwFlags = User32.MOUSEEVENTF.MOUSEEVENTF_LEFTUP; SendInput(3, inputs); }
public static void SendKeyPressedEvent(Keys code, bool isKeyUp) { var input = new User32.INPUT(); //TODO: consider moving this code into a factory input.type = User32.INPUTTYPE.INPUT_KEYBOARD; input.ki = new User32.KEYBDINPUT(); input.ki.time = 0; input.ki.dwFlags = isKeyUp ? User32.KEYEVENTF.KEYEVENTF_KEYUP | User32.KEYEVENTF.KEYEVENTF_SCANCODE : 0 | User32.KEYEVENTF.KEYEVENTF_SCANCODE; input.ki.dwExtraInfo = UIntPtr.Zero; input.ki.wScan = (ushort)KeysHelper.GetScanCode(code); input.ki.wVk = 0; User32.SendInput(1, new[] { input }, Marshal.SizeOf(typeof(User32.INPUT))); }
private unsafe void SendKey(Keys key, bool down) { var input = new User32.INPUT(); input.type = User32.INPUTENUM.KEYBOARD; input.inputUnion.ki.wVk = (ushort)key; input.inputUnion.ki.dwFlags = 0; input.inputUnion.ki.dwExtraInfo = IntPtr.Zero; input.inputUnion.ki.time = 0; input.inputUnion.ki.wScan = 0; if (!down) { input.inputUnion.ki.dwFlags |= User32.KEYEVENTF.KEYUP; } User32.SendInput(1, &input, Marshal.SizeOf(input)); }
private static uint SendKeyAction(bool keyDown, User32.VirtualKey virtualKey) { var key = new User32.INPUT { type = User32.InputType.INPUT_KEYBOARD, Inputs = new User32.INPUT.InputUnion() { ki = new User32.KEYBDINPUT() { dwFlags = (keyDown ? 0 : User32.KEYEVENTF.KEYEVENTF_KEYUP), wVk = virtualKey } } }; var inputs = new[] { key }; var response = User32.SendInput(inputs.Length, inputs, Marshal.SizeOf(key)); return(response); }
public static void SendKey(Keys key) { int vk = (int)key; int scan = User32.MapVirtualKey(vk, User32.MapVirtualKeyTranslation.MAPVK_VK_TO_VSC); User32.INPUT[] inputs = new User32.INPUT[2]; inputs[0].type = User32.InputType.INPUT_KEYBOARD; inputs[0].Inputs.ki.wVk = (User32.VirtualKey)vk; inputs[0].Inputs.ki.wScan = (User32.ScanCode)scan; inputs[0].Inputs.ki.dwFlags = 0; inputs[0].Inputs.ki.dwExtraInfo_IntPtr = IntPtr.Zero; inputs[0].Inputs.ki.time = 0; inputs[1].type = User32.InputType.INPUT_KEYBOARD; inputs[1].Inputs.ki.wVk = (User32.VirtualKey)vk; inputs[1].Inputs.ki.wScan = (User32.ScanCode)scan; inputs[1].Inputs.ki.dwFlags = User32.KEYEVENTF.KEYEVENTF_KEYUP; inputs[1].Inputs.ki.dwExtraInfo_IntPtr = IntPtr.Zero; inputs[1].Inputs.ki.time = 0; User32.SendInput(inputs.Length, inputs, Marshal.SizeOf(inputs[0])); }
private static uint SendKeyAction(bool keyDown, User32.ScanCode scanCode, bool extended) { var key = new User32.INPUT { type = User32.InputType.INPUT_KEYBOARD, Inputs = new User32.INPUT.InputUnion() { ki = new User32.KEYBDINPUT() { dwFlags = User32.KEYEVENTF.KEYEVENTF_SCANCODE | (extended ? User32.KEYEVENTF.KEYEVENTF_EXTENDED_KEY : 0) | (keyDown ? 0 : User32.KEYEVENTF.KEYEVENTF_KEYUP), wScan = scanCode } } }; var inputs = new[] { key }; var response = User32.SendInput(inputs.Length, inputs, Marshal.SizeOf(key)); return(response); }
static private void SetKey(KeyboardKey key, bool down) { if (is_down[(ushort)key] == down) { return; } is_down[(ushort)key] = down; User32.INPUT[] input_data = new User32.INPUT[1]; input_data[0] = new User32.INPUT(); input_data[0].type = (int)User32.InputType.INPUT_KEYBOARD; input_data[0].ki.dwFlags = 0; if ((int)key > 0x8000) { input_data[0].ki.wVk = (ushort)(key - 0x8000); // input_data[0].ki.dwFlags |= (uint)User32.SendInputFlags.KEYEVENTF_EXTENDEDKEY; } else { input_data[0].ki.wScan = (ushort)key; input_data[0].ki.dwFlags |= (uint)User32.SendInputFlags.KEYEVENTF_SCANCODE; } if (!down) { input_data[0].ki.dwFlags |= (uint)User32.SendInputFlags.KEYEVENTF_KEYUP; } uint result = User32.SendInput(1, input_data, Marshal.SizeOf(input_data[0])); if (result != 1) { Console.WriteLine("SendInput result != 1 {=" + result + "}"); } }
private void SendKey(ushort vk, uint dwFlags) { var input = new User32.INPUT[] { new User32.INPUT() { Type = User32.INPUT_KEYBOARD, ki = new User32.KEYBDINPUT() { wVk = vk, wScan = 0, dwFlags = dwFlags, time = 0, dwExtraInfo = IntPtr.Zero } } }; if (IsExtendedKey(vk)) { input[0].ki.dwFlags |= User32.KEYEVENTF_EXTENDEDKEY; } IntegrationHelper.SendInput(input); }
private void SendZalgo(object amount) { Thread.Sleep(1); // wait for event to be registered User32.INPUT[] inputs = new User32.INPUT[(int) amount * 2]; char previousZalgo = '\u0000'; for (int i = 0; i < inputs.Length; i++) { if (i % 2 == 0) previousZalgo = GetZalgo(); inputs[i].type = 1; // keyboard event inputs[i].U.ki.wVk = 0; inputs[i].U.ki.wScan = (User32.ScanCodeShort) previousZalgo; inputs[i].U.ki.dwFlags = i % 2 == 0 ? User32.KEYEVENTF.UNICODE : User32.KEYEVENTF.UNICODE | User32.KEYEVENTF.KEYUP; inputs[i].U.ki.time = 0; inputs[i].U.ki.dwExtraInfo = UIntPtr.Zero; } User32.SendInput((uint) inputs.Length, inputs, Marshal.SizeOf<User32.INPUT>()); }
public static void SendKey(bool sendDown, bool sendUp, KeyName keyName) { var code = User32.VirtualKey.VK_NO_KEY; switch (keyName) { case KeyName.Backspace: code = User32.VirtualKey.VK_BACK; break; case KeyName.Tab: code = User32.VirtualKey.VK_TAB; break; case KeyName.Enter: code = User32.VirtualKey.VK_RETURN; break; case KeyName.Space: code = User32.VirtualKey.VK_SPACE; break; case KeyName.Home: code = User32.VirtualKey.VK_HOME; break; case KeyName.End: code = User32.VirtualKey.VK_END; break; case KeyName.Delete: code = User32.VirtualKey.VK_DELETE; break; case KeyName.PageUp: code = User32.VirtualKey.VK_PRIOR; break; case KeyName.PageDown: code = User32.VirtualKey.VK_NEXT; break; case KeyName.ArrowUp: code = User32.VirtualKey.VK_UP; break; case KeyName.ArrowDown: code = User32.VirtualKey.VK_DOWN; break; case KeyName.ArrowLeft: code = User32.VirtualKey.VK_LEFT; break; case KeyName.ArrowRight: code = User32.VirtualKey.VK_RIGHT; break; case KeyName.F1: code = User32.VirtualKey.VK_F1; break; case KeyName.F2: code = User32.VirtualKey.VK_F2; break; case KeyName.F3: code = User32.VirtualKey.VK_F3; break; case KeyName.F4: code = User32.VirtualKey.VK_F4; break; case KeyName.F5: code = User32.VirtualKey.VK_F5; break; case KeyName.F6: code = User32.VirtualKey.VK_F6; break; case KeyName.F7: code = User32.VirtualKey.VK_F7; break; case KeyName.F8: code = User32.VirtualKey.VK_F8; break; case KeyName.F9: code = User32.VirtualKey.VK_F9; break; case KeyName.F10: code = User32.VirtualKey.VK_F10; break; case KeyName.F11: code = User32.VirtualKey.VK_F11; break; case KeyName.F12: code = User32.VirtualKey.VK_F12; break; case KeyName.Escape: code = User32.VirtualKey.VK_ESCAPE; break; } if (code != 0 && (sendDown || sendUp)) { var inputs = new User32.INPUT[2]; inputs[0].type = User32.InputType.INPUT_KEYBOARD; inputs[0].Inputs.ki.wVk = code; inputs[0].Inputs.ki.dwFlags = sendDown ? 0 : User32.KEYEVENTF.KEYEVENTF_KEYUP; inputs[1].type = User32.InputType.INPUT_KEYBOARD; inputs[1].Inputs.ki.wVk = code; inputs[1].Inputs.ki.dwFlags = User32.KEYEVENTF.KEYEVENTF_KEYUP; SendInput((sendUp && sendDown) ? 2 : 1, inputs); } }
public static void SendText(bool isShift, bool isCtrl, bool isAlt, bool isWindows, String text) { var length = text.Length; for (var i = 0; i < length; i++) { var ch = text[i]; var code = VkKeyScan(ch); if ((code & 0xFFFF) != 0xFFFF) { var isShiftNeeded = isShift || (code & 0x0100) != 0; var isCtrlNeeded = isCtrl || (code & 0x0200) != 0; var isAltNeeded = isAlt || (code & 0x0400) != 0; //var isHankakuNeeded = !!(code & 0x0800); var inputs = new User32.INPUT[8]; var count = 0; if (isShiftNeeded) { inputs[count].type = User32.InputType.INPUT_KEYBOARD; inputs[count].Inputs.ki.wVk = User32.VirtualKey.VK_SHIFT; count++; } if (isCtrlNeeded) { inputs[count].type = User32.InputType.INPUT_KEYBOARD; inputs[count].Inputs.ki.wVk = User32.VirtualKey.VK_CONTROL; count++; } if (isAltNeeded) { inputs[count].type = User32.InputType.INPUT_KEYBOARD; inputs[count].Inputs.ki.wVk = User32.VirtualKey.VK_MENU; count++; } inputs[count].type = User32.InputType.INPUT_KEYBOARD; inputs[count].Inputs.ki.wVk = (User32.VirtualKey)((int)code & 0xFF); count++; var countdown = count; while (countdown != 0) { countdown--; inputs[count].type = inputs[countdown].type; inputs[count].Inputs.ki.wVk = inputs[countdown].Inputs.ki.wVk; inputs[count].Inputs.ki.dwFlags = inputs[countdown].Inputs.ki.dwFlags ^ User32.KEYEVENTF.KEYEVENTF_KEYUP; count++; } SendInput(count, inputs); } else { Debug.WriteLine($"Cannot send {ch}"); } } }