xsl-validator/src/ui/AppSettings.py

from PySide6.QtWidgets import QDialog, QTableWidgetItem, QHeaderView
from PySide6.QtCore import Qt
from pathlib import Path

from ui.AppSettings_ui import Ui_Dialog
from ui.JavaVmConfigDialog import JavaVmConfigDialog
from ui.DiffPdfConfigDialog import DiffPdfConfigDialog
from ui.SaxonJarConfigDialog import SaxonJarConfigDialog
from ui.ApacheFopConfigDialog import ApacheFopConfigDialog
from ui.XslDirConfigDialog import XslDirConfigDialog
from ui.PostgreSqlConfigDialog import PostgreSqlConfigDialog
from ui.PdfProject import PdfProjectDlg
from conf import AppSettings, JavaVm, DiffPdf, SaxonJar, ApacheFop, XslDir, Project, PostgreSqlDb


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()
        self.temp_pdf_projects = self.settings.pdf_projects.copy()
        self.temp_postgresql_dbs = self.settings.postgresql_dbs.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.removeSaxon.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)

        # PDF-Projekte Tab
        self.ui.removeProject.clicked.connect(self._remove_pdf_project)
        self.ui.addProject.clicked.connect(self._add_pdf_project)
        self.ui.tablePdfProjects.itemSelectionChanged.connect(self._update_pdf_project_buttons)

        # PostgreSQL Tab
        self.ui.addPostgreSql.clicked.connect(self._add_postgresql_db)
        self.ui.removePostgreSql.clicked.connect(self._remove_postgresql_db)
        self.ui.tablePostgreSqlDbs.itemSelectionChanged.connect(self._update_postgresql_db_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", "Erweiterung"])
        self.ui.tableSaxons.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
        self.ui.tableSaxons.doubleClicked.connect(self._edit_saxon)

        # Apache FOP Tabelle
        self.ui.tableApacheFops.setHorizontalHeaderLabels(["Version", "Pfad", "Erweiterung"])
        self.ui.tableApacheFops.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
        self.ui.tableApacheFops.doubleClicked.connect(self._edit_apache_fop)

        # Diff PDF Tabelle
        self.ui.tableDiffPdfs.setHorizontalHeaderLabels(["Version", "Pfad", "Parameter", "Erweiterung"])
        self.ui.tableDiffPdfs.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
        self.ui.tableDiffPdfs.doubleClicked.connect(self._edit_diff_pdf)

        # PDF-Projekte Tabelle
        self.ui.tablePdfProjects.setHorizontalHeaderLabels(["Name", "Projekt-Ordner", "XSL-Ordner", "Java-VM", "Saxon", "Apache FOP", "Diff-PDF"])
        self.ui.tablePdfProjects.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
        self.ui.tablePdfProjects.doubleClicked.connect(self._edit_pdf_project)

        # PostgreSQL Tabelle
        self.ui.tablePostgreSqlDbs.setHorizontalHeaderLabels(["Name", "Host", "Port", "Datenbank", "Benutzer"])
        self.ui.tablePostgreSqlDbs.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
        self.ui.tablePostgreSqlDbs.doubleClicked.connect(self._edit_postgresql_db)

    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()
        self._populate_pdf_project_table()
        self._populate_postgresql_db_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):
            name_item = QTableWidgetItem(xsl_dir.name)
            name_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.ui.tableXsls.setItem(row, 0, name_item)
            
            path_item = QTableWidgetItem(str(xsl_dir.path_to_root_dir))
            path_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.ui.tableXsls.setItem(row, 1, path_item)
        self.ui.tableXsls.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.ResizeToContents)

    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):
            version_item = QTableWidgetItem(java_vm.version)
            version_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.ui.tableJavaVms.setItem(row, 0, version_item)
            
            path_item = QTableWidgetItem(str(java_vm.path_to_binary_file))
            path_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.ui.tableJavaVms.setItem(row, 1, path_item)
        self.ui.tableJavaVms.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.ResizeToContents)

    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):
            version_item = QTableWidgetItem(saxon.version)
            version_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.ui.tableSaxons.setItem(row, 0, version_item)
            
            path_item = QTableWidgetItem(str(saxon.path_to_jar_file))
            path_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.ui.tableSaxons.setItem(row, 1, path_item)
            
            extension_item = QTableWidgetItem(saxon.output_file_extension)
            extension_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.ui.tableSaxons.setItem(row, 2, extension_item)
        self.ui.tableSaxons.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.ResizeToContents)

    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):
            version_item = QTableWidgetItem(fop.version)
            version_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.ui.tableApacheFops.setItem(row, 0, version_item)
            
            path_item = QTableWidgetItem(str(fop.path_to_dir))
            path_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.ui.tableApacheFops.setItem(row, 1, path_item)
            
            extension_item = QTableWidgetItem(fop.output_file_extension)
            extension_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.ui.tableApacheFops.setItem(row, 2, extension_item)
        self.ui.tableApacheFops.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.ResizeToContents)

    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):
            version_item = QTableWidgetItem(diff_pdf.version)
            version_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.ui.tableDiffPdfs.setItem(row, 0, version_item)
            
            path_item = QTableWidgetItem(str(diff_pdf.path_to_binary_file))
            path_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.ui.tableDiffPdfs.setItem(row, 1, path_item)
            
            params_item = QTableWidgetItem(", ".join(diff_pdf.default_params))
            params_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.ui.tableDiffPdfs.setItem(row, 2, params_item)
            
            extension_item = QTableWidgetItem(diff_pdf.output_file_extension)
            extension_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.ui.tableDiffPdfs.setItem(row, 3, extension_item)
        self.ui.tableDiffPdfs.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.ResizeToContents)

    def _populate_pdf_project_table(self):
        """Füllt die PDF-Projekte Tabelle."""
        self.ui.tablePdfProjects.setRowCount(len(self.temp_pdf_projects))
        for row, pdf_project in enumerate(self.temp_pdf_projects):
            name_item = QTableWidgetItem(pdf_project.name)
            name_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.ui.tablePdfProjects.setItem(row, 0, name_item)
            
            project_dir_item = QTableWidgetItem(str(pdf_project.project_dir))
            project_dir_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.ui.tablePdfProjects.setItem(row, 1, project_dir_item)
            
            xsl_item = QTableWidgetItem(pdf_project.getXsl())
            xsl_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.ui.tablePdfProjects.setItem(row, 2, xsl_item)
            
            java_vm_item = QTableWidgetItem(pdf_project.getJavaVm())
            java_vm_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.ui.tablePdfProjects.setItem(row, 3, java_vm_item)
            
            saxon_item = QTableWidgetItem(pdf_project.getSaxon())
            saxon_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.ui.tablePdfProjects.setItem(row, 4, saxon_item)
            
            apache_fop_item = QTableWidgetItem(pdf_project.getApacheFop())
            apache_fop_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.ui.tablePdfProjects.setItem(row, 5, apache_fop_item)
            
            diff_pdf_item = QTableWidgetItem(pdf_project.getDiffPdf())
            diff_pdf_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.ui.tablePdfProjects.setItem(row, 6, diff_pdf_item)
        self.ui.tablePdfProjects.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.ResizeToContents)

    def _populate_postgresql_db_table(self):
        """Füllt die PostgreSQL-Datenbank Tabelle."""
        self.ui.tablePostgreSqlDbs.setRowCount(len(self.temp_postgresql_dbs))
        for row, postgresql_db in enumerate(self.temp_postgresql_dbs):
            name_item = QTableWidgetItem(postgresql_db.name)
            name_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.ui.tablePostgreSqlDbs.setItem(row, 0, name_item)
            
            host_item = QTableWidgetItem(postgresql_db.host)
            host_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.ui.tablePostgreSqlDbs.setItem(row, 1, host_item)
            
            port_item = QTableWidgetItem(str(postgresql_db.port))
            port_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.ui.tablePostgreSqlDbs.setItem(row, 2, port_item)
            
            database_item = QTableWidgetItem(postgresql_db.database)
            database_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.ui.tablePostgreSqlDbs.setItem(row, 3, database_item)
            
            username_item = QTableWidgetItem(postgresql_db.username)
            username_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.ui.tablePostgreSqlDbs.setItem(row, 4, username_item)
        self.ui.tablePostgreSqlDbs.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.ResizeToContents)

    # 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()
                
                self.settings.xsl_dirs = self.temp_xsl_dirs.copy()
                self.settings.save()

    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()
                
            self.settings.xsl_dirs = self.temp_xsl_dirs.copy()
            self.settings.save()

    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()
                
                self.settings.java_vms = self.temp_java_vms.copy()
                self.settings.save()

    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()
                
            self.settings.java_vms = self.temp_java_vms.copy()
            self.settings.save()

    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()
                
                self.settings.saxon_jars = self.temp_saxon_jars.copy()
                self.settings.save()

    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()
                
            self.settings.saxon_jars = self.temp_saxon_jars.copy()
            self.settings.save()

    def _update_saxon_buttons(self):
        """Aktualisiert den Status der Saxon-Buttons."""
        has_selection = self.ui.tableSaxons.currentRow() >= 0
        self.ui.removeSaxon.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()
                
                self.settings.apache_fops = self.temp_apache_fops.copy()
                self.settings.save()

    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()
                
            self.settings.apache_fops = self.temp_apache_fops.copy()
            self.settings.save()

    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()
                
                self.settings.diff_pdfs = self.temp_diff_pdfs.copy()
                self.settings.save()

    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()
                
            self.settings.diff_pdfs = self.temp_diff_pdfs.copy()
            self.settings.save()

    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)

    # PDF-Projekt Methoden
    def _add_pdf_project(self):
        """Fügt ein neues PDF-Projekt hinzu."""
        dialog = PdfProjectDlg(self)
        if dialog.exec() == PdfProjectDlg.DialogCode.Accepted:
            project_data = dialog.get_project_data()
            
            # Neue ID generieren
            new_id = max([p.id for p in self.temp_pdf_projects], default=0) + 1
            
            # Erstelle PdfProject-Objekt
            new_project = Project(
                id=new_id,
                name=project_data['name'],
                project_dir=Path(project_data['project_dir']),
                java_vm_id=project_data['java_vm_id'] if project_data['java_vm_id'] != -1 else 1,
                diff_pdf_id=project_data['diff_pdf_id'] if project_data['diff_pdf_id'] != -1 else 1,
                saxon_jar_id=project_data['saxon_jar_id'] if project_data['saxon_jar_id'] != -1 else 1,
                apache_fop_id=project_data['apache_fop_id'] if project_data['apache_fop_id'] != -1 else 1,
                xsl_dir_id=project_data['xsl_dir_id'] if project_data['xsl_dir_id'] != -1 else 1,
                postgre_sql_db_id=project_data['postgre_sql_db_id'] if project_data['postgre_sql_db_id'] != -1 else 1,
                fop_config_dir=Path(project_data['fop_config_dir']) if project_data.get('fop_config_dir') else None,
            )
            
            self.temp_pdf_projects.append(new_project)
            self._populate_pdf_project_table()
                
            self.settings.pdf_projects = self.temp_pdf_projects.copy()
            self.settings.save()

    def _remove_pdf_project(self):
        """Entfernt das ausgewählte PDF-Projekt."""
        current_row = self.ui.tablePdfProjects.currentRow()
        if current_row >= 0:
            del self.temp_pdf_projects[current_row]
            self._populate_pdf_project_table()
            self._update_pdf_project_buttons()
                
            self.settings.pdf_projects = self.temp_pdf_projects.copy()
            self.settings.save()

    def _update_pdf_project_buttons(self):
        """Aktualisiert den Status der PDF-Projekt-Buttons."""
        has_selection = self.ui.tablePdfProjects.currentRow() >= 0
        self.ui.removeProject.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 _edit_pdf_project(self, index):
        """Bearbeitet ein PDF-Projekt per Doppelklick (nur Einstellungen)."""
        row = index.row()
        if 0 <= row < len(self.temp_pdf_projects):
            pdf_project = self.temp_pdf_projects[row]
            
            # Projektdaten für Dialog vorbereiten
            project_data = {
                'name': pdf_project.name,
                'project_dir': str(pdf_project.project_dir),
                'java_vm_id': pdf_project.java_vm_id,
                'diff_pdf_id': pdf_project.diff_pdf_id,
                'saxon_jar_id': pdf_project.saxon_jar_id,
                'apache_fop_id': pdf_project.apache_fop_id,
                'xsl_dir_id': pdf_project.xsl_dir_id,
                'postgre_sql_db_id': pdf_project.postgre_sql_db_id,
                'fop_config_dir': str(pdf_project.fop_config_dir) if pdf_project.fop_config_dir else None
            }
            
            # Dialog im Edit-Modus öffnen (Projekt-Name und -Ordner deaktiviert)
            dialog = PdfProjectDlg(self, project_data, edit_mode=True)
            
            if dialog.exec() == PdfProjectDlg.DialogCode.Accepted:
                new_data = dialog.get_project_data()
                
                # Nur die Einstellungen aktualisieren (Name und Ordner bleiben unverändert)
                pdf_project.java_vm_id = new_data['java_vm_id'] if new_data['java_vm_id'] != -1 else pdf_project.java_vm_id
                pdf_project.diff_pdf_id = new_data['diff_pdf_id'] if new_data['diff_pdf_id'] != -1 else pdf_project.diff_pdf_id
                pdf_project.saxon_jar_id = new_data['saxon_jar_id'] if new_data['saxon_jar_id'] != -1 else pdf_project.saxon_jar_id
                pdf_project.apache_fop_id = new_data['apache_fop_id'] if new_data['apache_fop_id'] != -1 else pdf_project.apache_fop_id
                pdf_project.xsl_dir_id = new_data['xsl_dir_id'] if new_data['xsl_dir_id'] != -1 else pdf_project.xsl_dir_id
                pdf_project.postgre_sql_db_id = new_data['postgre_sql_db_id'] if new_data['postgre_sql_db_id'] != -1 else pdf_project.postgre_sql_db_id
                pdf_project.fop_config_dir = Path(new_data['fop_config_dir']) if new_data.get('fop_config_dir') else None

                self._populate_pdf_project_table()

                # Einstellungen speichern
                self.settings.pdf_projects = self.temp_pdf_projects.copy()
                self.settings.save()

    # PostgreSQL Methoden
    def _add_postgresql_db(self):
        """Fügt eine neue PostgreSQL-Datenbank hinzu."""
        dialog = PostgreSqlConfigDialog(self)
        if dialog.exec() == QDialog.DialogCode.Accepted:
            data = dialog.get_data()
            if data:
                new_id = max([x.id for x in self.temp_postgresql_dbs], default=0) + 1
                new_postgresql_db = PostgreSqlDb(
                    id=new_id,
                    name=data["name"],
                    host=data["host"],
                    port=data["port"],
                    database=data["database"],
                    username=data["username"],
                    password=data["password"]
                )
                self.temp_postgresql_dbs.append(new_postgresql_db)
                self._populate_postgresql_db_table()
                
                self.settings.postgresql_dbs = self.temp_postgresql_dbs.copy()
                self.settings.save()

    def _remove_postgresql_db(self):
        """Entfernt die ausgewählte PostgreSQL-Datenbank."""
        current_row = self.ui.tablePostgreSqlDbs.currentRow()
        if current_row >= 0:
            del self.temp_postgresql_dbs[current_row]
            self._populate_postgresql_db_table()
            self._update_postgresql_db_buttons()
                
            self.settings.postgresql_dbs = self.temp_postgresql_dbs.copy()
            self.settings.save()

    def _update_postgresql_db_buttons(self):
        """Aktualisiert den Status der PostgreSQL-Buttons."""
        has_selection = self.ui.tablePostgreSqlDbs.currentRow() >= 0
        self.ui.removePostgreSql.setEnabled(has_selection)

    def _edit_postgresql_db(self, index):
        """Bearbeitet eine PostgreSQL-Datenbank per Doppelklick."""
        row = index.row()
        if 0 <= row < len(self.temp_postgresql_dbs):
            postgresql_db = self.temp_postgresql_dbs[row]
            dialog = PostgreSqlConfigDialog(self)

            # Vorhandene Daten setzen
            data = {
                "name": postgresql_db.name,
                "host": postgresql_db.host,
                "port": postgresql_db.port,
                "database": postgresql_db.database,
                "username": postgresql_db.username,
                "password": postgresql_db.password
            }
            dialog.set_data(data)

            if dialog.exec() == QDialog.DialogCode.Accepted:
                new_data = dialog.get_data()
                if new_data:
                    # Daten aktualisieren
                    postgresql_db.name = new_data["name"]
                    postgresql_db.host = new_data["host"]
                    postgresql_db.port = new_data["port"]
                    postgresql_db.database = new_data["database"]
                    postgresql_db.username = new_data["username"]
                    postgresql_db.password = new_data["password"]
                    self._populate_postgresql_db_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.pdf_projects = self.temp_pdf_projects.copy()

        self.settings.save()

        super().accept()

    def get_settings(self) -> AppSettings:
        """Gibt die aktuellen Einstellungen zurück."""
        return self.settings