xsl-validator/src/ui/AppSettings.py

from PySide6.QtWidgets import QDialog, QTableWidgetItem, QFileDialog
from pathlib import Path

from ui.AppSettings_ui import Ui_Dialog
from ui.JavaVmConfigDialog_ui import Ui_JavaVmConfigDialog
from ui.DiffPdfConfigDialog_ui import Ui_DiffPdfConfigDialog
from ui.SaxonJarConfigDialog_ui import Ui_SaxonJarConfigDialog
from ui.ApacheFopConfigDialog_ui import Ui_ApacheFopConfigDialog
from ui.XslDirConfigDialog_ui import Ui_XslDirConfigDialog
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)
        
        # UI einrichten
        self.ui = Ui_JavaVmConfigDialog()
        self.ui.setupUi(self)
        
        # Signale verbinden
        self.ui.browseButton.clicked.connect(self.browse_binary_file)
    
    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.ui.pathEdit.setText(file_path)
    
    def set_data(self, data):
        """Setzt die Daten in den Dialog."""
        if data:
            self.ui.versionEdit.setText(data.get('version', ''))
            self.ui.pathEdit.setText(str(data.get('path_to_binary_file', '')))
    
    def get_data(self):
        """Gibt die eingegebenen Daten zurück."""
        if not self.ui.versionEdit.text().strip() or not self.ui.pathEdit.text().strip():
            return None
        
        return {
            'version': self.ui.versionEdit.text().strip(),
            'path_to_binary_file': Path(self.ui.pathEdit.text().strip())
        }


class DiffPdfConfigDialog(QDialog):
    """Dialog zur Konfiguration von DiffPdf ohne ID."""
    
    def __init__(self, parent=None):
        super().__init__(parent)
        
        # UI einrichten
        self.ui = Ui_DiffPdfConfigDialog()
        self.ui.setupUi(self)
        
        # Signale verbinden
        self.ui.browseButton.clicked.connect(self.browse_binary_file)
    
    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.ui.pathEdit.setText(file_path)
    
    def set_data(self, data):
        """Setzt die Daten in den Dialog."""
        if data:
            self.ui.versionEdit.setText(data.get('version', ''))
            self.ui.pathEdit.setText(str(data.get('path_to_binary_file', '')))
            self.ui.paramsEdit.setPlainText('\n'.join(data.get('default_params', [])))
            self.ui.extensionEdit.setText(data.get('output_file_extension', 'pdf'))
    
    def get_data(self):
        """Gibt die eingegebenen Daten zurück."""
        if not self.ui.versionEdit.text().strip() or not self.ui.pathEdit.text().strip():
            return None
        
        # Parameter aus dem Text extrahieren
        params_text = self.ui.paramsEdit.toPlainText().strip()
        params = [line.strip() for line in params_text.split('\n') if line.strip()] if params_text else []
        
        return {
            'version': self.ui.versionEdit.text().strip(),
            'path_to_binary_file': Path(self.ui.pathEdit.text().strip()),
            'default_params': params,
            'output_file_extension': self.ui.extensionEdit.text().strip() or "pdf"
        }


class SaxonJarConfigDialog(QDialog):
    """Dialog zur Konfiguration von Saxon JAR ohne ID."""
    
    def __init__(self, parent=None):
        super().__init__(parent)
        
        # UI einrichten
        self.ui = Ui_SaxonJarConfigDialog()
        self.ui.setupUi(self)
        
        # Signale verbinden
        self.ui.browseButton.clicked.connect(self.browse_jar_file)
    
    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.ui.pathEdit.setText(file_path)
    
    def set_data(self, data):
        """Setzt die Daten in den Dialog."""
        if data:
            self.ui.versionEdit.setText(data.get('version', ''))
            self.ui.pathEdit.setText(str(data.get('path_to_jar_file', '')))
            self.ui.extensionEdit.setText(data.get('output_file_extension', 'fo'))
    
    def get_data(self):
        """Gibt die eingegebenen Daten zurück."""
        if not self.ui.versionEdit.text().strip() or not self.ui.pathEdit.text().strip():
            return None
        
        return {
            'version': self.ui.versionEdit.text().strip(),
            'path_to_jar_file': Path(self.ui.pathEdit.text().strip()),
            'output_file_extension': self.ui.extensionEdit.text().strip() or "fo"
        }


