pdflinkcheck 1.1.73__py3-none-any.whl → 1.2.29__py3-none-any.whl

pdflinkcheck/gui.py

@@ -1,26 +1,24 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: MIT
 # src/pdflinkcheck/gui.py
+from __future__ import annotations
 import tkinter as tk
-from tkinter import filedialog, ttk, messagebox # Added messagebox
+from tkinter import filedialog, ttk, messagebox, PhotoImage
 import sys
 from pathlib import Path
-from typing import Optional # Added Optional
+from typing import Optional
 import unicodedata
 from importlib.resources import files
 import pyhabitat
-"""
-try:
-    import sv_ttk
-    # Apply Sun Valley Tk theme
-    sv_ttk.set_theme("light")
-except Exception:
-    # Theme not available in bundle — use default
-    pass
-"""
-# Import the core analysis function
-from pdflinkcheck.report import run_report
-from pdflinkcheck.validate import run_validation 
+import ctypes
+import threading
+
+# --- Core Imports ---
+from pdflinkcheck.report import run_report_and_call_exports
 from pdflinkcheck.version_info import get_version_from_pyproject
 from pdflinkcheck.io import get_first_pdf_in_cwd, get_friendly_path, PDFLINKCHECK_HOME
+from pdflinkcheck.environment import pymupdf_is_available, pdfium_is_available, clear_all_caches, is_in_git_repo
+from pdflinkcheck.tk_utils import center_window_on_primary
 
 class RedirectText:
     """A class to redirect sys.stdout messages to a Tkinter Text widget."""
@@ -28,319 +26,204 @@ class RedirectText:
         self.text_widget = text_widget
 
     def write(self, string):
-        """Insert the incoming string into the Text widget."""
         self.text_widget.insert(tk.END, string)
-        self.text_widget.see(tk.END) # Scroll to the end
-        self.text_widget.update_idletasks() # Refresh GUI to allow real timie updates << If suppress: The mainloop will handle updates efficiently without forcing them, , but info appears outdated when a new file is analyzed. Immediate feedback is better.
+        self.text_widget.see(tk.END)
+        self.text_widget.update_idletasks()
 
     def flush(self, *args):
-        """Required for file-like objects, but does nothing here."""
         pass
 
-class PDFLinkCheckerApp(tk.Tk):
-    def __init__(self):
-        super().__init__()
-        self.title(f"PDF Link Check v{get_version_from_pyproject()}")
-        self.geometry("800x600")
-        
-        # Style for the application
-        style = ttk.Style(self)
-        style.theme_use('clam')
-        
-        # --- 1. Initialize Variables ---
+class PDFLinkCheckApp:
+
+    # --- Lifecycle & Initialization ---
+
+    def __init__(self, root: tk.Tk):
+        self.root = root
+
+        # Do NOT load theme yet. 
+        # Run the "heavy" initialization first
+        self._initialize_vars()
+
+        # NOW load the theme (this takes ~100-300ms)
+        self._initialize_forest_theme()
+
+        # Apply the theme
+        style = ttk.Style()
+        style.configure(".", padding=2)                # global min padding
+        style.configure("TFrame", padding=2)
+        style.configure("TLabelFrame", padding=(4,2))
+        style.configure("TButton", padding=4)
+        style.configure("TCheckbutton", padding=2)
+        style.configure("TRadiobutton", padding=2)
+        style.theme_use("forest-dark")
+
+        self.root.title(f"PDF Link Check v{get_version_from_pyproject()}")  # Short title
+        self.root.geometry("700x500")  # Smaller starting size
+        self.root.minsize(600, 400)    # Prevent too-small window
+
+        self._set_icon()
+
+        # --- 2. Widget Construction ---
+        self._create_widgets()
+        self._initialize_menubar()
+
+    def _initialize_vars(self):
+        """Logic that takes time but doesn't need a UI yet."""
+
+        # --- 1. Variable State Management ---
         self.pdf_path = tk.StringVar(value="")
-        self.pdf_library_var = tk.StringVar(value="PyMuPDF")
-        #self.pdf_library_var.set("PyMuPDF")
-        self.max_links_var = tk.StringVar(value="50")
-        self.show_all_links_var = tk.BooleanVar(value=True)  
-        self.do_export_report_json_var = tk.BooleanVar(value=True) 
-        self.do_export_report_txt_var = tk.BooleanVar(value=False) 
+        self.pdf_library_var = tk.StringVar(value="pymupdf")
+        self.do_export_report_json_var = tk.BooleanVar(value=True)
+        self.do_export_report_txt_var = tk.BooleanVar(value=True)
         self.current_report_text = None
         self.current_report_data = None
 
-        self.supported_export_formats = ["JSON", "MD", "TXT"]
-        self.supported_export_formats = ["JSON"]
-        
-        
-        # --- 2. Create Widgets ---
-        self._create_widgets()
-        
-        # --- 3. Set Initial Dependent Widget States ---
-        self._toggle_max_links_entry() 
-        self._toggle_json_export()
-        self._toggle_txt_export()
-        
-    # In class PDFLinkCheckerApp:
+        # Track exported file paths
+        self.last_json_path: Optional[Path] = None
+        self.last_txt_path: Optional[Path] = None
+
+        # Engine detection (This can take a few ms)
+        self.pdf_library_var = tk.StringVar(value="PDFium")
+        if not pdfium_is_available():
+            self.pdf_library_var.set("PyMuPDF")
+        if not pymupdf_is_available():
+            self.pdf_library_var.set("pypdf")
 
