f.py

import os
import sys
import shutil
import json
import platform
import subprocess
import tkinter as tk
from tkinter import ttk, filedialog, messagebox, simpledialog
from datetime import datetime
import pandas as pd
import threading

class HospitalFileManager:
    VERSION = "2.3 Pro"
    COPYRIGHT = "© 李海峰 版权所有 | 大理大学第一附属医院"
    CONFIG_FILE = "config.json" # 配置文件名
    
    # 默认分类配置
    DEFAULT_CONFIG = {
        "文件类型过滤": [
            ".txt", ".doc", ".docx", ".pdf", ".xls", ".xlsx", 
            ".ppt", ".pptx", ".pps", ".jpg", ".png", ".exe", 
            ".rar", ".zip", ".7z", ".wav", ".mp3", ".mp4"
        ],
        "分类规则": {
            "通知": ["通知", "通告", "通报"],
            "请示": ["请示", "申请"],
            "报告": ["报告", "汇报", "总结"],
            "函": ["函", "公函"],
            "批复": ["批复"],
            "意见建议": ["意见", "建议"],
            "纪要": ["纪要", "会议记录"],
            "规章制度": ["办法", "制度", "规定", "条例"],
            "其他": [""]
        },
        "后缀分类规则": {
            "文档": [".doc", ".docx", ".pdf"],
            "表格": [".xls", ".xlsx", ".csv"],
            "演示文件": [".ppt", ".pptx", ".pps"],
            "文本文件": [".txt", ".md"],
            "图片": [".jpg", ".png", ".gif", ".jpeg", ".bmp"],
            "程序": [".exe", ".msi", ".bat"],
            "音视频": [".wav", ".mp3", ".mp4", ".avi", ".mov"],
            "压缩包": [".zip", ".rar", ".7z", ".tar", ".gz"],
            "其他": [""]
        }
    }

    def __init__(self):
        self.root = tk.Tk()
        self.root.title(f"大理大学第一附属医院综合文件管理工具 v{self.VERSION}")
        self.root.geometry("950x650")
        
        # 设置样式
        style = ttk.Style()
        style.theme_use('clam')
        style.configure("TButton", padding=6, relief="flat", background="#ccc")
        style.configure("Header.TLabel", font=('微软雅黑', 10, 'bold'))

        # 初始化变量
        self.load_local_config()
        self.progress_var = tk.DoubleVar()
        self.status_var = tk.StringVar(value="就绪")
        
        # 创建主界面
        self.create_main_interface()
        
    def load_local_config(self):
        """加载本地配置文件，如果不存在则使用默认"""
        if os.path.exists(self.CONFIG_FILE):
            try:
                with open(self.CONFIG_FILE, 'r', encoding='utf-8') as f:
                    self.config = json.load(f)
            except Exception as e:
                messagebox.showerror("配置错误", f"读取配置文件失败，将使用默认配置。\n错误：{e}")
                self.config = self.DEFAULT_CONFIG.copy()
        else:
            self.config = self.DEFAULT_CONFIG.copy()

    def save_local_config(self):
        """保存配置到本地文件"""
        try:
            with open(self.CONFIG_FILE, 'w', encoding='utf-8') as f:
                json.dump(self.config, f, indent=4, ensure_ascii=False)
        except Exception as e:
            messagebox.showerror("保存失败", f"无法保存配置文件：{e}")

    def create_main_interface(self):
        # 顶部标题栏
        header_frame = tk.Frame(self.root, bg="#2c3e50", height=50)
        header_frame.pack(fill=tk.X)
        tk.Label(header_frame, text=f" 🏥 {self.root.title()}", 
                 bg="#2c3e50", fg="white", font=("微软雅黑", 12, "bold")).pack(pady=10)

        # 选项卡容器
        self.notebook = ttk.Notebook(self.root)
        self.notebook.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)

        # --- 模块 1: 文件列表生成 ---
        self.tab_list = ttk.Frame(self.notebook)
        self.notebook.add(self.tab_list, text="📋 列表生成")
        self.init_list_generator_ui()

        # --- 模块 2: 智能分类 ---
        self.tab_classify = ttk.Frame(self.notebook)
        self.notebook.add(self.tab_classify, text="🗂️ 智能分类")
        self.init_classifier_ui()

        # --- 模块 3: 批量更名 ---
        self.tab_rename = ttk.Frame(self.notebook)
        self.notebook.add(self.tab_rename, text="✏️ 批量更名")
        self.init_renamer_ui()

        # --- 模块 4: 文件查找 ---
        self.tab_search = ttk.Frame(self.notebook)
        self.notebook.add(self.tab_search, text="🔍 极速查找")
        self.init_searcher_ui()

        # 底部状态栏
        status_frame = ttk.Frame(self.root, relief=tk.SUNKEN, padding=(5, 2))
        status_frame.pack(fill=tk.X, side=tk.BOTTOM)
        ttk.Label(status_frame, textvariable=self.status_var, font=("微软雅黑", 9)).pack(side=tk.LEFT)
        # 修复：将 ProgressBar 改为 Progressbar
        ttk.Progressbar(status_frame, variable=self.progress_var, length=200).pack(side=tk.RIGHT)
        ttk.Label(status_frame, text=self.COPYRIGHT + "  ", font=("微软雅黑", 8), foreground="gray").pack(side=tk.RIGHT)

    # ================= 工具方法 =================
    def update_status(self, text):
        self.status_var.set(text)
        self.root.update_idletasks()

    def is_hidden(self, filepath):
        """判断是否为隐藏文件"""
        name = os.path.basename(filepath)
        if name.startswith('.'): return True
        if platform.system() == 'Windows':
            try:
                attrs = os.stat(filepath).st_file_attributes
                return attrs & 2
            except: return False
        return False

    def open_file(self, path):
        """通用打开文件/文件夹方法"""
        try:
            if not os.path.exists(path):
                messagebox.showerror("错误", "文件不存在")
                return
            if platform.system() == "Windows": os.startfile(path)
            elif platform.system() == "Darwin": subprocess.call(["open", path])
            else: subprocess.call(["xdg-open", path])
        except Exception as e:
            messagebox.showerror("错误", f"无法打开：{str(e)}")

    # ================= 模块 1: 列表生成器逻辑 =================
    def init_list_generator_ui(self):
        frame = ttk.Frame(self.tab_list, padding=20)
        frame.pack(fill=tk.BOTH, expand=True)
        
        ttk.Label(frame, text="功能说明：扫描文件夹内所有文件并生成带超链接的Excel表格（含大小和时间）。", 
                  foreground="gray").pack(pady=10)
        
        btn = ttk.Button(frame, text="选择文件夹并开始生成", command=self.run_list_generator)
        btn.pack(pady=20, ipadx=20, ipady=10)
        
        self.list_log = tk.Text(frame, height=15, state=tk.DISABLED, bg="#f0f0f0")
        self.list_log.pack(fill=tk.BOTH, expand=True)

    def log_msg(self, widget, msg):
        widget.config(state=tk.NORMAL)
        widget.insert(tk.END, f"[{datetime.now().strftime('%H:%M:%S')}] {msg}\n")
        widget.see(tk.END)
        widget.config(state=tk.DISABLED)
        self.root.update()

    def run_list_generator(self):
        folder_path = filedialog.askdirectory(title="选择要扫描的文件夹")
        if not folder_path: return
        
        excel_path = os.path.join(folder_path, "文件列表.xlsx")
        if os.path.exists(excel_path):
            try: os.remove(excel_path) 
            except: pass

        self.update_status("正在扫描文件...")
        file_list = []
        total_files = sum([len(files) for r, d, files in os.walk(folder_path)])
        processed = 0
        
        try:
            for root, dirs, files in os.walk(folder_path):
                dirs[:] = [d for d in dirs if not self.is_hidden(os.path.join(root, d))]
                for file in files:
                    full_path = os.path.join(root, file)
                    if not self.is_hidden(full_path) and file != "文件列表.xlsx":
                        try:
                            stat_info = os.stat(full_path)
                            size_kb = stat_info.st_size / 1024
                            size_str = f"{size_kb:.2f} KB"
                            mtime_str = datetime.fromtimestamp(stat_info.st_mtime).strftime('%Y-%m-%d %H:%M:%S')
                        except:
                            size_str = "未知"
                            mtime_str = "未知"

                        relative_link = os.path.relpath(full_path, folder_path)
                        escaped_path = relative_link.replace('"', '""').replace("'", "''")
                        
                        file_list.append({
                            "文件名": file,
                            "链接": f'=HYPERLINK("{escaped_path}", "📂 打开")',
                            "文件大小": size_str,
                            "修改时间": mtime_str,
                            "所在路径": root,
                            "完整路径": full_path
                        })
                    
                    processed += 1
                    if processed % 10 == 0:
                        self.progress_var.set(processed / total_files * 100)
                        self.update_status(f"正在生成列表... {processed}/{total_files}")

            df = pd.DataFrame(file_list)
            with pd.ExcelWriter(excel_path, engine='xlsxwriter') as writer:
                cols = ["文件名", "链接", "文件大小", "修改时间", "所在路径"]
                df.to_excel(writer, index=False, sheet_name='文件列表', columns=cols)
                
                worksheet = writer.sheets['文件列表']
                worksheet.set_column('A:A', 45)
                worksheet.set_column('B:B', 8)
                worksheet.set_column('C:C', 12)
                worksheet.set_column('D:D', 20)
                worksheet.set_column('E:E', 50)
                link_format = writer.book.add_format({'font_color': 'blue', 'underline': 1})
                worksheet.set_column('B:B', None, link_format)

            self.log_msg(self.list_log, f"成功生成列表：{excel_path}")
            self.progress_var.set(100)
            if messagebox.askyesno("完成", "列表生成成功，是否立即打开？"):
                self.open_file(excel_path)

        except Exception as e:
            messagebox.showerror("错误", str(e))
        finally:
            self.update_status("就绪")

    # ================= 模块 2: 智能分类逻辑 =================
    def init_classifier_ui(self):
        paned = ttk.PanedWindow(self.tab_classify, orient=tk.HORIZONTAL)
        paned.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
        
        left_frame = ttk.Frame(paned)
        right_frame = ttk.Frame(paned)
        paned.add(left_frame, weight=1)
        paned.add(right_frame, weight=2)

        lbl_frame = ttk.LabelFrame(left_frame, text="源文件夹 (拖拽或添加)")
        lbl_frame.pack(fill=tk.BOTH, expand=True, padx=5)
        
        self.lst_sources = tk.Listbox(lbl_frame, height=10)
        self.lst_sources.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
        
        btn_box = ttk.Frame(lbl_frame)
        btn_box.pack(fill=tk.X, padx=5, pady=5)
        ttk.Button(btn_box, text="➕ 添加", command=self.add_classify_source).pack(side=tk.LEFT)
        ttk.Button(btn_box, text="➖ 移除", command=lambda: self.lst_sources.delete(tk.ANCHOR)).pack(side=tk.LEFT)
        ttk.Button(btn_box, text="🗑️ 清空", command=lambda: self.lst_sources.delete(0, tk.END)).pack(side=tk.RIGHT)

        dest_frame = ttk.Frame(left_frame)
        dest_frame.pack(fill=tk.X, pady=10)
        ttk.Label(dest_frame, text="目标文件夹:").pack(anchor="w")
        self.classify_target_var = tk.StringVar()
        entry_dest = ttk.Entry(dest_frame, textvariable=self.classify_target_var)
        entry_dest.pack(fill=tk.X, side=tk.LEFT, expand=True)
        ttk.Button(dest_frame, text="...", width=3, command=lambda: self.classify_target_var.set(filedialog.askdirectory())).pack(side=tk.LEFT)

        opt_frame = ttk.LabelFrame(right_frame, text="分类规则设置")
        opt_frame.pack(fill=tk.X, padx=5)
        
        self.classify_mode = tk.IntVar(value=1) 
        ttk.Radiobutton(opt_frame, text="按文件后缀归类 (推荐)", variable=self.classify_mode, value=1).pack(anchor="w", padx=10, pady=5)
        ttk.Radiobutton(opt_frame, text="按文件名关键词归类", variable=self.classify_mode, value=0).pack(anchor="w", padx=10, pady=5)
        
        btn_rule_manage = ttk.Button(opt_frame, text="⚙️ 管理/新增/修改 分类规则", command=self.open_rule_manager)
        btn_rule_manage.pack(anchor="w", padx=30, pady=5)
        
        self.keep_original = tk.BooleanVar(value=True)
        ttk.Checkbutton(opt_frame, text="保留原始文件 (复制模式)", variable=self.keep_original).pack(anchor="w", padx=10)

        ttk.Button(right_frame, text="🚀 开始智能分类", command=self.run_classifier).pack(pady=20, ipadx=20, ipady=5)
        
        self.classify_log = tk.Text(right_frame, height=10, state=tk.DISABLED, bg="#f0f0f0", font=("Consolas", 9))
        self.classify_log.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)

    # ================= 规则管理器逻辑 (已更新：支持修改) =================
    def open_rule_manager(self):
        win = tk.Toplevel(self.root)
        win.title("自定义分类规则管理")
        win.geometry("650x500") # 稍微加大窗口
        
        nb = ttk.Notebook(win)
        nb.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        self.create_rule_tab(nb, "后缀分类规则", "后缀列表 (用逗号分隔, 如: .jpg, .png)")
        self.create_rule_tab(nb, "分类规则", "关键词列表 (用逗号分隔, 如: 通知, 通告)")
        
        ttk.Label(win, text="提示：点击列表可编辑现有规则。修改后请点击“保存”生效。", foreground="gray").pack(pady=5)

    def create_rule_tab(self, notebook, config_key, hint_text):
        frame = ttk.Frame(notebook)
        notebook.add(frame, text="管理 " + ("后缀规则" if "后缀" in config_key else "关键词规则"))
        
        # 列表显示
        columns = ("category", "content")
        tree = ttk.Treeview(frame, columns=columns, show="headings", height=10)
        tree.heading("category", text="分类文件夹名")
        tree.heading("content", text="包含的内容")
        tree.column("category", width=150)
        tree.column("content", width=400)
        tree.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
        
        sb = ttk.Scrollbar(tree, orient="vertical", command=tree.yview)
        tree.configure(yscrollcommand=sb.set)
        sb.pack(side='right', fill='y')

        # 输入区域变量
        input_frame = ttk.LabelFrame(frame, text="编辑/新增区域")
        input_frame.pack(fill=tk.X, padx=5, pady=5)
        
        cat_var = tk.StringVar()
        content_var = tk.StringVar()

        # === 关键更新：点击列表自动填充输入框 ===
        def on_select(event):
            selected_items = tree.selection()
            if not selected_items: return
            item = tree.item(selected_items[0])
            values = item['values']
            # 填充到输入框
            cat_var.set(values[0])
            content_var.set(values[1])

        tree.bind('<<TreeviewSelect>>', on_select)
        # ======================================

        # 加载数据
        def load_data():
            tree.delete(*tree.get_children())
            for cat, content in self.config[config_key].items():
                content_str = ", ".join(content)
                tree.insert("", tk.END, values=(cat, content_str))
        load_data()

        # UI布局
        grid_frame = ttk.Frame(input_frame)
        grid_frame.pack(fill=tk.X, padx=5, pady=5)

        ttk.Label(grid_frame, text="分类名称:").grid(row=0, column=0, padx=5, sticky="e")
        ttk.Entry(grid_frame, textvariable=cat_var, width=20).grid(row=0, column=1, padx=5)
        
        ttk.Label(grid_frame, text=hint_text).grid(row=0, column=2, padx=5, sticky="e")
        ttk.Entry(grid_frame, textvariable=content_var, width=30).grid(row=0, column=3, padx=5)

        # 按钮功能
        def save_action():
            cat = cat_var.get().strip()
            raw_content = content_var.get().strip()
            if not cat or not raw_content:
                messagebox.showwarning("提示", "分类名称和内容不能为空", parent=frame)
                return
            
            content_list = [x.strip() for x in raw_content.replace("，", ",").split(",") if x.strip()]
            
            # 更新字典（如果是同名key，直接覆盖即为修改）
            self.config[config_key][cat] = content_list
            self.save_local_config()
            load_data()
            
            # 清空输入以便下一次操作
            cat_var.set("")
            content_var.set("")
            messagebox.showinfo("成功", f"规则 '{cat}' 已保存/更新！", parent=frame)

        def delete_action():
            selected = tree.selection()
            if not selected: return
            item = tree.item(selected[0])
            cat = item['values'][0]
            
            if messagebox.askyesno("确认", f"确定要删除分类规则 '{cat}' 吗？", parent=frame):
                del self.config[config_key][cat]
                self.save_local_config()
                load_data()
                # 如果删除的是当前正在编辑的，清空输入框
                if cat_var.get() == cat:
                    cat_var.set("")
                    content_var.set("")

        def clear_input():
            cat_var.set("")
            content_var.set("")
            # 取消列表选中状态
            if tree.selection():
                tree.selection_remove(tree.selection())

        btn_frame = ttk.Frame(input_frame)
        btn_frame.pack(fill=tk.X, padx=5, pady=5)
        
        ttk.Button(btn_frame, text="💾 保存/更新", command=save_action).pack(side=tk.LEFT, padx=5)
        ttk.Button(btn_frame, text="🧹 清空输入(新增模式)", command=clear_input).pack(side=tk.LEFT, padx=5)
        ttk.Button(btn_frame, text="🗑️ 删除选中", command=delete_action).pack(side=tk.RIGHT, padx=5)

    def add_classify_source(self):
        d = filedialog.askdirectory()
        if d: self.lst_sources.insert(tk.END, d)

    def run_classifier(self):
        sources = self.lst_sources.get(0, tk.END)
        target = self.classify_target_var.get()
        
        if not sources or not target:
            messagebox.showwarning("提示", "请先设置源文件夹和目标文件夹")
            return

        self.update_status("正在初始化分类任务...")
        total_files = 0
        for s in sources:
            for _, _, files in os.walk(s): total_files += len(files)
        processed_count = 0
        
        for source_path in sources:
            for root, dirs, files in os.walk(source_path):
                for file in files:
                    src_file = os.path.join(root, file)
                    category = "其他"
                    ext = os.path.splitext(file)[1].lower()
                    
                    if self.classify_mode.get() == 1:
                        for cat, exts in self.config["后缀分类规则"].items():
                            if ext in exts:
                                category = cat
                                break
                    else:
                        name = os.path.splitext(file)[0]
                        for cat, kws in self.config["分类规则"].items():
                            if any(kw in name for kw in kws):
                                category = cat
                                break
                    
                    dest_dir = os.path.join(target, category)
                    if not os.path.exists(dest_dir): os.makedirs(dest_dir)
                    
                    dest_file = os.path.join(dest_dir, file)
                    base, extension = os.path.splitext(dest_file)
                    counter = 1
                    while os.path.exists(dest_file):
                        dest_file = f"{base}_{counter}{extension}"
                        counter += 1
                    
                    try:
                        if self.keep_original.get():
                            shutil.copy2(src_file, dest_file)
                            action = "复制"
                        else:
                            shutil.move(src_file, dest_file)
                            action = "移动"
                        
                        processed_count += 1
                        if processed_count % 5 == 0:
                            self.log_msg(self.classify_log, f"{action}: {file} -> {category}")
                            self.progress_var.set(processed_count / total_files * 100)
                            self.update_status(f"处理中: {processed_count}/{total_files}")
                    except Exception as e:
                        self.log_msg(self.classify_log, f"错误: {file} - {str(e)}")

        self.progress_var.set(100)
        self.update_status("分类完成")
        messagebox.showinfo("完成", f"处理完成，共处理 {processed_count} 个文件")

    # ================= 模块 3: 批量更名逻辑 =================
    def init_renamer_ui(self):
        main_frame = ttk.Frame(self.tab_rename, padding=20)
        main_frame.pack(fill=tk.BOTH, expand=True)

        folder_frame = ttk.Frame(main_frame)
        folder_frame.pack(fill=tk.X)
        ttk.Label(folder_frame, text="目标文件夹:").pack(side=tk.LEFT)
        self.rename_path_var = tk.StringVar()
        ttk.Entry(folder_frame, textvariable=self.rename_path_var).pack(side=tk.LEFT, fill=tk.X, expand=True, padx=5)
        ttk.Button(folder_frame, text="选择", command=lambda: self.rename_path_var.set(filedialog.askdirectory())).pack(side=tk.LEFT)

        rule_frame = ttk.LabelFrame(main_frame, text="替换规则")
        rule_frame.pack(fill=tk.X, pady=15, padx=5)
        
        grid_f = ttk.Frame(rule_frame, padding=10)
        grid_f.pack(fill=tk.X)
        
        ttk.Label(grid_f, text="查找文件名中包含的字符:").grid(row=0, column=0, sticky="e")
        self.find_str_var = tk.StringVar()
        ttk.Entry(grid_f, textvariable=self.find_str_var, width=30).grid(row=0, column=1, padx=5, pady=5)
        
        ttk.Label(grid_f, text="替换为 (留空则删除):").grid(row=1, column=0, sticky="e")
        self.replace_str_var = tk.StringVar()
        ttk.Entry(grid_f, textvariable=self.replace_str_var, width=30).grid(row=1, column=1, padx=5, pady=5)

        btn_frame = ttk.Frame(main_frame)
        btn_frame.pack(pady=10)
        ttk.Button(btn_frame, text="⚠️ 执行批量更名", command=self.run_renamer).pack()
        
        self.rename_log = tk.Text(main_frame, height=10, bg="#fffff0", state=tk.DISABLED)
        self.rename_log.pack(fill=tk.BOTH, expand=True, pady=10)

    def run_renamer(self):
        folder = self.rename_path_var.get()
        find_str = self.find_str_var.get()
        replace_str = self.replace_str_var.get()

        if not folder or not find_str:
            messagebox.showerror("错误", "请指定文件夹和要查找的字符")
            return
        
        if not messagebox.askyesno("警告", "批量更名操作不可逆！\n建议先备份文件。\n确定要继续吗？"):
            return

        count = 0
        self.update_status("正在重命名...")
        
        for root, dirs, files in os.walk(folder):
            for file in files:
                if find_str in file:
                    old_path = os.path.join(root, file)
                    new_name = file.replace(find_str, replace_str)
                    new_path = os.path.join(root, new_name)
                    try:
                        if os.path.exists(new_path):
                            self.log_msg(self.rename_log, f"跳过: {new_name} 已存在")
                        else:
                            os.rename(old_path, new_path)
                            self.log_msg(self.rename_log, f"更名: {file} -> {new_name}")
                            count += 1
                    except Exception as e:
                        self.log_msg(self.rename_log, f"错误: {str(e)}")
        
        self.update_status("就绪")
        messagebox.showinfo("完成", f"成功重命名 {count} 个文件")

    # ================= 模块 4: 极速查找逻辑 =================
    def init_searcher_ui(self):
        top_frame = ttk.Frame(self.tab_search, padding=10)
        top_frame.pack(fill=tk.X)

        ttk.Label(top_frame, text="搜索范围:").pack(side=tk.LEFT)
        self.search_path_var = tk.StringVar()
        ttk.Entry(top_frame, textvariable=self.search_path_var, width=30).pack(side=tk.LEFT, padx=5)
        ttk.Button(top_frame, text="...", width=3, command=lambda: self.search_path_var.set(filedialog.askdirectory())).pack(side=tk.LEFT)

        ttk.Label(top_frame, text="关键词:").pack(side=tk.LEFT, padx=(15, 0))
        self.search_key_var = tk.StringVar()
        self.search_entry = ttk.Entry(top_frame, textvariable=self.search_key_var, width=20)
        self.search_entry.pack(side=tk.LEFT, padx=5)
        self.search_entry.bind('<Return>', lambda e: self.run_search())
        
        ttk.Button(top_frame, text="🔍 搜索", command=self.run_search).pack(side=tk.LEFT, padx=5)

        columns = ("filename", "path", "size")
        self.tree = ttk.Treeview(self.tab_search, columns=columns, show="headings")
        self.tree.heading("filename", text="文件名")
        self.tree.heading("path", text="完整路径")
        self.tree.heading("size", text="大小 (KB)")
        
        self.tree.column("filename", width=200)
        self.tree.column("path", width=400)
        self.tree.column("size", width=80)
        
        self.tree.pack(fill=tk.BOTH, expand=True, padx=10, pady=5)
        
        scrollbar = ttk.Scrollbar(self.tree, orient="vertical", command=self.tree.yview)
        self.tree.configure(yscrollcommand=scrollbar.set)
        scrollbar.pack(side='right', fill='y')

        self.tree.bind("<Double-1>", self.on_tree_double_click)
        ttk.Label(self.tab_search, text="提示: 双击搜索结果即可打开文件或文件夹", foreground="gray").pack(pady=5)

    def run_search(self):
        path = self.search_path_var.get()
        keyword = self.search_key_var.get()
        
        if not path or not keyword:
            return
        
        for item in self.tree.get_children():
            self.tree.delete(item)
            
        self.update_status("正在搜索...")
        count = 0
        
        for root, dirs, files in os.walk(path):
            for file in files:
                if keyword.lower() in file.lower():
                    full_path = os.path.join(root, file)
                    size = os.path.getsize(full_path) / 1024
                    self.tree.insert("", tk.END, values=(file, full_path, f"{size:.1f}"))
                    count += 1
            for d in dirs:
                 if keyword.lower() in d.lower():
                    full_path = os.path.join(root, d)
                    self.tree.insert("", tk.END, values=(f"📁 {d}", full_path, "-"))
                    count += 1
            if count % 50 == 0: self.root.update()

        self.update_status(f"搜索完成，找到 {count} 个项目")

    def on_tree_double_click(self, event):
        item = self.tree.selection()[0]
        path = self.tree.item(item, "values")[1]
        self.open_file(path)

if __name__ == "__main__":
    app = HospitalFileManager()
    app.root.mainloop()