Kartenschild und Legende hinzugefügt

ui/layout.py

@@ -11,6 +11,7 @@ from sn_basis.functions.qt_wrapper import QFont
 from sn_basis.functions.qgiscore_wrapper import (
     QgsLayoutItem,
     QgsLayoutItemLabel,
+    QgsLayoutItemLegend,
     QgsLayoutItemMap,
     QgsLayoutPoint,
     QgsLayoutSize,
@@ -29,19 +30,19 @@ class Layout:
 
     _TEXT_FORMAT_TEMPLATES = {
         "Format_1": {
-            "font_family": "New Helvetica roman",
+            "font_family": "Arial",
             "font_size": 10,
             "font_style": "normal",
         },
         "Format_2": {
-            "font_family": "New Helvetica roman",
+            "font_family": "Arial",
-            "font_size": 14,
+            "font_size": 10,
-            "font_style": "fett",
+            "font_style": "bold",
         },
         "Format_3": {
-            "font_family": "New Helvetica roman",
+            "font_family": "Arial",
-            "font_size": 10,
+            "font_size": 14,
-            "font_style": "normal",
+            "font_style": "bold",
         },
     }
 
@@ -70,6 +71,11 @@ class Layout:
             "html_mode": True,
             "text": "",
         },
+        "legende": {
+            "id": "Legende",
+            "object_name": "Legende",
+            "size_mm": (180.0, 60.0),
+        },
     }
 
     _QUELLENANGABE_TEXT = (
@@ -83,7 +89,7 @@ class Layout:
         "mit teilweise angepasster Signatur<br>"
     )
 
-    _SEITENZAHL_TEXT = "Seite [% attribute(@atlas_feature, 'Seitenzahl') %] von [% @atlas_totalfeatures %]"
+    _SEITENZAHL_TEXT = "Blatt [% attribute(@atlas_feature, 'Seitenzahl') %] von [% @atlas_totalfeatures %]"
 
     def __init__(self, project: Any | None = None) -> None:
         self.project = project or QgsProject.instance()
@@ -178,7 +184,14 @@ class Layout:
             object_name=object_name,
         )
 
