qrcode-generator-GUI.py

import tkinter as tk
from tkinter import ttk, filedialog, colorchooser, messagebox
from PIL import Image, ImageTk, ImageDraw, ImageFont # ImageDraw and Font for placeholder
import qrcode
from qrcode.image.styledpil import StyledPilImage
from qrcode.image.styles.moduledrawers import (
    SquareModuleDrawer,
    GappedSquareModuleDrawer,
    CircleModuleDrawer,
    RoundedModuleDrawer,
    VerticalBarsDrawer,
    HorizontalBarsDrawer,
)
from qrcode.image.styles.colormasks import (
    SolidFillColorMask,
    RadialGradiantColorMask,
    SquareGradiantColorMask,
    HorizontalGradiantColorMask,
    VerticalGradiantColorMask,
)
import os

# --- StyledPilImageWithHole Class ---
class StyledPilImageWithHole(StyledPilImage):
    def __init__(self, *args,
                 hole_size_factor=1/3,
                 force_punch_hole=False,
                 **kwargs):                 
        
        actual_embedded_image_path = kwargs.get('embeded_image_path') 
        self._hole_embedded_image_path = actual_embedded_image_path
        self._hole_size_factor = hole_size_factor
        self._force_punch_hole = force_punch_hole
        
        super().__init__(*args, **kwargs) 
        
        if self._hole_embedded_image_path or self._force_punch_hole:
            self._punch_hole_in_modules()

    def _punch_hole_in_modules(self):
        if not self.modules or self.width == 0:
            return

        qr_matrix_pixel_width = self.width * self.box_size
        qr_matrix_pixel_height = self.width * self.box_size

        hole_pixel_width = int(qr_matrix_pixel_width * self._hole_size_factor)
        hole_pixel_height = int(qr_matrix_pixel_height * self._hole_size_factor)

        qr_matrix_center_x_on_image = (self.border * self.box_size) + (qr_matrix_pixel_width / 2)
        qr_matrix_center_y_on_image = (self.border * self.box_size) + (qr_matrix_pixel_height / 2)
        
        hole_start_pixel_x_on_image = qr_matrix_center_x_on_image - (hole_pixel_width / 2)
        hole_start_pixel_y_on_image = qr_matrix_center_y_on_image - (hole_pixel_height / 2)
        hole_end_pixel_x_on_image = hole_start_pixel_x_on_image + hole_pixel_width
        hole_end_pixel_y_on_image = hole_start_pixel_y_on_image + hole_pixel_height

        for r_module in range(self.width):
            for c_module in range(self.width):
                module_pixel_start_x_on_image = (c_module + self.border) * self.box_size
                module_pixel_start_y_on_image = (r_module + self.border) * self.box_size
                module_center_pixel_x_on_image = module_pixel_start_x_on_image + self.box_size / 2
                module_center_pixel_y_on_image = module_pixel_start_y_on_image + self.box_size / 2

                if (hole_start_pixel_x_on_image <= module_center_pixel_x_on_image < hole_end_pixel_x_on_image and
                    hole_start_pixel_y_on_image <= module_center_pixel_y_on_image < hole_end_pixel_y_on_image):
                    if 0 <= r_module < len(self.modules) and 0 <= c_module < len(self.modules[r_module]):
                        self.modules[r_module][c_module] = False