class ApacheFopConfigDialog(QDialog):
    """Dialog zur Konfiguration von Apache FOP ohne ID."""
    
    def __init__(self, parent=None):
        super().__init__(parent)
        
        # UI einrichten
        self.ui = Ui_ApacheFopConfigDialog()
        self.ui.setupUi(self)
        
        # Signale verbinden
        self.ui.browseButton.clicked.connect(self.browse_directory)
    
    def browse_directory(self):
        """Öffnet einen Verzeichnisdialog."""
        dir_path = QFileDialog.getExistingDirectory(
            self, "Apache FOP Verzeichnis auswählen"
        )
        if dir_path:
            self.ui.pathEdit.setText(dir_path)
    
    def set_data(self, data):
        """Setzt die Daten in den Dialog."""
        if data:
            self.ui.versionEdit.setText(data.get('version', ''))
            self.ui.pathEdit.setText(str(data.get('path_to_dir', '')))
            self.ui.extensionEdit.setText(data.get('output_file_extension', 'pdf'))
    
    def get_data(self):
        """Gibt die eingegebenen Daten zurück."""
        if not self.ui.versionEdit.text().strip() or not self.ui.pathEdit.text().strip():
            return None
        
        return {
            'version': self.ui.versionEdit.text().strip(),
            'path_to_dir': Path(self.ui.pathEdit.text().strip()),
            'output_file_extension': self.ui.extensionEdit.text().strip() or "pdf"
        }


