Merge pull request 'dev' (#8) from dev into main

Reviewed-on: #8

SpaceSniffer.py

@@ -1,100 +1,102 @@
 import os
+import sys
+import webbrowser
 import threading
 import tkinter as tk
-from tkinter import ttk, messagebox
-import tkinter.filedialog
+from tkinter import ttk, filedialog, messagebox
 from queue import Queue
+from send2trash import send2trash
 import subprocess
-import send2trash
+import logging
+import requests
+
+logging.basicConfig(  # 配置日志记录器
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+    handlers=[
+        logging.FileHandler("scanner.log", encoding="utf-8"),
+        logging.StreamHandler(),
+    ],
+)
+
+proxy = {"http": None, "https": None}  # Requests代理设置
+
+
+def format_size(size):  # 格式化文件/目录大小
+    units = ["B", "KB", "MB", "GB", "TB"]
+    index = 0
+    while size >= 1024 and index < len(units) - 1:
+        size /= 1024.0
+        index += 1
+    return f"{size:.2f} {units[index]}"
 
 
 class FolderScanner(threading.Thread):
-    def __init__(self, start_path, queue):
-        """
-        初始化函数，创建一个线程并设置起始路径和队列。
+    def __init__(self, start_path, queue, progress_queue):
+        threading.Thread.__init__(self)
+        self.start_path = start_path  # 扫描路径
+        self.queue = queue  # 用于存储扫描结果
+        self.progress_queue = progress_queue  # 用于存储扫描进度
+        self.total_items = 0  # 总共扫描的文件/目录数量
 
-        Args:
-            start_path (str): 起始路径，表示要遍历的文件夹的根目录。
-            queue (Queue): 队列对象，用于线程间的通信，存放待处理或已处理过的文件或文件夹路径。
-
-        Returns:
-            None
-        """
-        # 使用super()调用父类threading.Thread的__init__方法
-        super().__init__()
-        self.start_path = start_path
-        self.queue = queue
-
-    def run(self):
-        """
-        运行扫描文件夹并获取文件信息的操作。
-
-        Args:
-            无参数。
-
-        Returns:
-            无返回值。
-
-        """
-        self.scan_folder(self.start_path)
+    def run(self):  # 扫描文件/目录
+        logging.info(f"开始扫描目录: {self.start_path}")
+        self.total_items = sum(
+            [len(files) + len(dirs) for r, dirs, files in os.walk(self.start_path)]
+        )  # 计算总共扫描的文件/目录数量
+        self.scan_folder(self.start_path)  # 扫描文件/目录
+        self.queue.put(None)  # 扫描结束
+        logging.info(f"扫描完成: {self.start_path}")
 
     def scan_folder(self, folder):
-        """
-        遍历指定文件夹下的所有子文件夹和文件，并将它们的路径、大小、父文件夹路径和类型（文件夹或文件）放入队列中。
-
-        Args:
-            folder (str): 需要遍历的文件夹路径。
-
-        Returns:
-            None.
-
-        """
+        scanned_items = 0
         for dirpath, dirnames, filenames in os.walk(folder):
             for dirname in dirnames:
                 folder_path = os.path.join(dirpath, dirname)
                 size = self.get_size(folder_path)
                 self.queue.put((folder_path, size, dirpath, "folder"))
+                scanned_items += 1
+                self.update_progress(scanned_items, folder_path)
+                logging.info(f"扫描目录: {folder_path} 大小: {format_size(size)} ")
+
             for filename in filenames:
                 file_path = os.path.join(dirpath, filename)
                 size = os.path.getsize(file_path)
                 self.queue.put((file_path, size, dirpath, "file"))
+                scanned_items += 1
+                self.update_progress(scanned_items, file_path)
+                logging.info(f"扫描文件: {file_path} 大小: {format_size(size)} ")
 
-    def get_size(self, path):
-        # 初始化总大小为0
+    def get_size(self, path):  # 获取文件/目录大小
         total_size = 0
-        # 遍历指定路径下的所有文件和目录
         for dirpath, dirnames, filenames in os.walk(path):
-            # 遍历当前目录下的所有文件
             for f in filenames:
-                # 拼接文件的完整路径
                 fp = os.path.join(dirpath, f)
-                # 将文件大小累加到总大小中
                 total_size += os.path.getsize(fp)
         return total_size
 
+    def update_progress(self, scanned_items, current_path):  # 更新扫描进度
+        progress = (scanned_items / self.total_items) * 100
+        self.progress_queue.put(
+            (progress, scanned_items, self.total_items, current_path)
+        )
+
 
 class App(tk.Tk):
-    def __init__(self, start_path):
-        """
-        初始化目录扫描器窗口
-
-        Args:
-            start_path (str): 开始扫描的目录路径
-
-        Returns:
-            None
-        """
+    def __init__(self, start_path):  # 初始化
         super().__init__()
-        self.title("目录扫描器 V1.0")
+        self.withdraw()
+        self.title("目录扫描器 V1.4.3")
         self.start_path = start_path
         self.queue = Queue()
-        self.scanner = FolderScanner(start_path, self.queue)
+        self.progress_queue = Queue()
+        self.progress_window = ProgressWindow(self)
+
+        self.scanner = FolderScanner(start_path, self.queue, self.progress_queue)
         self.scanner.start()
 
         self.style = ttk.Style(self)
-        self.style.configure(
-            "Treeview", font=("Helvetica", 10), rowheight=25
-        )  # 设置行高
+        self.style.configure("Treeview", font=("Helvetica", 10), rowheight=25)
         self.style.configure("Treeview.Heading", font=("Helvetica", 12, "bold"))
 
         self.tree = ttk.Treeview(self, style="Treeview")
@@ -105,27 +107,14 @@ class App(tk.Tk):
 
         self.folder_first_var = tk.BooleanVar()
         self.folder_first_checkbutton = tk.Checkbutton(
-            self, text="目录优先显示", variable=self.folder_first_var
+            self,
+            text="目录优先显示",
+            variable=self.folder_first_var,
+            command=self.update_folder_first_var,
         )
-        self.folder_first_checkbutton.pack(side=tk.LEFT, fill=tk.X)
-
-        self.folder_first_checkbutton.config(command=self.update_folder_first_var)
-
-        self.sort_by_size_button = tk.Button(
-            self, text="根据目录/文件大小排序", command=self.sort_by_size
-        )
-        self.sort_by_size_button.pack(side=tk.LEFT, fill=tk.X)
-
-        self.sort_by_name_button = tk.Button(
-            self, text="根据目录/文件名排序", command=self.sort_by_name
-        )
-        self.sort_by_name_button.pack(side=tk.LEFT, fill=tk.X)
-
-        self.refresh_button = tk.Button(
-            self, text="刷新列表", command=self.refresh_tree
-        )
-        self.refresh_button.pack(side=tk.LEFT, fill=tk.X)
 
+        self.tree.bind("<Double-1>", self.on_double_click)
+        self.tree.bind("<Return>", self.on_enter_press)
         self.tree.bind("<Button-3>", self.show_context_menu)
 
         self.size_sort_order = True
@@ -134,46 +123,161 @@ class App(tk.Tk):
 
         self.populate_root()
         self.update_tree()
+        self.update_progress()
 
         self.protocol("WM_DELETE_WINDOW", self.on_close)
         self.set_window_size()
+        self.create_menu()
 
-    def populate_root(self):
-        """
-        在树形控件中填充根节点。
+    def create_menu(self):
+        menu_bar = tk.Menu(self)
+        self.config(menu=menu_bar)
 
-        Args:
-            无参数。
+        file_menu = tk.Menu(menu_bar, tearoff=0)
+        menu_bar.add_cascade(label="文件", menu=file_menu)
+        file_menu.add_command(label="选择目录", command=self.reselect_directory)
+        file_menu.add_separator()
+        file_menu.add_command(label="退出", command=self.on_close)
 
-        Returns:
-            无返回值。
+        view_menu = tk.Menu(menu_bar, tearoff=0)
+        menu_bar.add_cascade(label="视图", menu=view_menu)
+        view_menu.add_checkbutton(
+            label="目录优先显示",
+            variable=self.folder_first_var,
+            command=self.update_folder_first_var,
+        )
+        view_menu.add_command(
+            label="根据目录/文件大小排序",
+            command=self.sort_by_size,
+        )
+        view_menu.add_command(
+            label="根据目录/文件名排序",
+            command=self.sort_by_size,
+        )
+        view_menu.add_command(
+            label="刷新列表",
+            command=self.refresh_tree,
+        )
 
-        """
-        size = self.scanner.get_size(self.start_path) / 1024 / 1024
+        help_menu = tk.Menu(menu_bar, tearoff=0)
+        menu_bar.add_cascade(label="帮助", menu=help_menu)
+        help_menu.add_command(label="帮助", command=self.show_help)
+        help_menu.add_command(label="更新日志", command=self.show_update_log)
+        help_menu.add_command(label="扫描日志", command=self.show_log)
+        help_menu.add_command(label="检查更新", command=self.check_updates)
+        help_menu.add_command(label="关于", command=self.show_about)
+
+    def show_help(self):
+        messagebox.showinfo(
+            "帮助",
+            "1. 双击文件夹可以展开/折叠\n2. 双击文件可以直接打开\n3. 右键单击文件/文件夹可以打开、删除文件/文件夹、进入所在目录\n4. 点击左上角文件菜单可以重新选择目录进行扫描\n5. 点击左上角视图菜单可以根据目录/文件大小、目录/文件名排序、刷新列表\n",
+        )
+
+    def show_update_log(self):
+        repo_owner = "ahdoawhfo"
+        repo_name = "SpaceSniffer"
+        base_url = "https://git.a6.wiki/api/v1/repos"
+
+        try:
+            # 发送 GET 请求获取最新的 Release
+            response = requests.get(
+                f"{base_url}/{repo_owner}/{repo_name}/releases/latest", proxies=proxy
+            )
+
+            if response.status_code == 200:
+                release_info = response.json()
+                latest_version = release_info["tag_name"]
+                release_notes = release_info["body"]
+                messagebox.showinfo(
+                    "更新日志", f"版本: {latest_version}\n\n{release_notes}"
+                )
+            else:
+                messagebox.showinfo(
+                    "更新日志",
+                    f"获取更新日志失败：{response.status_code}",
+                )
+        except requests.RequestException as e:
+            messagebox.showinfo("更新日志", f"获取更新日志时发生错误：{e}")
+
+    def show_log(self):
+        log_content = self.read_log_file()  # 从日志文件中读取日志内容
+        log_window = tk.Toplevel(self)
+        log_window.title("扫描日志")
+        log_window.geometry("1000x400")
+
+        text_widget = tk.Text(log_window, wrap=tk.WORD)
+        text_widget.pack(expand=True, fill=tk.BOTH)
+
+        scrollbar = tk.Scrollbar(text_widget)
+        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
+        text_widget.config(yscrollcommand=scrollbar.set)
+        scrollbar.config(command=text_widget.yview)
+
+        text_widget.insert(tk.END, log_content)
+        text_widget.config(state=tk.DISABLED)
+
+    def read_log_file(self):
+        log_file_path = "scanner.log"  # 日志文件路径
+        if os.path.exists(log_file_path):
+            try:
+                with open(log_file_path, "r", encoding="utf-8") as log_file:
+                    return log_file.read()
+            except UnicodeDecodeError:
+                return "日志文件编码错误，无法解析。"
+        else:
+            return "日志文件不存在。"
+
+    def check_updates(self):
+        # 创建一个新的 UpdateManager 实例，不销毁程序
+        update_manager = UpdateManager(self, is_startup=False)
+        update_manager.check_latest_release()
+
+    def show_about(self):
+        messagebox.showinfo(
+            "关于",
+            "一款开源的文件/目录扫描工具\n可以直观地展示目录的文件结构以及文件大小\n\n软件版本 V1.4.3\n作者 ahdoawhfo\n",
+        )
+
+    def on_double_click(self, event):  # V1.2 Update：当双击的是文件时，打开文件
+        item = self.tree.identify_row(event.y)
+        if item:
+            if os.path.isfile(item):
+                self.open_item(item)
+
+    def on_enter_press(self, event):  # V1.2 Update：当回车的是文件时，打开文件
+        item = self.tree.selection()[0]
+        if os.path.isfile(item):
+            self.open_item(item)
+
+    def reselect_directory(self):  # V1.2 Update：重新选择目录
+        new_path = filedialog.askdirectory()
+        if new_path:
+            self.start_path = new_path
+            self.refresh_tree()
+
+    def populate_root(self):  # 初始化根目录
+        size = self.scanner.get_size(self.start_path)
+        formatted_size = format_size(size)
         self.tree.insert(
             "",
             "end",
             iid=self.start_path,
-            text=f"{os.path.basename(self.start_path)} ({size:.2f} MB)",
+            text=f"{os.path.basename(self.start_path)} ({formatted_size})",
             tags=("folder",),
             open=True,
         )
 
-    def update_tree(self):
-        """
-        更新树形结构，将磁盘文件信息更新到树形视图中。
-
-        Args:
-            无
-
-        Returns:
-            无
-
-        """
+    def update_tree(self):  # 更新树状图
         if not self.is_sorting:
             while not self.queue.empty():
-                path, size, parent, tag = self.queue.get()
-                size_mb = size / 1024 / 1024
+                item = self.queue.get()
+                if item is None:  # Scanning is done
+                    self.progress_window.destroy()
+                    self.deiconify()
+                    return
+
+                path, size, parent, tag = item
+                formatted_size = format_size(size)
                 parent_iid = self.get_iid(parent)
                 if parent == self.start_path:
                     parent_iid = self.start_path
@@ -182,35 +286,32 @@ class App(tk.Tk):
                         parent_iid,
                         "end",
                         iid=self.get_iid(path),
-                        text=f"{os.path.basename(path)} ({size_mb:.2f} MB)",
+                        text=f"{os.path.basename(path)} ({formatted_size})",
                         tags=(tag,),
                         open=False,
                     )
             self.after(100, self.update_tree)
 
