805 lines
36 KiB
Python
805 lines
36 KiB
Python
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, XsltVersion
|
|
|
|
|
|
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()
|
|
|
|
# Performance-Tab initialisieren
|
|
self._populate_performance_tab()
|
|
|
|
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)
|
|
|
|
def _populate_performance_tab(self):
|
|
"""Initialisiert den Performance-Tab mit den aktuellen Einstellungen."""
|
|
# Worker-Anzahl setzen
|
|
self.ui.spinBoxWorkerCount.setValue(self.settings.max_workers)
|
|
|
|
# SaxonWorkerPool-Checkbox setzen
|
|
self.ui.checkBoxUseSaxonPool.setChecked(self.settings.use_saxon_worker_pool)
|
|
|
|
# XSLT-Version ComboBox setzen
|
|
if self.settings.saxon_xslt_version == XsltVersion.XSLT_1_0:
|
|
self.ui.comboBoxXsltVersion.setCurrentIndex(0)
|
|
else: # XSLT_2_0_3_0
|
|
self.ui.comboBoxXsltVersion.setCurrentIndex(1)
|
|
|
|
# FopWorkerPool-Checkbox setzen
|
|
self.ui.checkBoxUseFopPool.setChecked(self.settings.use_fop_worker_pool)
|
|
|
|
def _refresh_main_window_projects_menu(self):
|
|
"""Aktualisiert das Projekte-Menü im MainWindow, falls vorhanden."""
|
|
if self.parent() and hasattr(self.parent(), "_setup_projects_menu"):
|
|
self.parent()._setup_projects_menu()
|
|
|
|
# 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()
|
|
self._refresh_main_window_projects_menu()
|
|
|
|
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()
|
|
self._refresh_main_window_projects_menu()
|
|
|
|
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()
|
|
self._refresh_main_window_projects_menu()
|
|
|
|
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()
|
|
self._refresh_main_window_projects_menu()
|
|
|
|
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()
|
|
self._refresh_main_window_projects_menu()
|
|
|
|
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()
|
|
self._refresh_main_window_projects_menu()
|
|
|
|
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()
|
|
self._refresh_main_window_projects_menu()
|
|
|
|
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()
|
|
self._refresh_main_window_projects_menu()
|
|
|
|
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()
|
|
self._refresh_main_window_projects_menu()
|
|
|
|
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()
|
|
self._refresh_main_window_projects_menu()
|
|
|
|
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()
|
|
self._refresh_main_window_projects_menu()
|
|
|
|
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()
|
|
self._refresh_main_window_projects_menu()
|
|
|
|
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-Ordner deaktiviert)
|
|
dialog = PdfProjectDlg(self, project_data, edit_mode=True)
|
|
|
|
if dialog.exec() == PdfProjectDlg.DialogCode.Accepted:
|
|
new_data = dialog.get_project_data()
|
|
|
|
# Einstellungen aktualisieren (Ordner bleibt unverändert)
|
|
pdf_project.name = new_data["name"]
|
|
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()
|
|
self._refresh_main_window_projects_menu()
|
|
|
|
# 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()
|
|
self._refresh_main_window_projects_menu()
|
|
|
|
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()
|
|
self._refresh_main_window_projects_menu()
|
|
|
|
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()
|
|
|
|
# Performance-Einstellungen übernehmen
|
|
self.settings.max_workers = self.ui.spinBoxWorkerCount.value()
|
|
self.settings.use_saxon_worker_pool = self.ui.checkBoxUseSaxonPool.isChecked()
|
|
|
|
# XSLT-Version übernehmen
|
|
if self.ui.comboBoxXsltVersion.currentIndex() == 0:
|
|
self.settings.saxon_xslt_version = XsltVersion.XSLT_1_0
|
|
else:
|
|
self.settings.saxon_xslt_version = XsltVersion.XSLT_2_0_3_0
|
|
|
|
self.settings.use_fop_worker_pool = self.ui.checkBoxUseFopPool.isChecked()
|
|
|
|
self.settings.save()
|
|
self._refresh_main_window_projects_menu()
|
|
|
|
super().accept()
|
|
|
|
def get_settings(self) -> AppSettings:
|
|
"""Gibt die aktuellen Einstellungen zurück."""
|
|
return self.settings
|