-    def _setup_layout_objects(self, kartenfenster_untere_rechte_ecke_mm: tuple, is_atlas: bool = False) -> None:
+    def _setup_layout_objects(
+        self,
+        kartenfenster_untere_rechte_ecke_mm: tuple,
+        hauptkarte: Any,
+        map_top_mm: float,
+        map_height_mm: float,
+        is_atlas: bool = False,
+    ) -> None:
         """Zentrale Methode zum Hinzufügen aller Standard-Objekte ins Layout.
         
         Diese Methode wird sowohl von create_single_page_layout() als auch von create_atlas_layout() aufgerufen.
@@ -190,32 +203,71 @@ class Layout:
         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,
+            )
+        
         mode_html = getattr(QgsLayoutItemLabel, "ModeHtml", None)
         print(f"[Layout] QgsLayoutItemLabel.ModeHtml={mode_html!r}")
         lower_left = getattr(getattr(QgsLayoutItem, "ReferencePoint", object), "LowerLeft", None)
         print(f"[Layout] QgsLayoutItem.ReferencePoint.LowerLeft={lower_left!r}")
 
-        # Quellenangabe: unterschiedliche Positionen für Einzelblatt vs. Atlas
+        legende_x = kartenfenster_untere_rechte_ecke_mm[0] + 10.0
-        if is_atlas:
+        legende_height_mm = max(map_height_mm - 122.0, 20.0)
-            quellenangabe_x = kartenfenster_untere_rechte_ecke_mm[0] + 5.0
+        legende_y = map_top_mm
-            quellenangabe_y = kartenfenster_untere_rechte_ecke_mm[1]
+        legende = self._create_legend_item(
-        else:
-            quellenangabe_x = kartenfenster_untere_rechte_ecke_mm[0] + 10.0
-            quellenangabe_y = kartenfenster_untere_rechte_ecke_mm[1] - 120.0
-        
-        self._create_label_item(
             self._current_layout,
-            "quellenangabe",
+            "legende",
+            hauptkarte,
+            legende_x,
+            legende_y,
+            width_mm=180.0,
+            height_mm=legende_height_mm,
+            object_name="Legende",
+        )
+
+        legende_hoehe_mm = self._configure_legend_size(
+            legende,
+            width_limit_mm=180.0,
+            column_count=1,
+            equal_column_width=False,
+        )
+
+        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:
+            legende_hoehe_mm = self._configure_legend_size(
+                legende,
+                width_limit_mm=180.0,
+                column_count=2,
+                equal_column_width=True,
+            )
+            print("[Layout] Legende überlappt Quellenangabe – auf 2 Spalten umgestellt")
+
+        print("[Layout] Legende zum Layout hinzugefügt")
+        
+        # Quellenangabe:
+
+        self.add_text_label(
             self._QUELLENANGABE_TEXT,
             quellenangabe_x,
             quellenangabe_y,
+            width_mm=180.0,
+            height_mm=20.0,
+            text_format="Format_1",
             html_mode=True,
+            expression_enabled=True,
+            object_name="Quellenangabe",
         )
         print("[Layout] Quellenangabe zum Layout hinzugefügt")
         # Kartenschild-Box, -Linien und -Text werden hier ergänzt (TODO)
         #Kartenschild-Box
-        kartenschild_x = kartenfenster_untere_rechte_ecke_mm[0] + 10.0
+        kartenschild_x, kartenschild_y = _coords_rel_untere_rechte_ecke(10.0, 0.0)
-        kartenschild_y = kartenfenster_untere_rechte_ecke_mm[1] 
         self._create_rectangle_box_item(
             self._current_layout,
             "Kartenschild",
@@ -223,19 +275,20 @@ class Layout:
             kartenschild_y,
             180.0,
             92.0,
-            stroke_width_mm= 1.0,
+            stroke_width_mm=1.0,
         )
         print("[Layout] Kartenschild-Box zum Layout hinzugefügt")
         
         #Kartenschild-Linien
-        kartenschild_line_x = kartenfenster_untere_rechte_ecke_mm[0] + 10.0
+        kartenschild_line_x, _ = _coords_rel_untere_rechte_ecke(10.0, 0.0)
         kartenschild_line_offsets_y = (-10.0, -20.0, -30.0, -46.0, -62.0, -82.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,
-                kartenfenster_untere_rechte_ecke_mm[1] + offset_y,
+                line_y,
                 180.0,
                 0.0,
                 stroke_width_mm=0.1,
@@ -244,33 +297,147 @@ class Layout:
 
         #Kartenschild-Text
         #Herausgeber
-        self.add_text_label("@Amt", 10.0, -92.0, text_format="Format_1", object_name="Herausgeber")
+        herausgeber_x, herausgeber_y = _coords_rel_untere_rechte_ecke(16.0, -85.0)
+        self.add_text_label(
+            "[% @sn_amt %]",
+            herausgeber_x,
+            herausgeber_y,
+            width_mm=171.0,
+            height_mm=4.0,
+            text_format="Format_1",
+            expression_enabled=True,
+            object_name="Herausgeber",
+        )
         #Bezeichnung_Flurbereinigung
+        bezeichnung_flurbereinigung_x, bezeichnung_flurbereinigung_y = _coords_rel_untere_rechte_ecke(16.0, -75.0)
+        self.add_text_label(
+            "[% @sn_bezeichnung %]",
+            bezeichnung_flurbereinigung_x,
+            bezeichnung_flurbereinigung_y,
+            width_mm=171.0,
+            height_mm=4.0,
+            text_format="Format_1",
+            expression_enabled=True,
+            object_name="Bezeichnung_Flurbereinigung",
+        )
 
         #Name Flurbereinigung
+        name_flurbereinigung_x, name_flurbereinigung_y = _coords_rel_untere_rechte_ecke(16.0, -65.0)
+        self.add_text_label(
+            "[% @sn_name %]",
+            name_flurbereinigung_x,
+            name_flurbereinigung_y,
+            width_mm=171.0,
+            height_mm=5.0,
+            text_format="Format_3",
+            expression_enabled=True,
+            object_name="Name_Flurbereinigung",
+        )
 
         #Stadt_Gemeinde
+        stadt_gemeinde_x, stadt_gemeinde_y = _coords_rel_untere_rechte_ecke(16.0, -57.0)
+        self.add_text_label(
+            "[% @sn_gemeinden %]",
+            stadt_gemeinde_x,
+            stadt_gemeinde_y,
+            width_mm=171.0,
+            height_mm=4.0,
+            text_format="Format_1",
+            expression_enabled=True,
+            object_name="Stadt_Gemeinde",
+        )
 
         #Landkreis
+        landkreis_x, landkreis_y = _coords_rel_untere_rechte_ecke(16.0, -49.0)
+        self.add_text_label(
+            "[% @sn_landkreise_proj %]",
+            landkreis_x,
+            landkreis_y,
+            width_mm=171.0,
+            height_mm=4.0,
+            text_format="Format_1",
+            expression_enabled=True,
+            object_name="Landkreis",
+        )
 
         #Kartenname
+        kartenname_x, kartenname_y = _coords_rel_untere_rechte_ecke(16.0, -33.0)
+        self.add_text_label(
+            "[% @sn_kartenname %]",
+            kartenname_x,
+            kartenname_y,
+            width_mm=137.0,
+            height_mm=5.0,
+            text_format="Format_3",
+            expression_enabled=True,
+            object_name="Kartenname",
+        )
 
         #Ergänzung(Seitenzahl)
 
         #gefertigt
-
+        gefertigt_x, gefertigt_y = _coords_rel_untere_rechte_ecke(16.0, -23.0)
+        self.add_text_label(
+            "Gefertigt: ",
+            gefertigt_x,
+            gefertigt_y,
+            width_mm=81.0,
+            height_mm=4.0,
+            text_format="Format_1",
+            expression_enabled=True,
+            object_name="Gefertigt",
+        )
         #geprüft
-
+        geprüft_x, geprüft_y = _coords_rel_untere_rechte_ecke(101.0, -23.0)
+        self.add_text_label(
+            "Geprüft: ",
+            geprüft_x,
+            geprüft_y,
+            width_mm=81.0,
+            height_mm=4.0,
+            text_format="Format_1",
+            expression_enabled=True,
+            object_name="Geprüft",
+        )
         #Maßstab
-
+        maßstab_x, maßstab_y = _coords_rel_untere_rechte_ecke(16.0, -13.0)
+        self.add_text_label(   
+            "Maßstab: 1 : [%round(map_get(item_variables('Hauptkarte'),'map_scale'),0)%]",
+            maßstab_x,
+            maßstab_y,
+            width_mm=81.0,
+            height_mm=4.0,  
+            text_format="Format_1",
+            expression_enabled=True,
+            object_name="Maßstab",
+        )
         #Ausgabedatum
-
+        ausgabedatum_x, ausgabedatum_y = _coords_rel_untere_rechte_ecke(101.0, -13.0)
+        self.add_text_label(
+            "Ausgabedatum: [%format_date(now(), 'dd.MM.yyyy')%]",
+            ausgabedatum_x,
+            ausgabedatum_y,
+            width_mm=81.0,
+            height_mm=4.0,
+            text_format="Format_1",
+            expression_enabled=True,
+            object_name="Ausgabedatum",
+        )
         #Aktenzeichen
-
+        aktenzeichen_x, aktenzeichen_y = _coords_rel_untere_rechte_ecke(16.0, -3.0)
+        self.add_text_label(
+            "Aktenzeichen: ",
+            aktenzeichen_x,
+            aktenzeichen_y,
+            width_mm=171.0,
+            height_mm=4.0,
+            text_format="Format_1",
+            expression_enabled=True,
+            object_name="Aktenzeichen",
+        )
         # Seitenzahl nur bei Atlas-Layout
         if is_atlas:
-            seitenzahl_x = kartenfenster_untere_rechte_ecke_mm[0] + 5.0
+            seitenzahl_x, seitenzahl_y = _coords_rel_untere_rechte_ecke(166.0, -33.0)
-            seitenzahl_y = kartenfenster_untere_rechte_ecke_mm[1] - 2.0
             self._create_label_item(
                 self._current_layout,
                 "seitenzahl",
@@ -301,10 +468,11 @@ class Layout:
     ) -> Any:
         template = self._OBJECT_TEMPLATES[template_name]
         label = QgsLayoutItemLabel(layout)
-        label.setId(template["id"])
+        item_id = object_name or template["id"]
+        label.setId(item_id)
         set_object_name = getattr(label, "setObjectName", None)
         if callable(set_object_name):
-            set_object_name(object_name or template.get("object_name", template["id"]))
+            set_object_name(item_id)
         label.setText(text)
 
         if html_mode:
@@ -346,9 +514,276 @@ class Layout:
                 MM,
             )
         )
+        set_locked = getattr(label, "setLocked", None)
+        if callable(set_locked):
+            try:
+                set_locked(True)
+            except Exception:
+                pass
         layout.addLayoutItem(label)
         return label
 
+    def _resolve_visible_map_layers(self, map_item: Any) -> list[Any]:
+        layers_method = getattr(map_item, "layers", None)
+        if callable(layers_method):
+            try:
+                resolved_layers = layers_method()
+                if isinstance(resolved_layers, (list, tuple)):
+                    layers = [layer for layer in resolved_layers if layer is not None]
+                    if layers:
+                        return layers
+            except Exception:
+                pass
+
+        layer_tree_root_method = getattr(self.project, "layerTreeRoot", None)
+        if not callable(layer_tree_root_method):
+            return []
+
+        try:
+            root = layer_tree_root_method()
+        except Exception:
+            return []
+
+        find_layers = getattr(root, "findLayers", None)
+        if not callable(find_layers):
+            return []
+
+        visible_layers: list[Any] = []
+        try:
+            tree_layers = find_layers()
+            if not isinstance(tree_layers, (list, tuple)):
+                return []
+            for tree_layer in tree_layers:
+                is_visible = getattr(tree_layer, "itemVisibilityChecked", None)
+                if callable(is_visible) and not is_visible():
+                    continue
+                layer = getattr(tree_layer, "layer", None)
+                resolved_layer = layer() if callable(layer) else None
+                if resolved_layer is not None:
+                    visible_layers.append(resolved_layer)
+        except Exception:
+            return []
+
+        return visible_layers
+
+    def _create_legend_item(
+        self,
+        layout: Any,
+        template_name: str,
+        linked_map: Any,
+        x_mm: float,
+        y_mm: float,
+        *,
+        width_mm: float | None = None,
+        height_mm: float | None = None,
+        object_name: str | None = None,
+    ) -> Any:
+        template = self._OBJECT_TEMPLATES[template_name]
+        legend = QgsLayoutItemLegend(layout)
+        item_id = object_name or template["id"]
+        legend.setId(item_id)
+
+        set_object_name = getattr(legend, "setObjectName", None)
+        if callable(set_object_name):
+            set_object_name(item_id)
+
+        set_linked_map = getattr(legend, "setLinkedMap", None)
+        if callable(set_linked_map):
+            try:
+                set_linked_map(linked_map)
+            except Exception:
+                pass
+
+        set_title = getattr(legend, "setTitle", None)
+        if callable(set_title):
+            try:
+                set_title("Legende")
+            except Exception:
+                pass
+
+        set_auto_update_model = getattr(legend, "setAutoUpdateModel", None)
+        if callable(set_auto_update_model):
+            try:
+                set_auto_update_model(False)
+            except Exception:
+                pass
+
+        set_filter_by_map = getattr(legend, "setLegendFilterByMapEnabled", None)
+        if callable(set_filter_by_map):
+            try:
+                set_filter_by_map(False)
+            except Exception:
+                pass
+
+        model_method = getattr(legend, "model", None)
+        if callable(model_method):
+            try:
+                model = model_method()
+                root_group_method = getattr(model, "rootGroup", None)
+                root_group = root_group_method() if callable(root_group_method) else None
+                clear = getattr(root_group, "clear", None)
+                if callable(clear):
+                    clear()
+                add_layer = getattr(root_group, "addLayer", None)
+                if callable(add_layer):
+                    for layer in self._resolve_visible_map_layers(linked_map):
+                        add_layer(layer)
+            except Exception:
+                pass
+
+        set_reference_point = getattr(legend, "setReferencePoint", None)
+        upper_left = getattr(getattr(QgsLayoutItem, "ReferencePoint", object), "UpperLeft", None)
+        if callable(set_reference_point) and upper_left is not None:
+            set_reference_point(upper_left)
+
+        template_width, template_height = template.get("size_mm", (0.0, 0.0))
+        legend.attemptMove(QgsLayoutPoint(x_mm, y_mm, MM))
+        legend.attemptResize(
+            QgsLayoutSize(
+                width_mm if width_mm is not None else template_width,
+                height_mm if height_mm is not None else template_height,
+                MM,
+            )
+        )
+
+        set_frame_enabled = getattr(legend, "setFrameEnabled", None)
+        if callable(set_frame_enabled):
+            try:
+                set_frame_enabled(True)
+            except Exception:
+                pass
+
+        self._set_item_frame_stroke_width(legend, 0.3)
+
+        set_background_enabled = getattr(legend, "setBackgroundEnabled", None)
+        if callable(set_background_enabled):
+            try:
+                set_background_enabled(False)
+            except Exception:
+                pass
+
+        set_locked = getattr(legend, "setLocked", None)
+        if callable(set_locked):
+            try:
+                set_locked(True)
+            except Exception:
+                pass
+
+        layout.addLayoutItem(legend)
+
+        refresh = getattr(legend, "refresh", None)
+        if callable(refresh):
+            try:
+                refresh()
+            except Exception:
+                pass
+
+        return legend
+
+    def _get_item_size_mm(self, item: Any) -> tuple[float | None, float | None]:
+        def _to_float(value: Any) -> float | None:
+            if isinstance(value, (int, float)):
+                return float(value)
+            if isinstance(value, str):
+                try:
+                    return float(value)
+                except Exception:
+                    return None
+            return None
+
+        size_with_units = getattr(item, "sizeWithUnits", None)
+        if callable(size_with_units):
+            try:
+                size = size_with_units()
+                get_width = getattr(size, "width", None)
+                get_height = getattr(size, "height", None)
+                width = _to_float(get_width()) if callable(get_width) else None
+                height = _to_float(get_height()) if callable(get_height) else None
+                if width is not None and height is not None:
+                    return width, height
+            except Exception:
+                pass
+
+        rect = getattr(item, "rect", None)
+        if callable(rect):
+            try:
+                item_rect = rect()
+                get_width = getattr(item_rect, "width", None)
+                get_height = getattr(item_rect, "height", None)
+                width = _to_float(get_width()) if callable(get_width) else None
+                height = _to_float(get_height()) if callable(get_height) else None
+                return width, height
+            except Exception:
+                pass
+
+        return None, None
+
+    def _configure_legend_size(
+        self,
+        legend: Any,
+        *,
+        width_limit_mm: float,
+        column_count: int,
+        equal_column_width: bool,
+    ) -> float:
+        set_locked = getattr(legend, "setLocked", None)
+        if callable(set_locked):
+            try:
+                set_locked(False)
+            except Exception:
+                pass
+
+        set_column_count = getattr(legend, "setColumnCount", None)
+        if callable(set_column_count):
+            try:
+                set_column_count(column_count)
+            except Exception:
+                pass
+
+        set_equal_column_width = getattr(legend, "setEqualColumnWidth", None)
+        if callable(set_equal_column_width):
+            try:
+                set_equal_column_width(equal_column_width)
+            except Exception:
+                pass
+
+        refresh = getattr(legend, "refresh", None)
+        if callable(refresh):
+            try:
+                refresh()
+            except Exception:
+                pass
+
+        adjust_box_size = getattr(legend, "adjustBoxSize", None)
+        if callable(adjust_box_size):
+            try:
+                adjust_box_size()
+            except Exception:
+                pass
+
+        width_mm, height_mm = self._get_item_size_mm(legend)
+        resolved_width = width_mm if width_mm is not None else width_limit_mm
+        resolved_height = height_mm if height_mm is not None else 20.0
+        final_width = min(resolved_width, width_limit_mm)
+
+        legend.attemptResize(QgsLayoutSize(final_width, resolved_height, MM))
+
+        if callable(refresh):
+            try:
+                refresh()
+            except Exception:
+                pass
+
+        _, updated_height_mm = self._get_item_size_mm(legend)
+
+        if callable(set_locked):
+            try:
+                set_locked(True)
+            except Exception:
+                pass
+
+        return updated_height_mm if updated_height_mm is not None else resolved_height
+
     def _create_rectangle_box_item(
         self,
         layout: Any,
@@ -392,6 +827,13 @@ class Layout:
             except Exception:
                 pass
 
+        set_locked = getattr(box, "setLocked", None)
+        if callable(set_locked):
+            try:
+                set_locked(True)
+            except Exception:
+                pass
+
         layout.addLayoutItem(box)
         return box
 
@@ -531,7 +973,13 @@ class Layout:
         
         print(f"[Layout] Hauptkarte vollständig konfiguriert")
         
-        self._setup_layout_objects(kartenfenster_untere_rechte_ecke_mm, is_atlas=False)
+        self._setup_layout_objects(
+            kartenfenster_untere_rechte_ecke_mm,
+            hauptkarte,
+            map_top_mm,
+            map_height_mm,
+            is_atlas=False,
+        )
         
         layout_manager.addLayout(layout)
         print("[Layout] Layout zum LayoutManager hinzugefügt")
@@ -706,7 +1154,13 @@ class Layout:
         hauptkarte.attemptResize(QgsLayoutSize(map_width_mm, map_height_mm, MM))
         print(f"[Layout] Atlas Hauptkarte Größe nach Atlas-Konfiguration erneut gesetzt: {map_width_mm:.1f}mm × {map_height_mm:.1f}mm")
         
-        self._setup_layout_objects(kartenfenster_untere_rechte_ecke_mm, is_atlas=True)
+        self._setup_layout_objects(
+            kartenfenster_untere_rechte_ecke_mm,
+            hauptkarte,
+            map_top_mm,
+            map_height_mm,
+            is_atlas=True,
+        )
 
         atlas = layout.atlas()
         if atlas is not None:

ui/tab_b_logic.py

@@ -22,11 +22,11 @@ from sn_basis.modules.layerpruefer import Layerpruefer
 from sn_plan41.ui.layout import Layout
 
 
-KARTENNAME_VAR = "sn_kartenname"
+KARTENNAME_VAR = "kartenname"
-PLOTMASSSTAB_VAR = "sn_plotmassstab"
+PLOTMASSSTAB_VAR = "plotmassstab"
-VIEW_VAR = "sn_view"
+VIEW_VAR = "view"
-ZIELGROESSE_VAR = "sn_zielgroesse"
+ZIELGROESSE_VAR = "zielgroesse"
-FORMFAKTOR_VAR = "sn_formfaktor"
+FORMFAKTOR_VAR = "formfaktor"
 KARTENNAME_38 = "§38"
 KARTENNAME_41 = "§41"
 MASSSTAB_WIE_KARTENFENSTER = "Wie Kartenfenster"
@@ -287,12 +287,12 @@ class TabBLogic:
         return loaded_layer
 
     def set_kartenname_for_auswahl(self, auswahl: str) -> None:
-        """Setzt die Projektvariable ``sn_kartenname`` anhand der Kartennamen-Auswahl."""
+        """Setzt die Projektvariable ``kartenname`` anhand der Kartennamen-Auswahl."""
         kartenname = KARTENNAME_BY_AUSWAHL.get(auswahl, "")
         set_variable(KARTENNAME_VAR, kartenname, scope="project")
 
     def set_plotmassstab_for_auswahl(self, auswahl: str, aktueller_massstab: float | None = None) -> None:
-        """Setzt die Projektvariable ``sn_plotmassstab`` anhand der Maßstabsauswahl."""
+        """Setzt die Projektvariable ``plotmassstab`` anhand der Maßstabsauswahl."""
         if auswahl == MASSSTAB_WIE_KARTENFENSTER:
             if aktueller_massstab and aktueller_massstab > 0:
                 set_variable(PLOTMASSSTAB_VAR, str(int(round(aktueller_massstab))), scope="project")
@@ -304,7 +304,7 @@ class TabBLogic:
         set_variable(PLOTMASSSTAB_VAR, value, scope="project")
 
     def set_view_for_auswahl(self, auswahl: str) -> None:
-        """Setzt ``sn_view`` auf ``aktuell`` oder den Namen des gewählten Layerthemas."""
+        """Setzt die Projektvariable ``view`` auf ``aktuell`` oder den Namen des gewählten Layerthemas."""
         if auswahl == THEMA_WIE_KARTENFENSTER:
             set_variable(VIEW_VAR, "aktuell", scope="project")
             return
@@ -312,11 +312,11 @@ class TabBLogic:
         set_variable(VIEW_VAR, auswahl or "", scope="project")
 
     def set_zielgroesse_for_auswahl(self, auswahl: str) -> None:
-        """Setzt ``sn_zielgroesse`` auf den gewählten DIN-Namen."""
+        """Setzt ``zielgroesse`` auf den gewählten DIN-Namen."""
         set_variable(ZIELGROESSE_VAR, auswahl if auswahl in DIN_GROESSEN else DIN_STANDARD, scope="project")
 
     def set_formfaktor(self, endlosrolle: bool) -> None:
-        """Setzt ``sn_formfaktor`` auf ``Endlosrolle`` oder ``Blatt``."""
+        """Setzt die Projektvariable ``formfaktor`` auf ``Endlosrolle`` oder ``Blatt``."""
         set_variable(FORMFAKTOR_VAR, "Endlosrolle" if endlosrolle else "Blatt", scope="project")
 
     # ─────────────────────────────────────────────────────────────────────────
@@ -358,7 +358,7 @@ class TabBLogic:
             return {"ok": False, "switch_to_tab_a": True, "atlas_seiten": 0}
 
         layer_id = getattr(layer, "id", lambda: "")() or ""
-        set_variable("sn_verfahrensgebietslayer", layer_id, scope="project")
+        set_variable("verfahrensgebietslayer", layer_id, scope="project")
 
         # ─── 2. Kartenname prüfen ─────────────────────────────────────────
         if kartenname_auswahl not in (KARTENNAME_38, KARTENNAME_41):

ui/tab_b_ui.py

@@ -206,7 +206,7 @@ class TabB(QWidget):
         self._endlosrolle_cb.setChecked(saved_formfaktor == "Endlosrolle")
 
     def _on_kartenname_changed(self, value: str) -> None:
-        """Persistiert die Kartennamen-Auswahl und setzt ``sn_kartenname``."""
+        """Persistiert die Kartennamen-Auswahl und setzt ``kartenname``."""
         if value in (KARTENNAME_38, KARTENNAME_41):
             set_variable(KARTENNAME_VAR, value, scope="project")
         else:
@@ -216,26 +216,26 @@ class TabB(QWidget):
             self.logic.set_kartenname_for_auswahl(value)
 
     def _on_massstab_changed(self, value: str) -> None:
-        """Persistiert Maßstabsauswahl und setzt ``sn_plotmassstab``."""
+        """Persistiert Maßstabsauswahl und setzt ``plotmassstab``."""
         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:
-        """Persistiert die Thema-Auswahl und setzt ``sn_view``."""
+        """Persistiert die Thema-Auswahl und setzt ``view``."""
         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:
-        """Persistiert Blattgröße und setzt ``sn_zielgroesse``."""
+        """Persistiert Blattgröße und setzt ``zielgroesse``."""
         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:
-        """Persistiert Endlosrolle-Zustand und setzt ``sn_formfaktor``."""
+        """Persistiert Endlosrolle-Zustand und setzt ``formfaktor``."""
         checked = bool(state)
         set_variable(FORMFAKTOR_UI_VAR, "Endlosrolle" if checked else "Blatt", scope="project")
         if self.logic: