├── .gitignore ├── LICENSE ├── README.md ├── docs ├── WinApi.md ├── index.md ├── 后台设置.md ├── 图色设置.md ├── 基本设置.md ├── 常见算法.md ├── 文字识别.md ├── 窗口设置.md └── 键盘鼠标.md ├── mkdocs.yml ├── opdll_test.py ├── pyopdll ├── __init__.py ├── op.py ├── op_x64.dll └── op_x86.dll └── setup.py /.gitignore: -------------------------------------------------------------------------------- 1 | _doc 2 | *.egg 3 | *.egg-info 4 | dist 5 | build 6 | .idea 7 | *.pyc 8 | site -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2021 gaoyongxian 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Welcome to pyopdll 2 | 3 | ### 项目简介 4 | 5 | `pyopdll`是开源项目`OP(operator & open)`的Python接口, 6 | 内部封装了`op_x64.dll`和`op_x86.dll`,支持32位和64位Python3 7 | 8 | 9 | ### OP(operator & open) 10 | 11 | * Windows消息模拟，常见的键盘消息和鼠标消息模拟。 12 | * 支持常见的截图方式，gdi,dx（包括d3d9,d3d10,d3d11),opengl截图，支持常见模拟器（雷电，夜神）的最小化截图 13 | * 找色找图,支持偏色，支持模糊识别 14 | * 字符识别(OCR),最大支持255 X 255 超大点阵，支持偏色，支持模糊识别，支持系统字库，兼容大漠字库 15 | * 插件有32位和64位版本，支持32/64位绑定 16 | * 项目完全开源,无后门无病毒，可放心使用 17 | 18 | ### 项目地址 19 | 20 | * [OP(operator & open)](https://github.com/WallBreaker2/op) 21 | * [pyopdll](https://github.com/Gaoyongxian666/pyopdll) 22 | * [pyopdll文档](https://pyopdll.readthedocs.io/zh/latest/) 23 | 24 | ### 安装 25 | 26 | pip install pyopdll 27 | 28 | ### 快速开始 29 | 30 | import time 31 | from pyopdll import OP 32 | 33 | if __name__ == '__main__': 34 | 35 | op = OP() 36 | 37 | print(op.GetCursorPos()) 38 | 39 | # 打印注册路径 40 | path = op.GetBasePath() 41 | print(path) 42 | 43 | # 打印坐标颜色 44 | print(op.GetColor(2,2)) 45 | 46 | # 取消注册 47 | # op.Un_reg() 48 | 49 | # 运行本地程序 50 | # op.RunApp(r"C:\Program Files (x86)\Xianghu\CCtalk\CCtalk.exe",0) 51 | 52 | 53 | # 窗口句柄就是一个int类型的数字 54 | # 获取鼠标指向的窗口句柄 55 | hwnd = op.GetMousePointWindow() 56 | print(hwnd) 57 | # 打印窗口大小 58 | print(op.GetClientSize(hwnd)) 59 | # 打印窗体标题栏 60 | print(op.GetWindowTitle(hwnd)) 61 | 62 | # 获取在前台的窗口的句柄 63 | print(op.GetForegroundWindow()) 64 | 65 | # 寻找记事本的句柄 66 | # 标题需要严格一致才可找到 67 | txt_hwnd=op.FindWindow("","新建文本文档.txt - 记事本") 68 | print(txt_hwnd) 69 | # 打印程序路径 70 | print(op.GetWindowProcessPath(txt_hwnd)) 71 | # 最大化指定窗口,同时激活窗口. 72 | print(op.SetWindowState(txt_hwnd,4)) 73 | # 使记事本窗口移动 74 | op.MoveWindow(txt_hwnd, 10, 10) 75 | 76 | # 拖拽 77 | op.MoveTo(300,50) 78 | op.LeftDown() 79 | for i in range(100): 80 | time.sleep(0.01) 81 | op.MoveR(1,0) 82 | op.LeftUp() 83 | 84 | # 获取标题还有.py的所有句柄 85 | # 注意：返回的是str，但句柄必须是int类型，要强行转化 86 | hwnd_str_list=op.EnumWindow(0,".py","",1+2+4+8).split(",") 87 | print(hwnd_str_list) 88 | for hwnd in hwnd_str_list: 89 | print(op.GetWindowClass(int(hwnd))) 90 | print(op.GetWindowProcessPath(int(hwnd))) 91 | print(op.GetWindowTitle(int(hwnd))) 92 | # 全部移动 93 | # op.MoveWindow(int(hwnd),100,100) 94 | 95 | # 推荐相对移动 96 | op.MoveR(100, 100) 97 | 98 | 99 | ### 键盘代码 100 | 101 | | key_str | 虚拟键码 | 102 | | --------- | -------- | 103 | | "1", | 49 | 104 | | "2", | 50 | 105 | | "3", | 51 | 106 | | "4", | 52 | 107 | | "5", | 53 | 108 | | "6", | 54 | 109 | | "7", | 55 | 110 | | "8", | 56 | 111 | | "9", | 57 | 112 | | "0", | 48 | 113 | | "-", | 189 | 114 | | "=", | 187 | 115 | | "back", | 8 | 116 | | "a", | 65 | 117 | | "b", | 66 | 118 | | "c", | 67 | 119 | | "d", | 68 | 120 | | "e", | 69 | 121 | | "f", | 70 | 122 | | "g", | 71 | 123 | | "h", | 72 | 124 | | "i", | 73 | 125 | | "j", | 74 | 126 | | "k", | 75 | 127 | | "l", | 76 | 128 | | "m", | 77 | 129 | | "n", | 78 | 130 | | "o", | 79 | 131 | | "p", | 80 | 132 | | "q", | 81 | 133 | | "r", | 82 | 134 | | "s", | 83 | 135 | | "t", | 84 | 136 | | "u", | 85 | 137 | | "v", | 86 | 138 | | "w", | 87 | 139 | | "x", | 88 | 140 | | "y", | 89 | 141 | | "z", | 90 | 142 | | "ctrl", | 17 | 143 | | "alt", | 18 | 144 | | "shift", | 16 | 145 | | "win", | 91 | 146 | | "space", | 32 | 147 | | "cap", | 20 | 148 | | "tab", | 9 | 149 | | "~", | 192 | 150 | | "esc", | 27 | 151 | | "enter", | 13 | 152 | | "up", | 38 | 153 | | "down", | 40 | 154 | | "left", | 37 | 155 | | "right", | 39 | 156 | | "option", | 93 | 157 | | "print", | 44 | 158 | | "delete", | 46 | 159 | | "home", | 36 | 160 | | "end", | 35 | 161 | | "pgup", | 33 | 162 | | "pgdn", | 34 | 163 | | "f1", | 112 | 164 | | "f2", | 113 | 165 | | "f3", | 114 | 166 | | "f4", | 115 | 167 | | "f5", | 116 | 168 | | "f6", | 117 | 169 | | "f7", | 118 | 170 | | "f8", | 119 | 171 | | "f9", | 120 | 172 | | "f10", | 121 | 173 | | "f11", | 122 | 174 | | "f12", | 123 | 175 | | "[", | 219 | 176 | | "]", | 221 | 177 | | "\\", | 220 | 178 | | ";", | 186 | 179 | | "'", | 222 | 180 | | ",", | 188 | 181 | | ".", | 190 | 182 | | "/", | 191 | 183 | 184 | -------------------------------------------------------------------------------- /docs/WinApi.md: -------------------------------------------------------------------------------- 1 | ## `RunApp(self, app_path, mode)` 2 | 3 | 运行指定的应用程序. 4 | 5 | Parameters: 6 | 7 | - **app_path** (`str`) – 指定的可执行程序全路径. 8 | - **mode** (`int`) – 取值如下 0:普通模式 1:加强模式 9 | 10 | Returns: 11 | 12 | - `int` – 0 代表失败，1 代表成功 13 | 14 | ## `WinExec(self, cmdline, cmdshow)` 15 | 16 | 运行指定的应用程序. 17 | 18 | Parameters: 19 | 20 | - **cmdline** (`str`) – 指定的可执行程序全路径. 21 | - **cmdshow** (`int`) – 取值如下 0:隐藏 1:用最近的大小和位置显示, 激活 22 | 23 | Returns: 24 | 25 | - `str` – 0 代表失败，1 代表成功 26 | 27 | ## `GetCmdStr(self, cmdline, millseconds)` 28 | 29 | 运行指定的应用程序. 30 | 31 | Parameters: 32 | 33 | - **cmdline** (`str`) – 指定的可执行程序全路径. 34 | - **millseconds** (`int`) – 等待的时间(毫秒) 35 | 36 | Returns: 37 | 38 | - `str` – cmd 输出的字符 39 | -------------------------------------------------------------------------------- /docs/index.md: -------------------------------------------------------------------------------- 1 | # Welcome to pyopdll 2 | 3 | ### 项目简介 4 | 5 | `pyopdll`是开源项目`OP(operator & open)`的Python接口, 6 | 内部封装了`op_x64.dll`和`op_x86.dll`,支持32位和64位Python3 7 | 8 | 9 | ### OP(operator & open) 10 | 11 | * Windows消息模拟，常见的键盘消息和鼠标消息模拟。 12 | * 支持常见的截图方式，gdi,dx（包括d3d9,d3d10,d3d11),opengl截图，支持常见模拟器（雷电，夜神）的最小化截图 13 | * 找色找图,支持偏色，支持模糊识别 14 | * 字符识别(OCR),最大支持255 X 255 超大点阵，支持偏色，支持模糊识别，支持系统字库，兼容大漠字库 15 | * 插件有32位和64位版本，支持32/64位绑定 16 | * 项目完全开源,无后门无病毒，可放心使用 17 | 18 | ### 项目地址 19 | 20 | * [OP(operator & open)](https://github.com/WallBreaker2/op) 21 | * [pyopdll](https://github.com/Gaoyongxian666/pyopdll) 22 | * [pyopdll文档](https://pyopdll.readthedocs.io/zh/latest/) 23 | 24 | ### 安装 25 | 26 | pip install pyopdll 27 | 28 | ### 快速开始 29 | 30 | import time 31 | from pyopdll import OP 32 | 33 | if __name__ == '__main__': 34 | 35 | op = OP() 36 | 37 | print(op.GetCursorPos()) 38 | 39 | # 打印注册路径 40 | path = op.GetBasePath() 41 | print(path) 42 | 43 | # 打印坐标颜色 44 | print(op.GetColor(2,2)) 45 | 46 | # 取消注册 47 | # op.Un_reg() 48 | 49 | # 运行本地程序 50 | # op.RunApp(r"C:\Program Files (x86)\Xianghu\CCtalk\CCtalk.exe",0) 51 | 52 | 53 | # 窗口句柄就是一个int类型的数字 54 | # 获取鼠标指向的窗口句柄 55 | hwnd = op.GetMousePointWindow() 56 | print(hwnd) 57 | # 打印窗口大小 58 | print(op.GetClientSize(hwnd)) 59 | # 打印窗体标题栏 60 | print(op.GetWindowTitle(hwnd)) 61 | 62 | # 获取在前台的窗口的句柄 63 | print(op.GetForegroundWindow()) 64 | 65 | # 寻找记事本的句柄 66 | # 标题需要严格一致才可找到 67 | txt_hwnd=op.FindWindow("","新建文本文档.txt - 记事本") 68 | print(txt_hwnd) 69 | # 打印程序路径 70 | print(op.GetWindowProcessPath(txt_hwnd)) 71 | # 最大化指定窗口,同时激活窗口. 72 | print(op.SetWindowState(txt_hwnd,4)) 73 | # 使记事本窗口移动 74 | op.MoveWindow(txt_hwnd, 10, 10) 75 | 76 | # 拖拽 77 | op.MoveTo(300,50) 78 | op.LeftDown() 79 | for i in range(100): 80 | time.sleep(0.01) 81 | op.MoveR(1,0) 82 | op.LeftUp() 83 | 84 | # 获取标题还有.py的所有句柄 85 | # 注意：返回的是str，但句柄必须是int类型，要强行转化 86 | hwnd_str_list=op.EnumWindow(0,".py","",1+2+4+8).split(",") 87 | print(hwnd_str_list) 88 | for hwnd in hwnd_str_list: 89 | print(op.GetWindowClass(int(hwnd))) 90 | print(op.GetWindowProcessPath(int(hwnd))) 91 | print(op.GetWindowTitle(int(hwnd))) 92 | # 全部移动 93 | # op.MoveWindow(int(hwnd),100,100) 94 | 95 | # 推荐相对移动 96 | op.MoveR(100, 100) 97 | 98 | 99 | ### 键盘代码 100 | 101 | | key_str | 虚拟键码 | 102 | | --------- | -------- | 103 | | "1", | 49 | 104 | | "2", | 50 | 105 | | "3", | 51 | 106 | | "4", | 52 | 107 | | "5", | 53 | 108 | | "6", | 54 | 109 | | "7", | 55 | 110 | | "8", | 56 | 111 | | "9", | 57 | 112 | | "0", | 48 | 113 | | "-", | 189 | 114 | | "=", | 187 | 115 | | "back", | 8 | 116 | | "a", | 65 | 117 | | "b", | 66 | 118 | | "c", | 67 | 119 | | "d", | 68 | 120 | | "e", | 69 | 121 | | "f", | 70 | 122 | | "g", | 71 | 123 | | "h", | 72 | 124 | | "i", | 73 | 125 | | "j", | 74 | 126 | | "k", | 75 | 127 | | "l", | 76 | 128 | | "m", | 77 | 129 | | "n", | 78 | 130 | | "o", | 79 | 131 | | "p", | 80 | 132 | | "q", | 81 | 133 | | "r", | 82 | 134 | | "s", | 83 | 135 | | "t", | 84 | 136 | | "u", | 85 | 137 | | "v", | 86 | 138 | | "w", | 87 | 139 | | "x", | 88 | 140 | | "y", | 89 | 141 | | "z", | 90 | 142 | | "ctrl", | 17 | 143 | | "alt", | 18 | 144 | | "shift", | 16 | 145 | | "win", | 91 | 146 | | "space", | 32 | 147 | | "cap", | 20 | 148 | | "tab", | 9 | 149 | | "~", | 192 | 150 | | "esc", | 27 | 151 | | "enter", | 13 | 152 | | "up", | 38 | 153 | | "down", | 40 | 154 | | "left", | 37 | 155 | | "right", | 39 | 156 | | "option", | 93 | 157 | | "print", | 44 | 158 | | "delete", | 46 | 159 | | "home", | 36 | 160 | | "end", | 35 | 161 | | "pgup", | 33 | 162 | | "pgdn", | 34 | 163 | | "f1", | 112 | 164 | | "f2", | 113 | 165 | | "f3", | 114 | 166 | | "f4", | 115 | 167 | | "f5", | 116 | 168 | | "f6", | 117 | 169 | | "f7", | 118 | 170 | | "f8", | 119 | 171 | | "f9", | 120 | 172 | | "f10", | 121 | 173 | | "f11", | 122 | 174 | | "f12", | 123 | 175 | | "[", | 219 | 176 | | "]", | 221 | 177 | | "\\", | 220 | 178 | | ";", | 186 | 179 | | "'", | 222 | 180 | | ",", | 188 | 181 | | ".", | 190 | 182 | | "/", | 191 | 183 | 184 | -------------------------------------------------------------------------------- /docs/后台设置.md: -------------------------------------------------------------------------------- 1 | 2 | ## `BindWindow(self, hwnd, display, mouse, keypad, mode)` 3 | 4 | 绑定指定的窗口,并指定这个窗口的屏幕颜色获取方式,鼠标仿真模式,键盘仿真模式,以及模式设定. 5 | 6 | Parameters: 7 | 8 | - **hwnd** (`int`) – 指定的窗口句柄 9 | - **display** (`str`) – 屏幕颜色获取方式 取值有以下几种: "normal" : 正常模式,平常我们用的前台截屏模式 "gdi" : gdi 模式,用于窗口采用 GDI 方式刷新时. 此模式占用 CPU 较大. 参考 SetAero "dx" : dx 模式,等同于 dx.d3d9 "dx.d3d9" dx 模式，使用 d3d9 渲染 "dx.d3d10" dx 模式，使用 d3d10 渲染 "dx.d3d11" dx 模式，使用 d3d11 渲染 "opengl" opengl 模式，使用 opengl 渲染的窗口，支持最新版雷电模拟器，以及夜神 6.1，支持最小化窗口截图 "opengl.nox" opengl 模式，针对最新夜神模拟器的渲染方式，测试中。。。 10 | - **mouse** (`str`) – 鼠标仿真模式 取值有以下几种 "normal" : 正常模式,平常我们用的前台鼠标模式 "windows": Windows 模式,采取模拟 windows 消息方式 同按键自带后台插件. 11 | - **keypad** (`str`) – 键盘仿真模式 取值有以下几种 "normal" : 正常模式,平常我们用的前台键盘模式 "windows": Windows 模式,采取模拟 windows 消息方式 同按键的后台插件 12 | - **mode** (`int`) – 模式 13 | 14 | Returns: 15 | 16 | - `int` – 0 代表失败，1 代表成功 17 | 18 | ## `UnBindWindow(self)` 19 | 20 | 解除绑定窗口,并释放系统资源.一般在 OnScriptExit 调用 21 | 22 | Returns: 23 | 24 | - `int` – 0 代表失败，1 代表成功 25 | 26 | -------------------------------------------------------------------------------- /docs/图色设置.md: -------------------------------------------------------------------------------- 1 | ## `Capture(self, x1, y1, x2, y2, file)` 2 | 3 | 抓取指定区域(x1, y1, x2, y2)的图像,保存为 file(24 位位图) 4 | 5 | Parameters: 6 | 7 | - **x1** (`int`) – 区域的左上 X 坐标 8 | - **y1** (`int`) – 区域的左上 Y 坐标 9 | - **x2** (`int`) – 区域的右下 X 坐标 10 | - **y2** (`int`) – 区域的右下 Y 坐标 11 | - **file** (`str`) – 保存的文件名,保存的地方一般为 SetPath 中设置的目录,当然这里也可以指定全路径名. 12 | 13 | Returns: 14 | 15 | - `int` – 0 代表失败，1 代表成功 16 | 17 | ## `CmpColor(self, x, y, color, sim)` 18 | 19 | 比较指定坐标点(x,y)的颜色 20 | 21 | Parameters: 22 | 23 | - **x** (`int`) – X 坐标 24 | - **y** (`int`) – Y 坐标 25 | - **color** (`str`) – 颜色字符串,可以支持偏色,多色,例如 "ffffff-202020|000000-000000" 这个表示白色偏色为 202020,和黑色偏色为 000000.颜色最多支持 10 种颜色组合. 注意，这里只支持 RGB 颜色. 26 | - **sim** (`float`) – 相似度(0.1-1.0) 27 | 28 | Returns: 29 | 30 | - `0` – 颜色匹配 1: 颜色不匹配 31 | 32 | ## `FindColor(self, x1, y1, x2, y2, color, sim, dir)` 33 | 34 | 查找指定区域内的颜色,颜色格式"RRGGBB-DRDGDB",注意,和按键的颜色格式相反 35 | 36 | Parameters: 37 | 38 | - **x1** (`int`) – 区域的左上 X 坐标 39 | - **y1** (`int`) – 区域的左上 Y 坐标 40 | - **x2** (`int`) – 区域的右下 X 坐标 41 | - **y2** (`int`) – 区域的右下 Y 坐标 42 | - **color** (`str`) – 颜色 格式为"RRGGBB-DRDGDB",比如"123456-000000|aabbcc-202020".注意，这里只支持 RGB 颜色. 43 | - **sim** (`float`) – 相似度,取值范围 0.1-1.0 44 | - **dir** (`int`) – 查找方向 0: 从左到右,从上到下 1: 从左到右,从下到上 2: 从右到左,从上到下 3: 从右到左,从下到上 4：从中心往外查找 5: 从上到下,从左到右 6: 从上到下,从右到左 7: 从下到上,从左到右 8: 从下到上,从右到左 45 | 46 | Returns: 47 | 48 | - `tuple` – (x1, y1, x2, y2, color, sim, dir,返回 X 坐标,返回 Y 坐标) 49 | 50 | ## `FindColorEx(self, x1, y1, x2, y2, color, sim, dir)` 51 | 52 | 查找指定区域内的所有颜色,颜色格式"RRGGBB-DRDGDB",注意,和按键的颜色格式相反 53 | 54 | Parameters: 55 | 56 | - **x1** (`int`) – 区域的左上 X 坐标 57 | - **y1** (`int`) – 区域的左上 Y 坐标 58 | - **x2** (`int`) – 区域的右下 X 坐标 59 | - **y2** (`int`) – 区域的右下 Y 坐标 60 | - **color** (`str`) – 颜色 格式为"RRGGBB-DRDGDB",比如"123456-000000|aabbcc-202020".注意，这里只支持 RGB 颜色. 61 | - **sim** (`float`) – 相似度,取值范围 0.1-1.0 62 | - **dir** (`int`) – 查找方向 0: 从左到右,从上到下 1: 从左到右,从下到上 2: 从右到左,从上到下 3: 从右到左,从下到上 4：从中心往外查找 5: 从上到下,从左到右 6: 从上到下,从右到左 7: 从下到上,从左到右 8: 从下到上,从右到左 63 | 64 | Returns: 65 | 66 | - `str` – 返回所有颜色信息的坐标值,然后通过 GetResultCount 等接口来解析 (由于内存限制,返回的颜色数量最多为 1800 个左右) 67 | 68 | ## `FindMultiColor(self, x1, y1, x2, y2, first_color, offset_color, sim, dir)` 69 | 70 | 根据指定的多点查找颜色坐标 71 | 72 | Parameters: 73 | 74 | - **x1** (`int`) – 区域的左上 X 坐标 75 | - **y1** (`int`) – 区域的左上 Y 坐标 76 | - **x2** (`int`) – 区域的右下 X 坐标 77 | - **y2** (`int`) – 区域的右下 Y 坐标 78 | - **first_color** (`str`) – 颜色格式为"RRGGBB-DRDGDB|RRGGBB-DRDGDB|…………",比如"123456-000000"这里的含义和按键自带 Color 插件的意义相同，只不过我的可以支持偏色和多种颜色组合.所有的偏移色坐标都相对于此颜色.注意，这里只支持 RGB 颜色. 79 | - **offset_color** (`str`) – 偏移颜色可以支持任意多个点 格式和按键自带的 Color 插件意义相同, 只不过我的可以支持偏色和多种颜色组合,格式为"x1|y1|RRGGBB-DRDGDB|RRGGBB-DRDGDB……,……xn|yn|RRGGBB-DRDGDB|RRGGBB-DRDGDB……" 比如"1|3|aabbcc|aaffaa-101010,-5|-3|123456-000000|454545-303030|565656"等任意组合都可以，支持偏色还可以支持反色模式，比如"1|3|-aabbcc|-334455-101010,-5|-3|-123456-000000|-353535|454545-101010","-"表示除了指定颜色之外的颜色. 80 | - **sim** (`float`) – 相似度,取值范围 0.1-1.0 81 | - **dir** (`int`) – 查找方向 0: 从左到右,从上到下 1: 从左到右,从下到上 2: 从右到左,从上到下 3: 从右到左, 从下到上 82 | 83 | Returns: 84 | 85 | - `tuple` – (x1, y1, x2, y2,first_color,offset_color,sim, dir,返回的 X 坐标,返回的 Y 坐标) 坐标是 first_color 所在的坐标 86 | 87 | ## `FindMultiColorEx(self, x1, y1, x2, y2, first_color, offset_color, sim, dir)` 88 | 89 | 查找指定区域内的所有颜色,颜色格式"RRGGBB-DRDGDB",注意,和按键的颜色格式相反 90 | 91 | Parameters: 92 | 93 | - **x1** (`int`) – 区域的左上 X 坐标 94 | - **y1** (`int`) – 区域的左上 Y 坐标 95 | - **x2** (`int`) – 区域的右下 X 坐标 96 | - **y2** (`int`) – 区域的右下 Y 坐标 97 | - **first_color** (`str`) – 颜色格式为"RRGGBB-DRDGDB|RRGGBB-DRDGDB|…………",比如"123456-000000"这里的含义和按键自带 Color 插件的意义相同，只不过我的可以支持偏色和多种颜色组合.所有的偏移色坐标都相对于此颜色.注意，这里只支持 RGB 颜色. 98 | - **offset_color** (`str`) – 偏移颜色可以支持任意多个点 格式和按键自带的 Color 插件意义相同, 只不过我的可以支持偏色和多种颜色组合,格式为"x1|y1|RRGGBB-DRDGDB|RRGGBB-DRDGDB……,……xn|yn|RRGGBB-DRDGDB|RRGGBB-DRDGDB……" 比如"1|3|aabbcc|aaffaa-101010,-5|-3|123456-000000|454545-303030|565656"等任意组合都可以，支持偏色还可以支持反色模式，比如"1|3|-aabbcc|-334455-101010,-5|-3|-123456-000000|-353535|454545-101010","-"表示除了指定颜色之外的颜色. 99 | - **sim** (`float`) – 相似度,取值范围 0.1-1.0 100 | - **dir** (`int`) – 查找方向 0: 从左到右,从上到下 1: 从左到右,从下到上 2: 从右到左,从上到下 3: 从右到左, 从下到上 101 | 102 | Returns: 103 | 104 | - `str` – 返回所有颜色信息的坐标值,然后通过 GetResultCount 等接口来解析(由于内存限制,返回的坐标数量最多为 1800 个左右)坐标是 first_color 所在的坐标 105 | 106 | ## `FindPic(self, x1, y1, x2, y2, pic_name, delta_color, sim, dir)` 107 | 108 | 查找指定区域内的图片,位图必须是 24 位色格式,支持透明色,当图像上下左右 4 个顶点的颜色一样时,则这个颜色将作为透明色处理. 109 | 110 | Parameters: 111 | 112 | - **x1** (`int`) – 区域的左上 X 坐标 113 | - **y1** (`int`) – 区域的左上 Y 坐标 114 | - **x2** (`int`) – 区域的右下 X 坐标 115 | - **y2** (`int`) – 区域的右下 Y 坐标 116 | - **pic_name** (`str`) – 图片名,可以是多个图片,比如"test.bmp|test2.bmp|test3.bmp" 117 | - **delta_color** (`str`) – 颜色色偏比如"203040" 表示 RGB 的色偏分别是 20 30 40 (这里是 16 进制表示) 118 | - **sim** (`float`) – 相似度,取值范围 0.1-1.0 119 | - **dir** (`int`) – 查找方向 0: 从左到右,从上到下 1: 从左到右,从下到上 2: 从右到左,从上到下 3: 从右到左, 从下到上 120 | 121 | Returns: 122 | 123 | - `tuple` – (x1, y1, x2, y2, pic_name, delta_color,sim, dir,图片左上角的 X 坐标, 图片左上角的 Y 坐标) 124 | 125 | ## `FindPicEx(self, x1, y1, x2, y2, pic_name, delta_color, sim, dir)` 126 | 127 | 查找指定区域内的图片,位图必须是 24 位色格式,支持透明色,当图像上下左右 4 个顶点的颜色一样时,则这个颜色将作为透明色处理.这个函数可以查找多个图片,并且返回所有找到的图像的坐标. 128 | 129 | Parameters: 130 | 131 | - **x1** (`int`) – 区域的左上 X 坐标 132 | - **y1** (`int`) – 区域的左上 Y 坐标 133 | - **x2** (`int`) – 区域的右下 X 坐标 134 | - **y2** (`int`) – 区域的右下 Y 坐标 135 | - **pic_name** (`str`) – 图片名,可以是多个图片,比如"test.bmp|test2.bmp|test3.bmp" 136 | - **delta_color** (`str`) – 颜色色偏比如"203040" 表示 RGB 的色偏分别是 20 30 40 (这里是 16 进制表示) 137 | - **sim** (`float`) – 相似度,取值范围 0.1-1.0 138 | - **dir** (`int`) – 查找方向 0: 从左到右,从上到下 1: 从左到右,从下到上 2: 从右到左,从上到下 3: 从右到左, 从下到上 139 | 140 | Returns: 141 | 142 | - `str` – 返回的是所有找到的坐标格式如下"id,x,y|id,x,y..|id,x,y" (图片左上角的坐标)比如"0,100,20|2,30,40" 表示找到了两个,第一个,对应的图片是图像序号为 0 的图片,坐标是(100,20),第二个是序号为 2 的图片,坐标(30,40) (由于内存限制,返回的图片数量最多为 1500 个左右) 143 | 144 | ## `GetColor(self, x, y)` 145 | 146 | 获取(x,y)的颜色,颜色返回格式"RRGGBB",注意,和按键的颜色格式相反 147 | 148 | Parameters: 149 | 150 | - **x** (`int`) – X 坐标 151 | - **y** (`int`) – Y 坐标 152 | 153 | Returns: 154 | 155 | - `str` – 颜色字符串(注意这里都是小写字符，和工具相匹配) 156 | 157 | ## `CapturePre(self, file)` 158 | 159 | 抓取上次操作的图色区域，保存为 file(32 位位图) 160 | 161 | Parameters: 162 | 163 | - **file** (`str`) – 保存的文件名,保存的地方一般为 SetPath 中设置的目录,当然这里也可以指定全路径名. 164 | 165 | Returns: 166 | 167 | - `int` – 0 代表失败 1 代表成功 168 | 169 | 注意，要开启此函数，必须先调用 EnableDisplayDebug 任何图色或者文字识别函数，都可以通过这个来截取. 170 | 171 | ## `EnableDisplayDebug(self, enable_debug)` 172 | 173 | 开启图色调试模式，此模式会稍许降低图色和文字识别的速度.默认不开启. 174 | 175 | Parameters: 176 | 177 | - **enable_debug** (`int`) – 0 为关闭 1 为开启 178 | 179 | Returns: 180 | 181 | - `int` – 0 代表失败 1 代表成功 182 | 183 | ## `GetScreenData(self, x1, y1, x2, y2)` 184 | 185 | 获取指定区域的图像,用二进制数据的方式返回,（不适合按键使用）方便二次开发. 186 | 187 | Parameters: 188 | 189 | - **x1** (`int`) – 区域的左上 X 坐标 190 | - **y1** (`int`) – 区域的左上 Y 坐标 191 | - **x2** (`int`) – 区域的右下 X 坐标 192 | - **y2** (`int`) – 区域的右下 Y 坐标 193 | 194 | Returns: 195 | 196 | - `int` – 返回的是指定区域的二进制颜色数据地址,每个颜色是 4 个字节,表示方式为(BBGGRR00) 197 | 198 | 注意,调用完此接口后，返回的数据指针在当前 op 对象销毁时，或者再次调用 GetScreenData 时，会自动释放. 199 | 200 | ## `GetScreenDataBmp(self, x1, y1, x2, y2)` 201 | 202 | 获取指定区域的图像,用 24 位位图的数据格式返回,方便二次开发.（或者可以配合 SetDisplayInput 的 mem 模式） 203 | 204 | Parameters: 205 | 206 | - **x1** (`int`) – 区域的左上 X 坐标 207 | - **y1** (`int`) – 区域的左上 Y 坐标 208 | - **x2** (`int`) – 区域的右下 X 坐标 209 | - **y2** (`int`) – 区域的右下 Y 坐标 210 | 211 | Returns: 212 | 213 | - `tuple` – (x1,y1,x2,y2,返回图片的数据,返回图片的数据长度) 214 | 215 | ## `SetDisplayInput(self, mode)` 216 | 217 | 设定图色的获取方式，默认是显示器或者后台窗口(具体参考 BindWindow) 218 | 219 | Parameters: 220 | 221 | - **mode** (`str`) – 图色输入模式取值有以下几种 "screen" 这个是默认的模式，表示使用显示器或者后台窗口 "pic:file" 指定输入模式为指定的图片,如果使用了这个模式，则所有和图色相关的函数均视为对此图片进行处理，比如文字识别查找图片 颜色 等等一切图色函数.需要注意的是，设定以后，此图片就已经加入了缓冲，如果更改了源图片内容，那么需要 释放此缓冲，重新设置. "mem:addr" 指定输入模式为指定的图片,此图片在内存当中. addr 为图像内存地址,一般是 GetScreenDataBmp 的返回值（前 54 字节为位图信息，后面的是像素数据），注意与大漠的区别.如果使用了这个模式，则所有和图色相关的函数,均视为对此图片进行处理.比如文字识别 查找图片 颜色 等等一切图色函数所有坐标都相对此图片，如果不想受到影响，调用 GetScreenDataBmp 时应时整个窗口的大小. 222 | 223 | Returns: 224 | 225 | - `int` – 0 代表失败 1 代表成功 226 | -------------------------------------------------------------------------------- /docs/基本设置.md: -------------------------------------------------------------------------------- 1 | pyopdll 是开源项目 OP(operator & open)的 Python 接口。 2 | 3 | OP(operator & open)地址：https://github.com/WallBreaker2/op 4 | 5 | ## `__init__(self, dll_path=None)` `special` 6 | 7 | 初始化并且完成注册 8 | 9 | Parameters: 10 | 11 | - **dll_path** (`str`) – op_x64.dll 路径。可以指定本地的 dll 文件，但文件名称必须是 op_x64.dll 或者 op_x86 12 | 13 | ## `__repr__(self)` `special` 14 | 15 | 自我描述信息。 16 | 17 | Returns: 18 | 19 | - `str` – 自我描述信息。 20 | 21 | ## `Un_reg(self)` 22 | 23 | 取消已经注册的 dll 24 | 25 | Returns: 26 | 27 | - `None` – 无返回值 28 | - 29 | ## `GetBasePath(self)` 30 | 31 | 获取注册在系统中的 dll 的路径. 32 | 33 | Returns: 34 | 35 | - `str` – 返回 dll 所在路径. 36 | 37 | ## `GetID(self)` 38 | 39 | 返回当前对象的 ID 值，这个值对于每个对象是唯一存在的。可以用来判定两个对象是否一致. 40 | 41 | Returns: 42 | 43 | - `int` – 当前对象的 ID 值. 44 | 45 | ## `GetLastError(self)` 46 | 47 | 获取插件命令的最后错误 48 | 49 | Returns: 50 | 51 | - `int` – 返回值表示错误值。 0 表示无错误. 52 | 53 | 注: 此函数必须紧跟上一句函数调用，中间任何的语句调用都会改变这个值. 54 | 55 | ## `GetPath(self)` 56 | 57 | 获取全局路径.(可用于调试) 58 | 59 | Returns: 60 | 61 | - `str` – 以字符串的形式返回当前设置的全局路径 62 | 63 | ## `SetPath(self, path)` 64 | 65 | 设置全局路径,设置了此路径后,所有接口调用中,相关的文件都相对于此路径. 比如图片,字库等. 66 | 67 | Parameters: 68 | 69 | - **path** (`str`) – 路径,可以是相对路径,也可以是绝对路径 70 | 71 | Returns: 72 | 73 | - `int` – 0 代表失败，1 代表成功 74 | 75 | ## `SetShowErrorMsg(self, show)` 76 | 77 | 设置是否弹出错误信息,默认是打开. 78 | 79 | Parameters: 80 | 81 | - **show** (`int`) – 0 表示不打开,1 表示打开. 82 | 83 | Returns: 84 | 85 | - `int` – 0 代表失败，1 代表成功 86 | 87 | ## `ver(self)` 88 | 89 | 返回当前插件版本号 90 | 91 | Returns: 92 | 93 | - `str` – 当前插件的版本描述字符串 94 | 95 | ## `EnablePicCache(self, enable)` 96 | 97 | 设置是否开启或者关闭插件内部的图片缓存机制. (默认是打开). 98 | 99 | Parameters: 100 | 101 | - **enable** (`int`) – 0 代表关闭，1 代表打开 102 | 103 | Returns: 104 | 105 | - `int` – 0 代表失败，1 代表成功 106 | 107 | 注: 有些时候，系统内存比较吃紧，这时候再打开内部缓存，可能会导致缓存分配在虚拟内存，这样频繁换页，反而导致图色效率下降.这时候就建议关闭图色缓存. 所有图色缓存机制都是对本对象的，也就是说，调用图色缓存机制的函数仅仅对本对象生效. 每个对象都有一个图色缓存队列. 108 | -------------------------------------------------------------------------------- /docs/常见算法.md: -------------------------------------------------------------------------------- 1 | ## `AStarFindPath(self, mapWidth, mapHeight, disable_points, beginX, beginY, endX, endY)` 2 | 3 | A 星算法 4 | 5 | Parameters: 6 | 7 | - **mapWidth** (`int`) – 区域的左上 X 坐标 8 | - **mapHeight** (`int`) – 区域的左上 Y 坐标 9 | - **disable_points** (`str`) – 不可通行的坐标，以"|"分割，例如:"10,15|20,30" 10 | - **beginX** (`int`) – 源坐标 X 11 | - **beginY** (`int`) – 源坐标 Y 12 | - **endX** (`int`) – 目的坐标 X 13 | - **endY** (`int`) – 目的坐标 Y 14 | 15 | Returns: 16 | 17 | - `int` – 0 代表失败 1 代表成功 18 | -------------------------------------------------------------------------------- /docs/文字识别.md: -------------------------------------------------------------------------------- 1 | 2 | ## `FindStr(self, x1, y1, x2, y2, string_, color_format, sim)` 3 | 4 | 在屏幕范围(x1,y1,x2,y2)内,查找 string(可以是任意个字符串的组合),并返回符合 color_format 的坐标位置,相似度 sim 同 Ocr 接口描述.(多色,差色查找类似于 Ocr 接口,不再重述) 5 | 6 | Parameters: 7 | 8 | - **x1** (`int`) – 区域的左上 X 坐标 9 | - **y1** (`int`) – :区域的左上 Y 坐标 10 | - **x2** (`int`) – 区域的右下 X 坐标 11 | - **y2** (`int`) – 区域的右下 Y 坐标 12 | - **string\_** (`str`) – 待查找的字符串,可以是字符串组合，比如"长安|洛阳|大雁塔",中间用"|"来分割字符串 13 | - **color_format** (`str`) – 颜色格式串, 可以包含换行分隔符,语法是","后加分割字符串. 具体可以查看下面的示例 .注意，RGB 和 HSV 格式都支持 14 | - **sim** (`float`) – 双精度浮点数:相似度,取值范围 0.1-1.0 15 | 16 | Returns: 17 | 18 | - `tuple` – (x1,y1,x2,y2,string\_,color_format,sim,返回 X 坐标没找到返回-1,返回 Y 坐标没找到返回-1) 19 | 20 | 示例: 21 | 22 | op_ret = op.FindStr(0,0,2000,2000,"长安","9f2e3f-000000",1.0,intX,intY) 23 | If intX >= 0 and intY >= 0 Then 24 | op.MoveTo intX,intY 25 | End If 26 | 27 | op_ret = op.FindStr(0,0,2000,2000,"长安|洛阳","9f2e3f-000000",1.0,intX,intY) 28 | If intX >= 0 and intY >= 0 Then 29 | op.MoveTo intX,intY 30 | End If 31 | 32 | // 查找时,对多行文本进行换行,换行分隔符是"|". 语法是在","后增加换行字符串.任意字符串都可以. 33 | op_ret = op.FindStr(0,0,2000,2000,"长安|洛阳","9f2e3f-000000,|",1.0,intX,intY) 34 | If intX >= 0 and intY >= 0 Then 35 | op.MoveTo intX,intY 36 | End If 37 | 注: 此函数的原理是先Ocr识别，然后再查找。 38 | 39 | ## `FindStrEx(self, x1, y1, x2, y2, string_, color_format, sim)` 40 | 41 | 在屏幕范围(x1,y1,x2,y2)内,查找 string(可以是任意个字符串的组合),并返回符合 color_format 的坐标位置,相似度 sim 同 Ocr 接口描述.(多色,差色查找类似于 Ocr 接口,不再重述) 42 | 43 | Parameters: 44 | 45 | - **x1** (`int`) – 区域的左上 X 坐标 46 | - **y1** (`int`) – :区域的左上 Y 坐标 47 | - **x2** (`int`) – 区域的右下 X 坐标 48 | - **y2** (`int`) – 区域的右下 Y 坐标 49 | - **string\_** (`str`) – 待查找的字符串,可以是字符串组合，比如"长安|洛阳|大雁塔",中间用"|"来分割字符串 50 | - **color_format** (`str`) – 颜色格式串, 可以包含换行分隔符,语法是","后加分割字符串. 具体可以查看下面的示例 .注意，RGB 和 HSV 格式都支持 51 | - **sim** (`float`) – 双精度浮点数:相似度,取值范围 0.1-1.0 52 | 53 | Returns: 54 | 55 | - `返回所有找到的坐标集合,格式如下` – "id,x0,y0|id,x1,y1|......|id,xn,yn" 比如"0,100,20|2,30,40" 表示找到了两个,第一个,对应的是序号为 0 的字符串,坐标是(100,20),第二个是序号为 2 的字符串,坐标(30,40) 56 | 57 | 示例: 58 | 59 | op_ret = op.FindStrEx(0,0,2000,2000,"长安|洛阳","9f2e3f-000000",1.0) 60 | If len(op_ret) > 0 Then 61 | ss = split(op_ret,"|") 62 | index = 0 63 | count = UBound(ss) + 1 64 | Do While index < count 65 | TracePrint ss(index) 66 | sss = split(ss(index),",") 67 | id = int(sss(0)) 68 | x = int(sss(1)) 69 | y = int(sss(2)) 70 | op.MoveTo x,y 71 | Delay 1000 72 | index = index+1 73 | Loop 74 | End If 75 | 注: 此函数的原理是先Ocr识别，然后再查找。 76 | 77 | ## `Ocr(self, x1, y1, x2, y2, color_format, sim)` 78 | 79 | 识别屏幕范围(x1,y1,x2,y2)内符合 color_format 的字符串,并且相似度为 sim,sim 取值范围(0.1-1.0),这个值越大越精确,越大速度越快,越小速度越慢,请斟酌使用! 80 | 81 | Parameters: 82 | 83 | - **x1** (`int`) – 区域的左上 X 坐标 84 | - **y1** (`int`) – 区域的左上 Y 坐标 85 | - **x2** (`int`) – 区域的右下 X 坐标 86 | - **y2** (`int`) – 区域的右下 Y 坐标 87 | - **color_format** (`str`) – 区域的右下 Y 坐标 88 | - **sim** (`float`) – 双精度浮点数:相似度,取值范围 0.1-1.0 89 | 90 | Returns: 91 | 92 | - `str` – 返回识别到的字符串 93 | 94 | 示例: 95 | 96 | //RGB单色识别 97 | s = op.Ocr(0,0,2000,2000,"9f2e3f-000000",1.0) 98 | MessageBox s 99 | 100 | //RGB单色差色识别 101 | s = op.Ocr(0,0,2000,2000,"9f2e3f-030303",1.0) 102 | MessageBox s 103 | 104 | //RGB多色识别(最多支持10种,每种颜色用"|"分割) 105 | s = op.Ocr(0,0,2000,2000,"9f2e3f-030303|2d3f2f-000000|3f9e4d-100000",1.0) 106 | MessageBox s 107 | 108 | ## `OcrEx(self, x1, y1, x2, y2, color_format, sim)` 109 | 110 | 识别屏幕范围(x1,y1,x2,y2)内符合 color_format 的字符串,并且相似度为 sim,sim 取值范围(0.1-1.0),这个值越大越精确,越大速度越快,越小速度越慢,请斟酌使用!这个函数可以返回识别到的字符串，以及每个字符的坐标. 111 | 112 | Parameters: 113 | 114 | - **x1** (`int`) – 区域的左上 X 坐标 115 | - **y1** (`int`) – 区域的左上 Y 坐标 116 | - **x2** (`int`) – 区域的右下 X 坐标 117 | - **y2** (`int`) – 区域的右下 Y 坐标 118 | - **color_format** (`str`) – 区域的右下 Y 坐标 119 | - **sim** (`float`) – 双精度浮点数:相似度,取值范围 0.1-1.0 120 | 121 | Returns: 122 | 123 | - `str` – 返回识别到的字符串 格式如 "字符 0$x0$y0|…|字符 n$xn$yn" 124 | 125 | ## `SetDict(self, index, file)` 126 | 127 | 设置字库文件 128 | 129 | Parameters: 130 | 131 | - **index** (`int`) – 字库的序号,取值为 0-19,目前最多支持 20 个字库 132 | - **file** (`str`) – 字库文件名 133 | 134 | Returns: 135 | 136 | - `int` – 0 代表失败 1 代表成功 137 | 138 | ## `UseDict(self, index)` 139 | 140 | 表示使用哪个字库文件进行识别(index 范围:0-9)设置之后，永久生效，除非再次设定 141 | 142 | Parameters: 143 | 144 | - **index** (`int`) – 字库编号(0-9) 145 | 146 | Returns: 147 | 148 | - `int` – 0 代表失败 1 代表成功 149 | 150 | ## `OcrAuto(self, x1, y1, x2, y2, sim)` 151 | 152 | 识别屏幕范围(x1,y1,x2,y2)内的字符串,自动二值化，而无需指定颜色,适用于字体颜色和背景相差较大的场合 153 | 154 | Parameters: 155 | 156 | - **x1** (`int`) – 区域的左上 X 坐标 157 | - **y1** (`int`) – 区域的左上 Y 坐标 158 | - **x2** (`int`) – 区域的右下 X 坐标 159 | - **y2** (`int`) – 区域的右下 Y 坐标 160 | - **sim** (`float`) – 相似度,取值范围 0.1-1.0 161 | 162 | Returns: 163 | 164 | - `str` – 返回识别到的字符串 165 | 166 | ## `OcrFromFile(self, file_name, color_format, sim)` 167 | 168 | Parameters: 169 | 170 | - **file_name** (`str`) – 文件名 171 | - **color_format** (`str`) – 颜色格式串 172 | - **sim** (`float`) – 相似度,取值范围 0.1-1.0 173 | 174 | Returns: 175 | 176 | - `str` – 返回识别到的字符串 177 | 178 | ## `OcrAutoFromFile(self, file_name, sim)` 179 | 180 | Parameters: 181 | 182 | - **file_name** (`str`) – 文件名 183 | - **sim** (`float`) – 相似度,取值范围 0.1-1.0 184 | 185 | Returns: 186 | 187 | - `str` – 返回识别到的字符串 188 | 189 | --- 190 | 191 | Built with [MkDocs](https://www.mkdocs.org/) using a [theme](https://github.com/snide/sphinx_rtd_theme) provided by [Read the Docs](https://readthedocs.org). 192 | -------------------------------------------------------------------------------- /docs/窗口设置.md: -------------------------------------------------------------------------------- 1 | 2 | ## `ClientToScreen(self, hwnd)` 3 | 4 | 把窗口坐标转换为屏幕坐标 5 | 6 | Parameters: 7 | 8 | - **hwnd** (`int`) – 指定的窗口句柄.你可以使用 GetWindow，FindWindow 等返回窗口句柄的方法获取句柄 9 | 10 | Returns: 11 | 12 | - `tuple` – 返回元组数据类型,（窗口句柄，X 坐标，Y 坐标）. 13 | 14 | ## `EnumProcess(self, name)` 15 | 16 | 根据进程名枚举进程 17 | 18 | Parameters: 19 | 20 | - **name** (`str`) – 进程名,比如 qq.exe 21 | 22 | Returns: 23 | 24 | - `str` – 返回所有匹配的进程 PID,并按打开顺序排序,格式"pid1,pid2,pid3" 25 | 26 | ## `EnumWindow(self, parent, title, class_name, _filter)` 27 | 28 | 根据父窗口,枚举系统中符合条件的子窗口,可以枚举到按键自带的无法枚举到的窗口 29 | 30 | Parameters: 31 | 32 | - **parent** (`int`) – 获得的窗口句柄是该窗口的子窗口的窗口句柄,取 0 时为获得桌面句柄 33 | - **title** (`str`) – 窗口标题. 此参数是模糊匹配. 34 | - **class_name** (`str`) – 窗口类名. 此参数是模糊匹配. 35 | - **\_filter** (`int`) – 取值定义如下 1 : 匹配窗口标题,参数 title 有效 2 : 匹配窗口类名,参数 class_name 有效. 4 : 只匹配指定父窗口的第一层孩子窗口 8 : 匹配所有者窗口为 0 的窗口,即顶级窗口 16 : 匹配可见的窗口 32 : 匹配出的窗口按照窗口打开顺序依次排列 这些值可以相加,比如 4+8+16 就是类似于任务管理器中的窗口列表 36 | 37 | Returns: 38 | 39 | - `str` – 返回 str 数据类型，"hwnd1,hwnd2,hwnd3"，你可以字符串分割变成列表 40 | 41 | 示例: 42 | 43 | hwnds = dm.EnumWindow(0,"QQ三国","",1+4+8+16) 44 | 这句是获取到所有标题栏中有QQ三国这个字符串的窗口句柄集合 45 | hwnds = split(hwnds,",") 46 | 转换为数组后,就可以处理了 47 | 这里注意,hwnds数组里的是字符串,要用于使用,比如BindWindow时,还得强制类型转换,比如int(hwnds(0)) 48 | 49 | ## `EnumWindowByProcess(self, process_name, title, class_name, _filter)` 50 | 51 | 根据指定进程以及其它条件,枚举系统中符合条件的窗口,可以枚举到按键自带的无法枚举到的窗口 52 | 53 | Parameters: 54 | 55 | - **process_name** (`str`) – 进程映像名.比如(svchost.exe). 此参数是精确匹配,但不区分大小写. 56 | - **title** (`str`) – 窗口标题. 此参数是模糊匹配. 57 | - **class_name** (`str`) – 窗口类名. 此参数是模糊匹配. 58 | - **\_filter** (`int`) – 取值定义如下 1 : 匹配窗口标题,参数 title 有效 2 : 匹配窗口类名,参数 class_name 有效 4 : 只匹配指定映像的所对应的第一个进程. 可能有很多同映像名的进程，只匹配第一个进程的.8 : 匹配所有者窗口为 0 的窗口,即顶级窗口 16 : 匹配可见的窗口 59 | 60 | Returns: 61 | 62 | - `str` – 返回 str 数据类型，返回所有匹配的窗口句柄字符串,格式"hwnd1,hwnd2,hwnd3" 63 | 64 | ## `EnumWindowSuper(self, spec1, flag1, type1, spec2, flag2, type2, sort)` 65 | 66 | 根据两组设定条件来枚举指定窗口. 67 | 68 | Parameters: 69 | 70 | - **spec1** (`str`) – 查找串 1\. (内容取决于 flag1 的值) 71 | - **flag1** (`int`) – flag1 取值如下: 0 表示 spec1 的内容是标题 1 表示 spec1 的内容是程序名字. (比如 notepad) 2 表示 spec1 的内容是类名 3 表示 spec1 的内容是程序路径.(不包含盘符,比如\\windows\\system32) 4 表示 spec1 的内容是父句柄.(十进制表达的串) 5 表示 spec1 的内容是父窗口标题 6 表示 spec1 的内容是父窗口类名 7 表示 spec1 的内容是顶级窗口句柄.(十进制表达的串) 8 表示 spec1 的内容是顶级窗口标题 9 表示 spec1 的内容是顶级窗口类名 72 | - **type1** (`int`) – 0 精确判断 1 模糊判断 73 | - **spec2** (`str`) – 查找串 2\. (内容取决于 flag2 的值) 74 | - **flag2** (`int`) – flag2 取值如下: 0 表示 spec2 的内容是标题 1 表示 spec2 的内容是程序名字. (比如 notepad) 2 表示 spec2 的内容是类名 3 表示 spec2 的内容是程序路径.(不包含盘符,比如\\windows\\system32) 4 表示 spec2 的内容是父句柄.(十进制表达的串) 5 表示 spec2 的内容是父窗口标题 6 表示 spec2 的内容是父窗口类名 7 表示 spec2 的内容是顶级窗口句柄.(十进制表达的串) 8 表示 spec2 的内容是顶级窗口标题 9 表示 spec2 的内容是顶级窗口类名 75 | - **type2** (`int`) – 0 精确判断,1 模糊判断 76 | - **sort** (`int`) – 0 不排序.1 对枚举出的窗口进行排序,按照窗口打开顺序. 77 | 78 | Returns: 79 | 80 | - `str` – 返回所有匹配的窗口句柄字符串,格式"hwnd1,hwnd2,hwnd3" 81 | 82 | ## `FindWindow(self, class_name='', title_name='')` 83 | 84 | 查找符合类名或者标题名的顶层可见窗 85 | 86 | Parameters: 87 | 88 | - **class_name** (`str`) – 窗口类名，如果为空，则匹配所有. 这里的匹配是模糊匹配. 89 | - **title_name** (`str`) – 窗口标题,如果为空，则匹配所有.这里的匹配是模糊匹配. 90 | 91 | Returns: 92 | 93 | - `int` – 整数型表示的窗口句柄，没找到返回 0 94 | 95 | For example: 96 | 97 | hwnd = dm.FindWindow("","记事本") 98 | 99 | ## `FindWindowByProcess(self, process_name, class_, title)` 100 | 101 | 根据指定的进程名字，来查找可见窗口. 102 | 103 | Parameters: 104 | 105 | - **process_name** (`str`) – 进程名. 比如(notepad.exe).这里是精确匹配,但不区分大小写. 106 | - **class\_** (`str`) – 窗口类名，如果为空，则匹配所有. 这里的匹配是模糊匹配. 107 | - **title** (`str`) – 窗口标题,如果为空，则匹配所有.这里的匹配是模糊匹配. 108 | 109 | Returns: 110 | 111 | - `int` – 表示的窗口句柄，没找到返回 0 112 | 113 | ## `FindWindowByProcessId(self, process_id, class_, title)` 114 | 115 | 根据指定的进程 Id，来查找可见窗口. 116 | 117 | Parameters: 118 | 119 | - **process_id** (`int`) – 进程 id. 120 | - **class\_** (`str`) – 窗口类名，如果为空，则匹配所有. 这里的匹配是模糊匹配. 121 | - **title** (`str`) – 窗口标题,如果为空，则匹配所有.这里的匹配是模糊匹配. 122 | 123 | Returns: 124 | 125 | - `int` – 表示的窗口句柄，没找到返回 0 126 | 127 | ## `FindWindowEx(self, parent, _class, title)` 128 | 129 | 查找符合类名或者标题名的顶层可见窗口,如果指定了 parent,则在 parent 的第一层子窗口中查找. 130 | 131 | Parameters: 132 | 133 | - **parent** (`int`) – 父窗口句柄，如果为空，则匹配所有顶层窗口 134 | - **\_class** (`str`) – 窗口类名，如果为空，则匹配所有. 这里的匹配是模糊匹配. 135 | - **title** (`str`) – 窗口标题,如果为空，则匹配所有. 这里的匹配是模糊匹配. 136 | 137 | Returns: 138 | 139 | - `int` – 表示的窗口句柄，没找到返回 0 140 | 141 | For example: 142 | 143 | hwnd = dm.FindWindowEx(0,"","记事本") 144 | 145 | ## `FindWindowSuper(self, spec1, flag1, type1, spec2, flag2, type2)` 146 | 147 | 根据两组设定条件来查找指定窗口. 148 | 149 | Parameters: 150 | 151 | - **spec1** (`str`) – 查找串 1\. (内容取决于 flag1 的值) 152 | - **flag1** (`int`) – flag1 取值如下: 0 表示 spec1 的内容是标题 1 表示 spec1 的内容是程序名字. (比如 notepad) 2 表示 spec1 的内容是类名 3 表示 spec1 的内容是程序路径.(不包含盘符,比如\\windows\\system32) 4 表示 spec1 的内容是父句柄.(十进制表达的串) 5 表示 spec1 的内容是父窗口标题 6 表示 spec1 的内容是父窗口类名 7 表示 spec1 的内容是顶级窗口句柄.(十进制表达的串) 8 表示 spec1 的内容是顶级窗口标题 9 表示 spec1 的内容是顶级窗口类名 153 | - **type1** (`int`) – 0 精确判断 1 模糊判断 154 | - **spec2** (`str`) – 查找串 2\. (内容取决于 flag2 的值) 155 | - **flag2** (`int`) – flag2 取值如下: 0 表示 spec2 的内容是标题 1 表示 spec2 的内容是程序名字. (比如 notepad) 2 表示 spec2 的内容是类名 3 表示 spec2 的内容是程序路径.(不包含盘符,比如\\windows\\system32) 4 表示 spec2 的内容是父句柄.(十进制表达的串) 5 表示 spec2 的内容是父窗口标题 6 表示 spec2 的内容是父窗口类名 7 表示 spec2 的内容是顶级窗口句柄.(十进制表达的串) 8 表示 spec2 的内容是顶级窗口标题 9 表示 spec2 的内容是顶级窗口类名 156 | - **type2** (`int`) – 0 精确判断,1 模糊判断 157 | 158 | Returns: 159 | 160 | - `int` – 表示的窗口句柄，没找到返回 0 161 | 162 | ## `GetClientRect(self, hwnd)` 163 | 164 | 获取窗口客户区域在屏幕上的位置 165 | 166 | Parameters: 167 | 168 | - **hwnd** (`int`) – 指定的窗口句柄 169 | 170 | Returns: 171 | 172 | - `tuple` – (窗口句柄,窗口客户区左上角 X 坐标,窗口客户区左上角 Y 坐标,窗口客户区右下角 X 坐标,窗口客户区右下角 Y 坐标) 173 | 174 | ## `GetClientSize(self, hwnd)` 175 | 176 | 获取窗口客户区域的宽度和高度 177 | 178 | Parameters: 179 | 180 | - **hwnd** (`int`) – 指定的窗口句柄 181 | 182 | Returns: 183 | 184 | - `tuple` – (指定的窗口句柄,宽度,高度) 185 | 186 | ## `GetForegroundFocus(self)` 187 | 188 | 获取顶层活动窗口中具有输入焦点的窗口句柄 189 | 190 | Returns: 191 | 192 | - `int` – 返回整型表示的窗口句柄 193 | 194 | ## `GetForegroundWindow(self)` 195 | 196 | 获取顶层活动窗口,可以获取到按键自带插件无法获取到的句柄 197 | 198 | Returns: 199 | 200 | - `int` – 返回整型表示的窗口句柄 201 | 202 | ## `GetMousePointWindow(self)` 203 | 204 | 获取鼠标指向的窗口句柄,可以获取到按键自带的插件无法获取到的句柄 205 | 206 | Returns: 207 | 208 | - `int` – 返回整型表示的窗口句柄 209 | 210 | ## `GetPointWindow(self, x, y)` 211 | 212 | 获取给定坐标的窗口句柄,可以获取到按键自带的插件无法获取到的句柄 213 | 214 | Parameters: 215 | 216 | - **x** (`int`) – 屏幕 X 坐标 217 | - **y** (`int`) – 屏幕 Y 坐标 218 | 219 | Returns: 220 | 221 | - `int` – 返回整型表示的窗口句柄 222 | 223 | ## `GetSpecialWindow(self, flag)` 224 | 225 | 获取特殊窗口 226 | 227 | Parameters: 228 | 229 | - **flag** (`int`) – 取值定义如下 0 : 获取桌面窗口 1 : 获取任务栏窗口 230 | 231 | Returns: 232 | 233 | - `int` – 以整型数表示的窗口句柄 234 | 235 | ## `GetProcessInfo(self, pid)` 236 | 237 | 根据指定的 pid 获取进程详细信息,(进程名,进程全路径,CPU 占用率(百分比),内存占用量(字节)) 238 | 239 | Parameters: 240 | 241 | - **pid** (`int`) – 进程 pid 242 | 243 | Returns: 244 | 245 | - `字符串` – 格式"进程名|进程路径|cpu|内存" 246 | 247 | ## `GetWindow(self, hwnd, flag)` 248 | 249 | 获取给定窗口相关的窗口句柄 250 | 251 | Parameters: 252 | 253 | - **hwnd** (`int`) – 窗口句柄 254 | - **flag** (`int`) – 取值定义如下 0 : 获取父窗口 1 : 获取第一个儿子窗口 2 : 获取 First 窗口 3 : 获取 Last 窗口 4 : 获取下一个窗口 5 : 获取上一个窗口 6 : 获取拥有者窗口 7 : 获取顶层窗口 255 | 256 | Returns: 257 | 258 | - `int` – 返回整型表示的窗口句柄 259 | 260 | ## `GetWindowClass(self, hwnd)` 261 | 262 | 获取窗口的类名 263 | 264 | Parameters: 265 | 266 | - **hwnd** (`int`) – 指定的窗口句柄 267 | 268 | Returns: 269 | 270 | - `str` – 窗口的类名 271 | 272 | ## `GetWindowProcessId(self, hwnd)` 273 | 274 | 获取指定窗口所在的进程 ID. 275 | 276 | Parameters: 277 | 278 | - **hwnd** (`int`) – 窗口句柄 279 | 280 | Returns: 281 | 282 | - `int` – 返回整型表示的是进程 ID 283 | 284 | ## `GetWindowProcessPath(self, hwnd)` 285 | 286 | 获取指定窗口所在的进程的 exe 文件全路径. 287 | 288 | Parameters: 289 | 290 | - **hwnd** (`int`) – 窗口句柄 291 | 292 | Returns: 293 | 294 | - `str` – 返回字符串表示的是 exe 全路径名 295 | 296 | ## `GetWindowRect(self, hwnd)` 297 | 298 | 获取窗口在屏幕上的位置 299 | 300 | Parameters: 301 | 302 | - **hwnd** (`int`) – 指定的窗口句柄 303 | 304 | Returns: 305 | 306 | - `tuple` – (指定的窗口句柄,窗口左上角 X 坐标,窗口左上角 Y 坐标 窗口右下角 X 坐标,窗口右下角 Y 坐标) 307 | 308 | ## `GetWindowState(self, hwnd, flag)` 309 | 310 | 获取指定窗口的一些属性 311 | 312 | Parameters: 313 | 314 | - **hwnd** (`int`) – 指定的窗口句柄 315 | - **flag** (`int`) – 取值定义如下: 0 : 判断窗口是否存在 1 : 判断窗口是否处于激活 2 : 判断窗口是否可见 3 : 判断窗口是否最小化 4 : 判断窗口是否最大化 5 : 判断窗口是否置顶 6 : 判断窗口是否无响应 7 : 判断窗口是否可用(灰色为不可用) 8 : 另外的方式判断窗口是否无响应,如果 6 无效可以尝试这个 316 | 317 | Returns: 318 | 319 | - `int` – 0 代表失败，1 代表成功 320 | 321 | ## `GetWindowTitle(self, hwnd)` 322 | 323 | 获取窗口的标题 324 | 325 | Parameters: 326 | 327 | - **hwnd** (`int`) – 指定的窗口句柄 328 | 329 | Returns: 330 | 331 | - `str` – 窗口的标题 332 | 333 | ## `MoveWindow(self, hwnd, x, y)` 334 | 335 | 移动指定窗口到指定位置 336 | 337 | Parameters: 338 | 339 | - **hwnd** (`int`) – 指定的窗口句柄 340 | - **x** (`int`) – X 坐标 341 | - **y** (`int`) – Y 坐标 342 | 343 | Returns: 344 | 345 | - `int` – 0 代表失败，1 代表成功 346 | 347 | ## `ScreenToClient(self, hwnd)` 348 | 349 | 把屏幕坐标转换为窗口坐标 350 | 351 | Parameters: 352 | 353 | - **hwnd** (`int`) – 指定的窗口句柄 354 | 355 | Returns: 356 | 357 | - `tuple` – 返回元组（指定的窗口句柄，屏幕 X 坐标，屏幕 Y 坐标） 358 | 359 | ## `SendPaste(self, hwnd)` 360 | 361 | 向指定窗口发送粘贴命令. 把剪贴板的内容发送到目标窗口. 362 | 363 | Parameters: 364 | 365 | - **hwnd** (`int`) – 指定的窗口句柄 366 | 367 | Returns: 368 | 369 | - `int` – 0 代表失败，1 代表成功 370 | 371 | ## `SendString(self, hwnd, str)` 372 | 373 | 向指定窗口发送文本数据 374 | 375 | Parameters: 376 | 377 | - **hwnd** (`int`) – 指定的窗口句柄 378 | - **str** (`str`) – 发送的文本数据 379 | 380 | Returns: 381 | 382 | - `int` – 0 代表失败，1 代表成功 383 | 384 | ## `SendString2(self, hwnd, str)` 385 | 386 | 向指定窗口发送文本数据 387 | 388 | Parameters: 389 | 390 | - **hwnd** (`int`) – 指定的窗口句柄 391 | - **str** (`str`) – 发送的文本数据 392 | 393 | Returns: 394 | 395 | - `int` – 0 代表失败，1 代表成功 396 | 397 | 注: 此接口为老的 SendString，如果新的 SendString 不能输入，可以尝试此接口. 398 | 399 | ## `SetClientSize(self, hwnd, width, height)` 400 | 401 | 设置窗口客户区域的宽度和高度 402 | 403 | Parameters: 404 | 405 | - **hwnd** (`int`) – 指定的窗口句柄 406 | - **width** (`int`) – 宽度 407 | - **height** (`int`) – 高度 408 | 409 | Returns: 410 | 411 | - `int` – 0 代表失败，1 代表成功 412 | 413 | ## `SetWindowSize(self, hwnd, width, height)` 414 | 415 | 设置窗口的大小 416 | 417 | Parameters: 418 | 419 | - **hwnd** (`int`) – 指定的窗口句柄 420 | - **width** (`int`) – 宽度 421 | - **height** (`int`) – 高度 422 | 423 | Returns: 424 | 425 | - `int` – 0 代表失败，1 代表成功 426 | 427 | ## `SetWindowState(self, hwnd, flag)` 428 | 429 | 设置窗口的状态 430 | 431 | Parameters: 432 | 433 | - **hwnd** (`int`) – 指定的窗口句柄 434 | - **flag** (`int`) – 取值定义如下 0 : 关闭指定窗口 1 : 激活指定窗口 2 : 最小化指定窗口,但不激活 3 : 最小化指定窗口,并释放内存,但同时也会激活窗口. 4 : 最大化指定窗口,同时激活窗口. 5 : 恢复指定窗口 ,但不激活 6 : 隐藏指定窗口 7 : 显示指定窗口 8 : 置顶指定窗口 9 : 取消置顶指定窗口 10 : 禁止指定窗口 11 : 取消禁止指定窗口 12 : 恢复并激活指定窗口 13 : 强制结束窗口所在进程. 435 | 436 | Returns: 437 | 438 | - `int` – 0 代表失败，1 代表成功 439 | 440 | ## `SetWindowText(self, hwnd, title)` 441 | 442 | 设置窗口的标题 443 | 444 | Parameters: 445 | 446 | - **hwnd** (`int`) – 指定的窗口句柄 447 | - **title** (`str`) – 标题 448 | 449 | Returns: 450 | 451 | - `int` – 0 代表失败，1 代表成功 452 | 453 | ## `SetWindowTransparent(self, hwnd, trans)` 454 | 455 | 设置窗口的透明度 456 | 457 | Parameters: 458 | 459 | - **hwnd** (`int`) – 指定的窗口句柄 460 | - **trans** (`int`) – 透明度取值(0-255) 越小透明度越大 0 为完全透明(不可见) 255 为完全显示(不透明) 461 | 462 | Returns: 463 | 464 | - `int` – 0 代表失败，1 代表成功 465 | -------------------------------------------------------------------------------- /docs/键盘鼠标.md: -------------------------------------------------------------------------------- 1 | 2 | ## `GetCursorPos(self)` 3 | 4 | 获取鼠标位置. 5 | 6 | Returns: 7 | 8 | - `tuple` – (x,y) 9 | 10 | ## `GetKeyState(self, vk_code)` 11 | 12 | 获取指定的按键状态.(前台信息,不是后台) 13 | 14 | Parameters: 15 | 16 | - **vk_code** (`int`) – 虚拟按键码 17 | 18 | Returns: 19 | 20 | - `int` – 0 代表失败，1 代表成功 21 | 22 | ## `KeyDown(self, vk_code)` 23 | 24 | 按住指定的虚拟键码 25 | 26 | Parameters: 27 | 28 | - **vk_code** (`int`) – 虚拟按键码 29 | 30 | Returns: 31 | 32 | - `int` – 0 代表失败，1 代表成功 33 | 34 | ## `KeyDownChar(self, key_str)` 35 | 36 | 按住指定的虚拟键码 37 | 38 | Parameters: 39 | 40 | - **key_str** (`str`) – 符串描述的键码. 大小写无所谓. 点这里查看具体对应关系 41 | 42 | Returns: 43 | 44 | - `int` – 0 代表失败，1 代表成功 45 | 46 | ## `KeyPress(self, vk_code)` 47 | 48 | 按下指定的虚拟键码 49 | 50 | Parameters: 51 | 52 | - **vk_code** (`int`) – 虚拟按键码 53 | 54 | Returns: 55 | 56 | - `int` – 0 代表失败，1 代表成功 57 | 58 | ## `KeyPressChar(self, key_str)` 59 | 60 | 按下指定的虚拟键码 61 | 62 | Parameters: 63 | 64 | - **key_str** (`str`) – 字符串描述的键码. 大小写无所谓. 点这里查看具体对应关系 65 | 66 | Returns: 67 | 68 | - `int` – 0 代表失败，1 代表成功 69 | 70 | ## `KeyUp(self, vk_code)` 71 | 72 | 弹起来虚拟键 vk_code 73 | 74 | Parameters: 75 | 76 | - **vk_code** (`int`) – 虚拟按键码 77 | 78 | Returns: 79 | 80 | - `int` – 0 代表失败，1 代表成功 81 | 82 | ## `KeyUpChar(self, key_str)` 83 | 84 | 弹起来虚拟键 key_str 85 | 86 | Parameters: 87 | 88 | - **key_str** (`str`) – 字符串描述的键码. 大小写无所谓. 点这里查看具体对应关系. 89 | 90 | Returns: 91 | 92 | - `int` – 0 代表失败，1 代表成功 93 | 94 | ## `LeftClick(self)` 95 | 96 | 按下鼠标左键 97 | 98 | Returns: 99 | 100 | - `int` – 0 代表失败，1 代表成功 101 | 102 | ## `LeftDoubleClick(self)` 103 | 104 | 双击鼠标左键 105 | 106 | Returns: 107 | 108 | - `int` – 0 代表失败，1 代表成功 109 | 110 | ## `LeftDown(self)` 111 | 112 | 按住鼠标左键 113 | 114 | Returns: 115 | 116 | - `int` – 0 代表失败，1 代表成功 117 | 118 | ## `LeftUp(self)` 119 | 120 | 弹起鼠标左键 121 | 122 | Returns: 123 | 124 | - `int` – 0 代表失败，1 代表成功 125 | 126 | ## `MiddleClick(self)` 127 | 128 | 按下鼠标中键 129 | 130 | Returns: 131 | 132 | - `int` – 0 代表失败，1 代表成功 133 | 134 | ## `MoveR(self, rx, ry)` 135 | 136 | 鼠标相对于上次的位置移动 rx,ry 137 | 138 | Parameters: 139 | 140 | - **rx** (`int`) – 相对于上次的 X 偏移 141 | - **ry** (`int`) – 相对于上次的 Y 偏移 142 | 143 | Returns: 144 | 145 | - `int` – 0 代表失败，1 代表成功 146 | 147 | ## `MoveTo(self, x, y)` 148 | 149 | 把鼠标移动到目的点(x,y) 150 | 151 | Parameters: 152 | 153 | - **x** (`int`) – X 坐标 154 | - **y** (`int`) – Y 坐标 155 | 156 | Returns: 157 | 158 | - `int` – 0 代表失败，1 代表成功 159 | 160 | ## `MoveToEx(self, x, y, w, h)` 161 | 162 | 把鼠标移动到目的范围内的任意一点 163 | 164 | Parameters: 165 | 166 | - **x** (`int`) – X 坐标 167 | - **y** (`int`) – Y 坐标 168 | - **w** (`int`) – 宽度(从 x 计算起) 169 | - **h** (`int`) – 高度(从 y 计算起) 170 | 171 | Returns: 172 | 173 | - `str` – 返回要移动到的目标点. 格式为 x,y. 比如 MoveToEx 100,100,10,10,返回值可能是 101,102 174 | 175 | ## `RightClick(self)` 176 | 177 | 按下鼠标右键 178 | 179 | Returns: 180 | 181 | - `int` – 0 代表失败，1 代表成功 182 | 183 | ## `RightDown(self)` 184 | 185 | 按住鼠标右键 186 | 187 | Returns: 188 | 189 | - `int` – 0 代表失败，1 代表成功 190 | 191 | ## `RightUp(self)` 192 | 193 | 弹起鼠标右键 194 | 195 | Returns: 196 | 197 | - `int` – 0 代表失败，1 代表成功 198 | 199 | ## `WaitKey(self, vk_code, time_out)` 200 | 201 | 等待指定的按键按下 (前台,不是后台) 202 | 203 | Parameters: 204 | 205 | - **vk_code** (`int`) – 虚拟按键码,当此值为 0，表示等待任意按键。 鼠标左键是 1,鼠标右键时 2,鼠标中键是 4 206 | - **time_out** (`int`) – 等待多久,单位毫秒. 如果是 0，表示一直等待 207 | 208 | Returns: 209 | 210 | - `0` – 超时 1:指定的按键按下 (当 vk_code 不为 0 时) 按下的按键码:(当 vk_code 为 0 时) 211 | 212 | ## `WheelDown(self)` 213 | 214 | 滚轮向下滚 215 | 216 | Returns: 217 | 218 | - `int` – 0 代表失败，1 代表成功 219 | 220 | ## `WheelUp(self)` 221 | 222 | 滚轮向上滚 223 | 224 | Returns: 225 | 226 | - `int` – 0 代表失败，1 代表成功 227 | -------------------------------------------------------------------------------- /mkdocs.yml: -------------------------------------------------------------------------------- 1 | site_name: pyopdll 2 | 3 | 4 | nav: 5 | - '首页': index.md 6 | - '窗口设置': 窗口设置.md 7 | - '基本设置': 基本设置.md 8 | - '后台设置': 后台设置.md 9 | - '键盘鼠标': 键盘鼠标.md 10 | - 'WinApi': WinApi.md 11 | - '图色设置': 图色设置.md 12 | - '常见算法': 常见算法.md 13 | - '文字识别': 文字识别.md 14 | 15 | theme: 16 | # name: "material" 17 | name: "readthedocs" 18 | 19 | plugins: 20 | - search 21 | #- mkdocstrings: 22 | # default_handler: python 23 | # handlers: 24 | # python: 25 | # rendering: 26 | # show_source: false 27 | # setup_commands: 28 | # - import sys 29 | # - sys.path.insert(0, "..") 30 | 31 | -------------------------------------------------------------------------------- /opdll_test.py: -------------------------------------------------------------------------------- 1 | # -*- coding: UTF-8 -*- 2 | """ 3 | @Project ：pyopdll 4 | @File ：opdll_test.py 5 | @Author ：Gao yongxian 6 | @Date ：2021/10/25 20:19 7 | @contact: g1695698547@163.com 8 | """ 9 | 10 | import time 11 | from pyopdll import OP 12 | 13 | if __name__ == '__main__': 14 | 15 | op = OP() 16 | 17 | print(op.GetCursorPos()) 18 | 19 | # 打印注册路径 20 | path = op.GetBasePath() 21 | print(path) 22 | 23 | # 打印坐标颜色 24 | print(op.GetColor(2,2)) 25 | 26 | # 取消注册 27 | # op.Un_reg() 28 | 29 | # 运行本地程序 30 | # op.RunApp(r"C:\Program Files (x86)\Xianghu\CCtalk\CCtalk.exe",0) 31 | 32 | 33 | # 窗口句柄就是一个int类型的数字 34 | # 获取鼠标指向的窗口句柄 35 | hwnd = op.GetMousePointWindow() 36 | print(hwnd) 37 | # 打印窗口大小 38 | print(op.GetClientSize(hwnd)) 39 | # 打印窗体标题栏 40 | print(op.GetWindowTitle(hwnd)) 41 | 42 | # 获取在前台的窗口的句柄 43 | print(op.GetForegroundWindow()) 44 | 45 | # 寻找记事本的句柄 46 | # 标题需要严格一致才可找到 47 | txt_hwnd=op.FindWindow("","新建文本文档.txt - 记事本") 48 | print(txt_hwnd) 49 | # 打印程序路径 50 | print(op.GetWindowProcessPath(txt_hwnd)) 51 | # 最大化指定窗口,同时激活窗口. 52 | print(op.SetWindowState(txt_hwnd,4)) 53 | # 使记事本窗口移动 54 | op.MoveWindow(txt_hwnd, 10, 10) 55 | 56 | # 拖拽 57 | op.MoveTo(300,50) 58 | op.LeftDown() 59 | for i in range(100): 60 | time.sleep(0.01) 61 | op.MoveR(1,0) 62 | op.LeftUp() 63 | 64 | # 获取标题还有.py的所有句柄 65 | # 注意：返回的是str，但句柄必须是int类型，要强行转化 66 | hwnd_str_list=op.EnumWindow(0,".py","",1+2+4+8).split(",") 67 | print(hwnd_str_list) 68 | for hwnd in hwnd_str_list: 69 | print(op.GetWindowClass(int(hwnd))) 70 | print(op.GetWindowProcessPath(int(hwnd))) 71 | print(op.GetWindowTitle(int(hwnd))) 72 | # 全部移动 73 | # op.MoveWindow(int(hwnd),100,100) 74 | 75 | # 推荐相对移动 76 | op.MoveR(100, 100) 77 | -------------------------------------------------------------------------------- /pyopdll/__init__.py: -------------------------------------------------------------------------------- 1 | # -*- coding: UTF-8 -*- 2 | """ 3 | @Project ：pyopdll 4 | @File ：__init__.py.py 5 | @Author ：Gao yongxian 6 | @Date ：2021/10/25 15:52 7 | @contact: g1695698547@163.com 8 | """ 9 | name = "pyopdll" 10 | from .op import * -------------------------------------------------------------------------------- /pyopdll/op.py: -------------------------------------------------------------------------------- 1 | # -*- coding: UTF-8 -*- 2 | """ 3 | @Project ：pyopdll 4 | @File ：op.py 5 | @Author ：Gao yongxian 6 | @Date ：2021/10/25 15:53 7 | @contact: g1695698547@163.com 8 | """ 9 | 10 | import os 11 | import struct 12 | import time 13 | import ctypes 14 | try: 15 | from win32com.client import Dispatch 16 | except: 17 | pass 18 | 19 | 20 | class OP: 21 | """ 22 | pyopdll是开源项目OP(operator & open)的Python接口。 23 | 24 | OP(operator & open)地址：https://github.com/WallBreaker2/op 25 | """ 26 | 27 | def __init__(self, dll_path: str = None) -> None: 28 | """ 29 | 初始化并且完成注册 30 | 31 | Args: 32 | dll_path: op_x64.dll路径。可以指定本地的dll文件，但文件名称必须是op_x64.dll或者op_x86 33 | """ 34 | 35 | if struct.calcsize("P") * 8 == 32: 36 | self.dll_prefix = "op_x86.dll" 37 | else: 38 | self.dll_prefix = "op_x64.dll" 39 | self.dll_path = dll_path 40 | if dll_path is None: 41 | self.dll_path = os.path.join(os.path.dirname(__file__.replace('/', '\\')), self.dll_prefix) 42 | self.cmd_dll = 'regsvr32 \"' + self.dll_path + '\" /s' 43 | 44 | # 判断是否已经注册注册成功返回版本信息 45 | if self.__is_reg: 46 | print("成功注册：" + 'VER:', self.ver(), ',ID:', self.GetID(), ',PATH:', 47 | os.path.join(self.GetBasePath(), self.dll_prefix)) 48 | else: 49 | self.__reg_as_admin() 50 | if self.__is_reg: 51 | print("成功注册：" + 'VER:', self.ver(), ',ID:', self.GetID(), ',PATH:', 52 | os.path.join(self.GetBasePath(), self.dll_prefix)) 53 | else: 54 | print("注册失败：" + time.strftime('%Y-%m-%d-%H:%M:%S', 55 | time.localtime(time.time())) + self.dll_path + "：注册失败") 56 | 57 | def __unreg_as_admin(self) -> None: 58 | """ 59 | 删除注册的dll。 60 | 61 | Returns: 62 | 无返回值。 63 | """ 64 | self.cmd_un_dll = 'regsvr32 /u /s \"' + os.path.join(self.GetBasePath(), self.dll_prefix) + '\"' 65 | if self.__is_admin: 66 | os.system(self.cmd_un_dll) 67 | else: 68 | ctypes.windll.shell32.ShellExecuteW(None, "runas", "cmd.exe", "/C %s" % self.cmd_un_dll, None, 1) 69 | time.sleep(3) 70 | print("删除注册：" + 'VER:', self.ver(), ',ID:', self.GetID(), ',PATH:', 71 | os.path.join(self.GetBasePath(), self.dll_prefix)) 72 | 73 | def __reg_as_admin(self) -> None: 74 | """ 75 | 注册dll。 76 | 77 | Returns: 78 | 无返回值。 79 | """ 80 | if self.__is_admin: 81 | os.system(self.cmd_dll) 82 | else: 83 | ctypes.windll.shell32.ShellExecuteW(None, "runas", "cmd.exe", "/C %s" % self.cmd_dll, None, 1) 84 | time.sleep(3) 85 | 86 | @property 87 | def __is_reg(self) -> int: 88 | """ 89 | 判断dll是否调用成功。 90 | 91 | Returns: 92 | 返回int数据类型，1代表调用成功，0代表调用失败。 93 | """ 94 | try: 95 | self.op = Dispatch("op.opsoft") 96 | return 1 97 | except: 98 | print( 99 | "调用失败：" + time.strftime('%Y-%m-%d-%H:%M:%S', time.localtime(time.time())) + self.dll_path + "：调用失败") 100 | return 0 101 | 102 | @property 103 | def __is_admin(self) -> bool: 104 | """ 105 | 判断是否具有管理员权限。 106 | 107 | Returns: 108 | 返回bool类型。 109 | """ 110 | try: 111 | return ctypes.windll.shell32.IsUserAnAdmin() 112 | except: 113 | return False 114 | 115 | def __repr__(self) -> str: 116 | """ 117 | 自我描述信息。 118 | 119 | Returns: 120 | 自我描述信息。 121 | """ 122 | ret = 'VER:' + self.ver() + ',ID:' + str(self.GetID()) + ',PATH:' + os.path.join( 123 | self.GetBasePath() + self.dll_prefix) 124 | return ret 125 | 126 | """----------------------------------------取消注册------------------------------------------------""" 127 | 128 | def Un_reg(self) -> None: 129 | """ 130 | 取消已经注册的dll 131 | 132 | Returns: 133 | 无返回值 134 | """ 135 | self.__unreg_as_admin() 136 | 137 | """----------------------------------------窗口设置------------------------------------------------""" 138 | 139 | def ClientToScreen(self, hwnd: int) -> tuple: 140 | """ 141 | 把窗口坐标转换为屏幕坐标 142 | 143 | Args: 144 | hwnd: 指定的窗口句柄.你可以使用GetWindow，FindWindow等返回窗口句柄的方法获取句柄 145 | 146 | Returns: 147 | 返回元组数据类型,（窗口句柄，X坐标，Y坐标）. 148 | """ 149 | return self.op.ClientToScreen(hwnd, 1, 1) 150 | 151 | def EnumProcess(self, name: str) -> str: 152 | """ 153 | 根据进程名枚举进程 154 | 155 | Args: 156 | name:进程名,比如qq.exe 157 | 158 | Returns: 159 | 返回所有匹配的进程PID,并按打开顺序排序,格式"pid1,pid2,pid3" 160 | """ 161 | return self.op.EnumProcess(name) 162 | 163 | def EnumWindow(self, parent: int, title: str, class_name: str, _filter: int) -> str: 164 | """ 165 | 根据父窗口,枚举系统中符合条件的子窗口,可以枚举到按键自带的无法枚举到的窗口 166 | 167 | Args: 168 | parent: 获得的窗口句柄是该窗口的子窗口的窗口句柄,取0时为获得桌面句柄 169 | title: 窗口标题. 此参数是模糊匹配. 170 | class_name: 窗口类名. 此参数是模糊匹配. 171 | _filter: 取值定义如下 172 | 1 : 匹配窗口标题,参数title有效 173 | 2 : 匹配窗口类名,参数class_name有效. 174 | 4 : 只匹配指定父窗口的第一层孩子窗口 175 | 8 : 匹配所有者窗口为0的窗口,即顶级窗口 176 | 16 : 匹配可见的窗口 177 | 32 : 匹配出的窗口按照窗口打开顺序依次排列 178 | 这些值可以相加,比如4+8+16就是类似于任务管理器中的窗口列表 179 | 180 | Returns: 181 | 返回str数据类型，"hwnd1,hwnd2,hwnd3"，你可以字符串分割变成列表 182 | 183 | 示例: 184 | 185 | hwnds = dm.EnumWindow(0,"QQ三国","",1+4+8+16) 186 | 这句是获取到所有标题栏中有QQ三国这个字符串的窗口句柄集合 187 | hwnds = split(hwnds,",") 188 | 转换为数组后,就可以处理了 189 | 这里注意,hwnds数组里的是字符串,要用于使用,比如BindWindow时,还得强制类型转换,比如int(hwnds(0)) 190 | """ 191 | return self.op.EnumWindow(parent, title, class_name, _filter) 192 | 193 | def EnumWindowByProcess(self, process_name: str, title: str, class_name: str, _filter: int) -> str: 194 | """ 195 | 根据指定进程以及其它条件,枚举系统中符合条件的窗口,可以枚举到按键自带的无法枚举到的窗口 196 | 197 | Args: 198 | process_name:进程映像名.比如(svchost.exe). 此参数是精确匹配,但不区分大小写. 199 | title:窗口标题. 此参数是模糊匹配. 200 | class_name:窗口类名. 此参数是模糊匹配. 201 | _filter:取值定义如下 1 : 匹配窗口标题,参数title有效2 : 匹配窗口类名,参数class_name有效4 : 只匹配指定映像的所对应的第一个进程. 可能有很多同映像名的进程，只匹配第一个进程的.8 : 匹配所有者窗口为0的窗口,即顶级窗口16 : 匹配可见的窗口 202 | 203 | Returns: 204 | 返回str数据类型，返回所有匹配的窗口句柄字符串,格式"hwnd1,hwnd2,hwnd3" 205 | """ 206 | return self.op.EnumWindowByProcess(process_name, title, class_name, _filter) 207 | 208 | def EnumWindowSuper(self, spec1: str, flag1: int, type1: int, spec2: str, flag2: int, type2: int, sort: int) -> str: 209 | """ 210 | 根据两组设定条件来枚举指定窗口. 211 | 212 | Args: 213 | spec1:查找串1. (内容取决于flag1的值) 214 | flag1:flag1取值如下: 215 | 0表示spec1的内容是标题 216 | 1表示spec1的内容是程序名字. (比如notepad) 217 | 2表示spec1的内容是类名 218 | 3表示spec1的内容是程序路径.(不包含盘符,比如\windows\system32) 219 | 4表示spec1的内容是父句柄.(十进制表达的串) 220 | 5表示spec1的内容是父窗口标题 221 | 6表示spec1的内容是父窗口类名 222 | 7表示spec1的内容是顶级窗口句柄.(十进制表达的串) 223 | 8表示spec1的内容是顶级窗口标题 224 | 9表示spec1的内容是顶级窗口类名 225 | type1:0精确判断1模糊判断 226 | spec2:查找串2. (内容取决于flag2的值) 227 | flag2:flag2取值如下: 228 | 0表示spec2的内容是标题 229 | 1表示spec2的内容是程序名字. (比如notepad) 230 | 2表示spec2的内容是类名 231 | 3表示spec2的内容是程序路径.(不包含盘符,比如\windows\system32) 232 | 4表示spec2的内容是父句柄.(十进制表达的串) 233 | 5表示spec2的内容是父窗口标题 234 | 6表示spec2的内容是父窗口类名 235 | 7表示spec2的内容是顶级窗口句柄.(十进制表达的串) 236 | 8表示spec2的内容是顶级窗口标题 237 | 9表示spec2的内容是顶级窗口类名 238 | type2:0精确判断,1模糊判断 239 | sort:0不排序.1对枚举出的窗口进行排序,按照窗口打开顺序. 240 | 241 | Returns: 242 | 返回所有匹配的窗口句柄字符串,格式"hwnd1,hwnd2,hwnd3" 243 | """ 244 | return self.op.EnumWindowSuper(spec1, flag1, type1, spec2, flag2, type2, sort) 245 | 246 | def FindWindow(self, class_name: str = '', title_name: str = '') -> int: 247 | """ 248 | 查找符合类名或者标题名的顶层可见窗 249 | 250 | Args: 251 | class_name: 窗口类名，如果为空，则匹配所有. 这里的匹配是模糊匹配. 252 | title_name: 窗口标题,如果为空，则匹配所有.这里的匹配是模糊匹配. 253 | 254 | Returns: 255 | 整数型表示的窗口句柄，没找到返回0 256 | 257 | For example: 258 | 259 | hwnd = dm.FindWindow("","记事本") 260 | 261 | """ 262 | return self.op.FindWindow(class_name, title_name) 263 | 264 | def FindWindowByProcess(self, process_name: str, class_: str, title: str) -> int: 265 | """ 266 | 根据指定的进程名字，来查找可见窗口. 267 | 268 | Args: 269 | process_name:进程名. 比如(notepad.exe).这里是精确匹配,但不区分大小写. 270 | class_:窗口类名，如果为空，则匹配所有. 这里的匹配是模糊匹配. 271 | title:窗口标题,如果为空，则匹配所有.这里的匹配是模糊匹配. 272 | 273 | Returns: 274 | 表示的窗口句柄，没找到返回0 275 | """ 276 | return self.op.FindWindowByProcess(process_name, class_, title) 277 | 278 | def FindWindowByProcessId(self, process_id: int, class_: str, title: str) -> int: 279 | """ 280 | 根据指定的进程Id，来查找可见窗口. 281 | 282 | Args: 283 | process_id: 进程id. 284 | class_: 窗口类名，如果为空，则匹配所有. 这里的匹配是模糊匹配. 285 | title: 窗口标题,如果为空，则匹配所有.这里的匹配是模糊匹配. 286 | 287 | Returns: 288 | 表示的窗口句柄，没找到返回0 289 | """ 290 | return self.op.FindWindowByProcessId(process_id, class_, title) 291 | 292 | def FindWindowEx(self, parent: int, _class: str, title: str) -> int: 293 | """ 294 | 查找符合类名或者标题名的顶层可见窗口,如果指定了parent,则在parent的第一层子窗口中查找. 295 | 296 | Args: 297 | parent:父窗口句柄，如果为空，则匹配所有顶层窗口 298 | _class:窗口类名，如果为空，则匹配所有. 这里的匹配是模糊匹配. 299 | title:窗口标题,如果为空，则匹配所有. 这里的匹配是模糊匹配. 300 | 301 | Returns: 302 | 表示的窗口句柄，没找到返回0 303 | 304 | For example: 305 | 306 | hwnd = dm.FindWindowEx(0,"","记事本") 307 | 308 | """ 309 | return self.op.FindWindowEx(parent, _class, title) 310 | 311 | def FindWindowSuper(self, spec1: str, flag1: int, type1: int, spec2: str, flag2: int, type2: int) -> int: 312 | """ 313 | 根据两组设定条件来查找指定窗口. 314 | 315 | Args: 316 | spec1:查找串1. (内容取决于flag1的值) 317 | flag1:flag1取值如下: 318 | 0表示spec1的内容是标题 319 | 1表示spec1的内容是程序名字. (比如notepad) 320 | 2表示spec1的内容是类名 321 | 3表示spec1的内容是程序路径.(不包含盘符,比如\windows\system32) 322 | 4表示spec1的内容是父句柄.(十进制表达的串) 323 | 5表示spec1的内容是父窗口标题 324 | 6表示spec1的内容是父窗口类名 325 | 7表示spec1的内容是顶级窗口句柄.(十进制表达的串) 326 | 8表示spec1的内容是顶级窗口标题 327 | 9表示spec1的内容是顶级窗口类名 328 | type1:0精确判断1模糊判断 329 | spec2:查找串2. (内容取决于flag2的值) 330 | flag2:flag2取值如下: 331 | 0表示spec2的内容是标题 332 | 1表示spec2的内容是程序名字. (比如notepad) 333 | 2表示spec2的内容是类名 334 | 3表示spec2的内容是程序路径.(不包含盘符,比如\windows\system32) 335 | 4表示spec2的内容是父句柄.(十进制表达的串) 336 | 5表示spec2的内容是父窗口标题 337 | 6表示spec2的内容是父窗口类名 338 | 7表示spec2的内容是顶级窗口句柄.(十进制表达的串) 339 | 8表示spec2的内容是顶级窗口标题 340 | 9表示spec2的内容是顶级窗口类名 341 | type2:0精确判断,1模糊判断 342 | 343 | Returns: 344 | 表示的窗口句柄，没找到返回0 345 | """ 346 | return self.op.FindWindowSuper(spec1, flag1, type1, spec2, flag2, type2) 347 | 348 | def GetClientRect(self, hwnd: int) -> tuple: 349 | """ 350 | 获取窗口客户区域在屏幕上的位置 351 | 352 | Args: 353 | hwnd:指定的窗口句柄 354 | 355 | Returns: 356 | (窗口句柄,窗口客户区左上角X坐标,窗口客户区左上角Y坐标,窗口客户区右下角X坐标,窗口客户区右下角Y坐标) 357 | """ 358 | return self.op.GetClientRect(hwnd, 1, 1, 1, 1) 359 | 360 | def GetClientSize(self, hwnd: int) -> tuple: 361 | """ 362 | 获取窗口客户区域的宽度和高度 363 | 364 | Args: 365 | hwnd:指定的窗口句柄 366 | 367 | Returns: 368 | (指定的窗口句柄,宽度,高度) 369 | """ 370 | return self.op.GetClientSize(hwnd, 1, 1) 371 | 372 | def GetForegroundFocus(self) -> int: 373 | """ 374 | 获取顶层活动窗口中具有输入焦点的窗口句柄 375 | 376 | Returns: 377 | 返回整型表示的窗口句柄 378 | """ 379 | return self.op.GetForegroundFocus() 380 | 381 | def GetForegroundWindow(self) -> int: 382 | """ 383 | 获取顶层活动窗口,可以获取到按键自带插件无法获取到的句柄 384 | 385 | Returns: 386 | 返回整型表示的窗口句柄 387 | """ 388 | return self.op.GetForegroundWindow() 389 | 390 | def GetMousePointWindow(self) -> int: 391 | """ 392 | 获取鼠标指向的窗口句柄,可以获取到按键自带的插件无法获取到的句柄 393 | 394 | Returns: 395 | 返回整型表示的窗口句柄 396 | """ 397 | return self.op.GetMousePointWindow() 398 | 399 | def GetPointWindow(self, x: int, y: int) -> int: 400 | """ 401 | 获取给定坐标的窗口句柄,可以获取到按键自带的插件无法获取到的句柄 402 | 403 | Args: 404 | x:屏幕X坐标 405 | y:屏幕Y坐标 406 | 407 | Returns: 408 | 返回整型表示的窗口句柄 409 | """ 410 | return self.op.GetPointWindow(x, y) 411 | 412 | def GetSpecialWindow(self, flag: int) -> int: 413 | """ 414 | 获取特殊窗口 415 | 416 | Args: 417 | flag:取值定义如下 418 | 0 : 获取桌面窗口 419 | 1 : 获取任务栏窗口 420 | 421 | Returns: 422 | 以整型数表示的窗口句柄 423 | """ 424 | return self.op.GetSpecialWindow(flag) 425 | 426 | def GetProcessInfo(self, pid: int) -> str: 427 | """ 428 | 根据指定的pid获取进程详细信息,(进程名,进程全路径,CPU占用率(百分比),内存占用量(字节)) 429 | 430 | Args: 431 | pid:进程pid 432 | 433 | Returns: 434 | 字符串: 格式"进程名|进程路径|cpu|内存" 435 | """ 436 | return self.op.GetProcessInfo(pid) 437 | 438 | def GetWindow(self, hwnd: int, flag: int) -> int: 439 | """ 440 | 获取给定窗口相关的窗口句柄 441 | 442 | Args: 443 | hwnd:窗口句柄 444 | flag:取值定义如下 445 | 0 : 获取父窗口 446 | 1 : 获取第一个儿子窗口 447 | 2 : 获取First 窗口 448 | 3 : 获取Last窗口 449 | 4 : 获取下一个窗口 450 | 5 : 获取上一个窗口 451 | 6 : 获取拥有者窗口 452 | 7 : 获取顶层窗口 453 | 454 | Returns: 455 | 返回整型表示的窗口句柄 456 | """ 457 | return self.op.GetWindow(hwnd, flag) 458 | 459 | def GetWindowClass(self, hwnd: int) -> str: 460 | """ 461 | 获取窗口的类名 462 | 463 | Args: 464 | hwnd:指定的窗口句柄 465 | 466 | Returns: 467 | 窗口的类名 468 | """ 469 | return self.op.GetWindowClass(hwnd) 470 | 471 | def GetWindowProcessId(self, hwnd: int) -> int: 472 | """ 473 | 获取指定窗口所在的进程ID. 474 | 475 | Args: 476 | hwnd:窗口句柄 477 | 478 | Returns: 479 | 返回整型表示的是进程ID 480 | """ 481 | return self.op.GetWindowClass(hwnd) 482 | 483 | def GetWindowProcessPath(self, hwnd: int) -> str: 484 | """ 485 | 获取指定窗口所在的进程的exe文件全路径. 486 | 487 | Args: 488 | hwnd:窗口句柄 489 | 490 | Returns: 491 | 返回字符串表示的是exe全路径名 492 | """ 493 | return self.op.GetWindowProcessPath(hwnd) 494 | 495 | def GetWindowRect(self, hwnd: int) -> tuple: 496 | """ 497 | 获取窗口在屏幕上的位置 498 | 499 | Args: 500 | hwnd:指定的窗口句柄 501 | 502 | Returns: 503 | (指定的窗口句柄,窗口左上角X坐标,窗口左上角Y坐标 窗口右下角X坐标,窗口右下角Y坐标) 504 | """ 505 | return self.op.GetWindowRect(self, hwnd, 1, 1, 1, 1) 506 | 507 | def GetWindowState(self, hwnd: int, flag: int) -> int: 508 | """ 509 | 获取指定窗口的一些属性 510 | 511 | Args: 512 | hwnd: 指定的窗口句柄 513 | flag: 取值定义如下: 514 | 0 : 判断窗口是否存在 515 | 1 : 判断窗口是否处于激活 516 | 2 : 判断窗口是否可见 517 | 3 : 判断窗口是否最小化 518 | 4 : 判断窗口是否最大化 519 | 5 : 判断窗口是否置顶 520 | 6 : 判断窗口是否无响应 521 | 7 : 判断窗口是否可用(灰色为不可用) 522 | 8 : 另外的方式判断窗口是否无响应,如果6无效可以尝试这个 523 | 524 | Returns: 525 | 0代表失败，1代表成功 526 | 527 | """ 528 | return self.op.GetWindowState(hwnd, 4) 529 | 530 | def GetWindowTitle(self, hwnd: int) -> str: 531 | """ 532 | 获取窗口的标题 533 | 534 | Args: 535 | hwnd:指定的窗口句柄 536 | 537 | Returns: 538 | 窗口的标题 539 | """ 540 | return self.op.GetWindowTitle(hwnd) 541 | 542 | def MoveWindow(self, hwnd: int, x: int, y: int) -> int: 543 | """ 544 | 移动指定窗口到指定位置 545 | 546 | Args: 547 | hwnd:指定的窗口句柄 548 | x:X坐标 549 | y:Y坐标 550 | 551 | Returns: 552 | 0代表失败，1代表成功 553 | """ 554 | return self.op.MoveWindow(hwnd, x, y) 555 | 556 | def ScreenToClient(self, hwnd: int) -> tuple: 557 | """ 558 | 把屏幕坐标转换为窗口坐标 559 | 560 | Args: 561 | hwnd:指定的窗口句柄 562 | 563 | Returns: 564 | 返回元组（指定的窗口句柄，屏幕X坐标，屏幕Y坐标） 565 | """ 566 | return self.op.ScreenToClient(hwnd, 1, 1) 567 | 568 | def SendPaste(self, hwnd: int) -> int: 569 | """ 570 | 向指定窗口发送粘贴命令. 把剪贴板的内容发送到目标窗口. 571 | 572 | Args: 573 | hwnd:指定的窗口句柄 574 | 575 | Returns: 576 | 0代表失败，1代表成功 577 | """ 578 | return self.op.SendPaste(hwnd) 579 | 580 | def SendString(self, hwnd: int, str: str) -> int: 581 | """ 582 | 向指定窗口发送文本数据 583 | 584 | Args: 585 | hwnd:指定的窗口句柄 586 | str:发送的文本数据 587 | 588 | Returns: 589 | 0代表失败，1代表成功 590 | """ 591 | return self.op.SendString(hwnd, str) 592 | 593 | def SendString2(self, hwnd: int, str: str) -> int: 594 | """ 595 | 向指定窗口发送文本数据 596 | 597 | Args: 598 | hwnd: 指定的窗口句柄 599 | str: 发送的文本数据 600 | 601 | Returns: 602 | 0代表失败，1代表成功 603 | 604 | 注: 此接口为老的SendString，如果新的SendString不能输入，可以尝试此接口. 605 | """ 606 | return self.op.SendString2(hwnd, str) 607 | 608 | def SetClientSize(self, hwnd: int, width: int, height: int) -> int: 609 | """ 610 | 设置窗口客户区域的宽度和高度 611 | 612 | Args: 613 | hwnd: 指定的窗口句柄 614 | width: 宽度 615 | height: 高度 616 | 617 | Returns: 618 | 0代表失败，1代表成功 619 | """ 620 | return self.op.SetClientSize(hwnd, width, height) 621 | 622 | def SetWindowSize(self, hwnd: int, width: int, height: int) -> int: 623 | """ 624 | 设置窗口的大小 625 | 626 | Args: 627 | hwnd: 指定的窗口句柄 628 | width: 宽度 629 | height: 高度 630 | 631 | Returns: 632 | 0代表失败，1代表成功 633 | """ 634 | return self.op.SetWindowSize(hwnd, width, height) 635 | 636 | def SetWindowState(self, hwnd: int, flag: int) -> int: 637 | """ 638 | 设置窗口的状态 639 | 640 | Args: 641 | hwnd: 指定的窗口句柄 642 | flag: 取值定义如下 643 | 0 : 关闭指定窗口 644 | 1 : 激活指定窗口 645 | 2 : 最小化指定窗口,但不激活 646 | 3 : 最小化指定窗口,并释放内存,但同时也会激活窗口. 647 | 4 : 最大化指定窗口,同时激活窗口. 648 | 5 : 恢复指定窗口 ,但不激活 649 | 6 : 隐藏指定窗口 650 | 7 : 显示指定窗口 651 | 8 : 置顶指定窗口 652 | 9 : 取消置顶指定窗口 653 | 10 : 禁止指定窗口 654 | 11 : 取消禁止指定窗口 655 | 12 : 恢复并激活指定窗口 656 | 13 : 强制结束窗口所在进程. 657 | 658 | Returns: 659 | 0代表失败，1代表成功 660 | """ 661 | return self.op.SetWindowState(hwnd, flag) 662 | 663 | def SetWindowText(self, hwnd: int, title: str) -> int: 664 | """ 665 | 设置窗口的标题 666 | 667 | Args: 668 | hwnd: 指定的窗口句柄 669 | title: 标题 670 | 671 | Returns: 672 | 0代表失败，1代表成功 673 | """ 674 | return self.op.SetWindowText(hwnd, title) 675 | 676 | def SetWindowTransparent(self, hwnd: int, trans: int) -> int: 677 | """ 678 | 设置窗口的透明度 679 | 680 | Args: 681 | hwnd: 指定的窗口句柄 682 | trans: 透明度取值(0-255) 越小透明度越大 0为完全透明(不可见) 255为完全显示(不透明) 683 | 684 | Returns: 685 | 0代表失败，1代表成功 686 | """ 687 | return self.op.SetWindowTransparent(hwnd, trans) 688 | 689 | """----------------------------------------基本设置------------------------------------------------""" 690 | 691 | def GetBasePath(self) -> str: 692 | """ 693 | 获取注册在系统中的dll的路径. 694 | 695 | Returns: 696 | 返回dll所在路径. 697 | """ 698 | return self.op.GetBasePath() 699 | 700 | def GetID(self) -> int: 701 | """ 702 | 返回当前对象的ID值，这个值对于每个对象是唯一存在的。可以用来判定两个对象是否一致. 703 | 704 | Returns: 705 | 当前对象的ID值. 706 | """ 707 | return self.op.GetID() 708 | 709 | def GetLastError(self) -> int: 710 | """ 711 | 获取插件命令的最后错误 712 | 713 | Returns: 714 | 返回值表示错误值。 0表示无错误. 715 | 716 | 注: 此函数必须紧跟上一句函数调用，中间任何的语句调用都会改变这个值. 717 | """ 718 | return self.op.GetLastError() 719 | 720 | def GetPath(self) -> str: 721 | """ 722 | 获取全局路径.(可用于调试) 723 | 724 | Returns: 725 | 以字符串的形式返回当前设置的全局路径 726 | """ 727 | return self.op.GetPath() 728 | 729 | def SetPath(self, path: str) -> int: 730 | """ 731 | 设置全局路径,设置了此路径后,所有接口调用中,相关的文件都相对于此路径. 比如图片,字库等. 732 | 733 | Args: 734 | path: 路径,可以是相对路径,也可以是绝对路径 735 | 736 | Returns: 737 | 0代表失败，1代表成功 738 | """ 739 | return self.op.GetPath(path) 740 | 741 | def SetShowErrorMsg(self, show: int) -> int: 742 | """ 743 | 设置是否弹出错误信息,默认是打开. 744 | 745 | Args: 746 | show: 0表示不打开,1表示打开. 747 | 748 | Returns: 749 | 0代表失败，1代表成功 750 | """ 751 | return self.op.SetShowErrorMsg(show) 752 | 753 | def ver(self) -> str: 754 | """ 755 | 返回当前插件版本号 756 | 757 | Returns: 758 | 当前插件的版本描述字符串 759 | """ 760 | return self.op.ver() 761 | 762 | def EnablePicCache(self, enable: int) -> int: 763 | """ 764 | 设置是否开启或者关闭插件内部的图片缓存机制. (默认是打开). 765 | 766 | Args: 767 | enable:0代表关闭，1代表打开 768 | 769 | Returns: 770 | 0代表失败，1代表成功 771 | 772 | 注: 有些时候，系统内存比较吃紧，这时候再打开内部缓存，可能会导致缓存分配在虚拟内存，这样频繁换页，反而导致图色效率下降.这时候就建议关闭图色缓存. 所有图色缓存机制都是对本对象的，也就是说，调用图色缓存机制的函数仅仅对本对象生效. 每个对象都有一个图色缓存队列. 773 | """ 774 | return self.op.EnablePicCache(enable) 775 | 776 | """----------------------------------------后台设置------------------------------------------------""" 777 | 778 | def BindWindow(self, hwnd: int, display: str, mouse: str, keypad: str, mode: int) -> int: 779 | """ 780 | 绑定指定的窗口,并指定这个窗口的屏幕颜色获取方式,鼠标仿真模式,键盘仿真模式,以及模式设定. 781 | Args: 782 | hwnd:指定的窗口句柄 783 | display:屏幕颜色获取方式 取值有以下几种: 784 | "normal" : 正常模式,平常我们用的前台截屏模式 785 | "gdi" : gdi模式,用于窗口采用GDI方式刷新时. 此模式占用CPU较大. 参考SetAero 786 | "dx" : dx模式,等同于dx.d3d9 787 | "dx.d3d9" dx模式，使用d3d9渲染 788 | "dx.d3d10" dx模式，使用d3d10渲染 789 | "dx.d3d11" dx模式，使用d3d11渲染 790 | "opengl" opengl模式，使用opengl渲染的窗口，支持最新版雷电模拟器，以及夜神6.1，支持最小化窗口截图 791 | "opengl.nox" opengl模式，针对最新夜神模拟器的渲染方式，测试中。。。 792 | mouse:鼠标仿真模式 取值有以下几种 793 | "normal" : 正常模式,平常我们用的前台鼠标模式 794 | "windows": Windows模式,采取模拟windows消息方式 同按键自带后台插件. 795 | keypad:键盘仿真模式 取值有以下几种 796 | "normal" : 正常模式,平常我们用的前台键盘模式 797 | "windows": Windows模式,采取模拟windows消息方式 同按键的后台插件 798 | mode:模式 799 | 800 | Returns: 801 | 0代表失败，1代表成功 802 | """ 803 | return self.op.BindWindow(hwnd, display, mouse, keypad, mode) 804 | 805 | def UnBindWindow(self) -> int: 806 | """ 807 | 解除绑定窗口,并释放系统资源.一般在OnScriptExit调用 808 | 809 | Returns: 810 | 0代表失败，1代表成功 811 | """ 812 | return self.op.UnBindWindow() 813 | 814 | """----------------------------------------Win API------------------------------------------------""" 815 | 816 | def RunApp(self, app_path: str, mode: int) -> int: 817 | """ 818 | 运行指定的应用程序. 819 | 820 | Args: 821 | app_path:指定的可执行程序全路径. 822 | mode:取值如下0:普通模式 1:加强模式 823 | 824 | Returns: 825 | 0代表失败，1代表成功 826 | """ 827 | return self.op.RunApp(app_path, mode) 828 | 829 | def WinExec(self, cmdline: str, cmdshow: int) -> str: 830 | """ 831 | 运行指定的应用程序. 832 | 833 | Args: 834 | cmdline: 指定的可执行程序全路径. 835 | cmdshow: 取值如下 0:隐藏 1:用最近的大小和位置显示, 激活 836 | 837 | Returns: 838 | 0代表失败，1代表成功 839 | """ 840 | return self.op.WinExec(cmdline, cmdshow) 841 | 842 | def GetCmdStr(self, cmdline: str, millseconds: int) -> str: 843 | """ 844 | 运行指定的应用程序. 845 | 846 | Args: 847 | cmdline:指定的可执行程序全路径. 848 | millseconds:等待的时间(毫秒) 849 | 850 | Returns: 851 | cmd输出的字符 852 | """ 853 | return self.op.GetCmdStr(cmdline, millseconds) 854 | 855 | """----------------------------------------鼠标键盘------------------------------------------------""" 856 | ''' 857 | key_str 虚拟键码 858 | "1", 49 859 | "2", 50 860 | "3", 51 861 | "4", 52 862 | "5", 53 863 | "6", 54 864 | "7", 55 865 | "8", 56 866 | "9", 57 867 | "0", 48 868 | "-", 189 869 | "=", 187 870 | "back", 8 871 | "a", 65 872 | "b", 66 873 | "c", 67 874 | "d", 68 875 | "e", 69 876 | "f", 70 877 | "g", 71 878 | "h", 72 879 | "i", 73 880 | "j", 74 881 | "k", 75 882 | "l", 76 883 | "m", 77 884 | "n", 78 885 | "o", 79 886 | "p", 80 887 | "q", 81 888 | "r", 82 889 | "s", 83 890 | "t", 84 891 | "u", 85 892 | "v", 86 893 | "w", 87 894 | "x", 88 895 | "y", 89 896 | "z", 90 897 | "ctrl", 17 898 | "alt", 18 899 | "shift", 16 900 | "win", 91 901 | "space", 32 902 | "cap", 20 903 | "tab", 9 904 | "~", 192 905 | "esc", 27 906 | "enter", 13 907 | "up", 38 908 | "down", 40 909 | "left", 37 910 | "right", 39 911 | "option", 93 912 | "print", 44 913 | "delete", 46 914 | "home", 36 915 | "end", 35 916 | "pgup", 33 917 | "pgdn", 34 918 | "f1", 112 919 | "f2", 113 920 | "f3", 114 921 | "f4", 115 922 | "f5", 116 923 | "f6", 117 924 | "f7", 118 925 | "f8", 119 926 | "f9", 120 927 | "f10", 121 928 | "f11", 122 929 | "f12", 123 930 | "[", 219 931 | "]", 221 932 | "\\", 220 933 | ";", 186 934 | "'", 222 935 | ",", 188 936 | ".", 190 937 | "/", 191 938 | ''' 939 | 940 | def GetCursorPos(self) -> tuple: 941 | """ 942 | 获取鼠标位置. 943 | 944 | Returns: 945 | (x,y) 946 | """ 947 | return self.op.GetCursorPos(1, 1) 948 | 949 | def GetKeyState(self, vk_code: int) -> int: 950 | """ 951 | 获取指定的按键状态.(前台信息,不是后台) 952 | 953 | Args: 954 | vk_code: 虚拟按键码 955 | 956 | Returns: 957 | 0代表失败，1代表成功 958 | """ 959 | return self.op.GetKeyState(vk_code) 960 | 961 | def KeyDown(self, vk_code: int) -> int: 962 | """ 963 | 按住指定的虚拟键码 964 | 965 | Args: 966 | vk_code: 虚拟按键码 967 | 968 | Returns: 969 | 0代表失败，1代表成功 970 | """ 971 | return self.op.KeyDown(vk_code) 972 | 973 | def KeyDownChar(self, key_str: str) -> int: 974 | """ 975 | 按住指定的虚拟键码 976 | 977 | Args: 978 | key_str: 符串描述的键码. 大小写无所谓. 点这里查看具体对应关系 979 | 980 | Returns: 981 | 0代表失败，1代表成功 982 | """ 983 | return self.op.KeyDownChar(key_str) 984 | 985 | def KeyPress(self, vk_code: int) -> int: 986 | """ 987 | 按下指定的虚拟键码 988 | 989 | Args: 990 | vk_code: 虚拟按键码 991 | 992 | Returns: 993 | 0代表失败，1代表成功 994 | """ 995 | return self.op.KeyPress(vk_code) 996 | 997 | def KeyPressChar(self, key_str: str) -> int: 998 | """ 999 | 按下指定的虚拟键码 1000 | 1001 | Args: 1002 | key_str: 字符串描述的键码. 大小写无所谓. 点这里查看具体对应关系 1003 | 1004 | Returns: 1005 | 0代表失败，1代表成功 1006 | """ 1007 | return self.op.KeyPressChar(key_str) 1008 | 1009 | def KeyUp(self, vk_code: int) -> int: 1010 | """ 1011 | 弹起来虚拟键vk_code 1012 | 1013 | Args: 1014 | vk_code: 虚拟按键码 1015 | 1016 | Returns: 1017 | 0代表失败，1代表成功 1018 | """ 1019 | return self.op.KeyUp(vk_code) 1020 | 1021 | def KeyUpChar(self, key_str: str) -> int: 1022 | """ 1023 | 弹起来虚拟键key_str 1024 | 1025 | Args: 1026 | key_str: 字符串描述的键码. 大小写无所谓. 点这里查看具体对应关系. 1027 | 1028 | Returns: 1029 | 0代表失败，1代表成功 1030 | """ 1031 | return self.op.KeyUpChar(key_str) 1032 | 1033 | def LeftClick(self) -> int: 1034 | """ 1035 | 按下鼠标左键 1036 | 1037 | Returns: 1038 | 0代表失败，1代表成功 1039 | """ 1040 | return self.op.LeftClick() 1041 | 1042 | def LeftDoubleClick(self) -> int: 1043 | """ 1044 | 双击鼠标左键 1045 | 1046 | Returns: 1047 | 0代表失败，1代表成功 1048 | """ 1049 | return self.op.LeftDoubleClick() 1050 | 1051 | def LeftDown(self) -> int: 1052 | """ 1053 | 按住鼠标左键 1054 | 1055 | Returns: 1056 | 0代表失败，1代表成功 1057 | """ 1058 | return self.op.LeftDown() 1059 | 1060 | def LeftUp(self) -> int: 1061 | """ 1062 | 弹起鼠标左键 1063 | 1064 | Returns: 1065 | 0代表失败，1代表成功 1066 | """ 1067 | return self.op.LeftUp() 1068 | 1069 | def MiddleClick(self) -> int: 1070 | """ 1071 | 按下鼠标中键 1072 | 1073 | Returns: 1074 | 0代表失败，1代表成功 1075 | """ 1076 | return self.op.MiddleClick() 1077 | 1078 | def MoveR(self, rx: int, ry: int) -> int: 1079 | """ 1080 | 鼠标相对于上次的位置移动rx,ry 1081 | 1082 | Args: 1083 | rx: 相对于上次的X偏移 1084 | ry: 相对于上次的Y偏移 1085 | 1086 | Returns: 1087 | 0代表失败，1代表成功 1088 | """ 1089 | return self.op.MoveR(rx, ry) 1090 | 1091 | def MoveTo(self, x: int, y: int) -> int: 1092 | """ 1093 | 把鼠标移动到目的点(x,y) 1094 | 1095 | Args: 1096 | x: X坐标 1097 | y: Y坐标 1098 | 1099 | Returns: 1100 | 0代表失败，1代表成功 1101 | """ 1102 | return self.op.MoveTo(x, y) 1103 | 1104 | def MoveToEx(self, x: int, y: int, w: int, h: int) -> str: 1105 | """ 1106 | 把鼠标移动到目的范围内的任意一点 1107 | 1108 | Args: 1109 | x:X坐标 1110 | y:Y坐标 1111 | w:宽度(从x计算起) 1112 | h:高度(从y计算起) 1113 | 1114 | Returns: 1115 | 返回要移动到的目标点. 格式为x,y. 比如MoveToEx 100,100,10,10,返回值可能是101,102 1116 | """ 1117 | return self.op.MoveToEx(x, y, w, h) 1118 | 1119 | def RightClick(self) -> int: 1120 | """ 1121 | 按下鼠标右键 1122 | 1123 | Returns: 1124 | 0代表失败，1代表成功 1125 | """ 1126 | return self.op.RightClick() 1127 | 1128 | def RightDown(self) -> int: 1129 | """ 1130 | 按住鼠标右键 1131 | 1132 | Returns: 1133 | 0代表失败，1代表成功 1134 | """ 1135 | return self.op.RightDown() 1136 | 1137 | def RightUp(self) -> int: 1138 | """ 1139 | 弹起鼠标右键 1140 | 1141 | Returns: 1142 | 0代表失败，1代表成功 1143 | """ 1144 | return self.op.RightUp() 1145 | 1146 | def WaitKey(self, vk_code: int, time_out: int) -> int: 1147 | """ 1148 | 等待指定的按键按下 (前台,不是后台) 1149 | 1150 | Args: 1151 | vk_code:虚拟按键码,当此值为0，表示等待任意按键。 鼠标左键是1,鼠标右键时2,鼠标中键是4 1152 | time_out:等待多久,单位毫秒. 如果是0，表示一直等待 1153 | 1154 | Returns: 1155 | 0:超时 1:指定的按键按下 (当vk_code不为0时) 按下的按键码:(当vk_code为0时) 1156 | """ 1157 | return self.op.WaitKey(vk_code, time_out) 1158 | 1159 | def WheelDown(self) -> int: 1160 | """ 1161 | 滚轮向下滚 1162 | 1163 | Returns: 1164 | 0代表失败，1代表成功 1165 | """ 1166 | return self.op.WheelDown() 1167 | 1168 | def WheelUp(self) -> int: 1169 | """ 1170 | 滚轮向上滚 1171 | 1172 | Returns: 1173 | 0代表失败，1代表成功 1174 | """ 1175 | return self.op.WheelUp() 1176 | 1177 | """----------------------------------------图色功能------------------------------------------------""" 1178 | 1179 | def Capture(self, x1: int, y1: int, x2: int, y2: int, file: str) -> int: 1180 | """ 1181 | 抓取指定区域(x1, y1, x2, y2)的图像,保存为file(24位位图) 1182 | 1183 | Args: 1184 | x1:区域的左上X坐标 1185 | y1:区域的左上Y坐标 1186 | x2:区域的右下X坐标 1187 | y2:区域的右下Y坐标 1188 | file:保存的文件名,保存的地方一般为SetPath中设置的目录,当然这里也可以指定全路径名. 1189 | 1190 | Returns: 1191 | 0代表失败，1代表成功 1192 | """ 1193 | return self.op.Capture(x1, y1, x2, y2, file) 1194 | 1195 | def CmpColor(self, x: int, y: int, color: str, sim: float) -> int: 1196 | """ 1197 | 比较指定坐标点(x,y)的颜色 1198 | 1199 | Args: 1200 | x: X坐标 1201 | y: Y坐标 1202 | color: 颜色字符串,可以支持偏色,多色,例如 "ffffff-202020|000000-000000" 这个表示白色偏色为202020,和黑色偏色为000000.颜色最多支持10种颜色组合. 注意，这里只支持RGB颜色. 1203 | sim:相似度(0.1-1.0) 1204 | 1205 | Returns: 1206 | 0: 颜色匹配 1: 颜色不匹配 1207 | """ 1208 | return self.op.CmpColor(x, y, color, sim) 1209 | 1210 | def FindColor(self, x1: int, y1: int, x2: int, y2: int, color: str, sim: float, dir: int) -> tuple: 1211 | """ 1212 | 查找指定区域内的颜色,颜色格式"RRGGBB-DRDGDB",注意,和按键的颜色格式相反 1213 | 1214 | Args: 1215 | x1:区域的左上X坐标 1216 | y1:区域的左上Y坐标 1217 | x2:区域的右下X坐标 1218 | y2:区域的右下Y坐标 1219 | color:颜色 格式为"RRGGBB-DRDGDB",比如"123456-000000|aabbcc-202020".注意，这里只支持RGB颜色. 1220 | sim:相似度,取值范围0.1-1.0 1221 | dir:查找方向 0: 从左到右,从上到下 1: 从左到右,从下到上 2: 从右到左,从上到下 3: 从右到左,从下到上 4：从中心往外查找 5: 从上到下,从左到右 6: 从上到下,从右到左 7: 从下到上,从左到右 8: 从下到上,从右到左 1222 | 1223 | Returns: 1224 | (x1, y1, x2, y2, color, sim, dir,返回X坐标,返回Y坐标) 1225 | """ 1226 | return self.op.FindColor(x1, y1, x2, y2, color, sim, dir, 1, 1) 1227 | 1228 | def FindColorEx(self, x1: int, y1: int, x2: int, y2: int, color: str, sim: float, dir: int) -> str: 1229 | """ 1230 | 查找指定区域内的所有颜色,颜色格式"RRGGBB-DRDGDB",注意,和按键的颜色格式相反 1231 | 1232 | Args: 1233 | x1:区域的左上X坐标 1234 | y1:区域的左上Y坐标 1235 | x2:区域的右下X坐标 1236 | y2:区域的右下Y坐标 1237 | color:颜色 格式为"RRGGBB-DRDGDB",比如"123456-000000|aabbcc-202020".注意，这里只支持RGB颜色. 1238 | sim:相似度,取值范围0.1-1.0 1239 | dir:查找方向 0: 从左到右,从上到下 1: 从左到右,从下到上 2: 从右到左,从上到下 3: 从右到左,从下到上 4：从中心往外查找 5: 从上到下,从左到右 6: 从上到下,从右到左 7: 从下到上,从左到右 8: 从下到上,从右到左 1240 | 1241 | Returns: 1242 | 返回所有颜色信息的坐标值,然后通过GetResultCount等接口来解析 (由于内存限制,返回的颜色数量最多为1800个左右) 1243 | """ 1244 | return self.op.FindColorEx(x1, y1, x2, y2, color, sim, dir) 1245 | 1246 | def FindMultiColor(self, x1: int, y1: int, x2: int, y2: int, first_color: str, offset_color: str, sim: float, 1247 | dir: int) -> tuple: 1248 | """ 1249 | 根据指定的多点查找颜色坐标 1250 | 1251 | Args: 1252 | x1:区域的左上X坐标 1253 | y1:区域的左上Y坐标 1254 | x2:区域的右下X坐标 1255 | y2:区域的右下Y坐标 1256 | first_color:颜色格式为"RRGGBB-DRDGDB|RRGGBB-DRDGDB|…………",比如"123456-000000"这里的含义和按键自带Color插件的意义相同，只不过我的可以支持偏色和多种颜色组合.所有的偏移色坐标都相对于此颜色.注意，这里只支持RGB颜色. 1257 | offset_color:偏移颜色可以支持任意多个点 格式和按键自带的Color插件意义相同, 只不过我的可以支持偏色和多种颜色组合,格式为"x1|y1|RRGGBB-DRDGDB|RRGGBB-DRDGDB……,……xn|yn|RRGGBB-DRDGDB|RRGGBB-DRDGDB……" 1258 | 比如"1|3|aabbcc|aaffaa-101010,-5|-3|123456-000000|454545-303030|565656"等任意组合都可以，支持偏色还可以支持反色模式，比如"1|3|-aabbcc|-334455-101010,-5|-3|-123456-000000|-353535|454545-101010","-"表示除了指定颜色之外的颜色. 1259 | sim:相似度,取值范围0.1-1.0 1260 | dir:查找方向 0: 从左到右,从上到下 1: 从左到右,从下到上 2: 从右到左,从上到下 3: 从右到左, 从下到上 1261 | 1262 | Returns: 1263 | (x1, y1, x2, y2,first_color,offset_color,sim, dir,返回的X坐标,返回的Y坐标) 坐标是first_color所在的坐标 1264 | 1265 | """ 1266 | return self.op.FindMultiColor(x1, y1, x2, y2, first_color, offset_color, sim, dir, 1, 1) 1267 | 1268 | def FindMultiColorEx(self, x1: int, y1: int, x2: int, y2: int, first_color: str, offset_color: str, sim: float, 1269 | dir: int) -> str: 1270 | """ 1271 | 查找指定区域内的所有颜色,颜色格式"RRGGBB-DRDGDB",注意,和按键的颜色格式相反 1272 | 1273 | Args: 1274 | x1:区域的左上X坐标 1275 | y1:区域的左上Y坐标 1276 | x2:区域的右下X坐标 1277 | y2:区域的右下Y坐标 1278 | first_color:颜色格式为"RRGGBB-DRDGDB|RRGGBB-DRDGDB|…………",比如"123456-000000"这里的含义和按键自带Color插件的意义相同，只不过我的可以支持偏色和多种颜色组合.所有的偏移色坐标都相对于此颜色.注意，这里只支持RGB颜色. 1279 | offset_color:偏移颜色可以支持任意多个点 格式和按键自带的Color插件意义相同, 只不过我的可以支持偏色和多种颜色组合,格式为"x1|y1|RRGGBB-DRDGDB|RRGGBB-DRDGDB……,……xn|yn|RRGGBB-DRDGDB|RRGGBB-DRDGDB……" 1280 | 比如"1|3|aabbcc|aaffaa-101010,-5|-3|123456-000000|454545-303030|565656"等任意组合都可以，支持偏色还可以支持反色模式，比如"1|3|-aabbcc|-334455-101010,-5|-3|-123456-000000|-353535|454545-101010","-"表示除了指定颜色之外的颜色. 1281 | sim:相似度,取值范围0.1-1.0 1282 | dir:查找方向 0: 从左到右,从上到下 1: 从左到右,从下到上 2: 从右到左,从上到下 3: 从右到左, 从下到上 1283 | 1284 | 1285 | Returns: 1286 | 返回所有颜色信息的坐标值,然后通过GetResultCount等接口来解析(由于内存限制,返回的坐标数量最多为1800个左右)坐标是first_color所在的坐标 1287 | """ 1288 | return self.op.FindMultiColorEx(x1, y1, x2, y2, first_color, offset_color, sim, dir) 1289 | 1290 | def FindPic(self, x1: int, y1: int, x2: int, y2: int, pic_name: str, delta_color: str, sim: float, 1291 | dir: int) -> tuple: 1292 | """ 1293 | 查找指定区域内的图片,位图必须是24位色格式,支持透明色,当图像上下左右4个顶点的颜色一样时,则这个颜色将作为透明色处理. 1294 | 1295 | Args: 1296 | x1:区域的左上X坐标 1297 | y1:区域的左上Y坐标 1298 | x2:区域的右下X坐标 1299 | y2:区域的右下Y坐标 1300 | pic_name:图片名,可以是多个图片,比如"test.bmp|test2.bmp|test3.bmp" 1301 | delta_color:颜色色偏比如"203040" 表示RGB的色偏分别是20 30 40 (这里是16进制表示) 1302 | sim:相似度,取值范围0.1-1.0 1303 | dir:查找方向 0: 从左到右,从上到下 1: 从左到右,从下到上 2: 从右到左,从上到下 3: 从右到左, 从下到上 1304 | 1305 | Returns: 1306 | (x1, y1, x2, y2, pic_name, delta_color,sim, dir,图片左上角的X坐标, 图片左上角的Y坐标) 1307 | """ 1308 | return self.op.FindPic(x1, y1, x2, y2, pic_name, delta_color, sim, dir, 1, 1) 1309 | 1310 | def FindPicEx(self, x1: int, y1: int, x2: int, y2: int, pic_name: str, delta_color: str, sim: float, 1311 | dir: int) -> str: 1312 | """ 1313 | 查找指定区域内的图片,位图必须是24位色格式,支持透明色,当图像上下左右4个顶点的颜色一样时,则这个颜色将作为透明色处理.这个函数可以查找多个图片,并且返回所有找到的图像的坐标. 1314 | 1315 | Args: 1316 | x1:区域的左上X坐标 1317 | y1:区域的左上Y坐标 1318 | x2:区域的右下X坐标 1319 | y2:区域的右下Y坐标 1320 | pic_name:图片名,可以是多个图片,比如"test.bmp|test2.bmp|test3.bmp" 1321 | delta_color:颜色色偏比如"203040" 表示RGB的色偏分别是20 30 40 (这里是16进制表示) 1322 | sim:相似度,取值范围0.1-1.0 1323 | dir:查找方向 0: 从左到右,从上到下 1: 从左到右,从下到上 2: 从右到左,从上到下 3: 从右到左, 从下到上 1324 | 1325 | Returns: 1326 | 返回的是所有找到的坐标格式如下"id,x,y|id,x,y..|id,x,y" (图片左上角的坐标)比如"0,100,20|2,30,40" 表示找到了两个,第一个,对应的图片是图像序号为0的图片,坐标是(100,20),第二个是序号为2的图片,坐标(30,40) (由于内存限制,返回的图片数量最多为1500个左右) 1327 | """ 1328 | 1329 | return self.op.FindPicEx(x1, y1, x2, y2, pic_name, delta_color, sim, dir) 1330 | 1331 | def GetColor(self, x: int, y: int) -> str: 1332 | """ 1333 | 获取(x,y)的颜色,颜色返回格式"RRGGBB",注意,和按键的颜色格式相反 1334 | 1335 | Args: 1336 | x:X坐标 1337 | y:Y坐标 1338 | Returns: 1339 | 颜色字符串(注意这里都是小写字符，和工具相匹配) 1340 | """ 1341 | return self.op.GetColor(x, y) 1342 | 1343 | def CapturePre(self, file: str) -> int: 1344 | """ 1345 | 抓取上次操作的图色区域，保存为file(32位位图) 1346 | 1347 | Args: 1348 | file:保存的文件名,保存的地方一般为SetPath中设置的目录,当然这里也可以指定全路径名. 1349 | 1350 | Returns: 1351 | 0代表失败 1代表成功 1352 | 1353 | 注意，要开启此函数，必须先调用EnableDisplayDebug 任何图色或者文字识别函数，都可以通过这个来截取. 1354 | 1355 | """ 1356 | return self.op.CapturePre(file) 1357 | 1358 | def EnableDisplayDebug(self, enable_debug: int) -> int: 1359 | """ 1360 | 开启图色调试模式，此模式会稍许降低图色和文字识别的速度.默认不开启. 1361 | 1362 | Args: 1363 | enable_debug:0为关闭 1为开启 1364 | 1365 | Returns: 1366 | 0代表失败 1代表成功 1367 | 1368 | """ 1369 | return self.op.EnableDisplayDebug(enable_debug) 1370 | 1371 | def GetScreenData(self, x1: int, y1: int, x2: int, y2: int) -> int: 1372 | """ 1373 | 获取指定区域的图像,用二进制数据的方式返回,（不适合按键使用）方便二次开发. 1374 | 1375 | Args: 1376 | x1:区域的左上X坐标 1377 | y1:区域的左上Y坐标 1378 | x2:区域的右下X坐标 1379 | y2:区域的右下Y坐标 1380 | 1381 | Returns: 1382 | 返回的是指定区域的二进制颜色数据地址,每个颜色是4个字节,表示方式为(BBGGRR00) 1383 | 1384 | 注意,调用完此接口后，返回的数据指针在当前op对象销毁时，或者再次调用GetScreenData时，会自动释放. 1385 | 1386 | """ 1387 | return self.op.GetScreenData(x1, y1, x2, y2) 1388 | 1389 | def GetScreenDataBmp(self, x1: int, y1: int, x2: int, y2: int) -> tuple: 1390 | """ 1391 | 获取指定区域的图像,用24位位图的数据格式返回,方便二次开发.（或者可以配合SetDisplayInput的mem模式） 1392 | 1393 | Args: 1394 | x1:区域的左上X坐标 1395 | y1:区域的左上Y坐标 1396 | x2:区域的右下X坐标 1397 | y2:区域的右下Y坐标 1398 | 1399 | Returns: 1400 | (x1,y1,x2,y2,返回图片的数据,返回图片的数据长度) 1401 | """ 1402 | return self.op.GetScreenDataBmp(x1, y1, x2, y2, 1, 1) 1403 | 1404 | def SetDisplayInput(self, mode: str) -> int: 1405 | """ 1406 | 设定图色的获取方式，默认是显示器或者后台窗口(具体参考BindWindow) 1407 | 1408 | Args: 1409 | mode:图色输入模式取值有以下几种 1410 | "screen" 这个是默认的模式，表示使用显示器或者后台窗口 1411 | "pic:file" 指定输入模式为指定的图片,如果使用了这个模式，则所有和图色相关的函数均视为对此图片进行处理，比如文字识别查找图片 颜色 等等一切图色函数.需要注意的是，设定以后，此图片就已经加入了缓冲，如果更改了源图片内容，那么需要 释放此缓冲，重新设置. 1412 | "mem:addr" 指定输入模式为指定的图片,此图片在内存当中. addr为图像内存地址,一般是GetScreenDataBmp的返回值（前54字节为位图信息，后面的是像素数据），注意与大漠的区别.如果使用了这个模式，则所有和图色相关的函数,均视为对此图片进行处理.比如文字识别 查找图片 颜色 等等一切图色函数所有坐标都相对此图片，如果不想受到影响，调用GetScreenDataBmp时应时整个窗口的大小. 1413 | 1414 | Returns: 1415 | 0代表失败 1代表成功 1416 | """ 1417 | return self.op.SetDisplayInput(mode) 1418 | 1419 | """----------------------------------------常用算法------------------------------------------------""" 1420 | 1421 | def AStarFindPath(self, mapWidth: int, mapHeight: int, disable_points: str, beginX: int, beginY: int, endX: int, 1422 | endY: int) -> int: 1423 | """ 1424 | A星算法 1425 | 1426 | Args: 1427 | mapWidth:区域的左上X坐标 1428 | mapHeight:区域的左上Y坐标 1429 | disable_points:不可通行的坐标，以"|"分割，例如:"10,15|20,30" 1430 | beginX:源坐标X 1431 | beginY:源坐标Y 1432 | endX:目的坐标X 1433 | endY:目的坐标Y 1434 | 1435 | Returns: 1436 | 0代表失败 1代表成功 1437 | """ 1438 | return self.op.AStarFindPath(mapWidth, mapHeight, disable_points, beginX, beginY, endX, endY) 1439 | 1440 | """----------------------------------------文字识别------------------------------------------------""" 1441 | 1442 | def FindStr(self, x1: int, y1: int, x2: int, y2: int, string_: str, color_format: str, sim: float) -> tuple: 1443 | """ 1444 | 在屏幕范围(x1,y1,x2,y2)内,查找string(可以是任意个字符串的组合),并返回符合color_format的坐标位置,相似度sim同Ocr接口描述.(多色,差色查找类似于Ocr接口,不再重述) 1445 | 1446 | Args: 1447 | x1:区域的左上X坐标 1448 | y1::区域的左上Y坐标 1449 | x2:区域的右下X坐标 1450 | y2:区域的右下Y坐标 1451 | string_:待查找的字符串,可以是字符串组合，比如"长安|洛阳|大雁塔",中间用"|"来分割字符串 1452 | color_format:颜色格式串, 可以包含换行分隔符,语法是","后加分割字符串. 具体可以查看下面的示例 .注意，RGB和HSV格式都支持 1453 | sim:双精度浮点数:相似度,取值范围0.1-1.0 1454 | 1455 | Returns: 1456 | (x1,y1,x2,y2,string_,color_format,sim,返回X坐标没找到返回-1,返回Y坐标没找到返回-1) 1457 | 1458 | 示例: 1459 | 1460 | op_ret = op.FindStr(0,0,2000,2000,"长安","9f2e3f-000000",1.0,intX,intY) 1461 | If intX >= 0 and intY >= 0 Then 1462 | op.MoveTo intX,intY 1463 | End If 1464 | 1465 | op_ret = op.FindStr(0,0,2000,2000,"长安|洛阳","9f2e3f-000000",1.0,intX,intY) 1466 | If intX >= 0 and intY >= 0 Then 1467 | op.MoveTo intX,intY 1468 | End If 1469 | 1470 | // 查找时,对多行文本进行换行,换行分隔符是"|". 语法是在","后增加换行字符串.任意字符串都可以. 1471 | op_ret = op.FindStr(0,0,2000,2000,"长安|洛阳","9f2e3f-000000,|",1.0,intX,intY) 1472 | If intX >= 0 and intY >= 0 Then 1473 | op.MoveTo intX,intY 1474 | End If 1475 | 注: 此函数的原理是先Ocr识别，然后再查找。 1476 | 1477 | """ 1478 | return self.op.FindStr(x1, y1, x2, y2, string_, color_format, sim, 1, 1) 1479 | 1480 | def FindStrEx(self, x1: int, y1: int, x2: int, y2: int, string_: str, color_format: str, sim: float) -> str: 1481 | """ 1482 | 在屏幕范围(x1,y1,x2,y2)内,查找string(可以是任意个字符串的组合),并返回符合color_format的坐标位置,相似度sim同Ocr接口描述.(多色,差色查找类似于Ocr接口,不再重述) 1483 | 1484 | Args: 1485 | x1:区域的左上X坐标 1486 | y1::区域的左上Y坐标 1487 | x2:区域的右下X坐标 1488 | y2:区域的右下Y坐标 1489 | string_:待查找的字符串,可以是字符串组合，比如"长安|洛阳|大雁塔",中间用"|"来分割字符串 1490 | color_format:颜色格式串, 可以包含换行分隔符,语法是","后加分割字符串. 具体可以查看下面的示例 .注意，RGB和HSV格式都支持 1491 | sim:双精度浮点数:相似度,取值范围0.1-1.0 1492 | 1493 | Returns: 1494 | 返回所有找到的坐标集合,格式如下: "id,x0,y0|id,x1,y1|......|id,xn,yn" 比如"0,100,20|2,30,40" 表示找到了两个,第一个,对应的是序号为0的字符串,坐标是(100,20),第二个是序号为2的字符串,坐标(30,40) 1495 | 1496 | 示例: 1497 | 1498 | op_ret = op.FindStrEx(0,0,2000,2000,"长安|洛阳","9f2e3f-000000",1.0) 1499 | If len(op_ret) > 0 Then 1500 | ss = split(op_ret,"|") 1501 | index = 0 1502 | count = UBound(ss) + 1 1503 | Do While index < count 1504 | TracePrint ss(index) 1505 | sss = split(ss(index),",") 1506 | id = int(sss(0)) 1507 | x = int(sss(1)) 1508 | y = int(sss(2)) 1509 | op.MoveTo x,y 1510 | Delay 1000 1511 | index = index+1 1512 | Loop 1513 | End If 1514 | 注: 此函数的原理是先Ocr识别，然后再查找。 1515 | 1516 | """ 1517 | return self.op.FindStrEx(x1, y1, x2, y2, string_, color_format, sim) 1518 | 1519 | def Ocr(self, x1: int, y1: int, x2: int, y2: int, color_format: str, sim: float) -> str: 1520 | """ 1521 | 识别屏幕范围(x1,y1,x2,y2)内符合color_format的字符串,并且相似度为sim,sim取值范围(0.1-1.0),这个值越大越精确,越大速度越快,越小速度越慢,请斟酌使用! 1522 | 1523 | Args: 1524 | x1:区域的左上X坐标 1525 | y1:区域的左上Y坐标 1526 | x2:区域的右下X坐标 1527 | y2:区域的右下Y坐标 1528 | color_format:区域的右下Y坐标 1529 | sim:双精度浮点数:相似度,取值范围0.1-1.0 1530 | 1531 | Returns: 1532 | 返回识别到的字符串 1533 | 1534 | 示例: 1535 | 1536 | //RGB单色识别 1537 | s = op.Ocr(0,0,2000,2000,"9f2e3f-000000",1.0) 1538 | MessageBox s 1539 | 1540 | //RGB单色差色识别 1541 | s = op.Ocr(0,0,2000,2000,"9f2e3f-030303",1.0) 1542 | MessageBox s 1543 | 1544 | //RGB多色识别(最多支持10种,每种颜色用"|"分割) 1545 | s = op.Ocr(0,0,2000,2000,"9f2e3f-030303|2d3f2f-000000|3f9e4d-100000",1.0) 1546 | MessageBox s 1547 | 1548 | """ 1549 | return self.op.Ocr(x1, y1, x2, y2, color_format, sim) 1550 | 1551 | def OcrEx(self, x1: int, y1: int, x2: int, y2: int, color_format: str, sim: float) -> str: 1552 | """ 1553 | 识别屏幕范围(x1,y1,x2,y2)内符合color_format的字符串,并且相似度为sim,sim取值范围(0.1-1.0),这个值越大越精确,越大速度越快,越小速度越慢,请斟酌使用!这个函数可以返回识别到的字符串，以及每个字符的坐标. 1554 | 1555 | Args: 1556 | x1:区域的左上X坐标 1557 | y1:区域的左上Y坐标 1558 | x2:区域的右下X坐标 1559 | y2:区域的右下Y坐标 1560 | color_format:区域的右下Y坐标 1561 | sim:双精度浮点数:相似度,取值范围0.1-1.0 1562 | 1563 | Returns: 1564 | 返回识别到的字符串 格式如 "字符0$x0$y0|…|字符n$xn$yn" 1565 | """ 1566 | return self.op.OcrEx(x1, y1, x2, y2, color_format, sim) 1567 | 1568 | def SetDict(self, index: int, file: str) -> int: 1569 | """ 1570 | 设置字库文件 1571 | 1572 | Args: 1573 | index:字库的序号,取值为0-19,目前最多支持20个字库 1574 | file:字库文件名 1575 | 1576 | Returns: 1577 | 0代表失败 1代表成功 1578 | """ 1579 | return self.op.SetDict(index, file) 1580 | 1581 | def UseDict(self, index: int) -> int: 1582 | """ 1583 | 表示使用哪个字库文件进行识别(index范围:0-9)设置之后，永久生效，除非再次设定 1584 | 1585 | Args: 1586 | index:字库编号(0-9) 1587 | 1588 | Returns: 1589 | 0代表失败 1代表成功 1590 | """ 1591 | return self.op.UseDict(index) 1592 | 1593 | def OcrAuto(self, x1: int, y1: int, x2: int, y2: int, sim: float) -> str: 1594 | """ 1595 | 识别屏幕范围(x1,y1,x2,y2)内的字符串,自动二值化，而无需指定颜色,适用于字体颜色和背景相差较大的场合 1596 | 1597 | Args: 1598 | x1:区域的左上X坐标 1599 | y1:区域的左上Y坐标 1600 | x2:区域的右下X坐标 1601 | y2:区域的右下Y坐标 1602 | sim:相似度,取值范围0.1-1.0 1603 | 1604 | Returns: 1605 | 返回识别到的字符串 1606 | """ 1607 | return self.op.OcrAuto(x1, y1, x2, y2, sim) 1608 | 1609 | def OcrFromFile(self, file_name: str, color_format: str, sim: float) -> str: 1610 | """ 1611 | 1612 | Args: 1613 | file_name:文件名 1614 | color_format:颜色格式串 1615 | sim:相似度,取值范围0.1-1.0 1616 | 1617 | Returns: 1618 | 返回识别到的字符串 1619 | """ 1620 | return self.op.OcrFromFile(file_name, color_format, sim) 1621 | 1622 | def OcrAutoFromFile(self, file_name: str, sim: float) -> str: 1623 | """ 1624 | 1625 | Args: 1626 | file_name:文件名 1627 | sim:相似度,取值范围0.1-1.0 1628 | 1629 | Returns: 1630 | 返回识别到的字符串 1631 | """ 1632 | return self.op.OcrAutoFromFile(file_name, sim) 1633 | 1634 | """----------------------------------------系统设置------------------------------------------------""" 1635 | 1636 | # def Beep(self, duration: int = 1000, f: int = 800) -> int: 1637 | # """ 1638 | # 蜂鸣器 1639 | # 1640 | # Args: 1641 | # duration:时长(ms) 1642 | # f: 频率 1643 | # 1644 | # Returns: 1645 | # 0代表失败，1代表成功 1646 | # """ 1647 | # return self.op.Beep(f, duration) 1648 | # 1649 | # def ExitOs(self, _type: int) -> int: 1650 | # """ 1651 | # 退出系统(注销 重启 关机) 1652 | # 1653 | # Args: 1654 | # _type: 取值为以下类型 0 : 注销系统 1 : 关机 2 : 重新启动 1655 | # 1656 | # Returns: 1657 | # 0代表失败，1代表成功 1658 | # 1659 | # """ 1660 | # return self.op.ExitOs(_type) 1661 | # 1662 | # def GetClipboard(self) -> str: 1663 | # """ 1664 | # 获取剪贴板的内容 1665 | # 1666 | # Returns: 1667 | # 以字符串表示的剪贴板内容 1668 | # """ 1669 | # return self.op.GetClipboard() 1670 | # 1671 | # def GetMachineCode(self) -> str: 1672 | # """ 1673 | # 获取本机的机器码.(带网卡). 此机器码用于插件网站后台. 要求调用进程必须有管理员权限. 否则返回空串. 1674 | # 1675 | # Returns: 1676 | # 字符串:字符串表达的机器机器码 1677 | # 1678 | # 注: 此机器码包含的硬件设备有硬盘,显卡,网卡等. 其它不便透露. 重装系统不会改变此值. 1679 | # 另要注意,插拔任何USB设备,(U盘，U盾,USB移动硬盘,USB键鼠等),以及安装任何网卡驱动程序,(开启或者关闭无线网卡等)都会导致机器码改变. 1680 | # 1681 | # """ 1682 | # return self.op.GetMachineCode() 1683 | # 1684 | # def GetDiskSerial(self) -> str: 1685 | # """ 1686 | # 获取本机的硬盘序列号.支持ide scsi硬盘. 要求调用进程必须有管理员权限. 否则返回空串. 1687 | # 1688 | # Returns: 1689 | # 字符串表达的硬盘序列号 1690 | # 1691 | # """ 1692 | # return self.op.GetDiskSerial() 1693 | # 1694 | # def GetMachineCodeNoMac(self) -> str: 1695 | # """ 1696 | # 获取本机的机器码.(不带网卡) 要求调用进程必须有管理员权限. 否则返回空串. 1697 | # 1698 | # Returns: 1699 | # 字符串表达的机器机器码 1700 | # 1701 | # 注: 此机器码包含的硬件设备有硬盘,显卡,网卡等. 其它不便透露. 重装系统不会改变此值. 1702 | # 另要注意,插拔任何USB设备,(U盘，U盾,USB移动硬盘,USB键鼠等),以及安装任何网卡驱动程序,(开启或者关闭无线网卡等)都会导致机器码改变. 1703 | # 1704 | # """ 1705 | # return self.op.GetMachineCodeNoMac() 1706 | # 1707 | # def GetScreenHeight(self) -> int: 1708 | # """ 1709 | # 获取屏幕的高度. 1710 | # 1711 | # Returns: 1712 | # 返回屏幕的高度 1713 | # """ 1714 | # return self.op.GetScreenHeight() 1715 | # 1716 | # def GetScreenWidth(self) -> int: 1717 | # """ 1718 | # 获取屏幕的宽度. 1719 | # 1720 | # Returns: 1721 | # 返回屏幕的宽度 1722 | # """ 1723 | # return self.op.GetScreenWidth() 1724 | # 1725 | # def GetTime(self) -> int: 1726 | # """ 1727 | # 获取当前系统从开机到现在所经历过的时间，单位是毫秒 1728 | # 1729 | # Returns: 1730 | # 时间(单位毫秒) 1731 | # """ 1732 | # return self.op.GetTime() 1733 | # 1734 | # def SetClipboard(self, value: str) -> int: 1735 | # """ 1736 | # 设置剪贴板的内容 1737 | # 1738 | # Args: 1739 | # value: 以字符串表示的剪贴板内容 1740 | # 1741 | # Returns: 1742 | # 0代表失败，1代表成功 1743 | # """ 1744 | # return self.op.SetClipboard(value) 1745 | -------------------------------------------------------------------------------- /pyopdll/op_x64.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Gaoyongxian666/pyopdll/eff817d0f8d97367b9915ca773a48273d5318d53/pyopdll/op_x64.dll -------------------------------------------------------------------------------- /pyopdll/op_x86.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Gaoyongxian666/pyopdll/eff817d0f8d97367b9915ca773a48273d5318d53/pyopdll/op_x86.dll -------------------------------------------------------------------------------- /setup.py: -------------------------------------------------------------------------------- 1 | import setuptools 2 | 3 | with open("README.md", "r", encoding="utf-8") as fh: 4 | long_description = fh.read() 5 | 6 | setuptools.setup( 7 | name="pyopdll", 8 | version="0.0.1", 9 | author="Gaoyongxian666", 10 | author_email="g1695698547@163.com", 11 | description="OP插件的Python接口", 12 | long_description=long_description, 13 | long_description_content_type="text/markdown", 14 | url="https://github.com/Gaoyongxian666/pyopdll", 15 | packages=setuptools.find_packages(), 16 | classifiers=[ 17 | "Programming Language :: Python :: 3", 18 | "License :: OSI Approved :: MIT License", 19 | "Operating System :: OS Independent", 20 | ], 21 | install_requires=["pywin32"], 22 | include_package_data=True, 23 | package_data={'pyopdll': ["op_x64.dll","op_x86.dll"]}, 24 | project_urls={ 25 | 'Bug Reports': 'https://github.com/Gaoyongxian666/pyopdll', 26 | 'Source': 'https://github.com/Gaoyongxian666/pyopdll', 27 | }, 28 | ) 29 | 30 | # 笔记1：mkdocs.yml和项目同级在根目录，保证/docs/低一级就可以 31 | # 在readthedocs网站上mkdocstrings安装，你提供requirements.txt就好 32 | # 生成site文件夹，没有太大用 33 | # Linux不允许导入pywin32，可以用try 34 | 35 | # 笔记2：package_data={'pydmdll': ["dm.dll"]},包名可不是随便写的 36 | # python setup.py sdist bdist_wheel 37 | # twine upload dist/* 38 | 39 | # 笔记3:最好状态是去掉mkdocstrings插件,直接用md文件 40 | --------------------------------------------------------------------------------