Neuer Skill: dep-update-check für Dependency- und Python-Updates

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

.claude/settings.json

@@ -0,0 +1,5 @@
+{
+  "enabledPlugins": {
+    "feature-dev@claude-plugins-official": true
+  }
+}

.claude/skills/dep-update-check/SKILL.md

@@ -0,0 +1,154 @@
+---
+name: dep-update-check
+description: Prüft manuell, ob Python-Version und Projekt-Dependencies aktualisiert werden können, und testet die Kompatibilität. Verwende diesen Skill AUSSCHLIESSLICH wenn der Benutzer explizit danach fragt – z.B. '/dep-update-check', 'Prüfe Dependencies', 'Sind Updates verfügbar?', 'Kann ich Python updaten?'. Niemals automatisch auslösen.
+---
+
+# Dependency & Python Update Check
+
+Dieser Skill prüft systematisch, welche Updates für das DocuMentor-Projekt verfügbar sind und ob sie kompatibel miteinander sind. Verwendete Werkzeuge: `uv`, `pyproject.toml`.
+
+## Ablauf
+
+Führe alle Schritte der Reihe nach aus und erstelle am Ende einen übersichtlichen Report.
+
+---
+
+## Schritt 1: Python-Versionscheck
+
+Lies die Python-Constraint aus `pyproject.toml` (Feld `requires-python`).
+
+```bash
+grep "requires-python" pyproject.toml
+```
+
+Prüfe dann, welche stabilen Python-Versionen im erlaubten Bereich verfügbar sind:
+
+```bash
+uv python list
+```
+
+**Stabile Versionen** sind jene ohne Suffix wie `b1`, `rc1`, `a1` oder `+freethreaded`. Filtere Beta- und Release-Candidate-Versionen heraus.
+
+Vergleiche:
+- Aktuell verwendete Version: `uv run python --version`
+- Neueste stabile verfügbare Version innerhalb der Constraints
+
+Falls eine neuere stabile Version verfügbar ist, notiere dies für den Report.
+
+---
+
+## Schritt 2: Veraltete Dependencies ermitteln
+
+```bash
+uv tree --outdated
+```
+
+Extrahiere daraus die **direkten** Projektabhängigkeiten (aus `pyproject.toml`, Abschnitte `[project] dependencies` und `[dependency-groups]`) und trenne sie von transitiven Abhängigkeiten.
+
+Erstelle eine strukturierte Liste:
+- Direkte Dependencies: Name, aktuelle Version, neueste Version
+- Transitive Dependencies mit Updates (nur zur Information)
+
+---
+
+## Schritt 3: Kompatibilitätstest
+
+Sichere zunächst die aktuelle Lock-Datei:
+
+```bash
+cp uv.lock uv.lock.backup
+```
+
+Versuche dann, alle Dependencies auf die neuesten kompatiblen Versionen aufzulösen:
+
+```bash
+uv lock --upgrade 2>&1
+```
+
+**Interpretation:**
+- `Resolved X packages` ohne Fehler → alle Updates sind kompatibel
+- Fehlermeldungen über Versionskonflikte → notiere welche Pakete sich gegenseitig blockieren
+- Prüfe ob `uv.lock` verändert wurde: `diff uv.lock.backup uv.lock | head -50`
+
+Stelle die Lock-Datei wieder her (wir wollen die Umgebung nicht tatsächlich ändern):
+
+```bash
+mv uv.lock.backup uv.lock
+```
+
+---
+
+## Schritt 4: Report erstellen
+
+Gib den Report im folgenden Format aus:
+
+---
+
+### 🐍 Python-Version
+
+| | Version |
+|---|---|
+| Aktuell in Verwendung | z.B. 3.13.11 |
+| Neueste stabile im erlaubten Bereich | z.B. 3.13.13 |
+| Update empfohlen? | Ja / Nein |
+
+Falls ein Python-Update verfügbar ist, zeige den Befehl:
+```bash
+uv python install 3.X.Y
+# Dann in pyproject.toml requires-python anpassen falls nötig
+# Danach: uv sync
+```
+
+---
+
+### 📦 Direkte Dependencies
+
+Tabelle mit Spalten: Paket | Aktuell | Verfügbar | Status
+
+Status-Symbole:
+- ✅ Aktuell
+- ⬆️ Update verfügbar
+- ⚠️ Update verfügbar, aber Kompatibilitätsproblem
+
+---
+
+### 🔗 Transitive Dependencies (Auswahl)
+
+Nur falls es relevante Updates gibt, kurze Liste.
+
+---
+
+### 🔄 Kompatibilitäts-Ergebnis
+
+Klares Fazit:
+- Können alle direkten Dependencies gleichzeitig aktualisiert werden? Ja/Nein
+- Falls Nein: Welche Konflikte bestehen und warum?
+
+---
+
+### 📋 Empfohlene Aktion
+
+Falls Updates verfügbar und kompatibel:
+```bash
+uv sync --upgrade
+```
+
+Falls nur einzelne Pakete aktualisiert werden sollen:
+```bash
+uv add paketname>=neue.version
+```
+
+Falls Python aktualisiert werden soll (nur wenn innerhalb der Constraints):
+```bash
+uv python install 3.X.Y
+uv sync
+```
+
+---
+
+## Hinweise
+
+- **Nie `uv sync --upgrade` automatisch ausführen** – nur im Report vorschlagen, der Benutzer entscheidet.
+- Beta/RC-Python-Versionen werden nicht empfohlen (erkennbar an Suffixen wie `b1`, `rc1`).
+- `pyarrow` und andere native Pakete können bei Python-Upgrades besondere Anforderungen haben – darauf hinweisen falls relevant.
+- Wenn der `uv lock --upgrade`-Test fehlschlägt, die Lock-Datei **immer** aus dem Backup wiederherstellen.

.claude/skills/license-check/SKILL.md

@@ -0,0 +1,94 @@
+---
+name: license-check
+description: "Prüft und aktualisiert THIRD_PARTY_LICENSES.txt bei Dependency-Änderungen. Verwende diesen Skill IMMER zusammen mit dem version-bump Skill wenn der Benutzer einen Git-Commit erstellen möchte, 'commit' erwähnt, oder nach /commit fragt. Der Skill erkennt automatisch ob sich Dependencies in pyproject.toml geändert haben und aktualisiert die Lizenzdatei entsprechend."
+---
+
+# License Check Skill
+
+Dieser Skill stellt sicher, dass die Datei `THIRD_PARTY_LICENSES.txt` immer synchron mit den tatsächlichen Dependencies in `pyproject.toml` bleibt. Er wird automatisch als Teil des Commit-Workflows ausgeführt, parallel zum version-bump Skill.
+
+## Warum das wichtig ist
+
+DocuMentor listet alle verwendeten Drittanbieter-Bibliotheken mit Lizenzinformationen in `THIRD_PARTY_LICENSES.txt` auf. Wenn Dependencies hinzugefügt oder entfernt werden, muss diese Datei aktualisiert werden — sonst sind die Lizenzangaben unvollständig oder veraltet, was rechtliche Konsequenzen haben kann.
+
+## Ablauf
+
+### Schritt 1: Prüfskript ausführen
+
+Führe das gebündelte Prüfskript aus:
+
+```bash
+uv run python .claude/skills/license-check/scripts/check_licenses.py
+```
+
+Das Skript gibt JSON aus mit:
+- `missing`: Dependencies in pyproject.toml die in THIRD_PARTY_LICENSES.txt fehlen
+- `removed`: Einträge in THIRD_PARTY_LICENSES.txt die nicht mehr in pyproject.toml stehen
+- `info`: Automatisch ermittelte Lizenz-Metadaten für fehlende Pakete
+
+### Schritt 2: Ergebnis auswerten
+
+- Wenn `missing` und `removed` beide leer sind: **Keine Aktion nötig.** Fahre direkt mit dem Commit fort.
+- Wenn es Änderungen gibt: Zeige dem Benutzer eine Zusammenfassung und frage ob die Lizenzdatei aktualisiert werden soll.
+
+Beispiel-Zusammenfassung:
+```
+Lizenzdatei-Prüfung:
+  + lxml (BSD License) — neu hinzuzufügen
+  - some-old-lib — aus Lizenzdatei zu entfernen
+```
+
+### Schritt 3: THIRD_PARTY_LICENSES.txt aktualisieren
+
+#### Neue Dependencies hinzufügen
+
+Füge neue Einträge in die passende Sektion ein (Python-Abhängigkeiten oder Eingebettete Bibliotheken). Verwende das bestehende Format:
+
+```
+N. PaketName
+   Version: >=X.Y.Z
+   Lizenz: Lizenzname
+   Webseite: https://...
+   GitHub: https://github.com/...
+   Beschreibung: Kurzbeschreibung auf Englisch
+   Copyright: Copyright (c) Jahr Autor
+```
+
+Dabei gilt:
+- Die Nummerierung fortlaufend innerhalb der Sektion
+- Dev-Dependencies bekommen den Suffix `(Development)` im Namen
+- Transitive Dependencies bekommen den Suffix `(via HauptPaket)` im Namen
+- Die Lizenzinfos aus dem `info`-Feld des Skripts verwenden
+- Wenn das Skript keine Info liefert (Paket nicht installiert), recherchiere via Web
+
+#### Sortierung
+
+Die Reihenfolge der Einträge folgt der logischen Gruppierung:
+1. Haupt-Dependencies (Runtime)
+2. Transitive Dependencies direkt nach ihrem Eltern-Paket (z.B. ConnectorX nach Polars)
+3. Dev-Dependencies am Ende der Python-Sektion
+
+#### Entfernte Dependencies löschen
+
+Entferne den kompletten Block (Name, Version, Lizenz, etc.) des entfernten Pakets und nummeriere die verbleibenden Einträge neu.
+
+#### Neue Lizenztypen
+
+Wenn eine neue Dependency eine Lizenz verwendet, die noch nicht im Abschnitt "Lizenztexte" am Ende der Datei aufgeführt ist, füge den Lizenztext dort hinzu. Gängige Lizenztexte (MIT, Apache 2.0, BSD-3-Clause) sind bereits vorhanden.
+
+### Schritt 4: KNOWN_ALIASES aktualisieren
+
+Wenn neue Dependencies hinzugefügt werden, prüfe ob das `KNOWN_ALIASES`-Dict in `.claude/skills/license-check/scripts/check_licenses.py` aktualisiert werden muss:
+
+- Wenn der Paketname in pyproject.toml anders ist als in THIRD_PARTY_LICENSES.txt (z.B. durch Suffixe wie "(Development)" oder "(via X)")
+- Wenn eine Dependency transitive Dependencies hat, die separat gelistet werden
+
+### Schritt 5: Commit fortsetzen
+
+Füge die geänderte `THIRD_PARTY_LICENSES.txt` (und ggf. `check_licenses.py`) zum Staging-Bereich hinzu und fahre mit dem normalen Commit-Workflow fort.
+
+## Wichtige Hinweise
+
+- Das Skript prüft nur **Python-Abhängigkeiten** und **eingebettete Bibliotheken** — externe Tools (Saxon, FOP, diff-pdf) werden ignoriert
+- Die Lizenzdatei enthält auch den Abschnitt "Stand: Monat Jahr" am Ende — diesen bei Änderungen auf den aktuellen Monat aktualisieren
+- `uv.lock` nicht manuell ändern — wird durch `uv sync` automatisch aktualisiert

.claude/skills/license-check/scripts/check_licenses.py

@@ -0,0 +1,239 @@
+#!/usr/bin/env python3
+"""
+Vergleicht die Dependencies aus pyproject.toml mit den Einträgen in THIRD_PARTY_LICENSES.txt.
+
+Gibt eine JSON-Ausgabe mit:
+- missing: Dependencies die in pyproject.toml stehen aber nicht in THIRD_PARTY_LICENSES.txt
+- removed: Einträge in THIRD_PARTY_LICENSES.txt die nicht mehr in pyproject.toml stehen
+- version_changed: Dependencies deren Mindestversion sich geändert hat
+- info: Metadaten zu fehlenden Paketen (Lizenz, Homepage, etc.)
+"""
+
+import json
+import re
+import sys
+import tomllib
+from importlib.metadata import PackageNotFoundError, metadata
+from pathlib import Path
+
+
+def parse_pyproject(pyproject_path: Path) -> dict[str, str]:
+    """Parst pyproject.toml und extrahiert Dependencies mit Mindestversionen."""
+    with open(pyproject_path, "rb") as f:
+        data = tomllib.load(f)
+
+    deps: dict[str, str] = {}
+
+    # dependencies-Sektion
+    for dep_str in data.get("project", {}).get("dependencies", []):
+        m = re.match(r"([a-zA-Z0-9_-]+)(?:\[.*?\])?(?:>=([0-9.]+))?", dep_str)
+        if m:
+            deps[m.group(1).lower()] = m.group(2) or ""
+
+    # dependency-groups dev
+    for dep_str in data.get("dependency-groups", {}).get("dev", []):
+        if isinstance(dep_str, str):
+            m = re.match(r"([a-zA-Z0-9_-]+)(?:\[.*?\])?(?:>=([0-9.]+))?", dep_str)
+            if m:
+                deps[m.group(1).lower()] = m.group(2) or ""
+
+    return deps
+
+
+def parse_licenses_file(licenses_path: Path) -> tuple[dict[str, str], dict[str, str]]:
+    """Parst THIRD_PARTY_LICENSES.txt und extrahiert Paketnamen nach Sektion.
+
+    Returns:
+        tuple[dict, dict]: (python_deps, embedded_libs) — jeweils lowercase key -> original name
+    """
+    content = licenses_path.read_text(encoding="utf-8")
+    python_deps: dict[str, str] = {}
+    embedded_libs: dict[str, str] = {}
+    current_section = None
+    current_target = None
+
+    for line in content.splitlines():
+        if "Python-Abhängigkeiten" in line:
+            current_section = "python"
+            current_target = python_deps
+            continue
+        if "Eingebettete Bibliotheken" in line:
+            current_section = "embedded"
+            current_target = embedded_libs
+            continue
+        if "Externe Tools" in line or "Lizenztexte" in line:
+            current_section = None
+            current_target = None
+            continue
+        if current_target is None:
+            continue
+
+        # Nummerierter Eintrag: "1. PaketName" oder "1. PaketName (via X)"
+        entry_match = re.match(r"\s*\d+\.\s+(.+?)(?:\s+\(.*\))?\s*$", line)
+        if entry_match:
+            name = entry_match.group(1).strip()
+            current_target[name.lower()] = name
+            continue
+
+        # Version-Zeile: "   Version: >=X.Y.Z"
+        version_match = re.match(r"\s+Version:\s*>=?([\d.]+)", line)
+        if version_match and current_target:
+            last_key = list(current_target.keys())[-1]
+            current_target[last_key] = current_target[last_key] + "|" + version_match.group(1)
+
+    return python_deps, embedded_libs
+
+
+# Mapping: pyproject-Name -> zugehörige Einträge in THIRD_PARTY_LICENSES.txt
+# Deckt transitive Dependencies und Aliase mit Suffixen ab.
+KNOWN_ALIASES = {
+    "pyside6": ["pyside6"],
+    "pydantic-settings": ["pydantic-settings", "pydantic"],  # pydantic ist transitive Dep
+    "pydantic-yaml": ["pydantic-yaml"],
+    "polars": ["polars", "connectorx (via polars)", "pyarrow (via polars)"],
+    "connectorx": ["connectorx (via polars)"],
+    "psutil": ["psutil"],
+    "lxml": ["lxml"],  # BSD-3-Clause, XML/XSLT-Parsing
+    "ruff": ["ruff (development)"],
+    "pyinstaller": ["pyinstaller (development)"],
+    "pillow": ["pillow (development)"],
+}
+
+
+def get_package_info(pkg_name: str) -> dict:
+    """Holt Paket-Metadaten via importlib.metadata."""
+    info = {"name": pkg_name, "installed": False}
+    try:
+        m = metadata(pkg_name)
+        info["installed"] = True
+        info["version"] = m.get("Version", "")
+        info["summary"] = m.get("Summary", "")
+
+        # Lizenz ermitteln
+        license_expr = m.get("License-Expression") or ""
+        if not license_expr:
+            classifiers = [c for c in (m.get_all("Classifier") or []) if "License" in c]
+            if classifiers:
+                license_expr = classifiers[0].split(" :: ")[-1]
+            else:
+                lic_text = m.get("License") or ""
+                if "MIT" in lic_text:
+                    license_expr = "MIT License"
+                elif "BSD" in lic_text:
+                    license_expr = "BSD License"
+                elif "Apache" in lic_text:
+                    license_expr = "Apache License 2.0"
+                elif "LGPL" in lic_text or "GPL" in lic_text:
+                    license_expr = lic_text[:80]
+                else:
+                    license_expr = lic_text[:80] if lic_text else "Unbekannt"
+        info["license"] = license_expr
+
+        # Homepage/GitHub
+        urls = m.get_all("Project-URL") or []
+        for url_entry in urls:
+            if "," in url_entry:
+                label, url = url_entry.split(",", 1)
+                label = label.strip().lower()
+                url = url.strip()
+                if "homepage" in label or "home-page" in label:
+                    info["homepage"] = url
+                elif "repository" in label or "github" in label or "source" in label:
+                    info["github"] = url
+        if "homepage" not in info:
+            homepage = m.get("Home-page")
+            if homepage:
+                info["homepage"] = homepage
+
+        # Author/Copyright
+        author = m.get("Author") or m.get("Author-email") or ""
+        info["author"] = author
+
+    except PackageNotFoundError:
+        pass
+
+    return info
+
+
+def normalize_name(name: str) -> str:
+    """Normalisiert Paketnamen für Vergleich."""
+    return re.sub(r"[-_.]+", "-", name).lower().strip()
+
+
+def main():
+    project_root = Path(__file__).resolve().parents[4]  # .claude/skills/license-check/scripts -> root
+    pyproject_path = project_root / "pyproject.toml"
+    licenses_path = project_root / "THIRD_PARTY_LICENSES.txt"
+
+    if not pyproject_path.exists():
+        print(json.dumps({"error": f"pyproject.toml nicht gefunden: {pyproject_path}"}))
+        sys.exit(1)
+
+    if not licenses_path.exists():
+        print(json.dumps({"error": f"THIRD_PARTY_LICENSES.txt nicht gefunden: {licenses_path}"}))
+        sys.exit(1)
+
+    pyproject_deps = parse_pyproject(pyproject_path)
+    python_entries, embedded_entries = parse_licenses_file(licenses_path)
+
+    # Normalisiere Python-License-Entry-Keys
+    normalized_license_names = {}
+    for key in python_entries:
+        clean = re.sub(r"\s*\(.*?\)", "", key).strip()
+        normalized_license_names[normalize_name(clean)] = key
+
+    result = {
+        "pyproject_deps": {k: v for k, v in sorted(pyproject_deps.items())},
+        "python_license_entries": list(python_entries.keys()),
+        "embedded_license_entries": list(embedded_entries.keys()),
+        "missing": [],
+        "removed": [],
+        "info": {},
+    }
+
+    # Finde fehlende Dependencies
+    covered_in_licenses = set()
+    for dep_name in pyproject_deps:
+        norm = normalize_name(dep_name)
+        if norm in normalized_license_names:
+            covered_in_licenses.add(norm)
+        elif dep_name in KNOWN_ALIASES:
+            found = False
+            for alias in KNOWN_ALIASES[dep_name]:
+                alias_norm = normalize_name(re.sub(r"\s*\(.*?\)", "", alias))
+                if alias_norm in normalized_license_names:
+                    found = True
+                    covered_in_licenses.add(alias_norm)
+            if not found:
+                result["missing"].append(dep_name)
+                result["info"][dep_name] = get_package_info(dep_name)
+        else:
+            result["missing"].append(dep_name)
+            result["info"][dep_name] = get_package_info(dep_name)
+
+    # Finde entfernte Einträge (nur Python-Abhängigkeiten, NICHT eingebettete)
+    for norm_name, orig_key in normalized_license_names.items():
+        if norm_name not in covered_in_licenses:
+            # Prüfe ob es ein "via"-Eintrag ist
+            if "(via" in orig_key:
+                parent = re.search(r"\(via\s+(\w+)\)", orig_key)
+                if parent and normalize_name(parent.group(1)) in {normalize_name(d) for d in pyproject_deps}:
+                    continue
+            # Prüfe ob es über KNOWN_ALIASES abgedeckt ist
+            is_alias = False
+            for dep, aliases in KNOWN_ALIASES.items():
+                if dep in pyproject_deps:
+                    for alias in aliases:
+                        if normalize_name(re.sub(r"\s*\(.*?\)", "", alias)) == norm_name:
+                            is_alias = True
+                            break
+                if is_alias:
+                    break
+            if not is_alias:
+                result["removed"].append(orig_key)
+
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

.claude/skills/version-bump/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: version-bump
+description: "Versionsverwaltung für DocuMentor-Commits. Verwende diesen Skill IMMER wenn der Benutzer einen Git-Commit erstellen möchte, 'commit' erwähnt, oder nach /commit fragt. Der Skill fragt vor dem Commit, ob die Programmversion aktualisiert werden soll, und aktualisiert alle versionsbezogenen Dateien einheitlich."
+---
+
+# Version Bump Skill
+
+Dieser Skill stellt sicher, dass bei jedem Commit die Programmversion bewusst behandelt wird. Bevor der eigentliche Commit erstellt wird, wird der Benutzer gefragt, ob und wie die Version angepasst werden soll.
+
+## Warum das wichtig ist
+
+DocuMentor speichert die Version an mehreren Stellen gleichzeitig (pyproject.toml, Installer-Dateien, Lizenz-Footer). Wenn diese aus dem Takt geraten, entstehen inkonsistente Builds. Dieser Skill verhindert das, indem er alle Stellen auf einmal aktualisiert.
+
+## Ablauf
+
+### Schritt 1: Benutzer fragen
+
+Bevor du den Commit erstellst, frage den Benutzer mit dem AskUserQuestion-Tool:
+
+**Frage:** "Soll die Programmversion aktualisiert werden?"
+
+Optionen:
+- **Patch (X.Y.Z+1)** — Bugfix, kleine Änderung
+- **Minor (X.Y+1.0)** — Neues Feature, Erweiterung
+- **Major (X+1.0.0)** — Breaking Change, großer Meilenstein
+- **Nein, Version beibehalten** — Keine Versionsänderung
+
+Zeige dabei die aktuelle Version aus `pyproject.toml` in der Frage an.
+
+### Schritt 2: Version aktualisieren (falls gewünscht)
+
+Wenn der Benutzer eine Versionserhöhung wählt, aktualisiere **alle** folgenden Dateien einheitlich:
+
+1. **`pyproject.toml`** (Zeile 3) — Source of Truth
+   ```
+   version = "X.Y.Z"
+   ```
+
+2. **`DocuMentor.wxs`** (Zeile 7) — WiX Installer
+   ```xml
+   Version="X.Y.Z"
+   ```
+
+3. **`installer.iss`** (Zeile 13) — Inno Setup
+   ```
+   #define MyAppVersion "X.Y.Z"
+   ```
+
+4. **`THIRD_PARTY_LICENSES.txt`** (letzte Zeile) — Lizenz-Footer
+   ```
+   Erstellt für: DocuMentor vX.Y.Z
+   ```
+
+Lies zuerst die aktuelle Version aus `pyproject.toml`, berechne die neue Version, und aktualisiere dann alle Dateien.
+
+### Schritt 3: Commit erstellen
+
+Nachdem die Versionsdateien aktualisiert wurden (oder der Benutzer "Nein" gewählt hat), erstelle den Commit ganz normal nach den üblichen Commit-Konventionen. Falls die Version geändert wurde, füge die geänderten Versionsdateien zum Commit hinzu.
+
+## Wichtige Hinweise
+
+- Die Version in `pyproject.toml` ist die Single Source of Truth
+- `create_version_info.py` liest automatisch aus `pyproject.toml` — diese Datei muss nicht manuell angepasst werden
+- `uv.lock` wird durch `uv sync` automatisch aktualisiert — nicht manuell ändern
+- Wenn der Benutzer "Nein" wählt, einfach normal mit dem Commit fortfahren

.gitignore

@@ -6,5 +6,20 @@ dist/
 wheels/
 *.egg-info
 
+# PyInstaller
+*.spec.bak
+*.manifest
+*.log
+version_info.txt
+
+# Generierte Icons (optional - entfernen falls Icons versioniert werden sollen)
+# resources/icon.ico
+
 # Virtual environments
 .venv
+
+# WiX Installer Build-Artefakte
+ProductFiles.wxs
+*.msi
+*.wixpdb
+.wix/

BUILD.md

@@ -0,0 +1,404 @@
+# DocuMentor Build-Anleitung
+
+## Voraussetzungen
+
+```bash
+# Dependencies installieren (inkl. Pillow für Icon-Generierung und PyInstaller)
+uv sync --all-groups
+```
+
+Für MSI-Installer zusätzlich:
+- **WiX Toolset v6**: `dotnet tool install --global wix --version 6.*`
+  > **Hinweis**: WiX v7+ erfordert die Akzeptanz der OSMF-EULA (`wix eula accept`). WiX v6 vermeidet diese Einschränkung.
+
+Für Setup.exe zusätzlich:
+- **Inno Setup**: https://jrsoftware.org/isdl.php
+
+## Schnellstart: ZIP-Distribution erstellen
+
+```bash
+# Automatischer Build (empfohlen)
+uv run python build_windows.py
+```
+
+Dies erstellt automatisch:
+1. **Icon** (falls nicht vorhanden): `resources/icon.ico`
+2. **Versionsinformationen**: `version_info.txt`
+3. **Executable**: `dist/DocuMentor/DocuMentor.exe` (mit Icon und Versionsinformationen)
+4. **ZIP-Archiv**: `dist/DocuMentor-YYYYMMDD-Windows.zip`
+
+### Manuelle Build-Schritte
+
+```bash
+# 1. Cleanup
+rm -rf build/ dist/
+
+# 2. PyInstaller ausführen
+uv run pyinstaller --clean DocuMentor.spec
+
+# 3. Testen
+# Auf Windows: dist/DocuMentor/DocuMentor.exe
+# Mit Wine: wine dist/DocuMentor/DocuMentor.exe
+```
+
+## MSI-Installer erstellen (WiX Toolset)
+
+### Schritt 1: PyInstaller Build erstellen
+
+```bash
+uv run python build_windows.py
+```
+
+### Schritt 2: ProductFiles.wxs generieren
+
+**WICHTIG**: WiX v6 hat das `heat` Tool entfernt. Stattdessen wird ein Python-Skript verwendet:
+
+```bash
+# Generiert automatisch ProductFiles.wxs mit allen Dateien aus dist/DocuMentor
+uv run python generate_wix_files.py
+```
+
+### Schritt 3: MSI kompilieren
+
+```bash
+wix build DocuMentor.wxs ProductFiles.wxs -o DocuMentor.msi
+```
+
+### Schritt 4: MSI testen
+
+```bash
+# Installation (als Administrator)
+msiexec /i DocuMentor.msi
+
+# Silent Installation für Deployment
+msiexec /i DocuMentor.msi /quiet /qn /norestart
+
+# Deinstallation
+msiexec /x DocuMentor.msi
+```
+
+### MSI-Vorteile
+
+- Windows-Standard (`.msi` Format)
+- Gruppen-Richtlinien-Deployment (GPO) für Enterprise
+- Silent Installation (`msiexec /quiet`)
+- Windows Installer Transaktionen und Rollback
+- Patch-Unterstützung (.msp für Updates)
+- Versionsupgrades automatisch verwaltet
+
+### MSI-Build automatisieren
+
+Alternativ zu den manuellen Schritten kann ein `build_msi.py` Skript verwendet werden:
+
+```bash
+uv run python build_msi.py
+```
+
+Dieses Skript führt `generate_wix_files.py` und `wix build` automatisch nacheinander aus.
+
+## Setup.exe erstellen (Inno Setup)
+
+1. **GUID generieren** für `installer.iss` (nur beim ersten Mal!):
+   ```bash
+   uv run python generate_guid.py
+   ```
+
+   Kopiere die generierte GUID und füge sie in `installer.iss` bei `AppId` ein (Zeile ~22).
+
+   **WICHTIG**: Die GUID nur EINMAL generieren! Bei Updates dieselbe GUID verwenden.
+
+2. **Windows-Build erstellen**:
+   ```bash
+   uv run python build_windows.py
+   ```
+
+3. **Installer kompilieren**:
+   ```bash
+   iscc installer.iss
+   ```
+
+4. **Ergebnis**:
+   - `dist/installer/DocuMentor-Setup-0.1.0.exe` (mit Icon und Versionsinformationen)
+
+## Konfiguration anpassen
+
+### Icon anpassen
+
+**Option 1: Standard-Icon generieren**
+```bash
+uv run python create_icon.py
+```
+
+**Option 2: Eigenes Icon aus PNG erstellen**
+```bash
+uv run python create_icon.py ihr-logo.png
+```
+
+**Option 3: Manuell ICO-Datei platzieren**
+1. Icon erstellen oder downloaden (`.ico` Format mit mehreren Größen)
+2. Als `resources/icon.ico` speichern
+3. Beim nächsten Build wird es automatisch verwendet
+
+Das Icon wird automatisch verwendet für:
+- Windows-Executable (DocuMentor.exe)
+- Inno Setup Installer
+- Desktop-Verknüpfungen
+
+**Anforderungen:**
+- Multi-Size ICO (16x16 bis 256x256 Pixel)
+- Das `create_icon.py` Skript erstellt alle Größen automatisch
+
+### Versionsinformationen
+
+Versionsinformationen werden automatisch aus `pyproject.toml` generiert:
+
+```bash
+uv run python create_version_info.py
+```
+
+**Version ändern:**
+
+In `pyproject.toml`:
+```toml
+version = "0.2.0"
+```
+
+Auch aktualisieren in:
+- `installer.iss` (Zeile 13: `#define MyAppVersion`)
+
+Dann Versionsinformationen neu generieren:
+```bash
+uv run python create_version_info.py
+```
+
+**Was enthalten die Versionsinformationen:**
+- Dateiversion und Produktversion
+- Beschreibung und Copyright
+- Anwendungsname
+- Wird in Windows Explorer angezeigt (Rechtsklick → Eigenschaften → Details)
+
+### Build-Größe reduzieren
+
+In `DocuMentor.spec` Module ausschließen:
+```python
+excludes=[
+    'tkinter',
+    'matplotlib',
+    'test',
+    'unittest',
+],
+```
+
+### One-File Build (alles in einer .exe)
+
+In `DocuMentor.spec` ändern:
+```python
+exe = EXE(
+    pyz,
+    a.scripts,
+    a.binaries,      # Uncomment
+    a.zipfiles,      # Uncomment
+    a.datas,         # Uncomment
+    [],              # Comment out
+    exclude_binaries=False,  # Ändern
+    # ...
+    name='DocuMentor',
+    onefile=True,    # Hinzufügen
+)
+
+# COLLECT auskommentieren oder entfernen
+```
+
+**Achtung**: One-File ist langsamer beim Start (3-5 Sekunden).
+
+## Testing
+
+### Lokales Testing (Linux/WSL)
+
+```bash
+# Build erstellen
+uv run python build_windows.py
+
+# Mit Wine testen
+wine dist/DocuMentor/DocuMentor.exe
+```
+
+### Testing auf Windows
+
+1. ZIP-Datei auf Windows-System kopieren
+2. Entpacken
+3. `DocuMentor.exe` starten
+4. Features testen:
+   - [ ] Programmstart
+   - [ ] Einstellungsdialog öffnet beim ersten Start
+   - [ ] Projekt öffnen/erstellen
+   - [ ] Tree-Navigation
+   - [ ] XSL/XML-Dateien hinzufügen
+   - [ ] PDF-Generierung (mit konfigurierten Tools)
+   - [ ] PDF-Vergleich
+
+## Troubleshooting
+
+### "Module not found" beim Start
+
+**Lösung A** — Einfache Python-Module: Hidden imports in `DocuMentor.spec` ergänzen:
+```python
+hiddenimports=[
+    'missing_module',
+]
+```
+
+**Lösung B** — Packages mit nativen Extensions (Rust/C, z.B. `connectorx`):
+`hiddenimports` allein reicht nicht, da PyInstaller die `__init__.py` ins PYZ-Archiv packt, aber die `.pyd`-Extension separat im Dateisystem erwartet. Stattdessen `collect_all` verwenden:
+```python
+from PyInstaller.utils.hooks import collect_all
+cx_datas, cx_binaries, cx_hiddenimports = collect_all('problematic_package')
+
+a = Analysis(
+    # ...
+    binaries=cx_binaries,
+    datas=cx_datas,
+    hiddenimports=cx_hiddenimports,
+)
+```
+
+### Antivirus blockiert die .exe
+
+**Ursache**: Unsigned executables werden oft als verdächtig eingestuft.
+
+**Lösungen**:
+1. Code-Signing-Zertifikat kaufen und verwenden
+2. Bei Microsoft SmartScreen einreichen
+3. Exception in Antivirus eintragen (für Tests)
+
+### Executable ist zu groß (>200 MB)
+
+**Lösungen**:
+1. UPX-Kompression ist bereits aktiv
+2. Ungenutzte Module excluden (siehe oben)
+3. Virtual Environment aufräumen: `uv sync --no-dev`
+
+### UI-Dateien nicht gefunden
+
+**Problem**: `.ui` Dateien werden nicht gefunden.
+
+**Lösung**: In `DocuMentor.spec` prüfen:
+```python
+datas=ui_files,  # Muss gesetzt sein
+```
+
+Im Code müssen Ressource-Pfade PyInstaller-kompatibel aufgelöst werden:
+```python
+import sys
+from pathlib import Path
+
+if hasattr(sys, "_MEIPASS"):
+    res_path = Path(sys._MEIPASS) / "res" / "data.sql"
+else:
+    res_path = Path(__file__).parents[3] / "src" / "res" / "data.sql"
+```
+
+## Automatisierung
+
+### GitHub Actions (CI/CD)
+
+```yaml
+name: Build Windows Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  build:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v1
+
+      - name: Build
+        run: uv run python build_windows.py
+
+      - name: Create Release
+        uses: softprops/action-gh-release@v1
+        with:
+          files: dist/*.zip
+```
+
+### Lokales Release-Skript
+
+```bash
+#!/bin/bash
+# release.sh - Erstellt vollständiges Release
+
+VERSION="0.1.0"
+
+echo "Building DocuMentor v$VERSION..."
+
+# 1. Build
+uv run python build_windows.py
+
+# 2. Installer (falls Inno Setup installiert)
+if command -v iscc &> /dev/null; then
+    iscc installer.iss
+    echo "✓ Installer erstellt"
+fi
+
+echo ""
+echo "Release v$VERSION fertig!"
+echo "  • ZIP: dist/DocuMentor-*-Windows.zip"
+echo "  • Setup: dist/installer/DocuMentor-Setup-$VERSION.exe"
+```
+
+## Distributions-Formate im Vergleich
+
+| | ZIP | Setup.exe (Inno Setup) | MSI (WiX) |
+|---|---|---|---|
+| **Portabel** | Ja | Nein | Nein |
+| **Installation nötig** | Nein | Ja | Ja |
+| **Deinstallation** | Nein | Ja | Ja |
+| **Start-Menü** | Nein | Ja | Ja |
+| **GPO-Deployment** | Nein | Nein | Ja |
+| **Silent Install** | — | Ja | Ja |
+| **Rollback** | — | Nein | Ja |
+| **Patch-Support** | — | Nein | Ja (.msp) |
+
+## Externe Abhängigkeiten
+
+DocuMentor benötigt diese Tools (NICHT im Installer enthalten):
+
+1. **Java Runtime Environment (JRE) 11+** — Für Saxon und Apache FOP (https://adoptium.net/)
+2. **Apache FOP** — XSL-FO zu PDF Konvertierung (https://xmlgraphics.apache.org/fop/)
+3. **Saxon XSLT Prozessor** — XSLT 2.0/3.0 Transformationen (https://www.saxonica.com/)
+4. **diff-pdf** — PDF-Vergleich (https://vslavik.github.io/diff-pdf/)
+
+Nach der Installation müssen die Pfade zu diesen Tools in den DocuMentor-Einstellungen konfiguriert werden.
+
+## Dokumentation für Endbenutzer
+
+Die `dist/DocuMentor/README.txt` wird automatisch erstellt und enthält:
+- Installationsanweisungen
+- Liste der externen Abhängigkeiten
+- Konfigurationshinweise
+
+## Versionierung
+
+Version in folgenden Dateien aktualisieren:
+1. `pyproject.toml` — `version = "X.Y.Z"`
+2. `installer.iss` — `#define MyAppVersion "X.Y.Z"`
+
+Dann Versionsinformationen neu generieren:
+```bash
+uv run python create_version_info.py
+```
+
+## Lizenz und Rechtliches
+
+- PySide6 (LGPL): Dynamische Verlinkung ist OK
+- Polars (MIT): Unproblematisch
+- Pydantic (MIT): Unproblematisch
+
+Externe Tools (Saxon, FOP) haben eigene Lizenzen und müssen separat installiert werden.

CLAUDE.md

@@ -1,169 +1,356 @@
-# CLAUDE.md
+# CLAUDE.md
-
+
-Spreche mit mir auf Deutsch! (Communicate with me in German!)
+Spreche mit mir auf Deutsch! (Communicate with me in German!)
-
+
-## Projektübersicht
+## Projektübersicht
-
+
-DocuMentor (ehemals xsl-validator) ist eine PySide6-basierte Desktop-Anwendung zur Verwaltung und Validierung von XSL-Transformationen mit XML-Dateien. Sie bietet eine GUI zur Konfiguration von Transformations-Toolchains (Saxon, Apache FOP, diff-pdf) und zur Verwaltung von PDF-Generierungsprojekten mit PostgreSQL-Datenbankintegration.
+DocuMentor (ehemals xsl-validator) ist eine PySide6-basierte Desktop-Anwendung zur Verwaltung und Validierung von XSL-Transformationen mit XML-Dateien. Sie bietet eine GUI zur Konfiguration von Transformations-Toolchains (Saxon, Apache FOP, diff-pdf) und zur Verwaltung von PDF-Generierungsprojekten mit PostgreSQL-Datenbankintegration.
-
+
-## PySide6-GUI
+## Anvisiertes Nutzungsszenario
-- Beim Erstellen neuer Dialoge sollte immer eine passende UI-Datei erstellt werden
+Der primäre Einsatz ist die kontinuierliche Weiterentwicklung von PDF-Dokumenten in Flexnow (Software zur Prüfungsverwaltung). Dabei handelt es sich beispielsweise um amtliche Urkunden, Zeugnisse und Bescheide.
-- Der Entwickler sollte später in der Lage sein, den neuen Dialog über die UI-Datei zu gestalten
+
-- Aus der UI-Datei wird in Visual Studio Code über eine Erweiterung automatisch eine .py-Datei erzeugt
+Die Basis bilden etwa 100 XSL-Dateien. Die meisten sind mittels `<xsl:import/>` bzw. `<xsl:include/>` miteinander verknüpft (ähnlich der Klassen-Vererbung). Daher können sich Änderungen in einer XSL-Datei auf (unerwartet) viele andere auswirken. Um diese Auswirkungen im Auge zu behalten, wird DocuMentor entwickelt.
-- Die automatisch generierte .py-Datei muss in den Code eingebunden und verwendet werden
+
-
+**Typischer Workflow:**
-## Entwicklungskommandos
+1. Entwickler führt benötigte Änderungen an den XSL-Dateien durch
-
+2. Entwickler startet die Transformation im DocuMentor und begutachtet die generierte PDF-Diff
-### Paketverwaltung
+3. Prüfung: Wurden die richtigen PDF-Dateien geändert?
-Dieses Projekt verwendet den `uv` Paketmanager (nicht pip oder poetry):
+4. Prüfung: Hat die Änderung der XSL-Dateien die erhoffte Änderung in den PDF-Dateien ergeben?
-```bash
+
-uv sync                    # Abhängigkeiten installieren
+Diese Schritte können sich mehrfach wiederholen.
-uv run python src/main.py  # Anwendung starten
+
-uv run python test_hash_implementation.py  # Hash-Tests ausführen
+Da der DocuMentor permanent im Hintergrund läuft, ist ein sparsamer Umgang mit RAM wichtig:
-```
+- Worker-Pools nach Verwendung herunterfahren
-
+- Große Datenstrukturen frühzeitig freigeben
-### Linting
+- Polars DataFrames statt Pandas (geringerer RAM-Verbrauch)
-```bash
+- Lazy Loading wo möglich
-uv run ruff check         # Code-Style prüfen (Zeilenlänge: 120)
+
-uv run ruff format        # Code formatieren
+## Entwicklungskommandos
-```
+
-
+### Paketverwaltung
-## Architektur
+Dieses Projekt verwendet den `uv` Paketmanager (nicht pip oder poetry):
-
+```bash
-### Konfigurationssystem (src/conf.py)
+uv sync                    # Abhängigkeiten installieren
-
+uv run python src/main.py  # Anwendung starten
-Die Anwendung verwendet ein zentralisiertes Konfigurationsmodell mit Pydantic:
+```
-
+
-- **AppSettings**: Globales Singleton (`app_settings`), das die gesamte Anwendungskonfiguration speichert
+### Linting
-  - Wird an plattformspezifischen Orten gespeichert:
+```bash
-    - Linux: `~/.config/DocuMentor/config.json`
+uv run ruff check         # Code-Style prüfen (Zeilenlänge: 120)
-    - Windows: `%APPDATA%\DocuMentor\config.json`
+uv run ruff format        # Code formatieren
-    - macOS: `~/Library/Application Support/DocuMentor/config.json`
+```
-  - Enthält Listen von Tools: `java_vms`, `saxon_jars`, `apache_fops`, `diff_pdfs`, `xsl_dirs`, `postgresql_dbs`
+
-
+### Tests
-- **ProjectData**: Projektspezifische Einstellungen, die in `project.yaml` im jeweiligen Projektverzeichnis gespeichert werden
+Dieses Projekt verwendet KEINE pytest/unittest-Frameworks. Tests sind standalone Python-Skripte:
-  - Enthält hierarchische Baumstruktur von Transformationsknoten
+```bash
-  - Verwendet `TreeNode` und `XslFile` zur Organisation
+uv run python test_hash_implementation.py           # Hash-Tests
-  - Jede `XmlFile` hat eine optionale `hashsum` (blake2b) zur Änderungsverfolgung
+uv run python test_xml_hash_duplicate_detection.py  # Duplikatserkennung
-
+```
-### Wichtige Datenmodelle
+
-
+### Commit
-1. **Tool-Konfigurationsmodelle** (JavaVm, SaxonJar, ApacheFop, DiffPdf, XslDir, PostgreSqlDb):
+Jedes mal bei Commit diese Skills nutzen:
-   - Jedes hat eine `id` und `version`
+
-   - Speichert Pfade zu Binärdateien/Verzeichnissen
+- /license-check
-
+- /version-bump
-2. **Project-Modell**:
+
-   - Referenziert Tool-Konfigurationen über ID
+## Code-Style-Richtlinien
-   - Verlinkt zu einem Projektverzeichnis mit `project.yaml`
+
-   - Hat Hilfsmethoden wie `getXsl()`, `getJavaVm()` um IDs in Namen/Versionen aufzulösen
+### Import-Organisation
-
+
-3. **Baumstruktur** (TreeNode → XslFile → XmlFile):
+Reihenfolge (keine Leerzeilen zwischen Gruppen):
-   - Hierarchische Organisation von Transformations-Workflows
+```python
-   - `TreeNode`: Organisationseinheit mit `xslt_params` und Kindknoten/-dateien
+# 1. Standard Library
-   - `XslFile`: XSL-Stylesheet mit zugehörigen XML-Dateien und XSLT-Parametern
+import os
-   - `XmlFile`: XML-Eingabedatei mit optionalem blake2b-Hash
+import sys
-
+import logging
-### UI-Architektur (src/ui/)
+from pathlib import Path
-
+from typing import TYPE_CHECKING
-Die Anwendung folgt einem spezifischen PySide6-Muster:
+
-
+# 2. Drittanbieter
-1. **UI-Definitionsdateien** (`*_ui.py`): Automatisch generiert aus UI-Designer-Dateien
+from PySide6.QtCore import Qt, QThread, Signal
-   - Diese Dateien definieren die UI-Struktur als Klassen (z.B. `Ui_MainWindow`)
+from PySide6.QtWidgets import QDialog, QMainWindow
-   - Sollten NICHT manuell bearbeitet werden
+from pydantic import BaseModel, Field
-
+
-2. **Implementierungsdateien** (ohne `_ui` Suffix): Tatsächliche Dialog-/Fenster-Implementierungen
+# 3. Lokale Imports (IMMER absolute Imports, KEINE relativen .imports)
-   - Importieren und verwenden die entsprechende `*_ui.py` Datei
+from conf import app_settings, TreeNode, XslFile
-   - Enthalten Business-Logik und Signal/Slot-Verbindungen
+from ui.MainWindow import MainWindow
-   - Beispiel: `MainWindow.py` verwendet `Ui_MainWindow` aus `MainWinddow_ui.py`
+```
-
+
-Beim Erstellen neuer Dialoge:
+- `TYPE_CHECKING` für zirkuläre Import-Vermeidung nutzen
-- Immer zuerst eine entsprechende UI-Datei erstellen
+- Keine relativen Imports (`.` oder `..`)
-- Die UI-Datei wird automatisch als `.py`-Datei von einer VS Code Extension generiert
+
-- Die generierte UI-Klasse in der Implementierungsdatei importieren und verwenden
+### Type Annotations
-
+
-### Hauptfenster (src/ui/MainWindow.py)
+Moderne Union-Syntax verwenden:
-
+```python
-Zentrale Schaltstelle der Anwendung mit mehreren wichtigen Verantwortlichkeiten:
+# RICHTIG
-
+def transform(xml_path: Path, params: dict[str, str]) -> tuple[bool, str]:
-1. **Projektverwaltung**:
+    result: str | None = None
-   - Öffnet und verwaltet PDF-Transformationsprojekte
+    files: list[Path] = []
-   - Lädt/speichert `ProjectData` aus `project.yaml` Dateien
+
-
+# FALSCH
-2. **Tree Widget**: Zeigt hierarchische Struktur von Transformationsknoten an
+def transform(xml_path, params):  # Keine Annotations
-   - Kontextmenüs zum Hinzufügen/Bearbeiten/Löschen von Knoten, XSL-Dateien und XML-Dateien
+    result: Optional[str] = None  # Alte Union-Syntax
-   - Drag-and-Drop-Unterstützung für XML-Dateien
+    files: List[Path] = []  # Großgeschriebene Types
-
+```
-3. **PDF-Vergleichsansicht**:
+
-   - Drei-Panel-Ansicht (Referenz, Diff, Neu)
+### Naming Conventions
-   - Alpha-Blending für visuellen Vergleich
+
-   - Zoom- und Pan-Funktionalität
+```python
-
+# Klassen: PascalCase
-4. **Asynchrone Operationen**:
+class SaxonWorkerPool:
-   - `XmlHashCalculatorThread`: Hintergrund-blake2b-Hash-Berechnung für XML-Dateien
+
-   - `DatabaseTestThread` (in PostgreSqlConfigDialog): Asynchrones Testen von Datenbankverbindungen
+# Funktionen/Methoden: snake_case
-
+def transform_saxon(xml_file: Path) -> bool:
-### Hash-Berechnungssystem
+
-
+# Private Methoden: _snake_case mit Unterstrich
-Die Anwendung verwendet blake2b-Hashing zur Verfolgung von XML-Dateiänderungen:
+def _create_tree_item(self, node: TreeNode):
-
+
-- **Automatisch**: Hashes werden berechnet, wenn Projekte geladen werden (nur für Dateien ohne existierenden Hash)
+# Konstanten: UPPER_CASE
-- **Asynchron**: Hintergrund-Thread (`XmlHashCalculatorThread`) um die UI reaktionsfähig zu halten
+SAXON_WORKER_JAVA = """..."""
-- **Format**: `blake2b:<64-Zeichen-Hexdigest>`
+```
-- **Speicherung**: Persistiert in `project.yaml` innerhalb jedes `XmlFile`-Objekts
+
-- **Details**: Siehe `docs/blake2b_hash_implementation.md`
+### Formatierung
-
+- **Zeilenlänge:** 120 Zeichen (via Ruff konfiguriert)
-### Theme-System
+- **Strings:** Bevorzugt Double-Quotes `"..."`, aber konsistent im File
-
+- **Trailing Commas:** Bei mehrzeiligen Strukturen verwenden
-Die Anwendung unterstützt mehrere Qt-Themes:
+
-- Theme-Auswahlmenü wird dynamisch aus `QStyleFactory.keys()` befüllt
+### Error Handling
-- Theme-Präferenz wird in `AppSettings.theme` gespeichert
+
-- Dark-Theme-Unterstützung via `qdarktheme` Paket (aktuell in main.py auskommentiert)
+IMMER Logging statt `print()` verwenden:
-
+```python
-### Datenbankintegration
+import logging
-
+logger = logging.getLogger(__name__)
-PostgreSQL-Integration mit Polars und ConnectorX:
+
-- Konfiguration wird im `PostgreSqlDb`-Modell mit SSL-Modus-Unterstützung gespeichert
+def transform(xml_path: Path) -> tuple[bool, str]:
-- SQL-Abfragen werden via `_execute_sql_query()` im MainWindow ausgeführt
+    try:
-- Ergebnisse werden in Polars DataFrames geladen
+        logger.info(f"Transformation gestartet: {xml_path}")
-
+        result = do_transform(xml_path)
-## Wichtige Konventionen
+        return True, "Erfolg"
-
+    except FileNotFoundError as e:
-### Deutsche Sprache
+        error_msg = f"XML-Datei nicht gefunden: {xml_path}"
-Die Codebasis verwendet Deutsch für:
+        logger.error(error_msg)
-- UI-Texte und Labels
+        return False, error_msg
-- Kommentare und Dokumentation
+    except Exception as e:
-- Variablennamen wo kontextuell passend
+        error_msg = f"Fehler bei Transformation: {str(e)}"
-- Log-Meldungen
+        logger.exception(error_msg)  # Mit Stack Trace
-
+        return False, error_msg
-### Pfadbehandlung
+```
-- Immer `pathlib.Path`-Objekte verwenden, keine Strings
+
-- `expanduser()` und `expandvars()` für Benutzer-/Umgebungspfade verwenden
+- `logger.debug()` für Debugging-Infos
-- Projektrelative Pfade werden als relativ gespeichert, zur Laufzeit gegen `project_dir` aufgelöst
+- `logger.info()` für normale Operationen
-
+- `logger.warning()` für Warnungen
-### ID-basierte Lookups
+- `logger.error()` für Fehler ohne Stack Trace
-Konfigurationsentitäten (Tools, Datenbanken) werden in Projekten über ID referenziert. Die Hilfsmethoden des `Project`-Modells (`getXsl()`, `getJavaVm()`, etc.) verwenden, um IDs in Anzeigewerte aufzulösen.
+- `logger.exception()` für Fehler MIT Stack Trace
-
+- Fehlermeldungen auf Deutsch
-### Einstellungspersistenz
+
-- Globale Einstellungen: `app_settings.save()` nach Änderungen aufrufen
+### Docstrings
-- Projekteinstellungen: `project_data.writeSettings(project_dir)` nach Änderungen aufrufen
+
-
+Google-Style auf Deutsch:
-## Arbeiten mit der Codebasis
+```python
-
+def transform_xml_to_pdf(xml_path: Path, xsl_path: Path, output_dir: Path) -> tuple[bool, str]:
-### Neue Tool-Konfigurationen hinzufügen
+    """
-1. Modell zu `conf.py` hinzufügen (ähnlich wie `JavaVm`, `SaxonJar`)
+    Transformiert eine XML-Datei mit XSL zu PDF.
-2. Listenfeld zu `AppSettings` hinzufügen
+
-3. Konfigurationsdialog in `src/ui/` erstellen (UI-Datei + Implementierung)
+    Args:
-4. Zu `AppSettings.py` Tabs hinzufügen
+        xml_path: Pfad zur XML-Eingabedatei
-5. `Project`-Modell aktualisieren, falls das Tool projektspezifisch sein soll
+        xsl_path: Pfad zum XSL-Stylesheet
-
+        output_dir: Zielverzeichnis für PDF-Ausgabe
-### Neue Baumoperationen hinzufügen
+
-1. Aktion zum Kontextmenü in `_create_context_menu_for_type()` hinzufügen
+    Returns:
-2. Handler-Methode implementieren nach Namensschema `_action_tree_node()`, `_action_xsl_file()`, etc.
+        tuple[bool, str]: (Erfolg, Fehlermeldung oder Info-Text)
-3. Baum nach Änderungen mit `_load_nodes_to_tree()` aktualisieren
+
-4. `self.project_data.writeSettings(self.project.project_dir)` aufrufen um Änderungen zu persistieren
+    Raises:
-
+        FileNotFoundError: Wenn XML- oder XSL-Datei nicht existiert
-### Projektstruktur modifizieren
+    """
-Das `ProjectData`-Modell ist die Quelle der Wahrheit. Alle Änderungen an der Baumstruktur müssen:
+```
-1. Die `project_data.nodes` Liste modifizieren
+
-2. `project_data.writeSettings()` aufrufen um zu persistieren
+### Pfadbehandlung
-3. Baum mit `_load_nodes_to_tree()` neu laden um Änderungen in der UI zu reflektieren
+- Immer `pathlib.Path`-Objekte verwenden, keine Strings
+- `expanduser()` und `expandvars()` für Benutzer-/Umgebungspfade verwenden
+- Projektrelative Pfade werden als relativ gespeichert, zur Laufzeit gegen `project_dir` aufgelöst
+
+## Architektur
+
+### Konfigurationssystem (src/conf.py)
+
+Die Anwendung verwendet ein zentralisiertes Konfigurationsmodell mit Pydantic:
+
+- **AppSettings**: Globales Singleton (`app_settings`), das die gesamte Anwendungskonfiguration speichert
+  - Wird an plattformspezifischen Orten gespeichert:
+    - Linux: `~/.config/DocuMentor/config.json`
+    - Windows: `%APPDATA%\DocuMentor\config.json`
+    - macOS: `~/Library/Application Support/DocuMentor/config.json`
+  - Enthält Listen von Tools: `java_vms`, `saxon_jars`, `apache_fops`, `diff_pdfs`, `xsl_dirs`, `postgresql_dbs`
+
+- **ProjectData**: Projektspezifische Einstellungen, die in `project.yaml` im jeweiligen Projektverzeichnis gespeichert werden
+  - Enthält hierarchische Baumstruktur von Transformationsknoten
+  - Verwendet `TreeNode` und `XslFile` zur Organisation
+  - Jede `XmlFile` hat eine optionale `hashsum` (blake2b) zur Änderungsverfolgung
+
+### Wichtige Datenmodelle
+
+1. **Tool-Konfigurationsmodelle** (JavaVm, SaxonJar, ApacheFop, DiffPdf, XslDir, PostgreSqlDb):
+   - Jedes hat eine `id` und `version`
+   - Speichert Pfade zu Binärdateien/Verzeichnissen
+
+2. **Project-Modell**:
+   - Referenziert Tool-Konfigurationen über ID
+   - Verlinkt zu einem Projektverzeichnis mit `project.yaml`
+   - Hat Hilfsmethoden wie `getXsl()`, `getJavaVm()` um IDs in Namen/Versionen aufzulösen
+
+3. **Baumstruktur** (TreeNode → XslFile → XmlFile):
+   - Hierarchische Organisation von Transformations-Workflows
+   - `TreeNode`: Organisationseinheit mit `xslt_params` und Kindknoten/-dateien
+   - `XslFile`: XSL-Stylesheet mit zugehörigen XML-Dateien und XSLT-Parametern
+   - `XmlFile`: XML-Eingabedatei mit optionalem blake2b-Hash
+
+### UI-Architektur (src/ui/)
+
+Die Anwendung folgt einem spezifischen PySide6-Muster:
+
+1. **UI-Definitionsdateien** (`*_ui.py`): Automatisch generiert aus UI-Designer-Dateien
+   - Diese Dateien definieren die UI-Struktur als Klassen (z.B. `Ui_MainWindow`)
+   - Sollten NICHT manuell bearbeitet werden
+
+2. **Implementierungsdateien** (ohne `_ui` Suffix): Tatsächliche Dialog-/Fenster-Implementierungen
+   - Importieren und verwenden die entsprechende `*_ui.py` Datei
+   - Enthalten Business-Logik und Signal/Slot-Verbindungen
+   - Beispiel: `MainWindow.py` verwendet `Ui_MainWindow` aus `MainWinddow_ui.py`
+
+Beim Erstellen neuer Dialoge:
+- Immer zuerst eine entsprechende UI-Datei erstellen
+- Die UI-Datei wird automatisch als `.py`-Datei von einer VS Code Extension generiert
+- Die generierte UI-Klasse in der Implementierungsdatei importieren und verwenden
+
+**UI-Import-Pattern:**
+```python
+from PySide6.QtWidgets import QDialog
+from ui.JavaVmConfigDialog_ui import Ui_JavaVmConfigDialog
+
+class JavaVmConfigDialog(QDialog):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.ui = Ui_JavaVmConfigDialog()
+        self.ui.setupUi(self)
+        # Signale NACH setupUi() verbinden
+        self.ui.browseButton.clicked.connect(self._browse_file)
+```
+
+- UI-Klassen NIEMALS direkt erben, nur als `self.ui` Member
+- Alle Widgets über `self.ui.widgetName` zugreifen
+- Signal-Verbindungen immer NACH `setupUi()` aufrufen
+
+### Hauptfenster (src/ui/MainWindow.py)
+
+Zentrale Schaltstelle der Anwendung mit mehreren wichtigen Verantwortlichkeiten:
+
+1. **Projektverwaltung**:
+   - Öffnet und verwaltet PDF-Transformationsprojekte
+   - Lädt/speichert `ProjectData` aus `project.yaml` Dateien
+
+2. **Tree Widget**: Zeigt hierarchische Struktur von Transformationsknoten an
+   - Kontextmenüs zum Hinzufügen/Bearbeiten/Löschen von Knoten, XSL-Dateien und XML-Dateien
+   - Drag-and-Drop-Unterstützung für XML-Dateien
+
+3. **PDF-Vergleichsansicht**:
+   - Drei-Panel-Ansicht (Referenz, Diff, Neu)
+   - Alpha-Blending für visuellen Vergleich
+   - Zoom- und Pan-Funktionalität
+
+4. **Asynchrone Operationen**:
+   - `XmlHashCalculatorThread`: Hintergrund-blake2b-Hash-Berechnung für XML-Dateien
+   - `DatabaseTestThread` (in PostgreSqlConfigDialog): Asynchrones Testen von Datenbankverbindungen
+
+### XSL-Abhängigkeitsgraph (src/ui/XslDependencyDialog.py)
+
+Interaktiver Dialog zur Visualisierung von `<xsl:import/>`- und `<xsl:include/>`-Abhängigkeiten zwischen XSL-Dateien:
+- Sidebar mit Suchfilter zur Navigation
+- Abhängigkeitsgraph-Darstellung via vis.js
+- Parsing der XSL-Dateien mit lxml
+
+### Hash-Berechnungssystem
+
+Die Anwendung verwendet blake2b-Hashing zur Verfolgung von XML-Dateiänderungen:
+
+- **Automatisch**: Hashes werden berechnet, wenn Projekte geladen werden (nur für Dateien ohne existierenden Hash)
+- **Asynchron**: Hintergrund-Thread (`XmlHashCalculatorThread`) um die UI reaktionsfähig zu halten
+- **Format**: `blake2b:<64-Zeichen-Hexdigest>`
+- **Speicherung**: Persistiert in `project.yaml` innerhalb jedes `XmlFile`-Objekts
+- **Details**: Siehe `docs/blake2b_hash_implementation.md`
+
+### Theme-System
+
+Die Anwendung unterstützt mehrere Qt-Themes:
+- Theme-Auswahlmenü wird dynamisch aus `QStyleFactory.keys()` befüllt
+- Theme-Präferenz wird in `AppSettings.theme` gespeichert
+
+### Datenbankintegration
+
+PostgreSQL-Integration mit Polars und ConnectorX:
+- Konfiguration wird im `PostgreSqlDb`-Modell mit SSL-Modus-Unterstützung gespeichert
+- SQL-Abfragen werden asynchron via `DatabaseQueryThread` im `DatabaseMixin` ausgeführt
+- Ergebnisse werden in Polars DataFrames geladen
+
+### Thread-basierte Operationen
+
+```python
+from PySide6.QtCore import QThread, Signal
+
+class HashCalculatorThread(QThread):
+    progress = Signal(int)
+    finished = Signal(dict)
+
+    def __init__(self, files: list[Path]):
+        super().__init__()
+        self.files = files
+
+    def run(self):
+        for i, file_path in enumerate(self.files):
+            hash_value = calculate_hash(file_path)
+            self.progress.emit(i + 1)
+        self.finished.emit(results)
+
+# Verwendung
+thread = HashCalculatorThread(xml_files)
+thread.progress.connect(self._on_progress)
+thread.finished.connect(self._on_finished)
+thread.start()  # NICHT run() direkt aufrufen!
+```
+
+## Wichtige Konventionen
+
+### Deutsche Sprache
+Die Codebasis verwendet Deutsch für:
+- UI-Texte und Labels
+- Kommentare und Dokumentation
+- Variablennamen wo kontextuell passend
+- Log-Meldungen
+
+### ID-basierte Lookups
+Konfigurationsentitäten (Tools, Datenbanken) werden in Projekten über ID referenziert. Die Hilfsmethoden des `Project`-Modells (`getXsl()`, `getJavaVm()`, etc.) verwenden, um IDs in Anzeigewerte aufzulösen.
+
+### Einstellungspersistenz
+- Globale Einstellungen: `app_settings.save()` nach Änderungen aufrufen
+- Projekteinstellungen: `project_data.writeSettings(project_dir)` nach Änderungen aufrufen
+
+## Arbeiten mit der Codebasis
+
+### Neue Tool-Konfigurationen hinzufügen
+1. Modell zu `conf.py` hinzufügen (ähnlich wie `JavaVm`, `SaxonJar`)
+2. Listenfeld zu `AppSettings` hinzufügen
+3. Konfigurationsdialog in `src/ui/` erstellen (UI-Datei + Implementierung)
+4. Zu `AppSettings.py` Tabs hinzufügen
+5. `Project`-Modell aktualisieren, falls das Tool projektspezifisch sein soll
+
+### Neue Baumoperationen hinzufügen
+1. Aktion zum Kontextmenü in `_create_context_menu_for_type()` hinzufügen
+2. Handler-Methode implementieren nach Namensschema `_action_tree_node()`, `_action_xsl_file()`, etc.
+3. Baum nach Änderungen mit `_load_nodes_to_tree()` aktualisieren
+4. `self.project_data.writeSettings(self.project.project_dir)` aufrufen um Änderungen zu persistieren
+
+### Projektstruktur modifizieren
+Das `ProjectData`-Modell ist die Quelle der Wahrheit. Alle Änderungen an der Baumstruktur müssen:
+1. Die `project_data.nodes` Liste modifizieren
+2. `project_data.writeSettings()` aufrufen um zu persistieren
+3. Baum mit `_load_nodes_to_tree()` neu laden um Änderungen in der UI zu reflektieren

DocuMentor.spec

@@ -0,0 +1,92 @@
+# -*- mode: python ; coding: utf-8 -*-
+"""
+PyInstaller Konfiguration für DocuMentor
+Erstellt eine eigenständige Windows-Executable ohne Python-Installation
+"""
+
+import sys
+from pathlib import Path
+from PyInstaller.utils.hooks import collect_all
+
+block_cipher = None
+
+# Projektpfad
+project_root = Path(SPECPATH)
+src_path = project_root / 'src'
+
+# connectorx komplett sammeln (Python-Code, native .pyd und Metadaten)
+# PyInstaller erkennt connectorx nicht automatisch, da es zur Laufzeit
+# von polars per importlib.import_module() geladen wird
+cx_datas, cx_binaries, cx_hiddenimports = collect_all('connectorx')
+
+# Alle UI-Dateien sammeln
+ui_files = []
+for ui_file in (src_path / 'ui').glob('*.ui'):
+    ui_files.append((str(ui_file), 'ui'))
+
+# Ressource-Dateien (SQL, CSV) einbinden
+res_files = []
+for res_file in (src_path / 'res').glob('*'):
+    res_files.append((str(res_file), 'res'))
+
+a = Analysis(
+    [str(src_path / 'main.py')],
+    pathex=[str(src_path)],
+    binaries=cx_binaries,
+    datas=ui_files + res_files + cx_datas + [
+        (str(project_root / 'pyproject.toml'), '.'),
+        (str(project_root / 'THIRD_PARTY_LICENSES.txt'), '.'),
+        (str(project_root / 'resources' / 'icon.ico'), 'resources'),
+    ],
+    hiddenimports=[
+        'PySide6.QtCore',
+        'PySide6.QtGui',
+        'PySide6.QtWidgets',
+        'pydantic',
+        'pydantic_settings',
+        'pydantic_yaml',
+        'polars',
+        'pyarrow',
+    ] + cx_hiddenimports,
+    hookspath=[],
+    hooksconfig={},
+    runtime_hooks=[],
+    excludes=[],
+    win_no_prefer_redirects=False,
+    win_private_assemblies=False,
+    cipher=block_cipher,
+    noarchive=False,
+)
+
+pyz = PYZ(a.pure, a.zipped_data, cipher=block_cipher)
+
+exe = EXE(
+    pyz,
+    a.scripts,
+    [],
+    exclude_binaries=True,
+    name='DocuMentor',
+    debug=False,
+    bootloader_ignore_signals=False,
+    strip=False,
+    upx=True,
+    console=False,  # Keine Konsole anzeigen (GUI-Anwendung)
+    disable_windowed_traceback=False,
+    argv_emulation=False,
+    target_arch=None,
+    codesign_identity=None,
+    entitlements_file=None,
+    icon=str(project_root / 'resources' / 'icon.ico') if (project_root / 'resources' / 'icon.ico').exists() else None,
+    version=str(project_root / 'version_info.txt') if (project_root / 'version_info.txt').exists() else None,
+)
+
+coll = COLLECT(
+    exe,
+    a.binaries,
+    a.zipfiles,
+    a.datas,
+    strip=False,
+    upx=True,
+    upx_exclude=[],
+    name='DocuMentor',
+)

DocuMentor.wxs

@@ -0,0 +1,86 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Wix xmlns="http://wixtoolset.org/schemas/v4/wxs">
+  
+  <!-- Paket-Definition (ersetzt Product in v4) -->
+  <Package 
+    Name="DocuMentor" 
+    Version="1.6.3"
+    Manufacturer="Vitali Graf / Software- und Datenbankentwicklung" 
+    UpgradeCode="F498B66C-726D-44AA-95F4-CB4FBDCEF26E"
+    Language="1031"
+    Compressed="yes"
+    InstallerVersion="500">
+    
+    <MajorUpgrade 
+      DowngradeErrorMessage="Eine neuere Version ist bereits installiert." 
+      AllowSameVersionUpgrades="yes" />
+    
+    <!-- Media Template -->
+    <MediaTemplate EmbedCab="yes" />
+    
+    <!-- Feature-Definition -->
+    <Feature Id="ProductFeature" Title="DocuMentor" Level="1">
+      <ComponentGroupRef Id="ProductComponents" />
+      <ComponentRef Id="ApplicationShortcut" />
+      <ComponentRef Id="DesktopShortcut" />
+    </Feature>
+    
+    <!-- Minimal UI (Standard Windows Installer Dialog) -->
+    
+    <!-- Icon -->
+    <Icon Id="icon.ico" SourceFile="resources\icon.ico"/>
+    <Property Id="ARPPRODUCTICON" Value="icon.ico" />
+    <Property Id="ARPHELPLINK" Value="https://github.com/IhrRepo/DocuMentor" />
+  </Package>
+
+  <!-- Fragment: Verzeichnisstruktur -->
+  <Fragment>
+    <StandardDirectory Id="ProgramFilesFolder">
+      <Directory Id="INSTALLFOLDER" Name="DocuMentor" />
+    </StandardDirectory>
+    
+    <StandardDirectory Id="ProgramMenuFolder">
+      <Directory Id="ApplicationProgramsFolder" Name="DocuMentor"/>
+    </StandardDirectory>
+    
+    <StandardDirectory Id="DesktopFolder" />
+  </Fragment>
+
+  <!-- Fragment: Shortcuts -->
+  <Fragment>
+    <Component Id="ApplicationShortcut" Directory="ApplicationProgramsFolder" Guid="A498B66C-726D-44AA-95F4-CB4FBDCEF26E">
+      <Shortcut 
+        Id="ApplicationStartMenuShortcut" 
+        Name="DocuMentor" 
+        Description="XSL-Transformations-Verwaltung" 
+        Target="[INSTALLFOLDER]DocuMentor.exe" 
+        WorkingDirectory="INSTALLFOLDER" 
+        Icon="icon.ico" />
+      <RemoveFolder Id="CleanUpShortCut" On="uninstall"/>
+      <RegistryValue 
+        Root="HKCU" 
+        Key="Software\DocuMentor" 
+        Name="installed" 
+        Type="integer" 
+        Value="1" 
+        KeyPath="yes"/>
+    </Component>
+
+    <Component Id="DesktopShortcut" Directory="DesktopFolder" Guid="B498B66C-726D-44AA-95F4-CB4FBDCEF26E">
+      <Shortcut 
+        Id="DesktopShortcutId" 
+        Name="DocuMentor" 
+        Target="[INSTALLFOLDER]DocuMentor.exe" 
+        WorkingDirectory="INSTALLFOLDER" 
+        Icon="icon.ico" />
+      <RegistryValue 
+        Root="HKCU" 
+        Key="Software\DocuMentor" 
+        Name="desktopShortcut" 
+        Type="integer" 
+        Value="1" 
+        KeyPath="yes"/>
+    </Component>
+  </Fragment>
+  
+</Wix>

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 [Ihr Name / Your Name]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

LICENSES.md

@@ -0,0 +1,260 @@
+# Lizenzübersicht für DocuMentor
+
+## Verwendete Bibliotheken und ihre Lizenzen
+
+### Python-Abhängigkeiten (aus pyproject.toml)
+
+| Bibliothek | Version | Lizenz | Einschränkungen |
+|------------|---------|--------|-----------------|
+| **PySide6** | ≥6.9.1 | **LGPL-3.0 ODER GPL-2.0 ODER GPL-3.0** | ⚠️ Copyleft-Lizenz, siehe unten |
+| Pydantic | ≥2.9.1 | MIT | ✅ Keine Einschränkungen |
+| Pydantic-Settings | ≥2.9.1 | MIT | ✅ Keine Einschränkungen |
+| Pydantic-YAML | ≥1.5.1 | MIT | ✅ Keine Einschränkungen |
+| Polars | ≥1.31.0 | MIT | ✅ Keine Einschränkungen |
+| ConnectorX | (via Polars) | MIT | ✅ Keine Einschränkungen |
+| PyArrow | (via Polars) | Apache 2.0 | ✅ Keine Einschränkungen |
+| pyqtdarktheme | ≥2.1.0 | MIT | ✅ Keine Einschränkungen |
+| Ruff | ≥0.14.8 | MIT | ✅ Keine Einschränkungen (nur Dev) |
+
+### Externe Tools (nicht in Python integriert)
+
+| Tool | Lizenz | Verwendung | Einschränkungen |
+|------|--------|------------|-----------------|
+| **Saxon-HE** | Mozilla Public License 2.0 (MPL-2.0) | XSLT-Transformationen | ⚠️ Weak Copyleft |
+| **Apache FOP** | Apache License 2.0 | PDF-Generierung | ✅ Keine Einschränkungen |
+| diff-pdf | GPL-2.0 (vermutlich) | PDF-Vergleich | ⚠️ Nur externes Tool |
+
+---
+
+## Kritische Lizenz: PySide6 (LGPL-3.0)
+
+### Was bedeutet LGPL-3.0 für DocuMentor?
+
+**LGPL (Lesser GNU Public License)** ist eine "schwächere" Version der GPL und wurde speziell für Bibliotheken entwickelt.
+
+#### ✅ Was ist ERLAUBT:
+- **Kommerzielle Nutzung** - Du kannst DocuMentor verkaufen
+- **Proprietärer Code** - Dein Code muss NICHT Open Source sein
+- **Private Nutzung** - Keine Verpflichtungen
+- **Dynamisches Linking** - In Python automatisch gegeben (via pip/import)
+
+#### ⚠️ Was ist ERFORDERLICH:
+1. **LGPL-Lizenztext beilegen** - Du musst die LGPL-Lizenz mit verteilen
+2. **Copyright-Hinweise** - Erwähne PySide6 und Qt in deiner Software
+3. **Nutzern Bibliotheks-Austausch ermöglichen** - Bei Python automatisch erfüllt, da:
+   - Nutzer können `pip install pyside6==andere-version` ausführen
+   - Python-Module sind dynamisch geladen
+4. **Änderungen an PySide6 veröffentlichen** - Falls du PySide6 selbst änderst (sehr unwahrscheinlich)
+
+#### ❌ Was ist NICHT erforderlich:
+- **Dein eigener Code** muss NICHT unter LGPL stehen
+- **Dein Source Code** muss NICHT veröffentlicht werden
+- **Deine Änderungen** an DocuMentor müssen NICHT Open Source sein
+
+### Praktische Umsetzung für Python-Anwendungen
+
+Da Python-Pakete über pip installiert werden und dynamisch importiert werden, sind die LGPL-Anforderungen bereits erfüllt:
+- ✅ Dynamisches Linking durch `import PySide6`
+- ✅ Nutzer können andere PySide6-Versionen installieren
+- ✅ Keine statische Kompilierung in Binary
+
+**Fazit:** Du kannst DocuMentor unter praktisch jeder Lizenz veröffentlichen, auch proprietär.
+
+---
+
+## Empfohlene Lizenzen für DocuMentor
+
+### Option 1: MIT License (EMPFOHLEN) ⭐
+
+**Vorteile:**
+- ✅ Einfachste und permissivste Lizenz
+- ✅ Kompatibel mit LGPL und allen anderen verwendeten Lizenzen
+- ✅ Erlaubt kommerzielle Nutzung ohne Einschränkungen
+- ✅ Kurz und leicht verständlich
+- ✅ Sehr verbreitet in der Open-Source-Community
+- ✅ Gleiche Lizenz wie die meisten Dependencies (Pydantic, Polars, etc.)
+
+**Nachteile:**
+- Kein Patent-Schutz
+- Keine Copyleft-Schutz (andere können proprietäre Forks erstellen)
+
+**Wann verwenden:**
+Wenn du maximale Freiheit für Nutzer möchtest und Open Source fördern willst, ohne strenge Bedingungen.
+
+---
+
+### Option 2: Apache License 2.0
+
+**Vorteile:**
+- ✅ Kompatibel mit allen Dependencies
+- ✅ Expliziter Patent-Schutz
+- ✅ Erlaubt kommerzielle Nutzung
+- ✅ Professioneller für größere Projekte
+- ✅ Gleiche Lizenz wie Apache FOP
+
+**Nachteile:**
+- Etwas komplexer als MIT
+- Erfordert NOTICE-Datei für Änderungen
+
+**Wann verwenden:**
+Wenn du Patent-Schutz möchtest und ein professionelleres Image für Enterprise-Nutzer brauchst.
+
+---
+
+### Option 3: GPL-3.0 (Copyleft)
+
+**Vorteile:**
+- ✅ Kompatibel mit PySide6 (gleiche Lizenz)
+- ✅ Starker Copyleft-Schutz - Alle Derivate müssen Open Source sein
+- ✅ Schützt vor proprietären Forks
+- ✅ Für reine Open-Source-Projekte ideal
+
+**Nachteile:**
+- ❌ Strenge Copyleft-Anforderungen
+- ❌ Nutzer können DocuMentor nicht in proprietäre Software integrieren
+- ❌ Weniger flexibel für kommerzielle Nutzung
+
+**Wann verwenden:**
+Wenn du sicherstellen willst, dass alle Modifikationen Open Source bleiben.
+
+---
+
+### Option 4: LGPL-3.0
+
+**Vorteile:**
+- ✅ Gleiche Lizenz wie PySide6 (konsistent)
+- ✅ Schwächerer Copyleft als GPL
+- ✅ Erlaubt Verwendung in proprietärer Software
+
+**Nachteile:**
+- Komplexere Anforderungen als MIT/Apache
+- Weniger verbreitet für Anwendungen (eher für Bibliotheken)
+
+**Wann verwenden:**
+Wenn du einen Kompromiss zwischen GPL und MIT möchtest.
+
+---
+
+## Lizenz-Kompatibilitätsmatrix
+
+```
+DocuMentor Lizenz → Kompatibilität mit Dependencies
+
+MIT                 ✅ Kompatibel mit allen
+Apache 2.0          ✅ Kompatibel mit allen
+GPL-3.0             ✅ Kompatibel mit allen
+LGPL-3.0            ✅ Kompatibel mit allen
+Proprietär          ✅ Kompatibel mit allen (LGPL-Bedingungen beachten)
+```
+
+Alle genannten Lizenzen sind mit den verwendeten Bibliotheken kompatibel!
+
+---
+
+## Konkrete Empfehlung
+
+### Für DocuMentor: **MIT License** ⭐
+
+**Begründung:**
+1. ✅ Die meisten Dependencies (Pydantic, Polars, pyqtdarktheme) sind MIT-lizenziert
+2. ✅ LGPL-3.0 (PySide6) erlaubt die Verwendung in MIT-lizenzierter Software
+3. ✅ Maximale Freiheit für Nutzer und Entwickler
+4. ✅ Einfach und unkompliziert
+5. ✅ Fördert Adoption und Beiträge
+
+---
+
+## Nächste Schritte
+
+### 1. LICENSE-Datei erstellen
+
+Erstelle eine `LICENSE` Datei im Root-Verzeichnis mit dem MIT-Lizenztext:
+
+```
+MIT License
+
+Copyright (c) 2025 [Dein Name]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
+### 2. pyproject.toml aktualisieren
+
+```toml
+[project]
+name = "DocuMentor"
+version = "0.1.0"
+license = {text = "MIT"}  # Füge diese Zeile hinzu
+# ... rest bleibt gleich
+```
+
+### 3. Copyright-Hinweise hinzufügen
+
+Füge in jede Quellcode-Datei einen Header ein:
+
+```python
+# Copyright (c) 2025 [Dein Name]
+# Licensed under the MIT License
+```
+
+### 4. THIRD_PARTY_LICENSES.txt erstellen
+
+Erstelle eine Datei, die alle verwendeten Bibliotheken und ihre Lizenzen auflistet:
+
+```
+DocuMentor verwendet folgende Open-Source-Bibliotheken:
+
+1. PySide6 - LGPL-3.0 OR GPL-2.0 OR GPL-3.0
+   https://www.qt.io/qt-for-python
+
+2. Pydantic - MIT License
+   https://github.com/pydantic/pydantic
+
+3. Polars - MIT License
+   https://github.com/pola-rs/polars
+
+... (alle weiteren Bibliotheken)
+```
+
+---
+
+## Externe Tools (Saxon, Apache FOP)
+
+**Wichtig:** Saxon-HE und Apache FOP sind **externe Programme**, die nicht in DocuMentor eingebettet sind.
+
+- **Saxon-HE**: MPL-2.0 - Du darfst es verwenden, musst aber nicht deine Software unter MPL lizenzieren
+- **Apache FOP**: Apache 2.0 - Kompatibel mit MIT
+
+Da diese Tools nur **aufgerufen** werden (nicht eingebettet), hast du keine zusätzlichen Verpflichtungen.
+
+---
+
+## Quellen
+
+- [PySide6 License](https://doc.qt.io/qtforpython-6/licenses.html)
+- [Pydantic MIT License](https://github.com/pydantic/pydantic/blob/main/LICENSE)
+- [Polars License](https://github.com/pola-rs/polars)
+- [PyQtDarkTheme License](https://github.com/5yutan5/PyQtDarkTheme)
+- [Apache FOP License](https://xmlgraphics.apache.org/fop/license.html)
+- [Saxon License](https://github.com/Saxonica/Saxon-HE)
+
+---
+
+**Stand:** Januar 2025
+**Autor:** Lizenzanalyse für DocuMentor

README.md

@@ -0,0 +1,151 @@
+# DocuMentor
+
+**Professionelle XSL-Transformations-Verwaltung und PDF-Generierung**
+
+DocuMentor (ehemals xsl-validator) ist eine leistungsstarke PySide6-basierte Desktop-Anwendung zur Verwaltung und Validierung von XSL-Transformationen mit automatischer PDF-Generierung. Die Anwendung bietet eine intuitive GUI zur Konfiguration von Transformations-Toolchains (Saxon, Apache FOP, diff-pdf) und zur Verwaltung komplexer PDF-Generierungsprojekte mit PostgreSQL-Datenbankintegration.
+
+## Features
+
+### 🌳 Hierarchische Projektverwaltung
+- Organisieren Sie Ihre XSL-Transformationen in einer übersichtlichen Baumstruktur
+- Flexible Workflow-Definitionen mit verschachtelten Knoten
+- Projektspezifische Konfiguration mit `project.yaml`
+
+### ⚡ Asynchrone Batch-Verarbeitung
+- Verarbeiten Sie große Mengen von XML-Dateien im Hintergrund
+- Fortschrittsanzeige für lange Transformationen
+- 4x schnellere XSLT-Transformationen durch Worker-Pool-Architektur
+
+### 🔍 Intelligente Duplikatserkennung
+- Automatische Hash-basierte Erkennung von identischen XML-Dateien (Blake2b)
+- Verhindert Redundanzen und spart Speicherplatz
+- Asynchrone Hash-Berechnung im Hintergrund
+
+### 📄 PDF-Vergleichsansicht
+- Drei-Panel-Ansicht (Referenz, Diff, Neu)
+- Alpha-Blending für visuellen Vergleich
+- Zoom- und Pan-Funktionalität
+
+### 🗄️ PostgreSQL-Integration
+- Nahtlose Datenbankanbindung mit Polars und ConnectorX
+- Performante SQL-Abfragen und Datenverarbeitung
+- SSL-Modus-Unterstützung
+
+### 🛠️ Konfigurierbare Toolchains
+- Flexible Verwaltung von Saxon, Apache FOP und diff-pdf
+- Versionierung von Tools
+- Plattformübergreifende Unterstützung (Linux, Windows, macOS)
+
+### 🎨 Modernes UI
+- Dark-Theme-Unterstützung via `qdarktheme`
+- Drag-and-Drop für XML-Dateien
+- Responsive und intuitive Benutzeroberfläche
+
+## Installation
+
+### Voraussetzungen
+
+- Python 3.13 oder höher
+- [uv](https://github.com/astral-sh/uv) Paketmanager
+
+### Abhängigkeiten installieren
+
+```bash
+# Mit uv (empfohlen)
+uv sync
+
+# Oder mit pip
+pip install -e .
+```
+
+### Externe Tools (optional)
+
+Für die volle Funktionalität benötigen Sie:
+
+- **Saxon-HE**: XSLT 3.0 Prozessor ([Download](https://www.saxonica.com/download/))
+- **Apache FOP**: PDF-Generierung aus XSL-FO ([Download](https://xmlgraphics.apache.org/fop/download.html))
+- **diff-pdf**: PDF-Vergleich ([GitHub](https://github.com/vslavik/diff-pdf))
+
+## Verwendung
+
+### Anwendung starten
+
+```bash
+uv run python src/main.py
+```
+
+### Projekt erstellen
+
+1. Legen Sie ein neues Projekt an
+2. Konfigurieren Sie Ihre Tools (Saxon, Apache FOP) in den Einstellungen
+3. Organisieren Sie XSL-Stylesheets und XML-Dateien in der Baumstruktur
+4. Führen Sie Transformationen aus
+
+### Konfiguration
+
+Die Anwendung speichert Konfigurationsdateien an folgenden Orten:
+
+- **Linux**: `~/.config/DocuMentor/config.json`
+- **Windows**: `%APPDATA%\DocuMentor\config.json`
+- **macOS**: `~/Library/Application Support/DocuMentor/config.json`
+
+Projektdaten werden in `project.yaml` im jeweiligen Projektverzeichnis gespeichert.
+
+## Entwicklung
+
+### Code-Qualität
+
+```bash
+# Code-Style prüfen
+uv run ruff check
+
+# Code formatieren
+uv run ruff format
+```
+
+### Tests
+
+```bash
+# Hash-Implementierung testen
+uv run python test_hash_implementation.py
+
+# Duplikatserkennung testen
+uv run python test_xml_hash_duplicate_detection.py
+```
+
+### Architektur
+
+- **PySide6**: Native Qt-basierte GUI
+- **Pydantic**: Typsichere Konfigurationsverwaltung
+- **Polars**: Lightning-fast DataFrame-Verarbeitung
+- **Blake2b**: Kryptographische Hash-Funktion für Integritätsprüfung
+
+Siehe [CLAUDE.md](CLAUDE.md) für detaillierte Entwicklerdokumentation.
+
+## Lizenz
+
+DocuMentor ist unter der [MIT License](LICENSE) lizenziert.
+
+### Third-Party-Lizenzen
+
+Diese Software verwendet folgende Open-Source-Bibliotheken:
+
+- **PySide6** - LGPL-3.0 OR GPL-2.0 OR GPL-3.0
+- **Pydantic** - MIT License
+- **Polars** - MIT License
+- **pyqtdarktheme** - MIT License
+- Weitere siehe [THIRD_PARTY_LICENSES.txt](THIRD_PARTY_LICENSES.txt)
+
+Externe Tools (separat zu installieren):
+- **Saxon-HE** - Mozilla Public License 2.0
+- **Apache FOP** - Apache License 2.0
+
+Vollständige Lizenzanalyse: [LICENSES.md](LICENSES.md)
+
+## Danksagungen
+
+Vielen Dank an alle Entwickler der verwendeten Open-Source-Bibliotheken!
+
+---
+
+**DocuMentor** - Professionelle XSL-Transformations-Verwaltung für anspruchsvolle Projekte

THIRD_PARTY_LICENSES.txt

@@ -0,0 +1,257 @@
+================================================================================
+THIRD PARTY LICENSES
+================================================================================
+
+DocuMentor verwendet die folgenden Open-Source-Bibliotheken und Tools.
+Vielen Dank an alle Entwickler und Maintainer dieser Projekte!
+
+================================================================================
+Python-Abhängigkeiten
+================================================================================
+
+1. PySide6
+   Version: >=6.10.1
+   Lizenz: LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+   Webseite: https://www.qt.io/qt-for-python
+   GitHub: https://github.com/qt/pyside-pyside-setup
+   Beschreibung: Qt for Python - Official Python bindings for Qt
+   Copyright: Copyright (C) The Qt Company Ltd.
+
+2. Pydantic
+   Version: >=2.12.0
+   Lizenz: MIT License
+   Webseite: https://pydantic.dev
+   GitHub: https://github.com/pydantic/pydantic
+   Beschreibung: Data validation using Python type hints
+   Copyright: Copyright (c) 2017 to present Pydantic Services Inc.
+
+3. Pydantic-Settings
+   Version: >=2.12.0
+   Lizenz: MIT License
+   GitHub: https://github.com/pydantic/pydantic-settings
+   Beschreibung: Settings management using Pydantic
+   Copyright: Copyright (c) 2023 Pydantic Services Inc.
+
+4. Pydantic-YAML
+   Version: >=1.6.0
+   Lizenz: MIT License
+   GitHub: https://github.com/NowanIlfideme/pydantic-yaml
+   Beschreibung: YAML support for Pydantic models
+   Copyright: Copyright (c) 2020 Anatoly Makarevich
+
+5. Polars
+   Version: >=1.37.0
+   Lizenz: MIT License
+   Webseite: https://pola.rs
+   GitHub: https://github.com/pola-rs/polars
+   Beschreibung: Lightning-fast DataFrame library
+   Copyright: Copyright (c) 2025 Ritchie Vink
+
+6. ConnectorX (via Polars)
+   Lizenz: MIT License
+   GitHub: https://github.com/sfu-db/connector-x
+   Beschreibung: Fast database connector for DataFrames
+   Copyright: Copyright (c) 2021 SFU Database Group
+
+7. PyArrow (via Polars)
+   Lizenz: Apache License 2.0
+   Webseite: https://arrow.apache.org/docs/python/
+   GitHub: https://github.com/apache/arrow
+   Beschreibung: Python library for Apache Arrow
+   Copyright: Copyright (c) 2016-2025 The Apache Software Foundation
+
+8. psutil
+   Version: >=6.1.1
+   Lizenz: BSD-3-Clause License
+   GitHub: https://github.com/giampaolo/psutil
+   Beschreibung: Cross-platform lib for process and system monitoring
+   Copyright: Copyright (c) 2009 Giampaolo Rodola
+
+9. lxml
+   Version: >=6.0.2
+   Lizenz: BSD-3-Clause License
+   Webseite: https://lxml.de/
+   GitHub: https://github.com/lxml/lxml
+   Beschreibung: Powerful and Pythonic XML processing library combining libxml2/libxslt with the ElementTree API
+   Copyright: Copyright (c) 2004 Infrae. All rights reserved.
+
+10. Ruff (Development)
+   Version: >=0.14.11
+   Lizenz: MIT License
+   GitHub: https://github.com/astral-sh/ruff
+   Beschreibung: An extremely fast Python linter and code formatter
+   Copyright: Copyright (c) 2022 Charlie Marsh
+
+11. PyInstaller (Development)
+   Version: >=6.0.0
+   Lizenz: GPL-2.0 mit Bootloader-Ausnahme
+   Webseite: https://pyinstaller.org
+   GitHub: https://github.com/pyinstaller/pyinstaller
+   Beschreibung: Bundles Python applications into stand-alone executables
+   Copyright: Copyright (c) 2010-2025 PyInstaller Development Team
+
+12. Pillow (Development)
+   Version: >=10.0.0
+   Lizenz: HPND License (Historical Permission Notice and Disclaimer)
+   Webseite: https://python-pillow.org
+   GitHub: https://github.com/python-pillow/Pillow
+   Beschreibung: Python Imaging Library (Fork)
+   Copyright: Copyright (c) 2010-2025 Jeffrey A. Clark and contributors
+
+================================================================================
+Eingebettete Bibliotheken
+================================================================================
+
+Diese Bibliotheken sind direkt im Quellcode von DocuMentor enthalten.
+
+1. vis-network (vis.js)
+   Version: 9.1.9
+   Lizenz: Apache License 2.0 ODER MIT License (Dual-Lizenz)
+   Webseite: https://visjs.github.io/vis-network/
+   GitHub: https://github.com/visjs/vis-network
+   Beschreibung: A dynamic, browser-based network visualization library
+   Copyright: Copyright (c) 2011-2017 Almende B.V, http://almende.com
+              Copyright (c) 2017-2019 visjs contributors, https://github.com/visjs
+   Datei: src/res/vis-network.min.js
+   Hinweis: Wird inline in QWebEngineView für den XSL-Abhängigkeitsgraph verwendet
+
+================================================================================
+Externe Tools (nicht eingebettet)
+================================================================================
+
+Diese Tools werden als externe Programme aufgerufen und sind nicht
+Bestandteil der DocuMentor-Distribution. Sie müssen separat installiert werden.
+
+1. Saxon-HE (Home Edition)
+   Lizenz: Mozilla Public License 2.0 (MPL-2.0)
+   Webseite: https://www.saxonica.com/
+   GitHub: https://github.com/Saxonica/Saxon-HE
+   Beschreibung: XSLT 3.0 and XQuery 3.1 processor
+   Copyright: Copyright (c) Saxonica Limited
+   Hinweis: Für XSLT-Transformationen verwendet
+
+2. Apache FOP (Formatting Objects Processor)
+   Lizenz: Apache License 2.0
+   Webseite: https://xmlgraphics.apache.org/fop/
+   Beschreibung: XSL-FO to PDF converter
+   Copyright: Copyright (c) 1999-2025 The Apache Software Foundation
+   Hinweis: Für PDF-Generierung verwendet
+
+3. diff-pdf
+   Lizenz: GPL-2.0 (vermutlich)
+   GitHub: https://github.com/vslavik/diff-pdf
+   Beschreibung: Tool for visually comparing PDF files
+   Hinweis: Optional für PDF-Vergleich verwendet
+
+================================================================================
+Lizenztexte
+================================================================================
+
+--------------------------------------------------------------------------------
+MIT License
+--------------------------------------------------------------------------------
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+--------------------------------------------------------------------------------
+Apache License 2.0
+--------------------------------------------------------------------------------
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+--------------------------------------------------------------------------------
+BSD-3-Clause License (psutil)
+--------------------------------------------------------------------------------
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+3. Neither the name of the copyright holder nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+--------------------------------------------------------------------------------
+LGPL-3.0 / GPL-2.0 / GPL-3.0 (PySide6)
+--------------------------------------------------------------------------------
+
+PySide6 ist unter LGPL-3.0, GPL-2.0 oder GPL-3.0 lizenziert.
+Die vollständigen Lizenztexte finden Sie unter:
+
+LGPL-3.0: https://www.gnu.org/licenses/lgpl-3.0.html
+GPL-2.0:  https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+GPL-3.0:  https://www.gnu.org/licenses/gpl-3.0.html
+
+Weitere Informationen: https://doc.qt.io/qtforpython-6/licenses.html
+
+--------------------------------------------------------------------------------
+Mozilla Public License 2.0 (Saxon-HE)
+--------------------------------------------------------------------------------
+
+Der vollständige Lizenztext der Mozilla Public License 2.0 ist verfügbar unter:
+https://www.mozilla.org/en-US/MPL/2.0/
+
+================================================================================
+HINWEISE
+================================================================================
+
+1. PySide6 (LGPL-3.0):
+   DocuMentor verwendet PySide6 über dynamisches Linking (Python import).
+   Nutzer können die PySide6-Version über pip austauschen.
+   Der Quellcode von DocuMentor muss nicht unter LGPL veröffentlicht werden.
+
+2. Externe Tools:
+   Saxon-HE, Apache FOP und diff-pdf sind separate Programme, die von
+   DocuMentor aufgerufen werden, aber nicht in die Distribution eingebettet sind.
+   Nutzer müssen diese Tools selbst installieren.
+
+3. Aktualisierungen:
+   Bitte überprüfen Sie regelmäßig die Lizenzen der verwendeten Bibliotheken,
+   da sich diese ändern können.
+
+================================================================================
+Stand: April 2026
+Erstellt für: DocuMentor v1.6.3
+================================================================================

build_msi.py

@@ -0,0 +1,70 @@
+"""
+WiX MSI Build-Skript für DocuMentor (WiX v6)
+
+Erstellt einen MSI-Installer aus dem PyInstaller Build.
+"""
+
+import subprocess
+import sys
+import tomllib
+from pathlib import Path
+
+
+def get_version(project_root: Path) -> str:
+    """Liest die Versionsnummer aus pyproject.toml."""
+    pyproject_path = project_root / "pyproject.toml"
+    with pyproject_path.open("rb") as f:
+        data = tomllib.load(f)
+    return data["project"]["version"]
+
+
+def build_msi():
+    """Erstellt MSI-Installer mit WiX v6."""
+    project_root = Path(__file__).parent
+    dist_dir = project_root / "dist" / "DocuMentor"
+
+    if not dist_dir.exists():
+        print("FEHLER: PyInstaller Build nicht gefunden!")
+        print("Bitte zuerst ausführen: uv run python build_windows.py")
+        sys.exit(1)
+
+    version = get_version(project_root)
+    msi_output = project_root / "dist" / f"DocuMentor-{version}.msi"
+
+    print(f"DocuMentor Build gefunden: {dist_dir}")
+    print(f"Version: {version}")
+    print(f"MSI-Ausgabe: {msi_output}")
+    print()
+
+    # Schritt 1: ProductFiles.wxs generieren (ersetzt WiX heat)
+    print("Schritt 1/2: Generiere ProductFiles.wxs...")
+    result = subprocess.run(["uv", "run", "python", "generate_wix_files.py"], check=False)
+
+    if result.returncode != 0:
+        print("\nFEHLER: ProductFiles.wxs Generierung fehlgeschlagen!")
+        sys.exit(1)
+
+    print()
+
+    # Schritt 2: MSI kompilieren mit WiX v6
+    print("Schritt 2/2: Kompiliere MSI-Installer...")
+    result = subprocess.run(
+        ["wix", "build", "DocuMentor.wxs", "ProductFiles.wxs", "-o", str(msi_output)],
+        check=False,
+    )
+
+    if result.returncode != 0:
+        print("\nFEHLER: MSI-Kompilierung fehlgeschlagen!")
+        print("Stelle sicher, dass WiX v6 installiert ist:")
+        print("  dotnet tool install --global wix --version 6.*")
+        sys.exit(1)
+
+    print()
+    print(f"[OK] MSI erfolgreich erstellt: {msi_output}")
+    print()
+    print("Installation testen mit:")
+    print(f"  msiexec /i \"{msi_output}\"")
+
+
+if __name__ == "__main__":
+    build_msi()

build_windows.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""
+Build-Skript für Windows-Distribution von DocuMentor
+
+Erstellt:
+1. Eigenständige Executable mit PyInstaller
+2. Optional: ZIP-Archiv für portable Distribution
+"""
+
+import shutil
+import subprocess
+import sys
+import tomllib
+from pathlib import Path
+
+
+def get_version(project_root: Path) -> str:
+    """Liest die Versionsnummer aus pyproject.toml."""
+    with (project_root / "pyproject.toml").open("rb") as f:
+        return tomllib.load(f)["project"]["version"]
+
+
+def main():
+    project_root = Path(__file__).parent
+    dist_dir = project_root / "dist"
+    build_dir = project_root / "build"
+    resources_dir = project_root / "resources"
+    icon_path = resources_dir / "icon.ico"
+    version_info_path = project_root / "version_info.txt"
+
+    print("=" * 60)
+    print("DocuMentor Windows Build")
+    print("=" * 60)
+
+    # 1. Icon und Versionsinformationen generieren
+    print("\n[1/6] Icon und Versionsinformationen generieren...")
+
+    # Icon erstellen falls nicht vorhanden
+    if not icon_path.exists():
+        print("  Erstelle Standard-Icon...")
+        try:
+            subprocess.run([sys.executable, "create_icon.py"], check=True, cwd=project_root)
+            print("  ✓ Icon erstellt")
+        except subprocess.CalledProcessError as e:
+            print(f"  ✗ Icon-Erstellung fehlgeschlagen: {e}")
+            print("  ⚠ Fahre ohne Icon fort...")
+    else:
+        print(f"  ✓ Icon vorhanden: {icon_path.name}")
+
+    # Versionsinformationen erstellen
+    print("  Erstelle Versionsinformationen...")
+    try:
+        subprocess.run([sys.executable, "create_version_info.py"], check=True, cwd=project_root)
+        print("  ✓ Versionsinformationen erstellt")
+    except subprocess.CalledProcessError as e:
+        print(f"  ✗ Versionsinformationen-Erstellung fehlgeschlagen: {e}")
+        print("  ⚠ Fahre ohne Versionsinformationen fort...")
+
+    # 2. Cleanup alter Builds
+    print("\n[2/6] Cleanup alter Builds...")
+    if dist_dir.exists():
+        shutil.rmtree(dist_dir)
+        print("  ✓ dist/ gelöscht")
+    if build_dir.exists():
+        shutil.rmtree(build_dir)
+        print("  ✓ build/ gelöscht")
+
+    # 3. PyInstaller ausführen
+    print("\n[3/6] PyInstaller Build starten...")
+    try:
+        subprocess.run(
+            ["pyinstaller", "--clean", "DocuMentor.spec"],
+            check=True,
+            cwd=project_root
+        )
+        print("  ✓ Build erfolgreich")
+    except subprocess.CalledProcessError as e:
+        print(f"  ✗ Build fehlgeschlagen: {e}")
+        return 1
+
+    # 4. README für Distribution erstellen
+    print("\n[4/6] README erstellen...")
+    readme_content = """DocuMentor - XSL-Transformations-Verwaltung
+============================================
+
+Installation:
+1. Entpacken Sie dieses Archiv in ein Verzeichnis Ihrer Wahl
+2. Führen Sie DocuMentor.exe aus
+
+Externe Abhängigkeiten (separat zu installieren):
+- Java Runtime Environment (JRE) oder JDK
+- Apache FOP (für PDF-Generierung)
+- Saxon XSLT-Prozessor (JAR-Datei)
+- diff-pdf (für PDF-Vergleiche)
+
+Beim ersten Start werden Sie aufgefordert, die Pfade zu diesen
+Tools in den Programmeinstellungen zu konfigurieren.
+
+Konfiguration und Logs:
+- Windows: %APPDATA%\\DocuMentor\\
+- Konfiguration: config.json
+- Logs: logs\\
+
+Support:
+Bei Fragen oder Problemen erstellen Sie bitte ein Issue auf GitHub.
+"""
+
+    readme_path = dist_dir / "DocuMentor" / "README.txt"
+    readme_path.write_text(readme_content, encoding='utf-8')
+    print("  ✓ README.txt erstellt")
+
+    # 5. Icon ins dist-Verzeichnis kopieren (für Installer)
+    print("\n[5/6] Icon für Installer vorbereiten...")
+    if icon_path.exists():
+        dist_icon = dist_dir / "DocuMentor" / "icon.ico"
+        shutil.copy2(icon_path, dist_icon)
+        print("  ✓ Icon kopiert")
+    else:
+        print("  ⚠ Kein Icon vorhanden")
+
+    # 6. ZIP-Archiv erstellen
+    print("\n[6/6] ZIP-Archiv erstellen...")
+    version = get_version(project_root)
+    zip_name = f"DocuMentor-{version}"
+    zip_path = dist_dir / zip_name
+
+    shutil.make_archive(
+        str(zip_path),
+        'zip',
+        dist_dir,
+        'DocuMentor'
+    )
+    print(f"  ✓ {zip_name}.zip erstellt")
+
+    print("\n" + "=" * 60)
+    print("Build abgeschlossen!")
+    print("=" * 60)
+    print(f"\nErgebnisse:")
+    print(f"  • Executable: dist/DocuMentor/DocuMentor.exe")
+    print(f"  • ZIP-Archiv: dist/{zip_name}.zip")
+    print("\nNächste Schritte:")
+    print("  1. Testen Sie DocuMentor.exe auf einem Windows-System")
+    print("  2. Optional: Erstellen Sie einen Installer mit Inno Setup")
+
+    return 0
+
+if __name__ == "__main__":
+    sys.exit(main())

create_icon.py

@@ -0,0 +1,164 @@
+#!/usr/bin/env python3
+"""
+Icon-Generator für DocuMentor
+
+Erstellt ein Icon aus einem PNG oder generiert ein Standard-Icon.
+Unterstützt Windows (.ico) und verschiedene Größen.
+
+Verwendung:
+    python create_icon.py                    # Generiert Standard-Icon
+    python create_icon.py source.png         # Konvertiert PNG zu ICO
+"""
+
+import sys
+from pathlib import Path
+
+try:
+    from PIL import Image, ImageDraw, ImageFont
+except ImportError:
+    print("Fehler: Pillow ist nicht installiert.")
+    print("Installation: uv pip install pillow")
+    sys.exit(1)
+
+
+def create_default_icon(output_path: Path):
+    """Erstellt ein Standard-Icon mit DocuMentor-Branding."""
+    sizes = [256, 128, 64, 48, 32, 16]
+    images = []
+
+    for size in sizes:
+        # Neues Bild erstellen mit Farbverlauf
+        img = Image.new('RGB', (size, size), color='white')
+        draw = ImageDraw.Draw(img)
+
+        # Hintergrund: Blau-Verlauf (vereinfacht als solides Blau)
+        bg_color = (41, 128, 185)  # Professionelles Blau
+        draw.rectangle([0, 0, size, size], fill=bg_color)
+
+        # Dokument-Symbol (vereinfachte Darstellung)
+        margin = size // 8
+        doc_left = margin
+        doc_top = margin
+        doc_right = size - margin
+        doc_bottom = size - margin
+
+        # Weißes Dokument
+        draw.rectangle(
+            [doc_left, doc_top, doc_right, doc_bottom],
+            fill='white',
+            outline=(52, 73, 94),
+            width=max(1, size // 64)
+        )
+
+        # Ecke umgeknickt (rechts oben)
+        fold_size = size // 6
+        points = [
+            (doc_right - fold_size, doc_top),
+            (doc_right, doc_top + fold_size),
+            (doc_right - fold_size, doc_top + fold_size),
+        ]
+        draw.polygon(points, fill=(220, 220, 220), outline=(52, 73, 94))
+
+        # Text-Linien im Dokument (nur bei größeren Icons)
+        if size >= 32:
+            line_margin = doc_left + size // 12
+            line_width = doc_right - doc_left - size // 6
+            line_count = min(3, size // 32)
+            line_spacing = (doc_bottom - doc_top - fold_size) // (line_count + 2)
+
+            for i in range(line_count):
+                y = doc_top + fold_size + line_spacing * (i + 1)
+                draw.rectangle(
+                    [line_margin, y, line_margin + line_width, y + max(1, size // 128)],
+                    fill=(52, 73, 94)
+                )
+
+        # "M" für Mentor (nur bei großen Icons)
+        if size >= 64:
+            try:
+                # Versuche System-Font zu verwenden
+                font_size = size // 4
+                font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", font_size)
+            except:
+                # Fallback auf Default-Font
+                font = ImageFont.load_default()
+
+            text = "M"
+            # Zentrieren (grobe Schätzung)
+            bbox = draw.textbbox((0, 0), text, font=font)
+            text_width = bbox[2] - bbox[0]
+            text_height = bbox[3] - bbox[1]
+            text_x = (size - text_width) // 2
+            text_y = doc_bottom - text_height - margin // 2
+
+            draw.text((text_x, text_y), text, fill=bg_color, font=font)
+
+        images.append(img)
+
+    # Als ICO speichern
+    images[0].save(
+        output_path,
+        format='ICO',
+        sizes=[(img.width, img.height) for img in images],
+        append_images=images[1:]
+    )
+    print(f"✓ Standard-Icon erstellt: {output_path}")
+
+
+def convert_png_to_ico(source_path: Path, output_path: Path):
+    """Konvertiert ein PNG-Bild zu einem Multi-Size ICO."""
+    try:
+        img = Image.open(source_path)
+
+        # Zu RGBA konvertieren falls nötig
+        if img.mode != 'RGBA':
+            img = img.convert('RGBA')
+
+        # Verschiedene Größen erstellen
+        sizes = [256, 128, 64, 48, 32, 16]
+        images = []
+
+        for size in sizes:
+            resized = img.resize((size, size), Image.Resampling.LANCZOS)
+            images.append(resized)
+
+        # Als ICO speichern
+        images[0].save(
+            output_path,
+            format='ICO',
+            sizes=[(img.width, img.height) for img in images],
+            append_images=images[1:]
+        )
+        print(f"✓ Icon erstellt aus {source_path.name}: {output_path}")
+
+    except Exception as e:
+        print(f"✗ Fehler beim Konvertieren: {e}")
+        sys.exit(1)
+
+
+def main():
+    project_root = Path(__file__).parent
+    resources_dir = project_root / "resources"
+    resources_dir.mkdir(exist_ok=True)
+
+    output_ico = resources_dir / "icon.ico"
+
+    if len(sys.argv) > 1:
+        # PNG zu ICO konvertieren
+        source_path = Path(sys.argv[1])
+        if not source_path.exists():
+            print(f"Fehler: Datei nicht gefunden: {source_path}")
+            sys.exit(1)
+
+        convert_png_to_ico(source_path, output_ico)
+    else:
+        # Standard-Icon generieren
+        print("Erstelle Standard-Icon...")
+        create_default_icon(output_ico)
+
+    print(f"\nIcon gespeichert: {output_ico}")
+    print("Das Icon wird automatisch von PyInstaller und Inno Setup verwendet.")
+
+
+if __name__ == "__main__":
+    main()

create_version_info.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""
+Generiert Windows-Versionsinformationen für PyInstaller
+
+Liest Version aus pyproject.toml und erstellt version_info.txt
+"""
+
+import tomllib
+from pathlib import Path
+from datetime import datetime
+
+
+def parse_version(version_str: str) -> tuple[int, int, int, int]:
+    """Parst Version-String (z.B. '0.1.0') zu Tuple (0, 1, 0, 0)."""
+    parts = version_str.split('.')
+    major = int(parts[0]) if len(parts) > 0 else 0
+    minor = int(parts[1]) if len(parts) > 1 else 0
+    patch = int(parts[2]) if len(parts) > 2 else 0
+    build = 0  # Könnte aus Git-Commit-Count generiert werden
+    return (major, minor, patch, build)
+
+
+def create_version_info(project_root: Path):
+    """Erstellt version_info.txt für PyInstaller."""
+
+    # pyproject.toml lesen
+    pyproject_path = project_root / "pyproject.toml"
+    with open(pyproject_path, 'rb') as f:
+        pyproject = tomllib.load(f)
+
+    project = pyproject['project']
+    version = project['version']
+    name = project['name']
+    description = project['description']
+
+    # Version parsen
+    file_version = parse_version(version)
+    product_version = file_version
+
+    # Jahr für Copyright
+    year = datetime.now().year
+
+    # version_info.txt Content
+    version_info_content = f"""# UTF-8
+#
+# Generiert automatisch von create_version_info.py
+# NICHT manuell bearbeiten!
+#
+
+VSVersionInfo(
+  ffi=FixedFileInfo(
+    # filevers und prodvers als Tuple: (1, 0, 0, 0)
+    filevers={file_version},
+    prodvers={product_version},
+    # Maske für gültige Bits in filevers und prodvers
+    mask=0x3f,
+    # Flags - kann VS_FF_DEBUG, VS_FF_PRERELEASE, etc. enthalten
+    flags=0x0,
+    # Betriebssystem - VOS_NT_WINDOWS32
+    OS=0x40004,
+    # Dateityp - VFT_APP (Anwendung)
+    fileType=0x1,
+    # Subtyp (nicht verwendet für VFT_APP)
+    subtype=0x0,
+    # Datumsstempel
+    date=(0, 0)
+  ),
+  kids=[
+    StringFileInfo(
+      [
+      StringTable(
+        '040904B0',  # Deutsch (0x0409 = Englisch, 0x0407 = Deutsch), Unicode
+        [StringStruct('CompanyName', 'Vitali Graf / Software- und Datenbankentwicklung'),
+        StringStruct('FileDescription', '{description}'),
+        StringStruct('FileVersion', '{version}'),
+        StringStruct('InternalName', '{name}'),
+        StringStruct('LegalCopyright', '© {year} Vitali Graf. Alle Rechte vorbehalten.'),
+        StringStruct('OriginalFilename', '{name}.exe'),
+        StringStruct('ProductName', '{name}'),
+        StringStruct('ProductVersion', '{version}')])
+      ]),
+    VarFileInfo([VarStruct('Translation', [1033, 1200])])  # Englisch, Unicode
+  ]
+)
+"""
+
+    # version_info.txt schreiben
+    version_info_path = project_root / "version_info.txt"
+    version_info_path.write_text(version_info_content, encoding='utf-8')
+
+    print("✓ version_info.txt erstellt")
+    print(f"  Version: {version}")
+    print(f"  Datei: {version_info_path}")
+
+
+def main():
+    project_root = Path(__file__).parent
+    create_version_info(project_root)
+
+
+if __name__ == "__main__":
+    main()

docs/Transformation ohne Force - Entscheidungslogik

@@ -0,0 +1,69 @@
+# Transformation ohne Force — Entscheidungslogik
+
+Die zentrale Methode ist `is_up_to_date()` in transform.py:155-180. Sie basiert auf Modifikationszeiten (mtime), nicht auf Hashes.
+
+## Ablauf
+Die Prüfung erfolgt an zwei Stellen in der Pipeline:
+1. Vor Saxon-Transformation (`transform_saxon()`) — transform.py:192-194
+2. Vor PDF-Build (`build_pdf()`) — transform.py:322-324
+
+Beide rufen `is_up_to_date()` auf, die prüft:
+- Existiert die New-PDF?
+- Ist die XML-Datei neuer als die New-PDF?
+- Ist die XSL-Datei neuer als die New-PDF?
+
+Wenn die New-PDF existiert und älter als alle Inputs ist → Transformation wird übersprungen mit `(True, "Übersprungen (aktuell)")`.
+
+## Mermaid-Diagramm
+```mermaid
+flowchart TD
+    A["Transformation gestartet<br/>(force=False)"] --> B{"force == True?"}
+    B -- Ja --> EXEC["Transformation ausführen"]
+    B -- Nein --> C{"New-PDF existiert?"}
+    C -- Nein --> EXEC
+    C -- Ja --> D["mtime der New-PDF ermitteln"]
+    D --> E{"XML-Datei neuer<br/>als New-PDF?"}
+    E -- Ja --> EXEC
+    E -- Nein --> F{"XSL-Datei neuer<br/>als New-PDF?"}
+    F -- Ja --> EXEC
+    F -- Nein --> SKIP["Übersprungen (aktuell)<br/>return (True, 'Übersprungen')"]
+
+    EXEC --> S1["Schritt 1: Saxon<br/>XML → FO"]
+    S1 --> S1OK{"Saxon erfolgreich?"}
+    S1OK -- Nein --> FAIL["Pipeline abgebrochen"]
+    S1OK -- Ja --> S2CHECK{"force == True?<br/>(erneute Prüfung<br/>für build_pdf)"}
+    S2CHECK -- Ja --> S2["Schritt 2: FOP<br/>FO → PDF"]
+    S2CHECK -- Nein --> S2UP{"is_up_to_date()?"}
+    S2UP -- Ja --> S2SKIP["PDF-Build übersprungen"]
+    S2UP -- Nein --> S2
+    S2 --> S3["Schritt 3: diff-pdf<br/>PDF-Vergleich"]
+    S3 --> DONE["Pipeline abgeschlossen"]
+
+    style SKIP fill:#4CAF50,color:#fff
+    style EXEC fill:#2196F3,color:#fff
+    style FAIL fill:#f44336,color:#fff
+    style DONE fill:#4CAF50,color:#fff
+    style S2SKIP fill:#4CAF50,color:#fff
+```
+## Wichtige Details
+- Keine Hash-basierte Prüfung: Die Skip-Logik nutzt ausschließlich `mtime`-Vergleiche, nicht die blake2b-Hashes (die werden nur für Änderungsverfolgung in der UI verwendet).
+- Doppelte Prüfung: `is_up_to_date()` wird sowohl vor Saxon als auch vor FOP aufgerufen — theoretisch könnte Saxon ausgeführt, aber der PDF-Build übersprungen werden.
+- Skip = Erfolg: Ein übersprungener Schritt gilt als erfolgreich `(True, ...)`, die Pipeline läuft weiter.
+- Force-Aufruf: Über das Kontextmenü gibt es explizite Force-Methoden wie `_transform_all_xml_files_force()` in transformation.py.
+
+
+## Erweiterung
+
+```mermaid
+flowchart TD
+    LOAD["Projekt geladen"] --> BUILD["XSL-Abhängigkeitsgraph aufbauen<br/>dict[Path, set[Path]]"]
+    BUILD --> CACHE["Im Speicher halten"]
+
+    TRANSFORM["is_up_to_date() aufgerufen"] --> CHECK{"Graph-Eintrag<br/>vorhanden?"}
+    CHECK -- Nein --> PARSE["XSL parsen, Imports auflösen,<br/>Eintrag erstellen"]
+    PARSE --> MTIME
+    CHECK -- Ja --> STALE{"mtime der XSL<br/>geändert seit letztem Parse?"}
+    STALE -- Ja --> PARSE
+    STALE -- Nein --> MTIME["mtime aller Abhängigkeiten<br/>gegen New-PDF prüfen"]
+    MTIME --> RESULT["Ergebnis"]
+```

docs/icon_and_version_info.md

@@ -0,0 +1,274 @@
+# Icon und Versionsinformationen für Windows-Build
+
+## Übersicht
+
+DocuMentor unterstützt professionelle Windows-Builds mit:
+- **Anwendungs-Icon** in allen benötigten Größen
+- **Windows-Versionsinformationen** (Datei-Eigenschaften)
+- Automatische Integration in Build-Prozess
+
+## Icon-System
+
+### Automatische Icon-Generierung
+
+Das Build-Skript generiert automatisch ein Standard-Icon, falls keins vorhanden ist:
+
+```bash
+uv run python build_windows.py
+```
+
+Falls `resources/icon.ico` nicht existiert, wird automatisch ein Standard-Icon mit DocuMentor-Branding erstellt.
+
+### Manuelles Icon erstellen
+
+#### Option 1: Standard-Icon
+
+```bash
+uv run python create_icon.py
+```
+
+Erstellt ein einfaches Icon mit:
+- Blauem Hintergrund (professionelles Blau: #2980B9)
+- Weißem Dokument-Symbol
+- "M" für Mentor (bei großen Icons)
+- Umgeknickter Ecke
+- Mehreren Größen (16×16 bis 256×256)
+
+#### Option 2: Aus eigenem PNG
+
+```bash
+uv run python create_icon.py mein-logo.png
+```
+
+Konvertiert ein PNG-Bild zu einem Multi-Size Windows-Icon:
+- Unterstützt Transparenz
+- Erstellt alle benötigten Größen
+- Optimiert für verschiedene Bildschirmauflösungen
+
+**PNG-Anforderungen:**
+- Idealerweise 256×256 Pixel oder größer
+- Quadratisches Format
+- PNG oder JPEG Format
+- Transparenter Hintergrund empfohlen
+
+### Icon-Größen
+
+Das ICO-Format enthält folgende Auflösungen:
+
+| Größe   | Verwendung                           |
+|---------|--------------------------------------|
+| 256×256 | Windows 7+, Taskleiste, große Icons  |
+| 128×128 | Windows 7+, große Icons              |
+| 64×64   | Hohe DPI-Displays                    |
+| 48×48   | Standard Desktop-Icon                |
+| 32×32   | Explorer Details-Ansicht             |
+| 16×16   | Kleinstes Icon, Titelleiste          |
+
+### Wo wird das Icon verwendet?
+
+- **DocuMentor.exe** - Anwendungs-Icon
+- **Setup.exe** - Installer-Icon (Inno Setup)
+- **Desktop-Verknüpfung** - Erstellt beim Installieren
+- **Start-Menü** - Windows-Programmgruppe
+- **Taskleiste** - Beim Ausführen
+- **Deinstallations-Programm** - System-Einstellungen
+
+## Versionsinformationen
+
+### Automatische Generierung
+
+Versionsinformationen werden automatisch vom Build-Skript generiert:
+
+```bash
+uv run python build_windows.py
+```
+
+### Manuelle Generierung
+
+```bash
+uv run python create_version_info.py
+```
+
+### Inhalt der Versionsinformationen
+
+Die `version_info.txt` enthält:
+
+```
+FileVersion:        0.1.0.0
+ProductVersion:     0.1.0.0
+CompanyName:        Ihr Name/Organisation
+FileDescription:    Professionelle XSL-Transformations-Verwaltung und PDF-Generierung
+InternalName:       DocuMentor
+LegalCopyright:     © 2026 Ihr Name. Alle Rechte vorbehalten.
+OriginalFilename:   DocuMentor.exe
+ProductName:        DocuMentor
+```
+
+### Version aus pyproject.toml
+
+Die Version wird automatisch aus `pyproject.toml` gelesen:
+
+```toml
+[project]
+name = "DocuMentor"
+version = "0.1.0"
+description = "Professionelle XSL-Transformations-Verwaltung und PDF-Generierung"
+```
+
+### Version ändern
+
+**Schritt 1:** Version in `pyproject.toml` ändern:
+
+```toml
+version = "0.2.0"
+```
+
+**Schritt 2:** Version in `installer.iss` ändern (Zeile 13):
+
+```iss
+#define MyAppVersion "0.2.0"
+```
+
+**Schritt 3:** Build neu ausführen:
+
+```bash
+uv run python build_windows.py
+```
+
+Die Versionsinformationen werden automatisch neu generiert.
+
+### Versionsnummern-Schema
+
+DocuMentor verwendet [Semantic Versioning](https://semver.org/lang/de/):
+
+```
+MAJOR.MINOR.PATCH
+
+0.1.0 → Erste Beta-Version
+1.0.0 → Erste stabile Version
+1.1.0 → Neue Features
+1.1.1 → Bugfixes
+2.0.0 → Breaking Changes
+```
+
+### Windows-Eigenschaften anzeigen
+
+Nach dem Build können Sie die Versionsinformationen in Windows anzeigen:
+
+1. Rechtsklick auf `DocuMentor.exe`
+2. **Eigenschaften** auswählen
+3. Tab **Details** öffnen
+
+Dort sehen Sie:
+- Dateiversion
+- Produktversion
+- Beschreibung
+- Copyright
+- Produktname
+- Original-Dateiname
+
+## Integration in Build-Prozess
+
+### DocuMentor.spec
+
+```python
+exe = EXE(
+    # ...
+    icon=str(project_root / 'resources' / 'icon.ico') if (project_root / 'resources' / 'icon.ico').exists() else None,
+    version=str(project_root / 'version_info.txt') if (project_root / 'version_info.txt').exists() else None,
+)
+```
+
+**Automatische Erkennung:**
+- Icon wird verwendet, falls vorhanden
+- Versionsinformationen werden verwendet, falls vorhanden
+- Build funktioniert auch ohne Icon/Version (mit Warnung)
+
+### installer.iss
+
+```iss
+SetupIconFile=dist\DocuMentor\icon.ico
+UninstallDisplayIcon={app}\DocuMentor.exe
+```
+
+Das Icon wird automatisch vom `build_windows.py` nach `dist/DocuMentor/` kopiert.
+
+## Anpassungen
+
+### Company Name / Copyright
+
+In `create_version_info.py` (Zeile ~65):
+
+```python
+StringStruct('CompanyName', 'Ihr Name/Organisation'),
+StringStruct('LegalCopyright', '© {year} Ihr Name. Alle Rechte vorbehalten.'),
+```
+
+Ändern Sie "Ihr Name/Organisation" auf Ihren tatsächlichen Namen oder Firmennamen.
+
+### Icon-Design
+
+Falls Sie das Standard-Icon anpassen möchten, bearbeiten Sie `create_icon.py`:
+
+**Farben ändern** (Zeile ~31):
+```python
+bg_color = (41, 128, 185)  # Blau - ändern Sie RGB-Werte
+```
+
+**Symbol ändern:**
+- Bearbeiten Sie die `create_default_icon()` Funktion
+- Oder erstellen Sie Ihr eigenes Icon in einem Grafikprogramm
+
+## Best Practices
+
+### Icon-Design
+
+1. **Einfach und klar**: Funktioniert auch bei 16×16 Pixel
+2. **Hoher Kontrast**: Gut lesbar auf hellem und dunklem Hintergrund
+3. **Professionell**: Passend zum Business-Kontext
+4. **Wiedererkennbar**: Symbolisiert die Anwendung
+
+### Versionierung
+
+1. **Semantische Versionierung**: MAJOR.MINOR.PATCH
+2. **Vor jedem Release aktualisieren**
+3. **Git-Tags verwenden**: `git tag v0.1.0`
+4. **GUID beibehalten**: Nie die Inno Setup GUID ändern bei Updates!
+
+## Troubleshooting
+
+### Icon wird nicht angezeigt
+
+**Problem**: DocuMentor.exe zeigt kein Icon
+
+**Lösungen:**
+1. Prüfen ob `resources/icon.ico` existiert
+2. Build neu ausführen: `uv run python build_windows.py`
+3. Windows Icon-Cache löschen und neu starten
+
+### Versionsinformationen fehlen
+
+**Problem**: Eigenschaften → Details zeigt keine Informationen
+
+**Lösungen:**
+1. Prüfen ob `version_info.txt` existiert
+2. `uv run python create_version_info.py` ausführen
+3. Build neu ausführen
+
+### Pillow-Fehler beim Icon-Erstellen
+
+**Problem**: `ImportError: No module named 'PIL'`
+
+**Lösung:**
+```bash
+uv sync --all-groups
+```
+
+Dies installiert Pillow automatisch.
+
+## Weiterführende Informationen
+
+- **PyInstaller Icon-Dokumentation**: https://pyinstaller.org/en/stable/usage.html#icons
+- **Windows ICO Format**: https://en.wikipedia.org/wiki/ICO_(file_format)
+- **Semantic Versioning**: https://semver.org/lang/de/
+- **Pillow Dokumentation**: https://pillow.readthedocs.io/

generate_guid.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+"""
+GUID-Generator für Inno Setup
+
+Generiert eine eindeutige GUID für die AppId in installer.iss
+"""
+
+import uuid
+import sys
+
+
+def main():
+    # GUID generieren
+    guid = uuid.uuid4()
+    guid_str = f"{{{{{str(guid).upper()}}}}}"
+
+    print("=" * 60)
+    print("GUID für Inno Setup AppId")
+    print("=" * 60)
+    print()
+    print("Generierte GUID:")
+    print(f"  {guid_str}")
+    print()
+    print("Anleitung:")
+    print("1. Kopieren Sie die GUID oben")
+    print("2. Öffnen Sie installer.iss")
+    print("3. Suchen Sie nach 'AppId={{' (Zeile ~22)")
+    print("4. Ersetzen Sie die Beispiel-GUID mit Ihrer neuen GUID")
+    print()
+    print("Beispiel:")
+    print(f"  AppId={guid_str}")
+    print()
+    print("WICHTIG:")
+    print("- Die GUID sollte nur EINMAL beim ersten Setup generiert werden")
+    print("- Ändern Sie die GUID NICHT bei Updates, sonst wird die App")
+    print("  als separate Anwendung installiert!")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()

generate_wix_files.py

@@ -0,0 +1,184 @@
+"""
+WiX ProductFiles.wxs Generator
+
+Generiert automatisch eine WXS-Datei mit allen Dateien aus dist/DocuMentor.
+Ersetzt die veraltete 'wix heat' Funktionalität für WiX v6.
+"""
+
+import uuid
+from pathlib import Path
+from xml.etree import ElementTree as ET
+
+
+def generate_guid() -> str:
+    """Generiert eine neue GUID."""
+    return str(uuid.uuid4()).upper()
+
+
+def sanitize_id(name: str) -> str:
+    """
+    Macht einen String WiX-konform für IDs.
+
+    WiX erlaubt nur: A-Z, a-z, 0-9, _, .
+    Darf nicht mit Zahl beginnen.
+    """
+    # Ersetze illegale Zeichen
+    sanitized = name.replace("-", "_").replace(" ", "_").replace(".", "_")
+
+    # Entferne alle anderen nicht erlaubten Zeichen
+    allowed = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_"
+    sanitized = "".join(c if c in allowed else "_" for c in sanitized)
+
+    # Darf nicht mit Zahl beginnen
+    if sanitized and sanitized[0].isdigit():
+        sanitized = f"_{sanitized}"
+
+    return sanitized
+
+
+def create_wix_fragment(dist_dir: Path) -> ET.Element:
+    """
+    Erstellt ein WiX Fragment mit allen Dateien aus dem dist Verzeichnis.
+
+    Args:
+        dist_dir: Pfad zum dist/DocuMentor Verzeichnis
+
+    Returns:
+        ET.Element: Wix Root-Element mit Fragment
+    """
+    # Namespace (WiX v4+)
+    ns = "http://wixtoolset.org/schemas/v4/wxs"
+    ET.register_namespace("", ns)
+
+    # Root Element
+    wix = ET.Element(f"{{{ns}}}Wix")
+    fragment = ET.SubElement(wix, f"{{{ns}}}Fragment")
+    component_group = ET.SubElement(
+        fragment, f"{{{ns}}}ComponentGroup", {"Id": "ProductComponents", "Directory": "INSTALLFOLDER"}
+    )
+
+    # Sammle alle Dateien
+    all_files = sorted(dist_dir.rglob("*"))
+    files_only = [f for f in all_files if f.is_file()]
+
+    print(f"Gefunden: {len(files_only)} Dateien")
+
+    # Gruppiere nach Verzeichnis
+    dirs_dict: dict[Path, list[Path]] = {}
+    for file in files_only:
+        rel_dir = file.parent.relative_to(dist_dir)
+        if rel_dir not in dirs_dict:
+            dirs_dict[rel_dir] = []
+        dirs_dict[rel_dir].append(file)
+
+    # Erstelle Directory Fragments
+    dir_fragment = ET.SubElement(wix, f"{{{ns}}}Fragment")
+
+    # INSTALLFOLDER ist bereits in DocuMentor.wxs definiert
+    directory_ref = ET.SubElement(dir_fragment, f"{{{ns}}}DirectoryRef", {"Id": "INSTALLFOLDER"})
+
+    # Erstelle Verzeichnisstruktur
+    created_dirs = {"INSTALLFOLDER": directory_ref}
+
+    for rel_dir in sorted(dirs_dict.keys()):
+        if rel_dir == Path("."):
+            continue
+
+        parts = rel_dir.parts
+        parent_id = "INSTALLFOLDER"
+
+        for i, part in enumerate(parts):
+            current_path = Path(*parts[: i + 1])
+            dir_id = f"Dir_{sanitize_id(current_path.as_posix().replace('/', '_'))}"
+
+            if dir_id not in created_dirs:
+                parent_elem = created_dirs[parent_id]
+                new_dir = ET.SubElement(parent_elem, f"{{{ns}}}Directory", {"Id": dir_id, "Name": part})
+                created_dirs[dir_id] = new_dir
+                parent_id = dir_id
+            else:
+                parent_id = dir_id
+
+    # Füge Komponenten hinzu
+    component_counter = 0
+
+    for rel_dir, files in sorted(dirs_dict.items()):
+        if rel_dir == Path("."):
+            dir_id = "INSTALLFOLDER"
+        else:
+            dir_id = f"Dir_{sanitize_id(rel_dir.as_posix().replace('/', '_'))}"
+
+        # Erstelle eine Komponente pro Verzeichnis
+        component_id = f"Component_{sanitize_id(dir_id)}"
+        component_counter += 1
+
+        component = ET.SubElement(
+            component_group, f"{{{ns}}}Component", {"Id": component_id, "Directory": dir_id, "Guid": generate_guid()}
+        )
+
+        # Füge alle Dateien des Verzeichnisses hinzu
+        for idx, file in enumerate(files):
+            file_id = f"File_{sanitize_id(component_id)}_{idx}"
+            # Absoluter Pfad für WiX
+            source_path = str(file).replace("/", "\\")
+
+            file_attribs = {"Id": file_id, "Source": source_path, "Name": file.name}
+
+            # Erste Datei ist KeyPath
+            if idx == 0:
+                file_attribs["KeyPath"] = "yes"
+
+            ET.SubElement(component, f"{{{ns}}}File", file_attribs)
+
+    print(f"Erstellt: {component_counter} Komponenten")
+
+    return wix
+
+
+def format_xml(element: ET.Element, level: int = 0) -> None:
+    """Formatiert XML mit Einrückungen (in-place)."""
+    indent = "  "
+    i = f"\n{indent * level}"
+
+    if len(element):
+        if not element.text or not element.text.strip():
+            element.text = i + indent
+        if not element.tail or not element.tail.strip():
+            element.tail = i
+        last_child = None
+        for child in element:
+            format_xml(child, level + 1)
+            last_child = child
+        if last_child is not None and (not last_child.tail or not last_child.tail.strip()):
+            last_child.tail = i
+    else:
+        if level and (not element.tail or not element.tail.strip()):
+            element.tail = i
+
+
+def main():
+    """Hauptfunktion."""
+    dist_dir = Path("dist/DocuMentor")
+    output_file = Path("ProductFiles.wxs")
+
+    if not dist_dir.exists():
+        print(f"FEHLER: {dist_dir} existiert nicht!")
+        print("Führe zuerst 'uv run pyinstaller DocuMentor.spec' aus.")
+        return
+
+    print(f"Generiere ProductFiles.wxs aus {dist_dir}...")
+
+    wix_root = create_wix_fragment(dist_dir)
+    format_xml(wix_root)
+
+    # Schreibe XML
+    tree = ET.ElementTree(wix_root)
+    tree.write(output_file, encoding="utf-8", xml_declaration=True)
+
+    print(f"[OK] {output_file} erfolgreich erstellt!")
+    print(f"\nNaechste Schritte:")
+    print(f"1. wix build DocuMentor.wxs ProductFiles.wxs -o DocuMentor.msi")
+
+
+if __name__ == "__main__":
+    main()

installer.iss

@@ -0,0 +1,73 @@
+; Inno Setup Konfiguration für DocuMentor
+; Erstellt eine professionelle Setup.exe für Windows
+;
+; Installation von Inno Setup: https://jrsoftware.org/isdl.php
+;
+; WICHTIG: Vor dem ersten Build GUID generieren!
+;   python -c "import uuid; print(f'{{{{' + str(uuid.uuid4()).upper() + '}}}}')"
+;   Ergebnis in AppId unten einfügen
+;
+; Build-Befehl: iscc installer.iss
+
+#define MyAppName "DocuMentor"
+#define MyAppVersion "1.6.3"
+#define MyAppPublisher "Ihr Name/Organisation"
+#define MyAppURL "https://github.com/yourusername/xsl-validator"
+#define MyAppExeName "DocuMentor.exe"
+
+[Setup]
+; Basis-Informationen
+; WICHTIG: Ersetzen Sie die GUID mit einer eigenen generierten GUID!
+; AppId={{BEISPIEL-GUID-HIER-EINFÜGEN}}
+AppId={{A1B2C3D4-E5F6-4789-ABCD-EF0123456789}}
+AppName={#MyAppName}
+AppVersion={#MyAppVersion}
+AppPublisher={#MyAppPublisher}
+AppPublisherURL={#MyAppURL}
+AppSupportURL={#MyAppURL}
+AppUpdatesURL={#MyAppURL}
+
+; Installation
+DefaultDirName={autopf}\{#MyAppName}
+DefaultGroupName={#MyAppName}
+AllowNoIcons=yes
+
+; Output
+OutputDir=dist\installer
+OutputBaseFilename=DocuMentor-Setup-{#MyAppVersion}
+SetupIconFile=dist\DocuMentor\icon.ico
+UninstallDisplayIcon={app}\{#MyAppExeName}
+
+; Kompression
+Compression=lzma
+SolidCompression=yes
+
+; Moderne UI
+WizardStyle=modern
+
+; Rechte (normal für User-Installation, admin für System-weite Installation)
+PrivilegesRequired=lowest
+PrivilegesRequiredOverridesAllowed=dialog
+
+[Languages]
+Name: "german"; MessagesFile: "compiler:Languages\German.isl"
+Name: "english"; MessagesFile: "compiler:Default.isl"
+
+[Tasks]
+Name: "desktopicon"; Description: "{cm:CreateDesktopIcon}"; GroupDescription: "{cm:AdditionalIcons}"; Flags: unchecked
+
+[Files]
+; Alle Dateien aus dem PyInstaller-Build
+Source: "dist\DocuMentor\*"; DestDir: "{app}"; Flags: ignoreversion recursesubdirs createallsubdirs
+
+[Icons]
+Name: "{group}\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}"
+Name: "{group}\{cm:UninstallProgram,{#MyAppName}}"; Filename: "{uninstallexe}"
+Name: "{autodesktop}\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}"; Tasks: desktopicon
+
+[Run]
+Filename: "{app}\{#MyAppExeName}"; Description: "{cm:LaunchProgram,{#StringChange(MyAppName, '&', '&&')}}"; Flags: nowait postinstall skipifsilent
+
+[Messages]
+; Deutsche Anpassungen
+german.WelcomeLabel2=Dies wird [name/ver] auf Ihrem Computer installieren.%n%nBitte stellen Sie sicher, dass folgende externe Tools installiert sind:%n• Java Runtime Environment (JRE)%n• Apache FOP%n• Saxon XSLT-Prozessor%n• diff-pdf

pyproject.toml

@@ -1,15 +1,18 @@
 [project]
 name = "DocuMentor"
-version = "0.1.0"
+version = "1.6.3"
-description = "Add your description here"
+description = "Professionelle XSL-Transformations-Verwaltung und PDF-Generierung"
 readme = "README.md"
-requires-python = ">=3.13"
+license = {text = "MIT"}
+requires-python = ">=3.13,<3.15"
 dependencies = [
-    "pyqtdarktheme>=2.1.0",
+    "pydantic-settings>=2.12.0",
-    "pydantic-settings>=2.9.1",
+    "pyside6>=6.10.1",
-    "pyside6>=6.9.1",
+    "polars[connectorx,pyarrow]>=1.37.0",
-    "polars[connectorx,pyarrow]>=1.31.0",
+    "connectorx>=0.4.0",
-    "pydantic-yaml>=1.5.1",
+    "pydantic-yaml>=1.6.0",
+    "psutil>=6.1.1",
+    "lxml>=6.0.2",
 ]
 
 [tool.ruff]
@@ -24,5 +27,7 @@ extend-exclude = ["*_ui.py"]
 
 [dependency-groups]
 dev = [
-    "ruff>=0.14.8",
+    "ruff>=0.14.11",
+    "pyinstaller>=6.0.0",
+    "pillow>=10.0.0",
 ]

resources/README.md

@@ -0,0 +1,64 @@
+# Resources für DocuMentor
+
+Dieses Verzeichnis enthält Ressourcen für den Windows-Build.
+
+## Icon (icon.ico)
+
+Das Icon wird verwendet für:
+- Windows-Executable (DocuMentor.exe)
+- Inno Setup Installer
+- Desktop-Verknüpfungen
+- Start-Menü-Einträge
+
+### Icon erstellen
+
+#### Automatisch (Standard-Icon):
+```bash
+python create_icon.py
+```
+
+Dies erstellt ein einfaches Standard-Icon mit DocuMentor-Branding.
+
+#### Aus eigenem PNG-Bild:
+```bash
+python create_icon.py mein-icon.png
+```
+
+Ihr PNG sollte idealerweise:
+- Mindestens 256x256 Pixel groß sein
+- Quadratisch sein
+- Transparenten Hintergrund haben (optional)
+
+### Icon-Anforderungen
+
+Das `.ico`-Dateiformat enthält mehrere Auflösungen:
+- 256x256 (Windows 7+, Taskleiste)
+- 128x128
+- 64x64
+- 48x48 (Standard Desktop-Icon)
+- 32x32 (Explorer Details)
+- 16x16 (kleines Icon)
+
+Das `create_icon.py` Skript erstellt automatisch alle diese Größen.
+
+## Icon manuell ersetzen
+
+1. Eigenes Icon als `resources/icon.ico` speichern
+2. Oder mit einem Online-Tool PNG→ICO konvertieren
+3. Build-Skript verwendet automatisch die vorhandene Datei
+
+## Design-Richtlinien
+
+Falls Sie ein eigenes Icon erstellen:
+- **Einfach und klar**: Funktioniert auch in kleinen Größen (16x16)
+- **Professionell**: Passend zum Business-Kontext
+- **Wiedererkennbar**: DocuMentor steht für Dokumenten-Management
+- **Kontrast**: Gut sichtbar auf hellem und dunklem Hintergrund
+
+## Weitere Ressourcen
+
+In diesem Verzeichnis können später weitere Ressourcen abgelegt werden:
+- Splash-Screen-Bilder
+- Toolbar-Icons
+- Dokumentations-Bilder
+- etc.

resources/gemini_icon_prompt.txt

@@ -0,0 +1,45 @@
+Erstelle ein professionelles Icon für eine Desktop-Anwendung namens "DocuMentor".
+
+Die Anwendung wird verwendet für:
+- Verwaltung von XSL-Transformationen
+- Umwandlung von XML-Dokumenten zu PDF-Dateien
+- Vergleich und Validierung von PDF-Dokumenten
+
+Design-Anforderungen:
+
+1. Stil: Minimalistisch, modern, professionell, business-orientiert
+
+2. Farben:
+   - Hauptfarbe: Blau (#2980B9 oder ähnlich)
+   - Akzentfarbe: Weiß oder helles Grau
+   - Maximal 2-3 Farben insgesamt
+
+3. Elemente (wähle eine Kombination):
+   - Dokument-Symbol (Papier/Seite)
+   - Transformation/Workflow-Element (Pfeil, Zahnrad)
+   - Optional: Stilisierter Buchstabe "M" oder "D"
+
+4. Technische Anforderungen:
+   - Quadratisches Format
+   - Einfache, klare Linien
+   - Hoher Kontrast
+   - Muss auch bei 16x16 Pixel noch erkennbar sein
+   - Flat Design (keine 3D-Effekte)
+   - Keine Farbverläufe
+
+5. Hintergrund:
+   - Transparent ODER
+   - Einfarbig (blau oder weiß)
+
+6. Referenz-Stil:
+   - Ähnlich wie Microsoft Office Icons
+   - Ähnlich wie Visual Studio Code Icons
+   - Moderne SaaS-Anwendungs-Icons
+
+Bitte erstelle ein Icon, das:
+- Professionell und vertrauenswürdig wirkt
+- Für technische Anwender geeignet ist
+- Gut in einer Windows-Taskleiste aussieht
+- Auch als Desktop-Verknüpfung funktioniert
+
+Format: PNG oder SVG, mindestens 512x512 Pixel

resources/icon_prompt.md

@@ -0,0 +1,150 @@
+# Icon-Prompt für Bild-Generierungs-KI
+
+## DocuMentor Logo/Icon
+
+### Deutsche Version (für deutsche KI-Tools)
+
+```
+Erstelle ein professionelles, minimalistisches SVG-Icon für eine Business-Software namens "DocuMentor".
+
+Anwendungsbeschreibung:
+DocuMentor ist eine Desktop-Anwendung zur Verwaltung und Validierung von XSL-Transformationen. Die Software wird von technischen Redakteuren und Entwicklern verwendet, um XML-Dokumente in PDF-Dateien zu transformieren und diese zu vergleichen.
+
+Design-Anforderungen:
+- Stil: Professionell, modern, technisch, business-orientiert
+- Farben: Blaue Töne (z.B. #2980B9, #3498DB) kombiniert mit neutralen Grautönen oder Weiß
+- Elemente: Kombination aus Dokumenten-Symbol und Transformations-/Workflow-Elementen
+- Einfachheit: Muss auch in sehr kleinen Größen (16x16 Pixel) erkennbar sein
+- Klare Linien und hoher Kontrast
+
+Symbolik-Vorschläge:
+- Ein Dokument mit Transformations-Pfeilen
+- Gestapelte/verschachtelte Dokumente (XML → XSLT → PDF)
+- Stilisiertes "D" oder "M" für DocuMentor
+- Workflow-Diagramm mit Dokumenten-Symbolen
+- Dokument mit Zahnrad (Verarbeitung/Transformation)
+
+Format: Vektorgrafik (SVG), quadratisch (1:1 Verhältnis), 512x512 Pixel oder größer
+Hintergrund: Transparent oder einfarbig (blau/weiß)
+
+Stil-Referenzen: Microsoft Office Icons, Adobe Creative Cloud Icons, moderne SaaS-Anwendungen
+```
+
+### Englische Version (für internationale KI-Tools wie DALL-E, Midjourney, Stable Diffusion)
+
+```
+Create a professional, minimalist SVG icon for business software called "DocuMentor".
+
+Application Description:
+DocuMentor is a desktop application for managing and validating XSL transformations. The software is used by technical writers and developers to transform XML documents into PDF files and compare them.
+
+Design Requirements:
+- Style: Professional, modern, technical, business-oriented
+- Colors: Blue tones (e.g., #2980B9, #3498DB) combined with neutral grays or white
+- Elements: Combination of document symbol and transformation/workflow elements
+- Simplicity: Must be recognizable even at very small sizes (16x16 pixels)
+- Clean lines and high contrast
+
+Symbolism Suggestions:
+- A document with transformation arrows
+- Stacked/nested documents (XML → XSLT → PDF)
+- Stylized "D" or "M" for DocuMentor
+- Workflow diagram with document symbols
+- Document with gear icon (processing/transformation)
+
+Format: Vector graphic (SVG), square (1:1 ratio), 512x512 pixels or larger
+Background: Transparent or solid color (blue/white)
+
+Style References: Microsoft Office icons, Adobe Creative Cloud icons, modern SaaS applications
+
+Additional Instructions:
+- Flat design, not 3D
+- No gradients or complex shadows
+- Maximum 3 colors
+- Geometric shapes preferred
+- Professional and trustworthy appearance
+```
+
+### Alternativer Prompt (detaillierter für KIs wie ChatGPT mit DALL-E)
+
+```
+Design a minimalist icon for "DocuMentor" - a professional XML/XSL transformation management software.
+
+Concept: A clean, modern icon that combines:
+1. A document/page symbol (representing XML/PDF files)
+2. An element suggesting transformation or workflow (arrows, gears, or connecting lines)
+3. Professional color scheme: Primary blue (#2980B9) with white/gray accents
+
+Requirements:
+- Vector style, flat design
+- Must work well at 16x16, 48x48, and 256x256 pixels
+- High contrast for visibility
+- No text, icon only
+- Square format (512x512px minimum)
+- Transparent background preferred
+
+Style inspiration: Think Microsoft Office 365 icons, VS Code icons, or modern productivity app icons - clean, professional, instantly recognizable.
+
+Technical constraints:
+- Simple enough to work as a favicon
+- Clear silhouette when shown in monochrome
+- Distinctive enough to stand out in a taskbar or dock
+```
+
+## Prompt für spezifische Konzepte
+
+### Konzept 1: Dokument mit Transformation
+
+```
+A minimalist icon showing a document page with a curved arrow pointing to another document, symbolizing transformation. Blue (#2980B9) and white color scheme. Flat design, professional, suitable for business software. SVG style, 512x512px, transparent background.
+```
+
+### Konzept 2: Gestapelte Dokumente
+
+```
+An icon with three overlapping document sheets in a cascading arrangement, representing XML to XSL to PDF transformation workflow. Modern flat design, blue gradient (#3498DB to #2980B9), white accents. Professional business software icon. 512x512px SVG format.
+```
+
+### Konzept 3: Dokument + Zahnrad
+
+```
+A clean icon combining a document page with a small gear/cog symbol in the corner, representing document processing. Minimalist design, blue (#2980B9) on white background. Professional style like Microsoft Office icons. 512x512px, vector art, high contrast.
+```
+
+### Konzept 4: Stilisiertes "M"
+
+```
+A stylized letter "M" for "Mentor" integrated with document/page elements. Modern, geometric, professional. Blue (#2980B9) color scheme. Suitable for small sizes. Flat design, vector style, 512x512px, transparent background.
+```
+
+## Verwendung
+
+1. Wähle einen der Prompts oben
+2. Füge ihn in eine Bild-Generierungs-KI ein:
+   - **DALL-E 3** (ChatGPT Plus): Englischer Prompt empfohlen
+   - **Midjourney**: Englischer Prompt, evtl. kürzer
+   - **Adobe Firefly**: Deutscher oder englischer Prompt
+   - **Stable Diffusion**: Englischer Prompt mit detaillierten Tags
+   - **Leonardo.ai**: Englischer Prompt
+
+3. Lade das generierte Bild herunter (idealerweise als PNG)
+
+4. Konvertiere zu ICO:
+   ```bash
+   uv run python create_icon.py generiertes-icon.png
+   ```
+
+## Tipps für beste Ergebnisse
+
+- **Iteriere**: Generiere mehrere Varianten
+- **Einfachheit**: Betone "minimalist", "simple", "clean"
+- **Größe**: Teste das Icon in verschiedenen Größen
+- **Kontrast**: Achte auf gute Sichtbarkeit auf hellem und dunklem Hintergrund
+- **Professionalität**: Vermeide zu verspielte oder kindliche Designs
+
+## Nachbearbeitung
+
+Falls die KI kein perfektes SVG erstellt:
+1. PNG exportieren (hohe Auflösung, mind. 512x512px)
+2. Mit Inkscape oder Adobe Illustrator zu SVG konvertieren
+3. Oder direkt als PNG verwenden und mit `create_icon.py` konvertieren

src/conf.py

@@ -73,6 +73,72 @@ class SSLMode(str, Enum):
     VERIFY_FULL = "verify-full"
 
 
+class XsltVersion(str, Enum):
+    """XSLT-Version für Saxon-Transformationen."""
+
+    XSLT_1_0 = "1.0"  # JAXP API (nur XSLT 1.0)
+    XSLT_2_0_3_0 = "2.0/3.0"  # s9api (XSLT 2.0 und 3.0)
+
+
+class GraphLayout(str, Enum):
+    """vis.js Physics-Solver / Layout-Modus."""
+
+    BARNES_HUT = "barnesHut"
+    FORCE_ATLAS2 = "forceAtlas2Based"
+    REPULSION = "repulsion"
+    HIERARCHICAL = "hierarchical"
+
+
+class HierarchicalDirection(str, Enum):
+    """Richtung für hierarchisches Layout."""
+
+    UD = "UD"
+    DU = "DU"
+    LR = "LR"
+    RL = "RL"
+
+
+class HierarchicalSortMethod(str, Enum):
+    """Sortiermethode für hierarchisches Layout."""
+
+    HUBSIZE = "hubsize"
+    DIRECTED = "directed"
+
+
+class GraphLayoutSettings(BaseModel):
+    """Persistierte vis.js Layout-Einstellungen für den XSL-Abhängigkeitsgraph."""
+
+    layout: GraphLayout = GraphLayout.BARNES_HUT
+
+    # barnesHut
+    bh_gravitational_constant: int = -3000
+    bh_central_gravity: float = 0.3
+    bh_spring_length: int = 150
+    bh_spring_constant: float = 0.04
+    bh_damping: float = 0.09
+
+    # forceAtlas2Based
+    fa_gravitational_constant: int = -50
+    fa_central_gravity: float = 0.01
+    fa_spring_length: int = 100
+    fa_spring_constant: float = 0.08
+    fa_damping: float = 0.4
+
+    # repulsion
+    re_node_distance: int = 120
+    re_central_gravity: float = 0.0
+    re_spring_length: int = 200
+    re_spring_constant: float = 0.05
+    re_damping: float = 0.09
+
+    # hierarchical
+    hi_direction: HierarchicalDirection = HierarchicalDirection.UD
+    hi_sort_method: HierarchicalSortMethod = HierarchicalSortMethod.HUBSIZE
+    hi_level_separation: int = 150
+    hi_node_spacing: int = 100
+    hi_tree_spacing: int = 200
+
+
 class PostgreSqlDb(BaseModel):
     id: int
     name: str
@@ -82,6 +148,7 @@ class PostgreSqlDb(BaseModel):
     username: str
     password: str
     ssl_mode: SSLMode = SSLMode.PREFER
+    timeout: int = 10
 
 
 class Project(BaseModel):
@@ -95,42 +162,31 @@ class Project(BaseModel):
     xsl_dir_id: int = Field(..., description="ID des XSL-Verzeichnisses", gt=0)
     postgre_sql_db_id: int = Field(..., description="ID der PostgreSQL Datenbank", gt=0)
     fop_config_dir: Path | None = Field(None, description="Optionaler Pfad zum Apache FOP Config-Verzeichnis")
+    xslt_params: dict[str, str] = Field(default_factory=dict, description="Projektweite XSLT-Parameter")
+
+    @staticmethod
+    def _lookup(collection, item_id: int, attr: str) -> str:
+        """Sucht einen Wert in einer Konfigurationsliste anhand der ID."""
+        value = [getattr(x, attr) for x in collection if x.id == item_id]
+        return value[0] if value else ""
 
     def getXsl(self) -> str:
-        global app_settings
+        return self._lookup(app_settings.xsl_dirs, self.xsl_dir_id, "name")
-        value = [x.name for x in app_settings.xsl_dirs if x.id == self.xsl_dir_id]
-
-        return value[0] if len(value) else ""
 
     def getJavaVm(self) -> str:
-        global app_settings
+        return self._lookup(app_settings.java_vms, self.java_vm_id, "version")
-        value = [x.version for x in app_settings.java_vms if x.id == self.java_vm_id]
-
-        return value[0] if len(value) else ""
 
     def getSaxon(self) -> str:
-        global app_settings
+        return self._lookup(app_settings.saxon_jars, self.saxon_jar_id, "version")
-        value = [x.version for x in app_settings.saxon_jars if x.id == self.saxon_jar_id]
-
-        return value[0] if len(value) else ""
 
     def getApacheFop(self) -> str:
-        global app_settings
+        return self._lookup(app_settings.apache_fops, self.apache_fop_id, "version")
-        value = [x.version for x in app_settings.apache_fops if x.id == self.apache_fop_id]
-
-        return value[0] if len(value) else ""
 
     def getDiffPdf(self) -> str:
-        global app_settings
+        return self._lookup(app_settings.diff_pdfs, self.diff_pdf_id, "version")
-        value = [x.version for x in app_settings.diff_pdfs if x.id == self.diff_pdf_id]
-
-        return value[0] if len(value) else ""
 
     def getPostgreSqlDb(self) -> str:
-        global app_settings
+        return self._lookup(app_settings.postgresql_dbs, self.postgre_sql_db_id, "name")
-        value = [x.name for x in app_settings.postgresql_dbs if x.id == self.postgre_sql_db_id]
-
-        return value[0] if len(value) else ""
 
 
 class AppSettings(BaseSettings):
@@ -143,11 +199,15 @@ class AppSettings(BaseSettings):
     postgresql_dbs: list[PostgreSqlDb] = []
     theme: str | None = None
     max_workers: int = 8  # Anzahl paralleler Worker für Transformationen (Standard: 8)
+    use_saxon_worker_pool: bool = True  # SaxonWorkerPool aktivieren (schneller, benötigt JDK)
+    saxon_xslt_version: XsltVersion = XsltVersion.XSLT_2_0_3_0  # XSLT-Version für Saxon (Standard: 2.0/3.0 mit s9api)
+    use_fop_worker_pool: bool = True  # FopWorkerPool aktivieren (schneller, benötigt JDK)
 
     # UI-Zustand
     window_geometry: tuple[int, int, int, int] | None = None  # (x, y, width, height)
     splitter_sizes: list[int] | None = None  # Splitter-Positionen
     tree_column_widths: list[int] | None = None  # TreeWidget-Spaltenbreiten
+    graph_layout_settings: GraphLayoutSettings = Field(default_factory=GraphLayoutSettings)
 
     model_config = SettingsConfigDict(json_file=config_path)
 
@@ -163,7 +223,6 @@ class AppSettings(BaseSettings):
         return (JsonConfigSettingsSource(settings_cls),)
 
     def save(self):
-        global config_path
         # Ordner existert nicht
         if not config_path.parent.exists():
             config_path.parent.mkdir(parents=True, exist_ok=True)
@@ -207,6 +266,7 @@ class ProjectData(BaseModel):
     """
 
     nodes: list[TreeNode] = []
+    expanded_nodes: list[tuple] | None = None  # Optional: IDs der aufgeklappten Knoten (TreeNode und XslFile)
 
     @classmethod
     def readSettings(cls, project_dir: Path):

src/fop_pool.py

@@ -0,0 +1,282 @@
+"""
+FOP Worker Pool - Persistente JVM-Prozesse für schnelle PDF-Generierung.
+
+Eliminiert JVM-Startup-Overhead durch Vorinitialisierung von N Worker-Prozessen.
+Jeder Worker läuft als Daemon und verarbeitet mehrere FO→PDF Transformationen nacheinander.
+"""
+
+import glob
+import logging
+from pathlib import Path
+from typing import Optional
+
+from worker_pool_base import BaseWorkerPool, _CLASSPATH_SEP
+
+logger = logging.getLogger(__name__)
+
+# Java-Worker-Code (wird zur Laufzeit kompiliert)
+FOP_WORKER_JAVA = """
+import org.apache.fop.apps.*;
+import org.xml.sax.SAXException;
+import javax.xml.transform.*;
+import javax.xml.transform.sax.SAXResult;
+import javax.xml.transform.stream.StreamSource;
+import java.io.*;
+import java.net.URI;
+
+public class FopWorker {
+    public static void main(String[] args) {
+        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
+        String line;
+
+        System.err.println("FopWorker starting...");
+        System.err.flush();
+
+        // Create FopFactory once and reuse (major performance boost!)
+        FopFactory fopFactory = null;
+
+        try {
+            // Check if config file is provided as first argument
+            if (args.length > 0 && !args[0].isEmpty()) {
+                File configFile = new File(args[0]);
+                if (configFile.exists()) {
+                    System.err.println("Loading FOP config: " + configFile.getAbsolutePath());
+                    fopFactory = FopFactory.newInstance(configFile);
+                } else {
+                    System.err.println("Config file not found, using default configuration");
+                    fopFactory = FopFactory.newInstance(new File(".").toURI());
+                }
+            } else {
+                System.err.println("No config file specified, using default FOP configuration");
+                fopFactory = FopFactory.newInstance(new File(".").toURI());
+            }
+
+            System.err.println("FopWorker started and ready");
+            System.err.flush();
+
+        } catch (Exception e) {
+            System.err.println("FATAL: Failed to initialize FopFactory: " + e.getMessage());
+            e.printStackTrace(System.err);
+            System.exit(1);
+        }
+
+        try {
+            while ((line = reader.readLine()) != null) {
+                System.err.println("DEBUG: Received line: " + line.substring(0, Math.min(100, line.length())));
+                System.err.flush();
+
+                if ("EXIT".equals(line.trim())) {
+                    System.err.println("FopWorker exiting");
+                    break;
+                }
+
+                try {
+                    // Parse job
+                    System.err.println("DEBUG: Parsing job...");
+                    System.err.flush();
+
+                    String[] parts = line.split("\\t");
+                    System.err.println("DEBUG: Parts count: " + parts.length);
+                    System.err.flush();
+
+                    if (parts.length < 2) {
+                        System.out.println("ERROR: Invalid job format");
+                        System.out.flush();
+                        continue;
+                    }
+
+                    String inputFo = parts[0];
+                    String outputPdf = parts[1];
+
+                    System.err.println("DEBUG: Input FO: " + inputFo);
+                    System.err.println("DEBUG: Output PDF: " + outputPdf);
+                    System.err.flush();
+
+                    // Create FOUserAgent for this transformation
+                    FOUserAgent foUserAgent = fopFactory.newFOUserAgent();
+
+                    // Note: Event Listener für detailliertes Error-Logging könnte hier hinzugefügt werden,
+                    // aber ist nicht kritisch - Fehler werden durch Exceptions gefangen
+
+                    // Create output stream
+                    File outputFile = new File(outputPdf);
+                    outputFile.getParentFile().mkdirs();
+                    OutputStream out = new BufferedOutputStream(new FileOutputStream(outputFile));
+
+                    try {
+                        System.err.println("DEBUG: Creating Fop instance...");
+                        System.err.flush();
+
+                        // Create Fop instance
+                        Fop fop = fopFactory.newFop(MimeConstants.MIME_PDF, foUserAgent, out);
+
+                        System.err.println("DEBUG: Setting up transformer...");
+                        System.err.flush();
+
+                        // Setup Transformer
+                        TransformerFactory transformerFactory = TransformerFactory.newInstance();
+                        Transformer transformer = transformerFactory.newTransformer();
+
+                        // Setup input and output
+                        Source src = new StreamSource(new File(inputFo));
+                        Result res = new SAXResult(fop.getDefaultHandler());
+
+                        System.err.println("DEBUG: Running FOP transformation...");
+                        System.err.flush();
+
+                        // Run transformation
+                        transformer.transform(src, res);
+
+                        System.err.println("DEBUG: FOP transformation completed");
+                        System.err.flush();
+
+                    } finally {
+                        out.close();
+                    }
+
+                    // Transformation erfolgreich
+                    System.out.println("OK");
+                    System.out.flush();
+
+                } catch (Exception e) {
+                    System.err.println("DEBUG: Job processing exception: " + e.getClass().getName());
+                    System.err.flush();
+                    e.printStackTrace(System.err);
+
+                    String errorMsg = e.getMessage();
+                    if (errorMsg == null || errorMsg.isEmpty()) {
+                        errorMsg = e.getClass().getSimpleName();
+                    }
+                    System.out.println("ERROR: " + errorMsg);
+                    System.out.flush();
+                }
+            }
+        } catch (IOException e) {
+            System.err.println("FopWorker I/O error: " + e.getMessage());
+            e.printStackTrace(System.err);
+        }
+    }
+}
+"""
+
+
+class FopWorkerPool(BaseWorkerPool):
+    """
+    Pool von lang-laufenden JVM-Prozessen für Apache FOP PDF-Generierung.
+
+    Eliminiert JVM-Startup-Overhead durch Wiederverwendung von N Worker-Prozessen.
+    """
+
+    def __init__(
+        self,
+        num_workers: int,
+        java_vm_path: Path,
+        apache_fop_dir: Path,
+        fop_config_file: Optional[Path] = None,
+        log_dir: Optional[Path] = None,
+    ):
+        super().__init__(num_workers, java_vm_path, log_dir)
+        self.apache_fop_dir = apache_fop_dir
+        self.fop_config_file = fop_config_file
+        self.fop_classpath: Optional[str] = None
+
+        self._build_fop_classpath()
+        self._compile_worker_class()
+        self._start_workers()
+        logger.info(f"FopWorkerPool initialisiert mit {num_workers} Workern")
+
+    def _build_fop_classpath(self):
+        """Erstellt den Classpath für Apache FOP."""
+        all_jars = glob.glob(str(self.apache_fop_dir / "build" / "*.jar"))
+        lib_dir = self.apache_fop_dir / "lib"
+        if lib_dir.exists() and lib_dir.is_dir():
+            all_jars.extend(glob.glob(str(lib_dir / "*.jar")))
+
+        if not all_jars:
+            raise RuntimeError(f"Keine FOP JAR-Dateien gefunden in {self.apache_fop_dir}")
+
+        self.fop_classpath = _CLASSPATH_SEP.join(all_jars)
+        logger.debug(f"FOP Classpath: {len(all_jars)} JARs")
+
+    # --- Abstrakte Properties ---
+
+    @property
+    def _pool_name(self) -> str:
+        return "FOP"
+
+    @property
+    def _java_source_code(self) -> str:
+        return FOP_WORKER_JAVA
+
+    @property
+    def _java_class_name(self) -> str:
+        return "FopWorker"
+
+    @property
+    def _temp_dir_prefix(self) -> str:
+        return "fop_worker_"
+
+    @property
+    def _worker_init_sleep(self) -> float:
+        return 0.2  # FOP braucht etwas länger zum Initialisieren
+
+    # --- Abstrakte Methoden ---
+
+    def _get_classpath(self) -> str:
+        return self.fop_classpath
+
+    def _build_worker_cmd(self, full_classpath: str) -> list[str]:
+        cmd = [str(self.java_vm_path), "-cp", full_classpath, "FopWorker"]
+        if self.fop_config_file and self.fop_config_file.exists():
+            cmd.append(str(self.fop_config_file))
+        return cmd
+
+    def _stderr_log_name(self, i: int) -> str:
+        return f"fop_worker_{i}_stderr.log"
+
+    # --- FOP-spezifische Job-Methode ---
+
+    def build_pdf(self, input_fo: Path, output_pdf: Path) -> tuple[bool, str]:
+        """
+        Generiert PDF aus FO-Datei mit einem Worker aus dem Pool.
+
+        Args:
+            input_fo: Pfad zur FO-Eingabedatei
+            output_pdf: Pfad zur PDF-Ausgabedatei
+
+        Returns:
+            tuple[bool, str]: (Erfolg, Fehlermeldung/Info)
+        """
+        worker_idx = self._acquire_worker()
+        try:
+            worker = self.workers[worker_idx]
+
+            if worker.poll() is not None:
+                stderr_content = self._read_stderr_log(worker_idx)
+                error_msg = f"FOP Worker {worker_idx} ist beendet (Exit: {worker.returncode})\nstderr:\n{stderr_content}"
+                logger.error(error_msg)
+                return False, error_msg
+
+            job = f"{input_fo}\t{output_pdf}\n"
+            logger.debug(f"Sende FOP-Job an Worker {worker_idx}: {input_fo.name} → {output_pdf.name}")
+            worker.stdin.write(job)
+            worker.stdin.flush()
+
+            response = worker.stdout.readline().strip()
+            logger.debug(f"FOP Worker {worker_idx} Antwort: '{response}'")
+
+            if response == "OK":
+                return True, "Erfolgreich"
+            elif response.startswith("ERROR:"):
+                return False, f"FOP-Fehler: {response[6:].strip()}"
+            elif not response:
+                stderr_content = self._read_stderr_log(worker_idx, tail=500)
+                return False, f"FOP Worker {worker_idx} crashed (keine Antwort)\nstderr:\n{stderr_content}"
+            else:
+                return False, f"Unerwartete Antwort: {response}"
+
+        except Exception as e:
+            logger.error(f"Fehler bei FOP Worker {worker_idx}: {e}")
+            return False, f"Worker-Fehler: {str(e)}"
+        finally:
+            self.worker_locks[worker_idx].release()

src/license_parser.py

@@ -0,0 +1,195 @@
+"""
+Parser für THIRD_PARTY_LICENSES.txt.
+
+Extrahiert strukturierte Lizenzinformationen und ergänzt sie
+mit den tatsächlich installierten Paketversionen via importlib.metadata.
+"""
+import logging
+import re
+import sys
+from dataclasses import dataclass, field
+from importlib.metadata import PackageNotFoundError, version
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+# Pfad zur Lizenzdatei: im PyInstaller-Bundle aus sys._MEIPASS,
+# im Entwicklungsmodus relativ zum Projektroot
+if hasattr(sys, "_MEIPASS"):
+    LICENSE_FILE = Path(sys._MEIPASS) / "THIRD_PARTY_LICENSES.txt"  # type: ignore[attr-defined]
+else:
+    LICENSE_FILE = Path(__file__).parent.parent / "THIRD_PARTY_LICENSES.txt"
+
+# Mapping von Anzeigenamen zu PyPI-Paketnamen für Sonderfälle
+_PACKAGE_NAME_MAP: dict[str, str] = {
+    "PySide6": "PySide6",
+    "Pydantic": "pydantic",
+    "Pydantic-Settings": "pydantic-settings",
+    "Pydantic-YAML": "pydantic-yaml",
+    "Polars": "polars",
+    "ConnectorX (via Polars)": "connectorx",
+    "PyArrow (via Polars)": "pyarrow",
+    "psutil": "psutil",
+    "lxml": "lxml",
+    "Ruff (Development)": "ruff",
+    "PyInstaller (Development)": "pyinstaller",
+    "Pillow (Development)": "pillow",
+}
+
+# Regex für den Beginn eines nummerierten Eintrags (z.B. "1. PySide6" oder "10. PyInstaller (Development)")
+_ENTRY_PATTERN = re.compile(r"^\d+\.\s+(.+)$")
+
+# Bekannte Feldschlüssel in der Lizenzdatei
+_KNOWN_KEYS = {"Version", "Lizenz", "Webseite", "GitHub", "Beschreibung", "Copyright", "Datei", "Hinweis"}
+
+
+@dataclass
+class LicenseEntry:
+    """Ein einzelner Eintrag aus THIRD_PARTY_LICENSES.txt."""
+
+    name: str
+    license: str = ""
+    installed_version: str = ""
+    website: str = ""
+    description: str = ""
+    copyright: str = ""
+    category: str = ""
+
+
+@dataclass
+class ParsedLicenses:
+    """Ergebnis des Parsens der Lizenzdatei."""
+
+    entries: list[LicenseEntry] = field(default_factory=list)
+
+
+def _normalize_package_name(display_name: str) -> str:
+    """Normalisiert einen Anzeigenamen zu einem PyPI-Paketnamen."""
+    if display_name in _PACKAGE_NAME_MAP:
+        return _PACKAGE_NAME_MAP[display_name]
+    # Fallback: lowercase, Leerzeichen/Klammern entfernen
+    return display_name.lower().split("(")[0].strip()
+
+
+def _get_installed_version(package_name: str) -> str:
+    """Ermittelt die installierte Version eines Pakets."""
+    try:
+        return version(package_name)
+    except PackageNotFoundError:
+        return ""
+
+
+def parse_license_file(license_file: Path | None = None) -> ParsedLicenses:
+    """
+    Parst THIRD_PARTY_LICENSES.txt und gibt strukturierte Einträge zurück.
+
+    Args:
+        license_file: Pfad zur Lizenzdatei. Standard: LICENSE_FILE
+
+    Returns:
+        ParsedLicenses mit allen gefundenen Einträgen inkl. installierter Versionen
+    """
+    if license_file is None:
+        license_file = LICENSE_FILE
+
+    if not license_file.exists():
+        logger.warning(f"Lizenzdatei nicht gefunden: {license_file}")
+        return ParsedLicenses()
+
+    text = license_file.read_text(encoding="utf-8")
+    lines = text.splitlines()
+
+    result = ParsedLicenses()
+    current_category = ""
+    current_entry: LicenseEntry | None = None
+    last_key: str | None = None  # Letzter erkannter Schlüssel (für Fortsetzungszeilen)
+    separator_line = "=" * 20  # Mindestlänge für Sektions-Trennlinien
+
+    i = 0
+    while i < len(lines):
+        line = lines[i]
+
+        # Sektions-Trennlinie erkannt → nächste Zeile ist Sektionsname
+        if line.startswith(separator_line):
+            i += 1
+            if i < len(lines):
+                section_name = lines[i].strip()
+
+                # Bei "Lizenztexte" aufhören — ab hier kommen nur noch Volltexte
+                if section_name == "Lizenztexte":
+                    # Letzten Eintrag noch sichern
+                    if current_entry:
+                        result.entries.append(current_entry)
+                    break
+
+                # Neue Kategorie setzen (ignoriere den Datei-Header "THIRD PARTY LICENSES")
+                if section_name != "THIRD PARTY LICENSES":
+                    current_category = section_name
+
+            # Schließende Trennlinie der Sektion überspringen
+            i += 1
+            if i < len(lines) and lines[i].startswith(separator_line):
+                i += 1
+            continue
+
+        # Nummerierter Eintrag (z.B. "1. PySide6")
+        match = _ENTRY_PATTERN.match(line.strip())
+        if match:
+            # Vorherigen Eintrag speichern
+            if current_entry:
+                result.entries.append(current_entry)
+
+            entry_name = match.group(1).strip()
+            current_entry = LicenseEntry(name=entry_name, category=current_category)
+
+            # Installierte Version ermitteln
+            pypi_name = _normalize_package_name(entry_name)
+            current_entry.installed_version = _get_installed_version(pypi_name)
+
+            i += 1
+            continue
+
+        # Schlüssel-Wert-Zeile innerhalb eines Eintrags (z.B. "   Version: >=6.10.1")
+        stripped = line.strip()
+        if current_entry and ":" in stripped:
+            key, _, value = stripped.partition(":")
+            key = key.strip()
+            value = value.strip()
+
+            if key in _KNOWN_KEYS:
+                last_key = key
+                if key == "Lizenz":
+                    current_entry.license = value
+                elif key == "Webseite":
+                    current_entry.website = value
+                elif key == "GitHub" and not current_entry.website:
+                    # GitHub nur als Fallback wenn keine Webseite vorhanden
+                    current_entry.website = value
+                elif key == "Beschreibung":
+                    current_entry.description = value
+                elif key == "Copyright":
+                    current_entry.copyright = value
+            else:
+                last_key = None
+        elif current_entry and stripped and not stripped.startswith("="):
+            # Fortsetzungszeile (z.B. mehrzeiliger Copyright-Eintrag)
+            if last_key == "Copyright":
+                current_entry.copyright += "\n" + stripped
+
+        i += 1
+
+    # Letzten Eintrag sichern (falls Datei nicht mit "Lizenztexte" endet)
+    if current_entry and current_entry not in result.entries:
+        result.entries.append(current_entry)
+
+    logger.info(f"{len(result.entries)} Lizenzeinträge aus {license_file.name} geladen")
+    return result
+
+
+if __name__ == "__main__":
+    # Standalone-Test
+    logging.basicConfig(level=logging.DEBUG)
+    parsed = parse_license_file()
+    for entry in parsed.entries:
+        ver = entry.installed_version or "—"
+        logger.debug(f"[{entry.category}] {entry.name}: {ver} ({entry.license})")

src/main.py

@@ -1,6 +1,8 @@
 import sys
 import logging
+from pathlib import Path
 
+from PySide6.QtGui import QIcon
 from PySide6.QtWidgets import QApplication
 
 from ui.MainWindow import MainWindow
@@ -8,6 +10,39 @@ from ui.AppSettings import AppSettingsDlg
 from conf import app_settings
 
 
+def cleanup_old_logs(log_dir, max_age_hours=24):
+    """
+    Löscht Log-Dateien, die älter als die angegebene Anzahl von Stunden sind.
+
+    Args:
+        log_dir: Pfad zum Log-Verzeichnis
+        max_age_hours: Maximales Alter der Log-Dateien in Stunden (Standard: 24)
+    """
+    import time
+
+    if not log_dir.exists():
+        return
+
+    cutoff_time = time.time() - (max_age_hours * 3600)
+    deleted_count = 0
+
+    # Alle .log Dateien im Verzeichnis durchsuchen
+    for log_file in log_dir.glob("*.log"):
+        try:
+            # Änderungszeit der Datei abrufen
+            file_mtime = log_file.stat().st_mtime
+
+            # Wenn die Datei älter als die Grenzzeit ist, löschen
+            if file_mtime < cutoff_time:
+                log_file.unlink()
+                deleted_count += 1
+        except Exception as e:
+            logging.warning(f"Fehler beim Löschen von {log_file}: {e}")
+
+    if deleted_count > 0:
+        logging.info(f"{deleted_count} alte Log-Datei(en) gelöscht (älter als {max_age_hours} Stunden)")
+
+
 def main():
     """Haupteinstiegspunkt der Anwendung."""
     # Logging konfigurieren - sowohl Datei als auch Konsole
@@ -17,7 +52,7 @@ def main():
     from conf import config_path
 
     log_dir = config_path.parent / "logs"
-    log_dir.mkdir(exist_ok=True)
+    log_dir.mkdir(parents=True, exist_ok=True)
 
     # Log-Dateiname mit Timestamp
     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
@@ -44,9 +79,25 @@ def main():
 
     logging.info(f"Logging initialisiert: {log_file}")
 
+    # Alte Log-Dateien aufräumen (erst nach Logger-Init)
+    cleanup_old_logs(log_dir, max_age_hours=24)
+
+    # Unter Windows: AppUserModelID setzen, damit die Taskleiste das richtige Symbol zeigt
+    if sys.platform == "win32":
+        import ctypes
+        ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID("de.vitaligraf.documentor")
+
     # QApplication-Instanz erstellen
     app = QApplication(sys.argv)
 
+    # App-Symbol setzen (PyInstaller: sys._MEIPASS, sonst Quellpfad)
+    if getattr(sys, "frozen", False):
+        icon_path = Path(sys._MEIPASS) / "resources" / "icon.ico"
+    else:
+        icon_path = Path(__file__).parent.parent / "resources" / "icon.ico"
+    if icon_path.exists():
+        app.setWindowIcon(QIcon(str(icon_path)))
+
     # Hauptfenster erstellen
     window = MainWindow()
 

src/obsolete_detector.py

@@ -0,0 +1,166 @@
+"""
+Obsolete-Detector — Erkennung veralteter Projekteinträge nach DB-Import.
+
+Reine Analyselogik ohne Qt-Abhängigkeit. Findet XslFile-Einträge im Projekt,
+die nicht mehr in der Datenbank vorhanden sind.
+"""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from conf import TreeNode, XslFile
+
+
+@dataclass
+class ObsoleteXslEntry:
+    """Ein XslFile-Eintrag, der nicht mehr in der Datenbank vorhanden ist."""
+
+    xsl_file: XslFile
+    parent_node: TreeNode
+
+
+@dataclass
+class ObsoleteGroup:
+    """Gruppe veralteter XslFile-Einträge unter einem gemeinsamen Eltern-Pfad."""
+
+    node_path: list[str]
+    parent_node: TreeNode
+    xsl_entries: list[ObsoleteXslEntry] = field(default_factory=list)
+
+
+def extract_db_xsl_ids(new_nodes: list[TreeNode]) -> set[tuple]:
+    """
+    Extrahiert alle XslFile-IDs aus den frisch aus der DB geladenen Nodes.
+
+    Args:
+        new_nodes: Nodes aus _process_sql_data()
+
+    Returns:
+        Set aller XslFile-IDs (Tupel)
+    """
+    ids: set[tuple] = set()
+    _collect_ids_recursive(new_nodes, ids)
+    return ids
+
+
+def _collect_ids_recursive(nodes: list, ids: set[tuple]) -> None:
+    for node in nodes:
+        if isinstance(node, XslFile):
+            ids.add(node.id)
+        elif isinstance(node, TreeNode) and node.children:
+            _collect_ids_recursive(node.children, ids)
+
+
+def find_obsolete_xsl_entries(
+    project_nodes: list[TreeNode],
+    db_xsl_ids: set[tuple],
+) -> list[ObsoleteGroup]:
+    """
+    Findet alle XslFile-Einträge im Projekt, die nicht mehr in der DB vorhanden sind.
+
+    Args:
+        project_nodes: Aktuelle Nodes aus pdf_project.nodes
+        db_xsl_ids: Set aller XslFile-IDs aus der DB (von extract_db_xsl_ids)
+
+    Returns:
+        Liste von ObsoleteGroup, sortiert nach Hierarchiepfad
+    """
+    groups: dict[int, ObsoleteGroup] = {}
+
+    _find_obsolete_recursive(project_nodes, db_xsl_ids, path=[], groups=groups)
+
+    # Sortieren nach Pfad für stabile Darstellung
+    return sorted(groups.values(), key=lambda g: g.node_path)
+
+
+def _find_obsolete_recursive(
+    nodes: list,
+    db_xsl_ids: set[tuple],
+    path: list[str],
+    groups: dict[int, ObsoleteGroup],
+) -> None:
+    for node in nodes:
+        if isinstance(node, TreeNode):
+            _find_obsolete_in_tree_node(node, db_xsl_ids, path, groups)
+
+
+def _find_obsolete_in_tree_node(
+    node: TreeNode,
+    db_xsl_ids: set[tuple],
+    parent_path: list[str],
+    groups: dict[int, ObsoleteGroup],
+) -> None:
+    current_path = parent_path + [node.bez]
+
+    for child in node.children:
+        if isinstance(child, XslFile):
+            if child.id not in db_xsl_ids:
+                node_id = id(node)
+                if node_id not in groups:
+                    groups[node_id] = ObsoleteGroup(
+                        node_path=current_path,
+                        parent_node=node,
+                    )
+                groups[node_id].xsl_entries.append(ObsoleteXslEntry(xsl_file=child, parent_node=node))
+        elif isinstance(child, TreeNode):
+            _find_obsolete_in_tree_node(child, db_xsl_ids, current_path, groups)
+
+
+def remove_empty_tree_nodes(nodes: list) -> list:
+    """
+    Entfernt rekursiv alle TreeNodes, deren children-Liste nach der Bereinigung leer ist.
+    XslFile-Einträge werden immer behalten (sie wurden bereits entfernt oder sind noch gültig).
+
+    Args:
+        nodes: Liste von TreeNode|XslFile
+
+    Returns:
+        Bereinigte Liste ohne leere TreeNodes
+    """
+    result = []
+    for node in nodes:
+        if isinstance(node, TreeNode):
+            node.children = remove_empty_tree_nodes(node.children)
+            if node.children:
+                result.append(node)
+            # leere TreeNodes stillschweigend verwerfen
+        else:
+            result.append(node)
+    return result
+
+
+def collect_unused_xml_files(
+    obsolete_groups: list[ObsoleteGroup],
+    project_dir: Path,
+    is_xml_used_elsewhere_fn,
+) -> list[tuple[Path, Path]]:
+    """
+    Sammelt XML-Dateien der veralteten XslFiles, die nirgends anders mehr verwendet werden.
+
+    WICHTIG: Muss nach dem Entfernen der XslFiles aus dem Modell aufgerufen werden,
+    damit is_xml_used_elsewhere_fn korrekte Ergebnisse liefert.
+
+    Args:
+        obsolete_groups: Die veralteten Gruppen
+        project_dir: Absoluter Pfad zum Projektverzeichnis
+        is_xml_used_elsewhere_fn: Callable(xml_path, exclude_xsl_file) -> bool
+
+    Returns:
+        Liste von (xml_path_relativ, xml_path_absolut) für nicht mehr verwendete XML-Dateien
+    """
+    unused: list[tuple[Path, Path]] = []
+    seen: set[str] = set()
+
+    for group in obsolete_groups:
+        for entry in group.xsl_entries:
+            for xml_file_obj in entry.xsl_file.xmls:
+                xml_path_str = str(xml_file_obj.xml)
+                if xml_path_str in seen:
+                    continue
+                seen.add(xml_path_str)
+                xml_abs = project_dir / xml_file_obj.xml
+                if xml_abs.exists():
+                    if not is_xml_used_elsewhere_fn(xml_file_obj.xml, entry.xsl_file):
+                        unused.append((xml_file_obj.xml, xml_abs))
+
+    return unused

src/res/data.sql

@@ -8,4 +8,4 @@ select
 	r3.xsl_datei 
 from reporttyp r 
 inner join report r2 on r.reporttyp = r2.reporttyp and r2.aktiv = 1
-inner join repfile r3 on r2.reporttyp = r3.reporttyp and r2.report = r3.report and r3.xsl_datei is not null and r3.aktiv = 1
+inner join repfile r3 on r2.reporttyp = r3.reporttyp and r2.report = r3.report and r3.xsl_datei is not null and r3.aktiv = 1 and r3.export = 0

src/saxon_pool.py

@@ -6,12 +6,10 @@ Jeder Worker läuft als Daemon und verarbeitet mehrere Transformationen nacheina
 """
 
 import logging
-import subprocess
-import threading
 from pathlib import Path
-from queue import Queue
 from typing import Optional
-import tempfile
+
+from worker_pool_base import BaseWorkerPool, build_jar_classpath
 
 logger = logging.getLogger(__name__)
 
@@ -30,7 +28,10 @@ public class SaxonWorker {
         // Create TransformerFactory once and reuse
         TransformerFactory factory = TransformerFactory.newInstance();
 
-        System.err.println("SaxonWorker started and ready (using JAXP Transformer API)");
+        // Cache für kompilierte Stylesheets (Performance-Optimierung)
+        Map<String, Templates> templatesCache = new HashMap<>();
+
+        System.err.println("SaxonWorker started and ready (using JAXP Transformer API with stylesheet caching)");
         System.err.flush();
 
         try {
@@ -62,19 +63,33 @@ public class SaxonWorker {
                     String xslStylesheet = parts[1];
                     String outputFo = parts[2];
 
-                    System.err.println("DEBUG: Creating transformer from stylesheet...");
+                    // Prüfe ob Stylesheet bereits im Cache ist
+                    Templates templates;
+                    if (templatesCache.containsKey(xslStylesheet)) {
+                        templates = templatesCache.get(xslStylesheet);
+                        System.err.println("DEBUG: Using cached stylesheet: " + xslStylesheet);
+                        System.err.flush();
+                    } else {
+                        System.err.println("DEBUG: Compiling and caching stylesheet: " + xslStylesheet);
+                        System.err.flush();
+
+                        StreamSource xslSource = new StreamSource(new File(xslStylesheet));
+                        templates = factory.newTemplates(xslSource);
+                        templatesCache.put(xslStylesheet, templates);
+
+                        System.err.println("DEBUG: Stylesheet compiled and cached (cache size: " + templatesCache.size() + ")");
+                        System.err.flush();
+                    }
+
+                    System.err.println("DEBUG: Creating transformer from cached template...");
                     System.err.flush();
 
                     // Create Source and Result objects
-                    StreamSource xslSource = new StreamSource(new File(xslStylesheet));
                     StreamSource xmlSource = new StreamSource(new File(sourceXml));
                     StreamResult result = new StreamResult(new File(outputFo));
 
-                    System.err.println("DEBUG: Compiling stylesheet...");
+                    // Create transformer from templates
-                    System.err.flush();
+                    Transformer transformer = templates.newTransformer();
-
-                    // Create transformer from stylesheet
-                    Transformer transformer = factory.newTransformer(xslSource);
 
                     // Set parameters if present
                     if (parts.length > 3 && !parts[3].isEmpty()) {
@@ -155,9 +170,9 @@ public class SaxonWorker {
 """
 
 
-class SaxonWorkerPool:
+class SaxonWorkerPool(BaseWorkerPool):
     """
-    Pool von lang-laufenden JVM-Prozessen für Saxon-Transformationen.
+    Pool von lang-laufenden JVM-Prozessen für Saxon-Transformationen (JAXP/XSLT 1.0).
 
     Eliminiert JVM-Startup-Overhead durch Wiederverwendung von N Worker-Prozessen.
     """
@@ -170,144 +185,51 @@ class SaxonWorkerPool:
         classpath_cache: dict[Path, str],
         log_dir: Optional[Path] = None,
     ):
-        """
+        super().__init__(num_workers, java_vm_path, log_dir)
-        Initialisiert den Saxon-Worker-Pool.
-
-        Args:
-            num_workers: Anzahl der Worker-Prozesse
-            java_vm_path: Pfad zur Java VM Binary
-            saxon_jar_path: Pfad zur Saxon JAR-Datei
-            classpath_cache: Cache für Saxon-Classpaths
-            log_dir: Optionales Verzeichnis für Worker-Logs (Standard: temp_dir/temp)
-        """
-        self.num_workers = num_workers
-        self.java_vm_path = java_vm_path
         self.saxon_jar_path = saxon_jar_path
         self.classpath_cache = classpath_cache
-        self.log_dir = log_dir
 
-        # Worker-Prozesse und Queues
-        self.workers: list[subprocess.Popen] = []
-        self.job_queue: Queue = Queue()
-        self.result_queue: Queue = Queue()
-        self.worker_locks: list[threading.Lock] = []
-
-        # Temporäres Verzeichnis für kompilierte Java-Klasse
-        self.temp_dir: Optional[Path] = None
-        self.worker_class_path: Optional[Path] = None
-        self.worker_log_dir: Optional[Path] = None
-
-        # Initialisierung
         self._compile_worker_class()
         self._start_workers()
-
         logger.info(f"SaxonWorkerPool initialisiert mit {num_workers} Workern")
 
-    def _compile_worker_class(self):
+    # --- Abstrakte Properties ---
-        """Kompiliert die SaxonWorker-Java-Klasse."""
-        try:
-            # Erstelle temporäres Verzeichnis
-            self.temp_dir = Path(tempfile.mkdtemp(prefix="saxon_worker_"))
 
-            # Schreibe Java-Quellcode
+    @property
-            java_file = self.temp_dir / "SaxonWorker.java"
+    def _pool_name(self) -> str:
-            java_file.write_text(SAXON_WORKER_JAVA, encoding="utf-8")
+        return "Saxon"
 
-            # Hole Classpath
+    @property
-            saxon_dir = self.saxon_jar_path.parent
+    def _java_source_code(self) -> str:
-            if saxon_dir in self.classpath_cache:
+        return SAXON_WORKER_JAVA
-                classpath = self.classpath_cache[saxon_dir]
-            else:
-                # Fallback: Baue Classpath neu
-                import glob
-                import sys
 
-                all_jars = glob.glob(str(saxon_dir / "*.jar"))
+    @property
-                lib_dir = saxon_dir / "lib"
+    def _java_class_name(self) -> str:
-                if lib_dir.exists():
+        return "SaxonWorker"
-                    all_jars.extend(glob.glob(str(lib_dir / "*.jar")))
 
-                classpath_separator = ";" if sys.platform == "win32" else ":"
+    @property
-                classpath = classpath_separator.join(all_jars)
+    def _temp_dir_prefix(self) -> str:
+        return "saxon_worker_"
 
-            # Kompiliere Java-Klasse
+    @property
-            javac_cmd = [str(self.java_vm_path).replace("java", "javac"), "-cp", classpath, str(java_file)]
+    def _worker_init_sleep(self) -> float:
+        return 0.1
 
-            logger.debug(f"Kompiliere SaxonWorker: {' '.join(javac_cmd)}")
+    # --- Abstrakte Methoden ---
 
-            result = subprocess.run(javac_cmd, capture_output=True, text=True, timeout=30)
+    def _get_classpath(self) -> str:
-
-            if result.returncode != 0:
-                raise RuntimeError(f"Java-Kompilierung fehlgeschlagen: {result.stderr}")
-
-            self.worker_class_path = self.temp_dir
-
-            logger.info(f"SaxonWorker erfolgreich kompiliert: {self.temp_dir}")
-
-        except Exception as e:
-            logger.error(f"Fehler beim Kompilieren von SaxonWorker: {e}")
-            raise
-
-    def _start_workers(self):
-        """Startet N Worker-Prozesse."""
-        # Hole Classpath
         saxon_dir = self.saxon_jar_path.parent
-        classpath = self.classpath_cache.get(saxon_dir, "")
+        if saxon_dir not in self.classpath_cache:
+            self.classpath_cache[saxon_dir] = build_jar_classpath(saxon_dir)
+        return self.classpath_cache[saxon_dir]
 
-        # Füge Worker-Classpath hinzu
+    def _build_worker_cmd(self, full_classpath: str) -> list[str]:
-        import sys
+        return [str(self.java_vm_path), "-cp", full_classpath, "SaxonWorker"]
 
-        classpath_separator = ";" if sys.platform == "win32" else ":"
+    def _stderr_log_name(self, i: int) -> str:
-        full_classpath = str(self.worker_class_path) + classpath_separator + classpath
+        return f"worker_{i}_stderr.log"
 
-        # Bestimme Log-Verzeichnis
+    # --- Saxon-spezifische Job-Methode ---
-        self.worker_log_dir = self.log_dir if self.log_dir else self.temp_dir
-        if self.log_dir:
-            self.worker_log_dir.mkdir(parents=True, exist_ok=True)
-
-        for i in range(self.num_workers):
-            try:
-                # Starte JVM-Prozess mit SaxonWorker
-                cmd = [str(self.java_vm_path), "-cp", full_classpath, "SaxonWorker"]
-
-                # Öffne stderr-Log-Datei für diesen Worker
-                stderr_log = self.worker_log_dir / f"worker_{i}_stderr.log"
-                stderr_file = open(stderr_log, "w", encoding="utf-8")
-
-                process = subprocess.Popen(
-                    cmd,
-                    stdin=subprocess.PIPE,
-                    stdout=subprocess.PIPE,
-                    stderr=stderr_file,  # Redirect stderr to file
-                    text=True,
-                    bufsize=1,  # Line buffered
-                )
-
-                self.workers.append(process)
-                self.worker_locks.append(threading.Lock())
-
-                logger.debug(f"Worker {i} gestartet (PID: {process.pid}, stderr: {stderr_log})")
-
-                # Warte kurz damit Worker initialisieren kann
-                import time
-
-                time.sleep(0.1)
-
-                # Prüfe ob Worker noch läuft
-                if process.poll() is not None:
-                    # Worker ist bereits beendet - Fehler!
-                    stderr_file.close()
-                    with open(stderr_log, "r") as f:
-                        stderr_content = f.read()
-                    raise RuntimeError(
-                        f"Worker {i} ist sofort beendet (Exit Code: {process.returncode})\nstderr:\n{stderr_content}"
-                    )
-
-            except Exception as e:
-                logger.error(f"Fehler beim Starten von Worker {i}: {e}")
-                raise
-
-        logger.info(f"{len(self.workers)} Saxon-Worker erfolgreich gestartet")
 
     def transform(
         self, source_xml: Path, xsl_stylesheet: Path, output_fo: Path, xslt_params: dict[str, str]
@@ -324,119 +246,38 @@ class SaxonWorkerPool:
         Returns:
             tuple[bool, str]: (Erfolg, Fehlermeldung/Info)
         """
-        # Finde freien Worker
+        worker_idx = self._acquire_worker()
-        worker_idx = None
-        for i, lock in enumerate(self.worker_locks):
-            if lock.acquire(blocking=False):
-                worker_idx = i
-                break
-
-        if worker_idx is None:
-            # Kein freier Worker, warte auf ersten verfügbaren
-            for i, lock in enumerate(self.worker_locks):
-                lock.acquire()
-                worker_idx = i
-                break
-
         try:
             worker = self.workers[worker_idx]
 
-            # Prüfe ob Worker noch läuft
             if worker.poll() is not None:
-                # Worker ist tot!
+                stderr_content = self._read_stderr_log(worker_idx)
-                stderr_log = self.worker_log_dir / f"worker_{worker_idx}_stderr.log"
+                error_msg = f"Worker {worker_idx} ist beendet (Exit: {worker.returncode})\nstderr:\n{stderr_content}"
-                try:
-                    with open(stderr_log, "r") as f:
-                        stderr_content = f.read()
-                    error_msg = (
-                        f"Worker {worker_idx} ist beendet (Exit: {worker.returncode})\nstderr:\n{stderr_content}"
-                    )
-                except Exception:
-                    error_msg = f"Worker {worker_idx} ist beendet (Exit: {worker.returncode})"
                 logger.error(error_msg)
                 return False, error_msg
 
-            # Formatiere Parameter
+            params_str = "|||".join([f"{k}={v}" for k, v in xslt_params.items()])
-            params_str = "|||".join([f"{key}={value}" for key, value in xslt_params.items()])
-
-            # Erstelle Job-String (Tab-separated)
             job = f"{source_xml}\t{xsl_stylesheet}\t{output_fo}\t{params_str}\n"
 
             logger.debug(f"Sende Job an Worker {worker_idx}: {source_xml.name}")
-
-            # Sende Job an Worker
             worker.stdin.write(job)
             worker.stdin.flush()
 
-            # Warte auf Antwort
             response = worker.stdout.readline().strip()
-
             logger.debug(f"Worker {worker_idx} Antwort: '{response}'")
 
             if response == "OK":
                 return True, "Erfolgreich"
             elif response.startswith("ERROR:"):
-                error_msg = response[6:].strip()
+                return False, f"Saxon-Fehler: {response[6:].strip()}"
-                return False, f"Saxon-Fehler: {error_msg}"
+            elif not response:
+                stderr_content = self._read_stderr_log(worker_idx, tail=500)
+                return False, f"Worker {worker_idx} crashed (keine Antwort)\nstderr:\n{stderr_content}"
             else:
-                # Leere Antwort bedeutet Worker ist crashed
-                if not response:
-                    stderr_log = self.worker_log_dir / f"worker_{worker_idx}_stderr.log"
-                    try:
-                        with open(stderr_log, "r") as f:
-                            stderr_content = f.read()[-500:]  # Letzte 500 Zeichen
-                        return False, f"Worker {worker_idx} crashed (keine Antwort)\nstderr:\n{stderr_content}"
-                    except Exception:
-                        return False, f"Worker {worker_idx} crashed (keine Antwort)"
                 return False, f"Unerwartete Antwort: {response}"
 
         except Exception as e:
             logger.error(f"Fehler bei Worker {worker_idx}: {e}")
             return False, f"Worker-Fehler: {str(e)}"
-
         finally:
-            # Gebe Worker-Lock frei
             self.worker_locks[worker_idx].release()
-
-    def shutdown(self):
-        """Beendet alle Worker-Prozesse sauber."""
-        logger.info("Beende Saxon-Worker-Pool...")
-
-        for i, worker in enumerate(self.workers):
-            try:
-                # Sende EXIT-Befehl
-                if worker.stdin and not worker.stdin.closed:
-                    worker.stdin.write("EXIT\n")
-                    worker.stdin.flush()
-
-                # Warte auf Beendigung (max 2 Sekunden)
-                worker.wait(timeout=2)
-                logger.debug(f"Worker {i} beendet")
-
-            except subprocess.TimeoutExpired:
-                # Force kill falls nötig
-                worker.kill()
-                logger.warning(f"Worker {i} musste gekillt werden")
-
-            except Exception as e:
-                logger.error(f"Fehler beim Beenden von Worker {i}: {e}")
-
-        # Lösche temporäres Verzeichnis
-        if self.temp_dir and self.temp_dir.exists():
-            try:
-                import shutil
-
-                shutil.rmtree(self.temp_dir)
-                logger.debug(f"Temporäres Verzeichnis gelöscht: {self.temp_dir}")
-            except Exception as e:
-                logger.warning(f"Konnte temporäres Verzeichnis nicht löschen: {e}")
-
-        logger.info("Saxon-Worker-Pool beendet")
-
-    def __enter__(self):
-        """Context manager entry."""
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        """Context manager exit."""
-        self.shutdown()

src/saxon_pool_s9api.py

@@ -0,0 +1,267 @@
+"""
+Saxon Worker Pool (s9api) - Persistente JVM-Prozesse für XSLT 2.0/3.0 Transformationen.
+
+Diese Variante verwendet die Saxon s9api API anstatt JAXP und ist für XSLT 2.0 und 3.0 geeignet.
+Eliminiert JVM-Startup-Overhead durch Vorinitialisierung von N Worker-Prozessen.
+Jeder Worker läuft als Daemon und verarbeitet mehrere Transformationen nacheinander.
+"""
+
+import logging
+from pathlib import Path
+from typing import Optional
+
+from worker_pool_base import BaseWorkerPool, build_jar_classpath
+
+logger = logging.getLogger(__name__)
+
+# Java-Worker-Code für s9api (wird zur Laufzeit kompiliert)
+SAXON_S9API_WORKER_JAVA = """
+import net.sf.saxon.s9api.*;
+import javax.xml.transform.stream.StreamSource;
+import java.io.*;
+import java.util.HashMap;
+import java.util.Map;
+
+public class SaxonS9ApiWorker {
+    public static void main(String[] args) {
+        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
+        String line;
+
+        // Create Processor once and reuse (equivalent to TransformerFactory)
+        Processor processor = new Processor(false);
+
+        // Cache für kompilierte Stylesheets (Performance-Optimierung)
+        Map<String, XsltExecutable> stylesheetCache = new HashMap<>();
+
+        System.err.println("SaxonS9ApiWorker started and ready (using s9api for XSLT 2.0/3.0 with stylesheet caching)");
+        System.err.flush();
+
+        try {
+            while ((line = reader.readLine()) != null) {
+                System.err.println("DEBUG: Received line: " + line.substring(0, Math.min(100, line.length())));
+                System.err.flush();
+
+                if ("EXIT".equals(line.trim())) {
+                    System.err.println("SaxonS9ApiWorker exiting");
+                    break;
+                }
+
+                try {
+                    // Parse job
+                    System.err.println("DEBUG: Parsing job...");
+                    System.err.flush();
+
+                    String[] parts = line.split("\\\\t");
+                    System.err.println("DEBUG: Parts count: " + parts.length);
+                    System.err.flush();
+
+                    if (parts.length < 3) {
+                        System.out.println("ERROR: Invalid job format");
+                        System.out.flush();
+                        continue;
+                    }
+
+                    String sourceXml = parts[0];
+                    String xslStylesheet = parts[1];
+                    String outputFo = parts[2];
+
+                    // Prüfe ob Stylesheet bereits im Cache ist
+                    XsltExecutable executable;
+                    if (stylesheetCache.containsKey(xslStylesheet)) {
+                        executable = stylesheetCache.get(xslStylesheet);
+                        System.err.println("DEBUG: Using cached stylesheet: " + xslStylesheet);
+                        System.err.flush();
+                    } else {
+                        System.err.println("DEBUG: Compiling and caching stylesheet: " + xslStylesheet);
+                        System.err.flush();
+
+                        XsltCompiler compiler = processor.newXsltCompiler();
+                        executable = compiler.compile(new StreamSource(new File(xslStylesheet)));
+                        stylesheetCache.put(xslStylesheet, executable);
+
+                        System.err.println("DEBUG: Stylesheet compiled and cached (cache size: " + stylesheetCache.size() + ")");
+                        System.err.flush();
+                    }
+
+                    System.err.println("DEBUG: Creating transformer...");
+                    System.err.flush();
+
+                    // Create transformer
+                    XsltTransformer transformer = executable.load();
+
+                    // Set source
+                    transformer.setSource(new StreamSource(new File(sourceXml)));
+
+                    // Set destination
+                    Serializer serializer = processor.newSerializer(new File(outputFo));
+                    transformer.setDestination(serializer);
+
+                    // Set parameters if present
+                    if (parts.length > 3 && !parts[3].isEmpty()) {
+                        String[] params = parts[3].split("\\\\|\\\\|\\\\|");
+                        for (String param : params) {
+                            if (!param.isEmpty() && param.contains("=")) {
+                                String[] kv = param.split("=", 2);
+                                transformer.setParameter(new QName(kv[0]), new XdmAtomicValue(kv[1]));
+                                System.err.println("DEBUG: Set parameter: " + kv[0] + " = " + kv[1]);
+                            }
+                        }
+                        System.err.flush();
+                    }
+
+                    System.err.println("DEBUG: Running transformation...");
+                    System.err.flush();
+
+                    // Transform
+                    transformer.transform();
+
+                    System.err.println("DEBUG: Transformation completed");
+                    System.err.flush();
+
+                    System.out.println("OK");
+                    System.out.flush();
+
+                } catch (SaxonApiException e) {
+                    System.err.println("DEBUG: SaxonApiException: " + e.getClass().getName());
+                    System.err.flush();
+                    e.printStackTrace(System.err);
+
+                    String errorMsg = e.getMessage();
+                    if (errorMsg == null || errorMsg.isEmpty()) {
+                        errorMsg = e.getClass().getSimpleName();
+                    }
+                    System.out.println("ERROR: " + errorMsg);
+                    System.out.flush();
+
+                } catch (Exception e) {
+                    System.err.println("DEBUG: Job processing exception: " + e.getClass().getName());
+                    System.err.flush();
+                    e.printStackTrace(System.err);
+                    System.out.println("ERROR: " + (e.getMessage() != null ? e.getMessage() : e.getClass().getName()));
+                    System.out.flush();
+                }
+            }
+        } catch (IOException e) {
+            System.err.println("SaxonS9ApiWorker I/O error: " + e.getMessage());
+            e.printStackTrace(System.err);
+        }
+    }
+}
+"""
+
+
+class SaxonWorkerPoolS9Api(BaseWorkerPool):
+    """
+    Pool von lang-laufenden JVM-Prozessen für Saxon-Transformationen mit s9api.
+
+    Diese Variante verwendet die Saxon s9api API anstatt JAXP und unterstützt
+    vollständig XSLT 2.0 und 3.0 Transformationen.
+    """
+
+    def __init__(
+        self,
+        num_workers: int,
+        java_vm_path: Path,
+        saxon_jar_path: Path,
+        classpath_cache: dict[Path, str],
+        log_dir: Optional[Path] = None,
+    ):
+        super().__init__(num_workers, java_vm_path, log_dir)
+        self.saxon_jar_path = saxon_jar_path
+        self.classpath_cache = classpath_cache
+
+        self._compile_worker_class()
+        self._start_workers()
+        logger.info(f"SaxonWorkerPoolS9Api initialisiert mit {num_workers} Workern (XSLT 2.0/3.0)")
+
+    # --- Abstrakte Properties ---
+
+    @property
+    def _pool_name(self) -> str:
+        return "Saxon-S9Api"
+
+    @property
+    def _java_source_code(self) -> str:
+        return SAXON_S9API_WORKER_JAVA
+
+    @property
+    def _java_class_name(self) -> str:
+        return "SaxonS9ApiWorker"
+
+    @property
+    def _temp_dir_prefix(self) -> str:
+        return "saxon_s9api_worker_"
+
+    @property
+    def _worker_init_sleep(self) -> float:
+        return 0.1
+
+    # --- Abstrakte Methoden ---
+
+    def _get_classpath(self) -> str:
+        saxon_dir = self.saxon_jar_path.parent
+        if saxon_dir not in self.classpath_cache:
+            self.classpath_cache[saxon_dir] = build_jar_classpath(saxon_dir)
+            logger.debug(f"Classpath für {saxon_dir} neu erstellt und gecacht")
+        return self.classpath_cache[saxon_dir]
+
+    def _build_worker_cmd(self, full_classpath: str) -> list[str]:
+        return [str(self.java_vm_path), "-cp", full_classpath, "SaxonS9ApiWorker"]
+
+    def _stderr_log_name(self, i: int) -> str:
+        return f"s9api_worker_{i}_stderr.log"
+
+    # --- Saxon-s9api-spezifische Job-Methode ---
+
+    def transform(
+        self, source_xml: Path, xsl_stylesheet: Path, output_fo: Path, xslt_params: dict[str, str]
+    ) -> tuple[bool, str]:
+        """
+        Führt eine XSLT-Transformation mit einem Worker aus dem Pool aus.
+
+        Args:
+            source_xml: Pfad zur XML-Eingabedatei
+            xsl_stylesheet: Pfad zur XSL-Stylesheet-Datei
+            output_fo: Pfad zur FO-Ausgabedatei
+            xslt_params: Dictionary mit XSLT-Parametern
+
+        Returns:
+            tuple[bool, str]: (Erfolg, Fehlermeldung/Info)
+        """
+        worker_idx = self._acquire_worker()
+        try:
+            worker = self.workers[worker_idx]
+
+            if worker.poll() is not None:
+                stderr_content = self._read_stderr_log(worker_idx)
+                error_msg = (
+                    f"S9Api Worker {worker_idx} ist beendet (Exit: {worker.returncode})\nstderr:\n{stderr_content}"
+                )
+                logger.error(error_msg)
+                return False, error_msg
+
+            params_str = "|||".join([f"{k}={v}" for k, v in xslt_params.items()])
+            job = f"{source_xml}\t{xsl_stylesheet}\t{output_fo}\t{params_str}\n"
+
+            logger.debug(f"Sende Job an S9Api Worker {worker_idx}: {source_xml.name}")
+            worker.stdin.write(job)
+            worker.stdin.flush()
+
+            response = worker.stdout.readline().strip()
+            logger.debug(f"S9Api Worker {worker_idx} Antwort: '{response}'")
+
+            if response == "OK":
+                return True, "Erfolgreich"
+            elif response.startswith("ERROR:"):
+                return False, f"Saxon-Fehler (s9api): {response[6:].strip()}"
+            elif not response:
+                stderr_content = self._read_stderr_log(worker_idx, tail=500)
+                return False, f"S9Api Worker {worker_idx} crashed (keine Antwort)\nstderr:\n{stderr_content}"
+            else:
+                return False, f"Unerwartete Antwort: {response}"
+
+        except Exception as e:
+            logger.error(f"Fehler bei S9Api Worker {worker_idx}: {e}")
+            return False, f"Worker-Fehler: {str(e)}"
+        finally:
+            self.worker_locks[worker_idx].release()

src/transform.py

@@ -9,20 +9,31 @@ Dieses Modul implementiert die Transformations-Pipeline:
 
 import logging
 import subprocess
+import sys
 from pathlib import Path
 from datetime import datetime
 from typing import Any, Optional, TYPE_CHECKING
 
+# Verhindert Konsolenfenster bei Subprozessen in PyInstaller-EXE (Windows)
+_SUBPROCESS_FLAGS = subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0
+
 if TYPE_CHECKING:
     from saxon_pool import SaxonWorkerPool
+    from saxon_pool_s9api import SaxonWorkerPoolS9Api
+    from fop_pool import FopWorkerPool
+    from xsl_dependencies import XslDependencyGraph
 
 logger = logging.getLogger(__name__)
 
 # Globaler Saxon-Worker-Pool (wird von MainWindow initialisiert)
-_saxon_worker_pool: Optional["SaxonWorkerPool"] = None
+# Kann entweder JAXP oder s9api Variante sein
+_saxon_worker_pool: Optional["SaxonWorkerPool | SaxonWorkerPoolS9Api"] = None
+
+# Globaler FOP-Worker-Pool (wird von MainWindow initialisiert)
+_fop_worker_pool: Optional["FopWorkerPool"] = None
 
 
-def set_saxon_worker_pool(pool: Optional["SaxonWorkerPool"]):
+def set_saxon_worker_pool(pool: Optional["SaxonWorkerPool | SaxonWorkerPoolS9Api"]):
     """Setzt den globalen Saxon-Worker-Pool."""
     global _saxon_worker_pool
     _saxon_worker_pool = pool
@@ -32,6 +43,26 @@ def set_saxon_worker_pool(pool: Optional["SaxonWorkerPool"]):
         logger.info("Saxon-Worker-Pool deaktiviert (Fallback auf subprocess)")
 
 
+def get_saxon_worker_pool() -> Optional["SaxonWorkerPool | SaxonWorkerPoolS9Api"]:
+    """Gibt den aktuellen globalen Saxon-Worker-Pool zurück."""
+    return _saxon_worker_pool
+
+
+def set_fop_worker_pool(pool: Optional["FopWorkerPool"]):
+    """Setzt den globalen FOP-Worker-Pool."""
+    global _fop_worker_pool
+    _fop_worker_pool = pool
+    if pool:
+        logger.info(f"FOP-Worker-Pool aktiviert mit {pool.num_workers} Workern")
+    else:
+        logger.info("FOP-Worker-Pool deaktiviert (Fallback auf subprocess)")
+
+
+def get_fop_worker_pool() -> Optional["FopWorkerPool"]:
+    """Gibt den aktuellen globalen FOP-Worker-Pool zurück."""
+    return _fop_worker_pool
+
+
 class TransformationJob:
     """
     Repräsentiert einen einzelnen Transformations-Job.
@@ -55,6 +86,7 @@ class TransformationJob:
         diff_pdf_params: list[str],
         xsl_id: tuple | None = None,
         fop_config_dir: Path | None = None,
+        dependency_graph: Optional["XslDependencyGraph"] = None,
     ):
         """
         Initialisiert einen Transformations-Job.
@@ -71,6 +103,7 @@ class TransformationJob:
             diff_pdf_params: Standard-Parameter für diff-pdf
             xsl_id: ID der XSL-Datei (als Tuple)
             fop_config_dir: Optionaler Pfad zum FOP-Config-Verzeichnis (überschreibt Standardpfad)
+            dependency_graph: Optionaler XSL-Abhängigkeitsgraph für Import/Include-Prüfung
         """
         self.project_dir = project_dir
         self.xml_file = xml_file  # Relativ
@@ -85,6 +118,7 @@ class TransformationJob:
         self.fop_config_dir = fop_config_dir
         self.diff_pdf_path = diff_pdf_path
         self.diff_pdf_params = diff_pdf_params
+        self.dependency_graph = dependency_graph
 
         # Ausgabe-Verzeichnisse im Projektordner
         self.new_dir = project_dir / "new"
@@ -133,12 +167,12 @@ class TransformationJob:
         Returns:
             bool: True wenn New-PDF existiert und aktueller ist als alle Inputs
         """
-        if not self.new_pdf.exists():
+        try:
+            output_mtime = self.new_pdf.stat().st_mtime
+        except FileNotFoundError:
             logger.debug(f"New-PDF existiert nicht: {self.new_pdf}")
             return False
 
-        output_mtime = self.new_pdf.stat().st_mtime
-
         # Prüfe XML-Datei
         xml_abs = self.project_dir / self.xml_file
         if xml_abs.exists() and xml_abs.stat().st_mtime > output_mtime:
@@ -150,6 +184,13 @@ class TransformationJob:
             logger.debug(f"XSL-Datei ist neuer: {self.xsl_file}")
             return False
 
+        # Prüfe importierte/inkludierte XSL-Dateien (transitiv)
+        if self.dependency_graph and self.xsl_file.exists():
+            for dep_xsl in self.dependency_graph.get_dependencies(self.xsl_file):
+                if dep_xsl.exists() and dep_xsl.stat().st_mtime > output_mtime:
+                    logger.debug(f"Importierte XSL-Datei ist neuer: {dep_xsl}")
+                    return False
+
         logger.debug(f"Transformation ist aktuell: {self.new_pdf}")
         return True
 
@@ -256,6 +297,7 @@ class TransformationJob:
                 capture_output=True,
                 text=True,
                 timeout=120,  # 2 Minuten Timeout
+                creationflags=_SUBPROCESS_FLAGS,
             )
 
             # Saxon Ausgaben loggen
@@ -303,11 +345,55 @@ class TransformationJob:
             logger.error(error_msg)
             return False, error_msg
 
+        logger.info(f"Starte Apache FOP PDF-Generierung: {self.xml_file.name}")
+
+        # Versuche zuerst den Worker-Pool zu nutzen (schneller!)
+        global _fop_worker_pool
+        if _fop_worker_pool:
+            try:
+                success, message = _fop_worker_pool.build_pdf(
+                    input_fo=self.temp_fo,
+                    output_pdf=self.new_pdf,
+                )
+
+                if success:
+                    logger.info(f"FOP PDF-Generierung erfolgreich (Worker-Pool): {self.xml_file.name}")
+
+                    # Temporäre FO-Datei löschen
+                    if self.temp_fo.exists():
+                        try:
+                            self.temp_fo.unlink()
+                            logger.debug(f"Temporäre FO-Datei gelöscht: {self.temp_fo}")
+                        except Exception as e:
+                            logger.warning(f"Konnte FO-Datei nicht löschen: {e}")
+
+                    # Wenn kein Ref-PDF existiert, erstelle es
+                    if not self.ref_pdf.exists():
+                        try:
+                            import shutil
+
+                            shutil.copy2(self.new_pdf, self.ref_pdf)
+                            logger.info(f"Ref-PDF erstellt: {self.ref_pdf}")
+                        except Exception as e:
+                            logger.warning(f"Konnte Ref-PDF nicht erstellen: {e}")
+
+                    return True, "Erfolgreich"
+                else:
+                    logger.error(f"FOP PDF-Generierung fehlgeschlagen (Worker-Pool): {message}")
+                    return False, message
+
+            except Exception as e:
+                logger.warning(f"FOP Worker-Pool-Fehler, Fallback auf subprocess: {e}")
+                # Fallback auf subprocess unten
+
+        # Fallback: Traditionelle subprocess-Methode (langsamer, aber robuster)
+
         # Apache FOP Kommandozeile
+        fop_conf_exists = self.fop_conf.exists()
         cmd_line = [
             str(self.fop_cmd),
             "-c",
-            str(self.fop_conf) if self.fop_conf.exists() else "",
+            str(self.fop_conf) if fop_conf_exists else "",
             "-r",
             "-fo",
             str(self.temp_fo),
@@ -316,7 +402,7 @@ class TransformationJob:
         ]
 
         # Entferne leere Config-Parameter wenn fop.xconf nicht existiert
-        if not self.fop_conf.exists():
+        if not fop_conf_exists:
             cmd_line = [c for c in cmd_line if c not in ["-c", ""]]
 
         logger.info(f"Starte Apache FOP PDF-Generierung: {self.xml_file.name}")
@@ -328,6 +414,7 @@ class TransformationJob:
                 capture_output=True,
                 text=True,
                 timeout=180,  # 3 Minuten Timeout
+                creationflags=_SUBPROCESS_FLAGS,
             )
 
             # Apache FOP Ausgaben loggen
@@ -407,6 +494,7 @@ class TransformationJob:
                 capture_output=True,
                 text=True,
                 timeout=60,  # 1 Minute Timeout
+                creationflags=_SUBPROCESS_FLAGS,
             )
 
             if result.returncode == 0:
@@ -442,6 +530,7 @@ class TransformationJob:
                     capture_output=True,
                     text=True,
                     timeout=90,  # 1.5 Minuten Timeout
+                    creationflags=_SUBPROCESS_FLAGS,
                 )
 
                 if result_diff.returncode == 0 or self.diff_pdf.exists():

src/ui/AboutDialog.py

@@ -0,0 +1,157 @@
+"""
+Info-Dialog für DocuMentor.
+
+Zeigt Programmversion, Python-Version und alle Drittanbieter-Bibliotheken
+mit installierten Versionen und Lizenzinformationen an.
+"""
+import logging
+import sys
+from importlib.metadata import PackageNotFoundError, version
+from pathlib import Path
+
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QFont
+from PySide6.QtWidgets import (
+    QDialog,
+    QDialogButtonBox,
+    QFrame,
+    QHBoxLayout,
+    QHeaderView,
+    QLabel,
+    QTableWidget,
+    QTableWidgetItem,
+    QVBoxLayout,
+)
+
+from license_parser import parse_license_file
+
+logger = logging.getLogger(__name__)
+
+
+class AboutDialog(QDialog):
+    """Info-Dialog mit Versionsinformationen und Drittanbieter-Lizenzen."""
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Über DocuMentor")
+        self.resize(950, 620)
+        self.setSizeGripEnabled(True)
+        self.setModal(True)
+        self._setup_ui()
+        self._populate_data()
+
+    def _get_app_version(self) -> str:
+        """Ermittelt die Programmversion."""
+        try:
+            return version("DocuMentor")
+        except PackageNotFoundError:
+            # Fallback: pyproject.toml parsen (PyInstaller-Bundle oder Entwicklungsmodus)
+            try:
+                import tomllib
+
+                if hasattr(sys, "_MEIPASS"):
+                    pyproject = Path(sys._MEIPASS) / "pyproject.toml"  # type: ignore[attr-defined]
+                else:
+                    pyproject = Path(__file__).parent.parent.parent / "pyproject.toml"
+                with open(pyproject, "rb") as f:
+                    return tomllib.load(f)["project"]["version"]
+            except Exception:
+                return "unbekannt"
+
+    def _setup_ui(self):
+        """Erstellt das Dialog-Layout programmatisch."""
+        layout = QVBoxLayout(self)
+        layout.setSpacing(8)
+
+        # App-Name
+        self.app_name_label = QLabel("DocuMentor")
+        font = QFont()
+        font.setPointSize(18)
+        font.setBold(True)
+        self.app_name_label.setFont(font)
+        self.app_name_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        layout.addWidget(self.app_name_label)
+
+        # Beschreibung
+        self.description_label = QLabel("Professionelle XSL-Transformations-Verwaltung und PDF-Generierung")
+        self.description_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.description_label.setWordWrap(True)
+        layout.addWidget(self.description_label)
+
+        # Version + Python-Version
+        self.version_label = QLabel()
+        self.version_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        layout.addWidget(self.version_label)
+
+        # Lizenz
+        self.license_label = QLabel("Lizenz: MIT")
+        self.license_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        layout.addWidget(self.license_label)
+
+        # Separator
+        separator = QFrame()
+        separator.setFrameShape(QFrame.Shape.HLine)
+        separator.setFrameShadow(QFrame.Shadow.Sunken)
+        layout.addWidget(separator)
+
+        # Überschrift für Tabelle
+        header_layout = QHBoxLayout()
+        table_header = QLabel("Drittanbieter-Bibliotheken:")
+        header_font = QFont()
+        header_font.setBold(True)
+        table_header.setFont(header_font)
+        header_layout.addWidget(table_header)
+        header_layout.addStretch()
+        layout.addLayout(header_layout)
+
+        # Dependency-Tabelle
+        self.table = QTableWidget()
+        self.table.setColumnCount(6)
+        self.table.setHorizontalHeaderLabels(["Name", "Lizenz", "Installiert", "Webseite", "Copyright", "Kategorie"])
+        self.table.setEditTriggers(QTableWidget.EditTrigger.NoEditTriggers)
+        self.table.setSelectionBehavior(QTableWidget.SelectionBehavior.SelectRows)
+        self.table.setAlternatingRowColors(True)
+        self.table.setSortingEnabled(True)
+        self.table.verticalHeader().setVisible(False)
+
+        # Spaltenbreiten
+        header = self.table.horizontalHeader()
+        header.resizeSection(0, 170)  # Name
+        header.resizeSection(1, 180)  # Lizenz
+        header.resizeSection(2, 80)   # Installiert
+        header.resizeSection(5, 200)  # Kategorie
+        header.setSectionResizeMode(3, QHeaderView.ResizeMode.Stretch)  # Webseite
+        header.setSectionResizeMode(4, QHeaderView.ResizeMode.Stretch)  # Copyright
+
+        layout.addWidget(self.table)
+
+        # Schließen-Button
+        button_box = QDialogButtonBox(QDialogButtonBox.StandardButton.Close)
+        button_box.rejected.connect(self.reject)
+        button_box.setCenterButtons(True)
+        layout.addWidget(button_box)
+
+    def _populate_data(self):
+        """Befüllt den Dialog mit Versions- und Lizenzinformationen."""
+        # Version setzen
+        app_version = self._get_app_version()
+        python_version = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+        self.version_label.setText(f"Version: {app_version}  |  Python: {python_version}")
+
+        # Lizenzdaten laden und Tabelle befüllen
+        parsed = parse_license_file()
+        self.table.setRowCount(len(parsed.entries))
+
+        for row, entry in enumerate(parsed.entries):
+            self.table.setItem(row, 0, QTableWidgetItem(entry.name))
+            self.table.setItem(row, 1, QTableWidgetItem(entry.license))
+            self.table.setItem(row, 2, QTableWidgetItem(entry.installed_version or "—"))
+            if entry.website:
+                website_label = QLabel(f'<a href="{entry.website}">{entry.website}</a>')
+                website_label.setOpenExternalLinks(True)
+                website_label.setTextInteractionFlags(Qt.TextInteractionFlag.TextBrowserInteraction)
+                self.table.setCellWidget(row, 3, website_label)
+            else:
+                self.table.setItem(row, 3, QTableWidgetItem(""))
+            self.table.setItem(row, 4, QTableWidgetItem(entry.copyright))
+            self.table.setItem(row, 5, QTableWidgetItem(entry.category))

src/ui/AppSettings.py

@@ -1,4 +1,4 @@
-from PySide6.QtWidgets import QDialog, QTableWidgetItem, QHeaderView
+from PySide6.QtWidgets import QDialog, QTableWidgetItem, QHeaderView, QAbstractItemView
 from PySide6.QtCore import Qt
 from pathlib import Path
 
@@ -10,7 +10,7 @@ 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
+from conf import AppSettings, JavaVm, DiffPdf, SaxonJar, ApacheFop, XslDir, Project, PostgreSqlDb, XsltVersion
 
 
 class AppSettingsDlg(QDialog):
@@ -23,14 +23,11 @@ class AppSettingsDlg(QDialog):
     ):
         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()
@@ -39,89 +36,121 @@ class AppSettingsDlg(QDialog):
         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()
+        self._populate_performance_tab()
+
+    # --- Generische Helfer ---
+
+    def _update_remove_button(self, table, button):
+        """Aktiviert/deaktiviert einen Entfernen-Button je nach Tabellenauswahl."""
+        button.setEnabled(table.currentRow() >= 0)
+
+    def _add_item(self, dialog_class, temp_list, settings_attr, factory_fn, populate_fn):
+        """Öffnet einen Dialog, erstellt ein neues Objekt und fügt es der Liste hinzu."""
+        dialog = dialog_class(self)
+        if dialog.exec() == QDialog.DialogCode.Accepted:
+            data = dialog.get_data()
+            if data:
+                new_id = max((x.id for x in temp_list), default=0) + 1
+                temp_list.append(factory_fn(new_id, data))
+                populate_fn()
+                setattr(self.settings, settings_attr, temp_list.copy())
+                self.settings.save()
+                self._refresh_main_window_projects_menu()
+
+    def _remove_item(self, table, temp_list, settings_attr, update_fn, populate_fn):
+        """Entfernt das ausgewählte Element aus der Liste und speichert die Einstellungen."""
+        row = table.currentRow()
+        if row >= 0:
+            del temp_list[row]
+            populate_fn()
+            update_fn()
+            setattr(self.settings, settings_attr, temp_list.copy())
+            self.settings.save()
+            self._refresh_main_window_projects_menu()
+
+    def _edit_item(self, index, temp_list, dialog_class, fields, populate_fn):
+        """Öffnet einen Bearbeitungs-Dialog für das gewählte Element."""
+        row = index.row()
+        if 0 <= row < len(temp_list):
+            item = temp_list[row]
+            dialog = dialog_class(self)
+            dialog.set_data({f: getattr(item, f) for f in fields})
+            if dialog.exec() == QDialog.DialogCode.Accepted:
+                new_data = dialog.get_data()
+                if new_data:
+                    for f in fields:
+                        setattr(item, f, new_data[f])
+                    populate_fn()
+
+    # --- Signale und Tabellen-Setup ---
 
     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(
-        self.ui.tablePdfProjects.setHorizontalHeaderLabels(["Name", "Projekt-Ordner", "XSL-Ordner", "Java-VM", "Saxon", "Apache FOP", "Diff-PDF"])
+            ["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)
 
+    # --- Tabellen befüllen ---
+
     def _populate_tables(self):
         """Füllt alle Tabellen mit den aktuellen Einstellungen."""
         self._populate_xsl_table()
@@ -132,590 +161,333 @@ class AppSettingsDlg(QDialog):
         self._populate_pdf_project_table()
         self._populate_postgresql_db_table()
 
+    def _make_centered_item(self, text: str) -> QTableWidgetItem:
+        item = QTableWidgetItem(text)
+        item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
+        return item
+
     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):
+        for row, x in enumerate(self.temp_xsl_dirs):
-            name_item = QTableWidgetItem(xsl_dir.name)
+            self.ui.tableXsls.setItem(row, 0, self._make_centered_item(x.name))
-            name_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
+            self.ui.tableXsls.setItem(row, 1, self._make_centered_item(str(x.path_to_root_dir)))
-            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):
+        for row, x in enumerate(self.temp_java_vms):
-            version_item = QTableWidgetItem(java_vm.version)
+            self.ui.tableJavaVms.setItem(row, 0, self._make_centered_item(x.version))
-            version_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
+            self.ui.tableJavaVms.setItem(row, 1, self._make_centered_item(str(x.path_to_binary_file)))
-            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):
+        for row, x in enumerate(self.temp_saxon_jars):
-            version_item = QTableWidgetItem(saxon.version)
+            self.ui.tableSaxons.setItem(row, 0, self._make_centered_item(x.version))
-            version_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
+            self.ui.tableSaxons.setItem(row, 1, self._make_centered_item(str(x.path_to_jar_file)))
-            self.ui.tableSaxons.setItem(row, 0, version_item)
+            self.ui.tableSaxons.setItem(row, 2, self._make_centered_item(x.output_file_extension))
-            
-            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):
+        for row, x in enumerate(self.temp_apache_fops):
-            version_item = QTableWidgetItem(fop.version)
+            self.ui.tableApacheFops.setItem(row, 0, self._make_centered_item(x.version))
-            version_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
+            self.ui.tableApacheFops.setItem(row, 1, self._make_centered_item(str(x.path_to_dir)))
-            self.ui.tableApacheFops.setItem(row, 0, version_item)
+            self.ui.tableApacheFops.setItem(row, 2, self._make_centered_item(x.output_file_extension))
-            
-            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):
+        for row, x in enumerate(self.temp_diff_pdfs):
-            version_item = QTableWidgetItem(diff_pdf.version)
+            self.ui.tableDiffPdfs.setItem(row, 0, self._make_centered_item(x.version))
-            version_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
+            self.ui.tableDiffPdfs.setItem(row, 1, self._make_centered_item(str(x.path_to_binary_file)))
-            self.ui.tableDiffPdfs.setItem(row, 0, version_item)
+            self.ui.tableDiffPdfs.setItem(row, 2, self._make_centered_item(", ".join(x.default_params)))
-            
+            self.ui.tableDiffPdfs.setItem(row, 3, self._make_centered_item(x.output_file_extension))
-            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):
+        for row, p in enumerate(self.temp_pdf_projects):
-            name_item = QTableWidgetItem(pdf_project.name)
+            self.ui.tablePdfProjects.setItem(row, 0, self._make_centered_item(p.name))
-            name_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
+            self.ui.tablePdfProjects.setItem(row, 1, self._make_centered_item(str(p.project_dir)))
-            self.ui.tablePdfProjects.setItem(row, 0, name_item)
+            self.ui.tablePdfProjects.setItem(row, 2, self._make_centered_item(p.getXsl()))
-            
+            self.ui.tablePdfProjects.setItem(row, 3, self._make_centered_item(p.getJavaVm()))
-            project_dir_item = QTableWidgetItem(str(pdf_project.project_dir))
+            self.ui.tablePdfProjects.setItem(row, 4, self._make_centered_item(p.getSaxon()))
-            project_dir_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
+            self.ui.tablePdfProjects.setItem(row, 5, self._make_centered_item(p.getApacheFop()))
-            self.ui.tablePdfProjects.setItem(row, 1, project_dir_item)
+            self.ui.tablePdfProjects.setItem(row, 6, self._make_centered_item(p.getDiffPdf()))
-            
-            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):
+        for row, x in enumerate(self.temp_postgresql_dbs):
-            name_item = QTableWidgetItem(postgresql_db.name)
+            self.ui.tablePostgreSqlDbs.setItem(row, 0, self._make_centered_item(x.name))
-            name_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
+            self.ui.tablePostgreSqlDbs.setItem(row, 1, self._make_centered_item(x.host))
-            self.ui.tablePostgreSqlDbs.setItem(row, 0, name_item)
+            self.ui.tablePostgreSqlDbs.setItem(row, 2, self._make_centered_item(str(x.port)))
-            
+            self.ui.tablePostgreSqlDbs.setItem(row, 3, self._make_centered_item(x.database))
-            host_item = QTableWidgetItem(postgresql_db.host)
+            self.ui.tablePostgreSqlDbs.setItem(row, 4, self._make_centered_item(x.username))
-            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 _populate_performance_tab(self):
+        """Initialisiert den Performance-Tab mit den aktuellen Einstellungen."""
+        self.ui.spinBoxWorkerCount.setValue(self.settings.max_workers)
+        self.ui.checkBoxUseSaxonPool.setChecked(self.settings.use_saxon_worker_pool)
+        self.ui.comboBoxXsltVersion.setCurrentIndex(
+            0 if self.settings.saxon_xslt_version == XsltVersion.XSLT_1_0 else 1
+        )
+        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 ---
+
     def _add_xsl_dir(self):
-        """Fügt einen neuen XSL-Ordner hinzu."""
+        self._add_item(
-        dialog = XslDirConfigDialog(self)
+            XslDirConfigDialog, self.temp_xsl_dirs, "xsl_dirs",
-        if dialog.exec() == QDialog.DialogCode.Accepted:
+            lambda id, d: XslDir(id=id, name=d["name"], path_to_root_dir=d["path_to_root_dir"]),
-            data = dialog.get_data()
+            self._populate_xsl_table,
-            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."""
+        self._remove_item(
-        current_row = self.ui.tableXsls.currentRow()
+            self.ui.tableXsls, self.temp_xsl_dirs, "xsl_dirs",
-        if current_row >= 0:
+            self._update_xsl_buttons, self._populate_xsl_table,
-            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."""
+        self._update_remove_button(self.ui.tableXsls, self.ui.removeXsl)
-        has_selection = self.ui.tableXsls.currentRow() >= 0
+
-        self.ui.removeXsl.setEnabled(has_selection)
+    def _edit_xsl_dir(self, index):
+        self._edit_item(index, self.temp_xsl_dirs, XslDirConfigDialog,
+                        ["name", "path_to_root_dir"], self._populate_xsl_table)
+
+    # --- Java VM ---
 
-    # Java VM Methoden
     def _add_java_vm(self):
-        """Fügt eine neue Java VM hinzu."""
+        self._add_item(
-        dialog = JavaVmConfigDialog(self)
+            JavaVmConfigDialog, self.temp_java_vms, "java_vms",
-        if dialog.exec() == QDialog.DialogCode.Accepted:
+            lambda id, d: JavaVm(id=id, version=d["version"], path_to_binary_file=d["path_to_binary_file"]),
-            data = dialog.get_data()
+            self._populate_java_vm_table,
-            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."""
+        self._remove_item(
-        current_row = self.ui.tableJavaVms.currentRow()
+            self.ui.tableJavaVms, self.temp_java_vms, "java_vms",
-        if current_row >= 0:
+            self._update_java_vm_buttons, self._populate_java_vm_table,
-            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."""
+        self._update_remove_button(self.ui.tableJavaVms, self.ui.removeJavaVm)
-        has_selection = self.ui.tableJavaVms.currentRow() >= 0
+
-        self.ui.removeJavaVm.setEnabled(has_selection)
+    def _edit_java_vm(self, index):
+        self._edit_item(index, self.temp_java_vms, JavaVmConfigDialog,
+                        ["version", "path_to_binary_file"], self._populate_java_vm_table)
+
+    # --- Saxon ---
 
-    # Saxon Methoden
     def _add_saxon(self):
-        """Fügt eine neue Saxon JAR hinzu."""
+        self._add_item(
-        dialog = SaxonJarConfigDialog(self)
+            SaxonJarConfigDialog, self.temp_saxon_jars, "saxon_jars",
-        if dialog.exec() == QDialog.DialogCode.Accepted:
+            lambda id, d: SaxonJar(
-            data = dialog.get_data()
+                id=id, version=d["version"],
-            if data:
+                path_to_jar_file=d["path_to_jar_file"],
-                new_id = max([x.id for x in self.temp_saxon_jars], default=0) + 1
+                output_file_extension=d["output_file_extension"],
-                new_saxon = SaxonJar(
+            ),
-                    id=new_id,
+            self._populate_saxon_table,
-                    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."""
+        self._remove_item(
-        current_row = self.ui.tableSaxons.currentRow()
+            self.ui.tableSaxons, self.temp_saxon_jars, "saxon_jars",
-        if current_row >= 0:
+            self._update_saxon_buttons, self._populate_saxon_table,
-            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."""
+        self._update_remove_button(self.ui.tableSaxons, self.ui.removeSaxon)
-        has_selection = self.ui.tableSaxons.currentRow() >= 0
+
-        self.ui.removeSaxon.setEnabled(has_selection)
+    def _edit_saxon(self, index):
+        self._edit_item(index, self.temp_saxon_jars, SaxonJarConfigDialog,
+                        ["version", "path_to_jar_file", "output_file_extension"], self._populate_saxon_table)
+
+    # --- Apache FOP ---
 
-    # Apache FOP Methoden
     def _add_apache_fop(self):
-        """Fügt eine neue Apache FOP Konfiguration hinzu."""
+        self._add_item(
-        dialog = ApacheFopConfigDialog(self)
+            ApacheFopConfigDialog, self.temp_apache_fops, "apache_fops",
-        if dialog.exec() == QDialog.DialogCode.Accepted:
+            lambda id, d: ApacheFop(
-            data = dialog.get_data()
+                id=id, version=d["version"],
-            if data:
+                path_to_dir=d["path_to_dir"],
-                new_id = max([x.id for x in self.temp_apache_fops], default=0) + 1
+                output_file_extension=d["output_file_extension"],
-                new_fop = ApacheFop(
+            ),
-                    id=new_id,
+            self._populate_apache_fop_table,
-                    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."""
+        self._remove_item(
-        current_row = self.ui.tableApacheFops.currentRow()
+            self.ui.tableApacheFops, self.temp_apache_fops, "apache_fops",
-        if current_row >= 0:
+            self._update_apache_fop_buttons, self._populate_apache_fop_table,
-            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."""
+        self._update_remove_button(self.ui.tableApacheFops, self.ui.removeApacheFop)
-        has_selection = self.ui.tableApacheFops.currentRow() >= 0
+
-        self.ui.removeApacheFop.setEnabled(has_selection)
+    def _edit_apache_fop(self, index):
+        self._edit_item(index, self.temp_apache_fops, ApacheFopConfigDialog,
+                        ["version", "path_to_dir", "output_file_extension"], self._populate_apache_fop_table)
+
+    # --- Diff PDF ---
 
-    # Diff PDF Methoden
     def _add_diff_pdf(self):
-        """Fügt eine neue Diff PDF Konfiguration hinzu."""
+        self._add_item(
-        dialog = DiffPdfConfigDialog(self)
+            DiffPdfConfigDialog, self.temp_diff_pdfs, "diff_pdfs",
-        if dialog.exec() == QDialog.DialogCode.Accepted:
+            lambda id, d: DiffPdf(
-            data = dialog.get_data()
+                id=id, version=d["version"],
-            if data:
+                path_to_binary_file=d["path_to_binary_file"],
-                new_id = max([x.id for x in self.temp_diff_pdfs], default=0) + 1
+                default_params=d["default_params"],
-                new_diff_pdf = DiffPdf(
+                output_file_extension=d["output_file_extension"],
-                    id=new_id,
+            ),
-                    version=data["version"],
+            self._populate_diff_pdf_table,
-                    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."""
+        self._remove_item(
-        current_row = self.ui.tableDiffPdfs.currentRow()
+            self.ui.tableDiffPdfs, self.temp_diff_pdfs, "diff_pdfs",
-        if current_row >= 0:
+            self._update_diff_pdf_buttons, self._populate_diff_pdf_table,
-            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."""
+        self._update_remove_button(self.ui.tableDiffPdfs, self.ui.removeDiffPdf)
-        has_selection = self.ui.tableDiffPdfs.currentRow() >= 0
+
-        self.ui.removeDiffPdf.setEnabled(has_selection)
+    def _edit_diff_pdf(self, index):
+        self._edit_item(index, self.temp_diff_pdfs, DiffPdfConfigDialog,
+                        ["version", "path_to_binary_file", "default_params", "output_file_extension"],
+                        self._populate_diff_pdf_table)
+
+    # --- PDF-Projekte (Sonderbehandlung wegen komplexer Logik) ---
 
-    # 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()
-            
+            new_id = max((p.id for p in self.temp_pdf_projects), default=0) + 1
-            # 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'],
+                name=project_data["name"],
-                project_dir=Path(project_data['project_dir']),
+                project_dir=Path(project_data["project_dir"]),
-                java_vm_id=project_data['java_vm_id'] if project_data['java_vm_id'] != -1 else 1,
+                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,
+                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,
+                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,
+                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,
+                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,
+                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,
+                fop_config_dir=Path(project_data["fop_config_dir"]) if project_data.get("fop_config_dir") else None,
+                xslt_params=project_data.get("xslt_params", {}),
             )
-            
             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."""
+        self._remove_item(
-        current_row = self.ui.tablePdfProjects.currentRow()
+            self.ui.tablePdfProjects, self.temp_pdf_projects, "pdf_projects",
-        if current_row >= 0:
+            self._update_pdf_project_buttons, self._populate_pdf_project_table,
-            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."""
+        self._update_remove_button(self.ui.tablePdfProjects, self.ui.removeProject)
-        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,
+                "name": pdf_project.name,
-                'project_dir': str(pdf_project.project_dir),
+                "project_dir": str(pdf_project.project_dir),
-                'java_vm_id': pdf_project.java_vm_id,
+                "java_vm_id": pdf_project.java_vm_id,
-                'diff_pdf_id': pdf_project.diff_pdf_id,
+                "diff_pdf_id": pdf_project.diff_pdf_id,
-                'saxon_jar_id': pdf_project.saxon_jar_id,
+                "saxon_jar_id": pdf_project.saxon_jar_id,
-                'apache_fop_id': pdf_project.apache_fop_id,
+                "apache_fop_id": pdf_project.apache_fop_id,
-                'xsl_dir_id': pdf_project.xsl_dir_id,
+                "xsl_dir_id": pdf_project.xsl_dir_id,
-                'postgre_sql_db_id': pdf_project.postgre_sql_db_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
+                "fop_config_dir": str(pdf_project.fop_config_dir) if pdf_project.fop_config_dir else None,
+                "xslt_params": dict(pdf_project.xslt_params),
             }
-            
-            # 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()
-                
+                pdf_project.name = new_data["name"]
-                # Nur die Einstellungen aktualisieren (Name und Ordner bleiben unverändert)
+                pdf_project.java_vm_id = (
-                pdf_project.java_vm_id = new_data['java_vm_id'] if new_data['java_vm_id'] != -1 else 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.diff_pdf_id = (
-                pdf_project.apache_fop_id = new_data['apache_fop_id'] if new_data['apache_fop_id'] != -1 else pdf_project.apache_fop_id
+                    new_data["diff_pdf_id"] if new_data["diff_pdf_id"] != -1 else pdf_project.diff_pdf_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.saxon_jar_id = (
-                pdf_project.fop_config_dir = Path(new_data['fop_config_dir']) if new_data.get('fop_config_dir') else None
+                    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
+                )
+                pdf_project.xslt_params = new_data.get("xslt_params", {})
                 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 ---
 
-    # PostgreSQL Methoden
     def _add_postgresql_db(self):
-        """Fügt eine neue PostgreSQL-Datenbank hinzu."""
+        self._add_item(
-        dialog = PostgreSqlConfigDialog(self)
+            PostgreSqlConfigDialog, self.temp_postgresql_dbs, "postgresql_dbs",
-        if dialog.exec() == QDialog.DialogCode.Accepted:
+            lambda id, d: PostgreSqlDb(
-            data = dialog.get_data()
+                id=id, name=d["name"], host=d["host"], port=d["port"],
-            if data:
+                database=d["database"], username=d["username"], password=d["password"],
-                new_id = max([x.id for x in self.temp_postgresql_dbs], default=0) + 1
+            ),
-                new_postgresql_db = PostgreSqlDb(
+            self._populate_postgresql_db_table,
-                    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."""
+        self._remove_item(
-        current_row = self.ui.tablePostgreSqlDbs.currentRow()
+            self.ui.tablePostgreSqlDbs, self.temp_postgresql_dbs, "postgresql_dbs",
-        if current_row >= 0:
+            self._update_postgresql_db_buttons, self._populate_postgresql_db_table,
-            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."""
+        self._update_remove_button(self.ui.tablePostgreSqlDbs, self.ui.removePostgreSql)
-        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."""
+        self._edit_item(index, self.temp_postgresql_dbs, PostgreSqlConfigDialog,
-        row = index.row()
+                        ["name", "host", "port", "database", "username", "password"],
-        if 0 <= row < len(self.temp_postgresql_dbs):
+                        self._populate_postgresql_db_table)
-            postgresql_db = self.temp_postgresql_dbs[row]
-            dialog = PostgreSqlConfigDialog(self)
 
-            # Vorhandene Daten setzen
+    # --- Dialog-Abschluss ---
-            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()
@@ -723,8 +495,15 @@ class AppSettingsDlg(QDialog):
         self.settings.xsl_dirs = self.temp_xsl_dirs.copy()
         self.settings.pdf_projects = self.temp_pdf_projects.copy()
 
-        self.settings.save()
+        self.settings.max_workers = self.ui.spinBoxWorkerCount.value()
+        self.settings.use_saxon_worker_pool = self.ui.checkBoxUseSaxonPool.isChecked()
+        self.settings.saxon_xslt_version = (
+            XsltVersion.XSLT_1_0 if self.ui.comboBoxXsltVersion.currentIndex() == 0 else 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:

src/ui/AppSettings.ui

@@ -7,7 +7,7 @@
     <x>0</x>
     <y>0</y>
     <width>833</width>
-    <height>387</height>
+    <height>526</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -520,6 +520,208 @@
        </item>
       </layout>
      </widget>
+     <widget class="QWidget" name="tabPerformance">
+      <attribute name="title">
+       <string>Performance</string>
+      </attribute>
+      <layout class="QVBoxLayout" name="verticalLayout_9">
+       <item>
+        <widget class="QGroupBox" name="groupBoxWorker">
+         <property name="title">
+          <string>ThreadPoolExecutor Einstellungen</string>
+         </property>
+         <layout class="QVBoxLayout" name="verticalLayout_10">
+          <item>
+           <widget class="QLabel" name="labelWorkerCount">
+            <property name="text">
+             <string>Anzahl paralleler Worker für Transformationen:</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QSpinBox" name="spinBoxWorkerCount">
+            <property name="toolTip">
+             <string>Anzahl der parallelen Worker-Threads für Transformationen (Standard: 8)</string>
+            </property>
+            <property name="minimum">
+             <number>1</number>
+            </property>
+            <property name="maximum">
+             <number>32</number>
+            </property>
+            <property name="value">
+             <number>8</number>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item>
+        <widget class="QGroupBox" name="groupBoxSaxonPool">
+         <property name="title">
+          <string>SaxonWorkerPool Einstellungen</string>
+         </property>
+         <layout class="QVBoxLayout" name="verticalLayout_11">
+          <item>
+           <widget class="QCheckBox" name="checkBoxUseSaxonPool">
+            <property name="toolTip">
+             <string>Aktiviert persistente JVM-Prozesse für Saxon-Transformationen.
+Vorteile: Bis zu 10x schneller durch Eliminierung von JVM-Startup-Overhead
+Nachteile: Benötigt JDK (javac) - funktioniert nicht mit JRE allein
+
+Deaktivieren Sie diese Option, wenn:
+• Sie nur ein JRE (keine JDK) installiert haben
+• Sie Probleme mit dem Worker-Pool haben
+• Sie die Funktion testen möchten</string>
+            </property>
+            <property name="text">
+             <string>SaxonWorkerPool verwenden (empfohlen)</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <layout class="QHBoxLayout" name="horizontalLayoutXsltVersion">
+            <item>
+             <widget class="QLabel" name="labelXsltVersion">
+              <property name="text">
+               <string>XSLT-Version:</string>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <widget class="QComboBox" name="comboBoxXsltVersion">
+              <property name="toolTip">
+               <string>Wählen Sie die XSLT-Version für Saxon-Transformationen:
+
+XSLT 1.0 (JAXP): Verwendet die JAXP Transformer API
+• Nur für XSLT 1.0 vollständig spezifiziert
+• Kann bei XSLT 2.0/3.0 zu fehlerhaften Ausgaben führen
+
+XSLT 2.0/3.0 (s9api): Verwendet die Saxon s9api
+• Vollständige Unterstützung für XSLT 2.0 und 3.0
+• Empfohlen für moderne XSLT-Stylesheets</string>
+              </property>
+              <item>
+               <property name="text">
+                <string>XSLT 1.0 (JAXP)</string>
+               </property>
+              </item>
+              <item>
+               <property name="text">
+                <string>XSLT 2.0/3.0 (s9api) - Empfohlen</string>
+               </property>
+              </item>
+             </widget>
+            </item>
+            <item>
+             <spacer name="horizontalSpacerXsltVersion">
+              <property name="orientation">
+               <enum>Qt::Orientation::Horizontal</enum>
+              </property>
+              <property name="sizeHint" stdset="0">
+               <size>
+                <width>40</width>
+                <height>20</height>
+               </size>
+              </property>
+             </spacer>
+            </item>
+           </layout>
+          </item>
+          <item>
+           <widget class="QLabel" name="labelSaxonPoolInfo">
+            <property name="text">
+             <string>&lt;i&gt;Hinweis: SaxonWorkerPool benötigt ein JDK (Java Development Kit).&lt;br&gt;Mit JRE allein werden Transformationen im Fallback-Modus ausgeführt.&lt;/i&gt;</string>
+            </property>
+            <property name="wordWrap">
+             <bool>true</bool>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item>
+        <widget class="QGroupBox" name="groupBoxFopPool">
+         <property name="title">
+          <string>FopWorkerPool Einstellungen</string>
+         </property>
+         <layout class="QVBoxLayout" name="verticalLayout_12">
+          <item>
+           <widget class="QCheckBox" name="checkBoxUseFopPool">
+            <property name="toolTip">
+             <string>Aktiviert persistente JVM-Prozesse für Apache FOP PDF-Generierung.
+Vorteile: Bis zu 10x schneller durch Eliminierung von JVM-Startup-Overhead
+Nachteile: Benötigt JDK (javac) - funktioniert nicht mit JRE allein
+
+Deaktivieren Sie diese Option, wenn:
+• Sie nur ein JRE (keine JDK) installiert haben
+• Sie Probleme mit dem Worker-Pool haben
+• Sie die Funktion testen möchten</string>
+            </property>
+            <property name="text">
+             <string>FopWorkerPool verwenden (empfohlen)</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QLabel" name="labelFopPoolInfo">
+            <property name="text">
+             <string>&lt;i&gt;Hinweis: FopWorkerPool benötigt ein JDK (Java Development Kit).&lt;br&gt;Mit JRE allein werden PDFs im Fallback-Modus generiert.&lt;/i&gt;</string>
+            </property>
+            <property name="wordWrap">
+             <bool>true</bool>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item>
+        <spacer name="verticalSpacer">
+         <property name="orientation">
+          <enum>Qt::Orientation::Vertical</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>20</width>
+           <height>40</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+       <item>
+        <widget class="QLabel" name="label">
+         <property name="mouseTracking">
+          <bool>true</bool>
+         </property>
+         <property name="text">
+          <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-weight:700; font-style:italic;&quot;&gt;Hinweis: Änderungen in diesem Dialog sind unter Umständen erst nach neu start der Anwendung wirksam.&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+         </property>
+         <property name="alignment">
+          <set>Qt::AlignmentFlag::AlignCenter</set>
+         </property>
+         <property name="wordWrap">
+          <bool>true</bool>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <spacer name="verticalSpacerPerformance">
+         <property name="orientation">
+          <enum>Qt::Orientation::Vertical</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>20</width>
+           <height>40</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+      </layout>
+     </widget>
     </widget>
    </item>
    <item>

src/ui/AppSettings_ui.py

@@ -1,351 +1,498 @@
-# -*- coding: utf-8 -*-
+# -*- coding: utf-8 -*-
-
+
-################################################################################
+################################################################################
-## Form generated from reading UI file 'AppSettings.ui'
+## Form generated from reading UI file 'AppSettings.ui'
-##
+##
-## Created by: Qt User Interface Compiler version 6.9.1
+## Created by: Qt User Interface Compiler version 6.9.2
-##
+##
-## WARNING! All changes made in this file will be lost when recompiling UI file!
+## WARNING! All changes made in this file will be lost when recompiling UI file!
-################################################################################
+################################################################################
-
+
-from PySide6.QtCore import (QCoreApplication, QDate, QDateTime, QLocale,
+from PySide6.QtCore import (QCoreApplication, QDate, QDateTime, QLocale,
-    QMetaObject, QObject, QPoint, QRect,
+    QMetaObject, QObject, QPoint, QRect,
-    QSize, QTime, QUrl, Qt)
+    QSize, QTime, QUrl, Qt)
-from PySide6.QtGui import (QBrush, QColor, QConicalGradient, QCursor,
+from PySide6.QtGui import (QBrush, QColor, QConicalGradient, QCursor,
-    QFont, QFontDatabase, QGradient, QIcon,
+    QFont, QFontDatabase, QGradient, QIcon,
-    QImage, QKeySequence, QLinearGradient, QPainter,
+    QImage, QKeySequence, QLinearGradient, QPainter,
-    QPalette, QPixmap, QRadialGradient, QTransform)
+    QPalette, QPixmap, QRadialGradient, QTransform)
-from PySide6.QtWidgets import (QAbstractButton, QApplication, QDialog, QDialogButtonBox,
+from PySide6.QtWidgets import (QAbstractButton, QApplication, QCheckBox, QComboBox,
-    QFrame, QHBoxLayout, QHeaderView, QPushButton,
+    QDialog, QDialogButtonBox, QFrame, QGroupBox,
-    QSizePolicy, QTabWidget, QTableWidget, QTableWidgetItem,
+    QHBoxLayout, QHeaderView, QLabel, QPushButton,
-    QVBoxLayout, QWidget)
+    QSizePolicy, QSpacerItem, QSpinBox, QTabWidget,
-
+    QTableWidget, QTableWidgetItem, QVBoxLayout, QWidget)
-class Ui_Dialog(object):
+
-    def setupUi(self, Dialog):
+class Ui_Dialog(object):
-        if not Dialog.objectName():
+    def setupUi(self, Dialog):
-            Dialog.setObjectName(u"Dialog")
+        if not Dialog.objectName():
-        Dialog.resize(833, 387)
+            Dialog.setObjectName(u"Dialog")
-        self.verticalLayout = QVBoxLayout(Dialog)
+        Dialog.resize(833, 526)
-        self.verticalLayout.setObjectName(u"verticalLayout")
+        self.verticalLayout = QVBoxLayout(Dialog)
-        self.tabSettings = QTabWidget(Dialog)
+        self.verticalLayout.setObjectName(u"verticalLayout")
-        self.tabSettings.setObjectName(u"tabSettings")
+        self.tabSettings = QTabWidget(Dialog)
-        self.tabSettings.setEnabled(True)
+        self.tabSettings.setObjectName(u"tabSettings")
-        self.tabSettings.setElideMode(Qt.TextElideMode.ElideRight)
+        self.tabSettings.setEnabled(True)
-        self.tabXsls = QWidget()
+        self.tabSettings.setElideMode(Qt.TextElideMode.ElideRight)
-        self.tabXsls.setObjectName(u"tabXsls")
+        self.tabXsls = QWidget()
-        self.verticalLayout_5 = QVBoxLayout(self.tabXsls)
+        self.tabXsls.setObjectName(u"tabXsls")
-        self.verticalLayout_5.setObjectName(u"verticalLayout_5")
+        self.verticalLayout_5 = QVBoxLayout(self.tabXsls)
-        self.tableXsls = QTableWidget(self.tabXsls)
+        self.verticalLayout_5.setObjectName(u"verticalLayout_5")
-        if (self.tableXsls.columnCount() < 2):
+        self.tableXsls = QTableWidget(self.tabXsls)
-            self.tableXsls.setColumnCount(2)
+        if (self.tableXsls.columnCount() < 2):
-        self.tableXsls.setObjectName(u"tableXsls")
+            self.tableXsls.setColumnCount(2)
-        self.tableXsls.setColumnCount(2)
+        self.tableXsls.setObjectName(u"tableXsls")
-
+        self.tableXsls.setColumnCount(2)
-        self.verticalLayout_5.addWidget(self.tableXsls)
+
-
+        self.verticalLayout_5.addWidget(self.tableXsls)
-        self.frame_2 = QFrame(self.tabXsls)
+
-        self.frame_2.setObjectName(u"frame_2")
+        self.frame_2 = QFrame(self.tabXsls)
-        sizePolicy = QSizePolicy(QSizePolicy.Policy.Maximum, QSizePolicy.Policy.Preferred)
+        self.frame_2.setObjectName(u"frame_2")
-        sizePolicy.setHorizontalStretch(0)
+        sizePolicy = QSizePolicy(QSizePolicy.Policy.Maximum, QSizePolicy.Policy.Preferred)
-        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHorizontalStretch(0)
-        sizePolicy.setHeightForWidth(self.frame_2.sizePolicy().hasHeightForWidth())
+        sizePolicy.setVerticalStretch(0)
-        self.frame_2.setSizePolicy(sizePolicy)
+        sizePolicy.setHeightForWidth(self.frame_2.sizePolicy().hasHeightForWidth())
-        self.frame_2.setFrameShape(QFrame.Shape.NoFrame)
+        self.frame_2.setSizePolicy(sizePolicy)
-        self.frame_2.setFrameShadow(QFrame.Shadow.Raised)
+        self.frame_2.setFrameShape(QFrame.Shape.NoFrame)
-        self.horizontalLayout_2 = QHBoxLayout(self.frame_2)
+        self.frame_2.setFrameShadow(QFrame.Shadow.Raised)
-        self.horizontalLayout_2.setObjectName(u"horizontalLayout_2")
+        self.horizontalLayout_2 = QHBoxLayout(self.frame_2)
-        self.horizontalLayout_2.setContentsMargins(0, 1, 0, 0)
+        self.horizontalLayout_2.setObjectName(u"horizontalLayout_2")
-        self.addXsl = QPushButton(self.frame_2)
+        self.horizontalLayout_2.setContentsMargins(0, 1, 0, 0)
-        self.addXsl.setObjectName(u"addXsl")
+        self.addXsl = QPushButton(self.frame_2)
-        icon = QIcon(QIcon.fromTheme(QIcon.ThemeIcon.ListAdd))
+        self.addXsl.setObjectName(u"addXsl")
-        self.addXsl.setIcon(icon)
+        icon = QIcon(QIcon.fromTheme(QIcon.ThemeIcon.ListAdd))
-
+        self.addXsl.setIcon(icon)
-        self.horizontalLayout_2.addWidget(self.addXsl)
+
-
+        self.horizontalLayout_2.addWidget(self.addXsl)
-        self.removeXsl = QPushButton(self.frame_2)
+
-        self.removeXsl.setObjectName(u"removeXsl")
+        self.removeXsl = QPushButton(self.frame_2)
-        self.removeXsl.setEnabled(False)
+        self.removeXsl.setObjectName(u"removeXsl")
-        icon1 = QIcon(QIcon.fromTheme(QIcon.ThemeIcon.ListRemove))
+        self.removeXsl.setEnabled(False)
-        self.removeXsl.setIcon(icon1)
+        icon1 = QIcon(QIcon.fromTheme(QIcon.ThemeIcon.ListRemove))
-
+        self.removeXsl.setIcon(icon1)
-        self.horizontalLayout_2.addWidget(self.removeXsl)
+
-
+        self.horizontalLayout_2.addWidget(self.removeXsl)
-
+
-        self.verticalLayout_5.addWidget(self.frame_2)
+
-
+        self.verticalLayout_5.addWidget(self.frame_2)
-        self.tabSettings.addTab(self.tabXsls, "")
+
-        self.tabJavaVm = QWidget()
+        self.tabSettings.addTab(self.tabXsls, "")
-        self.tabJavaVm.setObjectName(u"tabJavaVm")
+        self.tabJavaVm = QWidget()
-        self.verticalLayout_2 = QVBoxLayout(self.tabJavaVm)
+        self.tabJavaVm.setObjectName(u"tabJavaVm")
-        self.verticalLayout_2.setObjectName(u"verticalLayout_2")
+        self.verticalLayout_2 = QVBoxLayout(self.tabJavaVm)
-        self.tableJavaVms = QTableWidget(self.tabJavaVm)
+        self.verticalLayout_2.setObjectName(u"verticalLayout_2")
-        if (self.tableJavaVms.columnCount() < 2):
+        self.tableJavaVms = QTableWidget(self.tabJavaVm)
-            self.tableJavaVms.setColumnCount(2)
+        if (self.tableJavaVms.columnCount() < 2):
-        self.tableJavaVms.setObjectName(u"tableJavaVms")
+            self.tableJavaVms.setColumnCount(2)
-        self.tableJavaVms.setColumnCount(2)
+        self.tableJavaVms.setObjectName(u"tableJavaVms")
-
+        self.tableJavaVms.setColumnCount(2)
-        self.verticalLayout_2.addWidget(self.tableJavaVms)
+
-
+        self.verticalLayout_2.addWidget(self.tableJavaVms)
-        self.frame_3 = QFrame(self.tabJavaVm)
+
-        self.frame_3.setObjectName(u"frame_3")
+        self.frame_3 = QFrame(self.tabJavaVm)
-        sizePolicy.setHeightForWidth(self.frame_3.sizePolicy().hasHeightForWidth())
+        self.frame_3.setObjectName(u"frame_3")
-        self.frame_3.setSizePolicy(sizePolicy)
+        sizePolicy.setHeightForWidth(self.frame_3.sizePolicy().hasHeightForWidth())
-        self.frame_3.setFrameShape(QFrame.Shape.NoFrame)
+        self.frame_3.setSizePolicy(sizePolicy)
-        self.frame_3.setFrameShadow(QFrame.Shadow.Raised)
+        self.frame_3.setFrameShape(QFrame.Shape.NoFrame)
-        self.horizontalLayout_3 = QHBoxLayout(self.frame_3)
+        self.frame_3.setFrameShadow(QFrame.Shadow.Raised)
-        self.horizontalLayout_3.setObjectName(u"horizontalLayout_3")
+        self.horizontalLayout_3 = QHBoxLayout(self.frame_3)
-        self.horizontalLayout_3.setContentsMargins(0, 0, 0, 0)
+        self.horizontalLayout_3.setObjectName(u"horizontalLayout_3")
-        self.addJavaVm = QPushButton(self.frame_3)
+        self.horizontalLayout_3.setContentsMargins(0, 0, 0, 0)
-        self.addJavaVm.setObjectName(u"addJavaVm")
+        self.addJavaVm = QPushButton(self.frame_3)
-        self.addJavaVm.setIcon(icon)
+        self.addJavaVm.setObjectName(u"addJavaVm")
-
+        self.addJavaVm.setIcon(icon)
-        self.horizontalLayout_3.addWidget(self.addJavaVm)
+
-
+        self.horizontalLayout_3.addWidget(self.addJavaVm)
-        self.removeJavaVm = QPushButton(self.frame_3)
+
-        self.removeJavaVm.setObjectName(u"removeJavaVm")
+        self.removeJavaVm = QPushButton(self.frame_3)
-        self.removeJavaVm.setEnabled(False)
+        self.removeJavaVm.setObjectName(u"removeJavaVm")
-        self.removeJavaVm.setIcon(icon1)
+        self.removeJavaVm.setEnabled(False)
-
+        self.removeJavaVm.setIcon(icon1)
-        self.horizontalLayout_3.addWidget(self.removeJavaVm)
+
-
+        self.horizontalLayout_3.addWidget(self.removeJavaVm)
-
+
-        self.verticalLayout_2.addWidget(self.frame_3)
+
-
+        self.verticalLayout_2.addWidget(self.frame_3)
-        self.tabSettings.addTab(self.tabJavaVm, "")
+
-        self.tabSaxon = QWidget()
+        self.tabSettings.addTab(self.tabJavaVm, "")
-        self.tabSaxon.setObjectName(u"tabSaxon")
+        self.tabSaxon = QWidget()
-        self.verticalLayout_4 = QVBoxLayout(self.tabSaxon)
+        self.tabSaxon.setObjectName(u"tabSaxon")
-        self.verticalLayout_4.setObjectName(u"verticalLayout_4")
+        self.verticalLayout_4 = QVBoxLayout(self.tabSaxon)
-        self.tableSaxons = QTableWidget(self.tabSaxon)
+        self.verticalLayout_4.setObjectName(u"verticalLayout_4")
-        if (self.tableSaxons.columnCount() < 3):
+        self.tableSaxons = QTableWidget(self.tabSaxon)
-            self.tableSaxons.setColumnCount(3)
+        if (self.tableSaxons.columnCount() < 3):
-        self.tableSaxons.setObjectName(u"tableSaxons")
+            self.tableSaxons.setColumnCount(3)
-        self.tableSaxons.setColumnCount(3)
+        self.tableSaxons.setObjectName(u"tableSaxons")
-
+        self.tableSaxons.setColumnCount(3)
-        self.verticalLayout_4.addWidget(self.tableSaxons)
+
-
+        self.verticalLayout_4.addWidget(self.tableSaxons)
-        self.frame_4 = QFrame(self.tabSaxon)
+
-        self.frame_4.setObjectName(u"frame_4")
+        self.frame_4 = QFrame(self.tabSaxon)
-        sizePolicy.setHeightForWidth(self.frame_4.sizePolicy().hasHeightForWidth())
+        self.frame_4.setObjectName(u"frame_4")
-        self.frame_4.setSizePolicy(sizePolicy)
+        sizePolicy.setHeightForWidth(self.frame_4.sizePolicy().hasHeightForWidth())
-        self.frame_4.setFrameShape(QFrame.Shape.NoFrame)
+        self.frame_4.setSizePolicy(sizePolicy)
-        self.frame_4.setFrameShadow(QFrame.Shadow.Raised)
+        self.frame_4.setFrameShape(QFrame.Shape.NoFrame)
-        self.horizontalLayout_4 = QHBoxLayout(self.frame_4)
+        self.frame_4.setFrameShadow(QFrame.Shadow.Raised)
-        self.horizontalLayout_4.setObjectName(u"horizontalLayout_4")
+        self.horizontalLayout_4 = QHBoxLayout(self.frame_4)
-        self.horizontalLayout_4.setContentsMargins(0, 0, 0, 0)
+        self.horizontalLayout_4.setObjectName(u"horizontalLayout_4")
-        self.addSaxon = QPushButton(self.frame_4)
+        self.horizontalLayout_4.setContentsMargins(0, 0, 0, 0)
-        self.addSaxon.setObjectName(u"addSaxon")
+        self.addSaxon = QPushButton(self.frame_4)
-        self.addSaxon.setIcon(icon)
+        self.addSaxon.setObjectName(u"addSaxon")
-
+        self.addSaxon.setIcon(icon)
-        self.horizontalLayout_4.addWidget(self.addSaxon)
+
-
+        self.horizontalLayout_4.addWidget(self.addSaxon)
-        self.removeSaxon = QPushButton(self.frame_4)
+
-        self.removeSaxon.setObjectName(u"removeSaxon")
+        self.removeSaxon = QPushButton(self.frame_4)
-        self.removeSaxon.setEnabled(False)
+        self.removeSaxon.setObjectName(u"removeSaxon")
-        self.removeSaxon.setIcon(icon1)
+        self.removeSaxon.setEnabled(False)
-
+        self.removeSaxon.setIcon(icon1)
-        self.horizontalLayout_4.addWidget(self.removeSaxon)
+
-
+        self.horizontalLayout_4.addWidget(self.removeSaxon)
-
+
-        self.verticalLayout_4.addWidget(self.frame_4)
+
-
+        self.verticalLayout_4.addWidget(self.frame_4)
-        self.tabSettings.addTab(self.tabSaxon, "")
+
-        self.tabApacheFop = QWidget()
+        self.tabSettings.addTab(self.tabSaxon, "")
-        self.tabApacheFop.setObjectName(u"tabApacheFop")
+        self.tabApacheFop = QWidget()
-        self.verticalLayout_3 = QVBoxLayout(self.tabApacheFop)
+        self.tabApacheFop.setObjectName(u"tabApacheFop")
-        self.verticalLayout_3.setObjectName(u"verticalLayout_3")
+        self.verticalLayout_3 = QVBoxLayout(self.tabApacheFop)
-        self.tableApacheFops = QTableWidget(self.tabApacheFop)
+        self.verticalLayout_3.setObjectName(u"verticalLayout_3")
-        if (self.tableApacheFops.columnCount() < 3):
+        self.tableApacheFops = QTableWidget(self.tabApacheFop)
-            self.tableApacheFops.setColumnCount(3)
+        if (self.tableApacheFops.columnCount() < 3):
-        self.tableApacheFops.setObjectName(u"tableApacheFops")
+            self.tableApacheFops.setColumnCount(3)
-        self.tableApacheFops.setColumnCount(3)
+        self.tableApacheFops.setObjectName(u"tableApacheFops")
-
+        self.tableApacheFops.setColumnCount(3)
-        self.verticalLayout_3.addWidget(self.tableApacheFops)
+
-
+        self.verticalLayout_3.addWidget(self.tableApacheFops)
-        self.frame = QFrame(self.tabApacheFop)
+
-        self.frame.setObjectName(u"frame")
+        self.frame = QFrame(self.tabApacheFop)
-        sizePolicy.setHeightForWidth(self.frame.sizePolicy().hasHeightForWidth())
+        self.frame.setObjectName(u"frame")
-        self.frame.setSizePolicy(sizePolicy)
+        sizePolicy.setHeightForWidth(self.frame.sizePolicy().hasHeightForWidth())
-        self.frame.setFrameShape(QFrame.Shape.NoFrame)
+        self.frame.setSizePolicy(sizePolicy)
-        self.frame.setFrameShadow(QFrame.Shadow.Raised)
+        self.frame.setFrameShape(QFrame.Shape.NoFrame)
-        self.horizontalLayout = QHBoxLayout(self.frame)
+        self.frame.setFrameShadow(QFrame.Shadow.Raised)
-        self.horizontalLayout.setObjectName(u"horizontalLayout")
+        self.horizontalLayout = QHBoxLayout(self.frame)
-        self.horizontalLayout.setContentsMargins(0, 0, 0, 0)
+        self.horizontalLayout.setObjectName(u"horizontalLayout")
-        self.addApacheFop = QPushButton(self.frame)
+        self.horizontalLayout.setContentsMargins(0, 0, 0, 0)
-        self.addApacheFop.setObjectName(u"addApacheFop")
+        self.addApacheFop = QPushButton(self.frame)
-        self.addApacheFop.setIcon(icon)
+        self.addApacheFop.setObjectName(u"addApacheFop")
-
+        self.addApacheFop.setIcon(icon)
-        self.horizontalLayout.addWidget(self.addApacheFop)
+
-
+        self.horizontalLayout.addWidget(self.addApacheFop)
-        self.removeApacheFop = QPushButton(self.frame)
+
-        self.removeApacheFop.setObjectName(u"removeApacheFop")
+        self.removeApacheFop = QPushButton(self.frame)
-        self.removeApacheFop.setEnabled(False)
+        self.removeApacheFop.setObjectName(u"removeApacheFop")
-        self.removeApacheFop.setIcon(icon1)
+        self.removeApacheFop.setEnabled(False)
-
+        self.removeApacheFop.setIcon(icon1)
-        self.horizontalLayout.addWidget(self.removeApacheFop)
+
-
+        self.horizontalLayout.addWidget(self.removeApacheFop)
-
+
-        self.verticalLayout_3.addWidget(self.frame)
+
-
+        self.verticalLayout_3.addWidget(self.frame)
-        self.tabSettings.addTab(self.tabApacheFop, "")
+
-        self.tabDiffPdf = QWidget()
+        self.tabSettings.addTab(self.tabApacheFop, "")
-        self.tabDiffPdf.setObjectName(u"tabDiffPdf")
+        self.tabDiffPdf = QWidget()
-        self.verticalLayout_6 = QVBoxLayout(self.tabDiffPdf)
+        self.tabDiffPdf.setObjectName(u"tabDiffPdf")
-        self.verticalLayout_6.setObjectName(u"verticalLayout_6")
+        self.verticalLayout_6 = QVBoxLayout(self.tabDiffPdf)
-        self.tableDiffPdfs = QTableWidget(self.tabDiffPdf)
+        self.verticalLayout_6.setObjectName(u"verticalLayout_6")
-        if (self.tableDiffPdfs.columnCount() < 4):
+        self.tableDiffPdfs = QTableWidget(self.tabDiffPdf)
-            self.tableDiffPdfs.setColumnCount(4)
+        if (self.tableDiffPdfs.columnCount() < 4):
-        self.tableDiffPdfs.setObjectName(u"tableDiffPdfs")
+            self.tableDiffPdfs.setColumnCount(4)
-        self.tableDiffPdfs.setColumnCount(4)
+        self.tableDiffPdfs.setObjectName(u"tableDiffPdfs")
-
+        self.tableDiffPdfs.setColumnCount(4)
-        self.verticalLayout_6.addWidget(self.tableDiffPdfs)
+
-
+        self.verticalLayout_6.addWidget(self.tableDiffPdfs)
-        self.frame_5 = QFrame(self.tabDiffPdf)
+
-        self.frame_5.setObjectName(u"frame_5")
+        self.frame_5 = QFrame(self.tabDiffPdf)
-        sizePolicy.setHeightForWidth(self.frame_5.sizePolicy().hasHeightForWidth())
+        self.frame_5.setObjectName(u"frame_5")
-        self.frame_5.setSizePolicy(sizePolicy)
+        sizePolicy.setHeightForWidth(self.frame_5.sizePolicy().hasHeightForWidth())
-        self.frame_5.setFrameShape(QFrame.Shape.NoFrame)
+        self.frame_5.setSizePolicy(sizePolicy)
-        self.frame_5.setFrameShadow(QFrame.Shadow.Raised)
+        self.frame_5.setFrameShape(QFrame.Shape.NoFrame)
-        self.horizontalLayout_5 = QHBoxLayout(self.frame_5)
+        self.frame_5.setFrameShadow(QFrame.Shadow.Raised)
-        self.horizontalLayout_5.setObjectName(u"horizontalLayout_5")
+        self.horizontalLayout_5 = QHBoxLayout(self.frame_5)
-        self.horizontalLayout_5.setContentsMargins(0, 0, 0, 0)
+        self.horizontalLayout_5.setObjectName(u"horizontalLayout_5")
-        self.addDiffPdf = QPushButton(self.frame_5)
+        self.horizontalLayout_5.setContentsMargins(0, 0, 0, 0)
-        self.addDiffPdf.setObjectName(u"addDiffPdf")
+        self.addDiffPdf = QPushButton(self.frame_5)
-        self.addDiffPdf.setIcon(icon)
+        self.addDiffPdf.setObjectName(u"addDiffPdf")
-
+        self.addDiffPdf.setIcon(icon)
-        self.horizontalLayout_5.addWidget(self.addDiffPdf)
+
-
+        self.horizontalLayout_5.addWidget(self.addDiffPdf)
-        self.removeDiffPdf = QPushButton(self.frame_5)
+
-        self.removeDiffPdf.setObjectName(u"removeDiffPdf")
+        self.removeDiffPdf = QPushButton(self.frame_5)
-        self.removeDiffPdf.setEnabled(False)
+        self.removeDiffPdf.setObjectName(u"removeDiffPdf")
-        self.removeDiffPdf.setIcon(icon1)
+        self.removeDiffPdf.setEnabled(False)
-
+        self.removeDiffPdf.setIcon(icon1)
-        self.horizontalLayout_5.addWidget(self.removeDiffPdf)
+
-
+        self.horizontalLayout_5.addWidget(self.removeDiffPdf)
-
+
-        self.verticalLayout_6.addWidget(self.frame_5)
+
-
+        self.verticalLayout_6.addWidget(self.frame_5)
-        self.tabSettings.addTab(self.tabDiffPdf, "")
+
-        self.tabPostgreSql = QWidget()
+        self.tabSettings.addTab(self.tabDiffPdf, "")
-        self.tabPostgreSql.setObjectName(u"tabPostgreSql")
+        self.tabPostgreSql = QWidget()
-        self.verticalLayout_8 = QVBoxLayout(self.tabPostgreSql)
+        self.tabPostgreSql.setObjectName(u"tabPostgreSql")
-        self.verticalLayout_8.setObjectName(u"verticalLayout_8")
+        self.verticalLayout_8 = QVBoxLayout(self.tabPostgreSql)
-        self.tablePostgreSqlDbs = QTableWidget(self.tabPostgreSql)
+        self.verticalLayout_8.setObjectName(u"verticalLayout_8")
-        if (self.tablePostgreSqlDbs.columnCount() < 5):
+        self.tablePostgreSqlDbs = QTableWidget(self.tabPostgreSql)
-            self.tablePostgreSqlDbs.setColumnCount(5)
+        if (self.tablePostgreSqlDbs.columnCount() < 5):
-        self.tablePostgreSqlDbs.setObjectName(u"tablePostgreSqlDbs")
+            self.tablePostgreSqlDbs.setColumnCount(5)
-        self.tablePostgreSqlDbs.setColumnCount(5)
+        self.tablePostgreSqlDbs.setObjectName(u"tablePostgreSqlDbs")
-
+        self.tablePostgreSqlDbs.setColumnCount(5)
-        self.verticalLayout_8.addWidget(self.tablePostgreSqlDbs)
+
-
+        self.verticalLayout_8.addWidget(self.tablePostgreSqlDbs)
-        self.frame_7 = QFrame(self.tabPostgreSql)
+
-        self.frame_7.setObjectName(u"frame_7")
+        self.frame_7 = QFrame(self.tabPostgreSql)
-        sizePolicy.setHeightForWidth(self.frame_7.sizePolicy().hasHeightForWidth())
+        self.frame_7.setObjectName(u"frame_7")
-        self.frame_7.setSizePolicy(sizePolicy)
+        sizePolicy.setHeightForWidth(self.frame_7.sizePolicy().hasHeightForWidth())
-        self.frame_7.setFrameShape(QFrame.Shape.NoFrame)
+        self.frame_7.setSizePolicy(sizePolicy)
-        self.frame_7.setFrameShadow(QFrame.Shadow.Raised)
+        self.frame_7.setFrameShape(QFrame.Shape.NoFrame)
-        self.horizontalLayout_7 = QHBoxLayout(self.frame_7)
+        self.frame_7.setFrameShadow(QFrame.Shadow.Raised)
-        self.horizontalLayout_7.setObjectName(u"horizontalLayout_7")
+        self.horizontalLayout_7 = QHBoxLayout(self.frame_7)
-        self.horizontalLayout_7.setContentsMargins(0, 0, 0, 0)
+        self.horizontalLayout_7.setObjectName(u"horizontalLayout_7")
-        self.addPostgreSql = QPushButton(self.frame_7)
+        self.horizontalLayout_7.setContentsMargins(0, 0, 0, 0)
-        self.addPostgreSql.setObjectName(u"addPostgreSql")
+        self.addPostgreSql = QPushButton(self.frame_7)
-        self.addPostgreSql.setIcon(icon)
+        self.addPostgreSql.setObjectName(u"addPostgreSql")
-
+        self.addPostgreSql.setIcon(icon)
-        self.horizontalLayout_7.addWidget(self.addPostgreSql)
+
-
+        self.horizontalLayout_7.addWidget(self.addPostgreSql)
-        self.removePostgreSql = QPushButton(self.frame_7)
+
-        self.removePostgreSql.setObjectName(u"removePostgreSql")
+        self.removePostgreSql = QPushButton(self.frame_7)
-        self.removePostgreSql.setEnabled(False)
+        self.removePostgreSql.setObjectName(u"removePostgreSql")
-        self.removePostgreSql.setIcon(icon1)
+        self.removePostgreSql.setEnabled(False)
-
+        self.removePostgreSql.setIcon(icon1)
-        self.horizontalLayout_7.addWidget(self.removePostgreSql)
+
-
+        self.horizontalLayout_7.addWidget(self.removePostgreSql)
-
+
-        self.verticalLayout_8.addWidget(self.frame_7)
+
-
+        self.verticalLayout_8.addWidget(self.frame_7)
-        self.tabSettings.addTab(self.tabPostgreSql, "")
+
-        self.tabPdfProject = QWidget()
+        self.tabSettings.addTab(self.tabPostgreSql, "")
-        self.tabPdfProject.setObjectName(u"tabPdfProject")
+        self.tabPdfProject = QWidget()
-        self.verticalLayout_7 = QVBoxLayout(self.tabPdfProject)
+        self.tabPdfProject.setObjectName(u"tabPdfProject")
-        self.verticalLayout_7.setObjectName(u"verticalLayout_7")
+        self.verticalLayout_7 = QVBoxLayout(self.tabPdfProject)
-        self.tablePdfProjects = QTableWidget(self.tabPdfProject)
+        self.verticalLayout_7.setObjectName(u"verticalLayout_7")
-        if (self.tablePdfProjects.columnCount() < 7):
+        self.tablePdfProjects = QTableWidget(self.tabPdfProject)
-            self.tablePdfProjects.setColumnCount(7)
+        if (self.tablePdfProjects.columnCount() < 7):
-        self.tablePdfProjects.setObjectName(u"tablePdfProjects")
+            self.tablePdfProjects.setColumnCount(7)
-        self.tablePdfProjects.setColumnCount(7)
+        self.tablePdfProjects.setObjectName(u"tablePdfProjects")
-
+        self.tablePdfProjects.setColumnCount(7)
-        self.verticalLayout_7.addWidget(self.tablePdfProjects)
+
-
+        self.verticalLayout_7.addWidget(self.tablePdfProjects)
-        self.frame_6 = QFrame(self.tabPdfProject)
+
-        self.frame_6.setObjectName(u"frame_6")
+        self.frame_6 = QFrame(self.tabPdfProject)
-        sizePolicy.setHeightForWidth(self.frame_6.sizePolicy().hasHeightForWidth())
+        self.frame_6.setObjectName(u"frame_6")
-        self.frame_6.setSizePolicy(sizePolicy)
+        sizePolicy.setHeightForWidth(self.frame_6.sizePolicy().hasHeightForWidth())
-        self.frame_6.setFrameShape(QFrame.Shape.NoFrame)
+        self.frame_6.setSizePolicy(sizePolicy)
-        self.frame_6.setFrameShadow(QFrame.Shadow.Raised)
+        self.frame_6.setFrameShape(QFrame.Shape.NoFrame)
-        self.horizontalLayout_6 = QHBoxLayout(self.frame_6)
+        self.frame_6.setFrameShadow(QFrame.Shadow.Raised)
-        self.horizontalLayout_6.setObjectName(u"horizontalLayout_6")
+        self.horizontalLayout_6 = QHBoxLayout(self.frame_6)
-        self.horizontalLayout_6.setContentsMargins(0, 0, 0, 0)
+        self.horizontalLayout_6.setObjectName(u"horizontalLayout_6")
-        self.addProject = QPushButton(self.frame_6)
+        self.horizontalLayout_6.setContentsMargins(0, 0, 0, 0)
-        self.addProject.setObjectName(u"addProject")
+        self.addProject = QPushButton(self.frame_6)
-        self.addProject.setIcon(icon)
+        self.addProject.setObjectName(u"addProject")
-
+        self.addProject.setIcon(icon)
-        self.horizontalLayout_6.addWidget(self.addProject)
+
-
+        self.horizontalLayout_6.addWidget(self.addProject)
-        self.removeProject = QPushButton(self.frame_6)
+
-        self.removeProject.setObjectName(u"removeProject")
+        self.removeProject = QPushButton(self.frame_6)
-        self.removeProject.setEnabled(False)
+        self.removeProject.setObjectName(u"removeProject")
-        self.removeProject.setIcon(icon1)
+        self.removeProject.setEnabled(False)
-
+        self.removeProject.setIcon(icon1)
-        self.horizontalLayout_6.addWidget(self.removeProject)
+
-
+        self.horizontalLayout_6.addWidget(self.removeProject)
-
+
-        self.verticalLayout_7.addWidget(self.frame_6)
+
-
+        self.verticalLayout_7.addWidget(self.frame_6)
-        self.tabSettings.addTab(self.tabPdfProject, "")
+
-
+        self.tabSettings.addTab(self.tabPdfProject, "")
-        self.verticalLayout.addWidget(self.tabSettings)
+        self.tabPerformance = QWidget()
-
+        self.tabPerformance.setObjectName(u"tabPerformance")
-        self.buttonBox = QDialogButtonBox(Dialog)
+        self.verticalLayout_9 = QVBoxLayout(self.tabPerformance)
-        self.buttonBox.setObjectName(u"buttonBox")
+        self.verticalLayout_9.setObjectName(u"verticalLayout_9")
-        self.buttonBox.setOrientation(Qt.Orientation.Horizontal)
+        self.groupBoxWorker = QGroupBox(self.tabPerformance)
-        self.buttonBox.setStandardButtons(QDialogButtonBox.StandardButton.Cancel|QDialogButtonBox.StandardButton.Ok)
+        self.groupBoxWorker.setObjectName(u"groupBoxWorker")
-        self.buttonBox.setCenterButtons(True)
+        self.verticalLayout_10 = QVBoxLayout(self.groupBoxWorker)
-
+        self.verticalLayout_10.setObjectName(u"verticalLayout_10")
-        self.verticalLayout.addWidget(self.buttonBox)
+        self.labelWorkerCount = QLabel(self.groupBoxWorker)
-
+        self.labelWorkerCount.setObjectName(u"labelWorkerCount")
-
+
-        self.retranslateUi(Dialog)
+        self.verticalLayout_10.addWidget(self.labelWorkerCount)
-        self.buttonBox.accepted.connect(Dialog.accept)
+
-        self.buttonBox.rejected.connect(Dialog.reject)
+        self.spinBoxWorkerCount = QSpinBox(self.groupBoxWorker)
-
+        self.spinBoxWorkerCount.setObjectName(u"spinBoxWorkerCount")
-        self.tabSettings.setCurrentIndex(0)
+        self.spinBoxWorkerCount.setMinimum(1)
-
+        self.spinBoxWorkerCount.setMaximum(32)
-
+        self.spinBoxWorkerCount.setValue(8)
-        QMetaObject.connectSlotsByName(Dialog)
+
-    # setupUi
+        self.verticalLayout_10.addWidget(self.spinBoxWorkerCount)
-
+
-    def retranslateUi(self, Dialog):
+
-        Dialog.setWindowTitle(QCoreApplication.translate("Dialog", u"Programm Einstellungen", None))
+        self.verticalLayout_9.addWidget(self.groupBoxWorker)
-        self.addXsl.setText(QCoreApplication.translate("Dialog", u"Hinzuf\u00fcgen", None))
+
-        self.removeXsl.setText(QCoreApplication.translate("Dialog", u"Entfernen", None))
+        self.groupBoxSaxonPool = QGroupBox(self.tabPerformance)
-        self.tabSettings.setTabText(self.tabSettings.indexOf(self.tabXsls), QCoreApplication.translate("Dialog", u"XSL-Ordner", None))
+        self.groupBoxSaxonPool.setObjectName(u"groupBoxSaxonPool")
-        self.addJavaVm.setText(QCoreApplication.translate("Dialog", u"Hinzuf\u00fcgen", None))
+        self.verticalLayout_11 = QVBoxLayout(self.groupBoxSaxonPool)
-        self.removeJavaVm.setText(QCoreApplication.translate("Dialog", u"Entfernen", None))
+        self.verticalLayout_11.setObjectName(u"verticalLayout_11")
-        self.tabSettings.setTabText(self.tabSettings.indexOf(self.tabJavaVm), QCoreApplication.translate("Dialog", u"Java VM", None))
+        self.checkBoxUseSaxonPool = QCheckBox(self.groupBoxSaxonPool)
-        self.addSaxon.setText(QCoreApplication.translate("Dialog", u"Hinzuf\u00fcgen", None))
+        self.checkBoxUseSaxonPool.setObjectName(u"checkBoxUseSaxonPool")
-        self.removeSaxon.setText(QCoreApplication.translate("Dialog", u"Entfernen", None))
+
-        self.tabSettings.setTabText(self.tabSettings.indexOf(self.tabSaxon), QCoreApplication.translate("Dialog", u"Saxon", None))
+        self.verticalLayout_11.addWidget(self.checkBoxUseSaxonPool)
-        self.addApacheFop.setText(QCoreApplication.translate("Dialog", u"Hinzuf\u00fcgen", None))
+
-        self.removeApacheFop.setText(QCoreApplication.translate("Dialog", u"Entfernen", None))
+        self.horizontalLayoutXsltVersion = QHBoxLayout()
-        self.tabSettings.setTabText(self.tabSettings.indexOf(self.tabApacheFop), QCoreApplication.translate("Dialog", u"Apache FOP", None))
+        self.horizontalLayoutXsltVersion.setObjectName(u"horizontalLayoutXsltVersion")
-        self.addDiffPdf.setText(QCoreApplication.translate("Dialog", u"Hinzuf\u00fcgen", None))
+        self.labelXsltVersion = QLabel(self.groupBoxSaxonPool)
-        self.removeDiffPdf.setText(QCoreApplication.translate("Dialog", u"Entfernen", None))
+        self.labelXsltVersion.setObjectName(u"labelXsltVersion")
-        self.tabSettings.setTabText(self.tabSettings.indexOf(self.tabDiffPdf), QCoreApplication.translate("Dialog", u"Diff-PDF", None))
+
-        self.addPostgreSql.setText(QCoreApplication.translate("Dialog", u"Hinzuf\u00fcgen", None))
+        self.horizontalLayoutXsltVersion.addWidget(self.labelXsltVersion)
-        self.removePostgreSql.setText(QCoreApplication.translate("Dialog", u"Entfernen", None))
+
-        self.tabSettings.setTabText(self.tabSettings.indexOf(self.tabPostgreSql), QCoreApplication.translate("Dialog", u"PostgreSQL", None))
+        self.comboBoxXsltVersion = QComboBox(self.groupBoxSaxonPool)
-        self.addProject.setText(QCoreApplication.translate("Dialog", u"Hinzuf\u00fcgen", None))
+        self.comboBoxXsltVersion.addItem("")
-        self.removeProject.setText(QCoreApplication.translate("Dialog", u"Entfernen", None))
+        self.comboBoxXsltVersion.addItem("")
-        self.tabSettings.setTabText(self.tabSettings.indexOf(self.tabPdfProject), QCoreApplication.translate("Dialog", u"PDF-Projekte", None))
+        self.comboBoxXsltVersion.setObjectName(u"comboBoxXsltVersion")
-    # retranslateUi
+
-
+        self.horizontalLayoutXsltVersion.addWidget(self.comboBoxXsltVersion)
+
+        self.horizontalSpacerXsltVersion = QSpacerItem(40, 20, QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum)
+
+        self.horizontalLayoutXsltVersion.addItem(self.horizontalSpacerXsltVersion)
+
+
+        self.verticalLayout_11.addLayout(self.horizontalLayoutXsltVersion)
+
+        self.labelSaxonPoolInfo = QLabel(self.groupBoxSaxonPool)
+        self.labelSaxonPoolInfo.setObjectName(u"labelSaxonPoolInfo")
+        self.labelSaxonPoolInfo.setWordWrap(True)
+
+        self.verticalLayout_11.addWidget(self.labelSaxonPoolInfo)
+
+
+        self.verticalLayout_9.addWidget(self.groupBoxSaxonPool)
+
+        self.groupBoxFopPool = QGroupBox(self.tabPerformance)
+        self.groupBoxFopPool.setObjectName(u"groupBoxFopPool")
+        self.verticalLayout_12 = QVBoxLayout(self.groupBoxFopPool)
+        self.verticalLayout_12.setObjectName(u"verticalLayout_12")
+        self.checkBoxUseFopPool = QCheckBox(self.groupBoxFopPool)
+        self.checkBoxUseFopPool.setObjectName(u"checkBoxUseFopPool")
+
+        self.verticalLayout_12.addWidget(self.checkBoxUseFopPool)
+
+        self.labelFopPoolInfo = QLabel(self.groupBoxFopPool)
+        self.labelFopPoolInfo.setObjectName(u"labelFopPoolInfo")
+        self.labelFopPoolInfo.setWordWrap(True)
+
+        self.verticalLayout_12.addWidget(self.labelFopPoolInfo)
+
+
+        self.verticalLayout_9.addWidget(self.groupBoxFopPool)
+
+        self.verticalSpacer = QSpacerItem(20, 40, QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Expanding)
+
+        self.verticalLayout_9.addItem(self.verticalSpacer)
+
+        self.label = QLabel(self.tabPerformance)
+        self.label.setObjectName(u"label")
+        self.label.setMouseTracking(True)
+        self.label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.label.setWordWrap(True)
+
+        self.verticalLayout_9.addWidget(self.label)
+
+        self.verticalSpacerPerformance = QSpacerItem(20, 40, QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Expanding)
+
+        self.verticalLayout_9.addItem(self.verticalSpacerPerformance)
+
+        self.tabSettings.addTab(self.tabPerformance, "")
+
+        self.verticalLayout.addWidget(self.tabSettings)
+
+        self.buttonBox = QDialogButtonBox(Dialog)
+        self.buttonBox.setObjectName(u"buttonBox")
+        self.buttonBox.setOrientation(Qt.Orientation.Horizontal)
+        self.buttonBox.setStandardButtons(QDialogButtonBox.StandardButton.Cancel|QDialogButtonBox.StandardButton.Ok)
+        self.buttonBox.setCenterButtons(True)
+
+        self.verticalLayout.addWidget(self.buttonBox)
+
+
+        self.retranslateUi(Dialog)
+        self.buttonBox.accepted.connect(Dialog.accept)
+        self.buttonBox.rejected.connect(Dialog.reject)
+
+        self.tabSettings.setCurrentIndex(0)
+
+
+        QMetaObject.connectSlotsByName(Dialog)
+    # setupUi
+
+    def retranslateUi(self, Dialog):
+        Dialog.setWindowTitle(QCoreApplication.translate("Dialog", u"Programm Einstellungen", None))
+        self.addXsl.setText(QCoreApplication.translate("Dialog", u"Hinzuf\u00fcgen", None))
+        self.removeXsl.setText(QCoreApplication.translate("Dialog", u"Entfernen", None))
+        self.tabSettings.setTabText(self.tabSettings.indexOf(self.tabXsls), QCoreApplication.translate("Dialog", u"XSL-Ordner", None))
+        self.addJavaVm.setText(QCoreApplication.translate("Dialog", u"Hinzuf\u00fcgen", None))
+        self.removeJavaVm.setText(QCoreApplication.translate("Dialog", u"Entfernen", None))
+        self.tabSettings.setTabText(self.tabSettings.indexOf(self.tabJavaVm), QCoreApplication.translate("Dialog", u"Java VM", None))
+        self.addSaxon.setText(QCoreApplication.translate("Dialog", u"Hinzuf\u00fcgen", None))
+        self.removeSaxon.setText(QCoreApplication.translate("Dialog", u"Entfernen", None))
+        self.tabSettings.setTabText(self.tabSettings.indexOf(self.tabSaxon), QCoreApplication.translate("Dialog", u"Saxon", None))
+        self.addApacheFop.setText(QCoreApplication.translate("Dialog", u"Hinzuf\u00fcgen", None))
+        self.removeApacheFop.setText(QCoreApplication.translate("Dialog", u"Entfernen", None))
+        self.tabSettings.setTabText(self.tabSettings.indexOf(self.tabApacheFop), QCoreApplication.translate("Dialog", u"Apache FOP", None))
+        self.addDiffPdf.setText(QCoreApplication.translate("Dialog", u"Hinzuf\u00fcgen", None))
+        self.removeDiffPdf.setText(QCoreApplication.translate("Dialog", u"Entfernen", None))
+        self.tabSettings.setTabText(self.tabSettings.indexOf(self.tabDiffPdf), QCoreApplication.translate("Dialog", u"Diff-PDF", None))
+        self.addPostgreSql.setText(QCoreApplication.translate("Dialog", u"Hinzuf\u00fcgen", None))
+        self.removePostgreSql.setText(QCoreApplication.translate("Dialog", u"Entfernen", None))
+        self.tabSettings.setTabText(self.tabSettings.indexOf(self.tabPostgreSql), QCoreApplication.translate("Dialog", u"PostgreSQL", None))
+        self.addProject.setText(QCoreApplication.translate("Dialog", u"Hinzuf\u00fcgen", None))
+        self.removeProject.setText(QCoreApplication.translate("Dialog", u"Entfernen", None))
+        self.tabSettings.setTabText(self.tabSettings.indexOf(self.tabPdfProject), QCoreApplication.translate("Dialog", u"PDF-Projekte", None))
+        self.groupBoxWorker.setTitle(QCoreApplication.translate("Dialog", u"ThreadPoolExecutor Einstellungen", None))
+        self.labelWorkerCount.setText(QCoreApplication.translate("Dialog", u"Anzahl paralleler Worker f\u00fcr Transformationen:", None))
+#if QT_CONFIG(tooltip)
+        self.spinBoxWorkerCount.setToolTip(QCoreApplication.translate("Dialog", u"Anzahl der parallelen Worker-Threads f\u00fcr Transformationen (Standard: 8)", None))
+#endif // QT_CONFIG(tooltip)
+        self.groupBoxSaxonPool.setTitle(QCoreApplication.translate("Dialog", u"SaxonWorkerPool Einstellungen", None))
+#if QT_CONFIG(tooltip)
+        self.checkBoxUseSaxonPool.setToolTip(QCoreApplication.translate("Dialog", u"Aktiviert persistente JVM-Prozesse f\u00fcr Saxon-Transformationen.\n"
+"Vorteile: Bis zu 10x schneller durch Eliminierung von JVM-Startup-Overhead\n"
+"Nachteile: Ben\u00f6tigt JDK (javac) - funktioniert nicht mit JRE allein\n"
+"\n"
+"Deaktivieren Sie diese Option, wenn:\n"
+"\u2022 Sie nur ein JRE (keine JDK) installiert haben\n"
+"\u2022 Sie Probleme mit dem Worker-Pool haben\n"
+"\u2022 Sie die Funktion testen m\u00f6chten", None))
+#endif // QT_CONFIG(tooltip)
+        self.checkBoxUseSaxonPool.setText(QCoreApplication.translate("Dialog", u"SaxonWorkerPool verwenden (empfohlen)", None))
+        self.labelXsltVersion.setText(QCoreApplication.translate("Dialog", u"XSLT-Version:", None))
+        self.comboBoxXsltVersion.setItemText(0, QCoreApplication.translate("Dialog", u"XSLT 1.0 (JAXP)", None))
+        self.comboBoxXsltVersion.setItemText(1, QCoreApplication.translate("Dialog", u"XSLT 2.0/3.0 (s9api) - Empfohlen", None))
+
+#if QT_CONFIG(tooltip)
+        self.comboBoxXsltVersion.setToolTip(QCoreApplication.translate("Dialog", u"W\u00e4hlen Sie die XSLT-Version f\u00fcr Saxon-Transformationen:\n"
+"\n"
+"XSLT 1.0 (JAXP): Verwendet die JAXP Transformer API\n"
+"\u2022 Nur f\u00fcr XSLT 1.0 vollst\u00e4ndig spezifiziert\n"
+"\u2022 Kann bei XSLT 2.0/3.0 zu fehlerhaften Ausgaben f\u00fchren\n"
+"\n"
+"XSLT 2.0/3.0 (s9api): Verwendet die Saxon s9api\n"
+"\u2022 Vollst\u00e4ndige Unterst\u00fctzung f\u00fcr XSLT 2.0 und 3.0\n"
+"\u2022 Empfohlen f\u00fcr moderne XSLT-Stylesheets", None))
+#endif // QT_CONFIG(tooltip)
+        self.labelSaxonPoolInfo.setText(QCoreApplication.translate("Dialog", u"<i>Hinweis: SaxonWorkerPool ben\u00f6tigt ein JDK (Java Development Kit).<br>Mit JRE allein werden Transformationen im Fallback-Modus ausgef\u00fchrt.</i>", None))
+        self.groupBoxFopPool.setTitle(QCoreApplication.translate("Dialog", u"FopWorkerPool Einstellungen", None))
+#if QT_CONFIG(tooltip)
+        self.checkBoxUseFopPool.setToolTip(QCoreApplication.translate("Dialog", u"Aktiviert persistente JVM-Prozesse f\u00fcr Apache FOP PDF-Generierung.\n"
+"Vorteile: Bis zu 10x schneller durch Eliminierung von JVM-Startup-Overhead\n"
+"Nachteile: Ben\u00f6tigt JDK (javac) - funktioniert nicht mit JRE allein\n"
+"\n"
+"Deaktivieren Sie diese Option, wenn:\n"
+"\u2022 Sie nur ein JRE (keine JDK) installiert haben\n"
+"\u2022 Sie Probleme mit dem Worker-Pool haben\n"
+"\u2022 Sie die Funktion testen m\u00f6chten", None))
+#endif // QT_CONFIG(tooltip)
+        self.checkBoxUseFopPool.setText(QCoreApplication.translate("Dialog", u"FopWorkerPool verwenden (empfohlen)", None))
+        self.labelFopPoolInfo.setText(QCoreApplication.translate("Dialog", u"<i>Hinweis: FopWorkerPool ben\u00f6tigt ein JDK (Java Development Kit).<br>Mit JRE allein werden PDFs im Fallback-Modus generiert.</i>", None))
+        self.label.setText(QCoreApplication.translate("Dialog", u"<html><head/><body><p><span style=\" font-weight:700; font-style:italic;\">Hinweis: \u00c4nderungen in diesem Dialog sind unter Umst\u00e4nden erst nach neu start der Anwendung wirksam.</span></p></body></html>", None))
+        self.tabSettings.setTabText(self.tabSettings.indexOf(self.tabPerformance), QCoreApplication.translate("Dialog", u"Performance", None))
+    # retranslateUi
+

src/ui/MainWinddow.ui

@@ -7,7 +7,7 @@
     <x>0</x>
     <y>0</y>
     <width>1263</width>
-    <height>774</height>
+    <height>779</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -61,6 +61,26 @@
         <property name="bottomMargin">
          <number>0</number>
         </property>
+        <item>
+         <widget class="QLabel" name="projectPath">
+          <property name="styleSheet">
+           <string notr="true">QLabel { padding: 5px; font-weight: bold; }</string>
+          </property>
+          <property name="text">
+           <string>Kein Projekt geladen</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QLineEdit" name="searchEdit">
+          <property name="placeholderText">
+           <string>Knoten oder XSL-Datei filtern...</string>
+          </property>
+          <property name="clearButtonEnabled">
+           <bool>true</bool>
+          </property>
+         </widget>
+        </item>
         <item>
          <widget class="QTreeWidget" name="treeWidget">
           <property name="sizePolicy">
@@ -69,8 +89,18 @@
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
+          <property name="styleSheet">
+           <string notr="true">QTreeWidget::item {
+	padding: 4px 4px;
+}
+
+QTreeWidget::item:selected {
+	background-color: palette(highlight);
+	color: palette(highlighted-text);
+}</string>
+          </property>
           <property name="columnCount">
-           <number>3</number>
+           <number>2</number>
           </property>
           <attribute name="headerHighlightSections">
            <bool>true</bool>
@@ -88,81 +118,6 @@
             <string notr="true">2</string>
            </property>
           </column>
-          <column>
-           <property name="text">
-            <string notr="true">3</string>
-           </property>
-          </column>
-         </widget>
-        </item>
-        <item>
-         <widget class="QFrame" name="frame_2">
-          <property name="frameShadow">
-           <enum>QFrame::Shadow::Raised</enum>
-          </property>
-          <layout class="QHBoxLayout" name="horizontalLayout_2">
-           <property name="leftMargin">
-            <number>0</number>
-           </property>
-           <property name="topMargin">
-            <number>0</number>
-           </property>
-           <property name="rightMargin">
-            <number>0</number>
-           </property>
-           <property name="bottomMargin">
-            <number>0</number>
-           </property>
-           <item>
-            <widget class="QPushButton" name="pushButton">
-             <property name="layoutDirection">
-              <enum>Qt::LayoutDirection::LeftToRight</enum>
-             </property>
-             <property name="text">
-              <string>nur geänderte generieren</string>
-             </property>
-             <property name="icon">
-              <iconset theme="QIcon::ThemeIcon::MediaPlaybackStart"/>
-             </property>
-            </widget>
-           </item>
-           <item>
-            <widget class="QPushButton" name="pushButton_2">
-             <property name="autoFillBackground">
-              <bool>false</bool>
-             </property>
-             <property name="text">
-              <string>Alle generieren</string>
-             </property>
-             <property name="icon">
-              <iconset theme="QIcon::ThemeIcon::MediaSeekForward"/>
-             </property>
-            </widget>
-           </item>
-           <item>
-            <spacer name="horizontalSpacer">
-             <property name="orientation">
-              <enum>Qt::Orientation::Horizontal</enum>
-             </property>
-             <property name="sizeHint" stdset="0">
-              <size>
-               <width>40</width>
-               <height>20</height>
-              </size>
-             </property>
-            </spacer>
-           </item>
-           <item>
-            <widget class="QPushButton" name="pB_lade_aus_fn2">
-             <property name="text">
-              <string>lade aus FN2</string>
-             </property>
-             <property name="icon">
-              <iconset theme="QIcon::ThemeIcon::GoDown"/>
-             </property>
-            </widget>
-           </item>
-          </layout>
          </widget>
         </item>
        </layout>
@@ -189,7 +144,7 @@
           <x>0</x>
           <y>0</y>
           <width>68</width>
-          <height>728</height>
+          <height>733</height>
          </rect>
         </property>
         <layout class="QVBoxLayout" name="verticalLayout_2">
@@ -278,14 +233,26 @@
             </spacer>
            </item>
            <item>
-            <widget class="QLabel" name="label_6">
+            <widget class="QPushButton" name="view_ref_pdf">
+             <property name="enabled">
+              <bool>false</bool>
+             </property>
              <property name="text">
               <string>Vorher (Referenz)</string>
              </property>
+             <property name="icon">
+              <iconset theme="QIcon::ThemeIcon::DocumentOpen"/>
+             </property>
             </widget>
            </item>
            <item>
             <widget class="QSlider" name="alpha">
+             <property name="enabled">
+              <bool>false</bool>
+             </property>
+             <property name="toolTip">
+              <string>Blendet zwischen Referenz-PDF (links) und neuer PDF (rechts) um. Doppelklick setzt auf Mitte zurück.</string>
+             </property>
              <property name="minimum">
               <number>-100</number>
              </property>
@@ -298,10 +265,16 @@
             </widget>
            </item>
            <item>
-            <widget class="QLabel" name="label_7">
+            <widget class="QPushButton" name="view_new_pdf">
+             <property name="enabled">
+              <bool>false</bool>
+             </property>
              <property name="text">
               <string>Nachher (Neu)</string>
              </property>
+             <property name="icon">
+              <iconset theme="QIcon::ThemeIcon::DocumentOpen"/>
+             </property>
             </widget>
            </item>
            <item>
@@ -326,6 +299,12 @@
            </item>
            <item>
             <widget class="QSlider" name="zoom">
+             <property name="enabled">
+              <bool>false</bool>
+             </property>
+             <property name="toolTip">
+              <string>Vergrößert oder verkleinert die PDF-Ansicht (25% bis 300%). Doppelklick setzt auf 100% zurück.</string>
+             </property>
              <property name="minimum">
               <number>25</number>
              </property>
@@ -359,7 +338,10 @@
               <bool>false</bool>
              </property>
              <property name="text">
-              <string>✅ Änderungen übernehmen</string>
+              <string>Änderungen übernehmen</string>
+             </property>
+             <property name="icon">
+              <iconset theme="emblem-default"/>
              </property>
             </widget>
            </item>
@@ -381,6 +363,9 @@
         </item>
         <item>
          <widget class="QScrollArea" name="scrollArea_2">
+          <property name="enabled">
+           <bool>true</bool>
+          </property>
           <property name="frameShape">
            <enum>QFrame::Shape::NoFrame</enum>
           </property>
@@ -395,8 +380,8 @@
             <rect>
              <x>0</x>
              <y>0</y>
-             <width>726</width>
+             <width>892</width>
-             <height>697</height>
+             <height>702</height>
             </rect>
            </property>
            <layout class="QVBoxLayout" name="verticalLayout_3">
@@ -448,7 +433,20 @@
      <string>Thema</string>
     </property>
    </widget>
+   <widget class="QMenu" name="menuAktion">
+    <property name="enabled">
+     <bool>false</bool>
+    </property>
+    <property name="title">
+     <string>Aktion</string>
+    </property>
+    <addaction name="actionAlle_XML_Dateien_transformieren"/>
+    <addaction name="actionAlle_XML_Dateien_neu_transformieren_force"/>
+    <addaction name="separator"/>
+    <addaction name="actionAus_Datenbank_laden"/>
+   </widget>
    <addaction name="menuProjekt"/>
+   <addaction name="menuAktion"/>
    <addaction name="menuThema"/>
   </widget>
   <widget class="QStatusBar" name="statusbar"/>
@@ -486,10 +484,36 @@
    <property name="enabled">
     <bool>false</bool>
    </property>
+   <property name="icon">
+    <iconset theme="folder-open"/>
+   </property>
    <property name="text">
     <string>Vorhandene Projekte</string>
    </property>
   </action>
+  <action name="actionAlle_XML_Dateien_transformieren">
+   <property name="text">
+    <string>Alle XML-Dateien transformieren</string>
+   </property>
+  </action>
+  <action name="actionAlle_XML_Dateien_neu_transformieren_force">
+   <property name="icon">
+    <iconset theme="QIcon::ThemeIcon::ViewRefresh"/>
+   </property>
+   <property name="text">
+    <string>Alle XML-Dateien neu transformieren (force)</string>
+   </property>
+  </action>
+  <action name="actionFN2">
+   <property name="text">
+    <string>FN2</string>
+   </property>
+  </action>
+  <action name="actionAus_Datenbank_laden">
+   <property name="text">
+    <string>Aus Datenbank laden</string>
+   </property>
+  </action>
  </widget>
  <resources/>
  <connections>

src/ui/MainWinddow_ui.py

@@ -3,7 +3,7 @@
 ################################################################################
 ## Form generated from reading UI file 'MainWinddow.ui'
 ##
-## Created by: Qt User Interface Compiler version 6.9.2
+## Created by: Qt User Interface Compiler version 6.10.1
 ##
 ## WARNING! All changes made in this file will be lost when recompiling UI file!
 ################################################################################
@@ -17,10 +17,10 @@ from PySide6.QtGui import (QAction, QBrush, QColor, QConicalGradient,
     QPainter, QPalette, QPixmap, QRadialGradient,
     QTransform)
 from PySide6.QtWidgets import (QApplication, QFrame, QHBoxLayout, QHeaderView,
-    QLabel, QMainWindow, QMenu, QMenuBar,
+    QLabel, QLineEdit, QMainWindow, QMenu,
-    QPushButton, QScrollArea, QSizePolicy, QSlider,
+    QMenuBar, QPushButton, QScrollArea, QSizePolicy,
-    QSpacerItem, QSplitter, QStatusBar, QTreeWidget,
+    QSlider, QSpacerItem, QSplitter, QStatusBar,
-    QTreeWidgetItem, QVBoxLayout, QWidget)
+    QTreeWidget, QTreeWidgetItem, QVBoxLayout, QWidget)
 
 class Ui_MainWindow(object):
     def setupUi(self, MainWindow):
@@ -42,6 +42,18 @@ class Ui_MainWindow(object):
         self.actionVorhandene_Projekte = QAction(MainWindow)
         self.actionVorhandene_Projekte.setObjectName(u"actionVorhandene_Projekte")
         self.actionVorhandene_Projekte.setEnabled(False)
+        icon3 = QIcon(QIcon.fromTheme(u"folder-open"))
+        self.actionVorhandene_Projekte.setIcon(icon3)
+        self.actionAlle_XML_Dateien_transformieren = QAction(MainWindow)
+        self.actionAlle_XML_Dateien_transformieren.setObjectName(u"actionAlle_XML_Dateien_transformieren")
+        self.actionAlle_XML_Dateien_neu_transformieren_force = QAction(MainWindow)
+        self.actionAlle_XML_Dateien_neu_transformieren_force.setObjectName(u"actionAlle_XML_Dateien_neu_transformieren_force")
+        icon4 = QIcon(QIcon.fromTheme(QIcon.ThemeIcon.ViewRefresh))
+        self.actionAlle_XML_Dateien_neu_transformieren_force.setIcon(icon4)
+        self.actionFN2 = QAction(MainWindow)
+        self.actionFN2.setObjectName(u"actionFN2")
+        self.actionAus_Datenbank_laden = QAction(MainWindow)
+        self.actionAus_Datenbank_laden.setObjectName(u"actionAus_Datenbank_laden")
         self.centralwidget = QWidget(MainWindow)
         self.centralwidget.setObjectName(u"centralwidget")
         self.horizontalLayout = QHBoxLayout(self.centralwidget)
@@ -65,9 +77,20 @@ class Ui_MainWindow(object):
         self.verticalLayout = QVBoxLayout(self.frame)
         self.verticalLayout.setObjectName(u"verticalLayout")
         self.verticalLayout.setContentsMargins(-1, -1, -1, 0)
+        self.projectPath = QLabel(self.frame)
+        self.projectPath.setObjectName(u"projectPath")
+        self.projectPath.setStyleSheet(u"QLabel { padding: 5px; font-weight: bold; }")
+
+        self.verticalLayout.addWidget(self.projectPath)
+
+        self.searchEdit = QLineEdit(self.frame)
+        self.searchEdit.setObjectName(u"searchEdit")
+        self.searchEdit.setClearButtonEnabled(True)
+
+        self.verticalLayout.addWidget(self.searchEdit)
+
         self.treeWidget = QTreeWidget(self.frame)
         __qtreewidgetitem = QTreeWidgetItem()
-        __qtreewidgetitem.setText(2, u"3");
         __qtreewidgetitem.setText(1, u"2");
         __qtreewidgetitem.setText(0, u"1");
         self.treeWidget.setHeaderItem(__qtreewidgetitem)
@@ -77,48 +100,20 @@ class Ui_MainWindow(object):
         sizePolicy1.setVerticalStretch(0)
         sizePolicy1.setHeightForWidth(self.treeWidget.sizePolicy().hasHeightForWidth())
         self.treeWidget.setSizePolicy(sizePolicy1)
-        self.treeWidget.setColumnCount(3)
+        self.treeWidget.setStyleSheet(u"QTreeWidget::item {\n"
+"	padding: 4px 4px;\n"
+"}\n"
+"\n"
+"QTreeWidget::item:selected {\n"
+"	background-color: palette(highlight);\n"
+"	color: palette(highlighted-text);\n"
+"}")
+        self.treeWidget.setColumnCount(2)
         self.treeWidget.header().setHighlightSections(True)
         self.treeWidget.header().setStretchLastSection(True)
 
         self.verticalLayout.addWidget(self.treeWidget)
 
-        self.frame_2 = QFrame(self.frame)
-        self.frame_2.setObjectName(u"frame_2")
-        self.frame_2.setFrameShadow(QFrame.Shadow.Raised)
-        self.horizontalLayout_2 = QHBoxLayout(self.frame_2)
-        self.horizontalLayout_2.setObjectName(u"horizontalLayout_2")
-        self.horizontalLayout_2.setContentsMargins(0, 0, 0, 0)
-        self.pushButton = QPushButton(self.frame_2)
-        self.pushButton.setObjectName(u"pushButton")
-        self.pushButton.setLayoutDirection(Qt.LayoutDirection.LeftToRight)
-        icon3 = QIcon(QIcon.fromTheme(QIcon.ThemeIcon.MediaPlaybackStart))
-        self.pushButton.setIcon(icon3)
-
-        self.horizontalLayout_2.addWidget(self.pushButton)
-
-        self.pushButton_2 = QPushButton(self.frame_2)
-        self.pushButton_2.setObjectName(u"pushButton_2")
-        self.pushButton_2.setAutoFillBackground(False)
-        icon4 = QIcon(QIcon.fromTheme(QIcon.ThemeIcon.MediaSeekForward))
-        self.pushButton_2.setIcon(icon4)
-
-        self.horizontalLayout_2.addWidget(self.pushButton_2)
-
-        self.horizontalSpacer = QSpacerItem(40, 20, QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum)
-
-        self.horizontalLayout_2.addItem(self.horizontalSpacer)
-
-        self.pB_lade_aus_fn2 = QPushButton(self.frame_2)
-        self.pB_lade_aus_fn2.setObjectName(u"pB_lade_aus_fn2")
-        icon5 = QIcon(QIcon.fromTheme(QIcon.ThemeIcon.GoDown))
-        self.pB_lade_aus_fn2.setIcon(icon5)
-
-        self.horizontalLayout_2.addWidget(self.pB_lade_aus_fn2)
-
-
-        self.verticalLayout.addWidget(self.frame_2)
-
         self.splitter.addWidget(self.frame)
         self.scrollArea = QScrollArea(self.splitter)
         self.scrollArea.setObjectName(u"scrollArea")
@@ -169,23 +164,29 @@ class Ui_MainWindow(object):
 
         self.horizontalLayout_3.addItem(self.horizontalSpacer_4)
 
-        self.label_6 = QLabel(self.frame_4)
+        self.view_ref_pdf = QPushButton(self.frame_4)
-        self.label_6.setObjectName(u"label_6")
+        self.view_ref_pdf.setObjectName(u"view_ref_pdf")
+        self.view_ref_pdf.setEnabled(False)
+        icon5 = QIcon(QIcon.fromTheme(QIcon.ThemeIcon.DocumentOpen))
+        self.view_ref_pdf.setIcon(icon5)
 
-        self.horizontalLayout_3.addWidget(self.label_6)
+        self.horizontalLayout_3.addWidget(self.view_ref_pdf)
 
         self.alpha = QSlider(self.frame_4)
         self.alpha.setObjectName(u"alpha")
+        self.alpha.setEnabled(False)
         self.alpha.setMinimum(-100)
         self.alpha.setMaximum(100)
         self.alpha.setOrientation(Qt.Orientation.Horizontal)
 
         self.horizontalLayout_3.addWidget(self.alpha)
 
-        self.label_7 = QLabel(self.frame_4)
+        self.view_new_pdf = QPushButton(self.frame_4)
-        self.label_7.setObjectName(u"label_7")
+        self.view_new_pdf.setObjectName(u"view_new_pdf")
+        self.view_new_pdf.setEnabled(False)
+        self.view_new_pdf.setIcon(icon5)
 
-        self.horizontalLayout_3.addWidget(self.label_7)
+        self.horizontalLayout_3.addWidget(self.view_new_pdf)
 
         self.horizontalSpacer_2 = QSpacerItem(40, 20, QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum)
 
@@ -198,6 +199,7 @@ class Ui_MainWindow(object):
 
         self.zoom = QSlider(self.frame_4)
         self.zoom.setObjectName(u"zoom")
+        self.zoom.setEnabled(False)
         self.zoom.setMinimum(25)
         self.zoom.setMaximum(300)
         self.zoom.setValue(100)
@@ -212,6 +214,8 @@ class Ui_MainWindow(object):
         self.accept_changes = QPushButton(self.frame_4)
         self.accept_changes.setObjectName(u"accept_changes")
         self.accept_changes.setEnabled(False)
+        icon6 = QIcon(QIcon.fromTheme(u"emblem-default"))
+        self.accept_changes.setIcon(icon6)
 
         self.horizontalLayout_3.addWidget(self.accept_changes)
 
@@ -224,12 +228,13 @@ class Ui_MainWindow(object):
 
         self.scrollArea_2 = QScrollArea(self.frame_3)
         self.scrollArea_2.setObjectName(u"scrollArea_2")
+        self.scrollArea_2.setEnabled(True)
         self.scrollArea_2.setFrameShape(QFrame.Shape.NoFrame)
         self.scrollArea_2.setFrameShadow(QFrame.Shadow.Raised)
         self.scrollArea_2.setWidgetResizable(True)
         self.scrollAreaWidgetContents_2 = QWidget()
         self.scrollAreaWidgetContents_2.setObjectName(u"scrollAreaWidgetContents_2")
-        self.scrollAreaWidgetContents_2.setGeometry(QRect(0, 0, 726, 697))
+        self.scrollAreaWidgetContents_2.setGeometry(QRect(0, 0, 880, 697))
         self.verticalLayout_3 = QVBoxLayout(self.scrollAreaWidgetContents_2)
         self.verticalLayout_3.setObjectName(u"verticalLayout_3")
         self.verticalLayout_3.setContentsMargins(0, 0, 0, 0)
@@ -249,12 +254,16 @@ class Ui_MainWindow(object):
         self.menuProjekt.setObjectName(u"menuProjekt")
         self.menuThema = QMenu(self.menubar)
         self.menuThema.setObjectName(u"menuThema")
+        self.menuAktion = QMenu(self.menubar)
+        self.menuAktion.setObjectName(u"menuAktion")
+        self.menuAktion.setEnabled(False)
         MainWindow.setMenuBar(self.menubar)
         self.statusbar = QStatusBar(MainWindow)
         self.statusbar.setObjectName(u"statusbar")
         MainWindow.setStatusBar(self.statusbar)
 
         self.menubar.addAction(self.menuProjekt.menuAction())
+        self.menubar.addAction(self.menuAktion.menuAction())
         self.menubar.addAction(self.menuThema.menuAction())
         self.menuProjekt.addAction(self.actionNeu)
         self.menuProjekt.addSeparator()
@@ -263,6 +272,10 @@ class Ui_MainWindow(object):
         self.menuProjekt.addAction(self.actionEinstellungen)
         self.menuProjekt.addSeparator()
         self.menuProjekt.addAction(self.actionBeenden)
+        self.menuAktion.addAction(self.actionAlle_XML_Dateien_transformieren)
+        self.menuAktion.addAction(self.actionAlle_XML_Dateien_neu_transformieren_force)
+        self.menuAktion.addSeparator()
+        self.menuAktion.addAction(self.actionAus_Datenbank_laden)
 
         self.retranslateUi(MainWindow)
         self.actionBeenden.triggered.connect(MainWindow.close)
@@ -282,16 +295,26 @@ class Ui_MainWindow(object):
         self.actionEinstellungen.setShortcut(QCoreApplication.translate("MainWindow", u"Ctrl+S", None))
 #endif // QT_CONFIG(shortcut)
         self.actionVorhandene_Projekte.setText(QCoreApplication.translate("MainWindow", u"Vorhandene Projekte", None))
-        self.pushButton.setText(QCoreApplication.translate("MainWindow", u"nur ge\u00e4nderte generieren", None))
+        self.actionAlle_XML_Dateien_transformieren.setText(QCoreApplication.translate("MainWindow", u"Alle XML-Dateien transformieren", None))
-        self.pushButton_2.setText(QCoreApplication.translate("MainWindow", u"Alle generieren", None))
+        self.actionAlle_XML_Dateien_neu_transformieren_force.setText(QCoreApplication.translate("MainWindow", u"Alle XML-Dateien neu transformieren (force)", None))
-        self.pB_lade_aus_fn2.setText(QCoreApplication.translate("MainWindow", u"lade aus FN2", None))
+        self.actionFN2.setText(QCoreApplication.translate("MainWindow", u"FN2", None))
+        self.actionAus_Datenbank_laden.setText(QCoreApplication.translate("MainWindow", u"Aus Datenbank laden", None))
+        self.projectPath.setText(QCoreApplication.translate("MainWindow", u"Kein Projekt geladen", None))
+        self.searchEdit.setPlaceholderText(QCoreApplication.translate("MainWindow", u"Knoten oder XSL-Datei filtern...", None))
         self.label.setText("")
         self.label_2.setText("")
-        self.label_6.setText(QCoreApplication.translate("MainWindow", u"Vorher (Referenz)", None))
+        self.view_ref_pdf.setText(QCoreApplication.translate("MainWindow", u"Vorher (Referenz)", None))
-        self.label_7.setText(QCoreApplication.translate("MainWindow", u"Nachher (Neu)", None))
+#if QT_CONFIG(tooltip)
+        self.alpha.setToolTip(QCoreApplication.translate("MainWindow", u"Blendet zwischen Referenz-PDF (links) und neuer PDF (rechts) um. Doppelklick setzt auf Mitte zur\u00fcck.", None))
+#endif // QT_CONFIG(tooltip)
+        self.view_new_pdf.setText(QCoreApplication.translate("MainWindow", u"Nachher (Neu)", None))
         self.label_5.setText(QCoreApplication.translate("MainWindow", u"Zoom", None))
-        self.accept_changes.setText(QCoreApplication.translate("MainWindow", u"\u2705 \u00c4nderungen \u00fcbernehmen", None))
+#if QT_CONFIG(tooltip)
+        self.zoom.setToolTip(QCoreApplication.translate("MainWindow", u"Vergr\u00f6\u00dfert oder verkleinert die PDF-Ansicht (25% bis 300%). Doppelklick setzt auf 100% zur\u00fcck.", None))
+#endif // QT_CONFIG(tooltip)
+        self.accept_changes.setText(QCoreApplication.translate("MainWindow", u"\u00c4nderungen \u00fcbernehmen", None))
         self.menuProjekt.setTitle(QCoreApplication.translate("MainWindow", u"Projekt", None))
         self.menuThema.setTitle(QCoreApplication.translate("MainWindow", u"Thema", None))
+        self.menuAktion.setTitle(QCoreApplication.translate("MainWindow", u"Aktion", None))
     # retranslateUi
 

src/ui/ObsoleteEntriesDialog.py

@@ -0,0 +1,137 @@
+"""
+ObsoleteEntriesDialog — Dialog zur Bestätigung des Entfernens veralteter Projekteinträge.
+
+Zeigt XslFile-Einträge an, die nicht mehr in der Datenbank vorhanden sind,
+und lässt den Benutzer entscheiden ob sie entfernt werden sollen.
+"""
+
+import logging
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import (
+    QCheckBox,
+    QDialog,
+    QDialogButtonBox,
+    QLabel,
+    QSizePolicy,
+    QTreeWidget,
+    QTreeWidgetItem,
+    QVBoxLayout,
+)
+
+from obsolete_detector import ObsoleteGroup
+
+logger = logging.getLogger(__name__)
+
+
+class ObsoleteEntriesDialog(QDialog):
+    """
+    Dialog zur Anzeige und Bestätigung veralteter Einträge nach einem DB-Import.
+
+    Zeigt die veralteten XslFile-Einträge gruppiert nach ihrer Baumhierarchie an.
+    Der Benutzer kann entscheiden ob die Einträge entfernt und ob nicht mehr
+    verwendete XML-Dateien physisch gelöscht werden sollen.
+    """
+
+    def __init__(self, parent, obsolete_groups: list[ObsoleteGroup]):
+        """
+        Args:
+            parent: Eltern-Widget
+            obsolete_groups: Veraltete Einträge gruppiert nach Hierarchiepfad
+        """
+        super().__init__(parent)
+        self._obsolete_groups = obsolete_groups
+        self._setup_ui()
+        self._populate_tree()
+
+    def _setup_ui(self) -> None:
+        """Erstellt die UI-Elemente des Dialogs."""
+        total_count = sum(len(g.xsl_entries) for g in self._obsolete_groups)
+
+        self.setWindowTitle("Veraltete Einträge gefunden")
+        self.resize(640, 420)
+        self.setSizeGripEnabled(True)
+
+        layout = QVBoxLayout(self)
+        layout.setSpacing(10)
+
+        # Erklärungstext
+        info_label = QLabel(
+            f"<b>{total_count} XSL-Datei(en)</b> sind nicht mehr in der Datenbank vorhanden "
+            f"und können aus dem Projekt entfernt werden."
+        )
+        info_label.setWordWrap(True)
+        layout.addWidget(info_label)
+
+        # Baumansicht der veralteten Einträge
+        self._tree = QTreeWidget()
+        self._tree.setColumnCount(3)
+        self._tree.setHeaderLabels(["Bezeichnung", "XSL-Datei", "XML-Dateien"])
+        self._tree.setColumnWidth(0, 280)
+        self._tree.setColumnWidth(1, 200)
+        self._tree.setColumnWidth(2, 80)
+        self._tree.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+        self._tree.setAlternatingRowColors(True)
+        self._tree.setEditTriggers(QTreeWidget.EditTrigger.NoEditTriggers)
+        layout.addWidget(self._tree)
+
+        # Checkbox für physische XML-Löschung
+        self._delete_xml_checkbox = QCheckBox("Nicht mehr verwendete XML-Dateien physisch löschen")
+        self._delete_xml_checkbox.setChecked(False)
+        layout.addWidget(self._delete_xml_checkbox)
+
+        # Dialog-Buttons
+        self._button_box = QDialogButtonBox()
+        remove_button = self._button_box.addButton(
+            "Veraltete Einträge entfernen", QDialogButtonBox.ButtonRole.AcceptRole
+        )
+        remove_button.setToolTip("Entfernt alle aufgelisteten Einträge aus dem Projekt")
+        self._button_box.addButton(QDialogButtonBox.StandardButton.Cancel)
+        self._button_box.accepted.connect(self.accept)
+        self._button_box.rejected.connect(self.reject)
+        layout.addWidget(self._button_box)
+
+    def _populate_tree(self) -> None:
+        """Befüllt den QTreeWidget mit den veralteten Einträgen."""
+        self._tree.clear()
+
+        for group in self._obsolete_groups:
+            # Hierarchiepfad als verschachtelte Items aufbauen
+            parent_item = self._tree.invisibleRootItem()
+            for path_part in group.node_path:
+                # Prüfe ob dieser Pfadteil bereits als Kind vorhanden ist
+                existing = None
+                for i in range(parent_item.childCount()):
+                    child = parent_item.child(i)
+                    if child.text(0) == path_part and not child.data(0, Qt.ItemDataRole.UserRole):
+                        existing = child
+                        break
+                if existing:
+                    parent_item = existing
+                else:
+                    node_item = QTreeWidgetItem(parent_item, [path_part])
+                    font = node_item.font(0)
+                    font.setBold(True)
+                    node_item.setFont(0, font)
+                    parent_item = node_item
+
+            # XslFile-Einträge unter dem Hierarchiepfad
+            for entry in group.xsl_entries:
+                xsl = entry.xsl_file
+                xml_count = str(len(xsl.xmls)) if xsl.xmls else "0"
+                xsl_item = QTreeWidgetItem(
+                    parent_item,
+                    [xsl.bez, xsl.xsl_file.name, xml_count],
+                )
+                xsl_item.setData(0, Qt.ItemDataRole.UserRole, xsl)
+                xsl_item.setToolTip(1, str(xsl.xsl_file))
+
+        self._tree.expandAll()
+
+    def delete_xml_files(self) -> bool:
+        """
+        Gibt zurück ob der Benutzer die physische Löschung der XML-Dateien gewünscht hat.
+
+        Returns:
+            True wenn die Checkbox aktiviert ist
+        """
+        return self._delete_xml_checkbox.isChecked()

src/ui/PdfProject.py

@@ -5,6 +5,7 @@ from PySide6.QtWidgets import QDialog, QFileDialog, QMessageBox
 
 from conf import app_settings
 from ui.PdfProject_ui import Ui_projectDlg
+from ui.ProjectXsltParamsDialog import ProjectXsltParamsDialog
 
 
 class PdfProjectDlg(QDialog):
@@ -15,7 +16,7 @@ class PdfProjectDlg(QDialog):
         Args:
             parent: Übergeordnetes Widget
             project_data: Bestehende Projektdaten zum Bearbeiten (optional)
-            edit_mode: Wenn True, werden Projekt-Name und -Ordner deaktiviert (nur Einstellungen ändern)
+            edit_mode: Wenn True, wird der Projekt-Ordner deaktiviert (nur Name und Einstellungen ändern)
         """
         super().__init__(parent)
         
@@ -26,6 +27,7 @@ class PdfProjectDlg(QDialog):
         # Projektdaten speichern
         self.project_data = project_data or {}
         self.edit_mode = edit_mode
+        self.xslt_params: dict[str, str] = dict(self.project_data.get("xslt_params", {}))
         
         # Dialog-Eigenschaften setzen
         self.setModal(True)
@@ -53,6 +55,9 @@ class PdfProjectDlg(QDialog):
         # Browse-Button für FOP-Config-Ordner
         self.ui.btnBrowseFopConfig.clicked.connect(self.browse_fop_config_dir)
 
+        # XSLT-Parameter bearbeiten
+        self.ui.btnEditXsltParams.clicked.connect(self._edit_xslt_params)
+
         # OK/Cancel Buttons sind bereits in der UI-Datei verbunden
         # self.ui.buttonBox.accepted.connect(self.accept)
         # self.ui.buttonBox.rejected.connect(self.reject)
@@ -190,6 +195,12 @@ class PdfProjectDlg(QDialog):
         if selected_dir:
             self.ui.lineFopConfigDir.setText(selected_dir)
 
+    def _edit_xslt_params(self):
+        """Öffnet den Dialog zur Bearbeitung der projektweiten XSLT-Parameter."""
+        dialog = ProjectXsltParamsDialog(self, self.xslt_params)
+        if dialog.exec() == ProjectXsltParamsDialog.DialogCode.Accepted:
+            self.xslt_params = dialog.get_params()
+
     def validate_and_accept(self):
         """Validiert die Eingaben und akzeptiert den Dialog."""
         # Projekt-Name prüfen
@@ -269,7 +280,8 @@ class PdfProjectDlg(QDialog):
             'apache_fop_id': self.ui.cB_ApacheFop.currentData(),
             'diff_pdf_id': self.ui.cB_Diff_Pdf.currentData(),
             'postgre_sql_db_id': self.ui.cB_Postgres.currentData(),
-            'fop_config_dir': fop_config_dir if fop_config_dir else None
+            'fop_config_dir': fop_config_dir if fop_config_dir else None,
+            'xslt_params': self.xslt_params,
         }
     
     def _configure_edit_mode(self):
@@ -291,50 +303,3 @@ class PdfProjectDlg(QDialog):
         self.project_data = project_data
         self._load_project_data()
 
-
-# Convenience-Funktionen für einfache Verwendung
-def create_project_dialog(parent=None):
-    """
-    Erstellt einen neuen Projekt-Dialog für ein neues Projekt.
-    
-    Args:
-        parent: Übergeordnetes Widget
-        
-    Returns:
-        PdfProjectDlg: Der Dialog
-    """
-    return PdfProjectDlg(parent)
-
-
-def edit_project_dialog(parent=None, project_data=None):
-    """
-    Erstellt einen Projekt-Dialog zum Bearbeiten eines bestehenden Projekts.
-    
-    Args:
-        parent: Übergeordnetes Widget
-        project_data: Bestehende Projektdaten
-        
-    Returns:
-        PdfProjectDlg: Der Dialog
-    """
-    return PdfProjectDlg(parent, project_data)
-
-
-def show_project_dialog(parent=None, project_data=None):
-    """
-    Zeigt einen Projekt-Dialog an und gibt die Ergebnisse zurück.
-    
-    Args:
-        parent: Übergeordnetes Widget
-        project_data: Bestehende Projektdaten (optional)
-        
-    Returns:
-        tuple: (accepted: bool, project_data: dict)
-    """
-    dialog = PdfProjectDlg(parent, project_data)
-    result = dialog.exec()
-    
-    if result == QDialog.DialogCode.Accepted:
-        return True, dialog.get_project_data()
-    else:
-        return False, None

src/ui/PdfProject.ui

@@ -7,7 +7,7 @@
     <x>0</x>
     <y>0</y>
     <width>608</width>
-    <height>331</height>
+    <height>375</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -135,6 +135,20 @@
       <item row="8" column="1">
        <widget class="QComboBox" name="cB_Postgres"/>
       </item>
+      <item row="9" column="0">
+       <widget class="QLabel" name="label_10">
+        <property name="text">
+         <string>XSLT-Parameter:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="9" column="1">
+       <widget class="QPushButton" name="btnEditXsltParams">
+        <property name="text">
+         <string>Bearbeiten ...</string>
+        </property>
+       </widget>
+      </item>
       <item row="6" column="1">
        <widget class="QFrame" name="frame_2">
         <property name="frameShape">

src/ui/PdfProject_ui.py

@@ -1,187 +1,199 @@
-# -*- coding: utf-8 -*-
+# -*- coding: utf-8 -*-
-
+
-################################################################################
+################################################################################
-## Form generated from reading UI file 'PdfProject.ui'
+## Form generated from reading UI file 'PdfProject.ui'
-##
+##
-## Created by: Qt User Interface Compiler version 6.9.2
+## Created by: Qt User Interface Compiler version 6.10.1
-##
+##
-## WARNING! All changes made in this file will be lost when recompiling UI file!
+## WARNING! All changes made in this file will be lost when recompiling UI file!
-################################################################################
+################################################################################
-
+
-from PySide6.QtCore import (QCoreApplication, QDate, QDateTime, QLocale,
+from PySide6.QtCore import (QCoreApplication, QDate, QDateTime, QLocale,
-    QMetaObject, QObject, QPoint, QRect,
+    QMetaObject, QObject, QPoint, QRect,
-    QSize, QTime, QUrl, Qt)
+    QSize, QTime, QUrl, Qt)
-from PySide6.QtGui import (QBrush, QColor, QConicalGradient, QCursor,
+from PySide6.QtGui import (QBrush, QColor, QConicalGradient, QCursor,
-    QFont, QFontDatabase, QGradient, QIcon,
+    QFont, QFontDatabase, QGradient, QIcon,
-    QImage, QKeySequence, QLinearGradient, QPainter,
+    QImage, QKeySequence, QLinearGradient, QPainter,
-    QPalette, QPixmap, QRadialGradient, QTransform)
+    QPalette, QPixmap, QRadialGradient, QTransform)
-from PySide6.QtWidgets import (QAbstractButton, QApplication, QComboBox, QDialog,
+from PySide6.QtWidgets import (QAbstractButton, QApplication, QComboBox, QDialog,
-    QDialogButtonBox, QFormLayout, QFrame, QHBoxLayout,
+    QDialogButtonBox, QFormLayout, QFrame, QHBoxLayout,
-    QLabel, QLineEdit, QPushButton, QSizePolicy,
+    QLabel, QLineEdit, QPushButton, QSizePolicy,
-    QVBoxLayout, QWidget)
+    QVBoxLayout, QWidget)
-
+
-class Ui_projectDlg(object):
+class Ui_projectDlg(object):
-    def setupUi(self, projectDlg):
+    def setupUi(self, projectDlg):
-        if not projectDlg.objectName():
+        if not projectDlg.objectName():
-            projectDlg.setObjectName(u"projectDlg")
+            projectDlg.setObjectName(u"projectDlg")
-        projectDlg.resize(608, 331)
+        projectDlg.resize(608, 331)
-        self.verticalLayout = QVBoxLayout(projectDlg)
+        self.verticalLayout = QVBoxLayout(projectDlg)
-        self.verticalLayout.setObjectName(u"verticalLayout")
+        self.verticalLayout.setObjectName(u"verticalLayout")
-        self.widget = QWidget(projectDlg)
+        self.widget = QWidget(projectDlg)
-        self.widget.setObjectName(u"widget")
+        self.widget.setObjectName(u"widget")
-        self.formLayout = QFormLayout(self.widget)
+        self.formLayout = QFormLayout(self.widget)
-        self.formLayout.setObjectName(u"formLayout")
+        self.formLayout.setObjectName(u"formLayout")
-        self.label = QLabel(self.widget)
+        self.label = QLabel(self.widget)
-        self.label.setObjectName(u"label")
+        self.label.setObjectName(u"label")
-
+
-        self.formLayout.setWidget(0, QFormLayout.ItemRole.LabelRole, self.label)
+        self.formLayout.setWidget(0, QFormLayout.ItemRole.LabelRole, self.label)
-
+
-        self.lineProjectName = QLineEdit(self.widget)
+        self.lineProjectName = QLineEdit(self.widget)
-        self.lineProjectName.setObjectName(u"lineProjectName")
+        self.lineProjectName.setObjectName(u"lineProjectName")
-
+
-        self.formLayout.setWidget(0, QFormLayout.ItemRole.FieldRole, self.lineProjectName)
+        self.formLayout.setWidget(0, QFormLayout.ItemRole.FieldRole, self.lineProjectName)
-
+
-        self.label_2 = QLabel(self.widget)
+        self.label_2 = QLabel(self.widget)
-        self.label_2.setObjectName(u"label_2")
+        self.label_2.setObjectName(u"label_2")
-
+
-        self.formLayout.setWidget(1, QFormLayout.ItemRole.LabelRole, self.label_2)
+        self.formLayout.setWidget(1, QFormLayout.ItemRole.LabelRole, self.label_2)
-
+
-        self.frame = QFrame(self.widget)
+        self.frame = QFrame(self.widget)
-        self.frame.setObjectName(u"frame")
+        self.frame.setObjectName(u"frame")
-        self.frame.setFrameShape(QFrame.Shape.StyledPanel)
+        self.frame.setFrameShape(QFrame.Shape.StyledPanel)
-        self.frame.setFrameShadow(QFrame.Shadow.Raised)
+        self.frame.setFrameShadow(QFrame.Shadow.Raised)
-        self.horizontalLayout = QHBoxLayout(self.frame)
+        self.horizontalLayout = QHBoxLayout(self.frame)
-        self.horizontalLayout.setObjectName(u"horizontalLayout")
+        self.horizontalLayout.setObjectName(u"horizontalLayout")
-        self.horizontalLayout.setContentsMargins(0, 0, 0, 0)
+        self.horizontalLayout.setContentsMargins(0, 0, 0, 0)
-        self.lineProjectDir = QLineEdit(self.frame)
+        self.lineProjectDir = QLineEdit(self.frame)
-        self.lineProjectDir.setObjectName(u"lineProjectDir")
+        self.lineProjectDir.setObjectName(u"lineProjectDir")
-
+
-        self.horizontalLayout.addWidget(self.lineProjectDir)
+        self.horizontalLayout.addWidget(self.lineProjectDir)
-
+
-        self.pushButton = QPushButton(self.frame)
+        self.pushButton = QPushButton(self.frame)
-        self.pushButton.setObjectName(u"pushButton")
+        self.pushButton.setObjectName(u"pushButton")
-
+
-        self.horizontalLayout.addWidget(self.pushButton)
+        self.horizontalLayout.addWidget(self.pushButton)
-
+
-
+
-        self.formLayout.setWidget(1, QFormLayout.ItemRole.FieldRole, self.frame)
+        self.formLayout.setWidget(1, QFormLayout.ItemRole.FieldRole, self.frame)
-
+
-        self.label_3 = QLabel(self.widget)
+        self.label_3 = QLabel(self.widget)
-        self.label_3.setObjectName(u"label_3")
+        self.label_3.setObjectName(u"label_3")
-
+
-        self.formLayout.setWidget(2, QFormLayout.ItemRole.LabelRole, self.label_3)
+        self.formLayout.setWidget(2, QFormLayout.ItemRole.LabelRole, self.label_3)
-
+
-        self.cB_XslDir = QComboBox(self.widget)
+        self.cB_XslDir = QComboBox(self.widget)
-        self.cB_XslDir.setObjectName(u"cB_XslDir")
+        self.cB_XslDir.setObjectName(u"cB_XslDir")
-
+
-        self.formLayout.setWidget(2, QFormLayout.ItemRole.FieldRole, self.cB_XslDir)
+        self.formLayout.setWidget(2, QFormLayout.ItemRole.FieldRole, self.cB_XslDir)
-
+
-        self.label_4 = QLabel(self.widget)
+        self.label_4 = QLabel(self.widget)
-        self.label_4.setObjectName(u"label_4")
+        self.label_4.setObjectName(u"label_4")
-
+
-        self.formLayout.setWidget(3, QFormLayout.ItemRole.LabelRole, self.label_4)
+        self.formLayout.setWidget(3, QFormLayout.ItemRole.LabelRole, self.label_4)
-
+
-        self.cB_JavaVm = QComboBox(self.widget)
+        self.cB_JavaVm = QComboBox(self.widget)
-        self.cB_JavaVm.setObjectName(u"cB_JavaVm")
+        self.cB_JavaVm.setObjectName(u"cB_JavaVm")
-
+
-        self.formLayout.setWidget(3, QFormLayout.ItemRole.FieldRole, self.cB_JavaVm)
+        self.formLayout.setWidget(3, QFormLayout.ItemRole.FieldRole, self.cB_JavaVm)
-
+
-        self.label_5 = QLabel(self.widget)
+        self.label_5 = QLabel(self.widget)
-        self.label_5.setObjectName(u"label_5")
+        self.label_5.setObjectName(u"label_5")
-
+
-        self.formLayout.setWidget(4, QFormLayout.ItemRole.LabelRole, self.label_5)
+        self.formLayout.setWidget(4, QFormLayout.ItemRole.LabelRole, self.label_5)
-
+
-        self.cB_SaxonJar = QComboBox(self.widget)
+        self.cB_SaxonJar = QComboBox(self.widget)
-        self.cB_SaxonJar.setObjectName(u"cB_SaxonJar")
+        self.cB_SaxonJar.setObjectName(u"cB_SaxonJar")
-
+
-        self.formLayout.setWidget(4, QFormLayout.ItemRole.FieldRole, self.cB_SaxonJar)
+        self.formLayout.setWidget(4, QFormLayout.ItemRole.FieldRole, self.cB_SaxonJar)
-
+
-        self.label_6 = QLabel(self.widget)
+        self.label_6 = QLabel(self.widget)
-        self.label_6.setObjectName(u"label_6")
+        self.label_6.setObjectName(u"label_6")
-
+
-        self.formLayout.setWidget(5, QFormLayout.ItemRole.LabelRole, self.label_6)
+        self.formLayout.setWidget(5, QFormLayout.ItemRole.LabelRole, self.label_6)
-
+
-        self.cB_ApacheFop = QComboBox(self.widget)
+        self.cB_ApacheFop = QComboBox(self.widget)
-        self.cB_ApacheFop.setObjectName(u"cB_ApacheFop")
+        self.cB_ApacheFop.setObjectName(u"cB_ApacheFop")
-
+
-        self.formLayout.setWidget(5, QFormLayout.ItemRole.FieldRole, self.cB_ApacheFop)
+        self.formLayout.setWidget(5, QFormLayout.ItemRole.FieldRole, self.cB_ApacheFop)
-
+
-        self.label_9 = QLabel(self.widget)
+        self.label_9 = QLabel(self.widget)
-        self.label_9.setObjectName(u"label_9")
+        self.label_9.setObjectName(u"label_9")
-
+
-        self.formLayout.setWidget(6, QFormLayout.ItemRole.LabelRole, self.label_9)
+        self.formLayout.setWidget(6, QFormLayout.ItemRole.LabelRole, self.label_9)
-
+
-        self.label_7 = QLabel(self.widget)
+        self.label_7 = QLabel(self.widget)
-        self.label_7.setObjectName(u"label_7")
+        self.label_7.setObjectName(u"label_7")
-
+
-        self.formLayout.setWidget(7, QFormLayout.ItemRole.LabelRole, self.label_7)
+        self.formLayout.setWidget(7, QFormLayout.ItemRole.LabelRole, self.label_7)
-
+
-        self.cB_Diff_Pdf = QComboBox(self.widget)
+        self.cB_Diff_Pdf = QComboBox(self.widget)
-        self.cB_Diff_Pdf.setObjectName(u"cB_Diff_Pdf")
+        self.cB_Diff_Pdf.setObjectName(u"cB_Diff_Pdf")
-
+
-        self.formLayout.setWidget(7, QFormLayout.ItemRole.FieldRole, self.cB_Diff_Pdf)
+        self.formLayout.setWidget(7, QFormLayout.ItemRole.FieldRole, self.cB_Diff_Pdf)
-
+
-        self.label_8 = QLabel(self.widget)
+        self.label_8 = QLabel(self.widget)
-        self.label_8.setObjectName(u"label_8")
+        self.label_8.setObjectName(u"label_8")
-
+
-        self.formLayout.setWidget(8, QFormLayout.ItemRole.LabelRole, self.label_8)
+        self.formLayout.setWidget(8, QFormLayout.ItemRole.LabelRole, self.label_8)
-
+
-        self.cB_Postgres = QComboBox(self.widget)
+        self.cB_Postgres = QComboBox(self.widget)
-        self.cB_Postgres.setObjectName(u"cB_Postgres")
+        self.cB_Postgres.setObjectName(u"cB_Postgres")
-
+
-        self.formLayout.setWidget(8, QFormLayout.ItemRole.FieldRole, self.cB_Postgres)
+        self.formLayout.setWidget(8, QFormLayout.ItemRole.FieldRole, self.cB_Postgres)
-
+
-        self.frame_2 = QFrame(self.widget)
+        self.label_10 = QLabel(self.widget)
-        self.frame_2.setObjectName(u"frame_2")
+        self.label_10.setObjectName(u"label_10")
-        self.frame_2.setFrameShape(QFrame.Shape.StyledPanel)
+
-        self.frame_2.setFrameShadow(QFrame.Shadow.Raised)
+        self.formLayout.setWidget(9, QFormLayout.ItemRole.LabelRole, self.label_10)
-        self.horizontalLayout_2 = QHBoxLayout(self.frame_2)
+
-        self.horizontalLayout_2.setObjectName(u"horizontalLayout_2")
+        self.btnEditXsltParams = QPushButton(self.widget)
-        self.horizontalLayout_2.setContentsMargins(0, 0, 0, 0)
+        self.btnEditXsltParams.setObjectName(u"btnEditXsltParams")
-        self.lineFopConfigDir = QLineEdit(self.frame_2)
+
-        self.lineFopConfigDir.setObjectName(u"lineFopConfigDir")
+        self.formLayout.setWidget(9, QFormLayout.ItemRole.FieldRole, self.btnEditXsltParams)
-
+
-        self.horizontalLayout_2.addWidget(self.lineFopConfigDir)
+        self.frame_2 = QFrame(self.widget)
-
+        self.frame_2.setObjectName(u"frame_2")
-        self.btnBrowseFopConfig = QPushButton(self.frame_2)
+        self.frame_2.setFrameShape(QFrame.Shape.StyledPanel)
-        self.btnBrowseFopConfig.setObjectName(u"btnBrowseFopConfig")
+        self.frame_2.setFrameShadow(QFrame.Shadow.Raised)
-
+        self.horizontalLayout_2 = QHBoxLayout(self.frame_2)
-        self.horizontalLayout_2.addWidget(self.btnBrowseFopConfig)
+        self.horizontalLayout_2.setObjectName(u"horizontalLayout_2")
-
+        self.horizontalLayout_2.setContentsMargins(0, 0, 0, 0)
-
+        self.lineFopConfigDir = QLineEdit(self.frame_2)
-        self.formLayout.setWidget(6, QFormLayout.ItemRole.FieldRole, self.frame_2)
+        self.lineFopConfigDir.setObjectName(u"lineFopConfigDir")
-
+
-
+        self.horizontalLayout_2.addWidget(self.lineFopConfigDir)
-        self.verticalLayout.addWidget(self.widget)
+
-
+        self.btnBrowseFopConfig = QPushButton(self.frame_2)
-        self.buttonBox = QDialogButtonBox(projectDlg)
+        self.btnBrowseFopConfig.setObjectName(u"btnBrowseFopConfig")
-        self.buttonBox.setObjectName(u"buttonBox")
+
-        self.buttonBox.setOrientation(Qt.Orientation.Horizontal)
+        self.horizontalLayout_2.addWidget(self.btnBrowseFopConfig)
-        self.buttonBox.setStandardButtons(QDialogButtonBox.StandardButton.Cancel|QDialogButtonBox.StandardButton.Ok)
+
-        self.buttonBox.setCenterButtons(True)
+
-
+        self.formLayout.setWidget(6, QFormLayout.ItemRole.FieldRole, self.frame_2)
-        self.verticalLayout.addWidget(self.buttonBox)
+
-
+
-
+        self.verticalLayout.addWidget(self.widget)
-        self.retranslateUi(projectDlg)
+
-        self.buttonBox.accepted.connect(projectDlg.accept)
+        self.buttonBox = QDialogButtonBox(projectDlg)
-        self.buttonBox.rejected.connect(projectDlg.reject)
+        self.buttonBox.setObjectName(u"buttonBox")
-
+        self.buttonBox.setOrientation(Qt.Orientation.Horizontal)
-        QMetaObject.connectSlotsByName(projectDlg)
+        self.buttonBox.setStandardButtons(QDialogButtonBox.StandardButton.Cancel|QDialogButtonBox.StandardButton.Ok)
-    # setupUi
+        self.buttonBox.setCenterButtons(True)
-
+
-    def retranslateUi(self, projectDlg):
+        self.verticalLayout.addWidget(self.buttonBox)
-        projectDlg.setWindowTitle(QCoreApplication.translate("projectDlg", u"PDF-Projekt", None))
+
-        self.label.setText(QCoreApplication.translate("projectDlg", u"Name:", None))
+
-        self.label_2.setText(QCoreApplication.translate("projectDlg", u"Projekt-Ordner:", None))
+        self.retranslateUi(projectDlg)
-        self.pushButton.setText(QCoreApplication.translate("projectDlg", u"Durchsuchen ...", None))
+        self.buttonBox.accepted.connect(projectDlg.accept)
-        self.label_3.setText(QCoreApplication.translate("projectDlg", u"XSL-Ordner:", None))
+        self.buttonBox.rejected.connect(projectDlg.reject)
-        self.label_4.setText(QCoreApplication.translate("projectDlg", u"Java VM:", None))
+
-        self.label_5.setText(QCoreApplication.translate("projectDlg", u"Saxon Jar:", None))
+        QMetaObject.connectSlotsByName(projectDlg)
-        self.label_6.setText(QCoreApplication.translate("projectDlg", u"Apache FOP:", None))
+    # setupUi
-        self.label_9.setText(QCoreApplication.translate("projectDlg", u"FOP-Config-Ordner:", None))
+
-        self.label_7.setText(QCoreApplication.translate("projectDlg", u"diff-pdf:", None))
+    def retranslateUi(self, projectDlg):
-        self.label_8.setText(QCoreApplication.translate("projectDlg", u"Postgres:", None))
+        projectDlg.setWindowTitle(QCoreApplication.translate("projectDlg", u"PDF-Projekt", None))
-        self.btnBrowseFopConfig.setText(QCoreApplication.translate("projectDlg", u"Durchsuchen ...", None))
+        self.label.setText(QCoreApplication.translate("projectDlg", u"Name:", None))
-    # retranslateUi
+        self.label_2.setText(QCoreApplication.translate("projectDlg", u"Projekt-Ordner:", None))
-
+        self.pushButton.setText(QCoreApplication.translate("projectDlg", u"Durchsuchen ...", None))
+        self.label_3.setText(QCoreApplication.translate("projectDlg", u"XSL-Ordner:", None))
+        self.label_4.setText(QCoreApplication.translate("projectDlg", u"Java VM:", None))
+        self.label_5.setText(QCoreApplication.translate("projectDlg", u"Saxon Jar:", None))
+        self.label_6.setText(QCoreApplication.translate("projectDlg", u"Apache FOP:", None))
+        self.label_9.setText(QCoreApplication.translate("projectDlg", u"FOP-Config-Ordner:", None))
+        self.label_7.setText(QCoreApplication.translate("projectDlg", u"diff-pdf:", None))
+        self.label_8.setText(QCoreApplication.translate("projectDlg", u"Postgres:", None))
+        self.label_10.setText(QCoreApplication.translate("projectDlg", u"XSLT-Parameter:", None))
+        self.btnEditXsltParams.setText(QCoreApplication.translate("projectDlg", u"Bearbeiten ...", None))
+        self.btnBrowseFopConfig.setText(QCoreApplication.translate("projectDlg", u"Durchsuchen ...", None))
+    # retranslateUi
+

src/ui/PostgreSqlConfigDialog.py

@@ -3,24 +3,29 @@ from PySide6.QtCore import QThread, Signal, Qt
 
 from ui.PostgreSqlConfigDialog_ui import Ui_PostgreSqlConfigDialog
 
-import polars as pl
-
 
 class DatabaseTestThread(QThread):
     """Thread für den Datenbankverbindungstest."""
-    
+
     # Signale für die Kommunikation mit dem UI-Thread
     test_completed = Signal(bool, str)  # success, message
-    
+
     def __init__(self, connection_data):
         super().__init__()
         self.connection_data = connection_data
-    
+
     def run(self):
         """Führt den Datenbanktest in einem separaten Thread aus."""
+        import polars as pl
         try:
-            uri = f"postgresql://{self.connection_data['username']}:{self.connection_data['password']}@{self.connection_data['host']}:{self.connection_data['port']}/{self.connection_data['database']}"
+            timeout = self.connection_data.get("timeout", 10)
-            
+            uri = (
+                f"postgresql://{self.connection_data['username']}:{self.connection_data['password']}"
+                f"@{self.connection_data['host']}:{self.connection_data['port']}"
+                f"/{self.connection_data['database']}"
+                f"?connect_timeout={timeout}"
+            )
+
             # Datenbankverbindung testen
             r = pl.read_database_uri(
                 query="SELECT 1",
@@ -106,6 +111,7 @@ class PostgreSqlConfigDialog(QDialog):
             self.ui.usernameEdit.setText(data.get("username", ""))
             self.ui.passwordEdit.setText(data.get("password", ""))
             self.ui.sslModeComboBox.setCurrentText(data.get("ssl_mode", "prefer"))
+            self.ui.timeoutSpinBox.setValue(data.get("timeout", 10))
 
     def get_data(self):
         """Gibt die eingegebenen Daten zurück."""
@@ -126,4 +132,5 @@ class PostgreSqlConfigDialog(QDialog):
             "username": self.ui.usernameEdit.text().strip(),
             "password": self.ui.passwordEdit.text(),  # Passwort kann leer sein
             "ssl_mode": self.ui.sslModeComboBox.currentText(),
+            "timeout": self.ui.timeoutSpinBox.value(),
         }

src/ui/PostgreSqlConfigDialog.ui

@@ -138,7 +138,27 @@
        </item>
       </widget>
      </item>
+     <item row="7" column="0">
+      <widget class="QLabel" name="timeoutLabel">
+       <property name="text">
+        <string>Timeout (s):</string>
+       </property>
+      </widget>
+     </item>
      <item row="7" column="1">
+      <widget class="QSpinBox" name="timeoutSpinBox">
+       <property name="minimum">
+        <number>1</number>
+       </property>
+       <property name="maximum">
+        <number>300</number>
+       </property>
+       <property name="value">
+        <number>10</number>
+       </property>
+      </widget>
+     </item>
+     <item row="8" column="1">
       <widget class="QPushButton" name="testConnectionButton">
        <property name="text">
         <string>Verbindung testen</string>

src/ui/PostgreSqlConfigDialog_ui.py

@@ -1,156 +1,170 @@
-# -*- coding: utf-8 -*-
+# -*- coding: utf-8 -*-
-
+
-################################################################################
+################################################################################
-## Form generated from reading UI file 'PostgreSqlConfigDialog.ui'
+## Form generated from reading UI file 'PostgreSqlConfigDialog.ui'
-##
+##
-## Created by: Qt User Interface Compiler version 6.9.1
+## Created by: Qt User Interface Compiler version 6.10.1
-##
+##
-## WARNING! All changes made in this file will be lost when recompiling UI file!
+## WARNING! All changes made in this file will be lost when recompiling UI file!
-################################################################################
+################################################################################
-
+
-from PySide6.QtCore import (QCoreApplication, QDate, QDateTime, QLocale,
+from PySide6.QtCore import (QCoreApplication, QDate, QDateTime, QLocale,
-    QMetaObject, QObject, QPoint, QRect,
+    QMetaObject, QObject, QPoint, QRect,
-    QSize, QTime, QUrl, Qt)
+    QSize, QTime, QUrl, Qt)
-from PySide6.QtGui import (QBrush, QColor, QConicalGradient, QCursor,
+from PySide6.QtGui import (QBrush, QColor, QConicalGradient, QCursor,
-    QFont, QFontDatabase, QGradient, QIcon,
+    QFont, QFontDatabase, QGradient, QIcon,
-    QImage, QKeySequence, QLinearGradient, QPainter,
+    QImage, QKeySequence, QLinearGradient, QPainter,
-    QPalette, QPixmap, QRadialGradient, QTransform)
+    QPalette, QPixmap, QRadialGradient, QTransform)
-from PySide6.QtWidgets import (QAbstractButton, QApplication, QComboBox, QDialog,
+from PySide6.QtWidgets import (QAbstractButton, QApplication, QComboBox, QDialog,
-    QDialogButtonBox, QFormLayout, QLabel, QLineEdit,
+    QDialogButtonBox, QFormLayout, QLabel, QLineEdit,
-    QPushButton, QSizePolicy, QSpinBox, QVBoxLayout,
+    QPushButton, QSizePolicy, QSpinBox, QVBoxLayout,
-    QWidget)
+    QWidget)
-
+
-class Ui_PostgreSqlConfigDialog(object):
+class Ui_PostgreSqlConfigDialog(object):
-    def setupUi(self, PostgreSqlConfigDialog):
+    def setupUi(self, PostgreSqlConfigDialog):
-        if not PostgreSqlConfigDialog.objectName():
+        if not PostgreSqlConfigDialog.objectName():
-            PostgreSqlConfigDialog.setObjectName(u"PostgreSqlConfigDialog")
+            PostgreSqlConfigDialog.setObjectName(u"PostgreSqlConfigDialog")
-        PostgreSqlConfigDialog.resize(397, 268)
+        PostgreSqlConfigDialog.resize(397, 268)
-        PostgreSqlConfigDialog.setModal(True)
+        PostgreSqlConfigDialog.setModal(True)
-        self.verticalLayout = QVBoxLayout(PostgreSqlConfigDialog)
+        self.verticalLayout = QVBoxLayout(PostgreSqlConfigDialog)
-        self.verticalLayout.setObjectName(u"verticalLayout")
+        self.verticalLayout.setObjectName(u"verticalLayout")
-        self.formLayout = QFormLayout()
+        self.formLayout = QFormLayout()
-        self.formLayout.setObjectName(u"formLayout")
+        self.formLayout.setObjectName(u"formLayout")
-        self.nameLabel = QLabel(PostgreSqlConfigDialog)
+        self.nameLabel = QLabel(PostgreSqlConfigDialog)
-        self.nameLabel.setObjectName(u"nameLabel")
+        self.nameLabel.setObjectName(u"nameLabel")
-
+
-        self.formLayout.setWidget(0, QFormLayout.ItemRole.LabelRole, self.nameLabel)
+        self.formLayout.setWidget(0, QFormLayout.ItemRole.LabelRole, self.nameLabel)
-
+
-        self.nameEdit = QLineEdit(PostgreSqlConfigDialog)
+        self.nameEdit = QLineEdit(PostgreSqlConfigDialog)
-        self.nameEdit.setObjectName(u"nameEdit")
+        self.nameEdit.setObjectName(u"nameEdit")
-
+
-        self.formLayout.setWidget(0, QFormLayout.ItemRole.FieldRole, self.nameEdit)
+        self.formLayout.setWidget(0, QFormLayout.ItemRole.FieldRole, self.nameEdit)
-
+
-        self.hostLabel = QLabel(PostgreSqlConfigDialog)
+        self.hostLabel = QLabel(PostgreSqlConfigDialog)
-        self.hostLabel.setObjectName(u"hostLabel")
+        self.hostLabel.setObjectName(u"hostLabel")
-
+
-        self.formLayout.setWidget(1, QFormLayout.ItemRole.LabelRole, self.hostLabel)
+        self.formLayout.setWidget(1, QFormLayout.ItemRole.LabelRole, self.hostLabel)
-
+
-        self.hostEdit = QLineEdit(PostgreSqlConfigDialog)
+        self.hostEdit = QLineEdit(PostgreSqlConfigDialog)
-        self.hostEdit.setObjectName(u"hostEdit")
+        self.hostEdit.setObjectName(u"hostEdit")
-
+
-        self.formLayout.setWidget(1, QFormLayout.ItemRole.FieldRole, self.hostEdit)
+        self.formLayout.setWidget(1, QFormLayout.ItemRole.FieldRole, self.hostEdit)
-
+
-        self.portLabel = QLabel(PostgreSqlConfigDialog)
+        self.portLabel = QLabel(PostgreSqlConfigDialog)
-        self.portLabel.setObjectName(u"portLabel")
+        self.portLabel.setObjectName(u"portLabel")
-
+
-        self.formLayout.setWidget(2, QFormLayout.ItemRole.LabelRole, self.portLabel)
+        self.formLayout.setWidget(2, QFormLayout.ItemRole.LabelRole, self.portLabel)
-
+
-        self.portSpinBox = QSpinBox(PostgreSqlConfigDialog)
+        self.portSpinBox = QSpinBox(PostgreSqlConfigDialog)
-        self.portSpinBox.setObjectName(u"portSpinBox")
+        self.portSpinBox.setObjectName(u"portSpinBox")
-        self.portSpinBox.setMinimum(1)
+        self.portSpinBox.setMinimum(1)
-        self.portSpinBox.setMaximum(65535)
+        self.portSpinBox.setMaximum(65535)
-        self.portSpinBox.setValue(5432)
+        self.portSpinBox.setValue(5432)
-
+
-        self.formLayout.setWidget(2, QFormLayout.ItemRole.FieldRole, self.portSpinBox)
+        self.formLayout.setWidget(2, QFormLayout.ItemRole.FieldRole, self.portSpinBox)
-
+
-        self.databaseLabel = QLabel(PostgreSqlConfigDialog)
+        self.databaseLabel = QLabel(PostgreSqlConfigDialog)
-        self.databaseLabel.setObjectName(u"databaseLabel")
+        self.databaseLabel.setObjectName(u"databaseLabel")
-
+
-        self.formLayout.setWidget(3, QFormLayout.ItemRole.LabelRole, self.databaseLabel)
+        self.formLayout.setWidget(3, QFormLayout.ItemRole.LabelRole, self.databaseLabel)
-
+
-        self.databaseEdit = QLineEdit(PostgreSqlConfigDialog)
+        self.databaseEdit = QLineEdit(PostgreSqlConfigDialog)
-        self.databaseEdit.setObjectName(u"databaseEdit")
+        self.databaseEdit.setObjectName(u"databaseEdit")
-
+
-        self.formLayout.setWidget(3, QFormLayout.ItemRole.FieldRole, self.databaseEdit)
+        self.formLayout.setWidget(3, QFormLayout.ItemRole.FieldRole, self.databaseEdit)
-
+
-        self.usernameLabel = QLabel(PostgreSqlConfigDialog)
+        self.usernameLabel = QLabel(PostgreSqlConfigDialog)
-        self.usernameLabel.setObjectName(u"usernameLabel")
+        self.usernameLabel.setObjectName(u"usernameLabel")
-
+
-        self.formLayout.setWidget(4, QFormLayout.ItemRole.LabelRole, self.usernameLabel)
+        self.formLayout.setWidget(4, QFormLayout.ItemRole.LabelRole, self.usernameLabel)
-
+
-        self.usernameEdit = QLineEdit(PostgreSqlConfigDialog)
+        self.usernameEdit = QLineEdit(PostgreSqlConfigDialog)
-        self.usernameEdit.setObjectName(u"usernameEdit")
+        self.usernameEdit.setObjectName(u"usernameEdit")
-
+
-        self.formLayout.setWidget(4, QFormLayout.ItemRole.FieldRole, self.usernameEdit)
+        self.formLayout.setWidget(4, QFormLayout.ItemRole.FieldRole, self.usernameEdit)
-
+
-        self.passwordLabel = QLabel(PostgreSqlConfigDialog)
+        self.passwordLabel = QLabel(PostgreSqlConfigDialog)
-        self.passwordLabel.setObjectName(u"passwordLabel")
+        self.passwordLabel.setObjectName(u"passwordLabel")
-
+
-        self.formLayout.setWidget(5, QFormLayout.ItemRole.LabelRole, self.passwordLabel)
+        self.formLayout.setWidget(5, QFormLayout.ItemRole.LabelRole, self.passwordLabel)
-
+
-        self.passwordEdit = QLineEdit(PostgreSqlConfigDialog)
+        self.passwordEdit = QLineEdit(PostgreSqlConfigDialog)
-        self.passwordEdit.setObjectName(u"passwordEdit")
+        self.passwordEdit.setObjectName(u"passwordEdit")
-        self.passwordEdit.setEchoMode(QLineEdit.EchoMode.Password)
+        self.passwordEdit.setEchoMode(QLineEdit.EchoMode.Password)
-
+
-        self.formLayout.setWidget(5, QFormLayout.ItemRole.FieldRole, self.passwordEdit)
+        self.formLayout.setWidget(5, QFormLayout.ItemRole.FieldRole, self.passwordEdit)
-
+
-        self.sslModeLabel = QLabel(PostgreSqlConfigDialog)
+        self.sslModeLabel = QLabel(PostgreSqlConfigDialog)
-        self.sslModeLabel.setObjectName(u"sslModeLabel")
+        self.sslModeLabel.setObjectName(u"sslModeLabel")
-
+
-        self.formLayout.setWidget(6, QFormLayout.ItemRole.LabelRole, self.sslModeLabel)
+        self.formLayout.setWidget(6, QFormLayout.ItemRole.LabelRole, self.sslModeLabel)
-
+
-        self.sslModeComboBox = QComboBox(PostgreSqlConfigDialog)
+        self.sslModeComboBox = QComboBox(PostgreSqlConfigDialog)
-        self.sslModeComboBox.addItem("")
+        self.sslModeComboBox.addItem("")
-        self.sslModeComboBox.addItem("")
+        self.sslModeComboBox.addItem("")
-        self.sslModeComboBox.addItem("")
+        self.sslModeComboBox.addItem("")
-        self.sslModeComboBox.addItem("")
+        self.sslModeComboBox.addItem("")
-        self.sslModeComboBox.addItem("")
+        self.sslModeComboBox.addItem("")
-        self.sslModeComboBox.addItem("")
+        self.sslModeComboBox.addItem("")
-        self.sslModeComboBox.setObjectName(u"sslModeComboBox")
+        self.sslModeComboBox.setObjectName(u"sslModeComboBox")
-
+
-        self.formLayout.setWidget(6, QFormLayout.ItemRole.FieldRole, self.sslModeComboBox)
+        self.formLayout.setWidget(6, QFormLayout.ItemRole.FieldRole, self.sslModeComboBox)
-
+
-        self.testConnectionButton = QPushButton(PostgreSqlConfigDialog)
+        self.timeoutLabel = QLabel(PostgreSqlConfigDialog)
-        self.testConnectionButton.setObjectName(u"testConnectionButton")
+        self.timeoutLabel.setObjectName(u"timeoutLabel")
-
+
-        self.formLayout.setWidget(7, QFormLayout.ItemRole.FieldRole, self.testConnectionButton)
+        self.formLayout.setWidget(7, QFormLayout.ItemRole.LabelRole, self.timeoutLabel)
-
+
-
+        self.timeoutSpinBox = QSpinBox(PostgreSqlConfigDialog)
-        self.verticalLayout.addLayout(self.formLayout)
+        self.timeoutSpinBox.setObjectName(u"timeoutSpinBox")
-
+        self.timeoutSpinBox.setMinimum(1)
-        self.buttonBox = QDialogButtonBox(PostgreSqlConfigDialog)
+        self.timeoutSpinBox.setMaximum(300)
-        self.buttonBox.setObjectName(u"buttonBox")
+        self.timeoutSpinBox.setValue(10)
-        self.buttonBox.setOrientation(Qt.Orientation.Horizontal)
+
-        self.buttonBox.setStandardButtons(QDialogButtonBox.StandardButton.Cancel|QDialogButtonBox.StandardButton.Ok)
+        self.formLayout.setWidget(7, QFormLayout.ItemRole.FieldRole, self.timeoutSpinBox)
-        self.buttonBox.setCenterButtons(True)
+
-
+        self.testConnectionButton = QPushButton(PostgreSqlConfigDialog)
-        self.verticalLayout.addWidget(self.buttonBox)
+        self.testConnectionButton.setObjectName(u"testConnectionButton")
-
+
-
+        self.formLayout.setWidget(8, QFormLayout.ItemRole.FieldRole, self.testConnectionButton)
-        self.retranslateUi(PostgreSqlConfigDialog)
+
-        self.buttonBox.accepted.connect(PostgreSqlConfigDialog.accept)
+
-        self.buttonBox.rejected.connect(PostgreSqlConfigDialog.reject)
+        self.verticalLayout.addLayout(self.formLayout)
-
+
-        QMetaObject.connectSlotsByName(PostgreSqlConfigDialog)
+        self.buttonBox = QDialogButtonBox(PostgreSqlConfigDialog)
-    # setupUi
+        self.buttonBox.setObjectName(u"buttonBox")
-
+        self.buttonBox.setOrientation(Qt.Orientation.Horizontal)
-    def retranslateUi(self, PostgreSqlConfigDialog):
+        self.buttonBox.setStandardButtons(QDialogButtonBox.StandardButton.Cancel|QDialogButtonBox.StandardButton.Ok)
-        PostgreSqlConfigDialog.setWindowTitle(QCoreApplication.translate("PostgreSqlConfigDialog", u"PostgreSQL Datenbank Konfiguration", None))
+        self.buttonBox.setCenterButtons(True)
-        self.nameLabel.setText(QCoreApplication.translate("PostgreSqlConfigDialog", u"Name:", None))
+
-        self.hostLabel.setText(QCoreApplication.translate("PostgreSqlConfigDialog", u"Host:", None))
+        self.verticalLayout.addWidget(self.buttonBox)
-        self.hostEdit.setText(QCoreApplication.translate("PostgreSqlConfigDialog", u"localhost", None))
+
-        self.portLabel.setText(QCoreApplication.translate("PostgreSqlConfigDialog", u"Port:", None))
+
-        self.databaseLabel.setText(QCoreApplication.translate("PostgreSqlConfigDialog", u"Datenbank:", None))
+        self.retranslateUi(PostgreSqlConfigDialog)
-        self.usernameLabel.setText(QCoreApplication.translate("PostgreSqlConfigDialog", u"Benutzername:", None))
+        self.buttonBox.accepted.connect(PostgreSqlConfigDialog.accept)
-        self.passwordLabel.setText(QCoreApplication.translate("PostgreSqlConfigDialog", u"Passwort:", None))
+        self.buttonBox.rejected.connect(PostgreSqlConfigDialog.reject)
-        self.sslModeLabel.setText(QCoreApplication.translate("PostgreSqlConfigDialog", u"SSL-Modus:", None))
+
-        self.sslModeComboBox.setItemText(0, QCoreApplication.translate("PostgreSqlConfigDialog", u"disable", None))
+        QMetaObject.connectSlotsByName(PostgreSqlConfigDialog)
-        self.sslModeComboBox.setItemText(1, QCoreApplication.translate("PostgreSqlConfigDialog", u"allow", None))
+    # setupUi
-        self.sslModeComboBox.setItemText(2, QCoreApplication.translate("PostgreSqlConfigDialog", u"prefer", None))
+
-        self.sslModeComboBox.setItemText(3, QCoreApplication.translate("PostgreSqlConfigDialog", u"require", None))
+    def retranslateUi(self, PostgreSqlConfigDialog):
-        self.sslModeComboBox.setItemText(4, QCoreApplication.translate("PostgreSqlConfigDialog", u"verify-ca", None))
+        PostgreSqlConfigDialog.setWindowTitle(QCoreApplication.translate("PostgreSqlConfigDialog", u"PostgreSQL Datenbank Konfiguration", None))
-        self.sslModeComboBox.setItemText(5, QCoreApplication.translate("PostgreSqlConfigDialog", u"verify-full", None))
+        self.nameLabel.setText(QCoreApplication.translate("PostgreSqlConfigDialog", u"Name:", None))
-
+        self.hostLabel.setText(QCoreApplication.translate("PostgreSqlConfigDialog", u"Host:", None))
-        self.testConnectionButton.setText(QCoreApplication.translate("PostgreSqlConfigDialog", u"Verbindung testen", None))
+        self.hostEdit.setText(QCoreApplication.translate("PostgreSqlConfigDialog", u"localhost", None))
-    # retranslateUi
+        self.portLabel.setText(QCoreApplication.translate("PostgreSqlConfigDialog", u"Port:", None))
-
+        self.databaseLabel.setText(QCoreApplication.translate("PostgreSqlConfigDialog", u"Datenbank:", None))
+        self.usernameLabel.setText(QCoreApplication.translate("PostgreSqlConfigDialog", u"Benutzername:", None))
+        self.passwordLabel.setText(QCoreApplication.translate("PostgreSqlConfigDialog", u"Passwort:", None))
+        self.sslModeLabel.setText(QCoreApplication.translate("PostgreSqlConfigDialog", u"SSL-Modus:", None))
+        self.sslModeComboBox.setItemText(0, QCoreApplication.translate("PostgreSqlConfigDialog", u"disable", None))
+        self.sslModeComboBox.setItemText(1, QCoreApplication.translate("PostgreSqlConfigDialog", u"allow", None))
+        self.sslModeComboBox.setItemText(2, QCoreApplication.translate("PostgreSqlConfigDialog", u"prefer", None))
+        self.sslModeComboBox.setItemText(3, QCoreApplication.translate("PostgreSqlConfigDialog", u"require", None))
+        self.sslModeComboBox.setItemText(4, QCoreApplication.translate("PostgreSqlConfigDialog", u"verify-ca", None))
+        self.sslModeComboBox.setItemText(5, QCoreApplication.translate("PostgreSqlConfigDialog", u"verify-full", None))
+
+        self.timeoutLabel.setText(QCoreApplication.translate("PostgreSqlConfigDialog", u"Timeout (s):", None))
+        self.testConnectionButton.setText(QCoreApplication.translate("PostgreSqlConfigDialog", u"Verbindung testen", None))
+    # retranslateUi
+

src/ui/ProjectXsltParamsDialog.py

@@ -0,0 +1,64 @@
+from PySide6.QtWidgets import QDialog, QTableWidgetItem
+from ui.ProjectXsltParamsDialog_ui import Ui_ProjectXsltParamsDialog
+
+
+class ProjectXsltParamsDialog(QDialog):
+    """Dialog zur Bearbeitung projektweiter XSLT-Parameter."""
+
+    def __init__(self, parent=None, xslt_params: dict[str, str] | None = None):
+        super().__init__(parent)
+
+        self.ui = Ui_ProjectXsltParamsDialog()
+        self.ui.setupUi(self)
+
+        self.ui.addParamButton.clicked.connect(self._add_parameter)
+        self.ui.removeParamButton.clicked.connect(self._remove_parameter)
+
+        self._setup_table()
+
+        if xslt_params:
+            self._load_params(xslt_params)
+
+    def _setup_table(self):
+        """Konfiguriert die Tabelle."""
+        self.ui.xsltParamsTable.setColumnWidth(0, 200)
+        self.ui.xsltParamsTable.setColumnWidth(1, 300)
+        self.ui.xsltParamsTable.horizontalHeader().setStretchLastSection(True)
+
+    def _load_params(self, params: dict[str, str]):
+        """Lädt die XSLT-Parameter in die Tabelle."""
+        self.ui.xsltParamsTable.setRowCount(len(params))
+        for row, (key, value) in enumerate(params.items()):
+            self.ui.xsltParamsTable.setItem(row, 0, QTableWidgetItem(str(key)))
+            self.ui.xsltParamsTable.setItem(row, 1, QTableWidgetItem(str(value)))
+
+    def _add_parameter(self):
+        """Fügt einen neuen Parameter hinzu."""
+        row_count = self.ui.xsltParamsTable.rowCount()
+        self.ui.xsltParamsTable.insertRow(row_count)
+        self.ui.xsltParamsTable.setItem(row_count, 0, QTableWidgetItem(""))
+        self.ui.xsltParamsTable.setItem(row_count, 1, QTableWidgetItem(""))
+        self.ui.xsltParamsTable.setCurrentCell(row_count, 0)
+
+    def _remove_parameter(self):
+        """Entfernt den ausgewählten Parameter."""
+        current_row = self.ui.xsltParamsTable.currentRow()
+        if current_row >= 0:
+            self.ui.xsltParamsTable.removeRow(current_row)
+
+    def get_params(self) -> dict[str, str]:
+        """
+        Gibt die bearbeiteten XSLT-Parameter zurück.
+
+        Returns:
+            dict[str, str]: Dictionary mit allen XSLT-Parametern
+        """
+        params = {}
+        for row in range(self.ui.xsltParamsTable.rowCount()):
+            key_item = self.ui.xsltParamsTable.item(row, 0)
+            value_item = self.ui.xsltParamsTable.item(row, 1)
+            if key_item and value_item:
+                key = key_item.text().strip()
+                if key:
+                    params[key] = value_item.text().strip()
+        return params

src/ui/ProjectXsltParamsDialog.ui

@@ -0,0 +1,164 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>ProjectXsltParamsDialog</class>
+ <widget class="QDialog" name="ProjectXsltParamsDialog">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>600</width>
+    <height>400</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Projektweite XSLT-Parameter</string>
+  </property>
+  <property name="modal">
+   <bool>true</bool>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <widget class="QGroupBox" name="xsltParamsGroupBox">
+     <property name="title">
+      <string>XSLT-Parameter</string>
+     </property>
+     <layout class="QVBoxLayout" name="xsltParamsLayout">
+      <property name="leftMargin">
+       <number>0</number>
+      </property>
+      <property name="topMargin">
+       <number>0</number>
+      </property>
+      <property name="rightMargin">
+       <number>0</number>
+      </property>
+      <property name="bottomMargin">
+       <number>0</number>
+      </property>
+      <item>
+       <widget class="QTableWidget" name="xsltParamsTable">
+        <property name="frameShape">
+         <enum>QFrame::Shape::NoFrame</enum>
+        </property>
+        <property name="columnCount">
+         <number>2</number>
+        </property>
+        <attribute name="horizontalHeaderVisible">
+         <bool>true</bool>
+        </attribute>
+        <column>
+         <property name="text">
+          <string>Parameter</string>
+         </property>
+        </column>
+        <column>
+         <property name="text">
+          <string>Wert</string>
+         </property>
+        </column>
+       </widget>
+      </item>
+      <item>
+       <layout class="QHBoxLayout" name="xsltParamsButtonLayout">
+        <item>
+         <spacer name="horizontalSpacer_left">
+          <property name="orientation">
+           <enum>Qt::Orientation::Horizontal</enum>
+          </property>
+          <property name="sizeHint" stdset="0">
+           <size>
+            <width>40</width>
+            <height>20</height>
+           </size>
+          </property>
+         </spacer>
+        </item>
+        <item>
+         <widget class="QPushButton" name="addParamButton">
+          <property name="text">
+           <string>Parameter hinzufügen</string>
+          </property>
+          <property name="icon">
+           <iconset theme="QIcon::ThemeIcon::ListAdd"/>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QPushButton" name="removeParamButton">
+          <property name="text">
+           <string>Parameter entfernen</string>
+          </property>
+          <property name="icon">
+           <iconset theme="QIcon::ThemeIcon::ListRemove"/>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <spacer name="horizontalSpacer_right">
+          <property name="orientation">
+           <enum>Qt::Orientation::Horizontal</enum>
+          </property>
+          <property name="sizeHint" stdset="0">
+           <size>
+            <width>40</width>
+            <height>20</height>
+           </size>
+          </property>
+         </spacer>
+        </item>
+       </layout>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
+    <widget class="QDialogButtonBox" name="buttonBox">
+     <property name="orientation">
+      <enum>Qt::Orientation::Horizontal</enum>
+     </property>
+     <property name="standardButtons">
+      <set>QDialogButtonBox::StandardButton::Cancel|QDialogButtonBox::StandardButton::Ok</set>
+     </property>
+     <property name="centerButtons">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>accepted()</signal>
+   <receiver>ProjectXsltParamsDialog</receiver>
+   <slot>accept()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>248</x>
+     <y>254</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>157</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>rejected()</signal>
+   <receiver>ProjectXsltParamsDialog</receiver>
+   <slot>reject()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>316</x>
+     <y>260</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>286</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>

src/ui/ProjectXsltParamsDialog_ui.py

@@ -0,0 +1,106 @@
+# -*- coding: utf-8 -*-
+
+################################################################################
+## Form generated from reading UI file 'ProjectXsltParamsDialog.ui'
+##
+## Created by: Qt User Interface Compiler version 6.10.1
+##
+## WARNING! All changes made in this file will be lost when recompiling UI file!
+################################################################################
+
+from PySide6.QtCore import (QCoreApplication, QDate, QDateTime, QLocale,
+    QMetaObject, QObject, QPoint, QRect,
+    QSize, QTime, QUrl, Qt)
+from PySide6.QtGui import (QBrush, QColor, QConicalGradient, QCursor,
+    QFont, QFontDatabase, QGradient, QIcon,
+    QImage, QKeySequence, QLinearGradient, QPainter,
+    QPalette, QPixmap, QRadialGradient, QTransform)
+from PySide6.QtWidgets import (QAbstractButton, QApplication, QDialog, QDialogButtonBox,
+    QFrame, QGroupBox, QHBoxLayout, QHeaderView,
+    QPushButton, QSizePolicy, QSpacerItem, QTableWidget,
+    QTableWidgetItem, QVBoxLayout, QWidget)
+
+class Ui_ProjectXsltParamsDialog(object):
+    def setupUi(self, ProjectXsltParamsDialog):
+        if not ProjectXsltParamsDialog.objectName():
+            ProjectXsltParamsDialog.setObjectName(u"ProjectXsltParamsDialog")
+        ProjectXsltParamsDialog.resize(600, 400)
+        ProjectXsltParamsDialog.setModal(True)
+        self.verticalLayout = QVBoxLayout(ProjectXsltParamsDialog)
+        self.verticalLayout.setObjectName(u"verticalLayout")
+        self.xsltParamsGroupBox = QGroupBox(ProjectXsltParamsDialog)
+        self.xsltParamsGroupBox.setObjectName(u"xsltParamsGroupBox")
+        self.xsltParamsLayout = QVBoxLayout(self.xsltParamsGroupBox)
+        self.xsltParamsLayout.setObjectName(u"xsltParamsLayout")
+        self.xsltParamsLayout.setContentsMargins(0, 0, 0, 0)
+        self.xsltParamsTable = QTableWidget(self.xsltParamsGroupBox)
+        if (self.xsltParamsTable.columnCount() < 2):
+            self.xsltParamsTable.setColumnCount(2)
+        __qtablewidgetitem = QTableWidgetItem()
+        self.xsltParamsTable.setHorizontalHeaderItem(0, __qtablewidgetitem)
+        __qtablewidgetitem1 = QTableWidgetItem()
+        self.xsltParamsTable.setHorizontalHeaderItem(1, __qtablewidgetitem1)
+        self.xsltParamsTable.setObjectName(u"xsltParamsTable")
+        self.xsltParamsTable.setFrameShape(QFrame.Shape.NoFrame)
+        self.xsltParamsTable.setColumnCount(2)
+        self.xsltParamsTable.horizontalHeader().setVisible(True)
+
+        self.xsltParamsLayout.addWidget(self.xsltParamsTable)
+
+        self.xsltParamsButtonLayout = QHBoxLayout()
+        self.xsltParamsButtonLayout.setObjectName(u"xsltParamsButtonLayout")
+        self.horizontalSpacer_left = QSpacerItem(40, 20, QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum)
+
+        self.xsltParamsButtonLayout.addItem(self.horizontalSpacer_left)
+
+        self.addParamButton = QPushButton(self.xsltParamsGroupBox)
+        self.addParamButton.setObjectName(u"addParamButton")
+        icon = QIcon(QIcon.fromTheme(QIcon.ThemeIcon.ListAdd))
+        self.addParamButton.setIcon(icon)
+
+        self.xsltParamsButtonLayout.addWidget(self.addParamButton)
+
+        self.removeParamButton = QPushButton(self.xsltParamsGroupBox)
+        self.removeParamButton.setObjectName(u"removeParamButton")
+        icon1 = QIcon(QIcon.fromTheme(QIcon.ThemeIcon.ListRemove))
+        self.removeParamButton.setIcon(icon1)
+
+        self.xsltParamsButtonLayout.addWidget(self.removeParamButton)
+
+        self.horizontalSpacer_right = QSpacerItem(40, 20, QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum)
+
+        self.xsltParamsButtonLayout.addItem(self.horizontalSpacer_right)
+
+
+        self.xsltParamsLayout.addLayout(self.xsltParamsButtonLayout)
+
+
+        self.verticalLayout.addWidget(self.xsltParamsGroupBox)
+
+        self.buttonBox = QDialogButtonBox(ProjectXsltParamsDialog)
+        self.buttonBox.setObjectName(u"buttonBox")
+        self.buttonBox.setOrientation(Qt.Orientation.Horizontal)
+        self.buttonBox.setStandardButtons(QDialogButtonBox.StandardButton.Cancel|QDialogButtonBox.StandardButton.Ok)
+        self.buttonBox.setCenterButtons(True)
+
+        self.verticalLayout.addWidget(self.buttonBox)
+
+
+        self.retranslateUi(ProjectXsltParamsDialog)
+        self.buttonBox.accepted.connect(ProjectXsltParamsDialog.accept)
+        self.buttonBox.rejected.connect(ProjectXsltParamsDialog.reject)
+
+        QMetaObject.connectSlotsByName(ProjectXsltParamsDialog)
+    # setupUi
+
+    def retranslateUi(self, ProjectXsltParamsDialog):
+        ProjectXsltParamsDialog.setWindowTitle(QCoreApplication.translate("ProjectXsltParamsDialog", u"Projektweite XSLT-Parameter", None))
+        self.xsltParamsGroupBox.setTitle(QCoreApplication.translate("ProjectXsltParamsDialog", u"XSLT-Parameter", None))
+        ___qtablewidgetitem = self.xsltParamsTable.horizontalHeaderItem(0)
+        ___qtablewidgetitem.setText(QCoreApplication.translate("ProjectXsltParamsDialog", u"Parameter", None));
+        ___qtablewidgetitem1 = self.xsltParamsTable.horizontalHeaderItem(1)
+        ___qtablewidgetitem1.setText(QCoreApplication.translate("ProjectXsltParamsDialog", u"Wert", None));
+        self.addParamButton.setText(QCoreApplication.translate("ProjectXsltParamsDialog", u"Parameter hinzuf\u00fcgen", None))
+        self.removeParamButton.setText(QCoreApplication.translate("ProjectXsltParamsDialog", u"Parameter entfernen", None))
+    # retranslateUi
+

src/ui/TreeNodeEditDialog.py

@@ -1,161 +1,9 @@
-from PySide6.QtWidgets import QDialog, QTableWidgetItem, QMessageBox
-from PySide6.QtCore import Qt
-
 from ui.TreeNodeEditDialog_ui import Ui_TreeNodeEditDialog
+from ui.XsltParamsEditDialog import XsltParamsEditDialog
 
 
-class TreeNodeEditDialog(QDialog):
+class TreeNodeEditDialog(XsltParamsEditDialog):
     """Dialog zur Bearbeitung von TreeNode-Objekten."""
 
-    def __init__(self, parent=None, node=None, parent_params=None):
+    def _create_ui(self):
-        """
+        return Ui_TreeNodeEditDialog()
-        Initialisiert den Dialog.
-        
-        Args:
-            parent: Übergeordnetes Widget
-            node: TreeNode-Objekt zum Bearbeiten
-            parent_params: Dictionary mit Eltern-Parametern (nur anzeigen)
-        """
-        super().__init__(parent)
-
-        # UI einrichten
-        self.ui = Ui_TreeNodeEditDialog()
-        self.ui.setupUi(self)
-
-        # Node-Objekt speichern
-        self.node = node
-        self.parent_params = parent_params or {}
-
-        # Signale verbinden
-        self.ui.addParamButton.clicked.connect(self.add_parameter)
-        self.ui.removeParamButton.clicked.connect(self.remove_parameter)
-
-        # Tabellen konfigurieren
-        self._setup_tables()
-
-        # Daten laden
-        if self.node:
-            self._load_data()
-
-    def _setup_tables(self):
-        """Konfiguriert die Tabellen."""
-        # XSLT Parameter Tabelle
-        self.ui.xsltParamsTable.setColumnWidth(0, 200)
-        self.ui.xsltParamsTable.setColumnWidth(1, 300)
-        self.ui.xsltParamsTable.horizontalHeader().setStretchLastSection(True)
-
-        # Eltern-Parameter Tabelle
-        self.ui.parentParamsTable.setColumnWidth(0, 200)
-        self.ui.parentParamsTable.setColumnWidth(1, 300)
-        self.ui.parentParamsTable.horizontalHeader().setStretchLastSection(True)
-
-    def _load_data(self):
-        """Lädt die Daten des TreeNode in den Dialog."""
-        if not self.node:
-            return
-
-        # Bezeichnung setzen
-        self.ui.bezEdit.setText(str(self.node.bez) if self.node.bez else "")
-
-        # XSLT Parameter laden
-        self._load_xslt_params()
-
-        # Eltern-Parameter laden
-        self._load_parent_params()
-
-    def _load_xslt_params(self):
-        """Lädt die XSLT Parameter in die Tabelle."""
-        if not self.node or not self.node.xslt_params:
-            return
-
-        params = self.node.xslt_params
-        self.ui.xsltParamsTable.setRowCount(len(params))
-
-        for row, (key, value) in enumerate(params.items()):
-            # Parameter-Name
-            key_item = QTableWidgetItem(str(key))
-            self.ui.xsltParamsTable.setItem(row, 0, key_item)
-
-            # Parameter-Wert
-            value_item = QTableWidgetItem(str(value))
-            self.ui.xsltParamsTable.setItem(row, 1, value_item)
-
-    def _load_parent_params(self):
-        """Lädt die Eltern-Parameter in die Tabelle (nur anzeigen)."""
-        if not self.parent_params:
-            return
-
-        self.ui.parentParamsTable.setRowCount(len(self.parent_params))
-
-        for row, (key, value) in enumerate(self.parent_params.items()):
-            # Parameter-Name
-            key_item = QTableWidgetItem(str(key))
-            key_item.setFlags(key_item.flags() & ~Qt.ItemFlag.ItemIsEditable)
-            self.ui.parentParamsTable.setItem(row, 0, key_item)
-
-            # Parameter-Wert
-            value_item = QTableWidgetItem(str(value))
-            value_item.setFlags(value_item.flags() & ~Qt.ItemFlag.ItemIsEditable)
-            self.ui.parentParamsTable.setItem(row, 1, value_item)
-
-    def add_parameter(self):
-        """Fügt einen neuen Parameter hinzu."""
-        row_count = self.ui.xsltParamsTable.rowCount()
-        self.ui.xsltParamsTable.insertRow(row_count)
-
-        # Leere Items hinzufügen
-        key_item = QTableWidgetItem("")
-        value_item = QTableWidgetItem("")
-
-        self.ui.xsltParamsTable.setItem(row_count, 0, key_item)
-        self.ui.xsltParamsTable.setItem(row_count, 1, value_item)
-
-        # Fokus auf den neuen Parameter setzen
-        self.ui.xsltParamsTable.setCurrentCell(row_count, 0)
-
-    def remove_parameter(self):
-        """Entfernt den ausgewählten Parameter."""
-        current_row = self.ui.xsltParamsTable.currentRow()
-        if current_row >= 0:
-            self.ui.xsltParamsTable.removeRow(current_row)
-
-    def get_data(self):
-        """
-        Gibt die bearbeiteten Daten zurück.
-
-        Returns:
-            dict: Dictionary mit den bearbeiteten Daten oder None bei Fehler
-        """
-        # Bezeichnung prüfen
-        bez = self.ui.bezEdit.text().strip()
-        if not bez:
-            QMessageBox.warning(self, "Warnung", "Bitte geben Sie eine Bezeichnung ein.")
-            return None
-
-        # XSLT Parameter sammeln
-        xslt_params = {}
-        for row in range(self.ui.xsltParamsTable.rowCount()):
-            key_item = self.ui.xsltParamsTable.item(row, 0)
-            value_item = self.ui.xsltParamsTable.item(row, 1)
-
-            if key_item and value_item:
-                key = key_item.text().strip()
-                value = value_item.text().strip()
-
-                if key:  # Nur Parameter mit nicht-leerem Schlüssel hinzufügen
-                    xslt_params[key] = value
-
-        # CheckBox für Force-Transformation prüfen
-        force_transform = self.ui.alle_xml_transformieren.isChecked()
-
-        return {
-            "bez": bez,
-            "xslt_params": xslt_params,
-            "force_transform": force_transform
-        }
-
-    def accept(self):
-        """Überschreibt accept() um Datenvalidierung durchzuführen."""
-        data = self.get_data()
-        if data is not None:
-            super().accept()

src/ui/WorkerPoolMetricsDialog.py

@@ -0,0 +1,253 @@
+"""
+Worker Pool Metriken-Dialog.
+
+Zeigt Performance- und Ressourcenverbrauch-Metriken für Saxon- und FOP-Worker-Pools an.
+"""
+
+import logging
+from PySide6.QtWidgets import (
+    QDialog,
+    QVBoxLayout,
+    QHBoxLayout,
+    QGroupBox,
+    QLabel,
+    QPushButton,
+    QTabWidget,
+    QWidget,
+)
+logger = logging.getLogger(__name__)
+
+
+class WorkerPoolMetricsDialog(QDialog):
+    """
+    Dialog zur Anzeige von Worker-Pool-Metriken.
+    """
+
+    def __init__(self, parent=None):
+        """
+        Initialisiert den Metriken-Dialog.
+
+        Args:
+            parent: Eltern-Widget
+        """
+        super().__init__(parent)
+        self.setWindowTitle("Worker Pool Performance-Metriken")
+        self.resize(800, 600)
+        self._setup_ui()
+        self._load_metrics()
+
+    def _setup_ui(self):
+        """Erstellt die UI-Elemente."""
+        layout = QVBoxLayout(self)
+
+        # Tab-Widget für Saxon und FOP
+        self.tab_widget = QTabWidget()
+        layout.addWidget(self.tab_widget)
+
+        # Saxon-Tab
+        self.saxon_tab = self._create_metrics_tab("Saxon Worker Pool")
+        self.tab_widget.addTab(self.saxon_tab, "Saxon (XSLT)")
+
+        # FOP-Tab
+        self.fop_tab = self._create_metrics_tab("FOP Worker Pool")
+        self.tab_widget.addTab(self.fop_tab, "FOP (PDF)")
+
+        # Schließen-Button
+        button_layout = QHBoxLayout()
+        button_layout.addStretch()
+        close_button = QPushButton("Schließen")
+        close_button.clicked.connect(self.accept)
+        button_layout.addWidget(close_button)
+        layout.addLayout(button_layout)
+
+    def _create_metrics_tab(self, title: str) -> QWidget:
+        """
+        Erstellt ein Tab-Widget für Metriken.
+
+        Args:
+            title: Titel der Metrik-Gruppe
+
+        Returns:
+            QWidget mit Metriken
+        """
+        tab = QWidget()
+        layout = QVBoxLayout(tab)
+
+        # Status-Label
+        status_label = QLabel("Status: <i>Nicht initialisiert</i>")
+        status_label.setObjectName("status_label")
+        layout.addWidget(status_label)
+
+        # Kompilierungs-Metriken
+        compile_group = QGroupBox("Kompilierung")
+        compile_layout = QVBoxLayout(compile_group)
+
+        compile_time_label = QLabel("Kompilierungszeit: -")
+        compile_time_label.setObjectName("compile_time_label")
+        compile_layout.addWidget(compile_time_label)
+
+        layout.addWidget(compile_group)
+
+        # Worker-Start-Metriken
+        worker_start_group = QGroupBox("Worker-Start")
+        worker_start_layout = QVBoxLayout(worker_start_group)
+
+        worker_count_label = QLabel("Anzahl Worker: -")
+        worker_count_label.setObjectName("worker_count_label")
+        worker_start_layout.addWidget(worker_count_label)
+
+        total_start_time_label = QLabel("Summe Startzeit: -")
+        total_start_time_label.setObjectName("total_start_time_label")
+        worker_start_layout.addWidget(total_start_time_label)
+
+        avg_start_time_label = QLabel("Durchschnitt Startzeit: -")
+        avg_start_time_label.setObjectName("avg_start_time_label")
+        worker_start_layout.addWidget(avg_start_time_label)
+
+        layout.addWidget(worker_start_group)
+
+        # RAM-Metriken
+        ram_group = QGroupBox("Arbeitsspeicher (RAM)")
+        ram_layout = QVBoxLayout(ram_group)
+
+        ram_before_label = QLabel("RAM vor Transformation: -")
+        ram_before_label.setObjectName("ram_before_label")
+        ram_layout.addWidget(ram_before_label)
+
+        ram_before_avg_label = QLabel("RAM vor Transformation (Durchschnitt/Worker): -")
+        ram_before_avg_label.setObjectName("ram_before_avg_label")
+        ram_layout.addWidget(ram_before_avg_label)
+
+        ram_after_label = QLabel("RAM nach Transformation: -")
+        ram_after_label.setObjectName("ram_after_label")
+        ram_layout.addWidget(ram_after_label)
+
+        ram_after_avg_label = QLabel("RAM nach Transformation (Durchschnitt/Worker): -")
+        ram_after_avg_label.setObjectName("ram_after_avg_label")
+        ram_layout.addWidget(ram_after_avg_label)
+
+        ram_delta_label = QLabel("RAM-Zunahme: -")
+        ram_delta_label.setObjectName("ram_delta_label")
+        ram_layout.addWidget(ram_delta_label)
+
+        layout.addWidget(ram_group)
+
+        layout.addStretch()
+
+        return tab
+
+    def _load_metrics(self):
+        """Lädt und zeigt die Metriken an."""
+        # Hole MainWindow-Instanz (parent)
+        main_window = self.parent()
+
+        # Saxon Worker Pool - verwende gespeicherte Metriken
+        if hasattr(main_window, "last_saxon_metrics") and main_window.last_saxon_metrics:
+            self._update_metrics_tab_from_metrics(
+                self.saxon_tab, main_window.last_saxon_metrics, "Saxon Worker Pool"
+            )
+        else:
+            self._set_tab_status(
+                self.saxon_tab, "<i>Keine Metriken verfügbar - bitte erst eine Transformation durchführen</i>"
+            )
+
+        # FOP Worker Pool - verwende gespeicherte Metriken
+        if hasattr(main_window, "last_fop_metrics") and main_window.last_fop_metrics:
+            self._update_metrics_tab_from_metrics(self.fop_tab, main_window.last_fop_metrics, "FOP Worker Pool")
+        else:
+            self._set_tab_status(
+                self.fop_tab, "<i>Keine Metriken verfügbar - bitte erst eine Transformation durchführen</i>"
+            )
+
+    def _set_tab_status(self, tab: QWidget, status: str):
+        """
+        Setzt den Status-Text eines Tabs.
+
+        Args:
+            tab: Das Tab-Widget
+            status: Der Status-Text
+        """
+        status_label = tab.findChild(QLabel, "status_label")
+        if status_label:
+            status_label.setText(f"Status: {status}")
+
+    def _update_metrics_tab_from_metrics(self, tab: QWidget, metrics, pool_name: str):
+        """
+        Aktualisiert die Metriken in einem Tab (direkt aus Metriken-Objekt).
+
+        Args:
+            tab: Das Tab-Widget
+            metrics: Das WorkerPoolMetrics-Objekt
+            pool_name: Name des Pools
+        """
+        # Status - berechne Worker-Anzahl aus Metriken
+        num_workers = len(metrics.worker_start_times) if metrics.worker_start_times else 0
+        self._set_tab_status(tab, f"<b>Letzte Transformation</b> ({num_workers} Worker)")
+
+        # Kompilierung
+        compile_time_label = tab.findChild(QLabel, "compile_time_label")
+        if compile_time_label:
+            compile_time_label.setText(f"Kompilierungszeit: <b>{metrics.compilation_time_seconds:.3f} s</b>")
+
+        # Worker-Start
+        worker_count_label = tab.findChild(QLabel, "worker_count_label")
+        if worker_count_label:
+            worker_count_label.setText(f"Anzahl Worker: <b>{len(metrics.worker_start_times)}</b>")
+
+        total_start_time_label = tab.findChild(QLabel, "total_start_time_label")
+        if total_start_time_label:
+            total_start_time_label.setText(
+                f"Summe Startzeit: <b>{metrics.total_worker_start_time_seconds:.3f} s</b>"
+            )
+
+        avg_start_time_label = tab.findChild(QLabel, "avg_start_time_label")
+        if avg_start_time_label:
+            avg_start_time_label.setText(
+                f"Durchschnitt Startzeit: <b>{metrics.average_worker_start_time_seconds:.3f} s/Worker</b>"
+            )
+
+        # RAM
+        ram_before_label = tab.findChild(QLabel, "ram_before_label")
+        if ram_before_label:
+            if metrics.total_ram_before_mb > 0:
+                ram_before_label.setText(f"RAM vor Transformation: <b>{metrics.total_ram_before_mb:.1f} MB</b>")
+            else:
+                ram_before_label.setText("RAM vor Transformation: <i>Noch nicht gemessen</i>")
+
+        ram_before_avg_label = tab.findChild(QLabel, "ram_before_avg_label")
+        if ram_before_avg_label:
+            if metrics.average_ram_before_mb > 0:
+                ram_before_avg_label.setText(
+                    f"RAM vor Transformation (Durchschnitt/Worker): <b>{metrics.average_ram_before_mb:.1f} MB</b>"
+                )
+            else:
+                ram_before_avg_label.setText(
+                    "RAM vor Transformation (Durchschnitt/Worker): <i>Noch nicht gemessen</i>"
+                )
+
+        ram_after_label = tab.findChild(QLabel, "ram_after_label")
+        if ram_after_label:
+            if metrics.total_ram_after_mb > 0:
+                ram_after_label.setText(f"RAM nach Transformation: <b>{metrics.total_ram_after_mb:.1f} MB</b>")
+            else:
+                ram_after_label.setText("RAM nach Transformation: <i>Noch nicht gemessen</i>")
+
+        ram_after_avg_label = tab.findChild(QLabel, "ram_after_avg_label")
+        if ram_after_avg_label:
+            if metrics.average_ram_after_mb > 0:
+                ram_after_avg_label.setText(
+                    f"RAM nach Transformation (Durchschnitt/Worker): <b>{metrics.average_ram_after_mb:.1f} MB</b>"
+                )
+            else:
+                ram_after_avg_label.setText(
+                    "RAM nach Transformation (Durchschnitt/Worker): <i>Noch nicht gemessen</i>"
+                )
+
+        ram_delta_label = tab.findChild(QLabel, "ram_delta_label")
+        if ram_delta_label:
+            if metrics.total_ram_before_mb > 0 and metrics.total_ram_after_mb > 0:
+                delta = metrics.total_ram_after_mb - metrics.total_ram_before_mb
+                delta_percent = (delta / metrics.total_ram_before_mb * 100) if metrics.total_ram_before_mb > 0 else 0
+                ram_delta_label.setText(f"RAM-Zunahme: <b>{delta:.1f} MB ({delta_percent:+.1f}%)</b>")
+            else:
+                ram_delta_label.setText("RAM-Zunahme: <i>Noch nicht gemessen</i>")

src/ui/XmlToXslAssignDialog.py

@@ -13,14 +13,23 @@ logger = logging.getLogger(__name__)
 class XmlToXslAssignDialog(QDialog):
     """Dialog zur Zuordnung einer XML-Datei zu XSL-Knoten."""
 
-    def __init__(self, parent=None, xml_file_path=None, project_nodes=None):
+    def __init__(
+        self,
+        parent=None,
+        xml_file_path=None,
+        project_nodes=None,
+        preselected_xsl_ids: set | None = None,
+        edit_mode: bool = False,
+    ):
         """
         Initialisiert den Dialog.
-        
+
         Args:
             parent: Übergeordnetes Widget
             xml_file_path: Pfad zur XML-Datei
             project_nodes: Liste der Projekt-Knoten
+            preselected_xsl_ids: Set von XslFile-IDs (tuple), deren Checkbox initial angehakt sein soll
+            edit_mode: True = Bearbeiten-Modus (Zuordnungen ändern), False = Neu-Zuordnen
         """
         super().__init__(parent)
 
@@ -31,9 +40,23 @@ class XmlToXslAssignDialog(QDialog):
         # Parameter speichern
         self.xml_file_path = Path(xml_file_path) if xml_file_path else None
         self.project_nodes = project_nodes or []
+        self.preselected_xsl_ids: set = set(preselected_xsl_ids) if preselected_xsl_ids else set()
+        self.edit_mode = edit_mode
 
         # Dictionary zum Speichern der Checkbox-Referenzen
-        self.xsl_checkboxes = {}  # {xsl_node_id: checkbox}
+        self.xsl_checkboxes = {}  # {python_id(node): checkbox}
+        self.xsl_nodes = {}  # {python_id(node): XslFile}
+        # Initial ausgewählte XslFile-IDs (tuple), um Diff beim Accept zu berechnen
+        self._initial_selected_ids: set = set()
+
+        # Edit-Modus: UI anpassen
+        if self.edit_mode:
+            self.setWindowTitle("XML-Zuordnungen bearbeiten")
+            self.ui.infoLabel.setText(
+                "Passen Sie die Zuordnungen der XML-Datei an. Hinzufügen per Haken, "
+                "Entfernen durch Abhaken (zugehörige PDFs werden gelöscht):"
+            )
+            self.ui.alle_xml.setVisible(False)
 
         # Signale verbinden
         self.ui.selectAllButton.clicked.connect(self.select_all)
@@ -45,6 +68,10 @@ class XmlToXslAssignDialog(QDialog):
         # Daten laden
         self._load_data()
 
+        # Duplikat-Warnung nur im Edit-Modus (um bestehende Aufrufer nicht bei jeder XML zu stören)
+        if self.edit_mode:
+            self._warn_on_duplicate_xsl_ids()
+
     def _setup_tree(self):
         """Konfiguriert das TreeWidget."""
         # Spaltenbreiten setzen
@@ -110,13 +137,19 @@ class XmlToXslAssignDialog(QDialog):
             if isinstance(node, XslFile):
                 # Erstelle zentrierte Checkbox für XSL-Knoten
                 checkbox_widget, checkbox = self._create_centered_checkbox()
-                
+
+                # Vorauswahl setzen, wenn ID in preselected_xsl_ids
+                if node.id in self.preselected_xsl_ids:
+                    checkbox.setChecked(True)
+                    self._initial_selected_ids.add(node.id)
+
                 # Setze das Widget in Spalte 2
                 self.ui.xslNodesTree.setItemWidget(item, 2, checkbox_widget)
-                
+
-                # Speichere Checkbox-Referenz
+                # Speichere Checkbox- und Node-Referenzen (id() als Key, da XSL-IDs theoretisch doppelt sein können)
                 self.xsl_checkboxes[id(node)] = checkbox
-                
+                self.xsl_nodes[id(node)] = node
+
                 logger.debug(f"Checkbox für XSL-Knoten '{node.bez}' hinzugefügt")
             
             # Rekursiv für Kinder
@@ -141,6 +174,8 @@ class XmlToXslAssignDialog(QDialog):
         # TreeWidget leeren
         self.ui.xslNodesTree.clear()
         self.xsl_checkboxes.clear()
+        self.xsl_nodes.clear()
+        self._initial_selected_ids.clear()
 
         # Sortiere Root-Nodes alphabetisch nach ID
         sorted_nodes = sorted(self.project_nodes, key=lambda node: node.id)
@@ -295,16 +330,66 @@ class XmlToXslAssignDialog(QDialog):
         """
         return self.ui.alle_xml.isChecked()
 
+    def get_selection_diff(self) -> tuple[list, list]:
+        """
+        Gibt die Änderungen der Auswahl gegenüber der Vorauswahl zurück.
+        Nützlich im Edit-Modus, um nur die tatsächlich geänderten Zuordnungen zu verarbeiten.
+
+        Returns:
+            tuple[list[XslFile], list[XslFile]]: (added_nodes, removed_nodes)
+                - added_nodes: XslFile-Objekte, die neu angehakt wurden
+                - removed_nodes: XslFile-Objekte, deren Haken entfernt wurde
+        """
+        added_nodes = []
+        removed_nodes = []
+
+        for py_id, checkbox in self.xsl_checkboxes.items():
+            node = self.xsl_nodes.get(py_id)
+            if node is None:
+                continue
+
+            was_selected = node.id in self._initial_selected_ids
+            is_selected = checkbox.isChecked()
+
+            if is_selected and not was_selected:
+                added_nodes.append(node)
+            elif not is_selected and was_selected:
+                removed_nodes.append(node)
+
+        return added_nodes, removed_nodes
+
+    def _warn_on_duplicate_xsl_ids(self):
+        """
+        Zeigt eine Warnung, wenn im Projekt mehrere XslFile-Instanzen mit identischer ID existieren.
+        Die ID soll eindeutig sein - Duplikate weisen auf einen Datenfehler hin.
+        """
+        id_to_nodes: dict = {}
+        for py_id, node in self.xsl_nodes.items():
+            id_to_nodes.setdefault(node.id, []).append(node)
+
+        duplicates = {xsl_id: nodes for xsl_id, nodes in id_to_nodes.items() if len(nodes) > 1}
+        if not duplicates:
+            return
+
+        dup_lines = [f"  - ID {xsl_id}: {len(nodes)}× ({', '.join(n.bez for n in nodes)})" for xsl_id, nodes in duplicates.items()]
+        logger.warning(f"Doppelte XSL-IDs im Projekt gefunden:\n{chr(10).join(dup_lines)}")
+        QMessageBox.warning(
+            self,
+            "Doppelte XSL-IDs",
+            "Im Projekt existieren XSL-Knoten mit identischer ID. "
+            "Die IDs sollten eindeutig sein:\n\n" + "\n".join(dup_lines),
+        )
+
     def accept(self):
         """Überschreibt accept() um Validierung durchzuführen."""
-        selected_nodes = self.get_selected_xsl_nodes()
+        # Im Edit-Modus: 0 Auswahlen erlauben (bedeutet: XML überall entfernen)
-        
+        if self.edit_mode:
-        if not selected_nodes:
+            super().accept()
-            QMessageBox.warning(
-                self, 
-                "Warnung", 
-                "Bitte wählen Sie mindestens einen XSL-Knoten aus."
-            )
             return
-        
+
+        selected_nodes = self.get_selected_xsl_nodes()
+        if not selected_nodes:
+            QMessageBox.warning(self, "Warnung", "Bitte wählen Sie mindestens einen XSL-Knoten aus.")
+            return
+
         super().accept()

src/ui/XmlToXslAssignDialog.ui

@@ -42,6 +42,16 @@
    </item>
    <item>
     <widget class="QTreeWidget" name="xslNodesTree">
+     <property name="styleSheet">
+      <string notr="true"> QTreeWidget::item {
+	 padding: 4px 4px;
+ }
+
+QTreeWidget::item:selected {
+	background-color: palette(highlight);
+	color: palette(highlighted-text);
+}</string>
+     </property>
      <property name="headerHidden">
       <bool>false</bool>
      </property>

src/ui/XmlToXslAssignDialog_ui.py

@@ -3,7 +3,7 @@
 ################################################################################
 ## Form generated from reading UI file 'XmlToXslAssignDialog.ui'
 ##
-## Created by: Qt User Interface Compiler version 6.9.2
+## Created by: Qt User Interface Compiler version 6.10.1
 ##
 ## WARNING! All changes made in this file will be lost when recompiling UI file!
 ################################################################################
@@ -42,6 +42,14 @@ class Ui_XmlToXslAssignDialog(object):
 
         self.xslNodesTree = QTreeWidget(XmlToXslAssignDialog)
         self.xslNodesTree.setObjectName(u"xslNodesTree")
+        self.xslNodesTree.setStyleSheet(u" QTreeWidget::item {\n"
+"	 padding: 4px 4px;\n"
+" }\n"
+"\n"
+"QTreeWidget::item:selected {\n"
+"	background-color: palette(highlight);\n"
+"	color: palette(highlighted-text);\n"
+"}")
         self.xslNodesTree.setHeaderHidden(False)
         self.xslNodesTree.setColumnCount(3)
         self.xslNodesTree.header().setVisible(True)

src/ui/XslDependencyDialog.ui

@@ -0,0 +1,349 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>XslDependencyDialog</class>
+ <widget class="QDialog" name="XslDependencyDialog">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>1000</width>
+    <height>700</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>XSL-Abhängigkeitsgraph</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <layout class="QHBoxLayout" name="toolbarLayout">
+     <item>
+      <spacer name="toolbarSpacer">
+       <property name="orientation">
+        <enum>Qt::Orientation::Horizontal</enum>
+       </property>
+       <property name="sizeHint" stdset="0">
+        <size>
+         <width>40</width>
+         <height>20</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+     <item>
+      <widget class="QPushButton" name="settingsButton">
+       <property name="maximumSize">
+        <size>
+         <width>28</width>
+         <height>28</height>
+        </size>
+       </property>
+       <property name="toolTip">
+        <string>Einstellungen ein-/ausblenden</string>
+       </property>
+       <property name="text">
+        <string/>
+       </property>
+       <property name="icon">
+        <iconset theme="applications-system"/>
+       </property>
+       <property name="flat">
+        <bool>true</bool>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item>
+    <widget class="QSplitter" name="mainSplitter">
+     <property name="orientation">
+      <enum>Qt::Orientation::Horizontal</enum>
+     </property>
+     <property name="childrenCollapsible">
+      <bool>true</bool>
+     </property>
+     <widget class="QTabWidget" name="tabWidget">
+      <property name="currentIndex">
+       <number>0</number>
+      </property>
+      <widget class="QWidget" name="treeTab">
+       <attribute name="title">
+        <string>Baumansicht</string>
+       </attribute>
+       <layout class="QVBoxLayout" name="treeTabLayout">
+        <item>
+         <widget class="QSplitter" name="splitter">
+          <property name="orientation">
+           <enum>Qt::Orientation::Horizontal</enum>
+          </property>
+          <widget class="QWidget" name="leftWidget" native="true">
+           <layout class="QVBoxLayout" name="leftLayout">
+            <property name="leftMargin">
+             <number>0</number>
+            </property>
+            <property name="topMargin">
+             <number>0</number>
+            </property>
+            <property name="rightMargin">
+             <number>0</number>
+            </property>
+            <property name="bottomMargin">
+             <number>0</number>
+            </property>
+            <item>
+             <widget class="QLabel" name="leftLabel">
+              <property name="text">
+               <string>XSL-Dateien</string>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <widget class="QTreeWidget" name="fileTree">
+              <property name="alternatingRowColors">
+               <bool>true</bool>
+              </property>
+              <property name="selectionMode">
+               <enum>QAbstractItemView::SelectionMode::SingleSelection</enum>
+              </property>
+              <property name="rootIsDecorated">
+               <bool>true</bool>
+              </property>
+              <column>
+               <property name="text">
+                <string notr="true">1</string>
+               </property>
+              </column>
+             </widget>
+            </item>
+           </layout>
+          </widget>
+          <widget class="QWidget" name="rightWidget" native="true">
+           <layout class="QVBoxLayout" name="rightLayout">
+            <property name="leftMargin">
+             <number>0</number>
+            </property>
+            <property name="topMargin">
+             <number>0</number>
+            </property>
+            <property name="rightMargin">
+             <number>0</number>
+            </property>
+            <property name="bottomMargin">
+             <number>0</number>
+            </property>
+            <item>
+             <widget class="QLabel" name="rightLabel">
+              <property name="text">
+               <string>Abhängigkeiten</string>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <widget class="QTreeWidget" name="depTree">
+              <property name="alternatingRowColors">
+               <bool>true</bool>
+              </property>
+              <property name="rootIsDecorated">
+               <bool>true</bool>
+              </property>
+              <column>
+               <property name="text">
+                <string notr="true">1</string>
+               </property>
+              </column>
+             </widget>
+            </item>
+           </layout>
+          </widget>
+         </widget>
+        </item>
+       </layout>
+      </widget>
+      <widget class="QWidget" name="graphTab">
+       <attribute name="title">
+        <string>Netzwerkgraph</string>
+       </attribute>
+       <layout class="QVBoxLayout" name="graphTabLayout">
+        <property name="leftMargin">
+         <number>0</number>
+        </property>
+        <property name="topMargin">
+         <number>0</number>
+        </property>
+        <property name="rightMargin">
+         <number>0</number>
+        </property>
+        <property name="bottomMargin">
+         <number>0</number>
+        </property>
+        <item>
+         <widget class="QWidget" name="graphContainer" native="true">
+          <layout class="QVBoxLayout" name="graphContainerLayout">
+           <property name="leftMargin">
+            <number>0</number>
+           </property>
+           <property name="topMargin">
+            <number>0</number>
+           </property>
+           <property name="rightMargin">
+            <number>0</number>
+           </property>
+           <property name="bottomMargin">
+            <number>0</number>
+           </property>
+          </layout>
+         </widget>
+        </item>
+       </layout>
+      </widget>
+     </widget>
+     <widget class="QWidget" name="sidebarWidget" native="true">
+      <layout class="QVBoxLayout" name="sidebarLayout">
+       <item>
+        <widget class="QLabel" name="sidebarLabel">
+         <property name="font">
+          <font>
+           <bold>true</bold>
+          </font>
+         </property>
+         <property name="text">
+          <string>Einstellungen</string>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <widget class="QLabel" name="searchLabel">
+         <property name="text">
+          <string>Suche:</string>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <widget class="QLineEdit" name="searchEdit">
+         <property name="placeholderText">
+          <string>XSL-Datei filtern...</string>
+         </property>
+         <property name="clearButtonEnabled">
+          <bool>true</bool>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <widget class="QStackedWidget" name="settingsStack">
+         <property name="currentIndex">
+          <number>0</number>
+         </property>
+         <widget class="QWidget" name="treeSettingsPage">
+          <layout class="QVBoxLayout" name="treeSettingsLayout">
+           <item>
+            <widget class="QLabel" name="treeSettingsLabel">
+             <property name="text">
+              <string>Baumansicht-Einstellungen</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <spacer name="treeSettingsSpacer">
+             <property name="orientation">
+              <enum>Qt::Orientation::Vertical</enum>
+             </property>
+             <property name="sizeHint" stdset="0">
+              <size>
+               <width>20</width>
+               <height>40</height>
+              </size>
+             </property>
+            </spacer>
+           </item>
+          </layout>
+         </widget>
+         <widget class="QWidget" name="graphSettingsPage">
+          <layout class="QVBoxLayout" name="graphSettingsLayout">
+           <item>
+            <widget class="QLabel" name="graphSettingsLabel">
+             <property name="text">
+              <string>Graph-Einstellungen</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QCheckBox" name="graphFilterConnectedCheck">
+             <property name="toolTip">
+              <string>Entfernt alle XSL-Dateien aus dem Graph, die nicht zum Suchbegriff passen und nicht direkt oder indirekt mit passenden Dateien verbunden sind</string>
+             </property>
+             <property name="text">
+              <string>Nur von der Suche betroffene Dateien anzeigen</string>
+             </property>
+             <property name="checked">
+              <bool>true</bool>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <spacer name="graphSettingsSpacer">
+             <property name="orientation">
+              <enum>Qt::Orientation::Vertical</enum>
+             </property>
+             <property name="sizeHint" stdset="0">
+              <size>
+               <width>20</width>
+               <height>40</height>
+              </size>
+             </property>
+            </spacer>
+           </item>
+          </layout>
+         </widget>
+        </widget>
+       </item>
+      </layout>
+     </widget>
+    </widget>
+   </item>
+   <item>
+    <widget class="QLabel" name="statusLabel">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="text">
+      <string/>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="QDialogButtonBox" name="buttonBox">
+     <property name="orientation">
+      <enum>Qt::Orientation::Horizontal</enum>
+     </property>
+     <property name="standardButtons">
+      <set>QDialogButtonBox::StandardButton::Close</set>
+     </property>
+     <property name="centerButtons">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>rejected()</signal>
+   <receiver>XslDependencyDialog</receiver>
+   <slot>reject()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>500</x>
+     <y>678</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>500</x>
+     <y>350</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>

src/ui/XslDependencyDialog_ui.py

@@ -0,0 +1,240 @@
+# -*- coding: utf-8 -*-
+
+################################################################################
+## Form generated from reading UI file 'XslDependencyDialog.ui'
+##
+## Created by: Qt User Interface Compiler version 6.10.1
+##
+## WARNING! All changes made in this file will be lost when recompiling UI file!
+################################################################################
+
+from PySide6.QtCore import (QCoreApplication, QDate, QDateTime, QLocale,
+    QMetaObject, QObject, QPoint, QRect,
+    QSize, QTime, QUrl, Qt)
+from PySide6.QtGui import (QBrush, QColor, QConicalGradient, QCursor,
+    QFont, QFontDatabase, QGradient, QIcon,
+    QImage, QKeySequence, QLinearGradient, QPainter,
+    QPalette, QPixmap, QRadialGradient, QTransform)
+from PySide6.QtWidgets import (QAbstractButton, QAbstractItemView, QApplication, QCheckBox,
+    QDialog, QDialogButtonBox, QHBoxLayout, QHeaderView,
+    QLabel, QLineEdit, QPushButton, QSizePolicy,
+    QSpacerItem, QSplitter, QStackedWidget, QTabWidget,
+    QTreeWidget, QTreeWidgetItem, QVBoxLayout, QWidget)
+
+class Ui_XslDependencyDialog(object):
+    def setupUi(self, XslDependencyDialog):
+        if not XslDependencyDialog.objectName():
+            XslDependencyDialog.setObjectName(u"XslDependencyDialog")
+        XslDependencyDialog.resize(1000, 700)
+        self.verticalLayout = QVBoxLayout(XslDependencyDialog)
+        self.verticalLayout.setObjectName(u"verticalLayout")
+        self.toolbarLayout = QHBoxLayout()
+        self.toolbarLayout.setObjectName(u"toolbarLayout")
+        self.toolbarSpacer = QSpacerItem(40, 20, QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum)
+
+        self.toolbarLayout.addItem(self.toolbarSpacer)
+
+        self.settingsButton = QPushButton(XslDependencyDialog)
+        self.settingsButton.setObjectName(u"settingsButton")
+        self.settingsButton.setMaximumSize(QSize(28, 28))
+        icon = QIcon(QIcon.fromTheme(u"applications-system"))
+        self.settingsButton.setIcon(icon)
+        self.settingsButton.setFlat(True)
+
+        self.toolbarLayout.addWidget(self.settingsButton)
+
+
+        self.verticalLayout.addLayout(self.toolbarLayout)
+
+        self.mainSplitter = QSplitter(XslDependencyDialog)
+        self.mainSplitter.setObjectName(u"mainSplitter")
+        self.mainSplitter.setOrientation(Qt.Orientation.Horizontal)
+        self.mainSplitter.setChildrenCollapsible(True)
+        self.tabWidget = QTabWidget(self.mainSplitter)
+        self.tabWidget.setObjectName(u"tabWidget")
+        self.treeTab = QWidget()
+        self.treeTab.setObjectName(u"treeTab")
+        self.treeTabLayout = QVBoxLayout(self.treeTab)
+        self.treeTabLayout.setObjectName(u"treeTabLayout")
+        self.splitter = QSplitter(self.treeTab)
+        self.splitter.setObjectName(u"splitter")
+        self.splitter.setOrientation(Qt.Orientation.Horizontal)
+        self.leftWidget = QWidget(self.splitter)
+        self.leftWidget.setObjectName(u"leftWidget")
+        self.leftLayout = QVBoxLayout(self.leftWidget)
+        self.leftLayout.setObjectName(u"leftLayout")
+        self.leftLayout.setContentsMargins(0, 0, 0, 0)
+        self.leftLabel = QLabel(self.leftWidget)
+        self.leftLabel.setObjectName(u"leftLabel")
+
+        self.leftLayout.addWidget(self.leftLabel)
+
+        self.fileTree = QTreeWidget(self.leftWidget)
+        __qtreewidgetitem = QTreeWidgetItem()
+        __qtreewidgetitem.setText(0, u"1");
+        self.fileTree.setHeaderItem(__qtreewidgetitem)
+        self.fileTree.setObjectName(u"fileTree")
+        self.fileTree.setAlternatingRowColors(True)
+        self.fileTree.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)
+        self.fileTree.setRootIsDecorated(True)
+
+        self.leftLayout.addWidget(self.fileTree)
+
+        self.splitter.addWidget(self.leftWidget)
+        self.rightWidget = QWidget(self.splitter)
+        self.rightWidget.setObjectName(u"rightWidget")
+        self.rightLayout = QVBoxLayout(self.rightWidget)
+        self.rightLayout.setObjectName(u"rightLayout")
+        self.rightLayout.setContentsMargins(0, 0, 0, 0)
+        self.rightLabel = QLabel(self.rightWidget)
+        self.rightLabel.setObjectName(u"rightLabel")
+
+        self.rightLayout.addWidget(self.rightLabel)
+
+        self.depTree = QTreeWidget(self.rightWidget)
+        __qtreewidgetitem1 = QTreeWidgetItem()
+        __qtreewidgetitem1.setText(0, u"1");
+        self.depTree.setHeaderItem(__qtreewidgetitem1)
+        self.depTree.setObjectName(u"depTree")
+        self.depTree.setAlternatingRowColors(True)
+        self.depTree.setRootIsDecorated(True)
+
+        self.rightLayout.addWidget(self.depTree)
+
+        self.splitter.addWidget(self.rightWidget)
+
+        self.treeTabLayout.addWidget(self.splitter)
+
+        self.tabWidget.addTab(self.treeTab, "")
+        self.graphTab = QWidget()
+        self.graphTab.setObjectName(u"graphTab")
+        self.graphTabLayout = QVBoxLayout(self.graphTab)
+        self.graphTabLayout.setObjectName(u"graphTabLayout")
+        self.graphTabLayout.setContentsMargins(0, 0, 0, 0)
+        self.graphContainer = QWidget(self.graphTab)
+        self.graphContainer.setObjectName(u"graphContainer")
+        self.graphContainerLayout = QVBoxLayout(self.graphContainer)
+        self.graphContainerLayout.setObjectName(u"graphContainerLayout")
+        self.graphContainerLayout.setContentsMargins(0, 0, 0, 0)
+
+        self.graphTabLayout.addWidget(self.graphContainer)
+
+        self.tabWidget.addTab(self.graphTab, "")
+        self.mainSplitter.addWidget(self.tabWidget)
+        self.sidebarWidget = QWidget(self.mainSplitter)
+        self.sidebarWidget.setObjectName(u"sidebarWidget")
+        self.sidebarLayout = QVBoxLayout(self.sidebarWidget)
+        self.sidebarLayout.setObjectName(u"sidebarLayout")
+        self.sidebarLabel = QLabel(self.sidebarWidget)
+        self.sidebarLabel.setObjectName(u"sidebarLabel")
+        font = QFont()
+        font.setBold(True)
+        self.sidebarLabel.setFont(font)
+
+        self.sidebarLayout.addWidget(self.sidebarLabel)
+
+        self.searchLabel = QLabel(self.sidebarWidget)
+        self.searchLabel.setObjectName(u"searchLabel")
+
+        self.sidebarLayout.addWidget(self.searchLabel)
+
+        self.searchEdit = QLineEdit(self.sidebarWidget)
+        self.searchEdit.setObjectName(u"searchEdit")
+        self.searchEdit.setClearButtonEnabled(True)
+
+        self.sidebarLayout.addWidget(self.searchEdit)
+
+        self.settingsStack = QStackedWidget(self.sidebarWidget)
+        self.settingsStack.setObjectName(u"settingsStack")
+        self.treeSettingsPage = QWidget()
+        self.treeSettingsPage.setObjectName(u"treeSettingsPage")
+        self.treeSettingsLayout = QVBoxLayout(self.treeSettingsPage)
+        self.treeSettingsLayout.setObjectName(u"treeSettingsLayout")
+        self.treeSettingsLabel = QLabel(self.treeSettingsPage)
+        self.treeSettingsLabel.setObjectName(u"treeSettingsLabel")
+
+        self.treeSettingsLayout.addWidget(self.treeSettingsLabel)
+
+        self.treeSettingsSpacer = QSpacerItem(20, 40, QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Expanding)
+
+        self.treeSettingsLayout.addItem(self.treeSettingsSpacer)
+
+        self.settingsStack.addWidget(self.treeSettingsPage)
+        self.graphSettingsPage = QWidget()
+        self.graphSettingsPage.setObjectName(u"graphSettingsPage")
+        self.graphSettingsLayout = QVBoxLayout(self.graphSettingsPage)
+        self.graphSettingsLayout.setObjectName(u"graphSettingsLayout")
+        self.graphSettingsLabel = QLabel(self.graphSettingsPage)
+        self.graphSettingsLabel.setObjectName(u"graphSettingsLabel")
+
+        self.graphSettingsLayout.addWidget(self.graphSettingsLabel)
+
+        self.graphFilterConnectedCheck = QCheckBox(self.graphSettingsPage)
+        self.graphFilterConnectedCheck.setObjectName(u"graphFilterConnectedCheck")
+        self.graphFilterConnectedCheck.setChecked(True)
+
+        self.graphSettingsLayout.addWidget(self.graphFilterConnectedCheck)
+
+        self.graphSettingsSpacer = QSpacerItem(20, 40, QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Expanding)
+
+        self.graphSettingsLayout.addItem(self.graphSettingsSpacer)
+
+        self.settingsStack.addWidget(self.graphSettingsPage)
+
+        self.sidebarLayout.addWidget(self.settingsStack)
+
+        self.mainSplitter.addWidget(self.sidebarWidget)
+
+        self.verticalLayout.addWidget(self.mainSplitter)
+
+        self.statusLabel = QLabel(XslDependencyDialog)
+        self.statusLabel.setObjectName(u"statusLabel")
+        sizePolicy = QSizePolicy(QSizePolicy.Policy.Preferred, QSizePolicy.Policy.Maximum)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.statusLabel.sizePolicy().hasHeightForWidth())
+        self.statusLabel.setSizePolicy(sizePolicy)
+
+        self.verticalLayout.addWidget(self.statusLabel)
+
+        self.buttonBox = QDialogButtonBox(XslDependencyDialog)
+        self.buttonBox.setObjectName(u"buttonBox")
+        self.buttonBox.setOrientation(Qt.Orientation.Horizontal)
+        self.buttonBox.setStandardButtons(QDialogButtonBox.StandardButton.Close)
+        self.buttonBox.setCenterButtons(True)
+
+        self.verticalLayout.addWidget(self.buttonBox)
+
+
+        self.retranslateUi(XslDependencyDialog)
+        self.buttonBox.rejected.connect(XslDependencyDialog.reject)
+
+        self.tabWidget.setCurrentIndex(0)
+        self.settingsStack.setCurrentIndex(0)
+
+
+        QMetaObject.connectSlotsByName(XslDependencyDialog)
+    # setupUi
+
+    def retranslateUi(self, XslDependencyDialog):
+        XslDependencyDialog.setWindowTitle(QCoreApplication.translate("XslDependencyDialog", u"XSL-Abh\u00e4ngigkeitsgraph", None))
+#if QT_CONFIG(tooltip)
+        self.settingsButton.setToolTip(QCoreApplication.translate("XslDependencyDialog", u"Einstellungen ein-/ausblenden", None))
+#endif // QT_CONFIG(tooltip)
+        self.settingsButton.setText("")
+        self.leftLabel.setText(QCoreApplication.translate("XslDependencyDialog", u"XSL-Dateien", None))
+        self.rightLabel.setText(QCoreApplication.translate("XslDependencyDialog", u"Abh\u00e4ngigkeiten", None))
+        self.tabWidget.setTabText(self.tabWidget.indexOf(self.treeTab), QCoreApplication.translate("XslDependencyDialog", u"Baumansicht", None))
+        self.tabWidget.setTabText(self.tabWidget.indexOf(self.graphTab), QCoreApplication.translate("XslDependencyDialog", u"Netzwerkgraph", None))
+        self.sidebarLabel.setText(QCoreApplication.translate("XslDependencyDialog", u"Einstellungen", None))
+        self.searchLabel.setText(QCoreApplication.translate("XslDependencyDialog", u"Suche:", None))
+        self.searchEdit.setPlaceholderText(QCoreApplication.translate("XslDependencyDialog", u"XSL-Datei filtern...", None))
+        self.treeSettingsLabel.setText(QCoreApplication.translate("XslDependencyDialog", u"Baumansicht-Einstellungen", None))
+        self.graphSettingsLabel.setText(QCoreApplication.translate("XslDependencyDialog", u"Graph-Einstellungen", None))
+#if QT_CONFIG(tooltip)
+        self.graphFilterConnectedCheck.setToolTip(QCoreApplication.translate("XslDependencyDialog", u"Entfernt alle XSL-Dateien aus dem Graph, die nicht zum Suchbegriff passen und nicht direkt oder indirekt mit passenden Dateien verbunden sind", None))
+#endif // QT_CONFIG(tooltip)
+        self.graphFilterConnectedCheck.setText(QCoreApplication.translate("XslDependencyDialog", u"Nur von der Suche betroffene Dateien anzeigen", None))
+        self.statusLabel.setText("")
+    # retranslateUi
+

src/ui/XslFileEditDialog.py

@@ -1,161 +1,16 @@
-from PySide6.QtWidgets import QDialog, QTableWidgetItem, QMessageBox
-from PySide6.QtCore import Qt
-
 from ui.XslFileEditDialog_ui import Ui_XslFileEditDialog
+from ui.XsltParamsEditDialog import XsltParamsEditDialog
 
 
-class XslFileEditDialog(QDialog):
+class XslFileEditDialog(XsltParamsEditDialog):
     """Dialog zur Bearbeitung von XslFile-Objekten."""
 
-    def __init__(self, parent=None, node=None, parent_params=None):
+    def _create_ui(self):
-        """
+        return Ui_XslFileEditDialog()
-        Initialisiert den Dialog.
-        
-        Args:
-            parent: Übergeordnetes Widget
-            node: XslFile-Objekt zum Bearbeiten
-            parent_params: Dictionary mit Eltern-Parametern (nur anzeigen)
-        """
-        super().__init__(parent)
-
-        # UI einrichten
-        self.ui = Ui_XslFileEditDialog()
-        self.ui.setupUi(self)
-
-        # Node-Objekt speichern
-        self.node = node
-        self.parent_params = parent_params or {}
-
-        # Signale verbinden
-        self.ui.addParamButton.clicked.connect(self.add_parameter)
-        self.ui.removeParamButton.clicked.connect(self.remove_parameter)
-
-        # Tabellen konfigurieren
-        self._setup_tables()
-
-        # Daten laden
-        if self.node:
-            self._load_data()
-
-    def _setup_tables(self):
-        """Konfiguriert die Tabellen."""
-        # XSLT Parameter Tabelle
-        self.ui.xsltParamsTable.setColumnWidth(0, 200)
-        self.ui.xsltParamsTable.setColumnWidth(1, 300)
-        self.ui.xsltParamsTable.horizontalHeader().setStretchLastSection(True)
-
-        # Eltern-Parameter Tabelle
-        self.ui.parentParamsTable.setColumnWidth(0, 200)
-        self.ui.parentParamsTable.setColumnWidth(1, 300)
-        self.ui.parentParamsTable.horizontalHeader().setStretchLastSection(True)
 
     def _load_data(self):
-        """Lädt die Daten des XslFile in den Dialog."""
+        """Lädt die Daten des XslFile-Knotens in den Dialog."""
         if not self.node:
             return
-
+        self.ui.xslFileValueLabel.setText(str(self.node.xsl_file) if self.node.xsl_file else "")
-        # Bezeichnung setzen
+        super()._load_data()
-        self.ui.bezEdit.setText(str(self.node.bez) if self.node.bez else "")
-
-        # XSLT Parameter laden
-        self._load_xslt_params()
-
-        # Eltern-Parameter laden
-        self._load_parent_params()
-
-    def _load_xslt_params(self):
-        """Lädt die XSLT Parameter in die Tabelle."""
-        if not self.node or not self.node.xslt_params:
-            return
-
-        params = self.node.xslt_params
-        self.ui.xsltParamsTable.setRowCount(len(params))
-
-        for row, (key, value) in enumerate(params.items()):
-            # Parameter-Name
-            key_item = QTableWidgetItem(str(key))
-            self.ui.xsltParamsTable.setItem(row, 0, key_item)
-
-            # Parameter-Wert
-            value_item = QTableWidgetItem(str(value))
-            self.ui.xsltParamsTable.setItem(row, 1, value_item)
-
-    def _load_parent_params(self):
-        """Lädt die Eltern-Parameter in die Tabelle (nur anzeigen)."""
-        if not self.parent_params:
-            return
-
-        self.ui.parentParamsTable.setRowCount(len(self.parent_params))
-
-        for row, (key, value) in enumerate(self.parent_params.items()):
-            # Parameter-Name
-            key_item = QTableWidgetItem(str(key))
-            key_item.setFlags(key_item.flags() & ~Qt.ItemFlag.ItemIsEditable)
-            self.ui.parentParamsTable.setItem(row, 0, key_item)
-
-            # Parameter-Wert
-            value_item = QTableWidgetItem(str(value))
-            value_item.setFlags(value_item.flags() & ~Qt.ItemFlag.ItemIsEditable)
-            self.ui.parentParamsTable.setItem(row, 1, value_item)
-
-    def add_parameter(self):
-        """Fügt einen neuen Parameter hinzu."""
-        row_count = self.ui.xsltParamsTable.rowCount()
-        self.ui.xsltParamsTable.insertRow(row_count)
-
-        # Leere Items hinzufügen
-        key_item = QTableWidgetItem("")
-        value_item = QTableWidgetItem("")
-
-        self.ui.xsltParamsTable.setItem(row_count, 0, key_item)
-        self.ui.xsltParamsTable.setItem(row_count, 1, value_item)
-
-        # Fokus auf den neuen Parameter setzen
-        self.ui.xsltParamsTable.setCurrentCell(row_count, 0)
-
-    def remove_parameter(self):
-        """Entfernt den ausgewählten Parameter."""
-        current_row = self.ui.xsltParamsTable.currentRow()
-        if current_row >= 0:
-            self.ui.xsltParamsTable.removeRow(current_row)
-
-    def get_data(self):
-        """
-        Gibt die bearbeiteten Daten zurück.
-
-        Returns:
-            dict: Dictionary mit den bearbeiteten Daten oder None bei Fehler
-        """
-        # Bezeichnung prüfen
-        bez = self.ui.bezEdit.text().strip()
-        if not bez:
-            QMessageBox.warning(self, "Warnung", "Bitte geben Sie eine Bezeichnung ein.")
-            return None
-
-        # XSLT Parameter sammeln
-        xslt_params = {}
-        for row in range(self.ui.xsltParamsTable.rowCount()):
-            key_item = self.ui.xsltParamsTable.item(row, 0)
-            value_item = self.ui.xsltParamsTable.item(row, 1)
-
-            if key_item and value_item:
-                key = key_item.text().strip()
-                value = value_item.text().strip()
-
-                if key:  # Nur Parameter mit nicht-leerem Schlüssel hinzufügen
-                    xslt_params[key] = value
-
-        # CheckBox für Force-Transformation prüfen
-        force_transform = self.ui.alle_xml_transformieren.isChecked()
-
-        return {
-            "bez": bez,
-            "xslt_params": xslt_params,
-            "force_transform": force_transform
-        }
-
-    def accept(self):
-        """Überschreibt accept() um Datenvalidierung durchzuführen."""
-        data = self.get_data()
-        if data is not None:
-            super().accept()

src/ui/XslFileEditDialog.ui

@@ -7,7 +7,7 @@
     <x>0</x>
     <y>0</y>
     <width>865</width>
-    <height>400</height>
+    <height>403</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -23,13 +23,30 @@
       <enum>QLayout::SizeConstraint::SetMaximumSize</enum>
      </property>
      <item row="0" column="0">
+      <widget class="QLabel" name="xslFileLabel">
+       <property name="text">
+        <string>XSL-Datei:</string>
+       </property>
+      </widget>
+     </item>
+     <item row="0" column="1">
+      <widget class="QLabel" name="xslFileValueLabel">
+       <property name="text">
+        <string/>
+       </property>
+       <property name="textInteractionFlags">
+        <set>Qt::TextInteractionFlag::TextSelectableByMouse</set>
+       </property>
+      </widget>
+     </item>
+     <item row="1" column="0">
       <widget class="QLabel" name="bezLabel">
        <property name="text">
         <string>Bezeichnung:</string>
        </property>
       </widget>
      </item>
-     <item row="0" column="1">
+     <item row="1" column="1">
       <widget class="QLineEdit" name="bezEdit"/>
      </item>
     </layout>

src/ui/XslFileEditDialog_ui.py

@@ -33,15 +33,26 @@ class Ui_XslFileEditDialog(object):
         self.formLayout = QFormLayout()
         self.formLayout.setObjectName(u"formLayout")
         self.formLayout.setSizeConstraint(QLayout.SizeConstraint.SetMaximumSize)
+        self.xslFileLabel = QLabel(XslFileEditDialog)
+        self.xslFileLabel.setObjectName(u"xslFileLabel")
+
+        self.formLayout.setWidget(0, QFormLayout.ItemRole.LabelRole, self.xslFileLabel)
+
+        self.xslFileValueLabel = QLabel(XslFileEditDialog)
+        self.xslFileValueLabel.setObjectName(u"xslFileValueLabel")
+        self.xslFileValueLabel.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse)
+
+        self.formLayout.setWidget(0, QFormLayout.ItemRole.FieldRole, self.xslFileValueLabel)
+
         self.bezLabel = QLabel(XslFileEditDialog)
         self.bezLabel.setObjectName(u"bezLabel")
 
-        self.formLayout.setWidget(0, QFormLayout.ItemRole.LabelRole, self.bezLabel)
+        self.formLayout.setWidget(1, QFormLayout.ItemRole.LabelRole, self.bezLabel)
 
         self.bezEdit = QLineEdit(XslFileEditDialog)
         self.bezEdit.setObjectName(u"bezEdit")
 
-        self.formLayout.setWidget(0, QFormLayout.ItemRole.FieldRole, self.bezEdit)
+        self.formLayout.setWidget(1, QFormLayout.ItemRole.FieldRole, self.bezEdit)
 
 
         self.verticalLayout.addLayout(self.formLayout)
@@ -151,6 +162,8 @@ class Ui_XslFileEditDialog(object):
 
     def retranslateUi(self, XslFileEditDialog):
         XslFileEditDialog.setWindowTitle(QCoreApplication.translate("XslFileEditDialog", u"XSL-Datei bearbeiten", None))
+        self.xslFileLabel.setText(QCoreApplication.translate("XslFileEditDialog", u"XSL-Datei:", None))
+        self.xslFileValueLabel.setText("")
         self.bezLabel.setText(QCoreApplication.translate("XslFileEditDialog", u"Bezeichnung:", None))
         self.xsltParamsGroupBox.setTitle(QCoreApplication.translate("XslFileEditDialog", u"XSLT-Parameter", None))
         ___qtablewidgetitem = self.xsltParamsTable.horizontalHeaderItem(0)

src/ui/XsltParamsEditDialog.py

@@ -0,0 +1,120 @@
+from PySide6.QtWidgets import QDialog, QTableWidgetItem, QMessageBox
+from PySide6.QtCore import Qt
+
+
+class XsltParamsEditDialog(QDialog):
+    """Gemeinsame Basisklasse für Dialoge zur Bearbeitung von XSLT-Parametern."""
+
+    def __init__(self, parent=None, node=None, parent_params=None):
+        super().__init__(parent)
+
+        self.ui = self._create_ui()
+        self.ui.setupUi(self)
+
+        self.node = node
+        self.parent_params = parent_params or {}
+
+        self.ui.addParamButton.clicked.connect(self.add_parameter)
+        self.ui.removeParamButton.clicked.connect(self.remove_parameter)
+
+        self._setup_tables()
+
+        if self.node:
+            self._load_data()
+
+    def _create_ui(self):
+        """Gibt eine Instanz der konkreten UI-Klasse zurück. Muss überschrieben werden."""
+        raise NotImplementedError
+
+    def _setup_tables(self):
+        """Konfiguriert die Tabellen."""
+        self.ui.xsltParamsTable.setColumnWidth(0, 200)
+        self.ui.xsltParamsTable.setColumnWidth(1, 300)
+        self.ui.xsltParamsTable.horizontalHeader().setStretchLastSection(True)
+
+        self.ui.parentParamsTable.setColumnWidth(0, 200)
+        self.ui.parentParamsTable.setColumnWidth(1, 300)
+        self.ui.parentParamsTable.horizontalHeader().setStretchLastSection(True)
+
+    def _load_data(self):
+        """Lädt die Daten des Knotens in den Dialog."""
+        if not self.node:
+            return
+
+        self.ui.bezEdit.setText(str(self.node.bez) if self.node.bez else "")
+        self._load_xslt_params()
+        self._load_parent_params()
+
+    def _load_xslt_params(self):
+        """Lädt die XSLT-Parameter in die Tabelle."""
+        if not self.node or not self.node.xslt_params:
+            return
+
+        params = self.node.xslt_params
+        self.ui.xsltParamsTable.setRowCount(len(params))
+
+        for row, (key, value) in enumerate(params.items()):
+            self.ui.xsltParamsTable.setItem(row, 0, QTableWidgetItem(str(key)))
+            self.ui.xsltParamsTable.setItem(row, 1, QTableWidgetItem(str(value)))
+
+    def _load_parent_params(self):
+        """Lädt die Eltern-Parameter in die Tabelle (nur anzeigen)."""
+        if not self.parent_params:
+            return
+
+        self.ui.parentParamsTable.setRowCount(len(self.parent_params))
+
+        for row, (key, value) in enumerate(self.parent_params.items()):
+            key_item = QTableWidgetItem(str(key))
+            key_item.setFlags(key_item.flags() & ~Qt.ItemFlag.ItemIsEditable)
+            self.ui.parentParamsTable.setItem(row, 0, key_item)
+
+            value_item = QTableWidgetItem(str(value))
+            value_item.setFlags(value_item.flags() & ~Qt.ItemFlag.ItemIsEditable)
+            self.ui.parentParamsTable.setItem(row, 1, value_item)
+
+    def add_parameter(self):
+        """Fügt einen neuen Parameter hinzu."""
+        row_count = self.ui.xsltParamsTable.rowCount()
+        self.ui.xsltParamsTable.insertRow(row_count)
+        self.ui.xsltParamsTable.setItem(row_count, 0, QTableWidgetItem(""))
+        self.ui.xsltParamsTable.setItem(row_count, 1, QTableWidgetItem(""))
+        self.ui.xsltParamsTable.setCurrentCell(row_count, 0)
+
+    def remove_parameter(self):
+        """Entfernt den ausgewählten Parameter."""
+        current_row = self.ui.xsltParamsTable.currentRow()
+        if current_row >= 0:
+            self.ui.xsltParamsTable.removeRow(current_row)
+
+    def get_data(self):
+        """
+        Gibt die bearbeiteten Daten zurück.
+
+        Returns:
+            dict mit 'bez', 'xslt_params', 'force_transform', oder None bei Validierungsfehler
+        """
+        bez = self.ui.bezEdit.text().strip()
+        if not bez:
+            QMessageBox.warning(self, "Warnung", "Bitte geben Sie eine Bezeichnung ein.")
+            return None
+
+        xslt_params = {}
+        for row in range(self.ui.xsltParamsTable.rowCount()):
+            key_item = self.ui.xsltParamsTable.item(row, 0)
+            value_item = self.ui.xsltParamsTable.item(row, 1)
+            if key_item and value_item:
+                key = key_item.text().strip()
+                if key:
+                    xslt_params[key] = value_item.text().strip()
+
+        return {
+            "bez": bez,
+            "xslt_params": xslt_params,
+            "force_transform": self.ui.alle_xml_transformieren.isChecked(),
+        }
+
+    def accept(self):
+        """Überschreibt accept() um Datenvalidierung durchzuführen."""
+        if self.get_data() is not None:
+            super().accept()

src/ui/mixins/__init__.py

@@ -0,0 +1,24 @@
+"""
+Mixins für das MainWindow.
+
+Dieses Paket enthält Mixins, die Funktionalität in separate Module auslagern,
+um die MainWindow-Klasse übersichtlicher zu gestalten.
+"""
+
+from ui.mixins.tree_manager import TreeManagerMixin
+from ui.mixins.pdf_viewer import PdfViewerMixin
+from ui.mixins.worker_pool import WorkerPoolMixin
+from ui.mixins.database import DatabaseMixin
+from ui.mixins.drag_drop import DragDropMixin
+from ui.mixins.hash_calculation import HashCalculationMixin
+from ui.mixins.transformation import TransformationMixin
+
+__all__ = [
+    "TreeManagerMixin",
+    "PdfViewerMixin",
+    "WorkerPoolMixin",
+    "DatabaseMixin",
+    "DragDropMixin",
+    "HashCalculationMixin",
+    "TransformationMixin",
+]

src/ui/mixins/database.py

@@ -0,0 +1,436 @@
+"""
+DatabaseMixin - Mixin für Datenbank-Operationen.
+
+Dieses Mixin enthält alle Methoden zur PostgreSQL-Datenbankanbindung
+und Datenverarbeitung für das MainWindow.
+"""
+
+import sys
+import time
+import logging
+from pathlib import Path
+
+from PySide6.QtCore import QThread, Signal, Qt
+from PySide6.QtWidgets import QMessageBox, QProgressDialog
+
+from conf import app_settings, TreeNode, XslFile
+from obsolete_detector import (
+    collect_unused_xml_files,
+    extract_db_xsl_ids,
+    find_obsolete_xsl_entries,
+    remove_empty_tree_nodes,
+)
+from ui.ObsoleteEntriesDialog import ObsoleteEntriesDialog
+
+logger = logging.getLogger(__name__)
+
+
+class DatabaseQueryThread(QThread):
+    """Thread für asynchrone Datenbankabfragen."""
+
+    query_completed = Signal(object)  # pl.DataFrame
+    query_failed = Signal(str)  # Fehlermeldung
+
+    def __init__(self, sql_query, connection_string):
+        super().__init__()
+        self.sql_query = sql_query
+        self.connection_string = connection_string
+
+    def run(self):
+        import polars as pl
+
+        try:
+            df = pl.read_database_uri(self.sql_query, self.connection_string, engine="connectorx").sort(
+                ["reporttyp_bez", "report_bez", "repfile_bez"]
+            )
+            self.query_completed.emit(df)
+        except Exception as e:
+            self.query_failed.emit(str(e))
+
+
+class DatabaseMixin:
+    """
+    Mixin für Datenbank-Operationen.
+
+    Dieses Mixin wird von MainWindow verwendet und erwartet folgende Attribute:
+    - self.project: Das aktuelle Projekt
+    - self.pdf_project: Die Projekt-Daten (ProjectData)
+    - self._load_nodes_to_tree(): Methode zum Laden der Nodes in den Tree
+    - self._save_project_settings(): Methode zum Speichern der Projekt-Einstellungen
+    """
+
+    def on_load_from_fn2_clicked(self):
+        """
+        Wird ausgeführt, wenn der Button "lade aus FN2" geklickt wird.
+        Startet SQL-Abfrage asynchron mit Fortschrittsdialog.
+        """
+        logger.debug("Button 'lade aus FN2' wurde geklickt!")
+
+        try:
+            # Prüfe ob ein Projekt geladen ist
+            if not hasattr(self, "project") or not self.project:
+                QMessageBox.warning(self, "Warnung", "Kein Projekt geladen. Bitte öffnen Sie zuerst ein Projekt.")
+                return
+
+            # Hole die PostgreSQL-Datenbank-Konfiguration
+            db_config = self._get_database_config(self.project.postgre_sql_db_id)
+            if not db_config:
+                QMessageBox.warning(self, "Warnung", "PostgreSQL-Datenbank-Konfiguration nicht gefunden.")
+                return
+
+            # SQL-Abfrage und Connection-String vorbereiten
+            sql_query, connection_string = self._prepare_sql_query(db_config)
+            if sql_query is None:
+                return  # Fehler bereits angezeigt
+
+            # Fortschrittsdialog erstellen
+            self._db_progress = QProgressDialog("Verbinde mit Datenbank...", "Abbrechen", 0, 0, self)
+            self._db_progress.setWindowTitle("Datenbank-Abfrage")
+            self._db_progress.setWindowModality(Qt.WindowModal)
+            self._db_progress.setMinimumDuration(0)
+
+            # Query-Thread erstellen und starten
+            self._db_query_thread = DatabaseQueryThread(sql_query, connection_string)
+            self._db_query_thread.query_completed.connect(self._on_db_query_completed)
+            self._db_query_thread.query_failed.connect(self._on_db_query_failed)
+            self._db_query_thread.finished.connect(self._cleanup_db_query)
+            self._db_progress.canceled.connect(self._on_db_query_canceled)
+            self._db_query_thread.start()
+
+        except Exception as e:
+            logger.error(f"Fehler beim Laden aus FN2: {e}")
+            QMessageBox.critical(self, "Fehler", f"Fehler beim Laden aus FN2:\n{str(e)}")
+
+    def _on_db_query_completed(self, df):
+        """Wird aufgerufen, wenn die Datenbankabfrage erfolgreich war."""
+        # Ignoriere Ergebnis, falls der Benutzer abgebrochen hat
+        if hasattr(self, "_db_progress") and self._db_progress.wasCanceled():
+            return
+
+        try:
+            new_nodes = self._process_sql_data(df)
+            self._merge_nodes_with_existing(new_nodes)
+            self._check_and_remove_obsolete_entries(new_nodes)
+            self._save_project_settings()
+            self._load_nodes_to_tree()
+        except Exception as e:
+            logger.error(f"Fehler beim Verarbeiten der DB-Daten: {e}")
+            QMessageBox.critical(self, "Fehler", f"Fehler beim Verarbeiten der Daten:\n{str(e)}")
+
+    def _on_db_query_failed(self, error_msg):
+        """Wird aufgerufen, wenn die Datenbankabfrage fehlgeschlagen ist."""
+        if hasattr(self, "_db_progress") and self._db_progress.wasCanceled():
+            return
+
+        error = f"Fehler beim Ausführen der SQL-Abfrage: {error_msg}"
+        logger.error(error)
+        QMessageBox.critical(self, "Fehler", error)
+
+    def _on_db_query_canceled(self):
+        """Wird aufgerufen, wenn der Benutzer die Abfrage abbricht."""
+        logger.info("Datenbankabfrage vom Benutzer abgebrochen")
+
+    def _cleanup_db_query(self):
+        """Räumt nach der Datenbankabfrage auf."""
+        if hasattr(self, "_db_progress"):
+            self._db_progress.canceled.disconnect(self._on_db_query_canceled)
+            self._db_progress.close()
+            self._db_progress.deleteLater()
+            del self._db_progress
+        if hasattr(self, "_db_query_thread"):
+            self._db_query_thread.deleteLater()
+            del self._db_query_thread
+
+    def _get_database_config(self, db_id):
+        """
+        Holt die Datenbank-Konfiguration anhand der ID.
+
+        Args:
+            db_id: ID der PostgreSQL-Datenbank
+
+        Returns:
+            PostgreSqlDb|None: Die Datenbank-Konfiguration oder None
+        """
+        for db in app_settings.postgresql_dbs:
+            if db.id == db_id:
+                return db
+        return None
+
+    def _prepare_sql_query(self, db_config):
+        """
+        Bereitet SQL-Abfrage und Connection-String vor.
+
+        Args:
+            db_config: PostgreSQL-Datenbank-Konfiguration
+
+        Returns:
+            tuple[str, str]|tuple[None, None]: (sql_query, connection_string) oder (None, None) bei Fehler
+        """
+        try:
+            # PyInstaller entpackt Ressourcen nach sys._MEIPASS;
+            # im Entwicklungsmodus liegt die Datei relativ zum Repo-Root
+            if hasattr(sys, "_MEIPASS"):
+                sql_file_path = Path(sys._MEIPASS) / "res" / "data.sql"  # type: ignore[attr-defined]
+            else:
+                sql_file_path = Path(__file__).parents[3] / "src" / "res" / "data.sql"
+            if not sql_file_path.exists():
+                QMessageBox.critical(self, "Fehler", f"SQL-Datei nicht gefunden: {sql_file_path}")
+                return None, None
+
+            with open(sql_file_path, "r", encoding="utf-8") as f:
+                sql_query = f.read()
+
+            logger.debug(f"SQL-Abfrage geladen: {len(sql_query)} Zeichen")
+
+            connection_string = (
+                "postgresql://"
+                f"{db_config.username}:"
+                f"{db_config.password}@"
+                f"{db_config.host}:"
+                f"{db_config.port}/"
+                f"{db_config.database}?"
+                f"sslmode={db_config.ssl_mode.value}"
+                f"&connect_timeout={db_config.timeout}"
+            )
+
+            logger.info(f"Verbinde zu PostgreSQL: {db_config.host}:{db_config.port}/{db_config.database}")
+
+            return sql_query, connection_string
+        except Exception as e:
+            error_msg = f"Fehler beim Vorbereiten der SQL-Abfrage: {str(e)}"
+            logger.error(error_msg)
+            QMessageBox.critical(self, "Fehler", error_msg)
+            return None, None
+
+    def _process_sql_data(self, df):
+        """
+        Verarbeitet die SQL-Daten wie in readCsv.py und erstellt Node-Struktur.
+
+        Args:
+            df: Polars DataFrame mit den SQL-Ergebnissen
+
+        Returns:
+            list[TreeNode]: Liste der erstellten Root-Nodes
+        """
+        import polars as pl
+
+        try:
+            start_time = time.time()
+
+            # Gruppiere die Daten wie in readCsv.py
+            ebene_1 = df.group_by(["reporttyp", "reporttyp_bez"]).len()
+            ebene_2 = df.group_by(["reporttyp", "report", "report_bez"]).len()
+            ebene_3 = df.group_by(["reporttyp", "report", "repfile", "repfile_bez", "xsl_datei"]).len()
+
+            group_time = time.time() - start_time
+            logger.debug(f"Performance: Gruppierung in {group_time:.3f}s")
+
+            new_nodes = []
+
+            start_time = time.time()
+
+            # Erstelle Node-Struktur wie in readCsv.py
+            for r1 in ebene_1.rows(named=True):
+                tn_1 = TreeNode(id=(r1["reporttyp"],), bez=r1["reporttyp_bez"], children=[])
+                r1_children = ebene_2.filter(pl.col("reporttyp") == r1["reporttyp"])
+
+                for r2 in r1_children.rows(named=True):
+                    tn_2 = TreeNode(id=(r2["reporttyp"], r2["report"]), bez=r2["report_bez"], children=[])
+                    r2_children = ebene_3.filter(
+                        (pl.col("reporttyp") == r1["reporttyp"]) & (pl.col("report") == r2["report"])
+                    )
+
+                    for r3 in r2_children.rows(named=True):
+                        x = XslFile(
+                            id=(r3["reporttyp"], r3["report"], r3["repfile"]),
+                            bez=r3["repfile_bez"],
+                            xsl_file=Path(r3["xsl_datei"]),
+                            xmls=[],
+                        )
+
+                        tn_2.children.append(x)
+                    tn_1.children.append(tn_2)
+                new_nodes.append(tn_1)
+
+            nodes_time = time.time() - start_time
+            logger.debug(f"Performance: Node-Erstellung in {nodes_time:.3f}s")
+            logger.info(f"Erstellt: {len(new_nodes)} Root-Nodes")
+
+            return new_nodes
+
+        except Exception as e:
+            logger.error(f"Fehler beim Verarbeiten der SQL-Daten: {e}")
+            raise
+
+    def _merge_nodes_with_existing(self, new_nodes):
+        """
+        Merged neue Nodes mit vorhandenen Nodes basierend auf IDs.
+        Überschreibt nur einzelne Eigenschaften, nicht ganze Nodes.
+
+        Args:
+            new_nodes: Liste der neuen Nodes
+        """
+        try:
+            logger.info("Merge neue Nodes mit vorhandenen...")
+
+            # Erstelle ein Dictionary der neuen Nodes für schnellen Zugriff
+            new_nodes_dict = {}
+            self._build_nodes_dict(new_nodes, new_nodes_dict)
+
+            logger.debug(f"Neue Nodes Dictionary erstellt: {len(new_nodes_dict)} Einträge")
+
+            # Merge mit vorhandenen Nodes
+            if self.pdf_project and self.pdf_project.nodes:
+                self._merge_nodes_recursive(self.pdf_project.nodes, new_nodes_dict)
+
+            # Füge komplett neue Root-Nodes hinzu
+            if self.pdf_project and self.pdf_project.nodes:
+                existing_root_ids = {node.id for node in self.pdf_project.nodes}
+                for new_node in new_nodes:
+                    if new_node.id not in existing_root_ids:
+                        self.pdf_project.nodes.append(new_node)
+                        logger.info(f"Neue Root-Node hinzugefügt: {new_node.bez}")
+            elif self.pdf_project:
+                # Wenn keine Nodes vorhanden sind, füge alle neuen Nodes hinzu
+                self.pdf_project.nodes = new_nodes
+                logger.info(f"Alle {len(new_nodes)} Root-Nodes hinzugefügt (keine vorhandenen Nodes)")
+
+            logger.info("Merge abgeschlossen")
+
+        except Exception as e:
+            logger.error(f"Fehler beim Mergen der Nodes: {e}")
+            raise
+
+    def _build_nodes_dict(self, nodes, nodes_dict):
+        """
+        Erstellt rekursiv ein Dictionary aller Nodes für schnellen ID-basierten Zugriff.
+
+        Args:
+            nodes: Liste der Nodes
+            nodes_dict: Dictionary zum Füllen
+        """
+        for node in nodes:
+            nodes_dict[node.id] = node
+
+            if isinstance(node, TreeNode) and node.children:
+                self._build_nodes_dict(node.children, nodes_dict)
+
+    def _merge_nodes_recursive(self, existing_nodes, new_nodes_dict):
+        """
+        Merged rekursiv vorhandene Nodes mit neuen Nodes.
+
+        Args:
+            existing_nodes: Liste der vorhandenen Nodes
+            new_nodes_dict: Dictionary der neuen Nodes
+        """
+        for existing_node in existing_nodes:
+            if existing_node.id in new_nodes_dict:
+                new_node = new_nodes_dict[existing_node.id]
+
+                # Aktualisiere nur die Bezeichnung, falls sie sich geändert hat
+                if existing_node.bez != new_node.bez:
+                    logger.info(
+                        f"Aktualisiere Bezeichnung für Node {existing_node.id}: '{existing_node.bez}' -> '{new_node.bez}'"
+                    )
+                    existing_node.bez = new_node.bez
+
+                # Für XslFile: Aktualisiere xsl_file Pfad
+                if isinstance(existing_node, XslFile) and isinstance(new_node, XslFile):
+                    if existing_node.xsl_file != new_node.xsl_file:
+                        logger.info(
+                            f"Aktualisiere XSL-Datei für Node {existing_node.id}: '{existing_node.xsl_file}' -> '{new_node.xsl_file}'"
+                        )
+                        existing_node.xsl_file = new_node.xsl_file
+
+            # Rekursiv für Knoten (nur bei TreeNode)
+            if isinstance(existing_node, TreeNode) and existing_node.children:
+                self._merge_nodes_recursive(existing_node.children, new_nodes_dict)
+
+                # Füge neue Knoten hinzu, die noch nicht existieren
+                if existing_node.id in new_nodes_dict:
+                    new_node = new_nodes_dict[existing_node.id]
+                    if isinstance(new_node, TreeNode) and new_node.children:
+                        existing_child_ids = {child.id for child in existing_node.children}
+                        for new_child in new_node.children:
+                            if new_child.id not in existing_child_ids:
+                                existing_node.children.append(new_child)
+                                logger.info(f"Neues Kind hinzugefügt zu Node {existing_node.id}: {new_child.bez}")
+
+    def _check_and_remove_obsolete_entries(self, new_nodes: list[TreeNode]) -> None:
+        """
+        Prüft nach dem Merge ob XslFile-Einträge nicht mehr in der DB vorhanden sind.
+        Zeigt einen Bestätigungsdialog und entfernt veraltete Einträge inklusive
+        PDF- und optionaler XML-Bereinigung.
+
+        Args:
+            new_nodes: Frisch aus der DB geladene Nodes (Ergebnis von _process_sql_data)
+        """
+        if not self.pdf_project or not self.pdf_project.nodes:
+            return
+
+        try:
+            db_xsl_ids = extract_db_xsl_ids(new_nodes)
+            obsolete_groups = find_obsolete_xsl_entries(self.pdf_project.nodes, db_xsl_ids)
+
+            if not obsolete_groups:
+                logger.debug("Keine veralteten Einträge gefunden")
+                return
+
+            total_count = sum(len(g.xsl_entries) for g in obsolete_groups)
+            logger.info(f"{total_count} veraltete XSL-Einträge gefunden")
+
+            dialog = ObsoleteEntriesDialog(self, obsolete_groups)
+            if dialog.exec() != ObsoleteEntriesDialog.DialogCode.Accepted:
+                logger.info("Entfernung veralteter Einträge vom Benutzer abgebrochen")
+                return
+
+            delete_xml = dialog.delete_xml_files()
+
+            # Phase 1: XslFiles aus dem Datenmodell entfernen
+            # WICHTIG: Zuerst entfernen, damit _is_xml_xsl_combination_used_elsewhere
+            # und _is_xml_file_used_elsewhere die gelöschten Einträge nicht mehr sehen
+            # (gleiche Reihenfolge wie in _delete_tree_node)
+            for group in obsolete_groups:
+                parent = group.parent_node
+                obsolete_xsl_ids = {id(entry.xsl_file) for entry in group.xsl_entries}
+                parent.children = [c for c in parent.children if id(c) not in obsolete_xsl_ids]
+                logger.info(f"{len(group.xsl_entries)} XSL-Einträge aus '{' > '.join(group.node_path)}' entfernt")
+
+            # Phase 2: PDF-Bereinigung für alle entfernten XslFiles
+            total_deleted_pdfs = 0
+            for group in obsolete_groups:
+                for entry in group.xsl_entries:
+                    xsl_id = entry.xsl_file.id
+                    for xml_file_obj in entry.xsl_file.xmls:
+                        is_used = self._is_xml_xsl_combination_used_elsewhere(xml_file_obj.xml, xsl_id, entry.xsl_file)
+                        if not is_used:
+                            total_deleted_pdfs += self._delete_pdf_files_for_xml_xsl_combination(
+                                xml_file_obj.xml, xsl_id
+                            )
+
+            if total_deleted_pdfs > 0:
+                logger.info(f"{total_deleted_pdfs} PDF-Datei(en) bereinigt")
+
+            # Phase 3: Leere TreeNodes bereinigen (bottom-up durch rekursiven Aufruf)
+            self.pdf_project.nodes = remove_empty_tree_nodes(self.pdf_project.nodes)
+
+            # Phase 4: Optionale physische XML-Löschung
+            if delete_xml:
+                unused_xml = collect_unused_xml_files(
+                    obsolete_groups,
+                    Path(self.project.project_dir),
+                    self._is_xml_file_used_elsewhere,
+                )
+                for _rel, xml_abs in unused_xml:
+                    try:
+                        xml_abs.unlink()
+                        logger.info(f"Physische XML-Datei gelöscht: {xml_abs}")
+                    except Exception as e:
+                        logger.warning(f"Konnte XML-Datei nicht löschen: {xml_abs} - {e}")
+
+            logger.info(f"Bereinigung abgeschlossen: {total_count} veraltete Einträge entfernt")
+
+        except Exception as e:
+            error_msg = f"Fehler beim Entfernen veralteter Einträge: {str(e)}"
+            logger.exception(error_msg)
+            QMessageBox.critical(self, "Fehler", error_msg)

src/ui/mixins/drag_drop.py

@@ -0,0 +1,346 @@
+"""
+DragDropMixin - Mixin für Drag-and-Drop-Funktionalität.
+
+Dieses Mixin enthält alle Methoden zur Verarbeitung von Drag-and-Drop-Operationen
+für das MainWindow.
+"""
+
+import logging
+from pathlib import Path
+
+from PySide6.QtGui import QDragEnterEvent, QDropEvent
+from PySide6.QtWidgets import QMessageBox, QProgressBar
+
+from ui.XmlToXslAssignDialog import XmlToXslAssignDialog
+from ui.threads import XmlBatchProcessingThread
+
+logger = logging.getLogger(__name__)
+
+
+class DragDropMixin:
+    """
+    Mixin für Drag-and-Drop-Funktionalität.
+
+    Dieses Mixin wird von MainWindow verwendet und erwartet folgende Attribute:
+    - self.ui: Das UI-Objekt mit treeWidget
+    - self.project: Das aktuelle Projekt
+    - self.pdf_project: Die Projekt-Daten (ProjectData)
+    - self.batch_processing_thread: Thread für Batch-Verarbeitung
+    - self.batch_progress_bar: QProgressBar für Batch-Fortschritt
+    - self._save_project_settings(): Methode zum Speichern der Projekt-Einstellungen
+    - self._load_nodes_to_tree(): Methode zum Laden der Nodes in den Tree
+    """
+
+    def _setup_drag_drop(self):
+        """Aktiviert Drag&Drop für das TreeWidget."""
+        try:
+            # Aktiviere Drag&Drop für das TreeWidget
+            self.ui.treeWidget.setAcceptDrops(True)
+            self.ui.treeWidget.setDragDropMode(self.ui.treeWidget.DragDropMode.DropOnly)
+
+            # Überschreibe die Drag&Drop-Events
+            self.ui.treeWidget.dragEnterEvent = self.tree_drag_enter_event
+            self.ui.treeWidget.dragMoveEvent = self.tree_drag_move_event
+            self.ui.treeWidget.dropEvent = self.tree_drop_event
+
+            logger.debug("Drag&Drop für TreeWidget aktiviert")
+
+        except Exception as e:
+            logger.error(f"Fehler beim Aktivieren von Drag&Drop: {e}")
+
+    def tree_drag_enter_event(self, event: QDragEnterEvent):
+        """
+        Wird ausgeführt, wenn ein Drag-Vorgang über das TreeWidget beginnt.
+
+        Args:
+            event: Das Drag-Enter-Event
+        """
+        try:
+            # Prüfe ob URLs (Dateien) gedraggt werden
+            if event.mimeData().hasUrls():
+                urls = event.mimeData().urls()
+
+                # Prüfe ob mindestens eine XML-Datei dabei ist
+                xml_files = [url.toLocalFile() for url in urls if url.toLocalFile().lower().endswith(".xml")]
+
+                if xml_files:
+                    event.acceptProposedAction()
+                    logger.debug(f"Drag-Enter akzeptiert: {len(xml_files)} XML-Dateien")
+                else:
+                    event.ignore()
+                    logger.debug("Drag-Enter ignoriert: Keine XML-Dateien")
+            else:
+                event.ignore()
+                logger.debug("Drag-Enter ignoriert: Keine URLs")
+
+        except Exception as e:
+            logger.error(f"Fehler in tree_drag_enter_event: {e}")
+            event.ignore()
+
+    def tree_drag_move_event(self, event):
+        """
+        Wird ausgeführt, wenn ein Drag-Vorgang über das TreeWidget bewegt wird.
+
+        Args:
+            event: Das Drag-Move-Event
+        """
+        try:
+            # Prüfe ob URLs (Dateien) gedraggt werden
+            if event.mimeData().hasUrls():
+                urls = event.mimeData().urls()
+
+                # Prüfe ob mindestens eine XML-Datei dabei ist
+                xml_files = [url.toLocalFile() for url in urls if url.toLocalFile().lower().endswith(".xml")]
+
+                if xml_files:
+                    event.acceptProposedAction()
+                else:
+                    event.ignore()
+            else:
+                event.ignore()
+
+        except Exception as e:
+            logger.error(f"Fehler in tree_drag_move_event: {e}")
+            event.ignore()
+
+    def tree_drop_event(self, event: QDropEvent):
+        """
+        Wird ausgeführt, wenn Dateien auf das TreeWidget gedroppt werden.
+
+        Args:
+            event: Das Drop-Event
+        """
+        try:
+            # Prüfe ob ein Projekt geladen ist
+            if not hasattr(self, "project") or not self.project:
+                QMessageBox.warning(self, "Warnung", "Kein Projekt geladen. Bitte öffnen Sie zuerst ein Projekt.")
+                event.ignore()
+                return
+
+            if not hasattr(self, "pdf_project") or not self.pdf_project:
+                QMessageBox.warning(self, "Warnung", "Keine Projekt-Einstellungen geladen.")
+                event.ignore()
+                return
+
+            # Hole die URLs aus dem Drop-Event
+            if not event.mimeData().hasUrls():
+                event.ignore()
+                return
+
+            urls = event.mimeData().urls()
+            xml_files = []
+
+            # Sammle alle XML-Dateien
+            for url in urls:
+                file_path = url.toLocalFile()
+                if file_path.lower().endswith(".xml"):
+                    xml_files.append(Path(file_path))
+
+            if not xml_files:
+                QMessageBox.information(self, "Information", "Keine XML-Dateien zum Hinzufügen gefunden.")
+                event.ignore()
+                return
+
+            logger.info(f"Drop-Event: {len(xml_files)} XML-Dateien erkannt")
+
+            # Verarbeite alle XML-Dateien mit optionalem "Alle zuordnen" Feature
+            self._handle_multiple_xml_files_drop(xml_files)
+
+            event.acceptProposedAction()
+
+        except Exception as e:
+            error_msg = f"Fehler beim Verarbeiten des Drop-Events: {str(e)}"
+            logger.error(error_msg)
+            QMessageBox.critical(self, "Fehler", error_msg)
+            event.ignore()
+
+    def _handle_multiple_xml_files_drop(self, xml_files: list):
+        """
+        Verarbeitet mehrere XML-Dateien asynchron per Drag&Drop.
+        Zeigt einen Dialog zur Auswahl der XSL-Knoten und startet dann die Batch-Verarbeitung im Hintergrund.
+
+        Args:
+            xml_files: Liste von Pfaden zu XML-Dateien
+        """
+        if not xml_files:
+            return
+
+        try:
+            # Prüfe ob Projekt-Nodes verfügbar sind
+            if not self.pdf_project or not self.pdf_project.nodes:
+                QMessageBox.warning(self, "Warnung", "Keine Projekt-Nodes verfügbar für die Zuordnung.")
+                return
+
+            # Zeige Dialog für die erste Datei
+            dialog = XmlToXslAssignDialog(parent=self, xml_file_path=xml_files[0], project_nodes=self.pdf_project.nodes)
+
+            if dialog.exec() != XmlToXslAssignDialog.DialogCode.Accepted:
+                logger.debug("Dialog abgebrochen - keine Dateien verarbeitet")
+                return
+
+            # Hole die ausgewählten XSL-Knoten
+            selected_xsl_nodes = dialog.get_selected_xsl_nodes()
+
+            if not selected_xsl_nodes:
+                logger.warning("Keine XSL-Knoten ausgewählt")
+                return
+
+            # Prüfe ob "Alle zuordnen" aktiviert wurde
+            apply_to_all = dialog.is_apply_to_all()
+
+            # Bestimme welche Dateien verarbeitet werden sollen
+            files_to_process = xml_files if apply_to_all else [xml_files[0]]
+
+            # Stoppe vorherigen Batch-Thread falls noch aktiv
+            if self.batch_processing_thread and self.batch_processing_thread.isRunning():
+                self.batch_processing_thread.quit()
+                self.batch_processing_thread.wait()
+
+            # Zusätzliche Sicherheitsprüfung für project_dir
+            if not self.project or not self.project.project_dir:
+                QMessageBox.warning(self, "Fehler", "Projekt-Verzeichnis ist nicht verfügbar")
+                return
+
+            # Erstelle und starte neuen Batch-Verarbeitungs-Thread
+            self.batch_processing_thread = XmlBatchProcessingThread(
+                xml_files=files_to_process,
+                selected_xsl_nodes=selected_xsl_nodes,
+                project_dir=Path(self.project.project_dir),
+                pdf_project=self.pdf_project,
+            )
+
+            # Verbinde Signale
+            self.batch_processing_thread.progress_update.connect(self._on_batch_progress_update)
+            self.batch_processing_thread.processing_finished.connect(self._on_batch_processing_finished)
+
+            # Zeige Progressbar
+            self._show_batch_progress_bar(len(files_to_process))
+
+            # Starte Thread
+            self.batch_processing_thread.start()
+
+            logger.info(
+                f"Batch-Verarbeitung von {len(files_to_process)} Datei(en) gestartet (apply_to_all={apply_to_all})"
+            )
+
+        except Exception as e:
+            error_msg = f"Fehler beim Starten der Batch-Verarbeitung: {str(e)}"
+            logger.error(error_msg)
+            QMessageBox.critical(self, "Fehler", error_msg)
+
+    def _show_batch_progress_bar(self, total_files: int):
+        """
+        Zeigt einen Progressbar in der Statusbar für die Batch-Verarbeitung.
+
+        Args:
+            total_files: Gesamtanzahl der zu verarbeitenden Dateien
+        """
+        if self.batch_progress_bar is None:
+            self.batch_progress_bar = QProgressBar()
+            self.batch_progress_bar.setMaximumHeight(20)
+            self.batch_progress_bar.setMaximumWidth(300)
+
+        self.batch_progress_bar.setMinimum(0)
+        self.batch_progress_bar.setMaximum(total_files)
+        self.batch_progress_bar.setValue(0)
+        self.batch_progress_bar.setFormat("%v/%m Dateien")
+
+        # Füge Progressbar zur Statusbar hinzu
+        self.statusBar().addPermanentWidget(self.batch_progress_bar)
+        self.batch_progress_bar.show()
+
+    def _hide_batch_progress_bar(self):
+        """Versteckt und entfernt den Progressbar aus der Statusbar."""
+        if self.batch_progress_bar:
+            self.statusBar().removeWidget(self.batch_progress_bar)
+            self.batch_progress_bar.hide()
+
+    def _on_batch_progress_update(self, current: int, total: int, current_file: str):
+        """
+        Wird aufgerufen wenn der Batch-Thread einen Fortschritt meldet.
+
+        Args:
+            current: Aktuelle Dateinummer
+            total: Gesamtanzahl der Dateien
+            current_file: Name der aktuellen Datei
+        """
+        if self.batch_progress_bar:
+            self.batch_progress_bar.setValue(current)
+
+        self.statusBar().showMessage(f"Verarbeite: {current_file} ({current}/{total})")
+
+    def _on_batch_processing_finished(self, stats: dict):
+        """
+        Wird aufgerufen wenn die Batch-Verarbeitung abgeschlossen ist.
+
+        Args:
+            stats: Statistik-Dictionary mit Verarbeitungsergebnissen
+        """
+        try:
+            # Verstecke Progressbar
+            self._hide_batch_progress_bar()
+
+            # Speichere Projekt-Einstellungen
+            if stats["processed"] > 0:
+                self._save_project_settings()
+
+            # Aktualisiere Tree
+            self._load_nodes_to_tree()
+
+            # Zeige Zusammenfassungsdialog
+            self._show_drop_summary_dialog(stats)
+
+            # Statusbar-Nachricht
+            self.statusBar().showMessage(
+                f"Batch-Verarbeitung abgeschlossen: {stats['processed']}/{stats['total']} Dateien", 5000
+            )
+
+        except Exception as e:
+            logger.error(f"Fehler beim Abschließen der Batch-Verarbeitung: {e}")
+
+    def _show_drop_summary_dialog(self, stats: dict):
+        """
+        Zeigt einen Zusammenfassungsdialog über die verarbeiteten XML-Dateien.
+
+        Args:
+            stats: Statistik-Dictionary mit Verarbeitungsergebnissen
+        """
+        # Erstelle Zusammenfassungstext
+        summary_lines = []
+        summary_lines.append("Verarbeitung abgeschlossen:\n")
+        summary_lines.append(f"Gesamt: {stats['total']} Datei(en)")
+        summary_lines.append(f"Verarbeitet: {stats['processed']} Datei(en)")
+
+        if stats["new_added"] > 0:
+            summary_lines.append(f"Neu hinzugefuegt: {stats['new_added']} Datei(en)")
+
+        if stats["existing_added"] > 0:
+            summary_lines.append(f"Vorhandene zugeordnet: {stats['existing_added']} Datei(en)")
+
+        if stats["already_assigned"] > 0:
+            summary_lines.append(f"Bereits zugeordnet: {stats['already_assigned']} Datei(en)")
+
+        if stats["cancelled"] > 0:
+            summary_lines.append(f"Abgebrochen: {stats['cancelled']} Datei(en)")
+
+        if stats["renamed_files"]:
+            summary_lines.append("\nUmbenannte Dateien:")
+            for renamed in stats["renamed_files"]:
+                summary_lines.append(f"   - {renamed}")
+
+        if stats["errors"] > 0:
+            summary_lines.append(f"\nFehler: {stats['errors']}")
+            for error_msg in stats["error_messages"][:5]:  # Zeige max. 5 Fehler
+                summary_lines.append(f"   - {error_msg}")
+            if len(stats["error_messages"]) > 5:
+                summary_lines.append(f"   ... und {len(stats['error_messages']) - 5} weitere Fehler")
+
+        summary_text = "\n".join(summary_lines)
+
+        # Wähle Icon basierend auf Erfolg
+        if stats["errors"] > 0:
+            QMessageBox.warning(self, "Verarbeitung mit Fehlern abgeschlossen", summary_text)
+        elif stats["cancelled"] > 0:
+            QMessageBox.information(self, "Verarbeitung abgebrochen", summary_text)
+        else:
+            QMessageBox.information(self, "Verarbeitung erfolgreich", summary_text)

src/ui/mixins/hash_calculation.py

@@ -0,0 +1,533 @@
+"""
+HashCalculationMixin - Mixin für Hash-Berechnung und XML-Dateiverwaltung.
+
+Dieses Mixin enthält alle Methoden zur blake2b-Hash-Berechnung,
+XML-Datei-Zuordnung und Duplikatserkennung für das MainWindow.
+"""
+
+import shutil
+import time
+import logging
+from pathlib import Path
+
+from conf import TreeNode, XslFile, XmlFile
+from ui.threads import XmlHashCalculatorThread
+from utils import calculate_blake2b_hash
+
+logger = logging.getLogger(__name__)
+
+
+class HashCalculationMixin:
+    """
+    Mixin für Hash-Berechnung und XML-Dateiverwaltung.
+
+    Dieses Mixin wird von MainWindow verwendet und erwartet folgende Attribute:
+    - self.project: Das aktuelle Projekt
+    - self.pdf_project: Die Projekt-Daten (ProjectData)
+    - self.hash_calculator_thread: Thread für Hash-Berechnung
+    - self._save_project_settings(): Methode zum Speichern der Projekt-Einstellungen
+    - self._load_nodes_to_tree(): Methode zum Laden der Nodes in den Tree
+    """
+
+    def _assign_xml_to_xsl_nodes(self, xml_file_path: Path, selected_xsl_nodes: list):
+        """
+        Ordnet eine XML-Datei den ausgewählten XSL-Knoten zu.
+        Implementiert Hash-basierte Duplikatserkennung und intelligente Dateinamen-Verwaltung.
+
+        Args:
+            xml_file_path: Pfad zur XML-Datei
+            selected_xsl_nodes: Liste der ausgewählten XSL-Knoten
+
+        Returns:
+            dict: Statistiken über die Verarbeitung
+        """
+        try:
+            logger.info(f"Ordne XML-Datei '{xml_file_path.name}' zu {len(selected_xsl_nodes)} XSL-Knoten zu")
+
+            # 1. Hash für die neue XML-Datei berechnen
+            file_hash = self._calculate_hash_for_file(xml_file_path)
+            if not file_hash:
+                logger.warning(f"Hash-Berechnung für {xml_file_path} fehlgeschlagen")
+
+            # 2. Prüfe ob eine XML-Datei mit gleichem Hash bereits im Projekt existiert
+            existing_xml = self._find_xml_file_by_hash(file_hash) if file_hash else None
+
+            if existing_xml:
+                # 3. Hash-Match gefunden: Ordne vorhandene XML-Datei zu
+                logger.info(f"Hash-Duplikat gefunden: {existing_xml.xml} hat gleichen Hash wie {xml_file_path.name}")
+                return self._assign_existing_xml_to_nodes(existing_xml, selected_xsl_nodes)
+            else:
+                # 4. Kein Hash-Match: Verarbeite als neue XML-Datei
+                logger.info(f"Keine Hash-Duplikate gefunden für {xml_file_path.name}, verarbeite als neue Datei")
+                return self._process_new_xml_file(xml_file_path, selected_xsl_nodes, file_hash)
+
+        except Exception as e:
+            error_msg = f"Fehler beim Zuordnen der XML-Datei: {str(e)}"
+            logger.error(error_msg)
+            return {"status": "error", "error_msg": error_msg}
+
+    def _start_xml_hash_calculation(self):
+        """
+        Startet die asynchrone Hash-Berechnung für alle XML-Dateien im Projekt.
+        """
+        try:
+            if not hasattr(self, "pdf_project") or not self.pdf_project:
+                logger.debug("Keine Projekt-Einstellungen verfügbar für Hash-Berechnung")
+                return
+
+            # Sammle alle XML-Dateien aus dem Projekt
+            xml_files = self._collect_all_xml_files()
+
+            if not xml_files:
+                logger.debug("Keine XML-Dateien für Hash-Berechnung gefunden")
+                return
+
+            logger.info(f"Starte Hash-Berechnung für {len(xml_files)} XML-Dateien")
+
+            # Prüfe ob Projekt verfügbar ist
+            if not self.project or not self.project.project_dir:
+                logger.warning("Kein Projekt-Verzeichnis für Hash-Berechnung verfügbar")
+                return
+
+            # Stoppe vorherigen Thread falls noch aktiv
+            if self.hash_calculator_thread and self.hash_calculator_thread.isRunning():
+                self.hash_calculator_thread.quit()
+                self.hash_calculator_thread.wait()
+
+            # Erstelle und starte neuen Hash-Berechnungs-Thread
+            self.hash_calculator_thread = XmlHashCalculatorThread(
+                project_dir=Path(self.project.project_dir), xml_files=xml_files
+            )
+
+            # Verbinde Signale
+            self.hash_calculator_thread.hash_calculated.connect(self._on_hash_calculated)
+            self.hash_calculator_thread.calculation_finished.connect(self._on_hash_calculation_finished)
+            self.hash_calculator_thread.error_occurred.connect(self._on_hash_calculation_error)
+
+            # Starte Thread
+            self.hash_calculator_thread.start()
+
+        except Exception as e:
+            logger.error(f"Fehler beim Starten der Hash-Berechnung: {e}")
+
+    def _collect_all_xml_files(self) -> list[XmlFile]:
+        """
+        Sammelt alle XmlFile-Objekte aus der Projektstruktur.
+
+        Returns:
+            list[XmlFile]: Liste aller gefundenen XML-Dateien
+        """
+        xml_files: list[XmlFile] = []
+        seen_paths: set = set()
+
+        try:
+            if self.pdf_project and self.pdf_project.nodes:
+                self._collect_xml_files_recursive(self.pdf_project.nodes, xml_files, seen_paths)
+
+            logger.debug(f"Gesammelt: {len(xml_files)} XML-Dateien")
+            return xml_files
+
+        except Exception as e:
+            logger.error(f"Fehler beim Sammeln der XML-Dateien: {e}")
+            return []
+
+    def _collect_xml_files_recursive(self, nodes, xml_files: list[XmlFile], seen_paths: set):
+        """
+        Sammelt rekursiv alle XML-Dateien aus den Nodes.
+
+        Args:
+            nodes: Liste der zu durchsuchenden Nodes
+            xml_files: Liste zum Sammeln der XML-Dateien
+            seen_paths: Set bereits gesehener Pfade (verhindert Duplikate)
+        """
+        for node in nodes:
+            if isinstance(node, XslFile) and node.xmls:
+                for xml_file in node.xmls:
+                    if xml_file.xml not in seen_paths:
+                        xml_files.append(xml_file)
+                        seen_paths.add(xml_file.xml)
+            elif isinstance(node, TreeNode) and node.children:
+                self._collect_xml_files_recursive(node.children, xml_files, seen_paths)
+
+    def _on_hash_calculated(self, xml_file: XmlFile, hash_value: str):
+        """
+        Wird aufgerufen, wenn ein Hash-Wert berechnet wurde.
+
+        Args:
+            xml_file: Das XmlFile-Objekt
+            hash_value: Der berechnete Hash-Wert mit Präfix
+        """
+        try:
+            # Setze den Hash-Wert
+            xml_file.hashsum = hash_value
+            logger.debug(f"Hash gesetzt für {xml_file.xml}: {hash_value}")
+
+        except Exception as e:
+            logger.error(f"Fehler beim Setzen des Hash-Werts: {e}")
+
+    def _on_hash_calculation_finished(self, processed_count: int, total_count: int):
+        """
+        Wird aufgerufen, wenn die Hash-Berechnung abgeschlossen ist.
+
+        Args:
+            processed_count: Anzahl der verarbeiteten Dateien
+            total_count: Gesamtanzahl der Dateien
+        """
+        try:
+            logger.info(f"Hash-Berechnung abgeschlossen: {processed_count}/{total_count} Dateien verarbeitet")
+
+            # Speichere die aktualisierten Projekt-Einstellungen
+            if processed_count > 0:
+                self._save_project_settings()
+                logger.info("Projekt-Einstellungen mit neuen Hash-Werten gespeichert")
+
+        except Exception as e:
+            logger.error(f"Fehler beim Abschließen der Hash-Berechnung: {e}")
+
+    def _on_hash_calculation_error(self, xml_file_path: str, error_message: str):
+        """
+        Wird aufgerufen, wenn ein Fehler bei der Hash-Berechnung auftritt.
+
+        Args:
+            xml_file_path: Pfad zur XML-Datei
+            error_message: Fehlermeldung
+        """
+        logger.warning(f"Hash-Berechnungsfehler für {xml_file_path}: {error_message}")
+
+    def _calculate_hash_for_xml_file(self, xml_file: XmlFile):
+        """
+        Berechnet synchron den Hash für eine einzelne XML-Datei.
+        Wird verwendet beim Hinzufügen neuer XML-Dateien.
+
+        Args:
+            xml_file: Das XmlFile-Objekt
+        """
+        try:
+            if xml_file.hashsum:
+                logger.debug(f"Hash bereits vorhanden für {xml_file.xml}: {xml_file.hashsum}")
+                return
+
+            if not self.project or not self.project.project_dir:
+                logger.warning("Kein Projekt-Verzeichnis für Hash-Berechnung verfügbar")
+                return
+
+            xml_file_path = Path(self.project.project_dir) / xml_file.xml
+            hash_value = calculate_blake2b_hash(xml_file_path)
+            if hash_value:
+                xml_file.hashsum = hash_value
+                logger.debug(f"Hash berechnet für {xml_file.xml}: {xml_file.hashsum}")
+
+        except Exception as e:
+            logger.error(f"Fehler beim Berechnen des Hash für {xml_file.xml}: {e}")
+
+    def _find_xml_file_by_hash(self, target_hash: str) -> XmlFile | None:
+        """
+        Sucht eine XML-Datei mit dem angegebenen Hash im gesamten Projekt.
+
+        Args:
+            target_hash: Der zu suchende Hash-Wert (mit blake2b: Präfix)
+
+        Returns:
+            XmlFile|None: Die gefundene XML-Datei oder None
+        """
+        try:
+            if not target_hash:
+                return None
+
+            all_xml_files = self._collect_all_xml_files()
+
+            for xml_file in all_xml_files:
+                if xml_file.hashsum == target_hash:
+                    logger.debug(f"Hash-Match gefunden: {xml_file.xml} hat Hash {target_hash}")
+                    return xml_file
+
+            logger.debug(f"Kein Hash-Match für {target_hash} gefunden")
+            return None
+
+        except Exception as e:
+            logger.error(f"Fehler bei Hash-Suche für {target_hash}: {e}")
+            return None
+
+    def _generate_alternative_filename(self, original_path: Path, xml_dir: Path) -> Path:
+        """
+        Generiert alternative Dateinamen im Format: datei_1.xml, datei_2.xml, ...
+
+        Args:
+            original_path: Ursprünglicher Dateipfad
+            xml_dir: Ziel-XML-Verzeichnis
+
+        Returns:
+            Path: Pfad mit alternativem Dateinamen
+        """
+        try:
+            base_name = original_path.stem  # "datei"
+            extension = original_path.suffix  # ".xml"
+
+            # Sammle einmalig alle verwendeten Dateinamen (Performance-Optimierung)
+            all_xml_files = self._collect_all_xml_files()
+            used_names = {xml_file.xml.name for xml_file in all_xml_files}
+
+            counter = 1
+            while True:
+                new_name = f"{base_name}_{counter}{extension}"
+                new_path = xml_dir / new_name
+
+                # Prüfe sowohl physische Existenz als auch Verwendung im Projekt (optimierter Set-Lookup)
+                if not new_path.exists() and new_name not in used_names:
+                    logger.debug(f"Alternativer Dateiname generiert: {new_name}")
+                    return new_path
+
+                counter += 1
+
+                # Sicherheitsgrenze um Endlosschleifen zu vermeiden
+                if counter > 1000:
+                    raise Exception("Zu viele alternative Dateinamen generiert")
+
+        except Exception as e:
+            logger.error(f"Fehler beim Generieren alternativer Dateinamen für {original_path}: {e}")
+            # Fallback: Zeitstempel verwenden
+            timestamp = int(time.time())
+            fallback_name = f"{original_path.stem}_{timestamp}{original_path.suffix}"
+            return xml_dir / fallback_name
+
+    def _is_filename_used_in_project(self, relative_xml_path: Path) -> bool:
+        """
+        Prüft ob ein relativer XML-Dateipfad bereits im Projekt verwendet wird.
+
+        Args:
+            relative_xml_path: Relativer Pfad zur XML-Datei (z.B. xml/datei_1.xml)
+
+        Returns:
+            bool: True wenn der Dateiname bereits verwendet wird
+        """
+        try:
+            all_xml_files = self._collect_all_xml_files()
+
+            for xml_file in all_xml_files:
+                if xml_file.xml == relative_xml_path:
+                    return True
+
+            return False
+
+        except Exception as e:
+            logger.error(f"Fehler beim Prüfen der Dateiname-Verwendung für {relative_xml_path}: {e}")
+            return True  # Im Zweifelsfall annehmen, dass der Name verwendet wird
+
+    def _calculate_hash_for_file(self, file_path: Path) -> str | None:
+        """Berechnet synchron den blake2b-Hash für eine Datei."""
+        return calculate_blake2b_hash(file_path)
+
+    def _assign_existing_xml_to_nodes(self, existing_xml: XmlFile, selected_xsl_nodes: list):
+        """
+        Ordnet eine bereits vorhandene XML-Datei (basierend auf Hash-Match) den XSL-Knoten zu.
+
+        Args:
+            existing_xml: Die bereits vorhandene XML-Datei
+            selected_xsl_nodes: Liste der ausgewählten XSL-Knoten
+
+        Returns:
+            dict: Statistiken mit 'status', 'added_count', 'existing_file'
+        """
+        try:
+            added_count = 0
+
+            for xsl_node in selected_xsl_nodes:
+                # Prüfe ob diese XML-Datei bereits in der XslFile-Node vorhanden ist
+                already_assigned = any(xml_file.xml == existing_xml.xml for xml_file in xsl_node.xmls)
+
+                if not already_assigned:
+                    # Erstelle neue XmlFile-Referenz mit gleichem Pfad und Hash
+                    new_xml_ref = XmlFile(xml=existing_xml.xml, hashsum=existing_xml.hashsum)
+                    xsl_node.xmls.append(new_xml_ref)
+                    added_count += 1
+                    logger.info(f"Vorhandene XML-Datei '{existing_xml.xml}' zu XSL-Node '{xsl_node.bez}' zugeordnet")
+                else:
+                    logger.debug(f"XML-Datei '{existing_xml.xml}' bereits in XSL-Node '{xsl_node.bez}' vorhanden")
+
+            if added_count > 0:
+                # Speichere die aktualisierten Projekt-Einstellungen
+                self._save_project_settings()
+
+                # Aktualisiere das TreeWidget
+                self._load_nodes_to_tree()
+
+                return {
+                    "status": "existing_added",
+                    "added_count": added_count,
+                    "existing_file": existing_xml.xml.name,
+                }
+            else:
+                return {"status": "already_assigned", "added_count": 0, "existing_file": existing_xml.xml.name}
+
+        except Exception as e:
+            error_msg = f"Fehler beim Zuordnen der vorhandenen XML-Datei: {str(e)}"
+            logger.error(error_msg)
+            return {"status": "error", "error_msg": error_msg}
+
+    def _process_new_xml_file(self, xml_file_path: Path, selected_xsl_nodes: list, file_hash: str | None):
+        """
+        Verarbeitet eine neue XML-Datei (kein Hash-Match gefunden).
+
+        Args:
+            xml_file_path: Pfad zur neuen XML-Datei
+            selected_xsl_nodes: Liste der ausgewählten XSL-Knoten
+            file_hash: Berechneter Hash der Datei
+
+        Returns:
+            dict: Statistiken mit 'status', 'added_count', 'new_file', 'renamed_from'
+        """
+        try:
+            # Prüfe ob Projekt verfügbar ist
+            if not self.project or not self.project.project_dir:
+                logger.error("Kein Projekt-Verzeichnis für neue XML-Datei verfügbar")
+                return {"status": "error", "error_msg": "Kein Projekt-Verzeichnis verfügbar."}
+
+            # Erstelle xml-Ordner im Projekt-Verzeichnis falls er nicht existiert
+            xml_dir = Path(self.project.project_dir) / "xml"
+            xml_dir.mkdir(parents=True, exist_ok=True)
+
+            # Bestimme den Ziel-Pfad in xml-Ordner
+            target_xml_path = xml_dir / xml_file_path.name
+
+            # Prüfe ob eine Datei mit gleichem Namen bereits existiert
+            if target_xml_path.exists() or self._is_filename_used_in_project(Path("xml") / xml_file_path.name):
+                # Generiere alternative Dateinamen
+                alternative_paths = []
+                for i in range(1, 6):  # Generiere bis zu 5 Alternativen
+                    alt_path = self._generate_alternative_filename(xml_file_path, xml_dir)
+                    if alt_path not in alternative_paths:
+                        alternative_paths.append(alt_path)
+
+                # Zeige Dialog zur Auswahl des Dateinamens
+                selected_path = self._show_filename_selection_dialog(xml_file_path.name, alternative_paths)
+
+                if not selected_path:
+                    # Benutzer hat abgebrochen
+                    return {"status": "cancelled", "added_count": 0}
+
+                target_xml_path = selected_path
+
+            # Kopiere die XML-Datei in den xml-Ordner
+            shutil.copy2(xml_file_path, target_xml_path)
+            logger.info(f"XML-Datei kopiert: {xml_file_path} -> {target_xml_path}")
+
+            # Erstelle relatives Path zur XML-Datei (relativ zum Projekt-Verzeichnis)
+            relative_xml_path = Path("xml") / target_xml_path.name
+
+            # Füge die XML-Datei zu allen ausgewählten XSL-Knoten hinzu
+            added_count = 0
+            for xsl_node in selected_xsl_nodes:
+                # Prüfe ob diese XML-Datei bereits in der XslFile-Node vorhanden ist
+                existing_xml = None
+                for xml_file in xsl_node.xmls:
+                    if xml_file.xml == relative_xml_path:
+                        existing_xml = xml_file
+                        break
+
+                if not existing_xml:
+                    # Erstelle neues XmlFile-Objekt mit Hash
+                    new_xml_file = XmlFile(xml=relative_xml_path, hashsum=file_hash)
+                    xsl_node.xmls.append(new_xml_file)
+                    added_count += 1
+                    logger.info(f"XML-Datei '{target_xml_path.name}' zu XSL-Node '{xsl_node.bez}' hinzugefügt")
+                else:
+                    logger.debug(f"XML-Datei '{target_xml_path.name}' bereits in XSL-Node '{xsl_node.bez}' vorhanden")
+
+            if added_count > 0:
+                # Speichere die aktualisierten Projekt-Einstellungen
+                self._save_project_settings()
+
+                # Aktualisiere das TreeWidget
+                self._load_nodes_to_tree()
+
+                return {
+                    "status": "new_added",
+                    "added_count": added_count,
+                    "new_file": target_xml_path.name,
+                    "renamed_from": xml_file_path.name if target_xml_path.name != xml_file_path.name else None,
+                }
+            else:
+                return {
+                    "status": "already_assigned",
+                    "added_count": 0,
+                    "new_file": target_xml_path.name,
+                }
+
+        except Exception as e:
+            error_msg = f"Fehler beim Verarbeiten der neuen XML-Datei: {str(e)}"
+            logger.error(error_msg)
+            return {"status": "error", "error_msg": error_msg}
+
+    def _show_filename_selection_dialog(self, original_name: str, alternative_paths: list[Path]) -> Path | None:
+        """
+        Zeigt einen Dialog zur Auswahl eines alternativen Dateinamens.
+
+        Args:
+            original_name: Ursprünglicher Dateiname
+            alternative_paths: Liste alternativer Pfade
+
+        Returns:
+            Path|None: Ausgewählter Pfad oder None bei Abbruch
+        """
+        try:
+            from PySide6.QtWidgets import (
+                QDialog,
+                QVBoxLayout,
+                QLabel,
+                QRadioButton,
+                QButtonGroup,
+                QPushButton,
+                QHBoxLayout,
+            )
+
+            dialog = QDialog(self)
+            dialog.setWindowTitle("Dateiname auswählen")
+            dialog.setModal(True)
+            dialog.resize(400, 300)
+
+            layout = QVBoxLayout(dialog)
+
+            # Erklärungstext
+            info_label = QLabel(
+                f"Eine Datei mit dem Namen '{original_name}' existiert bereits.\n\n"
+                "Bitte wählen Sie einen alternativen Dateinamen:"
+            )
+            layout.addWidget(info_label)
+
+            # Radio-Buttons für alternative Namen
+            button_group = QButtonGroup(dialog)
+            radio_buttons = []
+
+            for i, alt_path in enumerate(alternative_paths):
+                radio_button = QRadioButton(alt_path.name)
+                if i == 0:  # Ersten als Standard auswählen
+                    radio_button.setChecked(True)
+                button_group.addButton(radio_button, i)
+                radio_buttons.append(radio_button)
+                layout.addWidget(radio_button)
+
+            # Buttons
+            button_layout = QHBoxLayout()
+            ok_button = QPushButton("OK")
+            cancel_button = QPushButton("Abbrechen")
+
+            button_layout.addWidget(ok_button)
+            button_layout.addWidget(cancel_button)
+            layout.addLayout(button_layout)
+
+            # Event-Handler
+            ok_button.clicked.connect(dialog.accept)
+            cancel_button.clicked.connect(dialog.reject)
+
+            # Dialog anzeigen
+            if dialog.exec() == QDialog.DialogCode.Accepted:
+                selected_id = button_group.checkedId()
+                if 0 <= selected_id < len(alternative_paths):
+                    return alternative_paths[selected_id]
+
+            return None
+
+        except Exception as e:
+            logger.error(f"Fehler beim Anzeigen des Dateiname-Auswahl-Dialogs: {e}")
+            # Fallback: Ersten alternativen Namen verwenden
+            return alternative_paths[0] if alternative_paths else None

src/ui/mixins/pdf_viewer.py

@@ -0,0 +1,679 @@
+"""
+PdfViewerMixin - Mixin für PDF-Viewer-Operationen.
+
+Dieses Mixin enthält alle Methoden für die PDF-Anzeige und -Vergleich im MainWindow:
+- PDF-Rendering und -Anzeige
+- Alpha-Blending und Zoom
+- Thumbnail-Navigation
+- Drag-to-Scroll
+- PDF-Dokument-Management
+"""
+
+import gc
+import logging
+import time
+from pathlib import Path
+
+from PySide6.QtCore import Qt, QSize, QTimer, QUrl
+from PySide6.QtGui import QCursor, QPixmap, QPainter, QDesktopServices
+from PySide6.QtWidgets import QLabel, QMessageBox, QSpacerItem, QSizePolicy
+from PySide6.QtPdf import QPdfDocument
+
+
+logger = logging.getLogger(__name__)
+
+
+class PdfViewerMixin:
+    """
+    Mixin-Klasse für PDF-Viewer-Operationen.
+
+    Dieses Mixin erwartet, dass die verwendende Klasse folgende Attribute hat:
+    - self.ui: UI-Objekt mit Layouts, Slidern, etc.
+    - self.project: Aktuelles Projekt
+    - self.pdf_documents: Dict für PDF-Dokumente
+    - self.current_rendered_pixmaps: Cache für gerenderte Pixmaps
+    - self.fullsize_label: QLabel für Vollbild-Anzeige
+    - self.thumbnail_to_page: Dict für Thumbnail-zu-Seite-Mapping
+    - self.current_zoom: Aktueller Zoom-Faktor
+    - self.current_page: Aktuelle Seitennummer
+    - self.current_pdf: Aktueller PDF-Dateiname
+    - self.is_dragging: Drag-Status
+    - self.last_drag_position: Letzte Drag-Position
+    - self.drag_threshold: Mindestbewegung für Drag
+    - self.scroll_sensitivity: Scroll-Empfindlichkeit
+    """
+
+    def render_and_display_page(self, pdf_filename, page_num):
+        """
+        Rendert und zeigt eine spezifische Seite in der Vollansicht an.
+        Cached die gerenderten Pixmaps für bessere Performance.
+
+        Args:
+            pdf_filename: Name der PDF-Datei
+            page_num: Seitennummer (0-basiert)
+        """
+        logger.debug(f"Rendere Seite {page_num + 1} von {pdf_filename}")
+
+        if pdf_filename not in self.pdf_documents:
+            logger.warning(f"PDF-Dokument {pdf_filename} nicht gefunden")
+            return
+
+        start_time = time.time()
+
+        try:
+            docs = self.pdf_documents[pdf_filename]
+
+            # Diff-Seite laden (bestimmt die Abmessungen)
+            diff_doc = docs["diff"]
+            page_size = diff_doc.pagePointSize(page_num)
+
+            # Hohe Auflösung für Vollbild (entspricht ca. Matrix(2.0, 2.0) in PyMuPDF)
+            scale_factor = 2.0
+            render_size = QSize(int(page_size.width() * scale_factor), int(page_size.height() * scale_factor))
+
+            # Diff-Seite rendern (immer vorhanden)
+            diff_image = diff_doc.render(page_num, render_size)
+            diff_pixmap = QPixmap.fromImage(diff_image)
+
+            # Ermittle die Abmessungen für weiße Seiten
+            diff_width = diff_pixmap.width()
+            diff_height = diff_pixmap.height()
+
+            # Ref-Seite prüfen und rendern oder weiße Seite erstellen
+            ref_doc = docs["ref"]
+            if page_num < ref_doc.pageCount():
+                ref_image = ref_doc.render(page_num, render_size)
+                ref_pixmap = QPixmap.fromImage(ref_image)
+                logger.debug(f"Ref-Seite {page_num + 1} gerendert")
+            else:
+                # Erstelle weiße Seite mit gleichen Abmessungen wie Diff-Seite
+                ref_pixmap = QPixmap(diff_width, diff_height)
+                ref_pixmap.fill(Qt.GlobalColor.white)
+                logger.debug(f"Weiße Ref-Seite {page_num + 1} erstellt")
+
+            # New-Seite prüfen und rendern oder weiße Seite erstellen
+            new_doc = docs["new"]
+            if page_num < new_doc.pageCount():
+                new_image = new_doc.render(page_num, render_size)
+                new_pixmap = QPixmap.fromImage(new_image)
+                logger.debug(f"New-Seite {page_num + 1} gerendert")
+            else:
+                # Erstelle weiße Seite mit gleichen Abmessungen wie Diff-Seite
+                new_pixmap = QPixmap(diff_width, diff_height)
+                new_pixmap.fill(Qt.GlobalColor.white)
+                logger.debug(f"Weiße New-Seite {page_num + 1} erstellt")
+
+            # Cache die gerenderten Pixmaps für schnelle Alpha/Zoom-Operationen
+            self.current_rendered_pixmaps = {"ref": ref_pixmap, "diff": diff_pixmap, "new": new_pixmap}
+
+            # Aktualisiere aktuelle Seite
+            self.current_page = page_num
+            self.current_pdf = pdf_filename
+
+            # Zeige das Bild mit aktuellem Alpha- und Zoom-Wert an
+            self.update_current_display()
+
+            render_time = time.time() - start_time
+            logger.debug(f"Performance: Seite {page_num + 1} gerendert in {render_time:.3f}s")
+
+        except Exception as e:
+            logger.error(f"Fehler beim Rendern der Seite {page_num + 1}: {e}", exc_info=True)
+
+    def update_current_display(self):
+        """
+        Aktualisiert die Anzeige der aktuellen Seite basierend auf gecachten Pixmaps.
+        Verwendet für Alpha- und Zoom-Änderungen ohne erneutes PDF-Rendering.
+        """
+        if not self.current_rendered_pixmaps:
+            logger.warning("Keine gerenderten Pixmaps verfügbar")
+            return
+
+        if self.fullsize_label is None:
+            logger.warning("Fullsize-Label ist nicht verfügbar")
+            return
+
+        try:
+            # Hole die gecachten Pixmaps
+            ref_pixmap = self.current_rendered_pixmaps["ref"]
+            diff_pixmap = self.current_rendered_pixmaps["diff"]
+            new_pixmap = self.current_rendered_pixmaps["new"]
+
+            # Erstelle das überlagerte Bild mit aktuellem Alpha-Wert
+            alpha_value = self.ui.alpha.value()
+            layered_pixmap = self.create_layered_pixmap(ref_pixmap, diff_pixmap, new_pixmap, alpha_value)
+
+            # Wende aktuellen Zoom an
+            zoom_factor = self.current_zoom / 100.0
+            if zoom_factor != 1.0:
+                new_width = int(layered_pixmap.width() * zoom_factor)
+                layered_pixmap = layered_pixmap.scaledToWidth(new_width, Qt.TransformationMode.SmoothTransformation)
+
+            # Setze das überlagerte Bild
+            self.fullsize_label.setPixmap(layered_pixmap)
+            self.fullsize_label.setAlignment(Qt.AlignmentFlag.AlignHCenter)
+        except RuntimeError as e:
+            # C++-Objekt wurde bereits gelöscht
+            logger.warning(f"Fullsize-Label wurde bereits gelöscht: {e}")
+            self.fullsize_label = None
+
+    def create_layered_pixmap(self, ref_pixmap, diff_pixmap, new_pixmap, alpha_value):
+        """
+        Erstellt ein übergelagertes Pixmap basierend auf dem Alpha-Wert.
+
+        Args:
+            ref_pixmap: Unterste Ebene (ref)
+            diff_pixmap: Mittlere Ebene (diff)
+            new_pixmap: Oberste Ebene (new)
+            alpha_value: Alpha-Wert (-100 bis 100)
+
+        Returns:
+            QPixmap: Das überlagerte Bild
+        """
+        # Verwende die Größe des größten Bildes
+        max_width = max(ref_pixmap.width(), diff_pixmap.width(), new_pixmap.width())
+        max_height = max(ref_pixmap.height(), diff_pixmap.height(), new_pixmap.height())
+
+        # Erstelle ein leeres Pixmap für das Ergebnis
+        result = QPixmap(max_width, max_height)
+        result.fill(Qt.GlobalColor.white)
+
+        painter = QPainter(result)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+
+        if alpha_value <= 0:
+            # Alpha von -100 bis 0: Übergang von ref zu diff
+            ref_opacity = abs(alpha_value) / 100
+            diff_opacity = 1.0 - abs(alpha_value) / 100.0
+            new_opacity = 0.0
+        else:
+            ref_opacity = 0.0
+            diff_opacity = 1.0 - alpha_value / 100.0
+            new_opacity = alpha_value / 100.0
+
+        # Zeichne die Ebenen mit entsprechender Transparenz
+        if ref_opacity > 0:
+            painter.setOpacity(ref_opacity)
+            painter.drawPixmap(0, 0, ref_pixmap)
+
+        if diff_opacity > 0:
+            painter.setOpacity(diff_opacity)
+            painter.drawPixmap(0, 0, diff_pixmap)
+
+        if new_opacity > 0:
+            painter.setOpacity(new_opacity)
+            painter.drawPixmap(0, 0, new_pixmap)
+
+        painter.end()
+        return result
+
+    def _schedule_thumbnail_rendering(self, diff_doc, pdf_basename, thumbnail_labels, page_num):
+        """Rendert Thumbnails progressiv — ein Thumbnail pro Event-Loop-Iteration."""
+        if page_num >= len(thumbnail_labels):
+            return
+
+        thumbnail = thumbnail_labels[page_num]
+        # Prüfe ob das Label noch existiert (Benutzer könnte inzwischen anderes PDF geöffnet haben)
+        if thumbnail_labels[page_num] not in self.thumbnail_to_page:
+            return
+
+        page_size = diff_doc.pagePointSize(page_num)
+        scale_factor = 200.0 / page_size.width()
+        page_image = diff_doc.render(
+            page_num,
+            QSize(int(page_size.width() * scale_factor), int(page_size.height() * scale_factor)),
+        )
+        thumbnail.setPixmap(QPixmap.fromImage(page_image).scaledToWidth(200, Qt.TransformationMode.SmoothTransformation))
+        thumbnail.setMinimumHeight(0)
+
+        QTimer.singleShot(0, lambda: self._schedule_thumbnail_rendering(diff_doc, pdf_basename, thumbnail_labels, page_num + 1))
+
+    def _clear_layout(self, layout):
+        """Entfernt alle Widgets aus einem Layout."""
+        if layout is not None:
+            while layout.count():
+                item = layout.takeAt(0)
+                widget = item.widget()
+                if widget is not None:
+                    widget.deleteLater()
+
+    def on_alpha_changed(self, alpha_value):
+        """
+        Wird ausgeführt, wenn der Alpha-Slider geändert wird.
+        Optimiert: Verwendet gecachte Pixmaps statt erneutes PDF-Rendering.
+
+        Args:
+            alpha_value: Der neue Alpha-Wert (-100 bis 100)
+        """
+        logger.debug(f"Alpha geändert auf {alpha_value}")
+
+        start_time = time.time()
+        # Verwende gecachte Pixmaps für schnelle Alpha-Änderungen
+        self.update_current_display()
+        alpha_time = time.time() - start_time
+        logger.debug(f"Alpha-Update in {alpha_time:.6f}s")
+
+    def on_thumbnail_clicked(self, event, thumbnail):
+        """
+        Wird ausgeführt, wenn ein Thumbnail angeklickt wird.
+
+        Args:
+            event: Das Maus-Event
+            thumbnail: Das geklickte Thumbnail-Label
+        """
+        page_info = self.thumbnail_to_page.get(thumbnail)
+        if page_info:
+            pdf_filename = page_info["pdf_filename"]
+            page_num = page_info["page_num"]
+
+            logger.debug(f"Thumbnail für Seite {page_num + 1} von {pdf_filename} wurde angeklickt")
+
+            # Rendere und zeige die gewählte Seite an
+            self.render_and_display_page(pdf_filename, page_num)
+
+    def apply_zoom(self, zoom_value):
+        """
+        Wendet den Zoom-Faktor auf das aktuelle Bild an.
+        Optimiert: Verwendet gecachte Pixmaps statt erneutes PDF-Rendering.
+
+        Args:
+            zoom_value: Der neue Zoom-Wert (in Prozent)
+        """
+        self.current_zoom = zoom_value
+        logger.debug(f"Zoom geändert auf {zoom_value}%")
+
+        # Verwende gecachte Pixmaps für schnelle Zoom-Änderungen
+        self.update_current_display()
+
+    def on_fullsize_mouse_press(self, event, fullsize_label):
+        """Wird ausgeführt, wenn die Maustaste auf einem großen Bild gedrückt wird."""
+        if event.button() == Qt.MouseButton.LeftButton:
+            self.is_dragging = True
+            self.last_drag_position = event.globalPosition().toPoint()
+            fullsize_label.setCursor(QCursor(Qt.CursorShape.ClosedHandCursor))
+
+    def on_fullsize_mouse_move(self, event, fullsize_label):
+        """Wird ausgeführt, wenn die Maus über einem großen Bild bewegt wird."""
+        if self.is_dragging and self.last_drag_position is not None:
+            current_pos = event.globalPosition().toPoint()
+            delta = current_pos - self.last_drag_position
+
+            if abs(delta.x()) >= self.drag_threshold or abs(delta.y()) >= self.drag_threshold:
+                v_scrollbar = self.ui.scrollArea_2.verticalScrollBar()
+                h_scrollbar = self.ui.scrollArea_2.horizontalScrollBar()
+
+                scroll_delta_y = int(-delta.y() * self.scroll_sensitivity)
+                scroll_delta_x = int(-delta.x() * self.scroll_sensitivity)
+
+                new_v_value = v_scrollbar.value() + scroll_delta_y
+                new_h_value = h_scrollbar.value() + scroll_delta_x
+
+                v_scrollbar.setValue(new_v_value)
+                h_scrollbar.setValue(new_h_value)
+
+                self.last_drag_position = current_pos
+
+    def on_fullsize_mouse_release(self, event, fullsize_label):
+        """Wird ausgeführt, wenn die Maustaste auf einem großen Bild losgelassen wird."""
+        if event.button() == Qt.MouseButton.LeftButton:
+            self.is_dragging = False
+            self.last_drag_position = None
+            fullsize_label.setCursor(QCursor(Qt.CursorShape.OpenHandCursor))
+
+    def _load_pdf_for_comparison(self, xml_file_path: Path, xsl_id_str: str):
+        """
+        Lädt die PDFs (diff, ref, new) einer Transformation in den Vergleichs-Viewer.
+
+        Args:
+            xml_file_path: Pfad zur XML-Datei (relativ)
+            xsl_id_str: XSL-ID als String (z.B. "2002_1_128")
+        """
+        try:
+            if not self.project:
+                QMessageBox.warning(self, "Fehler", "Kein Projekt geöffnet")
+                return
+
+            # Ermittle PDF-Dateinamen basierend auf XML und XSL-ID
+            xml_stem = xml_file_path.stem
+            pdf_basename = f"{xml_stem}_xsl_{xsl_id_str}.pdf"
+
+            # Pfade zu den drei PDFs
+            diff_dir = self.project.project_dir / "diff"
+            ref_dir = self.project.project_dir / "ref"
+            new_dir = self.project.project_dir / "new"
+
+            diff_pdf_path = diff_dir / pdf_basename
+            ref_pdf_path = ref_dir / pdf_basename
+            new_pdf_path = new_dir / pdf_basename
+
+            # Prüfe ob PDFs existieren
+            if not diff_pdf_path.exists():
+                QMessageBox.information(self, "Keine Diff-PDF", f"Diff-PDF nicht gefunden:\n{pdf_basename}")
+                return
+
+            if not ref_pdf_path.exists() or not new_pdf_path.exists():
+                QMessageBox.warning(
+                    self,
+                    "Fehlende PDFs",
+                    f"Ref-PDF oder New-PDF nicht gefunden:\n{pdf_basename}\n\nNur Diff-PDF vorhanden.",
+                )
+                return
+
+            logger.info(f"Lade PDFs für Vergleich: {pdf_basename}")
+
+            # Entferne bestehende Widgets aus den Layouts
+            self._clear_layout(self.ui.verticalLayout_2)
+            self._clear_layout(self.ui.verticalLayout_3)
+
+            # Setze kompaktes Spacing für Thumbnail-Layout
+            self.ui.verticalLayout_2.setSpacing(5)  # Minimaler Abstand zwischen Widgets
+            self.ui.verticalLayout_2.setContentsMargins(0, 0, 0, 0)  # Keine Ränder
+
+            # Dicts zurücksetzen
+            self.thumbnail_to_page = {}
+            self.pdf_documents = {}
+            self.current_rendered_pixmaps = None
+            self.fullsize_label = None  # Label wurde durch _clear_layout gelöscht
+
+            # Alle drei PDF-Dateien öffnen mit QtPdf
+            diff_doc = QPdfDocument()
+            ref_doc = QPdfDocument()
+            new_doc = QPdfDocument()
+
+            # PDF-Dateien laden
+            diff_doc.load(str(diff_pdf_path))
+            ref_doc.load(str(ref_pdf_path))
+            new_doc.load(str(new_pdf_path))
+
+            # Warten bis PDFs geladen sind
+            if (
+                diff_doc.status() != QPdfDocument.Status.Ready
+                or ref_doc.status() != QPdfDocument.Status.Ready
+                or new_doc.status() != QPdfDocument.Status.Ready
+            ):
+                QMessageBox.critical(self, "Fehler", f"Fehler beim Laden der PDFs:\n{pdf_basename}")
+                return
+
+            # PDF-Dokumente speichern
+            self.pdf_documents[pdf_basename] = {"diff": diff_doc, "ref": ref_doc, "new": new_doc}
+
+            # PDF-Pfade für System-Viewer speichern
+            self.current_ref_pdf_path = ref_pdf_path
+            self.current_new_pdf_path = new_pdf_path
+
+            # Buttons zum Öffnen der PDFs im System-Viewer aktivieren
+            self.ui.view_ref_pdf.setEnabled(True)
+            self.ui.view_new_pdf.setEnabled(True)
+
+            # Slider aktivieren
+            self.ui.alpha.setEnabled(True)
+            self.ui.zoom.setEnabled(True)
+
+            logger.info(f"PDFs geladen: {pdf_basename}")
+            logger.info(f"  diff: {diff_doc.pageCount()} Seiten")
+            logger.info(f"  ref: {ref_doc.pageCount()} Seiten")
+            logger.info(f"  new: {new_doc.pageCount()} Seiten")
+
+            # Nehme die Seitenzahl der diff-PDF als Basis
+            max_pages = diff_doc.pageCount()
+
+            # Erstelle Placeholder-Labels für alle Seiten (sofort, ohne Rendern)
+            thumbnail_labels = []
+            for page_num in range(max_pages):
+                thumbnail = QLabel()
+                thumbnail.setObjectName(f"thumbnail_{pdf_basename}_page_{page_num + 1}")
+                thumbnail.setText(f"Seite {page_num + 1}\n…")
+                thumbnail.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
+                thumbnail.setMouseTracking(True)
+                thumbnail.setAlignment(Qt.AlignmentFlag.AlignCenter)
+                thumbnail.setMinimumHeight(150)
+                self.ui.verticalLayout_2.addWidget(thumbnail)
+
+                thumbnail_info = QLabel(f"Seite {page_num + 1}")
+                thumbnail_info.setAlignment(Qt.AlignmentFlag.AlignCenter)
+                thumbnail_info.setMaximumHeight(18)
+                thumbnail_info.setContentsMargins(0, 0, 0, 0)
+                self.ui.verticalLayout_2.addWidget(thumbnail_info)
+
+                self.thumbnail_to_page[thumbnail] = {"pdf_filename": pdf_basename, "page_num": page_num}
+                thumbnail.mousePressEvent = lambda event, t=thumbnail: self.on_thumbnail_clicked(event, t)
+                thumbnail_labels.append(thumbnail)
+
+            # Thumbnails progressiv rendern (nicht blockierend)
+            self._schedule_thumbnail_rendering(diff_doc, pdf_basename, thumbnail_labels, 0)
+
+            # Füge expandierenden Spacer am Ende hinzu, damit Thumbnails oben bleiben
+            spacer = QSpacerItem(20, 40, QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Expanding)
+            self.ui.verticalLayout_2.addItem(spacer)
+
+            # Erstelle das Vollbild-Label für die rechte Spalte (falls noch nicht vorhanden)
+            if self.fullsize_label is None:
+                self.fullsize_label = QLabel()
+                self.fullsize_label.setObjectName("fullsize_current_page")
+                self.fullsize_label.setAlignment(Qt.AlignmentFlag.AlignHCenter)
+                self.fullsize_label.setCursor(QCursor(Qt.CursorShape.OpenHandCursor))
+                self.ui.verticalLayout_3.addWidget(self.fullsize_label)
+
+                # Drag-to-Scroll Events für das große Bild einrichten
+                self.fullsize_label.mousePressEvent = lambda event: self.on_fullsize_mouse_press(
+                    event, self.fullsize_label
+                )
+                self.fullsize_label.mouseMoveEvent = lambda event: self.on_fullsize_mouse_move(
+                    event, self.fullsize_label
+                )
+                self.fullsize_label.mouseReleaseEvent = lambda event: self.on_fullsize_mouse_release(
+                    event, self.fullsize_label
+                )
+
+            # Setze die aktuelle PDF
+            self.current_pdf = pdf_basename
+
+            # Speichere Diff-PDF-Informationen für Accept Changes
+            self.current_diff_xml_path = xml_file_path
+            self.current_diff_xsl_id = xsl_id_str
+
+            # Aktiviere Accept-Changes-Button
+            self.ui.accept_changes.setEnabled(True)
+
+            # Zeige die erste Seite initial an
+            self.render_and_display_page(pdf_basename, 0)
+
+            logger.info(f"PDF-Vergleich geladen: {pdf_basename}")
+
+        except Exception as e:
+            logger.error(f"Fehler beim Laden der PDFs für Vergleich: {e}")
+            QMessageBox.critical(self, "Fehler", f"Konnte PDFs nicht laden:\n{str(e)}")
+
+    def _close_all_pdf_documents(self):
+        """Schließt alle geöffneten PDF-Dokumente explizit (wichtig für Windows)."""
+        if self.pdf_documents:
+            for pdf_basename, docs in self.pdf_documents.items():
+                for doc_type, doc in docs.items():
+                    if doc:
+                        doc.close()
+                        logger.debug(f"PDF-Dokument geschlossen: {pdf_basename} ({doc_type})")
+
+            # Lösche alle Referenzen
+            self.pdf_documents.clear()
+
+            # Lösche gerenderte Pixmaps
+            self.current_rendered_pixmaps = None
+
+            # Erzwinge Garbage Collection um Dateihandles freizugeben (wichtig für Windows)
+            gc.collect()
+
+            logger.info("Alle PDF-Dokumente geschlossen und Referenzen freigegeben")
+
+    def _clear_pdf_viewer(self):
+        """Leert den PDF-Viewer und alle Thumbnails."""
+        # Schließe alle PDF-Dokumente explizit (wichtig für Windows)
+        self._close_all_pdf_documents()
+
+        # Entferne Widgets aus Layouts
+        self._clear_layout(self.ui.verticalLayout_2)
+        self._clear_layout(self.ui.verticalLayout_3)
+
+        # Zurücksetzen der Datenstrukturen
+        self.thumbnail_to_page = {}
+        self.pdf_documents = {}
+        self.current_rendered_pixmaps = None
+        self.fullsize_label = None
+        self.current_pdf = None
+        self.current_diff_xml_path = None
+        self.current_diff_xsl_id = None
+
+        # PDF-Pfade zurücksetzen und Buttons deaktivieren
+        self.current_ref_pdf_path = None
+        self.current_new_pdf_path = None
+        self.ui.view_ref_pdf.setEnabled(False)
+        self.ui.view_new_pdf.setEnabled(False)
+        self.ui.accept_changes.setEnabled(False)
+
+        # Slider deaktivieren
+        self.ui.alpha.setEnabled(False)
+        self.ui.zoom.setEnabled(False)
+
+        logger.info("PDF-Viewer geleert")
+
+    def _on_view_ref_pdf_clicked(self):
+        """
+        Handler für view_ref_pdf Button.
+        Öffnet die Referenz-PDF im systemseitig installierten PDF-Viewer.
+        """
+        if not self.current_ref_pdf_path or not self.current_ref_pdf_path.exists():
+            QMessageBox.warning(self, "Fehler", "Referenz-PDF nicht gefunden")
+            logger.warning("Referenz-PDF nicht verfügbar")
+            return
+
+        logger.info(f"Öffne Referenz-PDF im System-Viewer: {self.current_ref_pdf_path}")
+        url = QUrl.fromLocalFile(str(self.current_ref_pdf_path))
+        if not QDesktopServices.openUrl(url):
+            QMessageBox.critical(self, "Fehler", f"Konnte Referenz-PDF nicht öffnen:\n{self.current_ref_pdf_path}")
+            logger.error(f"Fehler beim Öffnen der Referenz-PDF: {self.current_ref_pdf_path}")
+
+    def _load_ref_pdf_for_display(self, xml_file_path: Path, xsl_id_str: str):
+        """
+        Lädt nur die Ref-PDF in den Viewer (wenn keine Diff-PDF vorhanden ist).
+
+        Args:
+            xml_file_path: Pfad zur XML-Datei (relativ)
+            xsl_id_str: XSL-ID als String
+        """
+        try:
+            if not self.project:
+                return
+
+            xml_stem = xml_file_path.stem
+            pdf_basename = f"{xml_stem}_xsl_{xsl_id_str}.pdf"
+            ref_pdf_path = self.project.project_dir / "ref" / pdf_basename
+
+            if not ref_pdf_path.exists():
+                if self.pdf_documents:
+                    self._clear_pdf_viewer()
+                return
+
+            logger.info(f"Lade Ref-PDF für Anzeige: {pdf_basename}")
+
+            self._clear_layout(self.ui.verticalLayout_2)
+            self._clear_layout(self.ui.verticalLayout_3)
+            self.ui.verticalLayout_2.setSpacing(5)
+            self.ui.verticalLayout_2.setContentsMargins(0, 0, 0, 0)
+
+            self.thumbnail_to_page = {}
+            self.pdf_documents = {}
+            self.current_rendered_pixmaps = None
+            self.fullsize_label = None
+
+            ref_doc = QPdfDocument()
+            ref_doc.load(str(ref_pdf_path))
+
+            if ref_doc.status() != QPdfDocument.Status.Ready:
+                QMessageBox.critical(self, "Fehler", f"Fehler beim Laden der Ref-PDF:\n{pdf_basename}")
+                return
+
+            # Ref-Doc in allen drei Slots speichern, damit render_and_display_page funktioniert
+            self.pdf_documents[pdf_basename] = {"diff": ref_doc, "ref": ref_doc, "new": ref_doc}
+
+            self.current_ref_pdf_path = ref_pdf_path
+            self.current_new_pdf_path = None
+            self.ui.view_ref_pdf.setEnabled(True)
+            self.ui.view_new_pdf.setEnabled(False)
+
+            # Alpha deaktivieren (Blending nicht sinnvoll ohne Diff), Zoom aktivieren
+            self.ui.alpha.setValue(0)
+            self.ui.alpha.setEnabled(False)
+            self.ui.zoom.setEnabled(True)
+
+            self.ui.accept_changes.setEnabled(False)
+
+            max_pages = ref_doc.pageCount()
+            logger.info(f"Ref-PDF geladen: {pdf_basename}, {max_pages} Seiten")
+
+            thumbnail_labels = []
+            for page_num in range(max_pages):
+                thumbnail = QLabel()
+                thumbnail.setObjectName(f"thumbnail_{pdf_basename}_page_{page_num + 1}")
+                thumbnail.setText(f"Seite {page_num + 1}\n…")
+                thumbnail.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
+                thumbnail.setMouseTracking(True)
+                thumbnail.setAlignment(Qt.AlignmentFlag.AlignCenter)
+                thumbnail.setMinimumHeight(150)
+                self.ui.verticalLayout_2.addWidget(thumbnail)
+
+                thumbnail_info = QLabel(f"Seite {page_num + 1}")
+                thumbnail_info.setAlignment(Qt.AlignmentFlag.AlignCenter)
+                thumbnail_info.setMaximumHeight(18)
+                thumbnail_info.setContentsMargins(0, 0, 0, 0)
+                self.ui.verticalLayout_2.addWidget(thumbnail_info)
+
+                self.thumbnail_to_page[thumbnail] = {"pdf_filename": pdf_basename, "page_num": page_num}
+                thumbnail.mousePressEvent = lambda event, t=thumbnail: self.on_thumbnail_clicked(event, t)
+                thumbnail_labels.append(thumbnail)
+
+            self._schedule_thumbnail_rendering(ref_doc, pdf_basename, thumbnail_labels, 0)
+
+            spacer = QSpacerItem(20, 40, QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Expanding)
+            self.ui.verticalLayout_2.addItem(spacer)
+
+            if self.fullsize_label is None:
+                self.fullsize_label = QLabel()
+                self.fullsize_label.setObjectName("fullsize_current_page")
+                self.fullsize_label.setAlignment(Qt.AlignmentFlag.AlignHCenter)
+                self.fullsize_label.setCursor(QCursor(Qt.CursorShape.OpenHandCursor))
+                self.ui.verticalLayout_3.addWidget(self.fullsize_label)
+
+                self.fullsize_label.mousePressEvent = lambda event: self.on_fullsize_mouse_press(
+                    event, self.fullsize_label
+                )
+                self.fullsize_label.mouseMoveEvent = lambda event: self.on_fullsize_mouse_move(
+                    event, self.fullsize_label
+                )
+                self.fullsize_label.mouseReleaseEvent = lambda event: self.on_fullsize_mouse_release(
+                    event, self.fullsize_label
+                )
+
+            self.current_pdf = pdf_basename
+            self.current_diff_xml_path = None
+            self.current_diff_xsl_id = None
+
+            self.render_and_display_page(pdf_basename, 0)
+            logger.info(f"Ref-PDF-Anzeige geladen: {pdf_basename}")
+
+        except Exception as e:
+            logger.error(f"Fehler beim Laden der Ref-PDF: {e}")
+            QMessageBox.critical(self, "Fehler", f"Konnte Ref-PDF nicht laden:\n{str(e)}")
+
+    def _on_view_new_pdf_clicked(self):
+        """
+        Handler für view_new_pdf Button.
+        Öffnet die neue PDF im systemseitig installierten PDF-Viewer.
+        """
+        if not self.current_new_pdf_path or not self.current_new_pdf_path.exists():
+            QMessageBox.warning(self, "Fehler", "Neue PDF nicht gefunden")
+            logger.warning("Neue PDF nicht verfügbar")
+            return
+
+        logger.info(f"Öffne neue PDF im System-Viewer: {self.current_new_pdf_path}")
+        url = QUrl.fromLocalFile(str(self.current_new_pdf_path))
+        if not QDesktopServices.openUrl(url):
+            QMessageBox.critical(self, "Fehler", f"Konnte neue PDF nicht öffnen:\n{self.current_new_pdf_path}")
+            logger.error(f"Fehler beim Öffnen der neuen PDF: {self.current_new_pdf_path}")

src/ui/mixins/transformation.py

@@ -0,0 +1,846 @@
+"""
+TransformationMixin - Mixin für XSL-Transformationen.
+
+Dieses Mixin enthält alle Methoden zur Durchführung und Verwaltung von
+XSL-Transformationen für das MainWindow.
+"""
+
+import logging
+from copy import deepcopy
+from pathlib import Path
+
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import QMessageBox, QProgressBar, QTreeWidgetItem
+
+from conf import app_settings, TreeNode, XslFile, XmlFile
+from transform import TransformationJob
+from ui.threads import TransformationThread
+from xsl_dependencies import XslDependencyGraph
+
+logger = logging.getLogger(__name__)
+
+
+class TransformationMixin:
+    """
+    Mixin für XSL-Transformationen.
+
+    Dieses Mixin wird von MainWindow verwendet und erwartet folgende Attribute:
+    - self.project: Das aktuelle Projekt
+    - self.ui: Das UI-Objekt mit treeWidget, statusBar
+    - self.transformation_thread: Thread für Transformationen
+    - self.transformation_progress_bar: QProgressBar für Transformation-Fortschritt
+    - self.xml_item_map: Mapping von xml_path|xsl_id zu TreeWidgetItems
+    - self.last_saxon_metrics: Gecachte Saxon-Worker-Pool-Metriken
+    - self.last_fop_metrics: Gecachte FOP-Worker-Pool-Metriken
+    - self.xsl_dependency_graph: XslDependencyGraph für Import/Include-Erkennung
+
+    Erwartet folgende Methoden von anderen Mixins:
+    - self._initialize_saxon_worker_pool(): Von WorkerPoolMixin
+    - self._initialize_fop_worker_pool(): Von WorkerPoolMixin
+    - self._shutdown_saxon_worker_pool(): Von WorkerPoolMixin
+    - self._shutdown_fop_worker_pool(): Von WorkerPoolMixin
+    - self._create_centered_progress_bar(): Von TreeManagerMixin
+    - self._create_centered_diff_icon(): Von TreeManagerMixin
+    - self._collect_parent_params(): Von TreeManagerMixin
+    - self._update_diff_icons_for_existing_pdfs(): Von MainWindow
+    """
+
+    def _show_transformation_progress_bar(self, total_jobs: int):
+        """
+        Zeigt einen Progressbar in der Statusbar für Transformationen.
+
+        Args:
+            total_jobs: Gesamtanzahl der Transformations-Jobs
+        """
+        if self.transformation_progress_bar is None:
+            self.transformation_progress_bar = QProgressBar()
+            self.transformation_progress_bar.setMaximumHeight(20)
+            self.transformation_progress_bar.setMaximumWidth(300)
+
+        self.transformation_progress_bar.setMinimum(0)
+        self.transformation_progress_bar.setMaximum(total_jobs)
+        self.transformation_progress_bar.setValue(0)
+        self.transformation_progress_bar.setFormat("%v/%m Jobs")
+
+        # Füge Progressbar zur Statusbar hinzu
+        self.statusBar().addPermanentWidget(self.transformation_progress_bar)
+        self.transformation_progress_bar.show()
+
+    def _hide_transformation_progress_bar(self):
+        """Versteckt und entfernt den Transformation-Progressbar aus der Statusbar."""
+        if self.transformation_progress_bar:
+            self.statusBar().removeWidget(self.transformation_progress_bar)
+            self.transformation_progress_bar.hide()
+
+    def _update_transformation_progress(self):
+        """Aktualisiert den Transformation-Progressbar um einen Schritt."""
+        if self.transformation_progress_bar:
+            current_value = self.transformation_progress_bar.value()
+            self.transformation_progress_bar.setValue(current_value + 1)
+
+    def _transform_xml_file(self, item: QTreeWidgetItem, force: bool = False):
+        """
+        Transformiert eine einzelne XML-Datei.
+
+        Args:
+            item: Das TreeWidgetItem der XML-Datei
+            force: Wenn True, wird Transformation auch bei aktuellem Output durchgeführt
+        """
+        try:
+            # Hole XslFile vom Parent-Item
+            parent_item = item.parent()
+            if not parent_item:
+                logger.error("XML-Datei hat kein Parent-Item (XslFile)")
+                QMessageBox.warning(self, "Fehler", "XML-Datei hat keine zugeordnete XSL-Datei")
+                return
+
+            xsl_file_obj = parent_item.data(0, Qt.ItemDataRole.UserRole)
+            if not isinstance(xsl_file_obj, XslFile):
+                logger.error(f"Parent-Item ist kein XslFile: {type(xsl_file_obj)}")
+                QMessageBox.warning(self, "Fehler", "Konnte XSL-Datei nicht ermitteln")
+                return
+
+            # Hole XmlFile-Objekt
+            xml_file_obj = item.data(0, Qt.ItemDataRole.UserRole)
+            if not isinstance(xml_file_obj, XmlFile):
+                logger.error(f"Item ist kein XmlFile: {type(xml_file_obj)}")
+                QMessageBox.warning(self, "Fehler", "Konnte XML-Datei nicht ermitteln")
+                return
+
+            # Erstelle TransformationJob mit TreeWidgetItem-Kontext für Parameter-Sammlung
+            job = self._create_transformation_job(xsl_file_obj, xml_file_obj, parent_item)
+            if not job:
+                QMessageBox.warning(
+                    self,
+                    "Fehler",
+                    "Transformation kann nicht gestartet werden.\n\n"
+                    "Bitte überprüfen Sie, ob XML- und XSL-Dateien existieren.\n"
+                    "Details finden Sie im Log.",
+                )
+                return
+
+            # Starte Transformation in separatem Thread
+            self._start_transformation([job], force=force)
+
+        except Exception as e:
+            logger.error(f"Fehler beim Transformieren der XML-Datei: {e}")
+            QMessageBox.critical(self, "Fehler", f"Fehler beim Transformieren: {str(e)}")
+
+    def _transform_xsl_file(self, item: QTreeWidgetItem, force: bool = False):
+        """
+        Transformiert alle XML-Dateien einer XSL-Datei.
+
+        Args:
+            item: Das TreeWidgetItem der XSL-Datei
+            force: Wenn True, wird Transformation auch bei aktuellem Output durchgeführt
+        """
+        try:
+            # Hole XslFile-Objekt
+            xsl_file_obj = item.data(0, Qt.ItemDataRole.UserRole)
+            if not isinstance(xsl_file_obj, XslFile):
+                logger.error(f"Item ist kein XslFile: {type(xsl_file_obj)}")
+                QMessageBox.warning(self, "Fehler", "Konnte XSL-Datei nicht ermitteln")
+                return
+
+            # Prüfe ob XML-Dateien vorhanden sind
+            if not xsl_file_obj.xmls:
+                QMessageBox.information(self, "Info", "Keine XML-Dateien zugeordnet")
+                return
+
+            # Erstelle TransformationJobs für alle XML-Dateien
+            jobs = []
+            skipped_count = 0
+            for xml_file_obj in xsl_file_obj.xmls:
+                # Übergebe das XslFile-TreeWidgetItem für Parameter-Sammlung
+                job = self._create_transformation_job(xsl_file_obj, xml_file_obj, item)
+                if job:
+                    jobs.append(job)
+                else:
+                    skipped_count += 1
+
+            if not jobs:
+                QMessageBox.warning(
+                    self,
+                    "Fehler",
+                    f"Konnte keine gültigen Transformations-Jobs erstellen.\n\n"
+                    f"{skipped_count} XML-Datei(en) wurden übersprungen (fehlende Dateien).",
+                )
+                return
+
+            # Informiere Benutzer wenn einige Jobs übersprungen wurden
+            if skipped_count > 0:
+                logger.warning(f"{skipped_count} von {len(xsl_file_obj.xmls)} Jobs übersprungen (fehlende Dateien)")
+                QMessageBox.warning(
+                    self,
+                    "Warnung",
+                    f"{skipped_count} von {len(xsl_file_obj.xmls)} XML-Datei(en) werden übersprungen "
+                    f"(fehlende XML- oder XSL-Dateien).\n\n"
+                    f"{len(jobs)} Job(s) werden ausgeführt.",
+                )
+
+            # Starte Transformation in separatem Thread
+            self._start_transformation(jobs, force=force)
+
+        except Exception as e:
+            logger.error(f"Fehler beim Transformieren der XSL-Datei: {e}")
+            QMessageBox.critical(self, "Fehler", f"Fehler beim Transformieren: {str(e)}")
+
+    def _count_diff_pdfs_under_node(self, node: TreeNode | XslFile, node_item: QTreeWidgetItem) -> int:
+        """
+        Zählt die Anzahl der existierenden Diff-PDFs unter einem Knoten.
+
+        Args:
+            node: TreeNode oder XslFile Objekt
+            node_item: Das TreeWidgetItem des Knotens
+
+        Returns:
+            int: Anzahl der existierenden Diff-PDF-Dateien
+        """
+        count = 0
+
+        if isinstance(node, XslFile):
+            # Für XslFile: Zähle Diff-PDFs für jede XML-Datei
+            if not self.project:
+                return 0
+
+            diff_dir = self.project.project_dir / "diff"
+            xsl_id_str = "_".join(str(x) for x in node.id) if node.id else ""
+
+            for xml_file_obj in node.xmls:
+                xml_stem = xml_file_obj.xml.stem
+                pdf_basename = f"{xml_stem}_xsl_{xsl_id_str}.pdf"
+                diff_pdf_path = diff_dir / pdf_basename
+
+                if diff_pdf_path.exists():
+                    count += 1
+
+        elif isinstance(node, TreeNode):
+            # Für TreeNode: Rekursiv alle Kinder durchgehen
+            for i in range(node_item.childCount()):
+                child_item = node_item.child(i)
+                child_node = child_item.data(0, Qt.ItemDataRole.UserRole)
+
+                if isinstance(child_node, (XslFile, TreeNode)):
+                    count += self._count_diff_pdfs_under_node(child_node, child_item)
+
+        return count
+
+    def _update_diff_pdf_counts_recursive(self, tree_item: QTreeWidgetItem):
+        """
+        Aktualisiert rekursiv die Diff-PDF-Anzahl in Spalte 1 für alle TreeNode und XslFile Items.
+
+        Args:
+            tree_item: Das TreeWidgetItem (kann Root oder beliebiger Knoten sein)
+        """
+        node = tree_item.data(0, Qt.ItemDataRole.UserRole)
+
+        # Aktualisiere nur für TreeNode und XslFile, nicht für XmlFile
+        if isinstance(node, (TreeNode, XslFile)):
+            count = self._count_diff_pdfs_under_node(node, tree_item)
+            tree_item.setText(1, str(count) if count > 0 else "")
+
+        # Rekursiv für alle Kinder
+        for i in range(tree_item.childCount()):
+            child_item = tree_item.child(i)
+            self._update_diff_pdf_counts_recursive(child_item)
+
+    def _update_all_diff_pdf_counts(self):
+        """
+        Aktualisiert die Diff-PDF-Anzahl für alle Knoten im TreeWidget.
+        """
+        root = self.ui.treeWidget.invisibleRootItem()
+        for i in range(root.childCount()):
+            self._update_diff_pdf_counts_recursive(root.child(i))
+
+    def _has_xml_files_recursive(self, node: TreeNode) -> bool:
+        """
+        Prüft rekursiv, ob unter einem TreeNode mindestens eine XML-Datei vorhanden ist.
+
+        Args:
+            node: Der TreeNode
+
+        Returns:
+            bool: True wenn mindestens eine XML-Datei gefunden wurde
+        """
+        if not hasattr(node, "children") or not node.children:
+            return False
+
+        for child in node.children:
+            if isinstance(child, XslFile):
+                if child.xmls:
+                    return True
+            elif isinstance(child, TreeNode):
+                if self._has_xml_files_recursive(child):
+                    return True
+
+        return False
+
+    def _collect_all_xsl_xml_pairs_recursive(
+        self, tree_node: TreeNode, tree_item: QTreeWidgetItem
+    ) -> list[tuple[XslFile, XmlFile, QTreeWidgetItem]]:
+        """
+        Sammelt rekursiv alle (XslFile, XmlFile, XslFileItem) Tupel unter einem TreeNode.
+
+        Args:
+            tree_node: Der TreeNode
+            tree_item: Das TreeWidgetItem des TreeNode
+
+        Returns:
+            list: Liste von (XslFile, XmlFile, XslFileItem) Tupeln
+        """
+        pairs = []
+
+        if not hasattr(tree_node, "children") or not tree_node.children:
+            return pairs
+
+        # Durchlaufe alle Kinder des TreeNode
+        for i in range(tree_item.childCount()):
+            child_item = tree_item.child(i)
+            child_node = child_item.data(0, Qt.ItemDataRole.UserRole)
+
+            if isinstance(child_node, XslFile):
+                # XslFile gefunden - sammle alle XML-Dateien
+                for xml_file_obj in child_node.xmls:
+                    pairs.append((child_node, xml_file_obj, child_item))
+
+            elif isinstance(child_node, TreeNode):
+                # Rekursiv in Unterknoten suchen
+                pairs.extend(self._collect_all_xsl_xml_pairs_recursive(child_node, child_item))
+
+        return pairs
+
+    def _transform_tree_node(self, item: QTreeWidgetItem, force: bool = False):
+        """
+        Transformiert alle XML-Dateien unter einem TreeNode (rekursiv).
+
+        Args:
+            item: Das TreeWidgetItem des TreeNode
+            force: Wenn True, wird Transformation auch bei aktuellem Output durchgeführt
+        """
+        try:
+            # Hole TreeNode-Objekt
+            tree_node_obj = item.data(0, Qt.ItemDataRole.UserRole)
+            if not isinstance(tree_node_obj, TreeNode):
+                logger.error(f"Item ist kein TreeNode: {type(tree_node_obj)}")
+                QMessageBox.warning(self, "Fehler", "Konnte TreeNode nicht ermitteln")
+                return
+
+            # Prüfe ob XML-Dateien vorhanden sind
+            if not self._has_xml_files_recursive(tree_node_obj):
+                QMessageBox.information(self, "Info", "Keine XML-Dateien unter diesem Knoten gefunden")
+                return
+
+            # Sammle alle XSL/XML-Paare rekursiv
+            xsl_xml_pairs = self._collect_all_xsl_xml_pairs_recursive(tree_node_obj, item)
+
+            if not xsl_xml_pairs:
+                QMessageBox.information(self, "Info", "Keine XML-Dateien gefunden")
+                return
+
+            # Erstelle TransformationJobs für alle XML-Dateien
+            jobs = []
+            skipped_count = 0
+            for xsl_file_obj, xml_file_obj, xsl_file_item in xsl_xml_pairs:
+                # Übergebe das XslFile-TreeWidgetItem für Parameter-Sammlung
+                job = self._create_transformation_job(xsl_file_obj, xml_file_obj, xsl_file_item)
+                if job:
+                    jobs.append(job)
+                else:
+                    skipped_count += 1
+
+            if not jobs:
+                QMessageBox.warning(
+                    self,
+                    "Fehler",
+                    f"Konnte keine gültigen Transformations-Jobs erstellen.\n\n"
+                    f"{skipped_count} XML-Datei(en) wurden übersprungen (fehlende Dateien).",
+                )
+                return
+
+            # Informiere Benutzer wenn einige Jobs übersprungen wurden
+            if skipped_count > 0:
+                logger.warning(f"{skipped_count} von {len(xsl_xml_pairs)} Jobs übersprungen (fehlende Dateien)")
+                QMessageBox.warning(
+                    self,
+                    "Warnung",
+                    f"{skipped_count} von {len(xsl_xml_pairs)} XML-Datei(en) werden übersprungen "
+                    f"(fehlende XML- oder XSL-Dateien).\n\n"
+                    f"{len(jobs)} Job(s) werden ausgeführt.",
+                )
+
+            logger.info(f"Starte Transformation für {len(jobs)} XML-Dateien unter TreeNode '{tree_node_obj.bez}'")
+
+            # Starte Transformation in separatem Thread
+            self._start_transformation(jobs, force=force)
+
+        except Exception as e:
+            logger.error(f"Fehler beim Transformieren des TreeNode: {e}")
+            QMessageBox.critical(self, "Fehler", f"Fehler beim Transformieren: {str(e)}")
+
+    def _get_cached_project_tools(self):
+        """
+        Gibt die aufgelösten Tool-Konfigurationen des aktuellen Projekts zurück (gecacht).
+
+        Der Cache wird invalidiert, sobald sich die Projekt-ID ändert.
+        """
+        project_id = self.project.id if self.project else None
+        if getattr(self, "_tool_cache_project_id", None) != project_id:
+            self._tool_cache_project_id = project_id
+            self._tool_cache = (
+                next((jvm for jvm in app_settings.java_vms if jvm.id == self.project.java_vm_id), None),
+                next((sj for sj in app_settings.saxon_jars if sj.id == self.project.saxon_jar_id), None),
+                next((af for af in app_settings.apache_fops if af.id == self.project.apache_fop_id), None),
+                next((dp for dp in app_settings.diff_pdfs if dp.id == self.project.diff_pdf_id), None),
+                next((xd for xd in app_settings.xsl_dirs if xd.id == self.project.xsl_dir_id), None),
+            )
+        return self._tool_cache
+
+    def _create_transformation_job(
+        self, xsl_file_obj: XslFile, xml_file_obj: XmlFile, xsl_file_item: QTreeWidgetItem | None = None
+    ) -> TransformationJob | None:
+        """
+        Erstellt einen TransformationJob für eine XML/XSL-Kombination.
+
+        Args:
+            xsl_file_obj: Das XslFile-Objekt
+            xml_file_obj: Das XmlFile-Objekt
+            xsl_file_item: Optional das TreeWidgetItem des XslFile für hierarchische Parameter-Sammlung
+
+        Returns:
+            TransformationJob oder None bei Fehler
+        """
+        try:
+            if not self.project:
+                QMessageBox.warning(self, "Fehler", "Kein Projekt geöffnet")
+                return None
+
+            # Tool-Konfigurationen gecacht auflösen (einmalig pro Projekt)
+            java_vm, saxon_jar, apache_fop, diff_pdf, xsl_dir = self._get_cached_project_tools()
+
+            # Prüfe ob alle Konfigurationen vorhanden sind
+            if not all([java_vm, saxon_jar, apache_fop, diff_pdf, xsl_dir]):
+                missing = []
+                if not java_vm:
+                    missing.append("Java VM")
+                if not saxon_jar:
+                    missing.append("Saxon JAR")
+                if not apache_fop:
+                    missing.append("Apache FOP")
+                if not diff_pdf:
+                    missing.append("diff-pdf")
+                if not xsl_dir:
+                    missing.append("XSL-Verzeichnis")
+
+                QMessageBox.warning(
+                    self, "Fehlende Konfiguration", f"Folgende Konfigurationen fehlen: {', '.join(missing)}"
+                )
+                return None
+
+            # Zusätzliche Sicherheitsprüfung für path_to_binary_file Attribute
+            if java_vm is None or not hasattr(java_vm, "path_to_binary_file") or java_vm.path_to_binary_file is None:
+                QMessageBox.warning(self, "Konfigurationsfehler", "Java VM Pfad ist nicht konfiguriert")
+                return None
+
+            if saxon_jar is None or not hasattr(saxon_jar, "path_to_jar_file") or saxon_jar.path_to_jar_file is None:
+                QMessageBox.warning(self, "Konfigurationsfehler", "Saxon JAR Pfad ist nicht konfiguriert")
+                return None
+
+            if apache_fop is None or not hasattr(apache_fop, "path_to_dir") or apache_fop.path_to_dir is None:
+                QMessageBox.warning(self, "Konfigurationsfehler", "Apache FOP Pfad ist nicht konfiguriert")
+                return None
+
+            if diff_pdf is None or not hasattr(diff_pdf, "path_to_binary_file") or diff_pdf.path_to_binary_file is None:
+                QMessageBox.warning(self, "Konfigurationsfehler", "diff-pdf Pfad ist nicht konfiguriert")
+                return None
+
+            if xsl_dir is None or not hasattr(xsl_dir, "path_to_root_dir") or xsl_dir.path_to_root_dir is None:
+                QMessageBox.warning(self, "Konfigurationsfehler", "XSL-Verzeichnis Pfad ist nicht konfiguriert")
+                return None
+
+            # Erstelle absoluten Pfad zur XSL-Datei
+            xsl_file_abs = xsl_dir.path_to_root_dir / xsl_file_obj.xsl_file
+
+            # Prüfe ob XSL-Datei existiert
+            if not xsl_file_abs.exists():
+                error_msg = f"XSL-Datei nicht gefunden: {xsl_file_abs}"
+                logger.error(error_msg)
+                # Kein MessageBox hier - wird in der aufrufenden Funktion behandelt
+                return None
+
+            # Erstelle absoluten Pfad zur XML-Datei
+            xml_file_abs = self.project.project_dir / xml_file_obj.xml
+
+            # Prüfe ob XML-Datei existiert
+            if not xml_file_abs.exists():
+                error_msg = f"XML-Datei nicht gefunden: {xml_file_abs}"
+                logger.error(error_msg)
+                # Kein MessageBox hier - wird in der aufrufenden Funktion behandelt
+                return None
+
+            # Sammle XSLT-Parameter hierarchisch (TreeNode-Eltern → XslFile)
+            xslt_params = {}
+
+            # 1. Sammle Parameter von übergeordneten TreeNodes (falls TreeWidgetItem verfügbar)
+            if xsl_file_item is not None:
+                parent_params = self._collect_parent_params(xsl_file_item)
+                xslt_params.update(parent_params)
+                logger.debug(f"Hierarchische Parameter gesammelt: {parent_params}")
+            else:
+                # Ohne TreeWidgetItem-Kontext: nur Projekt-Parameter als Basis
+                if hasattr(self, "project") and self.project and self.project.xslt_params:
+                    xslt_params.update(self.project.xslt_params)
+                logger.warning(
+                    "Kein TreeWidgetItem-Kontext verfügbar - "
+                    "übergeordnete TreeNode-Parameter werden nicht berücksichtigt"
+                )
+
+            # 2. Überschreibe mit XslFile-eigenen Parametern (höchste Priorität)
+            xslt_params.update(xsl_file_obj.xslt_params)
+
+            logger.info(f"Finale XSLT-Parameter für {xml_file_obj.xml} mit {xsl_file_obj.bez}: {xslt_params}")
+
+            # Initialisiere XSL-Abhängigkeitsgraph (lazy, einmalig pro Mixin-Instanz)
+            if not hasattr(self, "xsl_dependency_graph") or self.xsl_dependency_graph is None:
+                self.xsl_dependency_graph = XslDependencyGraph()
+
+            # Erstelle TransformationJob
+            job = TransformationJob(
+                project_dir=self.project.project_dir,
+                xml_file=xml_file_obj.xml,
+                xsl_file=xsl_file_abs,
+                xslt_params=xslt_params,
+                java_vm_path=java_vm.path_to_binary_file,
+                saxon_jar_path=saxon_jar.path_to_jar_file,
+                apache_fop_dir=apache_fop.path_to_dir,
+                diff_pdf_path=diff_pdf.path_to_binary_file,
+                diff_pdf_params=diff_pdf.default_params,
+                xsl_id=xsl_file_obj.id,
+                fop_config_dir=self.project.fop_config_dir,
+                dependency_graph=self.xsl_dependency_graph,
+            )
+
+            return job
+
+        except Exception as e:
+            logger.error(f"Fehler beim Erstellen des TransformationJobs: {e}")
+            QMessageBox.critical(self, "Fehler", f"Fehler beim Erstellen des Jobs: {str(e)}")
+            return None
+
+    def _start_transformation(self, jobs: list[TransformationJob], force: bool = False):
+        """
+        Startet die Transformation in einem separaten Thread.
+
+        Args:
+            jobs: Liste der TransformationJobs
+            force: Wenn True, werden alle Jobs ausgeführt (ignoriert Up-to-Date)
+        """
+        try:
+            # Prüfe ob bereits ein Thread läuft
+            if self.transformation_thread and self.transformation_thread.isRunning():
+                QMessageBox.warning(self, "Warnung", "Es läuft bereits eine Transformation")
+                return
+
+            # Erstelle und konfiguriere Thread
+            self.transformation_thread = TransformationThread(jobs, force=force, max_workers=app_settings.max_workers)
+
+            # Verbinde Signale
+            self.transformation_thread.job_started.connect(self._on_transformation_job_started)
+            self.transformation_thread.job_finished.connect(self._on_transformation_job_finished)
+            self.transformation_thread.job_error.connect(self._on_transformation_job_error)
+            self.transformation_thread.all_jobs_finished.connect(self._on_all_transformations_finished)
+
+            # Zeige Progressbar
+            self._show_transformation_progress_bar(len(jobs))
+
+            # Initialisiere Worker-Pools (lazy loading - nur wenn benötigt)
+            self._initialize_saxon_worker_pool()
+            self._initialize_fop_worker_pool()
+
+            # Erfasse RAM-Verbrauch vor Transformation
+            import transform
+
+            if transform._saxon_worker_pool:
+                transform._saxon_worker_pool.capture_ram_before_transform()
+            if transform._fop_worker_pool:
+                transform._fop_worker_pool.capture_ram_before_transform()
+
+            # Starte Thread
+            self.transformation_thread.start()
+
+            logger.info(f"Transformation von {len(jobs)} Job(s) gestartet (force={force})")
+            self.statusBar().showMessage(f"Transformation von {len(jobs)} Job(s) gestartet...")
+
+        except Exception as e:
+            logger.error(f"Fehler beim Starten der Transformation: {e}")
+            QMessageBox.critical(self, "Fehler", f"Fehler beim Starten: {str(e)}")
+
+    def _expand_tree_item_parents(self, item: QTreeWidgetItem):
+        """
+        Öffnet alle Eltern-Knoten eines Tree-Items rekursiv.
+
+        Args:
+            item: Das Tree-Item, dessen Eltern geöffnet werden sollen
+        """
+        if item is None:
+            return
+
+        # Rekursiv alle Eltern öffnen
+        parent = item.parent()
+        while parent is not None:
+            parent.setExpanded(True)
+            parent = parent.parent()
+
+    def _on_transformation_job_started(self, xml_file_name: str, xsl_id_str: str):
+        """
+        Signal-Handler: Ein Job wurde gestartet.
+
+        Args:
+            xml_file_name: Name der XML-Datei
+            xsl_id_str: XSL-ID als String (z.B. "2002_1_128")
+        """
+        logger.info(f"Transformation gestartet: {xml_file_name} (XSL-ID: {xsl_id_str})")
+        self.statusBar().showMessage(f"Transformiere: {xml_file_name}")
+
+        # Progress Bar anzeigen
+        map_key = f"{xml_file_name}|{xsl_id_str}"
+        logger.info(f"Suche TreeWidget-Item für: '{map_key}'")
+        logger.info(f"Map hat {len(self.xml_item_map)} Einträge")
+        tree_item = self.xml_item_map.get(map_key)
+        if tree_item:
+            # Öffne alle Eltern-Knoten, damit der Benutzer den Fortschritt sehen kann
+            self._expand_tree_item_parents(tree_item)
+
+            # Scrolle zum Item, damit es sichtbar ist
+            self.ui.treeWidget.scrollToItem(tree_item)
+
+            # Entferne vorhandenes Widget (falls Icon vorhanden)
+            self.ui.treeWidget.removeItemWidget(tree_item, 1)
+
+            # Erstelle und setze Progress Bar
+            progress_widget, progress_bar = self._create_centered_progress_bar()
+            self.ui.treeWidget.setItemWidget(tree_item, 1, progress_widget)
+
+            logger.debug(f"Progress Bar für {xml_file_name} gesetzt und Eltern-Knoten geöffnet")
+        else:
+            logger.warning(f"Kein TreeWidget-Item für {xml_file_name} gefunden")
+
+    def _on_transformation_job_finished(self, result: dict):
+        """
+        Signal-Handler: Ein Job wurde abgeschlossen.
+
+        Args:
+            result: Ergebnis-Dictionary
+        """
+        # Aktualisiere Transformation-Progressbar
+        self._update_transformation_progress()
+
+        xml_file = result.get("xml_file", "?")
+        success = result.get("success", False)
+        duration = result.get("duration", 0)
+
+        if success:
+            logger.info(f"Transformation erfolgreich: {xml_file} ({duration:.2f}s)")
+            pdfs_identical = result.get("pdfs_identical", False)
+            if pdfs_identical:
+                self.statusBar().showMessage(f"✓ {xml_file} - PDFs identisch ({duration:.2f}s)", 3000)
+            else:
+                self.statusBar().showMessage(f"⚠ {xml_file} - Unterschiede gefunden ({duration:.2f}s)", 3000)
+        else:
+            logger.error(f"Transformation fehlgeschlagen: {xml_file}")
+            # Zeige Fehlerdetails an
+            steps = result.get("steps", {})
+            error_msgs = []
+            for step_name, step_info in steps.items():
+                if not step_info.get("success", True):
+                    error_msgs.append(f"{step_name}: {step_info.get('message', 'Unbekannter Fehler')}")
+
+            error_text = "\n".join(error_msgs) if error_msgs else "Unbekannter Fehler"
+            QMessageBox.critical(
+                self, "Transformation fehlgeschlagen", f"XML-Datei: {xml_file}\n\nFehler:\n{error_text}"
+            )
+
+        # Update Widget in Spalte 1: Entferne Progress Bar, zeige Icon wenn Diff-PDF existiert
+        xml_file_str = result.get("xml_file", "")
+        xsl_id = result.get("xsl_id", None)
+        xsl_id_str = "_".join(str(x) for x in xsl_id) if xsl_id else ""
+        map_key = f"{xml_file_str}|{xsl_id_str}"
+        diff_pdf_str = result.get("diff_pdf", None)
+        tree_item = self.xml_item_map.get(map_key)
+
+        if tree_item:
+            # Entferne Progress Bar
+            self.ui.treeWidget.removeItemWidget(tree_item, 1)
+
+            # Wenn Diff-PDF existiert, zeige Icon
+            if diff_pdf_str and Path(diff_pdf_str).exists():
+                xml_file_path = Path(xml_file_str)
+                icon_widget = self._create_centered_diff_icon(xml_file_path, xsl_id_str)
+                self.ui.treeWidget.setItemWidget(tree_item, 1, icon_widget)
+                logger.debug(f"Diff-Icon für {xml_file_str} gesetzt")
+            else:
+                logger.debug(f"Keine Diff-PDF für {xml_file_str}, kein Icon gesetzt")
+
+    def _on_transformation_job_error(self, xml_file_name: str, xsl_id_str: str, error_message: str):
+        """
+        Signal-Handler: Ein Job ist mit einem Fehler abgebrochen.
+
+        Args:
+            xml_file_name: Name der XML-Datei
+            xsl_id_str: XSL-ID als String
+            error_message: Fehlermeldung
+        """
+        # Aktualisiere Transformation-Progressbar
+        self._update_transformation_progress()
+
+        logger.error(f"Transformation-Fehler bei {xml_file_name} (XSL-ID: {xsl_id_str}): {error_message}")
+        QMessageBox.critical(self, "Fehler", f"Fehler bei {xml_file_name}:\n{error_message}")
+
+        # Entferne Progress Bar bei Fehler
+        map_key = f"{xml_file_name}|{xsl_id_str}"
+        tree_item = self.xml_item_map.get(map_key)
+        if tree_item:
+            self.ui.treeWidget.removeItemWidget(tree_item, 1)
+            logger.debug(f"Progress Bar für {map_key} entfernt (Fehler)")
+
+    def _on_all_transformations_finished(self, successful_count: int, total_count: int, total_duration: float):
+        """
+        Signal-Handler: Alle Jobs wurden abgeschlossen.
+
+        Args:
+            successful_count: Anzahl erfolgreicher Jobs
+            total_count: Gesamtanzahl der Jobs
+            total_duration: Gesamtdauer aller Transformationen in Sekunden
+        """
+        logger.info(
+            f"Alle Transformationen abgeschlossen: {successful_count}/{total_count} erfolgreich ({total_duration:.2f}s)"
+        )
+
+        # Erfasse RAM-Verbrauch nach Transformation
+        import transform
+
+        if transform._saxon_worker_pool:
+            transform._saxon_worker_pool.capture_ram_after_transform()
+            # Speichere Metriken vor Shutdown (für späteren Zugriff im Dialog)
+            self.last_saxon_metrics = deepcopy(transform._saxon_worker_pool.metrics)
+            logger.debug("Saxon Worker-Pool Metriken gespeichert")
+
+        if transform._fop_worker_pool:
+            transform._fop_worker_pool.capture_ram_after_transform()
+            # Speichere Metriken vor Shutdown (für späteren Zugriff im Dialog)
+            self.last_fop_metrics = deepcopy(transform._fop_worker_pool.metrics)
+            logger.debug("FOP Worker-Pool Metriken gespeichert")
+
+        # Beende Worker-Pools (RAM-Optimierung - Pools werden bei nächster Transformation neu gestartet)
+        self._shutdown_saxon_worker_pool()
+        self._shutdown_fop_worker_pool()
+
+        # Verstecke Transformation-Progressbar
+        self._hide_transformation_progress_bar()
+
+        # Aktualisiere Diff-PDF-Anzahl und Icons in allen Knoten
+        self._update_all_diff_pdf_counts()
+        self._update_diff_icons_for_existing_pdfs()
+
+        # Formatiere Dauer für Anzeige
+        duration_str = f"{total_duration:.2f}s"
+
+        if successful_count == total_count:
+            self.statusBar().showMessage(f"✓ Alle {total_count} Transformationen erfolgreich ({duration_str})", 5000)
+            QMessageBox.information(
+                self,
+                "Abgeschlossen",
+                f"Alle {total_count} Transformationen wurden erfolgreich abgeschlossen.\n\nGesamtdauer: {duration_str}",
+            )
+        else:
+            failed_count = total_count - successful_count
+            self.statusBar().showMessage(
+                f"⚠ {successful_count}/{total_count} erfolgreich, {failed_count} fehlgeschlagen ({duration_str})", 5000
+            )
+            QMessageBox.warning(
+                self,
+                "Abgeschlossen mit Fehlern",
+                f"{successful_count} von {total_count} Transformationen erfolgreich\n{failed_count} fehlgeschlagen\n\nGesamtdauer: {duration_str}",
+            )
+
+    def _transform_all_xml_files(self, force: bool = False):
+        """
+        Transformiert ALLE XML-Dateien in allen TreeNodes des TreeWidgets.
+
+        Args:
+            force: Wenn True, werden alle Dateien unabhängig vom Änderungsstatus neu transformiert.
+        """
+        try:
+            if not self.project or not self.pdf_project:
+                QMessageBox.warning(self, "Fehler", "Kein Projekt geladen")
+                return
+
+            # Sammle alle XSL/XML-Paare aus allen Root-Nodes
+            all_jobs = []
+            root = self.ui.treeWidget.invisibleRootItem()
+
+            for i in range(root.childCount()):
+                root_item = root.child(i)
+                root_node = root_item.data(0, Qt.ItemDataRole.UserRole)
+
+                if isinstance(root_node, TreeNode):
+                    # Sammle alle XSL/XML-Paare rekursiv
+                    xsl_xml_pairs = self._collect_all_xsl_xml_pairs_recursive(root_node, root_item)
+
+                    # Erstelle TransformationJobs
+                    for xsl_file_obj, xml_file_obj, xsl_file_item in xsl_xml_pairs:
+                        job = self._create_transformation_job(xsl_file_obj, xml_file_obj, xsl_file_item)
+                        if job:
+                            all_jobs.append(job)
+
+                elif isinstance(root_node, XslFile):
+                    # Direkt XslFile als Root-Element
+                    for xml_file_obj in root_node.xmls:
+                        job = self._create_transformation_job(root_node, xml_file_obj, root_item)
+                        if job:
+                            all_jobs.append(job)
+
+            if not all_jobs:
+                QMessageBox.information(self, "Info", "Keine XML-Dateien zum Transformieren gefunden")
+                return
+
+            # Frage Benutzer um Bestätigung
+            if force:
+                title = "Alle XML-Dateien neu transformieren (force)"
+                message = (
+                    f"Möchten Sie wirklich ALLE {len(all_jobs)} XML-Dateien NEU transformieren?\n\n"
+                    f"⚠ WARNUNG: Im Force-Modus werden alle Dateien unabhängig von ihrem Status neu verarbeitet!\n"
+                    f"Dies kann längere Zeit in Anspruch nehmen."
+                )
+                default_button = QMessageBox.StandardButton.No
+            else:
+                title = "Alle XML-Dateien transformieren"
+                message = (
+                    f"Möchten Sie wirklich alle {len(all_jobs)} XML-Dateien transformieren?\n\n"
+                    f"Nur Dateien mit Änderungen werden verarbeitet."
+                )
+                default_button = QMessageBox.StandardButton.Yes
+
+            reply = QMessageBox.question(
+                self,
+                title,
+                message,
+                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
+                default_button,
+            )
+
+            if reply != QMessageBox.StandardButton.Yes:
+                logger.info(f"{'Force-' if force else ''}Transformation abgebrochen durch Benutzer")
+                return
+
+            logger.info(f"Starte {'Force-' if force else ''}Transformation für alle {len(all_jobs)} XML-Dateien")
+
+            # Starte Transformation in separatem Thread
+            self._start_transformation(all_jobs, force=force)
+
+        except Exception as e:
+            logger.error(f"Fehler beim Transformieren aller XML-Dateien: {e}")
+            QMessageBox.critical(self, "Fehler", f"Fehler beim Starten der Transformation: {str(e)}")
+
+    def _transform_all_xml_files_force(self):
+        """Transformiert ALLE XML-Dateien im Force-Modus."""
+        self._transform_all_xml_files(force=True)

src/ui/mixins/worker_pool.py

@@ -0,0 +1,184 @@
+"""
+WorkerPoolMixin - Mixin für Worker-Pool-Verwaltung.
+
+Dieses Mixin enthält alle Methoden zur Verwaltung der Saxon- und FOP-Worker-Pools
+für das MainWindow.
+"""
+
+import logging
+
+from PySide6.QtWidgets import QMessageBox
+
+from conf import app_settings, XsltVersion
+from transform import TransformationJob, get_saxon_worker_pool, set_saxon_worker_pool, get_fop_worker_pool, set_fop_worker_pool
+from saxon_pool import SaxonWorkerPool
+from saxon_pool_s9api import SaxonWorkerPoolS9Api
+
+logger = logging.getLogger(__name__)
+
+
+class WorkerPoolMixin:
+    """
+    Mixin für Worker-Pool-Verwaltung.
+
+    Dieses Mixin wird von MainWindow verwendet und erwartet folgende Attribute:
+    - self.project: Das aktuelle Projekt
+    """
+
+    def _initialize_saxon_worker_pool(self):
+        """Initialisiert den Saxon-Worker-Pool für schnelle Transformationen."""
+        try:
+            # Shutdown vorherigen Pool falls vorhanden
+            self._shutdown_saxon_worker_pool()
+
+            # Prüfe ob SaxonWorkerPool aktiviert ist
+            if not app_settings.use_saxon_worker_pool:
+                logger.info("SaxonWorkerPool deaktiviert - Verwende Fallback-Modus (subprocess)")
+                return
+
+            if not self.project:
+                logger.warning("Kein Projekt geladen, Saxon-Worker-Pool nicht initialisiert")
+                return
+
+            # Hole Tool-Konfigurationen
+            java_vm = next((vm for vm in app_settings.java_vms if vm.id == self.project.java_vm_id), None)
+            saxon_jar = next((jar for jar in app_settings.saxon_jars if jar.id == self.project.saxon_jar_id), None)
+
+            if not java_vm or not saxon_jar:
+                logger.warning("Java VM oder Saxon JAR nicht gefunden, Pool nicht initialisiert")
+                return
+
+            # Erstelle Worker-Pool (wähle richtige Variante basierend auf XSLT-Version)
+            num_workers = app_settings.max_workers
+            log_dir = self.project.project_dir / "tmp"
+
+            # Wähle die richtige Worker-Pool-Implementierung
+            if app_settings.saxon_xslt_version == XsltVersion.XSLT_1_0:
+                # JAXP-basierte Variante für XSLT 1.0
+                pool = SaxonWorkerPool(
+                    num_workers=num_workers,
+                    java_vm_path=java_vm.path_to_binary_file,
+                    saxon_jar_path=saxon_jar.path_to_jar_file,
+                    classpath_cache=TransformationJob._classpath_cache,
+                    log_dir=log_dir,
+                )
+                pool_type = "JAXP (XSLT 1.0)"
+            else:
+                # s9api-basierte Variante für XSLT 2.0/3.0
+                pool = SaxonWorkerPoolS9Api(
+                    num_workers=num_workers,
+                    java_vm_path=java_vm.path_to_binary_file,
+                    saxon_jar_path=saxon_jar.path_to_jar_file,
+                    classpath_cache=TransformationJob._classpath_cache,
+                    log_dir=log_dir,
+                )
+                pool_type = "s9api (XSLT 2.0/3.0)"
+
+            # Setze globalen Pool
+            set_saxon_worker_pool(pool)
+
+            logger.info(
+                f"Saxon-Worker-Pool initialisiert: {num_workers} Worker mit {pool_type} "
+                f"(erwartet: {num_workers}x schneller für Saxon-Transformationen)"
+            )
+
+        except Exception as e:
+            logger.error(f"Fehler beim Initialisieren des Saxon-Worker-Pools: {e}")
+            logger.info("Fallback auf subprocess-Modus")
+            # Kein Pool ist OK - Fallback auf subprocess
+
+    def _shutdown_saxon_worker_pool(self):
+        """Beendet den Saxon-Worker-Pool sauber."""
+        try:
+            pool = get_saxon_worker_pool()
+            if pool:
+                logger.info("Beende Saxon-Worker-Pool...")
+                pool.shutdown()
+                set_saxon_worker_pool(None)
+                logger.info("Saxon-Worker-Pool beendet")
+
+        except Exception as e:
+            logger.error(f"Fehler beim Beenden des Saxon-Worker-Pools: {e}")
+
+    def _initialize_fop_worker_pool(self):
+        """Initialisiert den FOP-Worker-Pool für schnelle PDF-Generierung."""
+        try:
+            # Shutdown vorherigen Pool falls vorhanden
+            self._shutdown_fop_worker_pool()
+
+            # Prüfe ob FopWorkerPool aktiviert ist
+            if not app_settings.use_fop_worker_pool:
+                logger.info("FopWorkerPool deaktiviert - Verwende Fallback-Modus (subprocess)")
+                return
+
+            if not self.project:
+                logger.warning("Kein Projekt geladen, FOP-Worker-Pool nicht initialisiert")
+                return
+
+            # Hole Tool-Konfigurationen
+            java_vm = next((vm for vm in app_settings.java_vms if vm.id == self.project.java_vm_id), None)
+            apache_fop = next((fop for fop in app_settings.apache_fops if fop.id == self.project.apache_fop_id), None)
+
+            if not java_vm or not apache_fop:
+                logger.warning("Java VM oder Apache FOP nicht gefunden, Pool nicht initialisiert")
+                return
+
+            # FOP-Konfigurationsdatei (falls vorhanden)
+            fop_config_file = None
+            if self.project.fop_config_dir:
+                fop_config_file = self.project.fop_config_dir / "fop.xconf"
+            else:
+                default_config = apache_fop.path_to_dir / "conf" / "fop.xconf"
+                if default_config.exists():
+                    fop_config_file = default_config
+
+            # Importiere FopWorkerPool
+            from fop_pool import FopWorkerPool
+
+            # Erstelle Worker-Pool
+            num_workers = app_settings.max_workers
+            log_dir = self.project.project_dir / "tmp"
+            pool = FopWorkerPool(
+                num_workers=num_workers,
+                java_vm_path=java_vm.path_to_binary_file,
+                apache_fop_dir=apache_fop.path_to_dir,
+                fop_config_file=fop_config_file,
+                log_dir=log_dir,
+            )
+
+            # Setze globalen Pool
+            set_fop_worker_pool(pool)
+
+            logger.info(
+                f"FOP-Worker-Pool initialisiert: {num_workers} Worker "
+                f"(erwartet: {num_workers}x schneller für PDF-Generierung)"
+            )
+
+        except Exception as e:
+            logger.error(f"Fehler beim Initialisieren des FOP-Worker-Pools: {e}")
+            logger.info("Fallback auf subprocess-Modus")
+            # Kein Pool ist OK - Fallback auf subprocess
+
+    def _shutdown_fop_worker_pool(self):
+        """Beendet den FOP-Worker-Pool sauber."""
+        try:
+            pool = get_fop_worker_pool()
+            if pool:
+                logger.info("Beende FOP-Worker-Pool...")
+                pool.shutdown()
+                set_fop_worker_pool(None)
+                logger.info("FOP-Worker-Pool beendet")
+
+        except Exception as e:
+            logger.error(f"Fehler beim Beenden des FOP-Worker-Pools: {e}")
+
+    def _show_worker_pool_metrics(self):
+        """Zeigt den Worker-Pool-Metriken-Dialog an."""
+        try:
+            from ui.WorkerPoolMetricsDialog import WorkerPoolMetricsDialog
+
+            dialog = WorkerPoolMetricsDialog(self)
+            dialog.exec()
+        except Exception as e:
+            logger.error(f"Fehler beim Öffnen des Metriken-Dialogs: {e}")
+            QMessageBox.critical(self, "Fehler", f"Fehler beim Öffnen des Metriken-Dialogs:\n{str(e)}")

src/ui/threads.py

@@ -0,0 +1,422 @@
+"""
+Thread-Klassen für asynchrone Operationen in DocuMentor.
+
+Dieses Modul enthält alle QThread-Klassen, die für Hintergrundoperationen verwendet werden:
+- XmlHashCalculatorThread: Berechnung von blake2b-Hashes für XML-Dateien
+- XmlBatchProcessingThread: Batch-Verarbeitung von XML-Dateien
+- TransformationThread: Ausführung von XSL-Transformationen
+"""
+
+import logging
+import shutil
+from pathlib import Path
+from PySide6.QtCore import QThread, Signal
+
+from conf import TreeNode, XslFile, XmlFile
+from transform import TransformationJob
+from utils import calculate_blake2b_hash
+
+
+logger = logging.getLogger(__name__)
+
+
+class XmlHashCalculatorThread(QThread):
+    """
+    Thread für die asynchrone Berechnung von blake2b-Hash-Werten für XML-Dateien.
+    """
+
+    # Signale für die Kommunikation mit dem Haupt-Thread
+    hash_calculated = Signal(object, str)  # xml_file_object, hash_value
+    calculation_finished = Signal(int, int)  # processed_count, total_count
+    error_occurred = Signal(str, str)  # xml_file_path, error_message
+
+    def __init__(self, project_dir: Path, xml_files: list[XmlFile]):
+        """
+        Initialisiert den Hash-Berechnungs-Thread.
+
+        Args:
+            project_dir: Pfad zum Projekt-Verzeichnis
+            xml_files: Liste der XmlFile-Objekte für die Hash-Berechnung
+        """
+        super().__init__()
+        self.project_dir = project_dir
+        self.xml_files = xml_files
+        self.processed_count = 0
+
+    def run(self):
+        """
+        Führt die Hash-Berechnung für alle XML-Dateien aus.
+        """
+        logger.info(f"Starte Hash-Berechnung für {len(self.xml_files)} XML-Dateien")
+
+        for xml_file in self.xml_files:
+            try:
+                # Prüfe ob hashsum bereits vorhanden ist
+                if xml_file.hashsum:
+                    logger.debug(f"Hash bereits vorhanden für {xml_file.xml}: {xml_file.hashsum}")
+                    self.processed_count += 1
+                    continue
+
+                # Berechne Hash für die XML-Datei
+                xml_file_path = self.project_dir / xml_file.xml
+                hash_value = self._calculate_blake2b_hash(xml_file_path)
+
+                if hash_value:
+                    # Sende Signal mit berechnetem Hash
+                    self.hash_calculated.emit(xml_file, hash_value)
+                    logger.debug(f"Hash berechnet für {xml_file.xml}: {hash_value}")
+
+                self.processed_count += 1
+
+            except Exception as e:
+                error_msg = f"Fehler bei Hash-Berechnung für {xml_file.xml}: {str(e)}"
+                logger.error(error_msg)
+                self.error_occurred.emit(str(xml_file.xml), error_msg)
+                self.processed_count += 1
+
+        # Sende Abschluss-Signal
+        self.calculation_finished.emit(self.processed_count, len(self.xml_files))
+        logger.info(f"Hash-Berechnung abgeschlossen: {self.processed_count}/{len(self.xml_files)} verarbeitet")
+
+    def _calculate_blake2b_hash(self, file_path: Path) -> str | None:
+        """Berechnet den blake2b-Hash einer XML-Datei."""
+        return calculate_blake2b_hash(file_path)
+
+
+class XmlBatchProcessingThread(QThread):
+    """
+    Thread für die asynchrone Batch-Verarbeitung von mehreren XML-Dateien.
+    Verarbeitet XML-Dateien mit Hash-Berechnung, Duplikatserkennung und Dateikopieren.
+    """
+
+    # Signale für die Kommunikation mit dem Haupt-Thread
+    progress_update = Signal(int, int, str)  # current, total, current_file_name
+    file_processed = Signal(dict)  # result dictionary
+    processing_finished = Signal(dict)  # stats dictionary
+    error_occurred = Signal(str)  # error_message
+
+    def __init__(self, xml_files: list, selected_xsl_nodes: list, project_dir: Path, pdf_project):
+        """
+        Initialisiert den Batch-Verarbeitungs-Thread.
+
+        Args:
+            xml_files: Liste von Pfaden zu XML-Dateien
+            selected_xsl_nodes: Liste der ausgewählten XSL-Knoten
+            project_dir: Pfad zum Projekt-Verzeichnis
+            pdf_project: ProjectData-Objekt
+        """
+        super().__init__()
+        self.xml_files = xml_files
+        self.selected_xsl_nodes = selected_xsl_nodes
+        self.project_dir = project_dir
+        self.pdf_project = pdf_project
+
+        # Statistiken
+        self.stats = {
+            "total": len(xml_files),
+            "processed": 0,
+            "new_added": 0,
+            "existing_added": 0,
+            "already_assigned": 0,
+            "cancelled": 0,
+            "errors": 0,
+            "error_messages": [],
+            "renamed_files": [],
+        }
+
+    def run(self):
+        """
+        Führt die Batch-Verarbeitung aller XML-Dateien aus.
+        """
+        logger.info(f"Starte Batch-Verarbeitung für {len(self.xml_files)} XML-Dateien")
+
+        for i, xml_file_path in enumerate(self.xml_files):
+            try:
+                # Sende Progress-Update
+                self.progress_update.emit(i + 1, len(self.xml_files), xml_file_path.name)
+
+                # Prüfe ob die Datei existiert
+                if not xml_file_path.exists():
+                    self.stats["errors"] += 1
+                    self.stats["error_messages"].append(f"{xml_file_path.name}: Datei existiert nicht")
+                    continue
+
+                # Verarbeite die XML-Datei
+                result = self._process_xml_file(xml_file_path)
+
+                # Aktualisiere Statistiken
+                self._update_stats(result)
+
+                # Sende Ergebnis
+                self.file_processed.emit(result)
+
+            except Exception as e:
+                error_msg = f"Fehler bei {xml_file_path.name}: {str(e)}"
+                logger.error(error_msg)
+                self.stats["errors"] += 1
+                self.stats["error_messages"].append(error_msg)
+
+        # Sende Abschluss-Signal mit Statistiken
+        self.processing_finished.emit(self.stats)
+        logger.info(f"Batch-Verarbeitung abgeschlossen: {self.stats['processed']}/{self.stats['total']} verarbeitet")
+
+    def _process_xml_file(self, xml_file_path: Path) -> dict:
+        """
+        Verarbeitet eine einzelne XML-Datei.
+
+        Args:
+            xml_file_path: Pfad zur XML-Datei
+
+        Returns:
+            dict: Ergebnis-Dictionary mit Status
+        """
+        try:
+            # 1. Hash berechnen
+            file_hash = self._calculate_hash_for_file(xml_file_path)
+            if not file_hash:
+                logger.warning(f"Hash-Berechnung für {xml_file_path} fehlgeschlagen")
+
+            # 2. Prüfe auf Hash-Duplikat
+            existing_xml = self._find_xml_file_by_hash(file_hash) if file_hash else None
+
+            if existing_xml:
+                # Hash-Match: Ordne vorhandene Datei zu
+                return self._assign_existing_xml_to_nodes(existing_xml)
+            else:
+                # Keine Duplikate: Verarbeite als neue Datei
+                return self._process_new_xml_file(xml_file_path, file_hash)
+
+        except Exception as e:
+            return {"status": "error", "error_msg": str(e)}
+
+    def _calculate_hash_for_file(self, file_path: Path) -> str | None:
+        """Berechnet blake2b Hash für eine Datei."""
+        return calculate_blake2b_hash(file_path)
+
+    def _find_xml_file_by_hash(self, hash_value: str) -> XmlFile | None:
+        """Sucht eine XML-Datei anhand ihres Hash-Werts."""
+        if not hash_value or not self.pdf_project.nodes:
+            return None
+
+        def search_recursive(nodes):
+            for node in nodes:
+                if isinstance(node, XslFile) and node.xmls:
+                    for xml_file in node.xmls:
+                        if xml_file.hashsum == hash_value:
+                            return xml_file
+                elif isinstance(node, TreeNode) and node.children:
+                    found = search_recursive(node.children)
+                    if found:
+                        return found
+            return None
+
+        return search_recursive(self.pdf_project.nodes)
+
+    def _assign_existing_xml_to_nodes(self, existing_xml: XmlFile) -> dict:
+        """Ordnet eine vorhandene XML-Datei den Knoten zu."""
+        try:
+            added_count = 0
+
+            for xsl_node in self.selected_xsl_nodes:
+                already_assigned = any(xml_file.xml == existing_xml.xml for xml_file in xsl_node.xmls)
+
+                if not already_assigned:
+                    new_xml_ref = XmlFile(xml=existing_xml.xml, hashsum=existing_xml.hashsum)
+                    xsl_node.xmls.append(new_xml_ref)
+                    added_count += 1
+
+            if added_count > 0:
+                return {
+                    "status": "existing_added",
+                    "added_count": added_count,
+                    "existing_file": existing_xml.xml.name,
+                }
+            else:
+                return {"status": "already_assigned", "added_count": 0, "existing_file": existing_xml.xml.name}
+
+        except Exception as e:
+            return {"status": "error", "error_msg": str(e)}
+
+    def _process_new_xml_file(self, xml_file_path: Path, file_hash: str | None) -> dict:
+        """Verarbeitet eine neue XML-Datei."""
+        try:
+            # Erstelle xml-Ordner
+            xml_dir = self.project_dir / "xml"
+            xml_dir.mkdir(parents=True, exist_ok=True)
+
+            # Bestimme Ziel-Pfad
+            target_xml_path = xml_dir / xml_file_path.name
+
+            # Set aller bereits im Projekt verwendeten Dateinamen — einmalig aufbauen
+            used_filenames = self._collect_project_filenames()
+
+            # Prüfe auf Namenskonflikte und generiere ggf. alternativen Namen
+            original_name = xml_file_path.name
+            counter = 1
+            while target_xml_path.exists() or (Path("xml") / target_xml_path.name) in used_filenames:
+                # Generiere alternativen Namen
+                stem = xml_file_path.stem
+                suffix = xml_file_path.suffix
+                target_xml_path = xml_dir / f"{stem}_{counter}{suffix}"
+                counter += 1
+
+                # Sicherheit: Maximal 1000 Versuche
+                if counter > 1000:
+                    return {"status": "error", "error_msg": "Konnte keinen eindeutigen Dateinamen finden"}
+
+            # Kopiere Datei
+            shutil.copy2(xml_file_path, target_xml_path)
+
+            # Erstelle relatives Path
+            relative_xml_path = Path("xml") / target_xml_path.name
+
+            # Füge zu XSL-Knoten hinzu
+            added_count = 0
+            for xsl_node in self.selected_xsl_nodes:
+                existing_xml = any(xml_file.xml == relative_xml_path for xml_file in xsl_node.xmls)
+
+                if not existing_xml:
+                    new_xml_file = XmlFile(xml=relative_xml_path, hashsum=file_hash)
+                    xsl_node.xmls.append(new_xml_file)
+                    added_count += 1
+
+            if added_count > 0:
+                return {
+                    "status": "new_added",
+                    "added_count": added_count,
+                    "new_file": target_xml_path.name,
+                    "renamed_from": original_name if target_xml_path.name != original_name else None,
+                }
+            else:
+                return {"status": "already_assigned", "added_count": 0, "new_file": target_xml_path.name}
+
+        except Exception as e:
+            return {"status": "error", "error_msg": str(e)}
+
+    def _collect_project_filenames(self) -> set[Path]:
+        """Gibt ein Set aller im Projekt verwendeten XML-Dateipfade zurück."""
+        result: set[Path] = set()
+
+        def collect(nodes):
+            for node in nodes:
+                if isinstance(node, XslFile) and node.xmls:
+                    for xml_file in node.xmls:
+                        result.add(xml_file.xml)
+                elif isinstance(node, TreeNode) and node.children:
+                    collect(node.children)
+
+        collect(self.pdf_project.nodes or [])
+        return result
+
+    def _update_stats(self, result: dict):
+        """Aktualisiert die Statistiken."""
+        self.stats["processed"] += 1
+
+        status = result.get("status")
+        if status == "new_added":
+            self.stats["new_added"] += 1
+            if result.get("renamed_from"):
+                self.stats["renamed_files"].append(f"{result['renamed_from']} → {result['new_file']}")
+        elif status == "existing_added":
+            self.stats["existing_added"] += 1
+        elif status == "already_assigned":
+            self.stats["already_assigned"] += 1
+        elif status == "error":
+            self.stats["errors"] += 1
+            self.stats["error_messages"].append(result.get("error_msg", "Unbekannter Fehler"))
+
+
+class TransformationThread(QThread):
+    """
+    Thread für die asynchrone Ausführung von Transformations-Jobs.
+    """
+
+    # Signale für die Kommunikation mit dem Haupt-Thread
+    job_started = Signal(str, str)  # xml_file_name, xsl_id_str
+    job_finished = Signal(dict)  # result_dict
+    job_error = Signal(str, str, str)  # xml_file_name, xsl_id_str, error_message
+    all_jobs_finished = Signal(int, int, float)  # successful_count, total_count, total_duration
+
+    def __init__(self, jobs: list[TransformationJob], force: bool = False, max_workers: int = 8):
+        """
+        Initialisiert den Transformations-Thread.
+
+        Args:
+            jobs: Liste der TransformationJob-Objekte
+            force: Wenn True, werden alle Jobs ausgeführt (ignoriert Up-to-Date)
+            max_workers: Maximale Anzahl paralleler Worker (Standard: 8)
+        """
+        super().__init__()
+        self.jobs = jobs
+        self.force = force
+        self.max_workers = max_workers
+        self.successful_count = 0
+
+    def _process_single_job(self, job: TransformationJob) -> dict:
+        """
+        Verarbeitet einen einzelnen Transformations-Job (Thread-safe).
+
+        Args:
+            job: Der zu verarbeitende TransformationJob
+
+        Returns:
+            dict: Ergebnis-Dictionary des Jobs
+        """
+        try:
+            # Sende Start-Signal mit XSL-ID
+            xsl_id_str = "_".join(str(x) for x in job.xsl_id) if job.xsl_id else ""
+            self.job_started.emit(str(job.xml_file), xsl_id_str)
+
+            # Führe Transformations-Pipeline aus
+            result = job.run_full_pipeline(force=self.force)
+
+            # Sende Abschluss-Signal
+            self.job_finished.emit(result)
+
+            return result
+
+        except Exception as e:
+            error_msg = f"Unerwarteter Fehler bei Transformation: {str(e)}"
+            logger.error(error_msg)
+            xsl_id_str = "_".join(str(x) for x in job.xsl_id) if job.xsl_id else ""
+            self.job_error.emit(str(job.xml_file), xsl_id_str, error_msg)
+            return {"success": False, "error": error_msg}
+
+    def run(self):
+        """
+        Führt alle Transformations-Jobs parallel aus mit ThreadPoolExecutor.
+        """
+        from concurrent.futures import ThreadPoolExecutor, as_completed
+        from datetime import datetime
+        import threading
+
+        start_time = datetime.now()
+        logger.info(f"Starte parallele Transformation von {len(self.jobs)} Jobs mit {self.max_workers} Workern")
+
+        # Thread-sicherer Counter
+        successful_lock = threading.Lock()
+
+        # Verwende ThreadPoolExecutor für parallele Verarbeitung
+        with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
+            # Starte alle Jobs
+            future_to_job = {executor.submit(self._process_single_job, job): job for job in self.jobs}
+
+            # Warte auf Abschluss und sammle Ergebnisse
+            for future in as_completed(future_to_job):
+                try:
+                    result = future.result()
+                    if result.get("success", False):
+                        with successful_lock:
+                            self.successful_count += 1
+                except Exception as e:
+                    logger.error(f"Fehler beim Verarbeiten des Future: {e}")
+
+        # Berechne Gesamtdauer
+        total_duration = (datetime.now() - start_time).total_seconds()
+
+        # Sende Abschluss-Signal für alle Jobs mit Gesamtdauer
+        self.all_jobs_finished.emit(self.successful_count, len(self.jobs), total_duration)
+        logger.info(
+            f"Transformation abgeschlossen: {self.successful_count}/{len(self.jobs)} erfolgreich ({total_duration:.2f}s) "
+            f"[{len(self.jobs) / total_duration:.2f} Jobs/s mit {self.max_workers} Workern]"
+        )

src/utils.py

@@ -0,0 +1,38 @@
+"""
+Gemeinsame Utility-Funktionen für DocuMentor.
+"""
+
+import hashlib
+import logging
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+HASH_PREFIX = "blake2b"
+
+
+def calculate_blake2b_hash(file_path: Path) -> str | None:
+    """
+    Berechnet den blake2b-Hash einer Datei.
+
+    Args:
+        file_path: Pfad zur Datei
+
+    Returns:
+        str: Hash-Wert mit "blake2b:" Präfix oder None bei Fehler
+    """
+    try:
+        if not file_path.exists():
+            logger.warning(f"Datei für Hash-Berechnung nicht gefunden: {file_path}")
+            return None
+
+        hash_obj = hashlib.blake2b()
+        with open(file_path, "rb") as f:
+            for chunk in iter(lambda: f.read(8192), b""):
+                hash_obj.update(chunk)
+
+        return f"{HASH_PREFIX}:{hash_obj.hexdigest()}"
+
+    except Exception as e:
+        logger.error(f"Fehler beim Berechnen des Hash für {file_path}: {e}")
+        return None

src/worker_metrics.py

@@ -0,0 +1,62 @@
+"""
+Worker Pool Performance-Metriken.
+
+Gemeinsame Datenstrukturen für Performance- und Ressourcenverbrauch-Metriken
+der Worker-Pools (Saxon, FOP).
+"""
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class WorkerPoolMetrics:
+    """
+    Metriken für Worker-Pool Performance und Ressourcenverbrauch.
+    """
+
+    # Kompilierungszeit
+    compilation_time_seconds: float = 0.0
+
+    # Worker-Start-Zeiten
+    worker_start_times: list[float] = field(default_factory=list)
+    total_worker_start_time_seconds: float = 0.0
+    average_worker_start_time_seconds: float = 0.0
+
+    # RAM-Verbrauch (in MB)
+    ram_before_transform_mb_per_worker: list[float] = field(default_factory=list)
+    ram_after_transform_mb_per_worker: list[float] = field(default_factory=list)
+    total_ram_before_mb: float = 0.0
+    total_ram_after_mb: float = 0.0
+    average_ram_before_mb: float = 0.0
+    average_ram_after_mb: float = 0.0
+
+    # XSL-Kompilierungszeiten (nur für Saxon)
+    xsl_compilation_times: list[float] = field(default_factory=list)
+    total_xsl_compilation_time_seconds: float = 0.0
+    average_xsl_compilation_time_seconds: float = 0.0
+
+    def calculate_aggregates(self):
+        """Berechnet aggregierte Werte (Summen, Durchschnitte)."""
+        # Worker-Start-Zeiten
+        if self.worker_start_times:
+            self.total_worker_start_time_seconds = sum(self.worker_start_times)
+            self.average_worker_start_time_seconds = self.total_worker_start_time_seconds / len(
+                self.worker_start_times
+            )
+
+        # RAM vor Transformation
+        if self.ram_before_transform_mb_per_worker:
+            self.total_ram_before_mb = sum(self.ram_before_transform_mb_per_worker)
+            self.average_ram_before_mb = self.total_ram_before_mb / len(self.ram_before_transform_mb_per_worker)
+
+        # RAM nach Transformation
+        if self.ram_after_transform_mb_per_worker:
+            self.total_ram_after_mb = sum(self.ram_after_transform_mb_per_worker)
+            self.average_ram_after_mb = self.total_ram_after_mb / len(self.ram_after_transform_mb_per_worker)
+
+        # XSL-Kompilierungszeiten
+        if self.xsl_compilation_times:
+            self.total_xsl_compilation_time_seconds = sum(self.xsl_compilation_times)
+            self.average_xsl_compilation_time_seconds = self.total_xsl_compilation_time_seconds / len(
+                self.xsl_compilation_times
+            )

src/worker_pool_base.py

@@ -0,0 +1,312 @@
+"""
+BaseWorkerPool - Gemeinsame Basisklasse für JVM-Worker-Pools.
+
+Enthält alle gemeinsamen Methoden für SaxonWorkerPool, SaxonWorkerPoolS9Api
+und FopWorkerPool: Kompilierung, Worker-Start, RAM-Messung und Shutdown.
+"""
+
+import glob
+import logging
+import shutil
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Optional
+
+# Verhindert Konsolenfenster bei Subprozessen in PyInstaller-EXE (Windows)
+_SUBPROCESS_FLAGS = subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0
+
+import psutil
+
+from worker_metrics import WorkerPoolMetrics
+
+logger = logging.getLogger(__name__)
+
+_CLASSPATH_SEP = ";" if sys.platform == "win32" else ":"
+
+
+def build_jar_classpath(base_dir: Path, include_lib: bool = True) -> str:
+    """
+    Baut einen Classpath aus allen JAR-Dateien in einem Verzeichnis.
+
+    Args:
+        base_dir: Hauptverzeichnis mit JAR-Dateien
+        include_lib: Ob das lib/-Unterverzeichnis ebenfalls einbezogen wird
+
+    Returns:
+        Classpath-String (plattformspezifischer Trennzeichen)
+    """
+    all_jars = glob.glob(str(base_dir / "*.jar"))
+    if include_lib:
+        lib_dir = base_dir / "lib"
+        if lib_dir.exists():
+            all_jars.extend(glob.glob(str(lib_dir / "*.jar")))
+    return _CLASSPATH_SEP.join(all_jars)
+
+
+class BaseWorkerPool(ABC):
+    """
+    Abstrakte Basisklasse für JVM-basierte Worker-Pools.
+
+    Konkrete Unterklassen müssen folgende Properties/Methoden implementieren:
+    - _pool_name: Anzeigename für Log-Meldungen
+    - _java_source_code: Java-Quellcode-String
+    - _java_class_name: Name der Java-Klasse (ohne .java)
+    - _temp_dir_prefix: Präfix für das temporäre Verzeichnis
+    - _worker_init_sleep: Wartezeit nach Worker-Start (Sekunden)
+    - _get_classpath(): Gibt den Classpath für Kompilierung und Ausführung zurück
+    - _build_worker_cmd(full_classpath): Gibt die Worker-Startkommando-Liste zurück
+    - _stderr_log_name(i): Gibt den Dateinamen der stderr-Logdatei für Worker i zurück
+    """
+
+    def __init__(self, num_workers: int, java_vm_path: Path, log_dir: Optional[Path] = None):
+        self.num_workers = num_workers
+        self.java_vm_path = java_vm_path
+        self.log_dir = log_dir
+
+        # Worker-Prozesse
+        self.workers: list[subprocess.Popen] = []
+        self.worker_locks: list[threading.Lock] = []
+        self._worker_stderr_files: list = []
+
+        # Temporäres Verzeichnis für kompilierte Java-Klasse
+        self.temp_dir: Optional[Path] = None
+        self.worker_class_path: Optional[Path] = None
+        self.worker_log_dir: Optional[Path] = None
+
+        # Performance-Metriken
+        self.metrics = WorkerPoolMetrics()
+
+    # --- Abstrakte Schnittstelle ---
+
+    @property
+    @abstractmethod
+    def _pool_name(self) -> str:
+        """Anzeigename für Log-Meldungen (z.B. 'Saxon', 'FOP')."""
+
+    @property
+    @abstractmethod
+    def _java_source_code(self) -> str:
+        """Java-Quellcode-String der Worker-Klasse."""
+
+    @property
+    @abstractmethod
+    def _java_class_name(self) -> str:
+        """Name der Java-Klasse ohne Suffix (z.B. 'SaxonWorker')."""
+
+    @property
+    @abstractmethod
+    def _temp_dir_prefix(self) -> str:
+        """Präfix für das temporäre Verzeichnis (z.B. 'saxon_worker_')."""
+
+    @property
+    @abstractmethod
+    def _worker_init_sleep(self) -> float:
+        """Wartezeit in Sekunden nach Worker-Start."""
+
+    @abstractmethod
+    def _get_classpath(self) -> str:
+        """Gibt den Classpath-String für Kompilierung und Worker-Start zurück."""
+
+    @abstractmethod
+    def _build_worker_cmd(self, full_classpath: str) -> list[str]:
+        """Gibt die Worker-Startkommando-Liste zurück."""
+
+    @abstractmethod
+    def _stderr_log_name(self, i: int) -> str:
+        """Gibt den Dateinamen der stderr-Logdatei für Worker i zurück."""
+
+    # --- Gemeinsame Implementierungen ---
+
+    def _compile_worker_class(self):
+        """Kompiliert die Worker-Java-Klasse ins temporäre Verzeichnis."""
+        start_time = time.time()
+        try:
+            self.temp_dir = Path(tempfile.mkdtemp(prefix=self._temp_dir_prefix))
+
+            java_file = self.temp_dir / f"{self._java_class_name}.java"
+            java_file.write_text(self._java_source_code, encoding="utf-8")
+
+            classpath = self._get_classpath()
+            javac_cmd = [str(self.java_vm_path).replace("java", "javac"), "-cp", classpath, str(java_file)]
+
+            logger.debug(f"Kompiliere {self._java_class_name}: {' '.join(javac_cmd[:3])}...")
+
+            result = subprocess.run(javac_cmd, capture_output=True, text=True, timeout=30, creationflags=_SUBPROCESS_FLAGS)
+            if result.returncode != 0:
+                raise RuntimeError(f"Java-Kompilierung fehlgeschlagen: {result.stderr}")
+
+            self.worker_class_path = self.temp_dir
+            self.metrics.compilation_time_seconds = time.time() - start_time
+
+            logger.info(
+                f"{self._java_class_name} erfolgreich kompiliert: {self.temp_dir} "
+                f"({self.metrics.compilation_time_seconds:.3f}s)"
+            )
+
+        except Exception as e:
+            logger.error(f"Fehler beim Kompilieren von {self._java_class_name}: {e}")
+            raise
+
+    def _start_workers(self):
+        """Startet N Worker-Prozesse."""
+        classpath = self._get_classpath()
+        full_classpath = str(self.worker_class_path) + _CLASSPATH_SEP + classpath
+
+        self.worker_log_dir = self.log_dir if self.log_dir else self.temp_dir
+        if self.log_dir:
+            self.worker_log_dir.mkdir(parents=True, exist_ok=True)
+
+        cmd = self._build_worker_cmd(full_classpath)
+
+        for i in range(self.num_workers):
+            worker_start_time = time.time()
+            try:
+                stderr_log = self.worker_log_dir / self._stderr_log_name(i)
+                stderr_file = open(stderr_log, "w", encoding="utf-8")
+                self._worker_stderr_files.append(stderr_file)
+
+                process = subprocess.Popen(
+                    cmd,
+                    stdin=subprocess.PIPE,
+                    stdout=subprocess.PIPE,
+                    stderr=stderr_file,
+                    text=True,
+                    bufsize=1,
+                    creationflags=_SUBPROCESS_FLAGS,
+                )
+
+                self.workers.append(process)
+                self.worker_locks.append(threading.Lock())
+
+                logger.debug(f"{self._pool_name} Worker {i} gestartet (PID: {process.pid}, stderr: {stderr_log})")
+
+                time.sleep(self._worker_init_sleep)
+
+                if process.poll() is not None:
+                    stderr_file.close()
+                    with open(stderr_log, "r") as f:
+                        stderr_content = f.read()
+                    raise RuntimeError(
+                        f"{self._pool_name} Worker {i} ist sofort beendet "
+                        f"(Exit Code: {process.returncode})\nstderr:\n{stderr_content}"
+                    )
+
+                self.metrics.worker_start_times.append(time.time() - worker_start_time)
+
+            except Exception as e:
+                logger.error(f"Fehler beim Starten von {self._pool_name} Worker {i}: {e}")
+                raise
+
+        self.metrics.calculate_aggregates()
+        logger.info(
+            f"{len(self.workers)} {self._pool_name}-Worker erfolgreich gestartet "
+            f"(Summe: {self.metrics.total_worker_start_time_seconds:.3f}s, "
+            f"Durchschnitt: {self.metrics.average_worker_start_time_seconds:.3f}s)"
+        )
+
+    def _acquire_worker(self) -> int:
+        """Gibt den Index eines freien Workers zurück (blockiert bis einer frei ist)."""
+        for i, lock in enumerate(self.worker_locks):
+            if lock.acquire(blocking=False):
+                return i
+        # Kein freier Worker — warte auf den ersten verfügbaren
+        for i, lock in enumerate(self.worker_locks):
+            lock.acquire()
+            return i
+
+    def _read_stderr_log(self, worker_idx: int, tail: int = 0) -> str:
+        """Liest die stderr-Logdatei eines Workers (optional nur die letzten N Zeichen)."""
+        try:
+            stderr_log = self.worker_log_dir / self._stderr_log_name(worker_idx)
+            with open(stderr_log, "r") as f:
+                content = f.read()
+            return content[-tail:] if tail else content
+        except Exception:
+            return ""
+
+    def measure_ram_usage(self) -> tuple[float, float, list[float]]:
+        """
+        Misst den aktuellen RAM-Verbrauch aller Worker-Prozesse.
+
+        Returns:
+            tuple: (total_mb, average_mb, per_worker_mb_list)
+        """
+        ram_per_worker = []
+        for i, worker in enumerate(self.workers):
+            try:
+                if worker.poll() is None:
+                    process = psutil.Process(worker.pid)
+                    ram_mb = process.memory_info().rss / (1024 * 1024)
+                    ram_per_worker.append(ram_mb)
+                else:
+                    logger.warning(f"{self._pool_name} Worker {i} ist nicht mehr aktiv (kann RAM nicht messen)")
+            except (psutil.NoSuchProcess, psutil.AccessDenied) as e:
+                logger.warning(f"Konnte RAM für {self._pool_name} Worker {i} nicht messen: {e}")
+
+        total_ram = sum(ram_per_worker)
+        average_ram = total_ram / len(ram_per_worker) if ram_per_worker else 0.0
+        return total_ram, average_ram, ram_per_worker
+
+    def capture_ram_before_transform(self):
+        """Erfasst RAM-Verbrauch vor der ersten Transformation."""
+        total, average, per_worker = self.measure_ram_usage()
+        self.metrics.ram_before_transform_mb_per_worker = per_worker
+        self.metrics.total_ram_before_mb = total
+        self.metrics.average_ram_before_mb = average
+        logger.info(
+            f"RAM vor Transformation ({self._pool_name}): {total:.1f} MB (Ø {average:.1f} MB/Worker)"
+        )
+
+    def capture_ram_after_transform(self):
+        """Erfasst RAM-Verbrauch nach allen Transformationen."""
+        total, average, per_worker = self.measure_ram_usage()
+        self.metrics.ram_after_transform_mb_per_worker = per_worker
+        self.metrics.total_ram_after_mb = total
+        self.metrics.average_ram_after_mb = average
+        logger.info(
+            f"RAM nach Transformation ({self._pool_name}): {total:.1f} MB (Ø {average:.1f} MB/Worker)"
+        )
+
+    def shutdown(self):
+        """Beendet alle Worker-Prozesse sauber."""
+        logger.info(f"Beende {self._pool_name}-Worker-Pool...")
+
+        for i, worker in enumerate(self.workers):
+            try:
+                if worker.stdin and not worker.stdin.closed:
+                    worker.stdin.write("EXIT\n")
+                    worker.stdin.flush()
+                worker.wait(timeout=2)
+                logger.debug(f"{self._pool_name} Worker {i} beendet")
+            except subprocess.TimeoutExpired:
+                worker.kill()
+                logger.warning(f"{self._pool_name} Worker {i} musste gekillt werden")
+            except Exception as e:
+                logger.error(f"Fehler beim Beenden von {self._pool_name} Worker {i}: {e}")
+
+        for f in self._worker_stderr_files:
+            try:
+                f.close()
+            except Exception:
+                pass
+        self._worker_stderr_files.clear()
+
+        if self.temp_dir and self.temp_dir.exists():
+            try:
+                shutil.rmtree(self.temp_dir)
+                logger.debug(f"Temporäres Verzeichnis gelöscht: {self.temp_dir}")
+            except Exception as e:
+                logger.warning(f"Konnte temporäres Verzeichnis nicht löschen: {e}")
+
+        logger.info(f"{self._pool_name}-Worker-Pool beendet")
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.shutdown()

src/xsl_dependencies.py

@@ -0,0 +1,241 @@
+"""
+XSL-Abhängigkeitsgraph für die Erkennung transitiver Imports/Includes.
+
+Dieses Modul parst XSL-Dateien und baut einen Abhängigkeitsgraph auf,
+um alle direkt und transitiv importierten/inkludierten Dateien zu ermitteln.
+Der Graph wird im Speicher gehalten und bei Änderungen (mtime) automatisch invalidiert.
+"""
+
+import logging
+import time
+from lxml import etree
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+_XSL_NAMESPACE = "http://www.w3.org/1999/XSL/Transform"
+
+
+def _parse_import_include_hrefs(content: str) -> list[str]:
+    """Parst XSL-Dateiinhalt und gibt alle href-Werte von xsl:import/xsl:include zurück."""
+    try:
+        root = etree.fromstring(content.encode("utf-8"))
+    except etree.XMLSyntaxError:
+        return []
+    hrefs = []
+    for tag in ("import", "include"):
+        for elem in root.iter(f"{{{_XSL_NAMESPACE}}}{tag}"):
+            href = elem.get("href")
+            if href:
+                hrefs.append(href)
+    return hrefs
+
+
+class XslDependencyGraph:
+    """
+    Verwaltet einen Cache von XSL-Abhängigkeiten (import/include).
+
+    Für jede XSL-Datei wird die Menge aller transitiv referenzierten
+    XSL-Dateien gespeichert. Der Cache wird über die mtime der Dateien
+    automatisch invalidiert.
+    """
+
+    def __init__(self):
+        # Cache: xsl_path -> (mtime_bei_parse, set[Path] aller Abhängigkeiten)
+        self._cache: dict[Path, tuple[float, set[Path]]] = {}
+
+    def get_dependencies(self, xsl_file: Path) -> set[Path]:
+        """
+        Gibt alle transitiven Abhängigkeiten einer XSL-Datei zurück.
+
+        Args:
+            xsl_file: Absoluter Pfad zur XSL-Datei
+
+        Returns:
+            set[Path]: Menge aller transitiv importierten/inkludierten XSL-Dateien
+        """
+        xsl_file = xsl_file.resolve()
+
+        if not xsl_file.exists():
+            return set()
+
+        current_mtime = xsl_file.stat().st_mtime
+
+        # Cache-Hit prüfen
+        if xsl_file in self._cache:
+            cached_mtime, cached_deps = self._cache[xsl_file]
+            if cached_mtime == current_mtime:
+                return cached_deps
+
+        # Neu parsen
+        deps = self._resolve_recursive(xsl_file, set())
+        self._cache[xsl_file] = (current_mtime, deps)
+        logger.debug(f"XSL-Abhängigkeiten aufgelöst für {xsl_file.name}: {len(deps)} Abhängigkeit(en)")
+        return deps
+
+    def _resolve_recursive(self, xsl_file: Path, visited: set[Path]) -> set[Path]:
+        """
+        Löst rekursiv alle import/include-Referenzen auf.
+
+        Args:
+            xsl_file: Absoluter Pfad zur XSL-Datei
+            visited: Bereits besuchte Dateien (Zykluserkennung)
+
+        Returns:
+            set[Path]: Alle transitiven Abhängigkeiten (ohne die Datei selbst)
+        """
+        xsl_file = xsl_file.resolve()
+
+        if xsl_file in visited or not xsl_file.exists():
+            return set()
+
+        visited.add(xsl_file)
+        result: set[Path] = set()
+
+        try:
+            content = xsl_file.read_text(encoding="utf-8", errors="replace")
+        except Exception as e:
+            logger.warning(f"Konnte XSL-Datei nicht lesen: {xsl_file} ({e})")
+            return result
+
+        # Finde alle import/include-Referenzen
+        for href in _parse_import_include_hrefs(content):
+            referenced_path = (xsl_file.parent / href).resolve()
+
+            if referenced_path.exists() and referenced_path not in visited:
+                result.add(referenced_path)
+                # Rekursiv Abhängigkeiten der referenzierten Datei auflösen
+                result.update(self._resolve_recursive(referenced_path, visited))
+
+        return result
+
+    def get_reverse_dependencies(self, xsl_file: Path, xsl_root_dir: Path) -> set[Path]:
+        """
+        Gibt alle Dateien zurück, die die gegebene XSL-Datei direkt oder transitiv importieren/inkludieren.
+
+        Args:
+            xsl_file: Absoluter Pfad zur XSL-Datei
+            xsl_root_dir: Wurzelverzeichnis der XSL-Dateien (für den Scan)
+
+        Returns:
+            set[Path]: Menge aller Dateien, die diese Datei importieren
+        """
+        xsl_file = xsl_file.resolve()
+        result: set[Path] = set()
+
+        # Scanne alle XSL-Dateien im Verzeichnis
+        if not xsl_root_dir.exists():
+            return result
+
+        for candidate in xsl_root_dir.rglob("*.xsl"):
+            candidate = candidate.resolve()
+            if candidate == xsl_file:
+                continue
+            deps = self.get_dependencies(candidate)
+            if xsl_file in deps:
+                result.add(candidate)
+
+        return result
+
+    def build_full_graph(self, xsl_root_dir: Path) -> dict[Path, set[Path]]:
+        """
+        Baut den vollständigen Abhängigkeitsgraph für alle XSL-Dateien in einem Verzeichnis auf.
+
+        Args:
+            xsl_root_dir: Wurzelverzeichnis der XSL-Dateien
+
+        Returns:
+            dict[Path, set[Path]]: Mapping von XSL-Datei zu ihren Abhängigkeiten
+        """
+        graph: dict[Path, set[Path]] = {}
+
+        if not xsl_root_dir.exists():
+            return graph
+
+        start = time.perf_counter()
+        for xsl_file in sorted(xsl_root_dir.rglob("*.xsl")):
+            xsl_file = xsl_file.resolve()
+            deps = self.get_dependencies(xsl_file)
+            graph[xsl_file] = deps
+        elapsed = time.perf_counter() - start
+
+        logger.info(f"Vollständiger XSL-Graph aufgebaut: {len(graph)} Dateien in {elapsed:.3f}s")
+        return graph
+
+    def _get_direct_dependencies(self, xsl_file: Path) -> set[Path]:
+        """
+        Gibt nur die direkten (nicht-transitiven) import/include-Abhängigkeiten zurück.
+
+        Args:
+            xsl_file: Absoluter Pfad zur XSL-Datei
+
+        Returns:
+            set[Path]: Menge der direkt importierten/inkludierten XSL-Dateien
+        """
+        xsl_file = xsl_file.resolve()
+        result: set[Path] = set()
+
+        if not xsl_file.exists():
+            return result
+
+        try:
+            content = xsl_file.read_text(encoding="utf-8", errors="replace")
+        except Exception as e:
+            logger.warning(f"Konnte XSL-Datei nicht lesen: {xsl_file} ({e})")
+            return result
+
+        for href in _parse_import_include_hrefs(content):
+            referenced_path = (xsl_file.parent / href).resolve()
+            if referenced_path.exists():
+                result.add(referenced_path)
+
+        return result
+
+    def build_direct_graph(self, xsl_root_dir: Path) -> dict[Path, set[Path]]:
+        """
+        Baut einen Graph mit nur direkten (nicht-transitiven) Abhängigkeiten auf.
+
+        Args:
+            xsl_root_dir: Wurzelverzeichnis der XSL-Dateien
+
+        Returns:
+            dict[Path, set[Path]]: Mapping von XSL-Datei zu ihren direkten Abhängigkeiten
+        """
+        graph: dict[Path, set[Path]] = {}
+
+        if not xsl_root_dir.exists():
+            return graph
+
+        start = time.perf_counter()
+        for xsl_file in sorted(xsl_root_dir.rglob("*.xsl")):
+            xsl_file = xsl_file.resolve()
+            graph[xsl_file] = self._get_direct_dependencies(xsl_file)
+        elapsed = time.perf_counter() - start
+
+        logger.info(f"Direkter XSL-Graph aufgebaut: {len(graph)} Dateien in {elapsed:.3f}s")
+        return graph
+
+    def invalidate(self, xsl_file: Path | None = None):
+        """
+        Invalidiert den Cache für eine bestimmte Datei oder den gesamten Cache.
+
+        Args:
+            xsl_file: Pfad zur XSL-Datei oder None für vollständige Invalidierung
+        """
+        if xsl_file is None:
+            self._cache.clear()
+            logger.debug("XSL-Abhängigkeitscache vollständig invalidiert")
+        else:
+            xsl_file = xsl_file.resolve()
+            # Entferne nicht nur den direkten Eintrag, sondern auch alle Einträge,
+            # die diese Datei als Abhängigkeit haben
+            keys_to_remove = [xsl_file]
+            for cached_path, (_, deps) in self._cache.items():
+                if xsl_file in deps:
+                    keys_to_remove.append(cached_path)
+
+            for key in keys_to_remove:
+                self._cache.pop(key, None)
+
+            if keys_to_remove:
+                logger.debug(f"XSL-Abhängigkeitscache invalidiert für {len(keys_to_remove)} Einträg(e)")

uv.lock

@@ -1,6 +1,15 @@
 version = 1
 revision = 3
-requires-python = ">=3.13"
+requires-python = ">=3.13, <3.15"
+
+[[package]]
+name = "altgraph"
+version = "0.17.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7e/f8/97fdf103f38fed6792a1601dbc16cc8aac56e7459a9fff08c812d8ae177a/altgraph-0.17.5.tar.gz", hash = "sha256:c87b395dd12fabde9c99573a9749d67da8d29ef9de0125c7f536699b4a9bc9e7", size = 48428, upload-time = "2025-11-21T20:35:50.583Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a9/ba/000a1996d4308bc65120167c21241a3b205464a2e0b58deda26ae8ac21d1/altgraph-0.17.5-py2.py3-none-any.whl", hash = "sha256:f3a22400bce1b0c701683820ac4f3b159cd301acab067c51c653e06961600597", size = 21228, upload-time = "2025-11-21T20:35:49.444Z" },
+]
 
 [[package]]
 name = "annotated-types"
@@ -23,56 +32,205 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/9e/19/f4751510ad196e2894205d68d029c1699e67b4026ed655aee5487528cb5a/connectorx-0.4.4-cp313-none-win_amd64.whl", hash = "sha256:ef6ce2e95d04163862c1a2e5a673ae6371d74a3ca66a4e3fec4a7c281944b102", size = 34557019, upload-time = "2025-08-19T05:38:18.784Z" },
 ]
 
-[[package]]
-name = "darkdetect"
-version = "0.7.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/48/2e/346667de53b48417e6237efd9d076d6530c413666fcbc381adbfeff21ce7/darkdetect-0.7.1.tar.gz", hash = "sha256:47be3cf5134432ddb616bbffc927237718407914993c82809983e7ccebf49013", size = 6976, upload-time = "2022-07-18T21:10:27.64Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/63/bd/b31abc8fcaab163e0b9501020309dd9094b47d609035a23e6ec0a0a8ba10/darkdetect-0.7.1-py2.py3-none-any.whl", hash = "sha256:3efe69f8ecd5f1b7f4fbb0d1d93f656b0e493c45cc49222380ffe2a529cbc866", size = 8199, upload-time = "2022-07-18T21:10:26.178Z" },
-]
-
 [[package]]
 name = "documentor"
-version = "0.1.0"
+version = "1.6.3"
 source = { virtual = "." }
 dependencies = [
+    { name = "connectorx" },
+    { name = "lxml" },
     { name = "polars", extra = ["connectorx", "pyarrow"] },
+    { name = "psutil" },
     { name = "pydantic-settings" },
     { name = "pydantic-yaml" },
-    { name = "pyqtdarktheme" },
     { name = "pyside6" },
 ]
 
 [package.dev-dependencies]
 dev = [
+    { name = "pillow" },
+    { name = "pyinstaller" },
     { name = "ruff" },
 ]
 
 [package.metadata]
 requires-dist = [
-    { name = "polars", extras = ["connectorx", "pyarrow"], specifier = ">=1.31.0" },
+    { name = "connectorx", specifier = ">=0.4.0" },
-    { name = "pydantic-settings", specifier = ">=2.9.1" },
+    { name = "lxml", specifier = ">=6.0.2" },
-    { name = "pydantic-yaml", specifier = ">=1.5.1" },
+    { name = "polars", extras = ["connectorx", "pyarrow"], specifier = ">=1.37.0" },
-    { name = "pyqtdarktheme", specifier = ">=2.1.0" },
+    { name = "psutil", specifier = ">=6.1.1" },
-    { name = "pyside6", specifier = ">=6.9.1" },
+    { name = "pydantic-settings", specifier = ">=2.12.0" },
+    { name = "pydantic-yaml", specifier = ">=1.6.0" },
+    { name = "pyside6", specifier = ">=6.10.1" },
 ]
 
 [package.metadata.requires-dev]
-dev = [{ name = "ruff", specifier = ">=0.14.8" }]
+dev = [
+    { name = "pillow", specifier = ">=10.0.0" },
+    { name = "pyinstaller", specifier = ">=6.0.0" },
+    { name = "ruff", specifier = ">=0.14.11" },
+]
+
+[[package]]
+name = "lxml"
+version = "6.0.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/aa/88/262177de60548e5a2bfc46ad28232c9e9cbde697bd94132aeb80364675cb/lxml-6.0.2.tar.gz", hash = "sha256:cd79f3367bd74b317dda655dc8fcfa304d9eb6e4fb06b7168c5cf27f96e0cd62", size = 4073426, upload-time = "2025-09-22T04:04:59.287Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/53/fd/4e8f0540608977aea078bf6d79f128e0e2c2bba8af1acf775c30baa70460/lxml-6.0.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:9b33d21594afab46f37ae58dfadd06636f154923c4e8a4d754b0127554eb2e77", size = 8648494, upload-time = "2025-09-22T04:01:54.242Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/f4/2a94a3d3dfd6c6b433501b8d470a1960a20ecce93245cf2db1706adf6c19/lxml-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6c8963287d7a4c5c9a432ff487c52e9c5618667179c18a204bdedb27310f022f", size = 4661146, upload-time = "2025-09-22T04:01:56.282Z" },
+    { url = "https://files.pythonhosted.org/packages/25/2e/4efa677fa6b322013035d38016f6ae859d06cac67437ca7dc708a6af7028/lxml-6.0.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1941354d92699fb5ffe6ed7b32f9649e43c2feb4b97205f75866f7d21aa91452", size = 4946932, upload-time = "2025-09-22T04:01:58.989Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/0f/526e78a6d38d109fdbaa5049c62e1d32fdd70c75fb61c4eadf3045d3d124/lxml-6.0.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bb2f6ca0ae2d983ded09357b84af659c954722bbf04dea98030064996d156048", size = 5100060, upload-time = "2025-09-22T04:02:00.812Z" },
+    { url = "https://files.pythonhosted.org/packages/81/76/99de58d81fa702cc0ea7edae4f4640416c2062813a00ff24bd70ac1d9c9b/lxml-6.0.2-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eb2a12d704f180a902d7fa778c6d71f36ceb7b0d317f34cdc76a5d05aa1dd1df", size = 5019000, upload-time = "2025-09-22T04:02:02.671Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/35/9e57d25482bc9a9882cb0037fdb9cc18f4b79d85df94fa9d2a89562f1d25/lxml-6.0.2-cp313-cp313-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:6ec0e3f745021bfed19c456647f0298d60a24c9ff86d9d051f52b509663feeb1", size = 5348496, upload-time = "2025-09-22T04:02:04.904Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/8e/cb99bd0b83ccc3e8f0f528e9aa1f7a9965dfec08c617070c5db8d63a87ce/lxml-6.0.2-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:846ae9a12d54e368933b9759052d6206a9e8b250291109c48e350c1f1f49d916", size = 5643779, upload-time = "2025-09-22T04:02:06.689Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/34/9e591954939276bb679b73773836c6684c22e56d05980e31d52a9a8deb18/lxml-6.0.2-cp313-cp313-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ef9266d2aa545d7374938fb5c484531ef5a2ec7f2d573e62f8ce722c735685fd", size = 5244072, upload-time = "2025-09-22T04:02:08.587Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/27/b29ff065f9aaca443ee377aff699714fcbffb371b4fce5ac4ca759e436d5/lxml-6.0.2-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:4077b7c79f31755df33b795dc12119cb557a0106bfdab0d2c2d97bd3cf3dffa6", size = 4718675, upload-time = "2025-09-22T04:02:10.783Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/9f/f756f9c2cd27caa1a6ef8c32ae47aadea697f5c2c6d07b0dae133c244fbe/lxml-6.0.2-cp313-cp313-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a7c5d5e5f1081955358533be077166ee97ed2571d6a66bdba6ec2f609a715d1a", size = 5255171, upload-time = "2025-09-22T04:02:12.631Z" },
+    { url = "https://files.pythonhosted.org/packages/61/46/bb85ea42d2cb1bd8395484fd72f38e3389611aa496ac7772da9205bbda0e/lxml-6.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:8f8d0cbd0674ee89863a523e6994ac25fd5be9c8486acfc3e5ccea679bad2679", size = 5057175, upload-time = "2025-09-22T04:02:14.718Z" },
+    { url = "https://files.pythonhosted.org/packages/95/0c/443fc476dcc8e41577f0af70458c50fe299a97bb6b7505bb1ae09aa7f9ac/lxml-6.0.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:2cbcbf6d6e924c28f04a43f3b6f6e272312a090f269eff68a2982e13e5d57659", size = 4785688, upload-time = "2025-09-22T04:02:16.957Z" },
+    { url = "https://files.pythonhosted.org/packages/48/78/6ef0b359d45bb9697bc5a626e1992fa5d27aa3f8004b137b2314793b50a0/lxml-6.0.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:dfb874cfa53340009af6bdd7e54ebc0d21012a60a4e65d927c2e477112e63484", size = 5660655, upload-time = "2025-09-22T04:02:18.815Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/ea/e1d33808f386bc1339d08c0dcada6e4712d4ed8e93fcad5f057070b7988a/lxml-6.0.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:fb8dae0b6b8b7f9e96c26fdd8121522ce5de9bb5538010870bd538683d30e9a2", size = 5247695, upload-time = "2025-09-22T04:02:20.593Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/47/eba75dfd8183673725255247a603b4ad606f4ae657b60c6c145b381697da/lxml-6.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:358d9adae670b63e95bc59747c72f4dc97c9ec58881d4627fe0120da0f90d314", size = 5269841, upload-time = "2025-09-22T04:02:22.489Z" },
+    { url = "https://files.pythonhosted.org/packages/76/04/5c5e2b8577bc936e219becb2e98cdb1aca14a4921a12995b9d0c523502ae/lxml-6.0.2-cp313-cp313-win32.whl", hash = "sha256:e8cd2415f372e7e5a789d743d133ae474290a90b9023197fd78f32e2dc6873e2", size = 3610700, upload-time = "2025-09-22T04:02:24.465Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/0a/4643ccc6bb8b143e9f9640aa54e38255f9d3b45feb2cbe7ae2ca47e8782e/lxml-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:b30d46379644fbfc3ab81f8f82ae4de55179414651f110a1514f0b1f8f6cb2d7", size = 4010347, upload-time = "2025-09-22T04:02:26.286Z" },
+    { url = "https://files.pythonhosted.org/packages/31/ef/dcf1d29c3f530577f61e5fe2f1bd72929acf779953668a8a47a479ae6f26/lxml-6.0.2-cp313-cp313-win_arm64.whl", hash = "sha256:13dcecc9946dca97b11b7c40d29fba63b55ab4170d3c0cf8c0c164343b9bfdcf", size = 3671248, upload-time = "2025-09-22T04:02:27.918Z" },
+    { url = "https://files.pythonhosted.org/packages/03/15/d4a377b385ab693ce97b472fe0c77c2b16ec79590e688b3ccc71fba19884/lxml-6.0.2-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:b0c732aa23de8f8aec23f4b580d1e52905ef468afb4abeafd3fec77042abb6fe", size = 8659801, upload-time = "2025-09-22T04:02:30.113Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/e8/c128e37589463668794d503afaeb003987373c5f94d667124ffd8078bbd9/lxml-6.0.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4468e3b83e10e0317a89a33d28f7aeba1caa4d1a6fd457d115dd4ffe90c5931d", size = 4659403, upload-time = "2025-09-22T04:02:32.119Z" },
+    { url = "https://files.pythonhosted.org/packages/00/ce/74903904339decdf7da7847bb5741fc98a5451b42fc419a86c0c13d26fe2/lxml-6.0.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:abd44571493973bad4598a3be7e1d807ed45aa2adaf7ab92ab7c62609569b17d", size = 4966974, upload-time = "2025-09-22T04:02:34.155Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/d3/131dec79ce61c5567fecf82515bd9bc36395df42501b50f7f7f3bd065df0/lxml-6.0.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:370cd78d5855cfbffd57c422851f7d3864e6ae72d0da615fca4dad8c45d375a5", size = 5102953, upload-time = "2025-09-22T04:02:36.054Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/ea/a43ba9bb750d4ffdd885f2cd333572f5bb900cd2408b67fdda07e85978a0/lxml-6.0.2-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:901e3b4219fa04ef766885fb40fa516a71662a4c61b80c94d25336b4934b71c0", size = 5055054, upload-time = "2025-09-22T04:02:38.154Z" },
+    { url = "https://files.pythonhosted.org/packages/60/23/6885b451636ae286c34628f70a7ed1fcc759f8d9ad382d132e1c8d3d9bfd/lxml-6.0.2-cp314-cp314-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:a4bf42d2e4cf52c28cc1812d62426b9503cdb0c87a6de81442626aa7d69707ba", size = 5352421, upload-time = "2025-09-22T04:02:40.413Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5b/fc2ddfc94ddbe3eebb8e9af6e3fd65e2feba4967f6a4e9683875c394c2d8/lxml-6.0.2-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2c7fdaa4d7c3d886a42534adec7cfac73860b89b4e5298752f60aa5984641a0", size = 5673684, upload-time = "2025-09-22T04:02:42.288Z" },
+    { url = "https://files.pythonhosted.org/packages/29/9c/47293c58cc91769130fbf85531280e8cc7868f7fbb6d92f4670071b9cb3e/lxml-6.0.2-cp314-cp314-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:98a5e1660dc7de2200b00d53fa00bcd3c35a3608c305d45a7bbcaf29fa16e83d", size = 5252463, upload-time = "2025-09-22T04:02:44.165Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/da/ba6eceb830c762b48e711ded880d7e3e89fc6c7323e587c36540b6b23c6b/lxml-6.0.2-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:dc051506c30b609238d79eda75ee9cab3e520570ec8219844a72a46020901e37", size = 4698437, upload-time = "2025-09-22T04:02:46.524Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/24/7be3f82cb7990b89118d944b619e53c656c97dc89c28cfb143fdb7cd6f4d/lxml-6.0.2-cp314-cp314-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8799481bbdd212470d17513a54d568f44416db01250f49449647b5ab5b5dccb9", size = 5269890, upload-time = "2025-09-22T04:02:48.812Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/bd/dcfb9ea1e16c665efd7538fc5d5c34071276ce9220e234217682e7d2c4a5/lxml-6.0.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9261bb77c2dab42f3ecd9103951aeca2c40277701eb7e912c545c1b16e0e4917", size = 5097185, upload-time = "2025-09-22T04:02:50.746Z" },
+    { url = "https://files.pythonhosted.org/packages/21/04/a60b0ff9314736316f28316b694bccbbabe100f8483ad83852d77fc7468e/lxml-6.0.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:65ac4a01aba353cfa6d5725b95d7aed6356ddc0a3cd734de00124d285b04b64f", size = 4745895, upload-time = "2025-09-22T04:02:52.968Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/bd/7d54bd1846e5a310d9c715921c5faa71cf5c0853372adf78aee70c8d7aa2/lxml-6.0.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:b22a07cbb82fea98f8a2fd814f3d1811ff9ed76d0fc6abc84eb21527596e7cc8", size = 5695246, upload-time = "2025-09-22T04:02:54.798Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/32/5643d6ab947bc371da21323acb2a6e603cedbe71cb4c99c8254289ab6f4e/lxml-6.0.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:d759cdd7f3e055d6bc8d9bec3ad905227b2e4c785dc16c372eb5b5e83123f48a", size = 5260797, upload-time = "2025-09-22T04:02:57.058Z" },
+    { url = "https://files.pythonhosted.org/packages/33/da/34c1ec4cff1eea7d0b4cd44af8411806ed943141804ac9c5d565302afb78/lxml-6.0.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:945da35a48d193d27c188037a05fec5492937f66fb1958c24fc761fb9d40d43c", size = 5277404, upload-time = "2025-09-22T04:02:58.966Z" },
+    { url = "https://files.pythonhosted.org/packages/82/57/4eca3e31e54dc89e2c3507e1cd411074a17565fa5ffc437c4ae0a00d439e/lxml-6.0.2-cp314-cp314-win32.whl", hash = "sha256:be3aaa60da67e6153eb15715cc2e19091af5dc75faef8b8a585aea372507384b", size = 3670072, upload-time = "2025-09-22T04:03:38.05Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/e0/c96cf13eccd20c9421ba910304dae0f619724dcf1702864fd59dd386404d/lxml-6.0.2-cp314-cp314-win_amd64.whl", hash = "sha256:fa25afbadead523f7001caf0c2382afd272c315a033a7b06336da2637d92d6ed", size = 4080617, upload-time = "2025-09-22T04:03:39.835Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/5d/b3f03e22b3d38d6f188ef044900a9b29b2fe0aebb94625ce9fe244011d34/lxml-6.0.2-cp314-cp314-win_arm64.whl", hash = "sha256:063eccf89df5b24e361b123e257e437f9e9878f425ee9aae3144c77faf6da6d8", size = 3754930, upload-time = "2025-09-22T04:03:41.565Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/5c/42c2c4c03554580708fc738d13414801f340c04c3eff90d8d2d227145275/lxml-6.0.2-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:6162a86d86893d63084faaf4ff937b3daea233e3682fb4474db07395794fa80d", size = 8910380, upload-time = "2025-09-22T04:03:01.645Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/4f/12df843e3e10d18d468a7557058f8d3733e8b6e12401f30b1ef29360740f/lxml-6.0.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:414aaa94e974e23a3e92e7ca5b97d10c0cf37b6481f50911032c69eeb3991bba", size = 4775632, upload-time = "2025-09-22T04:03:03.814Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/0c/9dc31e6c2d0d418483cbcb469d1f5a582a1cd00a1f4081953d44051f3c50/lxml-6.0.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:48461bd21625458dd01e14e2c38dd0aea69addc3c4f960c30d9f59d7f93be601", size = 4975171, upload-time = "2025-09-22T04:03:05.651Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/2b/9b870c6ca24c841bdd887504808f0417aa9d8d564114689266f19ddf29c8/lxml-6.0.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:25fcc59afc57d527cfc78a58f40ab4c9b8fd096a9a3f964d2781ffb6eb33f4ed", size = 5110109, upload-time = "2025-09-22T04:03:07.452Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/0c/4f5f2a4dd319a178912751564471355d9019e220c20d7db3fb8307ed8582/lxml-6.0.2-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5179c60288204e6ddde3f774a93350177e08876eaf3ab78aa3a3649d43eb7d37", size = 5041061, upload-time = "2025-09-22T04:03:09.297Z" },
+    { url = "https://files.pythonhosted.org/packages/12/64/554eed290365267671fe001a20d72d14f468ae4e6acef1e179b039436967/lxml-6.0.2-cp314-cp314t-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:967aab75434de148ec80597b75062d8123cadf2943fb4281f385141e18b21338", size = 5306233, upload-time = "2025-09-22T04:03:11.651Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/31/1d748aa275e71802ad9722df32a7a35034246b42c0ecdd8235412c3396ef/lxml-6.0.2-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d100fcc8930d697c6561156c6810ab4a508fb264c8b6779e6e61e2ed5e7558f9", size = 5604739, upload-time = "2025-09-22T04:03:13.592Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/41/2c11916bcac09ed561adccacceaedd2bf0e0b25b297ea92aab99fd03d0fa/lxml-6.0.2-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2ca59e7e13e5981175b8b3e4ab84d7da57993eeff53c07764dcebda0d0e64ecd", size = 5225119, upload-time = "2025-09-22T04:03:15.408Z" },
+    { url = "https://files.pythonhosted.org/packages/99/05/4e5c2873d8f17aa018e6afde417c80cc5d0c33be4854cce3ef5670c49367/lxml-6.0.2-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:957448ac63a42e2e49531b9d6c0fa449a1970dbc32467aaad46f11545be9af1d", size = 4633665, upload-time = "2025-09-22T04:03:17.262Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/c9/dcc2da1bebd6275cdc723b515f93edf548b82f36a5458cca3578bc899332/lxml-6.0.2-cp314-cp314t-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b7fc49c37f1786284b12af63152fe1d0990722497e2d5817acfe7a877522f9a9", size = 5234997, upload-time = "2025-09-22T04:03:19.14Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/e2/5172e4e7468afca64a37b81dba152fc5d90e30f9c83c7c3213d6a02a5ce4/lxml-6.0.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e19e0643cc936a22e837f79d01a550678da8377d7d801a14487c10c34ee49c7e", size = 5090957, upload-time = "2025-09-22T04:03:21.436Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/b3/15461fd3e5cd4ddcb7938b87fc20b14ab113b92312fc97afe65cd7c85de1/lxml-6.0.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:1db01e5cf14345628e0cbe71067204db658e2fb8e51e7f33631f5f4735fefd8d", size = 4764372, upload-time = "2025-09-22T04:03:23.27Z" },
+    { url = "https://files.pythonhosted.org/packages/05/33/f310b987c8bf9e61c4dd8e8035c416bd3230098f5e3cfa69fc4232de7059/lxml-6.0.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:875c6b5ab39ad5291588aed6925fac99d0097af0dd62f33c7b43736043d4a2ec", size = 5634653, upload-time = "2025-09-22T04:03:25.767Z" },
+    { url = "https://files.pythonhosted.org/packages/70/ff/51c80e75e0bc9382158133bdcf4e339b5886c6ee2418b5199b3f1a61ed6d/lxml-6.0.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:cdcbed9ad19da81c480dfd6dd161886db6096083c9938ead313d94b30aadf272", size = 5233795, upload-time = "2025-09-22T04:03:27.62Z" },
+    { url = "https://files.pythonhosted.org/packages/56/4d/4856e897df0d588789dd844dbed9d91782c4ef0b327f96ce53c807e13128/lxml-6.0.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:80dadc234ebc532e09be1975ff538d154a7fa61ea5031c03d25178855544728f", size = 5257023, upload-time = "2025-09-22T04:03:30.056Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/85/86766dfebfa87bea0ab78e9ff7a4b4b45225df4b4d3b8cc3c03c5cd68464/lxml-6.0.2-cp314-cp314t-win32.whl", hash = "sha256:da08e7bb297b04e893d91087df19638dc7a6bb858a954b0cc2b9f5053c922312", size = 3911420, upload-time = "2025-09-22T04:03:32.198Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/1a/b248b355834c8e32614650b8008c69ffeb0ceb149c793961dd8c0b991bb3/lxml-6.0.2-cp314-cp314t-win_amd64.whl", hash = "sha256:252a22982dca42f6155125ac76d3432e548a7625d56f5a273ee78a5057216eca", size = 4406837, upload-time = "2025-09-22T04:03:34.027Z" },
+    { url = "https://files.pythonhosted.org/packages/92/aa/df863bcc39c5e0946263454aba394de8a9084dbaff8ad143846b0d844739/lxml-6.0.2-cp314-cp314t-win_arm64.whl", hash = "sha256:bb4c1847b303835d89d785a18801a883436cdfd5dc3d62947f9c49e24f0f5a2c", size = 3822205, upload-time = "2025-09-22T04:03:36.249Z" },
+]
+
+[[package]]
+name = "macholib"
+version = "1.16.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "altgraph" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/10/2f/97589876ea967487978071c9042518d28b958d87b17dceb7cdc1d881f963/macholib-1.16.4.tar.gz", hash = "sha256:f408c93ab2e995cd2c46e34fe328b130404be143469e41bc366c807448979362", size = 59427, upload-time = "2025-11-22T08:28:38.373Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/d1/a9f36f8ecdf0fb7c9b1e78c8d7af12b8c8754e74851ac7b94a8305540fc7/macholib-1.16.4-py2.py3-none-any.whl", hash = "sha256:da1a3fa8266e30f0ce7e97c6a54eefaae8edd1e5f86f3eb8b95457cae90265ea", size = 38117, upload-time = "2025-11-22T08:28:36.939Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "25.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" },
+]
+
+[[package]]
+name = "pefile"
+version = "2024.8.26"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/03/4f/2750f7f6f025a1507cd3b7218691671eecfd0bbebebe8b39aa0fe1d360b8/pefile-2024.8.26.tar.gz", hash = "sha256:3ff6c5d8b43e8c37bb6e6dd5085658d658a7a0bdcd20b6a07b1fcfc1c4e9d632", size = 76008, upload-time = "2024-08-26T20:58:38.155Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/16/12b82f791c7f50ddec566873d5bdd245baa1491bac11d15ffb98aecc8f8b/pefile-2024.8.26-py3-none-any.whl", hash = "sha256:76f8b485dcd3b1bb8166f1128d395fa3d87af26360c2358fb75b80019b957c6f", size = 74766, upload-time = "2024-08-26T21:01:02.632Z" },
+]
+
+[[package]]
+name = "pillow"
+version = "12.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d0/02/d52c733a2452ef1ffcc123b68e6606d07276b0e358db70eabad7e40042b7/pillow-12.1.0.tar.gz", hash = "sha256:5c5ae0a06e9ea030ab786b0251b32c7e4ce10e58d983c0d5c56029455180b5b9", size = 46977283, upload-time = "2026-01-02T09:13:29.892Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dd/c7/2530a4aa28248623e9d7f27316b42e27c32ec410f695929696f2e0e4a778/pillow-12.1.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:7b5dd7cbae20285cdb597b10eb5a2c13aa9de6cde9bb64a3c1317427b1db1ae1", size = 4062543, upload-time = "2026-01-02T09:11:31.566Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/1f/40b8eae823dc1519b87d53c30ed9ef085506b05281d313031755c1705f73/pillow-12.1.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:29a4cef9cb672363926f0470afc516dbf7305a14d8c54f7abbb5c199cd8f8179", size = 4138373, upload-time = "2026-01-02T09:11:33.367Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/77/6fa60634cf06e52139fd0e89e5bbf055e8166c691c42fb162818b7fda31d/pillow-12.1.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:681088909d7e8fa9e31b9799aaa59ba5234c58e5e4f1951b4c4d1082a2e980e0", size = 3601241, upload-time = "2026-01-02T09:11:35.011Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/bf/28ab865de622e14b747f0cd7877510848252d950e43002e224fb1c9ababf/pillow-12.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:983976c2ab753166dc66d36af6e8ec15bb511e4a25856e2227e5f7e00a160587", size = 5262410, upload-time = "2026-01-02T09:11:36.682Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/34/583420a1b55e715937a85bd48c5c0991598247a1fd2eb5423188e765ea02/pillow-12.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:db44d5c160a90df2d24a24760bbd37607d53da0b34fb546c4c232af7192298ac", size = 4657312, upload-time = "2026-01-02T09:11:38.535Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/fd/f5a0896839762885b3376ff04878f86ab2b097c2f9a9cdccf4eda8ba8dc0/pillow-12.1.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:6b7a9d1db5dad90e2991645874f708e87d9a3c370c243c2d7684d28f7e133e6b", size = 6232605, upload-time = "2026-01-02T09:11:40.602Z" },
+    { url = "https://files.pythonhosted.org/packages/98/aa/938a09d127ac1e70e6ed467bd03834350b33ef646b31edb7452d5de43792/pillow-12.1.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6258f3260986990ba2fa8a874f8b6e808cf5abb51a94015ca3dc3c68aa4f30ea", size = 8041617, upload-time = "2026-01-02T09:11:42.721Z" },
+    { url = "https://files.pythonhosted.org/packages/17/e8/538b24cb426ac0186e03f80f78bc8dc7246c667f58b540bdd57c71c9f79d/pillow-12.1.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e115c15e3bc727b1ca3e641a909f77f8ca72a64fff150f666fcc85e57701c26c", size = 6346509, upload-time = "2026-01-02T09:11:44.955Z" },
+    { url = "https://files.pythonhosted.org/packages/01/9a/632e58ec89a32738cabfd9ec418f0e9898a2b4719afc581f07c04a05e3c9/pillow-12.1.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6741e6f3074a35e47c77b23a4e4f2d90db3ed905cb1c5e6e0d49bff2045632bc", size = 7038117, upload-time = "2026-01-02T09:11:46.736Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/a2/d40308cf86eada842ca1f3ffa45d0ca0df7e4ab33c83f81e73f5eaed136d/pillow-12.1.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:935b9d1aed48fcfb3f838caac506f38e29621b44ccc4f8a64d575cb1b2a88644", size = 6460151, upload-time = "2026-01-02T09:11:48.625Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/88/f5b058ad6453a085c5266660a1417bdad590199da1b32fb4efcff9d33b05/pillow-12.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5fee4c04aad8932da9f8f710af2c1a15a83582cfb884152a9caa79d4efcdbf9c", size = 7164534, upload-time = "2026-01-02T09:11:50.445Z" },
+    { url = "https://files.pythonhosted.org/packages/19/ce/c17334caea1db789163b5d855a5735e47995b0b5dc8745e9a3605d5f24c0/pillow-12.1.0-cp313-cp313-win32.whl", hash = "sha256:a786bf667724d84aa29b5db1c61b7bfdde380202aaca12c3461afd6b71743171", size = 6332551, upload-time = "2026-01-02T09:11:52.234Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/07/74a9d941fa45c90a0d9465098fe1ec85de3e2afbdc15cc4766622d516056/pillow-12.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:461f9dfdafa394c59cd6d818bdfdbab4028b83b02caadaff0ffd433faf4c9a7a", size = 7040087, upload-time = "2026-01-02T09:11:54.822Z" },
+    { url = "https://files.pythonhosted.org/packages/88/09/c99950c075a0e9053d8e880595926302575bc742b1b47fe1bbcc8d388d50/pillow-12.1.0-cp313-cp313-win_arm64.whl", hash = "sha256:9212d6b86917a2300669511ed094a9406888362e085f2431a7da985a6b124f45", size = 2452470, upload-time = "2026-01-02T09:11:56.522Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/ba/970b7d85ba01f348dee4d65412476321d40ee04dcb51cd3735b9dc94eb58/pillow-12.1.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:00162e9ca6d22b7c3ee8e61faa3c3253cd19b6a37f126cad04f2f88b306f557d", size = 5264816, upload-time = "2026-01-02T09:11:58.227Z" },
+    { url = "https://files.pythonhosted.org/packages/10/60/650f2fb55fdba7a510d836202aa52f0baac633e50ab1cf18415d332188fb/pillow-12.1.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:7d6daa89a00b58c37cb1747ec9fb7ac3bc5ffd5949f5888657dfddde6d1312e0", size = 4660472, upload-time = "2026-01-02T09:12:00.798Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/c0/5273a99478956a099d533c4f46cbaa19fd69d606624f4334b85e50987a08/pillow-12.1.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e2479c7f02f9d505682dc47df8c0ea1fc5e264c4d1629a5d63fe3e2334b89554", size = 6268974, upload-time = "2026-01-02T09:12:02.572Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/26/0bf714bc2e73d5267887d47931d53c4ceeceea6978148ed2ab2a4e6463c4/pillow-12.1.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f188d580bd870cda1e15183790d1cc2fa78f666e76077d103edf048eed9c356e", size = 8073070, upload-time = "2026-01-02T09:12:04.75Z" },
+    { url = "https://files.pythonhosted.org/packages/43/cf/1ea826200de111a9d65724c54f927f3111dc5ae297f294b370a670c17786/pillow-12.1.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0fde7ec5538ab5095cc02df38ee99b0443ff0e1c847a045554cf5f9af1f4aa82", size = 6380176, upload-time = "2026-01-02T09:12:06.626Z" },
+    { url = "https://files.pythonhosted.org/packages/03/e0/7938dd2b2013373fd85d96e0f38d62b7a5a262af21ac274250c7ca7847c9/pillow-12.1.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0ed07dca4a8464bada6139ab38f5382f83e5f111698caf3191cb8dbf27d908b4", size = 7067061, upload-time = "2026-01-02T09:12:08.624Z" },
+    { url = "https://files.pythonhosted.org/packages/86/ad/a2aa97d37272a929a98437a8c0ac37b3cf012f4f8721e1bd5154699b2518/pillow-12.1.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:f45bd71d1fa5e5749587613037b172e0b3b23159d1c00ef2fc920da6f470e6f0", size = 6491824, upload-time = "2026-01-02T09:12:10.488Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/44/80e46611b288d51b115826f136fb3465653c28f491068a72d3da49b54cd4/pillow-12.1.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:277518bf4fe74aa91489e1b20577473b19ee70fb97c374aa50830b279f25841b", size = 7190911, upload-time = "2026-01-02T09:12:12.772Z" },
+    { url = "https://files.pythonhosted.org/packages/86/77/eacc62356b4cf81abe99ff9dbc7402750044aed02cfd6a503f7c6fc11f3e/pillow-12.1.0-cp313-cp313t-win32.whl", hash = "sha256:7315f9137087c4e0ee73a761b163fc9aa3b19f5f606a7fc08d83fd3e4379af65", size = 6336445, upload-time = "2026-01-02T09:12:14.775Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/3c/57d81d0b74d218706dafccb87a87ea44262c43eef98eb3b164fd000e0491/pillow-12.1.0-cp313-cp313t-win_amd64.whl", hash = "sha256:0ddedfaa8b5f0b4ffbc2fa87b556dc59f6bb4ecb14a53b33f9189713ae8053c0", size = 7045354, upload-time = "2026-01-02T09:12:16.599Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/82/8b9b97bba2e3576a340f93b044a3a3a09841170ab4c1eb0d5c93469fd32f/pillow-12.1.0-cp313-cp313t-win_arm64.whl", hash = "sha256:80941e6d573197a0c28f394753de529bb436b1ca990ed6e765cf42426abc39f8", size = 2454547, upload-time = "2026-01-02T09:12:18.704Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/87/bdf971d8bbcf80a348cc3bacfcb239f5882100fe80534b0ce67a784181d8/pillow-12.1.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:5cb7bc1966d031aec37ddb9dcf15c2da5b2e9f7cc3ca7c54473a20a927e1eb91", size = 4062533, upload-time = "2026-01-02T09:12:20.791Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/4f/5eb37a681c68d605eb7034c004875c81f86ec9ef51f5be4a63eadd58859a/pillow-12.1.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:97e9993d5ed946aba26baf9c1e8cf18adbab584b99f452ee72f7ee8acb882796", size = 4138546, upload-time = "2026-01-02T09:12:23.664Z" },
+    { url = "https://files.pythonhosted.org/packages/11/6d/19a95acb2edbace40dcd582d077b991646b7083c41b98da4ed7555b59733/pillow-12.1.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:414b9a78e14ffeb98128863314e62c3f24b8a86081066625700b7985b3f529bd", size = 3601163, upload-time = "2026-01-02T09:12:26.338Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/36/2b8138e51cb42e4cc39c3297713455548be855a50558c3ac2beebdc251dd/pillow-12.1.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:e6bdb408f7c9dd2a5ff2b14a3b0bb6d4deb29fb9961e6eb3ae2031ae9a5cec13", size = 5266086, upload-time = "2026-01-02T09:12:28.782Z" },
+    { url = "https://files.pythonhosted.org/packages/53/4b/649056e4d22e1caa90816bf99cef0884aed607ed38075bd75f091a607a38/pillow-12.1.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:3413c2ae377550f5487991d444428f1a8ae92784aac79caa8b1e3b89b175f77e", size = 4657344, upload-time = "2026-01-02T09:12:31.117Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/6b/c5742cea0f1ade0cd61485dc3d81f05261fc2276f537fbdc00802de56779/pillow-12.1.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e5dcbe95016e88437ecf33544ba5db21ef1b8dd6e1b434a2cb2a3d605299e643", size = 6232114, upload-time = "2026-01-02T09:12:32.936Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/8f/9f521268ce22d63991601aafd3d48d5ff7280a246a1ef62d626d67b44064/pillow-12.1.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d0a7735df32ccbcc98b98a1ac785cc4b19b580be1bdf0aeb5c03223220ea09d5", size = 8042708, upload-time = "2026-01-02T09:12:34.78Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/eb/257f38542893f021502a1bbe0c2e883c90b5cff26cc33b1584a841a06d30/pillow-12.1.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0c27407a2d1b96774cbc4a7594129cc027339fd800cd081e44497722ea1179de", size = 6347762, upload-time = "2026-01-02T09:12:36.748Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/5a/8ba375025701c09b309e8d5163c5a4ce0102fa86bbf8800eb0d7ac87bc51/pillow-12.1.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15c794d74303828eaa957ff8070846d0efe8c630901a1c753fdc63850e19ecd9", size = 7039265, upload-time = "2026-01-02T09:12:39.082Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/dc/cf5e4cdb3db533f539e88a7bbf9f190c64ab8a08a9bc7a4ccf55067872e4/pillow-12.1.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c990547452ee2800d8506c4150280757f88532f3de2a58e3022e9b179107862a", size = 6462341, upload-time = "2026-01-02T09:12:40.946Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/47/0291a25ac9550677e22eda48510cfc4fa4b2ef0396448b7fbdc0a6946309/pillow-12.1.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b63e13dd27da389ed9475b3d28510f0f954bca0041e8e551b2a4eb1eab56a39a", size = 7165395, upload-time = "2026-01-02T09:12:42.706Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/4c/e005a59393ec4d9416be06e6b45820403bb946a778e39ecec62f5b2b991e/pillow-12.1.0-cp314-cp314-win32.whl", hash = "sha256:1a949604f73eb07a8adab38c4fe50791f9919344398bdc8ac6b307f755fc7030", size = 6431413, upload-time = "2026-01-02T09:12:44.944Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/af/f23697f587ac5f9095d67e31b81c95c0249cd461a9798a061ed6709b09b5/pillow-12.1.0-cp314-cp314-win_amd64.whl", hash = "sha256:4f9f6a650743f0ddee5593ac9e954ba1bdbc5e150bc066586d4f26127853ab94", size = 7176779, upload-time = "2026-01-02T09:12:46.727Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/36/6a51abf8599232f3e9afbd16d52829376a68909fe14efe29084445db4b73/pillow-12.1.0-cp314-cp314-win_arm64.whl", hash = "sha256:808b99604f7873c800c4840f55ff389936ef1948e4e87645eaf3fccbc8477ac4", size = 2543105, upload-time = "2026-01-02T09:12:49.243Z" },
+    { url = "https://files.pythonhosted.org/packages/82/54/2e1dd20c8749ff225080d6ba465a0cab4387f5db0d1c5fb1439e2d99923f/pillow-12.1.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:bc11908616c8a283cf7d664f77411a5ed2a02009b0097ff8abbba5e79128ccf2", size = 5268571, upload-time = "2026-01-02T09:12:51.11Z" },
+    { url = "https://files.pythonhosted.org/packages/57/61/571163a5ef86ec0cf30d265ac2a70ae6fc9e28413d1dc94fa37fae6bda89/pillow-12.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:896866d2d436563fa2a43a9d72f417874f16b5545955c54a64941e87c1376c61", size = 4660426, upload-time = "2026-01-02T09:12:52.865Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/e1/53ee5163f794aef1bf84243f755ee6897a92c708505350dd1923f4afec48/pillow-12.1.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8e178e3e99d3c0ea8fc64b88447f7cac8ccf058af422a6cedc690d0eadd98c51", size = 6269908, upload-time = "2026-01-02T09:12:54.884Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/0b/b4b4106ff0ee1afa1dc599fde6ab230417f800279745124f6c50bcffed8e/pillow-12.1.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:079af2fb0c599c2ec144ba2c02766d1b55498e373b3ac64687e43849fbbef5bc", size = 8074733, upload-time = "2026-01-02T09:12:56.802Z" },
+    { url = "https://files.pythonhosted.org/packages/19/9f/80b411cbac4a732439e629a26ad3ef11907a8c7fc5377b7602f04f6fe4e7/pillow-12.1.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bdec5e43377761c5dbca620efb69a77f6855c5a379e32ac5b158f54c84212b14", size = 6381431, upload-time = "2026-01-02T09:12:58.823Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/b7/d65c45db463b66ecb6abc17c6ba6917a911202a07662247e1355ce1789e7/pillow-12.1.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:565c986f4b45c020f5421a4cea13ef294dde9509a8577f29b2fc5edc7587fff8", size = 7068529, upload-time = "2026-01-02T09:13:00.885Z" },
+    { url = "https://files.pythonhosted.org/packages/50/96/dfd4cd726b4a45ae6e3c669fc9e49deb2241312605d33aba50499e9d9bd1/pillow-12.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:43aca0a55ce1eefc0aefa6253661cb54571857b1a7b2964bd8a1e3ef4b729924", size = 6492981, upload-time = "2026-01-02T09:13:03.314Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/1c/b5dc52cf713ae46033359c5ca920444f18a6359ce1020dd3e9c553ea5bc6/pillow-12.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0deedf2ea233722476b3a81e8cdfbad786f7adbed5d848469fa59fe52396e4ef", size = 7191878, upload-time = "2026-01-02T09:13:05.276Z" },
+    { url = "https://files.pythonhosted.org/packages/53/26/c4188248bd5edaf543864fe4834aebe9c9cb4968b6f573ce014cc42d0720/pillow-12.1.0-cp314-cp314t-win32.whl", hash = "sha256:b17fbdbe01c196e7e159aacb889e091f28e61020a8abeac07b68079b6e626988", size = 6438703, upload-time = "2026-01-02T09:13:07.491Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/0e/69ed296de8ea05cb03ee139cee600f424ca166e632567b2d66727f08c7ed/pillow-12.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:27b9baecb428899db6c0de572d6d305cfaf38ca1596b5c0542a5182e3e74e8c6", size = 7182927, upload-time = "2026-01-02T09:13:09.841Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/f5/68334c015eed9b5cff77814258717dec591ded209ab5b6fb70e2ae873d1d/pillow-12.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:f61333d817698bdcdd0f9d7793e365ac3d2a21c1f1eb02b32ad6aefb8d8ea831", size = 2545104, upload-time = "2026-01-02T09:13:12.068Z" },
+]
 
 [[package]]
 name = "polars"
-version = "1.33.1"
+version = "1.37.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/85/da/8246f1d69d7e49f96f0c5529057a19af1536621748ef214bbd4112c83b8e/polars-1.33.1.tar.gz", hash = "sha256:fa3fdc34eab52a71498264d6ff9b0aa6955eb4b0ae8add5d3cb43e4b84644007", size = 4822485, upload-time = "2025-09-09T08:37:49.062Z" }
+dependencies = [
+    { name = "polars-runtime-32" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/84/ae/dfebf31b9988c20998140b54d5b521f64ce08879f2c13d9b4d44d7c87e32/polars-1.37.1.tar.gz", hash = "sha256:0309e2a4633e712513401964b4d95452f124ceabf7aec6db50affb9ced4a274e", size = 715572, upload-time = "2026-01-12T23:27:03.267Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/19/79/c51e7e1d707d8359bcb76e543a8315b7ae14069ecf5e75262a0ecb32e044/polars-1.33.1-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:3881c444b0f14778ba94232f077a709d435977879c1b7d7bd566b55bd1830bb5", size = 39132875, upload-time = "2025-09-09T08:36:38.609Z" },
+    { url = "https://files.pythonhosted.org/packages/08/75/ec73e38812bca7c2240aff481b9ddff20d1ad2f10dee4b3353f5eeaacdab/polars-1.37.1-py3-none-any.whl", hash = "sha256:377fed8939a2f1223c1563cfabdc7b4a3d6ff846efa1f2ddeb8644fafd9b1aff", size = 805749, upload-time = "2026-01-12T23:25:48.595Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/15/1094099a1b9cb4fbff58cd8ed3af8964f4d22a5b682ea0b7bb72bf4bc3d9/polars-1.33.1-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:29200b89c9a461e6f06fc1660bc9c848407640ee30fe0e5ef4947cfd49d55337", size = 35638783, upload-time = "2025-09-09T08:36:43.748Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/b9/9ac769e4d8e8f22b0f2e974914a63dd14dec1340cd23093de40f0d67d73b/polars-1.33.1-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:444940646e76342abaa47f126c70e3e40b56e8e02a9e89e5c5d1c24b086db58a", size = 39742297, upload-time = "2025-09-09T08:36:47.132Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/26/4c5da9f42fa067b2302fe62bcbf91faac5506c6513d910fae9548fc78d65/polars-1.33.1-cp39-abi3-manylinux_2_24_aarch64.whl", hash = "sha256:094a37d06789286649f654f229ec4efb9376630645ba8963b70cb9c0b008b3e1", size = 36684940, upload-time = "2025-09-09T08:36:50.561Z" },
-    { url = "https://files.pythonhosted.org/packages/06/a6/dc535da476c93b2efac619e04ab81081e004e4b4553352cd10e0d33a015d/polars-1.33.1-cp39-abi3-win_amd64.whl", hash = "sha256:c9781c704432a2276a185ee25898aa427f39a904fbe8fde4ae779596cdbd7a9e", size = 39456676, upload-time = "2025-09-09T08:36:54.612Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/4e/a4300d52dd81b58130ccadf3873f11b3c6de54836ad4a8f32bac2bd2ba17/polars-1.33.1-cp39-abi3-win_arm64.whl", hash = "sha256:c3cfddb3b78eae01a218222bdba8048529fef7e14889a71e33a5198644427642", size = 35445171, upload-time = "2025-09-09T08:36:58.043Z" },
 ]
 
 [package.optional-dependencies]
@@ -83,6 +241,50 @@ pyarrow = [
     { name = "pyarrow" },
 ]
 
+[[package]]
+name = "polars-runtime-32"
+version = "1.37.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/40/0b/addabe5e8d28a5a4c9887a08907be7ddc3fce892dc38f37d14b055438a57/polars_runtime_32-1.37.1.tar.gz", hash = "sha256:68779d4a691da20a5eb767d74165a8f80a2bdfbde4b54acf59af43f7fa028d8f", size = 2818945, upload-time = "2026-01-12T23:27:04.653Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/a2/e828ea9f845796de02d923edb790e408ca0b560cd68dbd74bb99a1b3c461/polars_runtime_32-1.37.1-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:0b8d4d73ea9977d3731927740e59d814647c5198bdbe359bcf6a8bfce2e79771", size = 43499912, upload-time = "2026-01-12T23:25:51.182Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/46/81b71b7aa9e3703ee6e4ef1f69a87e40f58ea7c99212bf49a95071e99c8c/polars_runtime_32-1.37.1-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:c682bf83f5f352e5e02f5c16c652c48ca40442f07b236f30662b22217320ce76", size = 39695707, upload-time = "2026-01-12T23:25:54.289Z" },
+    { url = "https://files.pythonhosted.org/packages/81/2e/20009d1fde7ee919e24040f5c87cb9d0e4f8e3f109b74ba06bc10c02459c/polars_runtime_32-1.37.1-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fc82b5bbe70ca1a4b764eed1419f6336752d6ba9fc1245388d7f8b12438afa2c", size = 41467034, upload-time = "2026-01-12T23:25:56.925Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/21/9b55bea940524324625b1e8fd96233290303eb1bf2c23b54573487bbbc25/polars_runtime_32-1.37.1-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a8362d11ac5193b994c7e9048ffe22ccfb976699cfbf6e128ce0302e06728894", size = 45142711, upload-time = "2026-01-12T23:26:00.817Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/25/c5f64461aeccdac6834a89f826d051ccd3b4ce204075e562c87a06ed2619/polars_runtime_32-1.37.1-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:04f5d5a2f013dca7391b7d8e7672fa6d37573a87f1d45d3dd5f0d9b5565a4b0f", size = 41638564, upload-time = "2026-01-12T23:26:04.186Z" },
+    { url = "https://files.pythonhosted.org/packages/35/af/509d3cf6c45e764ccf856beaae26fc34352f16f10f94a7839b1042920a73/polars_runtime_32-1.37.1-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:fbfde7c0ca8209eeaed546e4a32cca1319189aa61c5f0f9a2b4494262bd0c689", size = 44721136, upload-time = "2026-01-12T23:26:07.088Z" },
+    { url = "https://files.pythonhosted.org/packages/af/d1/5c0a83a625f72beef59394bebc57d12637997632a4f9d3ab2ffc2cc62bbf/polars_runtime_32-1.37.1-cp310-abi3-win_amd64.whl", hash = "sha256:da3d3642ae944e18dd17109d2a3036cb94ce50e5495c5023c77b1599d4c861bc", size = 44948288, upload-time = "2026-01-12T23:26:10.214Z" },
+    { url = "https://files.pythonhosted.org/packages/10/f3/061bb702465904b6502f7c9081daee34b09ccbaa4f8c94cf43a2a3b6dd6f/polars_runtime_32-1.37.1-cp310-abi3-win_arm64.whl", hash = "sha256:55f2c4847a8d2e267612f564de7b753a4bde3902eaabe7b436a0a4abf75949a0", size = 41001914, upload-time = "2026-01-12T23:26:12.997Z" },
+]
+
+[[package]]
+name = "psutil"
+version = "7.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/73/cb/09e5184fb5fc0358d110fc3ca7f6b1d033800734d34cac10f4136cfac10e/psutil-7.2.1.tar.gz", hash = "sha256:f7583aec590485b43ca601dd9cea0dcd65bd7bb21d30ef4ddbf4ea6b5ed1bdd3", size = 490253, upload-time = "2025-12-29T08:26:00.169Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/77/8e/f0c242053a368c2aa89584ecd1b054a18683f13d6e5a318fc9ec36582c94/psutil-7.2.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:ba9f33bb525b14c3ea563b2fd521a84d2fa214ec59e3e6a2858f78d0844dd60d", size = 129624, upload-time = "2025-12-29T08:26:04.255Z" },
+    { url = "https://files.pythonhosted.org/packages/26/97/a58a4968f8990617decee234258a2b4fc7cd9e35668387646c1963e69f26/psutil-7.2.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:81442dac7abfc2f4f4385ea9e12ddf5a796721c0f6133260687fec5c3780fa49", size = 130132, upload-time = "2025-12-29T08:26:06.228Z" },
+    { url = "https://files.pythonhosted.org/packages/db/6d/ed44901e830739af5f72a85fa7ec5ff1edea7f81bfbf4875e409007149bd/psutil-7.2.1-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ea46c0d060491051d39f0d2cff4f98d5c72b288289f57a21556cc7d504db37fc", size = 180612, upload-time = "2025-12-29T08:26:08.276Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/65/b628f8459bca4efbfae50d4bf3feaab803de9a160b9d5f3bd9295a33f0c2/psutil-7.2.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:35630d5af80d5d0d49cfc4d64c1c13838baf6717a13effb35869a5919b854cdf", size = 183201, upload-time = "2025-12-29T08:26:10.622Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/23/851cadc9764edcc18f0effe7d0bf69f727d4cf2442deb4a9f78d4e4f30f2/psutil-7.2.1-cp313-cp313t-win_amd64.whl", hash = "sha256:923f8653416604e356073e6e0bccbe7c09990acef442def2f5640dd0faa9689f", size = 139081, upload-time = "2025-12-29T08:26:12.483Z" },
+    { url = "https://files.pythonhosted.org/packages/59/82/d63e8494ec5758029f31c6cb06d7d161175d8281e91d011a4a441c8a43b5/psutil-7.2.1-cp313-cp313t-win_arm64.whl", hash = "sha256:cfbe6b40ca48019a51827f20d830887b3107a74a79b01ceb8cc8de4ccb17b672", size = 134767, upload-time = "2025-12-29T08:26:14.528Z" },
+    { url = "https://files.pythonhosted.org/packages/05/c2/5fb764bd61e40e1fe756a44bd4c21827228394c17414ade348e28f83cd79/psutil-7.2.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:494c513ccc53225ae23eec7fe6e1482f1b8a44674241b54561f755a898650679", size = 129716, upload-time = "2025-12-29T08:26:16.017Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/d2/935039c20e06f615d9ca6ca0ab756cf8408a19d298ffaa08666bc18dc805/psutil-7.2.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3fce5f92c22b00cdefd1645aa58ab4877a01679e901555067b1bd77039aa589f", size = 130133, upload-time = "2025-12-29T08:26:18.009Z" },
+    { url = "https://files.pythonhosted.org/packages/77/69/19f1eb0e01d24c2b3eacbc2f78d3b5add8a89bf0bb69465bc8d563cc33de/psutil-7.2.1-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:93f3f7b0bb07711b49626e7940d6fe52aa9940ad86e8f7e74842e73189712129", size = 181518, upload-time = "2025-12-29T08:26:20.241Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/6d/7e18b1b4fa13ad370787626c95887b027656ad4829c156bb6569d02f3262/psutil-7.2.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d34d2ca888208eea2b5c68186841336a7f5e0b990edec929be909353a202768a", size = 184348, upload-time = "2025-12-29T08:26:22.215Z" },
+    { url = "https://files.pythonhosted.org/packages/98/60/1672114392dd879586d60dd97896325df47d9a130ac7401318005aab28ec/psutil-7.2.1-cp314-cp314t-win_amd64.whl", hash = "sha256:2ceae842a78d1603753561132d5ad1b2f8a7979cb0c283f5b52fb4e6e14b1a79", size = 140400, upload-time = "2025-12-29T08:26:23.993Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/7b/d0e9d4513c46e46897b46bcfc410d51fc65735837ea57a25170f298326e6/psutil-7.2.1-cp314-cp314t-win_arm64.whl", hash = "sha256:08a2f175e48a898c8eb8eace45ce01777f4785bc744c90aa2cc7f2fa5462a266", size = 135430, upload-time = "2025-12-29T08:26:25.999Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/cf/5180eb8c8bdf6a503c6919f1da28328bd1e6b3b1b5b9d5b01ae64f019616/psutil-7.2.1-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:b2e953fcfaedcfbc952b44744f22d16575d3aa78eb4f51ae74165b4e96e55f42", size = 128137, upload-time = "2025-12-29T08:26:27.759Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/2c/78e4a789306a92ade5000da4f5de3255202c534acdadc3aac7b5458fadef/psutil-7.2.1-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:05cc68dbb8c174828624062e73078e7e35406f4ca2d0866c272c2410d8ef06d1", size = 128947, upload-time = "2025-12-29T08:26:29.548Z" },
+    { url = "https://files.pythonhosted.org/packages/29/f8/40e01c350ad9a2b3cb4e6adbcc8a83b17ee50dd5792102b6142385937db5/psutil-7.2.1-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5e38404ca2bb30ed7267a46c02f06ff842e92da3bb8c5bfdadbd35a5722314d8", size = 154694, upload-time = "2025-12-29T08:26:32.147Z" },
+    { url = "https://files.pythonhosted.org/packages/06/e4/b751cdf839c011a9714a783f120e6a86b7494eb70044d7d81a25a5cd295f/psutil-7.2.1-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ab2b98c9fc19f13f59628d94df5cc4cc4844bc572467d113a8b517d634e362c6", size = 156136, upload-time = "2025-12-29T08:26:34.079Z" },
+    { url = "https://files.pythonhosted.org/packages/44/ad/bbf6595a8134ee1e94a4487af3f132cef7fce43aef4a93b49912a48c3af7/psutil-7.2.1-cp36-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:f78baafb38436d5a128f837fab2d92c276dfb48af01a240b861ae02b2413ada8", size = 148108, upload-time = "2025-12-29T08:26:36.225Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/15/dd6fd869753ce82ff64dcbc18356093471a5a5adf4f77ed1f805d473d859/psutil-7.2.1-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:99a4cd17a5fdd1f3d014396502daa70b5ec21bf4ffe38393e152f8e449757d67", size = 147402, upload-time = "2025-12-29T08:26:39.21Z" },
+    { url = "https://files.pythonhosted.org/packages/34/68/d9317542e3f2b180c4306e3f45d3c922d7e86d8ce39f941bb9e2e9d8599e/psutil-7.2.1-cp37-abi3-win_amd64.whl", hash = "sha256:b1b0671619343aa71c20ff9767eced0483e4fc9e1f489d50923738caf6a03c17", size = 136938, upload-time = "2025-12-29T08:26:41.036Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/73/2ce007f4198c80fcf2cb24c169884f833fe93fbc03d55d302627b094ee91/psutil-7.2.1-cp37-abi3-win_arm64.whl", hash = "sha256:0d67c1822c355aa6f7314d92018fb4268a76668a536f133599b91edd48759442", size = 133836, upload-time = "2025-12-29T08:26:43.086Z" },
+]
+
 [[package]]
 name = "pyarrow"
 version = "21.0.0"
@@ -150,16 +352,16 @@ wheels = [
 
 [[package]]
 name = "pydantic-settings"
-version = "2.10.1"
+version = "2.12.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pydantic" },
     { name = "python-dotenv" },
     { name = "typing-inspection" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/68/85/1ea668bbab3c50071ca613c6ab30047fb36ab0da1b92fa8f17bbc38fd36c/pydantic_settings-2.10.1.tar.gz", hash = "sha256:06f0062169818d0f5524420a360d632d5857b83cffd4d42fe29597807a1614ee", size = 172583, upload-time = "2025-06-24T13:26:46.841Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/43/4b/ac7e0aae12027748076d72a8764ff1c9d82ca75a7a52622e67ed3f765c54/pydantic_settings-2.12.0.tar.gz", hash = "sha256:005538ef951e3c2a68e1c08b292b5f2e71490def8589d4221b95dab00dafcfd0", size = 194184, upload-time = "2025-11-10T14:25:47.013Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/58/f0/427018098906416f580e3cf1366d3b1abfb408a0652e9f31600c24a1903c/pydantic_settings-2.10.1-py3-none-any.whl", hash = "sha256:a60952460b99cf661dc25c29c0ef171721f98bfcb52ef8d9ea4c943d7c8cc796", size = 45235, upload-time = "2025-06-24T13:26:45.485Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/60/5d4751ba3f4a40a6891f24eec885f51afd78d208498268c734e256fb13c4/pydantic_settings-2.12.0-py3-none-any.whl", hash = "sha256:fddb9fd99a5b18da837b29710391e945b1e30c135477f484084ee513adb93809", size = 51880, upload-time = "2025-11-10T14:25:45.546Z" },
 ]
 
 [[package]]
@@ -177,20 +379,49 @@ wheels = [
 ]
 
 [[package]]
-name = "pyqtdarktheme"
+name = "pyinstaller"
-version = "2.1.0"
+version = "6.17.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "darkdetect" },
+    { name = "altgraph" },
+    { name = "macholib", marker = "sys_platform == 'darwin'" },
+    { name = "packaging" },
+    { name = "pefile", marker = "sys_platform == 'win32'" },
+    { name = "pyinstaller-hooks-contrib" },
+    { name = "pywin32-ctypes", marker = "sys_platform == 'win32'" },
+    { name = "setuptools" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/5c/f1/786feaad7a333072b34a913dbe38aef94b5ae43ad188934f5d70007aea79/pyqtdarktheme-2.1.0.tar.gz", hash = "sha256:5f8274ddfa3a5481ed9743cdb0f9debfeb7ff695b3a0d202a8104361d17dadb8", size = 42186, upload-time = "2022-12-25T08:33:11.662Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/80/9e0dad9c69a7cfd4b5aaede8c6225d762bab7247a2a6b7651e1995522001/pyinstaller-6.17.0.tar.gz", hash = "sha256:be372bd911392b88277e510940ac32a5c2a6ce4b8d00a311c78fa443f4f27313", size = 4014147, upload-time = "2025-11-24T19:43:32.109Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/12/cd/8ce0ac84e9f68dc549edcc5cbdeac7511439c5f7ee6c05f1f8826ef05d44/pyqtdarktheme-2.1.0-py3-none-any.whl", hash = "sha256:8739d99502230fbaca42551ea033c9ae31c81c4ebfec2f1ffde38f32a18bea7a", size = 54242, upload-time = "2022-12-25T08:33:10.125Z" },
+    { url = "https://files.pythonhosted.org/packages/35/f5/37e419d84d5284ecab11ef8b61306a3b978fe6f0fd69a9541e16bfd72e65/pyinstaller-6.17.0-py3-none-macosx_10_13_universal2.whl", hash = "sha256:4e446b8030c6e5a2f712e3f82011ecf6c7ead86008357b0d23a0ec4bcde31dac", size = 1031880, upload-time = "2025-11-24T19:42:30.862Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/b6/2e184879ab9cf90a1d2867fdd34d507c4d246b3cc52ca05aad00bfc70ee7/pyinstaller-6.17.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:aa9fd87aaa28239c6f0d0210114029bd03f8cac316a90bab071a5092d7c85ad7", size = 731968, upload-time = "2025-11-24T19:42:35.421Z" },
+    { url = "https://files.pythonhosted.org/packages/40/76/f529de98f7e5cce7904c19b224990003fc2267eda2ee5fdd8452acb420a9/pyinstaller-6.17.0-py3-none-manylinux2014_i686.whl", hash = "sha256:060b122e43e7c0b23e759a4153be34bd70914135ab955bb18a67181e0dca85a2", size = 743217, upload-time = "2025-11-24T19:42:39.286Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/10/c02bfbb050cafc4c353cf69baf95407e211e1372bd286ab5ce5cbc13a30a/pyinstaller-6.17.0-py3-none-manylinux2014_ppc64le.whl", hash = "sha256:cd213d1a545c97dfe4a3c40e8213ff7c5127fc115c49229f27a3fa541503444b", size = 741119, upload-time = "2025-11-24T19:42:43.12Z" },
+    { url = "https://files.pythonhosted.org/packages/11/9d/69fdacfd9335695f5900a376cfe3e4aed28f0720ffc15fee81fdb9d920bc/pyinstaller-6.17.0-py3-none-manylinux2014_s390x.whl", hash = "sha256:89c0d18ba8b62c6607abd8cf2299ae5ffa5c36d8c47f39608ce8c3f357f6099f", size = 738111, upload-time = "2025-11-24T19:42:46.97Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/1e/e8e36e1568f6865ac706c6e1f875c1a346ddaa9f9a8f923d66545d2240ed/pyinstaller-6.17.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:2a147b83cdebb07855bd5a663600891550062373a2ca375c58eacead33741a27", size = 737795, upload-time = "2025-11-24T19:42:50.675Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/15/9dc0f81ccb746c27bfa6ee53164422fe47ee079c7a717d9c4791aba78797/pyinstaller-6.17.0-py3-none-musllinux_1_1_aarch64.whl", hash = "sha256:f8cfbbfa6708e54fb936df6dd6eafaf133e84efb0d2fe25b91cfeefa793c4ca4", size = 736891, upload-time = "2025-11-24T19:42:54.458Z" },
+    { url = "https://files.pythonhosted.org/packages/97/e6/bed54821c1ebe1275c559661d3e7bfa23c406673b515252dfbf89db56c65/pyinstaller-6.17.0-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:97f4c1942f7b4cd73f9e38b49cc8f5f8a6fbb44922cb60dd3073a189b77ee1ae", size = 736752, upload-time = "2025-11-24T19:42:58.144Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/84/897d759198676b910d69d42640b6d25d50b449f2209e18127a974cf59dbe/pyinstaller-6.17.0-py3-none-win32.whl", hash = "sha256:ce0be227a037fd4be672226db709088565484f597d6b230bceec19850fdd4c85", size = 1317851, upload-time = "2025-11-24T19:43:04.361Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/f5/6a122efe024433ecc34aab6f499e0bd2bbe059c639b77b0045aa2421b0bf/pyinstaller-6.17.0-py3-none-win_amd64.whl", hash = "sha256:b019940dbf7a01489d6b26f9fb97db74b504e0a757010f7ad078675befc85a82", size = 1378685, upload-time = "2025-11-24T19:43:10.395Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/96/14991773c9e599707a53594429ccf372f9ee638df3b7d26b65fd1a7433f0/pyinstaller-6.17.0-py3-none-win_arm64.whl", hash = "sha256:3c92a335e338170df7e615f75279cfeea97ade89e6dd7694943c8c185460f7b7", size = 1320032, upload-time = "2025-11-24T19:43:16.388Z" },
+]
+
+[[package]]
+name = "pyinstaller-hooks-contrib"
+version = "2025.11"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "packaging" },
+    { name = "setuptools" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/45/2f/2c68b6722d233dae3e5243751aafc932940b836919cfaca22dd0c60d417c/pyinstaller_hooks_contrib-2025.11.tar.gz", hash = "sha256:dfe18632e06655fa88d218e0d768fd753e1886465c12a6d4bce04f1aaeec917d", size = 169183, upload-time = "2025-12-23T12:59:37.361Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a7/c4/3a096c6e701832443b957b9dac18a163103360d0c7f5842ca41695371148/pyinstaller_hooks_contrib-2025.11-py3-none-any.whl", hash = "sha256:777e163e2942474aa41a8e6d31ac1635292d63422c3646c176d584d04d971c34", size = 449478, upload-time = "2025-12-23T12:59:35.987Z" },
 ]
 
 [[package]]
 name = "pyside6"
-version = "6.9.2"
+version = "6.10.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pyside6-addons" },
@@ -198,42 +429,42 @@ dependencies = [
     { name = "shiboken6" },
 ]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/43/42/43577413bd5ab26f5f21e7a43c9396aac158a5d01900c87e4609c0e96278/pyside6-6.9.2-cp39-abi3-macosx_12_0_universal2.whl", hash = "sha256:71245c76bfbe5c41794ffd8546730ec7cc869d4bbe68535639e026e4ef8a7714", size = 558102, upload-time = "2025-08-26T07:52:57.302Z" },
+    { url = "https://files.pythonhosted.org/packages/56/22/f82cfcd1158be502c5741fe67c3fa853f3c1edbd3ac2c2250769dd9722d1/pyside6-6.10.1-cp39-abi3-macosx_13_0_universal2.whl", hash = "sha256:d0e70dd0e126d01986f357c2a555722f9462cf8a942bf2ce180baf69f468e516", size = 558169, upload-time = "2025-11-20T10:09:08.79Z" },
-    { url = "https://files.pythonhosted.org/packages/12/df/cb84f802df3dcc1d196d2f9f37dbb8227761826f936987c9386b8ae1ffcc/pyside6-6.9.2-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:64a9e2146e207d858e00226f68d7c1b4ab332954742a00dcabb721bb9e4aa0cd", size = 558243, upload-time = "2025-08-26T07:52:59.272Z" },
+    { url = "https://files.pythonhosted.org/packages/66/eb/54afe242a25d1c33b04ecd8321a549d9efb7b89eef7690eed92e98ba1dc9/pyside6-6.10.1-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:4053bf51ba2c2cb20e1005edd469997976a02cec009f7c46356a0b65c137f1fa", size = 557818, upload-time = "2025-11-20T10:09:10.132Z" },
-    { url = "https://files.pythonhosted.org/packages/94/2d/715db9da437b4632d06e2c4718aee9937760b84cf36c23d5441989e581b0/pyside6-6.9.2-cp39-abi3-manylinux_2_39_aarch64.whl", hash = "sha256:a78fad16241a1f2ed0fa0098cf3d621f591fc75b4badb7f3fa3959c9d861c806", size = 558245, upload-time = "2025-08-26T07:53:00.838Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/af/5706b1b33587dc2f3dfa3a5000424befba35e4f2d5889284eebbde37138b/pyside6-6.10.1-cp39-abi3-manylinux_2_39_aarch64.whl", hash = "sha256:7d3ca20a40139ca5324a7864f1d91cdf2ff237e11bd16354a42670f2a4eeb13c", size = 558358, upload-time = "2025-11-20T10:09:11.288Z" },
-    { url = "https://files.pythonhosted.org/packages/59/90/2e75cbff0e17f16b83d2b7e8434ae9175cae8d6ff816c9b56d307cf53c86/pyside6-6.9.2-cp39-abi3-win_amd64.whl", hash = "sha256:d1afbf48f9a5612b9ee2dc7c384c1a65c08b5830ba5e7d01f66d82678e5459df", size = 564604, upload-time = "2025-08-26T07:53:02.402Z" },
+    { url = "https://files.pythonhosted.org/packages/26/41/3f48d724ecc8e42cea8a8442aa9b5a86d394b85093275990038fd1020039/pyside6-6.10.1-cp39-abi3-win_amd64.whl", hash = "sha256:9f89ff994f774420eaa38cec6422fddd5356611d8481774820befd6f3bb84c9e", size = 564424, upload-time = "2025-11-20T10:09:12.677Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/34/e3dd4e046673efcbcfbe0aa2760df06b2877739b8f4da60f0229379adebd/pyside6-6.9.2-cp39-abi3-win_arm64.whl", hash = "sha256:1499b1d7629ab92119118e2636b4ace836b25e457ddf01003fdca560560b8c0a", size = 401833, upload-time = "2025-08-26T07:53:03.742Z" },
+    { url = "https://files.pythonhosted.org/packages/af/30/395411473b433875a82f6b5fdd0cb28f19a0e345bcaac9fbc039400d7072/pyside6-6.10.1-cp39-abi3-win_arm64.whl", hash = "sha256:9c5c1d94387d1a32a6fae25348097918ef413b87dfa3767c46f737c6d48ae437", size = 548866, upload-time = "2025-11-20T10:09:14.174Z" },
 ]
 
 [[package]]
 name = "pyside6-addons"
-version = "6.9.2"
+version = "6.10.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pyside6-essentials" },
     { name = "shiboken6" },
 ]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/47/39/a8f4a55001b6a0aaee042e706de2447f21c6dc2a610f3d3debb7d04db821/pyside6_addons-6.9.2-cp39-abi3-macosx_12_0_universal2.whl", hash = "sha256:7019fdcc0059626eb1608b361371f4dc8cb7f2d02f066908fd460739ff5a07cd", size = 316693692, upload-time = "2025-08-26T07:33:31.529Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/f9/b72a2578d7dbef7741bb90b5756b4ef9c99a5b40148ea53ce7f048573fe9/pyside6_addons-6.10.1-cp39-abi3-macosx_13_0_universal2.whl", hash = "sha256:4d2b82bbf9b861134845803837011e5f9ac7d33661b216805273cf0c6d0f8e82", size = 322639446, upload-time = "2025-11-20T09:54:50.75Z" },
-    { url = "https://files.pythonhosted.org/packages/14/48/0b16e9dabd4cafe02d59531832bc30b6f0e14c92076e90dd02379d365cb2/pyside6_addons-6.9.2-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:24350e5415317f269e743d1f7b4933fe5f59d90894aa067676c9ce6bfe9e7988", size = 166984613, upload-time = "2025-08-26T07:33:47.569Z" },
+    { url = "https://files.pythonhosted.org/packages/94/3b/3ed951c570a15570706a89d39bfd4eaaffdf16d5c2dca17e82fc3ec8aaa6/pyside6_addons-6.10.1-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:330c229b58d30083a7b99ed22e118eb4f4126408429816a4044ccd0438ae81b4", size = 170678293, upload-time = "2025-11-20T09:56:40.991Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/55/dc42a73387379bae82f921b7659cd2006ec0e80f7052f83ddc07e9eb9cca/pyside6_addons-6.9.2-cp39-abi3-manylinux_2_39_aarch64.whl", hash = "sha256:af8dee517de8d336735a6543f7dd496eb580e852c14b4d2304b890e2a29de499", size = 162908466, upload-time = "2025-08-26T07:39:49.331Z" },
+    { url = "https://files.pythonhosted.org/packages/22/77/4c780b204d0bf3323a75c184e349d063e208db44c993f1214aa4745d6f47/pyside6_addons-6.10.1-cp39-abi3-manylinux_2_39_aarch64.whl", hash = "sha256:56864b5fecd6924187a2d0f7e98d968ed72b6cc267caa5b294cd7e88fff4e54c", size = 166365011, upload-time = "2025-11-20T09:57:20.261Z" },
-    { url = "https://files.pythonhosted.org/packages/14/fa/396a2e86230c493b565e2dc89dc64e4b1c63582ac69afe77b693c3817a53/pyside6_addons-6.9.2-cp39-abi3-win_amd64.whl", hash = "sha256:98d2413904ee4b2b754b077af7875fa6ec08468c01a6628a2c9c3d2cece4874f", size = 160216647, upload-time = "2025-08-26T07:42:18.903Z" },
+    { url = "https://files.pythonhosted.org/packages/04/14/58239776499e6b279fa6ca2e0d47209531454b99f6bd2ad7c96f11109416/pyside6_addons-6.10.1-cp39-abi3-win_amd64.whl", hash = "sha256:b6e249d15407dd33d6a2ffabd9dc6d7a8ab8c95d05f16a71dad4d07781c76341", size = 164864664, upload-time = "2025-11-20T09:57:54.815Z" },
-    { url = "https://files.pythonhosted.org/packages/a7/fe/25f61259f1d5ec4648c9f6d2abd8e2cba2188f10735a57abafda719958e5/pyside6_addons-6.9.2-cp39-abi3-win_arm64.whl", hash = "sha256:b430cae782ff1a99fb95868043557f22c31b30c94afb9cf73278584e220a2ab6", size = 27126649, upload-time = "2025-08-26T07:42:37.696Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/cd/1b74108671ba4b1ebb2661330665c4898b089e9c87f7ba69fe2438f3d1b6/pyside6_addons-6.10.1-cp39-abi3-win_arm64.whl", hash = "sha256:0de303c0447326cdc6c8be5ab066ef581e2d0baf22560c9362d41b8304fdf2db", size = 34191225, upload-time = "2025-11-20T09:58:04.184Z" },
 ]
 
 [[package]]
 name = "pyside6-essentials"
-version = "6.9.2"
+version = "6.10.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "shiboken6" },
 ]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/08/21/41960c03721a99e7be99a96ebb8570bdfd6f76f512b5d09074365e27ce28/pyside6_essentials-6.9.2-cp39-abi3-macosx_12_0_universal2.whl", hash = "sha256:713eb8dcbb016ff10e6fca129c1bf2a0fd8cfac979e689264e0be3b332f9398e", size = 133092348, upload-time = "2025-08-26T07:43:57.231Z" },
+    { url = "https://files.pythonhosted.org/packages/04/b0/c43209fecef79912e9b1c70a1b5172b1edf76caebcc885c58c60a09613b0/pyside6_essentials-6.10.1-cp39-abi3-macosx_13_0_universal2.whl", hash = "sha256:cd224aff3bb26ff1fca32c050e1c4d0bd9f951a96219d40d5f3d0128485b0bbe", size = 105461499, upload-time = "2025-11-20T09:59:23.733Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/02/e38ff18f3d2d8d3071aa6823031aad6089267aa4668181db65ce9948bfc0/pyside6_essentials-6.9.2-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:84b8ca4fa56506e2848bdb4c7a0851a5e7adcb916bef9bce25ce2eeb6c7002cc", size = 96569791, upload-time = "2025-08-26T07:44:41.392Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/8e/b69ba7fa0c701f3f4136b50460441697ec49ee6ea35c229eb2a5ee4b5952/pyside6_essentials-6.10.1-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:e9ccbfb58c03911a0bce1f2198605b02d4b5ca6276bfc0cbcf7c6f6393ffb856", size = 76764617, upload-time = "2025-11-20T09:59:38.831Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/a1/1203d4db6919b42a937d9ac5ddb84b20ea42eb119f7c1ddeb77cb8fdb00c/pyside6_essentials-6.9.2-cp39-abi3-manylinux_2_39_aarch64.whl", hash = "sha256:d0f701503974bd51b408966539aa6956f3d8536e547ea8002fbfb3d77796bbc3", size = 94311809, upload-time = "2025-08-26T07:46:44.924Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/83/569d27f4b6c6b9377150fe1a3745d64d02614021bea233636bc936a23423/pyside6_essentials-6.10.1-cp39-abi3-manylinux_2_39_aarch64.whl", hash = "sha256:ec8617c9b143b0c19ba1cc5a7e98c538e4143795480cb152aee47802c18dc5d2", size = 75850373, upload-time = "2025-11-20T09:59:56.082Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/e3/3b3e869d3e332b6db93f6f64fac3b12f5c48b84f03f2aa50ee5c044ec0de/pyside6_essentials-6.9.2-cp39-abi3-win_amd64.whl", hash = "sha256:b2f746f795138ac63eb173f9850a6db293461a1b6ce22cf6dafac7d194a38951", size = 72624566, upload-time = "2025-08-26T07:48:04.64Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/64/a8df6333de8ccbf3a320e1346ca30d0f314840aff5e3db9b4b66bf38e26c/pyside6_essentials-6.10.1-cp39-abi3-win_amd64.whl", hash = "sha256:9555a48e8f0acf63fc6a23c250808db841b28a66ed6ad89ee0e4df7628752674", size = 74491180, upload-time = "2025-11-20T10:00:11.215Z" },
-    { url = "https://files.pythonhosted.org/packages/91/70/db78afc8b60b2e53f99145bde2f644cca43924a4dd869ffe664e0792730a/pyside6_essentials-6.9.2-cp39-abi3-win_arm64.whl", hash = "sha256:ecd7b5cd9e271f397fb89a6357f4ec301d8163e50869c6c557f9ccc6bed42789", size = 49561720, upload-time = "2025-08-26T07:49:43.708Z" },
+    { url = "https://files.pythonhosted.org/packages/67/da/65cc6c6a870d4ea908c59b2f0f9e2cf3bfc6c0710ebf278ed72f69865e4e/pyside6_essentials-6.10.1-cp39-abi3-win_arm64.whl", hash = "sha256:4d1d248644f1778f8ddae5da714ca0f5a150a5e6f602af2765a7d21b876da05c", size = 55190458, upload-time = "2025-11-20T10:00:26.226Z" },
 ]
 
 [[package]]
@@ -245,6 +476,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/5f/ed/539768cf28c661b5b068d66d96a2f155c4971a5d55684a514c1a0e0dec2f/python_dotenv-1.1.1-py3-none-any.whl", hash = "sha256:31f23644fe2602f88ff55e1f5c79ba497e01224ee7737937930c448e4d0e24dc", size = 20556, upload-time = "2025-06-24T04:21:06.073Z" },
 ]
 
+[[package]]
+name = "pywin32-ctypes"
+version = "0.2.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/85/9f/01a1a99704853cb63f253eea009390c88e7131c67e66a0a02099a8c917cb/pywin32-ctypes-0.2.3.tar.gz", hash = "sha256:d162dc04946d704503b2edc4d55f3dba5c1d539ead017afa00142c38b9885755", size = 29471, upload-time = "2024-08-14T10:15:34.626Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/de/3d/8161f7711c017e01ac9f008dfddd9410dff3674334c233bde66e7ba65bbf/pywin32_ctypes-0.2.3-py3-none-any.whl", hash = "sha256:8a1513379d709975552d202d942d9837758905c8d01eb82b8bcc30918929e7b8", size = 30756, upload-time = "2024-08-14T10:15:33.187Z" },
+]
+
 [[package]]
 name = "ruamel-yaml"
 version = "0.18.15"
@@ -276,40 +516,49 @@ wheels = [
 
 [[package]]
 name = "ruff"
-version = "0.14.8"
+version = "0.14.13"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ed/d9/f7a0c4b3a2bf2556cd5d99b05372c29980249ef71e8e32669ba77428c82c/ruff-0.14.8.tar.gz", hash = "sha256:774ed0dd87d6ce925e3b8496feb3a00ac564bea52b9feb551ecd17e0a23d1eed", size = 5765385, upload-time = "2025-12-04T15:06:17.669Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/50/0a/1914efb7903174b381ee2ffeebb4253e729de57f114e63595114c8ca451f/ruff-0.14.13.tar.gz", hash = "sha256:83cd6c0763190784b99650a20fec7633c59f6ebe41c5cc9d45ee42749563ad47", size = 6059504, upload-time = "2026-01-15T20:15:16.918Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/48/b8/9537b52010134b1d2b72870cc3f92d5fb759394094741b09ceccae183fbe/ruff-0.14.8-py3-none-linux_armv6l.whl", hash = "sha256:ec071e9c82eca417f6111fd39f7043acb53cd3fde9b1f95bbed745962e345afb", size = 13441540, upload-time = "2025-12-04T15:06:14.896Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/ae/0deefbc65ca74b0ab1fd3917f94dc3b398233346a74b8bbb0a916a1a6bf6/ruff-0.14.13-py3-none-linux_armv6l.whl", hash = "sha256:76f62c62cd37c276cb03a275b198c7c15bd1d60c989f944db08a8c1c2dbec18b", size = 13062418, upload-time = "2026-01-15T20:14:50.779Z" },
-    { url = "https://files.pythonhosted.org/packages/24/00/99031684efb025829713682012b6dd37279b1f695ed1b01725f85fd94b38/ruff-0.14.8-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:8cdb162a7159f4ca36ce980a18c43d8f036966e7f73f866ac8f493b75e0c27e9", size = 13669384, upload-time = "2025-12-04T15:06:51.809Z" },
+    { url = "https://files.pythonhosted.org/packages/47/df/5916604faa530a97a3c154c62a81cb6b735c0cb05d1e26d5ad0f0c8ac48a/ruff-0.14.13-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:914a8023ece0528d5cc33f5a684f5f38199bbb566a04815c2c211d8f40b5d0ed", size = 13442344, upload-time = "2026-01-15T20:15:07.94Z" },
-    { url = "https://files.pythonhosted.org/packages/72/64/3eb5949169fc19c50c04f28ece2c189d3b6edd57e5b533649dae6ca484fe/ruff-0.14.8-py3-none-macosx_11_0_arm64.whl", hash = "sha256:2e2fcbefe91f9fad0916850edf0854530c15bd1926b6b779de47e9ab619ea38f", size = 12806917, upload-time = "2025-12-04T15:06:08.925Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/f3/e0e694dd69163c3a1671e102aa574a50357536f18a33375050334d5cd517/ruff-0.14.13-py3-none-macosx_11_0_arm64.whl", hash = "sha256:d24899478c35ebfa730597a4a775d430ad0d5631b8647a3ab368c29b7e7bd063", size = 12354720, upload-time = "2026-01-15T20:15:09.854Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/08/5250babb0b1b11910f470370ec0cbc67470231f7cdc033cee57d4976f941/ruff-0.14.8-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9d70721066a296f45786ec31916dc287b44040f553da21564de0ab4d45a869b", size = 13256112, upload-time = "2025-12-04T15:06:23.498Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/e8/67f5fcbbaee25e8fc3b56cc33e9892eca7ffe09f773c8e5907757a7e3bdb/ruff-0.14.13-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9aaf3870f14d925bbaf18b8a2347ee0ae7d95a2e490e4d4aea6813ed15ebc80e", size = 12774493, upload-time = "2026-01-15T20:15:20.908Z" },
-    { url = "https://files.pythonhosted.org/packages/78/4c/6c588e97a8e8c2d4b522c31a579e1df2b4d003eddfbe23d1f262b1a431ff/ruff-0.14.8-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2c87e09b3cd9d126fc67a9ecd3b5b1d3ded2b9c7fce3f16e315346b9d05cfb52", size = 13227559, upload-time = "2025-12-04T15:06:33.432Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/ce/d2e9cb510870b52a9565d885c0d7668cc050e30fa2c8ac3fb1fda15c083d/ruff-0.14.13-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ac5b7f63dd3b27cc811850f5ffd8fff845b00ad70e60b043aabf8d6ecc304e09", size = 12815174, upload-time = "2026-01-15T20:15:05.74Z" },
-    { url = "https://files.pythonhosted.org/packages/23/ce/5f78cea13eda8eceac71b5f6fa6e9223df9b87bb2c1891c166d1f0dce9f1/ruff-0.14.8-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1d62cb310c4fbcb9ee4ac023fe17f984ae1e12b8a4a02e3d21489f9a2a5f730c", size = 13896379, upload-time = "2025-12-04T15:06:02.687Z" },
+    { url = "https://files.pythonhosted.org/packages/88/00/c38e5da58beebcf4fa32d0ddd993b63dfacefd02ab7922614231330845bf/ruff-0.14.13-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:78d2b1097750d90ba82ce4ba676e85230a0ed694178ca5e61aa9b459970b3eb9", size = 13680909, upload-time = "2026-01-15T20:15:14.537Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/79/13de4517c4dadce9218a20035b21212a4c180e009507731f0d3b3f5df85a/ruff-0.14.8-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:1af35c2d62633d4da0521178e8a2641c636d2a7153da0bac1b30cfd4ccd91344", size = 15372786, upload-time = "2025-12-04T15:06:29.828Z" },
+    { url = "https://files.pythonhosted.org/packages/61/61/cd37c9dd5bd0a3099ba79b2a5899ad417d8f3b04038810b0501a80814fd7/ruff-0.14.13-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:7d0bf87705acbbcb8d4c24b2d77fbb73d40210a95c3903b443cd9e30824a5032", size = 15144215, upload-time = "2026-01-15T20:15:22.886Z" },
-    { url = "https://files.pythonhosted.org/packages/00/06/33df72b3bb42be8a1c3815fd4fae83fa2945fc725a25d87ba3e42d1cc108/ruff-0.14.8-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:25add4575ffecc53d60eed3f24b1e934493631b48ebbc6ebaf9d8517924aca4b", size = 14990029, upload-time = "2025-12-04T15:06:36.812Z" },
+    { url = "https://files.pythonhosted.org/packages/56/8a/85502d7edbf98c2df7b8876f316c0157359165e16cdf98507c65c8d07d3d/ruff-0.14.13-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a3eb5da8e2c9e9f13431032fdcbe7681de9ceda5835efee3269417c13f1fed5c", size = 14706067, upload-time = "2026-01-15T20:14:48.271Z" },
-    { url = "https://files.pythonhosted.org/packages/64/61/0f34927bd90925880394de0e081ce1afab66d7b3525336f5771dcf0cb46c/ruff-0.14.8-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4c943d847b7f02f7db4201a0600ea7d244d8a404fbb639b439e987edcf2baf9a", size = 14407037, upload-time = "2025-12-04T15:06:39.979Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/2f/de0df127feb2ee8c1e54354dc1179b4a23798f0866019528c938ba439aca/ruff-0.14.13-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:642442b42957093811cd8d2140dfadd19c7417030a7a68cf8d51fcdd5f217427", size = 14133916, upload-time = "2026-01-15T20:14:57.357Z" },
-    { url = "https://files.pythonhosted.org/packages/96/bc/058fe0aefc0fbf0d19614cb6d1a3e2c048f7dc77ca64957f33b12cfdc5ef/ruff-0.14.8-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cb6e8bf7b4f627548daa1b69283dac5a296bfe9ce856703b03130732e20ddfe2", size = 14102390, upload-time = "2025-12-04T15:06:46.372Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/77/9b99686bb9fe07a757c82f6f95e555c7a47801a9305576a9c67e0a31d280/ruff-0.14.13-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4acdf009f32b46f6e8864af19cbf6841eaaed8638e65c8dac845aea0d703c841", size = 13859207, upload-time = "2026-01-15T20:14:55.111Z" },
-    { url = "https://files.pythonhosted.org/packages/af/a4/e4f77b02b804546f4c17e8b37a524c27012dd6ff05855d2243b49a7d3cb9/ruff-0.14.8-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:7aaf2974f378e6b01d1e257c6948207aec6a9b5ba53fab23d0182efb887a0e4a", size = 14230793, upload-time = "2025-12-04T15:06:20.497Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/46/2bdcb34a87a179a4d23022d818c1c236cb40e477faf0d7c9afb6813e5876/ruff-0.14.13-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:591a7f68860ea4e003917d19b5c4f5ac39ff558f162dc753a2c5de897fd5502c", size = 14043686, upload-time = "2026-01-15T20:14:52.841Z" },
-    { url = "https://files.pythonhosted.org/packages/3f/52/bb8c02373f79552e8d087cedaffad76b8892033d2876c2498a2582f09dcf/ruff-0.14.8-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:e5758ca513c43ad8a4ef13f0f081f80f08008f410790f3611a21a92421ab045b", size = 13160039, upload-time = "2025-12-04T15:06:49.06Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/a9/5c6a4f56a0512c691cf143371bcf60505ed0f0860f24a85da8bd123b2bf1/ruff-0.14.13-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:774c77e841cc6e046fc3e91623ce0903d1cd07e3a36b1a9fe79b81dab3de506b", size = 12663837, upload-time = "2026-01-15T20:15:18.921Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/ad/b69d6962e477842e25c0b11622548df746290cc6d76f9e0f4ed7456c2c31/ruff-0.14.8-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:f74f7ba163b6e85a8d81a590363bf71618847e5078d90827749bfda1d88c9cdf", size = 13205158, upload-time = "2025-12-04T15:06:54.574Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/bb/b920016ece7651fa7fcd335d9d199306665486694d4361547ccb19394c44/ruff-0.14.13-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:61f4e40077a1248436772bb6512db5fc4457fe4c49e7a94ea7c5088655dd21ae", size = 12805867, upload-time = "2026-01-15T20:14:59.272Z" },
-    { url = "https://files.pythonhosted.org/packages/06/63/54f23da1315c0b3dfc1bc03fbc34e10378918a20c0b0f086418734e57e74/ruff-0.14.8-py3-none-musllinux_1_2_i686.whl", hash = "sha256:eed28f6fafcc9591994c42254f5a5c5ca40e69a30721d2ab18bb0bb3baac3ab6", size = 13469550, upload-time = "2025-12-04T15:05:59.209Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/b3/0bd909851e5696cd21e32a8fc25727e5f58f1934b3596975503e6e85415c/ruff-0.14.13-py3-none-musllinux_1_2_i686.whl", hash = "sha256:6d02f1428357fae9e98ac7aa94b7e966fd24151088510d32cf6f902d6c09235e", size = 13208528, upload-time = "2026-01-15T20:15:03.732Z" },
-    { url = "https://files.pythonhosted.org/packages/70/7d/a4d7b1961e4903bc37fffb7ddcfaa7beb250f67d97cfd1ee1d5cddb1ec90/ruff-0.14.8-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:21d48fa744c9d1cb8d71eb0a740c4dd02751a5de9db9a730a8ef75ca34cf138e", size = 14211332, upload-time = "2025-12-04T15:06:06.027Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/3b/e2d94cb613f6bbd5155a75cbe072813756363eba46a3f2177a1fcd0cd670/ruff-0.14.13-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:e399341472ce15237be0c0ae5fbceca4b04cd9bebab1a2b2c979e015455d8f0c", size = 13929242, upload-time = "2026-01-15T20:15:11.918Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/93/2a5063341fa17054e5c86582136e9895db773e3c2ffb770dde50a09f35f0/ruff-0.14.8-py3-none-win32.whl", hash = "sha256:15f04cb45c051159baebb0f0037f404f1dc2f15a927418f29730f411a79bc4e7", size = 13151890, upload-time = "2025-12-04T15:06:11.668Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/c5/abd840d4132fd51a12f594934af5eba1d5d27298a6f5b5d6c3be45301caf/ruff-0.14.13-py3-none-win32.whl", hash = "sha256:ef720f529aec113968b45dfdb838ac8934e519711da53a0456038a0efecbd680", size = 12919024, upload-time = "2026-01-15T20:14:43.647Z" },
-    { url = "https://files.pythonhosted.org/packages/02/1c/65c61a0859c0add13a3e1cbb6024b42de587456a43006ca2d4fd3d1618fe/ruff-0.14.8-py3-none-win_amd64.whl", hash = "sha256:9eeb0b24242b5bbff3011409a739929f497f3fb5fe3b5698aba5e77e8c833097", size = 14537826, upload-time = "2025-12-04T15:06:26.409Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/55/6384b0b8ce731b6e2ade2b5449bf07c0e4c31e8a2e68ea65b3bafadcecc5/ruff-0.14.13-py3-none-win_amd64.whl", hash = "sha256:6070bd026e409734b9257e03e3ef18c6e1a216f0435c6751d7a8ec69cb59abef", size = 14097887, upload-time = "2026-01-15T20:15:01.48Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/63/8b41cea3afd7f58eb64ac9251668ee0073789a3bc9ac6f816c8c6fef986d/ruff-0.14.8-py3-none-win_arm64.whl", hash = "sha256:965a582c93c63fe715fd3e3f8aa37c4b776777203d8e1d8aa3cc0c14424a4b99", size = 13634522, upload-time = "2025-12-04T15:06:43.212Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/e1/7348090988095e4e39560cfc2f7555b1b2a7357deba19167b600fdf5215d/ruff-0.14.13-py3-none-win_arm64.whl", hash = "sha256:7ab819e14f1ad9fe39f246cfcc435880ef7a9390d81a2b6ac7e01039083dd247", size = 13080224, upload-time = "2026-01-15T20:14:45.853Z" },
+]
+
+[[package]]
+name = "setuptools"
+version = "80.9.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/18/5d/3bf57dcd21979b887f014ea83c24ae194cfcd12b9e0fda66b957c69d1fca/setuptools-80.9.0.tar.gz", hash = "sha256:f36b47402ecde768dbfafc46e8e4207b4360c654f1f3bb84475f0a28628fb19c", size = 1319958, upload-time = "2025-05-27T00:56:51.443Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a3/dc/17031897dae0efacfea57dfd3a82fdd2a2aeb58e0ff71b77b87e44edc772/setuptools-80.9.0-py3-none-any.whl", hash = "sha256:062d34222ad13e0cc312a4c02d73f059e86a4acbfbdea8f8f76b28c99f306922", size = 1201486, upload-time = "2025-05-27T00:56:49.664Z" },
 ]
 
 [[package]]
 name = "shiboken6"
-version = "6.9.2"
+version = "6.10.1"
 source = { registry = "https://pypi.org/simple" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1a/1e/62a8757aa0aa8d5dbf876f6cb6f652a60be9852e7911b59269dd983a7fb5/shiboken6-6.9.2-cp39-abi3-macosx_12_0_universal2.whl", hash = "sha256:8bb1c4326330e53adeac98bfd9dcf57f5173a50318a180938dcc4825d9ca38da", size = 406337, upload-time = "2025-08-26T07:52:39.614Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/8b/e5db743d505ceea3efc4cd9634a3bee22a3e2bf6e07cefd28c9b9edabcc6/shiboken6-6.10.1-cp39-abi3-macosx_13_0_universal2.whl", hash = "sha256:9f2990f5b61b0b68ecadcd896ab4441f2cb097eef7797ecc40584107d9850d71", size = 478483, upload-time = "2025-11-20T10:08:52.411Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/bb/72a8ed0f0542d9ea935f385b396ee6a4bbd94749c817cbf2be34e80a16d3/shiboken6-6.9.2-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3b54c0a12ea1b03b9dc5dcfb603c366e957dc75341bf7cb1cc436d0d848308ee", size = 206733, upload-time = "2025-08-26T07:52:41.768Z" },
+    { url = "https://files.pythonhosted.org/packages/56/ba/b50c1a44b3c4643f482afbf1a0ea58f393827307100389ce29404f9ad3b0/shiboken6-6.10.1-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:f4221a52dfb81f24a0d20cc4f8981cb6edd810d5a9fb28287ce10d342573a0e4", size = 271993, upload-time = "2025-11-20T10:08:54.093Z" },
-    { url = "https://files.pythonhosted.org/packages/52/c4/09e902f5612a509cef2c8712c516e4fe44f3a1ae9fcd8921baddb5e6bae4/shiboken6-6.9.2-cp39-abi3-manylinux_2_39_aarch64.whl", hash = "sha256:a5f5985938f5acb604c23536a0ff2efb3cccb77d23da91fbaff8fd8ded3dceb4", size = 202784, upload-time = "2025-08-26T07:52:43.172Z" },
+    { url = "https://files.pythonhosted.org/packages/16/b8/939c24ebd662b0aa5c945443d0973145b3fb7079f0196274ef7bb4b98f73/shiboken6-6.10.1-cp39-abi3-manylinux_2_39_aarch64.whl", hash = "sha256:c095b00f4d6bf578c0b2464bb4e264b351a99345374478570f69e2e679a2a1d0", size = 268691, upload-time = "2025-11-20T10:08:55.639Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/ea/a56b094a4bf6facf89f52f58e83684e168b1be08c14feb8b99969f3d4189/shiboken6-6.9.2-cp39-abi3-win_amd64.whl", hash = "sha256:68c33d565cd4732be762d19ff67dfc53763256bac413d392aa8598b524980bc4", size = 1152089, upload-time = "2025-08-26T07:52:45.162Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/a6/8c65ee0fa5e172ebcca03246b1bc3bd96cdaf1d60537316648536b7072a5/shiboken6-6.10.1-cp39-abi3-win_amd64.whl", hash = "sha256:c1601d3cda1fa32779b141663873741b54e797cb0328458d7466281f117b0a4e", size = 1234704, upload-time = "2025-11-20T10:08:57.417Z" },
-    { url = "https://files.pythonhosted.org/packages/48/64/562a527fc55fbf41fa70dae735929988215505cb5ec0809fb0aef921d4a0/shiboken6-6.9.2-cp39-abi3-win_arm64.whl", hash = "sha256:c5b827797b3d89d9b9a3753371ff533fcd4afc4531ca51a7c696952132098054", size = 1708948, upload-time = "2025-08-26T07:52:48.016Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/6a/c0fea2f2ac7d9d96618c98156500683a4d1f93fea0e8c5a2bc39913d7ef1/shiboken6-6.10.1-cp39-abi3-win_arm64.whl", hash = "sha256:5cf800917008587b551005a45add2d485cca66f5f7ecd5b320e9954e40448cc9", size = 1795567, upload-time = "2025-11-20T10:08:59.184Z" },
 ]
 
 [[package]]

web/datenschutz.html

@@ -0,0 +1,951 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Datenschutz — DocuMentor</title>
+    <link rel="stylesheet" href="fonts/fonts.css">
+    <style>
+        /* ============================================================
+           RESET & BASE
+           ============================================================ */
+        *, *::before, *::after {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        :root {
+            --concrete-dark: #1a1a1a;
+            --concrete-mid: #2a2a2a;
+            --concrete-light: #3a3a3a;
+            --concrete-surface: #444444;
+            --warning-yellow: #f0c030;
+            --warning-yellow-dim: #e8b800;
+            --safety-orange: #e05020;
+            --steel-text: #b0b0b0;
+            --steel-bright: #d0d0d0;
+            --white: #f0efe8;
+            --grid-line: rgba(240, 192, 48, 0.07);
+            --grid-dot: rgba(240, 192, 48, 0.12);
+            --led-green: #30e060;
+        }
+
+        html {
+            scroll-behavior: smooth;
+            font-size: 16px;
+        }
+
+        body {
+            font-family: 'Barlow', sans-serif;
+            background-color: var(--concrete-dark);
+            color: var(--steel-text);
+            line-height: 1.6;
+            overflow-x: hidden;
+            background-image:
+                repeating-linear-gradient(
+                    0deg,
+                    transparent,
+                    transparent 2px,
+                    rgba(255,255,255,0.008) 2px,
+                    rgba(255,255,255,0.008) 4px
+                ),
+                repeating-linear-gradient(
+                    90deg,
+                    transparent,
+                    transparent 2px,
+                    rgba(255,255,255,0.005) 2px,
+                    rgba(255,255,255,0.005) 4px
+                );
+        }
+
+        body::before {
+            content: '';
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            pointer-events: none;
+            z-index: 0;
+            background-image:
+                radial-gradient(circle, var(--grid-dot) 1px, transparent 1px);
+            background-size: 40px 40px;
+            opacity: 0.5;
+        }
+
+        /* ============================================================
+           UTILITY
+           ============================================================ */
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 0 2rem;
+            position: relative;
+            z-index: 1;
+        }
+
+        section {
+            position: relative;
+            z-index: 1;
+        }
+
+        /* ============================================================
+           STENCIL SECTION LABELS
+           ============================================================ */
+        .section-label {
+            font-family: 'Oswald', sans-serif;
+            font-weight: 700;
+            font-size: 0.75rem;
+            letter-spacing: 0.3em;
+            text-transform: uppercase;
+            color: var(--warning-yellow-dim);
+            display: flex;
+            align-items: center;
+            gap: 1rem;
+            margin-bottom: 0.75rem;
+        }
+
+        .section-label::before {
+            content: attr(data-num);
+            font-family: 'Share Tech Mono', monospace;
+            font-size: 0.65rem;
+            color: var(--concrete-surface);
+            border: 1px dashed var(--concrete-surface);
+            padding: 0.15rem 0.4rem;
+            letter-spacing: 0.1em;
+        }
+
+        .section-title {
+            font-family: 'Oswald', sans-serif;
+            font-weight: 700;
+            font-size: 2.5rem;
+            color: var(--white);
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+            line-height: 1.1;
+            margin-bottom: 1rem;
+        }
+
+        /* ============================================================
+           HAZARD STRIPE
+           ============================================================ */
+        .hazard-stripe {
+            height: 6px;
+            background: repeating-linear-gradient(
+                -45deg,
+                var(--warning-yellow),
+                var(--warning-yellow) 8px,
+                var(--concrete-dark) 8px,
+                var(--concrete-dark) 16px
+            );
+            width: 100%;
+        }
+
+        .hazard-stripe-thin {
+            height: 3px;
+            background: repeating-linear-gradient(
+                -45deg,
+                var(--warning-yellow-dim),
+                var(--warning-yellow-dim) 5px,
+                var(--concrete-mid) 5px,
+                var(--concrete-mid) 10px
+            );
+            opacity: 0.5;
+        }
+
+        /* ============================================================
+           CORNER BRACKETS
+           ============================================================ */
+        .corner-brackets {
+            position: relative;
+        }
+
+        .corner-brackets::before,
+        .corner-brackets::after {
+            content: '';
+            position: absolute;
+            width: 16px;
+            height: 16px;
+            pointer-events: none;
+        }
+
+        .corner-brackets::before {
+            top: -1px;
+            left: -1px;
+            border-top: 2px solid var(--warning-yellow-dim);
+            border-left: 2px solid var(--warning-yellow-dim);
+        }
+
+        .corner-brackets::after {
+            bottom: -1px;
+            right: -1px;
+            border-bottom: 2px solid var(--warning-yellow-dim);
+            border-right: 2px solid var(--warning-yellow-dim);
+        }
+
+        /* ============================================================
+           RIVET DECORATIONS
+           ============================================================ */
+        .riveted {
+            position: relative;
+        }
+
+        .riveted .rivet {
+            position: absolute;
+            width: 8px;
+            height: 8px;
+            border-radius: 50%;
+            background: radial-gradient(circle at 35% 35%, #555, #2a2a2a 60%, #1a1a1a);
+            box-shadow: inset 0 1px 1px rgba(255,255,255,0.15), 0 1px 2px rgba(0,0,0,0.5);
+        }
+
+        .riveted .rivet-tl { top: 10px; left: 10px; }
+        .riveted .rivet-tr { top: 10px; right: 10px; }
+        .riveted .rivet-bl { bottom: 10px; left: 10px; }
+        .riveted .rivet-br { bottom: 10px; right: 10px; }
+
+        /* ============================================================
+           LED INDICATOR
+           ============================================================ */
+        .led {
+            display: inline-block;
+            width: 8px;
+            height: 8px;
+            border-radius: 50%;
+            margin-right: 6px;
+            vertical-align: middle;
+            box-shadow: 0 0 4px currentColor;
+        }
+
+        .led-green {
+            background-color: var(--led-green);
+            color: var(--led-green);
+        }
+
+        /* ============================================================
+           SCROLL REVEAL
+           ============================================================ */
+        .reveal {
+            opacity: 0;
+            transform: translateY(30px);
+            transition: opacity 0.6s linear, transform 0.6s linear;
+        }
+
+        .reveal.visible {
+            opacity: 1;
+            transform: translate(0, 0);
+        }
+
+        /* ============================================================
+           NAVBAR
+           ============================================================ */
+        .navbar {
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            z-index: 1000;
+            background: rgba(26, 26, 26, 0.92);
+            backdrop-filter: blur(10px);
+            border-bottom: 1px solid rgba(240, 192, 48, 0.12);
+        }
+
+        .navbar-inner {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            padding: 0 2rem;
+            height: 56px;
+            max-width: 1200px;
+            margin: 0 auto;
+        }
+
+        .navbar-brand {
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+            text-decoration: none;
+        }
+
+        .navbar-brand-icon {
+            width: 28px;
+            height: 28px;
+            border: 2px solid var(--warning-yellow);
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-family: 'Oswald', sans-serif;
+            font-weight: 700;
+            font-size: 0.85rem;
+            color: var(--warning-yellow);
+        }
+
+        .navbar-brand-text {
+            font-family: 'Oswald', sans-serif;
+            font-weight: 600;
+            font-size: 1.1rem;
+            color: var(--white);
+            letter-spacing: 0.1em;
+            text-transform: uppercase;
+        }
+
+        .navbar-links {
+            display: flex;
+            gap: 2rem;
+            list-style: none;
+        }
+
+        .navbar-links a {
+            font-family: 'Share Tech Mono', monospace;
+            font-size: 0.75rem;
+            color: var(--steel-text);
+            text-decoration: none;
+            text-transform: uppercase;
+            letter-spacing: 0.15em;
+            padding: 0.25rem 0;
+            border-bottom: 1px solid transparent;
+            transition: color 0.2s linear, border-color 0.2s linear;
+        }
+
+        .navbar-links a:hover,
+        .navbar-links a.active {
+            color: var(--warning-yellow);
+            border-bottom-color: var(--warning-yellow);
+        }
+
+        .navbar-mobile-toggle {
+            display: none;
+            background: none;
+            border: 1px solid var(--concrete-surface);
+            color: var(--steel-text);
+            padding: 0.4rem 0.6rem;
+            font-family: 'Share Tech Mono', monospace;
+            font-size: 0.75rem;
+            cursor: pointer;
+            text-transform: uppercase;
+            letter-spacing: 0.1em;
+        }
+
+        /* ============================================================
+           PAGE HEADER
+           ============================================================ */
+        .page-header {
+            padding-top: 56px;
+            background: linear-gradient(135deg, var(--concrete-dark) 0%, var(--concrete-mid) 50%, var(--concrete-dark) 100%);
+            position: relative;
+            overflow: hidden;
+        }
+
+        .page-header::before {
+            content: '';
+            position: absolute;
+            inset: 0;
+            background-image:
+                linear-gradient(var(--grid-line) 1px, transparent 1px),
+                linear-gradient(90deg, var(--grid-line) 1px, transparent 1px);
+            background-size: 80px 80px;
+            opacity: 0.8;
+        }
+
+        .page-header-inner {
+            padding: 3rem 0 2.5rem;
+            position: relative;
+            z-index: 2;
+        }
+
+        .page-header-tag {
+            font-family: 'Share Tech Mono', monospace;
+            font-size: 0.7rem;
+            color: var(--concrete-surface);
+            letter-spacing: 0.2em;
+            margin-bottom: 1rem;
+            display: flex;
+            align-items: center;
+            gap: 0.75rem;
+        }
+
+        .page-header-title {
+            font-family: 'Oswald', sans-serif;
+            font-weight: 700;
+            font-size: 3rem;
+            color: var(--white);
+            text-transform: uppercase;
+            letter-spacing: 0.08em;
+            line-height: 1;
+        }
+
+        .page-header-title span {
+            color: var(--warning-yellow);
+        }
+
+        .page-header-sub {
+            font-family: 'Barlow Condensed', sans-serif;
+            font-weight: 400;
+            font-size: 1.1rem;
+            color: var(--steel-text);
+            margin-top: 0.5rem;
+            letter-spacing: 0.04em;
+        }
+
+        /* ============================================================
+           LEGAL CONTENT
+           ============================================================ */
+        .legal-section {
+            padding: 5rem 0;
+            background: var(--concrete-dark);
+        }
+
+        .legal-panel {
+            background: var(--concrete-mid);
+            border: 1px solid rgba(240, 192, 48, 0.12);
+            padding: 3rem;
+            max-width: 860px;
+            margin: 0 auto;
+            position: relative;
+        }
+
+        .legal-block {
+            margin-bottom: 2.5rem;
+        }
+
+        .legal-block:last-child {
+            margin-bottom: 0;
+        }
+
+        .legal-block-label {
+            font-family: 'Share Tech Mono', monospace;
+            font-size: 0.65rem;
+            color: var(--concrete-surface);
+            text-transform: uppercase;
+            letter-spacing: 0.2em;
+            margin-bottom: 0.5rem;
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+        }
+
+        .legal-block-label::before {
+            content: '';
+            display: inline-block;
+            width: 20px;
+            height: 1px;
+            background: var(--concrete-surface);
+        }
+
+        .legal-block h2 {
+            font-family: 'Barlow Condensed', sans-serif;
+            font-weight: 600;
+            font-size: 1.3rem;
+            color: var(--steel-bright);
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+            margin-bottom: 0.75rem;
+        }
+
+        .legal-block p {
+            font-family: 'Barlow', sans-serif;
+            font-weight: 300;
+            font-size: 0.95rem;
+            color: var(--steel-text);
+            line-height: 1.7;
+            margin-bottom: 0.5rem;
+        }
+
+        .legal-block p:last-child {
+            margin-bottom: 0;
+        }
+
+        .legal-block a {
+            color: var(--warning-yellow-dim);
+            text-decoration: none;
+            border-bottom: 1px solid transparent;
+            transition: border-color 0.2s linear;
+        }
+
+        .legal-block a:hover {
+            border-bottom-color: var(--warning-yellow-dim);
+        }
+
+        .legal-block ul {
+            margin: 0.5rem 0 0.5rem 1.5rem;
+            font-family: 'Barlow', sans-serif;
+            font-weight: 300;
+            font-size: 0.95rem;
+            color: var(--steel-text);
+            line-height: 1.7;
+        }
+
+        .legal-block ul li {
+            margin-bottom: 0.25rem;
+        }
+
+        .legal-divider {
+            height: 1px;
+            background: linear-gradient(90deg,
+                transparent 0%,
+                rgba(240, 192, 48, 0.15) 20%,
+                rgba(240, 192, 48, 0.15) 80%,
+                transparent 100%
+            );
+            margin: 2.5rem 0;
+        }
+
+        .legal-address {
+            font-family: 'Share Tech Mono', monospace;
+            font-size: 0.85rem;
+            color: var(--steel-text);
+            line-height: 2;
+            padding: 1rem 1.25rem;
+            background: rgba(26, 26, 26, 0.6);
+            border: 1px dashed rgba(240, 192, 48, 0.1);
+            display: inline-block;
+        }
+
+        .legal-address strong {
+            color: var(--steel-bright);
+            font-weight: 400;
+        }
+
+        .legal-note {
+            margin-top: 1.5rem;
+            padding: 1rem 1.25rem;
+            border-left: 3px solid var(--safety-orange);
+            background: rgba(224, 80, 32, 0.05);
+            font-family: 'Share Tech Mono', monospace;
+            font-size: 0.75rem;
+            color: var(--steel-text);
+            line-height: 1.6;
+        }
+
+        .legal-note strong {
+            color: var(--safety-orange);
+            font-weight: 400;
+        }
+
+        /* ============================================================
+           FOOTER
+           ============================================================ */
+        .footer {
+            padding: 3rem 0 2rem;
+            background: var(--concrete-dark);
+            border-top: 1px solid rgba(240, 192, 48, 0.08);
+            position: relative;
+            z-index: 1;
+        }
+
+        .footer-inner {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            flex-wrap: wrap;
+            gap: 1rem;
+        }
+
+        .footer-brand {
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+        }
+
+        .footer-brand-icon {
+            width: 22px;
+            height: 22px;
+            border: 1.5px solid var(--warning-yellow-dim);
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-family: 'Oswald', sans-serif;
+            font-weight: 700;
+            font-size: 0.7rem;
+            color: var(--warning-yellow-dim);
+        }
+
+        .footer-brand-text {
+            font-family: 'Oswald', sans-serif;
+            font-weight: 500;
+            font-size: 0.85rem;
+            color: var(--steel-text);
+            letter-spacing: 0.1em;
+            text-transform: uppercase;
+        }
+
+        .footer-meta {
+            font-family: 'Share Tech Mono', monospace;
+            font-size: 0.65rem;
+            color: var(--concrete-surface);
+            letter-spacing: 0.1em;
+            text-align: right;
+        }
+
+        .footer-links {
+            display: flex;
+            gap: 1.5rem;
+            list-style: none;
+        }
+
+        .footer-links a {
+            font-family: 'Share Tech Mono', monospace;
+            font-size: 0.7rem;
+            color: var(--steel-text);
+            text-decoration: none;
+            letter-spacing: 0.1em;
+            transition: color 0.2s linear;
+        }
+
+        .footer-links a:hover,
+        .footer-links a.active {
+            color: var(--warning-yellow);
+        }
+
+        /* ============================================================
+           RESPONSIVE
+           ============================================================ */
+        @media (max-width: 768px) {
+            .navbar-links {
+                display: none;
+                position: absolute;
+                top: 56px;
+                left: 0;
+                width: 100%;
+                background: rgba(26, 26, 26, 0.97);
+                flex-direction: column;
+                padding: 1rem 2rem;
+                gap: 0.75rem;
+                border-bottom: 1px solid rgba(240, 192, 48, 0.12);
+            }
+
+            .navbar-links.open {
+                display: flex;
+            }
+
+            .navbar-mobile-toggle {
+                display: block;
+            }
+
+            .page-header-title {
+                font-size: 2.2rem;
+            }
+
+            .legal-panel {
+                padding: 2rem 1.5rem;
+            }
+
+            .footer-inner {
+                flex-direction: column;
+                text-align: center;
+            }
+
+            .footer-links {
+                flex-wrap: wrap;
+                justify-content: center;
+            }
+
+            .footer-meta {
+                text-align: center;
+            }
+        }
+
+        @media (max-width: 480px) {
+            .container {
+                padding: 0 1rem;
+            }
+
+            .page-header-title {
+                font-size: 1.8rem;
+            }
+
+            .legal-panel {
+                padding: 1.5rem 1rem;
+            }
+
+            .navbar-inner {
+                padding: 0 1rem;
+            }
+        }
+    </style>
+</head>
+<body>
+
+    <!-- ============================================================
+         NAVBAR
+         ============================================================ -->
+    <nav class="navbar">
+        <div class="navbar-inner">
+            <a href="index.html" class="navbar-brand">
+                <div class="navbar-brand-icon">D</div>
+                <span class="navbar-brand-text">DocuMentor</span>
+            </a>
+            <button class="navbar-mobile-toggle" id="navToggle">MENU</button>
+            <ul class="navbar-links" id="navLinks">
+                <li><a href="index.html#features">Features</a></li>
+                <li><a href="index.html#workflow">Workflow</a></li>
+                <li><a href="index.html#techstack">Technik</a></li>
+                <li><a href="index.html#download">Download</a></li>
+                <li><a href="datenschutz.html" class="active">Datenschutz</a></li>
+            </ul>
+        </div>
+    </nav>
+
+    <!-- ============================================================
+         PAGE HEADER
+         ============================================================ -->
+    <div class="page-header">
+        <div class="hazard-stripe"></div>
+        <div class="container">
+            <div class="page-header-inner">
+                <div class="page-header-tag">
+                    <span class="led led-green"></span>
+                    SYSTEM AKTIV &mdash; DATENSCHUTZINFORMATIONEN
+                </div>
+                <h1 class="page-header-title">Daten<span>schutz</span></h1>
+                <p class="page-header-sub">Datenschutzerklärung gemäß DSGVO / BDSG</p>
+            </div>
+        </div>
+        <div class="hazard-stripe-thin"></div>
+    </div>
+
+    <!-- ============================================================
+         LEGAL CONTENT
+         ============================================================ -->
+    <section class="legal-section">
+        <div class="container">
+            <div class="section-label reveal" data-num="DSE-01">Datenschutzerklärung</div>
+            <h2 class="section-title reveal" style="margin-bottom: 2rem;">Datenschutz</h2>
+
+            <div class="legal-panel corner-brackets riveted reveal">
+                <span class="rivet rivet-tl"></span>
+                <span class="rivet rivet-tr"></span>
+                <span class="rivet rivet-bl"></span>
+                <span class="rivet rivet-br"></span>
+
+                <!-- 1. Verantwortlicher -->
+                <div class="legal-block">
+                    <div class="legal-block-label">§ 1 — VERANTWORTLICHER</div>
+                    <h2>Verantwortlicher</h2>
+                    <p>Verantwortlicher im Sinne der Datenschutz-Grundverordnung (DSGVO) und des Bundesdatenschutzgesetzes (BDSG) ist:</p>
+                    <div class="legal-address" style="margin-top: 0.75rem;">
+                        <strong>Vitali Graf</strong><br>
+                        Kulenkampffallee 65b<br>
+                        28213 Bremen<br>
+                        Deutschland
+                        E-Mail: <a href="mailto:info@vitaligraf.de">info@vitaligraf.de</a>
+                    </div>
+                    <!-- <div class="legal-note" style="margin-top: 1rem;">
+                        <strong>HINWEIS:</strong> Bitte Adresse vor Veröffentlichung ergänzen.
+                    </div> -->
+                </div>
+
+                <div class="legal-divider"></div>
+
+                <!-- 2. Allgemeines -->
+                <div class="legal-block">
+                    <div class="legal-block-label">§ 2 — GRUNDSATZ</div>
+                    <h2>Allgemeines zur Datenverarbeitung</h2>
+                    <p>
+                        Diese Website ist eine statische Informationsseite über das Open-Source-Projekt
+                        DocuMentor. Es werden <strong style="color: var(--steel-bright); font-weight: 400;">keine Cookies</strong>,
+                        <strong style="color: var(--steel-bright); font-weight: 400;">keine Tracking-Skripte</strong> und
+                        <strong style="color: var(--steel-bright); font-weight: 400;">keine Webanalyse-Dienste</strong> verwendet.
+                    </p>
+                    <p>
+                        Alle Schriftarten werden lokal ausgeliefert. Es werden keine externen
+                        Ressourcen von Drittanbietern geladen. Es findet keine Verarbeitung
+                        personenbezogener Daten durch diese Website statt.
+                    </p>
+                </div>
+
+                <div class="legal-divider"></div>
+
+                <!-- 3. Server-Log -->
+                <div class="legal-block">
+                    <div class="legal-block-label">§ 3 — SERVER-LOGDATEIEN</div>
+                    <h2>Server-Logdateien</h2>
+                    <p>
+                        Beim Abruf dieser Website werden durch den Hosting-Anbieter automatisch
+                        technische Zugriffsdaten in sogenannten Server-Logdateien erfasst.
+                        Diese Daten werden nicht aktiv durch uns erhoben und umfassen:
+                    </p>
+                    <ul>
+                        <li>Browsertyp und Browserversion</li>
+                        <li>Verwendetes Betriebssystem</li>
+                        <li>Referrer-URL (zuvor besuchte Seite)</li>
+                        <li>Hostname des zugreifenden Rechners</li>
+                        <li>Uhrzeit der Serveranfrage</li>
+                        <li>IP-Adresse</li>
+                    </ul>
+                    <p>
+                        Die Rechtsgrundlage für diese technisch notwendige Verarbeitung ist
+                        Art. 6 Abs. 1 lit. f DSGVO (berechtigtes Interesse am sicheren Betrieb
+                        der Website). Die Daten werden nicht mit anderen Datenquellen zusammengeführt
+                        und nach kurzer Zeit automatisch gelöscht.
+                    </p>
+                </div>
+
+                <div class="legal-divider"></div>
+
+                <!-- 4. Kontakt per E-Mail -->
+                <div class="legal-block">
+                    <div class="legal-block-label">§ 4 — KONTAKTAUFNAHME</div>
+                    <h2>Kontaktaufnahme per E-Mail</h2>
+                    <p>
+                        Wenn Sie uns per E-Mail kontaktieren, werden die übermittelten Daten
+                        (E-Mail-Adresse, Inhalt Ihrer Nachricht sowie ggf. weitere von Ihnen
+                        angegebene Daten) zur Bearbeitung Ihrer Anfrage und für den Fall von
+                        Anschlussfragen gespeichert.
+                    </p>
+                    <p>
+                        Die Verarbeitung dieser Daten erfolgt auf Grundlage von Art. 6 Abs. 1
+                        lit. b DSGVO, sofern Ihre Anfrage im Zusammenhang mit der Erfüllung
+                        eines Vertrages steht oder zur Durchführung vorvertraglicher Maßnahmen
+                        erforderlich ist. In allen übrigen Fällen beruht die Verarbeitung auf
+                        unserem berechtigten Interesse an der effektiven Bearbeitung der an uns
+                        gerichteten Anfragen (Art. 6 Abs. 1 lit. f DSGVO).
+                    </p>
+                    <p>
+                        Die Daten werden gelöscht, sobald Ihre Anfrage abschließend bearbeitet
+                        wurde und keine gesetzlichen Aufbewahrungspflichten entgegenstehen.
+                    </p>
+                </div>
+
+                <div class="legal-divider"></div>
+
+                <!-- 5. Desktop-Anwendung -->
+                <div class="legal-block">
+                    <div class="legal-block-label">§ 5 — DESKTOP-ANWENDUNG</div>
+                    <h2>DocuMentor Desktop-Anwendung</h2>
+                    <p>
+                        Die DocuMentor-Anwendung selbst läuft ausschließlich lokal auf Ihrem
+                        Rechner. Sie überträgt keine Daten an externe Server. Alle
+                        Konfigurationsdaten und Projektdateien werden ausschließlich lokal
+                        gespeichert:
+                    </p>
+                    <ul>
+                        <li>Linux: <code style="font-family: 'Share Tech Mono', monospace; font-size: 0.85em; color: var(--warning-yellow-dim);">~/.config/DocuMentor/config.json</code></li>
+                        <li>Windows: <code style="font-family: 'Share Tech Mono', monospace; font-size: 0.85em; color: var(--warning-yellow-dim);">%APPDATA%\DocuMentor\config.json</code></li>
+                        <li>macOS: <code style="font-family: 'Share Tech Mono', monospace; font-size: 0.85em; color: var(--warning-yellow-dim);">~/Library/Application Support/DocuMentor/config.json</code></li>
+                    </ul>
+                    <p>
+                        Datenbankverbindungen zu PostgreSQL werden nur auf ausdrückliche
+                        Konfiguration durch den Nutzer hergestellt und ausschließlich für den
+                        in der Anwendung angezeigten Zweck verwendet.
+                    </p>
+                </div>
+
+                <div class="legal-divider"></div>
+
+                <!-- 6. Betroffenenrechte -->
+                <div class="legal-block">
+                    <div class="legal-block-label">§ 6 — IHRE RECHTE</div>
+                    <h2>Ihre Rechte als betroffene Person</h2>
+                    <p>Sie haben gegenüber uns folgende Rechte hinsichtlich Ihrer personenbezogenen Daten:</p>
+                    <ul>
+                        <li><strong style="color: var(--steel-bright); font-weight: 400;">Auskunftsrecht</strong> (Art. 15 DSGVO)</li>
+                        <li><strong style="color: var(--steel-bright); font-weight: 400;">Recht auf Berichtigung</strong> (Art. 16 DSGVO)</li>
+                        <li><strong style="color: var(--steel-bright); font-weight: 400;">Recht auf Löschung</strong> (Art. 17 DSGVO)</li>
+                        <li><strong style="color: var(--steel-bright); font-weight: 400;">Recht auf Einschränkung der Verarbeitung</strong> (Art. 18 DSGVO)</li>
+                        <li><strong style="color: var(--steel-bright); font-weight: 400;">Recht auf Datenübertragbarkeit</strong> (Art. 20 DSGVO)</li>
+                        <li><strong style="color: var(--steel-bright); font-weight: 400;">Widerspruchsrecht</strong> (Art. 21 DSGVO)</li>
+                    </ul>
+                    <p>
+                        Zur Ausübung Ihrer Rechte wenden Sie sich bitte an:
+                        <a href="mailto:info@vitaligraf.de">info@vitaligraf.de</a>
+                    </p>
+                    <p>
+                        Sie haben zudem das Recht, sich bei einer Datenschutz-Aufsichtsbehörde
+                        über die Verarbeitung Ihrer personenbezogenen Daten zu beschweren.
+                    </p>
+                </div>
+
+                <div class="legal-divider"></div>
+
+                <!-- 7. Aktualität -->
+                <div class="legal-block">
+                    <div class="legal-block-label">§ 7 — AKTUALITÄT</div>
+                    <h2>Aktualität dieser Datenschutzerklärung</h2>
+                    <p>
+                        Diese Datenschutzerklärung ist aktuell gültig und hat den Stand April 2026.
+                        Durch die Weiterentwicklung dieser Website oder aufgrund geänderter
+                        gesetzlicher bzw. behördlicher Vorgaben kann es notwendig werden,
+                        diese Datenschutzerklärung zu ändern.
+                    </p>
+                    <p>
+                        Die jeweils aktuelle Datenschutzerklärung kann jederzeit auf dieser
+                        Seite abgerufen werden.
+                    </p>
+                </div>
+            </div>
+        </div>
+    </section>
+
+    <div class="hazard-stripe-thin"></div>
+
+    <!-- ============================================================
+         FOOTER
+         ============================================================ -->
+    <footer class="footer">
+        <div class="container">
+            <div class="footer-inner">
+                <div class="footer-brand">
+                    <div class="footer-brand-icon">D</div>
+                    <span class="footer-brand-text">DocuMentor</span>
+                </div>
+                <ul class="footer-links">
+                    <li><a href="index.html#features">Features</a></li>
+                    <li><a href="index.html#workflow">Workflow</a></li>
+                    <li><a href="index.html#techstack">Technik</a></li>
+                    <li><a href="index.html#download">Download</a></li>
+                    <li><a href="impressum.html">Impressum</a></li>
+                    <li><a href="datenschutz.html" class="active">Datenschutz</a></li>
+                </ul>
+                <div class="footer-meta">
+                    SYSTEM // DOCUMENTOR // BUILD 2026.02<br>
+                    PySide6 Desktop-Anwendung // Open Source
+                </div>
+            </div>
+        </div>
+    </footer>
+
+    <script>
+        (function() {
+            const toggle = document.getElementById('navToggle');
+            const links = document.getElementById('navLinks');
+            if (toggle && links) {
+                toggle.addEventListener('click', function() {
+                    links.classList.toggle('open');
+                    toggle.textContent = links.classList.contains('open') ? 'CLOSE' : 'MENU';
+                });
+            }
+        })();
+
+        (function() {
+            const reveals = document.querySelectorAll('.reveal');
+            const observer = new IntersectionObserver(function(entries) {
+                entries.forEach(function(entry) {
+                    if (entry.isIntersecting) {
+                        entry.target.classList.add('visible');
+                        observer.unobserve(entry.target);
+                    }
+                });
+            }, { threshold: 0.12, rootMargin: '0px 0px -40px 0px' });
+            reveals.forEach(function(el) { observer.observe(el); });
+        })();
+
+        (function() {
+            const navbar = document.querySelector('.navbar');
+            let ticking = false;
+            window.addEventListener('scroll', function() {
+                if (!ticking) {
+                    requestAnimationFrame(function() {
+                        navbar.style.borderBottomColor = window.scrollY > 80
+                            ? 'rgba(240, 192, 48, 0.25)'
+                            : 'rgba(240, 192, 48, 0.12)';
+                        ticking = false;
+                    });
+                    ticking = true;
+                }
+            });
+        })();
+    </script>
+</body>
+</html>