-    def _copy_pdf_path(self):
-        """Copies the current PDF path from the Entry widget to the system clipboard."""
-        path_to_copy = self.pdf_path.get()
-        
-        if path_to_copy:
-            try:
-                # Clear the clipboard
-                self.clipboard_clear()
-                # Append the path string to the clipboard
-                self.clipboard_append(path_to_copy)
-                # Notify the user (optional, but good UX)
-                messagebox.showinfo("Copied", "PDF Path copied to clipboard.")
-            except tk.TclError as e:
-                # Handle cases where clipboard access might be blocked
-                messagebox.showerror("Copy Error", f"Failed to access the system clipboard: {e}")
-        else:
-            messagebox.showwarning("Copy Failed", "The PDF Path field is empty.")
     
-    def _scroll_to_top(self):
-        """Scrolls the output text widget to the top."""
-        self.output_text.see('1.0') # '1.0' is the index for the very first character
+    # --- Theme & Visual Initialization ---
+    def _initialize_forest_theme(self):
+        theme_dir = files("pdflinkcheck.data.themes.forest")
+        self.root.tk.call("source", str(theme_dir / "forest-light.tcl"))
+        self.root.tk.call("source", str(theme_dir / "forest-dark.tcl"))
+
+    def _toggle_theme(self):
+        style = ttk.Style(self.root) # Explicitly link style to our root
+        if style.theme_use() == "forest-light":
+            style.theme_use("forest-dark")
+        elif style.theme_use() == "forest-dark":
+            style.theme_use("forest-light")
+
+    def _set_icon(self):
+        icon_dir = files("pdflinkcheck.data.icons")
+        try:
+            png_path = icon_dir.joinpath("Logo-150x150.png")
+            if png_path.exists():
+                self.icon_img = PhotoImage(file=str(png_path))
+                self.root.iconphoto(True, self.icon_img)
+        except Exception:
+            pass
+        try:
+            icon_path = icon_dir.joinpath("red_pdf_512px.ico")
+            if icon_path.exists():
+                self.root.iconbitmap(str(icon_path))
+        except Exception:
+            pass
 
-    def _scroll_to_bottom(self):
-        """Scrolls the output text widget to the bottom."""
-        self.output_text.see(tk.END) # tk.END is the index for the position just after the last character
 
-    def _show_license(self):
-        """
-        Reads the embedded LICENSE file (AGPLv3) and displays its content in a new modal window.
-        """
-        try:
-            # CORRECT WAY: Use the Traversable object's read_text() method.
-            # This handles files located inside zip archives (.pyz, pipx venvs) correctly.
-            license_path_traversable = files("pdflinkcheck.data") / "LICENSE"
-            license_content = license_path_traversable.read_text(encoding="utf-8")
-            
-        except FileNotFoundError:
-            messagebox.showerror(
-                "License Error", 
-                "LICENSE file not found within the installation package (pdflinkcheck.data/LICENSE). Check build process."
-            )
-            return
-        except Exception as e:
-            messagebox.showerror("Read Error", f"Failed to read embedded LICENSE file: {e}")
-            return
+    def _initialize_menubar(self):
+        """Builds the application menu bar."""
+        menubar = tk.Menu(self.root)
+        self.root.config(menu=menubar)
 
-        # --- Display in a New Toplevel Window ---
-        license_window = tk.Toplevel(self)
-        license_window.title("Software License")
-        license_window.geometry("600x400")
-        
-        # Text widget for content
-        text_widget = tk.Text(license_window, wrap=tk.WORD, font=('Monospace', 10), padx=10, pady=10)
-        text_widget.insert(tk.END, license_content)
-        text_widget.config(state=tk.DISABLED)
-        
-        # Scrollbar
-        scrollbar = ttk.Scrollbar(license_window, command=text_widget.yview)
-        text_widget['yscrollcommand'] = scrollbar.set
-        
-        # Layout
-        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
-        text_widget.pack(fill='both', expand=True)
-        
-        # Make the window modal (optional, but good practice for notices)
-        license_window.transient(self)
-        license_window.grab_set()
-        self.wait_window(license_window)
+        tools_menu = tk.Menu(menubar, tearoff=0)
+        menubar.add_cascade(label="Tools", menu=tools_menu)
 
-    def _show_readme(self):
-        """
-        Reads the embedded README.md file and displays its content in a new modal window.
-        """
-        try:
-            # CORRECT WAY: Use the Traversable object's read_text() method.
-            # This handles files located inside zip archives (.pyz, pipx venvs) correctly.
-            readme_path_traversable = files("pdflinkcheck.data") / "README.md"
-            readme_content = readme_path_traversable.read_text(encoding="utf-8")
-            readme_content = sanitize_glyphs_for_tkinter(readme_content)
-            
-        except FileNotFoundError:
-            messagebox.showerror(
-                "Readme Error", 
-                "README.md file not found within the installation package (pdflinkcheck.data/README.md). Check build process."
-            )
-            return
-        except Exception as e:
-            messagebox.showerror("Read Error", f"Failed to read embedded README.md file: {e}")
-            return
+        tools_menu.add_command(label="Toggle Theme", command=self._toggle_theme)
+        tools_menu.add_command(label="Clear Output Window", command=self._clear_output_window)
+        tools_menu.add_command(label="Copy Output to Clipboard", command=self._copy_output_to_clipboard)
+        tools_menu.add_command(label="Clear Cache", command=self._clear_all_caches)
 
-        # --- Display in a New Toplevel Window ---
-        readme_window = tk.Toplevel(self)
-        readme_window.title("pdflinkcheck README.md")
-        readme_window.geometry("600x400")
-        
-        # Text widget for content
-        text_widget = tk.Text(readme_window, wrap=tk.WORD, font=('Monospace', 10), padx=10, pady=10)
-        text_widget.insert(tk.END, readme_content)
-        text_widget.config(state=tk.DISABLED)
-        
-        # Scrollbar
-        scrollbar = ttk.Scrollbar(readme_window, command=text_widget.yview)
-        text_widget['yscrollcommand'] = scrollbar.set
-        
-        # Layout
-        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
-        text_widget.pack(fill='both', expand=True)
-        
-        # Make the window modal (optional, but good practice for notices)
-        readme_window.transient(self)
-        readme_window.grab_set()
-        self.wait_window(readme_window)
+        tools_menu.add_separator()
+        tools_menu.add_command(label="License", command=self._show_license)
+        tools_menu.add_command(label="Readme", command=self._show_readme)
+        tools_menu.add_command(label="I Have Questions", command=self._show_i_have_questions)
+
+    # --- UI Component Building ---
 
     def _create_widgets(self):
-        # --- Control Frame (Top) ---
-        control_frame = ttk.Frame(self, padding="10")
-        control_frame.pack(fill='x')
+        """Compact layout with reduced padding."""
 
-        # Row 0: File Selection
+        # --- Control Frame (Top) ---
+        control_frame = ttk.Frame(self.root, padding=(4, 2, 4, 2))
+        control_frame.pack(fill='x', pady=(2, 2))
 
-        # === File Selection Frame (Row 0) ===
+        # === Row 0: File Selection ===
         file_selection_frame = ttk.Frame(control_frame)
-        file_selection_frame.grid(row=0, column=0, columnspan=3, padx=0, pady=5, sticky='ew')
-        
-        # Elements are now packed/gridded within file_selection_frame
-        
-        # Label
-        ttk.Label(file_selection_frame, text="PDF Path:").pack(side=tk.LEFT, padx=(0, 5))
-        
-        # Entry (Path Display)
-        ttk.Entry(file_selection_frame, textvariable=self.pdf_path, width=50).pack(side=tk.LEFT, fill='x', expand=True, padx=5)
-        # The Entry field (column 1) must expand horizontally within its frame
-        # Since we are using PACK for this frame, we use fill='x', expand=True on the Entry.
-        
-        # Browse Button
-        ttk.Button(file_selection_frame, text="Browse...", command=self._select_pdf).pack(side=tk.LEFT, padx=(5, 5))
+        file_selection_frame.grid(row=0, column=0, columnspan=3, padx=0, pady=(2, 4), sticky='ew')
 
