鼠标录制精灵易语言， 鼠标动作录制脚本，键盘鼠标录制器【易语言】

文章附件下载：https://www.pan38.com/dow/share.php?code=JCnzE 提取密码：7447

非常牛X的一个鼠标键盘录制工具，连点器，我认为比按键精灵好用好几倍
源码部分：
.版本 2
.支持库 shellEx
.支持库 EThread
.支持库 eAPI
.支持库 spec
.支持库 shell
.支持库 iext

.程序集 窗口程序集_启动窗口
.程序集变量 索引, 整数型
.程序集变量 键盘钩子, 整数型
.程序集变量 鼠标钩子, 整数型
.程序集变量 间隔, 整数型
.程序集变量 记录, 逻辑型, , , 开始记录
.程序集变量 停止, 逻辑型, , , 暂停
.程序集变量 回放, 逻辑型, , , 开始回放
.程序集变量 速度状态, 逻辑型, , , 超级延时
.程序集变量 删除触发, 逻辑型
.程序集变量 行高, 整数型
.程序集变量 表项信息, 表项结构信息
.程序集变量 启动时间, 整数型
.程序集变量 时, 整数型
.程序集变量 分, 整数型
.程序集变量 秒, 整数型
.程序集变量 抖动, 逻辑型
.程序集变量 次数, 整数型
.程序集变量 F1, 整数型
.程序集变量 F3, 整数型
.程序集变量 F4, 整数型
.程序集变量 c, 整数型
.程序集变量 d, 整数型
.程序集变量 线程id, 整数型
.程序集变量 源信息, 整数型
.程序集变量 守护组, 文本型, , "0"
.程序集变量 路径组, 文本型, , "0"

.子程序 _启动窗口创建完毕
.局部变量 局_互斥体, 文本型
.局部变量 栏目文本, 文本型

' 禁止多开
局互斥体 ＝ “jfmi923owrj9823jr901omrop23mrfio” ' 等同与一个密码
.如果真 (API打开事件同步对象 (2031619, 假, 局互斥体) ≠ 0)
API控制窗口状态 (取数值注册项 (3, “脚本工具”, ), 1)
结束 ()
.如果真结束
API创建事件同步对象 (0, 假, 假, 局互斥体)
写注册项 (3, “脚本工具”, 启动窗口.取窗口句柄 ())

' 实时监控行数
时钟1.时钟周期 ＝ 100

' 超级列表框行距
华侨加载皮肤默认描边 ()
Cx超级列表框行距 (超级列表框2.取窗口句柄 (), 到整数 (20))
Cx超级列表框行距 (超级列表框3.取窗口句柄 (), 到整数 (20))

' 连点器
组合框1.现行选中项 ＝ 0
F1 ＝ 注册热键 (启动窗口.取窗口句柄 (), 标签1.取窗口句柄 (), 0, #F1键)
F3 ＝ 注册热键 (启动窗口.取窗口句柄 (), 标签1.取窗口句柄 (), 0, #F3键)
F4 ＝ 注册热键 (_启动窗口.取窗口句柄 (), 标签1.取窗口句柄 (), 0, #F4键)

' 超级列表框禁止拖动
源信息 ＝ 置窗口信息 (超级列表框2.取窗口句柄 (), -4, &处理函数)
源信息 ＝ 置窗口信息 (超级列表框3.取窗口句柄 (), -4, &处理函数)

' 脚本
现存脚本 ()
安装一个钩子 ()

' 放入文件夹内方可打开
.如果 (文件是否存在 (取运行目录 () ＋ “\脚本配置”) ＝ 真)

.否则
信息框 (“未找到配置文件夹”, 0, , )
结束 ()
.如果结束

' 崩溃自动恢复
启动线程 (&守护线程, , )
启动线程 (&防卡死, , )

.子程序 防卡死
.局部变量 进程名, 文本型, , "0"
.局部变量 计次, 整数型
.局部变量 计行, 整数型
.局部变量 停止值, 整数型

.判断循环首 (真)

.判断开始 (停止值 ＝ 2)

    跳出循环 ()
.默认

.判断结束

进程名 ＝ 取没有响应程序列表 ()
.计次循环首 (取数组成员数 (进程名), 计次)
    终止进程 (进程名 [计次])

    延迟 (2000)

.计次循环尾 ()
延迟 (5000)

.判断循环尾 ()

.子程序 守护线程
.局部变量 计行, 整数型
.局部变量 句柄组, 文本型, , "0"
.局部变量 计次, 整数型
.局部变量 找到状态, 整数型
.局部变量 停止值, 整数型

.判断循环首 (真)
.判断开始 (停止值 ＝ 2)

    跳出循环 ()

.默认

.判断结束

句柄组 ＝ 取所有窗口列表 ()


.计次循环首 (取数组成员数 (守护组), 计次)
    .判断开始 (计次 ＞ 取数组成员数 (守护组))
        跳出循环 ()
    .默认

    .判断结束


    找到状态 ＝ 0
    .计次循环首 (取数组成员数 (句柄组), 计行)

        .判断开始 (取窗口标题 (到整数 (句柄组 [计行])) ＝ 守护组 [计次])
            找到状态 ＝ 2
        .默认

        .判断结束

    .计次循环尾 ()
    .判断开始 (找到状态 ＝ 0)
        执行 (4, 路径组 [计次], , , )
        延迟 (5000)
    .默认

    .判断结束


.计次循环尾 ()

延迟 (10000)

.判断循环尾 ()

.子程序 时钟1周期事件

状态条1.置文本 (3, 到文本 (超级列表框3.取表项数 ()) ＋ “行”)

.子程序 处理函数, 整数型, , 超级列表框禁止拖动
.参数 Hwnd, 整数型
.参数 类型, 整数型
.参数 信息1, 整数型
.参数 信息2, 整数型

.判断开始 (类型 ＝ 78)
返回 (-1)
.默认
返回 (调窗口消息 (源信息, Hwnd, 类型, 信息1, 信息2))
.判断结束

.子程序 按钮3被单击

c ＝ 超级列表框2.插入表项 (, , , , , )
.判断开始 (编辑框1.内容 ＝ “”)
信息框 (“插入延时不能为空”, 0, , )
.默认
超级列表框2.置标题 (c, 0, 到文本 (c ＋ 1))
超级列表框2.置标题 (c, 1, “延时（” ＋ 编辑框1.内容 ＋ “）”)
.判断结束
超级列表框2.保证显示 (超级列表框2.取表项数 () － 1)
状态条1.置文本 (3, 到文本 (超级列表框2.取表项数 ()) ＋ “行”)

.子程序 按钮2被单击

c ＝ 超级列表框2.插入表项 (, , , , , )
超级列表框2.置标题 (c, 0, 到文本 (c ＋ 1))
超级列表框2.置标题 (c, 1, 组合框1.内容 ＋ “(x：” ＋ 编辑框2.内容 ＋ “y：” ＋ 编辑框3.内容 ＋ “)”)
超级列表框2.保证显示 (超级列表框2.取表项数 () － 1)
状态条1.置文本 (3, 到文本 (超级列表框2.取表项数 ()) ＋ “行”)

.子程序 按钮4被单击

线程id ＝ 线程_启动 (&模式选择, , )

.子程序 模式选择
.局部变量 i, 整数型

按钮4.禁止 ＝ 真
按钮5.禁止 ＝ 假
.计次循环首 (超级列表框2.取表项数 (), i) ' 清空状态
超级列表框2.置标题 (i － 1, 2, “”)
.计次循环尾 ()

.判断开始 (单选框1.选中 ＝ 真)

.循环判断首 ()
    .计次循环首 (超级列表框2.取表项数 (), i)
        超级列表框2.置标题 (i － 1, 2, “执行中”)
        .如果 (寻找文本 (超级列表框2.取标题 (i － 1, 1), “左键单击”, , 假) ≠ -1)
            模拟鼠标点击 (到整数 (文本_取出中间文本 (超级列表框2.取标题 (i － 1, 1), “x：”, “y：”, )), 到整数 (文本_取出中间文本 (超级列表框2.取标题 (i － 1, 1), “y：”, “)”, )), 0)
            状态条1.置文本 (3, 到文本 (超级列表框3.取表项数 ()) ＋ “行”)

        .否则
            .如果 (寻找文本 (超级列表框2.取标题 (i － 1, 1), “左键双击”, , 假) ≠ -1)
                模拟鼠标点击 (到整数 (文本_取出中间文本 (超级列表框2.取标题 (i － 1, 1), “x：”, “y：”, )), 到整数 (文本_取出中间文本 (超级列表框2.取标题 (i － 1, 1), “y：”, “)”, )), 1)
            .否则

                .如果 (寻找文本 (超级列表框2.取标题 (i － 1, 1), “右键单击”, , 假) ≠ -1)
                    模拟鼠标点击 (到整数 (文本_取出中间文本 (超级列表框2.取标题 (i － 1, 1), “x：”, “y：”, , )), 到整数 (文本_取出中间文本 (超级列表框2.取标题 (i － 1, 1), “y：”, “)”, )), 2)
                .否则
                    .如果 (寻找文本 (超级列表框2.取标题 (i － 1, 1), “右键双击”, , 假) ≠ -1)
                        模拟鼠标点击 (到整数 (文本_取出中间文本 (超级列表框2.取标题 (i － 1, 1), “x：”, “y：”, , )), 到整数 (文本_取出中间文本 (超级列表框2.取标题 (i － 1, 1), “y：”, “)”, )), 3)
                    .否则

                    .如果结束

                .如果结束

            .如果结束

        .如果结束


        .如果真 (寻找文本 (超级列表框2.取标题 (i － 1, 1), “延时”, , 假) ≠ -1)  ' 延时命令
            程序_延时 (到整数 (文本_取出中间文本 (超级列表框2.取标题 (i － 1, 1), “延时（”, “）”, , )))



        .如果真结束



        超级列表框2.置标题 (i － 1, 2, “完成”)


    .计次循环尾 ()




