new_file/TK_ui.py

# -*- encoding: utf-8 -*-
"""
@File    :   test2.py
@License :   (C)Copyright 2018-2022

@Modify Time      @Author    @Version    @Description
------------      -------    --------    -----------
2023/8/21 13:45   zart20      1.0         None
"""

import re
import read_bin
import numpy as np
import tkinter as tk
from files_sys_sim import *
from math import sin, cos, pi
from PIL import Image, ImageTk
from tkinter import scrolledtext

file_name_set = set()  # 文件项的唯一集合
blocks_label_set = set()  # 文件标签的唯一集合



def find_missing_and_duplicates(lst):
    print("列表长度:", len(lst))
    expected_set = set(range(1, 100))
    input_set = set(lst)
    print("转换集合长度:", len(input_set))

    missing_numbers = list(expected_set - input_set)
    duplicate_numbers = list(input_set.intersection(expected_set))

    print("缺失的数字：", missing_numbers)
    print("重复的数字：", duplicate_numbers)

    return missing_numbers, duplicate_numbers


def get_unique_tag():  # 获取唯一字母标签
    for ascii_code in range(65, 91):
        character = chr(ascii_code)
        if character not in blocks_label_set:
            blocks_label_set.add(character)
            return character


def set_canvas_size(foreground_image, up_or_down=None):
    # 调整前景
    new_width = 555  # 新的宽度
    if up_or_down == "up":
        new_height = 245  # 新的高度
    else:
        new_height = 555  # 新的高度
    foreground_image = foreground_image.resize((new_width, new_height), Image.LANCZOS)
    foreground_photo = ImageTk.PhotoImage(foreground_image)
    return foreground_photo