-        # Copy Button
-        # NOTE: Removed leading spaces from " Copy Path"
-        ttk.Button(file_selection_frame, text="Copy Path", command=self._copy_pdf_path).pack(side=tk.LEFT, padx=(0, 0))
-        
-        # === END: File Selection Frame ===
-
-        # --- Report brevity options ----
-        report_brevity_frame = ttk.LabelFrame(control_frame, text="Report Brevity Options:")
-        #report_brevity_frame.grid(row=1, column=0, columnspan=2, padx=5, pady=1, sticky='nsew')
-        report_brevity_frame.grid(row=1, column=0, padx=5, pady=5, sticky='nsew')
-        #
-        ttk.Checkbutton(
-            report_brevity_frame, 
-            text="Show All Links.", 
-            variable=self.show_all_links_var,
-            command=self._toggle_max_links_entry
-        ).pack(side='left', padx=5, pady=1)
-
-        ttk.Label(report_brevity_frame, text="Max Links to Display:").pack(side='left', padx=5, pady=1)
-        self.max_links_entry = ttk.Entry(report_brevity_frame, textvariable=self.max_links_var, width=4)
-        self.max_links_entry.pack(side='left', padx=5, pady=5)
-
-        # --- PDF Library Selection ---
-        # Create a labeled group for the PDF options
-        pdf_library_frame = ttk.LabelFrame(control_frame, text="Select PDF Library:")
-        pdf_library_frame.grid(row=1, column=1, padx=5, pady=5, sticky='nsew')
-
-        # Radio options inside the frame
-        ttk.Radiobutton(
-            pdf_library_frame,
-            text="PyMuPDF",
-            variable=self.pdf_library_var,
-            value="PyMuPDF",
-            
-        ).pack(side='left', padx=5, pady=1)   
-
-        ttk.Radiobutton(
-            pdf_library_frame,
-            text="pypdf",
-            variable=self.pdf_library_var,
-            value="pypdf",
-        ).pack(side='left', padx=5, pady=1)
-
-        export_group_frame = ttk.LabelFrame(control_frame, text="Export Format:")
-        #export_group_frame = ttk.LabelFrame(control_frame, text = "Export Filetype Selection:")
-        export_group_frame.grid(row=1, column=2, padx=5, pady=5, sticky='nseew') # Placed in the original Checkbutton's column
-        
-        ttk.Checkbutton(
-            export_group_frame, 
-            #text="Export Report",
-            text = "JSON" ,
-            variable=self.do_export_report_json_var
-        ).pack(side=tk.LEFT, padx=(0, 5)) # Pack Checkbutton to the left with small internal padding
-        ttk.Checkbutton(
-            export_group_frame, 
-            text = "TXT" ,
-            #state=tk.DISABLED,
-            variable=self.do_export_report_txt_var,
-        ).pack(side=tk.LEFT, padx=(0, 5)) # Pack Checkbutton to the left with small internal padding
-        
-        # Row 3: Run Button, Export Filetype selection, License Button, and readme button
-        # 1. Run Button (Spans columns 0 and 1)
-        run_analysis_btn = ttk.Button(control_frame, text="▶ Run Analysis", command=self._run_report_gui, style='Accent.TButton')
-        run_analysis_btn.grid(row=3, column=0, columnspan=2, pady=10, sticky='ew', padx=(0, 5))
-
-        run_validation_btn = ttk.Button(control_frame, text="▶ Run Validation", command=self._run_validation_gui, style='Accent.TButton')
-        run_validation_btn.grid(row=4, column=0, columnspan=2, pady=10, sticky='ew', padx=(0, 5))
-        # Ensure the run button frame expands to fill its column
-        #run_analysis_btn.grid_columnconfigure(0, weight=1)
-
-        # 2. Create a Frame to hold the two file link buttons (This frame goes into column 2)
-        info_btn_frame = ttk.Frame(control_frame)
-        info_btn_frame.grid(row=3, column=2, columnspan=1, pady=10, sticky='ew', padx=(5, 0))
-        # Ensure the info button frame expands to fill its column
-        info_btn_frame.grid_columnconfigure(0, weight=1)
-        info_btn_frame.grid_columnconfigure(1, weight=1)
-
-        # 3. Place License and Readme buttons inside the new frame
-        license_btn = ttk.Button(info_btn_frame, text="License", command=self._show_license)
-        # Use PACK or a 2-column GRID inside the info_btn_frame. GRID is cleaner here.
-        license_btn.grid(row=0, column=0, sticky='ew', padx=(0, 2)) # Left side of the frame
-
-        readme_btn = ttk.Button(info_btn_frame, text="Readme", command=self._show_readme)
-        readme_btn.grid(row=0, column=1, sticky='ew', padx=(2, 0)) # Right side of the frame
-
-        # Force the columns to distribute space evenly
-        control_frame.grid_columnconfigure(0, weight=2)
+        ttk.Label(file_selection_frame, text="PDF Path:").pack(side=tk.LEFT, padx=(0, 3))
+        entry = ttk.Entry(file_selection_frame, textvariable=self.pdf_path)
+        entry.pack(side=tk.LEFT, fill='x', expand=True, padx=3)
+        ttk.Button(file_selection_frame, text="Browse...", command=self._select_pdf, width=10).pack(side=tk.LEFT, padx=(3, 3))
+        ttk.Button(file_selection_frame, text="Copy Path", command=self._copy_pdf_path, width=10).pack(side=tk.LEFT, padx=(0, 0))
+
+        # === Row 1: Configuration & Export Jumps ===
+        pdf_library_frame = ttk.LabelFrame(control_frame, text="Backend Engine:")
+        pdf_library_frame.grid(row=1, column=0, padx=3, pady=3, sticky='nsew')
+
+        if pdfium_is_available():
+            ttk.Radiobutton(pdf_library_frame, text="PDFium", variable=self.pdf_library_var, value="PDFium").pack(side='left', padx=5, pady=1) 
+        if pymupdf_is_available():
+            ttk.Radiobutton(pdf_library_frame, text="PyMuPDF", variable=self.pdf_library_var, value="PyMuPDF").pack(side='left', padx=3, pady=1)
+        ttk.Radiobutton(pdf_library_frame, text="pypdf", variable=self.pdf_library_var, value="pypdf").pack(side='left', padx=3, pady=1)
+
+        export_config_frame = ttk.LabelFrame(control_frame, text="Export Enabled:")
+        export_config_frame.grid(row=1, column=1, padx=3, pady=3, sticky='nsew')
+
+        ttk.Checkbutton(export_config_frame, text="JSON", variable=self.do_export_report_json_var).pack(side=tk.LEFT, padx=4)
+        ttk.Checkbutton(export_config_frame, text="TXT", variable=self.do_export_report_txt_var).pack(side=tk.LEFT, padx=4)
+
+        self.export_actions_frame = ttk.LabelFrame(control_frame, text="Open Report Files:")
+        self.export_actions_frame.grid(row=1, column=2, padx=3, pady=3, sticky='nsew')
+
+        self.btn_open_json = ttk.Button(self.export_actions_frame, text="Open JSON", command=lambda: self._open_export_file("json"), width=10)
+        self.btn_open_json.pack(side=tk.LEFT, padx=3, pady=1)
+
+        self.btn_open_txt = ttk.Button(self.export_actions_frame, text="Open TXT", command=lambda: self._open_export_file("txt"), width=10)
+        self.btn_open_txt.pack(side=tk.LEFT, padx=3, pady=1)
+
+        # === Row 3: Action Buttons ===
+        run_analysis_btn = ttk.Button(control_frame, text="▶ Run Analysis", command=self._run_report_gui, style='Accent.TButton', width=16)
+        run_analysis_btn.grid(row=3, column=0, columnspan=2, pady=6, sticky='ew', padx=(0, 3))
+
+        clear_window_btn = ttk.Button(control_frame, text="Clear Output Window", command=self._clear_output_window, width=18)
+        clear_window_btn.grid(row=3, column=2, pady=6, sticky='ew', padx=3)
+
+        # Grid configuration
+        control_frame.grid_columnconfigure(0, weight=1)
         control_frame.grid_columnconfigure(1, weight=1)
         control_frame.grid_columnconfigure(2, weight=1)
 
         # --- Output Frame (Bottom) ---
