xsl-validator/src/MainWindow.py

import glob
import os

import pymupdf  # PyMuPDF
from PySide6.QtCore import Qt
from PySide6.QtGui import QCursor, QPixmap, QImage, QPainter, QAction
from PySide6.QtWidgets import QLabel, QMainWindow, QApplication, QStyleFactory

from ui.MainWinddow_ui import Ui_MainWindow


class MainWindow(QMainWindow):
    def __init__(self, parent=None):
        """
        Konstruktor für die MainWindow-Klasse.

        Args:
            parent: Übergeordnetes Widget, falls vorhanden
        """
        super().__init__(parent)

        # UI einrichten
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        # Dict zum Speichern der Beziehung zwischen Thumbnails und großen Bildern
        self.thumbnail_to_full_image = {}

        # Dicts zum Speichern der Original-Pixmaps für alle drei Ebenen
        self.ref_pixmaps = {}  # Unterste Ebene (ref)
        self.diff_pixmaps = {}  # Mittlere Ebene (diff)
        self.new_pixmaps = {}  # Oberste Ebene (new)

        # Aktueller Zoom-Faktor
        self.current_zoom = 100  # 100%

        # Variablen für Drag-to-Scroll (Anti-Jitter für 4K/DPI-Skalierung)
        self.is_dragging = False
        self.last_drag_position = None
        self.drag_threshold = 3  # Mindestbewegung in Pixeln vor dem Scrollen
        self.scroll_sensitivity = 0.7  # Reduzierte Empfindlichkeit für sanfteres Scrollen

        # Theme-Menü initialisieren
        self._setup_theme_menu()

        # Bilder laden
        self._load_images()

        # Signale und Slots verbinden
        self._connect_signals()

    def _setup_theme_menu(self):
        """Initialisiert das Theme-Menü mit verfügbaren Themes."""
        # Hole alle verfügbaren Themes
        available_themes = QStyleFactory.keys()
        current_theme = QApplication.style().objectName()

        print(f"Verfügbare Themes: {available_themes}")
        print(f"Aktuelles Theme: {current_theme}")

        # Füge Theme-Aktionen zum Menü hinzu
        for theme_name in available_themes:
            action = QAction(theme_name, self)
            action.setCheckable(True)

            # Markiere das aktuelle Theme
            if theme_name.lower() == current_theme.lower():
                action.setChecked(True)

            # Verbinde die Aktion mit der Theme-Wechsel-Funktion
            action.triggered.connect(lambda checked, theme=theme_name: self.change_theme(theme))

            # Füge die Aktion zum Theme-Menü hinzu
            self.ui.menuThema.addAction(action)

    def change_theme(self, theme_name):
        """
        Wechselt das Theme der Anwendung.

        Args:
            theme_name: Name des zu verwendenden Themes
        """
        print(f"Wechsle zu Theme: {theme_name}")

        try:
            # Erstelle den neuen Style
            style = QStyleFactory.create(theme_name)
            if style:
                # Wende den neuen Style auf die Anwendung an
                QApplication.setStyle(style)

                # Aktualisiere die Checkmarks im Menü
                for action in self.ui.menuThema.actions():
                    action.setChecked(action.text() == theme_name)

                print(f"Theme erfolgreich gewechselt zu: {theme_name}")
            else:
                print(f"Fehler: Theme '{theme_name}' konnte nicht erstellt werden")

        except Exception as e:
            print(f"Fehler beim Wechseln des Themes: {e}")

    def _load_images(self):
        """Lädt PDF-Seiten aus den drei Unterordnern ref, diff und new."""
        # Entferne bestehende Widgets aus den Layouts
        self._clear_layout(self.ui.verticalLayout_2)
        self._clear_layout(self.ui.verticalLayout_3)

        # Dicts zurücksetzen
        self.thumbnail_to_full_image = {}
        self.ref_pixmaps = {}
        self.diff_pixmaps = {}
        self.new_pixmaps = {}

        # Basis-Pfad zu den PDF-Ordnern
        base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
        pdf_base_dir = os.path.join(base_dir, "src", "ui", "res", "pdf")

        diff_dir = os.path.join(pdf_base_dir, "diff")
        ref_dir = os.path.join(pdf_base_dir, "ref")
        new_dir = os.path.join(pdf_base_dir, "new")

        # Prüfe ob diff-Ordner existiert und PDF-Dateien enthält
        if not os.path.exists(diff_dir):
            print(f"Diff-Ordner nicht gefunden: {diff_dir}")
            return

        # Finde alle PDF-Dateien im diff-Ordner
        diff_pdfs = glob.glob(os.path.join(diff_dir, "*.pdf"))
        if not diff_pdfs:
            print("Keine PDF-Dateien im diff-Ordner gefunden")
            return

        print(f"Gefundene PDF-Dateien im diff-Ordner: {diff_pdfs}")

        # Für jede PDF-Datei im diff-Ordner
        for diff_pdf_path in diff_pdfs:
            pdf_filename = os.path.basename(diff_pdf_path)
            ref_pdf_path = os.path.join(ref_dir, pdf_filename)
            new_pdf_path = os.path.join(new_dir, pdf_filename)

            # Prüfe ob gleichnamige PDFs in ref und new existieren
            if not os.path.exists(ref_pdf_path):
                print(f"Referenz-PDF nicht gefunden: {ref_pdf_path}")
                continue
            if not os.path.exists(new_pdf_path):
                print(f"New-PDF nicht gefunden: {new_pdf_path}")
                continue

            try:
                # Alle drei PDF-Dateien öffnen
                diff_doc = pymupdf.open(diff_pdf_path)
                ref_doc = pymupdf.open(ref_pdf_path)
                new_doc = pymupdf.open(new_pdf_path)

                print(f"PDFs geladen: {pdf_filename}")
                print(f"  diff: {len(diff_doc)} Seiten")
                print(f"  ref: {len(ref_doc)} Seiten")
                print(f"  new: {len(new_doc)} Seiten")

                # Nehme die minimale Seitenzahl aller drei PDFs
                max_pages = min(len(diff_doc), len(ref_doc), len(new_doc))

                # Für jede Seite
                for page_num in range(max_pages):
                    # Seiten aus allen drei PDFs laden
                    diff_page = diff_doc[page_num]
                    ref_page = ref_doc[page_num]
                    new_page = new_doc[page_num]

                    # Seiten in hoher Auflösung rendern
                    matrix = pymupdf.Matrix(2.0, 2.0)  # 2x Vergrößerung für bessere Qualität

                    # Diff-Seite für Thumbnail verwenden
                    diff_pix = diff_page.get_pixmap(matrix=matrix)
                    diff_img_data = diff_pix.tobytes("png")
                    diff_qimg = QImage.fromData(diff_img_data)
                    diff_pixmap = QPixmap.fromImage(diff_qimg)

                    # Ref-Seite für unterste Ebene
                    ref_pix = ref_page.get_pixmap(matrix=matrix)
                    ref_img_data = ref_pix.tobytes("png")
                    ref_qimg = QImage.fromData(ref_img_data)
                    ref_pixmap = QPixmap.fromImage(ref_qimg)

                    # New-Seite für oberste Ebene
                    new_pix = new_page.get_pixmap(matrix=matrix)
                    new_img_data = new_pix.tobytes("png")
                    new_qimg = QImage.fromData(new_img_data)
                    new_pixmap = QPixmap.fromImage(new_qimg)

                    # Thumbnail erstellen (aus diff-PDF) und zur linken Spalte hinzufügen
                    thumbnail = QLabel()
                    thumbnail.setObjectName(f"thumbnail_{pdf_filename}_page_{page_num + 1}")
                    thumbnail.setPixmap(diff_pixmap.scaledToWidth(200, Qt.TransformationMode.SmoothTransformation))
                    thumbnail.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
                    thumbnail.setMouseTracking(True)
                    self.ui.verticalLayout_2.addWidget(thumbnail)

                    # Seitennumer für Thumbnail anzeigen
                    thumbnail_label = QLabel(f"Seite: {page_num + 1}")
                    thumbnail_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
                    self.ui.verticalLayout_2.addWidget(thumbnail_label)

                    # Vollbild-Version erstellen (überlagerte Ebenen) und zur rechten Spalte hinzufügen
                    fullsize = QLabel()
                    fullsize.setObjectName(f"fullsize_{pdf_filename}_page_{page_num + 1}")
                    fullsize.setAlignment(Qt.AlignmentFlag.AlignHCenter)  # Horizontale Zentrierung
                    self.ui.verticalLayout_3.addWidget(fullsize)

                    # Seitennumer für Vollansich anzeigen
                    fullsize_label = QLabel(f"Seite: {page_num + 1}")
                    fullsize_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
                    self.ui.verticalLayout_3.addWidget(fullsize_label)

                    # Beziehungen speichern
                    self.thumbnail_to_full_image[thumbnail] = fullsize
                    self.ref_pixmaps[fullsize] = ref_pixmap
                    self.diff_pixmaps[fullsize] = diff_pixmap
                    self.new_pixmaps[fullsize] = new_pixmap

                    # Click-Event für das Thumbnail einrichten
                    thumbnail.mousePressEvent = lambda event, t=thumbnail: self.on_thumbnail_clicked(event, t)

                    # Drag-to-Scroll Events für große Bilder einrichten
                    fullsize.mousePressEvent = lambda event, f=fullsize: self.on_fullsize_mouse_press(event, f)
                    fullsize.mouseMoveEvent = lambda event, f=fullsize: self.on_fullsize_mouse_move(event, f)
                    fullsize.mouseReleaseEvent = lambda event, f=fullsize: self.on_fullsize_mouse_release(event, f)

                    print(f"Seite {page_num + 1} gerendert.")

                # PDF-Dokumente schließen
                diff_doc.close()
                ref_doc.close()
                new_doc.close()

            except Exception as e:
                print(f"Fehler beim Laden der PDFs: {e}")

        # Initiale Darstellung mit aktuellem Alpha-Wert
        self.update_layered_images()

    def _clear_layout(self, layout):
        """Entfernt alle Widgets aus einem Layout."""
        if layout is not None:
            while layout.count():
                item = layout.takeAt(0)
                widget = item.widget()
                if widget is not None:
                    widget.deleteLater()

    def _connect_signals(self):
        """Verbindet Signale mit den entsprechenden Slots."""
        # Button-Klicks verbinden
        self.ui.pushButton.clicked.connect(self.on_button_clicked)

        # Zoom-Slider verbinden
        self.ui.zoom.valueChanged.connect(self.apply_zoom)

        # Alpha-Slider verbinden
        self.ui.alpha.valueChanged.connect(self.on_alpha_changed)

    def on_alpha_changed(self, alpha_value):
        """
        Wird ausgeführt, wenn der Alpha-Slider geändert wird.

        Args:
            alpha_value: Der neue Alpha-Wert (-100 bis 100)
        """
        print(f"Alpha geändert auf {alpha_value}")
        self.update_layered_images()

    def update_layered_images(self):
        """Aktualisiert alle überlagerten Bilder basierend auf dem aktuellen Alpha-Wert."""
        alpha_value = self.ui.alpha.value()

        for fullsize_label in self.ref_pixmaps.keys():
            # Hole die Original-Pixmaps für alle drei Ebenen
            ref_pixmap = self.ref_pixmaps[fullsize_label]
            diff_pixmap = self.diff_pixmaps[fullsize_label]
            new_pixmap = self.new_pixmaps[fullsize_label]

            # Erstelle das überlagerte Bild
            layered_pixmap = self.create_layered_pixmap(ref_pixmap, diff_pixmap, new_pixmap, alpha_value)

            # Wende aktuellen Zoom an
            zoom_factor = self.current_zoom / 100.0
            if zoom_factor != 1.0:
                new_width = int(layered_pixmap.width() * zoom_factor)
                layered_pixmap = layered_pixmap.scaledToWidth(new_width, Qt.TransformationMode.SmoothTransformation)

            # Setze das überlagerte Bild
            fullsize_label.setPixmap(layered_pixmap)
            fullsize_label.setAlignment(Qt.AlignmentFlag.AlignHCenter)

    def create_layered_pixmap(self, ref_pixmap, diff_pixmap, new_pixmap, alpha_value):
        """
        Erstellt ein übergelagertes Pixmap basierend auf dem Alpha-Wert.

        Args:
            ref_pixmap: Unterste Ebene (ref)
            diff_pixmap: Mittlere Ebene (diff)
            new_pixmap: Oberste Ebene (new)
            alpha_value: Alpha-Wert (-100 bis 100)

        Returns:
            QPixmap: Das überlagerte Bild
        """
        # Verwende die Größe des größten Bildes
        max_width = max(ref_pixmap.width(), diff_pixmap.width(), new_pixmap.width())
        max_height = max(ref_pixmap.height(), diff_pixmap.height(), new_pixmap.height())

        # Erstelle ein leeres Pixmap für das Ergebnis
        result = QPixmap(max_width, max_height)
        result.fill(Qt.GlobalColor.white)

        painter = QPainter(result)
        painter.setRenderHint(QPainter.RenderHint.Antialiasing)

        if alpha_value <= 0:
            # Alpha von -100 bis 0: Übergang von ref zu diff
            # ref_opacity: 1.0 bei -100, 0.0 bei 0
            # diff_opacity: 0.0 bei -100, 1.0 bei 0
            ref_opacity = 1.0 - (alpha_value + 100) / 100.0
            diff_opacity = (alpha_value + 100) / 100.0
            new_opacity = 0.0
        else:
            # Alpha von 0 bis 100: Übergang von diff zu new
            # diff_opacity: 1.0 bei 0, 0.0 bei 100
            # new_opacity: 0.0 bei 0, 1.0 bei 100
            ref_opacity = 0.0
            diff_opacity = 1.0 - alpha_value / 100.0
            new_opacity = alpha_value / 100.0

        # Zeichne die Ebenen mit entsprechender Transparenz
        if ref_opacity > 0:
            painter.setOpacity(ref_opacity)
            painter.drawPixmap(0, 0, ref_pixmap)

        if diff_opacity > 0:
            painter.setOpacity(diff_opacity)
            painter.drawPixmap(0, 0, diff_pixmap)

        if new_opacity > 0:
            painter.setOpacity(new_opacity)
            painter.drawPixmap(0, 0, new_pixmap)

        painter.end()
        return result

    def on_button_clicked(self):
        """Wird ausgeführt, wenn der Button geklickt wird."""
        print("Button wurde geklickt!")
        # Hier kann die gewünschte Aktion für den Button definiert werden

    def on_thumbnail_clicked(self, event, thumbnail):
        """
        Wird ausgeführt, wenn ein Thumbnail angeklickt wird.

        Args:
            event: Das Maus-Event
            thumbnail: Das geklickte Thumbnail-Label
        """
        print(f"Thumbnail {thumbnail.objectName()} wurde angeklickt: {event}")

        # Zum entsprechenden Vollbild scrollen
        full_image = self.thumbnail_to_full_image.get(thumbnail)
        if full_image:
            self.ui.scrollArea_2.ensureWidgetVisible(full_image)

    def apply_zoom(self, zoom_value):
        """
        Wendet den Zoom-Faktor auf alle Bilder im rechten Panel an.

        Args:
            zoom_value: Der neue Zoom-Wert (in Prozent)
        """
        self.current_zoom = zoom_value
        print(f"Zoom geändert auf {zoom_value}%")

        # Aktualisiere alle überlagerten Bilder mit neuem Zoom
        self.update_layered_images()

    def on_fullsize_mouse_press(self, event, fullsize_label):
        """
        Wird ausgeführt, wenn die Maustaste auf einem großen Bild gedrückt wird.

        Args:
            event: Das Maus-Event
            fullsize_label: Das große Bild-Label
        """
        if event.button() == Qt.MouseButton.LeftButton:
            self.is_dragging = True
            # Verwende globale Position für bessere 4K/DPI Kompatibilität
            self.last_drag_position = event.globalPosition().toPoint()
            fullsize_label.setCursor(QCursor(Qt.CursorShape.ClosedHandCursor))

    def on_fullsize_mouse_move(self, event, fullsize_label):
        """
        Wird ausgeführt, wenn die Maus über einem großen Bild bewegt wird.

        Args:
            event: Das Maus-Event
            fullsize_label: Das große Bild-Label
        """
        if self.is_dragging and self.last_drag_position is not None:
            # Verwende globale Position für bessere 4K/DPI Kompatibilität
            current_pos = event.globalPosition().toPoint()
            delta = current_pos - self.last_drag_position

            # Prüfe ob die Bewegung groß genug ist (Anti-Jitter)
            if abs(delta.x()) >= self.drag_threshold or abs(delta.y()) >= self.drag_threshold:
                # Hole die aktuellen Scroll-Balken
                v_scrollbar = self.ui.scrollArea_2.verticalScrollBar()
                h_scrollbar = self.ui.scrollArea_2.horizontalScrollBar()

                # Berechne neue Scroll-Positionen mit reduzierter Empfindlichkeit
                scroll_delta_y = int(-delta.y() * self.scroll_sensitivity)
                scroll_delta_x = int(-delta.x() * self.scroll_sensitivity)

                new_v_value = v_scrollbar.value() + scroll_delta_y
                new_h_value = h_scrollbar.value() + scroll_delta_x

                # Setze die neuen Scroll-Positionen
                v_scrollbar.setValue(new_v_value)
                h_scrollbar.setValue(new_h_value)

                # Aktualisiere die letzte Position nur bei erfolgreichem Scroll
                self.last_drag_position = current_pos

    def on_fullsize_mouse_release(self, event, fullsize_label):
        """
        Wird ausgeführt, wenn die Maustaste auf einem großen Bild losgelassen wird.

        Args:
            event: Das Maus-Event
            fullsize_label: Das große Bild-Label
        """
        if event.button() == Qt.MouseButton.LeftButton:
            self.is_dragging = False
            self.last_drag_position = None
            fullsize_label.setCursor(QCursor(Qt.CursorShape.ArrowCursor))