-    def get_iid(self, path):
-        """
-        获取指定路径的iid值
+    def update_progress(self):  # 更新扫描进度
+        if not self.progress_window.winfo_exists():  # Check if the window still exists
+            return
+        while not self.progress_queue.empty():
+            progress, scanned_items, total_items, current_path = (
+                self.progress_queue.get()
+            )
+            self.progress_window.progress_var.set(progress)
+            self.progress_window.progress_bar["value"] = progress
+            self.progress_window.progress_label.config(
+                text=f"扫描进度: {scanned_items} / {total_items}"
+            )
+            self.progress_window.path_label.config(text=f"正在扫描: {current_path}")
 
-        Args:
-            path (str): 文件或目录的路径
+        self.after(100, self.update_progress)
 
-        Returns:
-            str: 路径本身作为iid值返回
-        """
+    def get_iid(self, path):  # 获取目录/文件的 iid
         return path
 
-    def sort_by_size(self):
-        """
-        根据文件或文件夹的大小对文件列表进行排序。
-
-        Args:
-            无参数。
-
-        Returns:
-            无返回值，直接修改当前实例的文件列表。
-
-        """
+    def sort_by_size(self):  # 根据目录/文件大小排序
         self.sort_items(
             lambda x: (
                 0 if x[1] == "folder" and self.folder_first_var.get() else 1,
@@ -224,17 +325,7 @@ class App(tk.Tk):
         )
         self.size_sort_order = not self.size_sort_order
 
-    def sort_by_name(self):
-        """
-        根据名称对列表进行排序
-
-        Args:
-            无
-
-        Returns:
-            无返回值，但会改变对象的内部状态
-
-        """
+    def sort_by_name(self):  # 根据目录/文件名排序
         self.sort_items(
             lambda x: (
                 0 if x[1] == "folder" and self.folder_first_var.get() else 1,
@@ -244,18 +335,7 @@ class App(tk.Tk):
         )
         self.name_sort_order = not self.name_sort_order
 
-    def sort_items(self, key, reverse):
-        """
-        对树形控件中的指定目录进行排序。
-
-        Args:
-            key (callable): 用于排序的key函数。
-            reverse (bool): 是否降序排序。
-
-        Returns:
-            None
-
-        """
+    def sort_items(self, key, reverse):  # 排序
         if self.folder_first_var.get():
             selected = self.tree.selection()
             if not selected:
@@ -315,24 +395,17 @@ class App(tk.Tk):
                 for index, item in enumerate(sorted_items):
                     self.tree.move(item[2], parent, index)
 
-    def show_context_menu(self, event):
-        """
-        显示上下文菜单
-
-        Args:
-            event (tkinter.Event): 鼠标事件对象
-
-        Returns:
-            None
-
-        """
+    def show_context_menu(self, event):  # 显示右键菜单
         item = self.tree.identify_row(event.y)
         if item:
             self.tree.selection_set(item)
             menu = tk.Menu(self, tearoff=0)
-            menu.add_command(label="打开文件", command=lambda: self.open_item(item))
             menu.add_command(
-                label="打开所在目录", command=lambda: self.open_directory(item)
+                label="打开文件", command=lambda: self.open_item(item, "Open File")
+            )
+            menu.add_command(
+                label="打开所在目录",
+                command=lambda: self.open_directory(item, "Open Containing Folder"),
             )
             menu.add_command(
                 label="删除文件/目录(放入回收站)",
@@ -340,53 +413,62 @@ class App(tk.Tk):
             )
             menu.post(event.x_root, event.y_root)
 
-    def open_item(self, item):
-        path = self.tree.item(item, "text").split(" ")[0]
-        full_path = os.path.join(self.start_path, path)
+    def open_item(self, item, context_menu_action=None):  # 打开文件/目录
+        name = self.tree.item(item, "text").split(" ")[0]
         try:
-            if os.path.isdir(full_path):
-                subprocess.Popen(f'explorer "{os.path.realpath(full_path)}"')
+            if os.path.isdir(item):
+                if context_menu_action == "Open File":
+                    subprocess.Popen(f'explorer "{os.path.realpath(item)}"')
+                elif context_menu_action == "Open Containing Folder":
+                    parent_folder = os.path.dirname(item)
+                    subprocess.Popen(f'explorer "{os.path.realpath(parent_folder)}"')
             else:
-                os.startfile(full_path)
+                os.startfile(item)
         except Exception as e:
-            messagebox.showerror("错误", f"无法打开 {full_path}\n{e}")
+            messagebox.showerror("错误", f"无法打开 {name}\n{e}")
 
-    def open_directory(self, item):
-        path = self.tree.item(item, "text").split(" ")[0]
-        full_path = os.path.join(self.start_path, path)
-        if not os.path.isdir(full_path):
-            full_path = os.path.dirname(full_path)
+    def open_directory(self, item, context_menu_action=None):  # 打开所在目录
+        name = self.tree.item(item, "text").split(" ")[0]
+        if item == self.start_path:
+            parent_path = item
+        else:
+            parent_path = os.path.dirname(item)
         try:
-            subprocess.Popen(f'explorer "{os.path.realpath(full_path)}"')
+            subprocess.Popen(f'explorer "{os.path.realpath(parent_path)}"')
         except Exception as e:
-            messagebox.showerror("错误", f"无法打开 {full_path}\n{e}")
+            messagebox.showerror("错误", f"无法打开 {name}\n{e}")
 
-    def delete_item(self, item):
+    def delete_item(self, item):  # 删除文件/目录
         path = self.tree.item(item, "text").split(" ")[0]
-        full_path = os.path.normpath(
-            os.path.join(self.start_path, path)
-        )  # 使用os.path.normpath来规范化路径
+        full_path = os.path.normpath(os.path.join(self.start_path, path))
         confirm = messagebox.askyesno("提示", f"你确定要删除 {full_path} 吗?")
         if confirm:
             try:
-                send2trash.send2trash(full_path)
+                send2trash(full_path)
                 self.tree.delete(item)
             except Exception as e:
                 messagebox.showerror("错误", f"无法删除 {full_path}\n{e}")
             self.refresh_tree()
 
-    def refresh_tree(self):
-        for item in self.tree.get_children():
-            self.tree.delete(item)
+    def refresh_tree(self):  # 刷新树状图
+        self.is_sorting = False
+        self.queue.queue.clear()
+        self.progress_queue.queue.clear()
+        self.tree.delete(*self.tree.get_children())
         self.populate_root()
-        self.scanner = FolderScanner(self.start_path, self.queue)
+        self.scanner = FolderScanner(self.start_path, self.queue, self.progress_queue)
+        self.progress_window = ProgressWindow(self)
+        self.withdraw()
         self.scanner.start()
+        self.update_tree()
+        self.update_progress()
 
-    def on_close(self):
-        self.scanner.join()
-        self.destroy()
+    def on_close(self):  # 关闭程序
+        if self.scanner.is_alive():
+            self.scanner.join()
+        sys.exit(0)
 
-    def set_window_size(self):
+    def set_window_size(self):  # 设置窗口大小
         screen_width = self.winfo_screenwidth()
         screen_height = self.winfo_screenheight()
         window_width = int(screen_width * 0.6)
@@ -396,7 +478,7 @@ class App(tk.Tk):
         )
         self.update_font_size()
 
-    def update_font_size(self):
+    def update_font_size(self):  # 更新字体大小
         current_font = self.style.lookup("Treeview", "font")
         font_size = int(current_font.split()[1])
         screen_width = self.winfo_screenwidth()
@@ -409,26 +491,117 @@ class App(tk.Tk):
                 font=(current_font.split()[0], new_font_size + 2, "bold"),
             )
 
