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

    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(value="Ho Ten")
        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.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)
    
        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)
    
        # 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ị cả hai canvas
        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)
    
        # Khung canvas xem trước
        self.preview_canvas_frame = tk.Frame(content_frame, bg='#2c2f33')
        self.preview_canvas_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
    
        self.preview_canvas = tk.Canvas(self.preview_canvas_frame, bg="gray")
        self.preview_canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
    
        # Thêm thanh cuộn cho canvas xem trước
        preview_hbar = tk.Scrollbar(self.preview_canvas_frame, orient=tk.HORIZONTAL)
        preview_hbar.pack(side=tk.BOTTOM, fill=tk.X)
        preview_hbar.config(command=self.preview_canvas.xview)
        preview_vbar = tk.Scrollbar(self.preview_canvas_frame, orient=tk.VERTICAL)
        preview_vbar.pack(side=tk.RIGHT, fill=tk.Y)
        preview_vbar.config(command=self.preview_canvas.yview)
        self.preview_canvas.config(xscrollcommand=preview_hbar.set, yscrollcommand=preview_vbar.set)
    
        # Khung xem trước
        self.preview_frame = tk.Frame(self.root, bg='#2c2f33')
        self.preview_frame.pack(fill=tk.BOTH, expand=True)
    
        # Khu vực văn bản
        self.text_area = tk.Text(self.preview_frame, height=10, width=100, bg='#23272a', fg='white')
        self.text_area.pack(side=tk.LEFT, padx=5, fill=tk.BOTH, expand=True)
    
        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)
    
        self.preview_canvas.bind("<MouseWheel>", self.zoom_with_mouse_wheel)
        self.preview_canvas.bind("<Button-4>", self.zoom_with_mouse_wheel)  # Cho Linux
        self.preview_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)
    
        # Thêm nút "Trước" và "Tiếp" cho xem trước
        preview_nav_frame = tk.Frame(self.preview_frame, bg='#2c2f33')
        preview_nav_frame.pack(fill=tk.X)
    
        prev_preview_button = tk.Button(preview_nav_frame, text="<< Trước", command=self.prev_preview, bg='#7289da',
                                        fg='white')
        prev_preview_button.pack(side=tk.LEFT, padx=2)
    
        next_preview_button = tk.Button(preview_nav_frame, text="Tiếp >>", command=self.next_preview, bg='#7289da',
                                        fg='white')
        next_preview_button.pack(side=tk.LEFT, padx=2)
        
    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  # 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
            # Không cần bỏ liên kết sự kiện trên root nữa vì chúng ta không liên kết nó
    
    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') and self.font_listbox.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)
                # 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 hoặc xem trước."""
        if self.is_previewing:
            if self.preview_page_index > 0:
                self.preview_page_index -= 1
                self.display_preview_page()
        elif 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 hoặc xem trước."""
        if self.is_previewing:
            if self.preview_page_index < len(self.preview_doc) - 1:
                self.preview_page_index += 1
                self.display_preview_page()
        elif self.pdf_doc:
            if self.current_page_index < len(self.pdf_doc) - 1:
                self.current_page_index += 1
                self.display_pdf_page()
    
    def render_text_on_page(self):
        """Hiển thị các trường văn bản và hình ảnh trên trang PDF hiện tại."""
        self.current_selected_text = None  # Đặt lại lựa chọn hiện tại
        page_items = self.coords.get(self.current_page_index, [])
        for item in page_items:
            # Tính tọa độ hiển thị trên canvas, có tính đến mức 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
                value = f"<{item['field']}>"
    
                # Tạo đối tượng văn bản trên 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)
    
                # Lấy kích thước thực tế của văn bản
                bbox = self.canvas.bbox(text_id)
                text_width = bbox[2] - bbox[0]
                text_height = bbox[3] - bbox[1]
    
                # Tính toán tỷ lệ scale nếu văn bản vượt quá 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
    
                # Lấy tùy chọn scale của người dùng
                scale_option_display = self.scale_option.get()
                scale_option = self.scale_option_mapping.get(scale_option_display, "uniform")
    
                if scale_option == "uniform":
                    # Scale đều cả hai chiều
                    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":
                    # Chỉ scale theo chiều ngang
                    pass  # Trong Canvas, không thể thực hiện
                elif scale_option == "vertical":
                    # Chỉ scale theo chiều dọc
                    pass  # Trong Canvas, không thể thực hiện
                elif scale_option == "kerning":
                    # Điều chỉnh khoảng cách giữa các ký tự
                    pass  # Trong Canvas, không thực hiện được dễ dàng
                else:
                    # Mặc định scale đều
                    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)
    
                # Cập nhật màu sắc cho văn bản
                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  # Cập nhật ID trong coords
    
                # Vẽ 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
    
                # Tạo các điểm neo (anchor) cho bounding box
                anchors = self.create_anchor_points(rect_id)
                item["anchors"] = anchors
    
                # Đảm bảo thứ tự hiển thị đúng trên 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':
                # Xử lý trường hợp là hình ảnh
                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()))
    
                width = width_points * self.zoom_level
                height = height_points * self.zoom_level
                rect_id = self.canvas.create_rectangle(
                    x - width / 2,
                    y - height / 2,
                    x + width / 2,
                    y + height / 2,
                    outline='blue', dash=(2, 2)
                )
                label_id = self.canvas.create_text(x, y, text=f"<{item['field']}>", anchor="center", fill="blue")
                item["id"] = rect_id
                item["label_id"] = label_id
    
                # Tạo các điểm neo (anchor)
                anchors = self.create_anchor_points(rect_id)
                item["anchors"] = anchors
    
                # Đảm bảo thứ tự hiển thị đúng
                self.canvas.tag_raise(label_id, rect_id)
                for anchor in anchors:
                    self.canvas.tag_raise(anchor, rect_id)
    
    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)
        if clicked_items:
            clicked_item = clicked_items[0]
            item_type = self.canvas.type(clicked_item)
            if item_type == "text" or item_type == "rectangle" 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)
                        # Deselect the item
                        self.deselect_item(clicked_item)
                    else:
                        self.selected_items.add(clicked_item)
                        # Select the item
                        self.select_item(clicked_item)
                else:
                    # Deselect previous selections
                    for item in self.selected_items:
                        self.deselect_item(item)
                    self.selected_items = set([clicked_item])
                    self.select_item(clicked_item)
                # Initialize move coordinates
                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')
    
        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', width=1)
        elif item_type == "text":
            self.canvas.itemconfig(item_id, fill='red')
    
        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 add_text(self, x, y):
        """Thêm một trường văn bản hoặc hình ảnh mới vào canvas và coords."""
        field = self.selected_field.get()
        field_type = self.field_type.get()
    
        # Điều chỉnh cho mức zoom
        x /= self.zoom_level
        y /= self.zoom_level
    
        if field_type == "Text":
            # Thiết lập kích thước ban đầu cho bounding box (đơn vị points)
            bounding_box_width = 100  # Chiều rộng mặc định
            bounding_box_height = 30  # Chiều cao mặc định
    
            # Tính toán vị trí cho văn bản và bounding box
            display_x = x * self.zoom_level
            display_y = y * self.zoom_level
    
            # Tạo đối tượng văn bản
            text_id = self.canvas.create_text(
                display_x, display_y,
                text=f"<{field}>",
                anchor="center",
                fill="red"
            )
    
            # Tạo một hình chữ nhật đại diện cho 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)
            )
    
            # Tạo các điểm neo ở các góc
            anchors = self.create_anchor_points(rect_id)
    
            # Đảm bảo văn bản được hiển thị phía trên hình chữ nhật và các điểm neo
            self.canvas.tag_raise(text_id, rect_id)
            for anchor in anchors:
                self.canvas.tag_raise(anchor, rect_id)
    
            # Khởi tạo dữ liệu mục
            new_item = {
                "id": text_id,
                "rect_id": rect_id,  # Tham chiếu đến bounding box
                "anchors": anchors,  # Tham chiếu đến các điểm neo
                "field": field,
                "x": x,
                "y": y,
                "width": bounding_box_width,   # Chiều rộng của bounding box
                "height": bounding_box_height,  # Chiều cao của 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(),
                },
                # Các thuộc tính bổ sung cho việc scale
                "is_resizing": False,         # Cờ để chỉ định nếu mục đang được thay đổi kích thước
                "resize_anchor": None,        # Điểm neo nào đang được sử dụng để thay đổi kích thước
            }
    
            # Thêm mục mới vào cấu trúc dữ liệu coords
            if self.current_page_index not in self.coords:
                self.coords[self.current_page_index] = []
            self.coords[self.current_page_index].append(new_item)
    
            # Cập nhật các mục được chọn
            self.selected_items = set([text_id, rect_id] + anchors)
    
            # Cập nhật font và các thuộc tính khác
            self.update_canvas_font()
    
            # Thêm vào ngăn xếp undo
            self.undo_stack.append(('add', new_item))
            self.redo_stack.clear()  # Xóa ngăn xếp redo
    
            self.update_preview()
    
        elif field_type == "Image":
            # Chuyển đổi kích thước từ mm sang 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
    
            # Tạo hình chữ nhật đại diện cho khu vực hình ảnh
            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)
            )
    
            label_id = self.canvas.create_text(display_x, display_y, text=f"<{field}>", anchor="center", fill="blue")
    
            anchors = self.create_anchor_points(rect_id)
    
            # Đảm bảo thứ tự hiển thị đúng
            self.canvas.tag_raise(label_id, rect_id)
            for anchor in anchors:
                self.canvas.tag_raise(anchor, rect_id)
    
            new_item = {
                "id": rect_id,
                "label_id": label_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)
    
            # Cập nhật các mục được chọn
            self.selected_items = set([rect_id, label_id] + anchors)
    
            # Thêm vào ngăn xếp undo
            self.undo_stack.append(('add', new_item))
            self.redo_stack.clear()
    
            self.update_preview()
    
    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 mà không thay đổi vị trí của trường."""
        # 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["id"] == field_id:
                item["width"] = new_width
                item["height"] = new_height
                break
        # Không cần di chuyển trường, giữ nguyên vị trí
    
    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["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):
        """Tải tệp Excel và hiển thị dữ liệu."""
        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)
                self.fields = self.df.columns.tolist()
                self.text_area.delete(1.0, tk.END)
                self.text_area.insert(tk.END, self.df.to_string())
                self.create_field_radiobuttons()
                self.reset_preview()
            except Exception as e:
                messagebox.showerror("Lỗi", f"Không thể đọc tệp Excel: {e}")
                self.excel_path = None
                self.df = None
    
    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 các tệp PDF với dữ liệu từ Excel và merge chúng."""
            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 xuất.")
                return
            if not self.coords:
                messagebox.showerror("Lỗi", "Chưa đặt trường nào trên tệp.")
                return
    
            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"
    
            # Danh sách lưu các tệp PDF cá nhân
            individual_pdfs = []
    
            for index, row in self.df.iterrows():
                doc = fitz.open(self.temp_pdf_path)
    
                # Tạo tên tệp duy nhất
                fields_in_name = '_'.join([str(row[field]) for field in self.fields[:3]])  # Tùy chỉnh nếu cần
                output_pdf_path = os.path.join(output_folder, f"{fields_in_name}_custom.pdf")
    
                # Tạo PDF tùy chỉnh
                self.create_text_pdf(output_pdf_path, row, selected_font_path)
    
                # Mở PDF tùy chỉnh
                new_doc = fitz.open(output_pdf_path)
    
                # Đảm bảo new_doc có cùng số trang
                if new_doc.page_count != len(doc):
                    messagebox.showerror("Lỗi", "Số trang trong tệp gốc và tệp mới không khớp.")
                    new_doc.close()
                    doc.close()
                    continue
    
                # Overlay các trang tùy chỉnh lên tệp gốc
                for page_num in range(len(doc)):
                    page = doc.load_page(page_num)
                    rect = fitz.Rect(0, 0, self.original_width, self.original_height)
                    page.show_pdf_page(rect, new_doc, page_num)
    
                new_doc.close()
    
                # Lưu PDF cuối cùng
                final_output_path = os.path.join(output_folder, f"{fields_in_name}_final.pdf")
                doc.save(final_output_path)
                individual_pdfs.append(final_output_path)
    
                doc.close()
    
            # Xóa tệp PDF tùy chỉnh tạm thời
            try:
                os.remove(output_pdf_path)
            except Exception as e:
                print(f"Lỗi khi xóa tệp tạm: {e}")
    
            # Merge các tệp PDF
            if individual_pdfs:
                merged_pdf_path = os.path.join(output_folder, "merged_final_output.pdf")
                self.merge_pdfs(individual_pdfs, merged_pdf_path)
                messagebox.showinfo("Thành công", "File PDF đã được xuất thành công với dữ liệu từ Excel.")
    
                # Hỏi người dùng có muốn áp dụng imposition không
                if messagebox.askyesno("Imposition", "Bạn có muốn áp dụng imposition cho file PDF đã xuất không?"):
                    # 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()
    
                    # Chuyển đổi các đơ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)
    
                    # Áp dụng imposition
                    imposed_pdf_path = os.path.join(output_folder, "imposed_output.pdf")
                    self.apply_imposition(merged_pdf_path, imposed_pdf_path)
    
                    messagebox.showinfo("Thành công", f"Imposition đã được áp dụng. File PDF đã được lưu tại {imposed_pdf_path}")
                else:
                    messagebox.showinfo("Thành công", f"File PDF đã được lưu tại {merged_pdf_path}")
            else:
                messagebox.showerror("Lỗi", "Không có file PDF nào được tạo.")
    
    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 với áp dụng imposition."""
        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
    
        # Nếu self.preview_doc đã mở, đóng nó trước
        if self.preview_doc is not None:
            self.preview_doc.close()
            self.preview_doc = None
    
        # 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()
    
        for index, row in self.df.iterrows():
            # Tạo PDF tùy chỉnh với dữ liệu từ hàng hiện tại
            temp_pdf_path = self.create_temp_pdf_with_data(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()
    
            # Xóa tệp PDF tùy chỉnh tạm thời
            os.remove(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)
    
        # Mở tệp xem trước đã áp dụng imposition
        self.preview_pdf_path = imposed_preview_pdf_path
        self.preview_doc = fitz.open(self.preview_pdf_path)
    
        self.is_previewing = True
        self.preview_page_index = 0
    
        # Hiển thị trang xem trước
        self.display_preview_page()
    
    def prev_preview(self):
        """Chuyển đến hàng dữ liệu trước trong Excel và cập nhật xem trước."""
        if self.excel_row_index > 0:
            self.excel_row_index -= 1
            self.preview_pdf()
    
    def next_preview(self):
        """Chuyển đến hàng dữ liệu tiếp theo trong Excel và cập nhật xem trước."""
        if self.excel_row_index < len(self.df) - 1:
            self.excel_row_index += 1
            self.preview_pdf()
    
    def display_preview_page(self):
        """Hiển thị trang hiện tại của PDF xem trước."""
        if self.preview_doc and 0 <= self.preview_page_index < len(self.preview_doc):
            try:
                page = self.preview_doc.load_page(self.preview_page_index)
                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.preview_image = ImageTk.PhotoImage(img)
                self.preview_canvas.delete("all")
                self.preview_canvas.create_image(0, 0, anchor="nw", image=self.preview_image)
                self.preview_canvas.config(width=pix.width, height=pix.height)
                self.preview_canvas.config(scrollregion=self.preview_canvas.bbox(tk.ALL))
            except Exception as e:
                messagebox.showerror("Lỗi", f"Không thể hiển thị trang xem trước: {e}")
    
    def update_preview(self):
        """Cập nhật xem trước khi có thay đổi."""
        if self.is_previewing:
            self.preview_pdf()
    
    def reset_preview(self):
        """Đặt lại xem trước khi tải tệp hoặc Excel mới."""
        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}")
        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
    

    if name == "main": root = tk.Tk() app = PDFEditorApp(root) root.protocol("WM_DELETE_WINDOW", app.on_closing) root.mainloop() mã này sau khi sửa hoạt động đúng như mong đợi bây giờ hãy thay đổi mã như sau các trường hiện tại khi đặt vào sẽ là tên của trường excel, tôi muốn nó ko để tên trường mà đổi thành các giá trị của trường đó bạn hiểu chứ, và có bao nhiêu dòng thì khi bấm nút tiếp sẽ tự qua data tiếp theo, khi data nào thực hiện việc scale thì trong khung excel dòng đó sẽ đánh dấu đỏ. và khi người dùng bấm vào dòng đỏ đó thì mã sẽ di chuyển đến data của file đó trong khung pdf để người dùng nhìn kết quả m khung canvan preview sẽ không xuất hiện mà khi người dùng bấm xem trước nó sẽ mở ra 1 cửa sổ mới để cho người dùng thấy file imposion bao gồm nọi dung pdf, nội dung data, cropmarks được tính toán theo hàm apply imposion, các nút chọn trường excel sẽ di chuyển lên cùng hàng với các nút canh trái, canh phải v.v.v.

  2. Assistant

    Chào bạn,

    Dựa trên yêu cầu của bạn, chúng tôi sẽ thực hiện các thay đổi sau trong mã để đáp ứng các yêu cầu:

    1. Hiển thị giá trị dữ liệu từ Excel thay vì tên trường trên canvas:

      • Trong phương thức add_text và render_text_on_page, thay vì hiển thị tên trường (ví dụ: ""), chúng ta sẽ lấy giá trị tương ứng từ hàng dữ liệu hiện tại trong Excel và hiển thị nó trên canvas.
      • Chúng ta sẽ sử dụng self.excel_row_index để lấy hàng dữ liệu hiện tại và truy xuất giá trị của trường từ self.df.
    2. Thay đổi dữ liệu khi bấm nút "Tiếp":

      • Thêm các nút "Dữ liệu trước" và "Dữ liệu tiếp" để di chuyển qua các hàng dữ liệu trong Excel.
      • Khi người dùng bấm các nút này, chúng ta sẽ cập nhật self.excel_row_index và gọi display_pdf_page() để cập nhật canvas với dữ liệu mới.
    3. Đánh dấu đỏ những dòng dữ liệu bị scale:

      • Trong quá trình hiển thị văn bản trên canvas, nếu chúng ta phải scale (thu nhỏ) văn bản do vượt quá kích thước bounding box, chúng ta sẽ lưu chỉ số hàng dữ liệu vào một danh sách self.scaled_rows.
      • Sử dụng Treeview để hiển thị dữ liệu Excel thay vì Text widget, giúp chúng ta dễ dàng đánh dấu các hàng dữ liệu bị scale bằng cách thay đổi màu nền của dòng đó.
    4. Chuyển đến dữ liệu tương ứng khi bấm vào dòng bị đánh dấu đỏ:

      • Khi người dùng nhấp đúp vào một dòng trong Treeview, chúng ta sẽ cập nhật self.excel_row_index và gọi display_pdf_page() để hiển thị dữ liệu tương ứng trên canvas.
    5. Mở cửa sổ mới khi bấm "Xem trước":

      • Thay vì hiển thị canvas xem trước trong cửa sổ chính, chúng ta sẽ tạo một cửa sổ Toplevel mới khi người dùng bấm "Xem trước".
      • Trong cửa sổ mới này, chúng ta sẽ hiển thị PDF imposion với nội dung PDF, dữ liệu và crop marks.
    6. Di chuyển các nút chọn trường Excel lên cùng hàng với các nút canh chỉnh:

      • Thay vì có một frame riêng cho các nút chọn trường Excel, chúng ta sẽ tạo một frame mới trong button_frame2 (nơi chứa các nút canh chỉnh) để chứa các nút này.

    Dưới đây là hướng dẫn cụ thể để bạn thực hiện các thay đổi:

    1. Hiển thị giá trị dữ liệu từ Excel trên canvas

    Trong phương thức render_text_on_page, thay đổi cách mà văn bản được hiển thị:

    def render_text_on_page(self):
        """Hiển thị các trường văn bản và hình ảnh trên trang PDF hiện tại."""
        self.current_selected_text = None  # Đặt lại lựa chọn hiện tại
        page_items = self.coords.get(self.current_page_index, [])
        current_row = self.get_current_data_row()
        scaling_occurred = False  # Biến cờ để kiểm tra xem có scale xảy ra không
        for item in page_items:
            # Tính tọa độ hiển thị trên canvas, có tính đến mức zoom
            x = item["x"] * self.zoom_level
            y = item["y"] * self.zoom_level
            field_name = item["field"]
            if current_row is not None and field_name in current_row:
                value = str(current_row[field_name])
            else:
                value = f"<{field_name}>"
            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
    
                # Tạo đối tượng văn bản trên 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)
    
                # Kiểm tra nếu văn bản bị scale
                bbox = self.canvas.bbox(text_id)
                text_width = bbox[2] - bbox[0]
                text_height = bbox[3] - bbox[1]
    
                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")
    
                scaled = False
    
                if scale_option == "uniform":
                    scale = min(scale_x, scale_y)
                    if scale < 1.0:
                        scaled = True
                        new_size = size * scale
                        text_font = (font_name, int(new_size * self.zoom_level))
                        self.canvas.itemconfig(text_id, font=text_font)
                # ... (các tùy chọn scale khác) ...
    
                if scaled:
                    scaling_occurred = True
    
                # ... (phần còn lại của mã) ...
    
        # Sau khi hiển thị tất cả các mục, nếu xảy ra scale, đánh dấu hàng dữ liệu
        if scaling_occurred:
            self.scaled_rows.add(self.excel_row_index)
            # Cập nhật Treeview để đánh dấu dòng này
            self.data_treeview.item(str(self.excel_row_index), tags=('scaled',))
            self.data_treeview.tag_configure('scaled', background='red')
        else:
            if self.excel_row_index in self.scaled_rows:
                self.scaled_rows.remove(self.excel_row_index)
                # Xóa tag 'scaled' nếu có
                self.data_treeview.item(str(self.excel_row_index), tags=())
    

    2. Thêm nút để di chuyển giữa các hàng dữ liệu

    Trong setup_ui, thêm các 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_row, 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_row, bg='#7289da', fg='white')
    next_data_button.pack(side=tk.LEFT, padx=2)
    

    Và trong lớp PDFEditorApp, thêm phương thức:

    def prev_data_row(self):
        if self.excel_row_index > 0:
            self.excel_row_index -= 1
            self.display_pdf_page()
    
    def next_data_row(self):
        if self.excel_row_index < len(self.df) - 1:
            self.excel_row_index += 1
            self.display_pdf_page()
    

    3. Sử dụng Treeview để hiển thị dữ liệu Excel và đánh dấu đỏ các dòng bị scale

    Thay vì sử dụng Text widget, chúng ta sẽ sử dụng Treeview:

    Trong setup_ui, thay thế phần tạo self.text_area bằng:

    # Khu vực hiển thị dữ liệu Excel
    self.data_treeview = ttk.Treeview(self.preview_frame)
    self.data_treeview.pack(side=tk.LEFT, padx=5, fill=tk.BOTH, expand=True)
    

    Trong phương thức load_excel, cập nhật để hiển thị dữ liệu trong Treeview:

    def load_excel(self):
        """Tải tệp Excel và hiển thị dữ liệu."""
        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)
                self.fields = self.df.columns.tolist()
                # Thiết lập Treeview
                self.data_treeview.delete(*self.data_treeview.get_children())
                self.data_treeview['columns'] = self.fields
                self.data_treeview['show'] = 'headings'
                for field in self.fields:
                    self.data_treeview.heading(field, text=field)
                    self.data_treeview.column(field, width=100)
                # Xóa danh sách scaled_rows
                self.scaled_rows = set()
                # Thêm dữ liệu vào Treeview
                for index, row in self.df.iterrows():
                    self.data_treeview.insert('', tk.END, values=list(row), iid=str(index))
                self.create_field_radiobuttons()
                self.reset_preview()
                # Liên kết sự kiện nhấp chuột
                self.data_treeview.bind("<Double-1>", self.on_data_row_click)
            except Exception as e:
                messagebox.showerror("Error", f"Cannot read Excel file: {e}")
                self.excel_path = None
                self.df = None
    

    4. Chuyển đến dữ liệu tương ứng khi bấm vào dòng trong Treeview

    Thêm phương thức để xử lý sự kiện nhấp chuột:

    def on_data_row_click(self, event):
        """Xử lý khi người dùng nhấp vào hàng dữ liệu trong Treeview."""
        selected_item = self.data_treeview.focus()
        if selected_item:
            row_index = int(selected_item)
            self.excel_row_index = row_index
            self.display_pdf_page()
    

    5. Mở cửa sổ mới khi bấm "Xem trước"

    Trong phương thức preview_pdf, thay đổi để tạo một cửa sổ mới hiển thị PDF:

    def preview_pdf(self):
        """Tạo và hiển thị PDF xem trước trong một cửa sổ mới."""
        # ... (phần tạo PDF xem trước như trước đây) ...
    
        # Mở cửa sổ mới để hiển thị PDF
        if hasattr(self, 'preview_window') and self.preview_window.winfo_exists():
            self.preview_window.lift()
            return
        else:
            self.preview_window = tk.Toplevel(self.root)
            self.preview_window.title("Xem trước")
            self.preview_window.geometry("800x600")
    
            # Tạo canvas để hiển thị PDF
            self.preview_canvas = tk.Canvas(self.preview_window, bg="gray")
            self.preview_canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
    
            # Thêm thanh cuộn và các nút điều hướng
            # ... (tương tự như cách bạn làm với canvas chính) ...
    
            self.preview_page_index = 0
    
            self.display_preview_page()
    

    6. Di chuyển các nút chọn trường Excel lên cùng hàng với các nút canh chỉnh

    Trong setup_ui, điều chỉnh phần tạo các nút chọn trường:

    • Xóa self.excel_button_frame.
    • Tạo một frame mới trong button_frame2 để chứa các nút này:
    # Trong button_frame2
    # Tạo frame để chứa các nút chọn trường
    field_button_frame = tk.Frame(button_frame2, bg='#2c2f33')
    field_button_frame.pack(side=tk.LEFT, padx=5, pady=5, fill=tk.X, expand=True)
    
    # Thêm canvas với thanh cuộn để chứa các nút
    field_canvas = tk.Canvas(field_button_frame, bg='#2c2f33', highlightthickness=0)
    field_scrollbar = tk.Scrollbar(field_button_frame, orient=tk.HORIZONTAL, command=field_canvas.xview)
    field_canvas.configure(xscrollcommand=field_scrollbar.set)
    
    field_inner_frame = tk.Frame(field_canvas, bg='#2c2f33')
    field_canvas.create_window((0, 0), window=field_inner_frame, anchor='nw')
    
    field_canvas.pack(side=tk.TOP, fill=tk.X, expand=True)
    field_scrollbar.pack(side=tk.BOTTOM, fill=tk.X)
    
    def configure_field_canvas(event):
        field_canvas.configure(scrollregion=field_canvas.bbox("all"))
    field_inner_frame.bind("<Configure>", configure_field_canvas)
    
    # Lưu tham chiếu đến field_inner_frame để sử dụng trong create_field_radiobuttons
    self.field_inner_frame = field_inner_frame
    

    Và cập nhật phương thức create_field_radiobuttons:

    def create_field_radiobuttons(self):
        """Tạo các nút radio cho các trường dữ liệu Excel."""
        # Xóa các nút hiện có
        for widget in self.field_inner_frame.winfo_children():
            widget.destroy()
    
        # Thêm các nút mới
        for field in self.fields:
            rb = tk.Radiobutton(self.field_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)
    

    Như vậy, với những thay đổi trên, bạn sẽ có một ứng dụng đáp ứng đầy đủ các yêu cầu của bạn. Hãy thử áp dụng và chạy lại ứng dụng để kiểm tra kết quả.

    Chúc bạn thành công!