import glob import os import pymupdf # PyMuPDF from PySide6.QtCore import Qt from PySide6.QtGui import QCursor, QPixmap, QImage, QPainter, QAction, QIcon 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))