class XslDirConfigDialog(QDialog):
    """Dialog zur Konfiguration von XSL-Verzeichnis ohne ID."""
    
    def __init__(self, parent=None):
        super().__init__(parent)
        
        # UI einrichten
        self.ui = Ui_XslDirConfigDialog()
        self.ui.setupUi(self)
        
        # Signale verbinden
        self.ui.browseButton.clicked.connect(self.browse_directory)
    
    def browse_directory(self):
        """Öffnet einen Verzeichnisdialog."""
        dir_path = QFileDialog.getExistingDirectory(
            self, "XSL Root-Verzeichnis auswählen"
        )
        if dir_path:
            self.ui.pathEdit.setText(dir_path)
    
    def set_data(self, data):
        """Setzt die Daten in den Dialog."""
        if data:
            self.ui.nameEdit.setText(data.get('name', ''))
            self.ui.pathEdit.setText(str(data.get('path_to_root_dir', '')))
    
    def get_data(self):
        """Gibt die eingegebenen Daten zurück."""
        if not self.ui.nameEdit.text().strip() or not self.ui.pathEdit.text().strip():
            return None
        
        return {
            'name': self.ui.nameEdit.text().strip(),
            'path_to_root_dir': Path(self.ui.pathEdit.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 und macht sie unveränderbar."""
        from PySide6.QtWidgets import QAbstractItemView
        
        # XSL-Ordner Tabelle
        self.ui.tableXsls.setHorizontalHeaderLabels(["Name", "Pfad"])
        self.ui.tableXsls.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
        self.ui.tableXsls.doubleClicked.connect(self._edit_xsl_dir)
        
        # Java VM Tabelle
        self.ui.tableJavaVms.setHorizontalHeaderLabels(["Version", "Pfad"])
        self.ui.tableJavaVms.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
        self.ui.tableJavaVms.doubleClicked.connect(self._edit_java_vm)
        
        # Saxon Tabelle
        self.ui.tableSaxons.setHorizontalHeaderLabels(["Version", "JAR-Pfad", "Extension"])
        self.ui.tableSaxons.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
        self.ui.tableSaxons.doubleClicked.connect(self._edit_saxon)
        
        # Apache FOP Tabelle
        self.ui.tableApacheFops.setHorizontalHeaderLabels(["Version", "Verzeichnis", "Extension"])
        self.ui.tableApacheFops.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
        self.ui.tableApacheFops.doubleClicked.connect(self._edit_apache_fop)
        
        # Diff PDF Tabelle
        self.ui.tableDiffPdfs.setHorizontalHeaderLabels(["Version", "Binary-Pfad", "Parameter", "Extension"])
        self.ui.tableDiffPdfs.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
        self.ui.tableDiffPdfs.doubleClicked.connect(self._edit_diff_pdf)
    
    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)
    
    # Bearbeitungsmethoden für Doppelklick-Events
    def _edit_xsl_dir(self, index):
        """Bearbeitet einen XSL-Ordner per Doppelklick."""
        row = index.row()
        if 0 <= row < len(self.temp_xsl_dirs):
            xsl_dir = self.temp_xsl_dirs[row]
            dialog = XslDirConfigDialog(self)
            
            # Vorhandene Daten setzen
            data = {
                'name': xsl_dir.name,
                'path_to_root_dir': xsl_dir.path_to_root_dir
            }
            dialog.set_data(data)
            
            if dialog.exec() == QDialog.DialogCode.Accepted:
                new_data = dialog.get_data()
                if new_data:
                    # Daten aktualisieren
                    xsl_dir.name = new_data['name']
                    xsl_dir.path_to_root_dir = new_data['path_to_root_dir']
                    self._populate_xsl_table()
    
    def _edit_java_vm(self, index):
        """Bearbeitet eine Java VM per Doppelklick."""
        row = index.row()
        if 0 <= row < len(self.temp_java_vms):
            java_vm = self.temp_java_vms[row]
            dialog = JavaVmConfigDialog(self)
            
            # Vorhandene Daten setzen
            data = {
                'version': java_vm.version,
                'path_to_binary_file': java_vm.path_to_binary_file
            }
            dialog.set_data(data)
            
            if dialog.exec() == QDialog.DialogCode.Accepted:
                new_data = dialog.get_data()
                if new_data:
                    # Daten aktualisieren
                    java_vm.version = new_data['version']
                    java_vm.path_to_binary_file = new_data['path_to_binary_file']
                    self._populate_java_vm_table()
    
    def _edit_saxon(self, index):
        """Bearbeitet eine Saxon JAR per Doppelklick."""
        row = index.row()
        if 0 <= row < len(self.temp_saxon_jars):
            saxon = self.temp_saxon_jars[row]
            dialog = SaxonJarConfigDialog(self)
            
            # Vorhandene Daten setzen
            data = {
                'version': saxon.version,
                'path_to_jar_file': saxon.path_to_jar_file,
                'output_file_extension': saxon.output_file_extension
            }
            dialog.set_data(data)
            
            if dialog.exec() == QDialog.DialogCode.Accepted:
                new_data = dialog.get_data()
                if new_data:
                    # Daten aktualisieren
                    saxon.version = new_data['version']
                    saxon.path_to_jar_file = new_data['path_to_jar_file']
                    saxon.output_file_extension = new_data['output_file_extension']
                    self._populate_saxon_table()
    
    def _edit_apache_fop(self, index):
        """Bearbeitet eine Apache FOP Konfiguration per Doppelklick."""
        row = index.row()
        if 0 <= row < len(self.temp_apache_fops):
            fop = self.temp_apache_fops[row]
            dialog = ApacheFopConfigDialog(self)
            
            # Vorhandene Daten setzen
            data = {
                'version': fop.version,
                'path_to_dir': fop.path_to_dir,
                'output_file_extension': fop.output_file_extension
            }
            dialog.set_data(data)
            
            if dialog.exec() == QDialog.DialogCode.Accepted:
                new_data = dialog.get_data()
                if new_data:
                    # Daten aktualisieren
                    fop.version = new_data['version']
                    fop.path_to_dir = new_data['path_to_dir']
                    fop.output_file_extension = new_data['output_file_extension']
                    self._populate_apache_fop_table()
    
    def _edit_diff_pdf(self, index):
        """Bearbeitet eine Diff PDF Konfiguration per Doppelklick."""
        row = index.row()
        if 0 <= row < len(self.temp_diff_pdfs):
            diff_pdf = self.temp_diff_pdfs[row]
            dialog = DiffPdfConfigDialog(self)
            
            # Vorhandene Daten setzen
            data = {
                'version': diff_pdf.version,
                'path_to_binary_file': diff_pdf.path_to_binary_file,
                'default_params': diff_pdf.default_params,
                'output_file_extension': diff_pdf.output_file_extension
            }
            dialog.set_data(data)
            
            if dialog.exec() == QDialog.DialogCode.Accepted:
                new_data = dialog.get_data()
                if new_data:
                    # Daten aktualisieren
                    diff_pdf.version = new_data['version']
                    diff_pdf.path_to_binary_file = new_data['path_to_binary_file']
                    diff_pdf.default_params = new_data['default_params']
                    diff_pdf.output_file_extension = new_data['output_file_extension']
                    self._populate_diff_pdf_table()
    
    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()
        
        self.settings.save()
        
        super().accept()
    
    def get_settings(self) -> AppSettings:
        """Gibt die aktuellen Einstellungen zurück."""
        return self.settings