Release 26.5.1-unstable

Reviewed-on: #46

__init__.py

@@ -1,3 +1,19 @@
+"""
+sn_basis – QGIS-Plugin für Basis-Verwaltung und zentrale Koordination.
+Orchestriert die Navigation und initialisiert abhängige sn_-Plugins.
+"""
+
+
 def classFactory(iface):
+    """
+    Factory-Funktion für QGIS.
+    Wird von QGIS aufgerufen, um die Plugin-Instanz zu erstellen.
+    
+    Args:
+        iface: QGIS-Schnittstellenobjekt
+        
+    Returns:
+        BasisPlugin: Instanziiertes Plugin
+    """
     from .main import BasisPlugin
     return BasisPlugin(iface)

assets/Objektstruktur.txt

@@ -1,188 +0,0 @@
-# Wrapper‑Architektur – Übersicht
-Die Wrapper‑Architektur von sn_basis bildet das Fundament für eine robuste, testbare und zukunftssichere QGIS‑Plugin‑Entwicklung.
-Sie kapselt sämtliche QGIS‑ und Qt‑Abhängigkeiten hinter klar definierten Schnittstellen und ermöglicht dadurch:
-
-Mock‑fähige Unit‑Tests ohne QGIS
-
-PyQt5/6‑Kompatibilität ohne Code‑Änderungen
-
-saubere Trennung von UI, Logik und Infrastruktur
-
-stabile APIs, die unabhängig von QGIS‑Versionen bleiben
-
-klare Erweiterbarkeit für zukünftige Module und Plugins
-
-Die Wrapper‑Schicht ist das zentrale Bindeglied zwischen der Plugin‑Logik und der QGIS‑/Qt‑Umgebung.
-
-## Ziele der Wrapper‑Architektur
-🎯 1. Entkopplung von QGIS und Qt
-Alle direkten Importe wie from qgis.core import ... oder from qgis.PyQt.QtWidgets import ... verschwinden aus der Plugin‑Logik.
-Stattdessen werden sie über Wrapper‑Module abstrahiert.
-
-🎯 2. Testbarkeit ohne QGIS
-Im Mock‑Modus liefern die Wrapper:
-
-Dummy‑Objekte
-
-simulierte Rückgabewerte
-
-speicherbare Zustände (z. B. Variablen, Layer, Nachrichten)
-
-Damit laufen Tests in jeder CI‑Umgebung.
-
-🎯 3. Einheitliche API für alle Plugins
-Plugins greifen nicht mehr direkt auf QGIS zu, sondern nutzen:
-
-Code
-sn_basis.functions.qgiscore_wrapper
-sn_basis.functions.qgisui_wrapper
-sn_basis.functions.qt_wrapper
-sn_basis.functions.variable_wrapper
-sn_basis.functions.message_wrapper
-sn_basis.functions.dialog_wrapper
-🎯 4. Zukunftssicherheit
-Ändert sich die QGIS‑ oder Qt‑API, wird nur der Wrapper angepasst, nicht jedes Plugin.
-
-## Architekturüberblick
-Die Wrapper‑Schicht besteht aus mehreren Modulen, die jeweils einen klar abgegrenzten Verantwortungsbereich haben.
-
-### 1. qt_wrapper – Qt‑Abstraktion
-Kapselt alle Qt‑Widgets, Dialoge und Konstanten:
-
-QWidget, QDialog, QMessageBox, QToolBar, QMenu, …
-
-Layouts, Buttons, Labels, LineEdits
-
-Qt‑Konstanten wie YES, NO, Dock‑Areas
-
-Mock‑Modus:  
-Stellt Dummy‑Widgets bereit, die keine UI öffnen.
-
-### 2. qgiscore_wrapper – QGIS‑Core‑Abstraktion
-Abstraktion für:
-
-QgsProject
-
-Layer‑Zugriff
-
-Projekt‑Metadaten
-
-Pfade, CRS, Feature‑Zugriff
-
-Mock‑Modus:  
-Simuliert ein Projekt und Layer‑Container.
-
-### 3. qgisui_wrapper – QGIS‑UI‑Abstraktion
-Kapselt UI‑bezogene QGIS‑Funktionen:
-
-Zugriff auf iface
-
-Dock‑Management
-
-Menü‑ und Toolbar‑Integration
-
-Hauptfenster‑Zugriff
-
-Mock‑Modus:  
-Stellt ein Dummy‑Interface bereit.
-
-### 4. variable_wrapper – QGIS‑Variablen
-Abstraktion für:
-
-Projektvariablen (projectScope)
-
-globale Variablen (globalScope)
-
-Mock‑Speicher für Tests
-
-Vorteile:
-
-keine QGIS‑Abhängigkeit in der Logik
-
-testbare Variablenverwaltung
-
-einheitliches API
-
-### 5. message_wrapper – Meldungen & Logging
-Einheitliche Schnittstelle für:
-
-Fehlermeldungen
-
-Warnungen
-
-Info‑Meldungen
-
-Logging
-
-Mock‑Modus:
-Speichert Nachrichten statt sie an QGIS zu senden.
-
-### 6. dialog_wrapper – Benutzer‑Dialoge
-Abstraktion für:
-
-Ja/Nein‑Dialoge
-
-spätere Erweiterungen (Eingabedialoge, Dateidialoge, etc.)
-
-Mock‑Modus:
-Gibt Default‑Werte zurück, öffnet keine UI.
-
-### 7. DockManager & Navigation
-Diese Module nutzen die Wrapper‑Schicht, um:
-
-DockWidgets sicher zu verwalten
-
-Toolbars und Menüs zu erzeugen
-
-Reload‑sichere UI‑Strukturen aufzubauen
-
-Sie sind keine Wrapper, sondern Wrapper‑Konsumenten.
-
-## Designprinzipien
-🧱 1. Single Source of Truth
-Jede QGIS‑ oder Qt‑Funktionalität wird nur an einer Stelle implementiert.
-
-🔄 2. Austauschbarkeit
-Mock‑Modus und Echtmodus sind vollständig austauschbar.
-
-🧪 3. Testbarkeit
-Jede Funktion kann ohne QGIS getestet werden.
-
-🧼 4. Saubere Trennung
-UI → qt_wrapper
-
-QGIS‑Core → qgiscore_wrapper
-
-QGIS‑UI → qgisui_wrapper
-
-Logik → settings_logic, layer_logic, prüfmanager, …
-
-🔌 5. Erweiterbarkeit
-Neue Wrapper können jederzeit ergänzt werden, ohne bestehende Plugins zu brechen.
-
-## Vorteile für Entwickler
-Keine QGIS‑Abhängigkeiten in der Logik
-
-IDE‑freundlich (Pylance, Autocomplete, Typing)
-
-CI‑fähig (Tests ohne QGIS)
-
-saubere Architektur
-
-leichte Wartbarkeit
-
-klare Dokumentation
-
-## Fazit
-Die Wrapper‑Architektur ist das Herzstück von sn_basis.
-Sie ermöglicht eine moderne, modulare und testbare QGIS‑Plugin‑Entwicklung, die unabhängig von QGIS‑Versionen, Qt‑Versionen und Entwicklungsumgebungen funktioniert.
-
-Sie bildet die Grundlage für:
-
-stabile APIs
-
-saubere UI‑Abstraktion
-
-automatisierte Tests
-
-nachhaltige Weiterentwicklung

assets/Pluginkonzept.md

@@ -1,144 +0,0 @@
-# Wrapper‑Architektur – Übersicht
-Die Wrapper‑Architektur von sn_basis bildet das Fundament für eine robuste, testbare und zukunftssichere QGIS‑Plugin‑Entwicklung.
-Sie kapselt sämtliche QGIS‑ und Qt‑Abhängigkeiten hinter klar definierten Schnittstellen und ermöglicht dadurch:
-
-- Mock‑fähige Unit‑Tests ohne QGIS
-- PyQt5/6‑Kompatibilität ohne Code‑Änderungen
-- saubere Trennung von UI, Logik und Infrastruktur
-- stabile APIs, die unabhängig von QGIS‑Versionen bleiben
-- klare Erweiterbarkeit für zukünftige Module und Plugins
-
-Die Wrapper‑Schicht ist das zentrale Bindeglied zwischen der Plugin‑Logik und der QGIS‑/Qt‑Umgebung.
-
-## Ziele der Wrapper‑Architektur
-1. Entkopplung von QGIS und Qt
-Alle direkten Importe wie from qgis.core import ... oder from qgis.PyQt.QtWidgets import ... verschwinden aus der Plugin‑Logik.
-Stattdessen werden sie über Wrapper‑Module abstrahiert.
-
-2. Testbarkeit ohne QGIS
-Im Mock‑Modus liefern die Wrapper:
-
-- Dummy‑Objekte
-- simulierte Rückgabewerte
-- speicherbare Zustände (z. B. Variablen, Layer, Nachrichten)
-
-Damit laufen Tests in jeder CI‑Umgebung.
-
-3. Einheitliche API für alle Plugins
-Plugins greifen nicht mehr direkt auf QGIS zu, sondern nutzen:
-
-
-- sn_basis.functions.qgiscore_wrapper
-- sn_basis.functions.qgisui_wrapper
-- sn_basis.functions.qt_wrapper
-- sn_basis.functions.variable_wrapper
-- sn_basis.functions.message_wrapper
-- sn_basis.functions.dialog_wrapper
-Aufgrund des Umfangs ist der Wrapper für die Layerbehandlung aufgeteilt:
-- ly_existence_wrapper
-- ly_geometry_wrapper
-- ly_Metadata_wrapper
-- ly_style_wrapper
-- ly_visibility_wrapper
-
-4. Zukunftssicherheit
-Ändert sich die QGIS‑ oder Qt‑API, wird nur der Wrapper angepasst, nicht jedes Plugin.
-
-## Architekturüberblick
-Die Wrapper‑Schicht besteht aus mehreren Modulen, die jeweils einen klar abgegrenzten Verantwortungsbereich haben.
-
-### 1. qt_wrapper – Qt‑Abstraktion
-Kapselt alle Qt‑Widgets, Dialoge und Konstanten:
-
-- QWidget, QDialog, QMessageBox, QToolBar, QMenu, …
-- Layouts, Buttons, Labels, LineEdits
-- Qt‑Konstanten wie YES, NO, Dock‑Areas
-
-Mock‑Modus:  
-Stellt Dummy‑Widgets bereit, die keine UI öffnen.
-
-### 2. qgiscore_wrapper – QGIS‑Core‑Abstraktion
-Abstraktion für:
-
-- QgsProject
-- Layer‑Zugriff
-- Projekt‑Metadaten
-- Pfade, CRS, Feature‑Zugriff
-
-Mock‑Modus:  
-Simuliert ein Projekt und Layer‑Container.
-
-### 3. qgisui_wrapper – QGIS‑UI‑Abstraktion
-Kapselt UI‑bezogene QGIS‑Funktionen:
-
-- Zugriff auf iface
-- Dock‑Management
-- Menü‑ und Toolbar‑Integration
-- Hauptfenster‑Zugriff
-
-Mock‑Modus:  
-Stellt ein Dummy‑Interface bereit.
-
-### 4. variable_wrapper – QGIS‑Variablen
-Abstraktion für:
-
-- Projektvariablen (projectScope)
-- globale Variablen (globalScope)
-- Mock‑Speicher für Tests
-
-Vorteile:
-
-- keine QGIS‑Abhängigkeit in der Logik
-- testbare Variablenverwaltung
-- einheitliches API
-
-### 5. message_wrapper – Meldungen & Logging
-Einheitliche Schnittstelle für:
-
-- Fehlermeldungen
-- Warnungen
-- Info‑Meldungen
-- Logging
-
-Mock‑Modus:
-Speichert Nachrichten statt sie an QGIS zu senden.
-
-### 6. dialog_wrapper – Benutzer‑Dialoge
-Abstraktion für:
-
-- Ja/Nein‑Dialoge
-- spätere Erweiterungen (Eingabedialoge, Dateidialoge, etc.)
-
-Mock‑Modus:
-Gibt Default‑Werte zurück, öffnet keine UI.
-
-### 7. DockManager & Navigation
-Diese Module nutzen die Wrapper‑Schicht, um:
-
-- DockWidgets sicher zu verwalten
-- Toolbars und Menüs zu erzeugen
-- Reload‑sichere UI‑Strukturen aufzubauen
-
-Sie sind keine Wrapper, sondern Wrapper‑Konsumenten. Alle Fach-Plugins nutzen den Dockmanager des Basisplugins.
-
-## Designprinzipien
-1. Single Source of Truth
-Jede QGIS‑ oder Qt‑Funktionalität wird nur an einer Stelle implementiert.
-
-2. Austauschbarkeit
-Mock‑Modus und Echtmodus sind vollständig austauschbar.
-
-3. Testbarkeit
-Jede Funktion kann ohne QGIS getestet werden.
-
-4. Saubere Trennung
-- UI → qt_wrapper
-- QGIS‑Core → qgiscore_wrapper
-- QGIS‑UI → qgisui_wrapper
-- Logik → settings_logic, layer_logic, prüfmanager, …
-
-5. Erweiterbarkeit
-Neue Wrapper können jederzeit ergänzt werden, ohne bestehende Plugins zu brechen.
-
-
-

assets/datagrabber.md

@@ -1,38 +0,0 @@
-```mermaid
-flowchart TD
-  subgraph Plugin
-    P[sn_plan41  Fachplugin]
-    A[Adapter Plan41LinklistAdapter]
-    PM[Pruefmanager]
-    LP[Layerpruefer]
-    KP[Linkpruefer]
-    SP[Stilpruefer]
-  end
-
-  subgraph Core
-    DG[DataGrabber]
-    NL[normalized entries]
-    LL[Layer Loader  Provider Dispatch]
-    SM[Spatial Matcher]
-    ST[Storage GPKG / PostGIS]
-    PR[Project QGIS - addMapLayer]
-    LOG[Log / Ergebnisstruktur]
-  end
-
-  P -->|gibt Adapter, Prüfer, Pruefmanager| DG
-  A -->|load liefert Rohdaten| DG
-  DG -->|adapter.normalize| NL
-  NL --> DG
-  DG -->|für jeden Eintrag: _check_link -> KP.check| KP
-  DG -->|für jeden Eintrag: _check_style -> SP.check| SP
-  DG -->|prüfe vorhandene Layer| LP
-  DG -->|lade Layer via provider| LL
-  LL -->|Features| SM
-  SM -->|Abgleich| DG
-  DG -->|speichern| ST
-  ST --> PR
-  DG --> PR
-  DG -->|Ergebnis/Fehler| LOG
-  LOG --> PM
-  DG --> PM
-```

assets/moduluebersicht.md

@@ -1,9 +0,0 @@
-```mermaid
-graph TD
-    M1["<div style='text-align:center'><b>sn_basis</b><br/><br/></b></div><div style='text-align:left'>➡ Initialisierung der GUI<br/> ➡ Exception Handling<br/> ➡ Bereitstellung der Stile"]
-    M2["<div style='text-align:center'><b>sn_verfahrensgebiet</b><br/><br/><div style='text-align:left'>➡ Abruf und Aufbereitung der Gebietsgrenze"<br/>➡ Erstellung neuer Gebietsgrenzen <br/>➡ Grenzpunktextraktion<br/>➡ Grenzpunktprüfung]
-    M3["<div style='text-align:center'><b>sn_Plan41</b><br/><br/><div style='text-align:left'>➡ Fachdatenabruf<br/>➡Versionierung der Fachdaten<br/>➡ Planung der TG-Maßnahmen <br/>➡Kartenerzeugung (NGG und P41)<br/>➡ Erzeugung der Begleitdokumente (Anlagenverzeichnis, MVZ, Maßnahmeblätter)"]
-
-    M1 --> M2 
-    M1 --> M3
-```

assets/plan-qgis340ExitCrashFix.prompt.md

@@ -0,0 +1,57 @@
+# Plan: QGIS 3.40 Exit-Crash absichern
+
+Der wahrscheinlichste Auslöser ist fehlendes Signal-Cleanup beim Plugin-Unload: globale Projekt-Listener und PrintTab-Listener bleiben aktiv, während QgsProject beim QGIS-Exit bereits zerstört wird. Die empfohlene Lösung ist ein minimaler, versionsneutraler Cleanup-Pfad (disconnect + defensive Guards), ohne Fachlogik zu ändern.
+
+## Steps
+
+1. Teardown-Funktion für globale Verfahrensgebiet-Listener ergänzen, inkl. idempotentem Disconnect und Rücksetzen des Installationsflags.
+   - Datei: `sn_basis/functions/verfahrensgebiet_manager.py` (nach `setup_verfahrensgebiet_listener`, ca. Zeile 132)
+   - Neue Funktion `teardown_verfahrensgebiet_listener()` disconnect alle 5 QgsProject-Signale (`layersAdded`, `layerRemoved`, `readProject`, `newProjectCreated`, `cleared`) und setzt `_listener_installed = False` zurück.
+   - RuntimeError abfangen (Projekt wird gerade zerstört → normal).
+
+2. Teardown in Unload-Pfad vor UI-Abbau aufrufen. (depends on step 1)
+   - Datei: `sn_basis/main.py` (in `BasisPlugin.unload`, ca. Zeile 52)
+   - Import und Aufruf von `teardown_verfahrensgebiet_listener()` als erste Zeile in `unload()`, bevor `self.ui.remove_all()` ausgeführt wird.
+
+3. PrintTab um kleinen Projekt-Signal-Cleanup ergänzen, symmetrisch zu bestehendem Theme-Cleanup. (parallel mit step 1)
+   - Datei: `sn_basis/ui/tabs/print_tab.py`
+   - Neue Methode `cleanup()` nach `_disconnect_theme_collection_signals` (ca. Zeile 485).
+   - Disconnectet QgsProject-Signale (`readProject`, `newProjectCreated`, `cleared`) von `self._on_project_changed` (analog zu bestehendem Theme-Disconnect-Muster).
+   - Ruft danach `self._disconnect_theme_collection_signals()` auf.
+
+4. BaseDockWidget.closeEvent so erweitern, dass Tab-Cleanup-Hooks vor Schließen aufgerufen werden. (depends on step 3)
+   - Datei: `sn_basis/ui/base_dockwidget.py` (in `closeEvent`, ca. Zeile 97)
+   - Vor dem bestehenden `self.action.setChecked(False)` Block: über alle Tabs iterieren, auf `cleanup`-Attribut prüfen, aufrufen; Exception abfangen.
+
+5. Optional nur bei Restinstabilität: defensive Guards bei Projektzugriffen in kritischen Handlern ergänzen.
+   - Datei: `sn_basis/functions/variable_wrapper.py` (in `get_variable`/`set_variable`, ca. Zeile 60 und 89)
+   - Datei: `sn_basis/functions/verfahrensgebiet_manager.py` (in `_on_layer_removed`, ca. Zeile 114)
+   - `QgsProject.instance()` auf None/RuntimeError prüfen und bei Zerstörung früh zurückkehren.
+
+## Relevant files
+
+- `sn_basis/functions/verfahrensgebiet_manager.py` — Listener-Setup/Teardown, Handler-Guards
+- `sn_basis/main.py` — Unload-Reihenfolge
+- `sn_basis/ui/tabs/print_tab.py` — Projekt-Signal-Cleanup
+- `sn_basis/ui/base_dockwidget.py` — zentraler Cleanup-Hook
+- `sn_basis/ui/dockmanager.py` — asynchrones deleteLater als Lifecycle-Kontext
+- `sn_basis/functions/variable_wrapper.py` — optional defensive Guards
+
+## Decisions
+
+- Include: minimaler Lifecycle-Fix über disconnect + Guards.
+- Exclude: Refactoring der gesamten Signal-Architektur, größere UI-Umbauten, versionsspezifische If-Branches.
+- Begründung: geringstes Risiko für Regressionen bei maximaler Wirkung gegen Shutdown-Crashs.
+- Keine Änderung an Business-Logik, keine Änderung an Variablennamen, keine QGIS-versionsspezifischen Sonderpfade — rein sichere Disconnect/Guard-Muster.
+
+## Verification
+
+1. Plugin laden, Dock öffnen/schließen, Projekt neu laden, Layer „Verfahrensgebiet" add/remove, dann QGIS 3.40.7 beenden → kein Access Violation.
+2. Dasselbe unter QGIS 4 → unverändertes Verhalten, keine Regression.
+3. Mehrfacher Plugin-Reload in einer Sitzung → keine doppelten Signal-Reaktionen, keine Exceptions beim Unload.
+4. Optionaler Stresstest: Unit-Test für idempotentes Teardown (mehrfaches unload ohne Exception).
+
+## Further considerations
+
+- Step 5 (defensive Guards in variable_wrapper) nur umsetzen, wenn nach Steps 1–4 noch reproduzierbare Exit-Crashs auftreten.
+- Ein kleiner Unit-Test für idempotentes Teardown (mehrfaches `unload()` ohne Exception) wäre empfehlenswert, falls die Testsuite erweitert wird.