-        output_frame = ttk.Frame(self, padding=(10, 2, 10, 10)) # Left, Top, Right, Bottom
+        output_frame = ttk.Frame(self.root, padding=(4, 2, 4, 4))
         output_frame.pack(fill='both', expand=True)
 
         output_header_frame = ttk.Frame(output_frame)
-        output_header_frame.pack(fill='x', pady=(0, 5))
-        
-        # Label
-        ttk.Label(output_header_frame, text="Analysis Report Output:").pack(side=tk.LEFT, fill='x', expand=True)
+        output_header_frame.pack(fill='x', pady=(0, 1))
 
-        # Scroll to Bottom Button # put this first so that it on the right when the Top button is added on the left.
-        bottom_btn = ttk.Button(output_header_frame, text="▼ Bottom", command=self._scroll_to_bottom, width=8)
-        bottom_btn.pack(side=tk.RIGHT, padx=(0, 5)) 
+        ttk.Label(output_header_frame, text="Analysis Report Logs:").pack(side=tk.LEFT, fill='x', expand=True)
 
-        # Scroll to Top Button
-        top_btn = ttk.Button(output_header_frame, text="▲ Top", command=self._scroll_to_top, width=6)
-        top_btn.pack(side=tk.RIGHT, padx=(5, 5))
+        ttk.Button(output_header_frame, text="▼ Bottom", command=self._scroll_to_bottom, width=10).pack(side=tk.RIGHT, padx=(0, 2))
+        ttk.Button(output_header_frame, text="▲ Top", command=self._scroll_to_top, width=6).pack(side=tk.RIGHT, padx=2)
 
-        # Open Report Button
-        self.open_report_btn = ttk.Button(output_header_frame, text="Open Report", command=self._open_report_text)
-        self.open_report_btn.pack(side=tk.RIGHT, padx=(5, 5))
-        
-        
-        # ----------------------------------------------------
-        
-        
-        # Scrollable Text Widget for output
-        # Use an internal frame for text and scrollbar to ensure correct packing
+        # Scrollable Text Area
         text_scroll_frame = ttk.Frame(output_frame)
-        text_scroll_frame.pack(fill='both', expand=True, padx=5, pady=5)
-        
-        self.output_text = tk.Text(text_scroll_frame, wrap=tk.WORD, state=tk.DISABLED, bg='#333333', fg='white', font=('Monospace', 10))
-        self.output_text.pack(side=tk.LEFT, fill='both', expand=True) # Text fills and expands
+        text_scroll_frame.pack(fill='both', expand=True, padx=3, pady=3)
+
+        self.output_text = tk.Text(text_scroll_frame, wrap=tk.WORD, state=tk.DISABLED, bg='#2b2b2b', fg='#ffffff', font=('Monospace', 10))
+        self.output_text.pack(side=tk.LEFT, fill='both', expand=True)
 
-        # Scrollbar (Scrollbar must be packed AFTER the text widget)
         scrollbar = ttk.Scrollbar(text_scroll_frame, command=self.output_text.yview)
         scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
-        self.output_text['yscrollcommand'] = scrollbar.set # Link text widget back to scrollbar
+        self.output_text['yscrollcommand'] = scrollbar.set
+
+    # --- Event Handlers & Business Logic ---
 
     def _select_pdf(self):
         if self.pdf_path.get():
             initialdir = str(Path(self.pdf_path.get()).parent)
+        elif pyhabitat.is_msix():
+            initialdir = str(Path.home())
         else:
             initialdir = str(Path.cwd())
 
@@ -352,238 +235,264 @@ class PDFLinkCheckerApp(tk.Tk):
         if file_path:
             self.pdf_path.set(get_friendly_path(file_path))
 
-
-    def _toggle_max_links_entry(self):
-        """Disables/enables the max_links entry based on show_all_links_var."""
-        if self.show_all_links_var.get():
-            self.max_links_entry.config(state=tk.DISABLED)
+    def _copy_pdf_path(self):
+        path_to_copy = self.pdf_path.get()
+        if path_to_copy:
+            try:
+                self.root.clipboard_clear()
+                self.root.clipboard_append(path_to_copy)
+                messagebox.showinfo("Copied", "PDF Path copied to clipboard.")
+            except tk.TclError as e:
+                messagebox.showerror("Copy Error", f"Clipboard access blocked: {e}")
         else:
-            self.max_links_entry.config(state=tk.NORMAL)
-    
-    def _toggle_json_export(self):
-        """Checkbox toggle for json filetype report."""
-        if self.do_export_report_json_var.get():
-            pass # placeholder # no side effects
-
-    def _toggle_txt_export(self):
-        """Checkbox toggle for TXT filetype report."""
-        if self.do_export_report_txt_var.get():
-            pass # placeholder # no side effects
-    
-    def _assess_pdf_path_str(self):
-        pdf_path_str = self.pdf_path.get().strip()
-        if not pdf_path_str: 
-            pdf_path_str = get_first_pdf_in_cwd()
-            if not pdf_path_str:
-                self._display_error("Error: No PDF found in current directory.")
-                return
-
-        p = Path(pdf_path_str).expanduser().resolve()
-
-        if not p.exists():
-            self._display_error(f"Error: PDF file not found at: {p}")
-            return
-            
-        # Use the resolved string version for the rest of the function
-        pdf_path_str_assessed = str(p)
-        return pdf_path_str_assessed
+            messagebox.showwarning("Copy Failed", "PDF Path field is empty.")
 
     def _run_report_gui(self):
-        
         pdf_path_str = self._assess_pdf_path_str()
         if not pdf_path_str:
             return
 
-        if self.show_all_links_var.get():
-            max_links_to_pass = 0 
-        else:
-            try:
-                max_links_to_pass = int(self.max_links_var.get())
-                if max_links_to_pass < 1:
-                     self._display_error("Error: Max Links must be a positive number (or use 'Show All').")
-                     return
-            except ValueError:
-                self._display_error("Error: Max Links must be an integer.")
-                return
-
-        export_format = None # default value, if selection is not made (if selection is not active)
         export_format = ""
         if self.do_export_report_json_var.get():
-            export_format = export_format + "JSON"
+            export_format += "JSON"
         if self.do_export_report_txt_var.get():
-            export_format = export_format + "TXT" 
+            export_format += "TXT"
 
-        pdf_library = self._discern_pdf_library()
+        pdf_library = self.pdf_library_var.get().lower()
 
-        
-        # 1. Clear previous output and enable editing
         self.output_text.config(state=tk.NORMAL)
         self.output_text.delete('1.0', tk.END)
 
-        # 2. Redirect standard output to the Text widget
         original_stdout = sys.stdout
         sys.stdout = RedirectText(self.output_text)
-        
+
         try:
