Fehler unter 3.44 behoben

- setResizeToContents(False) deaktiviert Auto-Fit auf Legende korrekt
- fitBoxToContents() + attemptResize() sizing
- Debug-Ausgaben entfernt
- Legende mit fester Breite (Kartenschild), dynamischer Höhe (Inhalt)

Funktioniert für alle Templates: standard (180mm), baufreigabe (80mm), custom.

config/label_configs/baufreigabe.json

@@ -0,0 +1,87 @@
+{
+  "template_name": "baufreigabe",
+  "description": "Baufreigabe-Layout mit 80mm Kartenschild (DIN A3/A4 Querformat)",
+  "kartenschild_width_mm": 80.0,
+  "kartenschild_height_mm": 58.0,
+  "kartenschild_line_offsets_y": [-10.0, -20.0, -30.0, -46.0],
+  "labels": [
+    {
+      "id": "Herausgeber",
+      "object_name": "Herausgeber",
+      "text": "Teilnehmergemeinschaft [%@sn_bezeichnung %] [%@sn_name %]",
+      "x_mm": 14.0,
+      "y_mm": -48.0,
+      "width_mm": 74.0,
+      "height_mm": 8.0,
+      "format": "Format_1",
+      "html_mode": false,
+      "expression_enabled": true,
+      "v_align": "bottom"
+    },
+    {
+      "id": "Bezeichnung_Flurbereinigung",
+      "object_name": "Bezeichnung_Flurbereinigung",
+      "text": "[% @sn_bezeichnung %]",
+      "x_mm": 14.0,
+      "y_mm": -41.0,
+      "width_mm": 74.0,
+      "height_mm": 4.0,
+      "format": "Format_1",
+      "html_mode": false,
+      "expression_enabled": true,
+      "v_align": "top"
+    },
+    {
+      "id": "Name_Flurbereinigung",
+      "object_name": "Name_Flurbereinigung",
+      "text": "[% @sn_name %]",
+      "x_mm": 14.0,
+      "y_mm": -32.0,
+      "width_mm": 74.0,
+      "height_mm": 5.0,
+      "format": "Format_2",
+      "html_mode": false,
+      "expression_enabled": true,
+      "v_align": "top"
+    },
+    {
+      "id": "Kartenname",
+      "object_name": "Kartenname",
+      "text": "[% @sn_kartenname %]",
+      "x_mm": 14.0,
+      "y_mm": -23.0,
+      "width_mm": 74.0,
+      "height_mm": 6.0,
+      "format": "Format_3",
+      "html_mode": false,
+      "expression_enabled": true,
+      "v_align": "top"
+    },
+    {
+      "id": "Ausgabedatum",
+      "object_name": "Ausgabedatum",
+      "text": "Ausgabedatum: [%format_date(now(), 'dd.MM.yyyy')%]",
+      "x_mm": 14.0,
+      "y_mm": -13.0,
+      "width_mm": 74.0,
+      "height_mm": 4.0,
+      "format": "Format_1",
+      "html_mode": false,
+      "expression_enabled": true,
+      "v_align": "top"
+    },
+    {
+      "id": "Massstab",
+      "object_name": "Massstab",
+      "text": "Ma\u00dfstab: 1 : [%round(map_get(item_variables('Hauptkarte'),'map_scale'),0)%]",
+      "x_mm": 14.0,
+      "y_mm": -3.0,
+      "width_mm": 74.0,
+      "height_mm": 4.0,
+      "format": "Format_1",
+      "html_mode": false,
+      "expression_enabled": true,
+      "v_align": "top"
+    }
+  ]
+}

config/label_configs/standard.json