changelog.txt

@@ -1,3 +1,26 @@
 ---
+Version 26.5.1-unstable:
+---
+Version 26.4.8-unstable:
+---
+Version 26.4.7-unstable:
+---
+Version 26.4.6-unstable:
+---
+Version 26.4.5-unstable:
+---
+Version 26.4.4-unstable:
+---
+Version 26.4.3-unstable:
+---
+Version 26.04.1-unstable:
+---
+Version 26.3.3-unstable:
+---
+Version 26.3.2-unstable:
+---
+Version 26.3.1-testing:
+- unstable als testing veröffentlicht
+---
 Version 26.3.1-unstable:
 - erster Test als echtes PlugIn 

functions/__init__.py

@@ -1,3 +1,8 @@
+"""
+sn_basis/functions – Wrapper und Hilfsfunktionen für QGIS-Kompatibilität.
+Bietet abstrahierte Schnittstellen für Qt, QGIS und OS-Operationen.
+"""
+
 from .ly_existence_wrapper import layer_exists
 from .ly_geometry_wrapper import (
     get_layer_geometry_type,
@@ -15,7 +20,7 @@ from .ly_metadata_wrapper import (
     is_layer_editable,
 )
 from .ly_style_wrapper import apply_style
-from .dialog_wrapper import ask_yes_no, ask_overwrite_append_cancel_custom
+from .dialog_wrapper import ask_yes_no, ask_overwrite_append_cancel_custom, ask_ergaenzen_entfernen_ersetzen_abbrechen, ask_detailpruefung_oder_vg_laden
 
 from .message_wrapper import (
     _get_message_bar,

functions/dialog_wrapper.py

@@ -128,6 +128,110 @@ def ask_overwrite_append_cancel_custom(
         return "cancel"
 
 
+def ask_ergaenzen_entfernen_ersetzen_abbrechen(
+    parent: Any,
+    title: str,
+    message: str,
+) -> Literal["ergaenzen", "entfernen", "ersetzen", "abbrechen"]:
+    """Zeigt Dialog mit vier Optionen für Verfahrensgebiet-Editoperationen.
+
+    Optionen:
+    - **Ergänzen**: ausgewählte Flurstücke zum Verfahrensgebiet hinzufügen
+    - **Entfernen**: ausgewählte Flurstücke aus dem Verfahrensgebiet entfernen
+    - **Ersetzen**: Verfahrensgebiet vollständig durch Auswahl ersetzen
+    - **Abbrechen**: Vorgang beenden ohne Änderung
+
+    Parameters
+    ----------
+    parent :
+        Eltern-Widget oder None.
+    title : str
+        Dialog-Titel.
+    message : str
+        Hauptmeldung mit Erklärung.
+
+    Returns
+    -------
+    Literal["ergaenzen", "entfernen", "ersetzen", "abbrechen"]
+        Genaue Entscheidung des Nutzers.
+    """
+    if QT_VERSION == 0:  # Mock-Modus
+        print(f"Mock-Modus: ask_ergaenzen_entfernen_ersetzen_abbrechen('{title}') → abbrechen")
+        return "abbrechen"
+
+    msg = QMessageBox(parent)
+    msg.setIcon(ICON_QUESTION)
+    msg.setWindowTitle(title)
+    msg.setText(message)
+
+    ergaenzen_btn = msg.addButton("Ergänzen", QMessageBox.ButtonRole.ActionRole)
+    entfernen_btn = msg.addButton("Entfernen", QMessageBox.ButtonRole.ActionRole)
+    ersetzen_btn = msg.addButton("Ersetzen", QMessageBox.ButtonRole.AcceptRole)
+    msg.addButton("Abbrechen", QMessageBox.ButtonRole.RejectRole)
+
+    exec_dialog(msg)
+
+    clicked = msg.clickedButton()
+    if clicked == ergaenzen_btn:
+        return "ergaenzen"
+    elif clicked == entfernen_btn:
+        return "entfernen"
+    elif clicked == ersetzen_btn:
+        return "ersetzen"
+    else:
+        return "abbrechen"
+
+
+def ask_detailpruefung_oder_vg_laden(
+    parent: Any,
+    title: str,
+    message: str,
+) -> Literal["detailpruefung", "als_vg_laden", "abbrechen"]:
+    """Zeigt Dialog mit drei Optionen nach erkannter Flächenabweichung.
+
+    Optionen:
+    - **Detailprüfung starten**: Knickpunktbasierte Prüfung des BROR-Umrings
+    - **Bodenordnungsobjekt als VG laden**: BROR direkt als Verfahrensgebiet übernehmen
+    - **Abbrechen**: Vorgang beenden ohne weitere Aktion
+
+    Parameters
+    ----------
+    parent :
+        Eltern-Widget oder None.
+    title : str
+        Dialog-Titel.
+    message : str
+        Hauptmeldung mit Flächen-Informationen.
+
+    Returns
+    -------
+    Literal["detailpruefung", "als_vg_laden", "abbrechen"]
+        Genaue Entscheidung des Nutzers.
+    """
+    if QT_VERSION == 0:  # Mock-Modus
+        print(f"Mock-Modus: ask_detailpruefung_oder_vg_laden('{title}') → abbrechen")
+        return "abbrechen"
+
+    msg = QMessageBox(parent)
+    msg.setIcon(ICON_QUESTION)
+    msg.setWindowTitle(title)
+    msg.setText(message)
+
+    detail_btn = msg.addButton("Detailprüfung starten", QMessageBox.ButtonRole.AcceptRole)
+    vg_btn = msg.addButton("Bodenordnungsobjekt als VG laden", QMessageBox.ButtonRole.ActionRole)
+    msg.addButton("Abbrechen", QMessageBox.ButtonRole.RejectRole)
+
+    exec_dialog(msg)
+
+    clicked = msg.clickedButton()
+    if clicked == detail_btn:
+        return "detailpruefung"
+    elif clicked == vg_btn:
+        return "als_vg_laden"
+    else:
+        return "abbrechen"
+
+
 class ProgressDialog:
     def __init__(self, total: int, title: str = "Fortschritt", label: str = "Verarbeite..."):
         self.total = max(total, 1)

functions/qgiscore_wrapper.py

@@ -24,10 +24,14 @@ QgsFeature: Type[Any]
 QgsField: Type[Any]
 QgsGeometry: Type[Any]
 QgsFeatureRequest: Type[Any]
+QgsRectangle: Type[Any]
 QgsCoordinateTransform: Type[Any]
 QgsCoordinateReferenceSystem: Type[Any]
 QgsPrintLayout: Type[Any]
 QgsLayoutItemMap: Type[Any]
+QgsLayoutItemMapGrid: Type[Any]
+QgsTextFormat: Type[Any]
+QgsTextBackgroundSettings: Type[Any]
 QgsLayoutItemLabel: Type[Any]
 QgsLayoutItemLegend: Type[Any]
 QgsLayoutPoint: Type[Any]
@@ -35,6 +39,25 @@ QgsLayoutSize: Type[Any]
 QgsUnitTypes: Type[Any]
 QgsLayoutItem: Type[Any]
 
+MAP_GRID_STYLE_MARKERS: Any = None
+MAP_GRID_STYLE_FRAME_ANNOTATIONS: Any = None
+MAP_GRID_FRAME_STYLE_INTERIOR_TICKS: Any = None
+MAP_GRID_UNIT_MAP_UNIT: Any = None
+MAP_GRID_ANNOTATION_FORMAT_DECIMAL: Any = None
+MAP_GRID_ANNOTATION_DISPLAY_HIDE_ALL: Any = None
+MAP_GRID_ANNOTATION_DISPLAY_SHOW_ALL: Any = None
+MAP_GRID_ANNOTATION_DISPLAY_SHOW_X: Any = None
+MAP_GRID_ANNOTATION_DISPLAY_SHOW_Y: Any = None
+MAP_GRID_BORDER_LEFT: Any = None
+MAP_GRID_BORDER_RIGHT: Any = None
+MAP_GRID_BORDER_TOP: Any = None
+MAP_GRID_BORDER_BOTTOM: Any = None
+MAP_GRID_ANNOTATION_POSITION_INSIDE_FRAME: Any = None
+TEXT_BACKGROUND_SHAPE_RECTANGLE: Any = None
+TEXT_BACKGROUND_SIZE_BUFFER: Any = None
+TEXT_RENDER_UNIT_MILLIMETERS: Any = None
+TEXT_RENDER_UNIT_POINTS: Any = None
+
 QGIS_AVAILABLE = False
 
 # ---------------------------------------------------------
@@ -54,10 +77,14 @@ try:
         QgsField as _QgsField,
         QgsGeometry as _QgsGeometry,
         QgsFeatureRequest as _QgsFeatureRequest,
+        QgsRectangle as _QgsRectangle,
         QgsCoordinateTransform as _QgsCoordinateTransform,
         QgsCoordinateReferenceSystem as _QgsCoordinateReferenceSystem,
         QgsPrintLayout as _QgsPrintLayout,
         QgsLayoutItemMap as _QgsLayoutItemMap,
+        QgsLayoutItemMapGrid as _QgsLayoutItemMapGrid,
+        QgsTextFormat as _QgsTextFormat,
+        QgsTextBackgroundSettings as _QgsTextBackgroundSettings,
         QgsLayoutItemLabel as _QgsLayoutItemLabel,
         QgsLayoutItemLegend as _QgsLayoutItemLegend,
         QgsLayoutPoint as _QgsLayoutPoint,
@@ -77,10 +104,14 @@ try:
     QgsField = _QgsField
     QgsGeometry = _QgsGeometry
     QgsFeatureRequest = _QgsFeatureRequest
+    QgsRectangle = _QgsRectangle
     QgsCoordinateTransform = _QgsCoordinateTransform
     QgsCoordinateReferenceSystem = _QgsCoordinateReferenceSystem
     QgsPrintLayout = _QgsPrintLayout
     QgsLayoutItemMap = _QgsLayoutItemMap
+    QgsLayoutItemMapGrid = _QgsLayoutItemMapGrid
+    QgsTextFormat = _QgsTextFormat
+    QgsTextBackgroundSettings = _QgsTextBackgroundSettings
     QgsLayoutItemLabel = _QgsLayoutItemLabel
     QgsLayoutItemLegend = _QgsLayoutItemLegend
     QgsLayoutPoint = _QgsLayoutPoint
@@ -88,6 +119,98 @@ try:
     QgsUnitTypes = _QgsUnitTypes
     QgsLayoutItem = _QgsLayoutItem
 
+    def _resolve_qgis_enum(*paths: tuple[Any, ...]) -> Any:
+        for path in paths:
+            value: Any = path[0]
+            ok = True
+            for name in path[1:]:
+                value = getattr(value, name, None)
+                if value is None:
+                    ok = False
+                    break
+            if ok:
+                return value
+        return None
+
+    MAP_GRID_STYLE_MARKERS = _resolve_qgis_enum(
+        (_Qgis, "MapGridStyle", "Markers"),
+        (_QgsLayoutItemMapGrid, "Markers"),
+    )
+    MAP_GRID_STYLE_FRAME_ANNOTATIONS = _resolve_qgis_enum(
+        (_Qgis, "MapGridStyle", "FrameAndAnnotationsOnly"),
+        (_QgsLayoutItemMapGrid, "FrameAndAnnotationsOnly"),
+        (_Qgis, "MapGridStyle", "FrameAnnotations"),
+        (_QgsLayoutItemMapGrid, "FrameAnnotations"),
+    )
+    MAP_GRID_FRAME_STYLE_INTERIOR_TICKS = _resolve_qgis_enum(
+        (_Qgis, "MapGridFrameStyle", "InteriorTicks"),
+        (_QgsLayoutItemMapGrid, "InteriorTicks"),
+    )
+    MAP_GRID_UNIT_MAP_UNIT = _resolve_qgis_enum(
+        (_Qgis, "MapGridUnit", "MapUnits"),
+        (_QgsLayoutItemMapGrid, "MapUnits"),
+        (_Qgis, "MapGridUnit", "MapUnit"),
+        (_QgsLayoutItemMapGrid, "MapUnit"),
+    )
+    MAP_GRID_ANNOTATION_FORMAT_DECIMAL = _resolve_qgis_enum(
+        (_Qgis, "MapGridAnnotationFormat", "Decimal"),
+        (_QgsLayoutItemMapGrid, "Decimal"),
+    )
+    MAP_GRID_ANNOTATION_DISPLAY_HIDE_ALL = _resolve_qgis_enum(
+        (_Qgis, "MapGridComponentVisibility", "HideAll"),
+        (_QgsLayoutItemMapGrid, "HideAll"),
+    )
+    MAP_GRID_ANNOTATION_DISPLAY_SHOW_ALL = _resolve_qgis_enum(
+        (_Qgis, "MapGridComponentVisibility", "ShowAll"),
+        (_QgsLayoutItemMapGrid, "ShowAll"),
+    )
+    MAP_GRID_ANNOTATION_DISPLAY_SHOW_X = _resolve_qgis_enum(
+        (_Qgis, "MapGridComponentVisibility", "LongitudeOnly"),
+        (_QgsLayoutItemMapGrid, "LongitudeOnly"),
+        (_Qgis, "MapGridComponentVisibility", "ShowLongitudeOnly"),
+        (_QgsLayoutItemMapGrid, "ShowLongitudeOnly"),
+    )
+    MAP_GRID_ANNOTATION_DISPLAY_SHOW_Y = _resolve_qgis_enum(
+        (_Qgis, "MapGridComponentVisibility", "LatitudeOnly"),
+        (_QgsLayoutItemMapGrid, "LatitudeOnly"),
+        (_Qgis, "MapGridComponentVisibility", "ShowLatitudeOnly"),
+        (_QgsLayoutItemMapGrid, "ShowLatitudeOnly"),
+    )
+    MAP_GRID_BORDER_LEFT = _resolve_qgis_enum(
+        (_Qgis, "MapGridBorderSide", "Left"),
+        (_QgsLayoutItemMapGrid, "Left"),
+    )
+    MAP_GRID_BORDER_RIGHT = _resolve_qgis_enum(
+        (_Qgis, "MapGridBorderSide", "Right"),
+        (_QgsLayoutItemMapGrid, "Right"),
+    )
+    MAP_GRID_BORDER_TOP = _resolve_qgis_enum(
+        (_Qgis, "MapGridBorderSide", "Top"),
+        (_QgsLayoutItemMapGrid, "Top"),
+    )
+    MAP_GRID_BORDER_BOTTOM = _resolve_qgis_enum(
+        (_Qgis, "MapGridBorderSide", "Bottom"),
+        (_QgsLayoutItemMapGrid, "Bottom"),
+    )
+    MAP_GRID_ANNOTATION_POSITION_INSIDE_FRAME = _resolve_qgis_enum(
+        (_Qgis, "MapGridAnnotationPosition", "InsideMapFrame"),
+        (_QgsLayoutItemMapGrid, "InsideMapFrame"),
+    )
+    TEXT_BACKGROUND_SHAPE_RECTANGLE = _resolve_qgis_enum(
+        (_QgsTextBackgroundSettings, "ShapeRectangle"),
+    )
+    TEXT_BACKGROUND_SIZE_BUFFER = _resolve_qgis_enum(
+        (_QgsTextBackgroundSettings, "SizeBuffer"),
+    )
+    TEXT_RENDER_UNIT_MILLIMETERS = _resolve_qgis_enum(
+        (_Qgis, "RenderUnit", "Millimeters"),
+        (_QgsUnitTypes, "RenderMillimeters"),
+    )
+    TEXT_RENDER_UNIT_POINTS = _resolve_qgis_enum(
+        (_Qgis, "RenderUnit", "Points"),
+        (_QgsUnitTypes, "RenderPoints"),
+    )
+
     QGIS_AVAILABLE = True
 
 # ---------------------------------------------------------
@@ -174,6 +297,7 @@ except Exception:
             self.project = project
             self._name = ""
             self._page = _MockQgsLayoutPage()
+            self.items: list[Any] = []
 
         def initializeDefaults(self) -> None:
             pass
@@ -188,7 +312,7 @@ except Exception:
             return self._page
 
         def addLayoutItem(self, item: Any) -> None:
-            pass
+            self.items.append(item)
 
     class _MockQgsLayoutPage:
         def setPageSize(self, size: Any) -> None:
@@ -201,15 +325,22 @@ except Exception:
     class _MockQgsLayoutItemMap:
         def __init__(self, layout: Any):
             self.layout = layout
+            self.item_id = ""
+            self.extent = None
+            self.scale = None
+            self.follow_visibility_preset = False
+            self.follow_visibility_preset_name = ""
+            self.keep_layer_set = False
+            self._grids = _MockQgsLayoutItemMapGridStack(self)
 
         def setId(self, item_id: str) -> None:
-            pass
+            self.item_id = item_id
 
         def setExtent(self, extent: Any) -> None:
-            pass
+            self.extent = extent
 
         def setScale(self, scale: float) -> None:
-            pass
+            self.scale = scale
 
         def attemptMove(self, point: Any) -> None:
             pass
@@ -218,11 +349,162 @@ except Exception:
             pass
 
         def setFollowVisibilityPreset(self, active: bool) -> None:
-            pass
+            self.follow_visibility_preset = active
 
         def setFollowVisibilityPresetName(self, name: str) -> None:
+            self.follow_visibility_preset_name = name
+
+        def setKeepLayerSet(self, enabled: bool) -> None:
+            self.keep_layer_set = enabled
+
+        def grids(self):
+            return self._grids
+
+        def updateBoundingRect(self) -> None:
             pass
 
+        def refresh(self) -> None:
+            pass
+
+    class _MockQgsLayoutItemMapGrid:
+        Markers = "Markers"
+        FrameAndAnnotationsOnly = "FrameAndAnnotationsOnly"
+        InteriorTicks = "InteriorTicks"
+        MapUnits = "MapUnits"
+        Decimal = "Decimal"
+        HideAll = "HideAll"
+        ShowAll = "ShowAll"
+        LongitudeOnly = "LongitudeOnly"
+        LatitudeOnly = "LatitudeOnly"
+        Left = "Left"
+        Right = "Right"
+        Top = "Top"
+        Bottom = "Bottom"
+        InsideMapFrame = "InsideMapFrame"
+
+        def __init__(self, name: str, map_item: Any):
+            self.name = name
+            self.map_item = map_item
+            self.enabled = False
+            self.style = None
+            self.units = None
+            self.interval_x = None
+            self.interval_y = None
+            self.annotation_enabled = False
+            self.annotation_format = None
+            self.annotation_precision = None
+            self.annotation_display: dict[Any, Any] = {}
+            self.annotation_position: dict[Any, Any] = {}
+            self.frame_style = None
+            self.annotation_text_format = None
+
+        def setEnabled(self, enabled: bool) -> None:
+            self.enabled = enabled
+
+        def setStyle(self, style: Any) -> None:
+            self.style = style
+
+        def setUnits(self, units: Any) -> None:
+            self.units = units
+
+        def setIntervalX(self, interval: float) -> None:
+            self.interval_x = interval
+
+        def setIntervalY(self, interval: float) -> None:
+            self.interval_y = interval
+
+        def setAnnotationEnabled(self, enabled: bool) -> None:
+            self.annotation_enabled = enabled
+
+        def setAnnotationFormat(self, annotation_format: Any) -> None:
+            self.annotation_format = annotation_format
+
+        def setAnnotationPrecision(self, precision: int) -> None:
+            self.annotation_precision = precision
+
+        def setAnnotationDisplay(self, display: Any, border: Any) -> None:
+            self.annotation_display[border] = display
+
+        def setAnnotationPosition(self, position: Any, border: Any) -> None:
+            self.annotation_position[border] = position
+
+        def setFrameStyle(self, frame_style: Any) -> None:
+            self.frame_style = frame_style
+
+        def setAnnotationTextFormat(self, annotation_text_format: Any) -> None:
+            self.annotation_text_format = annotation_text_format
+
+    class _MockQgsTextBackgroundSettings:
+        ShapeRectangle = "ShapeRectangle"
+        SizeBuffer = "SizeBuffer"
+
+        def __init__(self):
+            self.enabled = False
+            self.shape_type = None
+            self.size_type = None
+            self.size = None
+            self.size_unit = None
+            self.offset = None
+            self.offset_unit = None
+            self.fill_color = None
+
+        def setEnabled(self, enabled: bool) -> None:
+            self.enabled = enabled
+
+        def setType(self, shape_type: Any) -> None:
+            self.shape_type = shape_type
+
+        def setSizeType(self, size_type: Any) -> None:
+            self.size_type = size_type
+
+        def setSize(self, size: Any) -> None:
+            self.size = size
+
+        def setSizeUnit(self, unit: Any) -> None:
+            self.size_unit = unit
+
+        def setOffset(self, offset: Any) -> None:
+            self.offset = offset
+
+        def setOffsetUnit(self, unit: Any) -> None:
+            self.offset_unit = unit
+
+        def setFillColor(self, color: Any) -> None:
+            self.fill_color = color
+
+    class _MockQgsTextFormat:
+        def __init__(self):
+            self.font = None
+            self.size = None
+            self.size_unit = None
+            self.background = None
+
+        def setFont(self, font: Any) -> None:
+            self.font = font
+
+        def setSize(self, size: float) -> None:
+            self.size = size
+
+        def setSizeUnit(self, unit: Any) -> None:
+            self.size_unit = unit
+
+        def setBackground(self, background: Any) -> None:
+            self.background = background
+
+    class _MockQgsLayoutItemMapGridStack:
+        def __init__(self, map_item: Any):
+            self.map_item = map_item
+            self._grids: list[_MockQgsLayoutItemMapGrid] = []
+
+        def addGrid(self, grid: Any) -> None:
+            self._grids.append(grid)
+
+        def removeGrid(self, grid_id: str) -> None:
+            self._grids = [grid for grid in self._grids if getattr(grid, "name", "") != grid_id]
+
+        def asList(self) -> list[Any]:
+            return list(self._grids)
+
     class _MockQgsLayoutItemLabel:
         ModeHtml = 1
 
@@ -244,6 +526,9 @@ except Exception:
         def setReferencePoint(self, point: Any) -> None:
             pass
 
+        def setVAlign(self, alignment: Any) -> None:
+            pass
+
         def attemptMove(self, point: Any) -> None:
             pass
 
@@ -271,24 +556,30 @@ except Exception:
         def __init__(self, layout: Any):
             self.layout = layout
             self._model = _MockLegendModel()
+            self.item_id = ""
+            self.object_name = ""
+            self.linked_map = None
+            self.auto_update_model = None
+            self.legend_filter_by_map_enabled = None
+            self.title = ""
 
         def setId(self, item_id: str) -> None:
-            pass
+            self.item_id = item_id
 
         def setObjectName(self, name: str) -> None:
-            pass
+            self.object_name = name
 
         def setLinkedMap(self, map_item: Any) -> None:
-            pass
+            self.linked_map = map_item
 
         def setAutoUpdateModel(self, enabled: bool) -> None:
-            pass
+            self.auto_update_model = enabled
 
         def setLegendFilterByMapEnabled(self, enabled: bool) -> None:
-            pass
+            self.legend_filter_by_map_enabled = enabled
 
         def setTitle(self, title: str) -> None:
-            pass
+            self.title = title
 
         def setReferencePoint(self, point: Any) -> None:
             pass
@@ -322,6 +613,9 @@ except Exception:
 
     QgsPrintLayout = _MockQgsPrintLayout
     QgsLayoutItemMap = _MockQgsLayoutItemMap
+    QgsLayoutItemMapGrid = _MockQgsLayoutItemMapGrid
+    QgsTextFormat = _MockQgsTextFormat
+    QgsTextBackgroundSettings = _MockQgsTextBackgroundSettings
     QgsLayoutItemLabel = _MockQgsLayoutItemLabel
     QgsLayoutItemLegend = _MockQgsLayoutItemLegend
     QgsLayoutPoint = _MockQgsLayoutPoint
@@ -329,6 +623,53 @@ except Exception:
     QgsUnitTypes = _MockQgsUnitTypes
     QgsLayoutItem = _MockQgsLayoutItem
 
+    MAP_GRID_STYLE_MARKERS = _MockQgsLayoutItemMapGrid.Markers
+    MAP_GRID_STYLE_FRAME_ANNOTATIONS = _MockQgsLayoutItemMapGrid.FrameAndAnnotationsOnly
+    MAP_GRID_FRAME_STYLE_INTERIOR_TICKS = _MockQgsLayoutItemMapGrid.InteriorTicks
+    MAP_GRID_UNIT_MAP_UNIT = _MockQgsLayoutItemMapGrid.MapUnits
+    MAP_GRID_ANNOTATION_FORMAT_DECIMAL = _MockQgsLayoutItemMapGrid.Decimal
+    MAP_GRID_ANNOTATION_DISPLAY_HIDE_ALL = _MockQgsLayoutItemMapGrid.HideAll
+    MAP_GRID_ANNOTATION_DISPLAY_SHOW_ALL = _MockQgsLayoutItemMapGrid.ShowAll
+    MAP_GRID_ANNOTATION_DISPLAY_SHOW_X = _MockQgsLayoutItemMapGrid.LongitudeOnly
+    MAP_GRID_ANNOTATION_DISPLAY_SHOW_Y = _MockQgsLayoutItemMapGrid.LatitudeOnly
+    MAP_GRID_BORDER_LEFT = _MockQgsLayoutItemMapGrid.Left
+    MAP_GRID_BORDER_RIGHT = _MockQgsLayoutItemMapGrid.Right
+    MAP_GRID_BORDER_TOP = _MockQgsLayoutItemMapGrid.Top
+    MAP_GRID_BORDER_BOTTOM = _MockQgsLayoutItemMapGrid.Bottom
+    MAP_GRID_ANNOTATION_POSITION_INSIDE_FRAME = _MockQgsLayoutItemMapGrid.InsideMapFrame
+    TEXT_BACKGROUND_SHAPE_RECTANGLE = _MockQgsTextBackgroundSettings.ShapeRectangle
+    TEXT_BACKGROUND_SIZE_BUFFER = _MockQgsTextBackgroundSettings.SizeBuffer
+    TEXT_RENDER_UNIT_MILLIMETERS = "Millimeters"
+    TEXT_RENDER_UNIT_POINTS = "Points"
+
+    class _MockQgsFeature:
+        def __init__(self):
+            self._geometry = None
+            self._attributes = []
+
+        def setGeometry(self, geometry: Any) -> None:
+            self._geometry = geometry
+
+        def setAttributes(self, attributes: list[Any]) -> None:
+            self._attributes = attributes
+
+    class _MockQgsField:
+        def __init__(self, name: str = "", field_type: Any = None):
+            self.name = name
+            self.field_type = field_type
+
+    class _MockQgsGeometry:
+        @staticmethod
+        def unaryUnion(_geometries: list[Any]):
+            return None
+
+        def isEmpty(self) -> bool:
+            return True
+
+    QgsFeature = _MockQgsFeature
+    QgsField = _MockQgsField
+    QgsGeometry = _MockQgsGeometry
+
     class _MockQgsFeatureRequest:
         def __init__(self):
             self._filter_rect = None
@@ -613,3 +954,79 @@ def layer_exists_in_gpkg(gpkg_path: str, layer_name: str) -> bool:
         pass
 
     return False
+
+
+# ---------------------------------------------------------
+# QGIS-3/4-kompatible Geometrie-Hilfsfunktionen
+# ---------------------------------------------------------
+
+def polygon_zu_linie(geom: Any) -> Optional[Any]:
+    """Konvertiert ein Polygon/MultiPolygon zur Umringslinie (QGIS 3 + 4).
+
+    In QGIS 3.x existiert ``QgsGeometry.boundary()``, in QGIS 4.x wurde sie
+    entfernt. Diese Funktion kapselt die Versionsunterschiede und stellt dem
+    Fachplugin eine stabile API bereit.
+
+    Strategie (dreistufig):
+    1. ``geom.boundary()`` – funktioniert in QGIS 3.x
+    2. ``geom.convertToType(1, False)`` – ``1`` = LineGeometry-Wert,
+       identisch in ``QgsWkbTypes.LineGeometry`` (3.x) und
+       ``Qgis.GeometryType.Line`` (4.x)
+    3. Manuelle Ring-Extraktion via ``asPolygon()`` / ``asMultiPolygon()``
+       + ``QgsGeometry.fromPolylineXY()``
+
+    Parameters
+    ----------
+    geom :
+        Polygon- oder MultiPolygon-``QgsGeometry``.
+
+    Returns
+    -------
+    Optional[QgsGeometry]
+        Liniengeometrie (Umring) oder ``None`` bei Fehler / leerer Eingabe.
+    """
+    if geom is None:
+        return None
+    try:
+        if geom.isEmpty():
+            return None
+    except Exception:
+        return None
+
+    # Stufe 1: QGIS 3.x – .boundary() existiert und liefert alle Ringe korrekt
+    if hasattr(geom, "boundary"):
+        try:
+            result = geom.boundary()
+            if result is not None and not result.isEmpty():
+                return result
+        except Exception:
+            pass
+
+    # Stufe 2: Manuelle Ring-Extraktion (primärer QGIS-4.x-Pfad).
+    # convertToType(1, False) würde bei MultiPolygon nur den ersten Außenring
+    # zurückgeben und alle weiteren Polygone sowie Innenringe verwerfen → daher
+    # direkt die vollständige manuelle Extraktion als nächste Stufe.
+    lines = []
+    try:
+        if geom.isMultipart():
+            for polygon in geom.asMultiPolygon():
+                for ring in polygon:
+                    lines.append(QgsGeometry.fromPolylineXY(ring))
+        else:
+            for ring in geom.asPolygon():
+                lines.append(QgsGeometry.fromPolylineXY(ring))
+    except Exception:
+        pass
+    if lines:
+        return QgsGeometry.unaryUnion(lines)
+
+    # Stufe 3: Letzter Fallback – convertToType mit destMultipart=True, damit
+    # zumindest alle Außenringe eines MultiPolygons erfasst werden.
+    try:
+        result = geom.convertToType(1, True)
+        if result is not None and not result.isEmpty():
+            return result
+    except Exception:
+        pass
+
+    return None

functions/test.md

@@ -1,14 +0,0 @@
-mermaid´´´
-flowchart TD
-    A[Projekt]
-
-    subgraph children[ ]
-        direction TB
-        B[src]
-        C[docs]
-        D[README.md]
-    end
-
-    A --> B
-    A --> C
-    A --> D

functions/variable_wrapper.py

@@ -97,6 +97,10 @@ def set_variable(key: str, value: str, scope: str = "project") -> None:
     var_name = f"sn_{key}"
 
     if scope == "project":
+        current_value = get_variable(key, scope="project")
+        if current_value == value:
+            return
+
         project = QgsProject.instance()
         QgsExpressionContextUtils.setProjectVariable(
             project,

functions/verfahrensgebiet_manager.py

@@ -0,0 +1,216 @@
+"""
+sn_basis/functions/verfahrensgebiet_manager.py
+
+Zentrale Verwaltung des Verfahrensgebiet-Layers für alle sn_-Plugins.
+
+Die Variable `sn_verfahrensgebiet_layer` wird automatisch aktualisiert, wenn:
+- Ein Layer mit dem Namen "Verfahrensgebiet" ins Projekt geladen wird
+- Das Projekt neu geladen wird
+- Der Layer aus dem Projekt gelöscht wird
+
+Nutzer können diese Auswahl über das Dropdown in sn_verfahrensgebiet/working_tab
+manuell überschreiben.
+"""
+
+from typing import Optional
+
+from sn_basis.functions.qgiscore_wrapper import QgsProject, QGIS_AVAILABLE
+from sn_basis.functions.variable_wrapper import get_variable, set_variable
+
+
+# ---------------------------------------------------------
+# Globale State für Listener-Registrierung
+# ---------------------------------------------------------
+
+_listener_installed = False
+
+
+# ---------------------------------------------------------
+# Zentrale Verwaltung
+# ---------------------------------------------------------
+
+def get_verfahrensgebiet_layer_id() -> Optional[str]:
+    """
+    Gibt die Layer-ID des aktuellen Verfahrensgebiet-Layers zurück.
+    
+    Returns
+    -------
+    Optional[str]
+        Die Layer-ID oder None, wenn keine Variable gesetzt ist.
+    """
+    value = get_variable("verfahrensgebiet_layer", scope="project")
+    return value if value else None
+
+
+def set_verfahrensgebiet_layer_id(layer_id: str) -> None:
+    """
+    Setzt die Layer-ID des Verfahrensgebiet-Layers (von Nutzer-Auswahl im Dropdown).
+    
+    Parameters
+    ----------
+    layer_id : str
+        Die eindeutige Layer-ID des gewählten Layers.
+    """
+    set_variable("verfahrensgebiet_layer", layer_id, scope="project")
+
+
+def _find_verfahrensgebiet_layer():
+    """
+    Sucht einen Layer mit dem Namen 'Verfahrensgebiet' im aktuellen Projekt.
+    
+    Returns
+    -------
+    tuple[Optional[layer], Optional[str]]
+        (Layer-Objekt, Layer-ID) oder (None, None), wenn nicht gefunden.
+    """
+    if not QGIS_AVAILABLE:
+        return None, None
+    
+    try:
+        project = QgsProject.instance()
+        layers = project.mapLayersByName("Verfahrensgebiet")
+        
+        if layers:
+            # Nutze den ersten (bzw. zuletzt hinzugefügten) Layer mit diesem Namen
+            layer = layers[0]
+            return layer, layer.id()
+    except Exception:
+        pass
+    
+    return None, None
+
+
+def _update_verfahrensgebiet_from_project() -> bool:
+    """
+    Sucht automatisch nach einem Layer namens 'Verfahrensgebiet' im Projekt
+    und aktualisiert die Variable `sn_verfahrensgebiet_layer`.
+    
+    Diese Funktion wird aufgerufen bei:
+    - layersAdded Signal
+    - readProject Signal (Projekt-Reload)
+    - Projekt-Neuerstellung
+    
+    Returns
+    -------
+    bool
+        True, wenn ein Layer gefunden und gespeichert wurde, False sonst.
+    """
+    layer, layer_id = _find_verfahrensgebiet_layer()
+    
+    if layer and layer_id:
+        set_variable("verfahrensgebiet_layer", layer_id, scope="project")
+        return True
+    else:
+        # Layer nicht gefunden: Variable zurücksetzen
+        set_variable("verfahrensgebiet_layer", "", scope="project")
+        return False
+
+
+def _on_layers_added(layers) -> None:
+    """Signal-Handler für QgsProject.layersAdded"""
+    _update_verfahrensgebiet_from_project()
+
+
+def _on_layer_removed(layer_id: str) -> None:
+    """Signal-Handler für QgsProject.layerRemoved"""
+    # Prüfe, ob der entfernte Layer der aktuelle Verfahrensgebiet-Layer war
+    current_id = get_verfahrensgebiet_layer_id()
+    if current_id and current_id == layer_id:
+        # Layer wurde entfernt; versuche, neu zu suchen
+        _update_verfahrensgebiet_from_project()
+
+
+def _on_project_changed() -> None:
+    """Signal-Handler für QgsProject.readProject, newProjectCreated, cleared"""
+    _update_verfahrensgebiet_from_project()
+
+
+# ---------------------------------------------------------
+# Listener-Setup
+# ---------------------------------------------------------
+
+def setup_verfahrensgebiet_listener() -> None:
+    """
+    Registriert globale Event-Listener auf dem QgsProject-Singleton.
+    
+    Diese Funktion sollte EINMAL beim Plugin-Start aufgerufen werden
+    (z.B. in sn_basis.main.BasisPlugin.initGui()).
+    
+    Listener:
+    - layersAdded: automatische Aktualisierung, wenn Layer hinzugefügt werden
+    - layerRemoved: Validierung, wenn Layer gelöscht werden
+    - readProject: Neuinitialisierung beim Projekt-Reload
+    """
+    global _listener_installed
+    
+    if _listener_installed:
+        return  # Bereits registriert
+    
+    if not QGIS_AVAILABLE:
+        return  # QGIS nicht verfügbar
+    
+    try:
+        project = QgsProject.instance()
+        
+        # Verbinde Signale
+        project.layersAdded.connect(_on_layers_added)
+        project.layerRemoved.connect(_on_layer_removed)
+        
+        # readProject wird emittiert, wenn Projekt geladen wird
+        # newProjectCreated wird emittiert bei neuem Projekt
+        # cleared wird emittiert, wenn Projekt gelöscht wird
+        for signal_name in ("readProject", "newProjectCreated", "cleared"):
+            signal = getattr(project, signal_name, None)
+            if signal is not None:
+                signal.connect(_on_project_changed)
+        
+        _listener_installed = True
+        
+        # Initial: versuche, existierenden Layer zu finden
+        _update_verfahrensgebiet_from_project()
+        
+    except Exception:
+        pass
+
+
+def teardown_verfahrensgebiet_listener() -> None:
+    """
+    Trennt globale Event-Listener vom QgsProject-Singleton.
+
+    Diese Funktion ist idempotent und kann mehrfach aufgerufen werden.
+    """
+    global _listener_installed
+
+    if not _listener_installed:
+        return
+
+    try:
+        project = QgsProject.instance()
+        if project is None:
+            return
+
+        try:
+            project.layersAdded.disconnect(_on_layers_added)
+        except Exception:
+            pass
+
+        try:
+            project.layerRemoved.disconnect(_on_layer_removed)
+        except Exception:
+            pass
+
+        for signal_name in ("readProject", "newProjectCreated", "cleared"):
+            signal = getattr(project, signal_name, None)
+            if signal is None:
+                continue
+            try:
+                signal.disconnect(_on_project_changed)
+            except Exception:
+                pass
+
+    except RuntimeError:
+        pass
+    except Exception:
+        pass
+    finally:
+        _listener_installed = False

main.py

@@ -4,6 +4,10 @@ from qgis.utils import plugins
 
 from sn_basis.functions.qt_wrapper import QCoreApplication
 from sn_basis.functions.sys_wrapper import getattr_safe
+from sn_basis.functions.verfahrensgebiet_manager import (
+    setup_verfahrensgebiet_listener,
+    teardown_verfahrensgebiet_listener,
+)
 from sn_basis.ui.navigation import Navigation
 
 
@@ -34,6 +38,10 @@ class BasisPlugin:
         """
         self.ui = Navigation()
         self.ui.init_ui()
+        
+        # Zentrale Verwaltung des Verfahrensgebiet-Layers starten
+        setup_verfahrensgebiet_listener()
+        
         for name, plugin in plugins.items():
             if name.startswith("sn_") and name != "sn_basis":
                 try:
@@ -48,6 +56,8 @@ class BasisPlugin:
         """
         Räumt UI-Komponenten sauber auf.
         """
+        teardown_verfahrensgebiet_listener()
+
         if self.ui:
             self.ui.remove_all()
             self.ui = None

metadata.txt

@@ -1,12 +1,12 @@
 [general]
-version=26.3.1-unstable
+version=26.5.1-unstable
 name=LNO Sachsen | Plugin Basisfunktionen
 description=Plugin mit Basisfunktionen
 author=Daniel Helbig, Michael Otto
 homepage=https://entwicklung.flurneuordnung-sachsen.de/AG_QGIS/Plugin_SN_Basis
 tracker=https://entwicklung.flurneuordnung-sachsen.de/AG_QGIS/Plugin_SN_Basis/issues
 repository=https://entwicklung.flurneuordnung-sachsen.de/AG_QGIS/Plugin_SN_Basis/src/branch/unstable/
-
+QGISMaximumVersion=4.99
 qgisMinimumVersion=3.40
 experimental=true
 deprecated=false

modules/Dateipruefer.py

@@ -46,7 +46,7 @@ class Dateipruefer:
         standarddatei: Optional[str] = None,
         temporaer_erlaubt: bool = False,
         *,
-        verfahrens_db_modus: bool = True,  # 🆕 Verfahrens-DB-spezifische Logik
+        verfahrens_db_modus: bool = False,
     ) -> None:
         """
         Parameters
@@ -90,6 +90,8 @@ class Dateipruefer:
 
     def _pfad(self, relativer_pfad: str) -> Path:
         """Erzeugt OS-unabhängigen Pfad relativ zum Basisverzeichnis."""
+        if relativer_pfad.startswith(("/", "\\")):
+            return Path(relativer_pfad)
         return join_path(self.basis_pfad, relativer_pfad)
 
 
@@ -152,6 +154,22 @@ class Dateipruefer:
         #Excel-dateien erkennen
         dateityp = self.erkenne_dateityp(pfad)
 
+        if not self.verfahrens_db_modus:
+            if not file_exists(pfad):
+                return pruef_ergebnis(
+                    ok=False,
+                    meldung=f"Datei '{self.pfad}' wurde nicht gefunden.",
+                    aktion="datei_nicht_gefunden",
+                    kontext=pfad,
+                )
+
+            return pruef_ergebnis(
+                ok=True,
+                meldung="Datei ist gültig.",
+                aktion="ok",
+                kontext=pfad,
+            )
+
         if dateityp == "excel":
             if not file_exists(pfad):
                 return pruef_ergebnis(
@@ -176,7 +194,7 @@ class Dateipruefer:
             )
 
         # 🆕 2.c: Ungültiger GPKG-Pfad?
-        if not self.verfahrens_db_modus or not self._ist_gueltiger_gpkg_pfad(pfad):
+        if not self._ist_gueltiger_gpkg_pfad(pfad):
             return pruef_ergebnis(
                 ok=False,
                 meldung=f"Der Pfad '{self.pfad}' ist kein gültiger GPKG-Pfad.",

modules/Datenbankpruefer.py

@@ -1 +1,40 @@
-#Datenbankpruefer.py
+"""
+sn_basis/modules/Datenbankpruefer.py – Prüfung von Datenbanken.
+Validiert Datenbank-Verbindungen und -Strukturen.
+"""
+
+from typing import Optional, Any
+from sn_basis.modules.pruef_ergebnis import pruef_ergebnis
+
+
+class Datenbankpruefer:
+    """
+    Prüft Datenbankverbindungen und Datenbankstrukturen auf Gültigkeit.
+    Gibt pruef_ergebnis für die Weiterverarbeitung durch Pruefmanager zurück.
+    """
+
+    def __init__(self, pfad: Optional[str] = None) -> None:
+        """
+        Initialisiert den Datenbankprüfer.
+        
+        Args:
+            pfad: Optional Pfad zur Datenbankdatei (z.B. .gpkg, .sqlite)
+        """
+        self.pfad = pfad
+
+    def pruefe(self) -> pruef_ergebnis:
+        """
+        Prüft die Datenbank auf Gültigkeit und Verbindbarkeit.
+        
+        Returns:
+            pruef_ergebnis: Ergebnis der Prüfung mit ok-Flag und Aktion
+        """
+        if not self.pfad:
+            return pruef_ergebnis(
+                ok=False,
+                meldung="Kein Datenbankpfad angegeben.",
+                aktion="kein_dateipfad",
+                kontext=None,
+            )
+        # Implementierung folgt
+        return pruef_ergebnis(ok=True, meldung="Datenbank OK", aktion="ok", kontext=self.pfad)

modules/Pruefmanager.py

@@ -5,9 +5,9 @@ sn_basis/modules/Pruefmanager.py
 from __future__ import annotations
 from typing import Optional, Any
 
-from sn_basis.functions import ask_yes_no, info, warning, error, ask_overwrite_append_cancel_custom
+from sn_basis.functions import ask_yes_no, info, warning, error, ask_overwrite_append_cancel_custom, ask_ergaenzen_entfernen_ersetzen_abbrechen
+from sn_basis.functions.ly_visibility_wrapper import set_layer_visible
 from sn_basis.modules.pruef_ergebnis import pruef_ergebnis, PruefAktion
-print("DEBUG: Pruefmanager DATEI GELADEN:", __file__)
 
 class Pruefmanager:
     def __init__(self, ui_modus: str = "qgis", parent: Optional[Any] = None) -> None:
@@ -146,10 +146,7 @@ class Pruefmanager:
     # ------------------------------------------------------------------
     def _handle_basic_decision(self, ergebnis: pruef_ergebnis) -> pruef_ergebnis:
         """Basis-Entscheidung für einfache Ja/Nein-Fragen."""
-        print(f"DEBUG _handle_basic_decision: aktion='{ergebnis.aktion}', ui_modus='{self.ui_modus}'")
-        
         if self.ui_modus != "qgis":
-            print("DEBUG: Nicht QGIS → ergebnis unverändert")
             return ergebnis
 
         title_map = {
@@ -163,27 +160,32 @@ class Pruefmanager:
         meldung = ergebnis.meldung or ""
 
         try:
-            print(f"DEBUG ask_yes_no: title='{title}', meldung='{meldung[:50]}...'")
             yes = ask_yes_no(title, meldung, default=False, parent=self.parent)
-            print(f"DEBUG ask_yes_no: yes={yes}")
-        except Exception as e:
-            print(f"DEBUG ask_yes_no Exception: {e}")
+        except Exception:
             return ergebnis
 
         if not yes:
-            print("DEBUG: Nutzer sagte Nein → ok=False")
             return ergebnis
 
         # Nutzer sagte Ja
         if ergebnis.aktion == "temporaer_erlaubt":
-            print("DEBUG: temporaer_erlaubt bestätigt → ok=True")
             return pruef_ergebnis(
                 ok=True,
-                aktion="temporaer_erlaubt",
+                aktion="temporaer_erzeugen",
                 kontext=ergebnis.kontext
             )
 
-        print("DEBUG: Andere Aktion bestätigt → ok=True, aktion='ok'")
+        if ergebnis.aktion == "layer_unsichtbar":
+            try:
+                set_layer_visible(ergebnis.kontext, True)
+            except Exception:
+                return ergebnis
+            return pruef_ergebnis(
+                ok=True,
+                aktion="ok",
+                kontext=ergebnis.kontext,
+            )
+
         return pruef_ergebnis(
             ok=True,
             aktion="ok",
@@ -194,50 +196,80 @@ class Pruefmanager:
     # Hauptlogik: verarbeite() (KORRIGIERT!)
     # ------------------------------------------------------------------
     def verarbeite(self, ergebnis: pruef_ergebnis) -> pruef_ergebnis:
-        print("🔥 verarbeite() START")
-        print("DEBUG Pruefmanager:", ergebnis.ok, ergebnis.aktion)
-        print("DEBUG ergebnis.aktion TYPE:", type(ergebnis.aktion), repr(ergebnis.aktion))
-        
         # 1. Erfolg → direkt weiter
-        print("🔍 Schritt 1: Prüfe ergebnis.ok =", ergebnis.ok)
         if ergebnis.ok:
-            print("✅ Schritt 1: ok=True → return")
             return ergebnis
 
         # 2. VERFAHRENS-DB: Bestehende Datei
-        print("🔍 Schritt 2: Prüfe datei_existiert =", ergebnis.aktion == "datei_existiert")
         if ergebnis.aktion == "datei_existiert":
-            print("✅ Schritt 2: _handle_datei_existiert")
             return self._handle_datei_existiert(ergebnis)
 
+        # 3. Verfahrensgebiet-Editentscheidung
+        if ergebnis.aktion == "verfahrensgebiet_layer_existiert":
+            return self._handle_verfahrensgebiet_layer_existiert(ergebnis)
+
         # 3. Basis interaktive Aktionen
-        print("🔍 Schritt 3: Definiere interactive_actions")
         interactive_actions = {
             "leereingabe_erlaubt",
             "standarddatei_vorschlagen", 
             "temporaer_erlaubt",
             "layer_unsichtbar",
         }
-        print("DEBUG interactive_actions:", repr(interactive_actions))
-        print("DEBUG ergebnis.aktion in interactive_actions?", ergebnis.aktion in interactive_actions)
-        
         if ergebnis.aktion in interactive_actions:
-            print("✅ Schritt 3: Interaktive Aktion → _handle_basic_decision")
-            decision = self._handle_basic_decision(ergebnis)
-            print(f"DEBUG: _handle_basic_decision Ergebnis: ok={decision.ok}, aktion='{decision.aktion}'")
-            return decision
+            return self._handle_basic_decision(ergebnis)
 
         # 4. Fehler behandeln
-        print("❌ Schritt 4: FEHLER BEHANDELN")
         self.report_error(
             thema=ergebnis.aktion or "pruefung",
             meldung=ergebnis.meldung or "",
             aktion=ergebnis.aktion,
             kontext=ergebnis.kontext,
         )
-        print("🔥 verarbeite() ENDE mit ok=False")
         return ergebnis
 
+    def _handle_verfahrensgebiet_layer_existiert(self, ergebnis: pruef_ergebnis) -> pruef_ergebnis:
+        """Fragt Nutzer, was mit dem bestehenden Verfahrensgebiet-Layer geschehen soll.
+
+        Zeigt einen Dialog mit vier Optionen:
+        - **Ergänzen**: neue Flurstücke hinzufügen
+        - **Entfernen**: ausgewählte Flurstücke entfernen
+        - **Ersetzen**: Verfahrensgebiet vollständig ersetzen
+        - **Abbrechen**: Vorgang beenden
+
+        Returns
+        -------
+        pruef_ergebnis
+            ok=True mit aktion ``verfahrensgebiet_ergaenzen`` / ``verfahrensgebiet_entfernen`` /
+            ``verfahrensgebiet_ersetzen``, oder ok=False mit ``verfahrensgebiet_abbrechen``.
+        """
+        if self.ui_modus != "qgis":
+            return ergebnis
+
+        titel = "Verfahrensgebiet bereits vorhanden"
+        meldung = (
+            ergebnis.meldung
+            or "Ein Verfahrensgebiet-Layer existiert bereits.\nWas soll geschehen?"
+        )
+
+        entscheidung = ask_ergaenzen_entfernen_ersetzen_abbrechen(
+            parent=self.parent,
+            title=titel,
+            message=meldung,
+        )
+
+        aktion_map = {
+            "ergaenzen": "verfahrensgebiet_ergaenzen",
+            "entfernen": "verfahrensgebiet_entfernen",
+            "ersetzen":  "verfahrensgebiet_ersetzen",
+            "abbrechen": "verfahrensgebiet_abbrechen",
+        }
+
+        return pruef_ergebnis(
+            ok=(entscheidung != "abbrechen"),
+            aktion=aktion_map[entscheidung],
+            kontext=ergebnis.kontext,
+        )
+
     def _ask_use_or_replace_pufferlayer(self) -> str:
         """
         Fragt den Nutzer, ob ein vorhandener Pufferlayer verwendet

modules/print_layout_baufreigabe.py

@@ -0,0 +1,402 @@
+"""
+sn_basis/modules/print_layout_baufreigabe.py - Layout-Erstellung fuer Baufreigabe-Vorlagen.
+
+Baufreigabe-Layouts verwenden immer feste DIN A3/A4 Seitengroessen im Querformat,
+ein 120 mm breites Kartenschild (statt 180 mm) und erbenerben die Standard-Logik
+fuer Hauptkarte, Quellenangabe und Legende vom PrintLayout.
+
+Atlas-Integration erfolgt nach Layouterstellung durch externe Konfiguration
+in der PrintLogic.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from sn_basis.functions.qt_wrapper import QFont
+from sn_basis.functions.qgiscore_wrapper import (
+    QgsLayoutItem,
+    QgsLayoutItemLabel,
+    QgsLayoutItemLegend,
+    QgsLayoutItemMap,
+    QgsLayoutPoint,
+    QgsLayoutSize,
+    QgsPrintLayout,
+    QgsProject,
+    QgsUnitTypes,
+)
+from sn_basis.functions.qgisui_wrapper import open_layout_designer
+from sn_basis.modules.print_layout import PrintLayout
+
+
+MM = QgsUnitTypes.LayoutMillimeters
+
+
+class PrintLayoutBaufreigabe(PrintLayout):
+    """Erzeugt QGIS-Einzelblatt-Layouts mit fester DIN A3/A4 Querformat-Groesse und 80mm Kartenschild."""
+
+    _FRAME_STROKE_WIDTH_MM = 0.5
+    _KARTENSCHILD_WIDTH_MM = 80.0
+    _KARTENSCHILD_HEIGHT_MM = 58.0
+    _ATLAS_FRAME_MARGIN_MM = 10.0
+    _GRID_INTERVAL_MAP_UNITS = 500.0
+
+    # DIN-Formate: nur A3 und A4 im Querformat
+    _DIN_A3_LANDSCAPE = (420, 297)  # Breite x Hoehe (Querformat)
+    _DIN_A4_LANDSCAPE = (297, 210)  # Querformat
+
+    _TEXT_FORMAT_TEMPLATES = {
+        "Format_1": {"font_family": "Arial", "font_size": 11, "font_style": "normal"},
+        "Format_2": {"font_family": "Arial", "font_size": 13, "font_style": "bold"},
+        "Format_3": {"font_family": "Arial", "font_size": 16, "font_style": "bold"},
+    }
+
+    _OBJECT_TEMPLATES = {
+        "hauptkarte": {"id": "Hauptkarte", "object_name": "Hauptkarte"},
+        "quellenangabe": {
+            "id": "Quellenangabe",
+            "object_name": "Quellenangabe",
+            "size_mm": (80.0, 100.0),
+            "format": "Format_1",
+        },
+        "textfeld": {
+            "id": "Textfeld",
+            "object_name": "Textfeld",
+            "size_mm": (60.0, 8.0),
+            "format": "Format_1",
+            "html_mode": True,
+            "text": "",
+        },
+        "legende": {
+            "id": "Legende",
+            "object_name": "Legende",
+            "size_mm": (80.0, 60.0),
+        },
+    }
+
+    _QUELLENANGABE_TEXT = (
+        "Quelle Geobasisdaten: GeoSN, "
+        "<a href=\"https://www.govdata.de/dl-de/by-2-0\">dl-de/by-2-0</a><br>"
+        "Quelle Fachdaten: Darstellung auf der Grundlage von Daten und mit Erlaubnis des "
+        "Sächsischen Landesamtes für Umwelt, Landwirtschaft und Geologie<br>"
+        "Basemap:"
+        "© GeoBasis-DE / <a href=\"https://www.bkg.bund.de\">BKG</a> ([%year($now)%]) "
+        "<a href=\"https://creativecommons.org/licences/by/4.0/\">CC BY 4.0</a> "
+        "mit teilweise angepasster Signatur<br>"
+    )
+
+    def __init__(self, project: Any | None = None) -> None:
+        super().__init__(project)
+
+    def create_baufreigabe_layout(
+        self,
+        name: str,
+        din_format: str,
+        map_width_mm: float,
+        map_height_mm: float,
+        extent: Any,
+        plotmassstab: float,
+        thema: str = "",
+        fit_extent_to_map: bool = True,
+        atlas_driven: bool = True,
+    ) -> Any:
+        """Erstellt ein Baufreigabe-Layout mit fester DIN A3/A4 Querformat-Groesse.
+
+        Args:
+            name: Name des Layouts
+            din_format: "DIN A3" oder "DIN A4"
+            map_width_mm: Breite der Hauptkarte
+            map_height_mm: Hoehe der Hauptkarte
+            extent: QgsRectangle der Kartenausdehnung
+            plotmassstab: Plotmassstab (z.B. 5000 fuer 1:5000)
+            thema: Name des Visibility-Presets (optional)
+            fit_extent_to_map: Extent bei Bedarf auf das Karten-Seitenverhaeltnis erweitern
+
+        Returns:
+            QgsPrintLayout objektInstance (wird im Layout-Dialog geoeffnet)
+
+        Raises:
+            ValueError: Falls Name bereits existiert oder Format ungueltig ist
+        """
+        # Seitenformat auswaehlen (nur A3/A4 im Querformat)
+        if din_format == "DIN A3":
+            page_width_mm, page_height_mm = self._DIN_A3_LANDSCAPE
+        elif din_format == "DIN A4":
+            page_width_mm, page_height_mm = self._DIN_A4_LANDSCAPE
+        else:
+            raise ValueError(f"Baufreigabe: Format {din_format} ist nicht unterstützt. Nur DIN A3/A4 Querformat.")
+
+        layout_manager = self.project.layoutManager()
+        existing_layout = layout_manager.layoutByName(name)
+        if existing_layout is not None:
+            raise ValueError(f"Eine Vorlage mit der Bezeichnung '{name}' existiert bereits.")
+
+        layout = QgsPrintLayout(self.project)
+        layout.initializeDefaults()
+        layout.setName(name)
+        self._current_layout = layout
+
+        page = layout.pageCollection().page(0)
+        page.setPageSize(QgsLayoutSize(page_width_mm, page_height_mm, MM))
+
+        map_left_mm = 10.0
+        map_top_mm = 10.0
+        map_right_mm = map_left_mm + map_width_mm
+        map_bottom_mm = map_top_mm + map_height_mm
+        kartenfenster_untere_rechte_ecke_mm = (map_right_mm, map_bottom_mm)
+
+        hauptkarte = self._create_map_item(
+            layout,
+            "hauptkarte",
+            map_left_mm,
+            map_top_mm,
+            map_width_mm,
+            map_height_mm,
+        )
+
+        fitted_extent = extent
+        if fit_extent_to_map:
+            fitted_extent = self._fit_extent_to_map_item(extent, map_width_mm, map_height_mm)
+
+        if fitted_extent is not None and hasattr(fitted_extent, "isNull") and callable(fitted_extent.isNull) and not fitted_extent.isNull():
+            try:
+                set_extent = getattr(hauptkarte, "setExtent", None)
+                if callable(set_extent):
+                    set_extent(fitted_extent)
+                else:
+                    hauptkarte.zoomToExtent(fitted_extent)
+            except Exception:
+                pass
+
+        if isinstance(plotmassstab, (int, float)) and plotmassstab > 0:
+            try:
+                hauptkarte.setScale(plotmassstab)
+            except Exception:
+                pass
+
+        # Atlas-Steuerung nur aktivieren, wenn Atlas tatsaechlich genutzt wird.
+        # Andernfalls bleiben Extent/Scale unveraendert (z.B. Canvas-Ausschnitt).
+        if atlas_driven:
+            set_atlas_driven_fn = getattr(hauptkarte, "setAtlasDriven", None)
+            if callable(set_atlas_driven_fn):
+                try:
+                    set_atlas_driven_fn(True)
+                except Exception:
+                    pass
+
+            set_atlas_scaling_mode = getattr(hauptkarte, "setAtlasScalingMode", None)
+            atlas_mode_auto = getattr(getattr(QgsLayoutItemMap, "AtlasScalingMode", object), "Auto", None)
+            if callable(set_atlas_scaling_mode) and atlas_mode_auto is not None:
+                try:
+                    set_atlas_scaling_mode(atlas_mode_auto)
+                except Exception:
+                    pass
+
+            set_atlas_margin = getattr(hauptkarte, "setAtlasMargin", None)
+            if callable(set_atlas_margin):
+                try:
+                    set_atlas_margin(self._calc_atlas_margin_percent(map_width_mm, map_height_mm))
+                except Exception:
+                    pass
+
+        set_frame_enabled = getattr(hauptkarte, "setFrameEnabled", None)
+        if callable(set_frame_enabled):
+            try:
+                set_frame_enabled(True)
+            except Exception:
+                pass
+
+        set_frame_stroke_width = getattr(hauptkarte, "setFrameStrokeWidth", None)
+        if callable(set_frame_stroke_width):
+            try:
+                self._set_item_frame_stroke_width(hauptkarte, self._FRAME_STROKE_WIDTH_MM)
+            except Exception:
+                pass
+
+        if thema and thema != "aktuell":
+            follow_theme = getattr(hauptkarte, "setFollowVisibilityPreset", None)
+            set_theme_name = getattr(hauptkarte, "setFollowVisibilityPresetName", None)
+            if callable(follow_theme):
+                try:
+                    follow_theme(True)
+                except Exception:
+                    pass
+            if callable(set_theme_name):
+                try:
+                    set_theme_name(thema)
+                except Exception:
+                    pass
+
+        set_keep_layer_set = getattr(hauptkarte, "setKeepLayerSet", None)
+        if callable(set_keep_layer_set):
+            try:
+                set_keep_layer_set(True)
+            except Exception:
+                pass
+
+        set_refresh_strategy = getattr(hauptkarte, "setRefreshStrategy", None)
+        if callable(set_refresh_strategy):
+            refresh_cache = (
+                getattr(hauptkarte, "RefreshLaterOnly", None)
+                or getattr(hauptkarte, "RefreshWhenRequested", None)
+                or 0
+            )
+            try:
+                set_refresh_strategy(refresh_cache)
+            except Exception:
+                pass
+
+        self._configure_hauptkarte_grids(hauptkarte)
+
+        self._setup_layout_objects_baufreigabe(
+            kartenfenster_untere_rechte_ecke_mm,
+            hauptkarte,
+            map_top_mm,
+            map_height_mm,
+        )
+
+        layout_manager.addLayout(layout)
+        self._current_layout = None
+        open_layout_designer(layout)
+        return layout
+
+    def _setup_layout_objects_baufreigabe(
+        self,
+        kartenfenster_untere_rechte_ecke_mm: tuple,
+        hauptkarte: Any,
+        map_top_mm: float,
+        map_height_mm: float,
+    ) -> None:
+        """Erstellt Legende, Quellenangabe und Kartenschild fuer Baufreigabe-Layout.
+        
+        Angepasst fuer 80mm Kartenschild statt 180mm.
+        """
+        if self._current_layout is None:
+            raise RuntimeError("Kein Layout aktiv.")
+
+        def _coords_rel_untere_rechte_ecke(rel_x_mm: float, rel_y_mm: float) -> tuple[float, float]:
+            return (
+                kartenfenster_untere_rechte_ecke_mm[0] + rel_x_mm,
+                kartenfenster_untere_rechte_ecke_mm[1] + rel_y_mm,
+            )
+
+        # Legende: 80mm Breite, hoehe adaptive wie Standard
+        legende_x = kartenfenster_untere_rechte_ecke_mm[0] + 10.0
+        legende_height_mm = max(map_height_mm - 122.0, 20.0)
+        legende_y = map_top_mm
+        legende = self._create_legend_item(
+            self._current_layout,
+            "legende",
+            hauptkarte,
+            legende_x,
+            legende_y,
+            width_mm=self._KARTENSCHILD_WIDTH_MM,
+            height_mm=legende_height_mm,
+            object_name="Legende",
+        )
+
+        legende_hoehe_mm = self._configure_legend_size(
+            legende,
+            width_limit_mm=self._KARTENSCHILD_WIDTH_MM,
+            column_count=1,
+            equal_column_width=False,
+        )
+
+        # Quellenangabe: 80mm Breite
+        quellenangabe_x, quellenangabe_y = _coords_rel_untere_rechte_ecke(10.0, -102.0)
+        quellenangabe_hoehe_mm = 20.0
+        quellenangabe_obere_y = quellenangabe_y - quellenangabe_hoehe_mm
+        legende_untere_y = legende_y + legende_hoehe_mm
+
+        if legende_untere_y > quellenangabe_obere_y:
+            self._configure_legend_size(
+                legende,
+                width_limit_mm=self._KARTENSCHILD_WIDTH_MM,
+                column_count=2,
+                equal_column_width=True,
+            )
+
+        self.add_text_label(
+            self._QUELLENANGABE_TEXT,
+            quellenangabe_x,
+            quellenangabe_y,
+            width_mm=self._KARTENSCHILD_WIDTH_MM,
+            height_mm=20.0,
+            text_format="Format_1",
+            html_mode=True,
+            expression_enabled=True,
+            object_name="Quellenangabe",
+        )
+
+        # Kartenschild: 80mm Breite
+        kartenschild_x, kartenschild_y = _coords_rel_untere_rechte_ecke(10.0, 0.0)
+        self._create_rectangle_box_item(
+            self._current_layout,
+            "Kartenschild",
+            kartenschild_x,
+            kartenschild_y,
+            self._KARTENSCHILD_WIDTH_MM,
+            self._KARTENSCHILD_HEIGHT_MM,
+            stroke_width_mm=self._FRAME_STROKE_WIDTH_MM,
+        )
+
+        # Kartenschild-Linien: 6 Trennlinien (Positionen gleich)
+        kartenschild_line_x, _ = _coords_rel_untere_rechte_ecke(10.0, 0.0)
+        kartenschild_line_offsets_y = (-10.0, -20.0, -30.0, -46.0)
+        for index, offset_y in enumerate(kartenschild_line_offsets_y, start=1):
+            _, line_y = _coords_rel_untere_rechte_ecke(0.0, offset_y)
+            self._create_rectangle_box_item(
+                self._current_layout,
+                f"Kartenschild_Linie_{index}",
+                kartenschild_line_x,
+                line_y,
+                self._KARTENSCHILD_WIDTH_MM,
+                0.0,
+                stroke_width_mm=0.1,
+            )
+
+        # Textfelder im Kartenschild ohne Skalierungslogik.
+        # Positionen werden bewusst als feste Werte gesetzt und bei Bedarf manuell angepasst.
+
+        labels = [
+            ("Teilnehmergemeinschaft [%@sn_bezeichnung %] [%@sn_name %]", 14.0, -48.0, 74.0, 8.0, "Format_1", "Herausgeber","Bottom"),
+            ("[% @sn_bezeichnung %]", 14.0, -41.0, 74.0, 4.0, "Format_1", "Bezeichnung_Flurbereinigung"),
+            ("[% @sn_name %]", 14.0, -32.0, 74.0, 5.0, "Format_2", "Name_Flurbereinigung"),
+            ("[% @sn_kartenname %]", 14.0, -23.0, 74.0, 6.0, "Format_3", "Kartenname"),
+            ("Ausgabedatum: [%format_date(now(), 'dd.MM.yyyy')%]", 14.0, -13.0, 74.0, 4.0, "Format_1", "Ausgabedatum"),
+            (
+                "Maßstab: 1 : [%round(map_get(item_variables('Hauptkarte'),'map_scale'),0)%]",
+                14.0,
+                -3.0,
+                74.0,
+                4.0,
+                "Format_1",
+                "Massstab",
+            ),
+
+        ]
+
+        for entry in labels:
+            text, rx, ry, w, h, fmt, obj_name = entry[:7]
+            v_align = entry[7] if len(entry) > 7 else "top"
+            x, y = _coords_rel_untere_rechte_ecke(rx, ry)
+            self.add_text_label(
+                text,
+                x,
+                y,
+                width_mm=w,
+                height_mm=h,
+                text_format=fmt,
+                expression_enabled=True,
+                object_name=obj_name,
+                v_align=v_align,
+            )
+
+    def _calc_atlas_margin_percent(self, map_width_mm: float, map_height_mm: float) -> float:
+        """Berechnet Atlas-Margin in Prozent, sodass etwa 10 mm Rand sichtbar bleiben."""
+        margin_mm = self._ATLAS_FRAME_MARGIN_MM
+        if map_width_mm <= 2 * margin_mm or map_height_mm <= 2 * margin_mm:
+            return 5.0
+
+        p_width = (100.0 * margin_mm) / (map_width_mm - 2.0 * margin_mm)
+        p_height = (100.0 * margin_mm) / (map_height_mm - 2.0 * margin_mm)
+        return max(p_width, p_height)

modules/pruef_ergebnis.py

@@ -74,6 +74,13 @@ PruefAktion = Literal[
     "stil_not_implemented",
     "datei_unbekannt",
     "needs_user_action",
+
+    # Verfahrensgebiet-Editoperationen
+    "verfahrensgebiet_layer_existiert",  # bestehender Layer → Nutzerentscheidung
+    "verfahrensgebiet_ergaenzen",        # Flurstücke hinzufügen
+    "verfahrensgebiet_entfernen",        # Flurstücke entfernen
+    "verfahrensgebiet_ersetzen",         # Verfahrensgebiet vollständig ersetzen
+    "verfahrensgebiet_abbrechen",        # Nutzer hat abgebrochen
 ]
 
 

modules/stilpruefer.py

@@ -5,6 +5,7 @@ Die Anwendung erfolgt später über eine Aktion.
 """
 
 import os
+from pathlib import Path
 
 from sn_basis.functions.os_wrapper import is_absolute_path
 from sn_basis.functions.sys_wrapper import get_plugin_root, file_exists, join_path
@@ -43,7 +44,7 @@ class Stilpruefer:
 
         pfad = str(stil_pfad)
 
-        if not is_absolute_path(pfad):
+        if not is_absolute_path(pfad) and not pfad.startswith(("/", "\\")):
             plugin_root = get_plugin_root()
             pfad = str(join_path(plugin_root, "sn_plan41", "assets", pfad))
 
@@ -55,7 +56,7 @@ class Stilpruefer:
                 ok=False,
                 meldung=f"Die Stil-Datei '{stil_pfad}' wurde nicht gefunden.",
                 aktion="datei_nicht_gefunden",
-                kontext=pfad,
+                kontext=Path(pfad),
             )
 
         # -----------------------------------------------------
@@ -66,7 +67,7 @@ class Stilpruefer:
                 ok=False,
                 meldung="Die Stil-Datei muss die Endung '.qml' haben.",
                 aktion="falsche_endung",
-                kontext=pfad,
+                kontext=Path(pfad),
             )
 
         # -----------------------------------------------------
@@ -76,5 +77,5 @@ class Stilpruefer:
             ok=True,
             meldung="Stil-Datei ist gültig.",
             aktion="stil_anwendbar",
-            kontext=pfad,
+            kontext=Path(pfad),
         )

tests/__init__.py

@@ -1 +1,4 @@
-#Testordner
+"""
+sn_basis/tests – Test-Suite für das sn_basis Plugin.
+Enthält Unit-Tests und Integrationstests für alle Module.
+"""

tests/test_datagrabber.py

@@ -0,0 +1,127 @@
+import unittest
+from typing import Any, cast
+from unittest.mock import patch
+
+from sn_basis.modules.DataGrabber import DataGrabber
+from sn_basis.modules.pruef_ergebnis import pruef_ergebnis
+
+
+class _DummyPruefmanager:
+    def verarbeite(self, ergebnis: Any):
+        return ergebnis
+
+
+class TestDataGrabber(unittest.TestCase):
+
+    def _make_grabber(self) -> DataGrabber:
+        return DataGrabber(pruefmanager=cast(Any, _DummyPruefmanager()))
+
+    @patch("sn_basis.modules.DataGrabber.Dateipruefer")
+    def test_analyze_source_type_detects_excel(self, mock_dateipruefer):
+        mock_dateipruefer.return_value.pruefe.return_value = pruef_ergebnis(
+            ok=True,
+            meldung="ok",
+            aktion="ok",
+            kontext="C:/tmp/list.xlsx",
+        )
+        grabber = self._make_grabber()
+
+        source_type, result = grabber.analyze_source_type("C:/tmp/list.xlsx")
+
+        self.assertEqual(source_type, "excel")
+        self.assertTrue(result.ok)
+
+    @patch("sn_basis.modules.DataGrabber.Dateipruefer")
+    def test_analyze_source_type_returns_unknown_filetype(self, mock_dateipruefer):
+        mock_dateipruefer.return_value.pruefe.return_value = pruef_ergebnis(
+            ok=True,
+            meldung="ok",
+            aktion="ok",
+            kontext="C:/tmp/file.txt",
+        )
+        grabber = self._make_grabber()
+
+        source_type, _result = grabber.analyze_source_type("C:/tmp/file.txt")
+
+        self.assertEqual(source_type, "unbekannter_dateityp")
+
+    @patch("sn_basis.modules.DataGrabber.Linkpruefer")
+    @patch("sn_basis.modules.DataGrabber.Dateipruefer")
+    def test_analyze_source_type_detects_service_when_file_check_fails(self, mock_dateipruefer, mock_linkpruefer):
+        mock_dateipruefer.return_value.pruefe.return_value = pruef_ergebnis(
+            ok=False,
+            meldung="missing",
+            aktion="datei_nicht_gefunden",
+            kontext=None,
+        )
+        mock_linkpruefer.return_value.pruefe.return_value = pruef_ergebnis(
+            ok=True,
+            meldung="ok",
+            aktion="url_ok",
+            kontext="https://example.test",
+        )
+        grabber = self._make_grabber()
+
+        source_type, result = grabber.analyze_source_type("https://example.test")
+
+        self.assertEqual(source_type, "dienst")
+        self.assertTrue(result.ok)
+
+    @patch("sn_basis.modules.DataGrabber.Linkpruefer")
+    @patch("sn_basis.modules.DataGrabber.Dateipruefer")
+    def test_analyze_source_type_returns_unbekannte_quelle_on_full_failure(self, mock_dateipruefer, mock_linkpruefer):
+        mock_dateipruefer.return_value.pruefe.return_value = pruef_ergebnis(
+            ok=False,
+            meldung="missing",
+            aktion="datei_nicht_gefunden",
+            kontext=None,
+        )
+        mock_linkpruefer.return_value.pruefe.return_value = pruef_ergebnis(
+            ok=False,
+            meldung="bad",
+            aktion="url_nicht_erreichbar",
+            kontext=None,
+        )
+        grabber = self._make_grabber()
+
+        source_type, result = grabber.analyze_source_type("broken-input")
+
+        self.assertEqual(source_type, "unbekannte_quelle")
+        self.assertFalse(result.ok)
+
+    @patch.object(DataGrabber, "analyze_source_type")
+    @patch.object(DataGrabber, "_process_excel_source")
+    def test_run_returns_success_summary_with_valid_rows(self, mock_process_excel, mock_analyze):
+        mock_analyze.return_value = (
+            "excel",
+            pruef_ergebnis(ok=True, meldung="ok", aktion="ok", kontext=None),
+        )
+        mock_process_excel.return_value = (
+            {"rows": [{"ident": "A1"}]},
+            [],
+        )
+
+        grabber = self._make_grabber()
+        source_dict, summary = grabber.run("C:/tmp/list.xlsx")
+
+        self.assertEqual(len(source_dict["rows"]), 1)
+        self.assertTrue(summary.ok)
+        self.assertEqual(summary.aktion, "ok")
+
+    @patch.object(DataGrabber, "analyze_source_type")
+    def test_run_returns_failure_summary_without_rows(self, mock_analyze):
+        mock_analyze.return_value = (
+            "unbekannte_quelle",
+            pruef_ergebnis(ok=False, meldung="bad", aktion="unbekannte_quelle", kontext=None),
+        )
+
+        grabber = self._make_grabber()
+        source_dict, summary = grabber.run("???")
+
+        self.assertEqual(source_dict, {})
+        self.assertFalse(summary.ok)
+        self.assertEqual(summary.aktion, "keine_validen_eintraege")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_print_layout.py

@@ -0,0 +1,182 @@
+import unittest
+from unittest.mock import patch
+
+from sn_basis.functions.qgiscore_wrapper import (
+    MAP_GRID_ANNOTATION_DISPLAY_HIDE_ALL,
+    MAP_GRID_ANNOTATION_DISPLAY_SHOW_X,
+    MAP_GRID_ANNOTATION_DISPLAY_SHOW_Y,
+    MAP_GRID_BORDER_BOTTOM,
+    MAP_GRID_BORDER_LEFT,
+    MAP_GRID_BORDER_RIGHT,
+    MAP_GRID_BORDER_TOP,
+    MAP_GRID_FRAME_STYLE_INTERIOR_TICKS,
+    MAP_GRID_STYLE_FRAME_ANNOTATIONS,
+    TEXT_BACKGROUND_SHAPE_RECTANGLE,
+    TEXT_BACKGROUND_SIZE_BUFFER,
+    TEXT_RENDER_UNIT_MILLIMETERS,
+    TEXT_RENDER_UNIT_POINTS,
+    QgsLayoutItemLegend,
+    QgsLayoutItemMap,
+    QgsPrintLayout,
+    QgsProject,
+)
+from sn_basis.modules.print_layout import PrintLayout
+
+
+class _FakeExtent:
+    def isNull(self) -> bool:
+        return False
+
+
+class _FakeLegendForResize:
+    def __init__(self) -> None:
+        self.last_resize = None
+
+    def setLocked(self, _enabled: bool) -> None:
+        pass
+
+    def setColumnCount(self, _count: int) -> None:
+        pass
+
+    def setEqualColumnWidth(self, _enabled: bool) -> None:
+        pass
+
+    def refresh(self) -> None:
+        pass
+
+    def adjustBoxSize(self) -> None:
+        pass
+
+    def attemptResize(self, size) -> None:
+        self.last_resize = size
+
+
+class TestPrintLayout(unittest.TestCase):
+
+    def test_create_legend_item_links_map_and_enables_map_filtering(self):
+        project = QgsProject.instance()
+        print_layout = PrintLayout(project=project)
+        layout = QgsPrintLayout(project)
+        linked_map = QgsLayoutItemMap(layout)
+
+        legend = print_layout._create_legend_item(
+            layout,
+            "legende",
+            linked_map,
+            10.0,
+            20.0,
+            width_mm=50.0,
+            height_mm=30.0,
+        )
+
+        self.assertIs(legend.linked_map, linked_map)
+        self.assertTrue(legend.auto_update_model)
+        self.assertTrue(legend.legend_filter_by_map_enabled)
+
+    def test_create_legend_item_does_not_copy_project_layers_into_legend_model(self):
+        project = QgsProject.instance()
+        print_layout = PrintLayout(project=project)
+        layout = QgsPrintLayout(project)
+        linked_map = QgsLayoutItemMap(layout)
+
+        legend = print_layout._create_legend_item(
+            layout,
+            "legende",
+            linked_map,
+            10.0,
+            20.0,
+        )
+
+        root_group = legend.model().rootGroup()
+        self.assertEqual(root_group.layers, [])
+
+    def test_configure_legend_size_uses_content_adaptive_size(self):
+        project = QgsProject.instance()
+        print_layout = PrintLayout(project=project)
+        legend = _FakeLegendForResize()
+
+        with patch.object(print_layout, "_get_item_size_mm", return_value=(95.0, 33.0)):
+            height = print_layout._configure_legend_size(
+                legend,
+                width_limit_mm=180.0,
+                column_count=2,
+                equal_column_width=True,
+            )
+
+        self.assertIsNone(legend.last_resize)
+        self.assertEqual(height, 33.0)
+
+    def test_configure_hauptkarte_grids_uses_wrapper_constants(self):
+        project = QgsProject.instance()
+        print_layout = PrintLayout(project=project)
+        layout = QgsPrintLayout(project)
+        hauptkarte = QgsLayoutItemMap(layout)
+
+        print_layout._configure_hauptkarte_grids(hauptkarte)
+
+        grid_stack = hauptkarte.grids()
+        grids = grid_stack.asList()
+        self.assertEqual(len(grids), 1)
+
+        frame_grid = grids[0]
+
+        self.assertEqual(frame_grid.style, MAP_GRID_STYLE_FRAME_ANNOTATIONS)
+        self.assertEqual(frame_grid.frame_style, MAP_GRID_FRAME_STYLE_INTERIOR_TICKS)
+        self.assertTrue(frame_grid.annotation_enabled)
+        self.assertEqual(frame_grid.annotation_display[MAP_GRID_BORDER_LEFT], MAP_GRID_ANNOTATION_DISPLAY_HIDE_ALL)
+        self.assertEqual(frame_grid.annotation_display[MAP_GRID_BORDER_TOP], MAP_GRID_ANNOTATION_DISPLAY_HIDE_ALL)
+        self.assertEqual(frame_grid.annotation_display[MAP_GRID_BORDER_RIGHT], MAP_GRID_ANNOTATION_DISPLAY_SHOW_Y)
+        self.assertEqual(frame_grid.annotation_display[MAP_GRID_BORDER_BOTTOM], MAP_GRID_ANNOTATION_DISPLAY_SHOW_X)
+
+        text_format = frame_grid.annotation_text_format
+        self.assertIsNotNone(text_format)
+        self.assertEqual(getattr(text_format, "size", None), 10)
+        self.assertEqual(getattr(text_format, "size_unit", None), TEXT_RENDER_UNIT_POINTS)
+
+        background = getattr(text_format, "background", None)
+        self.assertIsNotNone(background)
+        self.assertTrue(getattr(background, "enabled", False))
+        self.assertEqual(getattr(background, "shape_type", None), TEXT_BACKGROUND_SHAPE_RECTANGLE)
+        self.assertEqual(getattr(background, "size_type", None), TEXT_BACKGROUND_SIZE_BUFFER)
+        self.assertEqual(getattr(background, "size_unit", None), TEXT_RENDER_UNIT_MILLIMETERS)
+        self.assertEqual(getattr(background, "offset_unit", None), TEXT_RENDER_UNIT_MILLIMETERS)
+        offset = getattr(background, "offset", None)
+        self.assertIsNotNone(offset)
+        if isinstance(offset, tuple):
+            self.assertEqual(offset[1], -1.0)
+        else:
+            y_value = getattr(offset, "y", None)
+            if callable(y_value):
+                self.assertEqual(y_value(), -1.0)
+            else:
+                self.assertEqual(getattr(offset, "y", None), -1.0)
+
+    @patch("sn_basis.modules.print_layout.open_layout_designer")
+    def test_create_single_page_layout_keeps_legend_linked_to_hauptkarte_and_theme(self, _mock_open_designer):
+        project = QgsProject.instance()
+        print_layout = PrintLayout(project=project)
+
+        layout = print_layout.create_single_page_layout(
+            name="Testlayout",
+            page_width_mm=420.0,
+            page_height_mm=297.0,
+            map_width_mm=200.0,
+            map_height_mm=150.0,
+            extent=_FakeExtent(),
+            plotmassstab=5000.0,
+            thema="Thema A",
+        )
+
+        hauptkarte = next(item for item in layout.items if isinstance(item, QgsLayoutItemMap))
+        legende = next(item for item in layout.items if isinstance(item, QgsLayoutItemLegend))
+
+        self.assertTrue(hauptkarte.follow_visibility_preset)
+        self.assertEqual(hauptkarte.follow_visibility_preset_name, "Thema A")
+        self.assertTrue(hauptkarte.keep_layer_set)
+        self.assertIs(legende.linked_map, hauptkarte)
+        self.assertTrue(legende.auto_update_model)
+        self.assertTrue(legende.legend_filter_by_map_enabled)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_print_logic.py

@@ -0,0 +1,191 @@
+import unittest
+from unittest.mock import MagicMock, patch
+
+from sn_basis.modules.print_logic import (
+    PrintLogic,
+    DRUCKBEREICH_RECHTECK,
+    DRUCKBEREICH_WIE_KARTENFENSTER,
+    ENDLOSROLLE_MAX_BREITE_MM,
+)
+
+
+class _FakeExtent:
+    def __init__(self, width: float = 100.0, height: float = 80.0) -> None:
+        self._width = width
+        self._height = height
+
+    def width(self) -> float:
+        return self._width
+
+    def height(self) -> float:
+        return self._height
+
+    def isNull(self) -> bool:
+        return False
+
+
+class _FakeCanvas:
+    def __init__(self, extent: object | None) -> None:
+        self._extent = extent
+
+    def extent(self) -> object | None:
+        return self._extent
+
+
+class TestPrintLogic(unittest.TestCase):
+
+    def setUp(self) -> None:
+        self.logic = PrintLogic(pruefmanager=MagicMock())
+
+    def test_get_baufreigabe_page_dimensions_prefers_a4_for_small_extent(self):
+        din_format, page_w, page_h, map_w, map_h, fallback = self.logic._get_baufreigabe_page_dimensions(80.0, 120.0)
+
+        self.assertEqual(din_format, "DIN A4")
+        self.assertEqual((page_w, page_h), (297.0, 210.0))
+        self.assertEqual((map_w, map_h), (187.0, 190.0))
+        self.assertFalse(fallback)
+
+    def test_get_baufreigabe_page_dimensions_escalates_to_a3(self):
+        din_format, page_w, page_h, map_w, map_h, fallback = self.logic._get_baufreigabe_page_dimensions(200.0, 180.0)
+
+        self.assertEqual(din_format, "DIN A3")
+        self.assertEqual((page_w, page_h), (420.0, 297.0))
+        self.assertEqual((map_w, map_h), (310.0, 277.0))
+        self.assertFalse(fallback)
+
+    def test_get_baufreigabe_page_dimensions_respects_a4_as_maximum_with_fallback(self):
+        din_format, page_w, page_h, map_w, map_h, fallback = self.logic._get_baufreigabe_page_dimensions(
+            200.0,
+            180.0,
+            max_format="DIN A4",
+        )
+
+        self.assertEqual(din_format, "DIN A4")
+        self.assertEqual((page_w, page_h), (297.0, 210.0))
+        self.assertEqual((map_w, map_h), (187.0, 190.0))
+        self.assertTrue(fallback)
+
+    def test_get_baufreigabe_page_dimensions_falls_back_to_a3_for_oversize_extent(self):
+        din_format, page_w, page_h, map_w, map_h, fallback = self.logic._get_baufreigabe_page_dimensions(400.0, 300.0)
+
+        self.assertEqual(din_format, "DIN A3")
+        self.assertEqual((page_w, page_h), (420.0, 297.0))
+        self.assertEqual((map_w, map_h), (310.0, 277.0))
+        self.assertTrue(fallback)
+
+    def test_select_standard_page_layout_uses_a4_as_minimum_sheet(self):
+        selected = self.logic._select_standard_page_layout(60.0, 100.0, max_format="DIN A3")
+
+        self.assertEqual(selected, (297.0, 210.0, 87.0, 190.0))
+
+    def test_select_standard_page_layout_limits_hauptkarte_to_a3(self):
+        selected = self.logic._select_standard_page_layout(120.0, 240.0, max_format="DIN A3")
+
+        self.assertEqual(selected, (420.0, 297.0, 210.0, 277.0))
+
+    def test_select_standard_page_layout_returns_none_if_a3_is_too_small(self):
+        selected = self.logic._select_standard_page_layout(260.0, 280.0, max_format="DIN A3")
+
+        self.assertIsNone(selected)
+
+    def test_get_standard_layout_dimensions_uses_a4_and_forces_fit_for_small_extent(self):
+        page_w, page_h, map_w, map_h, force_fit = self.logic._get_standard_layout_dimensions(
+            60.0,
+            100.0,
+            max_format="DIN A3",
+            formfaktor=False,
+        )
+
+        self.assertEqual((page_w, page_h), (297.0, 210.0))
+        self.assertEqual((map_w, map_h), (87.0, 190.0))
+        self.assertTrue(force_fit)
+
+    def test_get_standard_layout_dimensions_caps_endlosrolle_width_at_2000_mm(self):
+        page_w, page_h, map_w, map_h, force_fit = self.logic._get_standard_layout_dimensions(
+            2500.0,
+            100.0,
+            max_format="DIN A0",
+            formfaktor=True,
+        )
+
+        self.assertEqual(page_w, ENDLOSROLLE_MAX_BREITE_MM)
+        self.assertEqual(page_h, 210.0)
+        self.assertEqual((map_w, map_h), (2500.0, 190.0))
+        self.assertTrue(force_fit)
+
+    def test_apply_standard_minimum_a4_fallback_for_small_page(self):
+        page_w, page_h, map_w, map_h, forced = self.logic._apply_standard_minimum_a4_fallback(
+            250.0,
+            180.0,
+            40.0,
+            20.0,
+        )
+
+        self.assertTrue(forced)
+        self.assertEqual((page_w, page_h), (297.0, 210.0))
+        self.assertEqual((map_w, map_h), (87.0, 190.0))
+
+    def test_apply_standard_minimum_a4_fallback_keeps_large_page(self):
+        page_w, page_h, map_w, map_h, forced = self.logic._apply_standard_minimum_a4_fallback(
+            420.0,
+            297.0,
+            210.0,
+            277.0,
+        )
+
+        self.assertFalse(forced)
+        self.assertEqual((page_w, page_h), (420.0, 297.0))
+        self.assertEqual((map_w, map_h), (210.0, 277.0))
+
+    def test_does_plot_fit_page_true_for_standard_a4(self):
+        fits = self.logic._does_plot_fit_page(297.0, 210.0, 87.0, 190.0, 210.0, 20.0)
+
+        self.assertTrue(fits)
+
+    def test_does_plot_fit_page_false_if_objects_exceed_page(self):
+        fits = self.logic._does_plot_fit_page(297.0, 210.0, 120.0, 190.0, 210.0, 20.0)
+
+        self.assertFalse(fits)
+
+    @patch("sn_basis.modules.print_logic.set_variable")
+    def test_set_druckbereich_accepts_wie_kartenfenster(self, mock_set_variable):
+        self.logic.set_druckbereich_for_auswahl(DRUCKBEREICH_WIE_KARTENFENSTER)
+
+        mock_set_variable.assert_called_once_with("druckbereich", DRUCKBEREICH_WIE_KARTENFENSTER, scope="project")
+
+    @patch("sn_basis.modules.print_logic.iface")
+    def test_get_canvas_extent_returns_valid_extent(self, mock_iface):
+        extent = _FakeExtent(120.0, 90.0)
+        mock_iface.mapCanvas.return_value = _FakeCanvas(extent)
+
+        result = self.logic._get_canvas_extent()
+
+        self.assertIs(result, extent)
+
+    @patch.object(PrintLogic, "_buffer_extent")
+    @patch.object(PrintLogic, "_get_canvas_extent")
+    def test_resolve_extent_uses_canvas_extent_without_buffer(self, mock_get_canvas_extent, mock_buffer_extent):
+        extent = _FakeExtent(120.0, 90.0)
+        mock_get_canvas_extent.return_value = extent
+
+        result_extent, result_layer = self.logic._resolve_extent(None, DRUCKBEREICH_WIE_KARTENFENSTER, 5000.0)
+
+        self.assertIs(result_extent, extent)
+        self.assertIsNone(result_layer)
+        mock_buffer_extent.assert_not_called()
+
+    @patch.object(PrintLogic, "_buffer_extent")
+    @patch.object(PrintLogic, "_get_druckrechteck_extent")
+    def test_resolve_extent_uses_rectangle_extent_without_buffer(self, mock_get_rect_extent, mock_buffer_extent):
+        extent = _FakeExtent(120.0, 90.0)
+        mock_get_rect_extent.return_value = extent
+
+        result_extent, result_layer = self.logic._resolve_extent(None, DRUCKBEREICH_RECHTECK, 5000.0)
+
+        self.assertIs(result_extent, extent)
+        self.assertIsNone(result_layer)
+        mock_buffer_extent.assert_not_called()
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_pruefmanager.py

@@ -141,6 +141,40 @@ class TestPruefmanager(unittest.TestCase):
         self.assertFalse(entscheidung.ok)
         self.assertEqual(entscheidung.aktion, "unbekannt")
 
+    @patch("sn_basis.modules.Pruefmanager.ask_overwrite_append_cancel_custom", return_value="overwrite")
+    def test_datei_existiert_overwrite(self, _mock_choice):
+        ergebnis = pruef_ergebnis(False, "Datei existiert", "datei_existiert", "C:/tmp/v.gpkg")
+        entscheidung = self.manager.verarbeite(ergebnis)
+
+        self.assertTrue(entscheidung.ok)
+        self.assertEqual(entscheidung.aktion, "datei_existiert_ueberschreiben")
+        self.assertEqual(entscheidung.kontext, "C:/tmp/v.gpkg")
+
+    @patch("sn_basis.modules.Pruefmanager.ask_overwrite_append_cancel_custom", return_value="append")
+    def test_datei_existiert_append(self, _mock_choice):
+        ergebnis = pruef_ergebnis(False, "Datei existiert", "datei_existiert", "C:/tmp/v.gpkg")
+        entscheidung = self.manager.verarbeite(ergebnis)
+
+        self.assertTrue(entscheidung.ok)
+        self.assertEqual(entscheidung.aktion, "datei_existiert_anhaengen")
+
+    @patch("sn_basis.modules.Pruefmanager.ask_overwrite_append_cancel_custom", return_value="cancel")
+    def test_datei_existiert_cancel(self, _mock_choice):
+        ergebnis = pruef_ergebnis(False, "Datei existiert", "datei_existiert", "C:/tmp/v.gpkg")
+        entscheidung = self.manager.verarbeite(ergebnis)
+
+        self.assertTrue(entscheidung.ok)
+        self.assertEqual(entscheidung.aktion, "datei_existiert_ueberspringen")
+
+    def test_datei_existiert_in_non_qgis_mode_returns_input(self):
+        manager = Pruefmanager(ui_modus="test")
+        ergebnis = pruef_ergebnis(False, "Datei existiert", "datei_existiert", "C:/tmp/v.gpkg")
+
+        entscheidung = manager.verarbeite(ergebnis)
+
+        self.assertFalse(entscheidung.ok)
+        self.assertEqual(entscheidung.aktion, "datei_existiert")
+
 
 if __name__ == "__main__":
     unittest.main()

tests/test_settings_logic.py

@@ -55,6 +55,32 @@ class TestSettingsLogic(unittest.TestCase):
         self.assertIn("gemeinden", saved_keys)
         self.assertNotIn("unbekannt", saved_keys)
 
+    @patch("sn_basis.functions.settings_logic.get_variable")
+    def test_load_handles_partial_values_with_empty_fallback(self, mock_get):
+        values = {
+            "amt": "A1",
+            "behoerde": "",
+            "landkreis_user": "L1",
+        }
+        mock_get.side_effect = lambda key, scope="project": values.get(key, "")
+
+        logic = SettingsLogic()
+        daten = logic.load()
+
+        self.assertEqual(daten["amt"], "A1")
+        self.assertEqual(daten["behoerde"], "")
+        self.assertEqual(daten["landkreis_user"], "L1")
+        self.assertEqual(daten["sachgebiet"], "")
+
+    @patch("sn_basis.functions.settings_logic.set_variable")
+    def test_save_empty_string_value_is_persisted(self, mock_set):
+        logic = SettingsLogic()
+
+        logic.save({"amt": "", "behoerde": "B2"})
+
+        mock_set.assert_any_call("amt", "", scope="project")
+        mock_set.assert_any_call("behoerde", "B2", scope="project")
+
 
 if __name__ == "__main__":
     unittest.main()

tests/test_variable_wrapper.py

@@ -0,0 +1,78 @@
+import unittest
+from unittest.mock import patch
+
+from sn_basis.functions import variable_wrapper
+
+
+class _Scope:
+    def __init__(self, value: str):
+        self._value = value
+
+    def variable(self, _name: str) -> str:
+        return self._value
+
+
+class TestVariableWrapper(unittest.TestCase):
+
+    @patch("sn_basis.functions.variable_wrapper.QgsProject.instance")
+    @patch("sn_basis.functions.variable_wrapper.QgsExpressionContextUtils.setProjectVariable")
+    @patch("sn_basis.functions.variable_wrapper.QgsExpressionContextUtils.projectScope")
+    def test_set_variable_project_noop_write_is_skipped(
+        self,
+        mock_project_scope,
+        mock_set_project_variable,
+        mock_project_instance,
+    ):
+        mock_project_instance.return_value = object()
+        mock_project_scope.return_value = _Scope("layer_1")
+
+        variable_wrapper.set_variable("verfahrensgebiet_layer", "layer_1", scope="project")
+
+        mock_set_project_variable.assert_not_called()
+
+    @patch("sn_basis.functions.variable_wrapper.QgsProject.instance")
+    @patch("sn_basis.functions.variable_wrapper.QgsExpressionContextUtils.setProjectVariable")
+    @patch("sn_basis.functions.variable_wrapper.QgsExpressionContextUtils.projectScope")
+    def test_set_variable_project_changed_value_is_written(
+        self,
+        mock_project_scope,
+        mock_set_project_variable,
+        mock_project_instance,
+    ):
+        fake_project = object()
+        mock_project_instance.return_value = fake_project
+        mock_project_scope.return_value = _Scope("old_value")
+
+        variable_wrapper.set_variable("verfahrensgebiet_layer", "new_value", scope="project")
+
+        mock_set_project_variable.assert_called_once_with(
+            fake_project,
+            "sn_verfahrensgebiet_layer",
+            "new_value",
+        )
+
+    @patch("sn_basis.functions.variable_wrapper.QgsExpressionContextUtils.setGlobalVariable")
+    def test_set_variable_global_writes_prefixed_name(self, mock_set_global):
+        variable_wrapper.set_variable("verfahrensnummer", "123", scope="global")
+
+        mock_set_global.assert_called_once_with("sn_verfahrensnummer", "123")
+
+    @patch("sn_basis.functions.variable_wrapper.QgsExpressionContextUtils.globalScope")
+    def test_get_variable_global_returns_empty_string_fallback(self, mock_global_scope):
+        mock_global_scope.return_value = _Scope("")
+
+        value = variable_wrapper.get_variable("nicht_vorhanden", scope="global")
+
+        self.assertEqual(value, "")
+
+    def test_get_variable_invalid_scope_raises(self):
+        with self.assertRaises(ValueError):
+            variable_wrapper.get_variable("foo", scope="invalid")
+
+    def test_set_variable_invalid_scope_raises(self):
+        with self.assertRaises(ValueError):
+            variable_wrapper.set_variable("foo", "bar", scope="invalid")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_verfahrensgebiet_manager.py

@@ -0,0 +1,68 @@
+import unittest
+from unittest.mock import patch
+
+from sn_basis.functions import verfahrensgebiet_manager
+
+
+class _Scope:
+    def __init__(self, value: str):
+        self._value = value
+
+    def variable(self, _name: str) -> str:
+        return self._value
+
+
+class TestVerfahrensgebietManager(unittest.TestCase):
+
+    @patch("sn_basis.functions.verfahrensgebiet_manager.get_variable", return_value="layer_123")
+    def test_get_verfahrensgebiet_layer_id_returns_value(self, _mock_get_variable):
+        result = verfahrensgebiet_manager.get_verfahrensgebiet_layer_id()
+
+        self.assertEqual(result, "layer_123")
+
+    @patch("sn_basis.functions.verfahrensgebiet_manager.get_variable", return_value="")
+    def test_get_verfahrensgebiet_layer_id_returns_none_for_empty_value(self, _mock_get_variable):
+        result = verfahrensgebiet_manager.get_verfahrensgebiet_layer_id()
+
+        self.assertIsNone(result)
+
+    @patch("sn_basis.functions.verfahrensgebiet_manager.set_variable")
+    def test_set_verfahrensgebiet_layer_id_writes_project_variable(self, mock_set_variable):
+        verfahrensgebiet_manager.set_verfahrensgebiet_layer_id("layer_abc")
+
+        mock_set_variable.assert_called_once_with("verfahrensgebiet_layer", "layer_abc", scope="project")
+
+    @patch("sn_basis.functions.verfahrensgebiet_manager._find_verfahrensgebiet_layer")
+    @patch("sn_basis.functions.variable_wrapper.QgsProject.instance")
+    @patch("sn_basis.functions.variable_wrapper.QgsExpressionContextUtils.setProjectVariable")
+    @patch("sn_basis.functions.variable_wrapper.QgsExpressionContextUtils.projectScope")
+    def test_update_without_layer_does_not_write_when_already_empty(
+        self,
+        mock_project_scope,
+        mock_set_project_variable,
+        mock_project_instance,
+        mock_find_layer,
+    ):
+        mock_find_layer.return_value = (None, None)
+        mock_project_instance.return_value = object()
+        mock_project_scope.return_value = _Scope("")
+
+        result = verfahrensgebiet_manager._update_verfahrensgebiet_from_project()
+
+        self.assertFalse(result)
+        mock_set_project_variable.assert_not_called()
+
+    @patch("sn_basis.functions.verfahrensgebiet_manager._find_verfahrensgebiet_layer")
+    @patch("sn_basis.functions.verfahrensgebiet_manager.set_variable")
+    def test_update_with_layer_writes_variable(self, mock_set_variable, mock_find_layer):
+        mock_layer = object()
+        mock_find_layer.return_value = (mock_layer, "layer_99")
+
+        result = verfahrensgebiet_manager._update_verfahrensgebiet_from_project()
+
+        self.assertTrue(result)
+        mock_set_variable.assert_called_once_with("verfahrensgebiet_layer", "layer_99", scope="project")
+
+
+if __name__ == "__main__":
+    unittest.main()

ui/__init__.py

@@ -0,0 +1,4 @@
+"""
+sn_basis/ui – Benutzeroberflächen-Module für sn_basis.
+Enthält Dock-Manager, Navigation und einzelne Tabs.
+"""

ui/base_dockwidget.py

@@ -99,6 +99,20 @@ class BaseDockWidget(QDockWidget):
         Wird aufgerufen, wenn das Dock geschlossen wird.
         Setzt die zugehörige Toolbar-Action zurück.
         """
+        try:
+            tab_widget = self.widget()
+            if tab_widget and hasattr(tab_widget, "count") and hasattr(tab_widget, "widget"):
+                for index in range(tab_widget.count()):
+                    tab = tab_widget.widget(index)
+                    cleanup = getattr(tab, "cleanup", None)
+                    if callable(cleanup):
+                        try:
+                            cleanup()
+                        except Exception:
+                            pass
+        except Exception:
+            pass
+
         try:
             if self.action:
                 self.action.setChecked(False)

ui/tabs/__init__.py

@@ -0,0 +1,9 @@
+"""
+sn_basis/ui/tabs – Tab-Widgets für die sn_basis Benutzeroberfläche.
+Stellt print_tab und settings_tab bereit.
+"""
+
+# from sn_basis.ui.tabs.print_tab import PrintTab
+# from sn_basis.ui.tabs.settings_tab import SettingsTab
+
+# __all__ = ["PrintTab", "SettingsTab"]

ui/tabs/print_tab.py

@@ -0,0 +1,708 @@
+"""
+sn_basis/ui/tabs/print_tab.py - Zentraler Druck-Tab fuer sn-Plugins.
+"""
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from sn_basis.functions.qt_wrapper import (
+    QWidget,
+    QVBoxLayout,
+    QLabel,
+    QComboBox,
+    QCheckBox,
+    QHBoxLayout,
+    QPushButton,
+    QToolButton,
+    ToolButtonTextBesideIcon,
+    ArrowDown,
+    ArrowRight,
+)
+from sn_basis.functions.qgiscore_wrapper import QgsProject, QgsMapLayerProxyModel
+from sn_basis.functions.qgisui_wrapper import iface, QgsMapLayerComboBox
+from sn_basis.functions.variable_wrapper import get_variable, set_variable
+from sn_basis.modules.Pruefmanager import Pruefmanager
+from sn_basis.modules.DataGrabber import DataGrabber
+from sn_basis.modules.print_logic import (
+    PrintLogic,
+    MASSSTAB_WIE_KARTENFENSTER,
+    PLOTMASSSTAB_BY_AUSWAHL,
+    THEMA_WIE_KARTENFENSTER,
+    DIN_GROESSEN,
+    DIN_STANDARD,
+    DRUCKBEREICH_VAR,
+    DRUCKPUFFER_VAR,
+    DRUCKPUFFER_STANDARD_CM,
+    DRUCKBEREICH_VERFAHRENSGEBIET,
+    DRUCKBEREICH_WIE_KARTENFENSTER,
+    DRUCKBEREICH_AKTUELLE_AUSWAHL,
+    DRUCKBEREICH_RECHTECK,
+)
+
+
+KARTENNAME_VAR = "tab_b_kartenname"
+KARTENNAME_PLACEHOLDER = "Kartenname waehlen"
+KARTENNAME_38 = "§38"
+KARTENNAME_41 = "§41"
+KARTENNAME_BAUFREIGABE = "Anlage zur Baufreigabe"
+MASSSTAB_VAR = "tab_b_massstab"
+THEMA_VAR = "tab_b_thema"
+ZIELGROESSE_UI_VAR = "tab_b_zielgroesse"
+FORMFAKTOR_UI_VAR = "tab_b_formfaktor"
+ATLAS_ERZEUGEN_VAR = "tab_b_atlas_erzeugen"
+DRUCKBEREICH_OPTIONEN = [
+    DRUCKBEREICH_VERFAHRENSGEBIET,
+    DRUCKBEREICH_WIE_KARTENFENSTER,
+    DRUCKBEREICH_AKTUELLE_AUSWAHL,
+    DRUCKBEREICH_RECHTECK,
+]
+
+
+class PrintTab(QWidget):
+    """UI-Klasse fuer den zentralen Druck-Tab."""
+
+    tab_title = "Druck"
+
+    def __init__(self, parent: Optional[Any] = None):
+        super().__init__(parent)
+        self.pruefmanager: Optional[Pruefmanager] = None
+        self.logic = PrintLogic(self.pruefmanager)
+
+        
+        #self.logic: Optional[PrintLogic] = None
+        self._kartenname_combo: Optional[Any] = None
+        self._massstab_combo: Optional[Any] = None
+        self._thema_combo: Optional[Any] = None
+        self._theme_signal_connected = False
+        self._connected_theme_collection: object = None
+        self._zielgroesse_combo: Optional[Any] = None
+        self._druckbereich_combo: Optional[Any] = None
+        self._endlosrolle_cb: Optional[Any] = None
+        self._druckpuffer_button: Optional[Any] = None
+        self._btn_vorlage_erstellen: Optional[Any] = None
+        self._atlas_layer_combo: Optional[Any] = None
+        self._btn_auswahl_as_atlas: Optional[Any] = None
+        self._atlas_erzeugen_cb: Optional[Any] = None
+        self._atlas_button: Optional[Any] = None
+        self._atlas_content: Optional[Any] = None
+
+        self._build_ui()
+        self._restore_state()
+        self._connect_theme_collection_signals()
+        self._connect_project_signals()
+
+    def set_services(self, pruefmanager: Pruefmanager, data_grabber: DataGrabber) -> None:
+        _ = data_grabber
+        self.pruefmanager = pruefmanager
+        self.logic = PrintLogic(pruefmanager=self.pruefmanager)
+
+        if self._kartenname_combo:
+            self.logic.set_kartenname_for_auswahl(self._kartenname_combo.currentText())
+        if self._massstab_combo:
+            self.logic.set_plotmassstab_for_auswahl(
+                self._massstab_combo.currentText(),
+                self._get_current_canvas_scale(),
+            )
+        if self._thema_combo:
+            self.logic.set_view_for_auswahl(self._thema_combo.currentText())
+        if self._zielgroesse_combo:
+            self.logic.set_zielgroesse_for_auswahl(self._zielgroesse_combo.currentText())
+        if self._druckbereich_combo:
+            self.logic.set_druckbereich_for_auswahl(self._druckbereich_combo.currentText())
+        if self._endlosrolle_cb:
+            self.logic.set_formfaktor(self._endlosrolle_cb.isChecked())
+
+    def _build_ui(self) -> None:
+        main_layout = QVBoxLayout()
+        main_layout.setSpacing(4)
+        main_layout.setContentsMargins(4, 4, 4, 4)
+
+        kartenname_label = QLabel("Kartenname")
+        kartenname_label.setStyleSheet("font-weight: bold; margin-top: 6px;")
+        main_layout.addWidget(kartenname_label)
+
+        kartenname_combo = QComboBox(self)
+        kartenname_combo.addItem(KARTENNAME_PLACEHOLDER)
+        kartenname_combo.addItem(KARTENNAME_38)
+        kartenname_combo.addItem(KARTENNAME_41)
+        kartenname_combo.addItem(KARTENNAME_BAUFREIGABE)
+        kartenname_combo.currentTextChanged.connect(self._on_kartenname_changed)
+        self._kartenname_combo = kartenname_combo
+        main_layout.addWidget(kartenname_combo)
+
+        massstab_label = QLabel("Massstab")
+        massstab_label.setStyleSheet("font-weight: bold; margin-top: 6px;")
+        main_layout.addWidget(massstab_label)
+
+        massstab_combo = QComboBox(self)
+        massstab_combo.addItem(MASSSTAB_WIE_KARTENFENSTER)
+        massstab_combo.addItems(list(PLOTMASSSTAB_BY_AUSWAHL.keys()))
+        massstab_combo.currentTextChanged.connect(self._on_massstab_changed)
+        self._massstab_combo = massstab_combo
+        main_layout.addWidget(massstab_combo)
+
+        thema_label = QLabel("Thema")
+        thema_label.setStyleSheet("font-weight: bold; margin-top: 6px;")
+        main_layout.addWidget(thema_label)
+
+        thema_combo = QComboBox(self)
+        thema_combo.addItem(THEMA_WIE_KARTENFENSTER)
+        thema_combo.addItems(self._get_gespeicherte_themen())
+        thema_combo.currentTextChanged.connect(self._on_thema_changed)
+        self._thema_combo = thema_combo
+        main_layout.addWidget(thema_combo)
+
+        zielgroesse_label = QLabel("max. Blattgroesse")
+        zielgroesse_label.setStyleSheet("font-weight: bold; margin-top: 6px;")
+        main_layout.addWidget(zielgroesse_label)
+
+        zielgroesse_row = QHBoxLayout()
+        zielgroesse_row.setSpacing(6)
+        zielgroesse_combo = QComboBox(self)
+        zielgroesse_combo.addItems(list(DIN_GROESSEN.keys()))
+        zielgroesse_combo.setCurrentText(DIN_STANDARD)
+        zielgroesse_combo.currentTextChanged.connect(self._on_zielgroesse_changed)
+        self._zielgroesse_combo = zielgroesse_combo
+        zielgroesse_row.addWidget(zielgroesse_combo)
+
+        endlosrolle_cb = QCheckBox("Endlosrolle", self)
+        endlosrolle_cb.setChecked(False)
+        endlosrolle_cb.stateChanged.connect(self._on_formfaktor_changed)
+        self._endlosrolle_cb = endlosrolle_cb
+        zielgroesse_row.addWidget(endlosrolle_cb)
+        main_layout.addLayout(zielgroesse_row)
+
+        druckbereich_row = QHBoxLayout()
+        druckbereich_row.setSpacing(6)
+
+        druckbereich_column = QVBoxLayout()
+        druckbereich_column.setSpacing(4)
+        druckbereich_column.setContentsMargins(0, 0, 0, 0)
+
+        druckbereich_label = QLabel("Druckbereich")
+        druckbereich_label.setStyleSheet("font-weight: bold; margin-top: 6px;")
+        druckbereich_column.addWidget(druckbereich_label)
+
+        druckbereich_combo = QComboBox(self)
+        druckbereich_combo.addItems(DRUCKBEREICH_OPTIONEN)
+        druckbereich_combo.currentTextChanged.connect(self._on_druckbereich_changed)
+        self._druckbereich_combo = druckbereich_combo
+        druckbereich_column.addWidget(druckbereich_combo)
+        druckbereich_row.addLayout(druckbereich_column, 1)
+
+        druckpuffer_column = QVBoxLayout()
+        druckpuffer_column.setSpacing(4)
+        druckpuffer_column.setContentsMargins(0, 0, 0, 0)
+
+        druckpuffer_label = QLabel("Kartenpuffer")
+        druckpuffer_label.setStyleSheet("font-weight: bold; margin-top: 6px;")
+        druckpuffer_column.addWidget(druckpuffer_label)
+
+        druckpuffer_button = QPushButton(self._format_druckpuffer_label(DRUCKPUFFER_STANDARD_CM), self)
+        druckpuffer_button.setToolTip("Puffer")
+        druckpuffer_button.clicked.connect(self._on_druckpuffer_clicked)
+        self._druckpuffer_button = druckpuffer_button
+        druckpuffer_column.addWidget(druckpuffer_button)
+        druckbereich_row.addLayout(druckpuffer_column)
+
+        main_layout.addLayout(druckbereich_row)
+
+        # Atlas-Bereich (einklappbar, analog Tab A)
+        atlas_button = QToolButton()
+        atlas_button.setText("Atlas")
+        atlas_button.setCheckable(True)
+        atlas_button.setChecked(False)
+        atlas_button.setToolButtonStyle(ToolButtonTextBesideIcon)
+        atlas_button.setArrowType(ArrowRight)
+        atlas_button.setStyleSheet("font-weight: bold; margin-top: 6px;")
+        atlas_button.toggled.connect(self._toggle_atlas)
+        self._atlas_button = atlas_button
+        main_layout.addWidget(atlas_button)
+
+        atlas_content = QWidget()
+        atlas_layout = QVBoxLayout()
+        atlas_layout.setSpacing(4)
+        atlas_layout.setContentsMargins(10, 4, 4, 4)
+
+        atlas_erzeugen_cb = QCheckBox("Atlas erzeugen", self)
+        atlas_erzeugen_cb.setChecked(True)
+        atlas_erzeugen_cb.stateChanged.connect(self._on_atlas_erzeugen_changed)
+        self._atlas_erzeugen_cb = atlas_erzeugen_cb
+        atlas_layout.addWidget(atlas_erzeugen_cb)
+
+        atlas_layer_label = QLabel("Abdeckungslayer", self)
+        atlas_layout.addWidget(atlas_layer_label)
+
+        atlas_layer_combo = QgsMapLayerComboBox(self)
+        set_filters = getattr(atlas_layer_combo, "setFilters", None)
+        if callable(set_filters):
+            set_filters(QgsMapLayerProxyModel.VectorLayer)
+        layer_changed = getattr(atlas_layer_combo, "layerChanged", None)
+        if layer_changed is not None:
+            try:
+                layer_changed.connect(self._on_atlas_layer_changed)
+            except Exception:
+                pass
+        self._atlas_layer_combo = atlas_layer_combo
+        atlas_layout.addWidget(atlas_layer_combo)
+
+        btn_auswahl_as_atlas = QPushButton("Auswahl als Atlas anlegen", self)
+        btn_auswahl_as_atlas.clicked.connect(self._on_auswahl_as_atlas_clicked)
+        self._btn_auswahl_as_atlas = btn_auswahl_as_atlas
+        atlas_layout.addWidget(btn_auswahl_as_atlas)
+
+        atlas_content.setLayout(atlas_layout)
+        atlas_content.setVisible(False)
+        self._atlas_content = atlas_content
+        main_layout.addWidget(atlas_content)
+
+        btn_vorlage_erstellen = QPushButton("Vorlage erstellen", self)
+        btn_vorlage_erstellen.clicked.connect(self._on_vorlage_erstellen)
+        self._btn_vorlage_erstellen = btn_vorlage_erstellen
+        main_layout.addWidget(btn_vorlage_erstellen)
+
+        main_layout.addStretch(1)
+        self.setLayout(main_layout)
+
+    def _restore_state(self) -> None:
+        if not self._kartenname_combo or not self._massstab_combo or not self._thema_combo:
+            return
+        if not self._zielgroesse_combo or not self._endlosrolle_cb:
+            return
+        if not self._druckbereich_combo or not self._druckpuffer_button:
+            return
+
+        saved_kartenname = get_variable(KARTENNAME_VAR, scope="project")
+        if saved_kartenname in (KARTENNAME_38, KARTENNAME_41, KARTENNAME_BAUFREIGABE):
+            self._kartenname_combo.setCurrentText(saved_kartenname)
+        else:
+            self._kartenname_combo.setCurrentText(KARTENNAME_PLACEHOLDER)
+
+        saved_massstab = get_variable(MASSSTAB_VAR, scope="project")
+        valid_massstaebe = [MASSSTAB_WIE_KARTENFENSTER, *PLOTMASSSTAB_BY_AUSWAHL.keys()]
+        if saved_massstab in valid_massstaebe:
+            self._massstab_combo.setCurrentText(saved_massstab)
+        else:
+            self._massstab_combo.setCurrentText(MASSSTAB_WIE_KARTENFENSTER)
+
+        aktuelle_themen = [THEMA_WIE_KARTENFENSTER, *self._get_gespeicherte_themen()]
+        self._thema_combo.clear()
+        self._thema_combo.addItems(aktuelle_themen)
+
+        saved_thema = get_variable(THEMA_VAR, scope="project")
+        if saved_thema in aktuelle_themen:
+            self._thema_combo.setCurrentText(saved_thema)
+        else:
+            self._thema_combo.setCurrentText(THEMA_WIE_KARTENFENSTER)
+
+        saved_zielgroesse = get_variable(ZIELGROESSE_UI_VAR, scope="project")
+        if saved_zielgroesse in DIN_GROESSEN:
+            self._zielgroesse_combo.setCurrentText(saved_zielgroesse)
+        else:
+            self._zielgroesse_combo.setCurrentText(DIN_STANDARD)
+
+        saved_formfaktor = get_variable(FORMFAKTOR_UI_VAR, scope="project")
+        self._endlosrolle_cb.setChecked(saved_formfaktor == "Endlosrolle")
+
+        saved_druckbereich = get_variable(DRUCKBEREICH_VAR, scope="project")
+        if saved_druckbereich in DRUCKBEREICH_OPTIONEN:
+            self._druckbereich_combo.setCurrentText(saved_druckbereich)
+        else:
+            self._druckbereich_combo.setCurrentText(DRUCKBEREICH_VERFAHRENSGEBIET)
+
+        saved_druckpuffer = get_variable(DRUCKPUFFER_VAR, scope="project")
+        try:
+            druckpuffer_cm = int(str(saved_druckpuffer).strip())
+        except (TypeError, ValueError):
+            druckpuffer_cm = DRUCKPUFFER_STANDARD_CM
+        self._druckpuffer_button.setText(self._format_druckpuffer_label(max(0, druckpuffer_cm)))
+
+        if self._atlas_erzeugen_cb:
+            atlas_raw = get_variable(ATLAS_ERZEUGEN_VAR, scope="project")
+            atlas_checked = True if atlas_raw in (None, "") else str(atlas_raw).strip().lower() in {
+                "1",
+                "true",
+                "ja",
+                "yes",
+                "on",
+            }
+            self._atlas_erzeugen_cb.setChecked(atlas_checked)
+            self._on_atlas_erzeugen_changed(1 if atlas_checked else 0)
+
+        self._restore_atlas_layer_selection()
+
+    def _on_kartenname_changed(self, value: str) -> None:
+        if value in (KARTENNAME_38, KARTENNAME_41, KARTENNAME_BAUFREIGABE):
+            set_variable(KARTENNAME_VAR, value, scope="project")
+        else:
+            set_variable(KARTENNAME_VAR, "", scope="project")
+
+        # Atlas-Bereich automatisch ein-/ausklappen je nach Kartenname.
+        if self._atlas_button:
+            self._atlas_button.setChecked(value == KARTENNAME_BAUFREIGABE)
+
+        if self.logic:
+            self.logic.set_kartenname_for_auswahl(value)
+
+    def _on_massstab_changed(self, value: str) -> None:
+        set_variable(MASSSTAB_VAR, value, scope="project")
+        if self.logic:
+            self.logic.set_plotmassstab_for_auswahl(value, self._get_current_canvas_scale())
+
+    def _on_thema_changed(self, value: str) -> None:
+        set_variable(THEMA_VAR, value, scope="project")
+        if self.logic:
+            self.logic.set_view_for_auswahl(value)
+
+    def _on_zielgroesse_changed(self, value: str) -> None:
+        set_variable(ZIELGROESSE_UI_VAR, value, scope="project")
+        if self.logic:
+            self.logic.set_zielgroesse_for_auswahl(value)
+
+    def _on_formfaktor_changed(self, state: int) -> None:
+        checked = bool(state)
+        set_variable(FORMFAKTOR_UI_VAR, "Endlosrolle" if checked else "Blatt", scope="project")
+        if self.logic:
+            self.logic.set_formfaktor(checked)
+
+    def _on_druckbereich_changed(self, value: str) -> None:
+        if value not in DRUCKBEREICH_OPTIONEN:
+            value = DRUCKBEREICH_VERFAHRENSGEBIET
+        set_variable(DRUCKBEREICH_VAR, value, scope="project")
+        if self.logic:
+            self.logic.set_druckbereich_for_auswahl(value)
+            if value == DRUCKBEREICH_RECHTECK:
+                self.logic.activate_druckrechteck_capture()
+
+    def _on_atlas_erzeugen_changed(self, state: int) -> None:
+        enabled = bool(state)
+        set_variable(ATLAS_ERZEUGEN_VAR, "1" if enabled else "0", scope="project")
+
+        if self._atlas_layer_combo:
+            set_enabled = getattr(self._atlas_layer_combo, "setEnabled", None)
+            if callable(set_enabled):
+                try:
+                    set_enabled(enabled)
+                except Exception:
+                    pass
+
+        if self._btn_auswahl_as_atlas:
+            self._btn_auswahl_as_atlas.setEnabled(enabled)
+
+    def _on_druckpuffer_clicked(self) -> None:
+        if not self.pruefmanager:
+            return
+
+        current_value = get_variable(DRUCKPUFFER_VAR, scope="project") or str(DRUCKPUFFER_STANDARD_CM)
+        text_value, bestaetigt = self.pruefmanager.frage_text(
+            "Puffer um den Druckbereich",
+            "Puffer um den Druckbereich",
+            default_text=str(current_value),
+        )
+        if not bestaetigt:
+            return
+
+        try:
+            puffer_value = int(str(text_value).strip())
+        except (TypeError, ValueError):
+            self.pruefmanager.zeige_hinweis(
+                "Puffer um den Druckbereich",
+                "Der Puffer muss als ganze Zahl eingegeben werden.",
+            )
+            return
+
+        if puffer_value < 0:
+            self.pruefmanager.zeige_hinweis(
+                "Puffer um den Druckbereich",
+                "Der Puffer darf nicht negativ sein.",
+            )
+            return
+
+        set_variable(DRUCKPUFFER_VAR, str(puffer_value), scope="project")
+        if self._druckpuffer_button:
+            self._druckpuffer_button.setText(self._format_druckpuffer_label(puffer_value))
+
+    def _format_druckpuffer_label(self, value_cm: int) -> str:
+        return f"{value_cm} cm"
+
+    def _on_vorlage_erstellen(self) -> None:
+        if not self.logic or not self.pruefmanager:
+            return
+
+        self.logic.druckvorlage_anlegen(
+            layer=None,
+            kartenname_auswahl=self._kartenname_combo.currentText() if self._kartenname_combo else "",
+            massstab_auswahl=self._massstab_combo.currentText() if self._massstab_combo else "",
+            zielgroesse=self._zielgroesse_combo.currentText() if self._zielgroesse_combo else DIN_STANDARD,
+            formfaktor=self._endlosrolle_cb.isChecked() if self._endlosrolle_cb else False,
+            druckbereich_auswahl=self._druckbereich_combo.currentText() if self._druckbereich_combo else DRUCKBEREICH_VERFAHRENSGEBIET,
+        )
+
+    def _disconnect_project_signals(self) -> None:
+        try:
+            project = QgsProject.instance()
+        except Exception:
+            return
+
+        if project is None:
+            return
+
+        for signal_name in ("readProject", "newProjectCreated", "cleared"):
+            signal = getattr(project, signal_name, None)
+            if signal is None:
+                continue
+            try:
+                signal.disconnect(self._on_project_changed)
+            except Exception:
+                pass
+
+    def cleanup(self) -> None:
+        """Trennt Signalverbindungen vor dem Schliessen des Tabs."""
+        self._disconnect_theme_collection_signals()
+        self._disconnect_project_signals()
+
+    def _connect_project_signals(self) -> None:
+        try:
+            project = QgsProject.instance()
+        except Exception:
+            return
+
+        if project is None:
+            return
+
+        for signal_name in ("readProject", "newProjectCreated", "cleared"):
+            signal = getattr(project, signal_name, None)
+            if signal is None:
+                continue
+            try:
+                signal.connect(self._on_project_changed)
+            except Exception:
+                pass
+
+    def _on_project_changed(self, *args) -> None:
+        _ = args
+        self._disconnect_theme_collection_signals()
+        self._theme_signal_connected = False
+        self._connect_theme_collection_signals()
+        self._restore_state()
+
+    def _toggle_atlas(self, checked: bool) -> None:
+        if self._atlas_button:
+            self._atlas_button.setArrowType(ArrowDown if checked else ArrowRight)
+        if self._atlas_content:
+            self._atlas_content.setVisible(checked)
+
+    def _restore_atlas_layer_selection(self) -> None:
+        if not self._atlas_layer_combo:
+            return
+
+        layer_id = (get_variable("sn_abdeckungslayer", scope="project") or "").strip()
+        if not layer_id:
+            return
+
+        try:
+            layer = QgsProject.instance().mapLayer(layer_id)
+            if layer is None:
+                return
+
+            set_current_layer = getattr(self._atlas_layer_combo, "setLayer", None)
+            if callable(set_current_layer):
+                set_current_layer(layer)
+                return
+
+            set_current_layer = getattr(self._atlas_layer_combo, "setCurrentLayer", None)
+            if callable(set_current_layer):
+                set_current_layer(layer)
+        except Exception:
+            pass
+
+    def _disconnect_theme_collection_signals(self) -> None:
+        collection = self._connected_theme_collection
+        if collection is not None:
+            for signal_name in ("mapThemesChanged", "changed", "themeChanged"):
+                try:
+                    signal = getattr(collection, signal_name, None)
+                except RuntimeError:
+                    break
+                except Exception:
+                    continue
+                if signal is None:
+                    continue
+                try:
+                    signal.disconnect(self._refresh_thema_combo_live)
+                except Exception:
+                    pass
+        self._connected_theme_collection = None
+        self._theme_signal_connected = False
+
+    def _connect_theme_collection_signals(self) -> None:
+        if self._theme_signal_connected:
+            return
+
+        try:
+            theme_collection = QgsProject.instance().mapThemeCollection()
+        except Exception:
+            return
+
+        if theme_collection is None:
+            return
+
+        connected_any = False
+        for signal_name in ("mapThemesChanged", "changed", "themeChanged"):
+            signal = getattr(theme_collection, signal_name, None)
+            if signal is None:
+                continue
+            try:
+                signal.connect(self._refresh_thema_combo_live)
+                connected_any = True
+            except Exception:
+                pass
+
+        if connected_any:
+            self._connected_theme_collection = theme_collection
+        self._theme_signal_connected = connected_any
+
+    def _refresh_thema_combo_live(self, *args) -> None:
+        _ = args
+        if not self._thema_combo:
+            return
+
+        vorherige_auswahl = self._thema_combo.currentText() or THEMA_WIE_KARTENFENSTER
+        eintraege = [THEMA_WIE_KARTENFENSTER, *self._get_gespeicherte_themen()]
+
+        self._thema_combo.blockSignals(True)
+        self._thema_combo.clear()
+        self._thema_combo.addItems(eintraege)
+
+        if vorherige_auswahl in eintraege:
+            self._thema_combo.setCurrentText(vorherige_auswahl)
+        else:
+            self._thema_combo.setCurrentText(THEMA_WIE_KARTENFENSTER)
+        self._thema_combo.blockSignals(False)
+
+        self._on_thema_changed(self._thema_combo.currentText())
+
+    def _get_gespeicherte_themen(self) -> list[str]:
+        try:
+            theme_collection = QgsProject.instance().mapThemeCollection()
+            if theme_collection is None:
+                return []
+            themes = theme_collection.mapThemes()
+        except Exception:
+            return []
+
+        namen: list[str] = []
+        for theme_name in themes:
+            name = str(theme_name or "").strip()
+            if name and name not in namen:
+                namen.append(name)
+
+        return namen
+
+    def _get_current_canvas_scale(self) -> float | None:
+        try:
+            canvas = iface.mapCanvas()
+            if canvas is None:
+                return None
+            scale = canvas.scale()
+            return float(scale) if scale else None
+        except Exception:
+            return None
+
+    def _on_atlas_layer_changed(self, layer_or_name: Any) -> None:
+        """Speichert den ausgewaehlten Atlas-Layer als Layer-ID in Projektvariablen."""
+        if layer_or_name is None or layer_or_name == "":
+            set_variable("sn_abdeckungslayer", "", scope="project")
+            return
+
+        # Standardfall QgsMapLayerComboBox: echtes Layer-Objekt
+        layer_id_getter = getattr(layer_or_name, "id", None)
+        if callable(layer_id_getter):
+            layer_id = layer_id_getter() or ""
+            set_variable("sn_abdeckungslayer", layer_id, scope="project")
+            return
+
+        # Fallback: ggf. Name aus Mock/anderen Widgets
+        value = str(layer_or_name).strip()
+        if not value:
+            set_variable("sn_abdeckungslayer", "", scope="project")
+            return
+
+        try:
+            project = QgsProject.instance()
+            map_layers = project.mapLayers()
+            for layer_id, layer in map_layers.items():
+                if getattr(layer, "name", lambda: "")() == value:
+                    set_variable("sn_abdeckungslayer", layer_id, scope="project")
+                    return
+        except Exception:
+            pass
+
+    def _on_auswahl_as_atlas_clicked(self) -> None:
+        """Handler fuer Button 'Auswahl als Atlas anlegen'.
+        
+        Erstellt einen neuen Layer 'Atlaslayer' aus der aktuellen Feature-Auswahl
+        und traegt ihn ins Atlas-Dropdown ein.
+        """
+        if not self.logic or not self.pruefmanager:
+            return
+
+        atlas_layer, layer_id = self.logic.create_atlas_layer_from_selection()
+        if atlas_layer is None or not layer_id:
+            return
+
+        if self._atlas_button and self._atlas_content:
+            self._atlas_button.setChecked(True)
+            self._toggle_atlas(True)
+
+        # Neu erstellten Layer im Layer-Combo setzen
+        if self._atlas_layer_combo:
+            set_current_layer = getattr(self._atlas_layer_combo, "setLayer", None)
+            if callable(set_current_layer):
+                try:
+                    set_current_layer(atlas_layer)
+                    return
+                except Exception:
+                    pass
+
+            set_current_layer = getattr(self._atlas_layer_combo, "setCurrentLayer", None)
+            if callable(set_current_layer):
+                try:
+                    set_current_layer(atlas_layer)
+                    return
+                except Exception:
+                    pass
+
+            # Fallback nur fuer Mock/klassische ComboBox
+            self._populate_atlas_layer_combo()
+
+    def _populate_atlas_layer_combo(self) -> None:
+        """Fallback-Befuellung, falls kein echtes QgsMapLayerComboBox Verhalten verfuegbar ist."""
+        if not self._atlas_layer_combo:
+            return
+
+        clear_fn = getattr(self._atlas_layer_combo, "clear", None)
+        add_item_fn = getattr(self._atlas_layer_combo, "addItem", None)
+        if not callable(clear_fn) or not callable(add_item_fn):
+            return
+
+        self._atlas_layer_combo.blockSignals(True)
+        clear_fn()
+        add_item_fn("")
+
+        try:
+            project = QgsProject.instance()
+            map_layers = getattr(project, "mapLayers", None)
+            if not callable(map_layers):
+                self._atlas_layer_combo.blockSignals(False)
+                return
+
+            layers = map_layers().values() if hasattr(map_layers(), "values") else map_layers()
+            for layer in layers:
+                layer_name = getattr(layer, "name", lambda: None)()
+                if layer_name and layer_name not in ("", "Druckrechteck"):
+                    add_item_fn(layer_name)
+        except Exception:
+            pass
+
+        self._atlas_layer_combo.blockSignals(False)

ui/tabs/settings_tab.py

@@ -1,4 +1,8 @@
-#sn_basis/ui/tabs/settings_tab.py
+"""
+sn_basis/ui/tabs/settings_tab.py – Einstellungen-Tab für Projekteinformationen.
+Verwaltet benutzerspezifische und projektspezifische Einstellungen.
+"""
+
 from sn_basis.functions.qt_wrapper import (
     QWidget,
     QGridLayout,
@@ -12,9 +16,23 @@ from sn_basis.functions.settings_logic import SettingsLogic
 
 
 class SettingsTab(QWidget):
+    """
+    Tab-Widget für die Verwaltung von Projekt- und Benutzereinstellungen.
+    
+    Attributes:
+        tab_title: Anzeigetitel des Tabs ("Projekteigenschaften")
+        logic: SettingsLogic-Instanz für persistente Einstellungen
+    """
+    
     tab_title = "Projekteigenschaften"
 
     def __init__(self, parent=None):
+        """
+        Initialisiert den Settings-Tab mit Eingabefeldern.
+        
+        Args:
+            parent: Übergeordnetes Widget (Standard: None)
+        """
         super().__init__(parent)
         self.logic = SettingsLogic()