-    def sort_root_items(self, by="size"):
-        if by == "size":
-            self.sort_by_size()
-        elif by == "name":
-            self.sort_by_name()
+    def update_folder_first_var(self):  # 更新目录优先显示变量
+        self.folder_first_var.set(not self.folder_first_var.get())
 
-    def update_folder_first_var(self):
-        if self.folder_first_var.get():
-            self.folder_first_var.set(False)
-        else:
-            self.folder_first_var.set(True)
+
+class ProgressWindow(tk.Toplevel):  # 进度窗口
+    def __init__(self, parent):  # 初始化
+        super().__init__(parent)
+        self.title("扫描进度")
+        self.geometry("500x200")
+        self.label = tk.Label(
+            self, text="扫描中，请稍等", fg="deepskyblue", font=("Helvetica", 16)
+        )
+        self.label.pack(pady=20)
+        self.progress_var = tk.DoubleVar()
+        self.progress_bar = ttk.Progressbar(
+            self, variable=self.progress_var, maximum=100
+        )
+        self.progress_bar.pack(fill=tk.X, padx=20, pady=10)
+        self.progress_label = tk.Label(self, text="扫描进度: 0 / 0")
+        self.progress_label.pack(pady=5)
+        self.path_label = tk.Label(self, text="正在扫描: ")
+        self.path_label.pack(pady=5)
+        self.protocol("WM_DELETE_WINDOW", self.on_close)
+
+    def on_close(self):
+        pass  # 禁止关闭进度窗口
+
+
+class UpdateManager:
+    def __init__(self, root=None, is_startup=True):
+        self.root = root
+        self.is_startup = is_startup
+
+    def check_latest_release(self):
+        # Gitea 仓库信息和当前软件版本
+        repo_owner = "ahdoawhfo"
+        repo_name = "SpaceSniffer"
+        base_url = "https://git.a6.wiki/api/v1/repos"
+        current_version = "1.4.3"  # 替换成你的当前软件版本
+
+        try:
+            # 发送 GET 请求获取最新的 Release
+            response = requests.get(
+                f"{base_url}/{repo_owner}/{repo_name}/releases/latest", proxies=proxy
+            )
+
+            if response.status_code == 200:
+                release_info = response.json()
+                latest_version = release_info["tag_name"]
+                release_notes = release_info["body"]
+
+                # 比较最新版本和当前软件版本
+                if latest_version > current_version:
+                    # 提示用户更新
+                    choice = self.prompt_update(latest_version, release_notes)
+                    if choice:
+                        # 打开浏览器到 release 页面
+                        release_url = release_info["html_url"]
+                        webbrowser.open_new(release_url)
+                        if self.is_startup:
+                            return False
+                    else:
+                        return True
+                else:
+                    if not self.is_startup:  # 仅在用户点击检查更新时显示
+                        self.show_message("检查更新", "当前版本已经是最新版本")
+                    return True
+            else:
+                if not self.is_startup:  # 仅在用户点击检查更新时显示
+                    self.show_message(
+                        "获取 Release 失败",
+                        f"获取最新 Release 失败：{response.status_code}",
+                    )
+                return True
+        except requests.RequestException as e:
+            if not self.is_startup:  # 仅在用户点击检查更新时显示
+                self.show_message("请求错误", f"请求最新 Release 时发生错误：{e}")
+            return True
+
+    def prompt_update(self, latest_version, release_notes):
+        prompt_message = f"检查更新: {latest_version}\n\n更新说明:\n{release_notes}\n\n是否立即更新？"
+        choice = messagebox.askyesno("更新提示", prompt_message)
+        return choice
+
+    def show_message(self, title, message):
+        if self.root:
+            messagebox.showinfo(title, message)
+
+
+def clear_log_file():
+    log_file = "scanner.log"
+    try:
+        with open(log_file, "w", encoding="utf-8") as f:
+            f.truncate(0)  # 清空文件内容
+    except Exception as e:
+        messagebox.showinfo("Error", f"清空日志文件内容时发生错误: {e}")
 
 
 if __name__ == "__main__":
+    clear_log_file()
     root = tk.Tk()
     root.withdraw()
-    start_path = tkinter.filedialog.askdirectory()
+    update_manager = UpdateManager(root, is_startup=True)
+    proceed = update_manager.check_latest_release()
+    if not proceed:
+        sys.exit(0)
+    messagebox.showinfo("提示", "请选择你要扫描的目录")
+    start_path = filedialog.askdirectory()
     if start_path:
         app = App(start_path)
         app.mainloop()
     else:
         messagebox.showinfo("提示", "没有选中任何目录，程序即将退出")
-        root.destroy()
+        sys.exit(0)