（更新版本！）摸鱼必备：超级老板键：可以隐藏多个窗口！

skywalker0123

先声明：代码由本人编写，但是由于本人代码编写不太规范，为了方便理解，所以让AI添加注释并且修改函数名
介绍
超级老板键：可以隐藏窗口，一键恢复多个窗口，可以隐藏自身。如图，可以点左下角添加配置，可以添加多个老板键隐藏多个窗口。点击右边“捕获”可以自定义老板键，配置会保存在当前目录下。隐藏有三个选项，可以自己选择：隐藏老板键自身，隐藏最表层窗口和隐藏指定窗口（要写窗口标题）。配置好后点击”启动老板键“即可开始使用，有一键恢复窗口。
成品下载链接https://yanhe520.lanzoub.com/b0uma9hkj
密码:huuv                    
v3.2版本更新：https://yanhe520.lanzoub.com/b0umacogf
密码:14g4临时添加开机自启动测试（未经鲁棒性测试不知道稳不稳定）           各位还有什么想要的功能可以加分留言，加评分留言我会优先查看提供蓝奏云直接下载！
备注：因为我设置了无控制台（就是没有黑窗），所以360不知道为啥就报毒，各位不放心可以看看源码，或者自己反编译，spec也在附件中！，。以下内容便于检查人员反编译：python的打包版本："""E:\练手项目\项目3老板键>python --version
Python 3.10.8
pyinstaller版本E:\练手项目\项目3老板键>pyinstaller -v
6.14.2"""
问题修复等内容
如果遇到问题或者bug可以打开老板键所在目录，底下会有log.txt文件，将文件和你的问题或bug发给我，我看到会处理。如果有其他想要的功能也可以私信我哦！
源代码：v3.2（临时更新，添加开机自启动的选项！）

[Python] 纯文本查看 复制代码

import sys
import os

# ---------- 隐藏控制台黑窗（仅 Windows）----------
if sys.platform == "win32":
    import ctypes
    ctypes.windll.kernel32.FreeConsole()

import tkinter as tk
from tkinter import ttk, messagebox
import threading
import queue
import json
import logging
import winreg

# ---------- 依赖库 ----------
import pygetwindow as gw
import win32gui
import win32con
import win32event
import win32api
import winerror
from pynput import keyboard as pynput_keyboard

# ---------- 日志配置（追加模式）----------
LOG_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "log.txt")
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler(LOG_FILE, mode='a', encoding='utf-8')
    ]
)
logger = logging.getLogger(__name__)

CONFIG_FILE = "bosskey_config.json"
REG_PATH = r"Software\Microsoft\Windows\CurrentVersion\Run"
APP_NAME = "BossKeyApp"

# ---------- 进程互斥，防止多开 ----------
MUTEX_NAME = "Global\\BossKeyAppMutex"
mutex = win32event.CreateMutex(None, False, MUTEX_NAME)
if win32api.GetLastError() == winerror.ERROR_ALREADY_EXISTS:
    logger.warning("检测到已有实例运行，退出")
    sys.exit(0)


