# ===================== 【根号七的工具箱】 =====================

import tkinter as tk
from tkinter import ttk, messagebox, scrolledtext, colorchooser
from PIL import ImageTk, Image, ImageDraw
import webbrowser
import sys
import os
import threading
import time
import pyautogui
from pynput import keyboard
import datetime
import re

if sys.platform == "win32":
    import win32gui
    import win32con

# 全局打印计数器
print_counter = 1

# 带编号的打印函数
def numbered_print(msg):
    global print_counter
    print(f"({print_counter}) {msg}")
    print_counter += 1

# 实时时间
def get_time_str():
    t = datetime.datetime.now()
    return f"{t.hour:02d}:{t.minute:02d}:{t.second:02d}"

# 版本、版本号修改
VERSION = " " + "内测版"
VERNO = " " + "v2.2.4"


class ToolboxApp:
    def __init__(self, root):
        # 程序主界面与功能初始化
        self.root = root
        self.root.title(f"根号七的工具箱{VERSION}{VERNO}")
        self.root.geometry("1280x800")
        self.root.minsize(1000, 650)

        # 主题配色配置
        self.bg_color = "#F0F0F0"
        self.primary_color = "#1F7A48"
        self.second_color = "#E3F2EB"
        self.text_color = "#333333"
        self.root.configure(bg=self.bg_color)

        # 侧边栏动画参数
        self.nav_anim_id = None
        self.nav_collapse_width = 60
        self.nav_expand_width = 240

        # 用户信息
        self.username = "默认用户"
        self.is_editing = False
        self.user_avatar = self.load_circle_avatar("头像.png", size=32)
        self.zan_img = None
        self.qun_img = None

        # 连点器功能变量
        self.clicker_running = False
        self.clicker_thread = None
        self.hotkey_enabled = tk.BooleanVar(value=False)

        # 悬浮字幕功能变量
        self.float_running = False
        self.float_hotkey_enabled = tk.BooleanVar(value=False)
        self.float_listener = None
        self.float_window = None
        self.float_label = None
        self.float_x = 100
        self.float_y = 100
        self.float_font_size = 24
        self.float_color = "#ff0000"
        self.float_bg_color = "#00FF00"
        self.float_border_width = 2
        self.float_alpha = tk.DoubleVar(value=100)
        self.float_refresh_id = None
        self.float_font_family = "微软雅黑"

        # 功能模块公共变量
        self.current_module = None
        self.calc_expression = ""
        self.calc_history = []
        self.classic_images = []
        self.current_nav_btn = None

        # 界面与快捷键初始化
        self.setup_window_icon()
        self.setup_global_style()
        self.setup_layout()
        self.bind_shortcuts()
        self.setup_clicker_global_hotkeys()
        self.function0()

    # 悬浮字幕核心功能
    def parse_float_text(self, raw_text):
        #解析字幕文本，替换时间变量与数学表达式
        now = datetime.datetime.now()
        var_map = {
            "{year}": str(now.year),
            "{month}": f"{now.month:02d}",
            "{day}": f"{now.day:02d}",
            "{hour}": f"{now.hour:02d}",
            "{minute}": f"{now.minute:02d}",
            "{second}": f"{now.second:02d}"
        }
        text = raw_text
        for k, v in var_map.items():
            text = text.replace(k, v)

        math_pat = re.compile(r"\{math:(.+?)\}")

        def calc_match(m):
            expr = m.group(1)
            try:
                res = eval(expr, {"__builtins__": None}, {})
                return str(res)
            except:
                return "错误"

        text = math_pat.sub(calc_match, text)
        text = text.replace("\\n", "\n")
        return text

    def float_auto_refresh(self):
        # 悬浮字幕每秒自动刷新内容
        if self.float_window and self.float_label and hasattr(self, 'float_text_entry'):
            try:
                if not self.float_text_entry.winfo_exists():
                    return
                raw = self.float_text_entry.get("1.0", tk.END).strip()
                real_txt = self.parse_float_text(raw)
                self.float_label.config(text=real_txt)
            except:
                return
        self.float_refresh_id = self.root.after(1000, self.float_auto_refresh)

    def setup_float_global_hotkeys(self):
        # 注册悬浮字幕全局快捷键F10
        def on_f10_press(key):
            try:
                if key == keyboard.Key.f10 and self.float_hotkey_enabled.get():
                    self.root.after(0, self.toggle_float)
            except:
                pass
        self.float_listener = keyboard.Listener(on_press=on_f10_press)
        self.float_listener.daemon = True
        self.float_listener.start()

    def toggle_float(self):
        # 切换悬浮字幕显示/隐藏状态
        if not self.float_running:
            self.show_float_text()
        else:
            self.hide_float_text()

    # 连点器核心功能
    def setup_clicker_global_hotkeys(self):
        #注册连点器全局快捷键F9
        self.hotkey_listener = None

        def on_press(key):
            if not self.hotkey_enabled.get():
                return
            try:
                if key == keyboard.Key.f9:
                    self.root.after(0, self.toggle_clicker)
            except:
                pass

        try:
            self.hotkey_listener = keyboard.Listener(on_press=on_press, daemon=True)
            self.hotkey_listener.start()
        except:
            pass

    def toggle_clicker(self):
        # 切换连点器状态
        if self.clicker_running:
            self.stop_clicker()
        else:
            self.start_clicker()

    def start_clicker(self):
        # 启动鼠标连点执行线程
        if self.clicker_running:
            return
        try:
            interval = float(self.click_interval.get()) / 1000
            count = int(self.click_times.get())
            btn_text = self.click_btn.get()
            mode = self.click_mode.get()
            btn = "left" if btn_text == "左键" else "right"
        except:
            messagebox.showwarning("提示", "请输入有效数字")
            return

        self.clicker_running = True
        self.click_status.config(text="状态：运行中", fg="#e53e3e")

        def task():
            n = 0
            while self.clicker_running:
                pyautogui.click(button=btn) if mode == "单击" else pyautogui.doubleClick(button=btn)
                n += 1
                if count != -1 and n >= count:
                    break
                time.sleep(interval)
            self.clicker_running = False
            self.root.after(0, lambda: self.click_status.config(text="状态：已停止", fg=self.text_color))

        self.clicker_thread = threading.Thread(target=task, daemon=True)
        self.clicker_thread.start()

    def stop_clicker(self):
        # 停止鼠标连点功能
        self.clicker_running = False
        self.click_status.config(text="状态：已停止", fg=self.text_color)

    def function3(self):
        # 加载鼠标连点器功能界面
        self.clear_main_frame()
        self.current_module = "clicker"

        tk.Label(self.main_frame, text="🖱 鼠标指针辅助器", font=("微软雅黑", 22, "bold"),
                 bg=self.bg_color, fg=self.primary_color).pack(pady=(10, 20), anchor="w")

        frame = tk.Frame(self.main_frame, bg="white", bd=2, relief=tk.RIDGE)
        frame.pack(fill=tk.X, padx=0, pady=5)
        inner = tk.Frame(frame, bg="white")
        inner.pack(padx=20, pady=18)

        tk.Label(inner, text="点击间隔(ms)：", bg="white", font=("微软雅黑", 12)).grid(row=0, column=0, sticky="w", padx=5)
        self.click_interval = tk.Entry(inner, font=("微软雅黑", 12), width=8)
        self.click_interval.grid(row=0, column=1, padx=5)
        self.click_interval.insert(0, "100")

        tk.Label(inner, text="点击次数(-1无限)：", bg="white", font=("微软雅黑", 12)).grid(row=0, column=2, sticky="w", padx=5)
        self.click_times = tk.Entry(inner, font=("微软雅黑", 12), width=8)
        self.click_times.grid(row=0, column=3, padx=5)
        self.click_times.insert(0, "-1")

        tk.Label(inner, text="鼠标按键：", bg="white", font=("微软雅黑", 12)).grid(row=1, column=0, sticky="w", pady=12)
        self.click_btn = tk.StringVar(value="左键")
        ttk.Combobox(inner, textvariable=self.click_btn, values=["左键", "右键"], state="readonly", width=7).grid(row=1, column=1)

        tk.Label(inner, text="点击模式：", bg="white", font=("微软雅黑", 12)).grid(row=1, column=2, sticky="w")
        self.click_mode = tk.StringVar(value="单击")
        ttk.Combobox(inner, textvariable=self.click_mode, values=["单击", "双击"], state="readonly", width=7).grid(row=1, column=3)

        btn_frame = tk.Frame(self.main_frame, bg=self.bg_color)
        btn_frame.pack(pady=12)

        tk.Button(btn_frame, text="▶ 启动连点", font=("微软雅黑", 12, "bold"),
                  bg=self.primary_color, fg="white", relief=tk.FLAT, padx=18, pady=6,
                  command=self.start_clicker).grid(row=0, column=0, padx=8)

        tk.Button(btn_frame, text="⏹ 停止连点", font=("微软雅黑", 12, "bold"),
                  bg="#dc2626", fg="white", relief=tk.FLAT, padx=18, pady=6,
                  command=self.stop_clicker).grid(row=0, column=1, padx=8)

        self.click_status = tk.Label(self.main_frame, text="状态：已停止", font=("微软雅黑", 13),
                                     bg=self.bg_color, fg=self.text_color)
        self.click_status.pack(pady=4)

        hk_frame = tk.Frame(self.main_frame, bg=self.bg_color)
        hk_frame.pack(pady=4)
        tk.Label(hk_frame, text="快捷键：F9 切换启动/停止", font=("微软雅黑", 12), bg=self.bg_color).pack(side=tk.LEFT)
        tk.Checkbutton(hk_frame, text="启用快捷键", variable=self.hotkey_enabled, bg=self.bg_color, font=("微软雅黑", 11)).pack(side=tk.LEFT, padx=8)

    # 头像加载功能
    def load_circle_avatar(self, img_path, size=32):
        # 加载圆形用户头像，加载失败则使用默认头像
        try:
            img = Image.open(img_path).convert("RGBA")
            img = img.resize((size, size), Image.LANCZOS)
            mask = Image.new("L", (size, size), 0)
            draw = ImageDraw.Draw(mask)
            draw.ellipse((0, 0, size, size), fill=255)
            circle_img = Image.new("RGBA", (size, size), (255, 255, 255, 0))
            circle_img.paste(img, (0, 0), mask=mask)
            numbered_print(f"[{get_time_str()}] 图片 \"头像.png\" 加载成功")
            return ImageTk.PhotoImage(circle_img)
        except Exception:
            numbered_print(f"[{get_time_str()}] 图片 \"头像.png\" 加载失败，未找到图片")
            return self.create_default_avatar(size)

    def create_default_avatar(self, size=32):
        # 生成默认灰色圆形头像
        img = Image.new("RGBA", (size, size), (0, 0, 0, 0))
        draw = ImageDraw.Draw(img)
        draw.ellipse((0, 0, size, size), fill="#CCCCCC")
        draw.ellipse((size * 0.25, size * 0.15, size * 0.75, size * 0.45), fill="#AAAAAA")
        draw.rectangle((size * 0.2, size * 0.5, size * 0.8, size * 0.9), fill="#AAAAAA")
        return ImageTk.PhotoImage(img)

    def setup_window_icon(self):
        # 设置程序窗口图标
        try:
            icon_path = "图标4.ico"
            numbered_print(f"[{get_time_str()}] 图标 \"{icon_path}\" 加载成功")
            if os.path.exists(icon_path):
                self.root.iconbitmap(icon_path)
        except Exception:
            pass

    # ===================== 界面样式与布局 =====================
    def setup_global_style(self):
        # 全局组件样式配置
        self.style = ttk.Style()
        self.style.theme_use("clam")
        self.style.configure("Primary.TButton", font=("微软雅黑", 10, "bold"), background=self.primary_color,
                             foreground="white", padding=12)
        self.style.map("Primary.TButton", background=[('active', "#186439")])
        self.style.configure("Nav.TButton", font=("微软雅黑", 11), background="white", foreground=self.text_color,
                             padding=12, borderwidth=0)
        self.style.map("Nav.TButton", background=[('active', self.second_color), ('pressed', self.second_color)])
        self.style.configure("Selected.Nav.TButton", font=("微软雅黑", 11, "bold"), background="#E3F2EB",
                             foreground=self.text_color, padding=12, borderwidth=0, relief=tk.FLAT)
        self.style.map("Selected.Nav.TButton", background=[('active', "#C8E6D8")])

    def clear_main_frame(self):
        # 清空主界面内容，用于切换功能模块
        try:
            self.root.unbind("<MouseWheel>")
            self.root.unbind("<Key>")
        except:
            pass
        self.classic_images = []
        for widget in self.main_frame.winfo_children():
            widget.destroy()

    def bind_shortcuts(self):
        # 注册全局系统快捷键
        self.root.bind("<F11>", self.toggle_fullscreen)
        self.root.bind("<Escape>", self.exit_fullscreen)
        self.root.bind("<Control-q>", self.quit_app)

    def toggle_fullscreen(self, event=None):
        # 切换窗口全屏显示
        is_full = self.root.attributes("-fullscreen")
        self.root.attributes("-fullscreen", not is_full)

    def exit_fullscreen(self, event=None):
        # 退出窗口全屏显示
        self.root.attributes("-fullscreen", False)

    def quit_app(self, event=None):
        # 退出程序
        if messagebox.askokcancel("退出确认", "确定要退出工具箱吗？"):
            self.root.destroy()
            sys.exit(0)

    # ===================== 侧边栏动画 =====================
    def animate_expand(self):
        # 侧边栏展开动画
        if self.nav_anim_id is not None:
            self.root.after_cancel(self.nav_anim_id)

        cur = self.nav_frame.winfo_width()
        tar = self.nav_expand_width
        if cur >= tar:
            self.nav_frame.config(width=tar)
            self.nav_anim_id = None
            return

        diff = tar - cur
        step = max(1.5, diff / 8)
        self.nav_frame.config(width=cur + step)
        self.nav_anim_id = self.root.after(15, self.animate_expand)

    def animate_collapse(self):
        # 侧边栏收缩动画
        if self.nav_anim_id is not None:
            self.root.after_cancel(self.nav_anim_id)

        cur = self.nav_frame.winfo_width()
        tar = self.nav_collapse_width
        if cur <= tar:
            self.nav_frame.config(width=tar)
            self.nav_anim_id = None
            return

        diff = cur - tar
        step = max(1.5, diff / 8)
        self.nav_frame.config(width=cur - step)
        self.nav_anim_id = self.root.after(15, self.animate_collapse)

    def set_selected_nav(self, selected_btn):
        # 设置侧边栏选中按钮样式
        for btn, _, _ in self.nav_buttons:
            btn.config(style="Nav.TButton")
        selected_btn.config(style="Selected.Nav.TButton")
        self.current_nav_btn = selected_btn

    def setup_layout(self):
        # 主界面布局初始化：头部、侧边栏、主内容区、底部

        # 顶部标题栏
        self.header_frame = tk.Frame(self.root, bg=self.primary_color, height=60)
        self.header_frame.pack(fill=tk.X, side=tk.TOP)
        self.header_frame.pack_propagate(False)

        tk.Label(self.header_frame, text="🌵", font=("微软雅黑", 20, "bold"),
                 bg=self.primary_color, fg="white").pack(side=tk.LEFT, padx=(20, 5), pady=12)
        tk.Label(self.header_frame, text="根号七的工具箱", font=("微软雅黑", 18, "bold"),
                 bg=self.primary_color, fg="white").pack(side=tk.LEFT, pady=12)

        # 主内容区
        self.right_container = tk.Frame(self.root, bg=self.bg_color)
        self.right_container.pack(fill=tk.BOTH, expand=True, side=tk.LEFT, padx=(self.nav_collapse_width, 0))
        self.main_frame = tk.Frame(self.right_container, bg=self.bg_color)
        self.main_frame.pack(fill=tk.BOTH, expand=True, padx=20, pady=20)

        # 左侧导航栏
        self.nav_frame = tk.Frame(self.root, bg="white")
        self.nav_frame.place(x=0, y=60, relheight=1, height=-60)
        self.nav_frame.pack_propagate(False)
        self.nav_frame.config(width=self.nav_collapse_width)

        # 鼠标悬停展开/离开收缩
        def check_mouse_pos():
            try:
                mx, my = self.root.winfo_pointerxy()
                nx1 = self.nav_frame.winfo_rootx()
                nx2 = nx1 + self.nav_frame.winfo_width()
                ny1 = self.nav_frame.winfo_rooty()
                ny2 = ny1 + self.nav_frame.winfo_height()

                # 正在动画中，不重复触发（修复卡死）
                if self.nav_anim_id is not None:
                    self.root.after_cancel(self.nav_anim_id)
                    self.nav_anim_id = None

                if nx1 <= mx <= nx2 and ny1 <= my <= ny2:
                    self.animate_expand()
                else:
                    self.animate_collapse()
            except:
                pass
            self.root.after(30, check_mouse_pos)

        check_mouse_pos()

        # 导航栏按钮
        self.nav_buttons = []
        nav_config = [
            ("🏠", "🏠 首页", self.function0),
            ("🧭", "🧭 网址导航", self.function1),
            ("🧮", "🧮 计算器", self.function2),
            ("🖱", "🖱 鼠标指针辅助器", self.function3),
            ("📝", "📝 自定义漂浮字幕", self.function4),
            ("💖", "💖 支持根号七", self.function888)
        ]
        for icon, text, cmd in nav_config:
            btn = ttk.Button(self.nav_frame, text=icon, style="Nav.TButton")
            btn.config(command=lambda b=btn, c=cmd: (self.set_selected_nav(b), c()))
            btn.pack(fill=tk.X, pady=4, padx=8)
            self.nav_buttons.append((btn, icon, text))

        # 侧边栏底部用户信息
        bottom_frame = tk.Frame(self.nav_frame, bg="white")
        bottom_frame.pack(side=tk.BOTTOM, fill=tk.X, padx=0, pady=0)
        tk.Label(bottom_frame, text="——用户信息——————————", font=("微软雅黑", 10, "bold"),
                 bg="white", fg="#666666").pack(anchor=tk.W, padx=12, pady=(0, 2))

        self.tip_frame = None
        self.tip_label = None

        # 头像与用户名
        user_row = tk.Frame(bottom_frame, bg="white")
        user_row.pack(anchor=tk.W, padx=8, pady=(0, 10))
        tk.Label(user_row, image=self.user_avatar, bg="white").pack(side=tk.LEFT, padx=4)
        self.name_label = tk.Label(user_row, text=self.username, font=("微软雅黑", 11), bg="white", cursor="hand2")
        self.name_label.pack(side=tk.LEFT)
        self.name_label.bind("<Button-1>", lambda e: self.start_edit_name())

        self.name_edit_var = tk.StringVar(value=self.username)
        self.name_entry = None
        self.confirm_btn = None
        self.cancel_btn = None

        # 导航栏宽度自适应文字/图标
        def update_btn_text():
            w = self.nav_frame.winfo_width()
            for btn, ico, txt in self.nav_buttons:
                btn.config(text=txt if w > 180 else ico)
            self.root.after(50, update_btn_text)
        update_btn_text()
        self.set_selected_nav(self.nav_buttons[0][0])

        # 底部版本栏
        self.footer_frame = tk.Frame(self.root, bg="#DCDCDC", height=28)
        self.footer_frame.pack(fill=tk.X, side=tk.BOTTOM, before=self.header_frame)
        self.footer_frame.pack_propagate(False)

        version_label = tk.Label(self.footer_frame,
                                 text=f"根号七的工具箱{VERSION} | 版本号:{VERNO}",
                                 font=("微软雅黑", 9),
                                 bg="#DCDCDC",
                                 fg="black")
        version_label.pack(side=tk.RIGHT, padx=15, pady=4)

        # 提升侧边栏层级，使其覆盖在主界面上方
        self.nav_frame.lift()

    # 昵称修改功能
    def start_edit_name(self):
        # 进入用户名编辑状态
        if self.is_editing:
            return
        self.is_editing = True
        self.name_label.pack_forget()

        self.name_edit_var.set(self.username)
        self.name_entry = tk.Entry(self.name_label.master, textvariable=self.name_edit_var,
                                   font=("微软雅黑", 11), width=8, bg="#f8f8f8")
        self.name_entry.pack(side=tk.LEFT, padx=(2, 4))
        self.name_entry.focus()

        self.confirm_btn = tk.Button(self.name_label.master, text="确定", font=("微软雅黑", 9),
                                     bg="#3a7aff", fg="white", relief=tk.FLAT, padx=6, pady=1,
                                     command=self.confirm_edit_name)
        self.cancel_btn = tk.Button(self.name_label.master, text="取消", font=("微软雅黑", 9),
                                    bg="white", fg="#333", relief=tk.FLAT, padx=6, pady=1,
                                    command=self.cancel_edit_name)
        self.confirm_btn.pack(side=tk.LEFT, padx=2)
        self.cancel_btn.pack(side=tk.LEFT, padx=2)

        self.name_entry.bind("<Return>", lambda e: self.confirm_edit_name())
        self.name_entry.bind("<Escape>", lambda e: self.cancel_edit_name())

    def cancel_edit_name(self):
        # 取消用户名编辑
        self.hide_tip()
        self.is_editing = False
        self.name_entry.destroy()
        self.confirm_btn.destroy()
        self.cancel_btn.destroy()
        self.name_label.pack(side=tk.LEFT)

    def confirm_edit_name(self):
        # 确认修改用户名，包含格式校验
        new_name = self.name_edit_var.get().strip()
        if len(new_name) == 0 or len(new_name) > 8:
            self.show_tip("长度必须 1~8 位")
            return
        if not re.fullmatch(r'^[\u4e00-\u9fa5a-zA-Z0-9\.\-_]+$', new_name):
            self.show_tip("仅支持中文、英文、小数点、划线 和 下划线")
            return

        self.hide_tip()
        self.username = new_name
        self.name_label.config(text=new_name)
        self.cancel_edit_name()

    def show_tip(self, msg):
        # 显示错误提示标签
        self.hide_tip()
        self.tip_label = tk.Label(self.nav_frame, text=msg, font=("微软雅黑", 9),
                                  bg="#ffebee", fg="#d32f2f", padx=6, pady=2)
        self.tip_label.place(relx=0.05, rely=0.82)

    def hide_tip(self):
        # 隐藏错误提示标签
        if self.tip_label:
            self.tip_label.destroy()
            self.tip_label = None

    # ===================== 功能界面 =====================

    def function0(self):
        self.clear_main_frame()
        self.current_module = "home"

        main_container = tk.Frame(self.main_frame, bg=self.bg_color)
        main_container.pack(fill=tk.BOTH, expand=True)

        canvas = tk.Canvas(main_container, bg=self.bg_color, highlightthickness=0)
        content_frame = tk.Frame(canvas, bg=self.bg_color)

        def update_scrollregion(event):
            canvas.config(scrollregion=canvas.bbox("all"))

        content_frame.bind("<Configure>", update_scrollregion)

        def update_content_width(event):
            try:
                canvas.itemconfig(win_id, width=canvas.winfo_width())
            except:
                pass

        canvas.bind("<Configure>", update_content_width)

        win_id = canvas.create_window((0, 0), window=content_frame, anchor="nw")
        canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)


        # 平滑滚动参数
        self.scroll_vel = 0
        self.scroll_fric = 0  # 惯性 越大越丝滑、滑得越久
        self.scroll_step = 1.0  # 幅度 越小越慢

        # 鼠标滚轮滚动
        def smooth_scroll_loop():
            if abs(self.scroll_vel) < 0.05:
                return
            canvas.yview_scroll(int(self.scroll_vel), "units")
            self.scroll_vel *= self.scroll_fric
            self.root.after(15, smooth_scroll_loop)

        # 鼠标滚轮触发
        def on_wheel(event):
            delta = event.delta // 120
            self.scroll_vel += -delta * self.scroll_step
            smooth_scroll_loop()

        self.root.bind("<MouseWheel>", on_wheel)

        # ===================== 页面内容 =====================
        tk.Label(content_frame, text="欢迎使用 根号七的工具箱",
                 font=("微软雅黑", 24, "bold"), bg=self.bg_color,
                 fg=self.primary_color).pack(pady=40)

        tk.Label(content_frame, text="左侧工具栏可选择对应工具",
                 font=("微软雅黑", 14), bg=self.bg_color,
                 fg=self.text_color).pack(pady=10)

        tk.Label(content_frame, text="F11切换全屏 | Esc退出全屏 | Ctrl+Q退出程序",
                 font=("微软雅黑", 12), bg=self.bg_color,
                 fg=self.text_color).pack(pady=20)

        notice_frame = tk.Frame(content_frame, bg="white", bd=2, relief=tk.RIDGE)
        notice_frame.pack(fill=tk.X, padx=20, pady=20, expand=True)

        tk.Label(notice_frame, text="新增&修复 功能",
                 font=("微软雅黑", 16, "bold"), bg="white",
                 fg=self.primary_color).pack(pady=(18, 12), anchor="w", padx=25)

        version_data = [
            {
                "ver": "v2.2.4",
                "content": [
                    "1. 首页优化为可用滚轮滑动的长界面",
                    "2. 更改了工具栏展开的逻辑，现在展开不会再压缩工具界面",
                    "3. 优化工具栏的展开效果，现在更加丝滑"
                ]
            },
            {
                "ver": "v2.2.3",
                "content": [
                    "1. 增强计算器功能，支持复杂数学运算、科学计算、进制转换。"
                ]
            },
            {
                "ver": "v2.2.2",
                "content": [
                    "1. 修复快捷键无法使用的问题，更换为F功能键。",
                    "2. 完善漂浮字幕功能，优化显示效果。"
                ]
            },
            {
                "ver": "v2.2.1",
                "content": [
                    "1. 界面与功能细节优化。"
                ]
            },
            {
                "ver": "v2.1.n",
                "content": [
                    "1. 新增鼠标连点器功能。",
                    "2. 新增自定义漂浮字幕功能。",
                    "3. 优化整体UI与使用体验。"
                ]
            },

            {
                "ver": "V2.0.n",
                "content": [
                    "1. 将原来的粗糙界面更新为现在的简约风格",
                    "2. 新增主页、网页导航、计算器、支持根号七四个功能",
                    "3. 新增工具栏折叠状态，以及平移动画",
                    "4. 优化整体UI与使用体验。"
                ]
            },
        {
                "ver": "V1 完结！",
                "content": [
                    "1. 已打包",
                    "2. 太垃圾了，就不让大家看了"
            ]
             },
            {
                "ver": "V1.1",
                "content": [
                    "1. 将背景变为渐变风格",
                    "2. 新增第二个按钮“暂无更多”",
                    "3. 新增进群、b站关注功能"
                ]
            },
            {
                "ver": "V1.0",
                "content": [
                    "1. “写”下第一个代码",
                    "2. 新增第一个按钮“打开bilibili网站”",
                    "3. 新增赞赏功能"
                ]
            },
        {
                "ver": "制作之前",
                "content": [
                    "1. 梦想做一个爆火的工具箱",
                    "2. B站寻找Python教程",
                    "3. 下载豆包，全程指挥豆包给我写代码"
                ]
            },
        {
                "ver": "暂无更多历史记录",
                "content": [
                    "谢谢你能耐心地看到这里",
                    "有没有建议什么想对我说的呢？",
                    "左侧工具栏点击“支持根号七”通过第二栏进群，或通过第三栏找到我的B站账号，以提交意见",
                    ""
                ]
            }
        ]

        for item in version_data:
            tk.Label(notice_frame, text=item["ver"],
                     font=("微软雅黑", 13, "bold"), bg="white").pack(anchor="w", padx=30, pady=(8, 4))
            for txt in item["content"]:
                tk.Label(notice_frame, text=txt,
                         font=("微软雅黑", 11), bg="white", justify="left").pack(anchor="w", padx=45, pady=2)

        tk.Label(content_frame, text="", bg=self.bg_color).pack(pady=20)

        tk.Label(content_frame, text="该应用由 三分之根号七 制作",
                 font=("微软雅黑", 24, "bold"), bg=self.bg_color,
                 fg=self.primary_color).pack(pady=20)
        tk.Label(content_frame, text="谢谢你的支持~",
                 font=("微软雅黑", 12), bg=self.bg_color,
                 fg=self.text_color).pack(pady=20)

    def function1(self):
        # 加载网址导航界面
        self.clear_main_frame()
        self.current_module = "nav"
        tk.Label(self.main_frame, text="🧭 网址导航", font=("微软雅黑", 22, "bold"), bg=self.bg_color,
                 fg=self.primary_color).pack(pady=(10, 5), anchor="w")
        tk.Label(self.main_frame, text="网址为作者推荐", font=("微软雅黑", 10), bg=self.bg_color, fg="#9CA3AF").pack(pady=(0, 20), anchor="w")

        # 搜索栏
        search_frame = tk.Frame(self.main_frame, bg=self.bg_color)
        search_frame.pack(fill=tk.X, pady=10)
        search_engine = tk.StringVar(value="百度")
        engine_combobox = ttk.Combobox(search_frame, textvariable=search_engine, values=["百度", "必应", "搜狗", "哔哩哔哩 搜视频"],
                                       state="readonly", width=10, font=("微软雅黑", 24))
        engine_combobox.pack(side=tk.LEFT, padx=5)

        def search():
            # 执行网页搜索
            query = self.search_entry.get().strip()
            if not query or query == "输入搜索内容":
                messagebox.showwarning("提示", "请输入搜索内容")
                return
            engine = search_engine.get()
            url_map = {
                "百度": f"https://www.baidu.com/s?wd={query}",
                "必应": f"https://cn.bing.com/search?q={query}",
                "搜狗": f"https://www.sogou.com/web?query={query}",
                "哔哩哔哩 搜视频": f"https://search.bilibili.com/all?keyword={query}"
            }
            webbrowser.open_new_tab(url_map[engine])

        search_btn = tk.Button(search_frame, text="搜索", font=("微软雅黑", 15, "bold"),
                               bg=self.primary_color, fg="white", relief=tk.FLAT, command=search)
        search_btn.pack(side=tk.RIGHT, padx=5)

        self.search_entry = tk.Entry(search_frame, font=("微软雅黑", 24))
        self.search_entry.pack(side=tk.LEFT, padx=5, fill=tk.X, expand=True, ipady=2)
        self.search_entry.insert(0, "输入搜索内容")
        self.search_entry.bind("<Return>", lambda e: search())

        # 常用网址
        website_list = [
            ("哔哩哔哩", "https://www.bilibili.com"),
            ("抖音", "https://www.douyin.com"),
            ("豆包", "https://www.doubao.com"),
            ("Deepseek", "https://www.deepseek.com"),
            ("CCTV", "https://www.cctv.com"),
            ("MBTI测试","https://www.jyshare.com/front-end/10312/"),
            ("B站关注", "https://space.bilibili.com/3493288684292639")
        ]
        btn_container = tk.Frame(self.main_frame, bg=self.bg_color)
        btn_container.pack(fill=tk.BOTH, expand=True)

        def open_website(site_name, site_url):
            # 打开指定网址
            if messagebox.askyesno("导航提示", f"是否打开【{site_name}】官网？"):
                try:
                    webbrowser.open_new_tab(site_url)
                except Exception as e:
                    messagebox.showerror("跳转失败", f"打开网站失败：{str(e)}")

        col_count = 7
        for index, (site_name, site_url) in enumerate(website_list):
            row = index // col_count
            col = index % col_count
            nav_btn = tk.Button(btn_container, text=site_name,
                                command=lambda name=site_name, url=site_url: open_website(name, url),
                                width=16, font=("微软雅黑", 14), bg=self.primary_color,
                                fg="white", relief=tk.FLAT, cursor="hand2")
            nav_btn.grid(row=row, column=col, padx=6, pady=6, sticky="nsew")
        for col in range(col_count):
            btn_container.grid_columnconfigure(col, weight=1)

    def function2(self):
        # 加载计算器功能界面（增强科学计算+进制转换）
        self.clear_main_frame()
        self.current_module = "calculator"
        self.calc_expression = ""
        main_container = tk.Frame(self.main_frame, bg=self.bg_color)
        main_container.pack(fill=tk.BOTH, expand=True)

        # 左右布局：计算器 + 历史记录
        calc_frame = tk.Frame(main_container, bg=self.bg_color)
        calc_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=(0, 15))

        tk.Label(calc_frame, text="🧮 计算器", font=("微软雅黑", 20, "bold"), bg=self.bg_color,
                 fg=self.primary_color).pack(pady=(0, 15), anchor="w")

        # 模式切换
        self.calc_mode = tk.StringVar(value="普通模式")
        mode_box = ttk.Combobox(calc_frame, textvariable=self.calc_mode,
                                values=["普通模式", "科学模式"], state="readonly", width=12)
        mode_box.pack(anchor="w", pady=5)
        mode_box.bind("<<ComboboxSelected>>", lambda e: self.refresh_calc_buttons())

        # 显示屏
        self.calc_display = tk.Entry(calc_frame, font=("微软雅黑", 24), justify="right", bd=10, bg="white",
                                     relief=tk.FLAT)
        self.calc_display.pack(fill=tk.X, pady=10, ipady=15)

        # 按钮容器
        self.btn_frame = tk.Frame(calc_frame, bg=self.bg_color)
        self.btn_frame.pack(fill=tk.BOTH, expand=True, pady=10)

        # 初始渲染普通按钮
        self.refresh_calc_buttons()

        # 绑定键盘
        self.root.bind("<Key>", self.calc_keyboard_input)

        # ========== 右侧进制转换 + 历史记录 ==========
        right_frame = tk.Frame(main_container, bg="white", bd=2, relief=tk.RIDGE, width=280)
        right_frame.pack(side=tk.RIGHT, fill=tk.BOTH, expand=False, padx=(15, 0))
        right_frame.pack_propagate(False)

        # 进制转换
        tk.Label(right_frame, text="🔢 进制转换", font=("微软雅黑", 12, "bold"), bg="white").pack(pady=10)
        self.dec_var = tk.StringVar()
        self.bin_var = tk.StringVar()
        self.oct_var = tk.StringVar()
        self.hex_var = tk.StringVar()

        for txt, var in [("十进制:", self.dec_var), ("二进制:", self.bin_var), ("八进制:", self.oct_var),
                         ("十六进制:", self.hex_var)]:
            row = tk.Frame(right_frame, bg="white")
            row.pack(fill=tk.X, padx=10, pady=2)
            tk.Label(row, text=txt, bg="white", width=8, anchor="w").pack(side=tk.LEFT)
            ent = tk.Entry(row, textvariable=var, font=("微软雅黑", 10))
            ent.pack(side=tk.LEFT, fill=tk.X, expand=True)
            ent.bind("<Return>", lambda e: self.convert_base())

        ttk.Button(right_frame, text="一键转换", command=self.convert_base, style="Primary.TButton").pack(pady=8,
                                                                                                          padx=10,
                                                                                                          fill=tk.X)
        ttk.Button(right_frame, text="清空进制", command=self.clear_base, style="Primary.TButton").pack(pady=4, padx=10,
                                                                                                        fill=tk.X)

        # 历史记录
        tk.Label(right_frame, text="📝 计算历史记录", font=("微软雅黑", 12, "bold"), bg="white").pack(pady=15)
        self.history_display = scrolledtext.ScrolledText(right_frame, font=("微软雅黑", 10), wrap=tk.WORD,
                                                         bg="#F8FAFC", state=tk.DISABLED)
        self.history_display.pack(fill=tk.BOTH, expand=True, padx=10, pady=5)

        def clear_calc_history():
            self.calc_history = []
            self.update_history_display()

        ttk.Button(right_frame, text="清空历史记录", command=clear_calc_history, style="Primary.TButton").pack(pady=10,
                                                                                                               padx=10,
                                                                                                               fill=tk.X)
        self.update_history_display()

    # 计算器内部依赖函数
    def refresh_calc_buttons(self):
        # 清空旧按钮
        for w in self.btn_frame.winfo_children():
            w.destroy()
        mode = self.calc_mode.get()
        if mode == "普通模式":
            buttons = [
                ("C", 0, 0, "#EF4444", "white"), ("←", 0, 1, "#F59E0B", "white"), ("%", 0, 2, "#F59E0B", "white"),
                ("÷", 0, 3, "#F59E0B", "white"),
                ("7", 1, 0, "white", self.text_color), ("8", 1, 1, "white", self.text_color),
                ("9", 1, 2, "white", self.text_color), ("×", 1, 3, "#F59E0B", "white"),
                ("4", 2, 0, "white", self.text_color), ("5", 2, 1, "white", self.text_color),
                ("6", 2, 2, "white", self.text_color), ("-", 2, 3, "#F59E0B", "white"),
                ("1", 3, 0, "white", self.text_color), ("2", 3, 1, "white", self.text_color),
                ("3", 3, 2, "white", self.text_color), ("+", 3, 3, "#F59E0B", "white"),
                ("00", 4, 0, "white", self.text_color), ("0", 4, 1, "white", self.text_color),
                (".", 4, 2, "white", self.text_color), ("=", 4, 3, self.primary_color, "white"),
            ]
        else:
            buttons = [
                ("sin", 0, 0, "#E9E9E9", "#333"), ("cos", 0, 1, "#E9E9E9", "#333"), ("tan", 0, 2, "#E9E9E9", "#333"),
                ("π", 0, 3, "#E9E9E9", "#333"),
                ("√", 1, 0, "#E9E9E9", "#333"), ("x²", 1, 1, "#E9E9E9", "#333"), ("x³", 1, 2, "#E9E9E9", "#333"),
                ("e", 1, 3, "#E9E9E9", "#333"),
                ("(", 2, 0, "white", self.text_color), (")", 2, 1, "white", self.text_color),
                ("!", 2, 2, "white", self.text_color), ("/", 2, 3, "#F59E0B", "white"),
                ("7", 3, 0, "white", self.text_color), ("8", 3, 1, "white", self.text_color),
                ("9", 3, 2, "white", self.text_color), ("×", 3, 3, "#F59E0B", "white"),
                ("4", 4, 0, "white", self.text_color), ("5", 4, 1, "white", self.text_color),
                ("6", 4, 2, "white", self.text_color), ("-", 4, 3, "#F59E0B", "white"),
                ("1", 5, 0, "white", self.text_color), ("2", 5, 1, "white", self.text_color),
                ("3", 5, 2, "white", self.text_color), ("+", 5, 3, "#F59E0B", "white"),
                ("C", 6, 0, "#EF4444", "white"), ("←", 6, 1, "#F59E0B", "white"), ("0", 6, 2, "white", self.text_color),
                ("=", 6, 3, self.primary_color, "white"),
            ]
        for text, row, col, bg, fg in buttons:
            btn = tk.Button(self.btn_frame, text=text, font=("微软雅黑", 12, "bold"), bg=bg, fg=fg, bd=0,
                            relief=tk.FLAT,
                            command=lambda t=text: self.calc_btn_click(t))
            btn.grid(row=row, column=col, padx=3, pady=3, sticky="nsew")
        max_row = max(b[1] for b in buttons)
        max_col = max(b[2] for b in buttons)
        for i in range(max_row + 1):
            self.btn_frame.grid_rowconfigure(i, weight=1)
        for i in range(max_col + 1):
            self.btn_frame.grid_columnconfigure(i, weight=1)

    def calc_btn_click(self, value):
        import math
        if value == "C":
            self.calc_expression = ""
            self.calc_display.delete(0, tk.END)
        elif value == "←":
            self.calc_expression = self.calc_expression[:-1]
            self.calc_display.delete(0, tk.END)
            self.calc_display.insert(tk.END, self.calc_expression)
        elif value == "=":
            self.calc_result()
        elif value == "π":
            self.calc_expression += str(math.pi)
        elif value == "e":
            self.calc_expression += str(math.e)
        elif value == "√":
            self.calc_expression += "math.sqrt("
        elif value == "x²":
            self.calc_expression += "**2"
        elif value == "x³":
            self.calc_expression += "**3"
        elif value == "sin":
            self.calc_expression += "math.sin(math.radians("
        elif value == "cos":
            self.calc_expression += "math.cos(math.radians("
        elif value == "tan":
            self.calc_expression += "math.tan(math.radians("
        elif value == "!":
            self.calc_expression += "math.factorial("
        else:
            self.calc_expression += value
        self.calc_display.delete(0, tk.END)
        self.calc_display.insert(tk.END, self.calc_expression)

    def is_valid_expression(self, exp):
        if not exp:
            return False
        if exp[0] in "+×÷%.)" or exp[-1] in "+-×÷%.(":
            return False
        invalid = ["++", "+-", "+×", "+÷", "-+", "--", "-×", "-÷", "×+", "×-", "××", "×÷", "÷+", "÷-", "÷×", "÷÷", ".."]
        for s in invalid:
            if s in exp:
                return False
        return True

    def calc_result(self):
        import math
        if not self.is_valid_expression(self.calc_expression):
            self.calc_display.delete(0, tk.END)
            self.calc_display.insert(tk.END, "表达式错误")
            self.calc_expression = ""
            return
        try:
            expr = self.calc_expression.replace("×", "*").replace("÷", "/")
            res = eval(expr, {"__builtins__": None, "math": math})
            if isinstance(res, float) and res.is_integer():
                res = int(res)
            self.calc_history.append(f"{self.calc_expression} = {res}")
            self.update_history_display()
            self.calc_display.delete(0, tk.END)
            self.calc_display.insert(tk.END, str(res))
            self.calc_expression = str(res)
        except ZeroDivisionError:
            self.calc_display.delete(0, tk.END)
            self.calc_display.insert(tk.END, "除数不能为0")
            self.calc_expression = ""
        except:
            self.calc_display.delete(0, tk.END)
            self.calc_display.insert(tk.END, "表达式错误")
            self.calc_expression = ""

    def calc_keyboard_input(self, event):
        key = event.keysym
        key_map = {
            "0": "0", "1": "1", "2": "2", "3": "3", "4": "4", "5": "5", "6": "6", "7": "7", "8": "8", "9": "9",
            "period": ".", "KP_Decimal": ".", "plus": "+", "KP_Add": "+", "minus": "-", "KP_Subtract": "-",
            "asterisk": "×", "KP_Multiply": "×", "slash": "÷", "KP_Division": "÷"
        }
        if key in key_map:
            self.calc_expression += key_map[key]
        elif key == "Return":
            self.calc_result()
        elif key == "BackSpace":
            self.calc_expression = self.calc_expression[:-1]
        elif key == "Delete":
            self.calc_expression = ""
        self.calc_display.delete(0, tk.END)
        self.calc_display.insert(tk.END, self.calc_expression)

    def convert_base(self):
        try:
            dec = int(self.dec_var.get().strip())
            self.bin_var.set(bin(dec)[2:])
            self.oct_var.set(oct(dec)[2:])
            self.hex_var.set(hex(dec)[2:].upper())
        except:
            pass

    def clear_base(self):
        self.dec_var.set("")
        self.bin_var.set("")
        self.oct_var.set("")
        self.hex_var.set("")

    def update_history_display(self):
        self.history_display.config(state=tk.NORMAL)
        self.history_display.delete(1.0, tk.END)
        for item in reversed(self.calc_history):
            self.history_display.insert(tk.END, f"▶ {item}\n\n")
        self.history_display.config(state=tk.DISABLED)

    def function4(self):
        # 加载悬浮字幕功能界面
        self.clear_main_frame()
        self.current_module = "float_text"

        tk.Label(self.main_frame, text="📝 自定义漂浮字幕", font=("微软雅黑", 22, "bold"),
                 bg=self.bg_color, fg=self.primary_color).pack(pady=(10, 20), anchor="w")

        main_panel = tk.Frame(self.main_frame, bg=self.bg_color)
        main_panel.pack(fill=tk.BOTH, expand=True, padx=0, pady=5)

        frame = tk.Frame(main_panel, bg="white", bd=2, relief=tk.RIDGE)
        frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=0, pady=0)
        inner = tk.Frame(frame, bg="white")
        inner.pack(padx=20, pady=18, fill=tk.X)

        tk.Label(inner, text="字幕内容：", bg="white", font=("微软雅黑", 12)).grid(row=0, column=0, sticky="w", padx=5, pady=5)
        self.float_text_entry = tk.Text(inner, font=("微软雅黑", 12), width=30, height=3, wrap=tk.WORD)
        self.float_text_entry.grid(row=0, column=1, columnspan=3, padx=5, pady=5, sticky="ew")
        self.float_text_entry.insert("1.0", "点击修改漂浮字幕")

        tk.Label(inner, text="横向坐标：", bg="white", font=("微软雅黑", 12)).grid(row=1, column=0, sticky="w", padx=5, pady=5)
        self.float_x_entry = tk.Entry(inner, font=("微软雅黑", 12), width=10)
        self.float_x_entry.grid(row=1, column=1, padx=5, pady=5)
        self.float_x_entry.insert(0, "100")

        tk.Label(inner, text="纵向坐标：", bg="white", font=("微软雅黑", 12)).grid(row=1, column=2, sticky="w", padx=5, pady=5)
        self.float_y_entry = tk.Entry(inner, font=("微软雅黑", 12), width=10)
        self.float_y_entry.grid(row=1, column=3, padx=5, pady=5)
        self.float_y_entry.insert(0, "100")

        tk.Label(inner, text="文本大小：", bg="white", font=("微软雅黑", 12)).grid(row=2, column=0, sticky="w", padx=5, pady=5)
        self.float_size_entry = tk.Entry(inner, font=("微软雅黑", 12), width=10)
        self.float_size_entry.grid(row=2, column=1, padx=5, pady=5)
        self.float_size_entry.insert(0, "24")

        tk.Label(inner, text="文本字体：", bg="white", font=("微软雅黑", 12)).grid(row=3, column=0, sticky="w", padx=5, pady=5)
        self.float_font_entry = tk.Entry(inner, font=("微软雅黑", 12), width=10)
        self.float_font_entry.grid(row=3, column=1, padx=5, pady=5)
        self.float_font_entry.insert(0, "微软雅黑")

        tk.Label(inner, text="文本颜色：", bg="white", font=("微软雅黑", 12)).grid(row=4, column=0, sticky="w", padx=5, pady=5)
        self.color_btn = tk.Button(inner, text="选择颜色", command=self.choose_float_color, bg="#ff0000", fg="white", font=("微软雅黑", 10))
        self.color_btn.grid(row=4, column=1, padx=5, pady=5)

        tk.Label(inner, text="背景颜色：", bg="white", font=("微软雅黑", 12)).grid(row=5, column=0, sticky="w", padx=5, pady=5)
        self.bg_color_btn = tk.Button(inner, text="选择颜色", command=self.choose_float_bg_color, bg="#00FF00", fg="white", font=("微软雅黑", 10))
        self.bg_color_btn.grid(row=5, column=1, padx=5, pady=5)

        tk.Label(inner, text="透明度：", bg="white", font=("微软雅黑", 12)).grid(row=6, column=0, sticky="w", padx=5, pady=5)
        self.alpha_scale = tk.Scale(inner, from_=1, to=100, variable=self.float_alpha, orient=tk.HORIZONTAL, bg="white")
        self.alpha_scale.grid(row=6, column=1, columnspan=3, sticky="ew", padx=5, pady=5)
        self.alpha_scale.set(100)

        # 预设文本
        tk.Label(inner, text="预设：", bg="white", font=("微软雅黑", 12)).grid(row=7, column=0, sticky="w", padx=5, pady=8)
        def preset1():
            self.float_text_entry.delete("1.0", tk.END)
            self.float_text_entry.insert("1.0", "现在时间：{year}年{month}月{day}日 {hour}:{minute}:{second}")
        def preset2():
            self.float_text_entry.delete("1.0", tk.END)
            self.float_text_entry.insert("1.0", "默认文本")
        ttk.Button(inner, text="当前时间", command=preset1).grid(row=7, column=1, padx=3, pady=8)
        ttk.Button(inner, text="暂无更多", command=preset2).grid(row=7, column=2, padx=3, pady=8)

        # 使用说明
        help_frame = tk.Frame(main_panel, bg="white", bd=2, relief=tk.RIDGE)
        help_frame.pack(side=tk.RIGHT, padx=(10, 0), fill=tk.Y)
        tk.Label(help_frame, text="📌 变量使用说明", font=("微软雅黑", 14, "bold"), bg="white").pack(pady=(15, 10), padx=15)
        help_text = """输入以下内容可自动显示：
{year}   →  当前年份
{month}  →  当前月份
{day}   →  今日日期
{hour}   →  当前小时
{minute} →  当前分钟
{second} →  当前秒数
{math:表达式} → 计算结果
\\n → 换行"""
        tk.Label(help_frame, text=help_text, justify=tk.LEFT, font=("微软雅黑", 11), bg="white", fg="#333333").pack(anchor="w", padx=15, pady=5)

        # 控制按钮
        btn_frame = tk.Frame(self.main_frame, bg=self.bg_color)
        btn_frame.pack(pady=12)
        tk.Button(btn_frame, text="💬 显示字幕", font=("微软雅黑", 12, "bold"),
                  bg=self.primary_color, fg="white", relief=tk.FLAT, padx=18, pady=6,
                  command=self.show_float_text).grid(row=0, column=0, padx=8)
        tk.Button(btn_frame, text="❌ 隐藏字幕", font=("微软雅黑", 12, "bold"),
                  bg="#dc2626", fg="white", relief=tk.FLAT, padx=18, pady=6,
                  command=self.hide_float_text).grid(row=0, column=1, padx=8)

        self.float_status = tk.Label(self.main_frame, text="状态：已停止", font=("微软雅黑", 13),
                                     bg=self.bg_color, fg=self.text_color)
        self.float_status.pack(pady=4)

        float_hk_frame = tk.Frame(self.main_frame, bg=self.bg_color)
        float_hk_frame.pack(pady=4)
        tk.Label(float_hk_frame, text="快捷键：F10 切换显示/隐藏", font=("微软雅黑", 12), bg=self.bg_color).pack(side=tk.LEFT)
        tk.Checkbutton(float_hk_frame, text="启用快捷键", variable=self.float_hotkey_enabled,
                       bg=self.bg_color, font=("微软雅黑", 11)).pack(side=tk.LEFT, padx=8)

    def choose_float_color(self):
        #选择字幕文字颜色
        color = colorchooser.askcolor(title="选择文字颜色")[1]
        if color:
            self.float_color = color
            self.color_btn.config(bg=color)

    def choose_float_bg_color(self):
        #选择字幕背景颜色
        color = colorchooser.askcolor(title="选择背景颜色")[1]
        if color:
            self.float_bg_color = color
            self.bg_color_btn.config(bg=color)

    def set_click_through(self, hwnd):
        #设置窗口鼠标穿透（Windows）
        if sys.platform == "win32":
            ex_style = win32gui.GetWindowLong(hwnd, win32con.GWL_EXSTYLE)
            ex_style |= win32con.WS_EX_LAYERED | win32con.WS_EX_TRANSPARENT
            win32gui.SetWindowLong(hwnd, win32con.GWL_EXSTYLE, ex_style)
            win32gui.SetLayeredWindowAttributes(hwnd, 0, 255, 2)

    def show_float_text(self):
        #创建并显示悬浮字幕窗口
        if self.float_window:
            self.float_window.destroy()

        try:
            self.float_x = int(self.float_x_entry.get())
            self.float_y = int(self.float_y_entry.get())
            self.float_font_size = int(self.float_size_entry.get())
            self.float_font_family = self.float_font_entry.get().strip()
        except ValueError:
            messagebox.showwarning("输入错误", "坐标和字体大小必须为数字")
            return

        self.float_window = tk.Toplevel(self.root)
        self.float_window.overrideredirect(True)
        self.float_window.geometry(f"+{self.float_x}+{self.float_y}")
        self.float_window.attributes("-topmost", True)
        self.float_window.attributes("-alpha", self.float_alpha.get() / 100)
        self.float_window.config(bg=self.float_bg_color)

        raw_text = self.float_text_entry.get("1.0", tk.END).strip()
        real_txt = self.parse_float_text(raw_text)

        self.float_label = tk.Label(self.float_window, text=real_txt,
                                    font=(self.float_font_family, self.float_font_size, "bold"),
                                    fg=self.float_color, bg=self.float_bg_color)
        self.float_label.pack()

        self.float_window.update()
        hwnd = self.float_window.winfo_id()
        self.set_click_through(hwnd)
        self.float_auto_refresh()

        self.float_running = True
        self.float_status.config(text="状态：运行中", fg="#e53e3e")

    def hide_float_text(self):
        #销毁悬浮字幕窗口
        if self.float_refresh_id:
            self.root.after_cancel(self.float_refresh_id)
            self.float_refresh_id = None
        if self.float_window:
            self.float_window.destroy()
            self.float_window = None
            self.float_label = None

        self.float_running = False
        self.float_status.config(text="状态：已停止", fg=self.text_color)

    def function888(self):
        #加载支持作者界面
        self.clear_main_frame()
        self.current_module = "support"
        tk.Label(self.main_frame, text="💖 支持根号七", font=("微软雅黑", 24, "bold"), bg=self.bg_color,
                 fg=self.primary_color).pack(pady=30)
        content_frame = tk.Frame(self.main_frame, bg=self.bg_color)
        content_frame.pack(fill=tk.BOTH, expand=True, padx=50)

        # 赞赏码
        zanshang = tk.Frame(content_frame, bg="white", bd=2, relief=tk.RIDGE)
        zanshang.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=10, pady=10)
        tk.Label(zanshang, text="💰 赞赏码", font=("微软雅黑", 16, "bold"), bg="white").pack(pady=20)
        try:
            img = Image.open("赞赏码.png").resize((200, 200))
            self.zan_img = ImageTk.PhotoImage(img)
            tk.Label(zanshang, image=self.zan_img, bg="white").pack()
            numbered_print(f"[{get_time_str()}] 图片 \"赞赏码.png\" 加载成功")
        except:
            tk.Label(zanshang, text="未找到图片", font=("微软雅黑", 12), bg="white").pack()
            numbered_print(f"[{get_time_str()}] 图片 \"赞赏码.png\" 加载失败，未找到图片")
        tk.Label(zanshang, text="谢谢老板~", font=("微软雅黑", 14, "bold"), bg="white", fg=self.primary_color).pack(pady=15)

        # 交流群
        qun = tk.Frame(content_frame, bg="white", bd=2, relief=tk.RIDGE)
        qun.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=10, pady=10)
        tk.Label(qun, text="👥 交流群", font=("微软雅黑", 16, "bold"), bg="white").pack(pady=20)
        try:
            img = Image.open("交流群.png").resize((180, 180))
            self.qun_img = ImageTk.PhotoImage(img)
            tk.Label(qun, image=self.qun_img, bg="white").pack()
            numbered_print(f"[{get_time_str()}] 图片 \"交流群.png\" 加载成功")
        except:
            tk.Label(qun, text="未找到图片", font=("微软雅黑", 12), bg="white").pack()
            numbered_print(f"[{get_time_str()}] 图片 \"交流群.png\" 加载失败，未找到图片")
        tk.Label(qun, text="群号：1083170749", font=("微软雅黑", 14, "bold"), bg="white", fg=self.primary_color).pack(pady=15)

        # B站关注
        bili = tk.Frame(content_frame, bg="white", bd=2, relief=tk.RIDGE)
        bili.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=10, pady=10)
        tk.Label(bili, text="📺 B站关注", font=("微软雅黑", 16, "bold"), bg="white").pack(pady=20)
        tk.Label(bili, text="UP主：根号七大玉", font=("微软雅黑", 14), bg="white").pack(pady=10)

        def open_bili():
            webbrowser.open("https://space.bilibili.com/3493288684292639")
        ttk.Button(bili, text="🚀 立即前往关注", command=open_bili, style="Primary.TButton").pack(pady=30)

numbered_print(f"[{get_time_str()}] 窗口 \"根号七的工具箱{VERSION}{VERNO}\" 初始化完成")

# ===================== 程序启动入口 ==========================

if __name__ == "__main__":

    if sys.platform == "win32":
        import ctypes
        try:
            ctypes.windll.shcore.SetProcessDpiAwareness(1)
        except:
            pass

    root = tk.Tk()
    app = ToolboxApp(root)
    app.setup_float_global_hotkeys()
    numbered_print(f"[{get_time_str()}] 窗口 \"根号七的工具箱{VERSION}{VERNO}\" 弹窗完成")
    root.mainloop()

# ============================================================

# 由三分之根号七制作
# 交流群1083170749
# B站 根号七大玉 -> https://space.bilibili.com/3493288684292639
# QQ 根号圆周率 -> https://qm.qq.com/q/LSNcYCkvmK 群号1083170749

# ============================================================