To-do List App - DeepSeek

反复使用deepseek以及一点点人工修改得到一下python代码。

支持界面内加todo，删todo，拖拽排序，tick后自动排序。

用windows快捷方式或者mac的automator可以创建桌面的快捷应用。

Show Code

"""
Todo List 应用程序
使用Tkinter实现的图形界面待办事项管理工具
"""

import tkinter as tk
from tkinter import messagebox, filedialog
import json
import os

FONTSIZE = 16 # 字体大小

class TodoListApp:
    
    closest_index = None
    
    def __init__(self, root):
        """初始化应用程序"""
        self.root = root
        self.root.title("Todo List")  # 设置窗口标题
        self.tasks = []             # 存储任务数据的列表
        self.task_frames = []        # 存储任务界面组件的列表
        # 数据存储文件路径（存储在程序所在目录）
        self.data_file = "todolist.json"

        # 创建界面元素
        self.create_widgets()
        # 加载已保存的任务
        self.load_tasks()

    def create_widgets(self):
        """创建所有界面组件"""
        
        # 输入区域框架 -------------------------------------------------
        input_frame = tk.Frame(self.root)
        input_frame.pack(pady=FONTSIZE)  # 添加垂直间距

        # 任务输入框
        self.entry = tk.Entry(input_frame, width=4 * FONTSIZE)
        self.entry.pack(side=tk.LEFT, padx=FONTSIZE / 2)
        # 绑定回车键事件：按回车键添加任务
        self.entry.bind("<Return>", lambda event: self.add_task())

        # 添加任务按钮
        add_btn = tk.Button(input_frame, text="添加", command=self.add_task)
        add_btn.pack(side=tk.LEFT)

        # 任务列表区域 -------------------------------------------------
        self.list_frame = tk.Frame(self.root)
        self.list_frame.pack(fill=tk.BOTH, expand=True)  # 填充整个可用空间

        # 滚动条配置
        scrollbar = tk.Scrollbar(self.list_frame)
        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)  # 右侧垂直滚动条

        # 使用Canvas实现可滚动界面
        self.canvas = tk.Canvas(
            self.list_frame, 
            yscrollcommand=scrollbar.set,  # 绑定滚动条
            height=50 * FONTSIZE,          # 初始高度
            width=40 * FONTSIZE            # 初始宽度
        )
        self.canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        
        # 内部框架（实际存放任务的容器）
        self.inner_frame = tk.Frame(self.canvas)
        # 将内部框架添加到Canvas并保存窗口ID
        self.inner_frame_window = self.canvas.create_window(
            (0, 0), 
            window=self.inner_frame, 
            anchor="nw"
        )

        # 配置滚动条命令
        scrollbar.config(command=self.canvas.yview)

        # 绑定画布尺寸变化事件（调整内部框架宽度）
        self.canvas.bind("<Configure>", self.on_canvas_configure)
        # 绑定内部框架尺寸变化事件（更新滚动区域）
        self.inner_frame.bind("<Configure>", self.on_frame_configure)
        
        # 绑定鼠标滚轮滚动事件
        self.canvas.bind_all("<MouseWheel>", self.on_mousewheel)

    def on_canvas_configure(self, event):
        """当Canvas尺寸变化时，调整内部框架的宽度"""
        canvas_width = event.width
        self.canvas.itemconfig(self.inner_frame_window, width=canvas_width)

    def on_frame_configure(self, event):
        """当内部框架尺寸变化时，更新滚动区域"""
        self.canvas.configure(scrollregion=self.canvas.bbox("all"))

    def on_mousewheel(self, event):
        """处理鼠标滚轮滚动事件"""
        self.canvas.yview_scroll(int(-1*(event.delta/120)), "units")

        
    def add_task(self, task_text=None, completed=False):
        """添加新任务"""
        # 获取输入框内容（如果未传入特定任务文本）
        task_text = self.entry.get() if task_text is None else task_text
        if not task_text.strip():  # 过滤空输入
            return

        # 创建任务状态变量（用于复选框）
        var = tk.BooleanVar(value=completed)
        
        # 创建任务组件容器框架
        task_frame = tk.Frame(self.inner_frame)
        task_frame.pack(fill=tk.X, pady=FONTSIZE / 5)  # 水平填充，垂直间距2px

        # 添加拖动句柄
        drag_handle = tk.Label(task_frame, text="≡", cursor="hand2")
        drag_handle.pack(side=tk.LEFT)
        drag_handle.bind("<ButtonPress-1>", self.on_drag_start)
        drag_handle.bind("<B1-Motion>", self.on_drag_motion)
        drag_handle.bind("<ButtonRelease-1>", self.on_drag_end)

        # 复选框组件
        check = tk.Checkbutton(
            task_frame, 
            variable=var,
            command=lambda: self.toggle_task(task_frame)
        )
        check.pack(side=tk.LEFT)

        # 任务文本标签
        label = tk.Label(task_frame, text=task_text, width=30, anchor="w", font=("TkDefaultFont", FONTSIZE))
        label.pack(side=tk.LEFT, padx=FONTSIZE / 2)

        # 删除按钮
        del_btn = tk.Button(
            task_frame,
            text="删除",
            fg="red",
            command=lambda: self.delete_task(task_frame)
        )
        del_btn.pack(side=tk.RIGHT)

        # 保存任务数据到列表
        self.tasks.append({
            "frame": task_frame,
            "var": var,
            "label": label,
            "text": task_text,
            "completed": completed
        })
        
        self.sort_tasks()
        
        # 清空输入框并保存数据
        self.entry.delete(0, tk.END)
        self.update_task_display()
        self.save_tasks()

    def on_drag_start(self, event):
        """开始拖动任务"""
        drag_handle = event.widget
        task_frame = drag_handle.master
        self.dragged_task = None
        for task in self.tasks:
            if task['frame'] == task_frame:
                self.dragged_task = task
                # 设置被拖动任务的边框样式
                task_frame.config(highlightbackground="#3498db", highlightthickness=2)
                break
        if not self.dragged_task:
            return
        self.start_y = event.y_root
        self.original_index = self.tasks.index(self.dragged_task)
        
        # 显示插入线并初始化位置
        self.insert_line = tk.Frame(self.inner_frame, height=2, bg="#e74c3c")
        self.insert_line.place(relwidth=1, y=0)

    def on_drag_motion(self, event):
        """拖动过程中的动态效果"""
        if not hasattr(self, 'dragged_task') or not self.dragged_task:
            return

        # 计算相对位置
        x = event.x_root
        y = event.y_root
        canvas_y = self.canvas.canvasy(0)
        
        # 转换坐标到inner_frame坐标系
        rel_y = y - self.inner_frame.winfo_rooty() + canvas_y
        
        # 寻找最佳插入位置
        TodoListApp.closest_index = None
        min_distance = float('inf')
        line_y = 0
        
        # 检查是否在所有任务之上
        if rel_y < self.tasks[0]['frame'].winfo_y():
            TodoListApp.closest_index = 0
            line_y = 0
        else:
            # 遍历所有任务寻找插入位置
            for i, task in enumerate(self.tasks):
                frame = task['frame']
                task_top = frame.winfo_y()
                task_bottom = task_top + frame.winfo_height()
                
                # 计算到任务中心线的距离
                distance_to_top = abs(rel_y - task_top)
                distance_to_bottom = abs(rel_y - task_bottom)
                
                # 优先显示在上方的情况
                if distance_to_top < min_distance:
                    min_distance = distance_to_top
                    TodoListApp.closest_index = i
                    line_y = task_top
                if distance_to_bottom < min_distance:
                    min_distance = distance_to_top
                    TodoListApp.closest_index = i + 1
                    line_y = task_bottom
                    
                # 检查是否在两个任务之间
                # if i < len(self.tasks)-1:
                #     next_task_top = self.tasks[i+1]['frame'].winfo_y()
                #     if task_bottom < rel_y < next_task_top:
                #         line_y = task_bottom
                #         TodoListApp.closest_index = i+1
                #         break
        
        # 更新插入线位置
        self.insert_line.place(y=line_y)
        
        # 实时更新界面
        self.root.update_idletasks()

    def on_drag_end(self, event):
        """结束拖动时清理效果"""
        if hasattr(self, 'insert_line'):
            self.insert_line.destroy()
        if hasattr(self, 'dragged_task') and self.dragged_task:
            self.dragged_task['frame'].config(highlightthickness=0)
        
        """结束拖动，调整任务顺序"""
        if not hasattr(self, 'dragged_task') or not self.dragged_task:
            return
        # 计算目标位置时强制更新布局
        self.inner_frame.update_idletasks()
        inner_frame_height = self.inner_frame.winfo_height()
        x, y = event.x_root, event.y_root
        inner_frame_y = y - self.inner_frame.winfo_rooty()
        
        original_index = self.tasks.index(self.dragged_task)
        # target_index = None
        target_index = TodoListApp.closest_index
        single_height = self.tasks[0]["frame"].winfo_height()
        
        # 查找目标位置
        # for i, task in enumerate(self.tasks):
        #     frame = task['frame']
        #     if frame == self.dragged_task['frame']:
        #         continue
        #     frame_top = frame.winfo_y()
        #     frame_bottom = frame_top + single_height
        #     if frame_top <= inner_frame_y <= frame_bottom:
        #         frame_center = frame_top + (frame_bottom - frame_top) / 2
        #         target_index = i if inner_frame_y <= frame_center else i + 1
        #         # target_index = i + 1 if i >= original_index else i + 2
        #         break
        
        # 处理边界情况
        if target_index is None:
            target_index = len(self.tasks) if inner_frame_y > inner_frame_height else 0
        
        # 调整目标索引
        if original_index < target_index:
            target_index -= 1

        if target_index != original_index:
            task = self.tasks.pop(original_index)
            self.tasks.insert(target_index, task)
            self.rearrange_tasks()
            self.save_tasks()
            # 保持滚动位置稳定
            current_pos = self.canvas.yview()[0]
            self.canvas.yview_moveto(current_pos)

        del self.dragged_task
        del self.start_y
        del self.original_index

    def rearrange_tasks(self):
        """重新排列任务Frame的顺序"""
        # 解除所有任务的pack
        for task in self.tasks:
            task['frame'].pack_forget()
        
        # 按顺序重新pack
        for task in self.tasks:
            task['frame'].pack(fill=tk.X, pady=FONTSIZE / 5)
        
        # 强制更新布局并设置滚动区域
        self.inner_frame.update_idletasks()
        self.canvas.configure(scrollregion=self.canvas.bbox("all"))

    def delete_task(self, task_frame):
        """删除指定任务"""
        # 遍历任务列表找到对应框架
        for task in self.tasks:
            if task["frame"] == task_frame:
                task["frame"].destroy()  # 销毁界面组件
                self.tasks.remove(task)   # 从列表中移除
                break
        self.save_tasks()  # 保存更新后的数据

    def toggle_task(self, task_frame):
        """切换任务完成状态"""
        for task in self.tasks:
            if task["frame"] == task_frame:
                # 更新完成状态（从复选框变量获取）
                task["completed"] = task["var"].get()
                # 设置字体样式：完成时显示删除线
                font = ("TkDefaultFont", FONTSIZE)
                if task["completed"]:
                    font = ("TkDefaultFont", FONTSIZE, "overstrike")
                task["label"].config(font=font)
                break
        # self.save_tasks()
        self.sort_tasks()

    def update_task_display(self):
        """更新所有任务的显示样式"""
        for task in self.tasks:
            font = font = ("TkDefaultFont", FONTSIZE)
            if task["completed"]:
                font = font = ("TkDefaultFont", FONTSIZE, "overstrike")
            task["label"].config(font=font)

    def load_tasks(self):
        """从文件加载已保存的任务"""
        if os.path.exists(self.data_file):
            try:
                with open(self.data_file, "r") as f:
                    saved_tasks = json.load(f)
                    # 重新创建所有任务
                    for task in saved_tasks:
                        self.add_task(task["text"], task["completed"])
            except Exception as e:
                messagebox.showerror("错误", f"加载数据失败: {str(e)}")

    def save_tasks(self):
        """保存任务数据到文件"""
        try:
            data = []
            for task in self.tasks:
                data.append({
                    "text": task["text"],
                    "completed": task["completed"]
                })
            with open(self.data_file, "w") as f:
                json.dump(data, f, indent=2)  # 使用缩进格式保存
        except Exception as e:
            messagebox.showerror("错误", f"保存数据失败: {str(e)}")

    def sort_tasks(self):
        """勾选后重新排序"""
        self.tasks.sort(key=lambda x: x["completed"])
        
        self.rearrange_tasks()
        self.save_tasks()

        # 保持滚动位置稳定
        current_pos = self.canvas.yview()[0]
        self.canvas.yview_moveto(current_pos)
        

    def run(self):
        """启动应用程序"""
        # 绑定窗口关闭事件
        self.root.protocol("WM_DELETE_WINDOW", self.on_close)
        self.root.mainloop()

    def on_close(self):
        """关闭窗口时的处理"""
        self.save_tasks()  # 确保数据保存
        self.root.destroy()