class BossKeyApp:
    def __init__(self, root, auto_start=False, autostart_mode=False):
        self.root = root
        self.root.title("老板键 v2.3")
        self.root.geometry("500x550")  # 增加高度容纳自启动复选框
        self.root.resizable(False, False)
        self.root.protocol("WM_DELETE_WINDOW", self.on_closing)

        self.auto_start = auto_start          # 以管理员提升后自动启动
        self.autostart_mode = autostart_mode  # 通过开机自启动运行

        # ---------- 功能启用状态 ----------
        self.enable_self = tk.BooleanVar(value=True)
        self.enable_topmost = tk.BooleanVar(value=True)
        self.enable_target = tk.BooleanVar(value=True)
        self.autostart_enabled = tk.BooleanVar(value=False)  # 开机自启动

        # ---------- 快捷键变量 ----------
        self.self_hotkey = tk.StringVar(value="ctrl+shift+f9")
        self.topmost_hotkey = tk.StringVar(value="ctrl+shift+f11")
        self.target_hotkey = tk.StringVar(value="ctrl+shift+f10")
        self.target_title = tk.StringVar(value="")

        # ---------- 状态 ----------
        self.hidden_target_hwnds = []
        self.hidden_topmost_hwnd = None
        self.active = False
        self.action_queue = queue.Queue()

        self.hotkey_listener = None

        self.load_config()
        self.build_ui()

        # 启动模式判断：管理员提升或自启动模式都自动启用老板键
        if self.auto_start or self.autostart_mode:
            self.root.after(500, self.auto_activate)

        self.process_queue()
        logger.info("程序启动（pynput 热键引擎）")

    # ---------------------- 快捷键格式转换 ----------------------
    @staticmethod
    def to_pynput_hotkey(user_hotkey):
        parts = user_hotkey.strip().lower().split('+')
        mapping = {
            'ctrl': '<ctrl>', 'control': '<ctrl>',
            'shift': '<shift>',
            'alt': '<alt>',
            'win': '<cmd>', 'windows': '<cmd>', 'cmd': '<cmd>'
        }
        converted = []
        for p in parts:
            p = p.strip()
            if p in mapping:
                converted.append(mapping[p])
            else:
                converted.append(f'<{p}>')
        return '+'.join(converted)

    # ---------------------- 自启动注册表操作 ----------------------
    def get_exe_path(self):
        """获取用于注册表启动的程序路径（带参数）"""
        if getattr(sys, 'frozen', False):
            exe = sys.executable
        else:
            exe = sys.executable
            script = os.path.abspath(sys.argv[0])
            # 如果脚本是 .py 文件，用 pythonw.exe 运行以避免黑窗（若存在）
            if script.endswith('.py'):
                pythonw = os.path.join(os.path.dirname(sys.executable), 'pythonw.exe')
                if os.path.exists(pythonw):
                    return f'"{pythonw}" "{script}"'
            return f'"{exe}" "{script}"'
        return f'"{exe}"'

    def set_autostart(self, enable):
        try:
            key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, REG_PATH, 0, winreg.KEY_SET_VALUE)
            if enable:
                # 构建命令行：程序路径 + --autostart
                cmd = self.get_exe_path() + ' --autostart'
                winreg.SetValueEx(key, APP_NAME, 0, winreg.REG_SZ, cmd)
                logger.info(f"已添加开机自启动: {cmd}")
            else:
                try:
                    winreg.DeleteValue(key, APP_NAME)
                    logger.info("已取消开机自启动")
                except FileNotFoundError:
                    pass
            winreg.CloseKey(key)
        except Exception as e:
            logger.error(f"设置自启动失败: {e}")

    def on_autostart_toggle(self):
        """复选框变化时调用"""
        self.set_autostart(self.autostart_enabled.get())
        self.save_config()

    # ---------------------- 界面构建 ----------------------
    def build_ui(self):
        ttk.Label(self.root, text="老板键设置", font=("微软雅黑", 12, "bold")).pack(pady=(10, 5))

        # ---------- 1. 隐藏自身窗口 ----------
        frame_self = ttk.LabelFrame(self.root, text="隐藏老板键程序自身")
        frame_self.pack(fill="x", padx=20, pady=4)
        ttk.Checkbutton(frame_self, text="启用", variable=self.enable_self).pack(side="left", padx=(10, 5))
        ttk.Entry(frame_self, textvariable=self.self_hotkey, width=20,
                  font=("Consolas", 10)).pack(side="left", padx=5, pady=8)
        ttk.Button(frame_self, text="捕获",
                   command=lambda: self.capture_hotkey(self.self_hotkey)).pack(side="left", padx=5)

        # ---------- 2. 隐藏最表层窗口 ----------
        frame_top = ttk.LabelFrame(self.root, text="隐藏最表层窗口（当前前台窗口）")
        frame_top.pack(fill="x", padx=20, pady=4)
        ttk.Checkbutton(frame_top, text="启用", variable=self.enable_topmost).pack(side="left", padx=(10, 5))
        ttk.Entry(frame_top, textvariable=self.topmost_hotkey, width=20,
                  font=("Consolas", 10)).pack(side="left", padx=5, pady=8)
        ttk.Button(frame_top, text="捕获",
                   command=lambda: self.capture_hotkey(self.topmost_hotkey)).pack(side="left", padx=5)

        # ---------- 3. 隐藏指定窗口（按标题）----------
        frame_target = ttk.LabelFrame(self.root, text="隐藏指定窗口（按标题关键字）")
        frame_target.pack(fill="x", padx=20, pady=4)

        row1 = ttk.Frame(frame_target)
        row1.pack(fill="x", padx=10, pady=4)
        ttk.Checkbutton(row1, text="启用", variable=self.enable_target).pack(side="left")
        ttk.Entry(row1, textvariable=self.target_hotkey, width=20,
                  font=("Consolas", 10)).pack(side="left", padx=5)
        ttk.Button(row1, text="捕获",
                   command=lambda: self.capture_hotkey(self.target_hotkey)).pack(side="left", padx=5)

        row2 = ttk.Frame(frame_target)
        row2.pack(fill="x", padx=10, pady=(0, 8))
        ttk.Label(row2, text="窗口标题关键字:").pack(side="left")
        ttk.Entry(row2, textvariable=self.target_title, width=28).pack(side="left", padx=5)

        # ---------- 控制按钮区 ----------
        btn_frame = ttk.Frame(self.root)
        btn_frame.pack(pady=12)

        self.start_btn = ttk.Button(btn_frame, text="启动老板键", command=self.start)
        self.start_btn.pack(side="left", padx=5)

        self.stop_btn = ttk.Button(btn_frame, text="停止老板键", command=self.stop, state="disabled")
        self.stop_btn.pack(side="left", padx=5)

        self.recover_all_btn = ttk.Button(btn_frame, text="一键恢复所有隐藏窗口", command=self.recover_all_windows)
        self.recover_all_btn.pack(side="left", padx=5)

        # 状态标签
        self.status_label = ttk.Label(self.root, text="状态：未启动", foreground="gray")
        self.status_label.pack(pady=(5, 5))

        # ---------- 开机自启动复选框（底部）----------
        autostart_frame = ttk.Frame(self.root)
        autostart_frame.pack(pady=(0, 10))
        ttk.Checkbutton(autostart_frame, text="开机自启动（启动后自动启用老板键）",
                        variable=self.autostart_enabled, command=self.on_autostart_toggle).pack()

    # ---------------------- 一键恢复所有隐藏窗口 ----------------------
    def recover_all_windows(self):
        recovered = 0
        if self.root.state() == "withdrawn":
            self.root.deiconify()
            self.root.lift()
            self.root.focus_force()
            recovered += 1
            logger.info("一键恢复：自身窗口已显示")

        if self.hidden_topmost_hwnd and win32gui.IsWindow(self.hidden_topmost_hwnd):
            win32gui.ShowWindow(self.hidden_topmost_hwnd, win32con.SW_SHOW)
            recovered += 1
            logger.info("一键恢复：最表层窗口已恢复")
        self.hidden_topmost_hwnd = None

        for hwnd in self.hidden_target_hwnds:
            if win32gui.IsWindow(hwnd):
                win32gui.ShowWindow(hwnd, win32con.SW_SHOW)
                recovered += 1
        self.hidden_target_hwnds.clear()

        if recovered > 0:
            self.action_queue.put(("status", f"一键恢复完成，共恢复 {recovered} 个窗口"))
        else:
            self.action_queue.put(("status", "没有需要恢复的隐藏窗口"))

    # ---------------------- 权限工具 ----------------------
    @staticmethod
    def is_admin():
        try:
            return ctypes.windll.shell32.IsUserAnAdmin()
        except:
            return False

    @staticmethod
    def run_as_admin():
        try:
            if getattr(sys, 'frozen', False):
                ctypes.windll.shell32.ShellExecuteW(None, "runas", sys.executable, '--elevated', None, 1)
            else:
                script = sys.argv[0]
                params = f'"{script}" --elevated'
                ctypes.windll.shell32.ShellExecuteW(None, "runas", sys.executable, params, None, 1)
        except Exception as e:
            logger.error(f"请求管理员权限失败: {e}")

    def auto_activate(self):
        """自启动或提权后自动启用老板键并隐藏窗口"""
        logger.info("自动启动老板键（自启动或管理员模式）")
        self.start()
        if self.active:
            self.root.withdraw()
            logger.info("窗口已隐藏，后台监听热键")

    # ---------------------- 核心功能 ----------------------
    def toggle_self_window(self):
        if self.root.state() == "withdrawn":
            self.root.deiconify()
            self.root.lift()
            self.root.focus_force()
            logger.info("自身窗口已显示")
        else:
            self.root.withdraw()
            logger.info("自身窗口已隐藏")

    def toggle_topmost_window(self):
        if self.hidden_topmost_hwnd and win32gui.IsWindow(self.hidden_topmost_hwnd):
            win32gui.ShowWindow(self.hidden_topmost_hwnd, win32con.SW_SHOW)
            title = win32gui.GetWindowText(self.hidden_topmost_hwnd)
            self.action_queue.put(("status", f"已恢复窗口：{title}"))
            logger.info(f"恢复最表层窗口：{title}")
            self.hidden_topmost_hwnd = None
        else:
            hwnd = win32gui.GetForegroundWindow()
            if hwnd:
                title = win32gui.GetWindowText(hwnd)
                if hwnd == self.root.winfo_id():
                    self.action_queue.put(("status", "不能隐藏自身窗口，请使用自身隐藏键"))
                    return
                win32gui.ShowWindow(hwnd, win32con.SW_HIDE)
                self.hidden_topmost_hwnd = hwnd
                self.action_queue.put(("status", f"已隐藏窗口：{title}"))
                logger.info(f"隐藏最表层窗口：{title}")
            else:
                self.action_queue.put(("status", "未找到前台窗口"))

    def toggle_target_windows(self):
        if self.hidden_target_hwnds:
            restored = 0
            for hwnd in self.hidden_target_hwnds:
                if win32gui.IsWindow(hwnd):
                    win32gui.ShowWindow(hwnd, win32con.SW_SHOW)
                    restored += 1
            self.hidden_target_hwnds.clear()
            self.action_queue.put(("status", f"已显示 {restored} 个窗口"))
            logger.info(f"目标窗口已恢复显示，数量: {restored}")
        else:
            title = self.target_title.get().strip()
            if not title:
                self.action_queue.put(("status", "请先填写目标窗口标题关键字！"))
                logger.warning("尝试隐藏目标窗口，但未填写关键字")
                return
            matches = gw.getWindowsWithTitle(title)
            if not matches:
                self.action_queue.put(("status", f"未找到包含 '{title}' 的窗口"))
                logger.info(f"未找到匹配窗口: {title}")
                return
            hidden_count = 0
            for win in matches:
                if win.visible:
                    win.hide()
                    self.hidden_target_hwnds.append(win._hWnd)
                    hidden_count += 1
            if hidden_count:
                self.action_queue.put(("status", f"已隐藏 {hidden_count} 个窗口"))
                logger.info(f"隐藏目标窗口: {title}，数量: {hidden_count}")
            else:
                self.action_queue.put(("status", "没有可见的匹配窗口需要隐藏"))
                logger.info(f"没有可见的匹配窗口: {title}")

    # ---------------------- pynput 热键注册 ----------------------
    def _start_hotkeys(self):
        try:
            if self.hotkey_listener:
                self.hotkey_listener.stop()
                self.hotkey_listener = None

            hotkey_map = {}
            if self.enable_self.get() and self.self_hotkey.get().strip():
                pynput_hk = self.to_pynput_hotkey(self.self_hotkey.get().strip())
                hotkey_map[pynput_hk] = lambda: self.action_queue.put(("toggle_self",))
                logger.info(f"注册自身热键: {self.self_hotkey.get()}  ->  {pynput_hk}")
            if self.enable_topmost.get() and self.topmost_hotkey.get().strip():
                pynput_hk = self.to_pynput_hotkey(self.topmost_hotkey.get().strip())
                hotkey_map[pynput_hk] = lambda: self.action_queue.put(("toggle_topmost",))
                logger.info(f"注册最表层热键: {self.topmost_hotkey.get()}  ->  {pynput_hk}")
            if self.enable_target.get() and self.target_hotkey.get().strip():
                pynput_hk = self.to_pynput_hotkey(self.target_hotkey.get().strip())
                hotkey_map[pynput_hk] = lambda: self.action_queue.put(("toggle_target",))
                logger.info(f"注册目标窗口热键: {self.target_hotkey.get()}  ->  {pynput_hk}")

            if not hotkey_map:
                return False

            self.hotkey_listener = pynput_keyboard.GlobalHotKeys(hotkey_map)
            self.hotkey_listener.start()
            return True
        except Exception as e:
            logger.error(f"注册热键失败: {e}")
            return False

    def _stop_hotkeys(self):
        if self.hotkey_listener:
            self.hotkey_listener.stop()
            self.hotkey_listener = None
        if self.hidden_topmost_hwnd and win32gui.IsWindow(self.hidden_topmost_hwnd):
            win32gui.ShowWindow(self.hidden_topmost_hwnd, win32con.SW_SHOW)
        self.hidden_topmost_hwnd = None
        for hwnd in self.hidden_target_hwnds:
            if win32gui.IsWindow(hwnd):
                win32gui.ShowWindow(hwnd, win32con.SW_SHOW)
        self.hidden_target_hwnds.clear()
        if self.root.state() == "withdrawn":
            self.root.deiconify()
        self.active = False
        self.start_btn.config(state="normal")
        self.stop_btn.config(state="disabled")
        self.status_label.config(text="状态：已停止")
        logger.info("老板键已停止")

    def start(self):
        any_enabled = False
        if self.enable_self.get() and self.self_hotkey.get().strip():
            any_enabled = True
        if self.enable_topmost.get() and self.topmost_hotkey.get().strip():
            any_enabled = True
        if self.enable_target.get() and self.target_hotkey.get().strip():
            any_enabled = True

        if not any_enabled:
            messagebox.showwarning("提示", "请至少启用一项功能并设置快捷键！")
            return

        if not self.is_admin():
            if not messagebox.askyesno("权限提示",
                                       "pynput 热键通常无需管理员权限，是否继续启动？"):
                return

        if self._start_hotkeys():
            self.active = True
            self.start_btn.config(state="disabled")
            self.stop_btn.config(state="normal")
            self.status_label.config(text="状态：已启动（老板键生效）")
            self.save_config()
            logger.info("老板键已启动")
        else:
            if not self.is_admin():
                if messagebox.askyesno("热键注册失败",
                                       "全局热键注册失败。是否尝试以管理员身份重新启动？"):
                    self.save_config()
                    self.run_as_admin()
                    self.root.destroy()
                    sys.exit(0)
                else:
                    messagebox.showinfo("取消", "老板键未启动。")
            else:
                messagebox.showerror("错误", "热键注册失败，请检查快捷键是否被占用。")

    def stop(self):
        self.action_queue.put(("stop",))
        self.status_label.config(text="状态：已停止")

    def on_closing(self):
        if self.active:
            self._stop_hotkeys()
        logger.info("程序退出")
        self.root.destroy()

    # ---------------------- 快捷键捕获 ----------------------
    def capture_hotkey(self, var):
        def _capture():
            try:
                self.action_queue.put(("status", "请按下组合键（如 Ctrl+Shift+F9）..."))
                from pynput.keyboard import Key, KeyCode, Listener
                pressed = set()
                captured_combo = None
                combo_lock = threading.Lock()

                def on_press(key):
                    nonlocal captured_combo
                    pressed.add(key)
                    modifiers = {Key.ctrl, Key.ctrl_l, Key.ctrl_r,
                                 Key.shift, Key.shift_l, Key.shift_r,
                                 Key.alt, Key.alt_l, Key.alt_r,
                                 Key.cmd, Key.cmd_l, Key.cmd_r}
                    has_mod = bool(pressed & modifiers)
                    has_normal = any(isinstance(k, KeyCode) for k in pressed)
                    if has_mod and has_normal:
                        with combo_lock:
                            if captured_combo is None:
                                captured_combo = pressed.copy()
                                return False

                listener = Listener(on_press=on_press)
                listener.start()
                listener.join()

                if captured_combo:
                    parts = []
                    for key in captured_combo:
                        if key in (Key.ctrl, Key.ctrl_l, Key.ctrl_r):
                            parts.append('ctrl')
                        elif key in (Key.shift, Key.shift_l, Key.shift_r):
                            parts.append('shift')
                        elif key in (Key.alt, Key.alt_l, Key.alt_r):
                            parts.append('alt')
                        elif key in (Key.cmd, Key.cmd_l, Key.cmd_r):
                            parts.append('win')
                        elif isinstance(key, KeyCode):
                            if key.char:
                                parts.append(key.char)
                            else:
                                parts.append(key.name)
                        elif isinstance(key, Key):
                            name = key.name
                            if name and (name.startswith('f') and name[1:].isdigit()):
                                parts.append(name)
                            else:
                                parts.append(name)
                    order = ['ctrl', 'shift', 'alt', 'win']
                    mods = [p for p in parts if p in order]
                    keys = [p for p in parts if p not in order]
                    mods.sort(key=lambda x: order.index(x))
                    hotkey_str = '+'.join(mods + keys)
                else:
                    hotkey_str = var.get()

                self.action_queue.put(("update_hotkey", var, hotkey_str))
                logger.info(f"捕获快捷键: {hotkey_str}")
            except Exception as e:
                self.action_queue.put(("status", f"捕获失败: {e}"))
                logger.error(f"捕获快捷键失败: {e}")

        threading.Thread(target=_capture, daemon=True).start()

    # ---------------------- 队列处理 ----------------------
    def process_queue(self):
        try:
            while True:
                cmd = self.action_queue.get_nowait()
                if cmd[0] == "status":
                    self.status_label.config(text=cmd[1])
                elif cmd[0] == "update_hotkey":
                    _, var, value = cmd
                    var.set(value)
                elif cmd[0] == "toggle_self":
                    self.toggle_self_window()
                elif cmd[0] == "toggle_topmost":
                    self.toggle_topmost_window()
                elif cmd[0] == "toggle_target":
                    self.toggle_target_windows()
                elif cmd[0] == "stop":
                    self._stop_hotkeys()
        except queue.Empty:
            pass
        self.root.after(100, self.process_queue)

    # ---------------------- 配置持久化 ----------------------
    def save_config(self):
        data = {
            "enable_self": self.enable_self.get(),
            "enable_topmost": self.enable_topmost.get(),
            "enable_target": self.enable_target.get(),
            "autostart_enabled": self.autostart_enabled.get(),
            "self_hotkey": self.self_hotkey.get(),
            "topmost_hotkey": self.topmost_hotkey.get(),
            "target_hotkey": self.target_hotkey.get(),
            "target_title": self.target_title.get()
        }
        try:
            with open(CONFIG_FILE, "w", encoding="utf-8") as f:
                json.dump(data, f, ensure_ascii=False, indent=2)
            logger.debug("配置文件已保存")
        except Exception as e:
            logger.error(f"保存配置失败: {e}")

    def load_config(self):
        if os.path.exists(CONFIG_FILE):
            try:
                with open(CONFIG_FILE, "r", encoding="utf-8") as f:
                    data = json.load(f)
                self.enable_self.set(data.get("enable_self", True))
                self.enable_topmost.set(data.get("enable_topmost", True))
                self.enable_target.set(data.get("enable_target", True))
                self.autostart_enabled.set(data.get("autostart_enabled", False))
                self.self_hotkey.set(data.get("self_hotkey", "ctrl+shift+f9"))
                self.topmost_hotkey.set(data.get("topmost_hotkey", "ctrl+shift+f11"))
                self.target_hotkey.set(data.get("target_hotkey", "ctrl+shift+f10"))
                self.target_title.set(data.get("target_title", ""))
                # 根据配置同步注册表（防止手动删除注册表项而配置仍为True）
                if self.autostart_enabled.get():
                    self.set_autostart(True)
                else:
                    self.set_autostart(False)
                logger.info("已加载历史配置")
            except Exception as e:
                logger.error(f"加载配置失败: {e}")