.循环判断尾 (单选框1.选中 ＝ 真)

.判断 (单选框2.选中 ＝ 真)

.计次循环首 (到整数 (编辑框4.内容), )
    .计次循环首 (超级列表框2.取表项数 (), i)
        超级列表框2.置标题 (i － 1, 2, “执行中”)
        .如果 (寻找文本 (超级列表框2.取标题 (i － 1, 1), “左键单击”, , 假) ≠ -1)
            模拟鼠标点击 (到整数 (文本_取出中间文本 (超级列表框2.取标题 (i － 1, 1), “x：”, “y：”, )), 到整数 (文本_取出中间文本 (超级列表框2.取标题 (i － 1, 1), “y：”, “)”, )), 0)
        .否则
            .如果 (寻找文本 (超级列表框2.取标题 (i － 1, 1), “左键双击”, , 假) ≠ -1)
                模拟鼠标点击 (到整数 (文本_取出中间文本 (超级列表框2.取标题 (i － 1, 1), “x：”, “y：”, )), 到整数 (文本_取出中间文本 (超级列表框2.取标题 (i － 1, 1), “y：”, “)”, )), 1)
            .否则
                .如果 (寻找文本 (超级列表框2.取标题 (i － 1, 1), “右键单击”, , 假) ≠ -1)
                    模拟鼠标点击 (到整数 (文本_取出中间文本 (超级列表框2.取标题 (i － 1, 1), “x：”, “y：”, , )), 到整数 (文本_取出中间文本 (超级列表框2.取标题 (i － 1, 1), “y：”, “)”, )), 2)
                .否则
                    .如果 (寻找文本 (超级列表框2.取标题 (i － 1, 1), “右键双击”, , 假) ≠ -1)
                        模拟鼠标点击 (到整数 (文本_取出中间文本 (超级列表框2.取标题 (i － 1, 1), “x：”, “y：”, , )), 到整数 (文本_取出中间文本 (超级列表框2.取标题 (i － 1, 1), “y：”, “)”, )), 3)
                    .否则

                    .如果结束

                .如果结束

            .如果结束

        .如果结束


        .如果真 (寻找文本 (超级列表框2.取标题 (i － 1, 1), “延时”, , 假) ≠ -1)  ' 延时命令
            程序_延时 (到整数 (文本_取出中间文本 (超级列表框2.取标题 (i － 1, 1), “延时（”, “）”, , )))


        .如果真结束


        超级列表框2.置标题 (i － 1, 2, “完成”)


    .计次循环尾 ()



.计次循环尾 ()

.默认

.判断结束
按钮5.禁止 ＝ 真
按钮4.禁止 ＝ 假

.子程序 单选框1被单击

单选框2.选中 ＝ 假

.子程序 单选框2被单击

单选框1.选中 ＝ 假

.子程序 标签1反馈事件, 整数型, , 易语言学习资源、源码下载站：www.eyuyan.la
.参数 参数一, 整数型
.参数 参数二, 整数型

.如果真 (参数一 ＝ F1)
编辑框2.内容 ＝ 到文本 (取鼠标水平位置 ())
编辑框3.内容 ＝ 到文本 (取鼠标垂直位置 ())

.如果真结束
.如果真 (参数一 ＝ F3)
按钮4.禁止 ＝ 真
按钮5.禁止 ＝ 假
线程id ＝ 线程_启动 (&模式选择, , )

.如果真结束
.如果真 (参数一 ＝ F4)
按钮4.禁止 ＝ 假
按钮5.禁止 ＝ 真
强制结束线程 (线程id)
.如果真结束

.子程序 按钮6被单击
.局部变量 sj, 文本型, , "0"
.局部变量 i, 整数型