@@ -0,0 +1,153 @@
+{
+  "template_name": "standard",
+  "description": "Standard-Layout mit 180mm Kartenschild fuer §38/§41 FlurbG Karten",
+  "kartenschild_width_mm": 180.0,
+  "kartenschild_height_mm": 92.0,
+  "kartenschild_line_offsets_y": [-10.0, -20.0, -30.0, -46.0, -62.0, -82.0],
+  "labels": [
+    {
+      "id": "Herausgeber",
+      "object_name": "Herausgeber",
+      "text": "Teilnehmergemeinschaft [%@sn_bezeichnung %] [%@sn_name %]",
+      "text_if_kartenname_38": "[%@sn_landkreis_user%] [%@sn_behoerde%]",
+      "x_mm": 16.0,
+      "y_mm": -84.0,
+      "width_mm": 171.0,
+      "height_mm": 4.0,
+      "format": "Format_1",
+      "html_mode": false,
+      "expression_enabled": true,
+      "v_align": "top"
+    },
+    {
+      "id": "Bezeichnung_Flurbereinigung",
+      "object_name": "Bezeichnung_Flurbereinigung",
+      "text": "[% @sn_bezeichnung %]",
+      "x_mm": 16.0,
+      "y_mm": -75.0,
+      "width_mm": 171.0,
+      "height_mm": 4.0,
+      "format": "Format_1",
+      "html_mode": false,
+      "expression_enabled": true,
+      "v_align": "top"
+    },
+    {
+      "id": "Name_Flurbereinigung",
+      "object_name": "Name_Flurbereinigung",
+      "text": "[% @sn_name %]",
+      "x_mm": 16.0,
+      "y_mm": -64.0,
+      "width_mm": 171.0,
+      "height_mm": 5.0,
+      "format": "Format_2",
+      "html_mode": false,
+      "expression_enabled": true,
+      "v_align": "top"
+    },
+    {
+      "id": "Stadt_Gemeinde",
+      "object_name": "Stadt_Gemeinde",
+      "text": "[% @sn_gemeinden %]",
+      "x_mm": 16.0,
+      "y_mm": -56.0,
+      "width_mm": 171.0,
+      "height_mm": 4.0,
+      "format": "Format_1",
+      "html_mode": false,
+      "expression_enabled": true,
+      "v_align": "top"
+    },
+    {
+      "id": "Landkreis",
+      "object_name": "Landkreis",
+      "text": "[% @sn_landkreise_proj %]",
+      "x_mm": 16.0,
+      "y_mm": -48.0,
+      "width_mm": 171.0,
+      "height_mm": 4.0,
+      "format": "Format_1",
+      "html_mode": false,
+      "expression_enabled": true,
+      "v_align": "top"
+    },
+    {
+      "id": "Kartenname",
+      "object_name": "Kartenname",
+      "text": "[% @sn_kartenname %]",
+      "x_mm": 16.0,
+      "y_mm": -32.0,
+      "width_mm": 137.0,
+      "height_mm": 12.0,
+      "format": "Format_3",
+      "html_mode": false,
+      "expression_enabled": true,
+      "v_align": "top"
+    },
+    {
+      "id": "Gefertigt",
+      "object_name": "Gefertigt",
+      "text": "Gefertigt: ",
+      "x_mm": 16.0,
+      "y_mm": -23.0,
+      "width_mm": 81.0,
+      "height_mm": 4.0,
+      "format": "Format_1",
+      "html_mode": false,
+      "expression_enabled": true,
+      "v_align": "top"
+    },
+    {
+      "id": "Gepr\u00fcft",
+      "object_name": "Gepr\u00fcft",
+      "text": "Geprueft: ",
+      "x_mm": 101.0,
+      "y_mm": -23.0,
+      "width_mm": 81.0,
+      "height_mm": 4.0,
+      "format": "Format_1",
+      "html_mode": false,
+      "expression_enabled": true,
+      "v_align": "top"
+    },
+    {
+      "id": "Massstab",
+      "object_name": "Massstab",
+      "text": "Ma\u00dfstab: 1 : [%round(map_get(item_variables('Hauptkarte'),'map_scale'),0)%]",
+      "x_mm": 16.0,
+      "y_mm": -13.0,
+      "width_mm": 81.0,
+      "height_mm": 4.0,
+      "format": "Format_1",
+      "html_mode": false,
+      "expression_enabled": true,
+      "v_align": "top"
+    },
+    {
+      "id": "Ausgabedatum",
+      "object_name": "Ausgabedatum",
+      "text": "Ausgabedatum: [%format_date(now(), 'dd.MM.yyyy')%]",
+      "x_mm": 101.0,
+      "y_mm": -13.0,
+      "width_mm": 81.0,
+      "height_mm": 4.0,
+      "format": "Format_1",
+      "html_mode": false,
+      "expression_enabled": true,
+      "v_align": "top"
+    },
+    {
+      "id": "Aktenzeichen",
+      "object_name": "Aktenzeichen",
+      "text": "Aktenzeichen: XXX",
+      "x_mm": 16.0,
+      "y_mm": -3.0,
+      "width_mm": 171.0,
+      "height_mm": 4.0,
+      "format": "Format_1",
+      "html_mode": false,
+      "expression_enabled": true,
+      "v_align": "top"
+    }
+  ]
+}

