Der AppSettings-Dialog wird beim Start automatisch geöffnet, um fehlende Einstellungen eintragen zu können

* Es wurden weitere Dialoge für einzelne Tabellen erstellt.

src/conf.py

@@ -75,19 +75,21 @@ class AppSettings(BaseSettings):
     pdf_projects: list[PdfProject] = []
 
     model_config = SettingsConfigDict(json_file=config_path)
+    
+    def save(self):
+        global config_path
+        if not config_path.exists():
+            # Datei existert nicht
+            if not config_path.parent.exists():
+                # Ordner existiert nicht
+                config_path.parent.mkdir()
+            
+            # Konfiguration speichern
+            with open(config_path, "wb") as c:
+                c.write(app_settings.model_dump_json(indent=4).encode())
 
 app_settings = AppSettings()
 
-if not config_path.exists():
-    # Datei existert nicht
-    if not config_path.parent.exists():
-        # Ordner existiert nicht
-        config_path.parent.mkdir()
-    
-    # Konfiguration speichern
-    with open(config_path, "wb") as c:
-        c.write(app_settings.model_dump_json(indent=4).encode())
-
 
 class PdfProjectSettings(BaseSettings):
     """

src/main.py

@@ -3,6 +3,8 @@ import sys
 from PySide6.QtWidgets import QApplication
 
 from ui.MainWindow import MainWindow
+from ui.AppSettings import AppSettingsDlg
+from conf import app_settings
 
 #import qdarktheme
 
@@ -20,6 +22,11 @@ def main():
 
     # Hauptfenster anzeigen
     window.show()
+    
+    if len(app_settings.apache_fops) == 0 or len(app_settings.diff_pdfs) == 0 or len(app_settings.java_vms) == 0 or len(app_settings.saxon_jars):
+        # Als Modal Dialog öffnen!
+        dlg = AppSettingsDlg(window, app_settings)
+        dlg.exec()
 
     # Anwendung ausführen und Rückgabewert zurückgeben
     return app.exec()

src/ui/AppSettings.py

@@ -0,0 +1,589 @@
+from PySide6.QtWidgets import QDialog, QTableWidgetItem, QMessageBox, QLineEdit, QPushButton, QFileDialog, QTextEdit, QVBoxLayout, QHBoxLayout, QFormLayout, QDialogButtonBox
+from PySide6.QtCore import Qt
+from pathlib import Path
+from typing import Optional
+
+from ui.AppSettings_ui import Ui_Dialog
+from conf import AppSettings, JavaVm, DiffPdf, SaxonJar, ApacheFop, XslDir
+
+
+# Dialog-Klassen für die Eingabe ohne ID
+class JavaVmConfigDialog(QDialog):
+    """Dialog zur Konfiguration einer Java VM ohne ID."""
+    
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Java VM Konfiguration")
+        self.setModal(True)
+        self.resize(500, 200)
+        
+        # Layout erstellen
+        layout = QVBoxLayout()
+        form_layout = QFormLayout()
+        
+        # Version Eingabefeld
+        self.version_edit = QLineEdit()
+        form_layout.addRow("Version:", self.version_edit)
+        
+        # Pfad zur Binary-Datei
+        path_layout = QHBoxLayout()
+        self.path_edit = QLineEdit()
+        self.browse_button = QPushButton("Durchsuchen...")
+        self.browse_button.clicked.connect(self.browse_binary_file)
+        path_layout.addWidget(self.path_edit)
+        path_layout.addWidget(self.browse_button)
+        form_layout.addRow("Pfad zur Binary-Datei:", path_layout)
+        
+        layout.addLayout(form_layout)
+        
+        # Dialog-Buttons
+        button_box = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
+        button_box.accepted.connect(self.accept)
+        button_box.rejected.connect(self.reject)
+        layout.addWidget(button_box)
+        
+        self.setLayout(layout)
+    
+    def browse_binary_file(self):
+        """Öffnet einen Dateidialog für die Binary-Datei."""
+        file_path, _ = QFileDialog.getOpenFileName(
+            self, "Java Binary-Datei auswählen", "", 
+            "Executable Files (*.exe);;All Files (*)"
+        )
+        if file_path:
+            self.path_edit.setText(file_path)
+    
+    def get_data(self):
+        """Gibt die eingegebenen Daten zurück."""
+        if not self.version_edit.text().strip() or not self.path_edit.text().strip():
+            return None
+        
+        return {
+            'version': self.version_edit.text().strip(),
+            'path_to_binary_file': Path(self.path_edit.text().strip())
+        }
+
+
+class DiffPdfConfigDialog(QDialog):
+    """Dialog zur Konfiguration von DiffPdf ohne ID."""
+    
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("DiffPdf Konfiguration")
+        self.setModal(True)
+        self.resize(500, 300)
+        
+        # Layout erstellen
+        layout = QVBoxLayout()
+        form_layout = QFormLayout()
+        
+        # Version Eingabefeld
+        self.version_edit = QLineEdit()
+        form_layout.addRow("Version:", self.version_edit)
+        
+        # Pfad zur Binary-Datei
+        path_layout = QHBoxLayout()
+        self.path_edit = QLineEdit()
+        self.browse_button = QPushButton("Durchsuchen...")
+        self.browse_button.clicked.connect(self.browse_binary_file)
+        path_layout.addWidget(self.path_edit)
+        path_layout.addWidget(self.browse_button)
+        form_layout.addRow("Pfad zur Binary-Datei:", path_layout)
+        
+        # Standard-Parameter (als mehrzeiliger Text)
+        self.params_edit = QTextEdit()
+        self.params_edit.setMaximumHeight(80)
+        form_layout.addRow("Standard-Parameter\n(ein Parameter pro Zeile):", self.params_edit)
+        
+        # Output-Dateierweiterung
+        self.extension_edit = QLineEdit()
+        self.extension_edit.setText("pdf")
+        form_layout.addRow("Output-Dateierweiterung:", self.extension_edit)
+        
+        layout.addLayout(form_layout)
+        
+        # Dialog-Buttons
+        button_box = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
+        button_box.accepted.connect(self.accept)
+        button_box.rejected.connect(self.reject)
+        layout.addWidget(button_box)
+        
+        self.setLayout(layout)
+    
+    def browse_binary_file(self):
+        """Öffnet einen Dateidialog für die Binary-Datei."""
+        file_path, _ = QFileDialog.getOpenFileName(
+            self, "DiffPdf Binary-Datei auswählen", "", 
+            "Executable Files (*.exe);;All Files (*)"
+        )
+        if file_path:
+            self.path_edit.setText(file_path)
+    
+    def get_data(self):
+        """Gibt die eingegebenen Daten zurück."""
+        if not self.version_edit.text().strip() or not self.path_edit.text().strip():
+            return None
+        
+        # Parameter aus dem Text extrahieren
+        params_text = self.params_edit.toPlainText().strip()
+        params = [line.strip() for line in params_text.split('\n') if line.strip()] if params_text else []
+        
+        return {
+            'version': self.version_edit.text().strip(),
+            'path_to_binary_file': Path(self.path_edit.text().strip()),
+            'default_params': params,
+            'output_file_extension': self.extension_edit.text().strip() or "pdf"
+        }
+
+
+class SaxonJarConfigDialog(QDialog):
+    """Dialog zur Konfiguration von Saxon JAR ohne ID."""
+    
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Saxon JAR Konfiguration")
+        self.setModal(True)
+        self.resize(500, 200)
+        
+        # Layout erstellen
+        layout = QVBoxLayout()
+        form_layout = QFormLayout()
+        
+        # Version Eingabefeld
+        self.version_edit = QLineEdit()
+        form_layout.addRow("Version:", self.version_edit)
+        
+        # Pfad zur JAR-Datei
+        path_layout = QHBoxLayout()
+        self.path_edit = QLineEdit()
+        self.browse_button = QPushButton("Durchsuchen...")
+        self.browse_button.clicked.connect(self.browse_jar_file)
+        path_layout.addWidget(self.path_edit)
+        path_layout.addWidget(self.browse_button)
+        form_layout.addRow("Pfad zur JAR-Datei:", path_layout)
+        
+        # Output-Dateierweiterung
+        self.extension_edit = QLineEdit()
+        self.extension_edit.setText("fo")
+        form_layout.addRow("Output-Dateierweiterung:", self.extension_edit)
+        
+        layout.addLayout(form_layout)
+        
+        # Dialog-Buttons
+        button_box = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
+        button_box.accepted.connect(self.accept)
+        button_box.rejected.connect(self.reject)
+        layout.addWidget(button_box)
+        
+        self.setLayout(layout)
+    
+    def browse_jar_file(self):
+        """Öffnet einen Dateidialog für die JAR-Datei."""
+        file_path, _ = QFileDialog.getOpenFileName(
+            self, "Saxon JAR-Datei auswählen", "", 
+            "JAR Files (*.jar);;All Files (*)"
+        )
+        if file_path:
+            self.path_edit.setText(file_path)
+    
+    def get_data(self):
+        """Gibt die eingegebenen Daten zurück."""
+        if not self.version_edit.text().strip() or not self.path_edit.text().strip():
+            return None
+        
+        return {
+            'version': self.version_edit.text().strip(),
+            'path_to_jar_file': Path(self.path_edit.text().strip()),
+            'output_file_extension': self.extension_edit.text().strip() or "fo"
+        }
+
+
+class ApacheFopConfigDialog(QDialog):
+    """Dialog zur Konfiguration von Apache FOP ohne ID."""
+    
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Apache FOP Konfiguration")
+        self.setModal(True)
+        self.resize(500, 200)
+        
+        # Layout erstellen
+        layout = QVBoxLayout()
+        form_layout = QFormLayout()
+        
+        # Version Eingabefeld
+        self.version_edit = QLineEdit()
+        form_layout.addRow("Version:", self.version_edit)
+        
+        # Pfad zum Verzeichnis
+        path_layout = QHBoxLayout()
+        self.path_edit = QLineEdit()
+        self.browse_button = QPushButton("Durchsuchen...")
+        self.browse_button.clicked.connect(self.browse_directory)
+        path_layout.addWidget(self.path_edit)
+        path_layout.addWidget(self.browse_button)
+        form_layout.addRow("Pfad zum FOP-Verzeichnis:", path_layout)
+        
+        # Output-Dateierweiterung
+        self.extension_edit = QLineEdit()
+        self.extension_edit.setText("pdf")
+        form_layout.addRow("Output-Dateierweiterung:", self.extension_edit)
+        
+        layout.addLayout(form_layout)
+        
+        # Dialog-Buttons
+        button_box = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
+        button_box.accepted.connect(self.accept)
+        button_box.rejected.connect(self.reject)
+        layout.addWidget(button_box)
+        
+        self.setLayout(layout)
+    
+    def browse_directory(self):
+        """Öffnet einen Verzeichnisdialog."""
+        dir_path = QFileDialog.getExistingDirectory(
+            self, "Apache FOP Verzeichnis auswählen"
+        )
+        if dir_path:
+            self.path_edit.setText(dir_path)
+    
+    def get_data(self):
+        """Gibt die eingegebenen Daten zurück."""
+        if not self.version_edit.text().strip() or not self.path_edit.text().strip():
+            return None
+        
+        return {
+            'version': self.version_edit.text().strip(),
+            'path_to_dir': Path(self.path_edit.text().strip()),
+            'output_file_extension': self.extension_edit.text().strip() or "pdf"
+        }
+
+
+class XslDirConfigDialog(QDialog):
+    """Dialog zur Konfiguration von XSL-Verzeichnis ohne ID."""
+    
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("XSL-Verzeichnis Konfiguration")
+        self.setModal(True)
+        self.resize(500, 150)
+        
+        # Layout erstellen
+        layout = QVBoxLayout()
+        form_layout = QFormLayout()
+        
+        # Name Eingabefeld
+        self.name_edit = QLineEdit()
+        form_layout.addRow("Name:", self.name_edit)
+        
+        # Pfad zum Root-Verzeichnis
+        path_layout = QHBoxLayout()
+        self.path_edit = QLineEdit()
+        self.browse_button = QPushButton("Durchsuchen...")
+        self.browse_button.clicked.connect(self.browse_directory)
+        path_layout.addWidget(self.path_edit)
+        path_layout.addWidget(self.browse_button)
+        form_layout.addRow("Pfad zum Root-Verzeichnis:", path_layout)
+        
+        layout.addLayout(form_layout)
+        
+        # Dialog-Buttons
+        button_box = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
+        button_box.accepted.connect(self.accept)
+        button_box.rejected.connect(self.reject)
+        layout.addWidget(button_box)
+        
+        self.setLayout(layout)
+    
+    def browse_directory(self):
+        """Öffnet einen Verzeichnisdialog."""
+        dir_path = QFileDialog.getExistingDirectory(
+            self, "XSL Root-Verzeichnis auswählen"
+        )
+        if dir_path:
+            self.path_edit.setText(dir_path)
+    
+    def get_data(self):
+        """Gibt die eingegebenen Daten zurück."""
+        if not self.name_edit.text().strip() or not self.path_edit.text().strip():
+            return None
+        
+        return {
+            'name': self.name_edit.text().strip(),
+            'path_to_root_dir': Path(self.path_edit.text().strip())
+        }
+
+
+class AppSettingsDlg(QDialog):
+    """Dialog für die Anwendungseinstellungen mit vollständiger Funktionalität."""
+    
+    def __init__(self, parent=None, settings: AppSettings = AppSettings(
+            java_vms=[], diff_pdfs=[], saxon_jars=[], apache_fops=[], xsl_dirs=[]
+        )):
+        super().__init__(parent)
+        
+        # UI einrichten
+        self.ui = Ui_Dialog()
+        self.ui.setupUi(self)
+        
+        # Einstellungen speichern
+        self.settings = settings
+        
+        # Temporäre Listen für Änderungen
+        self.temp_java_vms = self.settings.java_vms.copy()
+        self.temp_diff_pdfs = self.settings.diff_pdfs.copy()
+        self.temp_saxon_jars = self.settings.saxon_jars.copy()
+        self.temp_apache_fops = self.settings.apache_fops.copy()
+        self.temp_xsl_dirs = self.settings.xsl_dirs.copy()
+        
+        # Signale verbinden
+        self._connect_signals()
+        
+        # Tabellen initialisieren
+        self._setup_tables()
+        self._populate_tables()
+    
+    def _connect_signals(self):
+        """Verbindet die Signale der UI-Elemente."""
+        # XSL-Ordner Tab
+        self.ui.addXsl.clicked.connect(self._add_xsl_dir)
+        self.ui.removeXsl.clicked.connect(self._remove_xsl_dir)
+        self.ui.tableXsls.itemSelectionChanged.connect(self._update_xsl_buttons)
+        
+        # Java VM Tab
+        self.ui.addJavaVm.clicked.connect(self._add_java_vm)
+        self.ui.removeJavaVm.clicked.connect(self._remove_java_vm)
+        self.ui.tableJavaVms.itemSelectionChanged.connect(self._update_java_vm_buttons)
+        
+        # Saxon Tab
+        self.ui.addSaxon.clicked.connect(self._add_saxon)
+        self.ui.removveSaxon.clicked.connect(self._remove_saxon)
+        self.ui.tableSaxons.itemSelectionChanged.connect(self._update_saxon_buttons)
+        
+        # Apache FOP Tab
+        self.ui.addApacheFop.clicked.connect(self._add_apache_fop)
+        self.ui.removeApacheFop.clicked.connect(self._remove_apache_fop)
+        self.ui.tableApacheFops.itemSelectionChanged.connect(self._update_apache_fop_buttons)
+        
+        # Diff PDF Tab
+        self.ui.addDiffPdf.clicked.connect(self._add_diff_pdf)
+        self.ui.removeDiffPdf.clicked.connect(self._remove_diff_pdf)
+        self.ui.tableDiffPdfs.itemSelectionChanged.connect(self._update_diff_pdf_buttons)
+    
+    def _setup_tables(self):
+        """Richtet die Tabellen-Header ein."""
+        # XSL-Ordner Tabelle
+        self.ui.tableXsls.setHorizontalHeaderLabels(["Name", "Pfad"])
+        
+        # Java VM Tabelle
+        self.ui.tableJavaVms.setHorizontalHeaderLabels(["Version", "Pfad"])
+        
+        # Saxon Tabelle
+        self.ui.tableSaxons.setHorizontalHeaderLabels(["Version", "JAR-Pfad", "Extension"])
+        
+        # Apache FOP Tabelle
+        self.ui.tableApacheFops.setHorizontalHeaderLabels(["Version", "Verzeichnis", "Extension"])
+        
+        # Diff PDF Tabelle
+        self.ui.tableDiffPdfs.setHorizontalHeaderLabels(["Version", "Binary-Pfad", "Parameter", "Extension"])
+    
+    def _populate_tables(self):
+        """Füllt alle Tabellen mit den aktuellen Einstellungen."""
+        self._populate_xsl_table()
+        self._populate_java_vm_table()
+        self._populate_saxon_table()
+        self._populate_apache_fop_table()
+        self._populate_diff_pdf_table()
+    
+    def _populate_xsl_table(self):
+        """Füllt die XSL-Ordner Tabelle."""
+        self.ui.tableXsls.setRowCount(len(self.temp_xsl_dirs))
+        for row, xsl_dir in enumerate(self.temp_xsl_dirs):
+            self.ui.tableXsls.setItem(row, 0, QTableWidgetItem(xsl_dir.name))
+            self.ui.tableXsls.setItem(row, 1, QTableWidgetItem(str(xsl_dir.path_to_root_dir)))
+    
+    def _populate_java_vm_table(self):
+        """Füllt die Java VM Tabelle."""
+        self.ui.tableJavaVms.setRowCount(len(self.temp_java_vms))
+        for row, java_vm in enumerate(self.temp_java_vms):
+            self.ui.tableJavaVms.setItem(row, 0, QTableWidgetItem(java_vm.version))
+            self.ui.tableJavaVms.setItem(row, 1, QTableWidgetItem(str(java_vm.path_to_binary_file)))
+    
+    def _populate_saxon_table(self):
+        """Füllt die Saxon Tabelle."""
+        self.ui.tableSaxons.setRowCount(len(self.temp_saxon_jars))
+        for row, saxon in enumerate(self.temp_saxon_jars):
+            self.ui.tableSaxons.setItem(row, 0, QTableWidgetItem(saxon.version))
+            self.ui.tableSaxons.setItem(row, 1, QTableWidgetItem(str(saxon.path_to_jar_file)))
+            self.ui.tableSaxons.setItem(row, 2, QTableWidgetItem(saxon.output_file_extension))
+    
+    def _populate_apache_fop_table(self):
+        """Füllt die Apache FOP Tabelle."""
+        self.ui.tableApacheFops.setRowCount(len(self.temp_apache_fops))
+        for row, fop in enumerate(self.temp_apache_fops):
+            self.ui.tableApacheFops.setItem(row, 0, QTableWidgetItem(fop.version))
+            self.ui.tableApacheFops.setItem(row, 1, QTableWidgetItem(str(fop.path_to_dir)))
+            self.ui.tableApacheFops.setItem(row, 2, QTableWidgetItem(fop.output_file_extension))
+    
+    def _populate_diff_pdf_table(self):
+        """Füllt die Diff PDF Tabelle."""
+        self.ui.tableDiffPdfs.setRowCount(len(self.temp_diff_pdfs))
+        for row, diff_pdf in enumerate(self.temp_diff_pdfs):
+            self.ui.tableDiffPdfs.setItem(row, 0, QTableWidgetItem(diff_pdf.version))
+            self.ui.tableDiffPdfs.setItem(row, 1, QTableWidgetItem(str(diff_pdf.path_to_binary_file)))
+            self.ui.tableDiffPdfs.setItem(row, 2, QTableWidgetItem(", ".join(diff_pdf.default_params)))
+            self.ui.tableDiffPdfs.setItem(row, 3, QTableWidgetItem(diff_pdf.output_file_extension))
+    
+    # XSL-Ordner Methoden
+    def _add_xsl_dir(self):
+        """Fügt einen neuen XSL-Ordner hinzu."""
+        dialog = XslDirConfigDialog(self)
+        if dialog.exec() == QDialog.DialogCode.Accepted:
+            data = dialog.get_data()
+            if data:
+                # Neue ID generieren
+                new_id = max([x.id for x in self.temp_xsl_dirs], default=0) + 1
+                new_xsl_dir = XslDir(id=new_id, name=data['name'], path_to_root_dir=data['path_to_root_dir'])
+                self.temp_xsl_dirs.append(new_xsl_dir)
+                self._populate_xsl_table()
+    
+    def _remove_xsl_dir(self):
+        """Entfernt den ausgewählten XSL-Ordner."""
+        current_row = self.ui.tableXsls.currentRow()
+        if current_row >= 0:
+            del self.temp_xsl_dirs[current_row]
+            self._populate_xsl_table()
+            self._update_xsl_buttons()
+    
+    def _update_xsl_buttons(self):
+        """Aktualisiert den Status der XSL-Buttons."""
+        has_selection = self.ui.tableXsls.currentRow() >= 0
+        self.ui.removeXsl.setEnabled(has_selection)
+    
+    # Java VM Methoden
+    def _add_java_vm(self):
+        """Fügt eine neue Java VM hinzu."""
+        dialog = JavaVmConfigDialog(self)
+        if dialog.exec() == QDialog.DialogCode.Accepted:
+            data = dialog.get_data()
+            if data:
+                new_id = max([x.id for x in self.temp_java_vms], default=0) + 1
+                new_java_vm = JavaVm(id=new_id, version=data['version'], path_to_binary_file=data['path_to_binary_file'])
+                self.temp_java_vms.append(new_java_vm)
+                self._populate_java_vm_table()
+    
+    def _remove_java_vm(self):
+        """Entfernt die ausgewählte Java VM."""
+        current_row = self.ui.tableJavaVms.currentRow()
+        if current_row >= 0:
+            del self.temp_java_vms[current_row]
+            self._populate_java_vm_table()
+            self._update_java_vm_buttons()
+    
+    def _update_java_vm_buttons(self):
+        """Aktualisiert den Status der Java VM-Buttons."""
+        has_selection = self.ui.tableJavaVms.currentRow() >= 0
+        self.ui.removeJavaVm.setEnabled(has_selection)
+    
+    # Saxon Methoden
+    def _add_saxon(self):
+        """Fügt eine neue Saxon JAR hinzu."""
+        dialog = SaxonJarConfigDialog(self)
+        if dialog.exec() == QDialog.DialogCode.Accepted:
+            data = dialog.get_data()
+            if data:
+                new_id = max([x.id for x in self.temp_saxon_jars], default=0) + 1
+                new_saxon = SaxonJar(
+                    id=new_id, version=data['version'], 
+                    path_to_jar_file=data['path_to_jar_file'],
+                    output_file_extension=data['output_file_extension']
+                )
+                self.temp_saxon_jars.append(new_saxon)
+                self._populate_saxon_table()
+    
+    def _remove_saxon(self):
+        """Entfernt die ausgewählte Saxon JAR."""
+        current_row = self.ui.tableSaxons.currentRow()
+        if current_row >= 0:
+            del self.temp_saxon_jars[current_row]
+            self._populate_saxon_table()
+            self._update_saxon_buttons()
+    
+    def _update_saxon_buttons(self):
+        """Aktualisiert den Status der Saxon-Buttons."""
+        has_selection = self.ui.tableSaxons.currentRow() >= 0
+        self.ui.removveSaxon.setEnabled(has_selection)
+    
+    # Apache FOP Methoden
+    def _add_apache_fop(self):
+        """Fügt eine neue Apache FOP Konfiguration hinzu."""
+        dialog = ApacheFopConfigDialog(self)
+        if dialog.exec() == QDialog.DialogCode.Accepted:
+            data = dialog.get_data()
+            if data:
+                new_id = max([x.id for x in self.temp_apache_fops], default=0) + 1
+                new_fop = ApacheFop(
+                    id=new_id, version=data['version'],
+                    path_to_dir=data['path_to_dir'],
+                    output_file_extension=data['output_file_extension']
+                )
+                self.temp_apache_fops.append(new_fop)
+                self._populate_apache_fop_table()
+    
+    def _remove_apache_fop(self):
+        """Entfernt die ausgewählte Apache FOP Konfiguration."""
+        current_row = self.ui.tableApacheFops.currentRow()
+        if current_row >= 0:
+            del self.temp_apache_fops[current_row]
+            self._populate_apache_fop_table()
+            self._update_apache_fop_buttons()
+    
+    def _update_apache_fop_buttons(self):
+        """Aktualisiert den Status der Apache FOP-Buttons."""
+        has_selection = self.ui.tableApacheFops.currentRow() >= 0
+        self.ui.removeApacheFop.setEnabled(has_selection)
+    
+    # Diff PDF Methoden
+    def _add_diff_pdf(self):
+        """Fügt eine neue Diff PDF Konfiguration hinzu."""
+        dialog = DiffPdfConfigDialog(self)
+        if dialog.exec() == QDialog.DialogCode.Accepted:
+            data = dialog.get_data()
+            if data:
+                new_id = max([x.id for x in self.temp_diff_pdfs], default=0) + 1
+                new_diff_pdf = DiffPdf(
+                    id=new_id, version=data['version'],
+                    path_to_binary_file=data['path_to_binary_file'],
+                    default_params=data['default_params'],
+                    output_file_extension=data['output_file_extension']
+                )
+                self.temp_diff_pdfs.append(new_diff_pdf)
+                self._populate_diff_pdf_table()
+    
+    def _remove_diff_pdf(self):
+        """Entfernt die ausgewählte Diff PDF Konfiguration."""
+        current_row = self.ui.tableDiffPdfs.currentRow()
+        if current_row >= 0:
+            del self.temp_diff_pdfs[current_row]
+            self._populate_diff_pdf_table()
+            self._update_diff_pdf_buttons()
+    
+    def _update_diff_pdf_buttons(self):
+        """Aktualisiert den Status der Diff PDF-Buttons."""
+        has_selection = self.ui.tableDiffPdfs.currentRow() >= 0
+        self.ui.removeDiffPdf.setEnabled(has_selection)
+    
+    def accept(self):
+        """Übernimmt die Änderungen und schließt den Dialog."""
+        # Aktualisiere die ursprünglichen Einstellungen
+        self.settings.java_vms = self.temp_java_vms.copy()
+        self.settings.diff_pdfs = self.temp_diff_pdfs.copy()
+        self.settings.saxon_jars = self.temp_saxon_jars.copy()
+        self.settings.apache_fops = self.temp_apache_fops.copy()
+        self.settings.xsl_dirs = self.temp_xsl_dirs.copy()
+        
+        super().accept()
+    
+    def get_settings(self) -> AppSettings:
+        """Gibt die aktuellen Einstellungen zurück."""
+        return self.settings