-            # 3. Call the core logic function
-            #self.output_text.insert(tk.END, "--- Starting Analysis ---\n")
-            report_results = run_report(
+            report_results = run_report_and_call_exports(
                 pdf_path=pdf_path_str,
-                max_links=max_links_to_pass,
                 export_format=export_format,
-                pdf_library = pdf_library, 
+                pdf_library=pdf_library,
             )
             self.current_report_text = report_results.get("text", "")
             self.current_report_data = report_results.get("data", {})
 
-            #self.output_text.insert(tk.END, "\n--- Analysis Complete ---\n")
+            self.last_json_path = report_results.get("files", {}).get("export_path_json")
+            self.last_txt_path = report_results.get("files", {}).get("export_path_txt")
 
         except Exception as e:
-            # Inform the user in the GUI with a clean message
-            self._display_error(f"An unexpected error occurred during analysis: {e}")
-
+            messagebox.showinfo(
+                "Engine Fallback",
+                f"Error encountered with {pdf_library}: {e}\n\nFalling back to pypdf."
+            )
+            self.pdf_library_var.set("pypdf")
         finally:
-            # 4. Restore standard output and disable editing
             sys.stdout = original_stdout
             self.output_text.config(state=tk.DISABLED)
-    
-    def _run_validation_gui(self):
-        
-        pdf_path_str = self._assess_pdf_path_str()
+
+    def _open_export_file(self, file_type: str):
+        target_path = self.last_json_path if file_type == "json" else self.last_txt_path
+
+        if target_path and Path(target_path).exists():
+            try:
+                #pyhabitat.edit_textfile(target_path)
+                threading.Thread(target=lambda: pyhabitat.edit_textfile(target_path), daemon=True).start()
+            except Exception as e:
+                messagebox.showerror("Open Error", f"Failed to open {file_type.upper()} report: {e}")
+        else:
+            messagebox.showwarning("File Not Found", f"The {file_type.upper()} report file does not exist.\n\nPlease click 'Run Analysis' to generate one.")
+
+    def _assess_pdf_path_str(self):
+        pdf_path_str = self.pdf_path.get().strip()
         if not pdf_path_str:
+            pdf_path_str = get_first_pdf_in_cwd()
+            if not pdf_path_str:
+                self._display_error("No PDF found in current directory.")
+                return
+
+        p = Path(pdf_path_str).expanduser().resolve()
+        if not p.exists():
+            self._display_error(f"PDF file not found at: {p}")
             return
 
-        pdf_library = self._discern_pdf_library()
+        return str(p)
+
+    # --- Utility Methods ---
 
-        # 1. Clear previous output and enable editing
+    def _clear_output_window(self):
         self.output_text.config(state=tk.NORMAL)
         self.output_text.delete('1.0', tk.END)
+        self.output_text.config(state=tk.DISABLED)
 
-        # 2. Redirect standard output to the Text widget
-        original_stdout = sys.stdout
-        sys.stdout = RedirectText(self.output_text)
-        
-        if not self.current_report_data:
-            self._run_report_gui()
-        report_results = self.current_report_data
-
-        try:
-            # 3. Call the core logic function
-            #self.output_text.insert(tk.END, "--- Starting Analysis ---\n")
-            validation_results = run_validation(
-                report_results=report_results,
-                pdf_path=pdf_path_str,
-                pdf_library=pdf_library,
-                export_json=True,
-                print_bool=True
-            )
-            self.current_report_text = report_results.get("text", "")
-            self.current_report_data = report_results.get("data", {})
+    def _copy_output_to_clipboard(self):
+        content = self.output_text.get('1.0', tk.END)
+        self.root.clipboard_clear()
+        self.root.clipboard_append(content)
+        messagebox.showinfo("Clipboard", "Output buffer copied to clipboard.")
 
-            #self.output_text.insert(tk.END, "\n--- Analysis Complete ---\n")
+    def _scroll_to_top(self):
+        self.output_text.see('1.0')
 
-        except Exception as e:
-            # Inform the user in the GUI with a clean message
-            self._display_error(f"An unexpected error occurred during analysis: {e}")
+    def _scroll_to_bottom(self):
+        self.output_text.see(tk.END)
 
-        finally:
-            # 4. Restore standard output and disable editing
-            sys.stdout = original_stdout
-            self.output_text.config(state=tk.DISABLED)
-        
+    def _clear_all_caches(self):
+        clear_all_caches()
+        messagebox.showinfo("Caches Cleared", f"All caches have been cleared.\nPyMuPDF available: {pymupdf_is_available()}\nPDFium available: {pdfium_is_available()}")
 
-    def _discern_pdf_library(self):
-        selected_lib = self.pdf_library_var.get().lower()
-        
-        if selected_lib == "pymupdf":
-            print("Using high-speed PyMuPDF engine.")
-        elif selected_lib == "pypdf":
-            print("Using pure-python pypdf engine.")
-        return selected_lib
-    
     def _display_error(self, message):
-        # Ensure output is in normal state to write
-        original_state = self.output_text.cget('state')
-        if original_state == tk.DISABLED:
-            self.output_text.config(state=tk.NORMAL)
-            
-        #self.output_text.delete('1.0', tk.END)
+        self.output_text.config(state=tk.NORMAL)
         self.output_text.insert(tk.END, f"[ERROR] {message}\n", 'error')
         self.output_text.tag_config('error', foreground='red')
         self.output_text.see(tk.END)
-
-        # Restore state
         self.output_text.config(state=tk.DISABLED)
 
-    def _open_report_text(self):
-        """Opens the LATEST analysis text in an editor, regardless of export settings."""
-        # 1. Check our internal buffer, not the window or the disk
-        if not self.current_report_text:
-            messagebox.showwarning("Open Failed", "No analysis data available. Please run an analysis first.")
-            return
+    # --- Modal Documentation Windows ---
 
+    def _show_license(self):
+        self._display_resource_window("LICENSE", "Software License")
+
+    def _show_readme(self):
+        self._display_resource_window("README.md", "pdflinkcheck README.md")
+
+    def _show_i_have_questions(self):
+        self._display_resource_window("I Have Questions.md", "I Have Questions.md")
+
+    def _display_resource_window(self, filename: str, title: str):
+        content = None
         try:
-            # 2. Always create a 'viewing' file in a temp directory or .tmp folder
-            # This prevents clobbering an actual user-saved report.
-            pdf_name = Path(self.pdf_path.get()).stem if self.pdf_path.get() else "report"
-            view_path = PDFLINKCHECK_HOME / f"LAST_REPORT_{pdf_name}.txt"
-            
-            # 3. Write our buffer to this 'View' file
-            view_path.write_text(self.current_report_text, encoding="utf-8")
-            
-            # 4. Open with pyhabitat
-            pyhabitat.edit_textfile(view_path)
-            
+            content = (files("pdflinkcheck.data") / filename).read_text(encoding="utf-8")
+        except FileNotFoundError:
+            if is_in_git_repo():
+                messagebox.showinfo("Development Mode", f"Embedded {filename} not found.\nTrying to copy from project root...")
+                try:
+                    from pdflinkcheck.datacopy import ensure_data_files_for_build
+                    ensure_data_files_for_build()
+                    content = (files("pdflinkcheck.data") / filename).read_text(encoding="utf-8")
+                except ImportError:
+                    messagebox.showerror("Fallback Failed", "Cannot import datacopy module.")
+                    return
+                except Exception as e:
+                    messagebox.showerror("Copy Failed", f"Failed to copy {filename}: {e}")
+                    return
+            else:
+                messagebox.showerror("Resource Missing", f"Embedded file '{filename}' not found.")
+                return
         except Exception as e:
-            messagebox.showerror("View Error", f"Could not launch editor: {e}")
+            messagebox.showerror("Read Error", f"Failed to read {filename}: {e}")
+            return
+
+        content = sanitize_glyphs_for_tkinter(content)
+        #content = sanitize_glyphs_for_compatibility(content)
+
+        win = tk.Toplevel(self.root)
+        win.title(title)
+        win.geometry("700x500")
+
+        txt = tk.Text(win, wrap=tk.WORD, font=('Monospace', 10), padx=6, pady=6)
+        txt.insert(tk.END, content)
+        txt.config(state=tk.DISABLED)
+
+        sb = ttk.Scrollbar(win, command=txt.yview)
+        txt['yscrollcommand'] = sb.set
+
+        sb.pack(side=tk.RIGHT, fill=tk.Y)
+        txt.pack(fill='both', expand=True)
+
+        win.transient(self.root)
+        win.grab_set()
+
+# --- Helper Functions ---
 
-"""
-def toggle_theme():
-    try:
-        current = sv_ttk.get_theme()
-        sv_ttk.set_theme("dark" if current == "light" else "light")
-    except Exception:
-        pass
-"""     
 def sanitize_glyphs_for_tkinter(text: str) -> str:
+    normalized = unicodedata.normalize('NFKD', text)
+    sanitized = normalized.encode('ascii', 'ignore').decode('utf-8')
+    return sanitized.replace('  ', ' ')
+
+def sanitize_glyphs_for_compatibility(text: str) -> str:
     """
-    Converts complex Unicode characters (like emojis and symbols) 
-    into their closest ASCII representation, ignoring those that 
-    cannot be mapped. This prevents the 'empty square' issue in Tkinter.
+    Replaces problematic glyphs with ASCII equivalents for WSL2/gedit compatibility.
+    Does not require external libraries like unidecode.
     """
-    # 1. Normalize the text (NFKD converts composite characters to their base parts)
-    normalized = unicodedata.normalize('NFKD', text)
+    # Define a explicit mapping for your validation glyphs
+    glyph_mapping = {
+        '✅': '[PASS]',
+        '🌐': '[WEB]',
+        '⚠️': '[WARN]',
+        '❌': '[FAIL]',
+        'ℹ️': '[INFO]'
+    }
     
-    # 2. Encode to ASCII and decode back. 
-    # The 'ignore' flag is crucial: it removes any characters 
-    # that don't have an ASCII representation.
+    # 1. Manual replacement for known report glyphs
+    for glyph, replacement in glyph_mapping.items():
+        text = text.replace(glyph, replacement)
+    
+    # 2. Normalize and strip remaining non-ASCII (NFKD decomposes characters)
+    normalized = unicodedata.normalize('NFKD', text)
     sanitized = normalized.encode('ascii', 'ignore').decode('utf-8')
     
-    # 3. Clean up any resulting double spaces or artifacts
-    sanitized = sanitized.replace('  ', ' ')
-    return sanitized
+    # 3. Clean up double spaces created by the stripping
+    return sanitized.replace('  ', ' ')
 
-def auto_close_window(root, delay_ms:int = 0):
-    """
-    Schedules the Tkinter window to be destroyed after a specified delay.
-    """
-    if delay_ms > 0:
-        print(f"Window is set to automatically close in {delay_ms/1000} seconds.")
-        root.after(delay_ms, root.destroy)
-    else:
+def start_gui(time_auto_close: int = 0):
+    # 1. Initialize Root and Splash instantly
+    root = tk.Tk()
+    root.withdraw() # Hide the ugly default window for a split second
+
+    from pdflinkcheck.splash import SplashFrame
+    splash = SplashFrame(root)
+    root.update() # Force drawing the splash screen
+    
+    # app = PDFLinkCheckApp(root=root)
+    # App Initialization
+    print("pdflinkcheck: Initializing PDF Link Check Engine...")
+    try:
+        app = PDFLinkCheckApp(root=root)
+    except Exception as e:
+        print(f"Startup Error: {e}")
+        root.destroy()
         return
+    
+    # === Artificial Loading Delay ===4
+    DEV_DELAY = False
+    if DEV_DELAY:
+        import time
+        for _ in range(40):
+            if not root.winfo_exists(): return
+            time.sleep(0.05)
+            root.update()
+    # ====================================
+    
+    # Handover
+    if root.winfo_exists():
+        splash.teardown() # The Splash cleans itself up
 
+        # Re-center the MAIN app window before showing it
+        app_w, app_h = 700, 500
+        # Center and then reveal
+        center_window_on_primary(root, app_w, app_h)
+        
+        root.deiconify()
+        # Restore window borders/decorations
+        #root.overrideredirect(False)
 
-def start_gui(time_auto_close:int=0):
-    """
-    Entry point function to launch the application.
-    """
-    print("pdflinkcheck: start_gui ...")
-    tk_app = PDFLinkCheckerApp()
+        # Force a title update to kick the window manager
+        root.title(f"PDF Link Check v{get_version_from_pyproject()}")
+
+        root.lift()
+        root.wm_attributes("-topmost", True)
+        root.after(200, lambda: root.wm_attributes("-topmost", False))
+
+        if pyhabitat.on_windows():
+            try:
+                hwnd = root.winfo_id()
+                ctypes.windll.user32.SetForegroundWindow(hwnd)
+            except:
+                pass
 
-    auto_close_window(tk_app, time_auto_close)
+        if time_auto_close > 0:
+            root.after(time_auto_close, root.destroy)
 
-    tk_app.mainloop()
+        root.focus_force()
+        root.mainloop()
     print("pdflinkcheck: gui closed.")
 
 if __name__ == "__main__":