i道i的鼠标键盘小工具，拥有鼠标操作，键盘操作，键盘鼠标录制，录制文件编辑的功能，现在正在测试阶段，欢迎试用与反馈bug。

下载链接：i道i的鼠标键盘小工具.exe

代码如下：（上千行粘贴到csdn挺容易卡死的）

这个没有分类整理，不过都有注释，能看，等测试完了或许会整理一下（或许)

import time  # 记录时间和线程睡眠用
import pickle  # 保存变量用
import tkinter as tk  # gui用
import tkinter.messagebox  # 弹出来的对话框
import tkinter.filedialog  # 文件相关窗口
from tkinter import ttk  # 仅仅用到了下拉列表
from pynput import mouse  # 鼠标操作
from pynput import keyboard  # 键盘操作
from pynput.mouse import Controller, Button
from threading import Thread  # 进程# 避免玩脱的关闭程序，没得说，就一直监听，一旦遇到设定的键了，赶紧关窗口
# 也兼职监听停止所有功能的操作
def Close_Program():def on_press(key):  # 碰到按键就记录处理global close_program, stop_all_keynow_key.add(key)  # 当前按下的键进入集合be_tap = 1  # 存在标记be_t = 1for i in close_program:  # 关闭程序任何一个开始按键if not i in now_key:  # 没有按下be_tap = 0  # 不存在，不允许breakif be_tap:  # 检测到所有开始按键/触发键main_window.destroy()for i in stop_all_key:if not i in now_key:  # 没有按下be_t = 0  # 不存在，不允许breakif be_t:  # 停止所有操作for i in range(1, len(gui_mouse)):Mouse_Gui_Stop(gui_mouse[i])for i in range(1, len(gui_fingerboard)):Fingerboard_Gui_Stop(gui_fingerboard[i])for i in range(1, len(gui_transcribe)):Transcribe_Gui_Stop(gui_transcribe[i])def on_release(key):now_key.discard(key)global main_window, stop_listener, gui_mouse, gui_fingerboard, gui_transcribenow_key = set()stop_listener = keyboard.Listener(on_press=on_press, on_release=on_release)stop_listener.start()# 对于文件，我们可以选择保存所有的gui，打开的时候直接替换gui即可，方便省事，bug少，缺点就是保存文件体积大，
# 或者，写一个保存文件函数和一个打开文件函数，提取gui里的关键信息，比如选项变量，按钮的值之类的，打开时再根据这些变量来更改gui的值，
#
# 打开文件函数
def Open_File():def Key_Str(b):b['text'] = ''if b.key is None:b['text'] = 'None'returnfor i in b.key:b['text'] = b['text'] + str(i) + '+'b['text'] = b['text'][0:-1]file_path = tk.filedialog.askopenfilename()  # 选择打开什么文件，返回文件名if file_path.strip() != '':  # 是空的时候，往往没有选择，直接关闭窗口global gui_mouse, gui_fingerboard, gui_transcribe, close_program, stop_all_keytry:file = open(file_path, 'rb')data = pickle.load(file)  # 数据取出来if not ('name' in data) or data['name'] != 'i道i的鼠标键盘小工具':tk.messagebox.showwarning(title='警告！', message='文件错误，非本程序所需文件')file.close()returnfile.close()except:tk.messagebox.showwarning(title='警告！',message='文件错误，文件可能损坏')return# 开始用读取到的数据替换当前变量close_program = data['close_program']stop_all_key = data['stop_all_key']for i in data['gui_mouse']:Add_Mouse()  # 创建鼠标guigui_mouse[-1].key.set(i['key'])gui_mouse[-1].click_type.set(i['click_type'])gui_mouse[-1].click_seat.set(i['click_seat'])gui_mouse[-1].sparked_b.key = i['sparked_key']Key_Str(gui_mouse[-1].sparked_b)gui_mouse[-1].stop_b.key = i['stop_key']Key_Str(gui_mouse[-1].stop_b)gui_mouse[-1].number.set(i['number'])gui_mouse[-1].press_time.set(i['press_time'])gui_mouse[-1].release_time.set(i['release_time'])for i in data['gui_fingerboard']:Add_Fingerboard()  # 创建键盘guigui_fingerboard[-1].use.set(i['use'])Chenge_Fingerboard_l(gui_fingerboard[-1])  # 显示的界面gui_fingerboard[-1].sparked_b.key = i['sparked_key']Key_Str(gui_fingerboard[-1].sparked_b)gui_fingerboard[-1].stop_b.key = i['stop_key']Key_Str(gui_fingerboard[-1].stop_b)gui_fingerboard[-1].l_frame_1.text.insert('0.0', i['text'])gui_fingerboard[-1].presskey_b.key = i['presskey_key']Key_Str(gui_fingerboard[-1].presskey_b)gui_fingerboard[-1].number.set(i['number'])gui_fingerboard[-1].press_time.set(i['press_time'])gui_fingerboard[-1].release_time.set(i['release_time'])for i in data['gui_transcribe']:Add_Transcribe()  # 创建录制guigui_transcribe[-1].l_frame.record_data = i['record_data']gui_transcribe[-1].l_frame.record_use.set(i['record_use'])gui_transcribe[-1].l_frame.sparked_b.key = i['l_sparked_key']Key_Str(gui_transcribe[-1].l_frame.sparked_b)gui_transcribe[-1].l_frame.stop_b.key = i['l_stop_key']Key_Str(gui_transcribe[-1].l_frame.sparked_b)gui_transcribe[-1].sparked_b.key = i['sparked_key']Key_Str(gui_transcribe[-1].sparked_b)gui_transcribe[-1].stop_b.key = i['stop_key']Key_Str(gui_transcribe[-1].stop_b)# 保存文件函数
def Save_File():global gui_mouse, gui_fingerboard, gui_transcribe, close_program, stop_all_keyfile_path = tk.filedialog.asksaveasfilename()  # 选择文件保存位置和名字if file_path.strip() != '':  # 是空的时候，往往没有选择，直接关闭窗口return# 开始保存所有需要保存的关键数据data = {'gui_mouse': [], 'gui_fingerboard': [], 'gui_transcribe': [], 'close_program': close_program,'stop_all_key': stop_all_key, 'name': 'i道i的鼠标键盘小工具'}  # 存数据用try:  # 存鼠标数据for i in gui_mouse[1:]:data['gui_mouse'].append({'key': i.key.get(), 'click_type': i.click_type.get(), 'click_seat': i.click_seat.get(),'sparked_key': i.sparked_b.key, 'stop_key': i.stop_b.key, 'number': i.number.get(),'press_time': i.press_time.get(), 'release_time': i.release_time.get()})except:tk.messagebox.showwarning(title='警告！',message='鼠标数据保存错误，请检查输入的数据是否正确。\n''不支持表达式，如：5+2用于数值的创建')returntry:for i in gui_fingerboard[1:]:  # 存键盘数据data['gui_fingerboard'].append({'use': i.use.get(), 'sparked_key': i.sparked_b.key, 'stop_key': i.stop_b.key,'text': i.l_frame_1.text.get('0.0', 'end'), 'presskey_key': i.presskey_b.key,'number': i.number.get(), 'press_time': i.press_time.get(),'release_time': i.release_time.get()})except:tk.messagebox.showwarning(title='警告！',message='键盘数据保存错误，请检查输入的数据是否正确。\n''不支持表达式，如：5+2用于数值的创建')returntry:for i in gui_transcribe[1:]:  # 存录制数据data['gui_transcribe'].append({'record_data': i.l_frame.record_data, 'record_use': i.l_frame.record_use.get(),'l_sparked_key': i.l_frame.sparked_b.key, 'l_stop_key': i.l_frame.stop_b.key,'sparked_key': i.sparked_b.key, 'stop_key': i.stop_b.key, })except:tk.messagebox.showwarning(title='警告！',message='录制数据保存错误，请检查输入的数据是否正确。\n''不支持表达式，如：5+2用于数值的创建')returnfile = open(file_path, 'wb')pickle.dump(data, file)file.close()# 设置函数，设置各个操作的键位
def Set_Up():def Define():global close_program, stop_all_keyclose_program = close_program_b.keystop_all_key = stop_all_key_b.keySet_Up_window.destroy()global main_window, close_program, stop_all_keySet_Up_window = tk.Toplevel(main_window)  # 生成设置窗口Set_Up_window.title("设置")Set_Up_window.geometry("800x200")close_program_l = tk.Label(Set_Up_window, text='关闭程序:')stop_all_key_l = tk.Label(Set_Up_window, text='关闭所有功能:')close_program_b = tk.Button(Set_Up_window, text='', )stop_all_key_b = tk.Button(Set_Up_window, text='', )close_program_b.key = close_program[:]stop_all_key_b.key = stop_all_key[:]for i in close_program_b.key:close_program_b['text'] = close_program_b['text'] + str(i) + '+'for i in stop_all_key_b.key:stop_all_key_b['text'] = stop_all_key_b['text'] + str(i) + '+'close_program_b['text'] = close_program_b['text'][0:-1]stop_all_key_b['text'] = stop_all_key_b['text'][0:-1]close_program_b['command'] = lambda button=close_program_b: Change_Key_B(button)stop_all_key_b['command'] = lambda button=stop_all_key_b: Change_Key_B(button)define_b = tk.Button(Set_Up_window, text='确定', command=Define)close_program_l.grid(row=0, column=0, )close_program_b.grid(row=0, column=1, )stop_all_key_l.grid(row=1, column=0, )stop_all_key_b.grid(row=1, column=1, )define_b.grid(row=2, column=0, )# 放缩控制for i in range(2):Set_Up_window.columnconfigure(i, weight=1)Set_Up_window.rowconfigure(i, weight=1)Set_Up_window.rowconfigure(2, weight=1)# 录制文件编辑方法
def Record_Edit(data):# 监听键盘按钮，更改按键的值，只监听一个按键def Change_Key():def on_press(key):  # 碰到按键就停止if s != edit_window.fingerboard_data_gui.entry.Selected:return Falseedit_window.fingerboard_content.b_button.key = keyedit_window.fingerboard_content.b_button['text'] = keyreturn Falses = edit_window.fingerboard_data_gui.entry.Selectededit_window.fingerboard_content.b_button['text'] = ''listener = keyboard.Listener(on_press=on_press)listener.start()def Set():  # 确定函数  关闭+保存窗口，含确认if tk.messagebox.askokcancel("确定", "确定更改录制文件？"):data[0] = edit_window.mouse_data_gui.datadata[1] = edit_window.fingerboard_data_gui.dataedit_window.destroy()# 监听下回鼠标点击位置def Seat_Mouse():def on_click(x, y, button, pressed):if pressed and button == mouse.Button.left:  # 碰到按下鼠标左键就更改文本框内容edit_window.mouse_content.x.set(x)edit_window.mouse_content.y.set(y)listener.stop()# 使用事件监听进程，监听到鼠标按下左键，返回位置到文本框listener = mouse.Listener(on_click=on_click)listener.start()# 添加操作def Add_Kind(gui):new_data = {'kind': 0, 'time': time.time(), 'sleep_time': 0}  # 新项，无操作gui.data.insert(gui.entry.Selected + 1, new_data)  # 插入选中位置下一位，若没选，插入开头。gui.e_data.set(gui.data)  # 更新显示# 删除操作def Remove_Kind(gui):if gui.entry.Selected < 0:return  # 负数直接跳过，python 负数索引指倒数，怕乱删del gui.data[gui.entry.Selected]  # 删除当前选中的值gui.entry.Selected = -1  # 取消当前选择gui.e_data.set(gui.data)  # 更新显示def Setting_Mouse_Kind(event=None):  # 鼠标类型设定,仅仅是按类型禁用部分组件x = edit_window.mouse_content.c_kind['value'].index(edit_window.mouse_content.c_kind.get())edit_window.mouse_content.c_button['state'] = 'disabled'edit_window.mouse_content.c_pressed['state'] = 'disabled'edit_window.mouse_content.e_x['state'] = 'disabled'edit_window.mouse_content.e_y['state'] = 'disabled'edit_window.mouse_content.e_dx['state'] = 'disabled'edit_window.mouse_content.e_dy['state'] = 'disabled'if x != 0:  # 移动edit_window.mouse_content.e_x['state'] = 'normal'edit_window.mouse_content.e_y['state'] = 'normal'if x == 2:  # 按键edit_window.mouse_content.c_button['state'] = 'normal'edit_window.mouse_content.c_pressed['state'] = 'normal'elif x == 3:  # 滚动edit_window.mouse_content.e_dx['state'] = 'normal'edit_window.mouse_content.e_dy['state'] = 'normal'def Setting_Fingerboard_Kind(event=None):  # 键盘类型设定x = edit_window.fingerboard_content.c_kind['value'].index(edit_window.fingerboard_content.c_kind.get())if x != 0:edit_window.fingerboard_content.b_button['state'] = 'normal'  # 不是无操作，启用else:edit_window.fingerboard_content.b_button['state'] = 'disabled'def Selected_Mouse(event=None):  # 选择鼠标列表框后的方法index = edit_window.mouse_data_gui.entry.curselection()  # 获取当前选中的位置if len(index) != 1:returnindex = index[0]edit_window.mouse_data_gui.entry.Selected = indexs_m_data = edit_window.mouse_data_gui.data[index]  # 选中的数据edit_window.mouse_content.c_kind.current(s_m_data['kind'])  # 切换类型Setting_Mouse_Kind()  # 禁用组件# 根据类型的不同，填入参数edit_window.mouse_content.time.set(s_m_data['time'])edit_window.mouse_content.sleep_time.set(s_m_data['sleep_time'])if s_m_data['kind'] != 0:  # 移动edit_window.mouse_content.x.set(s_m_data['x'])edit_window.mouse_content.y.set(s_m_data['y'])if s_m_data['kind'] == 2:  # 按键if s_m_data['button'] == Button.left:edit_window.mouse_content.c_button.current(0)elif s_m_data['button'] == Button.middle:edit_window.mouse_content.c_button.current(1)elif s_m_data['button'] == Button.right:edit_window.mouse_content.c_button.current(2)elif s_m_data['button'] == Button.x1:edit_window.mouse_content.c_button.current(3)elif s_m_data['button'] == Button.x2:edit_window.mouse_content.c_button.current(4)if s_m_data['pressed']:edit_window.mouse_content.c_pressed.current(0)else:edit_window.mouse_content.c_pressed.current(1)elif s_m_data['kind'] == 3:  # 滚动edit_window.mouse_content.dx.set(s_m_data['dx'])edit_window.mouse_content.dy.set(s_m_data['dy'])def Selected_Fingerboard(event=None):  # 选择键盘列表框后的方法index = edit_window.fingerboard_data_gui.entry.curselection()  # 获取当前选中的位置if len(index) != 1:returnindex = index[0]edit_window.fingerboard_data_gui.entry.Selected = indexs_m_data = edit_window.fingerboard_data_gui.data[index]  # 选中的数据edit_window.fingerboard_content.c_kind.current(s_m_data['kind'])  # 切换类型Setting_Fingerboard_Kind()  # 禁用组件# 根据类型的不同，填入参数edit_window.fingerboard_content.time.set(s_m_data['time'])edit_window.fingerboard_content.sleep_time.set(s_m_data['sleep_time'])if s_m_data['kind'] != 0:  # 有操作，设定键值edit_window.fingerboard_content.b_button.key = s_m_data['key']edit_window.fingerboard_content.b_button['text'] = s_m_data['key']def Mouse_Change():  # 点击鼠标确定更改后的操作index = edit_window.mouse_data_gui.entry.Selected  # 获取当前选中的位置if index < 0:  # 负数，错误输入，不改(出现在删除节点之后，以及刚进入，未选择节点时)returnchange_data = {'kind': edit_window.mouse_content.c_kind['value'].index(edit_window.mouse_content.c_kind.get())}  # 一个字典，存需要的数据，替换data中的项try:change_data['time'] = edit_window.mouse_content.time.get()  # 都有的时间if change_data['kind'] != 0:  # 移动change_data['x'] = edit_window.mouse_content.x.get()change_data['y'] = edit_window.mouse_content.y.get()if change_data['kind'] == 2:  # 按键change_data['button'] = edit_window.mouse_content.c_button['value'].index(edit_window.mouse_content.c_button.get())if change_data['button'] == 0:change_data['button'] = Button.leftelif change_data['button'] == 1:change_data['button'] = Button.middleelif change_data['button'] == 2:change_data['button'] = Button.rightelif change_data['button'] == 3:change_data['button'] = Button.x1elif change_data['button'] == 4:change_data['button'] = Button.x2if edit_window.mouse_content.c_pressed.get() == '按下':change_data['pressed'] = Trueelse:change_data['pressed'] = Falseelif change_data['kind'] == 3:  # 滚动change_data['dx'] = edit_window.mouse_content.dx.get()change_data['dy'] = edit_window.mouse_content.dy.get()change_data['sleep_time'] = edit_window.mouse_content.sleep_time.get()  # 这个放后面为了保持顺序不变（好看用）except:tk.messagebox.showwarning(title='警告！',message='输入数据错误，请检查输入的数据是否正确。\n''不支持表达式，如：5+2用于数值的创建')returnif change_data['sleep_time'] < 0:  # 睡眠负数警告tk.messagebox.showwarning(title='警告！',message='时间不能为负数，请检查输入的数据是否正确。\n''操作延迟时间，即睡眠时间不能为负数，操作时间随便填。')returnedit_window.mouse_data_gui.data[index] = change_data  # 替换数据edit_window.mouse_data_gui.e_data.set(edit_window.mouse_data_gui.data)  # 更改列表框的显示def Fingerboard_Change():  # 点击键盘确定更改后的操作index = edit_window.fingerboard_data_gui.entry.Selected  # 获取当前选中的位置if index < 0:  # 负数，错误输入，不改(出现在删除节点之后，以及刚进入，未选择节点时)returnchange_data = {'kind': edit_window.fingerboard_content.c_kind['value'].index(edit_window.fingerboard_content.c_kind.get())}  # 一个字典，存需要的数据，替换data中的项try:change_data['time'] = edit_window.fingerboard_content.time.get()  # 都有的时间if change_data['kind'] != 0:change_data['key'] = edit_window.fingerboard_content.b_button.keyif change_data['key'] is None:  # 空按键警告tk.messagebox.showwarning(title='警告！',message='选择按下或松开时按键不能为空。\n''请设定按键的值。')returnchange_data['sleep_time'] = edit_window.fingerboard_content.sleep_time.get()  # 这个放后面为了保持顺序不变except:tk.messagebox.showwarning(title='警告！',message='输入数据错误，请检查输入的数据是否正确。\n''不支持表达式，如：5+2用于数值的创建')returnif change_data['sleep_time'] < 0:  # 睡眠负数警告tk.messagebox.showwarning(title='警告！',message='时间不能为负数，请检查输入的数据是否正确。\n''操作延迟时间，即睡眠时间不能为负数，操作时间随便填。')returnedit_window.fingerboard_data_gui.data[index] = change_data  # 替换数据edit_window.fingerboard_data_gui.e_data.set(edit_window.fingerboard_data_gui.data)  # 更改列表框的显示def Resetting_gui():  # 打开页面前清除页面内容for i in edit_window.data_bar.grid_slaves():i.grid_forget()for i in edit_window.content_bar.grid_slaves():i.grid_forget()def Open_Mouse():  # 打开鼠标操作界面Resetting_gui()edit_window.mouse_data_gui.grid(sticky="nsew")edit_window.mouse_content.grid(sticky="nsew")def Open_Fingerboard():  # 打开键盘操作界面Resetting_gui()edit_window.fingerboard_data_gui.grid(sticky="nsew")edit_window.fingerboard_content.grid(sticky="nsew")global main_windowedit_window = tk.Toplevel(main_window)  # 生成编辑窗口edit_window.title("录制文件编辑")edit_window.geometry("1000x600")edit_window.class_bar = tk.LabelFrame(edit_window, text="操作", bg='gainsboro')  # 放左边容纳鼠标或键盘的框架edit_window.class_bar.grid(row=0, column=0, rowspan=2, sticky="nsew")edit_window.class_bar.class_bar = [tk.Button(edit_window.class_bar, text="鼠标操作", command=Open_Mouse),tk.Button(edit_window.class_bar, text="键盘操作", command=Open_Fingerboard),tk.Button(edit_window.class_bar, text="确定", command=Set)]  # 操作按钮组for i in range(3):edit_window.class_bar.class_bar[i].grid(row=i, column=0, padx=5, pady=2)edit_window.data_bar = tk.LabelFrame(edit_window, text="数据栏", )  # 放右上，显示所有变量edit_window.content_bar = tk.LabelFrame(edit_window, text="内容", )  # 放在右下，显示具体的操作edit_window.data_bar.grid(row=0, column=1, sticky="nsew")edit_window.content_bar.grid(row=1, column=1, sticky="nsew")# 鼠标操作guiedit_window.mouse_data_gui = tk.LabelFrame(edit_window.data_bar)edit_window.mouse_data_gui.scroll_bar_x = tk.Scrollbar(edit_window.mouse_data_gui, orient=tk.HORIZONTAL)  # 水平滚动条edit_window.mouse_data_gui.scroll_bar_y = tk.Scrollbar(edit_window.mouse_data_gui, orient=tk.VERTICAL)  # 垂直滚动条edit_window.mouse_data_gui.data = data[0][:]  # 实际上用的edit_window.mouse_data_gui.e_data = tk.StringVar()  # 面子上给用户看的edit_window.mouse_data_gui.e_data.set(data[0])edit_window.mouse_data_gui.entry = tk.Listbox(  # 列表框，关联滚动条edit_window.mouse_data_gui, xscrollcommand=edit_window.mouse_data_gui.scroll_bar_x.set,yscrollcommand=edit_window.mouse_data_gui.scroll_bar_y.set, listvariable=edit_window.mouse_data_gui.e_data, )edit_window.mouse_data_gui.entry.Selected = -1  # 这个用来保存选中的位置。edit_window.mouse_data_gui.entry.bind("<<ListboxSelect>>", Selected_Mouse)  # 绑定选中方法edit_window.mouse_data_gui.scroll_bar_x.config(command=edit_window.mouse_data_gui.entry.xview)edit_window.mouse_data_gui.scroll_bar_x.pack(side=tk.BOTTOM, fill=tk.X)  # 靠下，拉满xedit_window.mouse_data_gui.scroll_bar_y.config(command=edit_window.mouse_data_gui.entry.yview)edit_window.mouse_data_gui.scroll_bar_y.pack(side=tk.RIGHT, fill=tk.Y)  # 靠右，拉满yedit_window.mouse_data_gui.entry.pack(fill=tk.BOTH, expand=1)# 鼠标操作具体数据guiedit_window.mouse_content = tk.LabelFrame(edit_window.content_bar)# 鼠标相关数据关联变量：edit_window.mouse_content.x = tk.IntVar()  # 鼠标操作的位置edit_window.mouse_content.y = tk.IntVar()edit_window.mouse_content.dx = tk.IntVar()  # 鼠标滚动坐标edit_window.mouse_content.dy = tk.IntVar()edit_window.mouse_content.time = tk.DoubleVar()  # 按下的系统时间edit_window.mouse_content.sleep_time = tk.DoubleVar()  # 距离上一次 操作的时间# 各种组件edit_window.mouse_content.l_kind = tk.Label(edit_window.mouse_content, text='操作类型:')  # 类型edit_window.mouse_content.c_kind = ttk.Combobox(edit_window.mouse_content)  # 下拉列表edit_window.mouse_content.c_kind['value'] = ('无操作', '移动', '按键', '滚动')edit_window.mouse_content.c_kind['state'] = 'readonly'  # 只读edit_window.mouse_content.c_kind.bind("<<ComboboxSelected>>", Setting_Mouse_Kind)edit_window.mouse_content.c_kind.current(0)  # 首选项edit_window.mouse_content.l_button = tk.Label(edit_window.mouse_content, text='点击键位:')edit_window.mouse_content.c_button = ttk.Combobox(edit_window.mouse_content)edit_window.mouse_content.c_button['value'] = ('左键', '中键', '右键', '侧键1', '侧键2')edit_window.mouse_content.c_button.current(0)edit_window.mouse_content.l_pressed = tk.Label(edit_window.mouse_content, text='按下/放开:')edit_window.mouse_content.c_pressed = ttk.Combobox(edit_window.mouse_content)edit_window.mouse_content.c_pressed['value'] = ('按下', '放开')edit_window.mouse_content.c_pressed.current(0)edit_window.mouse_content.l_x = tk.Label(edit_window.mouse_content, text='鼠标位置x:')edit_window.mouse_content.e_x = tk.Entry(edit_window.mouse_content, textvariable=edit_window.mouse_content.x)edit_window.mouse_content.l_y = tk.Label(edit_window.mouse_content, text='鼠标位置y:')edit_window.mouse_content.e_y = tk.Entry(edit_window.mouse_content, textvariable=edit_window.mouse_content.y)edit_window.mouse_content.l_dx = tk.Label(edit_window.mouse_content, text='鼠标滚动dx:')edit_window.mouse_content.e_dx = tk.Entry(edit_window.mouse_content, textvariable=edit_window.mouse_content.dx)edit_window.mouse_content.l_dy = tk.Label(edit_window.mouse_content, text='鼠标滚动dy:')edit_window.mouse_content.e_dy = tk.Entry(edit_window.mouse_content, textvariable=edit_window.mouse_content.dy)edit_window.mouse_content.l_time = tk.Label(edit_window.mouse_content, text='操作时间:')edit_window.mouse_content.e_time = tk.Entry(edit_window.mouse_content, textvariable=edit_window.mouse_content.time)edit_window.mouse_content.l_sleep_time = tk.Label(edit_window.mouse_content, text='操作延迟时间:')edit_window.mouse_content.e_sleep_time = tk.Entry(edit_window.mouse_content,textvariable=edit_window.mouse_content.sleep_time)edit_window.mouse_content.seat_mouse = tk.Button(edit_window.mouse_content, text='获取点击位置', command=Seat_Mouse)edit_window.mouse_content.add_kind = tk.Button(edit_window.mouse_content, text='添加操作',command=lambda gui=edit_window.mouse_data_gui: Add_Kind(gui))edit_window.mouse_content.remove_kind = tk.Button(edit_window.mouse_content, text='删除操作',command=lambda gui=edit_window.mouse_data_gui: Remove_Kind(gui))edit_window.mouse_content.change_b = tk.Button(edit_window.mouse_content, text='确定更改', command=Mouse_Change)edit_window.mouse_content.point_out_l = tk.Label(edit_window.mouse_content,text='来自i道i的提示:按下按键后一定要记着放开，不会自动放开的')Setting_Mouse_Kind()edit_window.mouse_content.l_kind.grid(row=0, column=0, sticky='w')edit_window.mouse_content.c_kind.grid(row=0, column=1, sticky='w')edit_window.mouse_content.l_button.grid(row=1, column=0, sticky='w')edit_window.mouse_content.c_button.grid(row=1, column=1, sticky='w')edit_window.mouse_content.l_pressed.grid(row=2, column=0, sticky='w')edit_window.mouse_content.c_pressed.grid(row=2, column=1, sticky='w')edit_window.mouse_content.l_x.grid(row=0, column=2, sticky='w')edit_window.mouse_content.e_x.grid(row=0, column=3, sticky='w')edit_window.mouse_content.l_y.grid(row=0, column=4, sticky='w')edit_window.mouse_content.e_y.grid(row=0, column=5, sticky='w', columnspan=2)edit_window.mouse_content.l_dx.grid(row=1, column=2, sticky='w')edit_window.mouse_content.e_dx.grid(row=1, column=3, sticky='w')edit_window.mouse_content.l_dy.grid(row=1, column=4, sticky='w')edit_window.mouse_content.e_dy.grid(row=1, column=5, sticky='w', columnspan=2)edit_window.mouse_content.l_time.grid(row=2, column=2, sticky='w')edit_window.mouse_content.e_time.grid(row=2, column=3, sticky='w')edit_window.mouse_content.l_sleep_time.grid(row=3, column=2, sticky='w')edit_window.mouse_content.e_sleep_time.grid(row=3, column=3, sticky='w')edit_window.mouse_content.add_kind.grid(row=2, column=5, sticky='w', )edit_window.mouse_content.remove_kind.grid(row=3, column=5, sticky='w', )edit_window.mouse_content.seat_mouse.grid(row=2, column=6, sticky='w', )edit_window.mouse_content.change_b.grid(row=3, column=1, sticky='w', )edit_window.mouse_content.point_out_l.grid(row=4,column=1,columnspan=3)# 键盘操作guiedit_window.fingerboard_data_gui = tk.LabelFrame(edit_window.data_bar)edit_window.fingerboard_data_gui.scroll_bar_x = tk.Scrollbar(edit_window.fingerboard_data_gui,orient=tk.HORIZONTAL)  # 水平滚动条edit_window.fingerboard_data_gui.scroll_bar_y = tk.Scrollbar(edit_window.fingerboard_data_gui,orient=tk.VERTICAL)  # 垂直滚动条edit_window.fingerboard_data_gui.data = data[1][:]  # 实际上用的edit_window.fingerboard_data_gui.e_data = tk.StringVar()edit_window.fingerboard_data_gui.e_data.set(data[1])edit_window.fingerboard_data_gui.entry = tk.Listbox(  # 列表框，关联滚动条edit_window.fingerboard_data_gui, xscrollcommand=edit_window.fingerboard_data_gui.scroll_bar_x.set,yscrollcommand=edit_window.fingerboard_data_gui.scroll_bar_y.set,listvariable=edit_window.fingerboard_data_gui.e_data, )edit_window.fingerboard_data_gui.entry.Selected = -1  # 这个用来保存上一次选中的位置。edit_window.fingerboard_data_gui.entry.bind("<<ListboxSelect>>", Selected_Fingerboard)  # 绑定选中方法edit_window.fingerboard_data_gui.scroll_bar_x.config(command=edit_window.fingerboard_data_gui.entry.xview)edit_window.fingerboard_data_gui.scroll_bar_x.pack(side=tk.BOTTOM, fill=tk.X)  # 靠下，拉满xedit_window.fingerboard_data_gui.scroll_bar_y.config(command=edit_window.fingerboard_data_gui.entry.yview)edit_window.fingerboard_data_gui.scroll_bar_y.pack(side=tk.RIGHT, fill=tk.Y)  # 靠右，拉满yedit_window.fingerboard_data_gui.entry.pack(fill=tk.BOTH, expand=1)# 键盘操作具体数据guiedit_window.fingerboard_content = tk.LabelFrame(edit_window.content_bar)# 操作关联变量edit_window.fingerboard_content.time = tk.DoubleVar()edit_window.fingerboard_content.sleep_time = tk.DoubleVar()# 各种组件edit_window.fingerboard_content.l_kind = tk.Label(edit_window.fingerboard_content, text='操作类型:')  # 类型edit_window.fingerboard_content.c_kind = ttk.Combobox(edit_window.fingerboard_content)  # 下拉列表edit_window.fingerboard_content.c_kind['value'] = ('无操作', '按下', '松开')edit_window.fingerboard_content.c_kind['state'] = 'readonly'  # 只读edit_window.fingerboard_content.c_kind.bind("<<ComboboxSelected>>", Setting_Fingerboard_Kind)edit_window.fingerboard_content.c_kind.current(0)  # 首选项edit_window.fingerboard_content.l_button = tk.Label(edit_window.fingerboard_content, text='操作键位:')edit_window.fingerboard_content.b_button = tk.Button(edit_window.fingerboard_content, command=Change_Key)edit_window.fingerboard_content.b_button.key = None  # 需要按下的键edit_window.fingerboard_content.l_time = tk.Label(edit_window.fingerboard_content, text='操作时间:')edit_window.fingerboard_content.e_time = tk.Entry(edit_window.fingerboard_content,textvariable=edit_window.fingerboard_content.time)edit_window.fingerboard_content.l_sleep_time = tk.Label(edit_window.fingerboard_content, text='操作延迟时间:')edit_window.fingerboard_content.e_sleep_time = tk.Entry(edit_window.fingerboard_content,textvariable=edit_window.fingerboard_content.sleep_time)edit_window.fingerboard_content.add_kind = tk.Button(edit_window.fingerboard_content, text='添加操作', command=lambdagui=edit_window.fingerboard_data_gui: Add_Kind(gui))edit_window.fingerboard_content.remove_kind = tk.Button(edit_window.fingerboard_content, text='删除操作', command=lambdagui=edit_window.fingerboard_data_gui: Remove_Kind(gui))edit_window.fingerboard_content.change_b = tk.Button(edit_window.fingerboard_content, text='确定更改',command=Fingerboard_Change)edit_window.fingerboard_content.point_out_l = tk.Label(edit_window.fingerboard_content,text='来自i道i的提示:按下按键后一定要记着放开，不会自动放开的')Setting_Fingerboard_Kind()edit_window.fingerboard_content.l_kind.grid(row=0, column=0, sticky='w', )edit_window.fingerboard_content.c_kind.grid(row=0, column=1, sticky='w', )edit_window.fingerboard_content.l_button.grid(row=0, column=2, sticky='w')edit_window.fingerboard_content.b_button.grid(row=0, column=3, sticky='w', columnspan=2)edit_window.fingerboard_content.l_time.grid(row=1, column=2, sticky='w')edit_window.fingerboard_content.e_time.grid(row=1, column=3, sticky='w', columnspan=2)edit_window.fingerboard_content.l_sleep_time.grid(row=2, column=2, sticky='w')edit_window.fingerboard_content.e_sleep_time.grid(row=2, column=3, sticky='w', columnspan=2)edit_window.fingerboard_content.add_kind.grid(row=1, column=1, sticky='w', )edit_window.fingerboard_content.remove_kind.grid(row=2, column=1, sticky='w', )edit_window.fingerboard_content.change_b.grid(row=0, column=6, sticky='w', )edit_window.fingerboard_content.point_out_l.grid(row=4,column=1,columnspan=3)# 放缩控制edit_window.columnconfigure(1, weight=1)edit_window.rowconfigure(0, weight=1)edit_window.rowconfigure(1, weight=1)edit_window.data_bar.rowconfigure(0, weight=1)edit_window.content_bar.rowconfigure(0, weight=1)edit_window.data_bar.columnconfigure(0, weight=1)edit_window.content_bar.columnconfigure(0, weight=1)# 录制文件删除方法
def Record_Delete(data):if tk.messagebox.askokcancel("录制文件删除", "确定删除录制文件？"):data.clear()  # 删除上一回的录制data.append([{'kind': 0, 'time': time.time(), 'sleep_time': 0, }])  # 保存鼠标data.append([{'kind': 0, 'time': time.time(), 'sleep_time': 0, }])  # 保存键盘# 菜单栏
def Generate_Menu(main_window):menubar = tk.Menu(main_window)  # 菜单栏# 文件菜单是菜单栏的子菜单,且不能窗口化submenu_file = tk.Menu(menubar, tearoff=False)submenu_file.add_command(label='打开文件', command=Open_File)  # 文件子菜单添加选项submenu_file.add_command(label='保存文件', command=Save_File)submenu_file.add_separator()  # 分割线submenu_file.add_command(label='设置', command=Set_Up)  # command为要调用的函数menubar.add_cascade(label='文件', menu=submenu_file)  # 菜单添加文件子菜单项return menubar# gui删除，从gui_gather中删除gui,并更改其余gui的n值
def Delete_gui(gui_gather, gui, ):gui.sparked_stop_tab = [True]  # 功能终止标记gui.stop_tab = [True]  # 点击进程终止标记for i in range(gui['text'], len(gui_gather)):gui_gather[i]['text'] = int(gui_gather[i]['text']) - 1gui_gather.remove(gui)if works == 'mouse':  # 判断当前类型Common_Mouse()  # 重新启动elif works == 'fingerboard':Common_Fingerboard()elif works == 'transcribe':Common_Transcribe()# 监听键盘按钮，更改按键的值，可用组合键
def Change_Key_B(button):def on_press(key):  # 碰到按键就入列表if not key in button.key:button.key.append(key)button['text'] = button['text'] + str(key) + '+'def on_release(key):  # 某一个键松开，就结束监听，更改按键文本button['text'] = button['text'][0:-1]return Falsebutton['text'] = ''button.key = []  # 初始为空listener = keyboard.Listener(on_press=on_press, on_release=on_release)listener.start()# 监听下回鼠标点击位置
def Give_Mouse(seat):def on_click(x, y, button, pressed):if pressed and button == mouse.Button.left:  # 碰到按下鼠标左键就更改文本框内容seat.set(str(x) + ',' + str(y))  # 逗号分割便于之后直接用eval处理listener.stop()# 使用事件监听进程，监听到鼠标按下左键，返回位置到文本框listener = mouse.Listener(on_click=on_click)listener.start()# 替代用方法
def end():pass# 切换文本类组件的启用/停止
def Changing_Over(t, c):if c["state"] == 'normal':  # 是启用，设为禁用，左键恢复c['state'] = 'disabled'c['cursor'] = 'arrow'  # 鼠标样式更改c.bind('<Button-1>', (lambda t=t, entry=c: Changing_Over(t, entry)))c.bind('<Button-3>', lambda t=t: end())else:  # 是禁用if c['cursor'] == 'arrow':  # 大概率是这个函数设置的禁用c['state'] = 'normal'  # 启用c['cursor'] = 'xterm'  # 鼠标样式更改# 右键禁用c.bind('<Button-3>', (lambda t=t, entry=c: Changing_Over(t, entry)))c.bind('<Button-1>', lambda t=t: end())#  切换任意组件的启停，不更改鼠标样式
def Changing_All(c):if c["state"] == 'normal':c['state'] = 'disabled'else:c['state'] = 'normal'# 监听线程，监听到按下key_start生成并执行ability线程,随后监听key_stop,按下后关闭线程
# 拥有功能终止标记，操控进程终止标记,终止线程
def Monitor(gui):def on_press(key):  # 碰到按键就记录处理if gui.sparked_stop_tab[0]:  # 功能终止gui.stop_tab[0] = True  # 线程也终止listener.stop()  # 结束监听线程return Falsenow_key.add(key)  # 当前按下的键进入集合be_tap = 1  # 存在标记if gui.stop_tab[0]:  # 进程没开始for i in gui.sparked_b.key:  # 任何一个开始按键if not i in now_key:  # 没有按下be_tap = 0  # 不存在，不允许breakif be_tap:  # 检测到所有开始按键/触发键gui.stop_tab[0] = False  # 开始进程gui.New_ability()  # 生成+启动gui.ability.start()else:  # 进程开始了if gui.use.get():  # 针对输入text的功能，不会停止for i in gui.stop_b.key:  # 任何一个终止按键if not i in now_key:  # 没有按下be_tap = 0  # 不存在，不允许breakif be_tap:  # 且按键为结束键gui.stop_tab[0] = True  # 结束进程def on_release(key):now_key.discard(key)now_key = set()listener = keyboard.Listener(on_press=on_press, on_release=on_release)listener.start()# 鼠标gui的功能，模拟点击,
def Analog_Click(gui):control = Controller()  # 创建鼠标控制对象key = gui.key.get()  # 根据键位设置选择点击的键if key == 0:key = Button.leftelif key == 1:key = Button.middleelse:key = Button.rightfor i in range(gui.number.get()):  # 反复执行这么多次if gui.stop_tab[0]:  # 进程终止breakif gui.sparked_stop_tab[0]:  # 功能终止gui.stop_tab[0] = Truereturnif gui.click_type.get():  # 如果固定位置点击，移动到固定位置control.position = eval(gui.click_seat.get())control.press(key)  # 按下time.sleep(gui.press_time.get())  # 等待到时间后松开control.release(key)  # 松开if i < gui.number.get() - 1:  # 如果是最后一次就不等了time.sleep(gui.release_time.get())  # 等待到时间后下一轮if gui.sparked_stop_tab[0]:  # 功能终止returnelse:gui.stop_tab[0] = True  # 进程运行结束return# 点击启用按钮时，方法
def Mouse_Gui_Start(gui):def NA(g):g.ability = Thread(target=lambda g=g: Analog_Click(g))# 错误处理try:click_type = gui.click_type.get()if click_type == 1:x, y = eval(gui.click_seat.get())else:x, y = 0, 0except:tk.messagebox.showwarning(title='警告！',message='您选择了移动鼠标，但没有正确输入移动坐标点。\n''请用x,y格式输入，或直接获取下次鼠标点击位置')returnif gui.sparked_b['text'] == 'None' or gui.stop_b['text'] == 'None':  # 没有设定按键的情况tk.messagebox.showwarning(title='警告！', message='请设定触发按键和停止按键，以免无法开始或者停止')returntry:press_time = gui.press_time.get()release_time = gui.release_time.get()if press_time < 0 or release_time < 0:tk.messagebox.showwarning(title='警告！', message='按下时间和松开时间不能为负。')returnexcept:tk.messagebox.showwarning(title='警告！', message='次数或按下时间和松开时间设置错误。')return# 到这里没报错就可以开始进行gui.start_click_b['state'] = 'disabled'  # 禁用启用按钮gui.start_click_b['cursor'] = 'arrow'  # 鼠标样式更改gui.stop_click_b['state'] = 'normal'  # 启用停用按钮gui.stop_click_b['cursor'] = 'hand2'  # 鼠标样式更改# 虽然不禁用也行，但怕你们用的时候乱改报错，禁用比较好# 没有禁用的，在启用后更改，应该也能生效gui.click_type_b[0]['state'] = 'disabled'gui.click_type_b[1]['state'] = 'disabled'gui.click_entry['state'] = 'disabled'gui.number_entry['state'] = 'disabled'gui.press_time_entry['state'] = 'disabled'gui.release_time_entry['state'] = 'disabled'gui.sparked_b['state'] = 'disabled'gui.stop_b['state'] = 'disabled'gui.sparked_stop_tab = [False]  # 功能终止标记gui.stop_tab = [True]  # 点击进程终止标记gui.New_ability = lambda g=gui: NA(g)  # 新建点击线程gui.sparked = lambda g=gui: Monitor(gui)  # 监听线程gui.sparked()  # 启动监听# 点击停用按钮时，方法
def Mouse_Gui_Stop(gui):gui.stop_click_b['state'] = 'disabled'  # 禁用启用按钮gui.stop_click_b['cursor'] = 'arrow'  # 鼠标样式更改gui.start_click_b['state'] = 'normal'  # 启用停用按钮gui.start_click_b['cursor'] = 'hand2'  # 鼠标样式更改# 解禁gui.click_type_b[0]['state'] = 'normal'gui.click_type_b[1]['state'] = 'normal'gui.click_entry['state'] = 'normal'gui.number_entry['state'] = 'normal'gui.press_time_entry['state'] = 'normal'gui.release_time_entry['state'] = 'normal'gui.sparked_b['state'] = 'normal'gui.stop_b['state'] = 'normal'gui.sparked_stop_tab = [True]  # 功能终止标记gui.stop_tab = [True]  # 点击进程终止标记# 创建一个鼠标功能GUI
def Add_Mouse():global data_bar, gui_mousegui_mouse.append(tk.LabelFrame(data_bar, text=len(gui_mouse), ))  # 添加一个guin = len(gui_mouse) - 1  # 当前位置（不想用gui_mouse[-1]）# 左半边界面gui_mouse[n].l_frame = tk.LabelFrame(gui_mouse[n])  # 左半边框架gui_mouse[n].l_frame.grid(row=0, column=0, sticky="nsew")# 第一部分 选择按下的鼠标键gui_mouse[n].key = tk.IntVar()  # 单选按钮的值,用.get()可以取出来,初始0gui_mouse[n].key_type_b = [  # 键位的单选按钮组，variable控制的变量，value按钮代表的值tk.Radiobutton(gui_mouse[n].l_frame, text='左键', variable=gui_mouse[n].key, value=0),tk.Radiobutton(gui_mouse[n].l_frame, text='中键', variable=gui_mouse[n].key, value=1),tk.Radiobutton(gui_mouse[n].l_frame, text='右键', variable=gui_mouse[n].key, value=2)]for i in range(3):  # 显示一下gui_mouse[n].key_type_b[i].grid(row=0, column=i, )# 第二部分 选择鼠标按下的位置gui_mouse[n].click_type = tk.IntVar()  # 位置类型(设定位置/鼠标位置)gui_mouse[n].click_type_b = [  # 点击位置，选择鼠标直接点击，还是鼠标移动到指定点后点击tk.Radiobutton(gui_mouse[n].l_frame, text='保持位置', variable=gui_mouse[n].click_type, value=0),tk.Radiobutton(gui_mouse[n].l_frame, text='移动鼠标', variable=gui_mouse[n].click_type, value=1)]gui_mouse[n].click_type_b[0].grid(row=1, column=0, )gui_mouse[n].click_type_b[1].grid(row=2, column=0, )gui_mouse[n].click_seat = tk.StringVar()  # 文本框文本关联变量gui_mouse[n].click_seat.set('0,0')gui_mouse[n].click_entry = tk.Entry(  # 设定位置文本框gui_mouse[n].l_frame, exportselection=0, textvariable=gui_mouse[n].click_seat)gui_mouse[n].click_entry.grid(row=2, column=1, sticky='w', columnspan=2)gui_mouse[n].click_b = tk.Button(  # 获取点击位置按键gui_mouse[n].l_frame, text='获取下次鼠标点击位置',command=lambda seat=gui_mouse[n].click_seat: Give_Mouse(seat))gui_mouse[n].click_b.grid(row=1, column=1, sticky='w', columnspan=2)# 第三部分 选择功能的触发和停止按键gui_mouse[n].sparked_label = tk.Label(gui_mouse[n].l_frame, text='触发按键:')  # 触发按键前的提示文本gui_mouse[n].sparked_b = tk.Button(gui_mouse[n].l_frame, text='None', )  # 触发按键本身gui_mouse[n].sparked_b.key = Nonegui_mouse[n].sparked_b['command'] = lambda button=gui_mouse[n].sparked_b: Change_Key_B(button)gui_mouse[n].stop_label = tk.Label(gui_mouse[n].l_frame, text='停止按键:')  # 停止按键前的提示文本gui_mouse[n].stop_b = tk.Button(gui_mouse[n].l_frame, text='None', )  # 停止按键本身gui_mouse[n].stop_b.key = Nonegui_mouse[n].stop_b['command'] = lambda button=gui_mouse[n].stop_b: Change_Key_B(button)gui_mouse[n].sparked_label.grid(row=3, column=0, )  # 把这些显示出来，'w'是靠左(西)的意思。gui_mouse[n].sparked_b.grid(row=3, column=1, sticky='w', columnspan=2)gui_mouse[n].stop_label.grid(row=4, column=0, )gui_mouse[n].stop_b.grid(row=4, column=1, sticky='w', columnspan=2)# 该右半边界面了gui_mouse[n].r_frame = tk.LabelFrame(gui_mouse[n])  # 右半边框架gui_mouse[n].r_frame.grid(row=0, column=1, sticky="nsew")# 第一部分 填入点击次数，按下时间，松开时间属性 右键输入框可以锁定输入gui_mouse[n].number = tk.IntVar()  # 次数变量，控制点击次数，gui_mouse[n].number.set(1)  # 初始给一次gui_mouse[n].number_label = tk.Label(gui_mouse[n].r_frame, text='次数:')  # 次数提示标签gui_mouse[n].number_entry = tk.Entry(  # 设定次数文本框gui_mouse[n].r_frame, exportselection=0, textvariable=gui_mouse[n].number)gui_mouse[n].number_unit_label = tk.Label(gui_mouse[n].r_frame, text='次')  # 次数单位标签gui_mouse[n].press_time = tk.DoubleVar()  # 按下时间变量，控制按键时间gui_mouse[n].press_time.set(0.1)gui_mouse[n].press_time_label = tk.Label(gui_mouse[n].r_frame, text='按下时间:')  # 按下时间提示标签gui_mouse[n].press_time_entry = tk.Entry(  # 设定按下时间文本框gui_mouse[n].r_frame, exportselection=0, textvariable=gui_mouse[n].press_time)gui_mouse[n].press_time_unit_label = tk.Label(gui_mouse[n].r_frame, text='s')  # 按下时间单位标签gui_mouse[n].release_time = tk.DoubleVar()  # 松开时间变量，控制按键间隔时间gui_mouse[n].release_time.set(0.9)gui_mouse[n].release_time_label = tk.Label(gui_mouse[n].r_frame, text='松开时间:')  # 松开时间提示标签gui_mouse[n].release_time_entry = tk.Entry(  # 设定松开时间文本框gui_mouse[n].r_frame, exportselection=0, textvariable=gui_mouse[n].release_time)gui_mouse[n].release_time_unit_label = tk.Label(gui_mouse[n].r_frame, text='s')  # 松开时间单位标签gui_mouse[n].number_label.grid(row=0, column=0, sticky='w')  # 给这一堆东西放下来gui_mouse[n].number_entry.grid(row=0, column=1, sticky='w')gui_mouse[n].number_unit_label.grid(row=0, column=2, sticky='w')gui_mouse[n].press_time_label.grid(row=1, column=0, sticky='w')gui_mouse[n].press_time_entry.grid(row=1, column=1, sticky='w')gui_mouse[n].press_time_unit_label.grid(row=1, column=2, sticky='w')gui_mouse[n].release_time_label.grid(row=2, column=0, sticky='w')gui_mouse[n].release_time_entry.grid(row=2, column=1, sticky='w')gui_mouse[n].release_time_unit_label.grid(row=2, column=2, sticky='w')# 第二部分# 关键的启动和停止按钮gui_mouse[n].start_click_b = tk.Button(gui_mouse[n].r_frame, text='启用', )gui_mouse[n].stop_click_b = tk.Button(gui_mouse[n].r_frame, text='停用', )gui_mouse[n].stop_click_b['state'] = 'disabled'  # 初始，停用按钮为禁用gui_mouse[n].stop_click_b['cursor'] = 'arrow'  # 鼠标样式更改gui_mouse[n].start_click_b['command'] = lambda gui=gui_mouse[n]: Mouse_Gui_Start(gui)gui_mouse[n].stop_click_b['command'] = lambda gui=gui_mouse[n]: Mouse_Gui_Stop(gui)gui_mouse[n].start_click_b.grid(row=3, column=0, )gui_mouse[n].stop_click_b.grid(row=3, column=1, )# 第三部分，删除按钮gui_mouse[n].delete = tk.Button(gui_mouse[n].r_frame, text='删除', )gui_mouse[n].delete['command'] = lambda gui_gather=gui_mouse, gui=gui_mouse[n]: Delete_gui(gui_gather, gui)gui_mouse[n].delete.grid(row=4, column=1, )# 给所有文本框绑定一下点击启/禁用功能t = 0  # 盖住第一个点击位置的调用gui_mouse[n].click_entry.bind('<Button-3>',(lambda t=t, entry=gui_mouse[n].click_entry: Changing_Over(t, entry)))gui_mouse[n].number_entry.bind('<Button-3>',(lambda t=t, entry=gui_mouse[n].number_entry: Changing_Over(t, entry)))gui_mouse[n].press_time_entry.bind('<Button-3>',(lambda t=t, entry=gui_mouse[n].press_time_entry: Changing_Over(t, entry)))gui_mouse[n].release_time_entry.bind('<Button-3>',(lambda t=t, entry=gui_mouse[n].release_time_entry: Changing_Over(t, entry)))# 放缩控制gui_mouse[n].columnconfigure(0, weight=1)  # column为0,缩放比为1(列)gui_mouse[n].columnconfigure(1, weight=1)  # column为0,缩放比为1for i in range(5):gui_mouse[n].l_frame.rowconfigure(i, weight=1)for i in range(3):gui_mouse[n].l_frame.columnconfigure(i, weight=1)gui_mouse[n].use = tk.IntVar()  # 用于兼容键盘gui_mouse[n].use.set(1)Common_Mouse()  # 最后刷新一下gui界面# 键盘gui的功能，模拟按键或者模拟输入
def Analog_Key(gui):k = keyboard.Controller()  # 创建键盘控制对象if gui.use.get():  # 是1for i in range(gui.number.get()):  # 反复执行这么多次if gui.stop_tab[0]:  # 进程终止breakif gui.sparked_stop_tab[0]:  # 功能终止gui.stop_tab[0] = Truereturnfor key in gui.presskey_b.key:k.press(key)  # 按下time.sleep(gui.press_time.get())  # 等待到时间后松开for key in gui.presskey_b.key:k.release(key)  # 松开if i < gui.number.get() - 1:  # 如果是最后一次就不等了time.sleep(gui.release_time.get())  # 等待到时间后下一轮else:  # 0,单纯输出文本框的内容就行k.type(gui.l_frame_1.text.get('0.0', 'end'))if gui.sparked_stop_tab[0]:  # 功能终止returnelse:gui.stop_tab[0] = True  # 进程运行结束return# 点击启用按钮时，方法
def Fingerboard_Gui_Start(gui):def NA(g):  # 这里不判断操作类型，留到使用时再判断g.ability = Thread(target=lambda g=g: Analog_Key(g))# 错误处理if gui.sparked_b['text'] == 'None' or gui.stop_b['text'] == 'None':  # 没有设定按键的情况tk.messagebox.showwarning(title='警告！', message='请设定触发按键和停止按键，以免无法开始或者停止')returnif gui.use.get():try:press_time = gui.press_time.get()release_time = gui.release_time.get()if press_time < 0 or release_time < 0:tk.messagebox.showwarning(title='警告！', message='按下时间和松开时间不能为负。')returnexcept:tk.messagebox.showwarning(title='警告！', message='次数或按下时间和松开时间设置错误。')returnif gui.presskey_b['text'] == 'None':tk.messagebox.showwarning(title='警告！', message='请设定需要按下的按钮或组合键')return# 到这里没报错就可以开始进行gui.start_click_b['state'] = 'disabled'  # 禁用启用按钮gui.start_click_b['cursor'] = 'arrow'  # 鼠标样式更改gui.stop_click_b['state'] = 'normal'  # 启用停用按钮gui.stop_click_b['cursor'] = 'hand2'  # 鼠标样式更改# 基本与鼠标那边相同····甚至完全可以复用····这么区分清楚些(自我安慰)# 虽然不禁用也行，但怕你们用的时候乱改报错，禁用比较好# 没有禁用的，在启用后更改，应该也能生效gui.use_type_b[0]['state'] = 'disabled'gui.use_type_b[1]['state'] = 'disabled'gui.number_entry['state'] = 'disabled'gui.press_time_entry['state'] = 'disabled'gui.release_time_entry['state'] = 'disabled'gui.sparked_b['state'] = 'disabled'gui.stop_b['state'] = 'disabled'gui.sparked_stop_tab = [False]  # 功能终止标记gui.stop_tab = [True]  # 点击进程终止标记gui.New_ability = lambda g=gui: NA(g)  # 新建按下线程gui.sparked = lambda g=gui: Monitor(gui)  # 监听线程gui.sparked()  # 启动监听# 点击停用按钮时，方法
def Fingerboard_Gui_Stop(gui):gui.stop_click_b['state'] = 'disabled'  # 禁用启用按钮gui.stop_click_b['cursor'] = 'arrow'  # 鼠标样式更改gui.start_click_b['state'] = 'normal'  # 启用停用按钮gui.start_click_b['cursor'] = 'hand2'  # 鼠标样式更改# 启用单选按钮和文本框gui.use_type_b[0]['state'] = 'normal'gui.use_type_b[1]['state'] = 'normal'gui.number_entry['state'] = 'normal'gui.press_time_entry['state'] = 'normal'gui.release_time_entry['state'] = 'normal'gui.sparked_b['state'] = 'normal'gui.stop_b['state'] = 'normal'gui.sparked_stop_tab = [True]  # 功能终止标记gui.stop_tab = [True]  # 点击进程终止标记# 通过单选按钮，改变左边显示的框架
def Chenge_Fingerboard_l(gui):if gui.use.get():  # 选择的是第二个 0/1gui.l_frame_1.grid_forget()  # 取消显示1gui.l_frame_2.grid(row=0, column=0, sticky="nsew")  # 显示2else:  # 选择的是第一个gui.l_frame_1.grid(row=0, column=0, sticky="nsew")  # 显示1gui.l_frame_2.grid_forget()  # 取消显示2# 创建一个键盘功能GUI
def Add_Fingerboard():global data_bar, gui_fingerboardgui_fingerboard.append(tk.LabelFrame(data_bar, text=len(gui_fingerboard), ))  # 添加一个guin = len(gui_fingerboard) - 1  # 当前位置（不想用gui_fingerboard[-1]）# 先搞右半边界面，因为右半边选项会修改左半边界面gui_fingerboard[n].r_frame = tk.LabelFrame(gui_fingerboard[n])  # 右半边框架gui_fingerboard[n].r_frame.grid(row=0, column=1, sticky="nsew")# 第一部分gui_fingerboard[n].use = tk.IntVar()  # 单选按钮的值,用.get()可以取出来,初始0gui_fingerboard[n].use_type_b = [  # 功能选项的单选按钮组，variable控制的变量，value按钮代表的值tk.Radiobutton(gui_fingerboard[n].r_frame, text='输入字符串', variable=gui_fingerboard[n].use,value=0, command=lambda gui=gui_fingerboard[n]: Chenge_Fingerboard_l(gui)),tk.Radiobutton(gui_fingerboard[n].r_frame, text='按下固定键', variable=gui_fingerboard[n].use,value=1, command=lambda gui=gui_fingerboard[n]: Chenge_Fingerboard_l(gui))]for i in range(2):  # 显示一下gui_fingerboard[-1].use_type_b[i].grid(row=0, column=i, )# 第二部分 选择功能的触发键和停止键gui_fingerboard[n].sparked_label = tk.Label(gui_fingerboard[n].r_frame, text='触发按键:')  # 触发按键前的提示文本gui_fingerboard[n].sparked_b = tk.Button(gui_fingerboard[n].r_frame, text='None', )  # 触发按键本身gui_fingerboard[n].sparked_b.key = Nonegui_fingerboard[n].sparked_b['command'] = lambda button=gui_fingerboard[n].sparked_b: Change_Key_B(button)gui_fingerboard[n].stop_label = tk.Label(gui_fingerboard[n].r_frame, text='停止按键:')  # 停止按键前的提示文本gui_fingerboard[n].stop_b = tk.Button(gui_fingerboard[n].r_frame, text='None', )  # 停止按键本身gui_fingerboard[n].stop_b.key = Nonegui_fingerboard[n].stop_b['command'] = lambda button=gui_fingerboard[n].stop_b: Change_Key_B(button)gui_fingerboard[n].sparked_label.grid(row=1, column=0, )  # 把这些显示出来，'w'是靠左(西)的意思。gui_fingerboard[n].sparked_b.grid(row=1, column=1, sticky='w', columnspan=2)gui_fingerboard[n].stop_label.grid(row=2, column=0, )gui_fingerboard[n].stop_b.grid(row=2, column=1, sticky='w', columnspan=2)# 第三部分，启停按钮gui_fingerboard[n].start_click_b = tk.Button(gui_fingerboard[n].r_frame, text='启用', )gui_fingerboard[n].stop_click_b = tk.Button(gui_fingerboard[n].r_frame, text='停用', )gui_fingerboard[n].stop_click_b['state'] = 'disabled'  # 初始，停用按钮为禁用gui_fingerboard[n].stop_click_b['cursor'] = 'arrow'  # 鼠标样式更改gui_fingerboard[n].start_click_b['command'] = lambda gui=gui_fingerboard[n]: Fingerboard_Gui_Start(gui)gui_fingerboard[n].stop_click_b['command'] = lambda gui=gui_fingerboard[n]: Fingerboard_Gui_Stop(gui)gui_fingerboard[n].start_click_b.grid(row=3, column=0, )gui_fingerboard[n].stop_click_b.grid(row=3, column=1, sticky='w', )# 第四部分，删除按钮gui_fingerboard[n].delete = tk.Button(gui_fingerboard[n].r_frame, text='删除', )gui_fingerboard[n].delete['command'] = lambda gui_gather=gui_fingerboard, gui=gui_fingerboard[n]: Delete_gui(gui_gather, gui)gui_fingerboard[n].delete.grid(row=4, column=1, sticky='w', )# 左半边框架gui_fingerboard[n].l_frame_1 = tk.LabelFrame(gui_fingerboard[n])  # 右半边框架 输入字符串gui_fingerboard[n].l_frame_1.grid(row=0, column=0, sticky="nsew")  # 初始是0，显示1gui_fingerboard[n].l_frame_2 = tk.LabelFrame(gui_fingerboard[n])  # 右半边框架 按下固定按钮# gui_fingerboard[n].l_frame_2.grid(row=0, column=0, sticky="nsew")# 选择0时的左半边框架(只包含一个文本框（带滚动条）和一个标签)gui_fingerboard[n].l_frame_1.text_l = tk.Label(gui_fingerboard[n].l_frame_1, text='输入内容')  # 标签提示gui_fingerboard[n].l_frame_1.scrollbar_x = tk.Scrollbar(gui_fingerboard[n].l_frame_1, orient=tk.HORIZONTAL)  # 滚动条xgui_fingerboard[n].l_frame_1.scrollbar_y = tk.Scrollbar(gui_fingerboard[n].l_frame_1, orient=tk.VERTICAL)  # 滚动条ygui_fingerboard[n].l_frame_1.text = tk.Text(gui_fingerboard[n].l_frame_1, width=20, height=8, wrap=tk.NONE,  # 文本框xscrollcommand=gui_fingerboard[n].l_frame_1.scrollbar_x.set,yscrollcommand=gui_fingerboard[n].l_frame_1.scrollbar_y.set, )# 将他们显示出来gui_fingerboard[n].l_frame_1.text_l.pack()gui_fingerboard[n].l_frame_1.scrollbar_x.pack(side=tk.BOTTOM, fill=tk.X)  # 靠下，拉满xgui_fingerboard[n].l_frame_1.scrollbar_x.config(command=gui_fingerboard[n].l_frame_1.text.xview)gui_fingerboard[n].l_frame_1.scrollbar_y.pack(side=tk.RIGHT, fill=tk.Y)  # 靠右，拉满ygui_fingerboard[n].l_frame_1.scrollbar_y.config(command=gui_fingerboard[n].l_frame_1.text.yview)gui_fingerboard[n].l_frame_1.text.pack(fill=tk.BOTH)# 选择1时的左半边框架(包含按键选择，按下次数，按下时间，松开时间)gui_fingerboard[n].presskey_label = tk.Label(gui_fingerboard[n].l_frame_2, text='按下按键:')  # 需要按下按键前的提示文本gui_fingerboard[n].presskey_b = tk.Button(gui_fingerboard[n].l_frame_2, text='None', )  # 需要按下按键本身gui_fingerboard[n].presskey_b.key = Nonegui_fingerboard[n].presskey_b['command'] = lambda button=gui_fingerboard[n].presskey_b: Change_Key_B(button)gui_fingerboard[n].number = tk.IntVar()  # 次数变量，控制点击次数，gui_fingerboard[n].number.set(1)  # 初始给一次gui_fingerboard[n].number_label = tk.Label(gui_fingerboard[n].l_frame_2, text='次数:')  # 次数提示标签gui_fingerboard[n].number_entry = tk.Entry(  # 设定次数文本框gui_fingerboard[n].l_frame_2, exportselection=0, textvariable=gui_fingerboard[n].number)gui_fingerboard[n].number_unit_label = tk.Label(gui_fingerboard[n].l_frame_2, text='次')  # 次数单位标签gui_fingerboard[n].press_time = tk.DoubleVar()  # 按下时间变量，控制按键时间gui_fingerboard[n].press_time.set(0.1)gui_fingerboard[n].press_time_label = tk.Label(gui_fingerboard[n].l_frame_2, text='按下时间:')  # 按下时间提示标签gui_fingerboard[n].press_time_entry = tk.Entry(  # 设定按下时间文本框gui_fingerboard[n].l_frame_2, exportselection=0, textvariable=gui_fingerboard[n].press_time)gui_fingerboard[n].press_time_unit_label = tk.Label(gui_fingerboard[n].l_frame_2, text='s')  # 按下时间单位标签gui_fingerboard[n].release_time = tk.DoubleVar()  # 松开时间变量，控制按键间隔时间gui_fingerboard[n].release_time.set(0.9)gui_fingerboard[n].release_time_label = tk.Label(gui_fingerboard[n].l_frame_2, text='松开时间:')  # 松开时间提示标签gui_fingerboard[n].release_time_entry = tk.Entry(  # 设定松开时间文本框gui_fingerboard[n].l_frame_2, exportselection=0, textvariable=gui_fingerboard[n].release_time)gui_fingerboard[n].release_time_unit_label = tk.Label(gui_fingerboard[n].l_frame_2, text='s')  # 松开时间单位标签gui_fingerboard[n].presskey_label.grid(row=0, column=0, )  # 给这一堆东西放下来gui_fingerboard[n].presskey_b.grid(row=0, column=1, sticky='w', columnspan=2)gui_fingerboard[n].number_label.grid(row=1, column=0, sticky='w')gui_fingerboard[n].number_entry.grid(row=1, column=1, sticky='w')gui_fingerboard[n].number_unit_label.grid(row=1, column=2, sticky='w')gui_fingerboard[n].press_time_label.grid(row=2, column=0, sticky='w')gui_fingerboard[n].press_time_entry.grid(row=2, column=1, sticky='w')gui_fingerboard[n].press_time_unit_label.grid(row=2, column=2, sticky='w')gui_fingerboard[n].release_time_label.grid(row=3, column=0, sticky='w')gui_fingerboard[n].release_time_entry.grid(row=3, column=1, sticky='w')gui_fingerboard[n].release_time_unit_label.grid(row=3, column=2, sticky='w')# 给所有文本框绑定一下点击启/禁用功能t = 0  # 盖住第一个点击位置的调用gui_fingerboard[n].l_frame_1.text.bind('<Button-3>', (lambda t=t, entry=gui_fingerboard[n].l_frame_1.text: Changing_Over(t, entry)))gui_fingerboard[n].number_entry.bind('<Button-3>', (lambda t=t, entry=gui_fingerboard[n].number_entry: Changing_Over(t, entry)))gui_fingerboard[n].press_time_entry.bind('<Button-3>', (lambda t=t, entry=gui_fingerboard[n].press_time_entry: Changing_Over(t, entry)))gui_fingerboard[n].release_time_entry.bind('<Button-3>', (lambda t=t, entry=gui_fingerboard[n].release_time_entry: Changing_Over(t, entry)))# 放缩控制gui_fingerboard[n].columnconfigure(0, weight=1)  # column为0,缩放比为1(列)gui_fingerboard[n].columnconfigure(1, weight=1)  # column为0,缩放比为1for i in range(5):gui_fingerboard[n].l_frame_1.rowconfigure(i, weight=1)gui_fingerboard[n].l_frame_2.rowconfigure(i, weight=1)gui_fingerboard[n].r_frame.rowconfigure(i, weight=1)for i in range(3):gui_fingerboard[n].l_frame_1.columnconfigure(i, weight=1)gui_fingerboard[n].l_frame_2.columnconfigure(i, weight=1)gui_fingerboard[n].r_frame.columnconfigure(i, weight=1)Common_Fingerboard()  # 最后刷新一下gui界面# 录制的数据结构：[[鼠标],[键盘]]
# 鼠标 = {鼠标节点},{鼠标节点},{鼠标节点},
# 鼠标节点 = time: 按下的系统时间， sleep_time: 距离上一次 操作的时间
#           kind: 操作类型（0：初始无操作，1：移动 2：按下 3：滚动）
#           x,y: 鼠标操作的位置， button: 按下的键 pressed: 点击或松开
#           dx,dy:鼠标滚动坐标   类型往后的不一定都有
# 键盘节点 = time: 按下的系统时间， sleep_time: 距离上一次 操作的时间
#           kind: 操作类型（0：初始无操作，1：按下 2：松开）
#           key: 操作的按键# 录制指令
def Action_Record(g):# 录制鼠标def Record_Mouse(g):def l_stop():  # 终止判断if g.sparked_stop_tab[0]:  # 功能终止g.stop_tab[0] = True  # 线程终止listener_mouse.stop()  # 结束监听return Trueif g.stop_tab[0]:  # 进程终止listener_mouse.stop()  # 结束监听return Truereturn Falsedef on_move(x, y):  # 记录鼠标移动if l_stop():  # 终止判断return Falseg.record_data[0].append({'kind': 1, 'time': time.time(), 'x': x, 'y': y})g.record_data[0][-1]['sleep_time'] = g.record_data[0][-1]['time'] - g.record_data[0][-2]['time']def on_click(x, y, button, pressed):  # 记录鼠标点击g.record_data[0].append({'kind': 2, 'time': time.time(), 'x': x, 'y': y, 'button': button, 'pressed': pressed})g.record_data[0][-1]['sleep_time'] = g.record_data[0][-1]['time'] - g.record_data[0][-2]['time']def on_scroll(x, y, dx, dy):  # 记录鼠标滚动if l_stop():  # 终止判断return Falseg.record_data[0].append({'kind': 3, 'time': time.time(), 'x': x, 'y': y, 'dx': dx, 'dy': dy})g.record_data[0][-1]['sleep_time'] = g.record_data[0][-1]['time'] - g.record_data[0][-2]['time']listener_mouse = mouse.Listener(on_move, on_click, on_scroll)listener_mouse.start()# 录制键盘def Record_Keyboard(g):def l_stop():  # 终止判断if g.sparked_stop_tab[0]:  # 功能终止g.stop_tab[0] = True  # 线程终止listener_keyboard.stop()  # 结束监听return Trueif g.stop_tab[0]:  # 进程终止listener_keyboard.stop()  # 结束监听return Truereturn Falsedef on_press(key):  # 按下按键if l_stop():  # 终止判断return Falseg.record_data[1].append({'kind': 1, 'time': time.time(), 'key': key})g.record_data[1][-1]['sleep_time'] = g.record_data[1][-1]['time'] - g.record_data[1][-2]['time']def on_release(key):  # 松开按键g.record_data[1].append({'kind': 2, 'time': time.time(), 'key': key})g.record_data[1][-1]['sleep_time'] = g.record_data[1][-1]['time'] - g.record_data[1][-2]['time']listener_keyboard = keyboard.Listener(on_press=on_press, on_release=on_release)listener_keyboard.start()g.record_data.clear()  # 删除上一回的录制g.record_data.append([{'kind': 0, 'time': time.time(), 'sleep_time': 0, }])  # 保存鼠标g.record_data.append([{'kind': 0, 'time': time.time(), 'sleep_time': 0, }])  # 保存键盘if not g.record_use.get() == 1:  # 录制鼠标Record_Mouse(g)if not g.record_use.get() == 0:  # 录制键盘Record_Keyboard(g)return# 点击左半边录制启用按钮时，方法
def Transcribe_Gui_Start_l(gui):def NA(g):  # 这里不判断操作类型，留到使用时再判断g.ability = Thread(target=lambda g=g: Action_Record(g))# 错误处理if gui.sparked_b['text'] == 'None' or gui.stop_b['text'] == 'None':  # 没有设定按键的情况tk.messagebox.showwarning(title='警告！', message='请设定录制开始和录制停止按键，以免无法开始或者停止')return# 到这里没报错就可以开始进行gui.start_click_b['state'] = 'disabled'  # 禁用启用按钮gui.start_click_b['cursor'] = 'arrow'  # 鼠标样式更改gui.stop_click_b['state'] = 'normal'  # 启用停用按钮gui.stop_click_b['cursor'] = 'hand2'  # 鼠标样式更改# 基本与鼠标那边相同····甚至完全可以复用····这么区分清楚些(自我安慰)# 虽然不禁用也行，但怕你们用的时候乱改报错，禁用比较好# 没有禁用右半边,但是还是劝正常操作.gui.sparked_b['state'] = 'disabled'gui.stop_b['state'] = 'disabled'for i in range(3):gui.record_type_b[i]['state'] = 'disabled'gui.sparked_stop_tab = [False]  # 功能终止标记gui.stop_tab = [True]  # 点击进程终止标记gui.New_ability = lambda g=gui: NA(g)  # 新建按下线程gui.sparked = lambda g=gui: Monitor(gui)  # 监听线程gui.sparked()  # 启动监听# 点击左半边录制停用按钮时，方法
def Transcribe_Gui_Stop_l(gui):gui.stop_click_b['state'] = 'disabled'  # 禁用启用按钮gui.stop_click_b['cursor'] = 'arrow'  # 鼠标样式更改gui.start_click_b['state'] = 'normal'  # 启用停用按钮gui.start_click_b['cursor'] = 'hand2'  # 鼠标样式更改# 启用gui.sparked_b['state'] = 'normal'gui.stop_b['state'] = 'normal'for i in range(3):gui.record_type_b[i]['state'] = 'normal'gui.sparked_stop_tab = [True]  # 功能终止标记gui.stop_tab = [True]  # 点击进程终止标记# 录制重播方法
def Rebroadcast(g):def Rebroadcast_Move():  # 重播鼠标control = Controller()  # 创建鼠标控制对象for i in g.l_frame.record_data[0]:if g.sparked_stop_tab[0]:  # 功能终止g.stop_tab[0] = Truebreakif g.stop_tab[0]:  # 线程终止breaktime.sleep(i['sleep_time'])  # 睡if i['kind'] != 0:  # 不为0，有移动操作control.position = (i['x'], i['y'])if i['kind'] == 2:  # 点击if i['pressed']:control.press(i['button'])else:control.release(i['button'])elif i['kind'] == 3:  # 滚动control.scroll(i['dx'], i['dy'])def Rebroadcast_Keyboard():  # 重播键盘k = keyboard.Controller()  # 创建键盘控制对象for i in g.l_frame.record_data[1]:if g.sparked_stop_tab[0]:g.stop_tab[0] = Truebreakif g.stop_tab[0]:breaktime.sleep(i['sleep_time'])if i['kind'] == 1:k.press(i['key'])elif i['kind'] == 2:k.release(i['key'])rebroadcast_move = Thread(target=Rebroadcast_Move)rebroadcast_keyboard = Thread(target=Rebroadcast_Keyboard)rebroadcast_move.start()rebroadcast_keyboard.start()rebroadcast_move.join()rebroadcast_keyboard.join()g.stop_tab[0] = True# 点击录制重播启用按钮时，方法
def Transcribe_Gui_Start(gui):def NA(g):  # 录制文件重播g.ability = Thread(target=lambda g=g: Rebroadcast(g))if not gui.l_frame.sparked_stop_tab[0]:tk.messagebox.showwarning(title='警告！', message='录制功能正在开启，请停止录制后再使用')returnif gui.sparked_b['text'] == 'None' or gui.stop_b['text'] == 'None':  # 没有设定按键的情况tk.messagebox.showwarning(title='警告！', message='请设定录制开始和录制停止按键，以免无法开始或者停止')returngui.start_click_b['state'] = 'disabled'  # 禁用启用按钮gui.start_click_b['cursor'] = 'arrow'  # 鼠标样式更改gui.stop_click_b['state'] = 'normal'  # 启用停用按钮gui.stop_click_b['cursor'] = 'hand2'  # 鼠标样式更改gui.l_frame.start_click_b['state'] = 'disabled'gui.record_edit['state'] = 'disabled'gui.record_delete['state'] = 'disabled'gui.sparked_b['state'] = 'disabled'gui.stop_b['state'] = 'disabled'gui.sparked_stop_tab = [False]  # 功能终止标记gui.stop_tab = [True]  # 点击进程终止标记gui.New_ability = lambda g=gui: NA(g)  # 新建按下线程gui.sparked = lambda g=gui: Monitor(gui)  # 监听线程gui.sparked()  # 启动监听# 点击录制重播停用按钮时，方法
def Transcribe_Gui_Stop(gui):gui.stop_click_b['state'] = 'disabled'  # 禁用启用按钮gui.stop_click_b['cursor'] = 'arrow'  # 鼠标样式更改gui.start_click_b['state'] = 'normal'  # 启用停用按钮gui.start_click_b['cursor'] = 'hand2'  # 鼠标样式更改# 启用gui.l_frame.start_click_b['state'] = 'normal'gui.record_edit['state'] = 'normal'gui.record_delete['state'] = 'normal'gui.sparked_b['state'] = 'normal'gui.stop_b['state'] = 'normal'gui.sparked_stop_tab = [True]  # 功能终止标记gui.stop_tab = [True]  # 点击进程终止标记# 创建一个录制功能GUI
def Add_Transcribe():global data_bar, gui_transcribegui_transcribe.append(tk.LabelFrame(data_bar, text=len(gui_transcribe), ))  # 添加一个guin = len(gui_transcribe) - 1  # 当前位置（不想用gui_transcribe[-1]）# 左半边界面gui_transcribe[n].l_frame = tk.LabelFrame(gui_transcribe[n])  # 左半边框架gui_transcribe[n].l_frame.grid(row=0, column=0, sticky="nsew")gui_transcribe[n].l_frame.record_data = []  # 录制的数据保存在这里gui_transcribe[n].l_frame.record_data.append([{'kind': 0, 'time': time.time(), 'sleep_time': 0, }])  # 保存鼠标gui_transcribe[n].l_frame.record_data.append([{'kind': 0, 'time': time.time(), 'sleep_time': 0, }])  # 保存键盘# 第一部分,录制选项gui_transcribe[n].l_frame.record_use = tk.IntVar()gui_transcribe[n].l_frame.record_type_b = [tk.Radiobutton(gui_transcribe[n].l_frame, text='仅录鼠标', variable=gui_transcribe[n].l_frame.record_use, value=0),tk.Radiobutton(gui_transcribe[n].l_frame, text='仅录键盘', variable=gui_transcribe[n].l_frame.record_use, value=1),tk.Radiobutton(gui_transcribe[n].l_frame, text='两者都录', variable=gui_transcribe[n].l_frame.record_use, value=2)]for i in range(3):gui_transcribe[n].l_frame.record_type_b[i].grid(row=0, column=i, )# 第二部分,录制开始和停止按钮gui_transcribe[n].l_frame.sparked_label = tk.Label(gui_transcribe[n].l_frame, text='开始录制:')  # 触发按键前的提示文本gui_transcribe[n].l_frame.sparked_b = tk.Button(gui_transcribe[n].l_frame, text='None', )  # 触发按键本身gui_transcribe[n].l_frame.sparked_b.key = Nonegui_transcribe[n].l_frame.sparked_b['command'] = lambda button=gui_transcribe[n].l_frame.sparked_b: Change_Key_B(button)gui_transcribe[n].l_frame.stop_label = tk.Label(gui_transcribe[n].l_frame, text='停止录制:')  # 停止按键前的提示文本gui_transcribe[n].l_frame.stop_b = tk.Button(gui_transcribe[n].l_frame, text='None', )  # 停止按键本身gui_transcribe[n].l_frame.stop_b.key = Nonegui_transcribe[n].l_frame.stop_b['command'] = lambda button=gui_transcribe[n].l_frame.stop_b: Change_Key_B(button)gui_transcribe[n].l_frame.sparked_label.grid(row=1, column=0, )  # 把这些显示出来，'w'是靠左(西)的意思。gui_transcribe[n].l_frame.sparked_b.grid(row=1, column=1, sticky='w', columnspan=2)gui_transcribe[n].l_frame.stop_label.grid(row=2, column=0, )gui_transcribe[n].l_frame.stop_b.grid(row=2, column=1, sticky='w', columnspan=2)# 第三部分,录制的启停按钮gui_transcribe[n].l_frame.start_click_b = tk.Button(gui_transcribe[n].l_frame, text='启用录制', )gui_transcribe[n].l_frame.stop_click_b = tk.Button(gui_transcribe[n].l_frame, text='停用录制', )gui_transcribe[n].l_frame.stop_click_b['state'] = 'disabled'  # 初始，停用按钮为禁用gui_transcribe[n].l_frame.stop_click_b['cursor'] = 'arrow'  # 鼠标样式更改gui_transcribe[n].l_frame.start_click_b['command'] = \lambda gui=gui_transcribe[n].l_frame: Transcribe_Gui_Start_l(gui)gui_transcribe[n].l_frame.stop_click_b['command'] = \lambda gui=gui_transcribe[n].l_frame: Transcribe_Gui_Stop_l(gui)gui_transcribe[n].l_frame.start_click_b.grid(row=3, column=0, )gui_transcribe[n].l_frame.stop_click_b.grid(row=3, column=1, )# 该右半边界面了gui_transcribe[n].r_frame = tk.LabelFrame(gui_transcribe[n])  # 右半边框架gui_transcribe[n].r_frame.grid(row=0, column=1, sticky="nsew")# 第一部分,录制文件编辑和删除按钮gui_transcribe[n].record_edit = tk.Button(gui_transcribe[n].r_frame, text='录制编辑', )gui_transcribe[n].record_delete = tk.Button(gui_transcribe[n].r_frame, text='录制删除', )gui_transcribe[n].record_edit['command'] = lambda data=gui_transcribe[n].l_frame.record_data: Record_Edit(data)gui_transcribe[n].record_delete['command'] = lambda data=gui_transcribe[n].l_frame.record_data: Record_Delete(data)gui_transcribe[n].record_edit.grid(row=0, column=0, sticky="nsew")gui_transcribe[n].record_delete.grid(row=0, column=1, sticky="nsew")# 第二部分,开始和停止按键设置gui_transcribe[n].sparked_label = tk.Label(gui_transcribe[n].r_frame, text='触发按键:')  # 触发按键前的提示文本gui_transcribe[n].sparked_b = tk.Button(gui_transcribe[n].r_frame, text='None', )  # 触发按键本身gui_transcribe[n].sparked_b.key = Nonegui_transcribe[n].sparked_b['command'] = lambda button=gui_transcribe[n].sparked_b: Change_Key_B(button)gui_transcribe[n].stop_label = tk.Label(gui_transcribe[n].r_frame, text='停止按键:')  # 停止按键前的提示文本gui_transcribe[n].stop_b = tk.Button(gui_transcribe[n].r_frame, text='None', )  # 停止按键本身gui_transcribe[n].stop_b.key = Nonegui_transcribe[n].stop_b['command'] = lambda button=gui_transcribe[n].stop_b: Change_Key_B(button)gui_transcribe[n].sparked_label.grid(row=1, column=0, )  # 把这些显示出来，'w'是靠左(西)的意思。gui_transcribe[n].sparked_b.grid(row=1, column=1, sticky='w', columnspan=2)gui_transcribe[n].stop_label.grid(row=2, column=0, )gui_transcribe[n].stop_b.grid(row=2, column=1, sticky='w', columnspan=2)# 第三部分,启停按钮gui_transcribe[n].start_click_b = tk.Button(gui_transcribe[n].r_frame, text='启用', )gui_transcribe[n].stop_click_b = tk.Button(gui_transcribe[n].r_frame, text='停用', )gui_transcribe[n].stop_click_b['state'] = 'disabled'  # 初始，停用按钮为禁用gui_transcribe[n].stop_click_b['cursor'] = 'arrow'  # 鼠标样式更改gui_transcribe[n].start_click_b['command'] = lambda gui=gui_transcribe[n]: Transcribe_Gui_Start(gui)gui_transcribe[n].stop_click_b['command'] = lambda gui=gui_transcribe[n]: Transcribe_Gui_Stop(gui)gui_transcribe[n].start_click_b.grid(row=3, column=0, )gui_transcribe[n].stop_click_b.grid(row=3, column=1, sticky='w', )# 第四部分，删除按钮gui_transcribe[n].delete = tk.Button(gui_transcribe[n].r_frame, text='删除', )gui_transcribe[n].delete['command'] = lambda gui_gather=gui_transcribe, gui=gui_transcribe[n]: Delete_gui(gui_gather, gui)gui_transcribe[n].delete.grid(row=4, column=1, sticky='w', )# 放缩控制gui_transcribe[n].columnconfigure(0, weight=1)  # column为0,缩放比为1(列)gui_transcribe[n].columnconfigure(1, weight=1)  # column为0,缩放比为1for i in range(4):gui_transcribe[n].l_frame.rowconfigure(i, weight=1)gui_transcribe[n].r_frame.rowconfigure(i, weight=1)for i in range(3):gui_transcribe[n].l_frame.columnconfigure(i, weight=1)gui_transcribe[n].l_frame.sparked_stop_tab = [True]  # 功能终止标记gui_transcribe[n].l_frame.stop_tab = [True]  # 点击进程终止标记gui_transcribe[n].r_frame.columnconfigure(0, weight=1)gui_transcribe[n].r_frame.columnconfigure(1, weight=1)gui_transcribe[n].l_frame.use = tk.IntVar()  # 用于兼容键盘gui_transcribe[n].l_frame.use.set(2)gui_transcribe[n].use = tk.IntVar()  # 用于兼容键盘gui_transcribe[n].use.set(2)Common_Transcribe()  # 最后刷新一下gui界面# 由按钮控制的上翻页
def Gui_UP():global works, seat_mouse, seat_fingerboard, seat_transcribeif works == 'mouse':  # 判断当前类型if seat_mouse > 0:  # 看一眼长度是否越界seat_mouse -= 1  # 修改位置Common_Mouse()  # 重新启动elif works == 'fingerboard':if seat_fingerboard > 0:seat_fingerboard -= 1Common_Fingerboard()elif works == 'transcribe':if seat_transcribe > 0:seat_transcribe -= 1Common_Transcribe()# 按钮控制下翻页
def Gui_DOWN():global works, seat_mouse, seat_fingerboard, seat_transcribeglobal gui_mouse, gui_fingerboard, gui_transcribeif works == 'mouse':  # 判断当前类型if seat_mouse < len(gui_mouse) - 1:  # 看一眼长度是否越界seat_mouse += 1  # 修改位置Common_Mouse()  # 重新启动elif works == 'fingerboard':if seat_fingerboard < len(gui_fingerboard) - 1:seat_fingerboard += 1Common_Fingerboard()elif works == 'transcribe':if seat_transcribe < len(gui_transcribe) - 1:seat_transcribe += 1Common_Transcribe()# 重置数据栏
def Resetting_Data_Bar():global data_bar# 遍历所有数据栏组件，取消显示for i in data_bar.grid_slaves():i.grid_forget()# 普通模式功能按钮-鼠标
def Common_Mouse():global gui_mouse, data_bar, gui_data, seat_mouse, works, up_button, down_buttonResetting_Data_Bar()works = 'mouse'up_button.grid(row=0, )down_button.grid(row=4, )i = 0while i < 3:  # 将三个gui放在数据框中,如果没有就放空框if i + seat_mouse >= len(gui_mouse):gui_data[i].grid(row=i + 1, sticky="nsew")else:gui_mouse[i + seat_mouse].grid(row=i + 1, sticky="nsew")i += 1# 普通模式功能按钮-键盘
def Common_Fingerboard():global gui_fingerboard, gui_data, seat_fingerboard, works, up_button, down_buttonResetting_Data_Bar()works = 'fingerboard'up_button.grid(row=0, )down_button.grid(row=4, )i = 0while i < 3:  # 将三个gui放在数据框中,如果没有就放空框if i + seat_fingerboard >= len(gui_fingerboard):gui_data[i].grid(row=i + 1, sticky="nsew")else:gui_fingerboard[i + seat_fingerboard].grid(row=i + 1, sticky="nsew")i += 1# 普通模式功能按钮-录制
def Common_Transcribe():global gui_transcribe, gui_data, seat_transcribe, works, up_button, down_buttonResetting_Data_Bar()works = 'transcribe'up_button.grid(row=0, )down_button.grid(row=4, )i = 0while i < 3:  # 将三个gui放在数据框中,如果没有就放空框if i + seat_transcribe >= len(gui_transcribe):gui_data[i].grid(row=i + 1, sticky="nsew")else:gui_transcribe[i + seat_transcribe].grid(row=i + 1, sticky="nsew")i += 1# 普通模式下功能栏
def Common_Function(function_bar):function_b = [tk.Button(function_bar, text="鼠标功能", command=Common_Mouse),tk.Button(function_bar, text="键盘功能", command=Common_Fingerboard),tk.Button(function_bar, text="录制功能", command=Common_Transcribe)]  # 普通模式功能栏的按钮组for i in range(len(function_b)):function_b[i].grid(row=i, padx=5, pady=2)# 普通模式下的初始数据栏(之后可能把前半部分整合进初始化)
def Common_Data(data_bar):global gui_data, up_button, down_buttondata_bar.rowconfigure(1, weight=1)  # row为0，缩放比为1data_bar.rowconfigure(2, weight=1)  # row为1，缩放比为1data_bar.rowconfigure(3, weight=1)  # row为2，缩放比为1data_bar.columnconfigure(0, weight=1)  # column为0,缩放比为1gui_data = [tk.LabelFrame(data_bar, text="", ),tk.LabelFrame(data_bar, text="", ),tk.LabelFrame(data_bar, text="", )]for i in range(len(gui_data)):gui_data[i].grid(row=i + 1, sticky="nsew")# 添加两个按钮，控制gui滚动up_button = tk.Button(data_bar, text="︿", command=Gui_UP, width=20)up_button.grid(row=0, )down_button = tk.Button(data_bar, text="﹀", command=Gui_DOWN, width=20)down_button.grid(row=4, )# gui_data[0]['text'] = '0'# 初始化函数,初始化鼠标/键盘的GUI
def Initialization():global gui_mouse, gui_fingerboard, gui_transcribe, data_bar# 给每个功能添加新建GUI的栏目gui_mouse = [tk.LabelFrame(data_bar, text="鼠标数据添加", )]mb0 = tk.Button(gui_mouse[0], text="添加鼠标功能", command=Add_Mouse)mb0.pack()gui_fingerboard = [tk.LabelFrame(data_bar, text="键盘数据添加", )]fb0 = tk.Button(gui_fingerboard[0], text="添加键盘功能", command=Add_Fingerboard)fb0.pack()gui_transcribe = [tk.LabelFrame(data_bar, text="录制数据添加", )]tb0 = tk.Button(gui_transcribe[0], text="添加录制功能", command=Add_Transcribe)tb0.pack()works = None  # 当前功能
gui_mouse = []  # 鼠标功能界面
gui_fingerboard = []  # 键盘功能界面
gui_transcribe = []  # 录制功能界面
seat_mouse = 0  # 鼠标界面位置
seat_fingerboard = 0  # 键盘界面位置
seat_transcribe = 0  # 录制界面位置
main_window = tk.Tk()  # 调用Tk()创建主窗口
main_window.title("鼠标键盘模拟器")  # 给主窗口起一个名字
main_window.geometry("700x800+200+100")  # 大小
main_window.config(menu=Generate_Menu(main_window))  # 生成菜单栏，窗口与菜单关联
main_window.rowconfigure(0, weight=1)  # row为0，缩放比为1
main_window.columnconfigure(0, minsize=65)  # column为0,最小65
main_window.columnconfigure(1, weight=5)  # column为1，缩放比为1
function_bar = tk.LabelFrame(main_window, text="功能栏", bg='gainsboro')  # 放左边功能栏的框架
function_bar.grid(row=0, column=0, sticky="nsew")
Common_Function(function_bar)  # 普通模式下功能栏
data_bar = tk.LabelFrame(main_window, text="数据栏", )  # 右边的数据栏框架
data_bar.grid(row=0, column=1, sticky="nsew")
Common_Data(data_bar)  # 普通模式下数据栏
Initialization()  # GUI数据初始化
# 避免玩脱的关闭线程 导出为exe时有用，在编译器还是用Ctrl+F2，这里默认的是ctrl+shift+大写键+回车
close_program = [keyboard.Key.ctrl_l,keyboard.Key.shift,keyboard.Key.caps_lock,keyboard.Key.enter]
# 终止所有功能的按键，这里默认的是ctrl+shift+大写键+tab
stop_all_key = [keyboard.Key.ctrl_l,keyboard.Key.shift,keyboard.Key.caps_lock,keyboard.Key.tab]
stop_listener = None
Close_Program()  # 监听紧急关闭和紧急中止
main_window.mainloop()  # 开启主循环，让窗口处于显示状态

界面展示：