通用对话框1.打开 ()
sj ＝ 分割文本 (到文本 (读入文件 (通用对话框1.文件名)), #换行符, )
.计次循环首 (取数组成员数 (sj), i)
c ＝ 超级列表框2.插入表项 (, , , , , )
超级列表框2.置标题 (c, 0, 到文本 (c ＋ 1))
超级列表框2.置标题 (c, 1, sj [i])

.计次循环尾 ()

.子程序 按钮7被单击
.局部变量 i, 整数型
.局部变量 n, 文本型

输入框 (“请输入欲保存的文件名” ＋ #换行符 ＋ “默认保存运行目录”, “脚本配置提示您：”, , n, , )
.计次循环首 (超级列表框2.取表项数 (), i)
写到文件 (取运行目录 () ＋ “\” ＋ n ＋ “.txt”, 读入文件 (取运行目录 () ＋ “\” ＋ n ＋ “.txt”), 到字节集 (超级列表框2.取标题 (i － 1, 1)), 到字节集 (#换行符))
.计次循环尾 ()

.子程序 选择框1被单击

.如果真 (选择框1.选中 ＝ 真)
启动窗口.总在最前 ＝ 真
.如果真结束
.如果真 (选择框1.选中 ＝ 假) 启动窗口.总在最前 ＝ 假
.如果真结束

.子程序 超级列表框2右键单击表项

弹出菜单 (C, , )

.子程序 选中删除被选择
.局部变量 删除后置标题, 整数型

.如果真 (信息框 (“您确定删除选中数据吗？”, 0 ＋ #确认取消钮, , _启动窗口.取窗口句柄 ()) ＝ #确认钮)
.判断循环首 (超级列表框2.现行选中项 ≠ -1)
超级列表框2.删除表项 (超级列表框2.现行选中项)
.判断循环尾 ()
.计次循环首 (超级列表框2.取表项数 (), 删除后置标题)
超级列表框2.置标题 (删除后置标题 － 1, 0, 到文本 (删除后置标题))
.计次循环尾 ()
.如果真结束

.子程序 全部删除被选择

.如果真 (信息框 (“您确定删除全部数据吗？”, 0 ＋ #确认取消钮, , _启动窗口.取窗口句柄 ()) ＝ #确认钮)
超级列表框3.全部删除 ()
返回 ()
.如果真结束

.子程序 删除选中被选择
.局部变量 删除后置标题计次, 整数型

.如果真 (信息框 (“您确定删除选中数据吗？”, 0 ＋ #确认取消钮, , _启动窗口.取窗口句柄 ()) ＝ #确认钮)
.判断循环首 (超级列表框3.现行选中项 ≠ -1)
超级列表框3.删除表项 (超级列表框3.现行选中项)
.判断循环尾 ()
.计次循环首 (超级列表框3.取表项数 (), 删除后置标题计次)
超级列表框3.置标题 (删除后置标题计次 － 1, 0, 到文本 (删除后置标题计次))
.计次循环尾 ()
返回 ()
.如果真结束

.子程序 代码转换, 文本型
.参数 键代码, 整数型

.如果真 (键代码 ＝ 65)
返回 (“A”)
.如果真结束
.如果真 (键代码 ＝ 66)
返回 (“B”)
.如果真结束
.如果真 (键代码 ＝ 67)
返回 (“C”)
.如果真结束
.如果真 (键代码 ＝ 68)
返回 (“D”)
.如果真结束
.如果真 (键代码 ＝ 69)
返回 (“E”)
.如果真结束
.如果真 (键代码 ＝ 70)
返回 (“F”)
.如果真结束
.如果真 (键代码 ＝ 71)
返回 (“G”)
.如果真结束
.如果真 (键代码 ＝ 72)
返回 (“H”)
.如果真结束
.如果真 (键代码 ＝ 73)
返回 (“I”)
.如果真结束
.如果真 (键代码 ＝ 74)
返回 (“J”)
.如果真结束
.如果真 (键代码 ＝ 75)
返回 (“K”)
.如果真结束
.如果真 (键代码 ＝ 76)
返回 (“L”)
.如果真结束
.如果真 (键代码 ＝ 77)
返回 (“M”)
.如果真结束
.如果真 (键代码 ＝ 78)
返回 (“N”)
.如果真结束
.如果真 (键代码 ＝ 79)
返回 (“O”)
.如果真结束
.如果真 (键代码 ＝ 80)
返回 (“P”)
.如果真结束
.如果真 (键代码 ＝ 81)
返回 (“Q”)
.如果真结束
.如果真 (键代码 ＝ 82)
返回 (“R”)
.如果真结束
.如果真 (键代码 ＝ 83)
返回 (“S”)
.如果真结束
.如果真 (键代码 ＝ 84)
返回 (“T”)
.如果真结束
.如果真 (键代码 ＝ 85)
返回 (“U”)
.如果真结束
.如果真 (键代码 ＝ 86)
返回 (“V”)
.如果真结束
.如果真 (键代码 ＝ 87)
返回 (“W”)
.如果真结束
.如果真 (键代码 ＝ 88)
返回 (“X”)
.如果真结束
.如果真 (键代码 ＝ 89)
返回 (“Y”)
.如果真结束
.如果真 (键代码 ＝ 90)
返回 (“Z”)
.如果真结束
.如果真 (键代码 ＝ 48)
返回 (“0”)
.如果真结束
.如果真 (键代码 ＝ 49)
返回 (“1”)
.如果真结束
.如果真 (键代码 ＝ 50)
返回 (“2”)
.如果真结束
.如果真 (键代码 ＝ 51)
返回 (“3”)
.如果真结束
.如果真 (键代码 ＝ 52)
返回 (“4”)
.如果真结束
.如果真 (键代码 ＝ 53)
返回 (“5”)
.如果真结束
.如果真 (键代码 ＝ 54)
返回 (“6”)
.如果真结束
.如果真 (键代码 ＝ 55)
返回 (“7”)
.如果真结束
.如果真 (键代码 ＝ 56)
返回 (“8”)
.如果真结束
.如果真 (键代码 ＝ 57)
返回 (“9”)
.如果真结束
.如果真 (键代码 ＝ 112)
返回 (“F1”)
.如果真结束
.如果真 (键代码 ＝ 113)
返回 (“F2”)
.如果真结束
.如果真 (键代码 ＝ 114)
返回 (“F3”)
.如果真结束
.如果真 (键代码 ＝ 115)
返回 (“F4”)
.如果真结束
.如果真 (键代码 ＝ 116)
返回 (“F5”)
.如果真结束
.如果真 (键代码 ＝ 117)
返回 (“F6”)
.如果真结束
.如果真 (键代码 ＝ 118)
返回 (“F7”)
.如果真结束
.如果真 (键代码 ＝ 119)
返回 (“F8”)
.如果真结束
.如果真 (键代码 ＝ 120)
返回 (“F9”)
.如果真结束
.如果真 (键代码 ＝ 121)
返回 (“F10”)
.如果真结束
.如果真 (键代码 ＝ 122)
返回 (“F11”)
.如果真结束
.如果真 (键代码 ＝ 123)
返回 (“F12”)
.如果真结束
.如果真 (键代码 ＝ 8)
返回 (“Backspace”)
.如果真结束
.如果真 (键代码 ＝ 9)
返回 (“Tab”)
.如果真结束
.如果真 (键代码 ＝ 12)
返回 (“Clear”)
.如果真结束
.如果真 (键代码 ＝ 13)
返回 (“Enter”)
.如果真结束
.如果真 (键代码 ＝ 16 或 键代码 ＝ 160)
返回 (“Shift”)
.如果真结束
.如果真 (键代码 ＝ 17 或 键代码 ＝ 162)
返回 (“Ctrl”)
.如果真结束
.如果真 (键代码 ＝ 18 或 键代码 ＝ 164)
返回 (“Alt”)
.如果真结束
.如果真 (键代码 ＝ 20)
返回 (“Caps Lock”)
.如果真结束
.如果真 (键代码 ＝ 27)
返回 (“Esc”)
.如果真结束
.如果真 (键代码 ＝ 32)
返回 (“空格键”)
.如果真结束
.如果真 (键代码 ＝ 33)
返回 (“Page Up”)
.如果真结束
.如果真 (键代码 ＝ 34)
返回 (“Page Down”)
.如果真结束
.如果真 (键代码 ＝ 35)
返回 (“End”)
.如果真结束
.如果真 (键代码 ＝ 36)
返回 (“Home”)
.如果真结束
.如果真 (键代码 ＝ 37)
返回 (“左箭头”)
.如果真结束
.如果真 (键代码 ＝ 38)
返回 (“向上箭头”)
.如果真结束
.如果真 (键代码 ＝ 39)
返回 (“右箭头”)
.如果真结束
.如果真 (键代码 ＝ 40)
返回 (“向下箭头”)
.如果真结束
.如果真 (键代码 ＝ 45)
返回 (“Insert”)
.如果真结束
.如果真 (键代码 ＝ 46)
返回 (“Delete”)
.如果真结束
.如果真 (键代码 ＝ 47)
返回 (“Help”)
.如果真结束
.如果真 (键代码 ＝ 144)
返回 (“Num Lock”)
.如果真结束
.如果真 (键代码 ＝ 192)
返回 (“~”)
.如果真结束
.如果真 (键代码 ＝ 219)
返回 (“{”)
.如果真结束
.如果真 (键代码 ＝ 221)
返回 (“}”)
.如果真结束
.如果真 (键代码 ＝ 186)
返回 (“:”)
.如果真结束
.如果真 (键代码 ＝ 222)
返回 (#引号)
.如果真结束
.如果真 (键代码 ＝ 220)
返回 (“|”)
.如果真结束
.如果真 (键代码 ＝ 188)
返回 (“<”)
.如果真结束
.如果真 (键代码 ＝ 190)
返回 (“>”)
.如果真结束
.如果真 (键代码 ＝ 191)
返回 (“?”)
.如果真结束
返回 (“”)

.子程序 展开效果

.判断循环首 (高度 ＜ 470)
.如果 (高度 ＞ 470)
高度 ＝ 470
.否则
高度 ＝ 高度 ＋ 10
.如果结束
超级延时 (10)
处理事件 ()
.判断循环尾 ()
超级延时 (500)

.子程序 现存脚本
.局部变量 脚本文件名, 文本型

脚本列表框.清空 ()
脚本文件名 ＝ 寻找文件 (取运行目录 () ＋ “\脚本配置*.txt”, )
.判断循环首 (脚本文件名 ≠ “”)
脚本列表框.加入项目 (脚本文件名, )
脚本文件名 ＝ 寻找文件 (, )
.判断循环尾 ()
脚本列表框.现行选中项 ＝ 脚本列表框.取项目数 () － 1

.子程序 载入脚本
.参数 脚本文件名, 文本型
.局部变量 文本2, 整数型
.局部变量 索引2, 整数型
.局部变量 文本数组2, 文本型, , "0"

文本2 ＝ 打开文件 (脚本文件名, #读入, )
.判断循环首 (是否在文件尾 (文本2, ) ＝ 假)
文本数组2 ＝ 分割文本 (读入一行 (文本2), “-”, )
索引2 ＝ 超级列表框3.插入表项 (, , , , , )
超级列表框3.置标题 (索引2, 0, 文本数组2 [1])
超级列表框3.置标题 (索引2, 1, 文本数组2 [2])
超级列表框3.置标题 (索引2, 2, 文本数组2 [3])
超级列表框3.置标题 (索引2, 3, 文本数组2 [4])
超级列表框3.置标题 (索引2, 4, 文本数组2 [5])
超级列表框3.置标题 (索引2, 5, 文本数组2 [6])
超级列表框3.置标题 (索引2, 6, 文本数组2 [7])
超级列表框3.置标题 (索引2, 7, 文本数组2 [8])
状态条1.置文本 (3, 到文本 (超级列表框3.取表项数 ()) ＋ “行”)
.判断循环尾 ()
关闭文件 (文本2)

.子程序 安装一个钩子, , , 易语言学习资源、源码下载站：www.eyuyan.la

.如果真 (键盘钩子 ≠ 0)
超级延时 (500)
.如果真结束
键盘钩子 ＝ 安装钩子 (13, &键盘监视处理, 对象句柄 (0), 0)

.子程序 键盘监视处理, 整数型
.参数 nCode, 整数型
.参数 Wparam, 整数型
.参数 Lparam, 整数型
.局部变量 局状态键, 整数型, 静态
.局部变量 局键代码, 整数型
.局部变量 按键, 按键信息

.如果真 (nCode ＝ 0)
重叠复制 (按键, Lparam, 20)
.判断开始 (按键.标记 ＜ 35) ' 按下
局键代码 ＝ 按键.虚拟码
.判断开始 (按键.虚拟码 ＝ 160 或 按键.虚拟码 ＝ 161) ' 左Shift键 和 右Shift键
局_状态键 ＝ #Shift键

    .判断 (按键.虚拟码 ＝ 162 或 按键.虚拟码 ＝ 163)  ' 左Ctrl键 和 右Ctrl键
        局_状态键 ＝ #Ctrl键

    .判断 (按键.虚拟码 ＝ 164 或 按键.虚拟码 ＝ 165)  ' 左Alt键 和 右Alt键
        局_状态键 ＝ #Alt键

    .判断 (按键.虚拟码 ＝ 91 或 按键.虚拟码 ＝ 92)  ' 左Win键 和 右Win键
        局_状态键 ＝ 91
    .默认

    .判断结束
    键盘按下设置 (局_状态键, 局_键代码)  ' 按下触发
.判断 (按键.标记 ＞ 127)  ' 放开
    局_键代码 ＝ 按键.虚拟码
    .判断开始 (按键.虚拟码 ＝ 160 或 按键.虚拟码 ＝ 161)  ' 左Shift键 和 右Shift键
        局_状态键 ＝ 0

    .判断 (按键.虚拟码 ＝ 162 或 按键.虚拟码 ＝ 163)  ' 左Ctrl键 和 右Ctrl键
        局_状态键 ＝ 0

    .判断 (按键.虚拟码 ＝ 164 或 按键.虚拟码 ＝ 165)  ' 左Alt键 和 右Alt键
        局_状态键 ＝ 0

    .判断 (按键.虚拟码 ＝ 91 或 按键.虚拟码 ＝ 92)  ' 左Win键 和 右Win键
        局_状态键 ＝ 0
    .默认

    .判断结束
    键盘放开设置 (局_状态键, 局_键代码)  ' 键盘放开
.默认

.判断结束

.如果真结束
返回 (_下个钩子 (键盘钩子, nCode, Wparam, Lparam))

.子程序 鼠标监视处理, 整数型, , 本源码来自易语言资源网(www.eyuyan.la)
.参数 code, 整数型
.参数 wp, 整数型
.参数 lp, 整数型
.局部变量 按键信息, 按键信息
.局部变量 鼠标操作, 文本型
.局部变量 轨迹, 逻辑型

处理事件 ()
_重叠复制 (按键信息, lp, 20)
.如果真 (wp ＝ 513)
鼠标操作 ＝ “左键按下”
轨迹 ＝ 真
.如果真结束
.如果真 (wp ＝ 514)
鼠标操作 ＝ “左键弹起”
轨迹 ＝ 真
.如果真结束
.如果真 (wp ＝ 516)
鼠标操作 ＝ “右键按下”
轨迹 ＝ 真
.如果真结束
.如果真 (wp ＝ 517)
鼠标操作 ＝ “右键弹起”
轨迹 ＝ 真
.如果真结束
.如果真 (wp ＝ 519)
鼠标操作 ＝ “中键按下”
轨迹 ＝ 真
.如果真结束
.如果真 (wp ＝ 520)
鼠标操作 ＝ “中键弹起”
轨迹 ＝ 真
.如果真结束
.如果真 (wp ＝ 522)
.如果真 (按键信息.标记 ＝ 7864320)
鼠标操作 ＝ “滚轮向上”
轨迹 ＝ 真
.如果真结束
.如果真 (按键信息.标记 ＝ -7864320)
鼠标操作 ＝ “滚轮向下”
轨迹 ＝ 真
.如果真结束

.如果真结束
.如果 (选择框2.选中 ＝ 真)
间隔 ＝ 取启动时间 () － 间隔
索引 ＝ 超级列表框3.插入表项 (, , , , , )
超级列表框3.保证显示 (超级列表框3.取表项数 () － 1)
超级列表框3.现行选中项 ＝ 超级列表框3.取表项数 () － 1
超级列表框3.置标题 (索引, 0, 到文本 (超级列表框3.取表项数 ()))
超级列表框3.置标题 (索引, 1, 到文本 (取鼠标水平位置 ()))
超级列表框3.置标题 (索引, 2, 到文本 (取鼠标垂直位置 ()))
超级列表框3.置标题 (索引, 3, 到文本 (间隔))
超级列表框3.置标题 (索引, 4, “鼠标”)
超级列表框3.置标题 (索引, 5, 鼠标操作)
超级列表框3.置标题 (索引, 6, “”)
状态条1.置文本 (3, 到文本 (超级列表框3.取表项数 ()) ＋ “行”)
间隔 ＝ 取启动时间 ()

.否则
.如果 (轨迹 ＝ 真)
间隔 ＝ 取启动时间 () － 间隔
索引 ＝ 超级列表框3.插入表项 (, , , , , )
超级列表框3.保证显示 (超级列表框3.取表项数 () － 1)
超级列表框3.现行选中项 ＝ 超级列表框3.取表项数 () － 1
超级列表框3.置标题 (索引, 0, 到文本 (超级列表框3.取表项数 ()))
超级列表框3.置标题 (索引, 1, 到文本 (取鼠标水平位置 ()))
超级列表框3.置标题 (索引, 2, 到文本 (取鼠标垂直位置 ()))
超级列表框3.置标题 (索引, 3, 到文本 (间隔))
超级列表框3.置标题 (索引, 4, “鼠标”)
超级列表框3.置标题 (索引, 5, 鼠标操作)
超级列表框3.置标题 (索引, 6, “”)
状态条1.置文本 (3, 到文本 (超级列表框3.取表项数 ()) ＋ “行”)
间隔 ＝ 取启动时间 ()

.否则

.如果结束

.如果结束
返回 (_下个钩子 (鼠标钩子, code, wp, lp))

.子程序 键盘按下设置
.参数 功能键状态, 整数型
.参数 键代码, 整数型

处理事件 ()
.如果真 (键代码 ≠ 到整数 (记录编辑框11.内容) 且 记录 ＝ 真)
.如果真 (键代码 ＝ 到整数 (记录编辑框22.内容) 且 记录 ＝ 真)
返回 ()
.如果真结束
.如果真 (键代码 ＝ 到整数 (记录编辑框33.内容) 且 记录 ＝ 真)
返回 ()
.如果真结束
.如果真 (键代码 ＝ 到整数 (记录编辑框44.内容) 且 记录 ＝ 真)
返回 ()
.如果真结束
.如果真 (选择框3.选中 ＝ 真)
间隔 ＝ 取启动时间 () － 间隔
索引 ＝ 超级列表框3.插入表项 (, , , , , )
超级列表框3.保证显示 (超级列表框3.取表项数 () － 1)
超级列表框3.现行选中项 ＝ 超级列表框3.取表项数 () － 1
超级列表框3.置标题 (索引, 0, 到文本 (超级列表框3.取表项数 ()))
超级列表框3.置标题 (索引, 3, 到文本 (间隔))
超级列表框3.置标题 (索引, 4, 代码转换 (键代码))
超级列表框3.置标题 (索引, 5, “键盘按下”)
超级列表框3.置标题 (索引, 6, 到文本 (键代码))
间隔 ＝ 取启动时间 ()
状态条1.置文本 (3, 到文本 (超级列表框3.取表项数 ()) ＋ “行”)
.如果真结束

.如果真结束
.如果真 (键代码 ＝ 到整数 (记录编辑框11.内容))
.如果 (记录 ＝ 真)
A停止记录 ()
记录 ＝ 假
记录选择框.选中 ＝ 假
状态条1.置文本 (4, “结束录制”)
状态条1.置文本 (5, “。。。”)
.否则
.如果 (状态条1.取文本 (4) ＝ “正在执行”)

    .否则
        记录 ＝ 真
        A开始记录 ()
        记录选择框.选中 ＝ 真
        状态条1.置文本 (4, “正在录制”)
        状态条1.置文本 (5, “。。。”)
    .如果结束

.如果结束
鸣叫 ()

.如果真结束
.如果真 (键代码 ＝ 到整数 (记录编辑框22.内容))
.如果 (超级列表框3.取表项数 () ＝ 0)
状态条1.置文本 (5, “无脚本”)
返回 ()
.否则
.如果 (超级列表框3.取表项数 () ≠ 0 且 状态条1.取文本 (4) ≠ “正在执行”)
回放 ()
停止 ＝ 假
回放选择框.选中 ＝ 真
状态条1.置文本 (4, “执行”)
状态条1.置文本 (5, “执行”)
.否则
.如果 (状态条1.取文本 (4) ＝ “正在执行”)
停止 ＝ 真
时钟4.时钟周期 ＝ 0
回放选择框.选中 ＝ 假
循环选择框.选中 ＝ 假
状态条1.置文本 (4, “暂停”)
状态条1.置文本 (5, “暂停”)
.否则

        .如果结束

    .如果结束

.如果结束
鸣叫 ()

.如果真结束
.如果真 (键代码 ＝ 到整数 (记录编辑框33.内容))
.如果 (循环选择框.选中 ＝ 假)
循环选择框.选中 ＝ 真
状态条1.置文本 (6, “循环”)
.否则
循环选择框.选中 ＝ 假
状态条1.置文本 (6, “单次”)
.如果结束
鸣叫 ()
.如果真结束
.如果真 (键代码 ＝ 到整数 (记录编辑框44.内容))
停止 ＝ 真
关闭选择框.选中 ＝ 真
卸载钩子 (鼠标钩子) 卸载钩子 (键盘钩子)
销毁 ()
.如果真结束

.子程序 键盘放开设置
.参数 功能键状态, 整数型
.参数 键代码, 整数型

.如果真 (键代码 ≠ 到整数 (记录编辑框11.内容) 且 记录 ＝ 真)
.如果真 (键代码 ＝ 到整数 (记录编辑框22.内容) 且 记录 ＝ 真)
返回 ()
.如果真结束
.如果真 (键代码 ＝ 到整数 (记录编辑框33.内容) 且 记录 ＝ 真)
返回 ()
.如果真结束
.如果真 (键代码 ＝ 到整数 (记录编辑框44.内容) 且 记录 ＝ 真)
返回 ()
.如果真结束
.如果真 (选择框3.选中 ＝ 真)
间隔 ＝ 取启动时间 () － 间隔
索引 ＝ 超级列表框3.插入表项 (, , , , , )
超级列表框3.保证显示 (超级列表框3.取表项数 () － 1)
超级列表框3.现行选中项 ＝ 超级列表框3.取表项数 () － 1
超级列表框3.置标题 (索引, 0, 到文本 (超级列表框3.取表项数 ()))
超级列表框3.置标题 (索引, 3, 到文本 (间隔))
超级列表框3.置标题 (索引, 4, 代码转换 (键代码))
超级列表框3.置标题 (索引, 5, “键盘放开”)
超级列表框3.置标题 (索引, 6, 到文本 (键代码))
间隔 ＝ 取启动时间 ()
状态条1.置文本 (3, 到文本 (超级列表框3.取表项数 ()) ＋ “行”)

.如果真结束

.如果真结束
处理事件 ()

.子程序 A开始记录

间隔 ＝ 取启动时间 ()
鼠标钩子 ＝ 安装钩子 (14, &鼠标监视处理, 对象句柄 (0), 0)
.如果真 (选择框4.选中 ＝ 真)
位置 ＝ 2
.如果真结束

.子程序 A停止记录

_卸载钩子 (鼠标钩子)
位置 ＝ 0

.子程序 回放

.如果真 (选择框5.选中 ＝ 真)
位置 ＝ 2
.如果真结束

.如果真 (超级列表框3.取表项数 () ≠ 0)
启动线程 (&开始回放, , )
.如果真结束

.子程序 开始回放
.局部变量 当前项, 整数型
.局部变量 按键, 文本型
.局部变量 临时文本数组, 文本型, , "0"
.局部变量 计次, 整数型

处理事件 ()
.如果 (回放 ＝ 真)
返回 ()
.否则
回放 ＝ 真
超级列表框3.现行选中项 ＝ 0
.如果结束
.计次循环首 (超级列表框3.取表项数 (), 当前项)
.如果真 (停止 ＝ 真)
跳出循环 ()
位置 ＝ 0
.如果真结束
状态条1.置文本 (4, “正在执行”)
状态条1.置文本 (5, “执行中”)
超级列表框3.保证显示 (当前项 ＋ 5)
超级列表框3.现行选中项 ＝ 当前项
.判断开始 (超级列表框3.取标题 (当前项 － 1, 4) ＝ “鼠标”)
.如果真 (到整数 (超级列表框3.取标题 (当前项 － 1, 3)) ≠ 0)
超级延时 (到整数 (超级列表框3.取标题 (当前项 － 1, 3)))
.如果真结束
移动鼠标 (到整数 (超级列表框3.取标题 (当前项 － 1, 1)), 到整数 (超级列表框3.取标题 (当前项 － 1, 2)))
.如果真 (超级列表框3.取标题 (当前项 － 1, 5) ≠ “”)
按键 ＝ 超级列表框3.取标题 (当前项 － 1, 5)
.如果真 (按键 ＝ “左键按下”)
鼠标操作 (1, 3)
.如果真结束
.如果真 (按键 ＝ “左键弹起”)
鼠标操作 (1, 4)
.如果真结束
.如果真 (按键 ＝ “右键按下”)
鼠标操作 (2, 3)
.如果真结束
.如果真 (按键 ＝ “右键弹起”)
鼠标操作 (2, 4)
.如果真结束
.如果真 (按键 ＝ “中键按下”)
鼠标操作 (3, 3)
.如果真结束
.如果真 (按键 ＝ “中键弹起”)
鼠标操作 (3, 4)
.如果真结束
.如果真 (按键 ＝ “滚轮向上”)
发送消息 (取鼠标所在窗口句柄 (), 277, 0, 0) ' 向上滚动一行
.如果真结束
.如果真 (按键 ＝ “滚轮向下”)
发送_消息 (取鼠标所在窗口句柄 (), 277, 1, 0) ' 向下滚动一行
.如果真结束

    .如果真结束

.默认
    .如果真 (到整数 (超级列表框3.取标题 (当前项 － 1, 3)) ≠ 0)
        超级延时 (到整数 (超级列表框3.取标题 (当前项 － 1, 3)), )
    .如果真结束
    .如果真 (超级列表框3.取标题 (当前项 － 1, 6) ≠ “”)  ' 键值
        按键 ＝ 超级列表框3.取标题 (当前项 － 1, 5)
        .如果真 (按键 ＝ “键盘按下”)
            模拟键盘按键 (到整数 (超级列表框3.取标题 (当前项 － 1, 6)), 3, )
        .如果真结束
        .如果真 (按键 ＝ “键盘放开”)
            模拟键盘按键 (到整数 (超级列表框3.取标题 (当前项 － 1, 6)), 4, )
        .如果真结束

    .如果真结束

    .如果真 (到整数 (超级列表框3.取标题 (当前项 － 1, 3)) ＝ 0)
        .如果真 (超级列表框3.取标题 (当前项 － 1, 4) ＝ “文本”)
            文本_逐字分割 (超级列表框3.取标题 (当前项 － 1, 5), 临时文本数组)
            .计次循环首 (取数组成员数 (临时文本数组), 计次)
                调试输出 (临时文本数组 [计次])
                模拟键盘按键 (键盘_键名取键代码 (临时文本数组 [计次] ＋ “键”), 1)
                程序_延时 (到整数 (超级列表框3.取标题 (当前项 － 1, 6)))
            .计次循环尾 ()
        .如果真结束
        .如果真 (超级列表框3.取标题 (当前项 － 1, 4) ＝ “延时”)
            程序_延时 (到整数 (超级列表框3.取标题 (当前项 － 1, 5)))
        .如果真结束

    .如果真结束

.判断结束
处理事件 ()

.计次循环尾 ()
状态条1.置文本 (4, “结束”)
状态条1.置文本 (5, “结束”)
回放 ＝ 假
.如果 (循环选择框.选中 ＝ 真)
启动线程 (&开始回放, , )
状态条1.置文本 (6, “循环”)
.否则
状态条1.置文本 (6, “单次”)
.如果结束
回放选择框.选中 ＝ 假
.如果 (选择框5.选中 ＝ 真 且 状态条1.取文本 (6) ＝ “循环”)

.否则
' 位置 ＝ 0 ' 执行完毕弹出窗口
.如果结束

.子程序 超级延时, , , 高精度延时,cpu占用低,窗口不卡死,一次最大可延时几年 (无返回值)
.参数 延时间隔, 整数型, , 1000微秒 = 1毫秒 ； 1000毫秒 = 1秒
.参数 延时单位, 整数型, 可空, 可空:毫秒 0 毫秒 1 微秒 2 秒 3 分 4 小时 5 天
.局部变量 哈哈, 整数型
.局部变量 嘿嘿, 超级延时

.如果真 (速度状态 ＝ 真)
延时单位 ＝ 1
.如果真结束
.判断开始 (延时单位 ＝ 1)
嘿嘿.程序延时 ＝ -10 × 延时间隔 × 到数值 (速度编辑框.内容)
哈哈 ＝ 创建计时对象 (0, 假, 0) 启动计时对象 (哈哈, 嘿嘿, 0, 0, 0, 假)
.判断循环首 (等待消息 (1, 哈哈, 假, -1, 255) ≠ 0)
.如果真 (停止 ＝ 真)
跳出循环 ()
.如果真结束
处理事件 ()
.判断循环尾 () 关闭对象 (哈哈)
返回 ()

.判断 (延时单位 ＝ 0)
延时单位 ＝ 1
.判断 (延时单位 ＝ 2)
延时单位 ＝ 1000
.判断 (延时单位 ＝ 3)
延时单位 ＝ 1000 × 60
.判断 (延时单位 ＝ 4)
延时单位 ＝ 1000 × 60 × 60
.判断 (延时单位 ＝ 5)
延时单位 ＝ 1000 × 60 × 60 × 24
.默认

.判断结束
嘿嘿.程序延时 ＝ -10 × 延时间隔 × 1000 × 延时单位
哈哈 ＝ 创建计时对象 (0, 假, 0) 启动计时对象 (哈哈, 嘿嘿, 0, 0, 0, 假)
.判断循环首 (等待消息 (1, 哈哈, 假, -1, 255) ≠ 0)
.如果真 (停止 ＝ 真)
跳出循环 ()
.如果真结束
处理事件 ()
.判断循环尾 () 关闭对象 (哈哈)

.子程序 鼠标操作
.参数 键, 整数型, 可空, 可空:为左键 1 #左键 2 #右键 3 #中键
.参数 控制, 整数型, 可空, 可空:为单击 1 #单击 2 #双击 3 #按下 4 #放开_

.如果真 (键 ＝ 1 或 键 ＝ 0)
.如果真 (控制 ＝ 3)
控制鼠标 (2, 0, 0, 0, 0)
.如果真结束
.如果真 (控制 ＝ 4) 控制鼠标 (4, 0, 0, 0, 0)
.如果真结束
.如果真 (控制 ＝ 1 或 控制 ＝ 0)
控制鼠标 (2, 0, 0, 0, 0) 控制鼠标 (4, 0, 0, 0, 0)
.如果真结束
.如果真 (控制 ＝ 2)
控制鼠标 (2, 0, 0, 0, 0) 控制鼠标 (4, 0, 0, 0, 0)
程序延时 (取双击间隔 ()) 控制鼠标 (2, 0, 0, 0, 0)
_控制鼠标 (4, 0, 0, 0, 0)
.如果真结束

.如果真结束
.如果真 (键 ＝ 3)
.如果真 (控制 ＝ 3)
控制鼠标 (32, 0, 0, 0, 0)
.如果真结束
.如果真 (控制 ＝ 4) 控制鼠标 (64, 0, 0, 0, 0)
.如果真结束
.如果真 (控制 ＝ 1 或 控制 ＝ 0)
控制鼠标 (32, 0, 0, 0, 0) 控制鼠标 (64, 0, 0, 0, 0)
.如果真结束
.如果真 (控制 ＝ 2)
控制鼠标 (32, 0, 0, 0, 0) 控制鼠标 (64, 0, 0, 0, 0)
程序延时 (取双击间隔 ()) 控制鼠标 (32, 0, 0, 0, 0)
_控制鼠标 (64, 0, 0, 0, 0)
.如果真结束

.如果真结束
.如果真 (键 ＝ 2)
.如果真 (控制 ＝ 3)
控制鼠标 (8, 0, 0, 0, 0)
.如果真结束
.如果真 (控制 ＝ 4) 控制鼠标 (16, 0, 0, 0, 0)
.如果真结束
.如果真 (控制 ＝ 1 或 控制 ＝ 0)
控制鼠标 (8, 0, 0, 0, 0) 控制鼠标 (16, 0, 0, 0, 0)
.如果真结束
.如果真 (控制 ＝ 2)
控制鼠标 (8, 0, 0, 0, 0) 控制鼠标 (16, 0, 0, 0, 0)
程序延时 (取双击间隔 ()) 控制鼠标 (8, 0, 0, 0, 0)
_控制鼠标 (16, 0, 0, 0, 0)
.如果真结束

.如果真结束

.子程序 模拟键盘按键, , , 执行模拟按键(无返回值)
.参数 键代码, 整数型, , 按键的键代码↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓可解决某些屏蔽
.参数 状态, 整数型, , 可空:按键(按下+放开) 1 #按键 3 #按下 4 #放开_ 如果状态大于等于5则为按下与放开之间的延时,
.参数 功能键方式, 逻辑型, 可空, 默认为键码的默认方式, 真:功能键方式模拟,如ctrl键win键home键光标键等

.如果真 (状态 ＝ 0)
状态 ＝ 5
.如果真结束
.如果真 (是否为空 (功能键方式))
功能键方式 ＝ 是否功能键 (键代码)
.如果真结束
.如果 (功能键方式)
.判断开始 (状态 ＝ 3)
控制键盘 (键代码, 键码转换1 (键代码, 0), 1, 0)
.判断 (状态 ＝ 4)
控制键盘 (键代码, 键码转换1 (键代码, 0), 3, 0)
.默认
控制键盘 (键代码, 键码转换1 (键代码, 0), 1, 0)
超级延时 (状态)
控制键盘 (键代码, 键码转换1 (键代码, 0), 3, 0)
超级延时 (状态)
.判断结束

.否则
.判断开始 (状态 ＝ 3)
控制键盘 (键代码, 键码转换1 (键代码, 0), 0, 0)
.判断 (状态 ＝ 4)
控制键盘 (键代码, 键码转换1 (键代码, 0), 2, 0)
.默认
控制键盘 (键代码, 键码转换1 (键代码, 0), 0, 0)
超级延时 (状态)
控制键盘 (键代码, 键码转换1 (键代码, 0), 2, 0)
超级延时 (状态)
.判断结束

.如果结束
处理事件 ()

.子程序 是否功能键, 逻辑型, , www.eyuyan.la
.参数 虚拟键码, 整数型

返回 (取ACII码 (虚拟键码) ＝ 0)

.子程序 取ACII码, 整数型, , _-@S<取ACII码>
.参数 代码值, 整数型, , 虚拟键码或扫描码
.局部变量 ACII码, 整数型

ACII码 ＝ _键码转换1 (代码值, 2)
.如果真 (ACII码 ≥ 65 且 ACII码 ≤ 90)
ACII码 ＝ ACII码 ＋ 32
.如果真结束
返回 (ACII码)

.子程序 程序_延时, 逻辑型, , 不占用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 × 延时单位
哈哈 ＝ 创建计时对象 (0, 假, 0) 启动计时对象 (哈哈, 嘿嘿, 0, 0, 0, 假)
.判断循环首 (等待消息 (1, 哈哈, 假, -1, 255) ≠ 0)
处理事件 ()
.判断循环尾 () 关闭对象 (哈哈)
返回 (真)

.子程序 时钟4周期事件, , , 本源码来自易语言资源网(www.eyuyan.la)

处理事件 ()
状态条1.置文本 (1, “X=” ＋ 到文本 (取鼠标水平位置 ()))
状态条1.置文本 (2, “Y=” ＋ 到文本 (取鼠标垂直位置 ()))

.子程序 时钟5周期事件
.局部变量 栏目文本, 文本型

处理事件 ()
状态条1.置文本 (8, 到文本 (取现行时间 ()))

.子程序 启动_时间, 文本型

秒 ＝ 秒 ＋ 1
.如果 (秒 ＝ 60)
秒 ＝ 0
分 ＝ 分 ＋ 1
.否则
.如果 (分 ＝ 60)
时 ＝ 时 ＋ 1
分 ＝ 0
.否则
.如果 (时 ＝ 24)
时 ＝ 0
.否则

    .如果结束

.如果结束

.如果结束
返回 (取文本右边 (到文本 (时), 4) ＋ “:” ＋ 取文本右边 (到文本 (分), 4) ＋ “:” ＋ 取文本右边 (到文本 (秒), 4))

.子程序 超级列表框3被双击, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型
.局部变量 表项坐标, 坐标
.局部变量 i, 整数型

表项信息.横向 ＝ 横向位置
表项信息.纵向 ＝ 纵向位置
取表项结构信息 (超级列表框3.取窗口句柄 (), 4153, 0, 表项信息) ' 当前取表项行、列位置
.如果真 (表项信息.行 ≠ -1)
取表项坐标信息 (超级列表框3.取窗口句柄 (), 4096 ＋ 16, 表项信息.行, 表项坐标) ' 取出当前表项行列坐标点
超级编辑框.顶边 ＝ 超级列表框3.顶边 ＋ 表项坐标.y ＋ 1
超级编辑框.左边 ＝ 表项坐标.x ＋ 超级列表框3.左边 － 1
.如果真 (表项信息.列 ＝ 0)
超级编辑框.左边 ＝ 表项坐标.x ＋ 超级列表框3.左边
.如果真结束
.计次循环首 (表项信息.列, i)
超级编辑框.左边 ＝ 超级编辑框.左边 ＋ 超级列表框3.取列宽 (i － 1)
.计次循环尾 ()
超级编辑框.宽度 ＝ 超级列表框3.取列宽 (表项信息.列)
超级编辑框.内容 ＝ 超级列表框3.取标题 (表项信息.行, 表项信息.列)
超级编辑框.可视 ＝ 真
超级列表框3.禁止重画 ()
超级编辑框.获取焦点 ()
超级编辑框.被选择字符数 ＝ -1 ' 全选中编辑框中的内容
.如果真结束
超级列表框3.允许重画 ()

.子程序 超级编辑框放开某键, 逻辑型
.参数 键代码, 整数型
.参数 功能键状态, 整数型

.如果真 (键代码 ＝ #回车键)
超级编辑框失去焦点 ()
.如果真结束

.子程序 超级编辑框失去焦点

超级列表框3.置标题 (表项信息.行, 表项信息.列, 超级编辑框.内容)
超级编辑框.可视 ＝ 假
超级列表框3.允许重画 ()

.子程序 记录编辑框1按下某键, 逻辑型
.参数 键代码, 整数型
.参数 功能键状态, 整数型

记录编辑框1.内容 ＝ 代码转换 (键代码)
记录编辑框11.内容 ＝ 到文本 (键代码)

.子程序 记录编辑框2按下某键, 逻辑型
.参数 键代码, 整数型
.参数 功能键状态, 整数型

记录编辑框2.内容 ＝ 代码转换 (键代码)
记录编辑框22.内容 ＝ 到文本 (键代码)

.子程序 记录编辑框3按下某键, 逻辑型
.参数 键代码, 整数型
.参数 功能键状态, 整数型

记录编辑框3.内容 ＝ 代码转换 (键代码)
记录编辑框33.内容 ＝ 到文本 (键代码)
' 记录标签.获取焦点 ()

.子程序 记录编辑框4按下某键, 逻辑型
.参数 键代码, 整数型
.参数 功能键状态, 整数型

记录编辑框4.内容 ＝ 代码转换 (键代码)
记录编辑框44.内容 ＝ 到文本 (键代码)
' 记录标签.获取焦点 ()

.子程序 超级列表框3右键单击表项

弹出菜单 (A, , )

.子程序 脚本列表框鼠标右键被放开, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型

弹出菜单 (B, , )

.子程序 保存脚本被选择
.局部变量 索引啊, 整数型
.局部变量 脚本文件名, 文本型
.局部变量 文本, 文本型
.局部变量 n, 文本型

.如果 (超级列表框3.取表项数 () ＝ 0)
自动关闭信息框 (0, “提示：没有脚本可保存！”, “保存在运行目录 脚本配置 文件夹”, 64, 0, 5000)
.否则
创建目录 (取运行目录 () ＋ “\脚本配置”)
输入框 (“请输入欲保存的文件名” ＋ #换行符 ＋ “默认保存运行目录”, “脚本配置提示您：”, , n, , )
.计次循环首 (超级列表框3.取表项数 (), 索引啊)
文本 ＝ 文本 ＋ 到文本 (超级列表框3.取标题 (索引啊 － 1, 0)) ＋ “-” ＋ 到文本 (超级列表框3.取标题 (索引啊 － 1, 1)) ＋ “-” ＋ 到文本 (超级列表框3.取标题 (索引啊 － 1, 2)) ＋ “-” ＋ 到文本 (超级列表框3.取标题 (索引啊 － 1, 3)) ＋ “-” ＋ 到文本 (超级列表框3.取标题 (索引啊 － 1, 4)) ＋ “-” ＋ 到文本 (超级列表框3.取标题 (索引啊 － 1, 5)) ＋ “-” ＋ 到文本 (超级列表框3.取标题 (索引啊 － 1, 6)) ＋ “-” ＋ 到文本 (超级列表框3.取标题 (索引啊 － 1, 7)) ＋ “-” ＋ #换行符
.计次循环尾 ()
写到文件 (取运行目录 () ＋ “\脚本配置\” ＋ n ＋ “.txt”, 到字节集 (文本))
现存脚本 ()
状态条1.背景颜色 ＝ #浅灰
超级延时 (500)
状态条1.背景颜色 ＝ #黄色
.如果结束

.子程序 序号被选择
.局部变量 I, 整数型

.计次循环首 (超级列表框3.取表项数 (), I)
超级列表框3.置标题 (I － 1, 0, 到文本 (I))
.计次循环尾 ()
状态条1.背景颜色 ＝ #浅灰
超级延时 (500)
状态条1.背景颜色 ＝ #黄色

.子程序 重命名被选择
.局部变量 脚本目录, 文本型
.局部变量 新文件名, 文本型

.判断开始 (输入框 (“请输入新脚本名称-可忽略后缀.txt”, “重命名脚本名称”, 脚本列表框.取项目文本 (脚本列表框.现行选中项), 新文件名, 1, _启动窗口))
脚本目录 ＝ 取运行目录 () ＋ “\脚本配置\”
.判断开始 (取文本右边 (新文件名, 4) ≠ “.txt”)
新文件名 ＝ 新文件名 ＋ “.txt”
.默认

.判断结束
.判断开始 (文件更名 (脚本目录 ＋ 脚本列表框.取项目文本 (脚本列表框.现行选中项), 脚本目录 ＋ 新文件名))
    脚本列表框.置项目文本 (脚本列表框.现行选中项, 新文件名)
.默认

.判断结束

.默认

.判断结束
状态条1.背景颜色 ＝ #浅灰
超级延时 (500)
状态条1.背景颜色 ＝ #黄色

.子程序 删除脚本被选择

.如果真 (信息框 (“您确定删除当前脚本吗？”, 0 ＋ #确认取消钮, , _启动窗口.取窗口句柄 ()) ＝ #确认钮)
删除文件 (取运行目录 () ＋ “\脚本配置\” ＋ 脚本列表框.取项目文本 (脚本列表框.现行选中项))
现存脚本 ()
状态条1.背景颜色 ＝ #浅灰
超级延时 (500)
状态条1.背景颜色 ＝ #黄色
返回 ()
.如果真结束

.子程序 速度编辑框内容被改变

.如果 (速度编辑框.内容 ≠ 到文本 (到数值 (1000)))
速度状态 ＝ 真
.否则
速度状态 ＝ 假
.如果结束
.如果 (速度编辑框.内容 ＝ “2023”)
抖动 ＝ 真
.否则
抖动 ＝ 假
.如果结束

.子程序 速度编辑框被双击, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型

.如果真 (抖动 ＝ 真)
.如果 (速度编辑框.内容 ≠ “2023”)
返回 ()
.否则

.如果结束
.计次循环首 (10, 次数)
    超级延时 (10)
    左边 ＝ 左边 － 10
    顶边 ＝ 顶边 － 10
    超级延时 (10)
    左边 ＝ 左边 ＋ 10
    顶边 ＝ 顶边 ＋ 10
    .如果真 (停止 ＝ 真)
        跳出循环 ()
    .如果真结束
    处理事件 ()
.计次循环尾 ()

.如果真结束

.子程序 鼠标轨迹被选择, , , www.eyuyan.la

.判断开始 (鼠标轨迹.选中)
鼠标轨迹.选中 ＝ 假
选择框2.选中 ＝ 假
.默认
鼠标轨迹.选中 ＝ 真
选择框2.选中 ＝ 真
.判断结束

.子程序 记录键盘被选择

.判断开始 (记录键盘.选中)
记录键盘.选中 ＝ 假
选择框3.选中 ＝ 假
.默认
记录键盘.选中 ＝ 真
选择框3.选中 ＝ 真
.判断结束

.子程序 _启动窗口鼠标右键被按下, 逻辑型, , 本源码来自易语言资源网(www.eyuyan.la)
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型

_启动窗口.标题 ＝ “898911268”

.子程序 _启动窗口鼠标右键被放开, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型

_启动窗口.标题 ＝ “”

.子程序 _启动窗口可否被关闭, 逻辑型

停止 ＝ 真
卸载钩子 (鼠标钩子) 卸载钩子 (键盘钩子)
.判断循环首 (高度 ＞ 50)
超级延时 (10)
高度 ＝ 高度 － 10
.判断循环尾 ()

.子程序 _启动窗口将被销毁

停止 ＝ 真
卸载钩子 (鼠标钩子) 卸载钩子 (键盘钩子)

.子程序 时钟3周期事件

.如果真 (按键啊 (#上光标键) ＝ 1)
顶边 ＝ 顶边 － 10
.如果真结束
.如果真 (按键啊 (#下光标键) ＝ 1)
顶边 ＝ 顶边 ＋ 10
.如果真结束
.如果真 (按键啊 (#左光标键) ＝ 1)
左边 ＝ 左边 － 10
.如果真结束
.如果真 (按键啊 (#右光标键) ＝ 1)
左边 ＝ 左边 ＋ 10
.如果真结束

.子程序 按键啊, 整数型
.参数 键值, 整数型

.判断开始 (键码api (键值) ＝ -32768)
返回 (1)
.默认
返回 (0)
.判断结束

.子程序 导入脚本被选择
.局部变量 路径, 文本型

载入脚本 (取运行目录 () ＋ “\脚本配置\” ＋ 脚本列表框.取项目文本 (脚本列表框.现行选中项))
超级列表框3.保证显示 (超级列表框3.取表项数 () － 1)
状态条1.背景颜色 ＝ #浅灰
超级延时 (500)
状态条1.背景颜色 ＝ #黄色

.子程序 清空列表被选择

.如果真 (信息框 (“您确定删除全部数据吗？”, 0 ＋ #确认取消钮, , _启动窗口.取窗口句柄 ()) ＝ #确认钮)
超级列表框2.全部删除 ()
返回 ()
.如果真结束

.子程序 按钮1被单击

添加按键 (编辑框5.内容)

.子程序 添加按键
.参数 按键名称, 文本型

索引 ＝ 超级列表框3.插入表项 (, , , , , )
超级列表框3.置标题 (索引, 0, 到文本 (超级列表框3.取表项数 ()))
超级列表框3.保证显示 (超级列表框3.取表项数 () － 1)
超级列表框3.现行选中项 ＝ 超级列表框3.取表项数 () － 1
超级列表框3.置标题 (索引, 4, “文本”)
超级列表框3.置标题 (索引, 5, 按键名称)
状态条1.置文本 (3, 到文本 (超级列表框3.取表项数 ()) ＋ “行”)

.子程序 按钮8被单击

' 添加延时 (到整数 (编辑框6.内容))

.子程序 添加延时
.参数 数值, 整数型

' 索引 ＝ 超级列表框3.插入表项 (, , , , , )
' 超级列表框3.置标题 (索引, 0, 到文本 (超级列表框3.取表项数 ()))
' 超级列表框3.保证显示 (超级列表框3.取表项数 () － 1)
' 超级列表框3.现行选中项 ＝ 超级列表框3.取表项数 () － 1
' 超级列表框3.置标题 (索引, 4, “延时”)
' 超级列表框3.置标题 (索引, 5, 到文本 (数值))
' 状态条1.置文本 (3, 到文本 (超级列表框3.取表项数 ()) ＋ “行”)

.子程序 插入文本被选择
.局部变量 临时文本, 文本型

插入内容 (临时文本, 临时文本)

.子程序 插入内容
.参数 按键名称, 文本型
.参数 临时文本, 文本型

.如果真 (输入框 (“待输入内容”, “待输入内容”, “”, 临时文本, , ) ＝ 真)
索引 ＝ 超级列表框3.插入表项 (超级列表框3.现行选中项 ＋ 1, , , , , )
超级列表框3.置标题 (索引, 0, 到文本 (超级列表框3.取表项数 ()))
超级列表框3.现行选中项 ＝ 超级列表框3.取表项数 () － 1
超级列表框3.置标题 (索引, 4, “文本”)
超级列表框3.置标题 (索引, 5, 按键名称)
状态条1.置文本 (3, 到文本 (超级列表框3.取表项数 ()) ＋ “行”)
.如果真结束

.子程序 插入延时被选择
.局部变量 临时文本, 文本型

插入延时 (临时文本)

.子程序 插入延时
.参数 临时文本, 文本型

.如果真 (输入框 (“待输入延时” ＋ #换行符 ＋ “1000=1秒”, “待输入延时”, “”, 临时文本, , ) ＝ 真)
索引 ＝ 超级列表框3.插入表项 (超级列表框3.现行选中项 ＋ 1, , , , , )
超级列表框3.置标题 (索引, 0, 到文本 (超级列表框3.取表项数 ()))
超级列表框3.现行选中项 ＝ 超级列表框3.取表项数 () － 1
超级列表框3.置标题 (索引, 4, “延时”)
超级列表框3.置标题 (索引, 5, 临时文本)
状态条1.置文本 (3, 到文本 (超级列表框3.取表项数 ()) ＋ “行”)
.如果真结束

.子程序 插入空格被选择

索引 ＝ 超级列表框3.插入表项 (超级列表框3.现行选中项 ＋ 1, , , , , )
超级列表框3.置标题 (索引, 0, 到文本 (超级列表框3.取表项数 ()))
超级列表框3.现行选中项 ＝ 超级列表框3.取表项数 () － 1
超级列表框3.置标题 (索引, 4, “空格键”)
超级列表框3.置标题 (索引, 5, “键盘按下”)
超级列表框3.置标题 (索引, 6, 到文本 (32))
状态条1.置文本 (3, 到文本 (超级列表框3.取表项数 ()) ＋ “行”)

.子程序 插入回车被选择

索引 ＝ 超级列表框3.插入表项 (超级列表框3.现行选中项 ＋ 1, , , , , )
超级列表框3.置标题 (索引, 0, 到文本 (超级列表框3.取表项数 ()))
超级列表框3.现行选中项 ＝ 超级列表框3.取表项数 () － 1
超级列表框3.置标题 (索引, 4, “Enter”)
超级列表框3.置标题 (索引, 5, “键盘按下”)
超级列表框3.置标题 (索引, 6, 到文本 (13))
状态条1.置文本 (3, 到文本 (超级列表框3.取表项数 ()) ＋ “行”)

.子程序 查找内容被选择
.局部变量 临时文本, 文本型
.局部变量 是否找到, 逻辑型
.局部变量 a, 整数型

.如果真 (输入框 (“请输入需查找的内容”, “查找内容”, “”, 临时文本, , ) ＝ 真)
是否找到 ＝ 假
.计次循环首 (超级列表框3.取表项数 (), a)
索引 ＝ a － 1
.如果真 (表项关键字搜索 (超级列表框3, 索引, 0, 临时文本) ＝ 真)
是否找到 ＝ 真
跳出循环 ()
.如果真结束
.如果真 (表项关键字搜索 (超级列表框3, 索引, 1, 临时文本) ＝ 真)
是否找到 ＝ 真
跳出循环 ()
.如果真结束
.如果真 (表项关键字搜索 (超级列表框3, 索引, 2, 临时文本) ＝ 真)
是否找到 ＝ 真
跳出循环 ()
.如果真结束
.如果真 (表项关键字搜索 (超级列表框3, 索引, 3, 临时文本) ＝ 真)
是否找到 ＝ 真
跳出循环 ()
.如果真结束
.如果真 (表项关键字搜索 (超级列表框3, 索引, 4, 临时文本) ＝ 真)
是否找到 ＝ 真
跳出循环 ()
.如果真结束
.如果真 (表项关键字搜索 (超级列表框3, 索引, 5, 临时文本) ＝ 真)
是否找到 ＝ 真
跳出循环 ()
.如果真结束
.如果真 (表项关键字搜索 (超级列表框3, 索引, 6, 临时文本) ＝ 真)
是否找到 ＝ 真
跳出循环 ()
.如果真结束
.如果真 (表项关键字搜索 (超级列表框3, 索引, 7, 临时文本) ＝ 真)
是否找到 ＝ 真
跳出循环 ()
.如果真结束

.计次循环尾 ()
.如果真 (是否找到 ＝ 假)  ' 全部搜索没找到 弹出信息框
    索引 ＝ 0
    信息框 (“未找到指定内容” ＋ #换行符 ＋ #换行符 ＋ 临时文本, 0, “”, )
.如果真结束
超级列表框3.现行选中项 ＝ 索引
超级列表框3.保证显示 (索引)
超级列表框3.获取焦点 ()

.如果真结束

.子程序 表项关键字搜索, 逻辑型
.参数 欲搜索超级列表框, 超级列表框
.参数 欲搜索表项索引, 整数型
.参数 欲搜索列索引, 整数型
.参数 关键字, 文本型
.局部变量 标题文本, 文本型

标题文本 ＝ 超级列表框3.取标题 (欲搜索表项索引, 欲搜索列索引)
.如果 (寻找文本 (标题文本, 关键字, , 真) ＝ -1)
返回 (假) ' 未找到关键字
.否则
返回 (真) ' 找到关键字
.如果结束

.子程序 超级列表框3左键单击表项

列表框_编号 (超级列表框3, 0)

.子程序 列表框编号, , 公开
.参数 参列表框, 超级列表框
.参数 参_索引, 整数型
.局部变量 i, 整数型

.计次循环首 (参列表框.取表项数 (), i)
参列表框.置标题 (i － 1, 参_索引, 到文本 (i))
.计次循环尾 ()
连点器哈，