键盘鼠标模拟全知道（Delphi）
（整理自网络，如有侵权立删）
本文目录导航
一、基于windows 消息机制的鼠标键盘模拟
（一）、针对指定程序（窗口）模拟（PostMessage）——局部模拟(可后台)
1、模拟键盘按键。
2、模拟鼠标
3、例子
4、附录：获取窗口句柄handle
1） WindowFromPoint
2）FindWindow/FindWindowEx或者用GetWindow来遍历查找，
3）通过进程的文件名来查找窗口句柄。
（二）全局模拟
1、用API函数keybd_event和mouse_event。
1）函数keybd_event模拟键盘
2）mouse_event模拟按下鼠标
2、SendInput函数也可以模拟全局键盘鼠标事件。
1）键盘模拟
2）鼠标模拟
3) 附录： SIMouseKeyboard.pas的使用 ——利用SendInput模拟鼠标键盘的输入
4）SendInput模拟键盘输入应注意的问题
5）SendInput与WInIo的对比
3、用全局钩子也可以模拟键盘消息。
二、驱动级模拟（绕过windows消息）——WINIO模拟按键
*******************************************************************************************
一、基于windows 消息机制的鼠标键盘模拟
我们怎样才能用Delphi来写一个程序，用来代替人们按键的方法呢？那就让我们来先了解一下windows中响应键盘事件的机制。
当用户按下键盘上的一个键时，键盘内的芯片会检测到这个动作，并把这个信号传送到计算机。如何区别是哪一个键被按下了呢？键盘上的所有按键都有一个编码，称作键盘扫描码。当你按下一个键时，这个键的扫描码就被传给系统。扫描码是跟具体的硬件相关的，同一个键，在不同键盘上的扫描码有可能不同。键盘控制器就是将这个扫描码传给计算机，然后交给键盘驱动程序。键盘驱动程序会完成相关的工作，并把这个扫描码转换为键盘虚拟码。什么是虚拟码呢？因为扫描码与硬件相关，不具有通用性，为了统一键盘上所有键的编码，于是就提出了虚拟码概念。无论什么键盘，同一个按键的虚拟码总是相同的，这样程序就可以识别了。简单点说，虚拟码就是我们经常可以看到的像VK_A,VK_B这样的常数，比如键A的虚拟码是65，写成16进制就是&H41，注意，人们经常用16进制来表示虚拟码。当键盘驱动程序把扫描码转换为虚拟码后，会把这个键盘操作的扫描码和虚拟码还有其它信息一起传递给操作系统。然后操作系统则会把这些信息封装在一个消息中，并把这个键盘消息插入到消息列队。最后，要是不出意外的话，这个键盘消息最终会被送到当前的活动窗口那里，活动窗口所在的应用程序接收到这个消息后，就知道键盘上哪个键被按下，也就可以决定该作出什么响应给用户了。
这个过程可以简单的如下表示：
用户按下键盘上的一个键 >>>>> 键盘控制器就把这个键的扫描码传给计算机，然后交给键盘驱动程序 >>>>> 键盘驱动程序会把这个扫描码转换为键盘虚拟码(VK_A,VK_B这样的常数，比如键A的虚拟码是65，写成16进制就是&H41)传给操作系统 >>>>> 操作系统则会把这些信息封装在一个消息中，并把这个键盘消息插入到消息列队 >>>>> 键盘消息被发送到当前活动窗口 >>>>>活动窗口所在的应用程序接收到这个消息后，就知道键盘上哪个键被按下，也就可以决定该作出什么响应给用户了。
明白了这个过程，我们就可以编程实现在其中的某个环节来模拟键盘操作了。在Delphi中，有多种方法可以实现键盘模拟，我们就介绍几种比较典型的。
（一）、针对指定程序（窗口）模拟（PostMessage）——局部模拟(可后台)
windows提供了几个这样的API函数可以实现直接向目标程序发送消息的功能，常用的有SendMessage和PostMessage，它们的区别是PostMessage函数直接把消息仍给目标程序就不管了，而SendMessage把消息发出去后，还要等待目标程序返回些什么东西才好。这里要注意的是，模拟键盘消息一定要用PostMessage函数才好，用SendMessage是不正确的(因为模拟键盘消息是不需要返回值的，不然目标程序会没反应)，切记切记！
PostMessage函数的delphi声明如下：
PostMessage(
hWnd: HWND; {目标程序上某个控件的句柄}
Msg: UINT; {消息的类型}
wParam: WPARAM; {32位指定附加的消息特定的信息}
lParam: LPARAM {32位指定附加的消息特定的信息}
): BOOL;
参数hwnd 是你要发送消息的目标程序上某个控件的句柄，
参数Msg 是消息的类型，表示你要发送什么样的消息，
参数wParam 和lParam这两个参数是随消息附加的数据，具体内容要由消息决定。
参数Msg 这个，要模拟按键就靠这个了。
键盘消息参数Msg常用的有如下几个：
WM_KEYDOWN 表示一个普通键被按下
WM_KEYUP 表示一个普通键被释放
WM_SYSKEYDOWN 表示一个系统键被按下，比如Alt键
WM_SYSKEYUP 表示一个系统键被释放，比如Alt键
鼠标消息参数Msg：
WM_LBUTTONDOWN //左键按下
WM_RBUTTONDOWN //右键按下
WM_MBUTTONDOWN //中间键按下
WM_LButtonUp //左键放开
WM_RbuttonUp //右键放开
WM_MButtonUp //中键放开
WM_LBUTTONDBLCLK //左键双击
WM_RBUTTONDBLCLK //左键双击
WM_MBUTTONDBLCLK //中键双击
1、模拟键盘事件。
应用程序从 Windows 接收的关于键盘事件的消息可分为击键消息和字符消息两种。这与你看待键盘的两种方式是一致的。首先，你可以认为键盘是键的集合。键盘上仅有一个键表示为“A”。按下此键是一次击键，释放此键也认为是一次击键。同时键盘也是能产生可显示字符或者控制字符的输入设备。有些键不产生字母，如 Shift 键、功能键、光标移动键和特殊字符键（如 Insert 键和 Delete 键）。对于这些键，Windows 只产生击键消息。
一般有以下四个击键消息：
WM_KEYDOWN、WM_SYSKEYDOWN、WM_KEYUP、WM_SYSKEYUP。这里分为系统击键消息和非系统击键消息。而非系统击键消息是我们常用的。WM_KEYDOWN和WM_KEYUP消息通常是在按下或释放不带Alt键的键时产生；WM_SYSKEYDOWN和WM_SYSKEYUP消息通常由与Alt组合的击键产生，这些键激活程序菜单或系统菜单上的选项，或切换活动窗口，也可以用作系统菜单加速键。由于Windows处理所有Alt键的功能，应用程序无需捕获这些消息。
例如：
单个按健：PostMessage(h,WM_KEYDOWN,VK_F9,0);
ALT+按键：PostMessage(h,WM_SYSKEYDOWN,70,$20000000);
格式::PostMessage (MyHwnd, WM_KEYDOWN, wParam, lParam)
如果你确定要发送键盘消息，那么再来看看如何确定键盘消息中的wParam 和lParam 这两个参数。
wParam 参数的含义较简单，它表示你要发送的键盘事件的按键虚拟码，比如你要对目标程序模拟按下A键，那么wParam 参数的值就设为VK_A ,
lParam 这个参数就比较复杂了，因为它包含了多个信息，一般可以把它设为0。即 PostMessage (Hwnd, WM_KEYDOWN, key, 0);
但是如果你想要你的模拟更真实一些，或者你向记事本的文本框发送字符消息。那么你还需要设置一下这个参数。那么我们就详细了解一下lParam 吧。
lParam 这个参数就比较复杂了，因为它包含了多个信息。如果按住一个键不放，会使得自动重复功能生效，那么该键最后被释放时，Windows会给窗口过程发送一系列的WM_KEYDOWN（或WM_SYSKEYDWON）消息和一个WM_KEYUP（或WM_SYSKEYUP）消息。如果是发送“击键”，不需要产生字符，一般可以把它设为0。即PostMessage (Hwnd, WM_KEYDOWN, key, 0);而对于需要产生“字符”的击键消息，比如如向记事本发送字符“A”，要设置参数lParam，否则会产生一系列A。那么我们就详细了解一下lParam 吧。
lParam 是一个32 bit的参数，它在内存中占4个字节，写成二进制就是
00000000 00000000 00000000 00000000
大家一般习惯写成16进制的，那么就应该是
&H00 00 00 00
一共是32位，我们从右向左数，假设最右边那位为第0位(注意是从0而不是从1开始计数)，最左边的就是第31位。那么该参数的
0-15位表示键的发送次数等扩展信息 //一般为&H0001 如果不设置发送次数，因为按下键盘键,会自动触发重复发送消息。比如你向记事本的文本框发送字符消息消息时会出现多个字符。
16-23位为按键的扫描码
24-31位表示是按下键还是释放键。 按下键&H00，释放键则为&HC0,
那么16-23位的扫描码怎么会得呢？这需要用到一个API函数MapVirtualKey，这个函数可以将虚拟码转换为扫描码，或将扫描码转换为虚拟码，还可以把虚拟码转换为对应字符的ASCII码。它的delphi 声明如下：
MapVirtualKey(
uCode: UINT; {键值、扫描码或虚拟码 key code, scan code or virtual key}
uMapType: UINT {flags for translation mode}
): UINT; {returns translated key code}
参数uCode 表示待转换的码，参数uMapType 表示从什么转换为什么，如果是虚拟码转扫描码，则uMapType 设置为0，如果是扫描码转虚拟码，则wMapType 设置为1，如果是虚拟码转ASCII码，则uMapType 设置为2。相信有了这些，我们就可以构造键盘事件的lParam参数了。
下面给出一个构造lParam参数的函数：
function VKB_param(VirtualKey:Integer;flag:Integer):Integer; //函数名
var
s,Firstbyte,Secondbyte:String;
S_code:Integer;
Begin
if flag=1 then //按下键
begin
Firstbyte :='00'
end
else //弹起键
begin
Firstbyte :='C0'
end;
S_code:= MapVirtualKey(VirtualKey, 0);
Secondbyte:='00'+inttostr(s_code);
Secondbyte:=copy(Secondbyte,Length(Secondbyte)-1,2);
s:='$'+Firstbyte + Secondbyte + '0001';
Result:=strtoint(s);
End;
使用按键的方法：
说明：key为键值，如2键的值是$32，flag传递的是按键状态，1是按下，0是弹起。
lparam := VKB_param(key, 1); {按下键}
PostMessage (Hwnd, WM_KEYDOWN, key, lParam);
lParam := VKB_param(key, 0); {松开键}
PostMessage (Hwnd, WM_KEYUP, key, lParam);
例如：
var
hwnd, lparam:Cardinal;
begin
// hwnd:=FindWindow(nil,'无标题 - 记事本'); //这个函数不能在记事本输入。因为记事本里接收字符的是子窗口edit。
hwnd:=FindWindowEx(FindWindow(nil,'无标题 - 记事本'),0,'edit',nil);//获取记事本窗口句柄
lparam := VKB_param(97, 1); //按下键
//PostMessage (hwnd,WM_KEYDOWN,vk_F3,lparam) ; //按下F3键
PostMessage (hwnd,WM_CHAR,97,lparam); //输入字符 （edit控件接收字符）
lParam := VKB_param(97, 0); //松开键
PostMessage (hwnd,WM_CHAR,97,lparam); //输入字符 （edit控件接收字符）
//PostMessage (hwnd,WM_KEYUP,vk_F3,lparam); //释放F3键
end;
////////////////////////////////////
FindWindow(
lpClassName, {窗口的类名}
lpWindowName: PChar {窗口的标题}
): HWND; {返回窗口的句柄; 失败返回 0}
//FindWindowEx 比 FindWindow 多出两个句柄参数:
FindWindowEx(
Parent: HWND; {要查找子窗口的父窗口句柄}
Child: HWND; {子窗口句柄}
ClassName: PChar; {窗口的类名}
WindowName: PChar {窗口的标题}
): HWND;
///////////////////////////////
2、模拟鼠标
Msg 模拟鼠标点击消息参数：
WM_LBUTTONDOWN //左键按下
WM_RBUTTONDOWN //右键按下
WM_MBUTTONDOWN //中间键按下
/////////
WM_LButtonUp //左键放开
WM_RbuttonUp //右键放开
WM_MButtonUp //中键放开
/////////
WM_LBUTTONDBLCLK //左键双击
WM_RBUTTONDBLCLK //左键双击
WM_MBUTTONDBLCLK //中键双击
wparam模拟鼠标点击设置为0
Lparam参数为鼠标坐标。
对lparam的描述是:
lParam：低16位存放X坐标，高16位存放Y坐标
那么0到15位就是低16位，16到31就是高16位。
比如你有个坐标p.x=290 p.y=48。那么换成2进制
p.x=0000000000000000 0000000100100010
p.y=0000000000000000 0000000000110000
因为刚才说了lParam高16位是要存放y坐标的值，低16位存放X坐标的值。这样才能组成一个正确的lParam.
所以就要把p.y的值放到高16位去。怎么放呢？就是把p.y的低16的值全部左移16位移到高16位去。运算: p.x shl 16; 移动之后就变成
p.y=0000000000110000 0000000000000000
然后把p.y和p.x的值组合成一个新的整数。lparam:=p1.X+ p1.Y shl 16;
lParam=0000000000110000 0000000100100010
前面的是p.y的二进制数表示，后面是p.x的二进制表示。
----------------------------------------------------------------------------------------------------------------------
{补充小知识：}
shl 左移位 shr右移位
shl 是按位左移,右边补零shr 是按位右移,左边补零
左移一位等于乘2，右移一位等于除2。
左移2位等于乘2的2次方，右移一位等于除2的2次方。
左移n位等于乘2的n次方，右移n位等于除2的n次方。
所以lparam:=p1.X+ p1.Y shl 16也可以用: lparam:=p1.X+ p1.Y *power(2,16) (即lparam:=p1.X+ p1.Y *65536)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
3、例子:
Var
P1：Tpoint;
Lparam:integer;
begin
GetCursorPos(P1); // 获取屏幕坐标
P1.X:= P1.X+100;
P1.Y:=P1.Y+200;
lparam:=p1.X+ p1.Y shl 16;
sendmessage(h,messages.WM_LBUTTONDOWN ,0,lparam);// 按下鼠标左键
sendmessage(h,messages.WM_LBUTTONUP ,0, lparam); //抬起鼠标左键
End;
{-------------------------------------------}
{ 模拟键盘鼠标过程 }
{-------------------------------------------}
unit UAnalogKeyboardAndMouseDM;
interface
uses
Windows, Messages;
type
(*定义鼠标入键盘事件常量*)
TClickType = (leftDown, rightDown, midDown, leftUp, rightUp, midUp, leftDB, rightDB, midDB, vkeyDown, vkeyUp, vKeyClick, pageUp, PageDown);
procedure SendMouseClick(const WinHandle: HWND; const PosX, PosY: integer; const ClickFlag: TClickType);
procedure SendKey(const WinHandle: HWND; const Vkey: word;
const KeyClickFlag: TClickType);
implementation
{-------------------}
{ *模拟鼠标* }
{-------------------}
procedure SendMouseClick(const WinHandle: HWND; const PosX, PosY: integer; const ClickFlag: TClickType);
begin
case ClickFlag of
leftDown:
PostMessage(WinHandle, WM_LButtonDown, 0, PosX + PosY * 65536); //左键按下
leftUp:
PostMessage(WinHandle, WM_LButtonUp, 0, PosX + PosY * 65536); //左键放开
//-----
rightDown:
PostMessage(WinHandle, WM_RButtonDown, 0, PosX + PosY * 65536); //右键按下
rightUp:
PostMessage(WinHandle, WM_RButtonUp, 0, PosX + PosY * 65536); //右键放开
//-----
midDown:
PostMessage(WinHandle, WM_MBUTTONDOWN, 0, PosX + PosY * 65536); //中间键按下
midUp:
PostMessage(WinHandle, WM_MButtonUp, 0, PosX + PosY * 65536); //中键放开
//-----
leftDB:
PostMessage(WinHandle, WM_LBUTTONDBLCLK, 0, PosX + PosY * 65536); //左键双击
rightDB:
PostMessage(WinHandle, WM_RBUTTONDBLCLK, 0, PosX + PosY * 65536); //右键双击
midDB:
PostMessage(WinHandle, WM_MBUTTONDBLCLK, 0, PosX + PosY * 65536); //中键双击
end;
end;
{-------------------}
{ *模拟键盘* }
{-------------------}
procedure SendKey(const WinHandle: HWND; const Vkey: word;
const KeyClickFlag: TClickType);
begin
case KeyClickFlag of
vkeyDown:postMessage(WinHandle,WM_KEYDOWN,vkey,MapVirtualKey(Vkey,0));
vkeyUp:postMessage(WinHandle,WM_KEYUP,vkey,MapVirtualKey(Vkey,0));
vkeyClick:
begin
postMessage(WinHandle,WM_KEYDOWN,vkey,MapVirtualKey(Vkey,0));
postMessage(WinHandle,WM_KEYUP,vkey,MapVirtualKey(Vkey,0));
end;
end;
end;
end.
4、附录：获取窗口句柄handle
利用PostMessage模拟键盘鼠标的关键是获取窗口句柄handle。那么如何获取窗口(或子窗口)句柄呢?
获取handle（窗口句柄）的方法通常有：
1） WindowFromPoint
这个函数能够找出鼠标当前位置所对应的窗口句柄。
2）FindWindow/FindWindowEx或者用GetWindow来遍历查找，
如：
handle := FindWindow(nil,PChar('窗口的标题'));
或者：
procedure TForm1.Button1Click(Sender: TObject);
var
hCurrentWindow: HWnd;
WndText:String;
begin
hCurrentWindow := GetWindow(Handle, GW_HWNDFIRST);
while hCurrentWindow <> 0 do
begin
WndText:=GetWndText(hCurrentWindow);
if UpperCase(WndText)='窗口的标题' then begin
...
...
end;
hCurrentWindow:=GetWindow(hCurrentWindow, GW_HWNDNEXT);
end;
end;
//==========================================================
FindWindow(
lpClassName, {窗口的类名}
lpWindowName: PChar {窗口的标题}
): HWND; {返回窗口的句柄; 失败返回 0}
//FindWindowEx 比 FindWindow 多出两个句柄参数:
FindWindowEx(
Parent: HWND; {要查找子窗口的父窗口句柄}
Child: HWND; {子窗口句柄}
ClassName: PChar; {}
WindowName: PChar {}
): HWND;
{
如果 Parent 是 0, 则函数以桌面窗口为父窗口, 查找桌面窗口的所有子窗口;
如果 Parent 是 HWND_MESSAGE, 函数仅查找所有消息窗口;
Child子窗口必须是 Parent 窗口的直接子窗口;
如果 Child 是 0, 查找从 Parent 的第一个子窗口开始;
如果 Parent 和 Child 同时是 0, 则函数查找所有的顶层窗口及消息窗口.
}
//测试1: 试着找找新建程序主窗口的句柄
var
h: HWND;
begin
{现在我们知道窗口的标题是: Form1、窗口的类名是: TForm1}
h := FindWindow('TForm1', 'Form1');
ShowMessage(IntToStr(h)); {656180; 这是随机, 每次启动窗口肯定不一样}
{假如不知道类名}
h := FindWindow(nil, 'Form1');
ShowMessage(IntToStr(h)); {656180}
{假如不知道标题名}
h := FindWindow('TForm1', nil);
ShowMessage(IntToStr(h)); {656180}
{其实这个窗口的句柄不就是 Self.Handle 吗}
ShowMessage(IntToStr(Handle)); {656180}
end;
//测试2: 找计算器窗口的句柄(先打开计算器)
var
h: HWND;
begin
{如果不是简体中文系统, 这样可能不灵}
h := FindWindow(nil, '计算器');
ShowMessage(IntToStr(h)); {1508334}
{最好这样, 但你得提前知道计算器窗口的类名是: SciCalc}
h := FindWindow('SciCalc', nil);
ShowMessage(IntToStr(h)); {1508334}
end;
//==========================================================
3）通过进程的文件名来查找窗口句柄。
首先通过进程快照得到要查找的进程ID(ProcessId)，
其次，再跟据ProcessId获取进程的窗口句柄。以下为代码：
uses TLHelp32;//注意加上这个模块
procedure TForm1.Button1Click(Sender: TObject);
var
ProcessName : string; //进程名
FSnapshotHandle:THandle; //进程快照句柄
FProcessEntry32:TProcessEntry32; //进程入口的结构体信息
ContinueLoop:BOOL;
MyHwnd:THandle;
begin
FSnapshotHandle:=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0); //创建一个进程快照
FProcessEntry32.dwSize:=Sizeof(FProcessEntry32);
ContinueLoop:=Process32First(FSnapshotHandle,FProcessEntry32); //得到系统中第一个进程
//循环例举
while ContinueLoop do
begin
ProcessName := FProcessEntry32.szExeFile;
if(ProcessName = '要找的应用程序名.exe') then begin
MyHwnd := GetHWndByPID(FProcessEntry32.th32ProcessID);
...
...
end;
ContinueLoop:=Process32Next(FSnapshotHandle,FProcessEntry32);
end;
CloseHandle(FSnapshotHandle); // 释放快照句柄
end;
//跟据ProcessId获取进程的窗口句柄
function TForm1.GetHWndByPID(const hPID: THandle): THandle;
type
PEnumInfo = ^TEnumInfo;
TEnumInfo = record
ProcessID: DWORD;
HWND: THandle;
end;
function EnumWindowsProc(Wnd: DWORD; var EI: TEnumInfo): Bool; stdcall;
var
PID: DWORD;
begin
GetWindowThreadProcessID(Wnd, @PID);
Result := (PID <> EI.ProcessID) or
(not IsWindowVisible(WND)) or
(not IsWindowEnabled(WND));
if not Result then EI.HWND := WND;
end;
function FindMainWindow(PID: DWORD): DWORD;
var
EI: TEnumInfo;
begin
EI.ProcessID := PID;
EI.HWND := 0;
EnumWindows(@EnumWindowsProc, Integer(@EI));
Result := EI.HWND;
end;
begin
if hPID<>0 then
Result:=FindMainWindow(hPID)
else
Result:=0;
end;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
（二）全局模拟
即所有窗口都可以接收到键盘模拟。所以在利用全局模拟时有必要先把接收模拟键盘鼠标的窗口置顶。
模拟全局键盘和鼠标消息常见的可以有以下一些方法：
1、用API函数keybd_event和mouse_event。
1）函数keybd_event模拟键盘
keybd_event(
bVk: Byte; {虚拟键值}
bScan: Byte; {扫描码}
dwFlags: DWORD; {标志选项}
dwExtraInfo: DWORD {关于键的附加选项}
); {这个过程没有返回值}
keybd_event(VK_A, 0, 0, 0); //按下A键
Sleep(200);
keybd_event (VK_A, 0, KEYEVENTF_KEYUP, 0); //释放A键
注意有时候按键的速度不要太快，否则会出问题，可以用API函数Sleep来进行延时，delphi声明如下：
Sleep(
dwMilliseconds: DWORD {指定要暂停的毫秒数}
);
参数dwMilliseconds表示延时的时间，以毫秒为单位。
那么如果要模拟按下功能键怎么做呢？比如要按下Ctrl+C实现拷贝这个功能，可以这样：
keybd_event (VK_Ctrl, 0, 0, 0 ); //按下Ctrl键
keybd_event (VK_C, 0, 0, 0); //按下C键
Sleep(500 ); //延时500毫秒
keybd_event (VK_C, 0, KEYEVENTF_KEYUP, 0 ); //释放C键
keybd_event (VK_Ctrl, 0, KEYEVENTF_KEYUP, 0 ); //释放Ctrl键
好了，现在你可以试试是不是可以骗过目标程序了，这个函数对大部分的窗口程序都有效，可是仍然有一部分游戏对它产生的键盘事件熟视无睹，这时候，你就要用上bScan这个参数了。
一般的，bScan都传0，但是如果目标程序是一些DirectX游戏，那么你就需要正确使用这个参数传入扫描码，用了它可以产生正确的硬件事件消息，以被游戏识别。这样的话，就可以写成这样：
keybd_event (VK_A, MapVirtualKey(VK_A, 0), 0, 0); //按下A键
keybd_event (VK_A, MapVirtualKey(VK_A, 0), KEYEVENTF_KEYUP, 0 ); //释放A键
以上就是用keybd_event函数来模拟键盘事件。
2）mouse_event模拟按下鼠标
mouse_event(MOUSEEVENTF_LEFTDOWN,0,0,0,0);//鼠标左键按下
Sleep(200);
mouse_event(MOUSEEVENTF_LEFTUP,0,0,0,0);//鼠标左键弹起
{ ===========================================
模拟多次点击鼠标左键。 默认1次 。
============================================ }
procedure SeriesLeftClick(i: Byte = 1);
var
f: Byte;
begin
for f := 1 to i do
begin
Mouse_Event(MouseEventf_leftDown, 0, 0, 0, 0);
Sleep(200);
Mouse_Event(MouseEventf_leftUp, 0, 0, 0, 0);
end;
end;
2、SendInput函数也可以模拟全局键盘鼠标事件。
SendInput可以直接把一条消息插入到消息队列中，算是比较底层的了。
SendInput的参数其实很简单，在Windows.pas就有函数的声明如下：
function SendInput (
cInputs: UINT; // pInputs中记录数组的元素数目
var pInputs: TInput; //TInput类型记录数组的第1个元素
cbSize: Integer // 定义TInput的大小，一般为SizeOf(TInput)
): UINT; stdcall;
cInputs：定义pInputs中记录数组的元素数目。
pInputs：TInput类型记录数组的第1个元素。每个元素代表插人到系统消息队列的键盘或鼠标事件。
cbSize：定义TInput的大小，一般为SizeOf(TInput)。函数返回成功插入系统消息队列中事件的数目，失败返回0。
调用SendInput关键的就是要搞清楚它的几个记录结构的意思，在Windows.pas中对TInput的声明如下：
tagINPUT = packed record
Itype: DWORD;
case Integer of
0: (mi: TMouseInput);
1: (ki: TKeybdInput);
2: (hi: THardwareInput);
end;
TInput = tagINPUT;
其中mi、ki、hi是3个共用型的记录结构，Itype指出记录结构中所使用的类型，它有3个值。
INPUT_MOUSE：表示使用mi记录结构，忽略ki和hi；
INPUT_KEYBOARD：表示使用ki记录结构，忽略mi和hi。
1）键盘模拟
TKeybdInput记录结构的声明如下：
tagKEYBDINPUT = packed record
wVk: WORD; //是将要操作的按键的虚键码
wScan: WORD; // 是安全码，一般不用
dwFlags: DWORD; // 指定键盘所进行的操作，为0时表示按下某键，KEYEVENTF_KEYUP表示放开某键
time: DWORD;
dwExtraInfo: DWORD; //是扩展信息，可以使用API函数GetMessageExtraInfo的返回值
end;
TKeybdInput = tagKEYBDINPUT;
其中wVk是将要操作的按键的虚键码。wScan是安全码，一般不用。dwFlags指定键盘所进行的操作，为0时表示按下某键，KEYEVENTF_KEYUP表示放开某键。time是时间戳，可以使用API函数GetTickCount的返回值。dwExtraInfo是扩展信息，可以使用API函数GetMessageExtraInfo的返回值。例如击键“A”的程序如下：
procedure KeyPressA;
var
Inputs : array [0..1] of TInput;
begin
Inputs[0].Itype:=INPUT_KEYBOARD;
with Inputs[0].ki do
begin
wVk:=VK_A;
wScan:=0;
dwFlags:=0;
time:=GetTickCount;
dwExtraInfo:=GetMessageExtraInfo;
end;
Inputs[1].Itype:=INPUT_KEYBOARD;
with Inputs[1].ki do
begin
wVk:=VK_A;
wScan:=0;
dwFlags:=KEYEVENTF_KEYUP;
time:=GetTickCount;
dwExtraInfo:=GetMessageExtraInfo;
end;
SendInput(2,Inputs[0],SizeOf(TInput));
end;
注意：在Windows.pas单元中并没有字母和数字的虚键码的声明，最好在单元文件中对所有的虚键码进行了声明，包含了字母、数字和标点符号。
2）鼠标模拟
TMouseInput记录结构的声明如下：
tagMOUSEINPUT = packed record
dx: Longint;
dy: Longint;
mouseData: DWORD;
dwFlags: DWORD;
time: DWORD;
dwExtraInfo: DWORD;
end;
TMouseInput = tagMOUSEINPUT;
其中dx、dy是鼠标移动时的坐标差（不是象素单位），在鼠标移动时有效。
mouseData是鼠标滚轮滚动值，在滚动鼠标滚轮时有效。当mouseData小于0时向下滚动，当mouseData大于0时向上滚动，mouseData的绝对值一般设为120。
dwFlags指定鼠标所进行的操作，例如，MOUSEEVENTF_MOVE表示移动鼠标，MOUSEEVENTF_LEFTDOWN表示按下鼠标左键，MOUSEEVENTF_LEFTUP表示放开鼠标左键。
time是时间戳，可以使用API函数GetTickCount的返回值。
dwExtraInfo是扩展信息，可以使用API函数GetMessageExtraInfo的返回值。例如单击鼠标左键的程序如下：
procedure MouseClick;
var
Inputs : array [0..1] of TInput;
begin
Inputs[0].Itype:=INPUT_MOUSE;
with Inputs[0].mi do
begin
dx:=0;
dy:=0;
mouseData:=0;
dwFlags:=MOUSEEVENTF_LEFTDOWN;
time:=GetTickCount;
dwExtraInfo:=GetMessageExtraInfo;
end;
Inputs[1].Itype:=INPUT_MOUSE;
with Inputs[1].mi do
begin
dx:=0;
dy:=0;
mouseData:=0;
dwFlags:=MOUSEEVENTF_LEFTUP;
time:=GetTickCount;
dwExtraInfo:=GetMessageExtraInfo;
end;
SendInput(2,Inputs[0],SizeOf(TInput));
end;
鼠标的移动总是很麻烦，上面的dx、dy不是以象素为单位的，而是以鼠标设备移动量为单位的，它们之间的比值受鼠标移动速度设置的影响。具体的解决方法可参考《Delphi下利用WinIo模拟鼠标键盘详解》，这里不再重复。
dwFlags可以设置一个MOUSEEVENTF_ABSOLUTE标志，这使得可以用另外一种方法移动鼠标。当dwFlags设置了MOUSEEVENTF_ABSOLUTE标志，dx、dy为屏幕坐标值，表示将鼠标移动到dx，dy的位置。但是这个坐标值也不是以象素为单位的。这个值的范围是0到65535（$FFFF），当dx等于0、dy等于0时表示屏幕的最左上角，当dx等于65535、dy等于65535时表示屏幕的最右下角，相当于将屏幕的宽和高分别65536等分。API函数GetSystemMetrics(SM_CXSCREEN)可以返回屏幕的宽度，
函数GetSystemMetrics(SM_CYSCREEN)可以返回屏幕的高度，利用屏幕的宽度和高度就可以将象素坐标换算成相应的dx、dy。注意：这种换算最多会出现1象素的误差。
例如：将鼠标指针移动到屏幕150,120坐标处的程序如下：
procedure MouseMove;
var
Input : TInput;
begin
Input.Itype:=INPUT_MOUSE;
with Input.mi do
begin
dx:=($FFFF div (GetSystemMetrics(SM_CXSCREEN)-1)) * 150;
dy:=($FFFF div (GetSystemMetrics(SM_CYSCREEN)-1)) * 120;
mouseData:=0;
dwFlags:=MOUSEEVENTF_MOVE or MOUSEEVENTF_ABSOLUTE;
time:=GetTickCount;
dwExtraInfo:=GetMessageExtraInfo;
end;
SendInput(1,Input,SizeOf(TInput));
end;
3) 附录： SIMouseKeyboard.pas的使用 ——利用SendInput模拟鼠标键盘的输入
利用SendInput模拟鼠标键盘的输入。作者在SIMouseKeyboard.pas单元文件中对所有的虚键码进行了重新声明，包含了Windows.pas单元中没有声明的字母、数字和标点符号。在SIMouseKeyboard.pas单元文件中共有9个函数，使用方法如下：
1、procedure SIKeyDown(Key : WORD);
按下指定的键。Key为虚键码。
2、procedure SIKeyUp(Key : WORD);
放开指定的键。Key为虚键码。
3、procedure SIKeyPress(Key : WORD; Interval : Cardinal);
按下并放开指定的键，Interval为按下和放开之间的时间间隔。注意：本函数不支持重复机打，即无论Interval设的多么大都只有一次按键。
4、procedure SIKeyInput(const Text : String; Interval : Cardinal);
模拟键盘输入指定的文本，返回是否成功。文本中只能是单字节字符（#32~#126）、Tab（#9）键和回车键（#13），即可以从键盘上输入的字符，不能是汉字，其它字符会被忽略。Interval为按下和放开键之间的时间间隔，单位毫秒。
示范程序，组合键Ctrl+A如下：
SIKeyDown(VK_CONTROL); //按下Ctrl
SIKeyPress(VK_A); //击键A
SIKeyUp(VK_CONTROL); //放开Ctrl
5、procedure SIMouseDown(Key : WORD);
按下鼠标的指定键。Key为虚键码，鼠标左键为VK_LBUTTON，右键为VK_RBUTTON，中键为VK_MBUTTON。
6、procedure SIMouseUp(Key : WORD);
放开鼠标的指定键。Key为虚键码，鼠标左键为VK_LBUTTON，右键为VK_RBUTTON，中键为VK_MBUTTON。
7、procedure SIMouseClick(Key : WORD; Interval : Cardinal);
单击鼠标的指定键，Interval为按下和放开之间的时间间隔。过快的单击可能会使一些程序无法识别，适当的调整Interval的值可以解决这个问题。
8、procedure SIMouseWheel(dZ : Integer);
滚动鼠标的滚轮。当dZ小于0时向下滚动，当dZ大于0时向上滚动，dZ的绝对值一般设为120。
9、procedure SIMouseMoveTo(X,Y : Integer; MaxMove : Integer; Interval : Cardinal);
将鼠标指针移动到指定位置，返回是否成功。X和Y为象素值，X和Y的值的范围不能超出屏幕，MaxMove为移动时的dX和dY的最大值，Interval为两次移动之间的时间间隔，一些程序对鼠标移动速度敏感，当鼠标移动太快时无法对鼠标做出反应，适当的设置MaxMove和Interval的值可以解决这个问题。
示范程序，拖放到指定位置如下：
SIMouseDown(VK_LBUTTON); //按下鼠标左键
SIMouseMoveTo(780,300); //移动到指定位置
SIMouseUp(VK_LBUTTON); //放开鼠标左键
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//以下为利用SendInput模拟鼠标键盘的输入的单元。版权归作者所有。
//作者：yeye55 2010年1月31日
//版权 2010，由 yeye55 拥有，保留所有权利。
//本文件中的代码是免费程序，无需任何授权或许可即可用于个人和商业目的。使用者一切后果自负。
//
//如果你转载了本文件中的代码，请注明代码出处和代码作者；
//如果你修改了本文件中的代码，请注明修改位置和修改作者。
//
//本文件最早在http://www.programbbs.com/bbs/上发布
unit SIMouseKeyboard;
interface
uses
Windows;
const
//虚键码定义
VK_LBUTTON = $01;
VK_RBUTTON = $02;
VK_CANCEL = $03;
VK_MBUTTON = $04; //* NOT contiguous with L & RBUTTON */
VK_BACK = $08;
VK_TAB = $09;
VK_CLEAR = $0C;
VK_RETURN = $0D;
VK_SHIFT = $10;
VK_CONTROL = $11;
VK_MENU = $12;
VK_PAUSE = $13;
VK_CAPITAL = $14;
VK_KANA = $15;
VK_HANGEUL = $15; //* old name - should be here for compatibility */
VK_HANGUL = $15;
VK_JUNJA = $17;
VK_FINAL = $18;
VK_HANJA = $19;
VK_KANJI = $19;
VK_ESCAPE = $1B;
VK_CONVERT = $1C;
VK_NONCONVERT = $1D;
VK_ACCEPT = $1E;
VK_MODECHANGE = $1F;
VK_SPACE = $20;
VK_PRIOR = $21;
VK_NEXT = $22;
VK_END = $23;
VK_HOME = $24;
VK_LEFT = $25;
VK_UP = $26;
VK_RIGHT = $27;
VK_DOWN = $28;
VK_SELECT = $29;
VK_PRINT = $2A;
VK_EXECUTE = $2B;
VK_SNAPSHOT = $2C;
VK_INSERT = $2D;
VK_DELETE = $2E;
VK_HELP = $2F;
VK_C0 = $C0; //“`”和“~”
VK_BD = $BD; //“-”和“_”
VK_BB = $BB; //“=”和“+”
VK_DC = $DC; //“\”和“|”
VK_DB = $DB; //“[”和“{”
VK_DD = $DD; //“]”和“}”
VK_BA = $BA; //“;”和“:”
VK_DE = $DE; //“'”和“"”
VK_BC = $BC; //“,”和“<”
VK_BE = $BE; //“.”和“>”
VK_BF = $BF; //“/”和“?”
{* VK_0 thru VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) *}
VK_0 = $30;
VK_1 = $31;
VK_2 = $32;
VK_3 = $33;
VK_4 = $34;
VK_5 = $35;
VK_6 = $36;
VK_7 = $37;
VK_8 = $38;
VK_9 = $39;
{* VK_A thru VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) *}
VK_A = $41;
VK_B = $42;
VK_C = $43;
VK_D = $44;
VK_E = $45;
VK_F = $46;
VK_G = $47;
VK_H = $48;
VK_I = $49;
VK_J = $4A;
VK_K = $4B;
VK_L = $4C;
VK_M = $4D;
VK_N = $4E;
VK_O = $4F;
VK_P = $50;
VK_Q = $51;
VK_R = $52;
VK_S = $53;
VK_T = $54;
VK_U = $55;
VK_V = $56;
VK_W = $57;
VK_X = $58;
VK_Y = $59;
VK_Z = $5A;
VK_LWIN = $5B;
VK_RWIN = $5C;
VK_APPS = $5D;
VK_NUMPAD0 = $60;
VK_NUMPAD1 = $61;
VK_NUMPAD2 = $62;
VK_NUMPAD3 = $63;
VK_NUMPAD4 = $64;
VK_NUMPAD5 = $65;
VK_NUMPAD6 = $66;
VK_NUMPAD7 = $67;
VK_NUMPAD8 = $68;
VK_NUMPAD9 = $69;
VK_MULTIPLY = $6A;
VK_ADD = $6B;
VK_SEPARATOR = $6C;
VK_SUBTRACT = $6D;
VK_DECIMAL = $6E;
VK_DIVIDE = $6F;
VK_F1 = $70;
VK_F2 = $71;
VK_F3 = $72;
VK_F4 = $73;
VK_F5 = $74;
VK_F6 = $75;
VK_F7 = $76;
VK_F8 = $77;
VK_F9 = $78;
VK_F10 = $79;
VK_F11 = $7A;
VK_F12 = $7B;
VK_F13 = $7C;
VK_F14 = $7D;
VK_F15 = $7E;
VK_F16 = $7F;
VK_F17 = $80;
VK_F18 = $81;
VK_F19 = $82;
VK_F20 = $83;
VK_F21 = $84;
VK_F22 = $85;
VK_F23 = $86;
VK_F24 = $87;
VK_NUMLOCK = $90;
VK_SCROLL = $91;
{*
* VK_L* & VK_R* - left and right Alt, Ctrl and Shift virtual keys.
* Used only as parameters to GetAsyncKeyState() and GetKeyState().
* No other API or message will distinguish left and right keys in this way.
*}
VK_LSHIFT = $A0;
VK_RSHIFT = $A1;
VK_LCONTROL = $A2;
VK_RCONTROL = $A3;
VK_LMENU = $A4;
VK_RMENU = $A5;
VK_PROCESSKEY = $E5;
VK_ATTN = $F6;
VK_CRSEL = $F7;
VK_EXSEL = $F8;
VK_EREOF = $F9;
VK_PLAY = $FA;
VK_ZOOM = $FB;
VK_NONAME = $FC;
VK_PA1 = $FD;
VK_OEM_CLEAR = $FE;
//功能函数
procedure SIKeyDown(Key : WORD);
procedure SIKeyUp(Key : WORD);
procedure SIKeyPress(Key : WORD; Interval : Cardinal = 0);
procedure SIKeyInput(const Text : String; Interval : Cardinal = 0);
procedure SIMouseDown(Key : WORD);
procedure SIMouseUp(Key : WORD);
procedure SIMouseClick(Key : WORD; Interval : Cardinal = 0);
procedure SIMouseWheel(dZ : Integer);
procedure SIMouseMoveTo(X,Y : Integer; MaxMove : Integer = 20; Interval : Cardinal = 0);
implementation
var
PerWidth : Integer; //每象素宽度单位
PerHeight : Integer; //每象素高度单位
{功能函数}
//按下指定的键。
procedure SIKeyDown(Key : WORD);
var
Input : TInput;
begin
Input.Itype:=INPUT_KEYBOARD;
with Input.ki do
begin
wVk:=Key;
wScan:=0;
dwFlags:=0;
time:=GetTickCount;
dwExtraInfo:=GetMessageExtraInfo;
end;
SendInput(1,Input,SizeOf(TInput));
end;
//放开指定的键。
procedure SIKeyUp(Key : WORD);
var
Input : TInput;
begin
Input.Itype:=INPUT_KEYBOARD;
with Input.ki do
begin
wVk:=Key;
wScan:=0;
dwFlags:=KEYEVENTF_KEYUP;
time:=GetTickCount;
dwExtraInfo:=GetMessageExtraInfo;
end;
SendInput(1,Input,SizeOf(TInput));
end;
//按下并放开指定的键，Interval为按下和放开之间的时间间隔。
procedure SIKeyPress(Key : WORD; Interval : Cardinal);
var
Input : TInput;
begin
Input.Itype:=INPUT_KEYBOARD;
with Input.ki do
begin
wVk:=Key;
wScan:=0;
dwFlags:=0;
time:=GetTickCount;
dwExtraInfo:=GetMessageExtraInfo;
end;
SendInput(1,Input,SizeOf(TInput));
if Interval<>0 then Sleep(Interval);
Input.Itype:=INPUT_KEYBOARD;
with Input.ki do
begin
wVk:=Key;
wScan:=0;
dwFlags:=KEYEVENTF_KEYUP;
time:=GetTickCount;
dwExtraInfo:=GetMessageExtraInfo;
end;
SendInput(1,Input,SizeOf(TInput));
end;
//模拟键盘输入指定的文本，文本中只能是单字节字符（#32~#126）
//以及Tab（#9）键和回车键（#13），其它字符会被忽略，
//Interval为输入每个字符之间的时间间隔。
procedure SIKeyInput(const Text : String; Interval : Cardinal);
type
TCharTable = record
Key : WORD;
Char : array [0..1] of AnsiChar;
end;
const
CharCount = 50;
CharTable : array [0..CharCount-1] of TCharTable = (
(Key : VK_A; Char : 'aA'), (Key : VK_B; Char : 'bB'),
(Key : VK_C; Char : 'cC'), (Key : VK_D; Char : 'dD'),
(Key : VK_E; Char : 'eE'), (Key : VK_F; Char : 'fF'),
(Key : VK_G; Char : 'gG'), (Key : VK_H; Char : 'hH'),
(Key : VK_I; Char : 'iI'), (Key : VK_J; Char : 'jJ'),
(Key : VK_K; Char : 'kK'), (Key : VK_L; Char : 'lL'),
(Key : VK_M; Char : 'mM'), (Key : VK_N; Char : 'nN'),
(Key : VK_O; Char : 'oO'), (Key : VK_P; Char : 'pP'),
(Key : VK_Q; Char : 'qQ'), (Key : VK_R; Char : 'rR'),
(Key : VK_S; Char : 'sS'), (Key : VK_T; Char : 'tT'),
(Key : VK_U; Char : 'uU'), (Key : VK_V; Char : 'vV'),
(Key : VK_W; Char : 'wW'), (Key : VK_X; Char : 'xX'),
(Key : VK_Y; Char : 'yY'), (Key : VK_Z; Char : 'zZ'),
(Key : VK_0; Char : '0)'), (Key : VK_1; Char : '1!'),
(Key : VK_2; Char : '2@'), (Key : VK_3; Char : '3#'),
(Key : VK_4; Char : '4$'), (Key : VK_5; Char : '5%'),
(Key : VK_6; Char : '6^'), (Key : VK_7; Char : '7&'),
(Key : VK_8; Char : '8*'), (Key : VK_9; Char : '9('),
(Key : VK_C0; Char : '`~'), (Key : VK_BD; Char : '-_'),
(Key : VK_BB; Char : '=+'), (Key : VK_DC; Char : '\|'),
(Key : VK_DB; Char : '[{'), (Key : VK_DD; Char : ']}'),
(Key : VK_BA; Char : ';:'), (Key : VK_DE; Char : #39+'"'),
(Key : VK_BC; Char : ',<'), (Key : VK_BE; Char : '.>'),
(Key : VK_BF; Char : '/?'), (Key : VK_SPACE; Char : ' '+#0),
(Key : VK_TAB; Char : #9#0), (Key : VK_RETURN; Char : #13#0));
var
Input : TInput;
CapsState,NeedShift : Boolean;
i,id : Integer;
begin
CapsState:=((GetKeyState(VK_CAPITAL) and 1)<>0);
for i:=1 to Length(Text) do
begin
for id:=0 to CharCount-1 do
if (CharTable[id].Char[0]=Text[i]) or
(CharTable[id].Char[1]=Text[i]) then
break;
if id>=CharCount then continue;
NeedShift:=(CharTable[id].Char[1]=Text[i]);
if (CharTable[id].Char[0]>='a') and
(CharTable[id].Char[0]<='z') and CapsState then
NeedShift:=not NeedShift;
//按下上档键
if NeedShift then
begin
Input.Itype:=INPUT_KEYBOARD;
with Input.ki do
begin
wVk:=VK_SHIFT;
wScan:=0;
dwFlags:=0;
time:=GetTickCount;
dwExtraInfo:=GetMessageExtraInfo;
end;
SendInput(1,Input,SizeOf(TInput));
end;
//按下指定键
Input.Itype:=INPUT_KEYBOARD;
with Input.ki do
begin
wVk:=CharTable[id].Key;
wScan:=0;
dwFlags:=0;
time:=GetTickCount;
dwExtraInfo:=GetMessageExtraInfo;
end;
SendInput(1,Input,SizeOf(TInput));
//放开指定键
Input.Itype:=INPUT_KEYBOARD;
with Input.ki do
begin
wVk:=CharTable[id].Key;
wScan:=0;
dwFlags:=KEYEVENTF_KEYUP;
time:=GetTickCount;
dwExtraInfo:=GetMessageExtraInfo;
end;
SendInput(1,Input,SizeOf(TInput));
//放开上档键
if NeedShift then
begin
Input.Itype:=INPUT_KEYBOARD;
with Input.ki do
begin
wVk:=VK_SHIFT;
wScan:=0;
dwFlags:=KEYEVENTF_KEYUP;
time:=GetTickCount;
dwExtraInfo:=GetMessageExtraInfo;
end;
SendInput(1,Input,SizeOf(TInput));
end;
if Interval<>0 then Sleep(Interval);
end;
end;
//按下鼠标的指定键。
procedure SIMouseDown(Key : WORD);
var
Input : TInput;
begin
Input.Itype:=INPUT_MOUSE;
with Input.mi do
begin
dx:=0;
dy:=0;
mouseData:=0;
case Key of
VK_LBUTTON : dwFlags:=MOUSEEVENTF_LEFTDOWN;
VK_RBUTTON : dwFlags:=MOUSEEVENTF_RIGHTDOWN;
VK_MBUTTON : dwFlags:=MOUSEEVENTF_MIDDLEDOWN;
else exit;
end;
time:=GetTickCount;
dwExtraInfo:=GetMessageExtraInfo;
end;
SendInput(1,Input,SizeOf(TInput));
end;
//放开鼠标的指定键。
procedure SIMouseUp(Key : WORD);
var
Input : TInput;
begin
Input.Itype:=INPUT_MOUSE;
with Input.mi do
begin
dx:=0;
dy:=0;
mouseData:=0;
case Key of
VK_LBUTTON : dwFlags:=MOUSEEVENTF_LEFTUP;
VK_RBUTTON : dwFlags:=MOUSEEVENTF_RIGHTUP;
VK_MBUTTON : dwFlags:=MOUSEEVENTF_MIDDLEUP;
else exit;
end;
time:=GetTickCount;
dwExtraInfo:=GetMessageExtraInfo;
end;
SendInput(1,Input,SizeOf(TInput));
end;
//单击鼠标的指定键，Interval为按下和放开之间的时间间隔。
procedure SIMouseClick(Key : WORD; Interval : Cardinal);
var
Input : TInput;
begin
Input.Itype:=INPUT_MOUSE;
with Input.mi do
begin
dx:=0;
dy:=0;
mouseData:=0;
case Key of
VK_LBUTTON : dwFlags:=MOUSEEVENTF_LEFTDOWN;
VK_RBUTTON : dwFlags:=MOUSEEVENTF_RIGHTDOWN;
VK_MBUTTON : dwFlags:=MOUSEEVENTF_MIDDLEDOWN;
else exit;
end;
time:=GetTickCount;
dwExtraInfo:=GetMessageExtraInfo;
end;
SendInput(1,Input,SizeOf(TInput));
if Interval<>0 then Sleep(Interval);
Input.Itype:=INPUT_MOUSE;
with Input.mi do
begin
dx:=0;
dy:=0;
mouseData:=0;
case Key of
VK_LBUTTON : dwFlags:=MOUSEEVENTF_LEFTUP;
VK_RBUTTON : dwFlags:=MOUSEEVENTF_RIGHTUP;
VK_MBUTTON : dwFlags:=MOUSEEVENTF_MIDDLEUP;
else exit;
end;
time:=GetTickCount;
dwExtraInfo:=GetMessageExtraInfo;
end;
SendInput(1,Input,SizeOf(TInput));
end;
//滚动鼠标的滚轮。
procedure SIMouseWheel(dZ : Integer);
var
Input : TInput;
begin
Input.Itype:=INPUT_MOUSE;
with Input.mi do
begin
dx:=0;
dy:=0;
mouseData:=DWORD(dZ);
dwFlags:=MOUSEEVENTF_WHEEL;
time:=GetTickCount;
dwExtraInfo:=GetMessageExtraInfo;
end;
SendInput(1,Input,SizeOf(TInput));
end;
//将鼠标指针移动到指定位置，返回是否成功，
//X和Y为象素值，X和Y的值的范围不能超出屏幕，
//MaxMove为移动时的dX和dY的最大值，
//Interval为两次移动之间的时间间隔，
procedure SIMouseMoveTo(X,Y : Integer; MaxMove : Integer; Interval : Cardinal);
var
Input : TInput;
p : TPoint;
n : Integer;
begin
if MaxMove<=0 then MaxMove:=$7FFFFFFF;
GetCursorPos(p);
while (p.X<>X) or (p.Y<>Y) do
begin
n:=X-p.X;
if Abs(n)>MaxMove then
begin
if n>0 then n:=MaxMove
else n:=-MaxMove;
end;
p.X:=p.X+n;
//
n:=Y-p.Y;
if Abs(n)>MaxMove then
begin
if n>0 then n:=MaxMove
else n:=-MaxMove;
end;
p.Y:=p.Y+n;
//
Input.Itype:=INPUT_MOUSE;
with Input.mi do
begin
dx:=p.X*PerWidth;
dy:=p.Y*PerHeight;
mouseData:=0;
dwFlags:=MOUSEEVENTF_MOVE or MOUSEEVENTF_ABSOLUTE;
time:=GetTickCount;
dwExtraInfo:=GetMessageExtraInfo;
end;
SendInput(1,Input,SizeOf(TInput));
if Interval<>0 then Sleep(Interval);
end;
end;
initialization
begin
PerWidth:=($FFFF div (GetSystemMetrics(SM_CXSCREEN)-1)); //每象素宽度单位
PerHeight:=($FFFF div (GetSystemMetrics(SM_CYSCREEN)-1)); //每象素高度单位
end;
end.
{
示范程序，拖放到指定位置如下：
SIMouseDown(VK_LBUTTON); //按下鼠标左键
SIMouseMoveTo(780,300); //移动到指定位置
SIMouseUp(VK_LBUTTON); //放开鼠标左键
}
//=================================================
4）SendInput模拟键盘输入应注意的问题
叛逆的鲁鲁修love CC于 2019-07-22 23:56:37 发布
最近接触到这个函数，因此了解了一下，总结一下列在这。
我了解它的出发点是如何通过它向活动窗口输入字符，这是很多程序都有的功能（我猜Visual Assist X就用了这个功能）。
根据MSDN，此函数模拟按键操作，将一些消息插入键盘或鼠标的输入流中，Windows对它进行处理，生成相应的WM_KEYDOWN或 WM_KEYUP事件，这些事件与普通键盘输入一起进入应用程序的消息循环，它们不仅可以转换为WM_CHAR消息，还可以转换为其它（诸如加速键）等消息。
使用它来发送字符消息，并没有看起来那么简单。这有两个需要考虑的问题：
1. 输入法的转换。例如需要向活动窗口发送一些英文字符，我们可能想象这样来实现：获取对应键盘字符的虚拟键码，发送一个SendInput。但是如果活动窗口正在使用一个输入法，那么我们发送出去的消息，会进入输入法的Composition窗口，最终被转换为象形文字或被丢弃。只有当输入法关闭时，程序运行的效果才会像我们期望的那样，在活动窗口中显示出英文字符。
2. 对于中文字符，应该怎么发送给活动窗口？由于SendInput模拟的是WM_KEYDOWN和WM_KEYUP事件，按照一般的思路，我们是否应该获取中文字符的输入法编码（拼音或五笔码），然后向活动窗口发送编码相关的SendInput？那这不仅要求活动窗口开启输入法，甚至还要获知它的编码方式。
如上所述，若直接如想象中那样使用SendInput来输入字符，则必须分析活动窗口的输入法状态。而且输入英文时，要求关闭输入法，输入中文时，又要求打开输入法。若真要以这样的思路来实现，则必定是难以成功的。
那么，有没有不依赖活动窗口输入法状态的方式呢？
其实是有的，使用SendInput模拟键盘输入时，其参数是KEYBDINPUT结构，通过将其dwFlags成员设置 KEYEVENTF_UNICODE就可以了。使用此方式，只需将KEYBDINPUT.wScan设置为字符的Unicode编码即可。对于英文字符，不需要关闭活动窗口的输入法；对于中文字符，也不要求活动窗口打开输入法和将字符转换为输入法编码。
MSDN对此方式的说明为：INPUT_KEYBOARD支持非键盘的输入方式，例如手写识别或语音识别，通过KEYEVENTF_UNICODE 标识，这些方式与键盘（文本）输入别无二致。如果指定了KEYEVENTF_UNICODE，SendInput发送一个WM_KEYDOWN或 WM_KEYUP消息给活动窗口的线程消息队列，消息的wParam参数为VK_PACKET。GetMessage或PeedMessage一旦获得此消息，就把它传递给TranslateMessage，TranslateMessage根据wScan中指定的Unicode字符产生一个 WM_CHAR消息。若窗口是ANSI窗口，则Unicode字符会自动转换为相应的ANSI字符。
任何需要向活动窗口输入字符（包括英文）的功能均应使用这种方式来实现。事实上，键盘消息转换为字符消息的过程是很复杂的，这可能与键盘布局、区域、换档状态等诸多因素有关，这也是Windows要使用TranslateMessage来转换消息的原因。因此，不应该试图通过击键事件来意图向活动窗口输入特定的字符。
经测试，SendInput还有两个值得注意的地方：
1. 没有为KEYBDINPUT.dwFlags指定KEYEVENTF_KEYUP标识时，SendInput将生成WM_KEYDOWN消息，否则生成 WM_KEYUP消息，由于只有WM_KEYDOWN会转换为字符消息，因此，若以输入字符为目标，则不应指定KEYEVENTF_KEYUP标识。
相关知识：
输入法也可以处理SendInput发送的Unicode消息，具体方式不详。见MSDN中ImmGetProperty方法的参考：当dwIndex参数为IGP_PROPERTY时，IME_PROP_ACCEPT_WIDE_VKEY是一个可能的返回值，它表示IME会处理SendInput函数以VK_PACKET注入的Unicode字符，若返回值无该标识，则Unicode字符会直接发送给应用程序。
5）SendInput与WInIo的对比
WinIo有很多缺点，SendInput几乎没有这些缺点。SendInput的模拟要比WinIo简单的多。事件是被直接插入到系统消息队列的，所以它的速度比WinIo要快。系统也会保证数据的完整性，不会出现数据包混乱的情况。利用“绝对移动”可以将鼠标指针移动到准确的位置，同鼠标的配置隔离不会出现兼容性的问题。SendInput的缺点也是最要命的，它会被一些程序屏蔽。所以说在SendInput与WInIo都可以使用的情况下优先考虑SendInput。另外SendInput与WInIo可以接合使用，一些程序对鼠标左键单击敏感，可以使用WinIo模拟鼠标左键单击，其它操作由SendInput模拟。
{*****************************************************************************}
3、用全局钩子也可以模拟键盘消息。
如果你对windows中消息钩子的用法已经有所了解，那么你可以通过设置一个全局HOOK来模拟键盘消息，比如，你可以用WH_JOURNALPLAYBACK这个钩子来模拟按键。WH_JOURNALPLAYBACK是一个系统级的全局钩子，它和WH_JOURNALRECORD的功能是相对的，常用它们来记录并回放键盘鼠标操作。WH_JOURNALRECORD钩子用来将键盘鼠标的操作忠实地记录下来，记录下来的信息可以保存到文件中，而WH_JOURNALPLAYBACK则可以重现这些操作。当然亦可以单独使用WH_JOURNALPLAYBACK来模拟键盘操作。
SetWindowsHookEx函数，它可以用来安装消息钩子：
SetWindowsHookEx(
idHook: Integer; {hook type flag}
lpfn: TFNHookProc; {a pointer to the hook function}
hmod: HINST; {a handle to the module containing the hook function}
dwThreadId: DWORD {the identifier of the associated thread}
): HHOOK;
先安装WH_JOURNALPLAYBACK这个钩子，然后你需要自己写一个钩子函数，在系统调用它时，把你要模拟的事件传递给钩子参数lParam所指向的EVENTMSG区域，就可以达到模拟按键的效果。不过用这个钩子模拟键盘事件有一个副作用，就是它会锁定真实的鼠标键盘，不过如果你就是想在模拟的时候不会受真实键盘操作的干扰，那么用用它倒是个不错的主意。
在不需要监视系统消息时需要调用提供UnHookWindowsHookEx来解除对消息的监视。 下面来建立程序，在Delphi中建立一个工程，在Form1上添加3个按钮用于程序操作。另外再添加一个按钮控件和一个Edit控件用于验证操作。
下面是Form1的全部代码
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
StdCtrls;
type
TForm1 = class(TForm)
Button1: TButton;
Button2: TButton;
Button3: TButton;
Edit1: TEdit;
Button4: TButton;
procedure FormCreate(Sender: TObject);
procedure Button1Click(Sender: TObject);
procedure Button2Click(Sender: TObject);
procedure Button3Click(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
var
Form1: TForm1;
EventArr:array[0..1000]of EVENTMSG;
EventLog:Integer;
PlayLog:Integer;
hHook,hPlay:Integer;
recOK:Integer;
canPlay:Integer;
bDelay:Bool;
implementation
{$R *.DFM}
Function PlayProc(iCode:Integer;wParam:wParam;lParam:lParam):LRESULT;stdcall;
begin
canPlay:=1;
Result:=0;
if iCode < 0 then // 必须将消息传递到消息链的下一个接受单元
Result := CallNextHookEx(hPlay,iCode,wParam,lParam)
else if iCode = HC_SYSMODALON then
canPlay:=0
else if iCode = HC_SYSMODALOFF then
canPlay:=1
else if ((canPlay =1 )and(iCode=HC_GETNEXT)) then begin
if bDelay then begin
bDelay:=False;
Result:=50;
end;
pEventMSG(lParam)^:=EventArr[PlayLog];
end
else if ((canPlay = 1)and(iCode = HC_SKIP))then begin
bDelay := True;
PlayLog:=PlayLog+1;
end;
if PlayLog>=EventLog then begin
UNHookWindowsHookEx(hPlay);
end;
end;
function HookProc(iCode:Integer;wParam:wParam;lParam:lParam):LRESULT;stdcall;
begin
recOK:=1;
Result:=0;
if iCode < 0 then
Result := CallNextHookEx(hHook,iCode,wParam,lParam)
else if iCode = HC_SYSMODALON then
recOK:=0
else if iCode = HC_SYSMODALOFF then
recOK:=1
else if ((recOK>0) and (iCode = HC_ACTION)) then begin
EventArr[EventLog]:=pEventMSG(lParam)^;
EventLog:=EventLog+1;
if EventLog>=1000 then begin
UnHookWindowsHookEx(hHook);
end;
end;
end;
procedure TForm1.FormCreate(Sender: TObject);
begin
Button1.Caption:= '纪录';
Button2.Caption:= '停止';
Button3.Caption:= '回放';
Button4.Caption:= '范例';
Button2.Enabled:=False;
Button3.Enabled:=False;
end;
procedure TForm1.Button1Click(Sender: TObject);
begin
EventLog:=0; // 建立键盘鼠标操作消息纪录链
hHook:=SetwindowsHookEx(WH_JOURNALRECORD,HookProc,HInstance,0);
Button2.Enabled:=True;
Button1.Enabled:=False;
end;
procedure TForm1.Button2Click(Sender: TObject);
begin
UnHookWindowsHookEx(hHook);
hHook:=0;
Button1.Enabled:=True;
Button2.Enabled:=False;
Button3.Enabled:=True;
end;
procedure TForm1.Button3Click(Sender: TObject);
begin
PlayLog:=0; //建立键盘鼠标操作消息纪录回放链
hPlay:=SetwindowsHookEx(WH_JOURNALPLAYBACK,PlayProc,
HInstance,0);
Button3.Enabled:=False;
end;
end.
二、驱动级模拟（绕过windows消息）——WINIO模拟按键
有一些使用DirectX接口的游戏程序，它们在读取键盘操作时绕过了windows的消息机制，而使用DirectInput.这是因为有些游戏对实时性控制的要求比较高，比如赛车游戏，要求以最快速度响应键盘输入。而windows消息由于是队列形式的，消息在传递时会有不少延迟，有时1秒钟也就传递十几条消息，这个速度达不到游戏的要求。而DirectInput则绕过了windows消息，直接与键盘驱动程序打交道，效率当然提高了不少。因此也就造成，对这样的程序无论用PostMessage或者是keybd_event都不会有反应，因为这些函数都在较高层。对于这样的程序，只好用直接读写键盘端口的方法来模拟硬件事件了。要用这个方法来模拟键盘，需要先了解一下键盘编程的相关知识。
在DOS时代，当用户按下或者放开一个键时，就会产生一个键盘中断(如果键盘中断是允许的)，这样程序会跳转到BIOS中的键盘中断处理程序去执行。打开windows的设备管理器，可以查看到键盘控制器由两个端口控制。其中&H60是数据端口，可以读出键盘数据，而&H64是控制端口，用来发出控制信号。也就是，从&H60号端口可以读此键盘的按键信息，当从这个端口读取一个字节，该字节的低7位就是按键的扫描码，而高1位则表示是按下键还是释放键。当按下键时，最高位为0，称为通码，当释放键时，最高位为1，称为断码。既然从这个端口读数据可以获得按键信息，那么向这个端口写入数据就可以模拟按键了！用过QbASIC4.5的朋友可能知道，QB中有个OUT命令可以向指定端口写入数据，而INP函数可以读取指定端口的数据。那我们先看看如果用QB该怎么写代码：
假如你想模拟按下一个键，这个键的扫描码为&H50，那就这样
OUT &H64,&HD2 '把数据&HD2发送到&H64端口。这是一个KBC指令，表示将要向键盘写入数据
OUT &H60,&H50 '把扫描码&H50发送到&H60端口，表示模拟按下扫描码为&H50的这个键
那么要释放这个键呢？像这样，发送该键的断码：
OUT &H64,&HD2 '把数据&HD2发送到&H64端口。这是一个KBC指令，表示将要向键盘写入数据
OUT &H60,(&H50 or &H80) '把扫描码&H50与数据&H80进行或运算，可以把它的高位置1，得到断码，表示释放这个键
好了，现在的问题就是在delphi中如何向端口写入数据了。因为在windows中，普通应用程序是无权操作端口的，于是我们就需要一个驱动程序来帮助我们实现。在这里我们可以使用一个组件WINIO来完成读写端口操作。
什么是WINIO？WINIO是一个全免费的、无需注册的、含源程序的WINDOWS2000端口操作驱动程序组件(可以到http://www.internals.com/上去下载)。它不仅可以操作端口，还可以操作内存；不仅能在VB下用，还可以在DELPHI、VC等其它环境下使用，性能特别优异。
下载该组件，解压缩后可以看到几个文件夹，其中Release文件夹下的3个文件就是我们需要的，这3个文件是WinIo.sys(用于win xp下的驱动程序)，WINIO.VXD(用于win 98下的驱动程序)，WinIo.dll(封装函数的动态链接库)，我们只需要调用WinIo.dll中的函数，然后WinIo.dll就会安装并调用驱动程序来完成相应的功能。
值得一提的是这个组件完全是绿色的，无需安装，你只需要把这3个文件复制到与你的程序相同的文件夹下就可以使用了。
用法很简单：
1.先用里面的InitializeWinIo函数安装驱动程序，
2.然后就可以用GetPortVal来读取端口或者用SetPortVal来写入端口了。
3.最后必须在中止应用函数之前或者不再需要WinIO库时调用ShutdownWinIo函数在内存中清除WinIO库。
好，让我们来做一个驱动级的键盘模拟吧。先把winio的3个文件拷贝到你的程序的文件夹下。
下面给出使用WINIO模拟按键的单元和使用方法：（注意是32位和64位的区别）
{****************************************************************************}
unit MNwinio;
interface
const
KBC_KEY_CMD = $64; //键盘命令端口
KBC_KEY_DATA = $60; //键盘数据端口
implementation
function InitializeWinIo: Boolean; stdcall; external 'WinIo.dll' name 'InitializeWinIo';
{
本函数初始化WioIO函数库。
必须在调用所有其它功能函数之前调用本函数。
如果函数调用成功，返回值为非零值。
如果调用失败，则返回值为0。
procedure TForm1.FormActivate(Sender: TObject); //通常在程序启动时调用
begin
if InitializeWinIo = False then
begin
Messagebox(handle, '初始化失败！', '提示', MB_OK + MB_IconError)
end;
end;
}
function InstallWinIoDriver(pszWinIoDriverPath: PString; IsDemandLoaded: boolean
= false): Boolean; stdcall; external 'WinIo.dll' name 'InstallWinIoDriver';
function RemoveWinIoDriver: Boolean; stdcall; external 'WinIo.dll' name
'RemoveWinIoDriver';
function GetPortVal(PortAddr: Word; PortVal: PDWord; bSize: Byte): Boolean;
stdcall; external 'WinIo.dll' name 'GetPortVal';
function SetPortVal(PortAddr: Word; PortVal: DWord; bSize: Byte): Boolean;
stdcall; external 'WinIo.dll' name 'SetPortVal';
function GetPhysLong(PhysAddr: PByte; PhysVal: PDWord): Boolean; stdcall;
external 'WinIo.dll' name 'GetPhysLong';
function SetPhysLong(PhysAddr: PByte; PhysVal: DWord): Boolean; stdcall; external
'WinIo.dll' name 'SetPhysLong';
function MapPhysToLin(PhysAddr: PByte; PhysSize: DWord; PhysMemHandle: PHandle):
PByte; stdcall; external 'WinIo.dll' name 'MapPhysToLin';
function UnMapPhysicalMemory(PhysMemHandle: THandle; LinAddr: PByte): Boolean;
stdcall; external 'WinIo.dll' name 'UnmapPhysicalMemory';
procedure ShutdownWinIo; stdcall; external 'WinIo.dll' name 'ShutdownWinIo';
{ 本函数在内存中清除WinIO库
本函数必须在中止应用函数之前或者不再需要WinIO库时调用
procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); //通常在程序关闭时调用
begin
ShutdownWinIo;
end;
}
{**********以上为WINIO.dll中API函数的调用***************}
procedure KBCWait4IBE; //等待键盘缓冲区为空
var
dwVal: DWord;
begin
repeat
GetPortVal($64, @dwVal, 1);
{这句表示从&H64端口读取一个字节并把读出的数据放到变量dwVal中. GetPortVal函数的用法是 GetPortVal (端口号,存放读出数据的变量地址,读入的长度}
until (dwVal and $2) = 0;
{上面的是一个根据KBC规范写的过程，它的作用是在向键盘端口写入数据前等待一段时间，后面将会用到。}
end;
procedure MyKeyDown(vKeyCoad: Integer); // 这个用来模拟按下键，参数vKeyCoad传入按键的虚拟码
var
btScancode: DWord;
begin
btScancode := MapVirtualKey(vKeyCoad, 0);
KBCWait4IBE; // 发送数据前应该先等待键盘缓冲区为空
SetPortVal($64, $D2, 1); // 发送键盘写入命令
{SetPortVal函数用于向端口写入数据，它的用法是：SetPortVal(端口号,欲写入的数据，写入数据的长度)}
KBCWait4IBE;
SetPortVal($60, btScancode, 1); //写入按键信息,按下键
end;
procedure MyKeyUp(vKeyCoad: Integer); //这个用来模拟释放键，参数vKeyCoad传入按键的虚拟码
var
btScancode: DWord;
begin
btScancode := MapVirtualKey(vKeyCoad, 0);
KBCWait4IBE;
SetPortVal($64, $D2, 1);
KBCWait4IBE;
SetPortVal($64, (btScancode or $80), 1);
end;
end.
{
使用方法：
如模拟按键 1
MyKeyDown($31);
Sleep(50);
MyKeyUp($31);
}
