Files
xsl-validator/src/ui/AppSettings.py
T

590 lines
23 KiB
Python
Raw Normal View History

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