if __name__ == "__main__":
    # 创建Tkinter根窗口并启动程序
    root = tk.Tk()
    app = TodoListApp(root)
    app.run()

---

V2 - 实现了mac的滚动

Show Code

"""
Todo List 应用程序
使用Tkinter实现的图形界面待办事项管理工具
"""

import tkinter as tk
from tkinter import messagebox, filedialog
import json
import os
import platform
from time import time

FONTSIZE = 16 # 字体大小

class TodoListApp:
    
    closest_index = None
    pre_scroll_time = -1
    scroll_acumulation = 0
    
    def __init__(self, root):
        """初始化应用程序"""
        self.root = root
        self.root.title("Todo List")  # 设置窗口标题
        self.tasks = []             # 存储任务数据的列表
        self.task_frames = []        # 存储任务界面组件的列表
        # 数据存储文件路径（存储在程序所在目录）
        self.data_file = "todolist.json"

        # 创建界面元素
        self.create_widgets()
        # 加载已保存的任务
        self.load_tasks()

    def create_widgets(self):
        """创建所有界面组件"""
        
        # 输入区域框架 -------------------------------------------------
        input_frame = tk.Frame(self.root)
        input_frame.pack(pady=FONTSIZE)  # 添加垂直间距

        # 任务输入框
        self.entry = tk.Entry(input_frame, width=4 * FONTSIZE)
        self.entry.pack(side=tk.LEFT, padx=FONTSIZE / 2)
        # 绑定回车键事件：按回车键添加任务
        self.entry.bind("<Return>", lambda event: self.add_task())

        # 添加任务按钮
        add_btn = tk.Button(input_frame, text="添加", command=self.add_task)
        add_btn.pack(side=tk.LEFT)

        # 任务列表区域 -------------------------------------------------
        self.list_frame = tk.Frame(self.root)
        self.list_frame.pack(fill=tk.BOTH, expand=True)  # 填充整个可用空间

        # 滚动条配置
        scrollbar = tk.Scrollbar(self.list_frame)
        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)  # 右侧垂直滚动条

        # 使用Canvas实现可滚动界面
        self.canvas = tk.Canvas(
            self.list_frame, 
            yscrollcommand=scrollbar.set,  # 绑定滚动条
            height=50 * FONTSIZE,          # 初始高度
            width=40 * FONTSIZE            # 初始宽度
        )
        self.canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        
        # 内部框架（实际存放任务的容器）
        self.inner_frame = tk.Frame(self.canvas)
        # 将内部框架添加到Canvas并保存窗口ID
        self.inner_frame_window = self.canvas.create_window(
            (0, 0), 
            window=self.inner_frame, 
            anchor="nw"
        )

        # 配置滚动条命令
        scrollbar.config(command=self.canvas.yview)

        # 绑定画布尺寸变化事件（调整内部框架宽度）
        self.canvas.bind("<Configure>", self.on_canvas_configure)
        # 绑定内部框架尺寸变化事件（更新滚动区域）
        self.inner_frame.bind("<Configure>", self.on_frame_configure)
        
        # 绑定鼠标滚轮滚动事件
        os_name = platform.system()
        if os_name == "Windows":
            self.canvas.bind_all("<MouseWheel>", self.on_mousewheel_win)
        elif os_name == "Darwin": # MacOS
            self.canvas.bind_all("<MouseWheel>", self.on_mousewheel_mac)
            # print(os_name)

    def on_canvas_configure(self, event):
        """当Canvas尺寸变化时，调整内部框架的宽度"""
        canvas_width = event.width
        self.canvas.itemconfig(self.inner_frame_window, width=canvas_width)

    def on_frame_configure(self, event):
        """当内部框架尺寸变化时，更新滚动区域"""
        self.canvas.configure(scrollregion=self.canvas.bbox("all"))

    def on_mousewheel_win(self, event):
        """处理鼠标滚轮滚动事件（windows）"""
        self.canvas.yview_scroll(int(-1*(event.delta/120)), "units")
    
    def on_mousewheel_mac(self, event):
        """处理鼠标滚轮滚动事件（mac）"""
        print(event)
        if TodoListApp.pre_scroll_time == -1 or time() - TodoListApp.pre_scroll_time > 0.1:
            TodoListApp.pre_scroll_time = time()
            TodoListApp.scroll_acumulation = -event.delta
        else:
            TodoListApp.scroll_acumulation += -event.delta
            TodoListApp.pre_scroll_time = time()
        if abs(TodoListApp.scroll_acumulation) > 4:
            self.canvas.yview_scroll(int(-1*(event.delta)), "units")
            TodoListApp.scroll_acumulation = 0
    
    def add_task(self, task_text=None, completed=False):
        """添加新任务"""
        # 获取输入框内容（如果未传入特定任务文本）
        task_text = self.entry.get() if task_text is None else task_text
        if not task_text.strip():  # 过滤空输入
            return

        # 创建任务状态变量（用于复选框）
        var = tk.BooleanVar(value=completed)
        
        # 创建任务组件容器框架
        task_frame = tk.Frame(self.inner_frame)
        task_frame.pack(fill=tk.X, pady=FONTSIZE / 5)  # 水平填充，垂直间距2px

        # 添加拖动句柄
        drag_handle = tk.Label(task_frame, text="≡", cursor="hand2")
        drag_handle.pack(side=tk.LEFT)
        drag_handle.bind("<ButtonPress-1>", self.on_drag_start)
        drag_handle.bind("<B1-Motion>", self.on_drag_motion)
        drag_handle.bind("<ButtonRelease-1>", self.on_drag_end)

        # 复选框组件
        check = tk.Checkbutton(
            task_frame, 
            variable=var,
            command=lambda: self.toggle_task(task_frame)
        )
        check.pack(side=tk.LEFT)

        # 任务文本标签
        label = tk.Label(task_frame, text=task_text, width=30, anchor="w", font=("TkDefaultFont", FONTSIZE))
        label.pack(side=tk.LEFT, padx=FONTSIZE / 2)

        # 删除按钮
        del_btn = tk.Button(
            task_frame,
            text="删除",
            fg="red",
            command=lambda: self.delete_task(task_frame)
        )
        del_btn.pack(side=tk.RIGHT)

        # 保存任务数据到列表
        # self.tasks.append({
        #     "frame": task_frame,
        #     "var": var,
        #     "label": label,
        #     "text": task_text,
        #     "completed": completed
        # })
        
        self.tasks.insert(0, {
            "frame": task_frame,
            "var": var,
            "label": label,
            "text": task_text,
            "completed": completed
        })
        
        self.sort_tasks()
        
        # 清空输入框并保存数据
        self.entry.delete(0, tk.END)
        self.update_task_display()
        self.save_tasks()

    def on_drag_start(self, event):
        """开始拖动任务"""
        drag_handle = event.widget
        task_frame = drag_handle.master
        self.dragged_task = None
        for task in self.tasks:
            if task['frame'] == task_frame:
                self.dragged_task = task
                # 设置被拖动任务的边框样式
                task_frame.config(highlightbackground="#3498db", highlightthickness=2)
                break
        if not self.dragged_task:
            return
        self.start_y = event.y_root
        self.original_index = self.tasks.index(self.dragged_task)
        
        # 显示插入线并初始化位置
        self.insert_line = tk.Frame(self.inner_frame, height=2, bg="#e74c3c")
        self.insert_line.place(relwidth=1, y=0)

    def on_drag_motion(self, event):
        """拖动过程中的动态效果"""
        if not hasattr(self, 'dragged_task') or not self.dragged_task:
            return

        # 计算相对位置
        x = event.x_root
        y = event.y_root
        canvas_y = self.canvas.canvasy(0)
        
        # 转换坐标到inner_frame坐标系
        rel_y = y - self.inner_frame.winfo_rooty() + canvas_y
        
        # 寻找最佳插入位置
        TodoListApp.closest_index = None
        min_distance = float('inf')
        line_y = 0
        
        # 检查是否在所有任务之上
        if rel_y < self.tasks[0]['frame'].winfo_y():
            TodoListApp.closest_index = 0
            line_y = 0
        else:
            # 遍历所有任务寻找插入位置
            for i, task in enumerate(self.tasks):
                frame = task['frame']
                task_top = frame.winfo_y()
                task_bottom = task_top + frame.winfo_height()
                
                # 计算到任务中心线的距离
                distance_to_top = abs(rel_y - task_top)
                distance_to_bottom = abs(rel_y - task_bottom)
                
                # 优先显示在上方的情况
                if distance_to_top < min_distance:
                    min_distance = distance_to_top
                    TodoListApp.closest_index = i
                    line_y = task_top
                if distance_to_bottom < min_distance:
                    min_distance = distance_to_top
                    TodoListApp.closest_index = i + 1
                    line_y = task_bottom
                    
                # 检查是否在两个任务之间
                # if i < len(self.tasks)-1:
                #     next_task_top = self.tasks[i+1]['frame'].winfo_y()
                #     if task_bottom < rel_y < next_task_top:
                #         line_y = task_bottom
                #         TodoListApp.closest_index = i+1
                #         break
        
        # 更新插入线位置
        self.insert_line.place(y=line_y)
        
        # 实时更新界面
        self.root.update_idletasks()

    def on_drag_end(self, event):
        """结束拖动时清理效果"""
        if hasattr(self, 'insert_line'):
            self.insert_line.destroy()
        if hasattr(self, 'dragged_task') and self.dragged_task:
            self.dragged_task['frame'].config(highlightthickness=0)
        
        """结束拖动，调整任务顺序"""
        if not hasattr(self, 'dragged_task') or not self.dragged_task:
            return
        # 计算目标位置时强制更新布局
        self.inner_frame.update_idletasks()
        inner_frame_height = self.inner_frame.winfo_height()
        x, y = event.x_root, event.y_root
        inner_frame_y = y - self.inner_frame.winfo_rooty()
        
        original_index = self.tasks.index(self.dragged_task)
        # target_index = None
        target_index = TodoListApp.closest_index
        single_height = self.tasks[0]["frame"].winfo_height()
        
        # 查找目标位置
        # for i, task in enumerate(self.tasks):
        #     frame = task['frame']
        #     if frame == self.dragged_task['frame']:
        #         continue
        #     frame_top = frame.winfo_y()
        #     frame_bottom = frame_top + single_height
        #     if frame_top <= inner_frame_y <= frame_bottom:
        #         frame_center = frame_top + (frame_bottom - frame_top) / 2
        #         target_index = i if inner_frame_y <= frame_center else i + 1
        #         # target_index = i + 1 if i >= original_index else i + 2
        #         break
        
        # 处理边界情况
        if target_index is None:
            target_index = len(self.tasks) if inner_frame_y > inner_frame_height else 0
        
        # 调整目标索引
        if original_index < target_index:
            target_index -= 1

        if target_index != original_index:
            task = self.tasks.pop(original_index)
            self.tasks.insert(target_index, task)
            self.rearrange_tasks()
            self.save_tasks()
            # 保持滚动位置稳定
            current_pos = self.canvas.yview()[0]
            self.canvas.yview_moveto(current_pos)

        del self.dragged_task
        del self.start_y
        del self.original_index

    def rearrange_tasks(self):
        """重新排列任务Frame的顺序"""
        # 解除所有任务的pack
        for task in self.tasks:
            task['frame'].pack_forget()
        
        # 按顺序重新pack
        for task in self.tasks:
            task['frame'].pack(fill=tk.X, pady=FONTSIZE / 5)
        
        # 强制更新布局并设置滚动区域
        self.inner_frame.update_idletasks()
        self.canvas.configure(scrollregion=self.canvas.bbox("all"))

    def delete_task(self, task_frame):
        """删除指定任务"""
        # 遍历任务列表找到对应框架
        for task in self.tasks:
            if task["frame"] == task_frame:
                task["frame"].destroy()  # 销毁界面组件
                self.tasks.remove(task)   # 从列表中移除
                break
        self.save_tasks()  # 保存更新后的数据

    def toggle_task(self, task_frame):
        """切换任务完成状态"""
        for task in self.tasks:
            if task["frame"] == task_frame:
                # 更新完成状态（从复选框变量获取）
                task["completed"] = task["var"].get()
                # 设置字体样式：完成时显示删除线
                font = ("TkDefaultFont", FONTSIZE)
                if task["completed"]:
                    font = ("TkDefaultFont", FONTSIZE, "overstrike")
                task["label"].config(font=font)
                break
        # self.save_tasks()
        self.sort_tasks()

    def update_task_display(self):
        """更新所有任务的显示样式"""
        for task in self.tasks:
            font = font = ("TkDefaultFont", FONTSIZE)
            if task["completed"]:
                font = font = ("TkDefaultFont", FONTSIZE, "overstrike")
            task["label"].config(font=font)

    def load_tasks(self):
        """从文件加载已保存的任务"""
        if os.path.exists(self.data_file):
            try:
                with open(self.data_file, "r") as f:
                    saved_tasks = json.load(f)
                    # 重新创建所有任务
                    for task in saved_tasks:
                        self.add_task(task["text"], task["completed"])
            except Exception as e:
                messagebox.showerror("错误", f"加载数据失败: {str(e)}")

    def save_tasks(self):
        """保存任务数据到文件"""
        try:
            data = []
            for task in self.tasks:
                data.append({
                    "text": task["text"],
                    "completed": task["completed"]
                })
            with open(self.data_file, "w") as f:
                json.dump(data, f, indent=2)  # 使用缩进格式保存
        except Exception as e:
            messagebox.showerror("错误", f"保存数据失败: {str(e)}")

    def sort_tasks(self):
        """勾选后重新排序"""
        self.tasks.sort(key=lambda x: x["completed"])
        
        self.rearrange_tasks()
        self.save_tasks()

        # 保持滚动位置稳定
        current_pos = self.canvas.yview()[0]
        self.canvas.yview_moveto(current_pos)
        

    def run(self):
        """启动应用程序"""
        # 绑定窗口关闭事件
        self.root.protocol("WM_DELETE_WINDOW", self.on_close)
        self.root.mainloop()

    def on_close(self):
        """关闭窗口时的处理"""
        self.save_tasks()  # 确保数据保存
        self.root.destroy()

if __name__ == "__main__":
    # 创建Tkinter根窗口并启动程序
    root = tk.Tk()
    app = TodoListApp(root)
    app.run()

---