1752 lines
75 KiB
Python
1752 lines
75 KiB
Python
import tkinter as tk
|
|
from tkinter import ttk, messagebox
|
|
import os
|
|
import subprocess
|
|
import win32gui
|
|
import win32process
|
|
import win32con
|
|
import win32api
|
|
import win32com.client
|
|
import json
|
|
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
|
|
|
|
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):
|
|
|
|
if not is_admin():
|
|
if messagebox.askyesno("权限不足", "需要管理员权限才能运行同步功能。\n是否以管理员身份重新启动程序？"):
|
|
run_as_admin()
|
|
sys.exit()
|
|
|
|
self.root = tk.Tk()
|
|
self.root.title("NoBiggie社区Chrome多窗口管理器 V1.0")
|
|
|
|
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)}")
|
|
|
|
last_position = self.load_window_position()
|
|
if last_position:
|
|
self.root.geometry(last_position)
|
|
|
|
sv_ttk.set_theme("light") # 使用 light 主题
|
|
|
|
self.window_list = None # 先初始化为 None
|
|
self.windows = []
|
|
self.master_window = None
|
|
self.shortcut_path = self.load_settings().get('shortcut_path', '')
|
|
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.shortcut_hook = None
|
|
self.current_shortcut = None
|
|
|
|
# 从设置中加载快捷键
|
|
settings = self.load_settings()
|
|
if 'sync_shortcut' in settings:
|
|
self.set_shortcut(settings['sync_shortcut'])
|
|
|
|
self.root.protocol("WM_DELETE_WINDOW", self.on_closing)
|
|
|
|
# 创建界面
|
|
self.create_widgets()
|
|
self.create_styles()
|
|
|
|
|
|
self.root.update()
|
|
current_width = self.root.winfo_width()
|
|
current_height = self.root.winfo_height()
|
|
self.root.geometry(f"{current_width}x{current_height}")
|
|
self.root.resizable(False, False)
|
|
|
|
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)
|
|
|
|
if self.window_list:
|
|
self.window_list.tag_configure("master",
|
|
background="#0d6efd",
|
|
foreground='white'
|
|
)
|
|
|
|
# 链接样式
|
|
style.configure('Link.TLabel',
|
|
foreground='#0d6efd',
|
|
cursor='hand2',
|
|
font=('Microsoft YaHei UI', 9, 'underline')
|
|
)
|
|
|
|
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_frame = ttk.Frame(manage_frame)
|
|
button_frame.pack(fill=tk.X)
|
|
|
|
ttk.Button(button_frame, text="导入窗口", command=self.import_windows, style='Accent.TButton').pack(side=tk.LEFT, padx=2)
|
|
select_all_label = ttk.Label(button_frame, 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(button_frame, text="自动排列", command=self.auto_arrange_windows).pack(side=tk.LEFT, padx=2)
|
|
ttk.Button(button_frame, text="关闭选中", command=self.close_selected_windows).pack(side=tk.LEFT, padx=2)
|
|
|
|
self.sync_button = ttk.Button(
|
|
button_frame,
|
|
text="▶ 开始同步",
|
|
command=self.toggle_sync,
|
|
style='Accent.TButton'
|
|
)
|
|
self.sync_button.pack(side=tk.LEFT, padx=5)
|
|
|
|
ttk.Button(
|
|
button_frame,
|
|
text="快捷键",
|
|
command=self.show_shortcut_dialog,
|
|
style='Accent.TButton'
|
|
).pack(side=tk.LEFT, padx=5)
|
|
|
|
# 在 button_frame 中添加屏幕选择下拉框
|
|
screen_frame = ttk.Frame(button_frame)
|
|
screen_frame.pack(side=tk.LEFT, padx=2)
|
|
ttk.Label(screen_frame, text="屏幕:").pack(side=tk.LEFT)
|
|
|
|
# 创建屏幕选择下拉框
|
|
self.screen_var = tk.StringVar()
|
|
self.screen_combo = ttk.Combobox(
|
|
screen_frame,
|
|
textvariable=self.screen_var,
|
|
width=8,
|
|
state="readonly"
|
|
)
|
|
self.screen_combo.pack(side=tk.LEFT)
|
|
|
|
# 获取并设置屏幕列表
|
|
self.update_screen_list()
|
|
|
|
list_frame = ttk.Frame(manage_frame)
|
|
list_frame.pack(fill=tk.BOTH, expand=True, pady=2)
|
|
|
|
# 创建窗口列表
|
|
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=40, anchor="center")
|
|
self.window_list.column("number", width=40, anchor="center")
|
|
self.window_list.column("title", width=300)
|
|
self.window_list.column("master", width=40, 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)
|
|
|
|
# 添加滚动条
|
|
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")
|
|
|
|
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")
|
|
|
|
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")
|
|
|
|
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")
|
|
|
|
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")
|
|
|
|
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")
|
|
|
|
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")
|
|
|
|
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="打开窗口")
|
|
|
|
input_frame = ttk.Frame(open_window_tab)
|
|
input_frame.pack(fill=tk.X, padx=5, pady=5)
|
|
|
|
ttk.Label(input_frame, text="快捷方式目录:").pack(side=tk.LEFT)
|
|
self.path_entry = ttk.Entry(input_frame)
|
|
self.path_entry.pack(side=tk.LEFT, fill=tk.X, expand=True)
|
|
self.path_entry.insert(0, self.shortcut_path)
|
|
|
|
numbers_frame = ttk.Frame(input_frame)
|
|
numbers_frame.pack(pady=5, padx=10, fill=tk.X)
|
|
ttk.Label(numbers_frame, text="窗口编号:").pack(side=tk.LEFT)
|
|
self.numbers_entry = ttk.Entry(numbers_frame)
|
|
self.numbers_entry.pack(side=tk.LEFT, padx=5, fill=tk.X, expand=True)
|
|
|
|
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
|
|
).pack(side=tk.LEFT)
|
|
|
|
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=5, pady=5)
|
|
ttk.Label(url_frame, text="网址:").pack(side=tk.LEFT)
|
|
self.url_entry = ttk.Entry(url_frame)
|
|
self.url_entry.pack(side=tk.LEFT, fill=tk.X, expand=True)
|
|
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).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=5, pady=5)
|
|
|
|
ttk.Label(icon_frame, text="图标目录:").pack(side=tk.LEFT)
|
|
self.icon_path_entry = ttk.Entry(icon_frame)
|
|
self.icon_path_entry.pack(side=tk.LEFT, fill=tk.X, expand=True)
|
|
|
|
ttk.Label(icon_frame, text="窗口编号:").pack(side=tk.LEFT, padx=(10, 0))
|
|
self.icon_window_numbers = ttk.Entry(icon_frame, width=15)
|
|
self.icon_window_numbers.pack(side=tk.LEFT, padx=(0, 5))
|
|
ttk.Label(icon_frame, text="示例: 1-5,7,9-12").pack(side=tk.LEFT)
|
|
ttk.Button(icon_frame, text="替换图标", command=self.set_taskbar_icons).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)
|
|
|
|
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):
|
|
# 设置主控窗口
|
|
if not item:
|
|
return
|
|
|
|
try:
|
|
# 清除其他窗口的主控状态和标题
|
|
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 title.startswith("[主控]"):
|
|
new_title = title.replace("[主控]", "").strip()
|
|
win32gui.SetWindowText(hwnd, new_title)
|
|
# 恢复默认边框颜色
|
|
try:
|
|
ctypes.windll.dwmapi.DwmSetWindowAttribute(
|
|
hwnd,
|
|
self.DWMWA_BORDER_COLOR,
|
|
ctypes.byref(ctypes.c_int(0)),
|
|
ctypes.sizeof(ctypes.c_int)
|
|
)
|
|
except:
|
|
pass
|
|
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 title.startswith("[主控]"):
|
|
new_title = f"[主控] {title}"
|
|
win32gui.SetWindowText(self.master_window, new_title)
|
|
try:
|
|
# 设置红色边框
|
|
ctypes.windll.dwmapi.DwmSetWindowAttribute(
|
|
self.master_window,
|
|
self.DWMWA_BORDER_COLOR,
|
|
ctypes.byref(ctypes.c_int(0x000000FF)),
|
|
ctypes.sizeof(ctypes.c_int)
|
|
)
|
|
except:
|
|
pass
|
|
|
|
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("同步已开启")
|
|
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("同步已停止")
|
|
except Exception as e:
|
|
print(f"停止同步失败: {str(e)}")
|
|
|
|
def start_sync(self, selected_items):
|
|
try:
|
|
# 确保主控窗口存在
|
|
if not self.master_window:
|
|
raise Exception("未设置主控窗口")
|
|
|
|
# 保存选中的窗口列表，并按编号排序
|
|
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.hook_thread:
|
|
self.is_syncing = True
|
|
self.hook_thread = threading.Thread(target=self.message_loop)
|
|
self.hook_thread.daemon = True
|
|
self.hook_thread.start()
|
|
|
|
keyboard.hook(self.on_keyboard_event)
|
|
mouse.hook(self.on_mouse_event)
|
|
|
|
# 更新按钮状态
|
|
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}")
|
|
|
|
except Exception as e:
|
|
self.stop_sync() # 确保清理资源
|
|
print(f"开启同步失败: {str(e)}")
|
|
raise e
|
|
|
|
def message_loop(self):
|
|
# 消息循环
|
|
while self.is_syncing:
|
|
time.sleep(0.001)
|
|
|
|
def on_mouse_event(self, event):
|
|
try:
|
|
if self.is_syncing:
|
|
current_window = win32gui.GetForegroundWindow()
|
|
|
|
# 检查是否是主控窗口或其插件窗口
|
|
is_master = current_window == self.master_window
|
|
master_popups = self.get_chrome_popups(self.master_window)
|
|
is_popup = current_window in master_popups
|
|
|
|
if is_master or is_popup:
|
|
# 对于移动事件进行优化
|
|
if isinstance(event, mouse.MoveEvent):
|
|
# 检查移动距离和时间间隔
|
|
current_time = time.time()
|
|
if current_time - self.last_move_time < self.move_interval:
|
|
return
|
|
|
|
dx = abs(event.x - self.last_mouse_position[0])
|
|
dy = abs(event.y - self.last_mouse_position[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
|
|
|
|
# 获取鼠标位置
|
|
x, y = mouse.get_position()
|
|
|
|
# 获取当前窗口的相对坐标
|
|
current_rect = win32gui.GetWindowRect(current_window)
|
|
rel_x = (x - current_rect[0]) / (current_rect[2] - current_rect[0])
|
|
rel_y = (y - current_rect[1]) / (current_rect[3] - current_rect[1])
|
|
|
|
# 同步到其他窗口
|
|
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
|
|
|
|
# 获取目标窗口尺寸
|
|
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)
|
|
|
|
# 处理滚轮事件
|
|
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, 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:
|
|
vk_code = win32con.VK_UP if wheel_delta > 0 else win32con.VK_DOWN
|
|
vk_code = win32con.VK_UP if wheel_delta > 0 else win32con.VK_DOWN
|
|
repeat_count = min(abs(wheel_delta) * 3, 6)
|
|
for _ in range(repeat_count):
|
|
win32gui.PostMessage(target_hwnd, win32con.WM_KEYDOWN, vk_code, 0)
|
|
win32gui.PostMessage(target_hwnd, win32con.WM_KEYUP, vk_code, 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.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 isinstance(event, mouse.MoveEvent):
|
|
win32gui.PostMessage(target_hwnd, win32con.WM_MOUSEMOVE, 0, lparam)
|
|
|
|
except Exception as e:
|
|
print(f"同步到窗口 {target_hwnd} 失败: {str(e)}")
|
|
continue
|
|
|
|
except Exception as e:
|
|
print(f"处理鼠标事件失败: {str(e)}")
|
|
|
|
def on_keyboard_event(self, event):
|
|
# 改进的键盘事件处理
|
|
try:
|
|
if self.is_syncing:
|
|
current_window = win32gui.GetForegroundWindow()
|
|
|
|
# 检查是否是主控窗口或其插件窗口
|
|
is_master = current_window == self.master_window
|
|
master_popups = self.get_chrome_popups(self.master_window)
|
|
is_popup = current_window in master_popups
|
|
|
|
if is_master or is_popup:
|
|
# 获取实际的输入目标窗口
|
|
input_hwnd = win32gui.GetFocus()
|
|
|
|
# 同步到其他窗口
|
|
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
|
|
|
|
# 处理 Ctrl 组合键
|
|
if keyboard.is_pressed('ctrl'):
|
|
# 发送 Ctrl 按下
|
|
win32gui.PostMessage(target_hwnd, win32con.WM_KEYDOWN, win32con.VK_CONTROL, 0)
|
|
|
|
# 处理常用组合键
|
|
if event.name in ['a', 'c', 'v', 'x']:
|
|
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)
|
|
win32gui.PostMessage(target_hwnd, win32con.WM_KEYUP, win32con.VK_CONTROL, 0)
|
|
continue
|
|
|
|
# 处理普通按键
|
|
if event.name in ['enter', 'backspace', 'tab', 'esc', 'space',
|
|
'up', 'down', 'left', 'right', # 添加左右键
|
|
'home', 'end', 'page up', 'page down', 'delete']:
|
|
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
|
|
}
|
|
vk_code = vk_map[event.name]
|
|
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_DOWN:
|
|
win32gui.PostMessage(target_hwnd, win32con.WM_KEYDOWN, vk_code, 0)
|
|
else:
|
|
win32gui.PostMessage(target_hwnd, win32con.WM_KEYUP, vk_code, 0)
|
|
|
|
# 释放组合键
|
|
if keyboard.is_pressed('ctrl'):
|
|
win32gui.PostMessage(target_hwnd, win32con.WM_KEYUP, win32con.VK_CONTROL, 0)
|
|
|
|
except Exception as e:
|
|
print(f"同步到窗口 {target_hwnd} 失败: {str(e)}")
|
|
|
|
except Exception as e:
|
|
print(f"处理键盘事件失败: {str(e)}")
|
|
|
|
def stop_sync(self):
|
|
# 停止同步
|
|
try:
|
|
self.is_syncing = False
|
|
|
|
# 移除键盘钩子
|
|
if self.keyboard_hook:
|
|
keyboard.unhook(self.keyboard_hook)
|
|
self.keyboard_hook = None
|
|
|
|
# 移除鼠标钩子
|
|
if self.mouse_hook_id:
|
|
mouse.unhook(self.mouse_hook_id)
|
|
self.mouse_hook_id = None
|
|
|
|
# 等待监控线程结束
|
|
if self.hook_thread and self.hook_thread.is_alive():
|
|
self.hook_thread.join(timeout=1.0)
|
|
|
|
# 清理资源（保留主窗口设置）
|
|
self.sync_windows.clear()
|
|
self.popup_mappings.clear()
|
|
|
|
# 清理调试端口映射
|
|
self.debug_ports.clear()
|
|
|
|
# 重置鼠标状态
|
|
self.last_mouse_position = (0, 0)
|
|
self.last_move_time = 0
|
|
|
|
# 更新按钮状态
|
|
if self.sync_button:
|
|
self.sync_button.configure(text="▶ 开始同步", style='Accent.TButton')
|
|
|
|
except Exception as e:
|
|
print(f"停止同步失败: {str(e)}")
|
|
|
|
def on_closing(self):
|
|
# 窗口关闭事件
|
|
try:
|
|
self.stop_sync()
|
|
# 清理快捷键
|
|
if self.shortcut_hook:
|
|
keyboard.clear_all_hotkeys()
|
|
keyboard.unhook_all()
|
|
self.shortcut_hook = None
|
|
self.save_settings()
|
|
except Exception as e:
|
|
print(f"程序关闭时出错: {str(e)}")
|
|
finally:
|
|
self.root.destroy()
|
|
|
|
def auto_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:
|
|
number = int(values[1])
|
|
hwnd = int(values[4])
|
|
selected.append((number, hwnd, item))
|
|
|
|
if not selected:
|
|
messagebox.showinfo("提示", "请先选择要排列的窗口！")
|
|
return
|
|
|
|
# 按编号正序排序
|
|
selected.sort(key=lambda x: x[0])
|
|
|
|
# 获取选中的屏幕信息
|
|
screen_index = self.screen_combo.current()
|
|
if screen_index < 0 or screen_index >= len(self.screens):
|
|
messagebox.showerror("错误", "请选择有效的屏幕！")
|
|
return
|
|
|
|
screen = self.screens[screen_index]
|
|
screen_rect = screen['work_rect'] # 使用工作区而不是完整显示区
|
|
|
|
# 计算屏幕尺寸
|
|
screen_width = screen_rect[2] - screen_rect[0]
|
|
screen_height = screen_rect[3] - screen_rect[1]
|
|
|
|
# 计算最佳布局
|
|
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
|
|
|
|
# 创建位置映射（从左到右，从上到下）
|
|
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))
|
|
|
|
# 应用窗口位置
|
|
for i, (_, hwnd, _) in enumerate(selected):
|
|
try:
|
|
x, y = positions[i]
|
|
# 确保窗口可见并移动到指定位置
|
|
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)
|
|
except Exception as e:
|
|
print(f"移动窗口 {hwnd} 失败: {str(e)}")
|
|
continue
|
|
|
|
# 如果之前在同步，重新开启同步
|
|
if was_syncing:
|
|
self.start_sync([item for _, _, item in selected])
|
|
|
|
except Exception as 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") == "√":
|
|
selected.append(item)
|
|
|
|
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 in enumerate(selected):
|
|
values = self.window_list.item(item)['values']
|
|
if values and len(values) >= 5: # 确保有足够的值
|
|
hwnd = int(values[4])
|
|
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)}")
|
|
|
|
# 如果之前在同步，重新开启同步
|
|
if was_syncing:
|
|
self.start_sync(selected)
|
|
|
|
except Exception as e:
|
|
messagebox.showerror("错误", f"排列窗口失败: {str(e)}")
|
|
|
|
def load_settings(self) -> dict:
|
|
# 加载设置
|
|
try:
|
|
with open('settings.json', 'r') as f:
|
|
return json.load(f)
|
|
except:
|
|
return {}
|
|
|
|
def save_settings(self):
|
|
# 保存设置
|
|
try:
|
|
settings = {
|
|
'shortcut_path': self.path_entry.get(),
|
|
'window_position': self.root.geometry(),
|
|
'last_window_numbers': self.numbers_entry.get(), # 添加保存窗口编号
|
|
'arrange_params': {
|
|
'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()
|
|
},
|
|
'sync_shortcut': self.current_shortcut
|
|
}
|
|
with open('settings.json', 'w', encoding='utf-8') as f:
|
|
json.dump(settings, f, ensure_ascii=False, indent=4)
|
|
except Exception as e:
|
|
print(f"保存设置失败: {str(e)}")
|
|
|
|
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窗口
|
|
path = self.path_entry.get()
|
|
numbers = self.numbers_entry.get()
|
|
|
|
if not path or not numbers:
|
|
messagebox.showwarning("警告", "请输入快捷方式路径和窗口编号！")
|
|
return
|
|
|
|
try:
|
|
window_numbers = self.parse_window_numbers(numbers)
|
|
for num in window_numbers:
|
|
shortcut = os.path.join(path, f"{num}.lnk")
|
|
if os.path.exists(shortcut):
|
|
subprocess.Popen(["start", "", shortcut], shell=True)
|
|
time.sleep(0.5) # 添加延时确保按顺序打开
|
|
else:
|
|
messagebox.showwarning("警告", f"快捷方式不存在: {shortcut}")
|
|
|
|
# 保存路径
|
|
self.save_settings()
|
|
|
|
except Exception as e:
|
|
messagebox.showerror("错误", f"打开窗口失败: {str(e)}")
|
|
|
|
def get_shortcut_number(self, shortcut_path):
|
|
# 从快捷方式中获取窗口编号
|
|
handle = None
|
|
try:
|
|
# 获取目标进程
|
|
shortcut = self.shell.CreateShortCut(shortcut_path)
|
|
cmd_line = shortcut.Arguments
|
|
|
|
# 打开进程获取命令行
|
|
handle = win32api.OpenProcess(
|
|
win32con.PROCESS_QUERY_INFORMATION | win32con.PROCESS_VM_READ,
|
|
False,
|
|
self.pid
|
|
)
|
|
|
|
# 处理命令行
|
|
if '--user-data-dir=' in cmd_line:
|
|
data_dir = cmd_line.split('--user-data-dir=')[1].strip('"')
|
|
number = os.path.basename(data_dir)
|
|
return number
|
|
|
|
return None
|
|
|
|
except Exception as e:
|
|
print(f"获取快捷方式编号失败: {str(e)}")
|
|
return None
|
|
|
|
finally:
|
|
# 确保句柄被关闭
|
|
if handle:
|
|
try:
|
|
win32api.CloseHandle(handle)
|
|
except Exception as e:
|
|
print(f"关闭进程句柄失败: {str(e)}")
|
|
|
|
def import_windows(self):
|
|
# 导入当前打开的Chrome窗口
|
|
try:
|
|
# 清空列表
|
|
for item in self.window_list.get_children():
|
|
self.window_list.delete(item)
|
|
|
|
def callback(hwnd, windows):
|
|
if win32gui.IsWindowVisible(hwnd):
|
|
_, pid = win32process.GetWindowThreadProcessId(hwnd)
|
|
try:
|
|
handle = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION | win32con.PROCESS_VM_READ, False, pid)
|
|
path = win32process.GetModuleFileNameEx(handle, 0)
|
|
win32api.CloseHandle(handle)
|
|
|
|
if "chrome.exe" in path.lower():
|
|
title = win32gui.GetWindowText(hwnd)
|
|
if title and not title.startswith("Chrome 传递"):
|
|
# 为每个窗口分配一个调试端口
|
|
port = self.base_debug_port + len(windows)
|
|
self.debug_ports[hwnd] = port
|
|
windows.append((title, hwnd))
|
|
|
|
except Exception as e:
|
|
print(f"获取进程信息失败: {str(e)}")
|
|
|
|
windows = []
|
|
win32gui.EnumWindows(callback, windows)
|
|
|
|
# 反转windows列表，这样就会按照相反的顺序添加到列表中
|
|
windows.reverse()
|
|
|
|
# 添加到列表
|
|
for i, (title, hwnd) in enumerate(windows, 1):
|
|
self.window_list.insert("", "end", values=("", f"{i}", title, "", hwnd))
|
|
|
|
except Exception as 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 # 忽略已关闭窗口的错误
|
|
|
|
# 等待窗口关闭后刷新列表
|
|
time.sleep(0.5)
|
|
self.import_windows()
|
|
|
|
except Exception as e:
|
|
print(f"关闭窗口失败: {str(e)}") # 只打印错误，不显示错误对话框
|
|
|
|
def set_taskbar_icons(self):
|
|
# 设置独立任务栏图标
|
|
if not self.path_entry.get():
|
|
messagebox.showinfo("提示", "请先设置快捷方式目录！")
|
|
return
|
|
|
|
if not os.path.exists(self.path_entry.get()):
|
|
messagebox.showerror("错误", "快捷方式目录不存在！")
|
|
return
|
|
|
|
# 确认操作
|
|
choice = messagebox.askyesnocancel("选择操作", "选择要执行的操作：\n是 - 设置自定义图标\n否 - 恢复原始设置\n取消 - 不执行任何操作")
|
|
if choice is None: # 用户点击取消
|
|
return
|
|
|
|
try:
|
|
data_dir = self.path_entry.get()
|
|
icon_dir = self.icon_path_entry.get()
|
|
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(data_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"
|
|
|
|
# 恢复指定的快捷方式
|
|
for i in window_numbers:
|
|
shortcut_path = os.path.join(data_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="D:\\chrom duo\\Data\\{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):
|
|
# 批量打开网页
|
|
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") == "√":
|
|
hwnd = int(self.window_list.item(item)['values'][-1])
|
|
selected_windows.append(hwnd)
|
|
|
|
if not selected_windows:
|
|
messagebox.showwarning("警告", "请先选择要操作的窗口！")
|
|
return
|
|
|
|
# 在每个选中的窗口中打开网页
|
|
for hwnd in selected_windows:
|
|
try:
|
|
# 激活窗口
|
|
win32gui.ShowWindow(hwnd, win32con.SW_RESTORE)
|
|
win32gui.SetForegroundWindow(hwnd)
|
|
time.sleep(0.1)
|
|
|
|
# 打开新标签页
|
|
keyboard.press_and_release('ctrl+t')
|
|
time.sleep(0.1)
|
|
|
|
# 输入网址并回车
|
|
keyboard.write(url)
|
|
time.sleep(0.1)
|
|
keyboard.press_and_release('enter')
|
|
time.sleep(0.2)
|
|
|
|
except Exception as e:
|
|
print(f"在窗口 {hwnd} 打开URL失败: {str(e)}")
|
|
|
|
messagebox.showinfo("成功", "批量打开网页完成！")
|
|
|
|
except Exception as e:
|
|
messagebox.showerror("错误", f"批量打开网页失败: {str(e)}")
|
|
|
|
def run(self):
|
|
"""运行程序"""
|
|
self.root.mainloop()
|
|
|
|
def load_window_position(self):
|
|
# 从 settings.json 加载窗口位置
|
|
try:
|
|
settings = self.load_settings()
|
|
return settings.get('window_position')
|
|
except:
|
|
return None
|
|
|
|
def save_window_position(self):
|
|
# 保存窗口位置到 settings.json
|
|
try:
|
|
position = self.root.geometry()
|
|
settings = self.load_settings()
|
|
settings['window_position'] = position
|
|
|
|
with open('settings.json', 'w', encoding='utf-8') as f:
|
|
json.dump(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_1" 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
|
|
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 # 添加工具窗口检查
|
|
)
|
|
|
|
if is_popup:
|
|
popups.append(hwnd)
|
|
|
|
except Exception as e:
|
|
print(f"枚举窗口失败: {str(e)}")
|
|
|
|
win32gui.EnumWindows(enum_windows_callback, None)
|
|
return popups
|
|
|
|
def monitor_popups(self):
|
|
# 监控插件窗口变化
|
|
while self.is_syncing:
|
|
try:
|
|
self.sync_chrome_popups()
|
|
except:
|
|
pass
|
|
time.sleep(0.1)
|
|
|
|
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()
|
|
|
|
# 当前快捷键显示
|
|
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
|
|
|
|
def start_recording():
|
|
# 开始录制快捷键
|
|
nonlocal recording
|
|
recording = True
|
|
keys_pressed.clear()
|
|
shortcut_var.set("请按下快捷键组合...")
|
|
record_btn.configure(state='disabled')
|
|
|
|
def on_key_event(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()
|
|
|
|
keyboard.hook(on_key_event)
|
|
|
|
def stop_recording():
|
|
# 停止录制快捷键
|
|
nonlocal recording
|
|
recording = False
|
|
keyboard.unhook_all()
|
|
# 重新设置当前快捷键
|
|
if self.current_shortcut:
|
|
self.set_shortcut(self.current_shortcut)
|
|
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="保存",
|
|
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:
|
|
# 先完全清理所有快捷键和钩子
|
|
keyboard.unhook_all()
|
|
keyboard.clear_all_hotkeys()
|
|
|
|
if self.shortcut_hook:
|
|
self.shortcut_hook = None
|
|
|
|
if shortcut:
|
|
# 添加错误重试机制
|
|
max_retries = 3
|
|
for attempt in range(max_retries):
|
|
try:
|
|
# 注册新快捷键
|
|
self.shortcut_hook = keyboard.add_hotkey(
|
|
shortcut,
|
|
self.toggle_sync,
|
|
suppress=True,
|
|
trigger_on_release=True # 在按键释放时触发，避免卡键
|
|
)
|
|
self.current_shortcut = shortcut
|
|
print(f"快捷键 {shortcut} 设置成功")
|
|
break
|
|
except Exception as e:
|
|
print(f"第 {attempt + 1} 次设置快捷键失败: {str(e)}")
|
|
if attempt == max_retries - 1:
|
|
raise
|
|
time.sleep(0.5) # 重试前等待
|
|
|
|
except Exception as e:
|
|
print(f"设置快捷键失败: {str(e)}")
|
|
self.shortcut_hook = None
|
|
# 尝试恢复之前的快捷键
|
|
if self.current_shortcut and self.current_shortcut != shortcut:
|
|
try:
|
|
self.shortcut_hook = keyboard.add_hotkey(
|
|
self.current_shortcut,
|
|
self.toggle_sync,
|
|
suppress=True,
|
|
trigger_on_release=True
|
|
)
|
|
except:
|
|
self.current_shortcut = None
|
|
|
|
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.screen_combo['values'] = [screen['name'] for screen in screens]
|
|
self.screens = screens # 保存屏幕信息
|
|
|
|
# 默认选择主屏幕
|
|
for i, screen in enumerate(screens):
|
|
if '主屏幕' in screen['name']:
|
|
self.screen_combo.current(i)
|
|
break
|
|
else:
|
|
self.screen_combo.current(0)
|
|
|
|
# 打印调试信息
|
|
print("检测到的屏幕:")
|
|
for screen in screens:
|
|
print(f"名称: {screen['name']}")
|
|
print(f"位置: {screen['rect']}")
|
|
print(f"工作区: {screen['work_rect']}")
|
|
print("---")
|
|
|
|
except Exception as e:
|
|
print(f"获取屏幕列表失败: {str(e)}")
|
|
# 使用最基本的方案
|
|
try:
|
|
screen_width = win32api.GetSystemMetrics(win32con.SM_CXSCREEN)
|
|
screen_height = win32api.GetSystemMetrics(win32con.SM_CYSCREEN)
|
|
screens = [{
|
|
'name': "主屏幕",
|
|
'rect': (0, 0, screen_width, screen_height),
|
|
'work_rect': (0, 0, screen_width, screen_height),
|
|
'monitor': None
|
|
}]
|
|
self.screen_combo['values'] = [screen['name'] for screen in screens]
|
|
self.screens = screens
|
|
self.screen_combo.current(0)
|
|
except Exception as e2:
|
|
print(f"基本方案也失败了: {str(e2)}")
|
|
|
|
if __name__ == "__main__":
|
|
app = ChromeManager()
|
|
app.run() |