xsl-validator/src/MainWindow.py

import glob
import os

from PySide6.QtCore import Qt
from PySide6.QtGui import QCursor, QPixmap
from PySide6.QtWidgets import QLabel, QMainWindow

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 = {}

        # Dict zum Speichern der Original-Pixmaps für Zoom-Funktion
        self.original_pixmaps = {}

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

        # Bilder laden
        self._load_images()

        # Signale und Slots verbinden
        self._connect_signals()

    def _load_images(self):
        """Lädt alle GIF-Dateien aus dem Ressourcen-Verzeichnis."""
        # 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.original_pixmaps = {}

        # Pfad zum Ressourcen-Ordner
        base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
        res_dir = os.path.join(base_dir, "src", "ui", "res")

        # Alle GIF-Dateien finden
        gif_files = glob.glob(os.path.join(res_dir, "*.gif"))
        gif_files.sort()  # Dateien alphabetisch sortieren

        print(f"Gefundene GIF-Dateien: {gif_files}")

        # Für jede GIF-Datei:
        for gif_file in gif_files:
            filename = os.path.basename(gif_file)

            # Original-Pixmap laden und speichern
            original_pixmap = QPixmap(gif_file)

            # Thumbnail erstellen und zur linken Spalte hinzufügen
            thumbnail = QLabel()
            thumbnail.setObjectName(f"thumbnail_{filename}")
            thumbnail.setPixmap(original_pixmap.scaledToWidth(200))
            thumbnail.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
            thumbnail.setMouseTracking(True)
            self.ui.verticalLayout_2.addWidget(thumbnail)

            # Vollbild-Version erstellen und zur rechten Spalte hinzufügen
            fullsize = QLabel()
            fullsize.setObjectName(f"fullsize_{filename}")
            fullsize.setPixmap(original_pixmap)
            fullsize.setAlignment(Qt.AlignmentFlag.AlignHCenter)  # Horizontale Zentrierung
            self.ui.verticalLayout_3.addWidget(fullsize)

            # Beziehungen speichern
            self.thumbnail_to_full_image[thumbnail] = fullsize
            self.original_pixmaps[fullsize] = original_pixmap

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

    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)

    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}%")

        # Wende den Zoom auf alle Bilder an
        for fullsize_label, original_pixmap in self.original_pixmaps.items():
            # Berechne die neue Größe basierend auf dem Zoom-Faktor
            new_width = int(original_pixmap.width() * zoom_value / 100)

            # Skaliere das Bild und setze es ins Label
            scaled_pixmap = original_pixmap.scaledToWidth(new_width, Qt.TransformationMode.SmoothTransformation)
            fullsize_label.setPixmap(scaled_pixmap)

            # Stelle sicher, dass die horizontale Zentrierung beibehalten wird
            fullsize_label.setAlignment(Qt.AlignmentFlag.AlignHCenter)