5019 lines
232 KiB
Python
5019 lines
232 KiB
Python
import tkinter as tk
|
||
from tkinter import ttk, messagebox, filedialog
|
||
import os
|
||
import subprocess
|
||
import win32gui
|
||
import win32process
|
||
import win32con
|
||
import win32api
|
||
import win32com.client
|
||
import json
|
||
import requests
|
||
from typing import List, Dict, Optional
|
||
import math
|
||
import ctypes
|
||
from ctypes import wintypes
|
||
import threading
|
||
import time
|
||
import sys
|
||
import keyboard
|
||
import mouse
|
||
import webbrowser
|
||
import sv_ttk
|
||
import win32security
|
||
# 添加通知错误处理
|
||
try:
|
||
from win11toast import notify, toast
|
||
except ImportError:
|
||
# 简单的空函数替代
|
||
def toast(title, message, **kwargs):
|
||
pass
|
||
def notify(title, message, **kwargs):
|
||
pass
|
||
import re
|
||
import socket
|
||
import traceback
|
||
import wmi
|
||
import pythoncom # 添加pythoncom导入
|
||
import concurrent.futures
|
||
import random
|
||
|
||
# 添加滚轮钩子所需的结构体定义
|
||
class POINT(ctypes.Structure):
|
||
_fields_ = [("x", ctypes.c_long), ("y", ctypes.c_long)]
|
||
|
||
class MSLLHOOKSTRUCT(ctypes.Structure):
|
||
_fields_ = [
|
||
("pt", POINT),
|
||
("mouseData", wintypes.DWORD),
|
||
("flags", wintypes.DWORD),
|
||
("time", wintypes.DWORD),
|
||
("dwExtraInfo", ctypes.POINTER(wintypes.ULONG))
|
||
]
|
||
|
||
def is_admin():
|
||
# 检查是否具有管理员权限
|
||
try:
|
||
return ctypes.windll.shell32.IsUserAnAdmin()
|
||
except:
|
||
return False
|
||
|
||
def run_as_admin():
|
||
# 以管理员权限重新运行程序
|
||
ctypes.windll.shell32.ShellExecuteW(None, "runas", sys.executable, " ".join(sys.argv), None, 1)
|
||
|
||
class ChromeManager:
|
||
def __init__(self):
|
||
"""初始化"""
|
||
# 记录启动时间用于性能分析
|
||
self.start_time = time.time()
|
||
|
||
# 默认设置值
|
||
self.show_chrome_tip = True # 是否显示Chrome后台运行提示
|
||
|
||
# 加载设置
|
||
self.settings = self.load_settings()
|
||
|
||
self.enable_cdp = True # 始终开启CDP
|
||
|
||
# 从设置中读取是否显示Chrome提示的设置
|
||
if 'show_chrome_tip' in self.settings:
|
||
self.show_chrome_tip = self.settings['show_chrome_tip']
|
||
|
||
# 滚轮钩子相关参数
|
||
self.wheel_hook_id = None
|
||
self.wheel_hook_proc = None
|
||
self.standard_wheel_delta = 120 # 标准滚轮增量值
|
||
self.last_wheel_time = 0
|
||
self.wheel_threshold = 0.05 # 秒，防止事件触发过于频繁
|
||
self.use_wheel_hook = True # 是否使用滚轮钩子
|
||
|
||
# 存储快捷方式编号和进程ID的映射关系
|
||
self.shortcut_to_pid = {}
|
||
# 存储进程ID和窗口编号的映射关系
|
||
self.pid_to_number = {}
|
||
|
||
if not is_admin():
|
||
if messagebox.askyesno("权限不足", "需要管理员权限才能运行同步功能。\n是否以管理员身份重新启动程序？"):
|
||
run_as_admin()
|
||
sys.exit()
|
||
|
||
# 确保settings.json文件存在
|
||
if not os.path.exists('settings.json'):
|
||
with open('settings.json', 'w', encoding='utf-8') as f:
|
||
json.dump({}, f, ensure_ascii=False, indent=4)
|
||
|
||
self.root = tk.Tk()
|
||
self.root.title("NoBiggie社区Chrome多窗口管理器 V2.0")
|
||
|
||
# 先隐藏主窗口，避免闪烁
|
||
self.root.withdraw()
|
||
|
||
# 随机数字输入相关配置 - 移动到root创建之后
|
||
self.random_min_value = tk.StringVar(value="1000")
|
||
self.random_max_value = tk.StringVar(value="2000")
|
||
self.random_overwrite = tk.BooleanVar(value=True)
|
||
self.random_delayed = tk.BooleanVar(value=False)
|
||
|
||
try:
|
||
icon_path = os.path.join(os.path.dirname(__file__), "app.ico")
|
||
if os.path.exists(icon_path):
|
||
self.root.iconbitmap(icon_path)
|
||
except Exception as e:
|
||
print(f"设置图标失败: {str(e)}")
|
||
|
||
# 设置固定的窗口大小
|
||
self.window_width = 700
|
||
self.window_height = 360
|
||
self.root.geometry(f"{self.window_width}x{self.window_height}")
|
||
self.root.resizable(False, False)
|
||
|
||
# 设置关闭事件处理
|
||
self.root.protocol("WM_DELETE_WINDOW", self.on_closing)
|
||
|
||
# 加载主题
|
||
sv_ttk.set_theme("light")
|
||
print(f"[{time.time() - self.start_time:.3f}s] 主题加载完成")
|
||
|
||
# 仅保存/加载窗口位置，不包括大小
|
||
last_position = self.load_window_position()
|
||
if last_position:
|
||
try:
|
||
# 直接使用返回的位置信息
|
||
self.root.geometry(f"{self.window_width}x{self.window_height}{last_position}")
|
||
except Exception as e:
|
||
print(f"应用窗口位置时出错: {e}")
|
||
|
||
self.window_list = None
|
||
self.windows = []
|
||
self.master_window = None
|
||
self.screens = [] # 初始化屏幕列表
|
||
|
||
# 从设置加载所有路径
|
||
self.shortcut_path = self.settings.get('shortcut_path', '')
|
||
self.cache_dir = self.settings.get('cache_dir', '')
|
||
self.icon_dir = self.settings.get('icon_dir', '')
|
||
self.screen_selection = self.settings.get('screen_selection', '')
|
||
|
||
print("初始化加载设置:", self.settings) # 调试输出
|
||
|
||
self.path_entry = None
|
||
|
||
# 初始化快捷键相关属性
|
||
self.shortcut_hook = None
|
||
self.current_shortcut = self.settings.get('sync_shortcut', None)
|
||
if self.current_shortcut:
|
||
self.set_shortcut(self.current_shortcut)
|
||
|
||
self.shell = win32com.client.Dispatch("WScript.Shell")
|
||
self.select_all_var = tk.StringVar(value="全部选择")
|
||
|
||
self.is_syncing = False
|
||
self.sync_button = None
|
||
self.mouse_hook_id = None
|
||
self.keyboard_hook = None
|
||
self.hook_thread = None
|
||
self.user32 = ctypes.WinDLL('user32', use_last_error=True)
|
||
self.sync_windows = []
|
||
|
||
self.chrome_drivers = {}
|
||
|
||
# 调试端口映射 - 将窗口号映射到调试端口
|
||
self.debug_ports = {}
|
||
# 基础调试端口
|
||
self.base_debug_port = 9222
|
||
|
||
self.DWMWA_BORDER_COLOR = 34
|
||
self.DWM_MAGIC_COLOR = 0x00FF0000
|
||
|
||
self.popup_mappings = {}
|
||
|
||
self.popup_monitor_thread = None
|
||
|
||
self.mouse_threshold = 3
|
||
self.last_mouse_position = (0, 0)
|
||
self.last_move_time = 0
|
||
self.move_interval = 0.016
|
||
|
||
# 创建样式
|
||
self.create_styles()
|
||
|
||
# 创建界面
|
||
self.create_widgets()
|
||
|
||
# 更新树形视图样式
|
||
self.update_treeview_style()
|
||
|
||
# 窗口尺寸已在初始化时固定，无需再次调整
|
||
|
||
# 在初始化时设置进程缓解策略
|
||
PROCESS_CREATION_MITIGATION_POLICY_BLOCK_NON_MICROSOFT_BINARIES_ALWAYS_ON = 0x100000000000
|
||
ctypes.windll.kernel32.SetProcessMitigationPolicy(
|
||
0, # ProcessSignaturePolicy
|
||
ctypes.byref(ctypes.c_ulonglong(PROCESS_CREATION_MITIGATION_POLICY_BLOCK_NON_MICROSOFT_BINARIES_ALWAYS_ON)),
|
||
ctypes.sizeof(ctypes.c_ulonglong)
|
||
)
|
||
|
||
# 检测Windows版本
|
||
self.win_ver = sys.getwindowsversion()
|
||
self.is_win11 = self.win_ver.build >= 22000
|
||
|
||
# 初始化系统托盘通知
|
||
try:
|
||
if self.is_win11:
|
||
# Windows 11使用toast通知
|
||
self.notify_func = toast
|
||
else:
|
||
# Windows 10使用win32gui通知
|
||
self.hwnd = win32gui.GetForegroundWindow()
|
||
self.notification_flags = win32gui.NIF_ICON | win32gui.NIF_INFO | win32gui.NIF_TIP
|
||
|
||
# 加载app.ico图标
|
||
try:
|
||
icon_path = os.path.join(os.path.dirname(__file__), "app.ico")
|
||
if os.path.exists(icon_path):
|
||
# 加载应用程序图标
|
||
icon_handle = win32gui.LoadImage(
|
||
0, icon_path, win32con.IMAGE_ICON,
|
||
0, 0, win32con.LR_LOADFROMFILE | win32con.LR_DEFAULTSIZE
|
||
)
|
||
else:
|
||
# 使用默认图标
|
||
icon_handle = win32gui.LoadIcon(0, win32con.IDI_APPLICATION)
|
||
except Exception as e:
|
||
print(f"加载托盘图标失败: {str(e)}")
|
||
icon_handle = win32gui.LoadIcon(0, win32con.IDI_APPLICATION)
|
||
|
||
self.notify_id = (
|
||
self.hwnd,
|
||
0,
|
||
self.notification_flags,
|
||
win32con.WM_USER + 20,
|
||
icon_handle,
|
||
"Chrome多窗口管理器"
|
||
)
|
||
|
||
# 先注册托盘图标
|
||
try:
|
||
win32gui.Shell_NotifyIcon(win32gui.NIM_ADD, self.notify_id)
|
||
except Exception as e:
|
||
print(f"注册托盘图标失败: {str(e)}")
|
||
except Exception as e:
|
||
print(f"初始化通知功能失败: {str(e)}")
|
||
|
||
# 创建右键菜单
|
||
self.context_menu = tk.Menu(self.root, tearoff=0)
|
||
self.context_menu.add_command(label="剪切", command=self.cut_text)
|
||
self.context_menu.add_command(label="复制", command=self.copy_text)
|
||
self.context_menu.add_command(label="粘贴", command=self.paste_text)
|
||
self.context_menu.add_separator()
|
||
self.context_menu.add_command(label="全选", command=self.select_all_text)
|
||
|
||
# 保存当前焦点的文本框引用
|
||
self.current_text_widget = None
|
||
|
||
# 添加CDP WebSocket连接池
|
||
#self.ws_connections = {}
|
||
#self.ws_lock = threading.Lock()
|
||
#self.scroll_sync_enabled = True # 添加滚轮同步控制标志
|
||
|
||
# 安排延迟初始化
|
||
self.root.after(100, self.delayed_initialization)
|
||
print(f"[{time.time() - self.start_time:.3f}s] __init__ 完成, 已安排延迟初始化")
|
||
|
||
def create_styles(self):
|
||
style = ttk.Style()
|
||
|
||
default_font = ('Microsoft YaHei UI', 9)
|
||
|
||
style.configure('Small.TEntry',
|
||
padding=(4, 0),
|
||
font=default_font
|
||
)
|
||
|
||
style.configure('TButton', font=default_font)
|
||
style.configure('TLabel', font=default_font)
|
||
style.configure('TEntry', font=default_font)
|
||
style.configure('Treeview', font=default_font)
|
||
style.configure('Treeview.Heading', font=default_font)
|
||
style.configure('TLabelframe.Label', font=default_font)
|
||
style.configure('TNotebook.Tab', font=default_font)
|
||
|
||
# 链接样式
|
||
style.configure('Link.TLabel',
|
||
foreground='#0d6efd',
|
||
cursor='hand2',
|
||
font=('Microsoft YaHei UI', 9, 'underline')
|
||
)
|
||
|
||
def update_treeview_style(self):
|
||
"""更新Treeview组件的样式，此方法应在window_list初始化后调用"""
|
||
if self.window_list:
|
||
self.window_list.tag_configure("master",
|
||
background="#0d6efd",
|
||
foreground="white")
|
||
|
||
def create_widgets(self):
|
||
"""创建界面元素"""
|
||
main_frame = ttk.Frame(self.root)
|
||
main_frame.pack(fill=tk.X, padx=10, pady=5)
|
||
|
||
upper_frame = ttk.Frame(main_frame)
|
||
upper_frame.pack(fill=tk.X)
|
||
|
||
arrange_frame = ttk.LabelFrame(upper_frame, text="自定义排列")
|
||
arrange_frame.pack(side=tk.RIGHT, fill=tk.Y, padx=(3, 0))
|
||
|
||
manage_frame = ttk.LabelFrame(upper_frame, text="窗口管理")
|
||
manage_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=(0, 5))
|
||
|
||
# 创建两行按钮区域
|
||
button_rows = ttk.Frame(manage_frame)
|
||
button_rows.pack(fill=tk.X)
|
||
|
||
# 第一行：基本操作按钮
|
||
first_row = ttk.Frame(button_rows)
|
||
first_row.pack(fill=tk.X)
|
||
|
||
ttk.Button(first_row, text="导入窗口", command=self.import_windows, style='Accent.TButton').pack(side=tk.LEFT, padx=2)
|
||
select_all_label = ttk.Label(first_row, textvariable=self.select_all_var, style='Link.TLabel')
|
||
select_all_label.pack(side=tk.LEFT, padx=5)
|
||
select_all_label.bind('<Button-1>', self.toggle_select_all)
|
||
ttk.Button(first_row, text="自动排列", command=self.auto_arrange_windows).pack(side=tk.LEFT, padx=2)
|
||
ttk.Button(first_row, text="关闭选中", command=self.close_selected_windows).pack(side=tk.LEFT, padx=2)
|
||
|
||
self.sync_button = ttk.Button(
|
||
first_row,
|
||
text="▶ 开始同步",
|
||
command=self.toggle_sync,
|
||
style='Accent.TButton'
|
||
)
|
||
self.sync_button.pack(side=tk.LEFT, padx=5)
|
||
|
||
# 添加设置按钮
|
||
ttk.Button(
|
||
first_row,
|
||
text="🔗 设置",
|
||
command=self.show_settings_dialog,
|
||
width=8
|
||
).pack(side=tk.LEFT, padx=2)
|
||
|
||
list_frame = ttk.Frame(manage_frame)
|
||
list_frame.pack(fill=tk.BOTH, expand=True, pady=(2, 0))
|
||
|
||
# 创建窗口列表
|
||
self.window_list = ttk.Treeview(list_frame,
|
||
columns=("select", "number", "title", "master", "hwnd"),
|
||
show="headings",
|
||
height=4,
|
||
style='Accent.Treeview'
|
||
)
|
||
self.window_list.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
|
||
|
||
self.window_list.heading("select", text="选择")
|
||
self.window_list.heading("number", text="窗口序号")
|
||
self.window_list.heading("title", text="页面标题")
|
||
self.window_list.heading("master", text="主控")
|
||
self.window_list.heading("hwnd", text="")
|
||
|
||
self.window_list.column("select", width=50, anchor="center")
|
||
self.window_list.column("number", width=60, anchor="center")
|
||
self.window_list.column("title", width=260)
|
||
self.window_list.column("master", width=50, anchor="center")
|
||
self.window_list.column("hwnd", width=0, stretch=False) # 隐藏hwnd列
|
||
|
||
self.window_list.tag_configure("master", background="lightblue")
|
||
|
||
self.window_list.bind('<Button-1>', self.on_click)
|
||
|
||
# 添加右键菜单功能
|
||
self.window_list_menu = tk.Menu(self.root, tearoff=0)
|
||
self.window_list_menu.add_command(label="关闭此窗口", command=self.close_selected_window)
|
||
self.window_list.bind('<Button-3>', self.show_window_list_menu)
|
||
|
||
# 添加滚动条
|
||
scrollbar = ttk.Scrollbar(list_frame, orient=tk.VERTICAL, command=self.window_list.yview)
|
||
scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
|
||
self.window_list.configure(yscrollcommand=scrollbar.set)
|
||
|
||
params_frame = ttk.Frame(arrange_frame)
|
||
params_frame.pack(fill=tk.X, padx=5, pady=2)
|
||
|
||
left_frame = ttk.Frame(params_frame)
|
||
left_frame.pack(side=tk.LEFT, padx=(0, 5))
|
||
right_frame = ttk.Frame(params_frame)
|
||
right_frame.pack(side=tk.LEFT)
|
||
|
||
ttk.Label(left_frame, text="起始X坐标").pack(anchor=tk.W)
|
||
self.start_x = ttk.Entry(left_frame, width=8, style='Small.TEntry')
|
||
self.start_x.pack(fill=tk.X, pady=(0, 2))
|
||
self.start_x.insert(0, "0")
|
||
self.setup_right_click_menu(self.start_x)
|
||
|
||
ttk.Label(left_frame, text="窗口宽度").pack(anchor=tk.W)
|
||
self.window_width = ttk.Entry(left_frame, width=8, style='Small.TEntry')
|
||
self.window_width.pack(fill=tk.X, pady=(0, 2))
|
||
self.window_width.insert(0, "500")
|
||
self.setup_right_click_menu(self.window_width)
|
||
|
||
ttk.Label(left_frame, text="水平间距").pack(anchor=tk.W)
|
||
self.h_spacing = ttk.Entry(left_frame, width=8, style='Small.TEntry')
|
||
self.h_spacing.pack(fill=tk.X, pady=(0, 2))
|
||
self.h_spacing.insert(0, "0")
|
||
self.setup_right_click_menu(self.h_spacing)
|
||
|
||
ttk.Label(right_frame, text="起始Y坐标").pack(anchor=tk.W)
|
||
self.start_y = ttk.Entry(right_frame, width=8, style='Small.TEntry')
|
||
self.start_y.pack(fill=tk.X, pady=(0, 2))
|
||
self.start_y.insert(0, "0")
|
||
self.setup_right_click_menu(self.start_y)
|
||
|
||
ttk.Label(right_frame, text="窗口高度").pack(anchor=tk.W)
|
||
self.window_height = ttk.Entry(right_frame, width=8, style='Small.TEntry')
|
||
self.window_height.pack(fill=tk.X, pady=(0, 2))
|
||
self.window_height.insert(0, "400")
|
||
self.setup_right_click_menu(self.window_height)
|
||
|
||
ttk.Label(right_frame, text="垂直间距").pack(anchor=tk.W)
|
||
self.v_spacing = ttk.Entry(right_frame, width=8, style='Small.TEntry')
|
||
self.v_spacing.pack(fill=tk.X, pady=(0, 2))
|
||
self.v_spacing.insert(0, "0")
|
||
self.setup_right_click_menu(self.v_spacing)
|
||
|
||
for widget in left_frame.winfo_children() + right_frame.winfo_children():
|
||
if isinstance(widget, ttk.Entry):
|
||
widget.pack_configure(pady=(0, 2))
|
||
|
||
bottom_frame = ttk.Frame(arrange_frame)
|
||
bottom_frame.pack(fill=tk.X, padx=5, pady=2)
|
||
|
||
row_frame = ttk.Frame(bottom_frame)
|
||
row_frame.pack(side=tk.LEFT)
|
||
ttk.Label(row_frame, text="每行窗口数").pack(anchor=tk.W)
|
||
self.windows_per_row = ttk.Entry(row_frame, width=8, style='Small.TEntry')
|
||
self.windows_per_row.pack(pady=(2, 0))
|
||
self.windows_per_row.insert(0, "5")
|
||
self.setup_right_click_menu(self.windows_per_row)
|
||
|
||
ttk.Button(bottom_frame, text="自定义排列",
|
||
command=self.custom_arrange_windows,
|
||
style='Accent.TButton'
|
||
).pack(side=tk.RIGHT, pady=(15, 0))
|
||
|
||
bottom_frame = ttk.Frame(self.root)
|
||
bottom_frame.pack(fill=tk.X, padx=10, pady=(5, 0))
|
||
|
||
self.tab_control = ttk.Notebook(bottom_frame)
|
||
self.tab_control.pack(side=tk.LEFT, fill=tk.X, expand=True)
|
||
|
||
# 打开窗口标签
|
||
open_window_tab = ttk.Frame(self.tab_control)
|
||
self.tab_control.add(open_window_tab, text="打开窗口")
|
||
|
||
# 简化布局结构，移除多余的嵌套frame
|
||
numbers_frame = ttk.Frame(open_window_tab)
|
||
numbers_frame.pack(fill=tk.X, padx=10, pady=10) # 统一顶部边距
|
||
ttk.Label(numbers_frame, text="窗口编号:").pack(side=tk.LEFT)
|
||
self.numbers_entry = ttk.Entry(numbers_frame, width=20)
|
||
self.numbers_entry.pack(side=tk.LEFT, padx=5)
|
||
self.setup_right_click_menu(self.numbers_entry)
|
||
|
||
settings = self.load_settings()
|
||
if 'last_window_numbers' in settings:
|
||
self.numbers_entry.insert(0, settings['last_window_numbers'])
|
||
|
||
self.numbers_entry.bind('<Return>', lambda e: self.open_windows())
|
||
|
||
ttk.Button(
|
||
numbers_frame,
|
||
text="打开窗口",
|
||
command=self.open_windows,
|
||
style='Accent.TButton'
|
||
).pack(side=tk.LEFT, padx=5)
|
||
|
||
# 添加示例文字
|
||
ttk.Label(numbers_frame, text="示例: 1-5 或 1,3,5").pack(side=tk.LEFT, padx=5)
|
||
|
||
# 批量打开网页标签
|
||
url_tab = ttk.Frame(self.tab_control)
|
||
self.tab_control.add(url_tab, text="批量打开网页")
|
||
|
||
url_frame = ttk.Frame(url_tab)
|
||
url_frame.pack(fill=tk.X, padx=10, pady=10) # 统一边距
|
||
ttk.Label(url_frame, text="网址:").pack(side=tk.LEFT)
|
||
self.url_entry = ttk.Entry(url_frame, width=20)
|
||
self.url_entry.pack(side=tk.LEFT, padx=5)
|
||
self.url_entry.insert(0, "www.google.com")
|
||
|
||
self.url_entry.bind('<Return>', lambda e: self.batch_open_urls())
|
||
|
||
ttk.Button(
|
||
url_frame,
|
||
text="批量打开",
|
||
command=self.batch_open_urls,
|
||
style='Accent.TButton' # 设置蓝色风格
|
||
).pack(side=tk.LEFT, padx=5)
|
||
|
||
# 添加几个常用网站快速打开按钮
|
||
twitter_button = ttk.Button(
|
||
url_frame,
|
||
text="Twitter",
|
||
command=lambda: self.set_quick_url("https://twitter.com"),
|
||
style='Quick.TButton', # 使用自定义样式
|
||
width=8
|
||
)
|
||
twitter_button.pack(side=tk.LEFT, padx=2)
|
||
|
||
discord_button = ttk.Button(
|
||
url_frame,
|
||
text="Discord",
|
||
command=lambda: self.set_quick_url("https://discord.com/channels/@me"),
|
||
style='Quick.TButton', # 使用自定义样式
|
||
width=8
|
||
)
|
||
discord_button.pack(side=tk.LEFT, padx=2)
|
||
|
||
gmail_button = ttk.Button(
|
||
url_frame,
|
||
text="Gmail",
|
||
command=lambda: self.set_quick_url("https://mail.google.com"),
|
||
style='Quick.TButton', # 使用自定义样式
|
||
width=8
|
||
)
|
||
gmail_button.pack(side=tk.LEFT, padx=2)
|
||
|
||
# 标签页管理标签
|
||
tab_manage_tab = ttk.Frame(self.tab_control)
|
||
self.tab_control.add(tab_manage_tab, text="标签页管理")
|
||
|
||
tab_manage_frame = ttk.Frame(tab_manage_tab)
|
||
tab_manage_frame.pack(fill=tk.X, padx=10, pady=10)
|
||
|
||
ttk.Button(
|
||
tab_manage_frame,
|
||
text="仅保留当前标签页",
|
||
command=self.keep_only_current_tab,
|
||
width=20,
|
||
style='Accent.TButton' # 应用蓝色风格
|
||
).pack(side=tk.LEFT, padx=5)
|
||
|
||
ttk.Button(
|
||
tab_manage_frame,
|
||
text="仅保留新标签页",
|
||
command=self.keep_only_new_tab,
|
||
width=20,
|
||
style='Accent.TButton' # 应用蓝色风格
|
||
).pack(side=tk.LEFT, padx=5)
|
||
|
||
# 添加随机数字输入标签
|
||
random_number_tab = ttk.Frame(self.tab_control)
|
||
self.tab_control.add(random_number_tab, text="批量文本输入")
|
||
|
||
# 简化界面，只添加两个按钮
|
||
buttons_frame = ttk.Frame(random_number_tab)
|
||
buttons_frame.pack(fill=tk.X, padx=10, pady=10)
|
||
|
||
ttk.Button(
|
||
buttons_frame,
|
||
text="随机数字输入",
|
||
command=self.show_random_number_dialog,
|
||
width=20,
|
||
style='Accent.TButton' # 应用蓝色风格
|
||
).pack(side=tk.LEFT, padx=10)
|
||
|
||
ttk.Button(
|
||
buttons_frame,
|
||
text="指定文本输入",
|
||
command=self.show_text_input_dialog,
|
||
width=20,
|
||
style='Accent.TButton' # 应用蓝色风格
|
||
).pack(side=tk.LEFT, padx=10)
|
||
|
||
|
||
|
||
# 批量创建环境标签
|
||
env_create_tab = ttk.Frame(self.tab_control)
|
||
self.tab_control.add(env_create_tab, text="批量创建环境")
|
||
|
||
# 统一框架布局
|
||
input_row = ttk.Frame(env_create_tab)
|
||
input_row.pack(fill=tk.X, padx=10, pady=10) # 统一边距
|
||
|
||
# 环境编号
|
||
ttk.Label(input_row, text="创建编号:").pack(side=tk.LEFT)
|
||
self.env_numbers = ttk.Entry(input_row, width=20)
|
||
self.env_numbers.pack(side=tk.LEFT, padx=5)
|
||
self.setup_right_click_menu(self.env_numbers)
|
||
|
||
# 创建按钮
|
||
ttk.Button(
|
||
input_row,
|
||
text="开始创建",
|
||
command=self.create_environments,
|
||
style='Accent.TButton' # 设置蓝色风格
|
||
).pack(side=tk.LEFT, padx=5)
|
||
|
||
# 示例文字
|
||
ttk.Label(input_row, text="示例: 1-5,7,9-12").pack(side=tk.LEFT, padx=5)
|
||
|
||
# 替换图标标签页
|
||
icon_tab = ttk.Frame(self.tab_control)
|
||
self.tab_control.add(icon_tab, text="替换图标")
|
||
|
||
icon_frame = ttk.Frame(icon_tab)
|
||
icon_frame.pack(fill=tk.X, padx=10, pady=10) # 统一边距
|
||
|
||
ttk.Label(icon_frame, text="窗口编号:").pack(side=tk.LEFT)
|
||
self.icon_window_numbers = ttk.Entry(icon_frame, width=20)
|
||
self.icon_window_numbers.pack(side=tk.LEFT, padx=5)
|
||
|
||
ttk.Button(
|
||
icon_frame,
|
||
text="替换图标",
|
||
command=self.set_taskbar_icons,
|
||
style='Accent.TButton' # 设置蓝色风格
|
||
).pack(side=tk.LEFT, padx=5)
|
||
|
||
# 示例文字
|
||
ttk.Label(icon_frame, text="示例: 1-5,7,9-12").pack(side=tk.LEFT, padx=5)
|
||
|
||
# 底部按钮框架 - 在所有标签页设置完成后添加
|
||
footer_frame = ttk.Frame(self.root)
|
||
footer_frame.pack(side=tk.BOTTOM, fill=tk.X, padx=10, pady=5)
|
||
|
||
# 添加左侧的超链接
|
||
donate_frame = ttk.Frame(footer_frame)
|
||
donate_frame.pack(side=tk.LEFT)
|
||
|
||
donate_label = ttk.Label(
|
||
donate_frame,
|
||
text="铸造一个看上去没什么用的NFT 0.1SOL（其实就是打赏啦 😁）",
|
||
cursor="hand2",
|
||
foreground="black"
|
||
# 移除字体设置，使用系统默认字体
|
||
)
|
||
donate_label.pack(side=tk.LEFT)
|
||
donate_label.bind("<Button-1>", lambda e: webbrowser.open("https://truffle.wtf/project/Devilflasher"))
|
||
|
||
author_frame = ttk.Frame(footer_frame)
|
||
author_frame.pack(side=tk.RIGHT)
|
||
|
||
ttk.Label(author_frame, text="Compiled by Devilflasher").pack(side=tk.LEFT)
|
||
|
||
ttk.Label(author_frame, text=" ").pack(side=tk.LEFT)
|
||
|
||
twitter_label = ttk.Label(
|
||
author_frame,
|
||
text="Twitter",
|
||
cursor="hand2",
|
||
font=("Arial", 9)
|
||
)
|
||
twitter_label.pack(side=tk.LEFT)
|
||
twitter_label.bind("<Button-1>", lambda e: webbrowser.open("https://x.com/DevilflasherX"))
|
||
|
||
ttk.Label(author_frame, text=" ").pack(side=tk.LEFT)
|
||
|
||
telegram_label = ttk.Label(
|
||
author_frame,
|
||
text="Telegram",
|
||
cursor="hand2",
|
||
font=("Arial", 9)
|
||
)
|
||
telegram_label.pack(side=tk.LEFT)
|
||
telegram_label.bind("<Button-1>", lambda e: webbrowser.open("https://t.me/devilflasher0"))
|
||
|
||
def toggle_select_all(self, event=None):
|
||
#切换全选状态
|
||
try:
|
||
items = self.window_list.get_children()
|
||
if not items:
|
||
return
|
||
|
||
|
||
current_text = self.select_all_var.get()
|
||
|
||
|
||
if current_text == "全部选择":
|
||
|
||
for item in items:
|
||
self.window_list.set(item, "select", "√")
|
||
else:
|
||
|
||
for item in items:
|
||
self.window_list.set(item, "select", "")
|
||
|
||
# 更新按钮状态
|
||
self.update_select_all_status()
|
||
|
||
except Exception as e:
|
||
print(f"切换全选状态失败: {str(e)}")
|
||
|
||
def update_select_all_status(self):
|
||
# 更新全选状态
|
||
try:
|
||
# 获取所有项目
|
||
items = self.window_list.get_children()
|
||
if not items:
|
||
self.select_all_var.set("全部选择")
|
||
return
|
||
|
||
# 检查是否全部选中
|
||
selected_count = sum(1 for item in items if self.window_list.set(item, "select") == "√")
|
||
|
||
# 根据选中数量设置按钮文本
|
||
if selected_count == len(items):
|
||
self.select_all_var.set("取消全选")
|
||
else:
|
||
self.select_all_var.set("全部选择")
|
||
|
||
except Exception as e:
|
||
print(f"更新全选状态失败: {str(e)}")
|
||
|
||
def on_click(self, event):
|
||
# 处理点击事件
|
||
try:
|
||
region = self.window_list.identify_region(event.x, event.y)
|
||
if region == "cell":
|
||
column = self.window_list.identify_column(event.x)
|
||
item = self.window_list.identify_row(event.y)
|
||
|
||
if column == "#1": # 选择列
|
||
current = self.window_list.set(item, "select")
|
||
self.window_list.set(item, "select", "" if current == "√" else "√")
|
||
# 更新全选按钮状态
|
||
self.update_select_all_status()
|
||
elif column == "#4": # 主控列
|
||
self.set_master_window(item)
|
||
except Exception as e:
|
||
print(f"处理点击事件失败: {str(e)}")
|
||
|
||
def set_master_window(self, item):
|
||
"""设置主控窗口"""
|
||
try:
|
||
# 如果正在同步，先停止同步
|
||
if self.is_syncing:
|
||
self.stop_sync()
|
||
# 确保按钮状态更新
|
||
self.sync_button.configure(text="▶ 开始同步", style='Accent.TButton')
|
||
self.is_syncing = False
|
||
# 显示通知
|
||
self.show_notification("同步已关闭", "切换主控窗口，同步已停止")
|
||
|
||
# 清除其他窗口的主控状态和标题
|
||
for i in self.window_list.get_children():
|
||
values = self.window_list.item(i)['values']
|
||
if values and len(values) >= 5:
|
||
hwnd = int(values[4])
|
||
title = values[2]
|
||
# 移除所有主控标记
|
||
if "★" in title or "[主控]" in title:
|
||
new_title = title.replace("[主控]", "").strip()
|
||
new_title = new_title.replace("★", "").strip()
|
||
win32gui.SetWindowText(hwnd, new_title)
|
||
# 更新列表中显示的标题
|
||
self.window_list.set(i, "title", new_title)
|
||
# 恢复默认边框颜色
|
||
try:
|
||
# 使用 LoadLibrary 显式加载 dwmapi.dll
|
||
dwmapi = ctypes.WinDLL("dwmapi.dll")
|
||
|
||
# 定义参数类型
|
||
DWMWA_BORDER_COLOR = 34
|
||
color = ctypes.c_uint(0) # 默认颜色
|
||
|
||
# 恢复默认边框颜色
|
||
dwmapi.DwmSetWindowAttribute(
|
||
hwnd,
|
||
DWMWA_BORDER_COLOR,
|
||
ctypes.byref(color),
|
||
ctypes.sizeof(ctypes.c_int)
|
||
)
|
||
|
||
# 强制刷新窗口
|
||
win32gui.SetWindowPos(
|
||
hwnd,
|
||
0,
|
||
0, 0, 0, 0,
|
||
win32con.SWP_NOMOVE |
|
||
win32con.SWP_NOSIZE |
|
||
win32con.SWP_NOZORDER |
|
||
win32con.SWP_FRAMECHANGED
|
||
)
|
||
except Exception as e:
|
||
print(f"重置窗口边框颜色失败: {str(e)}")
|
||
self.window_list.set(i, "master", "")
|
||
self.window_list.item(i, tags=())
|
||
|
||
# 设置新的主控窗口
|
||
values = self.window_list.item(item)['values']
|
||
self.master_window = int(values[4])
|
||
|
||
# 设置主控标记和蓝色背景
|
||
self.window_list.set(item, "master", "√")
|
||
self.window_list.item(item, tags=("master",))
|
||
|
||
# 修改窗口标题和边框颜色
|
||
title = values[2]
|
||
if not "[主控]" in title and not "★" in title:
|
||
new_title = f"★ [主控] {title} ★"
|
||
win32gui.SetWindowText(self.master_window, new_title)
|
||
self.window_list.set(item, "title", new_title)
|
||
try:
|
||
# 加载 dwmapi.dll
|
||
dwmapi = ctypes.WinDLL("dwmapi.dll")
|
||
|
||
# 设置窗口边框颜色为红色
|
||
color = ctypes.c_uint(0x0000FF) # 红色 (BGR格式)
|
||
dwmapi.DwmSetWindowAttribute(
|
||
self.master_window,
|
||
34, # DWMWA_BORDER_COLOR
|
||
ctypes.byref(color),
|
||
ctypes.sizeof(ctypes.c_int)
|
||
)
|
||
|
||
# 强制刷新窗口
|
||
win32gui.SetWindowPos(
|
||
self.master_window,
|
||
0,
|
||
0, 0, 0, 0,
|
||
win32con.SWP_NOMOVE |
|
||
win32con.SWP_NOSIZE |
|
||
win32con.SWP_NOZORDER |
|
||
win32con.SWP_FRAMECHANGED
|
||
)
|
||
except Exception as e:
|
||
print(f"设置主控窗口边框颜色失败: {str(e)}")
|
||
|
||
except Exception as e:
|
||
print(f"设置主控窗口失败: {str(e)}")
|
||
|
||
def toggle_sync(self, event=None):
|
||
# 切换同步状态
|
||
if not self.window_list.get_children():
|
||
messagebox.showinfo("提示", "请先导入窗口！")
|
||
return
|
||
|
||
# 获取选中的窗口
|
||
selected = []
|
||
for item in self.window_list.get_children():
|
||
if self.window_list.set(item, "select") == "√":
|
||
selected.append(item)
|
||
|
||
if not selected:
|
||
messagebox.showinfo("提示", "请选择要同步的窗口！")
|
||
return
|
||
|
||
# 检查主控窗口
|
||
master_items = [item for item in self.window_list.get_children()
|
||
if self.window_list.set(item, "master") == "√"]
|
||
|
||
if not master_items:
|
||
# 如果没有主控窗口，设置第一个选中的窗口为主控
|
||
self.set_master_window(selected[0])
|
||
|
||
# 切换同步状态
|
||
if not self.is_syncing:
|
||
try:
|
||
self.start_sync(selected)
|
||
self.sync_button.configure(text="■ 停止同步", style='Accent.TButton')
|
||
self.is_syncing = True
|
||
print("同步已开启")
|
||
# 使用after方法异步显示通知
|
||
self.root.after(10, lambda: self.show_notification("同步已开启", "Chrome多窗口同步功能已启动"))
|
||
except Exception as e:
|
||
print(f"开启同步失败: {str(e)}")
|
||
# 确保状态正确
|
||
self.is_syncing = False
|
||
self.sync_button.configure(text="▶ 开始同步", style='Accent.TButton')
|
||
# 重新显示错误消息
|
||
messagebox.showerror("错误", str(e))
|
||
else:
|
||
try:
|
||
self.stop_sync()
|
||
self.sync_button.configure(text="▶ 开始同步", style='Accent.TButton')
|
||
self.is_syncing = False
|
||
print("同步已停止")
|
||
# 使用after方法异步显示通知
|
||
self.root.after(10, lambda: self.show_notification("同步已关闭", "Chrome多窗口同步功能已停止"))
|
||
except Exception as e:
|
||
print(f"停止同步失败: {str(e)}")
|
||
|
||
def show_notification(self, title, message):
|
||
"""显示系统通知"""
|
||
try:
|
||
if self.is_win11:
|
||
# Windows 11 使用toast通知
|
||
try:
|
||
# 使用线程来显示通知
|
||
def show_toast():
|
||
try:
|
||
self.notify_func(
|
||
title,
|
||
message,
|
||
duration="short",
|
||
app_id="Chrome多开管理工具",
|
||
on_dismissed=lambda x: None # 忽略关闭回调
|
||
)
|
||
except Exception:
|
||
pass
|
||
|
||
threading.Thread(target=show_toast).start()
|
||
except TypeError:
|
||
# 如果上面的方法失败，尝试使用另一种调用方式
|
||
def show_toast_alt():
|
||
try:
|
||
self.notify_func({
|
||
"title": title,
|
||
"message": message,
|
||
"duration": "short",
|
||
"app_id": "Chrome多开管理工具",
|
||
"on_dismissed": lambda x: None
|
||
})
|
||
except Exception:
|
||
pass
|
||
|
||
threading.Thread(target=show_toast_alt).start()
|
||
else:
|
||
# Windows 10 使用win32gui通知
|
||
try:
|
||
# 确保托盘图标已注册
|
||
if not hasattr(self, 'notify_id'):
|
||
self.hwnd = win32gui.GetForegroundWindow()
|
||
self.notification_flags = win32gui.NIF_ICON | win32gui.NIF_INFO | win32gui.NIF_TIP
|
||
|
||
# 加载app.ico图标
|
||
try:
|
||
icon_path = os.path.join(os.path.dirname(__file__), "app.ico")
|
||
if os.path.exists(icon_path):
|
||
# 加载应用程序图标
|
||
icon_handle = win32gui.LoadImage(
|
||
0, icon_path, win32con.IMAGE_ICON,
|
||
0, 0, win32con.LR_LOADFROMFILE | win32con.LR_DEFAULTSIZE
|
||
)
|
||
else:
|
||
# 使用默认图标
|
||
icon_handle = win32gui.LoadIcon(0, win32con.IDI_APPLICATION)
|
||
except Exception as e:
|
||
print(f"加载托盘图标失败: {str(e)}")
|
||
icon_handle = win32gui.LoadIcon(0, win32con.IDI_APPLICATION)
|
||
|
||
self.notify_id = (
|
||
self.hwnd,
|
||
0,
|
||
self.notification_flags,
|
||
win32con.WM_USER + 20,
|
||
icon_handle,
|
||
"Chrome多窗口管理器"
|
||
)
|
||
win32gui.Shell_NotifyIcon(win32gui.NIM_ADD, self.notify_id)
|
||
|
||
# 获取当前图标句柄
|
||
icon_handle = self.notify_id[4]
|
||
|
||
# 准备通知数据
|
||
notify_data = (
|
||
self.hwnd,
|
||
0,
|
||
self.notification_flags,
|
||
win32con.WM_USER + 20,
|
||
icon_handle,
|
||
"Chrome多窗口管理器", # 托盘提示
|
||
message, # 通知内容
|
||
1000, # 1秒 = 1000毫秒
|
||
title, # 通知标题
|
||
win32gui.NIIF_INFO # 通知类型
|
||
)
|
||
# 显示通知
|
||
win32gui.Shell_NotifyIcon(win32gui.NIM_MODIFY, notify_data)
|
||
except Exception as e:
|
||
print(f"Windows 10 通知显示失败: {str(e)}")
|
||
except Exception as e:
|
||
print(f"显示通知失败: {str(e)}")
|
||
|
||
def start_sync(self, selected_items):
|
||
try:
|
||
# 确保主控窗口存在
|
||
if not self.master_window:
|
||
raise Exception("未设置主控窗口")
|
||
|
||
# 清除之前可能的同步状态
|
||
if hasattr(self, 'is_sync') and self.is_sync:
|
||
self.stop_sync()
|
||
time.sleep(0.2) # 等待资源清理
|
||
|
||
# 初始化同步状态变量
|
||
self.is_sync = True
|
||
self.popup_windows = [] # 储存所有弹出窗口
|
||
self.last_mouse_position = (0, 0)
|
||
self.last_move_time = time.time()
|
||
|
||
# 保存选中的窗口列表，并按编号排序
|
||
self.sync_windows = []
|
||
window_info = []
|
||
|
||
# 收集所有选中的窗口
|
||
for item in selected_items:
|
||
values = self.window_list.item(item)['values']
|
||
if values and len(values) >= 5:
|
||
number = int(values[1])
|
||
hwnd = int(values[4])
|
||
if hwnd != self.master_window: # 排除主控窗口
|
||
window_info.append((number, hwnd))
|
||
|
||
# 按编号排序
|
||
window_info.sort(key=lambda x: x[0])
|
||
|
||
# 保存所有同步窗口的句柄
|
||
self.sync_windows = [hwnd for _, hwnd in window_info]
|
||
|
||
# 检查是否存在有效的同步窗口
|
||
if not self.sync_windows:
|
||
messagebox.showwarning("警告", "没有可同步的窗口，请至少选择两个窗口（一个主控，一个被控）")
|
||
self.is_sync = False
|
||
return
|
||
|
||
# 启动键盘和鼠标钩子
|
||
if not hasattr(self, 'hook_thread') or not self.hook_thread or not self.hook_thread.is_alive():
|
||
self.hook_thread = threading.Thread(target=self.message_loop)
|
||
self.hook_thread.daemon = True
|
||
self.hook_thread.start()
|
||
|
||
try:
|
||
# 设置键盘和鼠标钩子
|
||
keyboard.hook(self.on_keyboard_event)
|
||
mouse.hook(self.on_mouse_event)
|
||
print("已设置键盘和鼠标钩子")
|
||
|
||
# 尝试安装低级滚轮钩子，但不强制要求成功
|
||
if self.use_wheel_hook:
|
||
try:
|
||
self.setup_wheel_hook()
|
||
print("已安装低级滚轮钩子")
|
||
except Exception as e:
|
||
print(f"安装低级滚轮钩子失败: {str(e)}")
|
||
print("将使用常规鼠标钩子代替低级滚轮钩子")
|
||
# 失败后设置为不使用低级钩子
|
||
self.use_wheel_hook = False
|
||
except Exception as e:
|
||
print(f"设置钩子失败: {str(e)}")
|
||
self.stop_sync()
|
||
raise Exception(f"无法设置输入钩子: {str(e)}")
|
||
|
||
# 更新按钮状态
|
||
self.sync_button.configure(text="■ 停止同步", style='Accent.TButton')
|
||
|
||
# 启动插件窗口监控线程
|
||
self.popup_monitor_thread = threading.Thread(target=self.monitor_popups)
|
||
self.popup_monitor_thread.daemon = True
|
||
self.popup_monitor_thread.start()
|
||
|
||
print(f"已启动同步，主控窗口: {self.master_window}, 同步窗口: {self.sync_windows}")
|
||
|
||
# 添加：将所有窗口设置为置顶
|
||
for hwnd in self.sync_windows:
|
||
try:
|
||
# 设置窗口为置顶
|
||
win32gui.SetWindowPos(hwnd, win32con.HWND_TOPMOST, 0, 0, 0, 0,
|
||
win32con.SWP_NOMOVE | win32con.SWP_NOSIZE)
|
||
# 取消置顶（但保持在所有窗口前面）
|
||
win32gui.SetWindowPos(hwnd, win32con.HWND_NOTOPMOST, 0, 0, 0, 0,
|
||
win32con.SWP_NOMOVE | win32con.SWP_NOSIZE)
|
||
except Exception as e:
|
||
print(f"设置窗口 {hwnd} 置顶失败: {str(e)}")
|
||
|
||
# 添加：将主窗口设置为活动窗口
|
||
try:
|
||
# 确保主窗口可见
|
||
win32gui.ShowWindow(self.master_window, win32con.SW_RESTORE)
|
||
# 设置主窗口为前台窗口
|
||
win32gui.SetForegroundWindow(self.master_window)
|
||
print(f"已激活主窗口: {self.master_window}")
|
||
except Exception as e:
|
||
print(f"激活主窗口失败: {str(e)}")
|
||
|
||
except Exception as e:
|
||
self.stop_sync() # 确保清理资源
|
||
messagebox.showerror("错误", f"开启同步失败: {str(e)}")
|
||
print(f"开启同步失败: {str(e)}")
|
||
|
||
def message_loop(self):
|
||
# 消息循环 - 优化版本，降低CPU使用率
|
||
while self.is_sync:
|
||
# 增加更长的睡眠时间，减少CPU使用
|
||
time.sleep(0.005) # 5ms睡眠，平衡响应性和CPU使用率
|
||
|
||
def on_mouse_event(self, event):
|
||
try:
|
||
if self.is_sync:
|
||
current_window = win32gui.GetForegroundWindow()
|
||
|
||
# 检查是否是主控窗口或其插件窗口
|
||
is_master = current_window == self.master_window
|
||
master_popups = self.get_chrome_popups(self.master_window)
|
||
|
||
# 检查是否是主窗口的弹出窗口之一
|
||
is_popup = False
|
||
if not is_master and current_window in master_popups:
|
||
is_popup = True
|
||
# 确保这个弹出窗口在我们的同步列表中
|
||
if current_window not in self.popup_windows:
|
||
self.popup_windows.append(current_window)
|
||
|
||
# 只有当当前窗口是主控窗口或其弹出窗口时才处理事件
|
||
# 这样可以防止其他窗口控制同步
|
||
if is_master or is_popup:
|
||
# 获取鼠标位置
|
||
x, y = mouse.get_position()
|
||
|
||
# 获取当前窗口的矩形区域
|
||
current_rect = win32gui.GetWindowRect(current_window)
|
||
|
||
# 检查鼠标是否在当前窗口范围内
|
||
mouse_in_window = (
|
||
x >= current_rect[0] and x <= current_rect[2] and
|
||
y >= current_rect[1] and y <= current_rect[3]
|
||
)
|
||
|
||
# 只有当鼠标在窗口范围内时才进行同步
|
||
if not mouse_in_window:
|
||
return
|
||
|
||
# 对于移动事件进行优化
|
||
if isinstance(event, mouse.MoveEvent):
|
||
# 改进的移动事件节流策略
|
||
current_time = time.time()
|
||
if not hasattr(self, 'move_interval'):
|
||
self.move_interval = 0.01 # 10ms节流间隔
|
||
|
||
# 更精细的移动阈值控制
|
||
if not hasattr(self, 'mouse_threshold'):
|
||
self.mouse_threshold = 2 # 像素移动阈值
|
||
|
||
# 时间节流：忽略过于频繁的移动事件
|
||
if current_time - getattr(self, 'last_move_time', 0) < self.move_interval:
|
||
return
|
||
|
||
# 距离节流：忽略过小的移动
|
||
last_pos = getattr(self, 'last_mouse_position', (event.x, event.y))
|
||
dx = abs(event.x - last_pos[0])
|
||
dy = abs(event.y - last_pos[1])
|
||
if dx < self.mouse_threshold and dy < self.mouse_threshold:
|
||
return
|
||
|
||
# 更新上次位置和时间
|
||
self.last_mouse_position = (event.x, event.y)
|
||
self.last_move_time = current_time
|
||
|
||
# 计算当前窗口的相对坐标
|
||
rel_x = (x - current_rect[0]) / max((current_rect[2] - current_rect[0]), 1)
|
||
rel_y = (y - current_rect[1]) / max((current_rect[3] - current_rect[1]), 1)
|
||
|
||
# 使用线程池批量处理事件分发
|
||
sync_tasks = []
|
||
|
||
# 同步到其他窗口
|
||
for hwnd in self.sync_windows:
|
||
try:
|
||
# 确定目标窗口
|
||
if is_master:
|
||
target_hwnd = hwnd
|
||
else:
|
||
# 查找对应的扩展程序窗口
|
||
target_popups = self.get_chrome_popups(hwnd)
|
||
|
||
# 检查当前窗口是否为弹出类型的浮动窗口
|
||
style = win32gui.GetWindowLong(current_window, win32con.GWL_STYLE)
|
||
is_floating = (style & win32con.WS_POPUP) != 0
|
||
current_title = win32gui.GetWindowText(current_window)
|
||
|
||
if is_floating and target_popups:
|
||
# 按照相对位置和窗口标题匹配浮动窗口
|
||
best_match = None
|
||
min_diff = float('inf')
|
||
current_size = (current_rect[2] - current_rect[0], current_rect[3] - current_rect[1])
|
||
|
||
for popup in target_popups:
|
||
# 获取目标弹出窗口信息
|
||
popup_rect = win32gui.GetWindowRect(popup)
|
||
popup_style = win32gui.GetWindowLong(popup, win32con.GWL_STYLE)
|
||
popup_title = win32gui.GetWindowText(popup)
|
||
|
||
# 检查是否也是浮动窗口
|
||
if (popup_style & win32con.WS_POPUP) == 0:
|
||
continue
|
||
|
||
# 计算窗口大小差异
|
||
popup_size = (popup_rect[2] - popup_rect[0], popup_rect[3] - popup_rect[1])
|
||
size_diff = abs(current_size[0] - popup_size[0]) + abs(current_size[1] - popup_size[1])
|
||
|
||
# 计算标题相似度
|
||
title_sim = self.title_similarity(current_title, popup_title)
|
||
|
||
# 综合评分
|
||
diff = size_diff * (2.0 - title_sim)
|
||
|
||
if diff < min_diff:
|
||
min_diff = diff
|
||
best_match = popup
|
||
|
||
target_hwnd = best_match if best_match else hwnd
|
||
else:
|
||
# 按照相对位置匹配
|
||
best_match = None
|
||
min_diff = float('inf')
|
||
for popup in target_popups:
|
||
popup_rect = win32gui.GetWindowRect(popup)
|
||
master_rect = win32gui.GetWindowRect(current_window)
|
||
# 计算相对位置差异
|
||
master_rel_x = master_rect[0] - win32gui.GetWindowRect(self.master_window)[0]
|
||
master_rel_y = master_rect[1] - win32gui.GetWindowRect(self.master_window)[1]
|
||
popup_rel_x = popup_rect[0] - win32gui.GetWindowRect(hwnd)[0]
|
||
popup_rel_y = popup_rect[1] - win32gui.GetWindowRect(hwnd)[1]
|
||
|
||
diff = abs(master_rel_x - popup_rel_x) + abs(master_rel_y - popup_rel_y)
|
||
if diff < min_diff:
|
||
min_diff = diff
|
||
best_match = popup
|
||
target_hwnd = best_match if best_match else hwnd
|
||
|
||
if not target_hwnd:
|
||
continue
|
||
|
||
# 获取目标窗口尺寸
|
||
target_rect = win32gui.GetWindowRect(target_hwnd)
|
||
|
||
# 计算目标坐标 - 保护除以零
|
||
client_x = int((target_rect[2] - target_rect[0]) * rel_x)
|
||
client_y = int((target_rect[3] - target_rect[1]) * rel_y)
|
||
lparam = win32api.MAKELONG(client_x, client_y)
|
||
|
||
# 使用PostMessage代替SendMessage提高性能
|
||
# 处理滚轮事件
|
||
if isinstance(event, mouse.WheelEvent):
|
||
try:
|
||
wheel_delta = int(event.delta)
|
||
if keyboard.is_pressed('ctrl'):
|
||
if wheel_delta > 0:
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_KEYDOWN, win32con.VK_CONTROL, 0)
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_KEYDOWN, 0xBB, 0) # VK_OEM_PLUS
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_KEYUP, 0xBB, 0)
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_KEYUP, win32con.VK_CONTROL, 0)
|
||
else:
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_KEYDOWN, win32con.VK_CONTROL, 0)
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_KEYDOWN, 0xBD, 0) # VK_OEM_MINUS
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_KEYUP, 0xBD, 0)
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_KEYUP, win32con.VK_CONTROL, 0)
|
||
else:
|
||
# 获取滚轮方向和绝对值
|
||
abs_delta = abs(wheel_delta)
|
||
scroll_up = wheel_delta > 0
|
||
|
||
# 主要使用PageUp/PageDown键来实现更大的滚动幅度
|
||
# 对于小幅度滚动，使用箭头键；对于大幅度滚动，使用Page键
|
||
|
||
# 根据滚动大小决定策略，微调使同步窗口滚动幅度更接近主窗口
|
||
if abs_delta <= 1:
|
||
# 对于小幅度滚动，减少到2次箭头键
|
||
vk_code = win32con.VK_UP if scroll_up else win32con.VK_DOWN
|
||
for _ in range(2):
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_KEYDOWN, vk_code, 0)
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_KEYUP, vk_code, 0)
|
||
elif abs_delta <= 3:
|
||
# 对于中等幅度滚动，使用一次Page键但减少额外的箭头键
|
||
page_vk = win32con.VK_PRIOR if scroll_up else win32con.VK_NEXT # Page Up/Down
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_KEYDOWN, page_vk, 0)
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_KEYUP, page_vk, 0)
|
||
|
||
# 额外只增加1次箭头键，减少之前的额外按键
|
||
vk_code = win32con.VK_UP if scroll_up else win32con.VK_DOWN
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_KEYDOWN, vk_code, 0)
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_KEYUP, vk_code, 0)
|
||
else:
|
||
# 对于大幅度滚动，减少Page键系数
|
||
page_count = min(int(abs_delta * 0.4), 2) # 系数从0.6降到0.4，最多减少到2次
|
||
page_vk = win32con.VK_PRIOR if scroll_up else win32con.VK_NEXT
|
||
|
||
for _ in range(page_count):
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_KEYDOWN, page_vk, 0)
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_KEYUP, page_vk, 0)
|
||
|
||
# 移除额外的箭头键调整
|
||
|
||
except Exception as e:
|
||
print(f"处理滚轮事件失败: {str(e)}")
|
||
continue
|
||
|
||
# 处理鼠标点击
|
||
elif isinstance(event, mouse.ButtonEvent):
|
||
if event.event_type == mouse.DOWN:
|
||
if event.button == mouse.LEFT:
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_LBUTTONDOWN, win32con.MK_LBUTTON, lparam)
|
||
elif event.button == mouse.RIGHT:
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_RBUTTONDOWN, win32con.MK_RBUTTON, lparam)
|
||
elif event.button == mouse.MIDDLE: # 添加中键支持
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_MBUTTONDOWN, win32con.MK_MBUTTON, lparam)
|
||
elif event.event_type == mouse.UP:
|
||
if event.button == mouse.LEFT:
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_LBUTTONUP, 0, lparam)
|
||
elif event.button == mouse.RIGHT:
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_RBUTTONUP, 0, lparam)
|
||
elif event.button == mouse.MIDDLE: # 添加中键支持
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_MBUTTONUP, 0, lparam)
|
||
|
||
# 处理鼠标移动 - 减少移动事件传递，仅对实质性移动做处理
|
||
elif isinstance(event, mouse.MoveEvent):
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_MOUSEMOVE, 0, lparam)
|
||
|
||
except Exception as e:
|
||
error_msg = str(e)
|
||
# 减少错误日志输出频率
|
||
if not hasattr(self, 'last_error_time') or time.time() - self.last_error_time > 5:
|
||
print(f"同步到窗口 {hwnd} 失败: {error_msg}")
|
||
self.last_error_time = time.time()
|
||
except Exception as e:
|
||
print(f"鼠标事件处理总体错误: {str(e)}")
|
||
|
||
def on_keyboard_event(self, event):
|
||
# 优化版键盘事件处理
|
||
try:
|
||
if self.is_sync:
|
||
current_window = win32gui.GetForegroundWindow()
|
||
|
||
# 检查是否是主控窗口或其插件窗口
|
||
is_master = current_window == self.master_window
|
||
master_popups = self.get_chrome_popups(self.master_window)
|
||
|
||
# 检查是否是主窗口的弹出窗口之一
|
||
is_popup = False
|
||
if not is_master and current_window in master_popups:
|
||
is_popup = True
|
||
# 确保这个弹出窗口在我们的同步列表中
|
||
if current_window not in self.popup_windows:
|
||
self.popup_windows.append(current_window)
|
||
|
||
# 只有当当前窗口是主控窗口或其弹出窗口时才处理事件
|
||
# 这样可以防止其他窗口控制同步
|
||
if is_master or is_popup:
|
||
# 获取鼠标位置
|
||
x, y = mouse.get_position()
|
||
|
||
# 获取当前窗口的矩形区域
|
||
current_rect = win32gui.GetWindowRect(current_window)
|
||
|
||
# 检查鼠标是否在当前窗口范围内
|
||
mouse_in_window = (
|
||
x >= current_rect[0] and x <= current_rect[2] and
|
||
y >= current_rect[1] and y <= current_rect[3]
|
||
)
|
||
|
||
# 只有当鼠标在窗口范围内时才进行同步
|
||
if not mouse_in_window:
|
||
return
|
||
|
||
# 获取实际的输入目标窗口
|
||
input_hwnd = win32gui.GetFocus()
|
||
|
||
# 同步到其他窗口 - 键盘事件限流
|
||
current_time = time.time()
|
||
if not hasattr(self, 'last_key_time') or current_time - self.last_key_time > 0.01:
|
||
self.last_key_time = current_time
|
||
else:
|
||
# 对于连续的相同按键，适当限流，减少重复输入
|
||
if hasattr(self, 'last_key') and self.last_key == event.name and event.event_type == keyboard.KEY_DOWN:
|
||
return
|
||
|
||
# 记录最后一个按键
|
||
self.last_key = event.name
|
||
|
||
# 同步到其他窗口
|
||
for hwnd in self.sync_windows:
|
||
try:
|
||
# 确定目标窗口
|
||
if is_master:
|
||
target_hwnd = hwnd
|
||
else:
|
||
# 查找对应的扩展程序窗口
|
||
target_popups = self.get_chrome_popups(hwnd)
|
||
# 按照相对位置匹配
|
||
best_match = None
|
||
min_diff = float('inf')
|
||
for popup in target_popups:
|
||
popup_rect = win32gui.GetWindowRect(popup)
|
||
master_rect = win32gui.GetWindowRect(current_window)
|
||
# 计算相对位置差异
|
||
master_rel_x = master_rect[0] - win32gui.GetWindowRect(self.master_window)[0]
|
||
master_rel_y = master_rect[1] - win32gui.GetWindowRect(self.master_window)[1]
|
||
popup_rel_x = popup_rect[0] - win32gui.GetWindowRect(hwnd)[0]
|
||
popup_rel_y = popup_rect[1] - win32gui.GetWindowRect(hwnd)[1]
|
||
|
||
diff = abs(master_rel_x - popup_rel_x) + abs(master_rel_y - popup_rel_y)
|
||
if diff < min_diff:
|
||
min_diff = diff
|
||
best_match = popup
|
||
target_hwnd = best_match if best_match else hwnd
|
||
|
||
if not target_hwnd:
|
||
continue
|
||
|
||
# 检测组合键状态
|
||
modifiers = 0
|
||
modifier_keys = {
|
||
'ctrl': {'pressed': keyboard.is_pressed('ctrl'), 'vk': win32con.VK_CONTROL, 'flag': win32con.MOD_CONTROL},
|
||
'alt': {'pressed': keyboard.is_pressed('alt'), 'vk': win32con.VK_MENU, 'flag': win32con.MOD_ALT},
|
||
'shift': {'pressed': keyboard.is_pressed('shift'), 'vk': win32con.VK_SHIFT, 'flag': win32con.MOD_SHIFT}
|
||
}
|
||
|
||
# 处理修饰键和组合键
|
||
for mod_name, mod_info in modifier_keys.items():
|
||
if mod_info['pressed']:
|
||
# 按下修饰键
|
||
if event.event_type == keyboard.KEY_DOWN:
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_KEYDOWN, mod_info['vk'], 0)
|
||
|
||
modifiers |= mod_info['flag']
|
||
|
||
# 处理 Ctrl+组合键的特殊情况
|
||
if modifier_keys['ctrl']['pressed'] and event.name in ['a', 'c', 'v', 'x', 'z']:
|
||
vk_code = ord(event.name.upper())
|
||
if event.event_type == keyboard.KEY_DOWN:
|
||
# 发送组合键序列
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_KEYDOWN, vk_code, 0)
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_KEYUP, vk_code, 0)
|
||
|
||
# 对于这些特殊组合键，直接处理完毕
|
||
continue
|
||
|
||
# 处理普通按键
|
||
if event.name in ['enter', 'backspace', 'tab', 'esc', 'space',
|
||
'up', 'down', 'left', 'right',
|
||
'home', 'end', 'page up', 'page down', 'delete',
|
||
'f1', 'f2', 'f3', 'f4', 'f5', 'f6', 'f7', 'f8', 'f9', 'f10', 'f11', 'f12']:
|
||
vk_map = {
|
||
'enter': win32con.VK_RETURN,
|
||
'backspace': win32con.VK_BACK,
|
||
'tab': win32con.VK_TAB,
|
||
'esc': win32con.VK_ESCAPE,
|
||
'space': win32con.VK_SPACE,
|
||
'up': win32con.VK_UP,
|
||
'down': win32con.VK_DOWN,
|
||
'left': win32con.VK_LEFT,
|
||
'right': win32con.VK_RIGHT,
|
||
'home': win32con.VK_HOME,
|
||
'end': win32con.VK_END,
|
||
'page up': win32con.VK_PRIOR,
|
||
'page down': win32con.VK_NEXT,
|
||
'delete': win32con.VK_DELETE,
|
||
'f1': win32con.VK_F1,
|
||
'f2': win32con.VK_F2,
|
||
'f3': win32con.VK_F3,
|
||
'f4': win32con.VK_F4,
|
||
'f5': win32con.VK_F5,
|
||
'f6': win32con.VK_F6,
|
||
'f7': win32con.VK_F7,
|
||
'f8': win32con.VK_F8,
|
||
'f9': win32con.VK_F9,
|
||
'f10': win32con.VK_F10,
|
||
'f11': win32con.VK_F11,
|
||
'f12': win32con.VK_F12
|
||
}
|
||
vk_code = vk_map[event.name]
|
||
|
||
# 发送按键消息
|
||
if event.event_type == keyboard.KEY_DOWN:
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_KEYDOWN, vk_code, 0)
|
||
else:
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_KEYUP, vk_code, 0)
|
||
else:
|
||
# 处理普通字符
|
||
if len(event.name) == 1:
|
||
vk_code = win32api.VkKeyScan(event.name[0]) & 0xFF
|
||
if event.event_type == keyboard.KEY_DOWN:
|
||
# 直接发送字符消息，更有效
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_CHAR, ord(event.name[0]), 0)
|
||
continue
|
||
else:
|
||
continue
|
||
|
||
# 释放修饰键 - 仅在按键弹起时释放
|
||
if event.event_type == keyboard.KEY_UP:
|
||
for mod_name, mod_info in modifier_keys.items():
|
||
if mod_info['pressed']:
|
||
win32gui.PostMessage(target_hwnd, win32con.WM_KEYUP, mod_info['vk'], 0)
|
||
|
||
except Exception as e:
|
||
# 限制错误日志输出频率
|
||
if not hasattr(self, 'last_key_error_time') or time.time() - self.last_key_error_time > 5:
|
||
print(f"同步键盘事件到窗口 {hwnd} 失败: {str(e)}")
|
||
self.last_key_error_time = time.time()
|
||
|
||
except Exception as e:
|
||
# 限制错误日志输出频率
|
||
if not hasattr(self, 'last_keyboard_error_time') or time.time() - self.last_keyboard_error_time > 5:
|
||
print(f"处理键盘事件失败: {str(e)}")
|
||
self.last_keyboard_error_time = time.time()
|
||
|
||
def stop_sync(self):
|
||
"""停止同步 - 优化版，确保资源清理"""
|
||
try:
|
||
# 标记同步状态为False
|
||
self.is_sync = False
|
||
|
||
# 卸载低级滚轮钩子
|
||
self.unhook_wheel()
|
||
|
||
# 保存当前快捷键设置，用于后续恢复
|
||
current_shortcut = None
|
||
if hasattr(self, 'current_shortcut'):
|
||
current_shortcut = self.current_shortcut
|
||
|
||
# 保存当前快捷键钩子
|
||
shortcut_hook = None
|
||
if hasattr(self, 'shortcut_hook'):
|
||
shortcut_hook = self.shortcut_hook
|
||
self.shortcut_hook = None # 临时清除引用，避免被unhook_all移除
|
||
|
||
# 移除同步相关的键盘钩子，但保留快捷键钩子
|
||
try:
|
||
# 不使用 keyboard.unhook_all()，而是有选择地移除
|
||
# 暂时没有更好的方法来区分钩子，所以先重置然后恢复快捷键
|
||
keyboard.unhook_all()
|
||
print("已移除同步相关的键盘钩子")
|
||
except Exception as e:
|
||
print(f"移除键盘钩子失败: {str(e)}")
|
||
|
||
# 移除鼠标钩子
|
||
try:
|
||
mouse.unhook_all()
|
||
print("已移除鼠标钩子")
|
||
except Exception as e:
|
||
print(f"移除鼠标钩子失败: {str(e)}")
|
||
|
||
# 等待线程结束
|
||
if hasattr(self, 'hook_thread') and self.hook_thread:
|
||
try:
|
||
if self.hook_thread.is_alive():
|
||
self.hook_thread.join(timeout=0.5)
|
||
except Exception as e:
|
||
print(f"等待消息循环线程结束失败: {str(e)}")
|
||
self.hook_thread = None
|
||
|
||
# 等待弹出窗口监控线程结束
|
||
if hasattr(self, 'popup_monitor_thread') and self.popup_monitor_thread:
|
||
try:
|
||
if self.popup_monitor_thread.is_alive():
|
||
self.popup_monitor_thread.join(timeout=0.5)
|
||
except Exception as e:
|
||
print(f"等待弹出窗口监控线程结束失败: {str(e)}")
|
||
self.popup_monitor_thread = None
|
||
|
||
# 重置关键数据结构
|
||
self.popup_windows = []
|
||
self.sync_popups = {}
|
||
self.sync_windows = []
|
||
|
||
# 更新按钮状态 - 需要检查按钮是否存在
|
||
if hasattr(self, 'sync_button') and self.sync_button:
|
||
try:
|
||
self.sync_button.configure(text="▶ 开始同步", style='Accent.TButton')
|
||
except Exception as e:
|
||
print(f"更新按钮状态失败: {str(e)}")
|
||
|
||
# 重新设置快捷键 - 确保快捷键在停止同步后仍然有效
|
||
if current_shortcut:
|
||
try:
|
||
self.set_shortcut(current_shortcut)
|
||
print(f"已恢复快捷键设置: {current_shortcut}")
|
||
except Exception as e:
|
||
print(f"恢复快捷键失败: {str(e)}")
|
||
|
||
# 提示用户
|
||
print("同步已停止")
|
||
|
||
except Exception as e:
|
||
print(f"停止同步出错: {str(e)}")
|
||
traceback.print_exc()
|
||
# 确保按钮恢复正常状态
|
||
try:
|
||
if hasattr(self, 'sync_button') and self.sync_button:
|
||
self.sync_button.configure(text="▶ 开始同步", style='Accent.TButton')
|
||
except:
|
||
pass
|
||
|
||
def on_closing(self):
|
||
# 窗口关闭事件
|
||
try:
|
||
# 停止同步
|
||
if hasattr(self, 'is_sync') and self.is_sync:
|
||
self.stop_sync()
|
||
|
||
# 保存设置
|
||
self.save_settings()
|
||
# 保存窗口位置
|
||
self.save_window_position()
|
||
|
||
# 移除系统托盘图标
|
||
if not self.is_win11 and hasattr(self, 'notify_id'):
|
||
try:
|
||
win32gui.Shell_NotifyIcon(win32gui.NIM_DELETE, self.notify_id)
|
||
print("已移除系统托盘图标")
|
||
except Exception as e:
|
||
print(f"移除系统托盘图标失败: {str(e)}")
|
||
|
||
# 关闭所有Chrome窗口
|
||
if hasattr(self, 'close_all_windows') and messagebox.askyesno("确认", "关闭所有Chrome窗口?"):
|
||
self.close_all_windows()
|
||
|
||
# 销毁主窗口
|
||
self.root.destroy()
|
||
|
||
except Exception as e:
|
||
print(f"关闭程序时出错: {str(e)}")
|
||
self.root.destroy()
|
||
|
||
def auto_arrange_windows(self):
|
||
# 自动排列窗口
|
||
try:
|
||
print("开始自动排列窗口...")
|
||
# 先停止同步
|
||
was_syncing = self.is_syncing
|
||
if was_syncing:
|
||
self.stop_sync()
|
||
|
||
# 获取选中的窗口并按编号排序
|
||
selected = []
|
||
for item in self.window_list.get_children():
|
||
if self.window_list.set(item, "select") == "√":
|
||
values = self.window_list.item(item)['values']
|
||
if values and len(values) >= 5:
|
||
number = int(values[1])
|
||
hwnd = int(values[4])
|
||
selected.append((number, hwnd, item))
|
||
|
||
if not selected:
|
||
messagebox.showinfo("提示", "请先选择要排列的窗口！")
|
||
return
|
||
|
||
print(f"选中了 {len(selected)} 个窗口")
|
||
|
||
# 按编号升序排序
|
||
selected.sort(key=lambda x: x[0])
|
||
print("窗口排序结果:")
|
||
for num, hwnd, _ in selected:
|
||
print(f"编号: {num}, 句柄: {hwnd}")
|
||
|
||
# 获取选中的屏幕信息
|
||
screen_selection = self.screen_selection
|
||
print(f"当前选择的屏幕: {screen_selection}")
|
||
|
||
# 更新屏幕列表
|
||
screen_names = self.update_screen_list()
|
||
|
||
# 找到选中的屏幕索引
|
||
screen_index = 0 # 默认使用第一个屏幕
|
||
for i, name in enumerate(screen_names):
|
||
if name == screen_selection:
|
||
screen_index = i
|
||
break
|
||
|
||
if screen_index >= len(self.screens):
|
||
messagebox.showerror("错误", "请选择有效的屏幕！")
|
||
return
|
||
|
||
# 获取屏幕尺寸
|
||
screen = self.screens[screen_index]
|
||
screen_rect = screen['work_rect'] # 使用工作区而不是完整显示区
|
||
print(f"屏幕工作区: {screen_rect}")
|
||
|
||
# 计算屏幕尺寸
|
||
screen_width = screen_rect[2] - screen_rect[0]
|
||
screen_height = screen_rect[3] - screen_rect[1]
|
||
print(f"屏幕尺寸: {screen_width}x{screen_height}")
|
||
|
||
# 计算最佳布局
|
||
count = len(selected)
|
||
cols = int(math.sqrt(count))
|
||
if cols * cols < count:
|
||
cols += 1
|
||
rows = (count + cols - 1) // cols
|
||
|
||
# 计算窗口大小
|
||
width = screen_width // cols
|
||
height = screen_height // rows
|
||
print(f"窗口布局: {rows}行 x {cols}列, 窗口大小: {width}x{height}")
|
||
|
||
# 创建位置映射（从左到右，从上到下）
|
||
positions = []
|
||
for i in range(count):
|
||
row = i // cols
|
||
col = i % cols
|
||
x = screen_rect[0] + col * width
|
||
y = screen_rect[1] + row * height
|
||
positions.append((x, y))
|
||
print(f"位置 {i}: ({x}, {y})")
|
||
|
||
# 应用窗口位置
|
||
for i, (number, hwnd, _) in enumerate(selected):
|
||
try:
|
||
x, y = positions[i]
|
||
print(f"移动窗口 {number} (句柄: {hwnd}) 到位置 ({x}, {y})")
|
||
|
||
# 确保窗口可见并移动到指定位置
|
||
win32gui.ShowWindow(hwnd, win32con.SW_RESTORE)
|
||
|
||
# 先设置窗口样式确保可以移动
|
||
style = win32gui.GetWindowLong(hwnd, win32con.GWL_STYLE)
|
||
style |= win32con.WS_SIZEBOX | win32con.WS_SYSMENU
|
||
win32gui.SetWindowLong(hwnd, win32con.GWL_STYLE, style)
|
||
|
||
# 移动窗口
|
||
win32gui.MoveWindow(hwnd, x, y, width, height, True)
|
||
|
||
# 强制重绘
|
||
win32gui.UpdateWindow(hwnd)
|
||
print(f"窗口 {number} 移动成功")
|
||
|
||
except Exception as e:
|
||
print(f"移动窗口 {number} (句柄: {hwnd}) 失败: {str(e)}")
|
||
continue
|
||
|
||
print("窗口排列完成")
|
||
|
||
# 添加：将所有排列的窗口置顶
|
||
for _, hwnd, _ in selected:
|
||
try:
|
||
# 设置窗口为置顶
|
||
win32gui.SetWindowPos(hwnd, win32con.HWND_TOPMOST, 0, 0, 0, 0,
|
||
win32con.SWP_NOMOVE | win32con.SWP_NOSIZE)
|
||
# 取消置顶（但保持在所有窗口前面）
|
||
win32gui.SetWindowPos(hwnd, win32con.HWND_NOTOPMOST, 0, 0, 0, 0,
|
||
win32con.SWP_NOMOVE | win32con.SWP_NOSIZE)
|
||
except Exception as e:
|
||
print(f"设置窗口 {hwnd} 置顶失败: {str(e)}")
|
||
|
||
# 找到主窗口并激活
|
||
master_hwnd = None
|
||
for item in self.window_list.get_children():
|
||
if self.window_list.set(item, "master") == "√":
|
||
values = self.window_list.item(item)['values']
|
||
if values and len(values) >= 5:
|
||
master_hwnd = int(values[4])
|
||
break
|
||
|
||
# 如果找到主窗口，将其设为活动窗口
|
||
if master_hwnd:
|
||
try:
|
||
# 确保窗口可见
|
||
win32gui.ShowWindow(master_hwnd, win32con.SW_RESTORE)
|
||
# 设置为前台窗口
|
||
win32gui.SetForegroundWindow(master_hwnd)
|
||
print(f"已激活主窗口: {master_hwnd}")
|
||
except Exception as e:
|
||
print(f"激活主窗口失败: {str(e)}")
|
||
|
||
# 如果之前在同步，重新开启同步
|
||
if was_syncing:
|
||
self.start_sync([item for _, _, item in selected])
|
||
|
||
except Exception as e:
|
||
print(f"自动排列失败: {str(e)}")
|
||
messagebox.showerror("错误", f"自动排列失败: {str(e)}")
|
||
|
||
def custom_arrange_windows(self):
|
||
# 自定义排列窗口
|
||
try:
|
||
# 先停止同步
|
||
was_syncing = self.is_syncing
|
||
if was_syncing:
|
||
self.stop_sync()
|
||
|
||
selected = []
|
||
for item in self.window_list.get_children():
|
||
if self.window_list.set(item, "select") == "√":
|
||
values = self.window_list.item(item)['values']
|
||
if values and len(values) >= 5:
|
||
hwnd = int(values[4])
|
||
selected.append((item, hwnd))
|
||
|
||
if not selected:
|
||
messagebox.showinfo("提示", "请选择要排列的窗口！")
|
||
return
|
||
|
||
try:
|
||
# 获取参数
|
||
start_x = int(self.start_x.get())
|
||
start_y = int(self.start_y.get())
|
||
width = int(self.window_width.get())
|
||
height = int(self.window_height.get())
|
||
h_spacing = int(self.h_spacing.get())
|
||
v_spacing = int(self.v_spacing.get())
|
||
windows_per_row = int(self.windows_per_row.get())
|
||
|
||
# 排列窗口
|
||
for i, (item, hwnd) in enumerate(selected):
|
||
row = i // windows_per_row
|
||
col = i % windows_per_row
|
||
|
||
x = start_x + col * (width + h_spacing)
|
||
y = start_y + row * (height + v_spacing)
|
||
|
||
# 确保窗口可见并移动到指定位置
|
||
win32gui.ShowWindow(hwnd, win32con.SW_RESTORE)
|
||
win32gui.MoveWindow(hwnd, x, y, width, height, True)
|
||
|
||
# 保存参数
|
||
self.save_settings()
|
||
|
||
except ValueError:
|
||
messagebox.showerror("错误", "请输入有效的数字参数！")
|
||
except Exception as e:
|
||
messagebox.showerror("错误", f"排列窗口失败: {str(e)}")
|
||
|
||
# 添加：将所有排列的窗口置顶
|
||
for _, hwnd in selected:
|
||
try:
|
||
# 设置窗口为置顶
|
||
win32gui.SetWindowPos(hwnd, win32con.HWND_TOPMOST, 0, 0, 0, 0,
|
||
win32con.SWP_NOMOVE | win32con.SWP_NOSIZE)
|
||
# 取消置顶（但保持在所有窗口前面）
|
||
win32gui.SetWindowPos(hwnd, win32con.HWND_NOTOPMOST, 0, 0, 0, 0,
|
||
win32con.SWP_NOMOVE | win32con.SWP_NOSIZE)
|
||
except Exception as e:
|
||
print(f"设置窗口 {hwnd} 置顶失败: {str(e)}")
|
||
|
||
# 找到主窗口并激活
|
||
master_hwnd = None
|
||
for item in self.window_list.get_children():
|
||
if self.window_list.set(item, "master") == "√":
|
||
values = self.window_list.item(item)['values']
|
||
if values and len(values) >= 5:
|
||
master_hwnd = int(values[4])
|
||
break
|
||
|
||
# 如果找到主窗口，将其设为活动窗口
|
||
if master_hwnd:
|
||
try:
|
||
# 确保窗口可见
|
||
win32gui.ShowWindow(master_hwnd, win32con.SW_RESTORE)
|
||
# 设置为前台窗口
|
||
win32gui.SetForegroundWindow(master_hwnd)
|
||
print(f"已激活主窗口: {master_hwnd}")
|
||
except Exception as e:
|
||
print(f"激活主窗口失败: {str(e)}")
|
||
|
||
# 添加：如果之前在同步，重新开启同步
|
||
if was_syncing:
|
||
self.start_sync([item for item, _ in selected])
|
||
|
||
except Exception as e:
|
||
messagebox.showerror("错误", f"排列窗口失败: {str(e)}")
|
||
|
||
def load_settings(self) -> dict:
|
||
# 加载设置
|
||
settings = {}
|
||
try:
|
||
if os.path.exists('settings.json'):
|
||
with open('settings.json', 'r', encoding='utf-8') as f:
|
||
settings = json.load(f)
|
||
|
||
# 加载是否显示Chrome提示的设置
|
||
if 'show_chrome_tip' in settings:
|
||
self.show_chrome_tip = settings['show_chrome_tip']
|
||
except Exception as e:
|
||
print(f"加载设置失败: {str(e)}")
|
||
|
||
return settings
|
||
|
||
def save_settings(self):
|
||
# 保存设置
|
||
try:
|
||
# 确保信息是最新的
|
||
self.settings['shortcut_path'] = self.shortcut_path
|
||
self.settings['cache_dir'] = self.cache_dir
|
||
self.settings['icon_dir'] = self.icon_dir
|
||
if hasattr(self, 'current_shortcut') and self.current_shortcut:
|
||
self.settings['sync_shortcut'] = self.current_shortcut
|
||
if hasattr(self, 'screen_selection'):
|
||
self.settings['screen_selection'] = self.screen_selection
|
||
|
||
# 保存是否显示Chrome提示的设置
|
||
self.settings['show_chrome_tip'] = self.show_chrome_tip
|
||
|
||
# 保存排列参数
|
||
self.settings.update(self.get_arrange_params())
|
||
|
||
with open('settings.json', 'w', encoding='utf-8') as f:
|
||
json.dump(self.settings, f, ensure_ascii=False, indent=4)
|
||
print(f"保存设置成功，包括 show_chrome_tip = {self.show_chrome_tip}")
|
||
except Exception as e:
|
||
print(f"保存设置失败: {str(e)}")
|
||
|
||
def get_arrange_params(self):
|
||
return {
|
||
'start_x': self.start_x.get(),
|
||
'start_y': self.start_y.get(),
|
||
'window_width': self.window_width.get(),
|
||
'window_height': self.window_height.get(),
|
||
'h_spacing': self.h_spacing.get(),
|
||
'v_spacing': self.v_spacing.get(),
|
||
'windows_per_row': self.windows_per_row.get()
|
||
}
|
||
|
||
def load_arrange_params(self):
|
||
# 加载排列参数
|
||
settings = self.load_settings()
|
||
if 'arrange_params' in settings:
|
||
params = settings['arrange_params']
|
||
self.start_x.delete(0, tk.END)
|
||
self.start_x.insert(0, params.get('start_x', '0'))
|
||
self.start_y.delete(0, tk.END)
|
||
self.start_y.insert(0, params.get('start_y', '0'))
|
||
self.window_width.delete(0, tk.END)
|
||
self.window_width.insert(0, params.get('window_width', '500'))
|
||
self.window_height.delete(0, tk.END)
|
||
self.window_height.insert(0, params.get('window_height', '400'))
|
||
self.h_spacing.delete(0, tk.END)
|
||
self.h_spacing.insert(0, params.get('h_spacing', '0'))
|
||
self.v_spacing.delete(0, tk.END)
|
||
self.v_spacing.insert(0, params.get('v_spacing', '0'))
|
||
self.windows_per_row.delete(0, tk.END)
|
||
self.windows_per_row.insert(0, params.get('windows_per_row', '5'))
|
||
|
||
def parse_window_numbers(self, numbers_str: str) -> List[int]:
|
||
# 解析窗口编号字符串
|
||
if not numbers_str.strip():
|
||
return list(range(1, 49)) # 如果为空，返回所有编号
|
||
|
||
result = []
|
||
# 分割逗号分隔的部分
|
||
parts = numbers_str.split(',')
|
||
for part in parts:
|
||
part = part.strip()
|
||
if '-' in part:
|
||
# 处理范围，如 "1-5"
|
||
start, end = map(int, part.split('-'))
|
||
result.extend(range(start, end + 1))
|
||
else:
|
||
# 处理单个数字
|
||
result.append(int(part))
|
||
return sorted(list(set(result))) # 去重并排序
|
||
|
||
def open_windows(self):
|
||
"""打开Chrome窗口，依次打开但速度更快"""
|
||
# 获取快捷方式目录
|
||
shortcut_dir = self.shortcut_path
|
||
|
||
if not shortcut_dir:
|
||
messagebox.showinfo("提示", "请先在设置中设置快捷方式目录！")
|
||
return
|
||
|
||
if not os.path.exists(shortcut_dir):
|
||
messagebox.showerror("错误", "快捷方式目录不存在！")
|
||
return
|
||
|
||
# 获取用户设置的路径
|
||
abs_path = os.path.abspath(os.path.normpath(shortcut_dir))
|
||
if not os.path.isdir(abs_path):
|
||
messagebox.showerror("路径错误", "指定的路径不是一个有效目录")
|
||
return
|
||
|
||
# 快速验证路径可访问性
|
||
if not os.access(abs_path, os.R_OK):
|
||
messagebox.showerror("权限不足", "程序没有该目录的读取权限")
|
||
return
|
||
|
||
# 打开窗口逻辑
|
||
numbers = self.numbers_entry.get()
|
||
|
||
if not numbers:
|
||
messagebox.showwarning("警告", "请输入窗口编号！")
|
||
return
|
||
|
||
try:
|
||
window_numbers = self.parse_window_numbers(numbers)
|
||
|
||
# 清空现有调试端口映射
|
||
self.debug_ports.clear()
|
||
|
||
# 临时文件列表，用于最后清理
|
||
temp_files = []
|
||
|
||
for num in window_numbers:
|
||
shortcut = os.path.join(abs_path, f"{num}.lnk")
|
||
if not os.path.exists(shortcut):
|
||
print(f"警告: 快捷方式不存在: {shortcut}")
|
||
continue
|
||
|
||
# 如果启用了CDP，添加远程调试参数
|
||
if self.enable_cdp:
|
||
# 获取快捷方式信息
|
||
shortcut_obj = self.shell.CreateShortCut(shortcut)
|
||
target = shortcut_obj.TargetPath
|
||
args = shortcut_obj.Arguments
|
||
working_dir = shortcut_obj.WorkingDirectory
|
||
|
||
# 为每个窗口分配一个唯一的调试端口
|
||
debug_port = 9222 + int(num)
|
||
|
||
# 将窗口号和调试端口的映射保存到字典中
|
||
self.debug_ports[num] = debug_port
|
||
|
||
# 设置调试端口参数
|
||
if "--remote-debugging-port=" in args:
|
||
# 替换已有的调试端口参数
|
||
new_args = re.sub(r'--remote-debugging-port=\d+', f'--remote-debugging-port={debug_port}', args)
|
||
else:
|
||
# 添加新的调试端口参数
|
||
new_args = f"{args} --remote-debugging-port={debug_port}"
|
||
|
||
# 创建临时快捷方式
|
||
temp_shortcut = os.path.join(abs_path, f"temp_{num}.lnk")
|
||
temp_obj = self.shell.CreateShortCut(temp_shortcut)
|
||
temp_obj.TargetPath = target
|
||
temp_obj.Arguments = new_args
|
||
temp_obj.WorkingDirectory = working_dir
|
||
temp_obj.IconLocation = shortcut_obj.IconLocation
|
||
temp_obj.Save()
|
||
|
||
# 记录临时文件
|
||
temp_files.append(temp_shortcut)
|
||
|
||
# 确保临时文件创建成功
|
||
if os.path.exists(temp_shortcut):
|
||
# 启动临时快捷方式
|
||
print(f"启动窗口 {num}，调试端口: {debug_port}")
|
||
try:
|
||
subprocess.Popen(["start", "", temp_shortcut], shell=True)
|
||
# 只等待极短时间，让进程开始启动
|
||
time.sleep(0.1) # 从0.05改为0.1秒
|
||
except Exception as e:
|
||
print(f"启动窗口 {num} 失败: {str(e)}")
|
||
else:
|
||
# 如果临时文件创建失败，尝试直接启动原始快捷方式
|
||
print(f"警告: 临时快捷方式创建失败，直接启动原始快捷方式: {shortcut}")
|
||
try:
|
||
subprocess.Popen(["start", "", shortcut], shell=True)
|
||
time.sleep(0.1)
|
||
except Exception as e:
|
||
print(f"启动窗口 {num} 失败: {str(e)}")
|
||
else:
|
||
# 不启用CDP，直接打开
|
||
subprocess.Popen(["start", "", shortcut], shell=True)
|
||
time.sleep(0.05) # 只等待50毫秒
|
||
|
||
# 在所有窗口启动后，在后台清理临时文件
|
||
def cleanup_temp_files():
|
||
# 等待一小段时间再清理，确保所有窗口都已经启动
|
||
time.sleep(5) # 从1秒改为5秒，给Windows更多时间加载快捷方式
|
||
for temp_file in temp_files:
|
||
try:
|
||
if os.path.exists(temp_file):
|
||
os.remove(temp_file)
|
||
except:
|
||
pass # 忽略删除失败
|
||
|
||
# 启动清理线程，不阻塞主线程
|
||
cleanup_thread = threading.Thread(target=cleanup_temp_files)
|
||
cleanup_thread.daemon = True # 设为守护线程，程序退出时自动结束
|
||
cleanup_thread.start()
|
||
|
||
# 调试输出当前所有的端口映射，方便排查
|
||
print("窗口号到调试端口的映射:")
|
||
for window_num, port in self.debug_ports.items():
|
||
print(f"窗口 {window_num} -> 端口 {port}")
|
||
|
||
# 保存当前使用的窗口编号到设置
|
||
try:
|
||
# 重新加载设置，确保获取最新的设置
|
||
settings = self.load_settings()
|
||
settings['last_window_numbers'] = numbers
|
||
self.settings = settings # 更新当前实例中的设置
|
||
|
||
# 保存设置到文件
|
||
with open('settings.json', 'w', encoding='utf-8') as f:
|
||
json.dump(settings, f, ensure_ascii=False, indent=4)
|
||
print(f"成功保存窗口编号: {numbers}")
|
||
except Exception as e:
|
||
print(f"保存窗口编号设置失败: {str(e)}")
|
||
|
||
except Exception as e:
|
||
messagebox.showerror("错误", f"打开窗口失败: {str(e)}")
|
||
|
||
def get_shortcut_number(self, shortcut_path):
|
||
# 从快捷方式文件名中获取窗口编号
|
||
try:
|
||
# 首先从快捷方式文件名提取编号
|
||
# 例如 "D:/chrome duo/1.lnk" -> "1"
|
||
file_name = os.path.basename(shortcut_path)
|
||
name_without_ext = os.path.splitext(file_name)[0]
|
||
if name_without_ext.isdigit():
|
||
return name_without_ext
|
||
|
||
# 如果文件名不是纯数字，则尝试从参数中提取数据目录
|
||
shortcut = self.shell.CreateShortCut(shortcut_path)
|
||
cmd_line = shortcut.Arguments
|
||
|
||
if '--user-data-dir=' in cmd_line:
|
||
data_dir = cmd_line.split('--user-data-dir=')[1].strip('"')
|
||
# 注意：这里不再假设数据目录名就是数字
|
||
# 但为了向后兼容性，我们仍然检查是否为数字
|
||
base_name = os.path.basename(data_dir)
|
||
if base_name.isdigit():
|
||
return base_name
|
||
|
||
return None
|
||
|
||
except Exception as e:
|
||
print(f"获取快捷方式编号失败: {str(e)}")
|
||
return None
|
||
|
||
def import_windows(self):
|
||
"""导入当前打开的Chrome窗口，并显示进度对话框"""
|
||
try:
|
||
print("开始导入窗口...")
|
||
# 清空列表
|
||
for item in self.window_list.get_children():
|
||
self.window_list.delete(item)
|
||
|
||
# 创建进度对话框
|
||
progress_dialog = tk.Toplevel(self.root)
|
||
progress_dialog.title("加载窗口") # 修改标题
|
||
progress_dialog.geometry("300x120") # 减小高度，因为不需要显示那么多文字
|
||
progress_dialog.resizable(False, False)
|
||
progress_dialog.transient(self.root) # 设置为主窗口的临时窗口
|
||
progress_dialog.grab_set() # 模态对话框
|
||
|
||
# 设置图标
|
||
try:
|
||
if os.path.exists("app.ico"):
|
||
progress_dialog.iconbitmap("app.ico")
|
||
except Exception as e:
|
||
print(f"设置图标失败: {str(e)}")
|
||
|
||
# 保持对话框在顶层
|
||
progress_dialog.attributes('-topmost', True)
|
||
|
||
# 居中对话框
|
||
self.center_window(progress_dialog)
|
||
|
||
# 添加进度标签 - 只保留一个简单的说明
|
||
progress_label = ttk.Label(progress_dialog, text="正在加载窗口...", font=("微软雅黑", 10))
|
||
progress_label.pack(pady=(15, 10))
|
||
|
||
# 不再显示状态标签 (删除status_label)
|
||
|
||
# 添加进度条
|
||
progress_bar = ttk.Progressbar(progress_dialog, mode="indeterminate", length=250)
|
||
progress_bar.pack(pady=10)
|
||
progress_bar.start(10) # 开始动画
|
||
|
||
# 添加取消按钮
|
||
cancel_btn = ttk.Button(progress_dialog, text="取消", command=progress_dialog.destroy)
|
||
cancel_btn.pack(pady=5)
|
||
|
||
# 在后台线程中进行窗口导入操作
|
||
import_thread_active = [True] # 使用列表作为可变引用
|
||
|
||
def import_thread():
|
||
try:
|
||
# 初始化COM环境，必须在线程中使用WMI之前调用
|
||
pythoncom.CoInitialize()
|
||
|
||
windows = []
|
||
|
||
# 使用WMI搜索Chrome进程
|
||
def search_chrome_processes():
|
||
c = wmi.WMI()
|
||
chrome_processes = []
|
||
# 不再更新进度文字
|
||
|
||
for process in c.Win32_Process():
|
||
if not import_thread_active[0]:
|
||
return [] # 如果取消了，立即返回
|
||
|
||
# 检查ExecutablePath是否为None
|
||
if process.ExecutablePath is not None and "chrome.exe" in process.ExecutablePath.lower():
|
||
cmd_line = process.CommandLine
|
||
if cmd_line and '--user-data-dir=' in cmd_line:
|
||
chrome_processes.append(process)
|
||
|
||
return chrome_processes
|
||
|
||
# 获取Chrome进程
|
||
chrome_processes = search_chrome_processes()
|
||
total_processes = len(chrome_processes)
|
||
|
||
if not import_thread_active[0]:
|
||
return # 如果已取消，不继续处理
|
||
|
||
# 不再更新进度文字
|
||
|
||
# 处理每个Chrome进程
|
||
for index, process in enumerate(chrome_processes):
|
||
if not import_thread_active[0]:
|
||
return # 如果已取消，不继续处理
|
||
|
||
try:
|
||
pid = process.ProcessId
|
||
cmd_line = process.CommandLine
|
||
|
||
# 不再更新进度文字
|
||
|
||
if '--user-data-dir=' in cmd_line:
|
||
# 先检查这个进程是否有可见的Chrome窗口
|
||
def find_window_for_process(pid):
|
||
result = []
|
||
|
||
def enum_callback(hwnd, process_windows):
|
||
if win32gui.IsWindowVisible(hwnd):
|
||
_, win_pid = win32process.GetWindowThreadProcessId(hwnd)
|
||
if win_pid == pid:
|
||
title = win32gui.GetWindowText(hwnd)
|
||
if title and not title.startswith("Chrome 传递"):
|
||
process_windows.append(hwnd)
|
||
|
||
process_windows = []
|
||
win32gui.EnumWindows(enum_callback, process_windows)
|
||
return process_windows
|
||
|
||
# 获取该进程的窗口列表
|
||
chrome_windows = find_window_for_process(pid)
|
||
|
||
# 如果没有可见窗口，跳过这个进程
|
||
# 这有助于避免处理后台或扩展进程
|
||
if not chrome_windows:
|
||
continue
|
||
|
||
# 从命令行中提取用户数据目录路径
|
||
data_dir = re.search(r'--user-data-dir="?([^"]+)"?', cmd_line)
|
||
if data_dir:
|
||
data_path = data_dir.group(1)
|
||
|
||
# 尝试找到对应的快捷方式和编号
|
||
window_num = None
|
||
|
||
# 1. 首先尝试从快捷方式目录查找与此用户数据目录匹配的快捷方式
|
||
shortcut_dir = self.shortcut_path
|
||
if shortcut_dir and os.path.exists(shortcut_dir):
|
||
for shortcut_file in os.listdir(shortcut_dir):
|
||
if shortcut_file.endswith('.lnk'):
|
||
shortcut_path = os.path.join(shortcut_dir, shortcut_file)
|
||
try:
|
||
shortcut_obj = self.shell.CreateShortCut(shortcut_path)
|
||
shortcut_args = shortcut_obj.Arguments
|
||
|
||
# 检查是否为同一数据目录
|
||
if '--user-data-dir=' in shortcut_args:
|
||
shortcut_data_dir = re.search(r'--user-data-dir="?([^"]+)"?', shortcut_args)
|
||
if shortcut_data_dir and self.normalize_path(shortcut_data_dir.group(1)) == self.normalize_path(data_path):
|
||
# 找到匹配的快捷方式，从文件名提取编号
|
||
shortcut_name = os.path.splitext(shortcut_file)[0]
|
||
if shortcut_name.isdigit():
|
||
window_num = int(shortcut_name)
|
||
break
|
||
except Exception as e:
|
||
print(f"读取快捷方式失败: {str(e)}")
|
||
|
||
# 2. 如果未找到匹配的快捷方式，则尝试从数据目录名称中提取（向后兼容）
|
||
if window_num is None:
|
||
try:
|
||
base_name = os.path.basename(data_path)
|
||
if base_name.isdigit():
|
||
window_num = int(base_name)
|
||
except:
|
||
pass
|
||
|
||
# 3. 如果仍未找到编号，则创建一个临时编号
|
||
if window_num is None:
|
||
# 生成一个大于1001的临时编号，避免与用户自定义编号冲突
|
||
window_num = 1001 + len(windows)
|
||
print(f"未能确定窗口编号，使用临时编号: {window_num}，用户数据目录: {data_path}")
|
||
|
||
# 注意：这里不再需要重复查找窗口，因为我们已经在前面找到了窗口
|
||
# 使用第一个窗口
|
||
hwnd = chrome_windows[0]
|
||
title = win32gui.GetWindowText(hwnd)
|
||
windows.append({
|
||
'hwnd': hwnd,
|
||
'title': title,
|
||
'number': window_num
|
||
})
|
||
print(f"添加窗口: 编号={window_num}, 标题={title}")
|
||
except:
|
||
continue
|
||
|
||
# 按窗口编号排序（升序）
|
||
windows.sort(key=lambda w: w['number'])
|
||
|
||
# 导入完成，更新UI
|
||
def update_ui():
|
||
if not import_thread_active[0]:
|
||
return # 如果已取消，不更新UI
|
||
|
||
# 填充列表
|
||
for window in windows:
|
||
self.window_list.insert("", "end", values=("", f"{window['number']}", window['title'], "", window['hwnd']))
|
||
|
||
# 更新端口映射
|
||
self.debug_ports = {w['number']: 9222 + w['number'] for w in windows}
|
||
|
||
# 关闭进度对话框 - 不显示完成文字，直接变进度条状态
|
||
progress_bar.stop()
|
||
progress_bar.config(mode="determinate", value=100)
|
||
|
||
# 0.3秒后关闭对话框 - 减少等待时间，但还是给用户一点完成的视觉反馈
|
||
progress_dialog.after(300, progress_dialog.destroy)
|
||
|
||
# 显示导入结果 - 只在没有找到窗口时显示提示
|
||
if not windows:
|
||
# 延迟显示消息框，确保进度对话框已关闭
|
||
self.root.after(400, lambda: messagebox.showinfo("导入结果", "未找到任何Chrome窗口"))
|
||
else:
|
||
# 只在控制台打印结果，不再向用户显示
|
||
print(f"成功导入 {len(windows)} 个窗口")
|
||
|
||
# 在主线程中更新UI
|
||
if import_thread_active[0]:
|
||
progress_dialog.after(0, update_ui)
|
||
|
||
except Exception as import_error:
|
||
# 修复变量作用域问题 - 将异常保存到局部变量
|
||
error_message = str(import_error)
|
||
print(f"导入窗口线程内部错误: {error_message}")
|
||
|
||
# 在主线程中关闭对话框并显示错误
|
||
def show_error_message():
|
||
if progress_dialog.winfo_exists():
|
||
progress_dialog.destroy()
|
||
messagebox.showerror("错误", f"导入窗口失败: {error_message}")
|
||
|
||
progress_dialog.after(0, show_error_message)
|
||
|
||
finally:
|
||
# 清理COM环境
|
||
try:
|
||
pythoncom.CoUninitialize()
|
||
except:
|
||
pass
|
||
|
||
# 取消按钮的事件处理
|
||
def on_cancel():
|
||
import_thread_active[0] = False
|
||
progress_dialog.destroy()
|
||
|
||
cancel_btn.config(command=on_cancel)
|
||
|
||
# 启动导入线程
|
||
threading.Thread(target=import_thread, daemon=True).start()
|
||
|
||
except Exception as e:
|
||
print(f"导入窗口失败: {str(e)}")
|
||
messagebox.showerror("错误", f"导入窗口失败: {str(e)}")
|
||
|
||
def enum_window_callback(self, hwnd, windows):
|
||
# 枚举窗口回调函数
|
||
try:
|
||
# 检查窗口是否可见
|
||
if not win32gui.IsWindowVisible(hwnd):
|
||
return
|
||
|
||
# 获取窗口标题
|
||
title = win32gui.GetWindowText(hwnd)
|
||
if not title:
|
||
return
|
||
|
||
# 检查是否是Chrome窗口
|
||
if " - Google Chrome" in title:
|
||
# 提取窗口编号
|
||
number = None
|
||
if title.startswith("[主控]"):
|
||
title = title[4:].strip() # 移除[主控]标记
|
||
|
||
# 从进程命令行参数中获取窗口编号
|
||
try:
|
||
_, pid = win32process.GetWindowThreadProcessId(hwnd)
|
||
handle = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION | win32con.PROCESS_VM_READ, False, pid)
|
||
if handle:
|
||
cmd_line = win32process.GetModuleFileNameEx(handle, 0)
|
||
win32api.CloseHandle(handle)
|
||
|
||
# 从路径中提取编号
|
||
if "\\Data\\" in cmd_line:
|
||
number = int(cmd_line.split("\\Data\\")[-1].split("\\")[0])
|
||
except:
|
||
pass
|
||
|
||
if number is not None:
|
||
windows.append({
|
||
'hwnd': hwnd,
|
||
'title': title,
|
||
'number': number
|
||
})
|
||
|
||
except Exception as e:
|
||
print(f"枚举窗口失败: {str(e)}")
|
||
|
||
def close_selected_windows(self):
|
||
# 关闭选中的窗口
|
||
selected = []
|
||
for item in self.window_list.get_children():
|
||
if self.window_list.set(item, "select") == "√":
|
||
selected.append(item)
|
||
|
||
if not selected:
|
||
messagebox.showinfo("提示", "请先选择要关闭的窗口！")
|
||
return
|
||
|
||
try:
|
||
for item in selected:
|
||
# 从values中获取hwnd
|
||
hwnd = int(self.window_list.item(item)['values'][4])
|
||
try:
|
||
# 检查窗口是否还存在
|
||
if win32gui.IsWindow(hwnd):
|
||
win32gui.PostMessage(hwnd, win32con.WM_CLOSE, 0, 0)
|
||
except:
|
||
pass # 忽略已关闭窗口的错误
|
||
|
||
# 移除自动导入，改为手动从列表中删除项目
|
||
for item in selected:
|
||
self.window_list.delete(item)
|
||
|
||
# 重置全选按钮状态为"全部选择"
|
||
self.select_all_var.set("全部选择")
|
||
|
||
# 显示Chrome后台运行提示（如果启用）
|
||
if self.show_chrome_tip:
|
||
self.show_chrome_settings_tip()
|
||
|
||
except Exception as e:
|
||
print(f"关闭窗口失败: {str(e)}") # 只打印错误，不显示错误对话框
|
||
|
||
def set_taskbar_icons(self):
|
||
# 设置独立任务栏图标
|
||
# 从设置中获取目录信息
|
||
settings = self.load_settings()
|
||
shortcut_dir = self.shortcut_path
|
||
icon_dir = settings.get('icon_dir', '')
|
||
|
||
if not shortcut_dir:
|
||
messagebox.showinfo("提示", "请先在设置中设置快捷方式目录！")
|
||
return
|
||
|
||
if not os.path.exists(shortcut_dir):
|
||
messagebox.showerror("错误", "快捷方式目录不存在！")
|
||
return
|
||
|
||
if not icon_dir:
|
||
messagebox.showinfo("提示", "请先在设置中设置图标目录！")
|
||
return
|
||
|
||
if not os.path.exists(icon_dir):
|
||
messagebox.showerror("错误", "图标目录不存在！")
|
||
return
|
||
|
||
# 确认操作
|
||
choice = messagebox.askyesnocancel("选择操作", "选择要执行的操作：\n是 - 设置自定义图标\n否 - 恢复原始设置\n取消 - 不执行任何操作")
|
||
if choice is None: # 用户点击取消
|
||
return
|
||
|
||
try:
|
||
shell = win32com.client.Dispatch("WScript.Shell")
|
||
modified_count = 0
|
||
|
||
# 获取要修改的窗口编号列表
|
||
window_numbers = self.parse_window_numbers(self.icon_window_numbers.get())
|
||
|
||
if choice: # 设置自定义图标
|
||
# 确保图标目录存在
|
||
if not os.path.exists(icon_dir):
|
||
os.makedirs(icon_dir)
|
||
|
||
# 修改指定的快捷方式
|
||
for i in window_numbers:
|
||
shortcut_path = os.path.join(shortcut_dir, f"{i}.lnk")
|
||
if not os.path.exists(shortcut_path):
|
||
continue
|
||
|
||
# 修改快捷方式
|
||
shortcut = shell.CreateShortCut(shortcut_path)
|
||
|
||
# 设置自定义图标
|
||
icon_path = os.path.join(icon_dir, f"{i}.ico")
|
||
if os.path.exists(icon_path):
|
||
shortcut.IconLocation = icon_path
|
||
# 保存修改
|
||
shortcut.save()
|
||
modified_count += 1
|
||
|
||
messagebox.showinfo("成功", f"已成功修改 {modified_count} 个快捷方式的图标！")
|
||
else: # 恢复原始设置
|
||
chrome_path = r"C:\Program Files\Google\Chrome\Application\chrome.exe"
|
||
if not os.path.exists(chrome_path):
|
||
chrome_path = r"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe"
|
||
|
||
# 获取Chrome数据目录
|
||
chrome_data_dir = settings.get('cache_dir', 'D:\\chrom duo\\Data')
|
||
|
||
# 恢复指定的快捷方式
|
||
for i in window_numbers:
|
||
shortcut_path = os.path.join(shortcut_dir, f"{i}.lnk")
|
||
if not os.path.exists(shortcut_path):
|
||
continue
|
||
|
||
# 修改快捷方式
|
||
shortcut = shell.CreateShortCut(shortcut_path)
|
||
|
||
# 恢复默认图标
|
||
shortcut.IconLocation = f"{chrome_path},0"
|
||
|
||
# 恢复原始启动参数
|
||
original_args = f'--user-data-dir="{chrome_data_dir}\\{i}"'
|
||
shortcut.TargetPath = chrome_path
|
||
shortcut.Arguments = original_args
|
||
|
||
# 保存修改
|
||
shortcut.save()
|
||
modified_count += 1
|
||
|
||
messagebox.showinfo("成功", f"已成功恢复 {modified_count} 个快捷方式的原始设置！")
|
||
|
||
except Exception as e:
|
||
messagebox.showerror("错误", f"操作失败: {str(e)}")
|
||
|
||
def batch_open_urls(self):
|
||
"""批量打开网页，使用直接的命令行方式打开URL"""
|
||
try:
|
||
# 获取输入的网址
|
||
url = self.url_entry.get()
|
||
if not url:
|
||
messagebox.showwarning("警告", "请输入要打开的网址！")
|
||
return
|
||
|
||
# 确保 URL 格式正确
|
||
if not url.startswith(('http://', 'https://')):
|
||
url = 'https://' + url
|
||
|
||
# 获取选中的窗口
|
||
selected_windows = []
|
||
for item in self.window_list.get_children():
|
||
if self.window_list.set(item, "select") == "√":
|
||
try:
|
||
# 获取窗口编号和标题
|
||
# values列表: ["", "编号", "标题", "", hwnd]
|
||
window_values = self.window_list.item(item)['values']
|
||
window_num = int(window_values[1]) # 获取窗口编号
|
||
window_title = str(window_values[2]) if len(window_values) > 2 else ""
|
||
hwnd = int(window_values[-1]) if len(window_values) > 4 else 0
|
||
|
||
# 调试输出
|
||
print(f"选择了窗口: {window_title} (编号: {window_num}, 句柄: {hwnd})")
|
||
selected_windows.append(window_num)
|
||
except (ValueError, IndexError) as e:
|
||
print(f"解析窗口信息出错: {str(e)}")
|
||
# 忽略无法识别编号的窗口
|
||
|
||
if not selected_windows:
|
||
messagebox.showwarning("警告", "请先选择要操作的窗口！")
|
||
return
|
||
|
||
# 调试输出
|
||
print(f"选择的窗口编号: {selected_windows}")
|
||
|
||
# 验证快捷方式目录是否存在
|
||
shortcut_dir = self.shortcut_path
|
||
if not shortcut_dir or not os.path.exists(shortcut_dir):
|
||
messagebox.showerror("错误", "快捷方式目录不存在，请在设置中配置！")
|
||
return
|
||
|
||
# 查找Chrome路径
|
||
chrome_path = self.find_chrome_path()
|
||
if not chrome_path:
|
||
messagebox.showerror("错误", "未找到Chrome安装路径！")
|
||
return
|
||
|
||
# 创建WScript.Shell对象（如果尚未创建）
|
||
if not hasattr(self, 'shell') or self.shell is None:
|
||
self.shell = win32com.client.Dispatch("WScript.Shell")
|
||
|
||
# 为每个选中的窗口直接启动Chrome并打开指定URL
|
||
success_count = 0
|
||
for window_num in selected_windows:
|
||
try:
|
||
# 通过快捷方式获取用户数据目录路径
|
||
shortcut_path = os.path.join(shortcut_dir, f"{window_num}.lnk")
|
||
|
||
# 检查快捷方式是否存在
|
||
if not os.path.exists(shortcut_path):
|
||
print(f"警告: 窗口 {window_num} 的快捷方式不存在: {shortcut_path}")
|
||
continue
|
||
|
||
# 从快捷方式中获取用户数据目录
|
||
try:
|
||
shortcut_obj = self.shell.CreateShortCut(shortcut_path)
|
||
cmd_line = shortcut_obj.Arguments
|
||
|
||
# 提取user-data-dir参数
|
||
if '--user-data-dir=' in cmd_line:
|
||
user_data_dir = re.search(r'--user-data-dir="?([^"]+)"?', cmd_line)
|
||
if user_data_dir:
|
||
user_data_dir = user_data_dir.group(1)
|
||
else:
|
||
print(f"警告: 无法从快捷方式提取用户数据目录: {shortcut_path}")
|
||
continue
|
||
else:
|
||
# 尝试使用旧的方式（向后兼容）
|
||
user_data_dir = os.path.join(self.cache_dir, str(window_num))
|
||
if not os.path.exists(user_data_dir):
|
||
print(f"警告: 窗口 {window_num} 的用户数据目录不存在: {user_data_dir}")
|
||
continue
|
||
except Exception as e:
|
||
print(f"警告: 读取快捷方式失败: {str(e)}")
|
||
continue
|
||
|
||
# 使用subprocess.list形式构建命令，避免路径引号问题
|
||
cmd_list = [
|
||
chrome_path,
|
||
f'--user-data-dir={user_data_dir}',
|
||
]
|
||
|
||
# 如果启用了CDP，添加调试端口参数
|
||
if self.enable_cdp:
|
||
debug_port = 9222 + window_num
|
||
cmd_list.insert(1, f'--remote-debugging-port={debug_port}')
|
||
|
||
# 添加URL
|
||
cmd_list.append(url)
|
||
|
||
# 打印命令以便调试
|
||
print(f"执行命令: {' '.join(cmd_list)}")
|
||
|
||
# 使用不带shell的方式启动进程，避免命令行解析问题
|
||
subprocess.Popen(cmd_list)
|
||
|
||
success_count += 1
|
||
print(f"成功在窗口 {window_num} 打开URL: {url}")
|
||
|
||
# 短暂延迟，避免同时打开太多窗口导致系统过载
|
||
time.sleep(0.1)
|
||
|
||
except Exception as e:
|
||
print(f"打开URL失败 (窗口 {window_num}): {str(e)}")
|
||
|
||
# 移除通知提示，操作成功或失败都不再提示
|
||
# if success_count > 0:
|
||
# self.show_notification("成功", f"成功为 {success_count} 个窗口打开了网页！")
|
||
# else:
|
||
# messagebox.showerror("失败", "批量打开网页失败！")
|
||
|
||
except Exception as e:
|
||
messagebox.showerror("错误", f"批量打开网页失败: {str(e)}")
|
||
|
||
def find_chrome_path(self):
|
||
"""查找Chrome可执行文件路径"""
|
||
common_paths = [
|
||
r"C:\Program Files\Google\Chrome\Application\chrome.exe",
|
||
r"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe",
|
||
r"C:\Users\%USERNAME%\AppData\Local\Google\Chrome\Application\chrome.exe"
|
||
]
|
||
|
||
# 替换用户名
|
||
username = os.environ.get('USERNAME', '')
|
||
common_paths = [p.replace('%USERNAME%', username) for p in common_paths]
|
||
|
||
# 检查常见路径
|
||
for path in common_paths:
|
||
if os.path.exists(path):
|
||
return path
|
||
|
||
# 如果找不到，尝试从注册表获取
|
||
try:
|
||
import winreg
|
||
key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\chrome.exe")
|
||
chrome_path, _ = winreg.QueryValueEx(key, None)
|
||
if os.path.exists(chrome_path):
|
||
return chrome_path
|
||
except:
|
||
pass
|
||
|
||
# 如果以上方法都失败，返回None
|
||
return None
|
||
|
||
def run(self):
|
||
"""运行程序"""
|
||
try:
|
||
# 确保窗口快速显示
|
||
print(f"[{time.time() - self.start_time:.3f}s] 开始显示窗口...")
|
||
self.root.deiconify() # 显示窗口
|
||
self.root.attributes('-topmost', True) # 先设置为置顶
|
||
self.root.update() # 强制刷新UI
|
||
self.root.attributes('-topmost', False) # 取消置顶
|
||
print(f"[{time.time() - self.start_time:.3f}s] 窗口显示完成")
|
||
|
||
# 启动主循环
|
||
self.root.mainloop()
|
||
except Exception as e:
|
||
print(f"运行程序时出错: {str(e)}")
|
||
# 确保错误被显示出来
|
||
error_message = f"程序出现错误:\n{str(e)}\n\n{traceback.format_exc()}"
|
||
print(error_message)
|
||
try:
|
||
messagebox.showerror("程序错误", error_message)
|
||
except:
|
||
pass
|
||
|
||
def delayed_initialization(self):
|
||
"""延迟执行可能耗时的初始化操作"""
|
||
try:
|
||
print(f"[{time.time() - self.start_time:.3f}s] 开始执行延迟初始化")
|
||
|
||
# 检查管理员权限(延迟检查)
|
||
if not is_admin():
|
||
print(f"[{time.time() - self.start_time:.3f}s] 检测到非管理员权限，准备提示")
|
||
# 将管理员权限请求延迟显示，确保主窗口已完全显示
|
||
def show_admin_prompt():
|
||
result = messagebox.askquestion("权限提示", "没有管理员权限可能无法正常访问某些窗口，是否以管理员身份重新启动？")
|
||
if result == 'yes':
|
||
run_as_admin()
|
||
self.root.destroy()
|
||
# 延迟更长时间显示，避免干扰用户
|
||
self.root.after(1500, show_admin_prompt)
|
||
else:
|
||
print(f"[{time.time() - self.start_time:.3f}s] 已是管理员权限")
|
||
|
||
# 预热窗口枚举 (这个操作可能比较慢)
|
||
print(f"[{time.time() - self.start_time:.3f}s] 开始预热窗口枚举...")
|
||
try:
|
||
# 注意：这里不实际填充列表，只做枚举测试
|
||
windows = []
|
||
win32gui.EnumWindows(self.enum_window_callback, windows)
|
||
print(f"[{time.time() - self.start_time:.3f}s] 预热窗口枚举完成")
|
||
except Exception as e:
|
||
print(f"[{time.time() - self.start_time:.3f}s] 预热窗口枚举失败: {str(e)}")
|
||
|
||
# 其他可能耗时的初始化可以放在这里
|
||
|
||
print(f"[{time.time() - self.start_time:.3f}s] 所有延迟初始化任务完成")
|
||
except Exception as e:
|
||
print(f"[{time.time() - self.start_time:.3f}s] 延迟初始化出错: {str(e)}")
|
||
|
||
def load_window_position(self):
|
||
# 从 settings.json 加载窗口位置
|
||
try:
|
||
position = self.settings.get('window_position')
|
||
if position:
|
||
# 检查是否只包含位置信息（以+开头）
|
||
if position.startswith('+'):
|
||
return position # 直接返回位置信息
|
||
|
||
# 处理包含尺寸的旧格式（"widthxheight+x+y"）
|
||
if 'x' in position and '+' in position:
|
||
parts = position.split('+')
|
||
if len(parts) >= 3:
|
||
return f"+{parts[1]}+{parts[2]}" # 只返回位置部分
|
||
return None
|
||
except Exception as e:
|
||
print(f"加载窗口位置失败: {str(e)}")
|
||
return None
|
||
|
||
def save_window_position(self):
|
||
# 保存窗口位置到 settings.json（只保存位置，不保存尺寸）
|
||
try:
|
||
# 获取窗口当前位置
|
||
geometry = self.root.geometry()
|
||
|
||
# 提取位置信息 (x和y坐标)
|
||
position_parts = geometry.split('+')
|
||
if len(position_parts) >= 3:
|
||
x_pos = position_parts[1]
|
||
y_pos = position_parts[2]
|
||
position = f"+{x_pos}+{y_pos}" # 只保存位置信息
|
||
|
||
# 保存到设置
|
||
self.settings['window_position'] = position
|
||
|
||
# 写入文件
|
||
with open('settings.json', 'w', encoding='utf-8') as f:
|
||
json.dump(self.settings, f, ensure_ascii=False, indent=4)
|
||
except Exception as e:
|
||
print(f"保存窗口位置失败: {str(e)}")
|
||
|
||
def get_chrome_popups(self, chrome_hwnd):
|
||
"""改进的插件窗口检测，支持网页触发的钱包插件和网页浮动层"""
|
||
popups = []
|
||
def enum_windows_callback(hwnd, _):
|
||
try:
|
||
if not win32gui.IsWindowVisible(hwnd):
|
||
return
|
||
|
||
class_name = win32gui.GetClassName(hwnd)
|
||
title = win32gui.GetWindowText(hwnd)
|
||
_, chrome_pid = win32process.GetWindowThreadProcessId(chrome_hwnd)
|
||
_, popup_pid = win32process.GetWindowThreadProcessId(hwnd)
|
||
|
||
# 检查是否是Chrome相关窗口
|
||
if popup_pid == chrome_pid:
|
||
# 检查窗口类型
|
||
if "Chrome_WidgetWin" in class_name: # 放宽类名匹配条件
|
||
# 检查是否是扩展程序相关窗口，放宽检测条件
|
||
style = win32gui.GetWindowLong(hwnd, win32con.GWL_STYLE)
|
||
ex_style = win32gui.GetWindowLong(hwnd, win32con.GWL_EXSTYLE)
|
||
|
||
# 扩展窗口的特征
|
||
is_popup = (
|
||
"扩展程序" in title or
|
||
"插件" in title or
|
||
"OKX" in title or # 常见钱包名称
|
||
"MetaMask" in title or # 常见钱包名称
|
||
"钱包" in title or
|
||
"Wallet" in title or
|
||
win32gui.GetParent(hwnd) == chrome_hwnd or
|
||
(style & win32con.WS_POPUP) != 0 or
|
||
(style & win32con.WS_CHILD) != 0 or
|
||
(ex_style & win32con.WS_EX_TOOLWINDOW) != 0 or
|
||
(ex_style & win32con.WS_EX_DLGMODALFRAME) != 0 # 对话框样式窗口
|
||
)
|
||
|
||
# 获取窗口位置和大小，钱包插件通常较小
|
||
rect = win32gui.GetWindowRect(hwnd)
|
||
width = rect[2] - rect[0]
|
||
height = rect[3] - rect[1]
|
||
|
||
# 钱包插件窗口通常不会特别大
|
||
is_wallet_size = (width < 800 and height < 800 and width > 200 and height > 200)
|
||
|
||
# 网页浮动层通常是较小的弹窗
|
||
is_floating_layer = (
|
||
(style & win32con.WS_POPUP) != 0 and
|
||
(width < 600 and height < 600) and
|
||
hwnd != chrome_hwnd
|
||
)
|
||
|
||
if is_popup or is_wallet_size or is_floating_layer:
|
||
# 增加额外判断，如果窗口很像钱包弹窗，即使不满足其他条件也捕获
|
||
if hwnd != chrome_hwnd and hwnd not in popups:
|
||
if self.is_likely_wallet_popup(hwnd, chrome_hwnd) or is_floating_layer:
|
||
popups.append(hwnd)
|
||
print(f"识别到可能的钱包插件窗口或网页浮动层: {title} (句柄: {hwnd})")
|
||
elif is_popup:
|
||
popups.append(hwnd)
|
||
|
||
except Exception as e:
|
||
print(f"枚举窗口失败: {str(e)}")
|
||
|
||
win32gui.EnumWindows(enum_windows_callback, None)
|
||
return popups
|
||
|
||
def is_likely_wallet_popup(self, hwnd, parent_hwnd):
|
||
"""检查窗口是否可能是钱包弹出窗口或网页浮动层"""
|
||
try:
|
||
# 常见钱包和浮层关键词
|
||
keywords = [
|
||
"钱包", "okx", "metamask", "token", "connect", "wallet", "sign",
|
||
"signature", "transaction", "登录", "connect", "eth", "web3", "链接", "连接",
|
||
"确认", "confirm", "cancel", "取消", "dialog", "弹出层", "浮层", "modal",
|
||
"popup", "alert", "提示", "通知", "message", "消息"
|
||
]
|
||
|
||
# 检查窗口标题
|
||
title = win32gui.GetWindowText(hwnd).lower()
|
||
for keyword in keywords:
|
||
if keyword.lower() in title:
|
||
return True
|
||
|
||
# 尝试获取窗口内部的文本 (使用WM_GETTEXT消息)
|
||
buffer_size = 1024
|
||
buffer = ctypes.create_unicode_buffer(buffer_size)
|
||
try:
|
||
ctypes.windll.user32.SendMessageW(hwnd, win32con.WM_GETTEXT, buffer_size, ctypes.byref(buffer))
|
||
text = buffer.value.lower()
|
||
for keyword in keywords:
|
||
if keyword.lower() in text:
|
||
return True
|
||
except:
|
||
pass
|
||
|
||
# 检查窗口尺寸和样式特征
|
||
rect = win32gui.GetWindowRect(hwnd)
|
||
width = rect[2] - rect[0]
|
||
height = rect[3] - rect[1]
|
||
|
||
# 获取Chrome主窗口位置
|
||
parent_rect = win32gui.GetWindowRect(parent_hwnd)
|
||
|
||
# 检查窗口是否在Chrome窗口内或附近
|
||
is_near_chrome = (
|
||
rect[0] >= parent_rect[0] - 100 and
|
||
rect[1] >= parent_rect[1] - 100 and
|
||
rect[2] <= parent_rect[2] + 100 and
|
||
rect[3] <= parent_rect[3] + 100
|
||
)
|
||
|
||
# 检查窗口样式
|
||
style = win32gui.GetWindowLong(hwnd, win32con.GWL_STYLE)
|
||
ex_style = win32gui.GetWindowLong(hwnd, win32con.GWL_EXSTYLE)
|
||
|
||
# 弹出窗口特征
|
||
has_popup_style = (
|
||
(style & win32con.WS_POPUP) != 0 or
|
||
(ex_style & win32con.WS_EX_TOPMOST) != 0 or
|
||
(ex_style & win32con.WS_EX_TOOLWINDOW) != 0
|
||
)
|
||
|
||
# 检测是否为网页浮动层 (往往会有z-index较高，且有特定样式)
|
||
is_floating_layer = (
|
||
has_popup_style and
|
||
is_near_chrome and
|
||
(200 <= width <= 600 and 100 <= height <= 600)
|
||
)
|
||
|
||
# 综合判断
|
||
return (
|
||
((300 <= width <= 600 and 300 <= height <= 800) and # 典型钱包窗口尺寸
|
||
has_popup_style and
|
||
is_near_chrome) or
|
||
is_floating_layer
|
||
)
|
||
|
||
except Exception as e:
|
||
print(f"判断钱包窗口或浮动层失败: {str(e)}")
|
||
return False
|
||
|
||
def monitor_popups(self):
|
||
"""监控Chrome弹出窗口，改进以更好地支持钱包插件窗口"""
|
||
last_check_time = time.time()
|
||
last_error_time = 0
|
||
error_count = 0
|
||
|
||
# 钱包插件窗口同步历史
|
||
wallet_popup_history = {}
|
||
|
||
print("启动弹窗监控线程...")
|
||
|
||
while self.is_sync:
|
||
try:
|
||
# 优化CPU使用率
|
||
time.sleep(0.1) # 更快速的检查以捕获快速弹出的钱包窗口
|
||
|
||
# 每500毫秒执行一次完整检查
|
||
current_time = time.time()
|
||
if current_time - last_check_time < 0.5:
|
||
continue
|
||
|
||
last_check_time = current_time
|
||
|
||
# 检查主窗口是否有效
|
||
if not self.master_window or not win32gui.IsWindow(self.master_window):
|
||
if current_time - last_error_time > 10:
|
||
print("主窗口无效，停止同步")
|
||
last_error_time = current_time
|
||
self.stop_sync()
|
||
break
|
||
|
||
# 获取主窗口的弹出窗口
|
||
current_popups = self.get_chrome_popups(self.master_window)
|
||
|
||
# 检查是否有新增弹出窗口或关闭的弹出窗口
|
||
new_popups = [popup for popup in current_popups if popup not in self.popup_windows]
|
||
closed_popups = [popup for popup in self.popup_windows if popup not in current_popups]
|
||
|
||
has_changes = False
|
||
|
||
# 处理新的弹出窗口，特别注意钱包插件窗口
|
||
for popup in new_popups:
|
||
try:
|
||
if self.is_sync and win32gui.IsWindow(popup):
|
||
# 获取窗口标题
|
||
title = win32gui.GetWindowText(popup)
|
||
|
||
# 检查是否是钱包插件窗口
|
||
is_wallet = self.is_likely_wallet_popup(popup, self.master_window)
|
||
|
||
if is_wallet:
|
||
print(f"发现钱包插件窗口: {title}")
|
||
# 记录钱包窗口信息用于后续处理
|
||
wallet_popup_history[popup] = {
|
||
'detected_time': time.time(),
|
||
'title': title,
|
||
'synced': False
|
||
}
|
||
|
||
# 将弹出窗口添加到同步列表
|
||
if popup not in self.popup_windows:
|
||
self.popup_windows.append(popup)
|
||
has_changes = True
|
||
except Exception as e:
|
||
if current_time - last_error_time > 10:
|
||
print(f"处理新弹窗时出错: {str(e)}")
|
||
last_error_time = current_time
|
||
|
||
# 清理已关闭的弹出窗口
|
||
for popup in closed_popups:
|
||
if popup in self.popup_windows:
|
||
self.popup_windows.remove(popup)
|
||
if popup in wallet_popup_history:
|
||
del wallet_popup_history[popup]
|
||
has_changes = True
|
||
|
||
# 同步处理钱包窗口和其他弹出窗口
|
||
if has_changes:
|
||
self.sync_popups()
|
||
|
||
# 定期尝试同步钱包插件窗口，即使没有检测到变化
|
||
# 这有助于处理某些难以检测的网页触发钱包窗口
|
||
for hwnd, info in list(wallet_popup_history.items()):
|
||
if (not info.get('synced') and
|
||
current_time - info.get('detected_time', 0) > 0.5 and
|
||
win32gui.IsWindow(hwnd)):
|
||
# 尝试强制同步钱包窗口
|
||
try:
|
||
self.sync_specific_popup(hwnd)
|
||
info['synced'] = True
|
||
print(f"强制同步钱包窗口: {info['title']}")
|
||
except Exception as e:
|
||
if current_time - last_error_time > 10:
|
||
print(f"强制同步钱包窗口失败: {str(e)}")
|
||
last_error_time = current_time
|
||
|
||
# 清理无效的历史记录
|
||
for hwnd in list(wallet_popup_history.keys()):
|
||
if not win32gui.IsWindow(hwnd) or current_time - wallet_popup_history[hwnd]['detected_time'] > 60:
|
||
del wallet_popup_history[hwnd]
|
||
|
||
except Exception as e:
|
||
error_count += 1
|
||
|
||
# 限制错误日志频率
|
||
if current_time - last_error_time > 10:
|
||
print(f"弹出窗口监控异常: {str(e)}")
|
||
last_error_time = current_time
|
||
|
||
# 防止过多错误导致CPU占用过高
|
||
if error_count > 100:
|
||
print("错误次数过多，停止弹窗监控")
|
||
break
|
||
|
||
time.sleep(1) # 出错后等待一段时间
|
||
|
||
print("弹窗监控线程已结束")
|
||
|
||
def sync_specific_popup(self, popup_hwnd):
|
||
"""单独同步特定的弹出窗口（特别是钱包插件窗口）"""
|
||
try:
|
||
if not win32gui.IsWindow(popup_hwnd):
|
||
return
|
||
|
||
# 获取窗口位置
|
||
popup_rect = win32gui.GetWindowRect(popup_hwnd)
|
||
popup_x = popup_rect[0]
|
||
popup_y = popup_rect[1]
|
||
popup_width = popup_rect[2] - popup_rect[0]
|
||
popup_height = popup_rect[3] - popup_rect[1]
|
||
|
||
# 获取主窗口位置
|
||
master_rect = win32gui.GetWindowRect(self.master_window)
|
||
master_x = master_rect[0]
|
||
master_y = master_rect[1]
|
||
|
||
# 计算相对位置（相对于主窗口左上角）
|
||
relative_x = popup_x - master_x
|
||
relative_y = popup_y - master_y
|
||
|
||
# 确保在其他浏览器窗口中也能看到弹出窗口
|
||
for hwnd in self.sync_windows:
|
||
try:
|
||
if hwnd != self.master_window and win32gui.IsWindow(hwnd):
|
||
# 获取同步窗口位置
|
||
sync_rect = win32gui.GetWindowRect(hwnd)
|
||
sync_x = sync_rect[0]
|
||
sync_y = sync_rect[1]
|
||
|
||
# 计算新位置（相对于同步窗口）
|
||
new_x = sync_x + relative_x
|
||
new_y = sync_y + relative_y
|
||
|
||
# 检查同步窗口的弹出窗口
|
||
sync_popups = self.get_chrome_popups(hwnd)
|
||
|
||
# 查找匹配的弹出窗口，使用标题和大小作为匹配依据
|
||
target_title = win32gui.GetWindowText(popup_hwnd)
|
||
matching_popup = None
|
||
|
||
for sync_popup in sync_popups:
|
||
if win32gui.IsWindow(sync_popup):
|
||
sync_popup_title = win32gui.GetWindowText(sync_popup)
|
||
sync_popup_rect = win32gui.GetWindowRect(sync_popup)
|
||
sync_popup_width = sync_popup_rect[2] - sync_popup_rect[0]
|
||
sync_popup_height = sync_popup_rect[3] - sync_popup_rect[1]
|
||
|
||
# 如果标题相似且尺寸相近，认为是匹配的窗口
|
||
title_similarity = self.title_similarity(target_title, sync_popup_title)
|
||
size_match = (
|
||
abs(sync_popup_width - popup_width) < 50 and
|
||
abs(sync_popup_height - popup_height) < 50
|
||
)
|
||
|
||
if title_similarity > 0.5 or size_match:
|
||
matching_popup = sync_popup
|
||
break
|
||
|
||
# 移动匹配的弹出窗口
|
||
if matching_popup:
|
||
win32gui.SetWindowPos(
|
||
matching_popup,
|
||
win32con.HWND_TOP,
|
||
new_x, new_y,
|
||
popup_width, popup_height,
|
||
win32con.SWP_NOACTIVATE
|
||
)
|
||
|
||
except Exception as e:
|
||
print(f"同步特定弹窗失败: {str(e)}")
|
||
|
||
except Exception as e:
|
||
print(f"同步特定弹窗出错: {str(e)}")
|
||
|
||
def title_similarity(self, title1, title2):
|
||
"""计算两个窗口标题之间的相似度
|
||
|
||
Args:
|
||
title1: 第一个窗口标题
|
||
title2: 第二个窗口标题
|
||
|
||
Returns:
|
||
float: 0到1之间的相似度分数，1表示完全匹配
|
||
"""
|
||
# 处理空标题的情况
|
||
if not title1 and not title2:
|
||
return 1.0
|
||
if not title1 or not title2:
|
||
return 0.0
|
||
|
||
# 转换为小写以进行不区分大小写的比较
|
||
title1 = title1.lower()
|
||
title2 = title2.lower()
|
||
|
||
# 计算Jaccard相似度
|
||
set1 = set(title1)
|
||
set2 = set(title2)
|
||
|
||
# 计算交集和并集的大小
|
||
intersection_size = len(set1.intersection(set2))
|
||
union_size = len(set1.union(set2))
|
||
|
||
# 避免除以零
|
||
if union_size == 0:
|
||
return 1.0
|
||
|
||
return intersection_size / union_size
|
||
|
||
def show_shortcut_dialog(self):
|
||
# 显示快捷键设置对话框
|
||
# 创建对话框
|
||
dialog = tk.Toplevel(self.root)
|
||
dialog.title("设置同步功能快捷键")
|
||
dialog.geometry("300x150")
|
||
dialog.resizable(False, False)
|
||
|
||
# 使对话框模态
|
||
dialog.transient(self.root)
|
||
dialog.grab_set()
|
||
|
||
# 设置图标
|
||
try:
|
||
icon_path = os.path.join(os.path.dirname(__file__), "app.ico")
|
||
if os.path.exists(icon_path):
|
||
dialog.iconbitmap(icon_path)
|
||
except Exception as e:
|
||
print(f"设置图标失败: {str(e)}")
|
||
|
||
# 当前快捷键显示
|
||
current_label = ttk.Label(dialog, text=f"当前快捷键: {self.current_shortcut}")
|
||
current_label.pack(pady=10)
|
||
|
||
# 快捷键输入框
|
||
shortcut_var = tk.StringVar(value="点击下方按钮开始录制快捷键...")
|
||
shortcut_label = ttk.Label(dialog, textvariable=shortcut_var)
|
||
shortcut_label.pack(pady=5)
|
||
|
||
# 记录按键状态
|
||
keys_pressed = set()
|
||
recording = False
|
||
on_key_event = None # 在外部声明，方便后续引用
|
||
|
||
def start_recording():
|
||
# 开始录制快捷键
|
||
nonlocal recording, on_key_event
|
||
recording = True
|
||
keys_pressed.clear()
|
||
shortcut_var.set("请按下快捷键组合...")
|
||
record_btn.configure(state='disabled')
|
||
|
||
# 定义按键事件处理函数
|
||
def on_key_event_handler(e):
|
||
if not recording:
|
||
return
|
||
if e.event_type == keyboard.KEY_DOWN:
|
||
keys_pressed.add(e.name)
|
||
shortcut_var.set('+'.join(sorted(keys_pressed)))
|
||
elif e.event_type == keyboard.KEY_UP:
|
||
if e.name in keys_pressed:
|
||
keys_pressed.remove(e.name)
|
||
if not keys_pressed:
|
||
stop_recording()
|
||
|
||
# 保存引用以便后续取消钩子
|
||
on_key_event = on_key_event_handler
|
||
|
||
# 只为录制添加临时钩子
|
||
keyboard.hook(on_key_event)
|
||
|
||
def stop_recording():
|
||
# 停止录制快捷键
|
||
nonlocal recording
|
||
recording = False
|
||
|
||
# 移除录制时添加的临时钩子，而不是所有钩子
|
||
keyboard.unhook(on_key_event)
|
||
|
||
# 不再需要重新设置当前快捷键，保持原状
|
||
record_btn.configure(state='normal')
|
||
|
||
# 录制按钮
|
||
record_btn = ttk.Button(
|
||
dialog,
|
||
text="开始录制",
|
||
command=start_recording
|
||
)
|
||
record_btn.pack(pady=10)
|
||
|
||
def save_shortcut():
|
||
# 保存快捷键设置
|
||
new_shortcut = shortcut_var.get()
|
||
if new_shortcut and new_shortcut != "点击下方按钮开始录制快捷键..." and new_shortcut != "请按下快捷键组合...":
|
||
try:
|
||
# 设置新快捷键
|
||
self.set_shortcut(new_shortcut)
|
||
|
||
# 保存到设置文件
|
||
settings = self.load_settings()
|
||
settings['sync_shortcut'] = new_shortcut
|
||
with open('settings.json', 'w', encoding='utf-8') as f:
|
||
json.dump(settings, f, ensure_ascii=False, indent=4)
|
||
|
||
messagebox.showinfo("成功", f"快捷键已设置为: {new_shortcut}")
|
||
dialog.destroy()
|
||
except Exception as e:
|
||
messagebox.showerror("错误", f"设置快捷键失败: {str(e)}")
|
||
else:
|
||
messagebox.showwarning("警告", "请先录制快捷键！")
|
||
|
||
# 保存按钮
|
||
ttk.Button(
|
||
dialog,
|
||
text="保存",
|
||
style='Accent.TButton',
|
||
command=save_shortcut
|
||
).pack(pady=5)
|
||
|
||
# 确保关闭对话框时停止录制
|
||
dialog.protocol("WM_DELETE_WINDOW", lambda: [stop_recording(), dialog.destroy()])
|
||
|
||
# 居中显示对话框
|
||
dialog.update_idletasks()
|
||
width = dialog.winfo_width()
|
||
height = dialog.winfo_height()
|
||
x = (dialog.winfo_screenwidth() // 2) - (width // 2)
|
||
y = (dialog.winfo_screenheight() // 2) - (height // 2)
|
||
dialog.geometry(f'{width}x{height}+{x}+{y}')
|
||
|
||
def set_shortcut(self, shortcut):
|
||
# 设置快捷键
|
||
try:
|
||
# 只清除之前的快捷键钩子，而不是所有钩子
|
||
if hasattr(self, 'shortcut_hook') and self.shortcut_hook:
|
||
keyboard.remove_hotkey(self.shortcut_hook)
|
||
self.shortcut_hook = None
|
||
|
||
# 设置新的快捷键
|
||
if shortcut:
|
||
# 保存当前快捷键字符串，即使添加热键失败也能保留
|
||
self.current_shortcut = shortcut
|
||
|
||
# 添加新的热键钩子
|
||
self.shortcut_hook = keyboard.add_hotkey(
|
||
shortcut,
|
||
self.toggle_sync,
|
||
suppress=True,
|
||
trigger_on_release=True
|
||
)
|
||
print(f"快捷键 {shortcut} 设置成功")
|
||
|
||
# 保存到设置文件
|
||
settings = self.load_settings()
|
||
settings['sync_shortcut'] = shortcut
|
||
with open('settings.json', 'w', encoding='utf-8') as f:
|
||
json.dump(settings, f, ensure_ascii=False, indent=4)
|
||
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"设置快捷键失败: {str(e)}")
|
||
# 不重置current_shortcut，即使失败也保留当前值
|
||
return False
|
||
|
||
def update_screen_list(self):
|
||
"""更新屏幕列表，返回屏幕名称列表"""
|
||
try:
|
||
screens = []
|
||
def callback(hmonitor, hdc, lprect, lparam):
|
||
try:
|
||
# 获取显示器信息
|
||
monitor_info = win32api.GetMonitorInfo(hmonitor)
|
||
screen_name = f"屏幕 {len(screens) + 1}"
|
||
if monitor_info['Flags'] & 1: # MONITORINFOF_PRIMARY
|
||
screen_name += " (主)"
|
||
screens.append({
|
||
'name': screen_name,
|
||
'rect': monitor_info['Monitor'],
|
||
'work_rect': monitor_info['Work'],
|
||
'monitor': hmonitor
|
||
})
|
||
except Exception as e:
|
||
print(f"处理显示器信息失败: {str(e)}")
|
||
return True
|
||
|
||
# 定义回调函数类型
|
||
MONITORENUMPROC = ctypes.WINFUNCTYPE(
|
||
ctypes.c_bool,
|
||
ctypes.c_ulong,
|
||
ctypes.c_ulong,
|
||
ctypes.POINTER(wintypes.RECT),
|
||
ctypes.c_longlong
|
||
)
|
||
|
||
# 创建回调函数
|
||
callback_function = MONITORENUMPROC(callback)
|
||
|
||
# 枚举显示器
|
||
if ctypes.windll.user32.EnumDisplayMonitors(0, 0, callback_function, 0) == 0:
|
||
# EnumDisplayMonitors 失败，尝试使用备用方法
|
||
try:
|
||
# 获取虚拟屏幕范围
|
||
virtual_width = win32api.GetSystemMetrics(win32con.SM_CXVIRTUALSCREEN)
|
||
virtual_height = win32api.GetSystemMetrics(win32con.SM_CYVIRTUALSCREEN)
|
||
virtual_left = win32api.GetSystemMetrics(win32con.SM_XVIRTUALSCREEN)
|
||
virtual_top = win32api.GetSystemMetrics(win32con.SM_YVIRTUALSCREEN)
|
||
|
||
# 获取主屏幕信息
|
||
primary_monitor = win32api.MonitorFromPoint((0, 0), win32con.MONITOR_DEFAULTTOPRIMARY)
|
||
primary_info = win32api.GetMonitorInfo(primary_monitor)
|
||
|
||
# 添加主屏幕
|
||
screens.append({
|
||
'name': "屏幕 1 (主)",
|
||
'rect': primary_info['Monitor'],
|
||
'work_rect': primary_info['Work'],
|
||
'monitor': primary_monitor
|
||
})
|
||
|
||
# 尝试获取第二个屏幕
|
||
try:
|
||
second_monitor = win32api.MonitorFromPoint(
|
||
(virtual_left + virtual_width - 1,
|
||
virtual_top + virtual_height // 2),
|
||
win32con.MONITOR_DEFAULTTONULL
|
||
)
|
||
if second_monitor and second_monitor != primary_monitor:
|
||
second_info = win32api.GetMonitorInfo(second_monitor)
|
||
screens.append({
|
||
'name': "屏幕 2",
|
||
'rect': second_info['Monitor'],
|
||
'work_rect': second_info['Work'],
|
||
'monitor': second_monitor
|
||
})
|
||
except:
|
||
pass
|
||
|
||
except Exception as e:
|
||
print(f"备用方法失败: {str(e)}")
|
||
|
||
if not screens:
|
||
# 如果仍然没有找到屏幕，使用基本方案
|
||
screen_width = win32api.GetSystemMetrics(win32con.SM_CXSCREEN)
|
||
screen_height = win32api.GetSystemMetrics(win32con.SM_CYSCREEN)
|
||
screens.append({
|
||
'name': "屏幕 1 (主)",
|
||
'rect': (0, 0, screen_width, screen_height),
|
||
'work_rect': (0, 0, screen_width, screen_height),
|
||
'monitor': None
|
||
})
|
||
|
||
# 按照屏幕位置排序（从左到右）
|
||
screens.sort(key=lambda x: x['rect'][0])
|
||
|
||
# 保存屏幕信息
|
||
self.screens = screens
|
||
|
||
# 返回屏幕名称列表
|
||
screen_names = [screen['name'] for screen in screens]
|
||
return screen_names
|
||
|
||
except Exception as e:
|
||
print(f"获取屏幕列表失败: {str(e)}")
|
||
return ["主屏幕"] # 返回默认值
|
||
|
||
def create_environments(self):
|
||
"""批量创建Chrome环境"""
|
||
try:
|
||
# 从设置中获取目录信息
|
||
settings = self.load_settings()
|
||
cache_dir = settings.get('cache_dir', '')
|
||
shortcut_dir = self.shortcut_path
|
||
numbers = self.env_numbers.get().strip()
|
||
|
||
if not all([cache_dir, shortcut_dir, numbers]):
|
||
messagebox.showwarning("警告", "请先在设置中填写缓存目录和快捷方式目录!")
|
||
return
|
||
|
||
# 确保目录存在
|
||
os.makedirs(cache_dir, exist_ok=True)
|
||
os.makedirs(shortcut_dir, exist_ok=True)
|
||
|
||
# 查找chrome可执行文件
|
||
chrome_path = r"C:\Program Files\Google\Chrome\Application\chrome.exe"
|
||
if not os.path.exists(chrome_path):
|
||
chrome_path = r"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe"
|
||
|
||
if not os.path.exists(chrome_path):
|
||
messagebox.showerror("错误", "未找到Chrome安装路径！")
|
||
return
|
||
|
||
# 创建WScript.Shell对象
|
||
shell = win32com.client.Dispatch("WScript.Shell")
|
||
|
||
# 解析窗口编号
|
||
window_numbers = self.parse_window_numbers(numbers)
|
||
|
||
# 批量创建环境
|
||
for i in window_numbers:
|
||
# 创建数据目录 - 使用纯数字命名
|
||
data_dir_name = str(i) # 改回纯数字命名
|
||
|
||
# 使用os.path.join创建路径，然后统一转换为正斜杠格式
|
||
data_dir = os.path.join(cache_dir, data_dir_name)
|
||
data_dir = data_dir.replace('\\', '/') # 统一使用正斜杠
|
||
|
||
os.makedirs(data_dir, exist_ok=True)
|
||
|
||
# 创建快捷方式 - 仍然使用数字命名以便识别和分配端口
|
||
shortcut_path = os.path.join(shortcut_dir, f"{i}.lnk")
|
||
shortcut = shell.CreateShortCut(shortcut_path)
|
||
shortcut.TargetPath = chrome_path
|
||
shortcut.Arguments = f'--user-data-dir="{data_dir}"' # 使用统一的正斜杠格式
|
||
shortcut.WorkingDirectory = os.path.dirname(chrome_path)
|
||
shortcut.WindowStyle = 1 # 正常窗口
|
||
shortcut.IconLocation = f"{chrome_path},0"
|
||
shortcut.save()
|
||
|
||
messagebox.showinfo("成功", f"已成功创建 {len(window_numbers)} 个Chrome环境！")
|
||
|
||
except Exception as e:
|
||
messagebox.showerror("错误", f"创建环境失败: {str(e)}")
|
||
|
||
def setup_hotkey_message_handler(self):
|
||
"""设置热键消息处理"""
|
||
try:
|
||
# 获取窗口句柄
|
||
hwnd = int(self.root.winfo_id())
|
||
|
||
# 在这里我们添加额外的保障，确保快捷键设置有效
|
||
if hasattr(self, 'current_shortcut') and self.current_shortcut:
|
||
# 重新确认快捷键有效性
|
||
if hasattr(self, 'shortcut_hook') and not self.shortcut_hook:
|
||
# 如果快捷键被清除，重新设置
|
||
self.set_shortcut(self.current_shortcut)
|
||
print(f"已重新设置快捷键: {self.current_shortcut}")
|
||
|
||
# 使用定时器检查热键状态
|
||
def check_hotkey():
|
||
try:
|
||
if self.current_shortcut and keyboard.is_pressed(self.current_shortcut):
|
||
# 确保不会重复触发
|
||
keyboard.release(self.current_shortcut)
|
||
# 在主线程中执行toggle_sync
|
||
self.root.after(0, self.toggle_sync)
|
||
|
||
# 额外打印调试信息
|
||
print(f"检测到快捷键 {self.current_shortcut} 被按下")
|
||
except Exception as e:
|
||
print(f"检查热键状态失败: {str(e)}")
|
||
|
||
# 尝试恢复快捷键设置
|
||
if hasattr(self, 'current_shortcut') and self.current_shortcut:
|
||
try:
|
||
self.set_shortcut(self.current_shortcut)
|
||
print(f"已尝试恢复快捷键: {self.current_shortcut}")
|
||
except:
|
||
pass
|
||
finally:
|
||
# 继续检查
|
||
if not self.root.winfo_exists():
|
||
return
|
||
self.root.after(100, check_hotkey)
|
||
|
||
# 启动检查
|
||
check_hotkey()
|
||
|
||
except Exception as e:
|
||
print(f"设置热键消息处理失败: {str(e)}")
|
||
|
||
def show_settings_dialog(self):
|
||
"""显示设置对话框"""
|
||
# 创建设置对话框
|
||
settings_dialog = tk.Toplevel(self.root)
|
||
settings_dialog.title("设置")
|
||
settings_dialog.geometry("500x370") # 增加窗口高度
|
||
settings_dialog.resizable(False, False)
|
||
settings_dialog.transient(self.root)
|
||
settings_dialog.grab_set()
|
||
|
||
# 设置图标
|
||
try:
|
||
icon_path = os.path.join(os.path.dirname(__file__), "app.ico")
|
||
if os.path.exists(icon_path):
|
||
settings_dialog.iconbitmap(icon_path)
|
||
except Exception as e:
|
||
print(f"设置图标失败: {str(e)}")
|
||
|
||
# 创建内容和按钮的主框架
|
||
main_frame = ttk.Frame(settings_dialog)
|
||
main_frame.pack(fill=tk.BOTH, expand=True)
|
||
|
||
# 创建内容框架
|
||
content_frame = ttk.Frame(main_frame)
|
||
content_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
|
||
|
||
# 目录设置框架
|
||
settings_frame = ttk.LabelFrame(content_frame, text="目录设置", padding=10)
|
||
settings_frame.pack(fill=tk.X, pady=5)
|
||
|
||
# 加载当前设置
|
||
settings = self.load_settings()
|
||
|
||
# 快捷方式目录
|
||
shortcut_frame = ttk.Frame(settings_frame)
|
||
shortcut_frame.pack(fill=tk.X, pady=5)
|
||
ttk.Label(shortcut_frame, text="谷歌多开快捷方式目录:").pack(side=tk.LEFT)
|
||
shortcut_path_var = tk.StringVar(value=self.shortcut_path or settings.get('shortcut_path', ''))
|
||
shortcut_path_entry = ttk.Entry(shortcut_frame, textvariable=shortcut_path_var)
|
||
shortcut_path_entry.pack(side=tk.LEFT, fill=tk.X, expand=True, padx=5)
|
||
self.setup_right_click_menu(shortcut_path_entry)
|
||
ttk.Button(
|
||
shortcut_frame,
|
||
text="浏览",
|
||
command=lambda: shortcut_path_var.set(filedialog.askdirectory(initialdir=shortcut_path_var.get() or os.getcwd()))
|
||
).pack(side=tk.LEFT)
|
||
|
||
# 缓存存放目录
|
||
cache_frame = ttk.Frame(settings_frame)
|
||
cache_frame.pack(fill=tk.X, pady=5)
|
||
ttk.Label(cache_frame, text="谷歌多开缓存存放目录:").pack(side=tk.LEFT)
|
||
cache_dir_var = tk.StringVar(value=self.cache_dir or settings.get('cache_dir', ''))
|
||
cache_dir_entry = ttk.Entry(cache_frame, textvariable=cache_dir_var)
|
||
cache_dir_entry.pack(side=tk.LEFT, fill=tk.X, expand=True, padx=5)
|
||
self.setup_right_click_menu(cache_dir_entry)
|
||
ttk.Button(
|
||
cache_frame,
|
||
text="浏览",
|
||
command=lambda: cache_dir_var.set(filedialog.askdirectory(initialdir=cache_dir_var.get() or os.getcwd()))
|
||
).pack(side=tk.LEFT)
|
||
|
||
# 快捷方式图标资源目录
|
||
icon_frame = ttk.Frame(settings_frame)
|
||
icon_frame.pack(fill=tk.X, pady=5)
|
||
ttk.Label(icon_frame, text="快捷方式图标资源目录:").pack(side=tk.LEFT)
|
||
icon_dir_var = tk.StringVar(value=self.icon_dir or settings.get('icon_dir', ''))
|
||
icon_dir_entry = ttk.Entry(icon_frame, textvariable=icon_dir_var)
|
||
icon_dir_entry.pack(side=tk.LEFT, fill=tk.X, expand=True, padx=5)
|
||
self.setup_right_click_menu(icon_dir_entry)
|
||
ttk.Button(
|
||
icon_frame,
|
||
text="浏览",
|
||
command=lambda: icon_dir_var.set(filedialog.askdirectory(initialdir=icon_dir_var.get() or os.getcwd()))
|
||
).pack(side=tk.LEFT)
|
||
|
||
# 功能设置
|
||
function_frame = ttk.LabelFrame(content_frame, text="功能设置", padding=10)
|
||
function_frame.pack(fill=tk.X, pady=5)
|
||
|
||
# 屏幕选择
|
||
screen_frame = ttk.Frame(function_frame)
|
||
screen_frame.pack(fill=tk.X, pady=5)
|
||
ttk.Label(screen_frame, text="屏幕选择:").pack(side=tk.LEFT)
|
||
|
||
# 更新屏幕列表
|
||
screen_options = self.update_screen_list()
|
||
if not screen_options:
|
||
screen_options = ["主屏幕"]
|
||
|
||
screen_var = tk.StringVar(value=settings.get('screen_selection', ''))
|
||
screen_combo = ttk.Combobox(
|
||
screen_frame,
|
||
textvariable=screen_var,
|
||
width=15,
|
||
state="readonly"
|
||
)
|
||
screen_combo.pack(side=tk.LEFT, padx=5)
|
||
screen_combo['values'] = screen_options
|
||
|
||
# 如果之前选过屏幕且还在列表中，则选中它
|
||
if screen_var.get() and screen_var.get() in screen_options:
|
||
screen_combo.set(screen_var.get())
|
||
# 否则默认选择第一个屏幕
|
||
elif screen_options:
|
||
screen_combo.current(0)
|
||
|
||
# 快捷键设置
|
||
shortcut_frame = ttk.Frame(function_frame)
|
||
shortcut_frame.pack(fill=tk.X, pady=5)
|
||
ttk.Label(shortcut_frame, text="快捷键设置:").pack(side=tk.LEFT)
|
||
shortcut_button = ttk.Button(
|
||
shortcut_frame,
|
||
text="设置快捷键",
|
||
command=self.show_shortcut_dialog
|
||
)
|
||
shortcut_button.pack(side=tk.LEFT, padx=5)
|
||
|
||
# 底部按钮框架
|
||
button_frame = ttk.Frame(settings_dialog)
|
||
button_frame.pack(side=tk.BOTTOM, fill=tk.X, padx=10, pady=10)
|
||
|
||
cancel_button = ttk.Button(
|
||
button_frame,
|
||
text="取消",
|
||
command=settings_dialog.destroy
|
||
)
|
||
cancel_button.pack(side=tk.RIGHT, padx=5)
|
||
|
||
save_button = ttk.Button(
|
||
button_frame,
|
||
text="保存",
|
||
style='Accent.TButton',
|
||
command=lambda: self.save_settings_dialog(
|
||
settings_dialog,
|
||
shortcut_path_var.get(),
|
||
cache_dir_var.get(),
|
||
icon_dir_var.get(),
|
||
screen_var.get()
|
||
)
|
||
)
|
||
save_button.pack(side=tk.RIGHT, padx=5)
|
||
|
||
# 居中显示
|
||
self.center_window(settings_dialog)
|
||
|
||
# 为对话框中所有文本框添加右键菜单支持
|
||
def add_right_click_to_all_entries(parent):
|
||
"""为所有文本框添加右键菜单"""
|
||
for child in parent.winfo_children():
|
||
if isinstance(child, (tk.Entry, ttk.Entry, tk.Text, ttk.Combobox)):
|
||
self.setup_right_click_menu(child)
|
||
elif child.winfo_children():
|
||
add_right_click_to_all_entries(child)
|
||
|
||
# 在对话框创建完成后应用右键菜单
|
||
settings_dialog.after(100, lambda: add_right_click_to_all_entries(settings_dialog))
|
||
|
||
def save_settings_dialog(self, dialog, shortcut_path, cache_dir, icon_dir, screen):
|
||
"""保存设置对话框中的设置"""
|
||
try:
|
||
print("保存前设置:", self.load_settings()) # 调试输出
|
||
|
||
# 更新当前实例变量，确保在本次会话中立即生效
|
||
self.shortcut_path = shortcut_path
|
||
self.cache_dir = cache_dir
|
||
self.icon_dir = icon_dir
|
||
self.screen_selection = screen
|
||
self.enable_cdp = True # 始终开启CDP
|
||
|
||
# 准备新设置
|
||
new_settings = {
|
||
'shortcut_path': shortcut_path,
|
||
'cache_dir': cache_dir,
|
||
'icon_dir': icon_dir,
|
||
'screen_selection': screen,
|
||
'enable_cdp': True # 始终开启CDP
|
||
}
|
||
|
||
# 加载现有设置(不覆盖窗口等其他设置)
|
||
settings = self.load_settings()
|
||
settings.update(new_settings) # 更新设置
|
||
|
||
# 直接写入文件
|
||
with open('settings.json', 'w', encoding='utf-8') as f:
|
||
json.dump(settings, f, ensure_ascii=False, indent=4)
|
||
|
||
# 如果页面上有路径输入框，更新它
|
||
if hasattr(self, 'path_entry') and self.path_entry is not None:
|
||
self.path_entry.delete(0, tk.END)
|
||
self.path_entry.insert(0, shortcut_path)
|
||
|
||
print("保存后设置:", settings) # 调试输出
|
||
|
||
# 显示成功消息
|
||
messagebox.showinfo("成功", "设置已保存！")
|
||
dialog.destroy()
|
||
|
||
except Exception as e:
|
||
messagebox.showerror("错误", f"保存设置失败: {e}")
|
||
print(f"保存设置失败: {e}")
|
||
|
||
def center_window(self, window):
|
||
"""将窗口居中显示在屏幕上"""
|
||
# 先隐藏窗口，以便计算尺寸
|
||
window.withdraw()
|
||
|
||
# 更新窗口尺寸
|
||
window.update_idletasks()
|
||
|
||
# 获取屏幕尺寸
|
||
screen_width = window.winfo_screenwidth()
|
||
screen_height = window.winfo_screenheight()
|
||
|
||
# 获取窗口尺寸
|
||
window_width = window.winfo_width()
|
||
window_height = window.winfo_height()
|
||
|
||
# 确保窗口尺寸正确
|
||
if window_width < 100 or window_height < 100:
|
||
# 使用窗口请求的尺寸
|
||
geometry = window.geometry()
|
||
if 'x' in geometry and '+' in geometry:
|
||
size_part = geometry.split('+')[0]
|
||
if 'x' in size_part:
|
||
parts = size_part.split('x')
|
||
if len(parts) == 2 and parts[0].isdigit() and parts[1].isdigit():
|
||
window_width = int(parts[0])
|
||
window_height = int(parts[1])
|
||
|
||
# 计算居中位置
|
||
x = (screen_width - window_width) // 2
|
||
y = (screen_height - window_height) // 2
|
||
|
||
# 设置窗口位置
|
||
window.geometry(f"{window_width}x{window_height}+{x}+{y}")
|
||
|
||
# 显示窗口
|
||
window.deiconify()
|
||
|
||
def keep_only_current_tab(self):
|
||
"""仅保留当前标签页，关闭所有选中窗口的其它标签页（高性能版）"""
|
||
# 立即显示视觉反馈
|
||
self.root.config(cursor="wait") # 修改光标为等待状态
|
||
|
||
# 获取选中的窗口
|
||
selected = []
|
||
try:
|
||
for item in self.window_list.get_children():
|
||
if self.window_list.set(item, "select") == "√":
|
||
values = self.window_list.item(item)['values']
|
||
if len(values) >= 5:
|
||
hwnd = int(values[4])
|
||
window_num = int(values[1])
|
||
selected.append((window_num, hwnd))
|
||
except Exception as e:
|
||
print(f"获取选中窗口失败: {str(e)}")
|
||
self.root.config(cursor="") # 恢复光标
|
||
messagebox.showerror("错误", f"获取选中窗口失败: {str(e)}")
|
||
return
|
||
|
||
if not selected:
|
||
self.root.config(cursor="") # 恢复光标
|
||
messagebox.showinfo("提示", "请先选择要操作的窗口！")
|
||
return
|
||
|
||
# 如果debug_ports为空，尝试重建
|
||
if not hasattr(self, 'debug_ports') or not self.debug_ports:
|
||
print("未找到调试端口映射，尝试重建...")
|
||
self.debug_ports = {window_num: 9222 + window_num for window_num, _ in selected}
|
||
|
||
# 使用ThreadPoolExecutor在后台处理所有标签页操作
|
||
# 不再暂停同步功能，两者可以同时运行
|
||
def process_tabs():
|
||
try:
|
||
# 并行获取所有窗口的标签信息
|
||
port_to_tabs = {}
|
||
|
||
def get_tabs(window_data):
|
||
window_num, _ = window_data
|
||
if window_num in self.debug_ports:
|
||
port = self.debug_ports[window_num]
|
||
try:
|
||
# 使用更短的超时时间提高响应速度
|
||
response = requests.get(f"http://localhost:{port}/json", timeout=0.5)
|
||
if response.status_code == 200:
|
||
tabs = response.json()
|
||
page_tabs = [tab for tab in tabs if tab.get('type') == 'page']
|
||
if len(page_tabs) > 1: # 如果只有一个标签页则不处理
|
||
return port, page_tabs, window_num
|
||
except Exception as e:
|
||
print(f"获取窗口{window_num}的标签页失败: {str(e)}")
|
||
return None
|
||
|
||
# 并行获取所有窗口的标签页
|
||
with concurrent.futures.ThreadPoolExecutor(max_workers=20) as executor:
|
||
futures = []
|
||
for window_data in selected:
|
||
futures.append(executor.submit(get_tabs, window_data))
|
||
|
||
# 立即处理结果，不等待所有任务完成
|
||
for future in concurrent.futures.as_completed(futures):
|
||
result = future.result()
|
||
if result:
|
||
port, tabs, window_num = result
|
||
port_to_tabs[port] = (tabs, window_num)
|
||
|
||
# 如果没有可操作的标签页，立即结束并恢复光标
|
||
if not port_to_tabs:
|
||
self.root.after(0, lambda: self.root.config(cursor=""))
|
||
return
|
||
|
||
# 准备并行关闭请求
|
||
close_requests = []
|
||
|
||
for port, (tabs, window_num) in port_to_tabs.items():
|
||
keep_tab = tabs[0] # 始终保留第一个标签
|
||
to_close = []
|
||
for tab in tabs:
|
||
if tab.get('id') != keep_tab.get('id'):
|
||
to_close.append((port, tab.get('id')))
|
||
close_requests.extend(to_close)
|
||
|
||
# 并行执行所有关闭请求
|
||
def close_tab(request):
|
||
port, tab_id = request
|
||
try:
|
||
requests.get(f"http://localhost:{port}/json/close/{tab_id}", timeout=0.5)
|
||
return True
|
||
except Exception as e:
|
||
print(f"关闭标签页失败: {str(e)}")
|
||
return False
|
||
|
||
# 使用更大的线程池来加速处理
|
||
with concurrent.futures.ThreadPoolExecutor(max_workers=30) as executor:
|
||
futures = [executor.submit(close_tab, req) for req in close_requests]
|
||
for future in concurrent.futures.as_completed(futures):
|
||
future.result() # 仅为了确保所有请求完成
|
||
|
||
# 操作完成后立即恢复光标
|
||
self.root.after(0, lambda: self.root.config(cursor=""))
|
||
|
||
except Exception as e:
|
||
print(f"处理标签页时出错: {str(e)}")
|
||
traceback.print_exc()
|
||
# 确保UI状态恢复
|
||
self.root.after(0, lambda: self.root.config(cursor=""))
|
||
self.root.after(0, lambda: messagebox.showerror("错误", f"处理标签页时出错: {str(e)}"))
|
||
|
||
# 启动后台线程处理，不阻塞UI
|
||
threading.Thread(target=process_tabs, daemon=True).start()
|
||
|
||
def keep_only_new_tab(self):
|
||
"""仅保留新标签页，关闭所有选中窗口的其它标签页（高性能版）"""
|
||
# 立即显示视觉反馈
|
||
self.root.config(cursor="wait") # 修改光标为等待状态
|
||
|
||
# 获取选中的窗口
|
||
selected = []
|
||
try:
|
||
for item in self.window_list.get_children():
|
||
if self.window_list.set(item, "select") == "√":
|
||
values = self.window_list.item(item)['values']
|
||
if len(values) >= 5:
|
||
hwnd = int(values[4])
|
||
window_num = int(values[1])
|
||
selected.append((window_num, hwnd))
|
||
except Exception as e:
|
||
print(f"获取选中窗口失败: {str(e)}")
|
||
self.root.config(cursor="") # 恢复光标
|
||
messagebox.showerror("错误", f"获取选中窗口失败: {str(e)}")
|
||
return
|
||
|
||
if not selected:
|
||
self.root.config(cursor="") # 恢复光标
|
||
messagebox.showinfo("提示", "请先选择要操作的窗口！")
|
||
return
|
||
|
||
# 如果debug_ports为空，尝试重建
|
||
if not hasattr(self, 'debug_ports') or not self.debug_ports:
|
||
print("未找到调试端口映射，尝试重建...")
|
||
self.debug_ports = {window_num: 9222 + window_num for window_num, _ in selected}
|
||
|
||
# 使用ThreadPoolExecutor在后台处理所有标签页操作
|
||
# 不再暂停同步功能，两者可以同时运行
|
||
def process_tabs():
|
||
try:
|
||
# 并行获取所有窗口的标签信息
|
||
window_tabs = {}
|
||
|
||
def get_tabs(window_data):
|
||
window_num, _ = window_data
|
||
if window_num in self.debug_ports:
|
||
port = self.debug_ports[window_num]
|
||
try:
|
||
# 使用更短的超时时间提高响应速度
|
||
response = requests.get(f"http://localhost:{port}/json", timeout=0.5)
|
||
if response.status_code == 200:
|
||
tabs = response.json()
|
||
page_tabs = [tab.get('id') for tab in tabs if tab.get('type') == 'page']
|
||
if page_tabs:
|
||
return port, page_tabs, window_num
|
||
except Exception as e:
|
||
print(f"获取窗口{window_num}的标签页失败: {str(e)}")
|
||
return None
|
||
|
||
# 并行获取所有窗口的标签页
|
||
valid_ports = []
|
||
with concurrent.futures.ThreadPoolExecutor(max_workers=20) as executor:
|
||
futures = []
|
||
for window_data in selected:
|
||
futures.append(executor.submit(get_tabs, window_data))
|
||
|
||
# 立即处理结果，不等待所有任务完成
|
||
for future in concurrent.futures.as_completed(futures):
|
||
result = future.result()
|
||
if result:
|
||
port, tabs, window_num = result
|
||
window_tabs[port] = (tabs, window_num)
|
||
valid_ports.append(port)
|
||
|
||
# 如果没有可操作的标签页，立即结束并恢复光标
|
||
if not valid_ports:
|
||
self.root.after(0, lambda: self.root.config(cursor=""))
|
||
return
|
||
|
||
# 并行为所有窗口创建新标签页
|
||
created_tabs = {}
|
||
|
||
def create_new_tab(port_data):
|
||
port, window_num = port_data
|
||
try:
|
||
requests.put(f"http://localhost:{port}/json/new?chrome://newtab/", timeout=0.5)
|
||
return port, window_num, True
|
||
except Exception as e:
|
||
print(f"为窗口 {window_num} 创建新标签页失败: {str(e)}")
|
||
return port, window_num, False
|
||
|
||
# 并行创建新标签页
|
||
port_to_window = {port: window_num for port, (_, window_num) in window_tabs.items()}
|
||
with concurrent.futures.ThreadPoolExecutor(max_workers=20) as executor:
|
||
futures = [executor.submit(create_new_tab, (port, port_to_window[port])) for port in valid_ports]
|
||
for future in concurrent.futures.as_completed(futures):
|
||
port, window_num, success = future.result()
|
||
if success:
|
||
created_tabs[window_num] = port
|
||
|
||
# 并行关闭原有标签页
|
||
def close_old_tabs(port_data):
|
||
port, tabs, window_num = port_data
|
||
for tab_id in tabs:
|
||
try:
|
||
requests.get(f"http://localhost:{port}/json/close/{tab_id}", timeout=0.5)
|
||
except Exception as e:
|
||
print(f"关闭窗口 {window_num} 的标签页失败: {str(e)}")
|
||
|
||
# 只有在成功创建了新标签页的窗口才关闭旧标签页
|
||
with concurrent.futures.ThreadPoolExecutor(max_workers=20) as executor:
|
||
futures = []
|
||
for window_num, port in created_tabs.items():
|
||
tabs, _ = window_tabs[port]
|
||
futures.append(executor.submit(close_old_tabs, (port, tabs, window_num)))
|
||
|
||
# 等待所有关闭操作完成
|
||
for future in concurrent.futures.as_completed(futures):
|
||
future.result()
|
||
|
||
# 操作完成后立即恢复光标
|
||
self.root.after(0, lambda: self.root.config(cursor=""))
|
||
|
||
except Exception as e:
|
||
print(f"处理标签页时出错: {str(e)}")
|
||
traceback.print_exc()
|
||
# 确保UI状态恢复
|
||
self.root.after(0, lambda: self.root.config(cursor=""))
|
||
self.root.after(0, lambda: messagebox.showerror("错误", f"处理标签页时出错: {str(e)}"))
|
||
|
||
# 启动后台线程处理，不阻塞UI
|
||
threading.Thread(target=process_tabs, daemon=True).start()
|
||
|
||
def set_quick_url(self, url_template):
|
||
"""设置快捷网址模板到URL输入框"""
|
||
# 清空现有内容
|
||
self.url_entry.delete(0, tk.END)
|
||
|
||
# 根据不同的模板设置不同的URL组合
|
||
if url_template == "x.com" or url_template == "https://twitter.com":
|
||
self.url_entry.insert(0, "x.com")
|
||
elif url_template == "discord.com/app" or url_template == "https://discord.com/channels/@me":
|
||
self.url_entry.insert(0, "discord.com/app")
|
||
elif url_template == "mail.google.com" or url_template == "https://mail.google.com":
|
||
self.url_entry.insert(0, "mail.google.com")
|
||
else:
|
||
# 对于其他URL，直接使用传入的值
|
||
self.url_entry.insert(0, url_template)
|
||
|
||
# 自动触发批量打开网页
|
||
self.batch_open_urls()
|
||
|
||
# 添加右键菜单相关函数
|
||
def show_context_menu(self, event):
|
||
"""显示右键菜单"""
|
||
widget = event.widget
|
||
if isinstance(widget, (tk.Entry, ttk.Entry, tk.Text, ttk.Combobox)):
|
||
# 保存当前文本框引用
|
||
self.current_text_widget = widget
|
||
# 显示菜单
|
||
try:
|
||
self.context_menu.tk_popup(event.x_root, event.y_root)
|
||
finally:
|
||
self.context_menu.grab_release()
|
||
|
||
def cut_text(self):
|
||
"""剪切文本"""
|
||
if self.current_text_widget:
|
||
try:
|
||
self.current_text_widget.event_generate("<<Cut>>")
|
||
except:
|
||
pass
|
||
|
||
def copy_text(self):
|
||
"""复制文本"""
|
||
if self.current_text_widget:
|
||
try:
|
||
self.current_text_widget.event_generate("<<Copy>>")
|
||
except:
|
||
pass
|
||
|
||
def paste_text(self):
|
||
"""粘贴文本"""
|
||
if self.current_text_widget:
|
||
try:
|
||
self.current_text_widget.event_generate("<<Paste>>")
|
||
except:
|
||
pass
|
||
|
||
def select_all_text(self):
|
||
"""全选文本"""
|
||
if self.current_text_widget:
|
||
try:
|
||
if isinstance(self.current_text_widget, (tk.Entry, ttk.Entry, ttk.Combobox)):
|
||
self.current_text_widget.select_range(0, tk.END)
|
||
self.current_text_widget.icursor(tk.END)
|
||
elif isinstance(self.current_text_widget, tk.Text):
|
||
self.current_text_widget.tag_add(tk.SEL, "1.0", tk.END)
|
||
self.current_text_widget.mark_set(tk.INSERT, tk.END)
|
||
except:
|
||
pass
|
||
|
||
def setup_right_click_menu(self, widget):
|
||
"""为文本框设置右键菜单"""
|
||
widget.bind('<Button-3>', self.show_context_menu)
|
||
|
||
def show_window_list_menu(self, event):
|
||
"""显示窗口列表的右键菜单"""
|
||
try:
|
||
# 获取点击的行
|
||
item = self.window_list.identify_row(event.y)
|
||
if item:
|
||
# 保存当前右键点击的项
|
||
self.right_clicked_item = item
|
||
# 在点击位置显示菜单
|
||
self.window_list_menu.post(event.x_root, event.y_root)
|
||
except Exception as e:
|
||
print(f"显示右键菜单失败: {str(e)}")
|
||
|
||
def close_selected_window(self):
|
||
"""关闭右键菜单选中的窗口"""
|
||
try:
|
||
if hasattr(self, 'right_clicked_item') and self.right_clicked_item:
|
||
item = self.right_clicked_item
|
||
# 从values中获取hwnd
|
||
values = self.window_list.item(item)['values']
|
||
if values and len(values) > 4:
|
||
hwnd = int(values[4])
|
||
# 检查窗口是否存在
|
||
if win32gui.IsWindow(hwnd):
|
||
# 关闭窗口
|
||
win32gui.PostMessage(hwnd, win32con.WM_CLOSE, 0, 0)
|
||
# 从列表中删除
|
||
self.window_list.delete(item)
|
||
# 更新UI
|
||
self.update_select_all_status()
|
||
except Exception as e:
|
||
print(f"关闭窗口失败: {str(e)}")
|
||
|
||
def sync_popups(self):
|
||
"""同步主窗口的弹出窗口到所有同步窗口，改进对网页浮动层的处理"""
|
||
try:
|
||
if not self.is_sync or not self.master_window or not win32gui.IsWindow(self.master_window):
|
||
return
|
||
|
||
# 获取主窗口的所有弹出窗口
|
||
master_popups = self.get_chrome_popups(self.master_window)
|
||
if not master_popups:
|
||
return
|
||
|
||
# 获取主窗口位置
|
||
master_rect = win32gui.GetWindowRect(self.master_window)
|
||
master_x = master_rect[0]
|
||
master_y = master_rect[1]
|
||
|
||
# 针对每个主窗口的弹出窗口进行同步
|
||
for popup in master_popups:
|
||
try:
|
||
if not win32gui.IsWindow(popup):
|
||
continue
|
||
|
||
# 获取弹出窗口位置和大小
|
||
popup_rect = win32gui.GetWindowRect(popup)
|
||
popup_width = popup_rect[2] - popup_rect[0]
|
||
popup_height = popup_rect[3] - popup_rect[1]
|
||
|
||
# 检查窗口样式，确定是否为网页浮动层
|
||
style = win32gui.GetWindowLong(popup, win32con.GWL_STYLE)
|
||
ex_style = win32gui.GetWindowLong(popup, win32con.GWL_EXSTYLE)
|
||
|
||
is_floating_layer = (
|
||
(style & win32con.WS_POPUP) != 0 and
|
||
(popup_width < 600 and popup_height < 600)
|
||
)
|
||
|
||
# 计算相对于主窗口的位置
|
||
rel_x = popup_rect[0] - master_x
|
||
rel_y = popup_rect[1] - master_y
|
||
|
||
# 同步到所有其他窗口
|
||
for hwnd in self.sync_windows:
|
||
if hwnd != self.master_window and win32gui.IsWindow(hwnd):
|
||
# 获取同步窗口位置
|
||
sync_rect = win32gui.GetWindowRect(hwnd)
|
||
sync_x = sync_rect[0]
|
||
sync_y = sync_rect[1]
|
||
|
||
# 获取该窗口的所有弹出窗口
|
||
sync_popups = self.get_chrome_popups(hwnd)
|
||
|
||
# 寻找可能匹配的弹出窗口
|
||
target_title = win32gui.GetWindowText(popup)
|
||
best_match = None
|
||
best_score = 0
|
||
|
||
# 对网页浮动层和其他弹出窗口应用不同的匹配策略
|
||
if is_floating_layer:
|
||
# 为浮动层寻找相似的大小和位置
|
||
for sync_popup in sync_popups:
|
||
if not win32gui.IsWindow(sync_popup):
|
||
continue
|
||
|
||
sync_style = win32gui.GetWindowLong(sync_popup, win32con.GWL_STYLE)
|
||
|
||
# 检查是否同样是弹出样式
|
||
if (sync_style & win32con.WS_POPUP) == 0:
|
||
continue
|
||
|
||
# 对于网页浮动层，主要基于尺寸和位置相似度匹配
|
||
sync_rect = win32gui.GetWindowRect(sync_popup)
|
||
sync_width = sync_rect[2] - sync_rect[0]
|
||
sync_height = sync_rect[3] - sync_rect[1]
|
||
|
||
# 尺寸相似度
|
||
size_match = 1.0 - min(1.0, (abs(sync_width - popup_width) / max(popup_width, 1) +
|
||
abs(sync_height - popup_height) / max(popup_height, 1)) / 2)
|
||
|
||
# 相对位置相似度
|
||
sync_rel_x = sync_rect[0] - sync_x
|
||
sync_rel_y = sync_rect[1] - sync_y
|
||
pos_match = 1.0 - min(1.0, (abs(sync_rel_x - rel_x) + abs(sync_rel_y - rel_y)) /
|
||
max(sync_rect[2] - sync_rect[0] + sync_rect[3] - sync_rect[1], 1))
|
||
|
||
# 综合得分，对于浮动层位置更重要
|
||
score = size_match * 0.4 + pos_match * 0.6
|
||
|
||
if score > best_score and score > 0.6: # 提高匹配阈值
|
||
best_score = score
|
||
best_match = sync_popup
|
||
else:
|
||
# 对于普通弹出窗口，使用标题和尺寸综合匹配
|
||
for sync_popup in sync_popups:
|
||
if not win32gui.IsWindow(sync_popup):
|
||
continue
|
||
|
||
sync_title = win32gui.GetWindowText(sync_popup)
|
||
# 计算标题相似度
|
||
similarity = self.title_similarity(target_title, sync_title)
|
||
|
||
# 获取窗口大小相似度
|
||
sync_rect = win32gui.GetWindowRect(sync_popup)
|
||
sync_width = sync_rect[2] - sync_rect[0]
|
||
sync_height = sync_rect[3] - sync_rect[1]
|
||
size_match = min(1.0, 1.0 - (abs(sync_width - popup_width) + abs(sync_height - popup_height)) /
|
||
max(popup_width + popup_height, 1))
|
||
|
||
# 计算总匹配分数
|
||
score = similarity * 0.7 + size_match * 0.3
|
||
if score > best_score and score > 0.5:
|
||
best_score = score
|
||
best_match = sync_popup
|
||
|
||
# 如果找到匹配的弹出窗口，调整其位置
|
||
if best_match:
|
||
# 计算新位置
|
||
new_x = sync_x + rel_x
|
||
new_y = sync_y + rel_y
|
||
|
||
# 设置窗口位置
|
||
win32gui.SetWindowPos(
|
||
best_match,
|
||
win32con.HWND_TOP,
|
||
new_x, new_y,
|
||
popup_width, popup_height,
|
||
win32con.SWP_NOACTIVATE
|
||
)
|
||
elif is_floating_layer:
|
||
# 如果是浮动层但没找到匹配项，尝试通过模拟点击关闭和重新打开的方式同步
|
||
print(f"找不到匹配的浮动层，尝试通过其他方式同步")
|
||
# 这里可以实现其他同步策略，如向目标窗口发送模拟点击
|
||
# 由于模拟点击可能较复杂，这里只记录日志
|
||
except Exception as e:
|
||
print(f"同步单个弹窗出错: {str(e)}")
|
||
|
||
except Exception as e:
|
||
print(f"同步弹窗过程出错: {str(e)}")
|
||
|
||
def setup_wheel_hook(self):
|
||
"""设置全局滚轮钩子"""
|
||
if self.wheel_hook_id:
|
||
# 如果已经有钩子，先卸载
|
||
self.unhook_wheel()
|
||
|
||
# 定义钩子回调函数
|
||
def wheel_proc(nCode, wParam, lParam):
|
||
try:
|
||
# 检查是否为滚轮消息
|
||
if wParam == win32con.WM_MOUSEWHEEL and self.is_sync:
|
||
# 获取当前窗口
|
||
current_window = win32gui.GetForegroundWindow()
|
||
|
||
# 检查是否为主控窗口
|
||
is_master_window = current_window == self.master_window
|
||
|
||
# 获取主窗口的弹出窗口
|
||
master_popups = self.get_chrome_popups(self.master_window)
|
||
|
||
# 判断是否为主窗口的插件
|
||
is_master_plugin = current_window in master_popups
|
||
|
||
# 如果不是主控窗口也不是主窗口插件，直接放行事件
|
||
if not is_master_window and not is_master_plugin:
|
||
return ctypes.windll.user32.CallNextHookEx(self.wheel_hook_id, nCode, wParam, ctypes.cast(lParam, ctypes.c_void_p))
|
||
|
||
# 获取窗口层次结构信息
|
||
try:
|
||
# 获取窗口类名和标题
|
||
window_class = win32gui.GetClassName(current_window)
|
||
window_title = win32gui.GetWindowText(current_window)
|
||
|
||
# 获取窗口样式
|
||
style = win32gui.GetWindowLong(current_window, win32con.GWL_STYLE)
|
||
ex_style = win32gui.GetWindowLong(current_window, win32con.GWL_EXSTYLE)
|
||
|
||
# 获取窗口进程ID
|
||
_, process_id = win32process.GetWindowThreadProcessId(current_window)
|
||
_, master_process_id = win32process.GetWindowThreadProcessId(self.master_window)
|
||
|
||
# 获取位置和尺寸
|
||
rect = win32gui.GetWindowRect(current_window)
|
||
width = rect[2] - rect[0]
|
||
height = rect[3] - rect[1]
|
||
except:
|
||
window_class = ""
|
||
window_title = ""
|
||
style = 0
|
||
ex_style = 0
|
||
process_id = 0
|
||
master_process_id = 0
|
||
width = 0
|
||
height = 0
|
||
|
||
# 检查是否为无法用键盘控制滚动的特殊窗口
|
||
is_uncontrollable_window = False
|
||
if "Chrome_RenderWidgetHostHWND" in window_class:
|
||
is_uncontrollable_window = True
|
||
|
||
# 检查是否与Chrome相关
|
||
is_chrome_window = (
|
||
"Chrome_" in window_class or
|
||
"Chromium_" in window_class
|
||
)
|
||
|
||
# 检查是否是插件窗口
|
||
is_plugin_window = is_master_plugin
|
||
|
||
if is_master_plugin:
|
||
print(f"识别到主窗口插件: {window_title}, 句柄: {current_window}")
|
||
|
||
# 检查Ctrl键状态 - 如果按下Ctrl则不拦截事件（保留缩放功能）
|
||
ctrl_pressed = ctypes.windll.user32.GetKeyState(win32con.VK_CONTROL) & 0x8000 != 0
|
||
if ctrl_pressed and is_chrome_window:
|
||
print("检测到Ctrl键按下，不拦截滚轮事件(保留缩放功能)")
|
||
# 不拦截，让事件继续传递给Chrome处理缩放
|
||
return ctypes.windll.user32.CallNextHookEx(self.wheel_hook_id, nCode, wParam, ctypes.cast(lParam, ctypes.c_void_p))
|
||
|
||
# 只处理Chrome相关窗口且不是无法控制的特殊窗口
|
||
if is_chrome_window and not is_uncontrollable_window:
|
||
# 防止过于频繁触发
|
||
current_time = time.time()
|
||
if current_time - self.last_wheel_time < self.wheel_threshold:
|
||
# 阻止事件继续传递（返回1）
|
||
return 1
|
||
|
||
self.last_wheel_time = current_time
|
||
|
||
# 从MSLLHOOKSTRUCT结构体中获取滚轮增量
|
||
wheel_delta = ctypes.c_short(lParam.contents.mouseData >> 16).value
|
||
|
||
# 标准化滚轮增量
|
||
normalized_delta = self.normalize_wheel_delta(wheel_delta)
|
||
|
||
# 只同步到其他同步窗口，不包括主窗口自身
|
||
windows_to_sync = self.sync_windows
|
||
|
||
# 获取鼠标位置
|
||
mouse_x, mouse_y = lParam.contents.pt.x, lParam.contents.pt.y
|
||
print(f"拦截滚轮事件: 窗口={current_window}, 类型={'主窗口' if is_master_window else '主窗口插件' if is_master_plugin else '其他'}, wheel_delta={wheel_delta}")
|
||
|
||
# 如果是插件窗口，同步到其他窗口，但允许原始事件继续传递
|
||
if is_plugin_window:
|
||
# 向同步窗口发送模拟滚动
|
||
if windows_to_sync:
|
||
print(f"主窗口插件滚轮事件，同步到其他{len(windows_to_sync)}个窗口")
|
||
self.sync_specified_windows_scroll(normalized_delta, windows_to_sync)
|
||
|
||
# 允许原始事件继续传递，这样插件窗口本身可以正常滚动
|
||
print("允许插件窗口原始滚轮事件继续传递")
|
||
return ctypes.windll.user32.CallNextHookEx(self.wheel_hook_id, nCode, wParam, ctypes.cast(lParam, ctypes.c_void_p))
|
||
|
||
# 主窗口：拦截原始事件，向同步窗口发送模拟滚动
|
||
else:
|
||
# 包括主窗口在内的所有窗口
|
||
all_windows = [self.master_window] + self.sync_windows
|
||
print(f"主窗口滚轮事件，同步到所有{len(all_windows)}个窗口")
|
||
self.sync_specified_windows_scroll(normalized_delta, all_windows)
|
||
# 拦截原始滚轮事件
|
||
return 1
|
||
|
||
# 其他消息或非Chrome窗口，继续传递事件
|
||
return ctypes.windll.user32.CallNextHookEx(self.wheel_hook_id, nCode, wParam, ctypes.cast(lParam, ctypes.c_void_p))
|
||
|
||
except Exception as e:
|
||
print(f"滚轮钩子处理出错: {str(e)}")
|
||
# 异常情况下继续传递事件
|
||
return ctypes.windll.user32.CallNextHookEx(self.wheel_hook_id, nCode, wParam, ctypes.cast(lParam, ctypes.c_void_p))
|
||
|
||
# 创建钩子回调函数
|
||
self.wheel_hook_proc = ctypes.WINFUNCTYPE(
|
||
ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.POINTER(MSLLHOOKSTRUCT)
|
||
)(wheel_proc)
|
||
|
||
try:
|
||
# 安装钩子 - 修复整数溢出错误，直接使用0而不是GetModuleHandle(None)
|
||
self.wheel_hook_id = ctypes.windll.user32.SetWindowsHookExW(
|
||
win32con.WH_MOUSE_LL,
|
||
self.wheel_hook_proc,
|
||
0, # 直接使用0替代win32api.GetModuleHandle(None)
|
||
0
|
||
)
|
||
|
||
if not self.wheel_hook_id:
|
||
error = ctypes.windll.kernel32.GetLastError()
|
||
raise Exception(f"安装滚轮钩子失败，错误码: {error}")
|
||
|
||
except Exception as e:
|
||
print(f"安装滚轮钩子时出错: {str(e)}")
|
||
# 确保标记为None，以便其他部分代码知道钩子未成功安装
|
||
self.wheel_hook_id = None
|
||
raise
|
||
|
||
def unhook_wheel(self):
|
||
"""卸载滚轮钩子"""
|
||
if self.wheel_hook_id:
|
||
try:
|
||
if ctypes.windll.user32.UnhookWindowsHookEx(self.wheel_hook_id):
|
||
print("已卸载滚轮钩子")
|
||
else:
|
||
error = ctypes.windll.kernel32.GetLastError()
|
||
print(f"卸载滚轮钩子失败，错误码: {error}")
|
||
except Exception as e:
|
||
print(f"卸载滚轮钩子时出错: {str(e)}")
|
||
finally:
|
||
self.wheel_hook_id = None
|
||
self.wheel_hook_proc = None
|
||
|
||
def normalize_wheel_delta(self, delta, is_plugin=False):
|
||
"""标准化滚轮增量值 - 使用适中的缩放系数"""
|
||
# 检查是否可能来自触控板（通常有小数或不规则值）
|
||
abs_delta = abs(delta)
|
||
|
||
# 使用适中的缩放系数，不区分窗口类型
|
||
if abs_delta < 40: # 很小的值，可能是精确触控板
|
||
normalized = delta * 0.20 # 适中系数
|
||
elif abs_delta < 80: # 中等值
|
||
normalized = delta * 0.25 # 适中系数
|
||
else: # 标准鼠标滚轮
|
||
normalized = delta * 0.30 # 适中系数
|
||
|
||
# 保持方向一致，但标准化大小
|
||
direction = 1 if delta > 0 else -1
|
||
# 标准增量设为中等值，从120降至50
|
||
reduced_wheel_delta = int(self.standard_wheel_delta * 0.42)
|
||
return direction * reduced_wheel_delta
|
||
|
||
def sync_specified_windows_scroll(self, normalized_delta, window_list):
|
||
"""同步指定窗口列表的滚动 - 使用键盘事件模拟"""
|
||
try:
|
||
# 确定滚动方向和大小
|
||
is_scroll_up = normalized_delta > 0
|
||
abs_delta = abs(normalized_delta)
|
||
|
||
# 遍历所有需要同步的窗口
|
||
for hwnd in window_list:
|
||
try:
|
||
if not win32gui.IsWindow(hwnd):
|
||
continue
|
||
|
||
# 根据滚动大小决定使用不同的按键组合
|
||
if abs_delta < 40: # 小幅度滚动
|
||
key = win32con.VK_UP if is_scroll_up else win32con.VK_DOWN
|
||
repeat = max(1, min(int(abs_delta / 20), 2))
|
||
|
||
for _ in range(repeat):
|
||
win32gui.PostMessage(hwnd, win32con.WM_KEYDOWN, key, 0)
|
||
win32gui.PostMessage(hwnd, win32con.WM_KEYUP, key, 0)
|
||
|
||
elif abs_delta < 80: # 中等幅度滚动
|
||
# 使用Page键
|
||
key = win32con.VK_PRIOR if is_scroll_up else win32con.VK_NEXT
|
||
win32gui.PostMessage(hwnd, win32con.WM_KEYDOWN, key, 0)
|
||
win32gui.PostMessage(hwnd, win32con.WM_KEYUP, key, 0)
|
||
|
||
else: # 大幅度滚动
|
||
# 使用多个Page键
|
||
key = win32con.VK_PRIOR if is_scroll_up else win32con.VK_NEXT
|
||
repeat = min(int(abs_delta / 100) + 1, 2)
|
||
|
||
for _ in range(repeat):
|
||
win32gui.PostMessage(hwnd, win32con.WM_KEYDOWN, key, 0)
|
||
win32gui.PostMessage(hwnd, win32con.WM_KEYUP, key, 0)
|
||
|
||
except Exception as e:
|
||
print(f"向窗口 {hwnd} 发送滚动事件失败: {str(e)}")
|
||
|
||
except Exception as e:
|
||
print(f"同步滚动出错: {str(e)}")
|
||
|
||
def sync_all_windows_scroll(self, normalized_delta):
|
||
"""同步所有窗口的滚动 - 设置适中的滚动幅度"""
|
||
# 遍历所有窗口，包括主窗口
|
||
all_windows = [self.master_window] + self.sync_windows
|
||
|
||
# 调用指定窗口滚动函数
|
||
self.sync_specified_windows_scroll(normalized_delta, all_windows)
|
||
|
||
def normalize_path(self, path):
|
||
"""标准化路径格式，统一使用正斜杠，便于比较"""
|
||
if not path:
|
||
return ""
|
||
return os.path.normpath(path).lower().replace('\\', '/')
|
||
|
||
def input_random_number(self):
|
||
"""在选中的窗口中输入随机数字"""
|
||
try:
|
||
# 获取选中的窗口
|
||
selected_windows = []
|
||
for item in self.window_list.get_children():
|
||
if self.window_list.set(item, "select") == "√":
|
||
hwnd = int(self.window_list.item(item)['values'][-1])
|
||
selected_windows.append(hwnd)
|
||
|
||
if not selected_windows:
|
||
messagebox.showwarning("警告", "请先选择要操作的窗口！")
|
||
return
|
||
|
||
# 获取范围值
|
||
min_str = self.random_min_value.get().strip()
|
||
max_str = self.random_max_value.get().strip()
|
||
|
||
if not min_str or not max_str:
|
||
messagebox.showwarning("警告", "请输入有效的范围值！")
|
||
return
|
||
|
||
# 确定是整数还是小数
|
||
is_float = '.' in min_str or '.' in max_str
|
||
|
||
try:
|
||
if is_float:
|
||
min_val = float(min_str)
|
||
max_val = float(max_str)
|
||
# 获取小数位数
|
||
decimal_places = max(
|
||
len(min_str.split('.')[-1]) if '.' in min_str else 0,
|
||
len(max_str.split('.')[-1]) if '.' in max_str else 0
|
||
)
|
||
decimal_places = min(decimal_places, 10) # 最多10位小数
|
||
else:
|
||
min_val = int(min_str)
|
||
max_val = int(max_str)
|
||
except ValueError:
|
||
messagebox.showerror("错误", "请输入有效的数字范围！")
|
||
return
|
||
|
||
# 获取选项
|
||
overwrite = self.random_overwrite.get()
|
||
delayed = self.random_delayed.get()
|
||
|
||
print(f"准备为{len(selected_windows)}个窗口生成随机数 (范围: {min_val}-{max_val}, 覆盖: {overwrite}, 延迟: {delayed})")
|
||
|
||
# 为每个选中的窗口输入随机数
|
||
for hwnd in selected_windows:
|
||
# 为每个窗口单独生成一个随机数
|
||
if is_float:
|
||
# 生成随机小数，最多10位小数
|
||
random_number = round(random.uniform(min_val, max_val), decimal_places)
|
||
# 转为字符串，保留指定小数位
|
||
random_text = f"{random_number:.{decimal_places}f}"
|
||
# 去除尾部多余的0
|
||
if '.' in random_text:
|
||
random_text = random_text.rstrip('0').rstrip('.') if '.' in random_text else random_text
|
||
else:
|
||
random_number = random.randint(min_val, max_val)
|
||
random_text = str(random_number)
|
||
|
||
print(f"窗口 {hwnd} 的随机数: {random_text}")
|
||
|
||
# 激活窗口
|
||
try:
|
||
win32gui.SetForegroundWindow(hwnd)
|
||
time.sleep(0.1) # 等待窗口获得焦点
|
||
|
||
# 如果选择覆盖原有内容，先全选文本
|
||
if overwrite:
|
||
keyboard.press_and_release('ctrl+a')
|
||
time.sleep(0.05)
|
||
|
||
# 输入随机数
|
||
if delayed:
|
||
# 模拟真人输入，逐字输入
|
||
for char in random_text:
|
||
keyboard.write(char)
|
||
# 随机延迟50-150毫秒
|
||
time.sleep(random.uniform(0.05, 0.15))
|
||
else:
|
||
# 直接输入整个字符串
|
||
keyboard.write(random_text)
|
||
|
||
time.sleep(0.2) # 等待短暂时间再处理下一个窗口
|
||
except Exception as e:
|
||
print(f"向窗口 {hwnd} 输入随机数时出错: {str(e)}")
|
||
|
||
except Exception as e:
|
||
messagebox.showerror("错误", f"输入随机数时出错: {str(e)}")
|
||
|
||
def show_random_number_dialog(self):
|
||
"""显示随机数字输入对话框"""
|
||
dialog = tk.Toplevel(self.root)
|
||
dialog.title("随机数字输入")
|
||
dialog.geometry("400x300") # 增加高度从250到320
|
||
dialog.transient(self.root)
|
||
dialog.grab_set()
|
||
dialog.resizable(False, False)
|
||
|
||
# 设置图标
|
||
try:
|
||
icon_path = os.path.join(os.path.dirname(__file__), "app.ico")
|
||
if os.path.exists(icon_path):
|
||
dialog.iconbitmap(icon_path)
|
||
except Exception as e:
|
||
print(f"设置对话框图标失败: {str(e)}")
|
||
|
||
# 居中显示
|
||
self.center_window(dialog)
|
||
|
||
# 主框架
|
||
main_frame = ttk.Frame(dialog, padding=10)
|
||
main_frame.pack(fill=tk.BOTH, expand=True)
|
||
|
||
# 范围输入区域
|
||
range_frame = ttk.LabelFrame(main_frame, text="数字范围", padding=10)
|
||
range_frame.pack(fill=tk.X, pady=(0, 10))
|
||
|
||
range_inner_frame = ttk.Frame(range_frame)
|
||
range_inner_frame.pack(fill=tk.X)
|
||
|
||
ttk.Label(range_inner_frame, text="最小值:").pack(side=tk.LEFT)
|
||
min_entry = ttk.Entry(range_inner_frame, width=10, textvariable=self.random_min_value)
|
||
min_entry.pack(side=tk.LEFT, padx=(5, 15))
|
||
self.setup_right_click_menu(min_entry)
|
||
|
||
ttk.Label(range_inner_frame, text="最大值:").pack(side=tk.LEFT)
|
||
max_entry = ttk.Entry(range_inner_frame, width=10, textvariable=self.random_max_value)
|
||
max_entry.pack(side=tk.LEFT, padx=5)
|
||
self.setup_right_click_menu(max_entry)
|
||
|
||
# 选项区域
|
||
options_frame = ttk.LabelFrame(main_frame, text="输入选项", padding=10)
|
||
options_frame.pack(fill=tk.X, pady=(0, 15))
|
||
|
||
options_inner_frame = ttk.Frame(options_frame)
|
||
options_inner_frame.pack(fill=tk.X)
|
||
|
||
overwrite_var = tk.BooleanVar(value=True)
|
||
|
||
overwrite_check = ttk.Checkbutton(
|
||
options_inner_frame,
|
||
text="覆盖原有内容",
|
||
variable=self.random_overwrite
|
||
)
|
||
overwrite_check.pack(anchor=tk.W, pady=5)
|
||
|
||
delayed_check = ttk.Checkbutton(
|
||
options_inner_frame,
|
||
text="模拟人工输入（逐字输入并添加延迟）",
|
||
variable=self.random_delayed
|
||
)
|
||
delayed_check.pack(anchor=tk.W)
|
||
|
||
# 按钮区域
|
||
buttons_frame = ttk.Frame(main_frame)
|
||
buttons_frame.pack(fill=tk.X)
|
||
|
||
ttk.Button(
|
||
buttons_frame,
|
||
text="取消",
|
||
command=dialog.destroy,
|
||
width=10
|
||
).pack(side=tk.RIGHT, padx=5)
|
||
|
||
ttk.Button(
|
||
buttons_frame,
|
||
text="开始输入",
|
||
command=lambda: self.run_random_input(dialog),
|
||
style='Accent.TButton',
|
||
width=10
|
||
).pack(side=tk.RIGHT, padx=5)
|
||
|
||
def run_random_input(self, dialog):
|
||
"""执行随机数输入操作并关闭对话框"""
|
||
dialog.destroy()
|
||
self.input_random_number()
|
||
|
||
def show_text_input_dialog(self):
|
||
"""显示指定文本输入对话框"""
|
||
dialog = tk.Toplevel(self.root)
|
||
dialog.title("指定文本输入")
|
||
dialog.geometry("500x400") # 增加高度从300到400
|
||
dialog.transient(self.root)
|
||
dialog.grab_set()
|
||
dialog.resizable(False, False)
|
||
|
||
# 设置图标
|
||
try:
|
||
icon_path = os.path.join(os.path.dirname(__file__), "app.ico")
|
||
if os.path.exists(icon_path):
|
||
dialog.iconbitmap(icon_path)
|
||
except Exception as e:
|
||
print(f"设置对话框图标失败: {str(e)}")
|
||
|
||
# 居中显示
|
||
self.center_window(dialog)
|
||
|
||
# 主框架
|
||
main_frame = ttk.Frame(dialog, padding=10)
|
||
main_frame.pack(fill=tk.BOTH, expand=True)
|
||
|
||
# 文本文件选择区域
|
||
file_frame = ttk.LabelFrame(main_frame, text="文本文件", padding=10)
|
||
file_frame.pack(fill=tk.X, pady=(0, 10))
|
||
|
||
file_path_var = tk.StringVar()
|
||
file_path_entry = ttk.Entry(file_frame, textvariable=file_path_var, width=40)
|
||
file_path_entry.pack(side=tk.LEFT, fill=tk.X, expand=True, padx=(0, 5))
|
||
self.setup_right_click_menu(file_path_entry)
|
||
|
||
def browse_file():
|
||
filepath = filedialog.askopenfilename(
|
||
title="选择文本文件",
|
||
filetypes=[("文本文件", "*.txt"), ("所有文件", "*.*")]
|
||
)
|
||
if filepath:
|
||
file_path_var.set(filepath)
|
||
# 预览文本文件内容
|
||
try:
|
||
with open(filepath, 'r', encoding='utf-8') as f:
|
||
preview_text = "\n".join(f.read().splitlines()[:10])
|
||
if len(f.read().splitlines()) > 10:
|
||
preview_text += "\n..."
|
||
preview.delete(1.0, tk.END)
|
||
preview.insert(tk.END, preview_text)
|
||
except Exception as e:
|
||
messagebox.showerror("错误", f"读取文件失败: {str(e)}")
|
||
|
||
ttk.Button(
|
||
file_frame,
|
||
text="浏览...",
|
||
command=browse_file
|
||
).pack(side=tk.RIGHT)
|
||
|
||
# 文本预览区域
|
||
preview_frame = ttk.LabelFrame(main_frame, text="文件内容预览", padding=10)
|
||
preview_frame.pack(fill=tk.BOTH, expand=True, pady=(0, 10))
|
||
|
||
preview = tk.Text(preview_frame, height=6, width=50, wrap=tk.WORD)
|
||
preview.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
|
||
|
||
preview_scrollbar = ttk.Scrollbar(preview_frame, orient=tk.VERTICAL, command=preview.yview)
|
||
preview_scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
|
||
preview.configure(yscrollcommand=preview_scrollbar.set)
|
||
|
||
# 输入方式选择
|
||
input_method_frame = ttk.Frame(main_frame)
|
||
input_method_frame.pack(fill=tk.X, pady=(0, 10))
|
||
|
||
input_method = tk.StringVar(value="sequential")
|
||
|
||
ttk.Radiobutton(
|
||
input_method_frame,
|
||
text="顺序输入",
|
||
variable=input_method,
|
||
value="sequential"
|
||
).pack(side=tk.LEFT, padx=(0, 15))
|
||
|
||
ttk.Radiobutton(
|
||
input_method_frame,
|
||
text="随机输入",
|
||
variable=input_method,
|
||
value="random"
|
||
).pack(side=tk.LEFT)
|
||
|
||
# 选项区域
|
||
options_frame = ttk.Frame(main_frame)
|
||
options_frame.pack(fill=tk.X, pady=(0, 10))
|
||
|
||
overwrite_var = tk.BooleanVar(value=True)
|
||
|
||
overwrite_check = ttk.Checkbutton(
|
||
options_frame,
|
||
text="覆盖原有内容",
|
||
variable=overwrite_var
|
||
)
|
||
overwrite_check.pack(side=tk.LEFT, padx=(0, 10))
|
||
|
||
# 按钮区域
|
||
buttons_frame = ttk.Frame(main_frame)
|
||
buttons_frame.pack(fill=tk.X)
|
||
|
||
ttk.Button(
|
||
buttons_frame,
|
||
text="取消",
|
||
command=dialog.destroy,
|
||
width=10
|
||
).pack(side=tk.RIGHT, padx=5)
|
||
|
||
ttk.Button(
|
||
buttons_frame,
|
||
text="开始输入",
|
||
command=lambda: self.execute_text_input(
|
||
dialog,
|
||
file_path_var.get(),
|
||
input_method.get(),
|
||
overwrite_var.get(),
|
||
False # 永远不使用延迟输入
|
||
),
|
||
style='Accent.TButton',
|
||
width=10
|
||
).pack(side=tk.RIGHT, padx=5)
|
||
|
||
def execute_text_input(self, dialog, file_path, input_method, overwrite, delayed):
|
||
"""执行文本输入操作"""
|
||
if not file_path:
|
||
messagebox.showwarning("警告", "请选择文本文件！")
|
||
return
|
||
|
||
if not os.path.exists(file_path):
|
||
messagebox.showerror("错误", "文件不存在！")
|
||
return
|
||
|
||
# 关闭对话框
|
||
dialog.destroy()
|
||
|
||
# 调用文本输入功能
|
||
self.input_text_from_file(file_path, input_method, overwrite, delayed)
|
||
|
||
def input_text_from_file(self, file_path, input_method, overwrite, delayed):
|
||
"""从文件输入文本到选中的窗口"""
|
||
try:
|
||
# 获取选中的窗口
|
||
selected_windows = []
|
||
for item in self.window_list.get_children():
|
||
if self.window_list.set(item, "select") == "√":
|
||
hwnd = int(self.window_list.item(item)['values'][-1])
|
||
selected_windows.append(hwnd)
|
||
|
||
if not selected_windows:
|
||
messagebox.showwarning("警告", "请先选择要操作的窗口！")
|
||
return
|
||
|
||
# 读取文本文件
|
||
try:
|
||
with open(file_path, 'r', encoding='utf-8') as f:
|
||
lines = [line.strip() for line in f.readlines() if line.strip()]
|
||
except UnicodeDecodeError:
|
||
# 尝试其它编码
|
||
try:
|
||
with open(file_path, 'r', encoding='gbk') as f:
|
||
lines = [line.strip() for line in f.readlines() if line.strip()]
|
||
except Exception as e:
|
||
messagebox.showerror("错误", f"读取文件失败: {str(e)}")
|
||
return
|
||
|
||
if not lines:
|
||
messagebox.showwarning("警告", "文本文件为空！")
|
||
return
|
||
|
||
# 准备文本行
|
||
if input_method == "random":
|
||
# 为每个窗口随机选择一行
|
||
random.shuffle(lines)
|
||
# 如果窗口数量大于文本行数，循环使用
|
||
if len(selected_windows) > len(lines):
|
||
lines = lines * (len(selected_windows) // len(lines) + 1)
|
||
|
||
# 确保文本行至少与窗口数量一样多
|
||
while len(lines) < len(selected_windows):
|
||
lines.extend(lines)
|
||
|
||
# 输入进度窗口
|
||
progress_dialog = tk.Toplevel(self.root)
|
||
progress_dialog.title("文本输入")
|
||
progress_dialog.geometry("400x100")
|
||
progress_dialog.transient(self.root)
|
||
progress_dialog.grab_set()
|
||
progress_dialog.resizable(False, False)
|
||
|
||
# 设置图标
|
||
try:
|
||
icon_path = os.path.join(os.path.dirname(__file__), "app.ico")
|
||
if os.path.exists(icon_path):
|
||
progress_dialog.iconbitmap(icon_path)
|
||
except Exception as e:
|
||
print(f"设置进度对话框图标失败: {str(e)}")
|
||
|
||
self.center_window(progress_dialog)
|
||
|
||
progress_label = ttk.Label(progress_dialog, text="正在准备输入...")
|
||
progress_label.pack(pady=(20, 10))
|
||
|
||
progress_bar = ttk.Progressbar(progress_dialog, mode='determinate', length=350)
|
||
progress_bar.pack(pady=(0, 20))
|
||
|
||
progress_dialog.update()
|
||
|
||
try:
|
||
# 为每个窗口输入文本
|
||
for i, hwnd in enumerate(selected_windows):
|
||
# 更新进度
|
||
progress = int((i / len(selected_windows)) * 100)
|
||
progress_bar['value'] = progress
|
||
text_line = lines[i % len(lines)]
|
||
progress_label.config(text=f"正在输入 ({i+1}/{len(selected_windows)}): {text_line[:30]}...")
|
||
progress_dialog.update()
|
||
|
||
try:
|
||
# 激活窗口
|
||
win32gui.SetForegroundWindow(hwnd)
|
||
time.sleep(0.1) # 等待窗口获得焦点
|
||
|
||
# 如果选择覆盖原有内容，先全选文本
|
||
if overwrite:
|
||
keyboard.press_and_release('ctrl+a')
|
||
time.sleep(0.05)
|
||
|
||
# 输入文本 - 直接输入整个字符串
|
||
keyboard.write(text_line)
|
||
|
||
time.sleep(0.2) # 等待短暂时间再处理下一个窗口
|
||
except Exception as e:
|
||
print(f"向窗口 {hwnd} 输入文本时出错: {str(e)}")
|
||
continue
|
||
|
||
# 完成后更新进度
|
||
progress_bar['value'] = 100
|
||
progress_label.config(text="输入完成！")
|
||
progress_dialog.update()
|
||
|
||
# 短暂延迟后关闭进度窗口
|
||
self.root.after(1000, progress_dialog.destroy)
|
||
|
||
except Exception as e:
|
||
progress_dialog.destroy()
|
||
messagebox.showerror("错误", f"输入文本时出错: {str(e)}")
|
||
|
||
except Exception as e:
|
||
messagebox.showerror("错误", f"操作失败: {str(e)}")
|
||
|
||
def show_chrome_settings_tip(self):
|
||
"""显示Chrome后台运行设置提示"""
|
||
tip_dialog = tk.Toplevel(self.root)
|
||
tip_dialog.title("Chrome后台运行提示")
|
||
tip_dialog.geometry("420x255")
|
||
tip_dialog.transient(self.root)
|
||
tip_dialog.grab_set()
|
||
|
||
# 设置为模态对话框
|
||
tip_dialog.focus_set()
|
||
|
||
# 提示信息
|
||
tip_text = "如果窗口关闭后，Chrome仍在后台运行（右下角系统托盘区域里有多个chrome图标），请批量在浏览器设置页面取消后台运行：\n\n1. 批量打开Chrome浏览器\n2. 在地址栏输入：chrome://settings/system，或者进入设置-系统\n3. 找到\"关闭 Google Chrome 后继续运行后台应用\"选项\n4. 关闭该选项"
|
||
|
||
tip_label = ttk.Label(tip_dialog, text=tip_text, justify=tk.LEFT, wraplength=380)
|
||
tip_label.pack(pady=20, padx=20)
|
||
|
||
# 不再显示的选项
|
||
dont_show_var = tk.BooleanVar(value=False)
|
||
dont_show_check = ttk.Checkbutton(
|
||
tip_dialog,
|
||
text="下次不再显示",
|
||
variable=dont_show_var
|
||
)
|
||
dont_show_check.pack(pady=10)
|
||
|
||
# 确定按钮
|
||
def on_ok():
|
||
if dont_show_var.get():
|
||
self.show_chrome_tip = False
|
||
self.save_tip_settings()
|
||
tip_dialog.destroy()
|
||
|
||
ok_button = ttk.Button(tip_dialog, text="确定", command=on_ok, style='Accent.TButton')
|
||
ok_button.pack(pady=10)
|
||
|
||
# 居中显示
|
||
self.center_window(tip_dialog)
|
||
|
||
def save_tip_settings(self):
|
||
"""保存提示设置到设置文件"""
|
||
try:
|
||
# 强制设置为False - 确保选择"下次不再显示"后永远不再显示
|
||
self.show_chrome_tip = False
|
||
|
||
# 直接设置当前实例的设置
|
||
self.settings['show_chrome_tip'] = False
|
||
|
||
# 立即保存到settings.json
|
||
with open('settings.json', 'w', encoding='utf-8') as f:
|
||
json.dump(self.settings, f, ensure_ascii=False, indent=4)
|
||
|
||
print(f"成功保存Chrome提示设置: show_chrome_tip = {self.show_chrome_tip}")
|
||
|
||
except Exception as e:
|
||
print(f"保存提示设置失败: {str(e)}")
|
||
messagebox.showerror("设置保存失败", f"无法保存提示设置: {str(e)}")
|
||
|
||
def load_settings(self) -> dict:
|
||
# 加载设置
|
||
settings = {}
|
||
try:
|
||
if os.path.exists('settings.json'):
|
||
with open('settings.json', 'r', encoding='utf-8') as f:
|
||
settings = json.load(f)
|
||
except Exception as e:
|
||
print(f"加载设置失败: {str(e)}")
|
||
|
||
return settings
|
||
|
||
if __name__ == "__main__":
|
||
try:
|
||
app = ChromeManager()
|
||
app.run()
|
||
except Exception as e:
|
||
# 确保错误被显示出来
|
||
import traceback
|
||
error_message = f"程序出现错误:\n{str(e)}\n\n{traceback.format_exc()}"
|
||
print(error_message)
|
||
try:
|
||
# 尝试使用tkinter显示错误
|
||
from tkinter import messagebox
|
||
messagebox.showerror("程序错误", error_message)
|
||
except:
|
||
# 如果tkinter也失败了，尝试命令行保持窗口
|
||
print("\n按任意键退出...")
|
||
input() |