gui.py

import tkinter as tk
import tkinter.ttk as ttk
from tkinter import messagebox
import configparser
import os
import sys
import subprocess
import logging
from config_loader import AppConfig, get_base_path
from log_manager import get_module_logger
from utool import KEY_TO_VK, NAME_TO_PYNPUT_KEY
import autostart_manager
import path_manager
from key_mapping_mode import KeyMappingMode
from gui_widgets import FormattedLabel, ScrollableFrame

class KeyMouseGUI:
    """KeyMouse主界面类。"""
    

    

    
  
    def __init__(self, root, tray_icon=None, app_config=None):
        self.root = root
        self.tray_icon = tray_icon
        self.app_config = app_config # Store AppConfig instance

        # 设置模块专用日志记录器
        self.logger = get_module_logger('gui')

        self.root.title("KeyMouse 设置")
        self.root.geometry("600x500")
        self.root.minsize(450, 400)
        self.root.resizable(True, True)

        self.config_file_name = 'config.ini'
        self.config_path = os.path.join(get_base_path(), self.config_file_name)

        # 如果 app_config 为 None，则创建新的 AppConfig 实例
        if self.app_config is None:
            self.app_config = AppConfig(self.config_file_name)

        self.config = self.app_config  # 使用相同的 AppConfig 实例
        self.config_parser = configparser.ConfigParser()
        self.config_parser.read(self.config_path, encoding='utf-8')

        def _populate_default_mappings(self):
            """临时方法，将迁移到 GuiController"""
            pass

      

        self.main_frame = ttk.Notebook(root)
        self.main_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        self.keybindings_frame = ttk.Frame(self.main_frame)
        self.settings_frame = ttk.Frame(self.main_frame)
        self.key_mapping_frame = ttk.Frame(self.main_frame)
        self.main_frame.add(self.keybindings_frame, text="键位设置")
        self.main_frame.add(self.key_mapping_frame, text="按键映射")
        self.main_frame.add(self.settings_frame, text="通用设置")
        
        self.recording_key = None
        self.recording_entry = None
        self.original_key_value = ""
        self.key_vars = {}

        # 创建 GuiController 实例来管理业务逻辑
        from gui_controller import GuiController
        self.controller = GuiController(self, self.app_config, None)

        self._create_widgets()

    def _create_widgets(self):
        """创建所有界面控件。"""
        self.create_keybindings_ui()
        self.create_settings_ui()
        self.create_key_mapping_ui()
        
        self.button_frame = ttk.Frame(self.root)
        self.button_frame.pack(fill=tk.X, padx=10, pady=10)
        
        ttk.Button(
            self.button_frame,
            text="保存设置",
            command=self.save_settings
        ).pack(side=tk.RIGHT, padx=5)
        
        ttk.Button(
            self.button_frame,
            text="保存为默认",
            command=self.save_current_as_default
        ).pack(side=tk.RIGHT, padx=5)
        
        ttk.Button(
            self.button_frame,
            text="恢复默认",
            command=self.reset_defaults
        ).pack(side=tk.RIGHT, padx=5)
        
        self.status_var = tk.StringVar(value="就绪")
        self.status_bar = ttk.Label(
            self.root,
            textvariable=self.status_var,
            relief=tk.SUNKEN,
            anchor=tk.W
        )
        self.status_bar.pack(side=tk.BOTTOM, fill=tk.X)



    def create_keybindings_ui(self):
        """创建键位设置界面。"""
        scrollable_container = ScrollableFrame(self.keybindings_frame)
        scrollable_container.pack(fill=tk.BOTH, expand=True)
        keybindings_container = scrollable_container.content_frame
        
        # 鼠标移动控制
        move_frame = ttk.LabelFrame(keybindings_container, text="鼠标移动控制")
        move_frame.pack(fill=tk.X, pady=5, padx=10)
        
        self.create_key_setting(move_frame, "向上移动", "move_up", 0)
        self.create_key_setting(move_frame, "向下移动", "move_down", 1)
        self.create_key_setting(move_frame, "向左移动", "move_left", 2)
        self.create_key_setting(move_frame, "向右移动", "move_right", 3)
        self.create_key_setting(move_frame, "向上滚动", "scroll_up", 4)
        self.create_key_setting(move_frame, "向下滚动", "scroll_down", 5)
        
        # 鼠标点击控制
        click_frame = ttk.LabelFrame(keybindings_container, text="鼠标点击控制")
        click_frame.pack(fill=tk.X, pady=5, padx=10)
        
        self.create_key_setting(click_frame, "左键点击", "left_click", 0)
        self.create_key_setting(click_frame, "右键点击", "right_click", 1)
        self.create_key_setting(click_frame, "中键点击", "middle_click", 2)
        self.create_key_setting(click_frame, "粘滞左键 (切换)", "sticky_left_click", 3)
        
        # 模式控制
        mode_frame = ttk.LabelFrame(keybindings_container, text="模式控制")
        mode_frame.pack(fill=tk.X, pady=5, padx=10)
        
        self.create_key_setting(mode_frame, "切换模式热键", "toggle_mode_hotkey", 0)
        self.create_key_setting(mode_frame, "内部模式切换键", "toggle_mode_internal", 1)
        self.create_key_setting(mode_frame, "进入区域选择模式", "enter_region_select_mode", 2)
        self.create_key_setting(mode_frame, "退出程序", "exit_program", 3)

    def create_key_setting(self, parent, label_text, config_key, row):
        """创建单个键位设置行。"""
        ttk.Label(parent, text=label_text).grid(
            row=row, column=0, padx=5, pady=5, sticky=tk.W
        )
        
        key_var = tk.StringVar()
        key_var.set(self.config_parser.get('Keybindings', config_key, fallback=''))
        self.key_vars[config_key] = key_var
        
        key_entry = ttk.Entry(parent, textvariable=key_var, width=15)
        key_entry.grid(row=row, column=1, padx=5, pady=5)
        
        command = lambda k=config_key, e=key_entry: self.record_key(k, e)
        ttk.Button(
            parent,
            text="设置",
            command=command
        ).grid(row=row, column=2, padx=5, pady=5)

    def create_settings_ui(self):
        """创建通用设置界面。"""
        scrollable_container = ScrollableFrame(self.settings_frame)
        scrollable_container.pack(fill=tk.BOTH, expand=True)
        settings_container = scrollable_container.content_frame
        
        # 系统集成设置
        integration_frame = ttk.LabelFrame(settings_container, text="系统集成")
        integration_frame.pack(fill=tk.X, pady=5, padx=10)
        
        # 开机自启动
        self.autostart_var = tk.BooleanVar(value=autostart_manager.is_enabled())
        autostart_check = ttk.Checkbutton(
            integration_frame,
            text="开机时自动启动",
            variable=self.autostart_var,
            command=lambda: self.controller.toggle_autostart()
        )
        autostart_check.pack(side=tk.LEFT, padx=5, pady=5)
        
        # 管理员启动
        self.admin_var = tk.BooleanVar(
            value=self.config_parser.getboolean('Settings', 'run_as_admin', fallback=False)
        )
        admin_check = ttk.Checkbutton(
            integration_frame,
            text="以管理员身份启动 (解决权限问题)",
            variable=self.admin_var
        )
        admin_check.pack(side=tk.LEFT, padx=20, pady=5)
        
        # 鼠标速度设置
        speed_frame = ttk.LabelFrame(settings_container, text="鼠标速度设置")
        speed_frame.pack(fill=tk.X, pady=5, padx=10)
        
        # 基础移动速度
        self.move_speed_var = tk.IntVar(
            value=self.config_parser.getint('Settings', 'mouse_move_speed')
        )
        self._create_scale_with_label(speed_frame, 0, "基础移动速度", 1, 50, self.move_speed_var, 0)
        
        # Shift速度乘数
        self.shift_mult_var = tk.DoubleVar(
            value=self.config_parser.getfloat('Settings', 'mouse_speed_shift_multiplier')
        )
        self._create_scale_with_label(speed_frame, 1, "Shift速度乘数", 0.1, 2.0, self.shift_mult_var, 1)
        
        # CapsLock速度乘数
        self.caps_mult_var = tk.DoubleVar(
            value=self.config_parser.getfloat('Settings', 'mouse_speed_capslock_multiplier')
        )
        self._create_scale_with_label(speed_frame, 2, "CapsLock速度乘数", 0.1, 2.0, self.caps_mult_var, 1)
        
        # 平滑滚动设置
        smooth_scroll_frame = ttk.LabelFrame(settings_container, text="平滑滚动设置")
        smooth_scroll_frame.pack(fill=tk.X, pady=5, padx=10)
        
        # 初始速度
        self.initial_velocity_var = tk.DoubleVar(
            value=self.config_parser.getfloat('SmoothScrolling', 'initial_velocity')
        )
        self._create_scale_with_label(smooth_scroll_frame, 0, "初始速度 (px/s)", 50, 500, self.initial_velocity_var, 0)
        
        # 最大速度
        self.max_velocity_var = tk.DoubleVar(
            value=self.config_parser.getfloat('SmoothScrolling', 'max_velocity')
        )
        self._create_scale_with_label(smooth_scroll_frame, 1, "最大速度 (px/s)", 500, 6000, self.max_velocity_var, 0)
        
        # 加速度
        self.acceleration_var = tk.DoubleVar(
            value=self.config_parser.getfloat('SmoothScrolling', 'acceleration')
        )
        self._create_scale_with_label(smooth_scroll_frame, 2, "加速度 (px/s²)", 100, 2000, self.acceleration_var, 0)
        
        # 性能设置
        perf_frame = ttk.LabelFrame(settings_container, text="性能设置")
        perf_frame.pack(fill=tk.X, pady=5, padx=10)

        self.delay_var = tk.DoubleVar(
            value=self.config_parser.getfloat('Settings', 'delay_per_step')
        )
        self._create_scale_with_label(perf_frame, 0, "移动延迟(秒)", 0.001, 0.05, self.delay_var, 3)

    def create_key_mapping_ui(self):
        """创建按键映射设置界面。"""
        scrollable_container = ScrollableFrame(self.key_mapping_frame)
        scrollable_container.pack(fill=tk.BOTH, expand=True)
        self.key_mapping_container = scrollable_container.content_frame

        self.key_mappings = {}  # To store mapping widgets

        ttk.Button(self.key_mapping_container, text="添加映射", command=self.add_key_mapping_row).pack(pady=10)

        self.load_key_mappings()

    def add_key_mapping_row(self, source_key="", target_key="", note=""):
        """添加一行按键映射设置，包含备注。"""
        return self._create_key_mapping_row(source_key, target_key, note)


    def remove_key_mapping_row(self, frame, source_key):
        """移除一行按键映射设置。"""
        if source_key in self.key_mappings:
            del self.key_mappings[source_key]
        frame.destroy()

    def _create_key_mapping_row(self, source_key="", target_key="", note=""):
        """创建一行按键映射设置的辅助函数。"""
        row_frame = ttk.Frame(self.key_mapping_container)
        row_frame.pack(fill=tk.X, padx=10, pady=5)

        source_var = tk.StringVar(value=source_key)
        target_var = tk.StringVar(value=target_key)
        note_var = tk.StringVar(value=note)

        ttk.Label(row_frame, text="源:").pack(side=tk.LEFT, padx=(5,0))
        source_entry = ttk.Entry(row_frame, textvariable=source_var, width=10)
        source_entry.pack(side=tk.LEFT, padx=(2,5))
        ttk.Button(row_frame, text="设置", command=lambda: self.record_key_mapping(source_var, source_entry)).pack(side=tk.LEFT)
        ttk.Label(row_frame, text="目标:").pack(side=tk.LEFT, padx=(10,0))
        target_entry = ttk.Entry(row_frame, textvariable=target_var, width=15)
        target_entry.pack(side=tk.LEFT, padx=(2,5))
        ttk.Button(row_frame, text="设置", command=lambda: self.record_key_mapping(target_var, target_entry, is_combo=True)).pack(side=tk.LEFT)
        ttk.Label(row_frame, text="备注:").pack(side=tk.LEFT, padx=(10,0))
        note_entry = ttk.Entry(row_frame, textvariable=note_var, width=15)
        note_entry.pack(side=tk.LEFT, padx=(2,5), expand=True, fill=tk.X)
        ttk.Button(row_frame, text="删除", command=lambda: self.remove_key_mapping_row(row_frame, source_var.get())).pack(side=tk.RIGHT)

        # 当源按键为空时，说明是新添加的行，可能还没有key
        # 我们使用id作为临时key，在用户输入后更新
        row_key = source_key if source_key else id(row_frame)
        self.key_mappings[row_key] = {
            "frame": row_frame,
            "source_var": source_var,
            "target_var": target_var,
            "note_var": note_var,
        }

        return row_frame

    def _create_scale_with_label(self, parent, row, label_text, from_, to, variable, precision=0):
        """创建带有标签的滑块组件。"""
        ttk.Label(parent, text=label_text).grid(
            row=row, column=0, padx=5, pady=5, sticky=tk.W
        )
        ttk.Scale(
            parent,
            from_=from_,
            to=to,
            variable=variable,
            orient=tk.HORIZONTAL
        ).grid(row=row, column=1, padx=5, pady=5, sticky=tk.EW)
        if precision > 0:
            FormattedLabel(
                parent,
                textvariable=variable,
                precision=precision
            ).grid(row=row, column=2, padx=5, pady=5)
        else:
            FormattedLabel(
                parent,
                textvariable=variable
            ).grid(row=row, column=2, padx=5, pady=5)

    def load_key_mappings(self):
        """加载并显示按键映射和备注。"""
        # Clear existing widgets before loading
        for widget_dict in self.key_mappings.values():
            widget_dict["frame"].destroy()
        self.key_mappings.clear()

        if self.config_parser.has_section('CommandModeMacros'):
            for source, value in self.config_parser.items('CommandModeMacros'):
                # 仅加载和显示 SEND_KEYS 类型的宏作为可编辑的按键映射
                if value.upper().startswith('SEND_KEYS:'):
                    try:
                        target = value.split(':', 1)[1]
                        note = self.config_parser.get('CommandModeMacrosNotes', source, fallback='')
                        self.add_key_mapping_row(source, target, note)
                    except IndexError:
                        # 格式错误，忽略
                        print(f"警告：在 [CommandModeMacros] 中发现格式错误的 SEND_KEYS 宏: '{source}={value}'")
                # 其他类型的宏（如带参数的）将被保留但不在GUI中显示

    def record_key_mapping(self, key_var, entry, is_combo=False):
        """记录按键映射的源或目标键。"""
        self.controller.record_key_mapping(key_var, entry, is_combo)

    def on_key_mapping_press(self, event):
        """处理按键映射的按键按下事件。"""
        self.controller.on_key_mapping_press(event)

    def on_key_mapping_release(self, event):
        """处理按键映射的按键释放事件。"""
        self.controller.on_key_mapping_release(event)

    def finish_key_mapping_recording(self):
        """完成按键映射的录制。"""
        self.controller.finish_key_mapping_recording()

    def cancel_key_mapping_recording(self, event=None):
        """取消按键映射的录制。"""
        self.controller.cancel_key_mapping_recording(event)

    
    def record_key(self, config_key, entry):
        """记录键位。"""
        if self.recording_entry:
            self.cancel_recording()
            
        self.recording_key = config_key
        self.recording_entry = entry
        self.original_key_value = self.key_vars[config_key].get()
        
        entry.config(state='readonly')
        entry.delete(0, tk.END)
        entry.insert(0, "按下任意键...")
        entry.focus_set()
        
        self.root.bind('<Key>', self.on_key_press)
        self.root.bind('<Button-1>', self.cancel_recording)

    def cancel_recording(self, event=None):
        """取消键位记录。"""
        if not self.recording_key:
            return
            
        self.key_vars[self.recording_key].set(self.original_key_value)
        self.status_var.set("录制已取消")
        
        self.recording_entry.config(state='normal')
        self.root.unbind('<Key>')
        self.root.unbind('<Button-1>')
        
        self.recording_key = None
        self.recording_entry = None
        self.original_key_value = ""

    def on_key_press(self, event):
        """处理按键事件。"""
        if not self.recording_key:
            return
            
        keysym = event.keysym
        key_map = {
            'Shift_L': 'lshift',
            'Shift_R': 'rshift',
            'Control_L': 'lctrl',
            'Control_R': 'rctrl',
            'Alt_L': 'lalt',
            'Alt_R': 'ralt',
            'Caps_Lock': 'caps_lock',
            'Return': 'enter',
            'Escape': 'esc',
            'BackSpace': 'backspace',
            'space': 'space',
            'semicolon': 'semicolon',
            'apostrophe': 'apostrophe',
            'comma': 'comma',
            'period': 'period',
            'slash': 'slash',
            'enter_region_select_mode': 'f' 
        }
        
        final_key_str = key_map.get(keysym, keysym.lower())
        self.key_vars[self.recording_key].set(final_key_str)
        self.status_var.set(f"键位已设置: {final_key_str}")
        
        self.recording_entry.config(state='normal')
        self.root.unbind('<Key>')
        self.root.unbind('<Button-1>')
        
        self.recording_key = None
        self.recording_entry = None
        self.original_key_value = ""

    def save_settings(self):
        """保存设置到配置文件。"""
        try:
            # 智能保存逻辑：更新CommandModeMacros和Notes，同时保留复杂宏
            new_key_mappings = {}
            new_key_mapping_notes = {}

            # 从UI收集当前所有有效的映射和备注
            for widgets in self.key_mappings.values():
                source = widgets["source_var"].get()
                target = widgets["target_var"].get()
                note = widgets["note_var"].get()
                if source and target:
                    new_key_mappings[source] = target
                    if note:
                        new_key_mapping_notes[source] = note

            # 确保 [CommandModeMacros] 和 [CommandModeMacrosNotes] 节存在
            if not self.config_parser.has_section('CommandModeMacros'):
                self.config_parser.add_section('CommandModeMacros')
            if not self.config_parser.has_section('CommandModeMacrosNotes'):
                self.config_parser.add_section('CommandModeMacrosNotes')

            # 1. 识别并保护现有的非 SEND_KEYS 复杂宏
            macros_to_keep = {}
            if self.config_parser.has_section('CommandModeMacros'):
                for key, value in self.config_parser.items('CommandModeMacros'):
                    if ':' in value and not value.upper().startswith('SEND_KEYS:'):
                         macros_to_keep[key] = value

            # 2. 清空由UI管理的配置节
            self.config_parser.remove_section('CommandModeMacros')
            self.config_parser.add_section('CommandModeMacros')
            self.config_parser.remove_section('CommandModeMacrosNotes')
            self.config_parser.add_section('CommandModeMacrosNotes')

            # 3. 重新写入：先写回受保护的宏
            for key, value in macros_to_keep.items():
                self.config_parser.set('CommandModeMacros', key, value)

            # 4. 写入UI管理的映射和备注
            for key, value in new_key_mappings.items():
                # Normalize the key string for pynput before saving
                processed_value = self.controller._normalize_key_string_for_pynput(value)
                # 写入为标准的SEND_KEYS宏格式
                self.config_parser.set('CommandModeMacros', key, f"SEND_KEYS:{processed_value}")

            for key, note in new_key_mapping_notes.items():
                self.config_parser.set('CommandModeMacrosNotes', key, note)


            # 验证键位
            invalid_keys = []
            key_values = {}

            for key, var in self.key_vars.items():
                key_value = var.get()
                key_values[key] = key_value
                if '+' not in key_value and key_value not in KEY_TO_VK:
                    invalid_keys.append(f"{key}: {key_value}")

            if invalid_keys:
                messagebox.showerror(
                    "保存失败",
                    "以下键位设置无效:\n" + "\n".join(invalid_keys)
                )
                return False

            # 写入键位
            for key, value in key_values.items():
                self.config_parser.set('Keybindings', key, value)

            # 写入通用设置
            self.config_parser.set('Settings', 'mouse_move_speed',
                                 str(self.move_speed_var.get()))
            self.config_parser.set('Settings', 'mouse_speed_shift_multiplier',
                                 f"{self.shift_mult_var.get():.1f}")
            self.config_parser.set('Settings', 'mouse_speed_capslock_multiplier',
                                 f"{self.caps_mult_var.get():.1f}")
            self.config_parser.set('Settings', 'delay_per_step',
                                 f"{self.delay_var.get():.3f}")
            self.config_parser.set('Settings', 'run_as_admin',
                                 str(self.admin_var.get()).lower())

            # 写入平滑滚动设置
            self.config_parser.set('SmoothScrolling', 'initial_velocity',
                                 f"{self.initial_velocity_var.get():.1f}")
            self.config_parser.set('SmoothScrolling', 'max_velocity',
                                 f"{self.max_velocity_var.get():.1f}")
            self.config_parser.set('SmoothScrolling', 'acceleration',
                                 f"{self.acceleration_var.get():.1f}")

            # 保存到文件
            with open(self.config_path, 'w', encoding='utf-8') as f:
                self.config_parser.write(f)

            self.status_var.set("设置已保存")

            if messagebox.askyesno("重启程序",
                    "设置已保存。\n\n是否立即重启程序以应用新设置？\n\n"
                    "注意：所有未保存的工作将丢失。"):
                self.restart_program()
            else:
                # 不再显示额外的成功信息弹窗，仅在状态栏提示
                self.status_var.set("设置已保存，将在下次启动时应用")

            return True

        except Exception as e:
            messagebox.showerror("保存失败", f"无法保存设置: {str(e)}")
            return False

    # 原始的 restart_program 方法已迁移到 gui_controller.py
    # 临时保留此方法以维持程序运行，将在后续集成任务中更新为调用 GuiController
    def restart_program(self):
        """委托给 GuiController 处理重启"""
        # 在重启前设置键盘焦点到主窗口
        try:
            # 强制主窗口获得焦点
            self.root.focus_force()
            # 确保焦点在主窗口而不是子控件上
            self.root.focus_set()
            logging.info("GUI focus set to main window before restart")
        except Exception as e:
            logging.warning(f"Failed to set GUI focus before restart: {e}")

        # 委托给 GuiController 处理重启
        if hasattr(self, 'controller') and self.controller:
            self.controller.restart_program()
        else:
            logging.warning("GuiController not available for restart")
            # 备用方案：使用静态重启方法
            try:
                from process_manager import ProcessManager
                ProcessManager.restart_application()
            except Exception as e:
                logging.error(f"Failed to restart directly: {e}")

    def save_current_as_default(self):
        """将当前设置保存为默认配置。"""
        if messagebox.askyesno("确认", "确定要将当前设置保存为默认配置吗？"):
            if self.save_settings():
                messagebox.showinfo("成功", "当前设置已成功保存为默认配置。")

    def refresh_config(self):
        """刷新配置。"""
        result = self.controller.refresh_config()
        if result['success']:
            # 根据Controller返回的数据更新界面
            new_config = result['config']

            # 更新键位设置
            for key, var in self.key_vars.items():
                var.set(new_config.get_raw_value('Keybindings', key, fallback=''))

            # 更新通用设置
            self.move_speed_var.set(new_config.mouse_move_speed)
            self.shift_mult_var.set(new_config.mouse_speed_shift_multiplier)
            self.caps_mult_var.set(new_config.mouse_speed_capslock_multiplier)
            self.delay_var.set(new_config.delay_per_step)
            self.admin_var.set(new_config.run_as_admin)

            # 更新平滑滚动设置
            self.initial_velocity_var.set(new_config.initial_velocity)
            self.max_velocity_var.set(new_config.max_velocity)
            self.acceleration_var.set(new_config.acceleration)

            self.status_var.set(result['message'])
        else:
            from tkinter import messagebox
            messagebox.showerror("刷新失败", result['message'])

    def reset_defaults(self):
        """恢复默认设置。"""
        from tkinter import messagebox

        if messagebox.askyesno("确认", "确定要恢复所有设置到出厂默认值吗？"):
            # 使用控制器的 reset_defaults 方法
            result = self.controller.reset_defaults()

            if result['success']:  # 确保操作成功
                defaults = result['defaults']

                # 重置键位映射
                if 'key_mappings' in defaults:
                    key_defaults = defaults['key_mappings']
                    for key, value in key_defaults.items():
                        if key in self.key_vars:
                            self.key_vars[key].set(value)

                # 重置通用设置
                if 'settings' in defaults:
                    setting_defaults = defaults['settings']
                    self.move_speed_var.set(setting_defaults.get('mouse_move_speed', 16))
                    self.shift_mult_var.set(setting_defaults.get('mouse_speed_shift_multiplier', 0.5))
                    self.caps_mult_var.set(setting_defaults.get('mouse_speed_capslock_multiplier', 0.2))
                    self.delay_var.set(setting_defaults.get('delay_per_step', 0.010))
                    self.admin_var.set(setting_defaults.get('run_as_admin', True))

                    # 重置平滑滚动设置
                    self.initial_velocity_var.set(setting_defaults.get('initial_velocity', 150.0))
                    self.max_velocity_var.set(setting_defaults.get('max_velocity', 1500.0))
                    self.acceleration_var.set(setting_defaults.get('acceleration', 700.0))

                self.status_var.set(result['message'])
            else:
                messagebox.showerror("恢复失败", result['message'])


def run_gui(on_close_callback=None, tray_icon=None, app_config=None):
    """运行GUI程序。"""
    root = tk.Tk()
    app = KeyMouseGUI(root, tray_icon, app_config)
    
    def on_closing():
        if on_close_callback:
            on_close_callback()
        root.destroy()
        
    root.protocol("WM_DELETE_WINDOW", on_closing)
    root.mainloop()

if __name__ == "__main__":
    run_gui()