config/text_formats.json

@@ -0,0 +1,17 @@
+{
+  "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"
+  }
+}

modules/print_layout.py

@@ -4,7 +4,9 @@ sn_basis/modules/print_layout.py - Aufbau von Einzelblatt-Drucklayouts.
 from __future__ import annotations
 
 import importlib
+import json
 import math
+from pathlib import Path
 from typing import Any
 
 from sn_basis.functions.qt_wrapper import QFont, Qt
@@ -45,13 +47,19 @@ MM = QgsUnitTypes.LayoutMillimeters
 
 
 class PrintLayout:
-    """Erzeugt ein QGIS-Einzelblatt-Layout fuer den Druck."""
+    """Erzeugt ein QGIS-Einzelblatt-Layout fuer den Druck.
+
+    Der optionale Parameter config_name waehlt ein Schriftfeld-Template aus
+    config/label_configs/{config_name}.json. Wird kein Name angegeben, wird
+    "standard" verwendet. Neue Templates koennen ohne Code-Aenderungen durch
+    Erstellen einer neuen JSON-Datei hinzugefuegt werden.
+    """
 
     _FRAME_STROKE_WIDTH_MM = 0.5
-    _LEGEND_WIDTH_MM = 180.0
     _GRID_INTERVAL_MAP_UNITS = 500.0
 
-    _TEXT_FORMAT_TEMPLATES = {
+    # Eingebaute Fallback-Formate fuer den Fall, dass text_formats.json fehlt
+    _TEXT_FORMAT_TEMPLATES_DEFAULT = {
         "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"},
@@ -91,9 +99,51 @@ class PrintLayout:
         "mit teilweise angepasster Signatur<br>"
     )
 
-    def __init__(self, project: Any | None = None) -> None:
+    def __init__(self, project: Any | None = None, config_name: str = "standard") -> None:
         self.project = project or QgsProject.instance()
         self._current_layout: Any | None = None
+        self.config_name = config_name
+        self._label_config = self._load_label_config(config_name)
+        self._TEXT_FORMAT_TEMPLATES = self._load_text_formats()
+        self._LEGEND_WIDTH_MM = float(
+            self._label_config.get("kartenschild_width_mm", 180.0)
+        )
+
+    @staticmethod
+    def _get_config_dir() -> Path:
+        return Path(__file__).parent.parent / "config"
+
+    def _load_label_config(self, config_name: str) -> dict:
+        """Laedt Schriftfeld-Konfiguration aus config/label_configs/{config_name}.json.
+
+        Raises:
+            FileNotFoundError: Wenn die Konfigurationsdatei nicht existiert.
+            ValueError: Wenn die JSON-Datei nicht geparst werden kann.
+        """
+        config_file = self._get_config_dir() / "label_configs" / f"{config_name}.json"
+        if not config_file.exists():
+            raise FileNotFoundError(
+                f"Label-Config '{config_name}' nicht gefunden: {config_file}"
+            )
+        try:
+            with open(config_file, encoding="utf-8") as fh:
+                return json.load(fh)
+        except json.JSONDecodeError as exc:
+            raise ValueError(f"JSON-Fehler in {config_file}: {exc}") from exc
+
+    def _load_text_formats(self) -> dict:
+        """Laedt zentrale Schriftformat-Definitionen aus config/text_formats.json.
+
+        Faellt auf eingebaute Standardwerte zurueck, wenn die Datei fehlt.
+        """
+        formats_file = self._get_config_dir() / "text_formats.json"
+        if not formats_file.exists():
+            return dict(self._TEXT_FORMAT_TEMPLATES_DEFAULT)
+        try:
+            with open(formats_file, encoding="utf-8") as fh:
+                return json.load(fh)
+        except (json.JSONDecodeError, OSError):
+            return dict(self._TEXT_FORMAT_TEMPLATES_DEFAULT)
 
     def _create_map_item(
         self,
@@ -247,17 +297,51 @@ class PrintLayout:
         map_height_mm: float,
         kartenname_auswahl: str = "",
     ) -> None:
+        """Richtet Legende, Quellenangabe und Kartenschild ein.
+
+        Delegiert an _setup_layout_objects_from_config() unter Aufloesung
+        des optionalen kartenname_auswahl-Parameters fuer §38-spezifische Texte.
+        """
+        self._setup_layout_objects_from_config(
+            kartenfenster_untere_rechte_ecke_mm,
+            hauptkarte,
+            map_top_mm,
+            map_height_mm,
+            kartenname_auswahl=kartenname_auswahl,
+        )
+
+    def _setup_layout_objects_from_config(
+        self,
+        kartenfenster_untere_rechte_ecke_mm: tuple,
+        hauptkarte: Any,
+        map_top_mm: float,
+        map_height_mm: float,
+        kartenname_auswahl: str = "",
+    ) -> None:
+        """Erstellt Legende, Quellenangabe, Kartenschild und alle Labels aus der JSON-Config.
+
+        Die Label-Definitionen werden vollstaendig aus self._label_config geladen.
+        Einzige Ausnahme: Das Feld "text_if_kartenname_38" in einem Label-Eintrag
+        erlaubt einen alternativen Text speziell fuer kartenname_auswahl == '§38'.
+        """
         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]:
+        kartenschild_width_mm = float(self._label_config.get("kartenschild_width_mm", 180.0))
+        kartenschild_height_mm = float(self._label_config.get("kartenschild_height_mm", 92.0))
+        kartenschild_line_offsets_y: list[float] = [
+            float(v) for v in self._label_config.get("kartenschild_line_offsets_y", [-10.0, -20.0, -30.0, -46.0, -62.0, -82.0])
+        ]
+
+        def _coords(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
         legende_x = kartenfenster_untere_rechte_ecke_mm[0] + 10.0
-        legende_height_mm = max(map_height_mm - 122.0, 20.0)
+        legende_height_mm = 50.0  # Klein anfangen, fitBoxToContents() wird es vergrößern
         legende_y = map_top_mm
         legende = self._create_legend_item(
             self._current_layout,
@@ -265,36 +349,36 @@ class PrintLayout:
             hauptkarte,
             legende_x,
             legende_y,
-            width_mm=self._LEGEND_WIDTH_MM,
+            width_mm=kartenschild_width_mm,
             height_mm=legende_height_mm,
             object_name="Legende",
         )
-
+        
         legende_hoehe_mm = self._configure_legend_size(
             legende,
-            width_limit_mm=self._LEGEND_WIDTH_MM,
+            width_limit_mm=kartenschild_width_mm,
             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
+        quellenangabe_x, quellenangabe_y = _coords(10.0, -102.0)
+        quellenangabe_obere_y = quellenangabe_y - 20.0
         legende_untere_y = legende_y + legende_hoehe_mm
 
         if legende_untere_y > quellenangabe_obere_y:
-            self._configure_legend_size(
+            legende_hoehe_mm = self._configure_legend_size(
                 legende,
-                width_limit_mm=self._LEGEND_WIDTH_MM,
+                width_limit_mm=kartenschild_width_mm,
                 column_count=2,
                 equal_column_width=True,
             )
 
+        # Quellenangabe
         self.add_text_label(
             self._QUELLENANGABE_TEXT,
             quellenangabe_x,
             quellenangabe_y,
-            width_mm=self._LEGEND_WIDTH_MM,
+            width_mm=kartenschild_width_mm,
             height_mm=20.0,
             text_format="Format_1",
             html_mode=True,
@@ -302,72 +386,52 @@ class PrintLayout:
             object_name="Quellenangabe",
         )
 
-        kartenschild_x, kartenschild_y = _coords_rel_untere_rechte_ecke(10.0, 0.0)
+        # Kartenschild-Rahmen
+        kartenschild_x, kartenschild_y = _coords(10.0, 0.0)
         self._create_rectangle_box_item(
             self._current_layout,
             "Kartenschild",
             kartenschild_x,
             kartenschild_y,
-            self._LEGEND_WIDTH_MM,
-            92.0,
+            kartenschild_width_mm,
+            kartenschild_height_mm,
             stroke_width_mm=self._FRAME_STROKE_WIDTH_MM,
         )
 
-        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)
+        # Kartenschild-Trennlinien
+        kartenschild_line_x, _ = _coords(10.0, 0.0)
         for index, offset_y in enumerate(kartenschild_line_offsets_y, start=1):
-            _, line_y = _coords_rel_untere_rechte_ecke(0.0, offset_y)
+            _, line_y = _coords(0.0, offset_y)
             self._create_rectangle_box_item(
                 self._current_layout,
                 f"Kartenschild_Linie_{index}",
                 kartenschild_line_x,
                 line_y,
-                self._LEGEND_WIDTH_MM,
+                kartenschild_width_mm,
                 0.0,
                 stroke_width_mm=0.1,
             )
 
-        if kartenname_auswahl == "§38":
-            herausgeber_text = "[%@sn_landkreis_user%] [%@sn_behoerde%]"
-        else:
-            herausgeber_text = "Teilnehmergemeinschaft [%@sn_bezeichnung %] [%@sn_name %]"
+        # Labels aus Config
+        for label_def in self._label_config.get("labels", []):
+            # Alternativer Text fuer §38-Karten (falls in Config definiert)
+            if kartenname_auswahl == "§38" and "text_if_kartenname_38" in label_def:
+                text = label_def["text_if_kartenname_38"]
+            else:
+                text = label_def["text"]
 
-        labels = [
-            (herausgeber_text, 16.0, -84.0, 171.0, 4.0, "Format_1", "Herausgeber"),
-            ("[% @sn_bezeichnung %]", 16.0, -75.0, 171.0, 4.0, "Format_1", "Bezeichnung_Flurbereinigung"),
-            ("[% @sn_name %]", 16.0, -64.0, 171.0, 5.0, "Format_2", "Name_Flurbereinigung"),
-            ("[% @sn_gemeinden %]", 16.0, -56.0, 171.0, 4.0, "Format_1", "Stadt_Gemeinde"),
-            ("[% @sn_landkreise_proj %]", 16.0, -48.0, 171.0, 4.0, "Format_1", "Landkreis"),
-            ("[% @sn_kartenname %]", 16.0, -32.0, 137.0, 12.0, "Format_3", "Kartenname"),
-            ("Gefertigt: ", 16.0, -23.0, 81.0, 4.0, "Format_1", "Gefertigt"),
-            ("Geprueft: ", 101.0, -23.0, 81.0, 4.0, "Format_1", "Geprüft"),
-            (
-                "Maßstab: 1 : [%round(map_get(item_variables('Hauptkarte'),'map_scale'),0)%]",
-                16.0,
-                -13.0,
-                81.0,
-                4.0,
-                "Format_1",
-                "Massstab",
-            ),
-            ("Ausgabedatum: [%format_date(now(), 'dd.MM.yyyy')%]", 101.0, -13.0, 81.0, 4.0, "Format_1", "Ausgabedatum"),
-            ("Aktenzeichen: ", 16.0, -3.0, 171.0, 4.0, "Format_1", "Aktenzeichen"),
-        ]
-
-        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)
+            x, y = _coords(float(label_def["x_mm"]), float(label_def["y_mm"]))
             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,
+                width_mm=float(label_def["width_mm"]),
+                height_mm=float(label_def["height_mm"]),
+                text_format=label_def.get("format", "Format_1"),
+                html_mode=bool(label_def.get("html_mode", False)),
+                expression_enabled=bool(label_def.get("expression_enabled", True)),
+                object_name=label_def.get("object_name") or label_def.get("id"),
+                v_align=label_def.get("v_align", "top"),
             )
 
     def _create_label_item(
@@ -661,6 +725,14 @@ class PrintLayout:
             except Exception:
                 pass
 
+        # Deaktiviere Auto-Fit: Größe an Inhalt anpassen soll aus sein
+        set_resize_to_contents = getattr(legend, "setResizeToContents", None)
+        if callable(set_resize_to_contents):
+            try:
+                set_resize_to_contents(False)
+            except Exception:
+                pass
+
         set_column_count = getattr(legend, "setColumnCount", None)
         if callable(set_column_count):
             try:
@@ -682,17 +754,30 @@ class PrintLayout:
             except Exception:
                 pass
 
-        adjust_box_size = getattr(legend, "adjustBoxSize", None)
-        if callable(adjust_box_size):
+        # Versuche fitBoxToContents() zuerst, dann Fallback zu adjustBoxSize()
+        fit_box_to_contents = getattr(legend, "fitBoxToContents", None)
+        if callable(fit_box_to_contents):
             try:
-                adjust_box_size()
+                fit_box_to_contents()
             except Exception:
                 pass
+        else:
+            adjust_box_size = getattr(legend, "adjustBoxSize", None)
+            if callable(adjust_box_size):
+                try:
+                    adjust_box_size()
+                except Exception:
+                    pass
 
         _, updated_height_mm = self._get_item_size_mm(legend)
         if updated_height_mm is None:
             updated_height_mm = 20.0
 
+        # Breite auf Kartenschild-Breite setzen, Höhe an Inhalt angepasst behalten
+        legend.attemptResize(
+            QgsLayoutSize(width_limit_mm, updated_height_mm, MM)
+        )
+
         if callable(set_locked):
             try:
                 set_locked(True)

modules/print_layout_baufreigabe.py

@@ -1,9 +1,8 @@
 """
 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.
+Baufreigabe-Layouts verwenden immer feste DIN A3/A4 Seitengroessen im Querformat.
+Das Schriftfeld (80mm breit) wird ueber config/label_configs/baufreigabe.json definiert.
 
 Atlas-Integration erfolgt nach Layouterstellung durch externe Konfiguration
 in der PrintLogic.
@@ -12,11 +11,7 @@ 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,
@@ -32,60 +27,19 @@ MM = QgsUnitTypes.LayoutMillimeters
 
 
 class PrintLayoutBaufreigabe(PrintLayout):
-    """Erzeugt QGIS-Einzelblatt-Layouts mit fester DIN A3/A4 Querformat-Groesse und 80mm Kartenschild."""
+    """Erzeugt QGIS-Einzelblatt-Layouts mit fester DIN A3/A4 Querformat-Groesse.
+
+    Schriftfeld-Definition kommt aus config/label_configs/baufreigabe.json.
+    """
 
-    _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 __init__(self, project: Any | None = None, config_name: str = "baufreigabe") -> None:
+        super().__init__(project, config_name=config_name)
 
     def create_baufreigabe_layout(
         self,
@@ -110,9 +64,10 @@ class PrintLayoutBaufreigabe(PrintLayout):
             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
+            atlas_driven: Atlas-Steuerung fuer die Hauptkarte aktivieren
 
         Returns:
-            QgsPrintLayout objektInstance (wird im Layout-Dialog geoeffnet)
+            QgsPrintLayout-Instanz (wird im Layout-Designer geoeffnet)
 
         Raises:
             ValueError: Falls Name bereits existiert oder Format ungueltig ist
@@ -174,7 +129,6 @@ class PrintLayoutBaufreigabe(PrintLayout):
                 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):
@@ -247,7 +201,7 @@ class PrintLayoutBaufreigabe(PrintLayout):
 
         self._configure_hauptkarte_grids(hauptkarte)
 
-        self._setup_layout_objects_baufreigabe(
+        self._setup_layout_objects(
             kartenfenster_untere_rechte_ecke_mm,
             hauptkarte,
             map_top_mm,
@@ -259,138 +213,6 @@ class PrintLayoutBaufreigabe(PrintLayout):
         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

modules/print_logic.py

@@ -1166,6 +1166,7 @@ class PrintLogic:
         zielgroesse: str,
         formfaktor: bool,
         druckbereich_auswahl: str,
+        schriftfeld_template: str = "",
     ) -> dict:
         resolved_layer = layer or self._resolve_layer_from_project()
 
@@ -1270,8 +1271,9 @@ class PrintLogic:
         try:
             if kartenname_auswahl == KARTENNAME_BAUFREIGABE:
                 # Baufreigabe: feste DIN A3/A4 Querformat-Logik mit 80mm Kartenschild
+                config_to_use = schriftfeld_template or "baufreigabe"
                 din_format = "DIN A3" if auto_page_w >= 420.0 else "DIN A4"
-                PrintLayoutBaufreigabe().create_baufreigabe_layout(
+                PrintLayoutBaufreigabe(config_name=config_to_use).create_baufreigabe_layout(
                     name=vorlage_name if vorlage_name != kartenname else "Baufreigabe",
                     din_format=din_format,
                     map_width_mm=auto_map_w,
@@ -1284,7 +1286,8 @@ class PrintLogic:
                 )
             else:
                 # Standard-Layout: dynamische Groessenanpassung
-                PrintLayout().create_single_page_layout(
+                config_to_use = schriftfeld_template or "standard"
+                PrintLayout(config_name=config_to_use).create_single_page_layout(
                     name=vorlage_name,
                     page_width_mm=auto_page_w,
                     page_height_mm=auto_page_h,

ui/tabs/print_tab.py

@@ -3,6 +3,7 @@ sn_basis/ui/tabs/print_tab.py - Zentraler Druck-Tab fuer sn-Plugins.
 """
 from __future__ import annotations
 
+from pathlib import Path
 from typing import Any, Optional
 
 from sn_basis.functions.qt_wrapper import (
@@ -85,6 +86,7 @@ class PrintTab(QWidget):
         self._atlas_erzeugen_cb: Optional[Any] = None
         self._atlas_button: Optional[Any] = None
         self._atlas_content: Optional[Any] = None
+        self._schriftfeld_combo: Optional[Any] = None
 
         self._build_ui()
         self._restore_state()
@@ -256,6 +258,16 @@ class PrintTab(QWidget):
         self._atlas_content = atlas_content
         main_layout.addWidget(atlas_content)
 
+        schriftfeld_label = QLabel("Schriftfeld-Template")
+        schriftfeld_label.setStyleSheet("font-weight: bold; margin-top: 6px;")
+        main_layout.addWidget(schriftfeld_label)
+
+        schriftfeld_combo = QComboBox(self)
+        schriftfeld_combo.addItems(self._get_available_templates())
+        schriftfeld_combo.currentTextChanged.connect(self._on_schriftfeld_changed)
+        self._schriftfeld_combo = schriftfeld_combo
+        main_layout.addWidget(schriftfeld_combo)
+
         btn_vorlage_erstellen = QPushButton("Vorlage erstellen", self)
         btn_vorlage_erstellen.clicked.connect(self._on_vorlage_erstellen)
         self._btn_vorlage_erstellen = btn_vorlage_erstellen
@@ -329,6 +341,14 @@ class PrintTab(QWidget):
             self._atlas_erzeugen_cb.setChecked(atlas_checked)
             self._on_atlas_erzeugen_changed(1 if atlas_checked else 0)
 
+        if self._schriftfeld_combo:
+            saved_schriftfeld = get_variable("tab_b_schriftfeld_template", scope="project")
+            available_templates = self._get_available_templates()
+            if saved_schriftfeld in available_templates:
+                self._schriftfeld_combo.setCurrentText(saved_schriftfeld)
+            else:
+                self._schriftfeld_combo.setCurrentText("standard")
+
         self._restore_atlas_layer_selection()
 
     def _on_kartenname_changed(self, value: str) -> None:
@@ -436,6 +456,7 @@ class PrintTab(QWidget):
             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,
+            schriftfeld_template=self._schriftfeld_combo.currentText() if self._schriftfeld_combo else "",
         )
 
     def _disconnect_project_signals(self) -> None:
@@ -706,3 +727,29 @@ class PrintTab(QWidget):
             pass
 
         self._atlas_layer_combo.blockSignals(False)
+
+    def _get_available_templates(self) -> list[str]:
+        """Liest verfügbare Schriftfeld-Vorlagen aus dem config/label_configs Verzeichnis."""
+        config_dir = Path(__file__).parent.parent / "config" / "label_configs"
+        templates: list[str] = []
+        
+        try:
+            if config_dir.exists() and config_dir.is_dir():
+                for json_file in config_dir.glob("*.json"):
+                    template_name = json_file.stem
+                    if template_name and template_name not in templates:
+                        templates.append(template_name)
+        except Exception:
+            pass
+
+        if not templates:
+            templates = ["standard", "baufreigabe"]
+        elif "standard" not in templates:
+            templates.insert(0, "standard")
+
+        return sorted(templates)
+
+    def _on_schriftfeld_changed(self, template_name: str) -> None:
+        """Handler wenn Schriftfeld-Template wechselt."""
+        set_variable("tab_b_schriftfeld_template", template_name, scope="project")
+