# ---------------------- 主入口 ----------------------
if __name__ == "__main__":
    # 检测命令行参数
    auto_elevated = "--elevated" in sys.argv
    auto_autostart = "--autostart" in sys.argv
    root = tk.Tk()
    app = BossKeyApp(root, auto_start=auto_elevated, autostart_mode=auto_autostart)
    root.mainloop()

skywalker0123

q5236900 发表于 2026-6-17 08:10
下载试了使用了，挺好，如果可以开机自启动就好了。不然有时候 每次都得重启后 重新设置吧？

这个可以手动添加，如果开机自启动杀毒软件易报毒，下个版本我会更新自选该功能

SPU

看代码感觉会出现自动隐藏后无法打开主界面的问题

skywalker0123

jay2002zl 发表于 2026-6-17 22:15
楼主能尽快更新吗？我很需要用这个软件，开机自动启动 隐藏这个功能很好

已经更新添加开机自启动模式，但还未经完整测试，不保证稳定，你可以尝试用用，有bug向我反馈，如果可以给我添加评分！谢谢。

skywalker0123

SPU 发表于 2026-6-16 18:06
看代码感觉会出现自动隐藏后无法打开主界面的问题

？能详细说说吗

WORSONG178

现在不是都是屏幕监控了吗？真的还有用？

jituidadada

老板也逛论坛，看到后给你疯狂点赞~

woainono84

能适用于屏幕监控吗

zjtzjt

我爱摸鱼，摸鱼使我快乐

q5236900

下载试了使用了，挺好，如果可以开机自启动就好了。不然有时候 每次都得重启后 重新设置吧？

38342175

之前的是只能隐藏一个窗口，这个可以同时隐藏多个，不错

iawyxkdn8

自己用PY写了一个，能隐藏所有打开的窗口，打开指定的文件或路径，第二次按设定的快捷键的时候，能再切换回来。开机自动启动。

[Python] 纯文本查看 复制代码

# -*- coding: utf-8 -*-

import os
import sys
import ctypes
import json
import queue
import threading
import traceback
import time
import functools
import subprocess
from datetime import datetime
import winreg

def global_exception_handler(exc_type, exc_value, exc_tb):
    error_msg = f"程序崩溃异常:\n类型: {exc_type}\n值: {exc_value}\n堆栈: {''.join(traceback.format_tb(exc_tb))}"
    
    error_log_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), "crash_log.txt")
    try:
        with open(error_log_file, 'a', encoding='utf-8') as f:
            f.write(f"\n{'='*60}\n")
            f.write(f"时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
            f.write(error_msg)
            f.write(f"\n{'='*60}\n")
    except:
        pass
    
    sys.__excepthook__(exc_type, exc_value, exc_tb)

sys.excepthook = global_exception_handler

if sys.platform == "win32":
    try:
        ctypes.windll.kernel32.FreeConsole()
    except:
        pass

def install_dependencies():
    required_packages = {
        'keyboard': 'keyboard',
        'pygetwindow': 'pygetwindow',
        'pywin32': 'win32gui',
        'tkinter': 'tkinter'
    }
    
    missing_packages = []
    for package, import_name in required_packages.items():
        try:
            if package == 'tkinter':
                import tkinter
            else:
                __import__(import_name if import_name != 'win32gui' else 'win32gui')
        except ImportError:
            if package not in ['tkinter']:
                missing_packages.append(package)
    
    if missing_packages:
        try:
            import subprocess
            for package in missing_packages:
                subprocess.check_call([
                    sys.executable, "-m", "pip", "install", 
                    "-i", "https://pypi.tuna.tsinghua.edu.cn/simple",
                    package
                ])
            try:
                import tkinter.messagebox as msgbox
                msgbox.showinfo("依赖安装完成", "依赖安装完成，请重新运行程序")
            except:
                pass
            sys.exit(0)
        except Exception as e:
            print(f"依赖安装失败: {e}")
            sys.exit(1)

try:
    install_dependencies()
except:
    pass

try:
    import tkinter as tk
    from tkinter import ttk, messagebox, filedialog
    import keyboard
    import pygetwindow as gw
    import win32gui
    import win32con
    import win32event
    import win32api
    import winerror
except Exception as e:
    print(f"导入依赖库失败: {e}")
    sys.exit(1)

CONFIG_FILE = "bosskey_config.json"

def safe_is_window(hwnd):
    if hwnd is None:
        return False
    try:
        return win32gui.IsWindow(hwnd)
    except:
        return False

def safe_get_window_text(hwnd):
    try:
        if safe_is_window(hwnd):
            return win32gui.GetWindowText(hwnd)
    except:
        pass
    return ""

def safe_show_window(hwnd, show_cmd):
    try:
        if safe_is_window(hwnd):
            win32gui.ShowWindow(hwnd, show_cmd)
            return True
    except:
        pass
    return False

def safe_get_foreground_window():
    try:
        hwnd = win32gui.GetForegroundWindow()
        if safe_is_window(hwnd):
            return hwnd
    except:
        pass
    return None

def get_all_visible_windows():
    windows = []
    try:
        def callback(hwnd, extra):
            if win32gui.IsWindowVisible(hwnd):
                title = win32gui.GetWindowText(hwnd)
                if title and not title.startswith('Default'):
                    windows.append((hwnd, title))
            return True
        win32gui.EnumWindows(callback, None)
    except:
        pass
    return windows

def hide_all_except_target(target_path, exclude_hwnds=None):
    if exclude_hwnds is None:
        exclude_hwnds = []
    
    hidden = []
    try:
        windows = get_all_visible_windows()
        for hwnd, title in windows:
            try:
                if hwnd in exclude_hwnds:
                    continue
                if '任务栏' in title or 'Start' in title or 'Taskbar' in title:
                    continue
                if 'Program Manager' in title or '桌面' in title:
                    continue
                if target_path:
                    target_name = os.path.basename(target_path)
                    if target_name and target_name in title:
                        continue
                
                win32gui.ShowWindow(hwnd, win32con.SW_HIDE)
                hidden.append((hwnd, title))
            except:
                pass
    except:
        pass
    return hidden

def restore_all_windows(hidden_windows):
    restored = 0
    for hwnd, title in hidden_windows:
        try:
            if safe_is_window(hwnd):
                win32gui.ShowWindow(hwnd, win32con.SW_SHOW)
                restored += 1
        except:
            pass
    return restored

def open_target_path(path):
    try:
        if os.path.exists(path):
            os.startfile(path)
            return True, f"已打开: {os.path.basename(path)}"
        else:
            return False, f"路径不存在: {path}"
    except Exception as e:
        return False, f"打开失败: {str(e)}"

def set_auto_start():
    try:
        key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, 
                            r"Software\Microsoft\Windows\CurrentVersion\Run", 
                            0, winreg.KEY_SET_VALUE)
        exe_path = sys.executable if getattr(sys, 'frozen', False) else sys.argv[0]
        winreg.SetValueEx(key, "BossKey", 0, winreg.REG_SZ, f'"{exe_path}" --elevated')
        winreg.CloseKey(key)
        return True
    except:
        return False

def remove_auto_start():
    try:
        key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, 
                            r"Software\Microsoft\Windows\CurrentVersion\Run", 
                            0, winreg.KEY_SET_VALUE)
        winreg.DeleteValue(key, "BossKey")
        winreg.CloseKey(key)
        return True
    except:
        return False

def check_auto_start():
    try:
        key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, 
                            r"Software\Microsoft\Windows\CurrentVersion\Run", 
                            0, winreg.KEY_READ)
        value, _ = winreg.QueryValueEx(key, "BossKey")
        winreg.CloseKey(key)
        return True
    except:
        return False

try:
    MUTEX_NAME = "Global\\BossKeyAppMutex"
    mutex = win32event.CreateMutex(None, False, MUTEX_NAME)
    if win32api.GetLastError() == winerror.ERROR_ALREADY_EXISTS:
        sys.exit(0)
except:
    pass

class HideConfigItem:
    HIDE_ALL = "hideall"
    OPEN_TARGET = "opentarget"

    TYPE_MAP = {
        HIDE_ALL: "专注模式（隐藏所有，打开目标）",
        OPEN_TARGET: "仅打开目标"
    }
    REVERSE_MAP = {v: k for k, v in TYPE_MAP.items()}

    def __init__(self, enable=True, hide_type=HIDE_ALL, hotkey="", target_path=""):
        try:
            self.enable = tk.BooleanVar(value=enable)
            self.hide_type = tk.StringVar(value=hide_type)
            self.hotkey = tk.StringVar(value=hotkey)
            self.target_path = tk.StringVar(value=target_path)
            
            self.type_display = tk.StringVar(value=self.TYPE_MAP.get(hide_type, "专注模式"))
            self.type_display.trace("w", self._sync_hide_type)
            
            self.hidden_windows = []
            self.is_hidden = False
            self.target_opened = False
            self.lock = threading.Lock()
        except:
            pass

    def _sync_hide_type(self, *args):
        try:
            eng = self.REVERSE_MAP.get(self.type_display.get(), self.HIDE_ALL)
            if self.hide_type.get() != eng:
                self.hide_type.set(eng)
        except:
            pass

    def to_dict(self):
        try:
            return {
                "enable": self.enable.get(),
                "type": self.hide_type.get(),
                "hotkey": self.hotkey.get(),
                "target_path": self.target_path.get()
            }
        except:
            return {}

    @classmethod
    def from_dict(cls, data):
        try:
            return cls(
                enable=data.get("enable", True),
                hide_type=data.get("type", cls.HIDE_ALL),
                hotkey=data.get("hotkey", ""),
                target_path=data.get("target_path", "")
            )
        except:
            return cls()