class InterfaceFile:
    def __init__(self, root: tk.Tk):
        self.current_step = None
        self.file_modi_tag = False # 文件修改状态
        self.massages = []  # 系统消息队列
        self.sim_fat_copy = None # 仿真FAT表复制临时列表，用于校验
        self.sim_file_copy = None # 仿真文件复制临时列表，用于校验 
        self.ex_disk_oc = True  # 交替显示保存占用和添加占用标志
        self.ex_disk_la = True  # 修改保存标签和清除标签的标志
        self.sim_disk_copy = None  # 磁盘复制临时列表，用于校验
        self.block_modi_tag = False  # 磁盘块修改标志置否
        self.block_modi_lb = None  # 磁盘块标签值初始化
        self.old_key = None  # FAT表上一次的记录值
        self.fat_modi_num = None  # 打开下一个FAT单元格之前的修改数值
        self.fat_modi_tag = False  # 修改状态标签，为True时进入修改状态
        self.clear_tag = True  # 清除标签，让标签清理和fat清理操作互斥
        self.check = None  # 检查磁盘条件
        self.code = None  # 当前磁盘块标签字母
        self.creating = True  # 正在创建的状态
        self.SimFAT = initialize_simfat()  # SimFAT 表初始化
        self.SimDisk = initialize_simdisk()  # SimDisk 区域初始
        self.FolderItems = []  # 文件项储存
        self.fat_unique_set = {0}  # fat表去重集合，防止在一个位置建立多个磁盘块
        self.root = root
        self.canvas_width = 1440
        self.canvas_height = 830
        # self.root.geometry(f'{self.canvas_width}x{self.canvas_height}+{2100}+{100}')
        self.root.geometry(f'{self.canvas_width}x{self.canvas_height}')
        self.root.title("文件系统仿真TK版")

        self.canvas = tk.Canvas(root, width=self.canvas_width, height=self.canvas_height, bg="white")
        self.canvas.pack(fill="both", expand=True)

        self.fat_table_position_mapping = dict()  # FAT表位置-序号映射字典
        self.blocks_position_mapping = dict()  # 磁盘块位置-序号映射字典

        # 创建菜单栏
        menubar = tk.Menu(self.root, font=("son", 16))
        self.root.config(menu=menubar)

        # 创建文件菜单
        file_menu = tk.Menu(menubar, tearoff=0)
        file_menu.configure(font=("son", 16))
        menubar.add_cascade(label="真实磁盘操作", menu=file_menu)

        # 在文件菜单中添加选项
        sector_0 = read_bin.read_sector_0()
        file_menu.add_command(label="读取磁盘文件0扇区", command=lambda: self.show_real_disk("磁盘0扇区", sector_0))
        sector_FAT1_1 = read_bin.read_sector_FAT1()
        file_menu.add_command(label="读取磁盘文件FAT1",
                              command=lambda: self.show_real_disk("FAT1_0扇区", sector_FAT1_1))
        root_path0 = read_bin.read_sector_root_path(0)
        file_menu.add_command(label="读取根目录0扇区",
                              command=lambda: self.show_real_disk("根目录0扇区", root_path0))
        root_path1 = read_bin.read_sector_root_path(1)
        file_menu.add_command(label="读取根目录1扇区",
                              command=lambda: self.show_real_disk("根目录1扇区", root_path1))

        # 创建保存菜单  
        save_menu = tk.Menu(menubar, tearoff=0)
        save_menu.configure(font=("son", 16))
        menubar.add_cascade(label="手动保存", menu=save_menu)
        save_menu.add_command(label="开启手动保存模式", command=lambda : self.manual_save())
        
        # 将鼠标左键点击事件绑定到函数on_left_click
        self.canvas.bind("<Button-1>", self.on_left_click)

        background_image = Image.open("/home/headless/Desktop/workspace/myshixun/src/img/bg2.png")
        background_image = background_image.resize((1440, 830))
        background_photo = ImageTk.PhotoImage(background_image)

        # 在Canvas上显示背景图片
        self.canvas.create_image(0, 0, anchor="nw", image=background_photo)

        # 载入前景图片
        foreground_image_pink = Image.open("/home/headless/Desktop/workspace/myshixun/src/img/pink_bg.png")
        foreground_photo_pink = set_canvas_size(foreground_image_pink, "up")
        foreground_image_purple = Image.open("/home/headless/Desktop/workspace/myshixun/src/img/purple_bg.png")
        foreground_photo_purple = set_canvas_size(foreground_image_purple, "up")
        foreground_image_jb = Image.open("/home/headless/Desktop/workspace/myshixun/src/img/jade_blue_bg.png")
        foreground_photo_jb = set_canvas_size(foreground_image_jb)
        foreground_image_sky_blue = Image.open("/home/headless/Desktop/workspace/myshixun/src/img/sky_blue_bg.png")
        foreground_photo_sky_blue = set_canvas_size(foreground_image_sky_blue)

        x1, y1, x2, y2 = 1130, 10, 1433, 819
        self.canvas_child = tk.Canvas(self.canvas,)
        self.canvas_child.place(x=x1,y=y1)
        self.canvas_child.config(width=303, height=809)
        self.canvas_child.create_rectangle(x1, y1, x2, y2, outline="white", fill="white")

        # 在Canvas上显示调整后大小的前景图片
        self.canvas.create_image(10, 10, anchor="nw", image=foreground_photo_pink)
        self.canvas.create_image(570, 10, anchor="nw", image=foreground_photo_purple)
        self.canvas.create_image(10, 265, anchor="nw", image=foreground_photo_jb)
        self.canvas.create_image(570, 265, anchor="nw", image=foreground_photo_sky_blue)

        # 保留图片引用以防止垃圾回收
        self.canvas.background_image = background_photo
        self.canvas.foreground_image_pink = foreground_photo_pink
        self.canvas.foreground_photo_purple = foreground_photo_purple
        self.canvas.foreground_photo_jb = foreground_photo_jb
        self.canvas.foreground_photo_sky_blue = foreground_photo_sky_blue

        # 按键布局
        image_create = Image.open("/home/headless/Desktop/workspace/myshixun/src/img/创建文件.png")
        self.photo_create = ImageTk.PhotoImage(image_create)
        self.set_canvas_button([348, 20], self.photo_create, self.creat_file, bg="#996BC7")

        image_save = Image.open("/home/headless/Desktop/workspace/myshixun/src/img/保存.png")
        self.photo_save = ImageTk.PhotoImage(image_save)
        self.file_save_button = self.set_canvas_button([435, 20], self.photo_save, self.save_file, bg="#996BC7")

        image_query = Image.open("/home/headless/Desktop/workspace/myshixun/src/img/查询.png")
        self.photo_query = ImageTk.PhotoImage(image_query)
        self.set_canvas_button([495, 20], self.photo_query, self.query_file, bg="#996BC7")

        image_create_path = Image.open("/home/headless/Desktop/workspace/myshixun/src/img/创建目录项.png")
        self.photo_create_path = ImageTk.PhotoImage(image_create_path)
        self.creat_path_button = self.set_canvas_button([825, 20], self.photo_create_path, self.creat_path, bg="#785FDA")
        
        image_clear_file = Image.open("/home/headless/Desktop/workspace/myshixun/src/img/清除目录项.png")
        self.photo_clear_file = ImageTk.PhotoImage(image_clear_file)
        self.clear_file_button = self.set_canvas_button([915, 20], self.photo_clear_file, self.clear_file_label, bg="#785FDA")
        
        image_check = Image.open("/home/headless/Desktop/workspace/myshixun/src/img/文件校验.png")
        self.photo_check = ImageTk.PhotoImage(image_check)
        self.file_check_button = self.set_canvas_button([1015,20], self.photo_check, self.file_check)
        
        image_reset = Image.open("/home/headless/Desktop/workspace/myshixun/src/img/重置.png")
        self.photo_reset = ImageTk.PhotoImage(image_reset)
        self.set_canvas_button([1065, 20], self.photo_reset, self.restart, bg="#785FDA")

        image_fat_check = Image.open("/home/headless/Desktop/workspace/myshixun/src/img/校验.png")
        self.photo_fat_check = ImageTk.PhotoImage(image_fat_check)
        self.fat_check_button = self.set_canvas_button([165, 274], self.photo_fat_check, self.fat_checkout)

        image_clear_form = Image.open("/home/headless/Desktop/workspace/myshixun/src/img/清除表单项.png")
        self.photo_clear_form = ImageTk.PhotoImage(image_clear_form)
        self.set_canvas_button([270, 274], self.photo_clear_form, self.clear_fat_label)

        image_save_form = Image.open("/home/headless/Desktop/workspace/myshixun/src/img/保存表单项.png")
        self.photo_save_form = ImageTk.PhotoImage(image_save_form)
        self.set_canvas_button([368, 274], self.photo_save_form, self.modi_fat_save)

        image_change_form = Image.open("/home/headless/Desktop/workspace/myshixun/src/img/修改表单项.png")
        self.photo_change_form = ImageTk.PhotoImage(image_change_form)
        self.set_canvas_button([465, 274], self.photo_change_form, self.modi_fat)

        image_disk_check = Image.open("/home/headless/Desktop/workspace/myshixun/src/img/校验2.png")
        self.photo_disk_check = ImageTk.PhotoImage(image_disk_check)
        self.disk_check_button = self.set_canvas_button([680, 274], self.photo_disk_check, self.disk_checkout)

        image_save_occupy = Image.open("/home/headless/Desktop/workspace/myshixun/src/img/保存占用.png")
        self.photo_save_occupy = ImageTk.PhotoImage(image_save_occupy)
        image_add_occupy = Image.open("/home/headless/Desktop/workspace/myshixun/src/img/添加占用.png")
        self.photo_add_occupy = ImageTk.PhotoImage(image_add_occupy)
        self.exchange_button_disk_occupy()  # 动态按钮函数用于 表示交保存和添加占用

        image_revamp_label = Image.open("/home/headless/Desktop/workspace/myshixun/src/img/修改标签.png")
        self.photo_revamp_label = ImageTk.PhotoImage(image_revamp_label)
        image_save_label = Image.open("/home/headless/Desktop/workspace/myshixun/src/img/保存标签.png")
        self.photo_save_label = ImageTk.PhotoImage(image_save_label)
        self.exchange_button_disk_label()  # 动态标签函数用于 表示交换修改和保存标签

        image_clear_label = Image.open("/home/headless/Desktop/workspace/myshixun/src/img/清除标签.png")
        self.photo_clear_label = ImageTk.PhotoImage(image_clear_label)
        self.set_canvas_button([1040, 274], self.photo_clear_label, self.clear_disk_label)

        # 设置
        self.file_name_label = self.set_canvas_label_entry([20, 21], "输入文件名", 10, [120, 20])  # 设置输入框和输入标签
        self.blocks_num_label = self.set_canvas_label_entry([255, 21], "块数", 3, [295, 20])  # 设置输入框和输入标签
        self.path_name_label = self.set_canvas_label_entry([580, 21], "文件夹(目录)", 10, [690, 20])  # 设置输入框和输入标签

        # 设置canvas_label
        self.canvas.create_text(20, 275, text="文件分配表FAT", anchor="nw", fill="white", font=("Arial", 14))
        self.canvas.create_text(20, 65, text="初始文件模拟区：", anchor="nw", fill="white", font=("Arial", 14))
        self.canvas.create_text(580, 275, text="磁盘模块", anchor="nw", fill="white", font=("Arial", 14))
        self.canvas.create_text(575, 70, anchor=tk.NW, text="文件名\t首块\t块数\t标签", font=("Arial", 14),
                                fill="white", )
        self.canvas_child.create_text(150, 21, text="操作指引", anchor=tk.CENTER, fill="black", font=("son", 14, "bold"))
        self.canvas_child.create_text(150, 240, text="系统消息", anchor=tk.CENTER, fill="black", font=("son", 14, "bold"))

        self.photo_fk3 = self.image_transition("/home/headless/Desktop/workspace/myshixun/src/img/fk3.png")  # 黄色方块，创建文件用
        self.photo_fk1 = self.image_transition("/home/headless/Desktop/workspace/myshixun/src/img/fk1.png")  # 透明位置方块 提供棋盘
        self.photo_fk2 = self.image_transition("/home/headless/Desktop/workspace/myshixun/src/img/fk2.png")  # 灰色方块，代表未选择方块，或者占用方块

        # FAT模块
        self.draw_fat_line()

        # 磁盘模块
        self.draw_disk_background()
        
        # 创建滚动文本框
        self.info_text = scrolledtext.ScrolledText(self.canvas_child, wrap=tk.WORD, width=25, height=24)
        self.info_text.place(x=10,y=265)
        self.info_text.config(font=("Arial", 14))

        self.canvas_child.bind("<Button-1>", self.info_xy)
    
    def info_xy(self,event):
        print(event.x,event.y)
    
    def sys_info(self, massage):
        '''系统消息'''
        self.info_text.insert("end", massage+"\n")
        self.info_text.see("end")
        
    def special_info(self, s_msg):
        '''操作指引消息'''
        self.canvas_child.delete("s_msg")
        s_msgs = s_msg.split("\n")
        for i, msg in enumerate(s_msgs):
            self.canvas_child.create_text(150,60+i*25,text=msg,font=("Arial", 14), anchor=tk.CENTER, tags="s_msg")
        

    def exchange_button_disk_label(self):
        if self.ex_disk_la:
            self.set_canvas_button([950, 274], self.photo_revamp_label, self.modi_block_lb, tags="prl")
        else:
            self.set_canvas_button([950, 274], self.photo_save_label, self.modi_block_save, tags="psl")

    def exchange_button_disk_occupy(self):
        if self.ex_disk_oc:
            self.add_occupy_button = self.set_canvas_button([860, 274], self.photo_add_occupy, self.add_occupy, tags="pao")
        else:
            self.set_canvas_button([860, 274], self.photo_save_occupy, self.save_occupy, tags="pso")

    def set_canvas_label_entry(self, label_pot: list, label_text: str, entry_width: int, entry_pot: list):
        self.canvas.create_text(label_pot[0], label_pot[1], text=label_text, anchor="nw", fill="white",
                                font=("Arial", 14))
        return self.set_canvas_entry(entry_pot[0], entry_pot[1], entry_width, "")

    def set_canvas_button(self, button_pot: list, button_photo: ImageTk.PhotoImage, command, tags=None, bg="#3E97C1"):
        button = tk.Button(self.canvas, image=button_photo, command=command, bd=0, relief="raised",
                           highlightthickness=0, compound="center", bg=bg, activebackground=bg)
        self.canvas.create_window(button_pot, anchor="nw", window=button, tags=tags)
        return button

    def set_canvas_entry(self, x, y, entry_width: int, default: str, tags=None, font_size=None):
        if not font_size:
            font_size = 16
        entry_file_name = tk.Entry(self.root, width=entry_width, )
        entry_file_name.configure(font=("Arial", font_size), borderwidth=1, relief="sunken", )
        entry_file_name.insert(0, default)
        self.canvas.create_window(x, y, anchor="nw", window=entry_file_name, tags=tags)
        return entry_file_name

    def show_fat(self, row, column, length_side=430):
        """映射显示FAT表"""
        tags = "fat_tag"  # 定义删除标志
        side_half = length_side // 20  # 每行和每列的间隔距离的一半
        num = self.SimFAT[row][column]
        if num != 0:
            x = self.fat_table_position_mapping[row, column][0] + side_half
            y = self.fat_table_position_mapping[row, column][1] + side_half
            self.canvas.create_text(x, y, anchor=tk.CENTER, text=num, font=("Arial", 16),
                                    fill="white", tags=tags)

    def show_all_fat(self):
        self.canvas.delete("fat_tag")
        for i in range(10):
            for n in range(10):
                self.show_fat(i, n)

    # def load_files_list(self, fat_ls: list[int], block_label="default"):  # 直接根据含第一块位置的fat表生成fat和disk显示
    def load_files_list(self, fat_ls: List[int], block_label="default"):
        # 假设block的去重在数据层面就已经处理好了
        self.show_all_disk()  # 更新磁盘显示
        for i, value in enumerate(fat_ls):
            row = value // 10
            column = value % 10
            if block_label == "default":
                block_label = self.SimDisk[row][column][0]
            if i < len(fat_ls) - 1:
                self.SimFAT[row][column] = fat_ls[i + 1]
            else:
                self.SimFAT[row][column] = "FF"
            self.SimDisk[row][column] = f"{block_label}{i + 1}"
            self.show_disk(row, column, True)  # 最后创建颜色才为黄色
        self.show_all_fat()  # 更新fat表显示

    def draw_fat_line(self, left_top_point=(80, 365), length_side=430):
        """FAT框架显示"""
        left_x, left_y = left_top_point  # 偏移量x和y
        short_side = length_side // 10  # 每行和每列的间隔距离

        for i in range(10): # 坐标映射
            for n in range(10):
                x = short_side * i + left_x
                y = short_side * n + left_y
                self.fat_table_position_mapping[n, i] = [x, y]

        for line in range(11):  # 画线
            x1, x2 = short_side * line + left_x, left_x
            y1, y2 = short_side * line + left_y, left_y
            self.canvas.create_line(x1, left_y, x1, left_y + length_side, fill="white", width=1)
            self.canvas.create_line(left_x, y1, left_x + length_side, y1, fill="white", width=1)

        for num in range(10):  # 画序号
            x, y = short_side * num + left_x + (short_side // 2), short_side * num + left_y + (short_side // 2)
            self.canvas.create_text(x, left_y - 20, text=f"{num}", font=("Arial", 12), anchor="center", fill="white")
            self.canvas.create_text(left_x - 20, y, text=f"{num}", font=("Arial", 12), anchor="center", fill="white")

        return self.fat_table_position_mapping

    def show_disk(self, row, column, color_tag=None):
        """映射显示单个磁盘块"""
        tags = "fat_disk"  # 定义删除标志
        text = self.SimDisk[row][column]
        if text != 0:
            x = self.blocks_position_mapping[row, column][0] + 1
            y = self.blocks_position_mapping[row, column][1] + 1
            if color_tag:
                self.draw_blocks(x, y, tags, text, "label_disk", self.photo_fk3)
            else:
                self.draw_blocks(x, y, tags, text, "label_disk", self.photo_fk2)

    def show_all_disk(self):
        """显示所有磁盘块"""
        self.canvas.delete("fat_disk")
        self.canvas.delete("label_disk")
        for i in range(10):
            for n in range(10):
                self.show_disk(i, n)

    def draw_disk_background(self, left_top_point=(650, 365), length_side=430):
        """创建磁盘块图例，并返回每个磁盘块的磁盘块的序号位置映射关系"""
        left_x, left_y = left_top_point  # 偏移量x和y
        short_side = length_side // 10  # 每行和每列的间隔距离

        for i in range(10):
            for n in range(10):
                x, y = short_side * i + left_x, short_side * n + left_y
                self.canvas.create_image(x, y, anchor=tk.NW, image=self.photo_fk1)
                self.blocks_position_mapping[n, i] = [x, y]  # 保存每个磁盘块的序号位置映射关系

        for num in range(10):
            i = num
            x1, x2 = short_side * i + left_x + (short_side // 2), left_x - 20
            y = short_side * i + left_y + (short_side // 2)
            self.canvas.create_text(x1, left_y - 20, text=f"{num}", font=("Arial", 12), anchor="center", fill="white")
            self.canvas.create_text(x2, y, text=f"{num}", font=("Arial", 12), anchor="center", fill="white")

        return self.blocks_position_mapping

    def modify_image_color(self, image, channel_offset):  # 调整方块颜色
        image_array = np.array(image)  # 将图像转换为NumPy数组
        modified_image_array = image_array + np.array(channel_offset)  # 对每个通道进行加减操作（包括Alpha通道）
        modified_image_array = np.clip(modified_image_array, 0, 255)  # 限制像素值在0到255之间
        modified_image = Image.fromarray(np.uint8(modified_image_array))  # 创建新的图像
        return modified_image

    def image_transition(self, file_path, side=43, channel_offset=(0, 0, 0, 0)):
        """修改图片大小和颜色"""
        image = Image.open(file_path)
        if sum(channel_offset) != 0:
            image = self.modify_image_color(image, channel_offset)  # 按RGBA调整颜色
        image.thumbnail((side, side))
        return ImageTk.PhotoImage(image)

    def query_file(self):
        '''查询功能'''
        # self.sys_info("临时消息")
        file_name = self.file_name_label.get()
        if file_name in file_name_set:
            for item in self.FolderItems:
                if file_name == item[0]:
                    file_label = initialize_fileblock(item[2], item[3])
                    self.canvas.delete("fk3")
                    self.creat_file_blocks(file_label)
                    self.blocks_num_label.delete(0, tk.END)
                    block_nums = read_sim_fat(int(item[1]), self.SimFAT)  # 通过首块fat获取全部文件fat
                    self.load_files_list(block_nums)
            self.sys_info(f"查询成功！")
        else:
            print("文件夹中无该文件！")
            self.sys_info("文件夹中无该文件！")

    def check_condition(self, file_name, start_block_num, block_num):  # 检查创建和保存条件

        for row in self.SimFAT:  # 更新唯一SimFAT表
            self.fat_unique_set.update(row)
        if 'FF' in self.fat_unique_set:  # 判断磁盘空间时，排除掉非位置字符
            self.fat_unique_set.remove('FF')
        self.fat_unique_set.remove(100)  # 收藏判断需要删除100这个非位置值

        if self.clear_tag:
            if file_name != "" and block_num != "":  # 文件名和块数不为空才能保存
                if block_num.isdigit():  # 填入块数为正整数才能保存
                    if file_name not in file_name_set:  # 文件名不重复才能保存
                        if len(self.fat_unique_set) + int(block_num) <= 100:
                            if start_block_num:
                                if int(start_block_num) not in self.fat_unique_set:
                                    # fat_arr = self.generate_fat_array(start_block_num, int(block_num), self.SimFAT) # 生成fat表
                                    # if fat_arr: # 有返回才进行显示 
                                    return True
                                else:
                                    self.sys_info("首块位置已被占用！")
                            else:
                                self.sys_info("磁盘已满！")
                        else:
                            self.sys_info("磁盘空间不足！")
                    else:
                        self.sys_info("文件名不能重复！")
                else:
                    self.sys_info("请输入正整数！")
            else:
                self.sys_info("文件名或块数不能为空！")
        else:
            if self.fat_modi_tag:
                self.sys_info("正在执行FAT表修改任务！\n请完成FAT校验后再进行操作！")
            elif self.block_modi_tag:
                self.sys_info("正在执行磁盘块修改任务！\n请完成磁盘块校验后再进行操作！")

    def creat_file(self, file_name=None, f_block=None, block_num=None):
        print("创建文件")
        if not file_name:
            file_name = self.file_name_label.get()
        if not block_num:
            block_num = self.blocks_num_label.get()
        if not f_block:
            f_block = self.select_fat_unique()

        self.check = self.check_condition(file_name, f_block, block_num)  # 执行数据合规检查

        if self.check:  # 合规时执行
            if self.creating:  # 初始时获取字母，
                self.code = get_unique_tag()
                self.creating = False  # 获取后除非触发保存，下次创建不更新字母
            file_label = initialize_fileblock(block_num, self.code)
            self.canvas.delete("fk3")  # 新创建文件前执行一次删除
            self.creat_file_blocks(file_label)
            self.sys_info("创建文件成功！")

    def creat_file_start_end_label(self, i, n, left_x, left_y, side, tags):  # 创建起始和尾部标签组件
        if i == 0:
            self.canvas.create_text(left_x, left_y - 50, anchor=tk.NW, text="起始", font=("Arial", 14), fill="white",
                                    tags=tags)
            offset = 15  # 箭头外扩端点偏移量
            end_x = left_x + side - n * side * 0.3  # x轴线段从右到左节结束点x值
            self.canvas.create_line(left_x + side, left_y - offset, end_x, left_y - offset, fill="white", tags=tags)
            arrow_angle = 30  # 箭头的夹角
            angle_rad = arrow_angle * (pi / 180)  # 计算幅度
            self.canvas.create_line(end_x, left_y - offset, end_x + 10 * cos(angle_rad),
                                    left_y - offset + 10 * sin(angle_rad), fill="white", tags=tags)
            self.canvas.create_line(end_x, left_y - offset, end_x + 10 * cos(-angle_rad),
                                    left_y - offset + 10 * sin(-angle_rad), fill="white", tags=tags)
        if i == n - 1:
            self.canvas.create_text(left_x - i * side, left_y - 30, anchor=tk.NW, text="尾部", font=("Arial", 14),
                                    fill="white", tags=tags)

    def draw_blocks(self, x, y, tags, label_block, label_ctrl=None, image=None):  # 画创建文件中的方块和文字
        if not image:
            image = self.photo_fk3
        self.canvas.create_image(x, y, anchor=tk.NW,
                                 image=image, tags=tags)
        if label_ctrl:
            tags = label_ctrl
        self.canvas.create_text(x + 5, y + 12, anchor=tk.NW,
                                text=label_block, font=("Arial", 12), tags=tags)

    def creat_file_blocks(self, list: list):
        left_x = 465
        left_y = 150
        side = 43  # 元素边
        tags = "fk3"
        n = len(list)
        if n <= 11:
            for i in range(n):
                x = left_x - i * side
                y = left_y
                self.draw_blocks(x, y, tags, f"{list[i]}")
                self.creat_file_start_end_label(i, n, left_x, left_y, side, tags)
        else:
            end_i = n - 5  # 取最后5块
            for i in range(n):
                x = left_x - i * side
                y = left_y
                self.creat_file_start_end_label(i, 11, left_x, left_y, side, tags)
                if i < 5:
                    self.draw_blocks(x, y, tags, f"{list[i]}")
                elif i == 5:
                    self.draw_blocks(x, y, tags, "...")
                elif i < 11:
                    self.draw_blocks(x, y, tags, f"{list[end_i]}")
                    end_i += 1

    def creat_path(self):
        print("创建目录项")
        if self.clear_tag:
            path_name = self.path_name_label.get()  # 获取文件夹
            text_ls = path_name.split(",")
            if text_ls[0] not in file_name_set:
                if len(text_ls) == 3 and text_ls[1].isdigit() and text_ls[2].isdigit():  # 确保格式和类型一致
                    if self.check_condition(text_ls[0], text_ls[1], text_ls[2]):
                        self.save_file(text_ls[0], text_ls[1], text_ls[2])
                        self.sys_info("创建目录成功！")
                else:
                    self.sys_info("请检查输入格式{'str','int','int'}！")
            else:
                self.sys_info("文件名重复！")
        else:
            self.sys_info("目前正在执行磁盘修改任务！")

    def show_path_info(self, ):  # 显示文件目录信息
        self.canvas.delete("creat_path")  # 画新图前元素清空
        start_x = 580
        start_y = 96
        tags = "creat_path"  # 删除标签
        word_high = 26  # 字高
        self.path_delete_image = self.image_transition("/home/headless/Desktop/workspace/myshixun/src/img/删除.png")
        self.path_edit_image = self.image_transition("/home/headless/Desktop/workspace/myshixun/src/img/编辑.png")
        
        for i, item in enumerate(self.FolderItems):
            item = [str(n) for n in item]
            text = "\t".join(item)  # 制表符加工
            if start_y + i * word_high < 250:  # 超出范围限制显示
                self.canvas.create_text(start_x, start_y + i * word_high, anchor=tk.NW, text=text, font=("Arial", 14),
                                        fill="white", tags=tags)
                self.set_canvas_button([start_x + 440, start_y + i * word_high], self.path_edit_image,
                                       lambda n=i, x=start_x, y=start_y: self.path_info_edit(n, x, y), tags,
                                       bg="#434FC5")
                self.set_canvas_button([start_x + 470, start_y + i * word_high], self.path_delete_image,
                                       lambda n=i: self.path_info_delete(n), tags, bg="#434FC5")
            else:
                self.sys_info("文件显示将溢出")
                break

    def delete_edit_file(self, index):  # 点击编辑后就先清空当前文件的保留
        first_block = self.FolderItems[index][1]  # 获取选中的文件的第一块位置
        file_name = self.FolderItems[index][0]
        fat_table = read_sim_fat(int(first_block), self.SimFAT)  # 获取文件的fat表
        file_name_set.remove(file_name)
        for fat in fat_table:
            row = fat // 10
            column = fat % 10
            self.SimFAT[row][column] = 0
            self.SimDisk[row][column] = 0
            self.fat_unique_set.remove(fat)

    def path_info_edit(self, index, x, y):
        print("文件修改")
        if self.file_modi_tag:
            self.special_info("正在修改文件，\n修改完成请保存。")
            tags = "creat_path"  # 删除标签
            word_high = 26  # 字高
            file_name = self.FolderItems[index][0]
            first_block = self.FolderItems[index][1]
            blocks = self.FolderItems[index][2]
            mark_char = self.FolderItems[index][3]
            self.path_save_image = self.image_transition("/home/headless/Desktop/workspace/myshixun/src/img/保存弹窗.png")
            self.path_cancel_image = self.image_transition("/home/headless/Desktop/workspace/myshixun/src/img/取消弹窗.png")
            y = y + index * word_high
            self.file_name = self.set_canvas_entry(x, y, 6, file_name, tags)  # 显示entry组件，输入字符
            self.first_block = self.set_canvas_entry(x + 80, y, 6, first_block, tags)
            self.blocks = self.set_canvas_entry(x + 160, y, 6, blocks, tags)
            self.mark_char = self.set_canvas_entry(x + 240, y, 6, mark_char, tags)
            self.set_canvas_button([x + 330, y], self.path_save_image, tags=tags, bg="#434FC5",
                                   command=lambda: self.path_info_edit_save(index))
            self.set_canvas_button([x + 380, y], self.path_cancel_image, tags=tags, bg="#434FC5",
                                   command=lambda: self.path_info_edit_cancel())
            self.sys_info(f"{file_name} 文件修改中...")
        else:
            self.sys_info("未开启文件校验流程，无法修改文件")
    # def path_info_edit_save(self, index):  # 文件项编辑的保存
    #     if self.file_modi_tag and not self.clear_tag:
    #         file_name = self.file_name.get()
    #         first_block = self.first_block.get()
    #         block_num = self.blocks.get()
    #         old_first_block = int(self.FolderItems[index][1])
    #         old_fat_table = read_sim_fat(int(old_first_block), self.SimFAT)  # 获取文件的fat表
    #         if file_name != "" and first_block != "" and block_num != "":
    #             if first_block.isdigit() and block_num.isdigit():
    #                 if int(first_block) not in self.fat_unique_set or int(first_block) in old_fat_table:
    # 
    #                     if len(self.fat_unique_set) + int(block_num) - len(old_fat_table) <= 100:
    #                         b_label = self.FolderItems[index][3]
    #                         self.delete_edit_file(index)  # 执行前先删除旧的记录
    #                         self.FolderItems[index] = [file_name, first_block, block_num, b_label]
    #                         fat_arr = self.generate_fat_array(int(first_block), int(block_num))  # 重新生成fat表
    #                         file_name_set.add(file_name)
    #                         self.load_files_list(fat_arr, b_label)
    #                         self.show_path_info()
    #                         self.sys_info("修改成功！")
    #                     else:
    #                         self.sys_info("磁盘空间不足！")
    #                 else:
    #                     self.sys_info("首块位置已被占用！")
    #             else:
    #                 self.sys_info("请输入正整数！")
    #         else:
    #             self.sys_info("修改值不能为空！")
    #     else:
    #         self.sys_info("目前正在执行磁盘修改任务！")

    def path_info_edit_save(self, index):  # 文件项编辑的保存
        print("文件保存")
        if self.file_modi_tag and not self.clear_tag:
            self.special_info("文件已保存，可以开始校验。")
            file_name = self.file_name.get()    # 文件名
            first_block = self.first_block.get()    # 磁盘首块
            if first_block.isdigit():
                first_block = int(first_block)
            block_num = self.blocks.get()   # 磁盘块数
            mark_char = self.mark_char.get()    # 磁盘标签
            self.FolderItems[index] = [file_name, first_block, block_num, mark_char]
            file_name_set.add(file_name)
            self.show_path_info()
            self.sys_info("修改成功！")              
        else:
            self.sys_info("未开启文件修改任务")

    def path_info_edit_cancel(self):
        self.show_path_info()
        self.sys_info("已取消操作！")

    def path_info_delete(self, index):
        if self.clear_tag:
            self.delete_edit_file(index)  # 清空disk和fat
            file_info = self.FolderItems.pop(index)  # 删除该索引指向的元素
            blocks_label_set.remove(file_info[3])
            self.canvas.delete("fk3")
            self.show_path_info()  # 重新显示文件信息
            self.show_all_fat()
            self.show_all_disk()
            self.sys_info(f"文件 {file_info[0]} 删除成功！")
        else:
            self.sys_info("正在进行校验操作，无法执行删除操作！")

    def select_fat_unique(self):
        while True:  # 确保每次不同的字符被选中
            unique_num = random.randint(0, 99)
            if unique_num not in self.fat_unique_set:
                return unique_num
            if len(self.fat_unique_set) >= 100:
                return None

    def generate_fat_array(self, first_block: int, block_num: int):  # 生成fat表文件列表
        fat_arr = [first_block]
        self.fat_unique_set.update(fat_arr)
        for i in range(block_num - 1):
            while True:
                num = random.randint(1, 99)
                if len(self.fat_unique_set) >= 101:
                    num = None
                    break
                if num not in self.fat_unique_set:
                    self.fat_unique_set.add(num)
                    break
            if num:
                fat_arr.append(num)
            else:
                break
        return fat_arr

    def save_file(self, file_name=None, f_block=None, blocks=None):
        print("保存文件")
        if file_name:
            file_name = file_name
        else:
            file_name = self.file_name_label.get()

        if blocks:
            blocks = blocks
        else:
            blocks = self.blocks_num_label.get()

        if self.creating:  # 如果保存时没有创建过，先创建
            self.creat_file(file_name, f_block, blocks)  # 保存的同时执行创建

        if self.check:
            if f_block:
                f_block = int(f_block)
            else:
                f_block = self.select_fat_unique()
            fat_arr = self.generate_fat_array(f_block, int(blocks))  # 生成fat表
            self.FolderItems.append([file_name, f_block, blocks, self.code])  # 添加到文件夹
            file_name_set.add(file_name)  # 添加唯一性文件名集合
            self.fat_unique_set.update(fat_arr)  # 将占用的磁盘位置信息添加进唯一集合，防止重复取数
            self.load_files_list(fat_arr, self.code)  # 根据fat表向磁盘装载文件数据并显示
            self.show_path_info()  # 保存后显示文件夹    
            self.creating = True  # 上一次保存执行完成后才能开始二次执行
            self.sys_info("保存成功")

    def restart(self):
        global blocks_label_set
        global file_name_set
        self.modi_fat_save()
        self.modi_block_save()
        self.save_occupy()
        self.canvas.delete("creat_path")
        self.canvas.delete("fk3")
        self.canvas.delete("fat_tag")
        self.canvas.delete("fat_disk")
        self.canvas.delete("label_disk")
        self.canvas.delete("info")

        self.massages = []  # 清空消息
        self.FolderItems = []  # 清空文件项
        blocks_label_set = set()  # 块标签集合清空
        file_name_set = set()  # 唯一性文件名清空
        self.fat_unique_set = {0}  # 重置fat唯一位置检查集合
        self.SimFAT = initialize_simfat()  # 重置fat表
        self.SimDisk = initialize_simdisk()  # 重置磁盘
        self.sim_fat_copy = None  # fat表深拷贝初始化
        self.ex_disk_oc = True  # 交替显示保存占用和添加占用标志
        self.ex_disk_la = True  # 修改保存标签和清除标签的标志
        self.sim_disk_copy = None  # 磁盘块深拷贝初始化
        self.block_modi_tag = False  # 磁盘块修改标志置否
        self.block_modi_lb = None  # 磁盘块标签值初始化
        self.old_key = None  # FAT表上一次的记录值
        self.fat_modi_num = None  # 打开下一个FAT单元格之前的修改数值
        self.fat_modi_tag = False  # 修改状态标签，为True时进入修改状态
        self.clear_tag = True  # 清除标签，让标签清理和fat清理操作互斥
        self.check = None  # 检查磁盘条件
        self.code = None  # 当前磁盘块标签字母
        self.creating = True  # 正在创建的状态
        self.file_modi_tag = False  # 文件修改状态
        self.sim_file_copy = None  # 仿真文件复制临时列表，用于校验 
        
        self.file_save_button.config(state="normal")  # 禁用一部分按键
        self.fat_check_button.config(state="normal")
        self.disk_check_button.config(state="normal")
        self.creat_path_button.config(state="normal")
        self.add_occupy_button.config(state="normal")
        self.clear_file_button.config(state="normal")
        self.file_check_button.config(state="normal")
        
        try:
            self.last_step.destroy()
            self.next_step.destroy()
        except:
            pass    
        self.sys_info("重置成功！")
        self.special_info("重置成功！")
        

    def file_check(self):
        global file_name_set
        if self.file_modi_tag:
            sum = 0
            for i in range(len(self.FolderItems)):
                if self.FolderItems[i][1:] == self.sim_file_copy[i][1:]:
                    sum+=1
                    file_name_set.add(self.FolderItems[i][0])   # 将新文件名添加到唯一结构
            if sum == len(self.FolderItems):
                self.sys_info("校验正确")
                self.special_info("恭喜！\n文件校验成功！")
                self.sim_file_copy = None   # 校验正确才值无
            else:
                self.sys_info("校验错误。")
                self.special_info("文件校验失败。")
                
            self.file_modi_tag = False
            self.clear_tag = True
        else:
            self.sys_info("没有开启文件校验流程，无法校验。")


    def clear_file_label(self):
        """清除FAT表"""
        global file_name_set
        print("清除文件标签")
        if len(self.FolderItems)>0:
            if self.clear_tag:
                self.special_info("正在进行文件校验！\n请点击目录项的铅笔图标。\n修改目录项。")
                self.file_modi_tag = True
                self.canvas.delete("creat_path")
                self.clear_tag = False # 锁定文件校验状态
                if not self.sim_file_copy:
                    self.sim_file_copy = copy.deepcopy(self.FolderItems)    # 深拷贝复制一份原正确列表并保存为复制对象
                    file_name_set = set()
                t0 = list()
                for i in range(len(self.FolderItems)):
                    item = ["-","-","-","-"]
                    t0.append(item)
                self.FolderItems = t0
                self.show_path_info()
                self.sys_info("文件清除成功！")
            else:
                self.sys_info("正在执行校验任务,无法清除目录项！")
        else:
            self.sys_info("文件夹无文件无法清除目录！")
        
    
    
    def manual_save(self):
        print("手动保存")
        self.restart()
        if self.current_step:
            self.last_step.destroy()
            self.next_step.destroy()
            
        self.last_step = tk.Button(self.canvas_child, text="上一步", command=self.last_step_func)
        self.canvas_child.create_window([80, 180], anchor="nw", window=self.last_step)
        self.last_step.config(state="disabled")

        self.next_step = tk.Button(self.canvas_child, text="下一步", command=self.next_step_func)
        self.canvas_child.create_window([160, 180], anchor="nw", window=self.next_step)
          
        self.current_step = 1
        self.file_info_edit()   # 开启构造文件夹操作
        self.file_save_button.config(state="disabled")  # 禁用一部分按键
        self.fat_check_button.config(state="disabled")
        self.disk_check_button.config(state="disabled")
        self.creat_path_button.config(state="disabled")
        self.add_occupy_button.config(state="disabled")
        self.clear_file_button.config(state="disabled")
        self.file_check_button.config(state="disabled")

    def last_step_func(self):
        print("上一步")     
        if self.current_step == 2:
            print(1)
            self.current_step = 1
            # 开启文件夹修改
            self.last_step.config(state="disabled")
            self.file_info_edit()   # 开启文件夹构造操作
            self.modi_fat_save()
            
        elif self.current_step == 3:
            print(2)
            self.current_step = 2
            # 开启FAT修改
            self.modi_block_save()
            self.clear_fat_label()
            self.next_step.config(state="normal")
            self.next_step.config(text="下一步")
        
        elif self.current_step == 4:
            self.current_step =3
            print(3)
            # 开启磁盘修改
            self.clear_disk_label()
            self.next_step.config(text="完 成")

    def next_step_func(self):
        print("下一步")
        if self.current_step == 1:
            print("2")
            self.current_step = 2
            self.last_step.config(state="normal")
            # 开启FAT修改
            self.file_info_save()   # 保存文件夹构造，并将文件信息添加到类属性self.FolderItems
            self.clear_fat_label() # 清除FAT表
            # self.modi_fat()
            
        elif self.current_step == 2:
            print("3")
            self.current_step = 3
            self.modi_fat_save()
            self.clear_disk_label()
            # 开启磁盘修改
            # self.next_step.config(state="disabled")
            self.next_step.config(text="完 成")
        
        elif self.current_step == 3:
            print("4")
            self.current_step = 4
            self.modi_block_save()
            # 完成
            # self.next_step.config(text="完 成")
            self.next_step.config(text="校 验")
            
        elif self.current_step == 4:
            # 校验F
            # self.next_step.config(text="校 验")
            self.save_check()
            
    def save_check(self):
        folder_item = self.FolderItems
        fat_table = self.SimFAT
        block_table = self.SimDisk
        f_num = 0
        for folders in folder_item:
            num = 0
            name = folders[0]
            first = folders[1]
            # if first.isdigit():
            if isinstance(first, int):
                blocks = int(folders[2])
                label = folders[3]
                label = label[-1]
                fat = read_sim_fat(first, fat_table)
                
                # print("fat值",fat)
                
                if len(fat) == int(blocks):
                    num += 1
                    # print("块数正确")
                for i, loca in enumerate(fat):
                    row = loca // 10
                    col = loca % 10
                    
                    if block_table[row][col] == f"{label}{i+1}":
                        num += 1
                        # print("block 链正确")
                    if i < len(fat)-1:
                        if fat_table[row][col] == fat[i+1]:
                            num += 1
                            # print("fat 链正确")
                    elif i == len(fat)-1:
                        if fat_table[row][col] == "FF":
                            num += 1
                            # print("fat表结束正确")
                            
                if num == 2*len(fat)+1:
                    self.sys_info(f"{name}校验正确！")
                    f_num += 1
                    break
                else:
                    self.sys_info(f"{name}校验错误！")
                    # f_num += 1
            else:
                self.sys_info(f"{name}校验错误！")
        if f_num == len(self.FolderItems):
            self.special_info("校验成功")
            try:
                self.last_step.destroy()
                self.next_step.destroy()
            except:
                pass
        else:
            self.special_info("校验失败")
    
    def file_info_edit(self):
        print("手动保存文件夹文件")
        if self.current_step ==1:
            self.special_info("手动保存模式。\n请先在初始区创建文件\n然后再完善文件信息。\n最后点击下一步。")
            tags = "creat_path"  # 删除标签
            self.canvas.delete(tags)
            x = 580
            y = 96
            self.file_name = self.set_canvas_entry(x, y, 6, "", tags)  # 显示entry组件，输入字符
            self.first_block = self.set_canvas_entry(x + 80, y, 6, "", tags)
            self.blocks = self.set_canvas_entry(x + 160, y, 6, "", tags)
            self.mark_char = self.set_canvas_entry(x + 240, y, 6, " ", tags)

    def file_info_save(self):
        self.special_info("文件保存成功\n现在开始添加文件分配表。")
        if self.FolderItems != []:
            self.FolderItems.pop()
        file_name = self.file_name.get()  # 文件名
        first_block = self.first_block.get()  # 磁盘首块
        if first_block.isdigit():
            first_block = int(first_block)
        block_num = self.blocks.get()  # 磁盘块数
        mark_char = self.mark_char.get()  # 磁盘标签
        self.FolderItems.append([file_name, first_block, block_num, mark_char]) 
        file_name_set.add(file_name)    # 添加唯一文件名
        blocks_label_set.add(mark_char) # 添加磁盘唯一块标志

        tags = "creat_path"  # 删除标签
        self.canvas.delete(tags)
        for i, item in enumerate(self.FolderItems):
            item = [str(n) for n in item]
            text = "\t".join(item)  # 制表符加工
            self.canvas.create_text(580, 96, anchor=tk.NW, text=text, font=("Arial", 14),
                                        fill="white", tags=tags)
        self.sys_info("修改成功！")
        
    def clear_fat_label(self):
        print("清除表单项")
        self.special_info("正在进行FAT校验！\n请点击修改表单项。\n修改FAT表。")
        self.fat_modi_tag = True    # 开启FAT修改标签
        if self.clear_tag:
            self.canvas.delete("fat_tag")
            self.clear_tag = False
            if not self.sim_fat_copy:
                self.sim_fat_copy = copy.deepcopy(self.SimFAT)  # 深拷贝复制一份原正确列表并保存为复制对象
            self.SimFAT = initialize_simfat()  # 同时清空原FAT表
            self.sys_info("清除成功！")

        else:
            self.sys_info("正在执行校验任务,无法清除表单项！")

    def modi_fat(self):
        if self.fat_modi_tag:
            self.special_info("正在修改FAT表。\n点击FAT表对应区域修改值。\n完成后保存表单项。")
            if not self.sim_fat_copy and self.fat_modi_tag:
                self.sim_fat_copy = copy.deepcopy(self.SimFAT)  # 深拷贝复制一份原正确列表并保存为复制对象
        else:
            self.sys_info("未开启FAT校验流程。")

    def modi_fat_entry(self, row, column, lt_top):
        default = self.SimFAT[row][column]
        if self.fat_modi_num and self.old_key:
            if self.fat_modi_num.get().isdigit() or self.fat_modi_num.get().upper() == "FF":
                if self.fat_modi_num.get().isdigit():
                    self.SimFAT[self.old_key[0]][self.old_key[1]] = int(self.fat_modi_num.get())
                else:
                    self.SimFAT[self.old_key[0]][self.old_key[1]] = "FF"
                self.sys_info(f"{self.old_key} -> {self.fat_modi_num.get()}添加成功！")
            else:
                self.sys_info("请输入正整数,或FF！")

        self.canvas.delete("fat_entry")
        self.fat_modi_num = self.set_canvas_entry(lt_top[0] + 8, lt_top[1] + 8, 2, default, "fat_entry")
        self.old_key = [row, column]
        self.show_all_fat()

    def modi_fat_save(self):
        print("保存表单项")
        if self.fat_modi_tag:
            self.canvas.delete("fat_entry")
            self.fat_modi_tag = False  # 修改标志置否保存后就不再能修改
            self.clear_tag = True  # 保存后清除项就置真
            if self.fat_modi_num and self.old_key:
                if self.fat_modi_num.get().isdigit() or self.fat_modi_num.get().upper() == "FF":
                    if self.fat_modi_num.get().isdigit():
                        self.SimFAT[self.old_key[0]][self.old_key[1]] = int(self.fat_modi_num.get())
                    else:
                        self.SimFAT[self.old_key[0]][self.old_key[1]] = "FF"
                else:
                    self.sys_info("请输入正整数,或FF！")
            self.show_all_fat()
            self.old_key = None
    
            for i in range(10):
                for n in range(10):
                    if self.SimFAT[i][n] != 0:
                        num = i * 10 + n
                        self.fat_unique_set.add(num)
            self.sys_info("保存表单成功！")
            self.special_info("FAT 保存成功！\n可以开始校验。")
            self.fat_modi_tag = False  # 修改标志置否保存后就不再能修改
        else:
            self.sys_info("未开启FAT校验流程。")

    def fat_checkout(self):
        print("FAT校验")
        if self.sim_fat_copy and not self.fat_modi_tag:
            num = 0
            tag = False
            for i in range(10):
                for n in range(10):
                    num += 1
                    if self.SimFAT[i][n] != self.sim_fat_copy[i][n]:
                        self.sys_info(f"校验失败\n{i}行{n}列错误")
                        tag = True
                        break
                if tag:
                    break

            if num == 100:
                self.sys_info("校验正确")
                self.special_info("恭喜！\nFAT校验正确！")
                
                self.sim_fat_copy = None
                
        else:
            self.sys_info("未完成修改操作，不可校验")

    def clear_disk_label(self):
        print("清除标签")
        if self.clear_tag:
            self.block_modi_tag = True
            self.special_info("正在进行磁盘块校验。\n请点击修改标签,\n补充清除的磁盘块标签。")
            self.canvas.delete("block_entry")
            self.canvas.delete("label_disk")
            # self.canvas.delete("")
            self.clear_tag = False  # 将清除标志置否，防止其他模块改动
            if not self.sim_disk_copy:
                self.sim_disk_copy = copy.deepcopy(self.SimDisk)  # 复制一份原正确列表并保存为复制对象

            for i in range(10):
                for j in range(10):
                    if self.SimDisk[i][j] != 0:
                        self.SimDisk[i][j] = 0
            self.sys_info("清除成功！")
            self.show_all_disk()
        else:
            self.sys_info("正在执行校验任务，无法清除磁盘模块标签。")
            

    def modi_block_lb(self):  # 修改标签
        print("修改标签")
        if self.block_modi_tag:
            self.special_info("正在修改磁盘块。\n点击磁盘模块区域修改值。\n完成后保存标签。")
            self.clear_tag = False  # 修改磁盘标签时冻结文件分配表的按钮
            if not self.sim_disk_copy:
                self.sim_disk_copy = copy.deepcopy(self.SimDisk)  # 深度拷贝数组
    
            self.ex_disk_la = False
            self.canvas.delete("prl")
            self.exchange_button_disk_label()
        else:
            self.sys_info("未开启磁盘块校验流程。")

    def modi_block_entry(self, row, column, lt_top):
        default = self.SimDisk[row][column]

        if self.block_modi_lb:
            label = self.block_modi_lb.get().upper()
            if label != "0":
                if re.match(r'^[A-Za-z]\d+$', label):  # 正则表达式将匹配如 "A1"、"b2"、"Z9" 等形式的字符串
                    self.SimDisk[self.old_key[0]][self.old_key[1]] = label
                    self.sys_info(f"{self.old_key} -> {label}添加成功！")
                else:
                    self.sys_info("请输入正确格式，如：A1！")

        self.canvas.delete("block_entry")
        self.block_modi_lb = self.set_canvas_entry(lt_top[0] + 2, lt_top[1] + 10, 3, default, "block_entry", 12)
        self.block_modi_lb.select_range(0, tk.END)  # 使Entry组件获得焦点（选中），以便可以直接修改值
        self.old_key = [row, column]
        self.show_all_disk()

    def modi_block_save(self):
        print("保存标签")
        if self.block_modi_tag:
            self.canvas.delete("block_entry")
            self.ex_disk_la = True
            self.canvas.delete("psl")
            self.exchange_button_disk_label()
            if self.block_modi_lb:
                label = self.block_modi_lb.get().upper()
                if label != "0":
                    if re.match(r'^[A-Za-z]\d+$', label):  # 正则表达式将匹配如 "A1"、"b2"、"Z9" 等形式的字符串
                        self.SimDisk[self.old_key[0]][self.old_key[1]] = label
                        self.sys_info(f"{self.old_key} -> {label}添加成功！")
                    else:
                        self.sys_info("请输入正确格式，如：A1！")
    
                for i in range(10):
                    for n in range(10):
                        if self.SimDisk[i][n] != 0 and self.SimDisk[i][n] != "":
                            num = i * 10 + n
                            code = self.SimDisk[i][n][0]  # 取第一个字母
                            blocks_label_set.add(code)  # 添加字母到字母唯一集合
                            self.fat_unique_set.add(num)  # 将被占用的位置添加到唯一FAT表中防止被选中
    
            self.block_modi_lb = False  # 修改标签置否。                
            self.show_all_disk()
            self.block_modi_tag = False  # 磁盘修改标签置否
            self.clear_tag = True
            self.special_info("磁盘块已保存。\n可以开始校验。")
            self.sys_info("磁盘块保存成功！")
        else:
            self.sys_info("未开启磁盘校验流程")

    def add_occupy(self):
        print("添加占用")
        self.ex_disk_oc = False
        self.canvas.delete("pao")
        self.exchange_button_disk_occupy()
        self.sys_info("正在添加占用...")
        self.special_info("正在添加占用。")

    def add_occupy_click(self, x, y):
        if not self.ex_disk_oc:
            for key, block_lt in self.blocks_position_mapping.items():
                if block_lt[0] < x < block_lt[0] + 43 and block_lt[1] < y < block_lt[1] + 43:
                    self.SimDisk[key[0]][key[1]] = ""
                    self.SimFAT[key[0]][key[1]] = "X"
                    print(key[0], key[1])
                    self.show_all_disk()
                    self.show_all_fat()
                    self.sys_info(f"{key}添加成功")

    def disk_checkout(self):
        print("Disk校验")
        if self.sim_disk_copy and not self.block_modi_tag:
            num = 0
            tag = False
            for i in range(10):
                for n in range(10):
                    num += 1
                    if self.SimDisk[i][n] != self.sim_disk_copy[i][n]:
                        if self.SimDisk[i][n] != "":
                            self.sys_info(f"校验失败\n{i}行{n}列错误")
                            tag = True
                            break
                if tag:
                    break
            if num == 100:
                self.special_info("恭喜！\n磁盘校验正确！")
                self.sys_info("校验正确")
                self.sim_disk_copy = None
        else:
            self.sys_info("未进行修改操作，不可校验")

    def save_occupy(self):
        print("保存占用")
        self.ex_disk_oc = True
        self.canvas.delete("pso")
        self.exchange_button_disk_occupy()

        for i in range(10):
            for n in range(10):
                if self.SimDisk[i][n] != 0:
                    num = i * 10 + n
                    self.fat_unique_set.add(num)
        self.sys_info("保存占用成功！")
        self.special_info("保存占用成功！")

    def on_left_click(self, event, ):
        x = event.x
        y = event.y
        print(x, y)
        if self.fat_modi_tag:
            for key, fat_lt in self.fat_table_position_mapping.items():
                if fat_lt[0] < x < fat_lt[0] + 43 and fat_lt[1] < y < fat_lt[1] + 43:
                    self.modi_fat_entry(key[0], key[1], fat_lt)

        if self.block_modi_tag:
            for key, block_lt in self.blocks_position_mapping.items():
                if block_lt[0] < x < block_lt[0] + 43 and block_lt[1] < y < block_lt[1] + 43:
                    self.modi_block_entry(key[0], key[1], block_lt)

        self.add_occupy_click(x, y)

        # pprint(self.SimFAT)

    def show_real_disk(self, title, sector):
        child_window = tk.Toplevel(self.root)
        child_window.title(title)
        
        child_window1 = tk.Toplevel(self.root)
        child_window1.title(f"{title}_字节解析")
        
        sector_num, Bytes = sector
        canvas = tk.Canvas(child_window, width=750, height=830, bg="white", )
        canvas1 = tk.Canvas(child_window1, width=750, height=830, bg="white", )
        BYTES_PER_LINE = 16  # 每行字节数
        n = 0
        s = 0
        for byte in range(16):
            if s % 9 == 0:
                s = s + 1
            canvas.create_text(100 + s * 35, 20 + n * 24, text=f"{byte:02X}", anchor="nw", fill="red",
                               font=("Arial", 14))
            canvas1.create_text(100 + s * 35, 20 + n * 24, text=f"{byte:02X}", anchor="nw", fill="red",
                               font=("Arial", 14))
            s += 1
        n += 1
        for i in range(0, len(Bytes), BYTES_PER_LINE):
            line_data = Bytes[i:i + BYTES_PER_LINE]
            print(f"{sector_num * 32 + i:08X}:", end=" ")
            canvas.create_text(20, 20 + n * 24, text=f"{sector_num * 32 + i:08X}:", anchor="nw", fill="red",font=("Arial", 14))
            canvas1.create_text(20, 20 + n * 24, text=f"{sector_num * 32 + i:08X}:", anchor="nw", fill="red",font=("Arial", 14))
            s = 0
            for byte in line_data:
                print(f"{byte:02X}", end=" ")
                print(chr(byte), end="  ")
                if s % 9 == 0:
                    s = s + 1
                canvas.create_text(100 + s * 35, 20 + n * 24, text=f"{byte:02X}", anchor="nw", fill="black",font=("Arial", 14))
                canvas1.create_text(100 + s * 35, 20 + n * 24, text=f"{chr(byte)}", anchor="nw", fill="black",font=("Arial", 14))
                s += 1
            print()
            n += 1
        canvas.pack(fill=tk.BOTH, expand=True)
        canvas1.pack(fill=tk.BOTH, expand=True)
        self.sys_info(f"正在查看{title}")


if __name__ == '__main__':
    root = tk.Tk()
    root.resizable(False, False)  # 禁止用户调整窗口大小
    main = InterfaceFile(root)
    # root.after(60000, close_window)
    root.mainloop()