# --- Main Application UI Class ---
class QRCodeApp:
    PREVIEW_SIZE = (512, 512)
    MAX_SAVE_SIZE_RASTER = (1024, 1024)
    MAX_HOLE_SIZE_FACTOR = 0.35

    DEFAULT_QR_DATA = "https://www.example.com"
    DEFAULT_ERROR_CORRECTION = "H (High ~30%)"
    DEFAULT_BOX_SIZE = 20 
    DEFAULT_BORDER = 2
    DEFAULT_COLOR_MASK_TYPE = "Solid Color"
    DEFAULT_FRONT_COLOR1 = "#000000"
    DEFAULT_FRONT_COLOR2 = "#5599FF"
    DEFAULT_BACK_COLOR = "#FFFFFF"
    DEFAULT_MODULE_DRAWER = "Rounded Squares"
    DEFAULT_EYE_DRAWER = "Rounded Squares"
    DEFAULT_LOGO_PATH = ""
    DEFAULT_LOGO_DISPLAY_NAME = "No logo"
    DEFAULT_HOLE_SIZE_FACTOR = 0.25
    DEFAULT_PUNCH_HOLE = False # Default state for punch_hole when no logo

    MODULE_DRAWERS = {
        "Rounded Squares": RoundedModuleDrawer(),
        "Squares": SquareModuleDrawer(),
        "Gapped Squares": GappedSquareModuleDrawer(),
        "Circles": CircleModuleDrawer(),
        "Vertical Bars": VerticalBarsDrawer(),
        "Horizontal Bars": HorizontalBarsDrawer(),
    }

    COLOR_MASKS_TYPES = {
        "Solid Color": "SolidFillColorMask",
        "Radial Gradient": "RadialGradiantColorMask",
        "Square Gradient": "SquareGradiantColorMask",
        "Horizontal Gradient": "HorizontalGradiantColorMask",
        "Vertical Gradient": "VerticalGradiantColorMask",
    }

    ERROR_CORRECTION_MAP = {
        "L (Low ~7%)": qrcode.constants.ERROR_CORRECT_L,
        "M (Medium ~15%)": qrcode.constants.ERROR_CORRECT_M,
        "Q (Quartile ~25%)": qrcode.constants.ERROR_CORRECT_Q,
        "H (High ~30%)": qrcode.constants.ERROR_CORRECT_H,
    }

    def __init__(self, root_window):
        self.root = root_window
        self.root.title("QR Code Generator")
        self.root.geometry("1100x750")

        self.qr_data_var = tk.StringVar()
        self.error_correction_var = tk.StringVar()
        self.box_size_var = tk.IntVar()
        self.border_var = tk.IntVar()
        self.color_mask_type_var = tk.StringVar()
        self.front_color1_var = tk.StringVar()
        self.front_color2_var = tk.StringVar()
        self.back_color_var = tk.StringVar()
        self.module_drawer_var = tk.StringVar()
        self.eye_drawer_var = tk.StringVar()
        self.logo_path_var = tk.StringVar()
        self.logo_display_name_var = tk.StringVar()
        self.hole_size_factor_var = tk.DoubleVar()
        self.punch_hole_var = tk.BooleanVar()

        self.current_qr_image_pil = None
        self.current_qr_photoimage_preview = None
        self.initial_placeholder_photo = None
        
        # UI elements that need to be accessed later
        self.punch_hole_check = None 

        self.apply_default_settings() 
        self.setup_ui()
        self.update_all_ui_elements_from_vars()
        self.generate_and_display_qr()
        self._update_punch_hole_check_state() # Initial state update

    def apply_default_settings(self):
        self.qr_data_var.set(self.DEFAULT_QR_DATA)
        self.error_correction_var.set(self.DEFAULT_ERROR_CORRECTION)
        self.box_size_var.set(self.DEFAULT_BOX_SIZE)
        self.border_var.set(self.DEFAULT_BORDER)
        self.color_mask_type_var.set(self.DEFAULT_COLOR_MASK_TYPE)
        self.front_color1_var.set(self.DEFAULT_FRONT_COLOR1)
        self.front_color2_var.set(self.DEFAULT_FRONT_COLOR2)
        self.back_color_var.set(self.DEFAULT_BACK_COLOR)
        self.module_drawer_var.set(self.DEFAULT_MODULE_DRAWER)
        self.eye_drawer_var.set(self.DEFAULT_EYE_DRAWER)
        self.logo_path_var.set(self.DEFAULT_LOGO_PATH)
        self.logo_display_name_var.set(self.DEFAULT_LOGO_DISPLAY_NAME)
        self.hole_size_factor_var.set(self.DEFAULT_HOLE_SIZE_FACTOR)
        self.punch_hole_var.set(self.DEFAULT_PUNCH_HOLE)
        # self._update_punch_hole_check_state() will be called after UI setup

    def update_all_ui_elements_from_vars(self):
        self.update_color_swatch(self.front_color1_var)
        self.update_color_swatch(self.front_color2_var)
        self.update_color_swatch(self.back_color_var)
        self.update_color_mask_options() 
        self._update_punch_hole_check_state() # Ensure check state is correct

    def reset_settings(self):
        if messagebox.askyesno("Reset", "Are you sure you want to reset all settings to their default values?"):
            self.apply_default_settings()
            self.update_all_ui_elements_from_vars() # This will call _update_punch_hole_check_state
            if hasattr(self, 'hole_size_val_label'):
                 self._update_slider_label(self.hole_size_factor_var.get(), self.hole_size_val_label)
            self.generate_and_display_qr()

    def _update_punch_hole_check_state(self):
        """Updates the state of the punch_hole_check based on logo presence."""
        if self.punch_hole_check: # Ensure the widget has been created
            if self.logo_path_var.get(): # If there is a logo path
                self.punch_hole_var.set(True) # Force check to True
                self.punch_hole_check.config(state=tk.DISABLED)
            else:
                self.punch_hole_check.config(state=tk.NORMAL)
                # self.punch_hole_var.set(self.DEFAULT_PUNCH_HOLE) # Optionally reset to default if no logo

    def hex_to_rgb(self, hex_color):
        h = hex_color.lstrip('#')
        return tuple(int(h[i:i+2], 16) for i in (0, 2, 4))

    def get_module_drawer_instance(self, drawer_name_key):
        return self.MODULE_DRAWERS.get(drawer_name_key, RoundedModuleDrawer())

    def get_eye_drawer_instance(self, drawer_name_key, module_drawer_instance):
        if drawer_name_key == "Same as modules":
            return module_drawer_instance
        return self.MODULE_DRAWERS.get(drawer_name_key, module_drawer_instance)

    def get_color_mask_instance(self):
        mask_key = self.color_mask_type_var.get()
        if mask_key not in self.COLOR_MASKS_TYPES:
            mask_key = self.DEFAULT_COLOR_MASK_TYPE 
        mask_type_str = self.COLOR_MASKS_TYPES[mask_key]
        
        fc1_rgb = self.hex_to_rgb(self.front_color1_var.get())
        fc2_rgb = self.hex_to_rgb(self.front_color2_var.get())
        bc_rgb = self.hex_to_rgb(self.back_color_var.get())

        if mask_type_str == "SolidFillColorMask":
            return SolidFillColorMask(back_color=bc_rgb, front_color=fc1_rgb)
        elif mask_type_str == "RadialGradiantColorMask":
            return RadialGradiantColorMask(back_color=bc_rgb, center_color=fc1_rgb, edge_color=fc2_rgb)
        elif mask_type_str == "SquareGradiantColorMask":
            return SquareGradiantColorMask(back_color=bc_rgb, center_color=fc1_rgb, edge_color=fc2_rgb)
        elif mask_type_str == "HorizontalGradiantColorMask":
            return HorizontalGradiantColorMask(back_color=bc_rgb, left_color=fc1_rgb, right_color=fc2_rgb)
        elif mask_type_str == "VerticalGradiantColorMask":
            return VerticalGradiantColorMask(back_color=bc_rgb, top_color=fc1_rgb, bottom_color=fc2_rgb)
        return SolidFillColorMask(back_color=bc_rgb, front_color=fc1_rgb)

    def generate_qr_code_pil_image(self):
        try:
            data = self.qr_data_var.get()
            if not data:
                messagebox.showerror("Error", "QR code data cannot be empty.")
                return None

            qr = qrcode.QRCode(
                version=None,
                error_correction=self.ERROR_CORRECTION_MAP[self.error_correction_var.get()],
                box_size=self.box_size_var.get(),
                border=self.border_var.get(),
            )
            qr.add_data(data)
            qr.make(fit=True)

            module_drawer_inst = self.get_module_drawer_instance(self.module_drawer_var.get())
            eye_drawer_inst = self.get_eye_drawer_instance(self.eye_drawer_var.get(), module_drawer_inst)
            color_mask_inst = self.get_color_mask_instance()
            
            logo_p = self.logo_path_var.get() if self.logo_path_var.get() else None
            hole_f = self.hole_size_factor_var.get()
            # punch_hole_var is now automatically set if logo exists, or user-controlled if no logo
            force_punch = self.punch_hole_var.get() 

            img = qr.make_image(
                image_factory=StyledPilImageWithHole,
                module_drawer=module_drawer_inst,
                eye_drawer=eye_drawer_inst,
                color_mask=color_mask_inst,
                embeded_image_path=logo_p,
                hole_size_factor=hole_f,
                force_punch_hole=force_punch
            )
            self.current_qr_image_pil = img
            return img
        except Exception as e:
            messagebox.showerror("QR Generation Error", f"Detail: {str(e)}")
            self.current_qr_image_pil = None
            return None

    def generate_and_display_qr(self, event=None):
        pil_image = self.generate_qr_code_pil_image()
        if pil_image:
            preview_image = pil_image.copy()
            preview_image.thumbnail(self.PREVIEW_SIZE, Image.Resampling.LANCZOS)
            self.current_qr_photoimage_preview = ImageTk.PhotoImage(preview_image)
            self.qr_image_label.config(image=self.current_qr_photoimage_preview)
            self.qr_image_label.image = self.current_qr_photoimage_preview
        else:
            placeholder = Image.new("RGB", self.PREVIEW_SIZE, (230,230,230))
            try:
                draw = ImageDraw.Draw(placeholder)
                try: font = ImageFont.truetype("arial.ttf", 18)
                except IOError: font = ImageFont.load_default()
                text = "Error or no data"
                if hasattr(draw, 'textbbox'):
                    bbox = draw.textbbox((0,0), text, font=font); text_w = bbox[2]-bbox[0]; text_h = bbox[3]-bbox[1]
                else: 
                    text_w, text_h = draw.textsize(text, font=font) # type: ignore
                draw.text(((self.PREVIEW_SIZE[0]-text_w)/2, (self.PREVIEW_SIZE[1]-text_h)/2), text, fill="red", font=font)
            except Exception: pass
            self.current_qr_photoimage_preview = ImageTk.PhotoImage(placeholder)
            self.qr_image_label.config(image=self.current_qr_photoimage_preview)
            self.qr_image_label.image = self.current_qr_photoimage_preview

    def ask_color(self, color_variable_tk, title="Choose a color"):
        current_color = color_variable_tk.get()
        color_code = colorchooser.askcolor(initialcolor=current_color, title=title)
        if color_code and color_code[1]:
            color_variable_tk.set(color_code[1])
            self.update_color_swatch(color_variable_tk)
            self.generate_and_display_qr()

    def update_color_swatch(self, color_variable_tk):
        if color_variable_tk == self.front_color1_var and hasattr(self, 'front_color1_swatch'):
            self.front_color1_swatch.config(bg=self.front_color1_var.get())
        elif color_variable_tk == self.front_color2_var and hasattr(self, 'front_color2_swatch'):
            self.front_color2_swatch.config(bg=self.front_color2_var.get())
        elif color_variable_tk == self.back_color_var and hasattr(self, 'back_color_swatch'):
            self.back_color_swatch.config(bg=self.back_color_var.get())

    def browse_logo(self):
        filepath = filedialog.askopenfilename(
            title="Select a logo",
            filetypes=(("PNG Images", "*.png"), ("JPG Images", "*.jpg;*.jpeg"), ("All files", "*.*"))
        )
        if filepath:
            self.logo_path_var.set(filepath)
            self.logo_display_name_var.set(os.path.basename(filepath))
            # self.punch_hole_var.set(True) # No longer needed here, _update_punch_hole_check_state handles it
            self._update_punch_hole_check_state() # Update checkbox state
            self.generate_and_display_qr()
    
    def clear_logo(self):
        self.logo_path_var.set(self.DEFAULT_LOGO_PATH)
        self.logo_display_name_var.set(self.DEFAULT_LOGO_DISPLAY_NAME)
        # self.punch_hole_var.set(self.DEFAULT_PUNCH_HOLE) # Optionally reset to default. Let _update handle it.
        self._update_punch_hole_check_state() # Update checkbox state
        self.generate_and_display_qr()

    def save_qr(self):
        if self.current_qr_image_pil:
            data_slug = "".join(filter(str.isalnum, self.qr_data_var.get()[:20])) or "qrcode"
            initial_file = f"{data_slug}.png"
            filepath = filedialog.asksaveasfilename(
                initialfile=initial_file,
                defaultextension=".png",
                filetypes=(("PNG Image", "*.png"), ("JPG Image", "*.jpg"), ("SVG Image", "*.svg")),
                title="Save QR Code"
            )
            if filepath:
                try:
                    if filepath.lower().endswith(".svg"):
                        qr_svg = qrcode.QRCode(
                            version=None,
                            error_correction=self.ERROR_CORRECTION_MAP[self.error_correction_var.get()],
                            box_size=self.box_size_var.get(),
                            border=self.border_var.get(),
                        )
                        qr_svg.add_data(self.qr_data_var.get())
                        qr_svg.make(fit=True)
                        img_svg = qr_svg.make_image(image_factory=qrcode.image.svg.SvgFragmentImage) 
                        img_svg.save(filepath)
                        messagebox.showinfo("Success", f"SVG QR Code saved: {filepath}\n(Note: Advanced styles and logo are not included in SVG for now)")
                    else:
                        img_to_save = self.current_qr_image_pil.copy()
                        if img_to_save.width > self.MAX_SAVE_SIZE_RASTER[0] or \
                           img_to_save.height > self.MAX_SAVE_SIZE_RASTER[1]:
                            img_to_save.thumbnail(self.MAX_SAVE_SIZE_RASTER, Image.Resampling.LANCZOS)
                            messagebox.showinfo("Resized", f"The image was resized to {img_to_save.width}x{img_to_save.height} to not exceed {self.MAX_SAVE_SIZE_RASTER[0]}x{self.MAX_SAVE_SIZE_RASTER[1]}px.")
                        img_to_save.save(filepath)
                        messagebox.showinfo("Success", f"QR Code saved: {filepath}")
                except Exception as e:
                    messagebox.showerror("Save Error", f"Could not save: {str(e)}")
        else:
            messagebox.showwarning("Attention", "No QR Code to save. Generate one first.")

    def update_color_mask_options(self, event=None):
        selected_mask_name = self.color_mask_type_var.get()
        is_solid_mask = self.COLOR_MASKS_TYPES.get(selected_mask_name) == "SolidFillColorMask"
        
        if hasattr(self, 'front_color2_button'):
            if is_solid_mask:
                self.front_color2_button.config(state=tk.DISABLED)
                if hasattr(self, 'front_color2_swatch'): self.front_color2_swatch.config(bg="grey")
            else:
                self.front_color2_button.config(state=tk.NORMAL)
                if hasattr(self, 'front_color2_swatch'): self.front_color2_swatch.config(bg=self.front_color2_var.get())
        
        if event:
            self.generate_and_display_qr()

    def _update_slider_label(self, value_str_or_float, label_widget):
        try:
            val = float(value_str_or_float)
            if label_widget:
                label_widget.config(text=f"{val*100:.0f}%")
        except (ValueError, AttributeError):
             if label_widget:
                label_widget.config(text="---")

    def setup_ui(self):
        main_frame = ttk.Frame(self.root, padding="10")
        main_frame.pack(fill=tk.BOTH, expand=True)

        controls_frame = ttk.LabelFrame(main_frame, text="QR Code Settings", padding="10")
        controls_frame.grid(row=0, column=0, padx=10, pady=10, sticky="nswe")
        
        preview_frame = ttk.LabelFrame(main_frame, text="Preview & Save", padding="10")
        preview_frame.grid(row=0, column=1, padx=10, pady=10, sticky="nswe")

        main_frame.columnconfigure(1, weight=1)
        main_frame.rowconfigure(0, weight=1)

        current_row = 0
        
        ttk.Label(controls_frame, text="Data (URL/Text):").grid(row=current_row, column=0, sticky="w", pady=2)
        data_entry = ttk.Entry(controls_frame, textvariable=self.qr_data_var, width=35)
        data_entry.grid(row=current_row, column=1, columnspan=3, sticky="ew", pady=2)
        data_entry.bind("<KeyRelease>", self.generate_and_display_qr)
        current_row += 1

        ttk.Label(controls_frame, text="Error Correction:").grid(row=current_row, column=0, sticky="w", pady=2)
        error_combo = ttk.Combobox(controls_frame, textvariable=self.error_correction_var,
                                   values=list(self.ERROR_CORRECTION_MAP.keys()), state="readonly")
        error_combo.grid(row=current_row, column=1, columnspan=3, sticky="ew", pady=2)
        error_combo.bind("<<ComboboxSelected>>", self.generate_and_display_qr)
        current_row += 1

        ttk.Label(controls_frame, text="Module Size (px):").grid(row=current_row, column=0, sticky="w", pady=2)
        box_size_spin = tk.Spinbox(controls_frame, from_=1, to=100, textvariable=self.box_size_var, command=self.generate_and_display_qr, width=7)
        box_size_spin.grid(row=current_row, column=1, sticky="w", pady=2)

        ttk.Label(controls_frame, text="Border (modules):").grid(row=current_row, column=2, sticky="w", padx=(10,0), pady=2)
        border_spin = tk.Spinbox(controls_frame, from_=0, to=20, textvariable=self.border_var, command=self.generate_and_display_qr, width=7)
        border_spin.grid(row=current_row, column=3, sticky="w", pady=2)
        current_row += 1

        ttk.Label(controls_frame, text="Color Mask Type:").grid(row=current_row, column=0, sticky="w", pady=2)
        color_mask_combo = ttk.Combobox(controls_frame, textvariable=self.color_mask_type_var,
                                        values=list(self.COLOR_MASKS_TYPES.keys()), state="readonly")
        color_mask_combo.grid(row=current_row, column=1, columnspan=3, sticky="ew", pady=2)
        color_mask_combo.bind("<<ComboboxSelected>>", self.update_color_mask_options)
        current_row += 1

        def create_color_picker(parent, label_text, color_var, swatch_attr_name, row_num):
            ttk.Label(parent, text=label_text).grid(row=row_num, column=0, sticky="w", pady=2)
            picker_frame = ttk.Frame(parent)
            picker_frame.grid(row=row_num, column=1, columnspan=3, sticky="ew", pady=2)
            button = ttk.Button(picker_frame, text="Choose...", command=lambda: self.ask_color(color_var, f"Choose {label_text.lower().replace(':', '')}"))
            button.pack(side=tk.LEFT, fill=tk.X, expand=True)
            swatch = tk.Canvas(picker_frame, width=25, height=20, bg=color_var.get(), relief="sunken", borderwidth=1)
            swatch.pack(side=tk.LEFT, padx=(5,0))
            setattr(self, swatch_attr_name, swatch)
            return button

        self.front_color1_button = create_color_picker(controls_frame, "Front Color 1:", self.front_color1_var, "front_color1_swatch", current_row)
        current_row += 1
        self.front_color2_button = create_color_picker(controls_frame, "Front Color 2 (Gradient):", self.front_color2_var, "front_color2_swatch", current_row)
        current_row += 1
        self.back_color_button = create_color_picker(controls_frame, "Background Color:", self.back_color_var, "back_color_swatch", current_row)
        current_row += 1

        ttk.Label(controls_frame, text="Module Style:").grid(row=current_row, column=0, sticky="w", pady=2)
        module_drawer_combo = ttk.Combobox(controls_frame, textvariable=self.module_drawer_var,
                                           values=list(self.MODULE_DRAWERS.keys()), state="readonly")
        module_drawer_combo.grid(row=current_row, column=1, columnspan=3, sticky="ew", pady=2)
        module_drawer_combo.bind("<<ComboboxSelected>>", self.generate_and_display_qr)
        current_row += 1
        
        ttk.Label(controls_frame, text="Eye Style:").grid(row=current_row, column=0, sticky="w", pady=2)
        eye_drawer_values = ["Same as modules"] + list(self.MODULE_DRAWERS.keys())
        eye_drawer_combo = ttk.Combobox(controls_frame, textvariable=self.eye_drawer_var,
                                        values=eye_drawer_values, state="readonly")
        eye_drawer_combo.grid(row=current_row, column=1, columnspan=3, sticky="ew", pady=2)
        eye_drawer_combo.bind("<<ComboboxSelected>>", self.generate_and_display_qr)
        current_row += 1

        # Store the checkbutton to manage its state
        self.punch_hole_check = ttk.Checkbutton(controls_frame, text="Punch a hole in the center", 
                                                variable=self.punch_hole_var, 
                                                command=self.generate_and_display_qr)
        self.punch_hole_check.grid(row=current_row, column=0, columnspan=2, sticky="w", pady=(5,2))
        current_row += 1

        ttk.Label(controls_frame, text="Logo (Optional):").grid(row=current_row, column=0, sticky="w", pady=(5,2))
        logo_buttons_frame = ttk.Frame(controls_frame)
        logo_buttons_frame.grid(row=current_row, column=1, columnspan=3, sticky="ew")
        ttk.Button(logo_buttons_frame, text="Browse...", command=self.browse_logo).pack(side=tk.LEFT, padx=(0,5))
        ttk.Button(logo_buttons_frame, text="Remove", command=self.clear_logo).pack(side=tk.LEFT)
        current_row += 1
        
        ttk.Label(controls_frame, textvariable=self.logo_display_name_var, wraplength=250, font=("Segoe UI", 8)).grid(row=current_row, column=1, columnspan=3, sticky="w", pady=2)
        current_row += 1

        ttk.Label(controls_frame, text="Hole Size (%):").grid(row=current_row, column=0, sticky="w", pady=2)
        self.hole_size_scale = ttk.Scale(controls_frame, from_=0.01, to=self.MAX_HOLE_SIZE_FACTOR, orient="horizontal", variable=self.hole_size_factor_var, command=self.generate_and_display_qr_throttled)
        self.hole_size_scale.grid(row=current_row, column=1, columnspan=2, sticky="ew", pady=2)
        self.hole_size_val_label = ttk.Label(controls_frame, text="", width=5)
        self.hole_size_val_label.grid(row=current_row, column=3, sticky="w", pady=2)
        self.hole_size_factor_var.trace_add("write", lambda n,i,m,lw=self.hole_size_val_label: self._update_slider_label(self.hole_size_factor_var.get(), lw))
        self._update_slider_label(self.hole_size_factor_var.get(), self.hole_size_val_label)
        current_row += 1

        reset_button = ttk.Button(controls_frame, text="Reset Settings", command=self.reset_settings)
        reset_button.grid(row=current_row, column=0, columnspan=4, sticky="ew", pady=(15,5))
        current_row += 1

        initial_placeholder_pil = Image.new('RGB', self.PREVIEW_SIZE, (230, 230, 230))
        try:
            draw = ImageDraw.Draw(initial_placeholder_pil)
            try: font = ImageFont.truetype("arial.ttf", 24)
            except IOError: font = ImageFont.load_default()
            text = f"QR Preview ({self.PREVIEW_SIZE[0]}x{self.PREVIEW_SIZE[1]})"
            if hasattr(draw, 'textbbox'):
                bbox = draw.textbbox((0,0), text, font=font); text_w = bbox[2]-bbox[0]; text_h = bbox[3]-bbox[1]
            else: 
                text_w, text_h = draw.textsize(text, font=font) # type: ignore
            draw.text(((self.PREVIEW_SIZE[0]-text_w)/2, (self.PREVIEW_SIZE[1]-text_h)/2), text, fill=(100,100,100), font=font)
        except Exception as e: print(f"Error creating placeholder: {e}")
        self.initial_placeholder_photo = ImageTk.PhotoImage(initial_placeholder_pil)

        self.qr_image_label = ttk.Label(preview_frame, image=self.initial_placeholder_photo, anchor="center", relief="sunken")
        self.qr_image_label.image = self.initial_placeholder_photo
        self.qr_image_label.pack(padx=5, pady=5, expand=True, fill=tk.BOTH, anchor="center")
        
        save_button = ttk.Button(preview_frame, text="Save QR Code", command=self.save_qr)
        save_button.pack(pady=10, fill=tk.X, padx=5)
        
        controls_frame.columnconfigure(1, weight=1)
        controls_frame.columnconfigure(3, weight=0)

        self._after_id_scale = None

    def generate_and_display_qr_throttled(self, event_or_value=None):
        if self._after_id_scale:
            self.root.after_cancel(self._after_id_scale)
        self._after_id_scale = self.root.after(150, self.generate_and_display_qr)

if __name__ == "__main__":
    root = tk.Tk()
    try:
        style = ttk.Style(root)
        available_themes = style.theme_names()
        if 'clam' in available_themes: style.theme_use('clam')
        elif 'vista' in available_themes and os.name == 'nt': style.theme_use('vista')
    except Exception as e: print(f"Error setting theme: {e}")

    app = QRCodeApp(root)
    root.mainloop()