class BossKeyApp:
    def __init__(self, root, auto_start=False):
        try:
            self.root = root
            self.root.title("老板键 V26.06.16 制作：洪强盛15980027880")
            self.root.geometry("700x450")
            self.root.resizable(True, True)
            
            self.root.protocol("WM_DELETE_WINDOW", self.safe_close)
            
            self._closing = False
            self._root_exists = True
            
            self.auto_start = auto_start
            self.config_items = []
            self.config_frames = []
            self.active = False
            self.action_queue = queue.Queue()
            self.registered_hotkeys = {}
            self.running = True
            
            self.all_hidden_windows = []
            self.self_hidden = False
            self.auto_start_enabled = check_auto_start()

            self.load_config()
            self.build_ui()

            if self.auto_start:
                self.root.after(500, self.auto_elevated_start)

            self.process_queue()
            
        except:
            pass

    def safe_close(self):
        if self._closing:
            return
        self._closing = True
        
        try:
            self.running = False
            if self.active:
                self._stop_hotkeys()
            
            self.restore_all_global_windows()
            
            try:
                if self.self_hidden:
                    self.root.deiconify()
                    self.self_hidden = False
            except:
                pass
            
            self._root_exists = False
            try:
                self.root.destroy()
            except:
                pass
        except:
            pass
        finally:
            sys.exit(0)

    def restore_all_global_windows(self):
        try:
            restored = 0
            for hwnd, title in self.all_hidden_windows:
                if safe_show_window(hwnd, win32con.SW_SHOW):
                    restored += 1
            self.all_hidden_windows.clear()
        except:
            pass

    def build_ui(self):
        try:
            title_frame = ttk.Frame(self.root)
            title_frame.pack(fill="x", padx=20, pady=(10, 5))
            
            ttk.Label(title_frame, text="老板键", 
                     font=("微软雅黑", 14, "bold")).pack(side="left")
            
            ttk.Label(title_frame, text="一键隐藏所有窗口，只留目标文件/文件夹", 
                     font=("微软雅黑", 9), foreground="gray").pack(side="left", padx=10)

            container = ttk.Frame(self.root)
            container.pack(fill="both", expand=True, padx=20, pady=4)

            canvas = tk.Canvas(container, borderwidth=0, highlightthickness=0)
            scrollbar = ttk.Scrollbar(container, orient="vertical", command=canvas.yview)
            self.config_list_frame = ttk.Frame(canvas)

            self.config_list_frame.bind("<Configure>",
                lambda e: canvas.configure(scrollregion=canvas.bbox("all")))

            canvas.create_window((0, 0), window=self.config_list_frame, anchor="nw")
            canvas.configure(yscrollcommand=scrollbar.set)

            canvas.pack(side="left", fill="both", expand=True)
            scrollbar.pack(side="right", fill="y")

            for item in self.config_items:
                self._add_config_row(item)

            if not self.config_items:
                default_item = HideConfigItem(
                    hide_type=HideConfigItem.HIDE_ALL, 
                    hotkey="ctrl+enter",
                    target_path=""
                )
                self.config_items.append(default_item)
                self._add_config_row(default_item)

            bottom_frame = ttk.Frame(self.root)
            bottom_frame.pack(pady=(8, 5), fill="x", padx=20)

            btn_frame = ttk.Frame(bottom_frame)
            btn_frame.pack()

            ttk.Button(btn_frame, text="添加配置", command=self.add_config_item).pack(side="left", padx=3)
            self.start_btn = ttk.Button(btn_frame, text="启动老板键", command=self.start)
            self.start_btn.pack(side="left", padx=3)
            self.stop_btn = ttk.Button(btn_frame, text="停止老板键", command=self.stop, state="disabled")
            self.stop_btn.pack(side="left", padx=3)
            ttk.Button(btn_frame, text="恢复所有窗口", command=self.restore_all_windows_ui).pack(side="left", padx=3)
            
            self.auto_start_btn = ttk.Button(btn_frame, text="开机自启", command=self.toggle_auto_start)
            self.auto_start_btn.pack(side="left", padx=3)
            self.update_auto_start_btn()

            status_frame = ttk.Frame(self.root)
            status_frame.pack(fill="x", padx=20, pady=(5, 10))
            
            self.status_label = ttk.Label(status_frame, text="状态：未启动", foreground="gray")
            self.status_label.pack(side="left")
            
        except:
            pass

    def update_auto_start_btn(self):
        try:
            if self.auto_start_enabled:
                self.auto_start_btn.config(text="&#10003; 开机自启", foreground="green")
            else:
                self.auto_start_btn.config(text="开机自启", foreground="black")
        except:
            pass

    def toggle_auto_start(self):
        try:
            if self.auto_start_enabled:
                if remove_auto_start():
                    self.auto_start_enabled = False
                    self.update_auto_start_btn()
                    self.update_status("已取消开机自启")
                    messagebox.showinfo("提示", "已取消开机自启")
                else:
                    messagebox.showerror("错误", "取消开机自启失败，请以管理员身份运行")
            else:
                if set_auto_start():
                    self.auto_start_enabled = True
                    self.update_auto_start_btn()
                    self.update_status("已设置开机自启")
                    messagebox.showinfo("提示", "已设置开机自启")
                else:
                    messagebox.showerror("错误", "设置开机自启失败，请以管理员身份运行")
        except:
            pass

    def restore_all_windows_ui(self):
        try:
            for item in self.config_items:
                item.is_hidden = False
                item.hidden_windows.clear()
                item.target_opened = False
            
            self.restore_all_global_windows()
            
            if self.self_hidden:
                try:
                    self.root.deiconify()
                    self.self_hidden = False
                except:
                    pass
            
            self.update_status("已恢复所有窗口")
        except:
            pass

    def _add_config_row(self, item):
        try:
            if not self._root_exists:
                return
                
            frame = ttk.Frame(self.config_list_frame, relief="ridge", borderwidth=1)
            frame.pack(fill="x", pady=3, padx=2)

            row1 = ttk.Frame(frame)
            row1.pack(fill="x", pady=2)
            
            ttk.Checkbutton(row1, variable=item.enable).pack(side="left", padx=(5, 2))

            type_combo = ttk.Combobox(row1, textvariable=item.type_display,
                                     values=["专注模式（隐藏所有，打开目标）", "仅打开目标"],
                                     state="readonly", width=28)
            type_combo.pack(side="left", padx=2)

            ttk.Label(row1, text="快捷键:").pack(side="left", padx=(5, 2))
            hotkey_entry = ttk.Entry(row1, textvariable=item.hotkey, width=18, font=("Consolas", 10))
            hotkey_entry.pack(side="left", padx=2)

            ttk.Button(row1, text="捕获",
                      command=lambda it=item: self.capture_hotkey(it.hotkey)).pack(side="left", padx=2)

            status_label = ttk.Label(row1, text="○", foreground="gray")
            status_label.pack(side="left", padx=5)
            item._status_label = status_label

            ttk.Button(row1, text="删除",
                      command=lambda f=frame, it=item: self.delete_config_item(f, it)).pack(side="right", padx=5)

            row2 = ttk.Frame(frame)
            row2.pack(fill="x", pady=2)
            
            path_label = ttk.Label(row2, text="目标路径:")
            path_label.pack(side="left", padx=(10, 2))
            path_entry = ttk.Entry(row2, textvariable=item.target_path, width=45)
            path_entry.pack(side="left", padx=2)
            
            ttk.Button(row2, text="浏览文件", 
                      command=lambda it=item: self.browse_file(it)).pack(side="left", padx=2)
            ttk.Button(row2, text="浏览文件夹", 
                      command=lambda it=item: self.browse_folder(it)).pack(side="left", padx=2)

            self.config_frames.append(frame)
        except:
            pass

    def browse_file(self, item):
        try:
            file_path = filedialog.askopenfilename(
                title="选择文件",
                filetypes=[("所有文件", "*.*"), ("可执行文件", "*.exe")]
            )
            if file_path:
                item.target_path.set(file_path)
        except:
            pass

    def browse_folder(self, item):
        try:
            folder_path = filedialog.askdirectory(title="选择文件夹")
            if folder_path:
                item.target_path.set(folder_path)
        except:
            pass

    def add_config_item(self):
        try:
            if not self._root_exists:
                return
            new_item = HideConfigItem(hide_type=HideConfigItem.HIDE_ALL, hotkey="")
            self.config_items.append(new_item)
            self._add_config_row(new_item)
        except:
            pass

    def delete_config_item(self, frame, item):
        try:
            if len(self.config_items) <= 1:
                messagebox.showinfo("提示", "至少保留一个配置项")
                return
            if self.active:
                messagebox.showwarning("提示", "请先停止老板键")
                return

            self.config_items.remove(item)
            frame.destroy()
            self.config_frames.remove(frame)
        except:
            pass

    def update_status(self, text):
        try:
            if self._root_exists:
                self.status_label.config(text=f"状态：{text}")
        except:
            pass

    def start(self):
        if self.active:
            return

        valid = any(item.enable.get() and item.hotkey.get().strip() for item in self.config_items)
        if not valid:
            messagebox.showwarning("提示", "请至少启用一个配置项并设置快捷键！")
            return

        if self._start_hotkeys():
            self.active = True
            self.start_btn.config(state="disabled")
            self.stop_btn.config(state="normal")
            self.update_status("已启动")
            self.save_config()
            
            hk_list = "\n".join([f"  {hk} -> {item.type_display.get()}" 
                                for hk, item in self.registered_hotkeys.items()])
            messagebox.showinfo("启动成功", f"老板键已启动！\n\n已注册热键：\n{hk_list}")
        else:
            messagebox.showerror("错误", "热键注册失败！")

    def stop(self):
        try:
            self.action_queue.put(("stop",))
            self.update_status("已停止")
        except:
            pass

    def _start_hotkeys(self):
        try:
            registered = {}
            success_count = 0
            
            for item in self.config_items:
                if not item.enable.get():
                    continue
                hk = item.hotkey.get().strip()
                if not hk:
                    continue
                
                try:
                    try:
                        keyboard.remove_hotkey(hk)
                    except:
                        pass
                    
                    keyboard.add_hotkey(hk, functools.partial(self._hotkey_callback, item))
                    registered[hk] = item
                    success_count += 1
                except:
                    pass
            
            self.registered_hotkeys = registered
            return success_count > 0
                
        except:
            return False

    def _hotkey_callback(self, item):
        try:
            if self.running and self.active:
                self.action_queue.put(("toggle_item", item))
        except:
            pass

    def _stop_hotkeys(self):
        try:
            for hk in list(self.registered_hotkeys.keys()):
                try:
                    keyboard.remove_hotkey(hk)
                except:
                    pass
            
            self.registered_hotkeys.clear()
            
            self.restore_all_global_windows()
            for item in self.config_items:
                item.is_hidden = False
                item.hidden_windows.clear()
                item.target_opened = False
            
            self.active = False
            self.start_btn.config(state="normal")
            self.stop_btn.config(state="disabled")
        except:
            pass

    def toggle_by_item(self, item):
        try:
            if not self.running or not self.active:
                return
                
            t = item.hide_type.get()
            
            if t == HideConfigItem.HIDE_ALL:
                self._focus_mode(item)
            elif t == HideConfigItem.OPEN_TARGET:
                self._open_target_only(item)
        except:
            pass

    def _focus_mode(self, item):
        try:
            with item.lock:
                if item.is_hidden:
                    restored = restore_all_windows(item.hidden_windows)
                    item.hidden_windows.clear()
                    item.is_hidden = False
                    item.target_opened = False
                    
                    if self.self_hidden:
                        try:
                            self.root.deiconify()
                            self.self_hidden = False
                        except:
                            pass
                    
                    self.update_status(f"已恢复 {restored} 个窗口")
                    if hasattr(item, '_status_label'):
                        item._status_label.config(text="○", foreground="gray")
                else:
                    target_path = item.target_path.get().strip()
                    if not target_path:
                        self.update_status("请设置目标路径")
                        messagebox.showwarning("提示", "请先设置要打开的目标路径！")
                        return
                    
                    if not os.path.exists(target_path):
                        self.update_status("目标路径不存在")
                        messagebox.showerror("错误", f"目标路径不存在:\n{target_path}")
                        return
                    
                    if not self.self_hidden:
                        try:
                            self.root.withdraw()
                            self.self_hidden = True
                        except:
                            pass
                    
                    exclude_hwnds = []
                    try:
                        exclude_hwnds.append(int(self.root.winfo_id()))
                    except:
                        pass
                    
                    if not item.target_opened:
                        success, msg = open_target_path(target_path)
                        if success:
                            item.target_opened = True
                            time.sleep(0.3)
                    
                    hidden = hide_all_except_target(target_path, exclude_hwnds)
                    
                    item.hidden_windows = hidden
                    item.is_hidden = True
                    
                    self.all_hidden_windows.extend(hidden)
                    
                    if item.target_opened:
                        target_name = os.path.basename(target_path)
                        self.update_status(f"已隐藏 {len(hidden)} 个窗口，已打开 {target_name}")
                    else:
                        self.update_status(f"已隐藏 {len(hidden)} 个窗口")
                    
                    if hasattr(item, '_status_label'):
                        item._status_label.config(text="●", foreground="red")
        except:
            pass

    def _open_target_only(self, item):
        try:
            target_path = item.target_path.get().strip()
            if not target_path:
                self.update_status("请设置目标路径")
                messagebox.showwarning("提示", "请先设置要打开的目标路径！")
                return
            
            if not os.path.exists(target_path):
                self.update_status("目标路径不存在")
                messagebox.showerror("错误", f"目标路径不存在:\n{target_path}")
                return
            
            success, msg = open_target_path(target_path)
            self.update_status(msg)
            if success:
                messagebox.showinfo("成功", msg)
            else:
                messagebox.showerror("错误", msg)
        except:
            pass

    def capture_hotkey(self, var):
        def _capture():
            try:
                self.update_status("请按下组合键...")
                hotkey_str = keyboard.read_hotkey(suppress=False)
                if self.running:
                    var.set(hotkey_str)
                    self.update_status(f"已捕获: {hotkey_str}")
            except:
                pass
        
        threading.Thread(target=_capture, daemon=True).start()

    def process_queue(self):
        try:
            while True:
                try:
                    cmd = self.action_queue.get_nowait()
                    if not self.running:
                        continue
                    
                    if cmd[0] == "status":
                        self.update_status(cmd[1])
                    elif cmd[0] == "update_hotkey":
                        _, var, value = cmd
                        var.set(value)
                    elif cmd[0] == "toggle_item":
                        self.toggle_by_item(cmd[1])
                    elif cmd[0] == "stop":
                        self._stop_hotkeys()
                except queue.Empty:
                    break
                except:
                    pass
        except:
            pass
        
        if self.running:
            try:
                self.root.after(100, self.process_queue)
            except:
                pass

    def save_config(self):
        try:
            data = [item.to_dict() for item in self.config_items]
            with open(CONFIG_FILE, "w", encoding="utf-8") as f:
                json.dump(data, f, ensure_ascii=False, indent=2)
        except:
            pass

    def load_config(self):
        try:
            if os.path.exists(CONFIG_FILE):
                with open(CONFIG_FILE, "r", encoding="utf-8") as f:
                    data = json.load(f)
                if isinstance(data, list):
                    for item_data in data:
                        try:
                            self.config_items.append(HideConfigItem.from_dict(item_data))
                        except:
                            pass
        except:
            pass

    @staticmethod
    def is_admin():
        try:
            return ctypes.windll.shell32.IsUserAnAdmin()
        except:
            return False

    @staticmethod
    def run_as_admin():
        try:
            script = sys.argv[0]
            ctypes.windll.shell32.ShellExecuteW(None, "runas", sys.executable, f'"{script}" --elevated', None, 1)
        except:
            pass

    def auto_elevated_start(self):
        try:
            self.start()
            if self.active:
                self.root.withdraw()
                self.self_hidden = True
        except:
            pass

if __name__ == "__main__":
    try:
        auto_mode = "--elevated" in sys.argv
        
        root = tk.Tk()
        app = BossKeyApp(root, auto_start=auto_mode)
        root.mainloop()
        
    except Exception as e:
        try:
            root = tk.Tk()
            root.withdraw()
            messagebox.showerror("启动错误", f"程序启动失败:\n{str(e)}")
            root.destroy()
        except:
            pass
        sys.exit(1)