Skip to content
TheChatArchiveThe Chat Archive
o1-preview-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

import tkinter as tk from tkinter import filedialog, messagebox import tkinter.ttk as…

  1. User

    import tkinter as tk from tkinter import filedialog, messagebox import tkinter.ttk as ttk # Thêm để sử dụng ttk import fitz # PyMuPDF import pandas as pd from PIL import Image, ImageTk import os import tempfile from reportlab.pdfgen import canvas as reportlab_canvas from reportlab.pdfbase.ttfonts import TTFont from reportlab.pdfbase import pdfmetrics import matplotlib.font_manager as fm from fontTools.ttLib import TTFont as FontToolsTTFont import sys import cairosvg # Để chuyển đổi SVG sang PDF import comtypes.client import win32com.client as win32 from docx2pdf import convert as docx2pdf_convert import uuid import time import gc

    class PDFEditorApp: def init(self, root): # Chú ý: init với hai dấu gạch dưới self.root = root self.root.title("Phần mềm tạo dữ liệu biến đổi - Bản quyền thuộc về NhanNguyen") self.root.configure(bg='#2c2f33') self.root.bind("", self.delete_text) self.root.bind("", self.undo) self.root.bind("", self.redo)

        self.file_path = None
        self.excel_path = None
        self.pdf_image = None
        self.coords = {}
        self.df = None
        self.fields = []
        self.font_var = tk.StringVar(value="Arial")
        self.font_size_var = tk.IntVar(value=12)
        self.cmyk_vars = {
            "C": tk.DoubleVar(value=0.0),
            "M": tk.DoubleVar(value=0.0),
            "Y": tk.DoubleVar(value=0.0),
            "K": tk.DoubleVar(value=0.0)
        }
    
        self.original_width = 0
        self.original_height = 0
        self.current_page_index = 0
        self.pdf_doc = None
        self.font_file_dict = {}
        self.undo_stack = []
        self.redo_stack = []
    
        self.field_type = tk.StringVar(value="Text")
        self.image_width_var = tk.DoubleVar(value=100.0)
        self.image_height_var = tk.DoubleVar(value=100.0)
    
        self.selected_field = tk.StringVar()
        self.selected_items = set()
        self.zoom_level = 1.0
    
        self.preview_pdf_path = None
        self.preview_doc = None
        self.preview_page_index = 0
    
        self.is_previewing = False
    
        self.excel_row_index = 0
    
        self.cropmark_offset_var = tk.DoubleVar(value=3.0)
        self.cropmark_length_var = tk.DoubleVar(value=5.0)
    
        self.scale_option = tk.StringVar(value="Scale đều")
        
        self.start_number_var = tk.IntVar(value=1)
        self.end_number_var = tk.IntVar(value=1000)
        self.total_zeros_var = tk.IntVar(value=5)
    
        self.setup_ui()
    
    def get_installed_fonts(self):
        """Lấy danh sách các font TrueType đã cài đặt."""
        font_list = fm.findSystemFonts(fontpaths=None, fontext='ttf')
        for font_path in font_list:
            font_name = self.get_font_full_name(font_path)
            if font_name:
                self.font_file_dict[font_name] = font_path
        return list(self.font_file_dict.keys())
    
    def get_font_full_name(self, font_path):
        """Lấy tên đầy đủ của font sử dụng fontTools."""
        try:
            font = FontToolsTTFont(font_path)
            name = ""
            for record in font['name'].names:
                if record.nameID == 4 and record.platformID == 3:
                    name = record.string.decode('utf-16-be')
                    break
                elif record.nameID == 4 and record.platformID == 1:
                    name = record.string.decode('utf-8')
                    break
            font.close()
            return name
        except Exception:
            return None
    
    def check_font_availability(self, font_path):
        """Kiểm tra xem tệp font có khả dụng và hợp lệ không."""
        try:
            font = FontToolsTTFont(font_path)
            font.close()
            return True
        except Exception:
            return False
    
    def setup_ui(self):
        """Thiết lập các thành phần giao diện người dùng."""
        # Hàng đầu tiên của các nút
        button_frame = tk.Frame(self.root, bg='#2c2f33')
        button_frame.pack(pady=5, fill=tk.X)
    
        select_pdf_button = tk.Button(button_frame, text="Chọn tệp", command=self.load_file, bg='#7289da', fg='white')
        select_pdf_button.pack(side=tk.LEFT, padx=2)
    
        select_excel_button = tk.Button(button_frame, text="Chọn Excel", command=self.load_excel, bg='#7289da', fg='white')
        select_excel_button.pack(side=tk.LEFT, padx=2)
    
        save_button = tk.Button(button_frame, text="Xuất PDF", command=self.export_pdfs, bg='#7289da', fg='white')
        save_button.pack(side=tk.LEFT, padx=2)
    
        prev_button = tk.Button(button_frame, text="Trang trước", command=self.prev_page, bg='#7289da', fg='white')
        prev_button.pack(side=tk.LEFT, padx=2)
    
        next_button = tk.Button(button_frame, text="Trang tiếp", command=self.next_page, bg='#7289da', fg='white')
        next_button.pack(side=tk.LEFT, padx=2)
    
        # Thêm nút Dữ liệu trước và Dữ liệu tiếp
        prev_data_button = tk.Button(button_frame, text="Dữ liệu trước", command=self.prev_data, bg='#7289da', fg='white')
        prev_data_button.pack(side=tk.LEFT, padx=2)
    
        next_data_button = tk.Button(button_frame, text="Dữ liệu tiếp", command=self.next_data, bg='#7289da', fg='white')
        next_data_button.pack(side=tk.LEFT, padx=2)
    
        font_label = tk.Label(button_frame, text="Chọn font:", bg='#2c2f33', fg='white')
        font_label.pack(side=tk.LEFT, padx=2)
    
        # Lấy và sắp xếp danh sách font chữ theo thứ tự chữ cái
        self.font_files = sorted(self.get_installed_fonts())
    
        # Tạo Entry cho việc nhập và chọn font chữ
        self.font_entry = tk.Entry(button_frame, textvariable=self.font_var)
        self.font_entry.pack(side=tk.LEFT, padx=2)
        self.font_entry.bind('<KeyRelease>', self.on_font_entry_keyrelease)
        self.font_entry.bind('<Button-1>', self.show_font_listbox)
        size_label = tk.Label(button_frame, text="Kích cỡ chữ:", bg='#2c2f33', fg='white')
        size_label.pack(side=tk.LEFT, padx=2)
    
        size_entry = tk.Entry(button_frame, textvariable=self.font_size_var, width=5)
        size_entry.pack(side=tk.LEFT, padx=2)
        size_entry.bind("<KeyRelease>", self.update_canvas_font)
    
        # Nhập màu CMYK
        for color in ["C", "M", "Y", "K"]:
            color_label = tk.Label(button_frame, text=f"{color}:", bg='#2c2f33', fg='white')
            color_label.pack(side=tk.LEFT, padx=2)
            color_entry = tk.Entry(button_frame, textvariable=self.cmyk_vars[color], width=5)
            color_entry.pack(side=tk.LEFT, padx=2)
            color_entry.bind("<KeyRelease>", self.update_canvas_font)
    
        # Chọn loại trường
        tk.Radiobutton(button_frame, text="Văn bản", variable=self.field_type, value="Text",
                       bg='#2c2f33', fg='white', selectcolor='#7289da').pack(side=tk.LEFT, padx=2)
        tk.Radiobutton(button_frame, text="Hình ảnh", variable=self.field_type, value="Image",
                       bg='#2c2f33', fg='white', selectcolor='#7289da').pack(side=tk.LEFT, padx=2)
    
        # Nhập kích thước hình ảnh
        tk.Label(button_frame, text="Chiều rộng (mm):", bg='#2c2f33', fg='white').pack(side=tk.LEFT, padx=2)
        tk.Entry(button_frame, textvariable=self.image_width_var, width=5).pack(side=tk.LEFT, padx=2)
    
        tk.Label(button_frame, text="Chiều cao (mm):", bg='#2c2f33', fg='white').pack(side=tk.LEFT, padx=2)
        tk.Entry(button_frame, textvariable=self.image_height_var, width=5).pack(side=tk.LEFT, padx=2)
    
        # Hàng thứ hai của các nút
        button_frame2 = tk.Frame(self.root, bg='#2c2f33')
        button_frame2.pack(pady=5, fill=tk.X)
    
        align_left_button = tk.Button(button_frame2, text="Canh trái", command=self.align_left, bg='#7289da', fg='white')
        align_left_button.pack(side=tk.LEFT, padx=2)
    
        align_right_button = tk.Button(button_frame2, text="Canh phải", command=self.align_right, bg='#7289da', fg='white')
        align_right_button.pack(side=tk.LEFT, padx=2)
    
        align_center_button = tk.Button(button_frame2, text="Canh giữa", command=self.align_center, bg='#7289da', fg='white')
        align_center_button.pack(side=tk.LEFT, padx=2)
    
        align_top_button = tk.Button(button_frame2, text="Canh trên", command=self.align_top, bg='#7289da', fg='white')
        align_top_button.pack(side=tk.LEFT, padx=2)
    
        align_bottom_button = tk.Button(button_frame2, text="Canh dưới", command=self.align_bottom, bg='#7289da', fg='white')
        align_bottom_button.pack(side=tk.LEFT, padx=2)
    
        preview_button = tk.Button(button_frame2, text="Xem trước", command=self.preview_pdf, bg='#7289da', fg='white')
        preview_button.pack(side=tk.LEFT, padx=2)
    
        # Thêm Combobox cho tùy chọn scale
        scale_options = ["Scale đều", "Scale ngang", "Scale dọc", "Điều chỉnh kerning"]
        self.scale_option_combobox = ttk.Combobox(button_frame2, textvariable=self.scale_option,
                                                  values=scale_options, state="readonly")
        self.scale_option_combobox.pack(side=tk.LEFT, padx=2)
        self.scale_option_combobox.current(0)  # Đặt giá trị mặc định là "Scale đều"
    
        # Ánh xạ giá trị hiển thị sang giá trị nội bộ
        self.scale_option_mapping = {
            "Scale đều": "uniform",
            "Scale ngang": "horizontal",
            "Scale dọc": "vertical",
            "Điều chỉnh kerning": "kerning"
        }
    
        # Liên kết sự kiện khi thay đổi giá trị trong Combobox
        self.scale_option_combobox.bind("<<ComboboxSelected>>", self.on_scale_option_changed)
        
        # Đánh số nhảy
        tk.Label(button_frame2, text="Số bắt đầu:", bg='#2c2f33', fg='white').pack(side=tk.LEFT, padx=2)
        tk.Entry(button_frame2, textvariable=self.start_number_var, width=5).pack(side=tk.LEFT, padx=2)
    
        tk.Label(button_frame2, text="Số kết thúc:", bg='#2c2f33', fg='white').pack(side=tk.LEFT, padx=2)
        tk.Entry(button_frame2, textvariable=self.end_number_var, width=5).pack(side=tk.LEFT, padx=2)
    
        tk.Label(button_frame2, text="Tổng số 0:", bg='#2c2f33', fg='white').pack(side=tk.LEFT, padx=2)
        tk.Entry(button_frame2, textvariable=self.total_zeros_var, width=5).pack(side=tk.LEFT, padx=2)
    
        # Hàng thứ ba của các nút (thông số Imposition)
        imposition_frame = tk.Frame(self.root, bg='#2c2f33')
        imposition_frame.pack(pady=5, fill=tk.X)
    
        tk.Label(imposition_frame, text="Khổ giấy (mm):", bg='#2c2f33', fg='white').pack(side=tk.LEFT, padx=2)
    
        tk.Label(imposition_frame, text="Chiều rộng:", bg='#2c2f33', fg='white').pack(side=tk.LEFT, padx=2)
        self.new_page_width_var = tk.DoubleVar(value=210.0)
        tk.Entry(imposition_frame, textvariable=self.new_page_width_var, width=5).pack(side=tk.LEFT, padx=2)
    
        tk.Label(imposition_frame, text="Chiều cao:", bg='#2c2f33', fg='white').pack(side=tk.LEFT, padx=2)
        self.new_page_height_var = tk.DoubleVar(value=297.0)
        tk.Entry(imposition_frame, textvariable=self.new_page_height_var, width=5).pack(side=tk.LEFT, padx=2)
    
        tk.Label(imposition_frame, text="Lề (mm):", bg='#2c2f33', fg='white').pack(side=tk.LEFT, padx=2)
    
        tk.Label(imposition_frame, text="Trên:", bg='#2c2f33', fg='white').pack(side=tk.LEFT, padx=2)
        self.margin_top_var = tk.DoubleVar(value=10.0)
        tk.Entry(imposition_frame, textvariable=self.margin_top_var, width=5).pack(side=tk.LEFT, padx=2)
    
        tk.Label(imposition_frame, text="Dưới:", bg='#2c2f33', fg='white').pack(side=tk.LEFT, padx=2)
        self.margin_bottom_var = tk.DoubleVar(value=10.0)
        tk.Entry(imposition_frame, textvariable=self.margin_bottom_var, width=5).pack(side=tk.LEFT, padx=2)
    
        tk.Label(imposition_frame, text="Trái:", bg='#2c2f33', fg='white').pack(side=tk.LEFT, padx=2)
        self.margin_left_var = tk.DoubleVar(value=10.0)
        tk.Entry(imposition_frame, textvariable=self.margin_left_var, width=5).pack(side=tk.LEFT, padx=2)
    
        tk.Label(imposition_frame, text="Phải:", bg='#2c2f33', fg='white').pack(side=tk.LEFT, padx=2)
        self.margin_right_var = tk.DoubleVar(value=10.0)
        tk.Entry(imposition_frame, textvariable=self.margin_right_var, width=5).pack(side=tk.LEFT, padx=2)
    
        # Khoảng cách crop marks
        tk.Label(imposition_frame, text="Khoảng cách crop marks (mm):", bg='#2c2f33',
                 fg='white').pack(side=tk.LEFT, padx=2)
        self.cropmark_offset_var = tk.DoubleVar(value=3.0)
        tk.Entry(imposition_frame, textvariable=self.cropmark_offset_var, width=5).pack(side=tk.LEFT, padx=2)
    
        # Độ dài crop marks
        tk.Label(imposition_frame, text="Độ dài crop marks (mm):", bg='#2c2f33', fg='white').pack(side=tk.LEFT, padx=2)
        self.cropmark_length_var = tk.DoubleVar(value=5.0)
        tk.Entry(imposition_frame, textvariable=self.cropmark_length_var, width=5).pack(side=tk.LEFT, padx=2)
    
        # Điều chỉnh khung để hiển thị canvas chính
        content_frame = tk.Frame(self.root, bg='#2c2f33')
        content_frame.pack(pady=5, fill=tk.BOTH, expand=True)
    
        # Khung canvas chính
        main_canvas_frame = tk.Frame(content_frame, bg='#2c2f33')
        main_canvas_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
    
        self.canvas = tk.Canvas(main_canvas_frame, bg="gray")
        self.canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
    
        # Thêm thanh cuộn cho canvas
        hbar = tk.Scrollbar(main_canvas_frame, orient=tk.HORIZONTAL)
        hbar.pack(side=tk.BOTTOM, fill=tk.X)
        hbar.config(command=self.canvas.xview)
        vbar = tk.Scrollbar(main_canvas_frame, orient=tk.VERTICAL)
        vbar.pack(side=tk.RIGHT, fill=tk.Y)
        vbar.config(command=self.canvas.yview)
        self.canvas.config(xscrollcommand=hbar.set, yscrollcommand=vbar.set)
    
        self.canvas.bind("<Button-1>", self.canvas_click)
        self.canvas.bind("<B1-Motion>", self.move_text)
        self.canvas.bind("<MouseWheel>", self.zoom_with_mouse_wheel)
        self.canvas.bind("<Button-4>", self.zoom_with_mouse_wheel)  # Cho Linux
        self.canvas.bind("<Button-5>", self.zoom_with_mouse_wheel)
    
        # Khung chọn trường
        self.excel_button_frame = tk.Frame(self.root, bg='#2c2f33')
        self.excel_button_frame.pack(fill=tk.X, padx=5, pady=5)
        
        self.start_number_var.trace('w', self.update_numbering_and_canvas)
        self.end_number_var.trace('w', self.update_numbering_and_canvas)
        self.total_zeros_var.trace('w', self.update_numbering_and_canvas)
    
    def show_font_listbox(self, event):
        """Hiển thị Listbox với danh sách font và thanh cuộn."""
        if hasattr(self, 'font_listbox_window') and self.font_listbox_window.winfo_exists():
            return  # Nếu cửa sổ Listbox đang hiển thị, không làm gì cả
    
        # Tạo cửa sổ toplevel mới
        self.font_listbox_window = tk.Toplevel(self.root)
        self.font_listbox_window.wm_overrideredirect(True)
    
        # Lấy vị trí của Entry để đặt cửa sổ Listbox
        x = self.font_entry.winfo_rootx()
        y = self.font_entry.winfo_rooty() + self.font_entry.winfo_height()
        width = self.font_entry.winfo_width()
        self.font_listbox_window.geometry(f"{width}x200+{x}+{y}")
    
        # Tạo Listbox và thanh cuộn
        self.font_scrollbar = tk.Scrollbar(self.font_listbox_window)
        self.font_scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
    
        self.font_listbox = tk.Listbox(self.font_listbox_window, yscrollcommand=self.font_scrollbar.set, height=10)
        self.font_listbox.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        self.font_scrollbar.config(command=self.font_listbox.yview)
    
        # Điền danh sách font vào Listbox
        self.update_font_listbox(self.font_files)
    
        # Liên kết sự kiện chọn font
        self.font_listbox.bind('<<ListboxSelect>>', self.on_font_listbox_select)
    
        # Thay vì liên kết sự kiện nhấp chuột lên root, chúng ta liên kết FocusOut trên Listbox window
        self.font_listbox_window.bind('<FocusOut>', self.hide_font_listbox)
    
    def hide_font_listbox(self, event=None):
        """Ẩn Listbox và bỏ liên kết sự kiện."""
        if hasattr(self, 'font_listbox_window') and self.font_listbox_window.winfo_exists():
            self.font_listbox_window.destroy()
            del self.font_listbox_window
            del self.font_listbox  # Xóa thuộc tính font_listbox để tránh lỗi sau này
            del self.font_scrollbar  # Xóa thuộc tính font_scrollbar
    
    def on_font_listbox_select(self, event):
        """Xử lý khi người dùng chọn font từ Listbox."""
        selection = self.font_listbox.curselection()
        if selection:
            index = selection[0]
            font_name = self.font_listbox.get(index)
            self.font_var.set(font_name)
            self.update_canvas_font()
            # Đóng cửa sổ Listbox
            self.hide_font_listbox()
    
    def on_font_entry_keyrelease(self, event):
        """Cập nhật Listbox dựa trên đầu vào của người dùng."""
        value = self.font_var.get()
        value = value.strip().lower()
        if value == '':
            data = self.font_files
        else:
            data = []
            for item in self.font_files:
                if value in item.lower():
                    data.append(item)
        # Cập nhật Listbox
        if hasattr(self, 'font_listbox_window') and self.font_listbox_window.winfo_exists():
            self.update_font_listbox(data)
        else:
            self.show_font_listbox(event)
    
    def update_font_listbox(self, font_list):
        """Cập nhật nội dung của Listbox."""
        if not (hasattr(self, 'font_listbox') and self.font_listbox.winfo_exists()):
            return  # Nếu Listbox không tồn tại, không làm gì cả
        self.font_listbox.delete(0, tk.END)
        for font in font_list:
            self.font_listbox.insert(tk.END, font)
    
    def on_scale_option_changed(self, event):
        """Xử lý khi người dùng thay đổi tùy chọn scale."""
        # Cập nhật xem trước nếu cần
        self.update_preview()
    
    def load_file(self):
        """Tải tệp đã chọn và hiển thị trang đầu tiên."""
        filetypes = [
            ("Supported files", "*.pdf *.ai *.eps *.svg *.tiff *.tif *.jpg *.jpeg .png .pptx"),
            ("PDF files", ".pdf"),
            ("Image files", ".tiff .tif .jpg .jpeg .png"),
            ("Vector files", ".ai .eps .svg"),
            ("PowerPoint files", ".pptx"),
            ("All files", ".")
        ]
        self.file_path = filedialog.askopenfilename(filetypes=filetypes)
        if self.file_path:
            try:
                # Đóng tài liệu hiện tại nếu đang mở
                if self.pdf_doc:
                    self.pdf_doc.close()
                self.convert_file_to_pdf()
                self.pdf_doc = fitz.open(self.temp_pdf_path)
                self.current_page_index = 0  # Đặt lại chỉ số trang
                self.display_pdf_page()
                self.reset_preview()
            except Exception as e:
                messagebox.showerror("Lỗi", f"Không thể mở tệp: {e}")
                self.file_path = None
                self.pdf_doc = None
    
    def convert_file_to_pdf(self):
        """Chuyển đổi tệp đầu vào sang PDF nếu cần thiết."""
        ext = os.path.splitext(self.file_path)[1].lower()
        temp_dir = tempfile.gettempdir()
        unique_id = str(uuid.uuid4())
        self.temp_pdf_path = os.path.join(temp_dir, f"temp_input_{unique_id}.pdf")
    
        if ext == ".pdf":
            self.temp_pdf_path = self.file_path  # Không cần chuyển đổi
    
        elif ext in [".doc", ".docx"]:
            try:
                docx2pdf_convert(self.file_path, self.temp_pdf_path)
            except Exception as e:
                raise Exception(f"Không thể chuyển đổi tệp Word sang PDF: {e}")
    
        elif ext in [".xls", ".xlsx"]:
            try:
                excel = win32.Dispatch("Excel.Application")
                excel.Visible = False
                wb = excel.Workbooks.Open(self.file_path)
                wb.ExportAsFixedFormat(0, self.temp_pdf_path)
                wb.Close(False)
                excel.Quit()
            except Exception as e:
                raise Exception(f"Không thể chuyển đổi tệp Excel sang PDF: {e}")
    
        elif ext == ".ai":
            try:
                app = comtypes.client.CreateObject("Illustrator.Application")
                doc = app.Open(self.file_path)
                options = comtypes.client.CreateObject("Illustrator.PDFSaveOptions")
                doc.SaveAs(self.temp_pdf_path, options)
                doc.Close()
                app.Quit()
            except Exception as e:
                raise Exception(f"Không thể chuyển đổi tệp AI sang PDF: {e}")
    
        elif ext == ".cdr":
            try:
                app = comtypes.client.CreateObject("CorelDRAW.Application")
                doc = app.OpenDocument(self.file_path)
                doc.PublishToPDF(self.temp_pdf_path)
                doc.Close()
                app.Quit()
            except Exception as e:
                raise Exception(f"Không thể chuyển đổi tệp CDR sang PDF: {e}")
    
        elif ext == ".psd":
            try:
                app = comtypes.client.CreateObject("Photoshop.Application")
                doc = app.Open(self.file_path)
                options = comtypes.client.CreateObject("Photoshop.PDFSaveOptions")
                doc.SaveAs(self.temp_pdf_path, options)
                doc.Close()
                app.Quit()
            except Exception as e:
                raise Exception(f"Không thể chuyển đổi tệp PSD sang PDF: {e}")
    
        elif ext == ".indd":
            try:
                app = comtypes.client.CreateObject("InDesign.Application")
                doc = app.Open(self.file_path)
                pdf_preset = app.PDFExportPresets.Item("High Quality Print")
                doc.Export(1242363897, self.temp_pdf_path, False, pdf_preset)
                doc.Close()
                app.Quit()
            except Exception as e:
                raise Exception(f"Không thể chuyển đổi tệp InDesign sang PDF: {e}")
    
        elif ext in [".jpg", ".jpeg", ".png", ".tif", ".tiff", ".webp"]:
            # Chuyển đổi hình ảnh sang PDF với kích thước trang chính xác
            image = Image.open(self.file_path)
            width_px, height_px = image.size
            dpi = image.info.get('dpi', (72, 72))[0]  # Lấy DPI từ hình ảnh, mặc định là 72
            width_inch = width_px / dpi
            height_inch = height_px / dpi
            page_width = width_inch * 72  # 1 inch = 72 points
            page_height = height_inch * 72
    
            c = reportlab_canvas.Canvas(self.temp_pdf_path, pagesize=(page_width, page_height))
            c.drawImage(self.file_path, 0, 0, width=page_width, height=page_height)
            c.showPage()
            c.save()
    
            # Thiết lập các hộp PDF
            doc = fitz.open(self.temp_pdf_path)
            for page in doc:
                rect = fitz.Rect(0, 0, page_width, page_height)
                page.set_cropbox(rect)
                page.set_trimbox(rect)
                page.set_artbox(rect)
            doc.saveIncr()
            doc.close()
    
        elif ext == ".svg":
            # Chuyển đổi SVG sang PDF
            cairosvg.svg2pdf(url=self.file_path, write_to=self.temp_pdf_path)
    
        elif ext == ".eps":
            # Chuyển đổi EPS sang PDF bằng Ghostscript
            try:
                import subprocess
                subprocess.call(['gs', '-dNOPAUSE', '-dBATCH', '-sDEVICE=pdfwrite',
                                 '-sOutputFile=' + self.temp_pdf_path, self.file_path])
            except Exception as e:
                raise Exception(f"Không thể chuyển đổi tệp EPS sang PDF: {e}")
    
        elif ext == ".ps":
            # Chuyển đổi PostScript sang PDF bằng Ghostscript
            try:
                import subprocess
                subprocess.call(['gs', '-dNOPAUSE', '-dBATCH', '-sDEVICE=pdfwrite',
                                 '-sOutputFile=' + self.temp_pdf_path, self.file_path])
            except Exception as e:
                raise Exception(f"Không thể chuyển đổi tệp PS sang PDF: {e}")
    
        elif ext == ".pptx":
            # Chuyển đổi PowerPoint sang PDF
            try:
                powerpoint = comtypes.client.CreateObject("Powerpoint.Application")
                powerpoint.Visible = 1
                deck = powerpoint.Presentations.Open(self.file_path)
                deck.SaveAs(self.temp_pdf_path, 32)  # 32 cho định dạng PDF
                deck.Close()
                powerpoint.Quit()
            except Exception as e:
                raise Exception(f"Không thể chuyển đổi tệp PPTX sang PDF: {e}")
    
        else:
            raise Exception("Định dạng tệp không được hỗ trợ.")
    
    def display_pdf_page(self):
        """Hiển thị trang hiện tại của PDF."""
        if self.pdf_doc:
            try:
                page = self.pdf_doc.load_page(self.current_page_index)
                self.original_width, self.original_height = page.rect.width, page.rect.height
                # Điều chỉnh ma trận cho zoom
                zoom_matrix = fitz.Matrix(self.zoom_level, self.zoom_level)
                pix = page.get_pixmap(matrix=zoom_matrix)
                img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
                self.pdf_image = ImageTk.PhotoImage(img)
                self.canvas.delete("all")
                self.canvas.create_image(0, 0, anchor="nw", image=self.pdf_image, tags='background')
                # Cập nhật kích thước canvas
                self.canvas.config(width=pix.width, height=pix.height)
                self.canvas.config(scrollregion=self.canvas.bbox(tk.ALL))
                self.render_text_on_page()
            except Exception as e:
                messagebox.showerror("Lỗi", f"Không thể hiển thị trang: {e}")
    
    def prev_page(self):
        """Chuyển đến trang trước của PDF."""
        if self.pdf_doc:
            if self.current_page_index > 0:
                self.current_page_index -= 1
                self.display_pdf_page()
    
    def next_page(self):
        """Chuyển đến trang tiếp theo của PDF."""
        if self.pdf_doc:
            if self.current_page_index < len(self.pdf_doc) - 1:
                self.current_page_index += 1
                self.display_pdf_page()
    
    def prev_data(self):
        """Chuyển đến hàng dữ liệu trước trong Excel và cập nhật hiển thị."""
        if self.df is not None and self.excel_row_index > 0:
            self.excel_row_index -= 1
            self.display_pdf_page()  # Cập nhật canvas chính
            if self.is_previewing:
                self.preview_pdf()
    
    def next_data(self):
        """Chuyển đến hàng dữ liệu tiếp theo trong Excel và cập nhật hiển thị."""
        if self.df is not None and self.excel_row_index < len(self.df) - 1:
            self.excel_row_index += 1
            self.display_pdf_page()  # Cập nhật canvas chính
            if self.is_previewing:
                self.preview_pdf()
    
    def canvas_click(self, event):
        """Xử lý sự kiện khi người dùng nhấp chuột trên canvas."""
        clicked_items = self.canvas.find_withtag(tk.CURRENT)
        # Bỏ qua hình ảnh nền
        if clicked_items:
            clicked_item = clicked_items[0]
            if 'background' in self.canvas.gettags(clicked_item):
                clicked_items = ()
        if clicked_items:
            clicked_item = clicked_items[0]
            item_type = self.canvas.type(clicked_item)
            if item_type in ["text", "rectangle", "image"] or "anchor" in self.canvas.gettags(clicked_item):
                if event.state & 0x0001 or event.state & 0x0004:  # Shift or Control pressed
                    if clicked_item in self.selected_items:
                        self.selected_items.remove(clicked_item)
                        # Bỏ chọn mục
                        self.deselect_item(clicked_item)
                    else:
                        self.selected_items.add(clicked_item)
                        # Chọn mục
                        self.select_item(clicked_item)
                else:
                    # Bỏ chọn các mục trước đó
                    for item in self.selected_items:
                        self.deselect_item(item)
                    self.selected_items = set([clicked_item])
                    self.select_item(clicked_item)
                # Khởi tạo tọa độ di chuyển
                self.last_move_x = event.x
                self.last_move_y = event.y
            else:
                self.add_text(event.x, event.y)
        else:
            self.add_text(event.x, event.y)
        self.update_preview()
    
    def select_item(self, item_id):
        """Hiển thị mục được chọn."""
        item_type = self.canvas.type(item_id)
        if item_type == "rectangle":
            self.canvas.itemconfig(item_id, outline='yellow', width=2)
        elif item_type == "text":
            self.canvas.itemconfig(item_id, fill='yellow')
        elif item_type == "image":
            # Tìm field liên quan đến hình ảnh này
            field = self.get_field_by_text_id(item_id)
            if field and "rect_id" in field:
                self.canvas.itemconfig(field["rect_id"], outline='yellow', width=2)
    
        field = self.get_field_by_text_id(item_id)
        if field and field.get('label_id'):
            self.canvas.itemconfig(field['label_id'], fill='yellow')
    
    def deselect_item(self, item_id):
        """Bỏ chọn mục."""
        item_type = self.canvas.type(item_id)
        if item_type == "rectangle":
            self.canvas.itemconfig(item_id, outline='blue' if self.get_field_by_text_id(item_id).get('type') == 'Image' else 'green', width=1)
        elif item_type == "text":
            self.canvas.itemconfig(item_id, fill='red')
        elif item_type == "image":
            # Tìm field liên quan đến hình ảnh này
            field = self.get_field_by_text_id(item_id)
            if field and "rect_id" in field:
                self.canvas.itemconfig(field["rect_id"], outline='blue', width=1)
    
        field = self.get_field_by_text_id(item_id)
        if field and field.get('label_id'):
            self.canvas.itemconfig(field['label_id'], fill='blue')
    
    def get_field_by_text_id(self, text_id):
        """Lấy thuộc tính của trường dựa trên ID."""
        page_items = self.coords.get(self.current_page_index, [])
        for item in page_items:
            if item["id"] == text_id or item.get("label_id") == text_id:
                return item
        return None
    def render_text_on_page(self):
        """Display text and image fields on the current PDF page."""
        self.current_selected_text = None  # Reset current selection
        page_items = self.coords.get(self.current_page_index, [])
        for item in page_items:
                # Calculate display coordinates on the canvas, considering zoom
                x = item["x"] * self.zoom_level
                y = item["y"] * self.zoom_level
    
                if item.get('type', 'Text') == 'Text':
                    font_name = item["font"]
                    size = item["size"]
                    bounding_width = item["width"] * self.zoom_level
                    bounding_height = item["height"] * self.zoom_level
    
                    # Get data from Excel or Numbering
                    if self.df is not None and not self.df.empty:
                        row_index = self.excel_row_index if self.excel_row_index is not None else 0
                        if row_index >= len(self.df):
                            row_index = len(self.df) - 1
                        elif row_index < 0:
                            row_index = 0
                        row = self.df.iloc[row_index]
                        field_name = item["field"]
                        if field_name in row:
                            value = str(row[field_name])
                        else:
                            value = f"<{field_name}>"
                    else:
                        # If no data, check if field is 'Numbering'
                        if item["field"] == 'Numbering':
                            numbering_df = self.generate_numbering_data()
                            if not numbering_df.empty:
                                value = numbering_df.iloc[0]['Numbering']
                            else:
                                value = '1'.zfill(self.total_zeros_var.get())
                        else:
                            value = f"<{item['field']}>"
    
                    # Create text object on canvas
                    text_id = self.canvas.create_text(
                        x, y, text=value, anchor="center", fill="red"
                    )
                    text_font = (font_name, int(size * self.zoom_level))
                    self.canvas.itemconfig(text_id, font=text_font)
    
                    # Get the actual size of the text
                    bbox = self.canvas.bbox(text_id)
                    text_width = bbox[2] - bbox[0]
                    text_height = bbox[3] - bbox[1]
    
                    # Calculate scaling ratios if text exceeds bounding box
                    scale_x = scale_y = 1.0
                    if text_width > bounding_width:
                        scale_x = bounding_width / text_width
                    if text_height > bounding_height:
                        scale_y = bounding_height / text_height
    
                    # Get user's scale option
                    scale_option_display = self.scale_option.get()
                    scale_option = self.scale_option_mapping.get(scale_option_display, "uniform")
    
                    if scale_option == "uniform":
                        # Scale both dimensions equally
                        scale = min(scale_x, scale_y)
                        new_size = size * scale
                        text_font = (font_name, int(new_size * self.zoom_level))
                        self.canvas.itemconfig(text_id, font=text_font)
                    elif scale_option == "horizontal":
                        # Scale horizontally only (not implemented in Canvas)
                        pass
                    elif scale_option == "vertical":
                        # Scale vertically only (not implemented in Canvas)
                        pass
                    elif scale_option == "kerning":
                        # Adjust spacing between characters (not implemented)
                        pass
                    else:
                        # Default to uniform scaling
                        scale = min(scale_x, scale_y)
                        new_size = size * scale
                        text_font = (font_name, int(new_size * self.zoom_level))
                        self.canvas.itemconfig(text_id, font=text_font)
    
                    # Update text color
                    c = item['color_cmyk']['C'] / 100
                    m = item['color_cmyk']['M'] / 100
                    y_col = item['color_cmyk']['Y'] / 100
                    k = item['color_cmyk']['K'] / 100
                    r, g, b = self.cmyk_to_rgb(c, m, y_col, k)
                    color = f'#{int(r):02x}{int(g):02x}{int(b):02x}'
                    self.canvas.itemconfig(text_id, fill=color)
                    item["id"] = text_id  # Update ID in coords
    
                    # Draw bounding box
                    rect_id = self.canvas.create_rectangle(
                        x - (item["width"] / 2) * self.zoom_level,
                        y - (item["height"] / 2) * self.zoom_level,
                        x + (item["width"] / 2) * self.zoom_level,
                        y + (item["height"] / 2) * self.zoom_level,
                        outline='green', dash=(2, 2)
                    )
                    item["rect_id"] = rect_id
    
                    # Create anchor points for the bounding box
                    anchors = self.create_anchor_points(rect_id)
                    item["anchors"] = anchors
    
                    # Ensure correct display order on canvas
                    self.canvas.tag_raise(text_id, rect_id)
                    for anchor in anchors:
                        self.canvas.tag_raise(anchor, rect_id)
    
                elif item.get('type') == 'Image':
                    # Handle image fields
                    # Get image dimensions from item
                    width_points = item.get("width_points", self.mm_to_points(self.image_width_var.get()))
                    height_points = item.get("height_points", self.mm_to_points(self.image_height_var.get()))
    
                    # Calculate display size on canvas, considering zoom
                    width = width_points * self.zoom_level
                    height = height_points * self.zoom_level
    
                    x_left = x - width / 2
                    y_top = y - height / 2
                    x_right = x + width / 2
                    y_bottom = y + height / 2
    
                    # Get image data from Excel or specified path
                    image_loaded = False
                    if self.df is not None and not self.df.empty:
                        row_index = self.excel_row_index if self.excel_row_index is not None else 0
                        if row_index >= len(self.df):
                            row_index = len(self.df) - 1
                        elif row_index < 0:
                            row_index = 0
                        row = self.df.iloc[row_index]
                        field_name = item['field']
                        if field_name in row:
                            image_path = str(row[field_name])
                            if not os.path.isabs(image_path):
                                image_path = os.path.join(os.path.dirname(self.excel_path), image_path)
                            if os.path.exists(image_path):
                                try:
                                    image = Image.open(image_path)
                                    image = image.resize((int(width), int(height)), Image.LANCZOS)
                                    photo_image = ImageTk.PhotoImage(image)
                                    image_id = self.canvas.create_image(x, y, image=photo_image, anchor='center')
                                    # Store image reference to avoid garbage collection
                                    if not hasattr(self, 'image_refs'):
                                        self.image_refs = []
                                    self.image_refs.append(photo_image)
                                    item["id"] = image_id  # Update ID
                                    image_loaded = True
                                except Exception as e:
                                    print(f"Error loading image '{image_path}': {e}")
                            else:
                                print(f"Image '{image_path}' does not exist.")
                        else:
                            print(f"Field '{field_name}' does not exist in the data.")
                    else:
                        print("No data loaded or data is empty.")
    
                    # If image was not loaded, use a placeholder
                    if not image_loaded:
                        # Create a rectangle as a placeholder
                        rect_id = self.canvas.create_rectangle(
                            x_left,
                            y_top,
                            x_right,
                            y_bottom,
                            outline='blue', dash=(2, 2)
                        )
                        item["id"] = rect_id
                        item["rect_id"] = rect_id
                    else:
                        # Create a bounding box around the image
                        rect_id = self.canvas.create_rectangle(
                            x_left,
                            y_top,
                            x_right,
                            y_bottom,
                            outline='blue', dash=(2, 2)
                        )
                        item["rect_id"] = rect_id
    
                    # Create anchor points
                    anchors = self.create_anchor_points(rect_id)
                    item["anchors"] = anchors
    
                    # Ensure image is displayed above bounding box and anchors
                    self.canvas.tag_raise(item["id"], rect_id)
                    for anchor in anchors:
                        self.canvas.tag_raise(anchor, rect_id)
    
    def add_text(self, x, y):
        """Add a new text or image field to the canvas and coords."""
        if not self.selected_field.get():
            # If no field is selected, and no Excel file is loaded, set field to 'Numbering'
            field = 'Numbering'
            self.selected_field.set('Numbering')
        else:
            field = self.selected_field.get()
        field_type = self.field_type.get()
    
        # Adjust for zoom level
        x /= self.zoom_level
        y /= self.zoom_level
    
        if field_type == "Text":
            # Initial size for the bounding box (in points)
            bounding_box_width = 100  # Default width
            bounding_box_height = 30  # Default height
    
            # Calculate position for text and bounding box
            display_x = x * self.zoom_level
            display_y = y * self.zoom_level
    
            # Fetch data from Excel or Numbering
            if self.df is not None and not self.df.empty:
                row_index = self.excel_row_index if self.excel_row_index is not None else 0
                # Ensure index is within bounds
                if row_index >= len(self.df):
                    row_index = len(self.df) - 1
                elif row_index < 0:
                    row_index = 0
                row = self.df.iloc[row_index]
                field_name = field
                if field_name in row:
                    value = str(row[field_name])
                else:
                    value = f"<{field_name}>"
            else:
                # If no data, check if field is 'Numbering'
                if field == 'Numbering':
                    numbering_df = self.generate_numbering_data()
                    if not numbering_df.empty:
                        value = numbering_df.iloc[0]['Numbering']
                    else:
                        value = '1'.zfill(self.total_zeros_var.get())
                else:
                    value = f"<{field}>"
    
            # Create text object on canvas
            text_id = self.canvas.create_text(
                display_x, display_y,
                text=value,
                anchor="center",
                fill="red"
            )
    
            # Create a rectangle representing the bounding box
            rect_id = self.canvas.create_rectangle(
                display_x - (bounding_box_width / 2) * self.zoom_level,
                display_y - (bounding_box_height / 2) * self.zoom_level,
                display_x + (bounding_box_width / 2) * self.zoom_level,
                display_y + (bounding_box_height / 2) * self.zoom_level,
                outline='green', dash=(2, 2)
            )
    
            # Create anchor points at the corners
            anchors = self.create_anchor_points(rect_id)
    
            # Ensure text is displayed above the rectangle and anchors
            self.canvas.tag_raise(text_id, rect_id)
            for anchor in anchors:
                self.canvas.tag_raise(anchor, rect_id)
    
            # Initialize item data
            new_item = {
                "id": text_id,
                "rect_id": rect_id,  # Reference to bounding box
                "anchors": anchors,  # Reference to anchor points
                "field": field,
                "x": x,
                "y": y,
                "width": bounding_box_width,   # Width of bounding box
                "height": bounding_box_height,  # Height of bounding box
                "type": "Text",
                "font": self.font_var.get(),
                "size": self.font_size_var.get(),
                "color_cmyk": {
                    "C": self.cmyk_vars["C"].get(),
                    "M": self.cmyk_vars["M"].get(),
                    "Y": self.cmyk_vars["Y"].get(),
                    "K": self.cmyk_vars["K"].get(),
                },
                # Additional attributes for scaling
                "is_resizing": False,         # Flag to indicate if the item is being resized
                "resize_anchor": None,        # Which anchor point is being used to resize
            }
    
            # Add new item to the coords data structure
            if self.current_page_index not in self.coords:
                self.coords[self.current_page_index] = []
            self.coords[self.current_page_index].append(new_item)
    
            # Update selected items
            self.selected_items = set([text_id, rect_id] + anchors)
    
            # Update font and other attributes
            self.update_canvas_font()
    
            # Add to undo stack
            self.undo_stack.append(('add', new_item))
            self.redo_stack.clear()  # Clear redo stack
    
            # Refresh the canvas
            self.display_pdf_page()
    
        elif field_type == "Image":
            # Convert dimensions from mm to points
            width_points = self.mm_to_points(self.image_width_var.get())
            height_points = self.mm_to_points(self.image_height_var.get())
    
            display_x = x * self.zoom_level
            display_y = y * self.zoom_level
    
            # Get image data from Excel
            if self.df is not None and not self.df.empty:
                row_index = self.excel_row_index if self.excel_row_index is not None else 0
                # Ensure index is within bounds
                if row_index >= len(self.df):
                    row_index = len(self.df) - 1
                elif row_index < 0:
                    row_index = 0
                row = self.df.iloc[row_index]
                field_name = field
                if field_name in row:
                    image_path = str(row[field_name])
                    if not os.path.isabs(image_path):
                        image_path = os.path.join(os.path.dirname(self.excel_path), image_path)
                    if os.path.exists(image_path):
                        image = Image.open(image_path)
                        image = image.resize((int(width_points * self.zoom_level), int(height_points * self.zoom_level)), Image.LANCZOS)
                        photo_image = ImageTk.PhotoImage(image)
                        image_id = self.canvas.create_image(display_x, display_y, image=photo_image, anchor="center")
                        # Store image reference to avoid garbage collection
                        if not hasattr(self, 'image_refs'):
                            self.image_refs = []
                        self.image_refs.append(photo_image)
                    else:
                        messagebox.showerror("Lỗi", f"Hình ảnh '{image_path}' không tồn tại.")
                        # Display placeholder
                        image_id = self.canvas.create_rectangle(
                            display_x - (width_points / 2) * self.zoom_level,
                            display_y - (height_points / 2) * self.zoom_level,
                            display_x + (width_points / 2) * self.zoom_level,
                            display_y + (height_points / 2) * self.zoom_level,
                            outline='blue', dash=(2, 2)
                        )
                else:
                    messagebox.showerror("Lỗi", f"Trường '{field_name}' không tồn tại trong tệp Excel.")
                    return
            else:
                messagebox.showerror("Lỗi", "Chưa tải tệp Excel hoặc tệp Excel trống.")
                return
    
            # Create a rectangle representing the bounding box
            rect_id = self.canvas.create_rectangle(
                display_x - (width_points / 2) * self.zoom_level,
                display_y - (height_points / 2) * self.zoom_level,
                display_x + (width_points / 2) * self.zoom_level,
                display_y + (height_points / 2) * self.zoom_level,
                outline='blue', dash=(2, 2)
            )
    
            # Create anchor points at the corners
            anchors = self.create_anchor_points(rect_id)
    
            # Ensure image is displayed above the rectangle and anchors
            self.canvas.tag_raise(image_id, rect_id)
            for anchor in anchors:
                self.canvas.tag_raise(anchor, rect_id)
    
            # Initialize item data
            new_item = {
                "id": image_id,
                "rect_id": rect_id,
                "anchors": anchors,
                "field": field,
                "x": x,
                "y": y,
                "width_points": width_points,
                "height_points": height_points,
                "type": "Image",
                "is_resizing": False,
                "resize_anchor": None,
            }
    
            if self.current_page_index not in self.coords:
                self.coords[self.current_page_index] = []
            self.coords[self.current_page_index].append(new_item)
    
            # Update selected items
            self.selected_items = set([rect_id, image_id] + anchors)
    
            # Add to undo stack
            self.undo_stack.append(('add', new_item))
            self.redo_stack.clear()
    
            # Refresh the canvas
            self.display_pdf_page()
        
    def create_anchor_points(self, rect_id):
        """Tạo các điểm neo nhỏ (anchor) ở các góc của bounding box."""
        # Lấy tọa độ hiện tại của hình chữ nhật
        coords = self.canvas.coords(rect_id)
        x0, y0, x1, y1 = coords
    
        # Định nghĩa kích thước của điểm neo
        anchor_size = 6  # Kích thước của điểm neo
    
        # Vị trí cho bốn góc
        positions = [
            (x0, y0),  # Trên - trái
            (x1, y0),  # Trên - phải
            (x1, y1),  # Dưới - phải
            (x0, y1),  # Dưới - trái
        ]
    
        anchors = []
        for (x, y) in positions:
            anchor = self.canvas.create_oval(
                x - anchor_size / 2, y - anchor_size / 2,
                x + anchor_size / 2, y + anchor_size / 2,
                fill='blue', outline='black', tags='anchor'
            )
            # Gắn sự kiện chuột cho điểm neo
            self.canvas.tag_bind(anchor, '<ButtonPress-1>', self.on_anchor_press)
            self.canvas.tag_bind(anchor, '<B1-Motion>', self.on_anchor_drag)
            self.canvas.tag_bind(anchor, '<ButtonRelease-1>', self.on_anchor_release)
            anchors.append(anchor)
    
        return anchors
    
    def on_anchor_press(self, event):
        """Xử lý sự kiện nhấn chuột trên một điểm neo."""
        # Xác định điểm neo đang được nhấn
        anchor_id = self.canvas.find_withtag(tk.CURRENT)[0]
        self.resizing_item = self.get_field_by_anchor_id(anchor_id)
        if self.resizing_item:
            self.resizing_item["is_resizing"] = True
            self.resizing_item["resize_anchor"] = anchor_id
            # Ghi lại vị trí ban đầu
            self.resizing_start = (event.x, event.y)
    
    def on_anchor_drag(self, event):
        """Xử lý sự kiện kéo trên một điểm neo."""
        if not hasattr(self, 'resizing_item') or not self.resizing_item.get("is_resizing"):
            return
    
        dx = event.x - self.resizing_start[0]
        dy = event.y - self.resizing_start[1]
        anchor_id = self.resizing_item.get("resize_anchor")
        if not anchor_id:
            return
    
        # Cập nhật vị trí bắt đầu
        self.resizing_start = (event.x, event.y)
    
        # Lấy hình chữ nhật liên quan đến điểm neo này
        rect_id = self.resizing_item["rect_id"]
        coords = self.canvas.coords(rect_id)
        x0, y0, x1, y1 = coords
    
        # Xác định điểm neo nào đang được kéo và cập nhật tọa độ hình chữ nhật
        if anchor_id == self.resizing_item["anchors"][0]:  # Trên - trái
            new_x0 = x0 + dx
            new_y0 = y0 + dy
            self.canvas.coords(rect_id, new_x0, new_y0, x1, y1)
        elif anchor_id == self.resizing_item["anchors"][1]:  # Trên - phải
            new_x1 = x1 + dx
            new_y0 = y0 + dy
            self.canvas.coords(rect_id, x0, new_y0, new_x1, y1)
        elif anchor_id == self.resizing_item["anchors"][2]:  # Dưới - phải
            new_x1 = x1 + dx
            new_y1 = y1 + dy
            self.canvas.coords(rect_id, x0, y0, new_x1, new_y1)
        elif anchor_id == self.resizing_item["anchors"][3]:  # Dưới - trái
            new_x0 = x0 + dx
            new_y1 = y1 + dy
            self.canvas.coords(rect_id, new_x0, y0, x1, new_y1)
    
        # Cập nhật vị trí văn bản hoặc hình ảnh liên quan nếu cần
        field_id = self.resizing_item["id"]
        self.update_field_position_after_resize(field_id, rect_id)
    
        # Di chuyển các điểm neo tương ứng
        self.update_anchor_positions(self.resizing_item)
    
    def on_anchor_release(self, event):
        """Xử lý sự kiện thả chuột trên một điểm neo."""
        if hasattr(self, 'resizing_item') and self.resizing_item.get("is_resizing"):
            self.resizing_item["is_resizing"] = False
            self.resizing_item["resize_anchor"] = None
            self.resizing_start = None
            # Thêm hành động thay đổi kích thước vào ngăn xếp undo nếu cần
            self.undo_stack.append(('resize', self.resizing_item.copy()))
            self.redo_stack.clear()
            self.update_preview()
    
    def get_field_by_anchor_id(self, anchor_id):
        """Lấy trường liên quan đến một ID điểm neo."""
        page_items = self.coords.get(self.current_page_index, [])
        for item in page_items:
            if anchor_id in item.get("anchors", []):
                return item
        return None
    
    def update_field_position_after_resize(self, field_id, rect_id):
        """Cập nhật kích thước của bounding box và cập nhật nội dung trường nếu cần."""
        # Lấy tọa độ mới của bounding box
        coords = self.canvas.coords(rect_id)
        x0, y0, x1, y1 = coords
        new_width = (x1 - x0) / self.zoom_level
        new_height = (y1 - y0) / self.zoom_level
        # Cập nhật kích thước của bounding box trong item
        for item in self.coords[self.current_page_index]:
            if item["rect_id"] == rect_id:
                if item.get('type') == 'Text':
                    item["width"] = new_width
                    item["height"] = new_height
                elif item.get('type') == 'Image':
                    item["width_points"] = new_width
                    item["height_points"] = new_height
                # Cập nhật vị trí trung tâm
                item["x"] = (x0 + x1) / (2 * self.zoom_level)
                item["y"] = (y0 + y1) / (2 * self.zoom_level)
                # Nếu là hình ảnh, cần cập nhật lại hình ảnh trên canvas
                if item.get('type') == 'Image':
                    # Xóa hình ảnh cũ
                    self.canvas.delete(item["id"])
                    # Lấy dữ liệu hình ảnh từ tệp Excel
                    image_loaded = False
                    if self.df is not None and not self.df.empty:
                        row_index = self.excel_row_index if self.excel_row_index is not None else 0
                        if row_index >= len(self.df):
                            row_index = len(self.df) - 1
                        elif row_index < 0:
                            row_index = 0
                        row = self.df.iloc[row_index]
                        field_name = item['field']
                        if field_name in row:
                            image_path = str(row[field_name])
                            if not os.path.isabs(image_path):
                                image_path = os.path.join(os.path.dirname(self.excel_path), image_path)
                            if os.path.exists(image_path):
                                try:
                                    width = new_width * self.zoom_level
                                    height = new_height * self.zoom_level
                                    image = Image.open(image_path)
                                    image = image.resize((int(width), int(height)), Image.LANCZOS)
                                    photo_image = ImageTk.PhotoImage(image)
                                    image_id = self.canvas.create_image(item["x"] * self.zoom_level, item["y"] * self.zoom_level,
                                                                        image=photo_image, anchor='center')
                                    # Lưu trữ ảnh để tránh bị xóa bởi garbage collector
                                    if not hasattr(self, 'image_refs'):
                                        self.image_refs = []
                                    self.image_refs.append(photo_image)
                                    item["id"] = image_id  # Cập nhật ID
                                    image_loaded = True
                                except Exception as e:
                                    print(f"Lỗi khi tải ảnh '{image_path}': {e}")
                    # Nếu không tải được hình ảnh, sử dụng placeholder
                    if not image_loaded:
                        item["id"] = self.canvas.create_rectangle(x0, y0, x1, y1, outline='blue', dash=(2, 2))
                    # Đảm bảo hình ảnh được hiển thị phía trên bounding box và anchors
                    self.canvas.tag_raise(item["id"], item["rect_id"])
                    for anchor in item.get("anchors", []):
                        self.canvas.tag_raise(anchor, item["rect_id"])
                break
    
    def update_anchor_positions(self, item):
        """Định vị lại các điểm neo dựa trên hình chữ nhật đã thay đổi kích thước."""
        rect_id = item["rect_id"]
        anchors = item["anchors"]
        coords = self.canvas.coords(rect_id)
        x0, y0, x1, y1 = coords
    
        # Định nghĩa kích thước của điểm neo
        anchor_size = 6
    
        # Vị trí mới cho các điểm neo
        positions = [
            (x0, y0),  # Trên - trái
            (x1, y0),  # Trên - phải
            (x1, y1),  # Dưới - phải
            (x0, y1),  # Dưới - trái
        ]
    
        for anchor, (x, y) in zip(anchors, positions):
            self.canvas.coords(
                anchor,
                x - anchor_size / 2, y - anchor_size / 2,
                x + anchor_size / 2, y + anchor_size / 2
            )
    
    def move_text(self, event):
        """Xử lý việc di chuyển các trường văn bản hoặc hình ảnh trên canvas."""
        if self.selected_items:
            dx = event.x - self.last_move_x
            dy = event.y - self.last_move_y
            for item_id in self.selected_items.copy():
                field = self.get_field_by_text_id(item_id)
                if field:
                    # Di chuyển hình chữ nhật bao quanh
                    self.canvas.move(field["rect_id"], dx, dy)
                    # Di chuyển các điểm neo
                    for anchor in field.get("anchors", []):
                        self.canvas.move(anchor, dx, dy)
                    # Di chuyển văn bản hoặc hình ảnh
                    self.canvas.move(field["id"], dx, dy)
                    # Cập nhật tọa độ
                    field["x"] += dx / self.zoom_level
                    field["y"] += dy / self.zoom_level
            self.last_move_x = event.x
            self.last_move_y = event.y
            self.undo_stack.append(('move', list(self.selected_items), dx / self.zoom_level, dy / self.zoom_level))
            self.redo_stack.clear()
            self.update_preview()
    
    def update_canvas_font(self, event=None):
        """Cập nhật thuộc tính font của văn bản được chọn."""
        if self.selected_items:
            for item_id in self.selected_items:
                field = self.get_field_by_text_id(item_id)
                if field and field.get('type', 'Text') == 'Text':
                    # Kiểm tra kích thước font
                    try:
                        size = int(self.font_size_var.get())
                        if size <= 0:
                            raise ValueError
                    except ValueError:
                        messagebox.showerror("Lỗi nhập liệu", "Kích thước font phải là số nguyên dương.")
                        self.font_size_var.set(12)
                        return
    
                    self.canvas.itemconfig(item_id, font=(self.font_var.get(), int(self.font_size_var.get() * self.zoom_level)))
                    c = self.cmyk_vars['C'].get() / 100
                    m = self.cmyk_vars['M'].get() / 100
                    y = self.cmyk_vars['Y'].get() / 100
                    k = self.cmyk_vars['K'].get() / 100
                    r, g, b = self.cmyk_to_rgb(c, m, y, k)
                    color = f'#{int(r):02x}{int(g):02x}{int(b):02x}'
                    self.canvas.itemconfig(item_id, fill=color)
                    field["font"] = self.font_var.get()
                    field["size"] = self.font_size_var.get()
                    field["color_cmyk"] = {
                        "C": self.cmyk_vars["C"].get(),
                        "M": self.cmyk_vars["M"].get(),
                        "Y": self.cmyk_vars["Y"].get(),
                        "K": self.cmyk_vars["K"].get(),
                    }
            self.update_preview()
    
    def delete_text(self, event=None):
        """Xóa các trường văn bản hoặc hình ảnh được chọn khỏi canvas."""
        if self.selected_items:
            for item_id in list(self.selected_items):
                field = self.get_field_by_text_id(item_id)
                if field:
                    # Xóa các mục liên quan
                    items_to_delete = [field["id"], field["rect_id"]] + field.get("anchors", [])
                    if field.get("label_id"):
                        items_to_delete.append(field["label_id"])
                    for del_id in items_to_delete:
                        self.canvas.delete(del_id)
                    self.coords[self.current_page_index].remove(field)
                    self.undo_stack.append(('delete', field))
                    self.redo_stack.clear()  # Xóa ngăn xếp redo
            self.selected_items.clear()
            self.update_preview()
    
    def undo(self, event=None):
        """Hoàn tác hành động cuối cùng."""
        if self.undo_stack:
            action = self.undo_stack.pop()
            if action[0] == 'add':
                # Xóa mục đã thêm
                item = action[1]
                self.canvas.delete(item["id"])
                if item.get("label_id"):
                    self.canvas.delete(item["label_id"])
                for anchor in item.get("anchors", []):
                    self.canvas.delete(anchor)
                self.canvas.delete(item.get("rect_id", ""))
                self.coords[self.current_page_index].remove(item)
                self.redo_stack.append(('add', item))
            elif action[0] == 'move':
                # Di chuyển trở lại vị trí trước đó
                item_ids, dx, dy = action[1:]
                for item_id in item_ids:
                    self.canvas.move(item_id, -dx * self.zoom_level, -dy * self.zoom_level)
                    field = self.get_field_by_text_id(item_id)
                    if field:
                        self.canvas.move(field.get("label_id", ""), -dx * self.zoom_level, -dy * self.zoom_level)
                        for anchor in field.get("anchors", []):
                            self.canvas.move(anchor, -dx * self.zoom_level, -dy * self.zoom_level)
                        field["x"] -= dx
                        field["y"] -= dy
                self.redo_stack.append(('move', item_ids, dx, dy))
            elif action[0] == 'delete':
                # Thêm lại mục đã xóa
                item = action[1]
                if item.get('type', 'Text') == 'Text':
                    self.add_text(item["x"] * self.zoom_level, item["y"] * self.zoom_level)
                elif item.get('type') == 'Image':
                    self.add_text(item["x"] * self.zoom_level, item["y"] * self.zoom_level)
                self.coords[self.current_page_index].append(item)
                self.redo_stack.append(('delete', item))
            self.update_preview()
    
    def redo(self, event=None):
        """Làm lại hành động đã hoàn tác."""
        if self.redo_stack:
            action = self.redo_stack.pop()
            if action[0] == 'add':
                # Thêm lại mục
                item = action[1]
                self.add_text(item["x"] * self.zoom_level, item["y"] * self.zoom_level)
                self.coords[self.current_page_index].append(item)
                self.undo_stack.append(('add', item))
            elif action[0] == 'move':
                # Di chuyển đến vị trí mới
                item_ids, dx, dy = action[1:]
                for item_id in item_ids:
                    self.canvas.move(item_id, dx * self.zoom_level, dy * self.zoom_level)
                    field = self.get_field_by_text_id(item_id)
                    if field:
                        self.canvas.move(field.get("label_id", ""), dx * self.zoom_level, dy * self.zoom_level)
                        for anchor in field.get("anchors", []):
                            self.canvas.move(anchor, dx * self.zoom_level, dy * self.zoom_level)
                        field["x"] += dx
                        field["y"] += dy
                self.undo_stack.append(('move', item_ids, dx, dy))
            elif action[0] == 'delete':
                # Xóa mục
                item = action[1]
                self.canvas.delete(item["id"])
                if item.get("label_id"):
                    self.canvas.delete(item.get("label_id"))
                for anchor in item.get("anchors", []):
                    self.canvas.delete(anchor)
                self.canvas.delete(item.get("rect_id", ""))
                self.coords[self.current_page_index].remove(item)
                self.undo_stack.append(('delete', item))
            self.update_preview()
    
    def load_excel(self):
        """Load Excel file and display data."""
        self.excel_path = filedialog.askopenfilename(filetypes=[("Excel files", ".xlsx"), ("Excel files", ".xls")])
    
        if self.excel_path:
            try:
                self.df = pd.read_excel(self.excel_path)
                # Generate numbering data matching the length of Excel data
                numbering_df = self.generate_numbering_data(num_rows=len(self.df))
                self.df['Numbering'] = numbering_df['Numbering'].values
                # Add 'Numbering' to the list of fields if not already present
                if 'Numbering' not in self.df.columns:
                    self.df['Numbering'] = numbering_df['Numbering'].values
                self.fields = self.df.columns.tolist()
                self.selected_field.set(self.fields[0])  # Default selected field
                self.create_field_radiobuttons()
                self.reset_preview()
                self.excel_row_index = 0  # Reset index to 0
            except Exception as e:
                messagebox.showerror("Error", f"Cannot read Excel file: {e}")
                self.excel_path = None
                self.df = None
        else:
            # If no Excel file is selected, use Numbering data only
            self.df = self.generate_numbering_data()
            if self.df.empty:
                messagebox.showerror("Error", "Numbering data is empty. Please check the parameters.")
                return
            self.fields = ['Numbering']
            self.selected_field.set('Numbering')  # Set default field
            self.create_field_radiobuttons()
            self.reset_preview()
            self.excel_row_index = 0
    
    def create_field_radiobuttons(self):
        """Tạo các nút radio cho các trường dữ liệu Excel."""
        # Xóa khung nút hiện có và tạo mới
        for widget in self.excel_button_frame.winfo_children():
            widget.destroy()
    
        # Tạo canvas để chứa các nút với thanh cuộn
        canvas = tk.Canvas(self.excel_button_frame, bg='#2c2f33', highlightthickness=0)
        scrollbar = tk.Scrollbar(self.excel_button_frame, orient=tk.HORIZONTAL, command=canvas.xview)
        canvas.configure(xscrollcommand=scrollbar.set)
    
        inner_frame = tk.Frame(canvas, bg='#2c2f33')
    
        # Thêm inner_frame vào canvas
        canvas.create_window((0, 0), window=inner_frame, anchor='nw')
    
        canvas.pack(side=tk.TOP, fill=tk.X, expand=True)
        scrollbar.pack(side=tk.BOTTOM, fill=tk.X)
    
        # Cập nhật scrollregion sau khi thêm widget
        def configure_canvas(event):
            canvas.configure(scrollregion=canvas.bbox("all"))
        inner_frame.bind("<Configure>", configure_canvas)
    
        # Đặt tất cả các nút trong inner_frame
        for field in self.fields:
            rb = tk.Radiobutton(inner_frame, text=field, variable=self.selected_field, value=field,
                                bg='#2c2f33', fg='white', selectcolor='#7289da')
            rb.pack(side=tk.LEFT, padx=5, pady=5)
        canvas.config(scrollregion=canvas.bbox("all"))
    
    def cmyk_to_rgb(self, c, m, y, k):
        """Chuyển đổi giá trị CMYK sang RGB."""
        r = min(max(0, 255 * (1 - c) * (1 - k)), 255)
        g = min(max(0, 255 * (1 - m) * (1 - k)), 255)
        b = min(max(0, 255 * (1 - y) * (1 - k)), 255)
        return int(r), int(g), int(b)
    
    def mm_to_points(self, mm):
        """Chuyển đổi millimeters sang points."""
        return mm * 72 / 25.4
    
    def points_to_mm(self, points):
        """Chuyển đổi points sang millimeters."""
        return points * 25.4 / 72
    
    def create_text_pdf(self, output_pdf_path, row, selected_font_path):
        """Tạo tệp PDF tùy chỉnh với các trường văn bản và hình ảnh."""
        c = reportlab_canvas.Canvas(output_pdf_path, pagesize=(self.original_width, self.original_height))
        total_pages = len(self.pdf_doc)
    
        for page_index in range(total_pages):
            c.setPageSize((self.original_width, self.original_height))
            if page_index in self.coords:
                fields = self.coords[page_index]
                for item in fields:
                    field_name = item["field"]
                    if field_name not in row:
                        print(f"Trường '{field_name}' không có trong dữ liệu. Bỏ qua...")
                        continue
                    x = item["x"]
                    y = item["y"]
                    if item.get('type', 'Text') == 'Text':
                        font_name = item["font"]
                        size = item["size"]
                        color_cmyk = item["color_cmyk"]
                        bounding_width = item["width"]
                        bounding_height = item["height"]
    
                        # Lấy đường dẫn font
                        font_path = self.font_file_dict.get(font_name, selected_font_path)
                        if not self.check_font_availability(font_path):
                            font_path = selected_font_path
    
                        # Đăng ký và đặt font
                        if font_name not in pdfmetrics.getRegisteredFontNames():
                            pdfmetrics.registerFont(TTFont(font_name, font_path))
    
                        value = str(row[field_name])
    
                        # Cài đặt màu
                        c.setFillColorCMYK(
                            color_cmyk["C"] / 100,
                            color_cmyk["M"] / 100,
                            color_cmyk["Y"] / 100,
                            color_cmyk["K"] / 100
                        )
    
                        # Tính kích thước nội dung
                        text_width = pdfmetrics.stringWidth(value, font_name, size)
                        text_height = size  # Xấp xỉ chiều cao bằng kích thước font
    
                        # Tính toán scale
                        scale_x = scale_y = 1.0
                        if text_width > bounding_width:
                            scale_x = bounding_width / text_width
                        if text_height > bounding_height:
                            scale_y = bounding_height / text_height
    
                        scale_option_display = self.scale_option.get()
                        scale_option = self.scale_option_mapping.get(scale_option_display, "uniform")
    
                        if scale_option == "uniform":
                            scale = min(scale_x, scale_y)
                            new_size = size * scale
                            c.setFont(font_name, new_size)
                            text_width_scaled = pdfmetrics.stringWidth(value, font_name, new_size)
                            adjusted_y = self.original_height - y - new_size / 2
                            adjusted_x = x - text_width_scaled / 2
                            c.drawString(adjusted_x, adjusted_y, value)
                        elif scale_option == "horizontal":
                            scale = scale_x
                            new_size = size  # Giữ nguyên kích thước font
                            c.setFont(font_name, new_size)
                            c.saveState()
                            c.translate(x, self.original_height - y)
                            c.scale(scale, 1)
                            adjusted_x = -text_width / 2
                            adjusted_y = -new_size / 2
                            c.drawString(adjusted_x, adjusted_y, value)
                            c.restoreState()
                        elif scale_option == "vertical":
                            scale = scale_y
                            new_size = size  # Giữ nguyên kích thước font
                            c.setFont(font_name, new_size)
                            c.saveState()
                            c.translate(x, self.original_height - y)
                            c.scale(1, scale)
                            adjusted_x = -text_width / 2
                            adjusted_y = -new_size / 2
                            c.drawString(adjusted_x, adjusted_y, value)
                            c.restoreState()
                        elif scale_option == "kerning":
                            # Điều chỉnh khoảng cách giữa các ký tự
                            total_characters = len(value)
                            if total_characters > 1:
                                total_space_needed = text_width - bounding_width
                                if total_space_needed > 0:
                                    extra_space_per_char = total_space_needed / (total_characters - 1)
                                    c.setFont(font_name, size)
                                    adjusted_x_positions = []
                                    current_x = x - text_width / 2
                                    for char in value:
                                        adjusted_x_positions.append(current_x)
                                        char_width = pdfmetrics.stringWidth(char, font_name, size)
                                        current_x += char_width - extra_space_per_char
                                    # Vẽ từng ký tự tại vị trí mới
                                    adjusted_y = self.original_height - y - size / 2
                                    for i, char in enumerate(value):
                                        c.drawString(adjusted_x_positions[i], adjusted_y, char)
    
                    elif item.get('type') == 'Image':
                        image_path = str(row[field_name])
                        if not os.path.isabs(image_path):
                            image_path = os.path.join(os.path.dirname(self.excel_path), image_path)
                        if not os.path.exists(image_path):
                            print(f"Hình ảnh '{image_path}' không tồn tại. Bỏ qua...")
                            continue
                        # Sử dụng chiều rộng và chiều cao đã lưu
                        width_in_points = item["width_points"]
                        height_in_points = item["height_points"]
                        adjusted_y = self.original_height - y - height_in_points / 2
                        adjusted_x = x - width_in_points / 2
                        try:
                            c.drawImage(image_path, adjusted_x, adjusted_y,
                                        width=width_in_points,
                                        height=height_in_points)
                        except Exception as e:
                            print(f"Lỗi khi chèn hình ảnh: {e}")
    
            c.showPage()
    
        c.save()
    
    def export_pdfs(self):
        """Xuất PDF đã áp dụng imposition với dữ liệu từ Excel và/hoặc Numbering."""
        if not self.file_path:
            messagebox.showerror("Lỗi", "Hãy chọn tệp trước khi xuất.")
            return
        if not self.coords:
            messagebox.showerror("Lỗi", "Chưa đặt trường nào trên tệp.")
            return
    
        # Nếu không có dữ liệu, tạo dữ liệu Numbering
        if self.df is None or self.df.empty:
            self.df = self.generate_numbering_data()
            if self.df.empty:
                messagebox.showerror("Lỗi", "Dữ liệu Numbering trống. Vui lòng kiểm tra lại các thông số.")
                return
            self.fields = ['Numbering']
            self.create_field_radiobuttons()
            self.excel_row_index = 0
    
        output_folder = filedialog.askdirectory()
        if not output_folder:
            return
    
        selected_font_name = self.font_var.get()
        selected_font_path = self.font_file_dict.get(selected_font_name, None)
        if not selected_font_path or not self.check_font_availability(selected_font_path):
            messagebox.showerror("Lỗi", f"Không thể mở tệp font {selected_font_name}, sử dụng font mặc định.")
            if sys.platform == "win32":
                selected_font_path = "C:/Windows/Fonts/Arial.ttf"
            else:
                selected_font_path = "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"
    
        # Chuẩn bị tệp PDF hợp nhất với tất cả dữ liệu (không lưu các tệp riêng lẻ)
        temp_dir = tempfile.gettempdir()
        merged_pdf_path = os.path.join(temp_dir, "merged_data.pdf")
        doc = fitz.open()
    
        for index, row in self.df.iterrows():
            # Tạo tệp PDF tạm thời với dữ liệu cho hàng này
            temp_pdf_path = os.path.join(temp_dir, f"temp_data_{uuid.uuid4()}.pdf")
            self.create_text_pdf(temp_pdf_path, row, selected_font_path)
    
            # Mở tài liệu gốc và PDF dữ liệu bằng 'with'
            with fitz.open(self.temp_pdf_path) as original_doc, fitz.open(temp_pdf_path) as data_doc:
                # Kiểm tra số trang
                if data_doc.page_count != original_doc.page_count:
                    messagebox.showerror("Lỗi", "Số trang trong tệp nguồn và tệp dữ liệu không khớp.")
                    continue
    
                # Chồng PDF dữ liệu lên PDF gốc
                for page_num in range(original_doc.page_count):
                    original_page = original_doc.load_page(page_num)
                    data_page = data_doc.load_page(page_num)
    
                    # Tạo trang mới trong tài liệu hợp nhất
                    new_page = doc.new_page(width=original_page.rect.width, height=original_page.rect.height)
                    new_page.show_pdf_page(original_page.rect, original_doc, page_num)
                    new_page.show_pdf_page(data_page.rect, data_doc, page_num)
    
            # Xóa tệp PDF tạm thời
            try:
                os.remove(temp_pdf_path)
            except PermissionError:
                # Chờ một chút và thử lại
                time.sleep(0.1)
                try:
                    os.remove(temp_pdf_path)
                except PermissionError as e:
                    print(f"Không thể xóa tệp tạm thời {temp_pdf_path}: {e}")
    
        # Lưu tài liệu PDF hợp nhất
        doc.save(merged_pdf_path)
        doc.close()
    
        # Áp dụng Imposition và lưu vào tệp mới
        imposed_pdf_path = os.path.join(output_folder, "imposed_output.pdf")
        self.apply_imposition(merged_pdf_path, imposed_pdf_path)
    
        # Xóa tệp PDF hợp nhất tạm thời
        try:
            os.remove(merged_pdf_path)
        except PermissionError as e:
            print(f"Không thể xóa tệp tạm thời hợp nhất {merged_pdf_path}: {e}")
    
        messagebox.showinfo("Thành công", f"File PDF đã được lưu tại {imposed_pdf_path}")
    
    def merge_pdfs(self, pdf_paths, output_path):
        """Merge nhiều tệp PDF thành một."""
        merged_doc = fitz.open()
        for pdf_path in pdf_paths:
            individual_doc = fitz.open(pdf_path)
            merged_doc.insert_pdf(individual_doc)
            individual_doc.close()
        merged_doc.save(output_path)
        merged_doc.close()
    
    def align_left(self):
        """Căn trái các mục đã chọn."""
        if not self.selected_items:
            messagebox.showinfo("Thông báo", "Chưa chọn mục nào để căn chỉnh.")
            return
        min_x = None
        for item_id in self.selected_items:
            field = self.get_field_by_text_id(item_id)
            if field:
                x = field['x']
                if min_x is None or x < min_x:
                    min_x = x
        for item_id in self.selected_items:
            field = self.get_field_by_text_id(item_id)
            if field:
                dx = (min_x - field['x']) * self.zoom_level
                self.canvas.move(item_id, dx, 0)
                field['x'] = min_x
                if field.get('label_id'):
                    self.canvas.move(field['label_id'], dx, 0)
        self.update_preview()
    
    def align_right(self):
        """Căn phải các mục đã chọn."""
        if not self.selected_items:
            messagebox.showinfo("Thông báo", "Chưa chọn mục nào để căn chỉnh.")
            return
        max_x = None
        for item_id in self.selected_items:
            field = self.get_field_by_text_id(item_id)
            if field:
                x = field['x']
                if max_x is None or x > max_x:
                    max_x = x
        for item_id in self.selected_items:
            field = self.get_field_by_text_id(item_id)
            if field:
                dx = (max_x - field['x']) * self.zoom_level
                self.canvas.move(item_id, dx, 0)
                field['x'] = max_x
                if field.get('label_id'):
                    self.canvas.move(field['label_id'], dx, 0)
        self.update_preview()
    
    def align_top(self):
        """Căn trên các mục đã chọn."""
        if not self.selected_items:
            messagebox.showinfo("Thông báo", "Chưa chọn mục nào để căn chỉnh.")
            return
        min_y = None
        for item_id in self.selected_items:
            field = self.get_field_by_text_id(item_id)
            if field:
                y = field['y']
                if min_y is None or y < min_y:
                    min_y = y
        for item_id in self.selected_items:
            field = self.get_field_by_text_id(item_id)
            if field:
                dy = (min_y - field['y']) * self.zoom_level
                self.canvas.move(item_id, 0, dy)
                field['y'] = min_y
                if field.get('label_id'):
                    self.canvas.move(field['label_id'], 0, dy)
        self.update_preview()
    
    def align_bottom(self):
        """Căn dưới các mục đã chọn."""
        if not self.selected_items:
            messagebox.showinfo("Thông báo", "Chưa chọn mục nào để căn chỉnh.")
            return
        max_y = None
        for item_id in self.selected_items:
            field = self.get_field_by_text_id(item_id)
            if field:
                y = field['y']
                if max_y is None or y > max_y:
                    max_y = y
        for item_id in self.selected_items:
            field = self.get_field_by_text_id(item_id)
            if field:
                dy = (max_y - field['y']) * self.zoom_level
                self.canvas.move(item_id, 0, dy)
                field['y'] = max_y
                if field.get('label_id'):
                    self.canvas.move(field['label_id'], 0, dy)
        self.update_preview()
    
    def align_center(self):
        """Căn giữa các mục đã chọn."""
        if not self.selected_items:
            messagebox.showinfo("Thông báo", "Chưa chọn mục nào để căn chỉnh.")
            return
        total_x = 0
        count = 0
        for item_id in self.selected_items:
            field = self.get_field_by_text_id(item_id)
            if field:
                total_x += field['x']
                count += 1
        if count == 0:
            return
        avg_x = total_x / count
        for item_id in self.selected_items:
            field = self.get_field_by_text_id(item_id)
            if field:
                dx = (avg_x - field['x']) * self.zoom_level
                self.canvas.move(item_id, dx, 0)
                field['x'] = avg_x
                if field.get('label_id'):
                    self.canvas.move(field['label_id'], dx, 0)
        self.update_preview()
    
    def zoom_in(self):
        """Phóng to canvas."""
        self.zoom_level *= 1.1
        self.display_pdf_page()
        # self.display_preview_page()
    
    def zoom_out(self):
        """Thu nhỏ canvas."""
        self.zoom_level /= 1.1
        self.display_pdf_page()
        # self.display_preview_page()
    
    def zoom_with_mouse_wheel(self, event):
        """Phóng to hoặc thu nhỏ bằng con lăn chuột."""
        if event.delta > 0 or event.num == 4:
            self.zoom_in()
        elif event.delta < 0 or event.num == 5:
            self.zoom_out()
    
    def preview_pdf(self):
        """Tạo và hiển thị PDF xem trước trong một cửa sổ mới."""
        if not self.file_path or not self.excel_path:
            messagebox.showerror("Lỗi", "Hãy chọn tệp và Excel trước khi xem trước.")
            return
        if not self.coords:
            messagebox.showerror("Lỗi", "Chưa đặt trường nào trên tệp.")
            return
    
        # Tạo PDF xem trước trong thư mục tạm
        temp_dir = tempfile.gettempdir()
        self.preview_pdf_path = os.path.join(temp_dir, "preview.pdf")
    
        selected_font_name = self.font_var.get()
        selected_font_path = self.font_file_dict.get(selected_font_name, None)
        if not selected_font_path or not self.check_font_availability(selected_font_path):
            if sys.platform == "win32":
                selected_font_path = "C:/Windows/Fonts/Arial.ttf"
            else:
                selected_font_path = "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"
    
        # Tạo một file PDF duy nhất chứa tất cả các trang với dữ liệu được điền
        doc = fitz.open()
    
        # Danh sách lưu các tệp PDF cá nhân
        individual_pdfs = []
    
        for index, row in self.df.iterrows():
            temp_pdf_path = os.path.join(temp_dir, f"temp_data_{uuid.uuid4()}.pdf")
    
            # Tạo PDF tùy chỉnh
            self.create_text_pdf(temp_pdf_path, row, selected_font_path)
    
            # Mở PDF tùy chỉnh và thêm vào doc
            temp_doc = fitz.open(temp_pdf_path)
            doc.insert_pdf(temp_doc)
            temp_doc.close()
    
            # Thêm vào danh sách để xóa sau này
            individual_pdfs.append(temp_pdf_path)
    
        # Lưu tài liệu PDF với dữ liệu
        output_pdf_path = os.path.join(temp_dir, "output_with_data_preview.pdf")
        doc.save(output_pdf_path)
        doc.close()
    
        # Áp dụng Imposition và lưu vào tệp mới
        imposed_preview_pdf_path = os.path.join(temp_dir, "imposed_preview.pdf")
        self.apply_imposition(output_pdf_path, imposed_preview_pdf_path)
    
        # Xóa các tệp PDF tạm thời
        try:
            for pdf_path in individual_pdfs:
                os.remove(pdf_path)
            os.remove(output_pdf_path)
        except Exception as e:
            print(f"Lỗi khi xóa tệp tạm: {e}")
    
        # Mở tệp xem trước đã áp dụng imposition
        self.preview_pdf_path = imposed_preview_pdf_path
        if self.preview_doc is not None:
            self.preview_doc.close()
        self.preview_doc = fitz.open(self.preview_pdf_path)
        self.preview_page_index = 0
    
        # Tạo cửa sổ xem trước mới nếu chưa có
        if hasattr(self, 'preview_window') and self.preview_window.winfo_exists():
            # Nếu cửa sổ đã tồn tại, chỉ cần cập nhật canvas
            self.display_preview_page()
        else:
            # Tạo cửa sổ xem trước mới
            self.preview_window = tk.Toplevel(self.root)
            self.preview_window.title("Xem trước")
            self.preview_window.geometry("800x600")
    
            # Thêm sự kiện khi đóng cửa sổ
            self.preview_window.protocol("WM_DELETE_WINDOW", self.close_preview_window)
    
            # Tạo canvas trong cửa sổ xem trước
            self.preview_canvas = tk.Canvas(self.preview_window, bg="gray")
            self.preview_canvas.pack(fill=tk.BOTH, expand=True)
    
            # Thêm thanh cuộn cho canvas
            hbar = tk.Scrollbar(self.preview_window, orient=tk.HORIZONTAL)
            hbar.pack(side=tk.BOTTOM, fill=tk.X)
            hbar.config(command=self.preview_canvas.xview)
            vbar = tk.Scrollbar(self.preview_window, orient=tk.VERTICAL)
            vbar.pack(side=tk.RIGHT, fill=tk.Y)
            vbar.config(command=self.preview_canvas.yview)
            self.preview_canvas.config(xscrollcommand=hbar.set, yscrollcommand=vbar.set)
    
            # Hiển thị trang xem trước
            self.display_preview_page()
    
        self.is_previewing = True
    
    def close_preview_window(self):
        """Xử lý khi đóng cửa sổ xem trước."""
        if self.preview_doc is not None:
            self.preview_doc.close()
            self.preview_doc = None
        if hasattr(self, 'preview_window') and self.preview_window.winfo_exists():
            self.preview_window.destroy()
        self.is_previewing = False
    
    def update_preview(self):
        """Cập nhật xem trước khi có thay đổi."""
        if self.is_previewing and hasattr(self, 'preview_window') and self.preview_window.winfo_exists():
            self.preview_pdf()
    
    def reset_preview(self):
        """Đặt lại xem trước khi tải tệp hoặc Excel mới."""
        if hasattr(self, 'preview_window') and self.preview_window.winfo_exists():
            self.preview_window.destroy()
        self.preview_doc = None
        self.preview_pdf_path = None
        self.preview_page_index = 0
        self.is_previewing = False
        self.excel_row_index = 0  # Đặt lại chỉ số hàng dữ liệu..
    
    def on_closing(self):
        """Xử lý khi đóng ứng dụng."""
        if hasattr(self, 'temp_pdf_path') and os.path.exists(self.temp_pdf_path):
            try:
                os.remove(self.temp_pdf_path)
            except Exception as e:
                print(f"Lỗi khi xóa tệp tạm: {e}")
        if self.preview_doc is not None:
            self.preview_doc.close()
        if hasattr(self, 'preview_window') and self.preview_window.winfo_exists():
            self.preview_window.destroy()
        self.root.destroy()
    
    def apply_imposition(self, input_pdf_path, output_pdf_path):
        """Áp dụng Imposition để sắp xếp nhiều dữ liệu trên một trang."""
        # Lấy các thông số từ giao diện
        new_page_width = self.new_page_width_var.get()
        new_page_height = self.new_page_height_var.get()
        margin_top = self.margin_top_var.get()
        margin_bottom = self.margin_bottom_var.get()
        margin_left = self.margin_left_var.get()
        margin_right = self.margin_right_var.get()
        cropmark_offset = self.cropmark_offset_var.get()
    
        # Lấy độ dài crop marks
        crop_length_mm = self.cropmark_length_var.get()
        crop_length_pt = self.mm_to_points(crop_length_mm)
    
        # Chuyển đổi đơn vị từ mm sang points
        new_page_width_pt = self.mm_to_points(new_page_width)
        new_page_height_pt = self.mm_to_points(new_page_height)
        margin_top_pt = self.mm_to_points(margin_top)
        margin_bottom_pt = self.mm_to_points(margin_bottom)
        margin_left_pt = self.mm_to_points(margin_left)
        margin_right_pt = self.mm_to_points(margin_right)
        cropmark_offset_pt = self.mm_to_points(cropmark_offset)
    
        # Tính diện tích khả dụng trên trang
        available_width = new_page_width_pt - margin_left_pt - margin_right_pt
        available_height = new_page_height_pt - margin_top_pt - margin_bottom_pt
    
        # Đọc tệp PDF đầu vào
        doc = fitz.open(input_pdf_path)
        new_doc = fitz.open()
        total_pages = len(doc)
    
        # Lấy kích thước của dữ liệu
        input_page = doc.load_page(0)
        bbox = input_page.rect
        entry_width = bbox.width
        entry_height = bbox.height
    
        # Tính số lượng mục có thể đặt trên trang
        entries_per_row = int(available_width / entry_width)
        entries_per_column = int(available_height / entry_height)
    
        # Kiểm tra nếu ít nhất một mục phù hợp
        if entries_per_row < 1 or entries_per_column < 1:
            messagebox.showerror("Lỗi", "Kích thước trang hoặc lề quá nhỏ để đặt bất kỳ dữ liệu nào.")
            return
    
        # Tính tổng chiều rộng và chiều cao của lưới
        total_grid_width = entries_per_row * entry_width
        total_grid_height = entries_per_column * entry_height
    
        # Tính offset để căn giữa lưới trên trang
        x_offset = (available_width - total_grid_width) / 2 + margin_left_pt
        y_offset = (available_height - total_grid_height) / 2 + margin_top_pt
    
        # Tham số cho crop marks
        crop_thickness = 0.5  # Độ dày mặc định của crop marks (in points)
    
        # Đặt các mục trên các trang mới
        page_index = 0
        while page_index < total_pages:
            new_page = new_doc.new_page(width=new_page_width_pt, height=new_page_height_pt)
            x = x_offset
            y = y_offset
    
            # Tính số lượng mục sẽ đặt trên trang này
            entries_remaining = total_pages - page_index
            entries_on_this_page = min(entries_per_row * entries_per_column, entries_remaining)
            rows_on_this_page = (entries_on_this_page + entries_per_row - 1) // entries_per_row
    
            for row in range(rows_on_this_page):
                x = x_offset  # Reset vị trí X cho mỗi hàng
                for col in range(entries_per_row):
                    if page_index >= total_pages:
                        break
                    # Định vị mục hiện tại
                    rect = fitz.Rect(x, y, x + entry_width, y + entry_height)
                    new_page.show_pdf_page(rect, doc, pno=page_index)
    
                    # Xác định các cạnh là cạnh ngoài
                    edges = []
                    if row == 0:
                        edges.append('top')
                    if row == rows_on_this_page - 1:
                        edges.append('bottom')
                    if col == 0:
                        edges.append('left')
                    if col == entries_per_row - 1:
                        edges.append('right')
    
                    # Thêm crop marks vào các cạnh ngoài
                    self.add_crop_marks(new_page, rect, edges, cropmark_offset_pt, crop_length_pt, crop_thickness)
    
                    # Chuyển đến mục tiếp theo theo chiều ngang
                    x += entry_width
                    page_index += 1
    
                # Chuyển đến hàng tiếp theo theo chiều dọc
                y += entry_height
    
        # Lưu tệp PDF đã áp dụng imposition
        new_doc.save(output_pdf_path)
        new_doc.close()
        doc.close()
    
    def add_crop_marks(self, page, rect, edges, offset, crop_length, crop_thickness):
        """Thêm crop marks vào các cạnh chỉ định."""
        x0, y0 = rect.x0, rect.y0
        x1, y1 = rect.x1, rect.y1
    
        crop_marks = []
        if 'top' in edges:
            # Trên - trái
            crop_marks.append([(x0 + offset, y0 - crop_length), (x0 + offset, y0)])
            # Trên - phải
            crop_marks.append([(x1 - offset, y0 - crop_length), (x1 - offset, y0)])
        if 'bottom' in edges:
            # Dưới - trái
            crop_marks.append([(x0 + offset, y1), (x0 + offset, y1 + crop_length)])
            # Dưới - phải
            crop_marks.append([(x1 - offset, y1), (x1 - offset, y1 + crop_length)])
        if 'left' in edges:
            # Trái - trên
            crop_marks.append([(x0 - crop_length, y0 + offset), (x0, y0 + offset)])
            # Trái - dưới
            crop_marks.append([(x0 - crop_length, y1 - offset), (x0, y1 - offset)])
        if 'right' in edges:
            # Phải - trên
            crop_marks.append([(x1, y0 + offset), (x1 + crop_length, y0 + offset)])
            # Phải - dưới
            crop_marks.append([(x1, y1 - offset), (x1 + crop_length, y1 - offset)])
    
        # Vẽ các crop mark
        for start, end in crop_marks:
            page.draw_line(start, end, width=crop_thickness, color=(0, 0, 0))
    
    def create_temp_pdf_with_data(self, row, selected_font_path):
        """Tạo tệp PDF tạm thời với dữ liệu từ một hàng Excel."""
        temp_dir = tempfile.gettempdir()
        temp_pdf_path = os.path.join(temp_dir, f"temp_data{uuid.uuid4()}.pdf")
    
        # Tạo PDF tùy chỉnh
        self.create_text_pdf(temp_pdf_path, row, selected_font_path)
    
        return temp_pdf_path
    
        
    def generate_numbering_data(self, num_rows=None):
        """Generate numbering data based on user input."""
        start = self.start_number_var.get()
        end = self.end_number_var.get()
        total_zeros = self.total_zeros_var.get()
        if num_rows is not None:
            end = start + num_rows - 1
        if start > end:
            messagebox.showerror("Error", "Start number must be less than or equal to End number.")
            return pd.DataFrame()
        numbering_list = []
        for num in range(start, end + 1):
            numbering = str(num).zfill(total_zeros)
            numbering_list.append(numbering)
        numbering_df = pd.DataFrame({'Numbering': numbering_list})
        return numbering_df
    def update_numbering_and_canvas(self, *args):
        """Update numbering data and refresh the canvas."""
        self.df = self.generate_numbering_data()
        self.display_pdf_page()
    

    if name == "main": root = tk.Tk() app = PDFEditorApp(root) root.protocol("WM_DELETE_WINDOW", app.on_closing) root.mainloop() hãy xem kỹ và phân tích mã này hiện tại tôi đang gặp vấn đề về việc xuất ra file pdf với lỗi khoogng thể xóa tệp tạm thời

  2. Assistant

    The issue you're encountering, where temporary PDF files cannot be deleted because they are still in use, is likely due to file handles not being properly closed before you attempt to delete the files. This is a common problem when working with files in Python, especially when dealing with libraries that handle file operations internally.

    In your code, the fitz (PyMuPDF) library is being used to open and manipulate PDF documents. If a fitz.Document object is not properly closed, the file remains open in the system, which prevents it from being deleted, especially on Windows systems.

    Here's how you can resolve the issue:

    1. Ensure All fitz.Document Instances Are Closed: Before attempting to delete any temporary files, make sure that all fitz.Document instances that might be using those files are properly closed. This includes documents opened in different methods or even in other threads.

    2. Explicitly Close self.pdf_doc: In your export_pdfs method, you might be using self.pdf_doc, which was opened earlier and may still be open when you're trying to delete temporary files. To fix this, you should ensure that self.pdf_doc is closed before you attempt to delete any temporary files.

    3. Add self.pdf_doc.close() Before Deletion: Add self.pdf_doc.close() in your export_pdfs method before you try to delete the temporary files.

    Here is the updated export_pdfs method with the necessary changes:

    def export_pdfs(self):
        """Xuất PDF đã áp dụng imposition với dữ liệu từ Excel và/hoặc Numbering."""
        if not self.file_path:
            messagebox.showerror("Lỗi", "Hãy chọn tệp trước khi xuất.")
            return
        if not self.coords:
            messagebox.showerror("Lỗi", "Chưa đặt trường nào trên tệp.")
            return
    
        # Nếu không có dữ liệu, tạo dữ liệu Numbering
        if self.df is None or self.df.empty:
            self.df = self.generate_numbering_data()
            if self.df.empty:
                messagebox.showerror("Lỗi", "Dữ liệu Numbering trống. Vui lòng kiểm tra lại các thông số.")
                return
            self.fields = ['Numbering']
            self.create_field_radiobuttons()
            self.excel_row_index = 0
    
        output_folder = filedialog.askdirectory()
        if not output_folder:
            return
    
        selected_font_name = self.font_var.get()
        selected_font_path = self.font_file_dict.get(selected_font_name, None)
        if not selected_font_path or not self.check_font_availability(selected_font_path):
            messagebox.showerror("Lỗi", f"Không thể mở tệp font {selected_font_name}, sử dụng font mặc định.")
            if sys.platform == "win32":
                selected_font_path = "C:/Windows/Fonts/Arial.ttf"
            else:
                selected_font_path = "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"
    
        # Chuẩn bị tệp PDF hợp nhất với tất cả dữ liệu (không lưu các tệp riêng lẻ)
        temp_dir = tempfile.gettempdir()
        merged_pdf_path = os.path.join(temp_dir, "merged_data.pdf")
        doc = fitz.open()
    
        for index, row in self.df.iterrows():
            # Tạo tệp PDF tạm thời với dữ liệu cho hàng này
            temp_pdf_path = os.path.join(temp_dir, f"temp_data_{uuid.uuid4()}.pdf")
            self.create_text_pdf(temp_pdf_path, row, selected_font_path)
    
            # Mở tài liệu gốc và PDF dữ liệu bằng 'with'
            with fitz.open(self.temp_pdf_path) as original_doc, fitz.open(temp_pdf_path) as data_doc:
                # Kiểm tra số trang
                if data_doc.page_count != original_doc.page_count:
                    messagebox.showerror("Lỗi", "Số trang trong tệp nguồn và tệp dữ liệu không khớp.")
                    continue
    
                # Chồng PDF dữ liệu lên PDF gốc
                for page_num in range(original_doc.page_count):
                    original_page = original_doc.load_page(page_num)
                    data_page = data_doc.load_page(page_num)
    
                    # Tạo trang mới trong tài liệu hợp nhất
                    new_page = doc.new_page(width=original_page.rect.width, height=original_page.rect.height)
                    new_page.show_pdf_page(original_page.rect, original_doc, page_num)
                    new_page.show_pdf_page(data_page.rect, data_doc, page_num)
    
            # Đảm bảo rằng data_doc và original_doc đã được đóng
            # Trước khi xóa tệp tạm thời, đặt các đối tượng doc thành None
            original_doc = None
            data_doc = None
    
            # Xóa tệp PDF tạm thời
            try:
                os.remove(temp_pdf_path)
            except PermissionError:
                # Chờ một chút và thử lại
                time.sleep(0.1)
                try:
                    os.remove(temp_pdf_path)
                except PermissionError as e:
                    print(f"Không thể xóa tệp tạm thời {temp_pdf_path}: {e}")
    
        # Đóng self.pdf_doc nếu đang mở
        if self.pdf_doc:
            self.pdf_doc.close()
            self.pdf_doc = None
    
        # Lưu tài liệu PDF hợp nhất
        doc.save(merged_pdf_path)
        doc.close()
    
        # Áp dụng Imposition và lưu vào tệp mới
        imposed_pdf_path = os.path.join(output_folder, "imposed_output.pdf")
        self.apply_imposition(merged_pdf_path, imposed_pdf_path)
    
        # Xóa tệp PDF hợp nhất tạm thời
        try:
            os.remove(merged_pdf_path)
        except PermissionError as e:
            print(f"Không thể xóa tệp tạm thời hợp nhất {merged_pdf_path}: {e}")
    
        messagebox.showinfo("Thành công", f"File PDF đã được lưu tại {imposed_pdf_path}")
    

    Key Changes:

    • Closing self.pdf_doc Before Deletion: At the end of the merging process but before deleting any temporary files, we ensure that self.pdf_doc is closed by checking if it exists and then calling self.pdf_doc.close(). This releases any file locks that might be held on the temporary files.

    • Setting Document Objects to None: After the with block, where original_doc and data_doc are used, we explicitly set them to None. This helps the garbage collector know that these objects are no longer needed, and it can clean them up promptly.

    • Ensuring All Files Are Closed Before Deletion: Before attempting to delete any temporary files, verify that all related files are closed. This includes any documents opened with PyMuPDF (fitz), and any file-like objects used by ReportLab.

    Additional Suggestions:

    • Use the Latest Version of PyMuPDF: Ensure you are using the latest version of PyMuPDF, as earlier versions might have issues with file handles not being released promptly.

    • Explicitly Close All Documents: For every fitz.Document you open, make sure to call doc.close() when you're done with it. Even though the with statement should handle this, explicitly closing documents can help avoid such issues.

    • Reduce the Scope of Variables: Limit the scope of variables that hold opened documents. For example, only use them within the with block and avoid assigning them to instance variables unless necessary.

    • Avoid Reusing Temporary File Paths: Since you're using temporary files, ensure that each temporary file has a unique name and that you manage them carefully to avoid conflicts.

    General Debugging Steps:

    1. Reproduce the Error: Run your application and perform the actions that lead to the error. Note exactly when the error occurs.

    2. Check for Open Files: Use debugging tools or add logging statements to check which files are open at the time you're trying to delete the temporary files.

    3. Add Exception Handling: Capture exceptions around file operations and log them to get more detailed information about what's happening.

    4. Test on Different Systems: If possible, test your application on another operating system (like Linux) to see if the issue persists. This can help determine if the problem is specific to Windows file locking behavior.

    Understanding the Issue:

    • File Locking on Windows: On Windows, a file cannot be deleted if it is open in any process. This is different from Unix-like systems, where files can be unlinked (deleted) even if they're open, and the space is only freed when all handles are closed.

    • Garbage Collection Delay: Sometimes, the garbage collector doesn't immediately free objects when they go out of scope. Explicitly setting objects to None can help.

    By ensuring that all files are properly closed before attempting deletion, and explicitly managing your file handles, you should be able to resolve the issue with temporary files not being deleted.