[ADD] Gerüst Träger können nun über das Menü in Bricscad eingefügt werden wie durch die Bihler Bibliothek; Beschriftungsausrichtung nach Norm korrigiert; Nachträgliche Beschriftung über Makro für alle platzierten Träger möglich

Lisp/GeruestInsert.lsp

@@ -67,6 +67,24 @@
   )
 )
 
+;; Rohr-Geruest-Traeger: dasselbe Schema plus die beiden Laengenabzuege und
+;; VARIANTE (Name der Geometrie-Variante). Bewusst ein eigenes Schema - die
+;; anderen GR_-Bloecke behalten ihres. LAENGE ist beim Traeger die
+;; NETTO-Laenge (Strecke minus Abzuege). VARIANTE macht den Block
+;; selbstbeschreibend: GERUEST_TRAEGER_BESCHRIFTEN findet darueber die
+;; Formatierung der Beschriftung, ohne den Dialog zu kennen.
+;; Ohne null-Guard: ein Neuladen der Datei soll ein erweitertes Schema sofort
+;; wirksam machen.
+(setq *geruest-traeger-attrib-defs*
+  (append *geruest-attrib-defs*
+          '(("LAENGENABZUGANFANG" "")
+            ("LAENGENABZUGENDE"   "")
+            ("VARIANTE"           "")))
+)
+
+;; XDATA-App der Traeger-Beschriftung: Gruppe 1005 = Handle des Traeger-Blocks.
+(setq *geruest-beschr-app* "SSG_GR_BESCHR")
+
 (if (null *geruest-block-counter*) (setq *geruest-block-counter* 0))
 
 
@@ -116,10 +134,14 @@
 
 ;; Alle Baugruppen als ((id . objekt) ...) in Dateireihenfolge - diese
 ;; Reihenfolge bestimmt auch die Reihenfolge im Bereichs-Dropdown.
+;; Baugruppen mit "einfuegeart": "linie" (Rohr-Geruest-Traeger) fehlen hier:
+;; sie haben einen eigenen Dialog und einen eigenen Einfuegeablauf
+;; (c:GERUEST_TRAEGER) und gehoeren nicht in das Bereichs-Dropdown.
 (defun geruest-baugruppen-liste ( / erg)
   (setq erg nil)
   (foreach eintrag (geruest-daten)
-    (if (listp (cdr eintrag))
+    (if (and (listp (cdr eintrag))
+             (not (equal (ssg-json-get (cdr eintrag) "einfuegeart") "linie")))
       (setq erg (append erg
                   (list (cons (ssg-json-get (cdr eintrag) "id") (cdr eintrag)))))
     )
@@ -623,17 +645,44 @@
   (princ)
 )
 
-;; Aktuell gewaehlte Farbe als Text.
+;; Farbliste des Dialogs aus der TEILEFARBE-Definition aufbauen: Optionen +
-(defun geruest-dlg-farbwert ( / idx)
+;; freie Option ans Listenende; deren Index merkt sich der Callback, um das
-  (setq idx (atoi *geruest-dlg-farbe*))
+;; Freitextfeld freizuschalten. Genutzt vom GERUEST- und vom Traeger-Dialog.
+(defun geruest-farb-liste-setzen (farb-opts / frei-opt)
+  (setq *geruest-farb-liste* nil *geruest-frei-idx* -1)
+  (if farb-opts
+    (progn
+      (setq *geruest-farb-liste* (ssg-json-get farb-opts "optionen"))
+      (if (ssg-json-get farb-opts "frei_erlaubt")
+        (progn
+          (setq frei-opt (ssg-json-get farb-opts "frei_option"))
+          (if (null frei-opt) (setq frei-opt "Individuell"))
+          (setq *geruest-frei-idx* (length *geruest-farb-liste*))
+          (setq *geruest-farb-liste*
+                (append *geruest-farb-liste* (list frei-opt)))
+        )
+      )
+    )
+  )
+)
+
+;; Gewaehlte Farbe als Text. idx-str = Tile-Wert der Farbliste,
+;; frei = Inhalt des Freitextfelds.
+(defun geruest-farbwert (idx-str frei / idx)
+  (setq idx (atoi idx-str))
   (cond
     ((null *geruest-farb-liste*) "")
-    ((= idx *geruest-frei-idx*) *geruest-dlg-frei*)
+    ((= idx *geruest-frei-idx*) frei)
     ((nth idx *geruest-farb-liste*) (nth idx *geruest-farb-liste*))
     (T "")
   )
 )
 
+;; Aktuell gewaehlte Farbe des GERUEST-Dialogs als Text.
+(defun geruest-dlg-farbwert ( / )
+  (geruest-farbwert *geruest-dlg-farbe* *geruest-dlg-frei*)
+)
+
 ;; Konfiguration anwenden und die Tiles nachziehen. Wird direkt aus dem
 ;; popup_list-Rueckruf aufgerufen - set_tile aendert die Anzeige im laufenden
 ;; Dialog, ein Neuaufbau ist nicht noetig. Index 0 = "(keine)".
@@ -919,33 +968,17 @@
 ;;   ("WECHSEL" bereich-index) - Nutzer hat den Bereich umgestellt
 ;;   nil - abgebrochen
 (defun geruest-dialog (bg bereich-idx bereiche / dcl-pfad dat attr laenge-def
-                         farb-opts frei-opt min-l max-l fertig rueckgabe
+                         farb-opts min-l max-l fertig rueckgabe
                          ergebnis wert-l oben-m unten-m name neu-idx)
   (setq *geruest-varianten*  (ssg-json-get bg "geometrie_varianten"))
   (setq *geruest-anbauteile* (ssg-json-get bg "anbaugruppen"))
   (setq attr       (ssg-json-get bg "attribute"))
-  (setq laenge-def (if attr (ssg-json-get attr "Laenge")))
+  (setq laenge-def (if attr (ssg-json-get attr "LAENGE")))
-  (setq farb-opts  (if attr (ssg-json-get attr "Teilefarbe")))
+  (setq farb-opts  (if attr (ssg-json-get attr "TEILEFARBE")))
   (setq min-l (if laenge-def (ssg-json-get laenge-def "min")))
   (setq max-l (if laenge-def (ssg-json-get laenge-def "max")))
 
-  ;; Farboptionen + freie Option ans Listenende; Index davon merkt sich der
+  (geruest-farb-liste-setzen farb-opts)
-  ;; Callback, um das Freitextfeld freizuschalten.
-  (setq *geruest-farb-liste* nil *geruest-frei-idx* -1)
-  (if farb-opts
-    (progn
-      (setq *geruest-farb-liste* (ssg-json-get farb-opts "optionen"))
-      (if (ssg-json-get farb-opts "frei_erlaubt")
-        (progn
-          (setq frei-opt (ssg-json-get farb-opts "frei_option"))
-          (if (null frei-opt) (setq frei-opt "Individuell"))
-          (setq *geruest-frei-idx* (length *geruest-farb-liste*))
-          (setq *geruest-farb-liste*
-                (append *geruest-farb-liste* (list frei-opt)))
-        )
-      )
-    )
-  )
 
   (setq *geruest-konfig-liste* (geruest-konfigs bg))
   ;; Frueheren Stand dieses Bereichs wiederherstellen, sonst Ausgangszustand
@@ -1136,7 +1169,7 @@
 ;; als reine Geometrie bei 0,0,0 mit in den Block wandern.
 ;; Rueckgabe: (blockname . entity) oder nil.
 (defun geruest-block-bauen (bg variante werte pt teile-dwgs / datei dummy lastEnt dummyEnt
-                               e ss bname blockEnt dummy-attribs attribs)
+                               dummy-attribs attribs)
   ;; Eine Variante darf eine eigene Dummy-DWG mitbringen; sonst gilt die der
   ;; Baugruppe.
   (setq datei (geruest-variante-wert variante bg "dummy"))
@@ -1173,6 +1206,22 @@
       ;; ssg-attrib-merge legt alle Tags aus *geruest-attrib-defs* an und
       ;; uebernimmt zusaetzlich alle Tags der Dummy-DWG.
       (setq attribs (ssg-attrib-merge dummy-attribs *geruest-attrib-defs*))
+      ;; nil = Drehwinkel interaktiv am Cursor
+      (geruest-block-abschliessen bg attribs werte lastEnt pt nil)
+    )
+  )
+)
+
+;; Gemeinsamer Schluss aller Geruest-Bloecke: Werte ins Schema eintragen,
+;; ATTDEFs erzeugen, alles Neue seit lastEnt zu GR_<id>_<ts> zusammenfassen
+;; und bei pt einfuegen.
+;; attribs = Schema-Alist (Tags + Vorgabewerte), werte = berechnete Werte
+;; rot     = Drehwinkel in Grad (Zahl) oder nil fuer interaktive Drehung.
+;;           Bei einer Zahl muss der Aufrufer ANGBASE/ANGDIR/AUNITS auf 0
+;;           gesetzt haben, sonst deutet INSERT den Wert anders.
+;; Rueckgabe: (blockname . entity) oder nil.
+(defun geruest-block-abschliessen (bg attribs werte lastEnt pt rot
+                                    / e ss bname blockEnt)
   (foreach paar werte
     (if (assoc (car paar) attribs)
       (setq attribs (subst paar (assoc (car paar) attribs) attribs))
@@ -1182,7 +1231,7 @@
 
   (ssg-attrib-make-defs (ssg-attrib-alist-to-defs attribs) 50.0)
 
-      ;; Alles Neue seit lastEnt einsammeln (Dummy-INSERT + ATTDEFs)
+  ;; Alles Neue seit lastEnt einsammeln (Geometrie + ATTDEFs)
   (setq ss (ssadd))
   (setq e (if lastEnt (entnext lastEnt) (entnext)))
   (while e
@@ -1198,8 +1247,7 @@
   ;; fremdes Objekt - ohne diesen Vergleich wuerden dessen Attribute
   ;; ueberschrieben.
   (setq lastEnt (entlast))
-      ;; pause = Drehwinkel interaktiv am Cursor
+  (command "_.INSERT" bname pt 1 1 (if rot rot pause))
-      (command "_.INSERT" bname pt 1 1 pause)
   ;; Laufende Einfuegung sicher beenden (z.B. ESC waehrend der Drehung)
   (if (> (getvar "CMDACTIVE") 0) (command))
   (if (> (getvar "CMDACTIVE") 0) (command))
@@ -1213,8 +1261,6 @@
       (cons bname blockEnt)
     )
   )
-    )
-  )
 )
 
 
@@ -1362,5 +1408,800 @@
 (defun c:GERUEST_ROHRABHAENGER ( / ) (geruest-starten "Rohrabhaenger"))
 (defun c:GERUEST_WANDBEFESTIGUNG ( / ) (geruest-starten "Wandbefestigung"))
 
-(princ "\nGeruestInsert.lsp geladen. Befehle: GERUEST, GERUEST_SAEULEN, GERUEST_ROHRABHAENGER, GERUEST_WANDBEFESTIGUNG")
+
+;; ============================================================
+;; ROHR-GERUEST-TRAEGER (Baugruppe mit "einfuegeart": "linie")
+;; ============================================================
+;; Eigener Dialog (dcl/geruest_traeger.dcl): Variante, Farbe und zwei
+;; Laengenabzuege. Die Laenge selbst wird DANACH in der Zeichnung bestimmt -
+;; Startpunkt, dann Endpunkt oder getippte Laenge (+ Richtung), wie beim
+;; Kreisel. Aktive Abzuege ruecken die Linie beidseitig ein: Strecke 1000,
+;; Abzug Anfang 20, Ende 35 -> Linie beginnt 20 mm hinter dem Startklick und
+;; ist 945 mm lang.
+;;
+;; Keine Dummy-DWG: die Geometrie ist eine einzige LINE, die je Block eine
+;; andere Laenge hat. Sie entsteht per entmake von (0,0,0) nach (L,0,0) auf
+;; dem Layer der Variante; der Block wird am eingerueckten Startpunkt mit dem
+;; Richtungswinkel eingefuegt. Es wird wiederholt eingefuegt, bis der Nutzer
+;; ESC/Enter drueckt - jeder Traeger ist ein eigener GR_Traeger_<ts>-Block.
+
+;; Baugruppe ueber das ASCII-Feld "id" (auch solche, die
+;; geruest-baugruppen-liste auslaesst).
+(defun geruest-baugruppe (id / erg)
+  (setq erg nil)
+  (foreach eintrag (geruest-daten)
+    (if (and (null erg) (listp (cdr eintrag))
+             (equal (ssg-json-get (cdr eintrag) "id") id))
+      (setq erg (cdr eintrag))
+    )
+  )
+  erg
+)
+
+;; Feld einer Attribut-Definition (attribute -> TAG -> feld). Eine Variante
+;; darf einen eigenen "attribute"-Block mitbringen, der vor dem der Baugruppe
+;; gilt (z.B. ein anderer Laengenabzug bei einer Muffen-Variante). assoc
+;; statt ssg-json-get, damit ein in der Variante gesetztes false (= nil) den
+;; Wert der Baugruppe ueberschreibt, statt als "fehlt" durchzufallen.
+(defun geruest-attr-feld (variante bg tag feld)
+  (geruest-obj-feld variante bg (list "attribute" tag) feld)
+)
+
+;; Objekt unter einem Schluesselpfad, z.B. ("attribute" "LAENGE"); nil, wenn
+;; ein Schluessel fehlt.
+(defun geruest-json-pfad-get (obj pfad)
+  (foreach k pfad (setq obj (if (and obj (listp obj)) (ssg-json-get obj k))))
+  obj
+)
+
+;; Allgemeine Form von geruest-attr-feld: Feld unter pfad, Variante vor
+;; Baugruppe, je FELD aufgeloest (eine Variante nennt nur, was abweicht).
+;; Genutzt fuer "attribute" und "beschriftung".
+(defun geruest-obj-feld (variante bg pfad feld / def paar)
+  (setq def (if variante (geruest-json-pfad-get variante pfad)))
+  (setq paar (if (and def (listp def)) (assoc feld def)))
+  (if paar
+    (cdr paar)
+    (ssg-json-get (geruest-json-pfad-get bg pfad) feld)
+  )
+)
+
+;; Millimeter-Eingabe als Zahl >= 0 (Komma wie Punkt), sonst nil.
+;; Leere Eingabe -> nil.
+(defun geruest-mm-zahl (s / w)
+  (setq s (vl-string-translate "," "." (ssg-cfg-trim (if s s ""))))
+  (if (and (/= s "") (setq w (distof s 2)) (>= w 0.0)) w)
+)
+
+;; Abzug-Feld: leer -> 0, gueltige Zahl -> Zahl, sonst nil.
+(defun geruest-abzug-wert (s)
+  (if (= (ssg-cfg-trim (if s s "")) "")
+    0.0
+    (geruest-mm-zahl s)
+  )
+)
+
+;; Millimeterwert fuer Attribute/Meldungen: ganze Zahl ohne Nachkommastelle,
+;; sonst eine Stelle.
+(defun geruest-mm-string (w / r)
+  (setq r (fix (+ w 0.5)))
+  (if (equal w r 1e-6) (itoa r) (rtos w 2 1))
+)
+
+;; Netto-Laenge der Linie: Strecke minus beide Abzuege, nil wenn <= 0.
+(defun geruest-traeger-laenge (strecke abzug-a abzug-e / netto)
+  (setq netto (- strecke (if abzug-a abzug-a 0.0) (if abzug-e abzug-e 0.0)))
+  (if (> netto 1e-6) netto)
+)
+
+;; Eingerueckter Startpunkt: abzug-a entlang winkel ab p1, Z von p1.
+(defun geruest-traeger-start (p1 winkel abzug-a / p)
+  (setq p (polar p1 winkel (if abzug-a abzug-a 0.0)))
+  (list (car p) (cadr p) (if (caddr p1) (caddr p1) 0.0))
+)
+
+;; Positionen der Querstreben entlang der Traegerlinie (Abstand ab Linienanfang).
+;; Regeln: Abstand zwischen zwei Streben hoechstens abstand-max, beide
+;; Endabstaende gleich und in [rand-min, rand-max], so wenige Streben wie
+;; moeglich.
+;;   netto <= 2*rand-max -> eine Strebe in der Mitte
+;;   sonst               -> k = aufgerundet (netto - 2*rand-max) / abstand-max
+;;                          Felder (= wenigste Streben). Rand
+;;                          r = max(rand-min, (netto - k*abstand-max) / 2):
+;;                          der Abstand ist damit GENAU abstand-max, solange der
+;;                          Rand >= rand-min bleibt; nur sonst bleibt der Rand
+;;                          bei rand-min und der Abstand wird etwas kleiner.
+;; Mit genau abstand-max geht nicht jede Laenge auf (1100 mm: 2 Streben ->
+;; Rand 300, 3 Streben -> Rand 50) - dort ergibt sich 100 | 450 | 450 | 100.
+;; r <= rand-max ist durch die Wahl von k garantiert.
+;; Kuerzer als 2*rand-min -> keine Strebe (der Mindestrand waere verletzt).
+(defun geruest-traeger-streben (netto abstand-max rand-min rand-max / k r s i erg)
+  (cond
+    ((or (null netto) (< netto (- (* 2.0 rand-min) 1e-6))) nil)
+    ((<= netto (+ (* 2.0 rand-max) 1e-6)) (list (/ netto 2.0)))
+    (T
+      (setq k (/ (- netto (* 2.0 rand-max)) abstand-max))
+      ;; aufrunden, Rundungsrauschen (z.B. 2.0000000001) nicht mitzaehlen
+      (setq k (if (equal k (fix k) 1e-6) (fix k) (1+ (fix k))))
+      (setq r (max rand-min (/ (- netto (* k abstand-max)) 2.0)))
+      (setq s (/ (- netto (* 2.0 r)) k))
+      (setq erg nil i k)
+      (while (>= i 0)
+        (setq erg (cons (+ r (* i s)) erg))
+        (setq i (1- i))
+      )
+      erg
+    )
+  )
+)
+
+;; Querstreben-Konfiguration (Variante vor Baugruppe) als
+;; (dummy laenge querlinie abstand-max rand-min rand-max) oder nil, wenn keine
+;; "querstrebe" definiert ist.
+;;   dummy     = DWG unter data/geruest (Basispunkt Strebenmitte, 30 mm laengs
+;;               X) oder nil
+;;   laenge/querlinie = nur fuer den Rueckfall ohne Dummy-DWG: zwei Querlinien
+;;               im Abstand laenge, je querlinie lang
+;; Fehlende Zahlenwerte -> Standard 30/25/500/100/250.
+(defun geruest-traeger-strebe-cfg (variante bg / q w d)
+  (setq q (geruest-variante-wert variante bg "querstrebe"))
+  (if (and q (listp q))
+    (progn
+      (setq d (ssg-json-get q "dummy"))
+      (cons (if (and d (= (type d) 'STR) (/= d "")) d)
+            (mapcar '(lambda (feld std)
+                       (setq w (ssg-json-get q feld))
+                       (if (numberp w) (float w) std))
+                    '("laenge" "querlinie" "abstand_max" "rand_min" "rand_max")
+                    '(30.0 25.0 500.0 100.0 250.0)))
+    )
+  )
+)
+
+;; Muffen-Dummy einer Variante: nur bei "mit_muffe": true die "dummy"-Datei
+;; aus "muffe" (Variante vor Baugruppe), sonst nil. Das Flag steht bewusst
+;; ausdruecklich je Variante, statt aus dem Namen ("mit Muffe") geraten zu
+;; werden. Bei "mit 2 Muffen" wird trotzdem nur eine Muffe gezeichnet.
+(defun geruest-traeger-muffe-dummy (variante bg / m d)
+  (if (and variante (ssg-json-get variante "mit_muffe"))
+    (progn
+      (setq m (geruest-variante-wert variante bg "muffe"))
+      (setq d (if (and m (listp m)) (ssg-json-get m "dummy")))
+      (if (and d (= (type d) 'STR) (/= d "")) d)
+    )
+  )
+)
+
+;; Liegt netto in [min-l, max-l]? Fehlende Grenzen gelten nicht.
+(defun geruest-traeger-pruefen (netto min-l max-l)
+  (and netto
+       (or (null min-l) (>= netto min-l))
+       (or (null max-l) (<= netto max-l)))
+)
+
+;; BEZEICHNUNG: Teileart + Variante + aktive Abzuege, mit " + " verkettet
+;; (Artikelnamen enthalten Kommas, siehe geruest-einfuegen).
+(defun geruest-traeger-bezeichnung (teileart variante-name abzug-a abzug-e / teile)
+  (setq teile (list teileart variante-name))
+  (if (> abzug-a 0.0)
+    (setq teile (append teile (list (ssg-textf "gr-tr-bez-abzug-anfang"
+                                      (list (geruest-mm-string abzug-a)))))))
+  (if (> abzug-e 0.0)
+    (setq teile (append teile (list (ssg-textf "gr-tr-bez-abzug-ende"
+                                      (list (geruest-mm-string abzug-e)))))))
+  (ssg-join teile " + ")
+)
+
+(defun geruest-traeger-dcl-pfad ( / basis)
+  (setq basis (cond ((getenv "DXFM_DCL"))
+                    ((getenv "DXFMAKRO") (strcat (getenv "DXFMAKRO") "/dcl"))))
+  (if basis
+    (strcat (vl-string-translate "\\" "/" basis) "/geruest_traeger.dcl")
+  )
+)
+
+;; --- Dialogzustand (Globals, siehe Abschnitt DIALOGZUSTAND oben) ---
+;; Bleibt zwischen zwei GERUEST_TRAEGER-Aufrufen erhalten.
+
+;; Abzug-Vorgaben (aktiv + Wert) der Variante idx in den Zustand laden.
+(defun geruest-tr-vorgaben-laden (idx / v)
+  (setq v (nth idx (ssg-json-get *geruest-tr-bg* "geometrie_varianten")))
+  (setq *geruest-tr-abzug-a*
+        (if (geruest-attr-feld v *geruest-tr-bg* "LAENGENABZUGANFANG" "aktiv") "1" "0"))
+  (setq *geruest-tr-abzug-a-w*
+        (geruest-zahl-string (geruest-attr-feld v *geruest-tr-bg* "LAENGENABZUGANFANG" "vorgabe")))
+  (setq *geruest-tr-abzug-e*
+        (if (geruest-attr-feld v *geruest-tr-bg* "LAENGENABZUGENDE" "aktiv") "1" "0"))
+  (setq *geruest-tr-abzug-e-w*
+        (geruest-zahl-string (geruest-attr-feld v *geruest-tr-bg* "LAENGENABZUGENDE" "vorgabe")))
+)
+
+(defun geruest-tr-abzug-schreiben ( / )
+  (set_tile "abzug_a"   *geruest-tr-abzug-a*)
+  (set_tile "abzug_a_w" *geruest-tr-abzug-a-w*)
+  (set_tile "abzug_e"   *geruest-tr-abzug-e*)
+  (set_tile "abzug_e_w" *geruest-tr-abzug-e-w*)
+  (mode_tile "abzug_a_w" (if (= *geruest-tr-abzug-a* "1") 0 1))
+  (mode_tile "abzug_e_w" (if (= *geruest-tr-abzug-e* "1") 0 1))
+)
+
+;; Variantenwechsel im Dialog: Abzug-Vorgaben der neuen Variante uebernehmen.
+(defun geruest-tr-variante-gewaehlt (wert / )
+  (setq *geruest-tr-variante* wert)
+  (geruest-tr-vorgaben-laden (atoi wert))
+  (geruest-tr-abzug-schreiben)
+)
+
+(defun geruest-tr-dlg-lesen ( / )
+  (setq *geruest-tr-variante*  (get_tile "variante"))
+  (setq *geruest-tr-farbe*     (get_tile "farbe"))
+  (setq *geruest-tr-frei*      (get_tile "farbe_frei"))
+  (setq *geruest-tr-abzug-a*   (get_tile "abzug_a"))
+  (setq *geruest-tr-abzug-a-w* (get_tile "abzug_a_w"))
+  (setq *geruest-tr-abzug-e*   (get_tile "abzug_e"))
+  (setq *geruest-tr-abzug-e-w* (get_tile "abzug_e_w"))
+  (setq *geruest-tr-beschriftung* (get_tile "beschriftung"))
+)
+
+;; Wert eines Abzugs aus dem Zustand: inaktiv -> 0, aktiv -> Zahl oder nil.
+(defun geruest-tr-abzug (aktiv wert)
+  (if (= aktiv "1") (geruest-abzug-wert wert) 0.0)
+)
+
+;; Traeger-Dialog. Rueckgabe:
+;; (variante-index farbe abzug-anfang abzug-ende beschriften-p) oder nil bei
+;; Abbruch.
+(defun geruest-traeger-dialog (bg / varianten dcl-pfad dat fertig rueckgabe
+                                 ergebnis aw ew)
+  (setq varianten (ssg-json-get bg "geometrie_varianten"))
+  (setq *geruest-tr-bg* bg)
+  (geruest-farb-liste-setzen
+    (ssg-json-get (ssg-json-get bg "attribute") "TEILEFARBE"))
+  ;; Ausgangszustand beim ersten Aufruf bzw. wenn der gemerkte Index nach
+  ;; einer JSON-Aenderung nicht mehr passt.
+  (if (or (null *geruest-tr-variante*)
+          (>= (atoi *geruest-tr-variante*) (length varianten)))
+    (progn
+      (setq *geruest-tr-variante* "0" *geruest-tr-farbe* "0" *geruest-tr-frei* "")
+      (geruest-tr-vorgaben-laden 0)
+    )
+  )
+  ;; Beschriftung standardmaessig an; der Haken bleibt zwischen Aufrufen
+  (if (null *geruest-tr-beschriftung*) (setq *geruest-tr-beschriftung* "1"))
+  (setq dcl-pfad (geruest-traeger-dcl-pfad))
+  (setq fertig nil rueckgabe nil)
+
+  ;; Schleife: ungueltige Eingaben zeigen den Dialog mit dem bisherigen
+  ;; Stand erneut - DCL kann Zahlen nicht selbst pruefen.
+  (while (not fertig)
+    (setq dat (if (and dcl-pfad (findfile dcl-pfad)) (load_dialog dcl-pfad) -1))
+    (if (or (< dat 0) (not (new_dialog "geruest_traeger" dat)))
+      (progn
+        (alert (ssg-textf "gr-tr-fehler-dcl"
+                 (list (if dcl-pfad dcl-pfad "geruest_traeger.dcl"))))
+        (setq fertig T)
+      )
+      (progn
+        (start_list "variante")
+        (foreach v varianten (add_list (geruest-eintrag-name v)))
+        (end_list)
+        (set_tile "variante" *geruest-tr-variante*)
+
+        (if *geruest-farb-liste*
+          (progn
+            (start_list "farbe")
+            (foreach f *geruest-farb-liste* (add_list f))
+            (end_list)
+            (set_tile "farbe" *geruest-tr-farbe*)
+            (mode_tile "farbe_frei"
+              (if (= (atoi *geruest-tr-farbe*) *geruest-frei-idx*) 0 1))
+            (action_tile "farbe"
+              "(mode_tile \"farbe_frei\" (if (= (atoi $value) *geruest-frei-idx*) 0 1))")
+          )
+          (progn
+            (mode_tile "farbe" 1)
+            (mode_tile "farbe_frei" 1)
+          )
+        )
+        (set_tile "farbe_frei" *geruest-tr-frei*)
+        (geruest-tr-abzug-schreiben)
+        (set_tile "beschriftung" *geruest-tr-beschriftung*)
+        (set_tile "hinweis" (ssg-text "gr-tr-hinweis"))
+
+        (action_tile "variante" "(geruest-tr-variante-gewaehlt $value)")
+        (action_tile "abzug_a"
+          "(mode_tile \"abzug_a_w\" (if (= $value \"1\") 0 1))")
+        (action_tile "abzug_e"
+          "(mode_tile \"abzug_e_w\" (if (= $value \"1\") 0 1))")
+        (action_tile "accept" "(geruest-tr-dlg-lesen) (done_dialog 1)")
+        (action_tile "cancel" "(done_dialog 0)")
+        (setq ergebnis (start_dialog))
+        (unload_dialog dat)
+
+        (cond
+          ((= ergebnis 0) (setq fertig T))
+          ((or (null (setq aw (geruest-tr-abzug *geruest-tr-abzug-a* *geruest-tr-abzug-a-w*)))
+               (null (setq ew (geruest-tr-abzug *geruest-tr-abzug-e* *geruest-tr-abzug-e-w*))))
+            (alert (ssg-text "gr-tr-alert-abzug"))
+          )
+          (T
+            (setq rueckgabe
+              (list (atoi *geruest-tr-variante*)
+                    (geruest-farbwert *geruest-tr-farbe* *geruest-tr-frei*)
+                    aw ew
+                    (= *geruest-tr-beschriftung* "1")))
+            (setq fertig T)
+          )
+        )
+      )
+    )
+  )
+  rueckgabe
+)
+
+;; X-Positionen der beiden Querlinien einer Strebe: Anfang und Ende des
+;; Flacheisens, laenge mittig um die Strebenposition x.
+(defun geruest-traeger-strebe-enden (x laenge)
+  (list (- x (/ laenge 2.0)) (+ x (/ laenge 2.0)))
+)
+
+;; Querstrebe darstellen: an Anfang und Ende je eine Linie quer zum Traeger
+;; (Laenge querlinie, mittig auf der Traegerlinie y = 0).
+(defun geruest-traeger-strebe-zeichnen (x laenge querlinie lay / hq)
+  (setq hq (/ querlinie 2.0))
+  (foreach xe (geruest-traeger-strebe-enden x laenge)
+    (entmake (list '(0 . "LINE") (cons 8 lay)
+                   (list 10 xe (- hq) 0.0) (list 11 xe hq 0.0)))
+  )
+)
+
+;; Vollstaendiger Pfad einer Dummy-DWG unter data/geruest oder nil (mit
+;; Meldung), wenn sie fehlt. datei = nil -> stilles nil (nichts konfiguriert).
+(defun geruest-dummy-finden (datei / pfad)
+  (if datei
+    (progn
+      (setq pfad (geruest-dummy-pfad datei))
+      (if (and pfad (findfile pfad))
+        pfad
+        (progn
+          (princ (ssg-textf "gr-fehler-dummy" (list (if pfad pfad datei))))
+          nil
+        )
+      )
+    )
+  )
+)
+
+;; Dummy-DWG als verschachtelten Block bei pt (Drehung 0) einfuegen. Ist die
+;; Blockdefinition (Dateiname ohne .dwg) schon in der Zeichnung, wird per
+;; Blockname eingefuegt - sonst wuerde die DWG bei jeder Strebe neu gelesen
+;; (und ggf. "Block neu definieren?" gefragt). ATTREQ/ATTDIA muss der Aufrufer
+;; auf 0 gesetzt haben.
+(defun geruest-dummy-einfuegen (pfad pt / bname)
+  (setq bname (vl-filename-base pfad))
+  (command "_.INSERT" (if (tblsearch "BLOCK" bname) bname pfad) pt 1 1 0)
+)
+
+;; Linie + Querstreben + Muffe + ATTDEFs zu einem Block zusammenfassen und am
+;; Startpunkt mit dem Richtungswinkel einfuegen. Im Block laeuft der Traeger
+;; entlang +X, die Dummys werden darum ohne Drehung eingefuegt.
+;;   strebe      = Ergebnis von geruest-traeger-strebe-cfg (nil = keine Streben)
+;;   strebe-pfad = Pfad der Strebe-DWG oder nil -> Rueckfall auf Querlinien
+;;   muffe-pfad  = Pfad der Muffen-DWG oder nil -> keine Muffe; sonst eine
+;;                 Muffe (Basispunkt Muffenmitte) am Linienende
+;; Der Aufrufer sichert die Systemvariablen per ssg-start.
+;; Rueckgabe: (blockname . entity) oder nil.
+(defun geruest-traeger-block-bauen (bg layer netto strebe strebe-pfad muffe-pfad
+                                     werte pt winkel / lastEnt lay)
+  (setvar "ATTREQ" 0)
+  (setvar "ATTDIA" 0)
+  (setvar "OSMODE" 0)
+  ;; Drehwinkel wird als Grad an INSERT uebergeben - nur eindeutig mit
+  ;; Winkel-Nullrichtung Ost, gegen den Uhrzeigersinn, Einheit Grad.
+  (setvar "ANGBASE" 0.0)
+  (setvar "ANGDIR" 0)
+  (setvar "AUNITS" 0)
+  ;; Nicht (entlast) - siehe geruest-block-bauen.
+  (setq lastEnt (ssg-lastent-ohne-attribute))
+
+  (setq lay (if (and layer (/= layer "")) layer "0"))
+  ;; Aktiv setzen, damit auch die verschachtelten Dummy-INSERTs auf dem
+  ;; Traeger-Layer landen (CLAYER sichert ssg-start immer mit).
+  (ssg-make-layer lay (ssg-layer-farbe-fuer-name lay) T)
+  (entmake (list '(0 . "LINE") (cons 8 lay)
+                 '(10 0.0 0.0 0.0) (list 11 netto 0.0 0.0)))
+  ;; strebe = (dummy laenge querlinie abstand-max rand-min rand-max)
+  (if strebe
+    (foreach x (geruest-traeger-streben netto (nth 3 strebe) (nth 4 strebe) (nth 5 strebe))
+      (if strebe-pfad
+        (geruest-dummy-einfuegen strebe-pfad (list x 0.0 0.0))
+        (geruest-traeger-strebe-zeichnen x (nth 1 strebe) (nth 2 strebe) lay)
+      )
+    )
+  )
+  (if muffe-pfad
+    (geruest-dummy-einfuegen muffe-pfad (list netto 0.0 0.0))
+  )
+
+  (geruest-block-abschliessen bg
+    (ssg-attrib-merge nil *geruest-traeger-attrib-defs*)
+    werte lastEnt pt (* winkel (/ 180.0 pi)))
+)
+
+;; Einfuege-Schleife: Startpunkt, Endpunkt oder Laenge, bis ESC/Enter.
+;; wahl = Rueckgabe von geruest-traeger-dialog.
+(defun geruest-traeger-einfuegen (bg wahl / variante teileart layer paare farbe
+                                    abzug-a abzug-e min-l max-l bez werte-basis
+                                    werte weiter p1 eingabe strecke winkel netto
+                                    ergebnis anzahl strebe strebe-pfad muffe-pfad
+                                    beschriften)
+  (setq variante (nth (car wahl) (ssg-json-get bg "geometrie_varianten")))
+  (setq farbe    (cadr wahl)
+        abzug-a  (caddr wahl)
+        abzug-e  (cadddr wahl)
+        beschriften (nth 4 wahl))
+  (setq *geruest-beschr-gemeldet* nil)
+  (setq teileart (geruest-variante-wert variante bg "teileart"))
+  (setq layer    (geruest-variante-wert variante bg "layer"))
+  (setq min-l    (geruest-attr-feld variante bg "LAENGE" "min"))
+  (setq max-l    (geruest-attr-feld variante bg "LAENGE" "max"))
+  (setq paare    (geruest-teile-paare variante nil))
+  (setq strebe   (geruest-traeger-strebe-cfg variante bg))
+  ;; DWGs einmal je Durchgang aufloesen - eine fehlende Datei wird so nur
+  ;; einmal gemeldet, nicht bei jedem Traeger. Fehlt die Strebe-DWG, werden
+  ;; stattdessen Querlinien gezeichnet; fehlt die Muffe, entfaellt sie.
+  (setq strebe-pfad (if strebe (geruest-dummy-finden (car strebe))))
+  (setq muffe-pfad  (geruest-dummy-finden (geruest-traeger-muffe-dummy variante bg)))
+  (setq bez      (geruest-traeger-bezeichnung teileart
+                   (geruest-eintrag-name variante) abzug-a abzug-e))
+
+  ;; Fuer alle Traeger dieses Durchgangs gleich - nur LAENGE aendert sich.
+  (setq werte-basis
+    (list (cons "ARTINR"             (ssg-join (mapcar 'car paare) ","))
+          (cons "BEZEICHNUNG"        bez)
+          (cons "TEILEART"           teileart)
+          (cons "LAENGENABZUGANFANG" (geruest-mm-string abzug-a))
+          (cons "LAENGENABZUGENDE"   (geruest-mm-string abzug-e))
+          ;; Block selbstbeschreibend - die Beschriftung (auch spaeter per
+          ;; GERUEST_TRAEGER_BESCHRIFTEN) findet darueber ihre Formatierung
+          (cons "VARIANTE"           (geruest-eintrag-name variante))))
+  (if (and layer (/= layer ""))
+    (setq werte-basis (append werte-basis (list (cons "LAYER" layer)))))
+  (if (/= farbe "")
+    (setq werte-basis (append werte-basis (list (cons "TEILEFARBE"
+      (ssg-join (geruest-farbliste paare farbe) ","))))))
+
+  (setq weiter T anzahl 0)
+  (while weiter
+    (setq strecke nil)
+    (setq p1 (getpoint (ssg-text "gr-tr-prompt-start")))
+    (if (null p1)
+      (setq weiter nil)
+      (progn
+        ;; 128 = beliebige Eingabe: ein Punkt liefert Laenge UND Richtung,
+        ;; eine getippte Zahl nur die Laenge (Richtung wird nachgefragt).
+        (initget 128)
+        (setq eingabe (getpoint p1 (ssg-text "gr-tr-prompt-ende")))
+        ;; Reihenfolge wichtig: nil ist auch listp, und "" darf erst nach dem
+        ;; Punkt-Fall verglichen werden.
+        (cond
+          ((null eingabe) (setq weiter nil))
+          ((listp eingabe)
+            ;; Laenge in der XY-Ebene, die Linie liegt auf Z des Startpunkts
+            (setq strecke (distance (list (car p1) (cadr p1))
+                                    (list (car eingabe) (cadr eingabe))))
+            (setq winkel (angle p1 eingabe))
+          )
+          ((= eingabe "") (setq weiter nil))
+          ((setq strecke (geruest-mm-zahl eingabe))
+            (setq winkel (getangle p1 (ssg-text "gr-tr-prompt-richtung")))
+            (if (null winkel) (setq winkel 0.0))
+          )
+          (T (princ (ssg-textf "gr-tr-eingabe-ungueltig" (list eingabe))))
+        )
+      )
+    )
+
+    (if (and weiter strecke)
+      (progn
+        (setq netto (geruest-traeger-laenge strecke abzug-a abzug-e))
+        (cond
+          ((null netto)
+            (princ (ssg-textf "gr-tr-laenge-null"
+                     (list (geruest-mm-string strecke)
+                           (geruest-mm-string (+ abzug-a abzug-e))))))
+          ((not (geruest-traeger-pruefen netto min-l max-l))
+            (princ (ssg-textf "gr-tr-laenge-bereich"
+                     (list (geruest-mm-string netto)
+                           (if min-l (geruest-mm-string min-l) "0")
+                           (if max-l (geruest-mm-string max-l) "-")))))
+          (T
+            (setq werte (cons (cons "LAENGE" (geruest-mm-string netto)) werte-basis))
+            (ssg-start nil '(("OSMODE") ("ATTREQ") ("ATTDIA")
+                             ("ANGBASE") ("ANGDIR") ("AUNITS")))
+            (setq ergebnis (geruest-traeger-block-bauen bg layer netto strebe
+                             strebe-pfad muffe-pfad werte
+                             (geruest-traeger-start p1 winkel abzug-a) winkel))
+            ;; Beschriftung aus dem fertigen Block ableiten (dieselbe Funktion
+            ;; wie GERUEST_TRAEGER_BESCHRIFTEN)
+            (if (and ergebnis beschriften)
+              (geruest-traeger-beschriften (cdr ergebnis)))
+            (ssg-end)
+            (if ergebnis
+              (progn
+                (setq anzahl (1+ anzahl))
+                (princ (ssg-textf "gr-tr-fertig"
+                         (list (geruest-mm-string netto) (car ergebnis))))
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+  (princ (ssg-textf "gr-tr-ende" (list (itoa anzahl))))
+  (princ)
+)
+
+;; ============================================================
+;; TRAEGER-BESCHRIFTUNG
+;; ============================================================
+;; Eigenes TEXT-Objekt neben dem Block, z.B. "RT 80/80 L=2650". Es wird
+;; AUSSCHLIESSLICH aus dem fertigen Block abgeleitet (Einfuegepunkt, Drehung,
+;; Attribute LAENGE und VARIANTE) - darum nutzen das Einfuegen und
+;; GERUEST_TRAEGER_BESCHRIFTEN dieselbe Funktion, und ein von Hand
+;; verschobener/gedrehter Traeger wird beim Neubeschriften korrekt erfasst.
+;; Der Text traegt per XDATA (*geruest-beschr-app*, 1005) den Handle seines
+;; Blocks; so wird er beim Neubeschriften ersetzt statt verdoppelt.
+;;
+;; Formatierung aus geruest.json, "beschriftung" (Variante vor Baugruppe, je
+;; Feld): NUR stil, ausrichtung, hoehe - alles andere regelt der Textstil
+;; ausserhalb (es wird kein Stil angelegt). Dazu Inhalt (format/text) und
+;; Layer.
+
+;; Winkel auf [0, 2pi) normieren.
+(defun geruest-winkel-norm (w)
+  (setq w (rem w (* 2.0 pi)))
+  (if (< w 0.0) (+ w (* 2.0 pi)) w)
+)
+
+;; Textwinkel entlang des Traegers nach DIN-Konvention (lesbar von unten und
+;; von rechts): fuer 90 < w <= 270 Grad um 180 Grad gedreht, sonst w.
+(defun geruest-text-winkel (w / e)
+  (setq w (geruest-winkel-norm w) e 1e-9)
+  (if (and (> w (+ (/ pi 2.0) e)) (<= w (+ (* 1.5 pi) e)))
+    (geruest-winkel-norm (+ w pi))
+    w
+  )
+)
+
+;; Ausrichtungs-Code wie bei TEXT "Ausrichten" (T/M/B + L/C/R, z.B. "BC") ->
+;; (dxf72 dxf73), nil bei unbekanntem Code.
+(defun geruest-ausrichtung-codes (code / h v)
+  (if (and code (= (type code) 'STR) (= (strlen code) 2))
+    (progn
+      (setq code (strcase code))
+      (setq v (cdr (assoc (substr code 1 1) '(("T" . 3) ("M" . 2) ("B" . 1)))))
+      (setq h (cdr (assoc (substr code 2 1) '(("L" . 0) ("C" . 1) ("R" . 2)))))
+      (if (and v h) (list h v))
+    )
+  )
+)
+
+;; Lage des Textes: (punkt textwinkel dxf72 dxf73). p0 = Traeger-Startpunkt,
+;; w = Traegerwinkel, laenge = Traegerlaenge. Der Bezugspunkt liegt auf der
+;; Linie: L = in Leserichtung linkes Ende, C = Mitte, R = rechtes Ende. Nach
+;; einer 180-Grad-Drehung ist "links" also das Linienende. Unbekannter Code
+;; -> BC (die Meldung gibt der Aufrufer aus).
+(defun geruest-traeger-text-lage (p0 w laenge code / codes tw p1 links rechts pt)
+  (setq codes (geruest-ausrichtung-codes code))
+  (if (null codes) (setq codes '(1 1)))
+  (setq tw (geruest-text-winkel w))
+  (setq p1 (polar p0 w laenge))
+  ;; Projektion auf die Leserichtung entscheidet, welches Ende links liegt
+  (if (<= (+ (* (car p0) (cos tw)) (* (cadr p0) (sin tw)))
+          (+ (* (car p1) (cos tw)) (* (cadr p1) (sin tw))))
+    (setq links p0 rechts p1)
+    (setq links p1 rechts p0)
+  )
+  (setq pt (cond ((= (car codes) 0) links)
+                 ((= (car codes) 2) rechts)
+                 (T (polar p0 w (/ laenge 2.0)))))
+  (list pt tw (car codes) (cadr codes))
+)
+
+;; Alle Vorkommen von alt in s durch neu ersetzen.
+(defun geruest-string-ersetzen (s alt neu / pos)
+  (setq pos (vl-string-search alt s))
+  (while pos
+    (setq s (strcat (substr s 1 pos) neu (substr s (+ pos (strlen alt) 1))))
+    (setq pos (vl-string-search alt s (+ pos (strlen neu))))
+  )
+  s
+)
+
+;; Beschriftungstext: %1 = Text der Variante, %2 = Laenge auf ganze mm.
+(defun geruest-traeger-text-string (fmt txt laenge)
+  (geruest-string-ersetzen
+    (geruest-string-ersetzen fmt "%1" txt)
+    "%2" (itoa (fix (+ laenge 0.5))))
+)
+
+;; Beschriftungs-Konfiguration als Alist (format text stil ausrichtung hoehe
+;; layer), je Feld Variante vor Baugruppe vor Code-Standard. Fehlt "text",
+;; gilt der Variantenname bzw. ersatz-text (Block ohne bekannte Variante).
+;; stil/layer = nil -> aktueller Textstil/Layer.
+(defun geruest-traeger-beschr-cfg (variante bg ersatz-text / txt h)
+  (setq txt (geruest-beschr-feld variante bg "text"))
+  (if (not (and txt (= (type txt) 'STR) (/= txt "")))
+    (setq txt (if variante (geruest-eintrag-name variante) ersatz-text)))
+  (setq h (geruest-beschr-feld variante bg "hoehe"))
+  (list (cons "format"      (cond ((geruest-beschr-feld variante bg "format")) ("%1 L=%2")))
+        (cons "text"        (if txt txt ""))
+        (cons "stil"        (geruest-beschr-feld variante bg "stil"))
+        (cons "ausrichtung" (cond ((geruest-beschr-feld variante bg "ausrichtung")) ("BC")))
+        (cons "hoehe"       (if (numberp h) (float h) 50.0))
+        (cons "layer"       (geruest-beschr-feld variante bg "layer")))
+)
+
+(defun geruest-beschr-feld (variante bg feld)
+  (geruest-obj-feld variante bg '("beschriftung") feld)
+)
+
+;; Handle des Traeger-Blocks aus der XDATA einer Beschriftung (oder nil).
+(defun geruest-beschr-handle (ent / xd)
+  (setq xd (cadr (assoc -3 (entget ent (list *geruest-beschr-app*)))))
+  (if xd (cdr (assoc 1005 (cdr xd))))
+)
+
+;; Alle Beschriftungen der Zeichnung (Auswahlsatz oder nil).
+(defun geruest-beschr-alle ( / )
+  (ssget "_X" (list '(0 . "TEXT") (list -3 (list *geruest-beschr-app*))))
+)
+
+;; Beschriftung(en) zu einem Block-Handle loeschen.
+(defun geruest-beschr-entfernen (handle / ss i e)
+  (if (and handle (setq ss (geruest-beschr-alle)))
+    (progn
+      (setq i 0)
+      (repeat (sslength ss)
+        (setq e (ssname ss i))
+        (if (equal (geruest-beschr-handle e) handle) (entdel e))
+        (setq i (1+ i))
+      )
+    )
+  )
+)
+
+;; Textstil pruefen: vorhanden -> Name, sonst einmal je Lauf melden und den
+;; aktuellen TEXTSTYLE nehmen. *geruest-beschr-gemeldet* setzt der Aufrufer
+;; je Lauf zurueck.
+(defun geruest-beschr-stil (stil / )
+  (cond
+    ((and stil (/= stil "") (tblsearch "STYLE" stil)) stil)
+    (T
+      (if (and stil (/= stil "") (not (member stil *geruest-beschr-gemeldet*)))
+        (progn
+          (princ (ssg-textf "gr-tr-beschr-stil-fehlt" (list stil (getvar "TEXTSTYLE"))))
+          (setq *geruest-beschr-gemeldet* (cons stil *geruest-beschr-gemeldet*))
+        )
+      )
+      (getvar "TEXTSTYLE")
+    )
+  )
+)
+
+;; Einen Traeger-Block beschriften (eine evtl. vorhandene Beschriftung wird
+;; ersetzt). Rueckgabe: "ok", "ersatz" (Block ohne bekannte VARIANTE, mit den
+;; Vorgaben der Baugruppe beschriftet) oder nil (nicht beschriftbar).
+(defun geruest-traeger-beschriften (blockEnt / ed attribs bg vname idx variante
+                                     cfg laenge lage lay handle code erg)
+  (setq ed (entget blockEnt))
+  (setq attribs (ssg-attrib-read blockEnt))
+  (setq bg (geruest-baugruppe "Traeger"))
+  (setq laenge (atof (cond ((cdr (assoc "LAENGE" attribs))) ("0"))))
+  (if (and bg (> laenge 0.0))
+    (progn
+      (setq vname (cdr (assoc "VARIANTE" attribs)))
+      (setq idx (if (and vname (/= vname ""))
+                  (geruest-name-index vname (ssg-json-get bg "geometrie_varianten"))))
+      (setq variante (if idx (nth idx (ssg-json-get bg "geometrie_varianten"))))
+      (setq cfg (geruest-traeger-beschr-cfg variante bg
+                  (cond ((cdr (assoc "TEILEART" attribs))) (""))))
+      (setq code (cdr (assoc "ausrichtung" cfg)))
+      (if (and (null (geruest-ausrichtung-codes code))
+               (not (member code *geruest-beschr-gemeldet*)))
+        (progn
+          (princ (ssg-textf "gr-tr-beschr-ausrichtung" (list code)))
+          (setq *geruest-beschr-gemeldet* (cons code *geruest-beschr-gemeldet*))
+        )
+      )
+      (setq lage (geruest-traeger-text-lage (cdr (assoc 10 ed)) (cdr (assoc 50 ed))
+                                            laenge code))
+      (setq lay (cdr (assoc "layer" cfg)))
+      (if (and lay (/= lay ""))
+        (ssg-make-layer lay (ssg-layer-farbe-fuer-name lay) nil)
+        (setq lay (getvar "CLAYER"))
+      )
+      (setq handle (cdr (assoc 5 ed)))
+      (geruest-beschr-entfernen handle)
+      (if (not (tblsearch "APPID" *geruest-beschr-app*)) (regapp *geruest-beschr-app*))
+      ;; 73 ist immer >= 1, damit gilt Gruppe 11 als Ausrichtungspunkt
+      (if (entmake (list '(0 . "TEXT")
+                         (cons 8  lay)
+                         (cons 7  (geruest-beschr-stil (cdr (assoc "stil" cfg))))
+                         (cons 10 (nth 0 lage))
+                         (cons 11 (nth 0 lage))
+                         (cons 40 (cdr (assoc "hoehe" cfg)))
+                         (cons 1  (geruest-traeger-text-string
+                                    (cdr (assoc "format" cfg))
+                                    (cdr (assoc "text" cfg)) laenge))
+                         (cons 50 (nth 1 lage))
+                         (cons 72 (nth 2 lage))
+                         (cons 73 (nth 3 lage))
+                         (list -3 (list *geruest-beschr-app* (cons 1005 handle)))))
+        (setq erg (if variante "ok" "ersatz"))
+      )
+    )
+  )
+  erg
+)
+
+;; Alle Traeger der Zeichnung (neu) beschriften und Beschriftungen, deren
+;; Block nicht mehr existiert, entfernen - unabhaengig von der Checkbox im
+;; Einfuegedialog.
+(defun c:GERUEST_TRAEGER_BESCHRIFTEN ( / ss i n-ok n-ersatz n-fehl n-weg e h ziel erg)
+  (setq *geruest-beschr-gemeldet* nil)
+  (setq n-ok 0 n-ersatz 0 n-fehl 0 n-weg 0)
+  (ssg-start nil nil)
+  ;; Verwaiste Beschriftungen zuerst entfernen
+  (if (setq ss (geruest-beschr-alle))
+    (progn
+      (setq i 0)
+      (repeat (sslength ss)
+        (setq e (ssname ss i))
+        (setq h (geruest-beschr-handle e))
+        (setq ziel (if h (handent h)))
+        (if (not (and ziel (entget ziel)
+                      (= (cdr (assoc 0 (entget ziel))) "INSERT")))
+          (progn (entdel e) (setq n-weg (1+ n-weg)))
+        )
+        (setq i (1+ i))
+      )
+    )
+  )
+  (if (setq ss (ssget "_X" '((0 . "INSERT") (2 . "GR_Traeger_*"))))
+    (progn
+      (setq i 0)
+      (repeat (sslength ss)
+        (setq erg (geruest-traeger-beschriften (ssname ss i)))
+        (cond ((= erg "ok")     (setq n-ok (1+ n-ok)))
+              ((= erg "ersatz") (setq n-ersatz (1+ n-ersatz)))
+              (T                (setq n-fehl (1+ n-fehl))))
+        (setq i (1+ i))
+      )
+      (princ (ssg-textf "gr-tr-beschr-ergebnis"
+               (list (itoa (+ n-ok n-ersatz)) (itoa n-ersatz) (itoa n-fehl) (itoa n-weg))))
+    )
+    (princ (ssg-text "gr-tr-beschr-keine"))
+  )
+  (ssg-end)
+  (princ)
+)
+
+(defun c:GERUEST_TRAEGER ( / bg wahl)
+  (setq bg (geruest-baugruppe "Traeger"))
+  (cond
+    ((null bg)
+      (princ (ssg-textf "gr-fehler-baugruppe" (list "Traeger"))))
+    ((null (ssg-json-get bg "geometrie_varianten"))
+      (princ (ssg-textf "gr-fehler-keine-varianten" (list "Traeger"))))
+    ((null (setq wahl (geruest-traeger-dialog bg)))
+      (princ (ssg-text "gr-abgebrochen")))
+    (T (geruest-traeger-einfuegen bg wahl))
+  )
+  (princ)
+)
+
+(princ "\nGeruestInsert.lsp geladen. Befehle: GERUEST, GERUEST_SAEULEN, GERUEST_ROHRABHAENGER, GERUEST_WANDBEFESTIGUNG, GERUEST_TRAEGER, GERUEST_TRAEGER_BESCHRIFTEN")
 (princ)

data/json/geruest.json

@@ -5,13 +5,13 @@
         "teileart": "Geruest Rohrabhaenger",
         "dummy": "Rohrabhaenger_dummy.dwg",
         "attribute": {
-            "Laenge": {
+            "LAENGE": {
                 "typ": "number",
                 "min": 0,
                 "max": 6000,
                 "einheit": "mm"
             },
-            "Teilefarbe": {
+            "TEILEFARBE": {
                 "typ": "auswahl",
                 "optionen": [
                     "RAL7035",
@@ -202,13 +202,13 @@
         "teileart": "Geruest Saeule",
         "dummy": "R2-Saeule_dummy.dwg",
         "attribute": {
-            "Laenge": {
+            "LAENGE": {
                 "typ": "number",
                 "min": 0,
                 "max": 6000,
                 "einheit": "mm"
             },
-            "Teilefarbe": {
+            "TEILEFARBE": {
                 "typ": "auswahl",
                 "optionen": [
                     "RAL7035",
@@ -483,5 +483,197 @@
                 "unten": []
             }
         ]
+    },
+    "Rohr-Gerüst-Träger": {
+        "id": "Traeger",
+        "titel": "Traeger",
+        "teileart": "Geruest Traeger",
+        "einfuegeart": "linie",
+        "querstrebe": {
+            "dummy": "dummy_Strebe_30x4.dwg",
+            "abstand_max": 500,
+            "rand_min": 100,
+            "rand_max": 250
+        },
+        "muffe": {
+            "dummy": "dummy_Muffe_1zoll.dwg"
+        },
+        "beschriftung": {
+            "format": "%1 L=%2",
+            "stil": "Lan",
+            "ausrichtung": "BL",
+            "hoehe": 100
+        },
+        "attribute": {
+            "LAENGE": {
+                "typ": "number",
+                "min": 0,
+                "max": 6000,
+                "einheit": "mm"
+            },
+            "LAENGENABZUGANFANG": {
+                "typ": "number",
+                "einheit": "mm",
+                "vorgabe": 35,
+                "aktiv": false
+            },
+            "LAENGENABZUGENDE": {
+                "typ": "number",
+                "einheit": "mm",
+                "vorgabe": 35,
+                "aktiv": false
+            },
+            "TEILEFARBE": {
+                "typ": "auswahl",
+                "optionen": [
+                    "RAL7035",
+                    "RAL7030"
+                ],
+                "frei_erlaubt": true,
+                "frei_option": "Individuell"
+            }
+        },
+        "geometrie_varianten": [
+            {
+                "name": "Rohr 1\"",
+                "beschriftung": {
+                    "text": "Rohr 1\"",
+                    "layer": "D-6-BEM"
+                },
+                "teileart": "Geruest Traeger",
+                "layer": "D-6",
+                "teile": [
+                    {
+                        "artikel": "ROHR R 1\"",
+                        "sivas_id": 821006026,
+                        "farbig": true,
+                        "menge": 1
+                    }
+                ]
+            },
+            {
+                "name": "Rohr 1\" mit Muffe",
+                "beschriftung": {
+                    "text": "Rohr 1\"",
+                    "layer": "D-6-BEM"
+                },
+                "mit_muffe": true,
+                "teileart": "Geruest Traeger",
+                "layer": "D-6",
+                "teile": [
+                    {
+                        "artikel": "ROHR R 1\" mit Muffe",
+                        "sivas_id": 825004000,
+                        "farbig": true,
+                        "menge": 1
+                    }
+                ]
+            },
+            {
+                "name": "DRT 80 1\"",
+                "beschriftung": {
+                    "text": "DRT 80",
+                    "layer": "D-1-BEM"
+                },
+                "teileart": "Geruest Traeger",
+                "layer": "D-1",
+                "teile": [
+                    {
+                        "artikel": "DRT DOPPELROHRTRAEGER 80 1\"",
+                        "sivas_id": 825084000,
+                        "farbig": true,
+                        "menge": 1
+                    }
+                ]
+            },
+            {
+                "name": "DRT 80 1\" mit 2 Muffen",
+                "beschriftung": {
+                    "text": "DRT 80",
+                    "layer": "D-1-BEM"
+                },
+                "mit_muffe": true,
+                "teileart": "Geruest Traeger",
+                "layer": "D-1",
+                "teile": [
+                    {
+                        "artikel": "DRT DOPPELROHRTRAEGER 80 1\" mit 2 Muffen",
+                        "sivas_id": 825084007,
+                        "farbig": true,
+                        "menge": 1
+                    }
+                ]
+            },
+            {
+                "name": "DRT 114 1\"",
+                "beschriftung": {
+                    "text": "DRT 114",
+                    "layer": "D-3-BEM"
+                },
+                "teileart": "Geruest Traeger",
+                "layer": "D-3",
+                "teile": [
+                    {
+                        "artikel": "DRT DOPPELROHRTRAEGER 114 1\"",
+                        "sivas_id": 825104000,
+                        "farbig": true,
+                        "menge": 1
+                    }
+                ]
+            },
+            {
+                "name": "DRT 114 1\" mit 2 Muffen",
+                "beschriftung": {
+                    "text": "DRT 114",
+                    "layer": "D-3-BEM"
+                },
+                "mit_muffe": true,
+                "teileart": "Geruest Traeger",
+                "layer": "D-3",
+                "teile": [
+                    {
+                        "artikel": "DRT DOPPELROHRTRAEGER 114 1\" mit 2 Muffen",
+                        "sivas_id": 825104007,
+                        "farbig": true,
+                        "menge": 1
+                    }
+                ]
+            },
+            {
+                "name": "RT 80/80 1\"",
+                "beschriftung": {
+                    "text": "RT 80/80",
+                    "layer": "D-5-BEM"
+                },
+                "teileart": "Geruest Traeger",
+                "layer": "D-5",
+                "teile": [
+                    {
+                        "artikel": "RT ROHRTRAEGER 80/80 1\"",
+                        "sivas_id": 825144000,
+                        "farbig": true,
+                        "menge": 1
+                    }
+                ]
+            },
+            {
+                "name": "RT 80/80 1\" mit 2 Muffen",
+                "beschriftung": {
+                    "text": "RT 80/80",
+                    "layer": "D-5-BEM"
+                },
+                "mit_muffe": true,
+                "teileart": "Geruest Traeger",
+                "layer": "D-5",
+                "teile": [
+                    {
+                        "artikel": "RT ROHRTRAEGER 80/80 1\" mit 2 Muffen",
+                        "sivas_id": 825144007,
+                        "farbig": true,
+                        "menge": 1
+                    }
+                ]
+            }
+        ]
     }
 }

dcl/geruest_traeger.dcl

@@ -0,0 +1,39 @@
+// ============================================================
+// geruest_traeger.dcl - Rohr-Geruest-Traeger konfigurieren
+// Verwendet von: GERUEST_TRAEGER (GeruestInsert.lsp, geruest-traeger-dialog)
+//
+// Die Laenge steht bewusst NICHT im Dialog - sie wird nach dem Dialog in der
+// Zeichnung per Start-/Endpunkt (oder getippter Laenge) bestimmt. Aktive
+// Laengenabzuege ruecken die Linie am Anfang bzw. Ende ein.
+// ============================================================
+
+geruest_traeger : dialog {
+  label = "Rohr-Geruest-Traeger konfigurieren";
+
+  : boxed_column {
+    label = "Basis";
+    : popup_list { key = "variante"; label = "Variante:"; width = 56; }
+    : row {
+      : popup_list { key = "farbe"; label = "Farbe:"; width = 25; }
+      : edit_box { key = "farbe_frei"; label = "eigene:"; edit_width = 12; }
+    }
+  }
+
+  : boxed_column {
+    label = "Laengenabzug";
+    : row {
+      : toggle { key = "abzug_a"; label = "Laengenabzug Anfang"; width = 24; fixed_width = true; }
+      : edit_box { key = "abzug_a_w"; label = "mm:"; edit_width = 8; fixed_width = true; }
+    }
+    : row {
+      : toggle { key = "abzug_e"; label = "Laengenabzug Ende"; width = 24; fixed_width = true; }
+      : edit_box { key = "abzug_e_w"; label = "mm:"; edit_width = 8; fixed_width = true; }
+    }
+  }
+
+  : toggle { key = "beschriftung"; label = "Beschriftung einfuegen"; }
+
+  : text { key = "hinweis"; label = ""; width = 56; }
+
+  ok_cancel;
+}

lang/de_DE.json

@@ -1022,6 +1022,23 @@
     "gr-konfig-teil-unbekannt": "\nGeruest: Anbauteil '%1' aus Konfiguration '%2' ist bei dieser Baugruppe unbekannt - uebersprungen.",
     "gr-konfig-variante-unbekannt": "\nGeruest: Variante '%1' aus Konfiguration '%2' ist bei dieser Baugruppe unbekannt - Auswahl unveraendert.",
     "gr-fehler-schreiben": "\nGeruest: Datei konnte nicht geschrieben werden: %1",
-    "gr-fehler-keine-baugruppen": "\nGeruest: Die Datendatei enthaelt keine Baugruppen."
+    "gr-fehler-keine-baugruppen": "\nGeruest: Die Datendatei enthaelt keine Baugruppen.",
+    "gr-tr-fehler-dcl": "Dialog %1 konnte nicht geladen werden.",
+    "gr-tr-hinweis": "Die Laenge wird nach OK in der Zeichnung bestimmt.",
+    "gr-tr-alert-abzug": "Laengenabzug ungueltig. Erlaubt ist eine Zahl ab 0 (mm); ein leeres Feld gilt als 0.",
+    "gr-tr-prompt-start": "\nStartpunkt des Traegers waehlen <Ende>: ",
+    "gr-tr-prompt-ende": "\nEndpunkt waehlen oder Laenge (mm) eingeben: ",
+    "gr-tr-prompt-richtung": "\nRichtung angeben <0>: ",
+    "gr-tr-eingabe-ungueltig": "\nEingabe '%1' ist weder Punkt noch Laenge.",
+    "gr-tr-laenge-null": "\nStrecke %1 mm ist nicht laenger als die Abzuege (%2 mm) - kein Traeger eingefuegt.",
+    "gr-tr-laenge-bereich": "\nTraegerlaenge %1 mm ausserhalb des erlaubten Bereichs %2 bis %3 mm - kein Traeger eingefuegt.",
+    "gr-tr-fertig": "\nTraeger %1 mm eingefuegt (Block %2).",
+    "gr-tr-ende": "\n%1 Traeger eingefuegt.",
+    "gr-tr-bez-abzug-anfang": "Abzug Anfang %1 mm",
+    "gr-tr-bez-abzug-ende": "Abzug Ende %1 mm",
+    "gr-tr-beschr-stil-fehlt": "\nTextstil %1 fehlt in der Zeichnung - Beschriftung mit aktuellem Stil %2.",
+    "gr-tr-beschr-ausrichtung": "\nUnbekannte Ausrichtung %1 fuer die Traeger-Beschriftung - verwende BC.",
+    "gr-tr-beschr-ergebnis": "\n%1 Traeger beschriftet (davon %2 ohne bekannte Variante), %3 nicht beschriftbar, %4 verwaiste Beschriftungen entfernt.",
+    "gr-tr-beschr-keine": "\nKeine Rohr-Geruest-Traeger in der Zeichnung."
   }
 }

lang/en_GB.json

@@ -1022,6 +1022,23 @@
     "gr-konfig-teil-unbekannt": "\nScaffold: add-on part '%1' from configuration '%2' is unknown for this assembly - skipped.",
     "gr-konfig-variante-unbekannt": "\nScaffold: variant '%1' from configuration '%2' is unknown for this assembly - selection unchanged.",
     "gr-fehler-schreiben": "\nScaffold: could not write file: %1",
-    "gr-fehler-keine-baugruppen": "\nScaffold: the data file contains no assemblies."
+    "gr-fehler-keine-baugruppen": "\nScaffold: the data file contains no assemblies.",
+    "gr-tr-fehler-dcl": "Dialog %1 could not be loaded.",
+    "gr-tr-hinweis": "The length is defined in the drawing after OK.",
+    "gr-tr-alert-abzug": "Invalid length deduction. Allowed is a number from 0 (mm); an empty field counts as 0.",
+    "gr-tr-prompt-start": "\nSelect start point of the beam <exit>: ",
+    "gr-tr-prompt-ende": "\nSelect end point or enter length (mm): ",
+    "gr-tr-prompt-richtung": "\nSpecify direction <0>: ",
+    "gr-tr-eingabe-ungueltig": "\nInput '%1' is neither a point nor a length.",
+    "gr-tr-laenge-null": "\nDistance %1 mm is not longer than the deductions (%2 mm) - no beam inserted.",
+    "gr-tr-laenge-bereich": "\nBeam length %1 mm outside the allowed range %2 to %3 mm - no beam inserted.",
+    "gr-tr-fertig": "\nBeam %1 mm inserted (block %2).",
+    "gr-tr-ende": "\n%1 beam(s) inserted.",
+    "gr-tr-bez-abzug-anfang": "Deduction start %1 mm",
+    "gr-tr-bez-abzug-ende": "Deduction end %1 mm",
+    "gr-tr-beschr-stil-fehlt": "\nText style %1 missing in drawing - labelling with current style %2.",
+    "gr-tr-beschr-ausrichtung": "\nUnknown justification %1 for beam label - using BC.",
+    "gr-tr-beschr-ergebnis": "\n%1 beam(s) labelled (%2 without known variant), %3 not labellable, %4 orphaned label(s) removed.",
+    "gr-tr-beschr-keine": "\nNo pipe scaffold beams in the drawing."
   }
 }

lib/export_csv.py

@@ -319,16 +319,25 @@ def build_geruest_merkmale(block):
     pattern_geruest in cfg/export.cfg, GeruestInsert.lsp *geruest-attrib-defs*).
 
     ARTINR/LAENGE/BEZEICHNUNG wandern in feste CSV-Spalten (teileid/
-    bezeichnung ueben in process_blocks unten), TEILEART/FARBE/LAYER bleiben
+    bezeichnung ueben in process_blocks unten), TEILEART/TEILEFARBE/LAYER
-    als Rest-Attribute in der Merkmale-JSON-Spalte - so wie bei Separator/
+    bleiben als Rest-Attribute in der Merkmale-JSON-Spalte - so wie bei
-    Scanner/BTMT bereits ueblich."""
+    Separator/Scanner/BTMT bereits ueblich.
+
+    Die Laengenabzuege gibt es nur beim Rohr-Geruest-Traeger
+    (*geruest-traeger-attrib-defs*) und erscheinen darum nur, wenn der Block
+    sie traegt - die Merkmale der anderen GR_-Bloecke bleiben unveraendert."""
     attribs = block.get("attribs", {})
-    return {
+    merkmale = {
         "TeileArt": attribs.get("TEILEART", ""),
-        "Farbe": attribs.get("FARBE", ""),
+        "Farbe": attribs.get("TEILEFARBE", ""),
         "Laenge": attribs.get("LAENGE", ""),
         "Layer": attribs.get("LAYER", ""),
     }
+    for tag, name in (("LAENGENABZUGANFANG", "LaengenabzugAnfang"),
+                      ("LAENGENABZUGENDE", "LaengenabzugEnde")):
+        if tag in attribs:
+            merkmale[name] = attribs[tag]
+    return merkmale
 
 
 def format_sensor_id(prefix, n):

menu/SSG_LIB.cui

@@ -539,7 +539,7 @@
       <MenuMacro UID="MM_00115">
         <Macro>
           <Name>Rohr-Geruest-Traeger</Name>
-          <Command>^C^C(ssg-ensure "GeruestInsert") GERUEST</Command>
+          <Command>^C^C(ssg-ensure "GeruestInsert") GERUEST_TRAEGER</Command>
         </Macro>
       </MenuMacro>
       <MenuMacro UID="MM_00116">
@@ -560,211 +560,223 @@
           <Command>^C^C(ssg-ensure "GeruestInsert") GERUEST_WANDBEFESTIGUNG</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00122">
+      <MenuMacro UID="MM_00119">
+        <Macro>
+          <Name>Gattertraeger</Name>
+          <Command>^C^C(ssg-ensure "GeruestInsert") GERUEST</Command>
+        </Macro>
+      </MenuMacro>
+      <MenuMacro UID="MM_00121">
+        <Macro>
+          <Name>Traeger beschriften</Name>
+          <Command>^C^C(ssg-ensure "GeruestInsert") GERUEST_TRAEGER_BESCHRIFTEN</Command>
+        </Macro>
+      </MenuMacro>
+      <MenuMacro UID="MM_00124">
         <Macro>
           <Name>Marker einfuegen</Name>
           <Command>^C^C(ssg-ensure "Tro_Edit") TRO_INSERT</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00123">
+      <MenuMacro UID="MM_00125">
         <Macro>
           <Name>Marker bearbeiten</Name>
           <Command>^C^C(ssg-ensure "Tro_Edit") TRO_EDIT</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00124">
+      <MenuMacro UID="MM_00126">
         <Macro>
           <Name>Bearbeiten (Auto)</Name>
           <Command>^C^C(ssg-ensure "SSG_LIB_Commands") SSG_BLOCKEDIT</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00126">
+      <MenuMacro UID="MM_00128">
         <Macro>
           <Name>Verbindung einfuegen</Name>
           <Command>^C^C(ssg-ensure "Connection_Edit") CONNECTION_INSERT</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00127">
+      <MenuMacro UID="MM_00129">
         <Macro>
           <Name>Verbindung bearbeiten</Name>
           <Command>^C^C(ssg-ensure "Connection_Edit") CONNECTION_EDIT</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00129">
+      <MenuMacro UID="MM_00131">
         <Macro>
           <Name>Eingang</Name>
           <Command>^C^C(ssg-ensure "SSG_LIB_Commands") ILS_EINGANG_INSERT</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00130">
+      <MenuMacro UID="MM_00132">
         <Macro>
           <Name>Ausgang</Name>
           <Command>^C^C(ssg-ensure "SSG_LIB_Commands") ILS_AUSGANG_INSERT</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00131">
+      <MenuMacro UID="MM_00133">
         <Macro>
           <Name>SPS Schliessen</Name>
           <Command>^C^C</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00133">
+      <MenuMacro UID="MM_00135">
         <Macro>
           <Name>Export Sivas</Name>
           <Command>^C^C(ssg-ensure "export") EXPORTSIVAS</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00134">
+      <MenuMacro UID="MM_00136">
         <Macro>
           <Name>Export CSV</Name>
           <Command>^C^C(ssg-ensure "export") EXPORTCSV</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00136">
+      <MenuMacro UID="MM_00138">
         <Macro>
           <Name>Umschalten 2D und 3D</Name>
           <Command>^C^C(ssg-ensure "SSG_LIB_Commands") SSG_DIM_SWITCH</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00137">
+      <MenuMacro UID="MM_00139">
         <Macro>
           <Name>Alle Bloecke auf 2D</Name>
           <Command>^C^C(ssg-ensure "SSG_LIB_Commands") SSG_DIM_ALL_2D</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00138">
+      <MenuMacro UID="MM_00140">
         <Macro>
           <Name>Alle Bloecke auf 3D</Name>
           <Command>^C^C(ssg-ensure "SSG_LIB_Commands") SSG_DIM_ALL_3D</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00139">
+      <MenuMacro UID="MM_00141">
         <Macro>
           <Name>Sprache</Name>
           <Command>^C^C(ssg-ensure "SSG_LIB_Commands") SSG_SPRACHE</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00140">
+      <MenuMacro UID="MM_00142">
         <Macro>
           <Name>Planquadrate an/aus</Name>
           <Command>^C^C(ssg-ensure "DrawPlanquadrate") PLANQUADRATE_TOGGLE</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00141">
+      <MenuMacro UID="MM_00143">
         <Macro>
           <Name>CSV-Export</Name>
           <Command>^C^C(ssg-ensure "export") CSV_EXPORT_KONFIG</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00143">
+      <MenuMacro UID="MM_00145">
         <Macro>
           <Name>alle Tests ausfuehren und exportieren</Name>
           <Command>^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_run_all.lsp")) (c:SSG_RUN_ALL_TESTS_EXPORT)</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00144">
+      <MenuMacro UID="MM_00146">
         <Macro>
           <Name>Tests ausfuehren und stehen lassen</Name>
           <Command>^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_run_all.lsp")) (c:SSG_RUN_ALL_TESTS_OFFEN)</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00145">
+      <MenuMacro UID="MM_00147">
         <Macro>
           <Name>Export CSV/Sivas ALL</Name>
           <Command>^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_export_all.lsp")) (c:TEST_EXPORT_ALL)</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00147">
+      <MenuMacro UID="MM_00149">
         <Macro>
           <Name>Kreisel</Name>
           <Command>^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_kreisel.lsp")) (c:TEST_KREISEL)</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00148">
+      <MenuMacro UID="MM_00150">
         <Macro>
           <Name>Foerderer</Name>
           <Command>^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_foerderer.lsp")) (c:TEST_FOERDERER)</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00149">
+      <MenuMacro UID="MM_00151">
         <Macro>
           <Name>Foerderer-Linienzug</Name>
           <Command>^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_linienzug.lsp")) (c:TEST_LINIENZUG) (c:TEST_LINIENZUG_STUFE2)</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00150">
+      <MenuMacro UID="MM_00152">
         <Macro>
           <Name>Omniflo</Name>
           <Command>^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_omniflo.lsp")) (c:TEST_OMNIFLO)</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00151">
+      <MenuMacro UID="MM_00153">
         <Macro>
           <Name>Omniflo Strecke</Name>
           <Command>^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_omniflo_strecke.lsp")) (c:TEST_OMNIFLO_STRECKE)</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00152">
+      <MenuMacro UID="MM_00154">
         <Macro>
           <Name>Gefaellestrecke</Name>
           <Command>^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_gefaellestrecke.lsp")) (c:TEST_GEFAELLESTRECKE)</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00153">
+      <MenuMacro UID="MM_00155">
         <Macro>
           <Name>Mubea Gesamtmodell</Name>
           <Command>^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_mubea.lsp")) (c:TEST_MUBEA)</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00154">
+      <MenuMacro UID="MM_00156">
         <Macro>
           <Name>HundM05 Kreisel-Abschnitt</Name>
           <Command>^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_hundm05.lsp")) (c:TEST_HUNDM05)</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00155">
+      <MenuMacro UID="MM_00157">
         <Macro>
           <Name>KS 2D/3D pruefen (CSV)</Name>
           <Command>^C^C(load (strcat (getenv "DXFMAKRO") "/Lisp/ks_pruefung.lsp")) KS_PRUEFEN</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00167">
+      <MenuMacro UID="MM_00169">
         <Macro>
           <Name>Kreisel bearbeiten</Name>
           <Command>(ssg-ensure "KreiselInsert") KreiselEdit</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00168">
+      <MenuMacro UID="MM_00170">
         <Macro>
           <Name>Omniflo Element bearbeiten</Name>
           <Command>(ssg-ensure "OmniModulInsert") OMNI_EDIT</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00169">
+      <MenuMacro UID="MM_00171">
         <Macro>
           <Name>Gefaellestrecke bearbeiten</Name>
           <Command>(ssg-ensure "Gefaellestrecke") GEFAELLESTRECKE_EDIT</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00170">
+      <MenuMacro UID="MM_00172">
         <Macro>
           <Name>VarioFoerderer bearbeiten</Name>
           <Command>(ssg-ensure "VarioFoerderer") VARIOFOERDERER_EDIT</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00171">
+      <MenuMacro UID="MM_00173">
         <Macro>
           <Name>TRO-Marker bearbeiten</Name>
           <Command>(ssg-ensure "Tro_Edit") TRO_EDIT</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00172">
+      <MenuMacro UID="MM_00174">
         <Macro>
           <Name>Verbindung bearbeiten</Name>
           <Command>(ssg-ensure "Connection_Edit") CONNECTION_EDIT</Command>
         </Macro>
       </MenuMacro>
-      <MenuMacro UID="MM_00174">
+      <MenuMacro UID="MM_00176">
         <Macro>
           <Name>SSG Bearbeiten (Auto)</Name>
           <Command>(ssg-ensure "SSG_LIB_Commands") SSG_BLOCKEDIT</Command>
@@ -782,10 +794,10 @@
           <PopMenuRef pUID="PM_00005"/>
           <PopMenuRef pUID="PM_00031"/>
           <PopMenuRef pUID="PM_00114"/>
-          <PopMenuRef pUID="PM_00120"/>
+          <PopMenuRef pUID="PM_00122"/>
-          <PopMenuRef pUID="PM_00132"/>
+          <PopMenuRef pUID="PM_00134"/>
-          <PopMenuRef pUID="PM_00135"/>
+          <PopMenuRef pUID="PM_00137"/>
-          <PopMenuRef pUID="PM_00142"/>
+          <PopMenuRef pUID="PM_00144"/>
         </PopMenu>
         <PopMenu UID="PM_00005">
           <Name>ILS</Name>
@@ -1413,249 +1425,259 @@
           <PopMenuItem>
             <NameRef>Gattertraeger</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00115"/>
+              <MacroRef MenuMacroID="MM_00119"/>
+            </MenuItem>
+          </PopMenuItem>
+          <PopMenuRef pUID="PM_00120"/>
+        </PopMenu>
+        <PopMenu UID="PM_00120">
+          <Name>Funktionen</Name>
+          <PopMenuItem>
+            <NameRef>Traeger beschriften</NameRef>
+            <MenuItem>
+              <MacroRef MenuMacroID="MM_00121"/>
             </MenuItem>
           </PopMenuItem>
         </PopMenu>
-        <PopMenu UID="PM_00120">
+        <PopMenu UID="PM_00122">
           <Name>SPS</Name>
-          <PopMenuRef pUID="PM_00121"/>
+          <PopMenuRef pUID="PM_00123"/>
-          <PopMenuRef pUID="PM_00125"/>
+          <PopMenuRef pUID="PM_00127"/>
           <PopMenuItem>
             <NameRef>Eingang</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00129"/>
+              <MacroRef MenuMacroID="MM_00131"/>
             </MenuItem>
           </PopMenuItem>
           <PopMenuItem>
             <NameRef>Ausgang</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00130"/>
+              <MacroRef MenuMacroID="MM_00132"/>
             </MenuItem>
           </PopMenuItem>
           <PopMenuItem>
             <NameRef>SPS Schliessen</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00131"/>
+              <MacroRef MenuMacroID="MM_00133"/>
             </MenuItem>
           </PopMenuItem>
         </PopMenu>
-        <PopMenu UID="PM_00121">
+        <PopMenu UID="PM_00123">
           <Name>TRO</Name>
           <PopMenuItem>
             <NameRef>Marker einfuegen</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00122"/>
+              <MacroRef MenuMacroID="MM_00124"/>
             </MenuItem>
           </PopMenuItem>
           <PopMenuItem>
             <NameRef>Marker bearbeiten</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00123"/>
+              <MacroRef MenuMacroID="MM_00125"/>
             </MenuItem>
           </PopMenuItem>
           <PopMenuItem>
             <NameRef>Bearbeiten (Auto)</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00124"/>
+              <MacroRef MenuMacroID="MM_00126"/>
             </MenuItem>
           </PopMenuItem>
         </PopMenu>
-        <PopMenu UID="PM_00125">
+        <PopMenu UID="PM_00127">
           <Name>Connections</Name>
           <PopMenuItem>
             <NameRef>Verbindung einfuegen</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00126"/>
+              <MacroRef MenuMacroID="MM_00128"/>
             </MenuItem>
           </PopMenuItem>
           <PopMenuItem>
             <NameRef>Verbindung bearbeiten</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00127"/>
+              <MacroRef MenuMacroID="MM_00129"/>
             </MenuItem>
           </PopMenuItem>
           <PopMenuItem>
             <NameRef>Bearbeiten (Auto)</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00124"/>
+              <MacroRef MenuMacroID="MM_00126"/>
             </MenuItem>
           </PopMenuItem>
         </PopMenu>
-        <PopMenu UID="PM_00132">
+        <PopMenu UID="PM_00134">
           <Name>Export</Name>
           <PopMenuItem>
             <NameRef>Export Sivas</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00133"/>
+              <MacroRef MenuMacroID="MM_00135"/>
             </MenuItem>
           </PopMenuItem>
           <PopMenuItem>
             <NameRef>Export CSV</NameRef>
-            <MenuItem>
-              <MacroRef MenuMacroID="MM_00134"/>
-            </MenuItem>
-          </PopMenuItem>
-        </PopMenu>
-        <PopMenu UID="PM_00135">
-          <Name>Konfiguration</Name>
-          <PopMenuItem>
-            <NameRef>Umschalten 2D und 3D</NameRef>
             <MenuItem>
               <MacroRef MenuMacroID="MM_00136"/>
             </MenuItem>
           </PopMenuItem>
+        </PopMenu>
+        <PopMenu UID="PM_00137">
+          <Name>Konfiguration</Name>
           <PopMenuItem>
-            <NameRef>Alle Bloecke auf 2D</NameRef>
+            <NameRef>Umschalten 2D und 3D</NameRef>
-            <MenuItem>
-              <MacroRef MenuMacroID="MM_00137"/>
-            </MenuItem>
-          </PopMenuItem>
-          <PopMenuItem>
-            <NameRef>Alle Bloecke auf 3D</NameRef>
             <MenuItem>
               <MacroRef MenuMacroID="MM_00138"/>
             </MenuItem>
           </PopMenuItem>
           <PopMenuItem>
-            <NameRef>Sprache</NameRef>
+            <NameRef>Alle Bloecke auf 2D</NameRef>
             <MenuItem>
               <MacroRef MenuMacroID="MM_00139"/>
             </MenuItem>
           </PopMenuItem>
           <PopMenuItem>
-            <NameRef>Planquadrate an/aus</NameRef>
+            <NameRef>Alle Bloecke auf 3D</NameRef>
             <MenuItem>
               <MacroRef MenuMacroID="MM_00140"/>
             </MenuItem>
           </PopMenuItem>
           <PopMenuItem>
-            <NameRef>CSV-Export</NameRef>
+            <NameRef>Sprache</NameRef>
             <MenuItem>
               <MacroRef MenuMacroID="MM_00141"/>
             </MenuItem>
           </PopMenuItem>
+          <PopMenuItem>
+            <NameRef>Planquadrate an/aus</NameRef>
+            <MenuItem>
+              <MacroRef MenuMacroID="MM_00142"/>
+            </MenuItem>
+          </PopMenuItem>
+          <PopMenuItem>
+            <NameRef>CSV-Export</NameRef>
+            <MenuItem>
+              <MacroRef MenuMacroID="MM_00143"/>
+            </MenuItem>
+          </PopMenuItem>
         </PopMenu>
-        <PopMenu UID="PM_00142">
+        <PopMenu UID="PM_00144">
           <Name>Tests</Name>
           <PopMenuItem>
             <NameRef>alle Tests ausfuehren und exportieren</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00143"/>
+              <MacroRef MenuMacroID="MM_00145"/>
             </MenuItem>
           </PopMenuItem>
           <PopMenuItem>
             <NameRef>Tests ausfuehren und stehen lassen</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00144"/>
+              <MacroRef MenuMacroID="MM_00146"/>
             </MenuItem>
           </PopMenuItem>
           <PopMenuItem>
             <NameRef>Export CSV/Sivas ALL</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00145"/>
+              <MacroRef MenuMacroID="MM_00147"/>
             </MenuItem>
           </PopMenuItem>
           <PopMenuItem IsSeparator="true"/>
           <PopMenuItem>
             <NameRef>Kreisel</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00147"/>
+              <MacroRef MenuMacroID="MM_00149"/>
             </MenuItem>
           </PopMenuItem>
           <PopMenuItem>
             <NameRef>Foerderer</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00148"/>
+              <MacroRef MenuMacroID="MM_00150"/>
             </MenuItem>
           </PopMenuItem>
           <PopMenuItem>
             <NameRef>Foerderer-Linienzug</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00149"/>
+              <MacroRef MenuMacroID="MM_00151"/>
             </MenuItem>
           </PopMenuItem>
           <PopMenuItem>
             <NameRef>Omniflo</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00150"/>
+              <MacroRef MenuMacroID="MM_00152"/>
             </MenuItem>
           </PopMenuItem>
           <PopMenuItem>
             <NameRef>Omniflo Strecke</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00151"/>
+              <MacroRef MenuMacroID="MM_00153"/>
             </MenuItem>
           </PopMenuItem>
           <PopMenuItem>
             <NameRef>Gefaellestrecke</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00152"/>
+              <MacroRef MenuMacroID="MM_00154"/>
             </MenuItem>
           </PopMenuItem>
           <PopMenuItem>
             <NameRef>Mubea Gesamtmodell</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00153"/>
+              <MacroRef MenuMacroID="MM_00155"/>
             </MenuItem>
           </PopMenuItem>
           <PopMenuItem>
             <NameRef>HundM05 Kreisel-Abschnitt</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00154"/>
+              <MacroRef MenuMacroID="MM_00156"/>
             </MenuItem>
           </PopMenuItem>
           <PopMenuItem>
             <NameRef>KS 2D/3D pruefen (CSV)</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00155"/>
+              <MacroRef MenuMacroID="MM_00157"/>
             </MenuItem>
           </PopMenuItem>
         </PopMenu>
-        <PopMenu UID="PM_00166">
+        <PopMenu UID="PM_00168">
           <Alias>POP501</Alias>
           <Name>SSG_LIB Edit Context</Name>
           <PopMenuItem>
             <NameRef>Kreisel bearbeiten</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00167"/>
+              <MacroRef MenuMacroID="MM_00169"/>
             </MenuItem>
           </PopMenuItem>
           <PopMenuItem>
             <NameRef>Omniflo Element bearbeiten</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00168"/>
+              <MacroRef MenuMacroID="MM_00170"/>
             </MenuItem>
           </PopMenuItem>
           <PopMenuItem>
             <NameRef>Gefaellestrecke bearbeiten</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00169"/>
+              <MacroRef MenuMacroID="MM_00171"/>
             </MenuItem>
           </PopMenuItem>
           <PopMenuItem>
             <NameRef>VarioFoerderer bearbeiten</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00170"/>
+              <MacroRef MenuMacroID="MM_00172"/>
             </MenuItem>
           </PopMenuItem>
           <PopMenuItem>
             <NameRef>TRO-Marker bearbeiten</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00171"/>
+              <MacroRef MenuMacroID="MM_00173"/>
             </MenuItem>
           </PopMenuItem>
           <PopMenuItem>
             <NameRef>Verbindung bearbeiten</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00172"/>
+              <MacroRef MenuMacroID="MM_00174"/>
             </MenuItem>
           </PopMenuItem>
           <PopMenuItem IsSeparator="true"/>
           <PopMenuItem>
             <NameRef>SSG Bearbeiten (Auto)</NameRef>
             <MenuItem>
-              <MacroRef MenuMacroID="MM_00174"/>
+              <MacroRef MenuMacroID="MM_00176"/>
             </MenuItem>
           </PopMenuItem>
         </PopMenu>

menu/SSG_LIB.mnu

@@ -112,11 +112,13 @@
 [<-~APBW 110 R550/67,5 58x497]^C^C(ssg-ensure "OmniModulInsert") OMNI_APBW_R550_675_58
 [<-Element bearbeiten]^C^C(ssg-ensure "OmniModulInsert") OMNI_EDIT
 [->Geruest]^C^C(ssg-ensure "GeruestInsert") GERUEST
-[Rohr-Geruest-Traeger]^C^C(ssg-ensure "GeruestInsert") GERUEST
+[Rohr-Geruest-Traeger]^C^C(ssg-ensure "GeruestInsert") GERUEST_TRAEGER
 [Saeulen]^C^C(ssg-ensure "GeruestInsert") GERUEST_SAEULEN
 [Rohrabhaenger]^C^C(ssg-ensure "GeruestInsert") GERUEST_ROHRABHAENGER
 [Wandbefestigung]^C^C(ssg-ensure "GeruestInsert") GERUEST_WANDBEFESTIGUNG
-[<-Gattertraeger]^C^C(ssg-ensure "GeruestInsert") GERUEST
+[Gattertraeger]^C^C(ssg-ensure "GeruestInsert") GERUEST
+[->Funktionen]
+[<-<-Traeger beschriften]^C^C(ssg-ensure "GeruestInsert") GERUEST_TRAEGER_BESCHRIFTEN
 [->SPS]
 [->TRO]
 [Marker einfuegen]^C^C(ssg-ensure "Tro_Edit") TRO_INSERT

tests/test_unit.lsp

@@ -754,9 +754,9 @@
   (if (findfile _datei)
     (progn
       (setq _daten (ssg-json-laden _datei))
-      ;; Drei Bereiche: Rohrabhaenger, Saeulen (1 und 2 Zoll zusammengefuehrt),
+      ;; Vier Baugruppen: Rohrabhaenger, Saeulen (1 und 2 Zoll
-      ;; Wandbefestigung
+      ;; zusammengefuehrt), Wandbefestigung, Rohr-Geruest-Traeger
-      (tu-eq "json/geruest-baugruppen" 3 (length _daten))
+      (tu-eq "json/geruest-baugruppen" 4 (length _daten))
       ;; Baugruppe ueber das ASCII-Feld "id" finden (aeusserer Schluessel
       ;; traegt Umlaute bzw. Anfuehrungszeichen)
       (setq _bg nil)
@@ -773,11 +773,16 @@
                  (ssg-json-get _bg "teileart"))
           (tu-eq "json/geruest-dummy" "Rohrabhaenger_dummy.dwg"
                  (ssg-json-get _bg "dummy"))
-          ;; Sivas-ID als Zahl geparst, Laengengrenze aus dem attribute-Block
+          ;; Sivas-ID als Zahl geparst, Laengengrenze aus dem attribute-Block.
+          ;; Die Keys unter "attribute" sind die Block-Attribut-Tags und darum
+          ;; GROSS geschrieben (ssg-json-get unterscheidet Gross/Klein).
           (tu-eq "json/geruest-sivas" 821006026
                  (ssg-json-get (car (ssg-json-get (car _var) "teile")) "sivas_id"))
           (tu-eq "json/geruest-max" 6000
-                 (ssg-json-get (ssg-json-get (ssg-json-get _bg "attribute") "Laenge") "max"))
+                 (ssg-json-get (ssg-json-get (ssg-json-get _bg "attribute") "LAENGE") "max"))
+          (tu-eq "json/geruest-farboptionen" '("RAL7035" "RAL7030")
+                 (ssg-json-get (ssg-json-get (ssg-json-get _bg "attribute") "TEILEFARBE")
+                               "optionen"))
         )
       )
     )
@@ -978,6 +983,245 @@
                    (geruest-variante-wert
                      (nth _rec (ssg-json-get _saeulen "geometrie_varianten"))
                      _saeulen "teileart")))
+          ;; Attribut-Keys GROSS - sonst findet geruest-dialog min/max und
+          ;; Farben nicht (Laengenfeld ohne Pruefung, leere Farbliste).
+          (tu-eq "geruest/saeulen-laenge-max" 6000
+                 (geruest-attr-feld nil _saeulen "LAENGE" "max"))
+          (tu-true "geruest/saeulen-farboptionen"
+                   (geruest-attr-feld nil _saeulen "TEILEFARBE" "optionen"))
+        )
+      )
+
+      ;; --- Rohr-Geruest-Traeger: reine Berechnung ---
+      ;; Netto-Laenge = Strecke minus beide Abzuege, nil wenn nichts uebrig
+      (tu-eqf "geruest-traeger-laenge/ende"   965.0 (geruest-traeger-laenge 1000.0 0.0 35.0))
+      (tu-eqf "geruest-traeger-laenge/beide"  945.0 (geruest-traeger-laenge 1000.0 20.0 35.0))
+      (tu-eqf "geruest-traeger-laenge/ohne"  1000.0 (geruest-traeger-laenge 1000.0 nil nil))
+      (tu-nil "geruest-traeger-laenge/zu-kurz"      (geruest-traeger-laenge 50.0 30.0 30.0))
+      (tu-nil "geruest-traeger-laenge/genau-null"   (geruest-traeger-laenge 60.0 30.0 30.0))
+      ;; Startpunkt wird um den Anfangsabzug entlang der Richtung eingerueckt,
+      ;; Z bleibt die des Startklicks
+      (tu-eqf "geruest-traeger-start/0grad" '(20.0 0.0 500.0)
+              (geruest-traeger-start '(0.0 0.0 500.0) 0.0 20.0))
+      (tu-eqf "geruest-traeger-start/90grad" '(100.0 220.0 0.0)
+              (geruest-traeger-start '(100.0 200.0 0.0) (/ pi 2.0) 20.0))
+      (tu-eqf "geruest-traeger-start/2d-punkt" '(5.0 0.0 0.0)
+              (geruest-traeger-start '(5.0 0.0) 0.0 0.0))
+      ;; Querstreben: Abstand max. 500, Rand 100..250 beidseitig gleich,
+      ;; so wenige wie moeglich
+      ;; Abstand genau 500, solange der Rand in 100..250 bleibt
+      (tu-eqf "geruest-traeger-streben/1200" '(100.0 600.0 1100.0)
+              (geruest-traeger-streben 1200.0 500.0 100.0 250.0))
+      (tu-eqf "geruest-traeger-streben/1300" '(150.0 650.0 1150.0)
+              (geruest-traeger-streben 1300.0 500.0 100.0 250.0))
+      ;; 1100 geht mit genau 500 nicht auf -> Rand 100, Abstand 450
+      (tu-eqf "geruest-traeger-streben/1100" '(100.0 550.0 1000.0)
+              (geruest-traeger-streben 1100.0 500.0 100.0 250.0))
+      (tu-eqf "geruest-traeger-streben/1500" '(250.0 750.0 1250.0)
+              (geruest-traeger-streben 1500.0 500.0 100.0 250.0))
+      (tu-eqf "geruest-traeger-streben/1000" '(250.0 750.0)
+              (geruest-traeger-streben 1000.0 500.0 100.0 250.0))
+      (tu-eqf "geruest-traeger-streben/eine" '(200.0)
+              (geruest-traeger-streben 400.0 500.0 100.0 250.0))
+      (tu-eqf "geruest-traeger-streben/grenze-500" '(250.0)
+              (geruest-traeger-streben 500.0 500.0 100.0 250.0))
+      (tu-eqf "geruest-traeger-streben/501" '(100.0 401.0)
+              (geruest-traeger-streben 501.0 500.0 100.0 250.0))
+      (tu-nil "geruest-traeger-streben/zu-kurz"
+              (geruest-traeger-streben 150.0 500.0 100.0 250.0))
+      (tu-eqf "geruest-traeger-streben/min-200" '(100.0)
+              (geruest-traeger-streben 200.0 500.0 100.0 250.0))
+      ;; 6000 mm: 11 Felder a 500 -> 12 Streben, letzte bei 5750
+      (setq _rec (geruest-traeger-streben 6000.0 500.0 100.0 250.0))
+      (tu-eq  "geruest-traeger-streben/6000-anzahl" 12 (length _rec))
+      (tu-eqf "geruest-traeger-streben/6000-letzte" 5750.0 (last _rec))
+      ;; Konfiguration: fehlende Felder -> Standard, ohne querstrebe -> nil
+      ;; Ergebnis (dummy laenge querlinie abstand-max rand-min rand-max)
+      (tu-eqf "geruest-traeger-strebe-cfg/standard" '(nil 30.0 25.0 500.0 100.0 250.0)
+              (geruest-traeger-strebe-cfg nil
+                (ssg-json-parse "{\"querstrebe\": {\"rand_min\": 100}}")))
+      (tu-eqf "geruest-traeger-strebe-cfg/dummy" '("s.dwg" 30.0 25.0 500.0 100.0 250.0)
+              (geruest-traeger-strebe-cfg nil
+                (ssg-json-parse "{\"querstrebe\": {\"dummy\": \"s.dwg\"}}")))
+      (tu-eqf "geruest-traeger-strebe-cfg/wert" '(nil 30.0 25.0 400.0 100.0 250.0)
+              (geruest-traeger-strebe-cfg nil
+                (ssg-json-parse "{\"querstrebe\": {\"abstand_max\": 400}}")))
+      ;; Querlinien an Anfang und Ende der 30 mm langen Strebe
+      (tu-eqf "geruest-traeger-strebe-enden" '(235.0 265.0)
+              (geruest-traeger-strebe-enden 250.0 30.0))
+      (tu-nil "geruest-traeger-strebe-cfg/ohne"
+              (geruest-traeger-strebe-cfg nil (ssg-json-parse "{\"id\": \"X\"}")))
+      ;; Muffe nur bei "mit_muffe": true; Variante darf eigene Muffe mitbringen
+      (setq _bgtest (ssg-json-parse "{\"muffe\": {\"dummy\": \"m.dwg\"}}"))
+      (tu-eq "geruest-traeger-muffe-dummy/flag" "m.dwg"
+             (geruest-traeger-muffe-dummy
+               (ssg-json-parse "{\"name\": \"A\", \"mit_muffe\": true}") _bgtest))
+      (tu-nil "geruest-traeger-muffe-dummy/ohne-flag"
+              (geruest-traeger-muffe-dummy
+                (ssg-json-parse "{\"name\": \"Rohr mit Muffe\"}") _bgtest))
+      (tu-eq "geruest-traeger-muffe-dummy/variante" "m2.dwg"
+             (geruest-traeger-muffe-dummy
+               (ssg-json-parse
+                 "{\"mit_muffe\": true, \"muffe\": {\"dummy\": \"m2.dwg\"}}")
+               _bgtest))
+      (tu-nil "geruest-traeger-muffe-dummy/ohne-variante"
+              (geruest-traeger-muffe-dummy nil _bgtest))
+
+      ;; --- Traeger-Beschriftung: reine Berechnung ---
+      ;; Textwinkel entlang des Traegers, DIN: 90 < w <= 270 wird gedreht
+      (tu-eqf "geruest-text-winkel/0"    0.0        (geruest-text-winkel 0.0))
+      (tu-eqf "geruest-text-winkel/45"   (/ pi 4.0) (geruest-text-winkel (/ pi 4.0)))
+      (tu-eqf "geruest-text-winkel/90"   (/ pi 2.0) (geruest-text-winkel (/ pi 2.0)))
+      (tu-eqf "geruest-text-winkel/91"   (* 271 (/ pi 180.0))
+              (geruest-text-winkel (* 91 (/ pi 180.0))))
+      (tu-eqf "geruest-text-winkel/180"  0.0        (geruest-text-winkel pi))
+      (tu-eqf "geruest-text-winkel/270"  (/ pi 2.0) (geruest-text-winkel (* 1.5 pi)))
+      (tu-eqf "geruest-text-winkel/271"  (* 271 (/ pi 180.0))
+              (geruest-text-winkel (* 271 (/ pi 180.0))))
+      ;; -90 = 270 -> gedreht auf 90 (von unten nach oben lesbar)
+      (tu-eqf "geruest-text-winkel/-90"  (/ pi 2.0) (geruest-text-winkel (- (/ pi 2.0))))
+      ;; Ausrichtungs-Codes wie TEXT "Ausrichten" -> (dxf72 dxf73)
+      (tu-eq "geruest-ausrichtung/TL" '(0 3) (geruest-ausrichtung-codes "TL"))
+      (tu-eq "geruest-ausrichtung/TC" '(1 3) (geruest-ausrichtung-codes "TC"))
+      (tu-eq "geruest-ausrichtung/TR" '(2 3) (geruest-ausrichtung-codes "TR"))
+      (tu-eq "geruest-ausrichtung/ML" '(0 2) (geruest-ausrichtung-codes "ML"))
+      (tu-eq "geruest-ausrichtung/MC" '(1 2) (geruest-ausrichtung-codes "MC"))
+      (tu-eq "geruest-ausrichtung/MR" '(2 2) (geruest-ausrichtung-codes "MR"))
+      (tu-eq "geruest-ausrichtung/BL" '(0 1) (geruest-ausrichtung-codes "BL"))
+      (tu-eq "geruest-ausrichtung/BC" '(1 1) (geruest-ausrichtung-codes "BC"))
+      (tu-eq "geruest-ausrichtung/BR" '(2 1) (geruest-ausrichtung-codes "BR"))
+      (tu-eq "geruest-ausrichtung/klein" '(1 1) (geruest-ausrichtung-codes "bc"))
+      (tu-nil "geruest-ausrichtung/unbekannt" (geruest-ausrichtung-codes "XY"))
+      (tu-nil "geruest-ausrichtung/nil"       (geruest-ausrichtung-codes nil))
+      ;; Textlage: Bezugspunkt auf der Linie, "links" in Leserichtung
+      (tu-eqf "geruest-text-lage/0-BC" '((1000.0 0.0 0.0) 0.0 1 1)
+              (geruest-traeger-text-lage '(0.0 0.0 0.0) 0.0 2000.0 "BC"))
+      (tu-eqf "geruest-text-lage/0-BL" '((0.0 0.0 0.0) 0.0 0 1)
+              (geruest-traeger-text-lage '(0.0 0.0 0.0) 0.0 2000.0 "BL"))
+      (tu-eqf "geruest-text-lage/0-BR" '((2000.0 0.0 0.0) 0.0 2 1)
+              (geruest-traeger-text-lage '(0.0 0.0 0.0) 0.0 2000.0 "BR"))
+      ;; Traeger nach links (180): Text gedreht auf 0, links = Linienende
+      (tu-eqf "geruest-text-lage/180-BL" '((-2000.0 0.0 0.0) 0.0 0 1)
+              (geruest-traeger-text-lage '(0.0 0.0 0.0) pi 2000.0 "BL"))
+      (tu-eqf "geruest-text-lage/180-BR" '((0.0 0.0 0.0) 0.0 2 1)
+              (geruest-traeger-text-lage '(0.0 0.0 0.0) pi 2000.0 "BR"))
+      (tu-eqf "geruest-text-lage/180-BC" '((-1000.0 0.0 0.0) 0.0 1 1)
+              (geruest-traeger-text-lage '(0.0 0.0 0.0) pi 2000.0 "BC"))
+      ;; Unbekannter Code -> BC
+      (tu-eqf "geruest-text-lage/ersatz" '((1000.0 0.0 0.0) 0.0 1 1)
+              (geruest-traeger-text-lage '(0.0 0.0 0.0) 0.0 2000.0 "XY"))
+      ;; Text: %1 = Variantentext, %2 = Laenge auf ganze mm
+      (tu-eq "geruest-text-string/beispiel" "RT 80/80 L=2650"
+             (geruest-traeger-text-string "%1 L=%2" "RT 80/80" 2649.5))
+      (tu-eq "geruest-text-string/abrunden" "L=965 RT"
+             (geruest-traeger-text-string "L=%2 %1" "RT" 965.4))
+      (tu-eq "geruest-text-string/mehrfach" "A A 10"
+             (geruest-traeger-text-string "%1 %1 %2" "A" 10.0))
+      ;; Konfiguration je Feld: Variante vor Baugruppe vor Code-Standard
+      (setq _bgtest (ssg-json-parse
+        (strcat "{\"beschriftung\": {\"format\": \"%1 L=%2\", \"stil\": \"S1\","
+                " \"ausrichtung\": \"BC\", \"hoehe\": 50, \"layer\": \"D-5-BEM\"}}")))
+      (setq _rec (geruest-traeger-beschr-cfg
+        (ssg-json-parse
+          "{\"name\": \"RT 80/80 1 Zoll\", \"beschriftung\": {\"text\": \"RT 80/80\", \"layer\": \"D-6-BEM\"}}")
+        _bgtest "ERSATZ"))
+      (tu-eq  "geruest-beschr-cfg/text"   "RT 80/80" (cdr (assoc "text" _rec)))
+      (tu-eq  "geruest-beschr-cfg/layer"  "D-6-BEM"  (cdr (assoc "layer" _rec)))
+      (tu-eq  "geruest-beschr-cfg/stil"   "S1"       (cdr (assoc "stil" _rec)))
+      (tu-eqf "geruest-beschr-cfg/hoehe"  50.0       (cdr (assoc "hoehe" _rec)))
+      (setq _rec (geruest-traeger-beschr-cfg
+        (ssg-json-parse "{\"name\": \"Ohne Text\"}") _bgtest "ERSATZ"))
+      (tu-eq  "geruest-beschr-cfg/text-name" "Ohne Text" (cdr (assoc "text" _rec)))
+      (tu-eq  "geruest-beschr-cfg/layer-bg"  "D-5-BEM"   (cdr (assoc "layer" _rec)))
+      (setq _rec (geruest-traeger-beschr-cfg nil (ssg-json-parse "{\"id\": \"X\"}") "ERSATZ"))
+      (tu-eq  "geruest-beschr-cfg/ersatz"    "ERSATZ"   (cdr (assoc "text" _rec)))
+      (tu-eq  "geruest-beschr-cfg/std-format" "%1 L=%2" (cdr (assoc "format" _rec)))
+      (tu-eq  "geruest-beschr-cfg/std-ausr"  "BC"       (cdr (assoc "ausrichtung" _rec)))
+      (tu-eqf "geruest-beschr-cfg/std-hoehe" 50.0       (cdr (assoc "hoehe" _rec)))
+      (tu-nil "geruest-beschr-cfg/std-layer"            (cdr (assoc "layer" _rec)))
+      ;; Bereichspruefung auf der Netto-Laenge
+      (tu-true "geruest-traeger-pruefen/innen"  (geruest-traeger-pruefen 965.0 0 6000))
+      (tu-nil  "geruest-traeger-pruefen/ueber"  (geruest-traeger-pruefen 6001.0 0 6000))
+      (tu-true "geruest-traeger-pruefen/grenze" (geruest-traeger-pruefen 6000.0 0 6000))
+      (tu-true "geruest-traeger-pruefen/ohne"   (geruest-traeger-pruefen 99999.0 nil nil))
+      (tu-nil  "geruest-traeger-pruefen/nil"    (geruest-traeger-pruefen nil 0 6000))
+      ;; Eingaben in mm: Komma wie Punkt, negativ/Text ungueltig
+      (tu-eqf "geruest-mm-zahl/ganz"    35.0 (geruest-mm-zahl "35"))
+      (tu-eqf "geruest-mm-zahl/komma"   17.5 (geruest-mm-zahl "17,5"))
+      (tu-nil "geruest-mm-zahl/text"         (geruest-mm-zahl "abc"))
+      (tu-nil "geruest-mm-zahl/negativ"      (geruest-mm-zahl "-5"))
+      (tu-nil "geruest-mm-zahl/leer"         (geruest-mm-zahl ""))
+      (tu-eqf "geruest-abzug-wert/leer"  0.0 (geruest-abzug-wert ""))
+      (tu-nil "geruest-abzug-wert/text"      (geruest-abzug-wert "x"))
+      (tu-eqf "geruest-tr-abzug/inaktiv" 0.0 (geruest-tr-abzug "0" "x"))
+      (tu-eqf "geruest-tr-abzug/aktiv"  35.0 (geruest-tr-abzug "1" "35"))
+      (tu-eq "geruest-mm-string/ganz"   "965"  (geruest-mm-string 965.0))
+      (tu-eq "geruest-mm-string/dezimal" "17.5" (geruest-mm-string 17.5))
+      ;; Variante darf Attribut-Felder ueberschreiben - auch mit false
+      (setq _bgtest (ssg-json-parse
+        "{\"attribute\": {\"LAENGENABZUGENDE\": {\"vorgabe\": 35, \"aktiv\": true}}}"))
+      (tu-eq "geruest-attr-feld/baugruppe" 35
+             (geruest-attr-feld nil _bgtest "LAENGENABZUGENDE" "vorgabe"))
+      (tu-eq "geruest-attr-feld/variante" 50
+             (geruest-attr-feld
+               (ssg-json-parse "{\"attribute\": {\"LAENGENABZUGENDE\": {\"vorgabe\": 50}}}")
+               _bgtest "LAENGENABZUGENDE" "vorgabe"))
+      (tu-nil "geruest-attr-feld/variante-false"
+              (geruest-attr-feld
+                (ssg-json-parse "{\"attribute\": {\"LAENGENABZUGENDE\": {\"aktiv\": false}}}")
+                _bgtest "LAENGENABZUGENDE" "aktiv"))
+
+      ;; --- Rohr-Geruest-Traeger in der echten Datendatei ---
+      ;; Eigener Dialog: im Bereichs-Dropdown von GERUEST darf er fehlen,
+      ;; ueber geruest-baugruppe muss er aber auffindbar sein.
+      (setq _rec nil)
+      (foreach _e (geruest-baugruppen-liste)
+        (if (equal (car _e) "Traeger") (setq _rec T)))
+      (tu-nil "geruest/traeger-nicht-im-dropdown" _rec)
+      (setq _traeger (geruest-baugruppe "Traeger"))
+      (tu-true "geruest/traeger-vorhanden" _traeger)
+      (if _traeger
+        (progn
+          (tu-eq "geruest/traeger-einfuegeart" "linie"
+                 (ssg-json-get _traeger "einfuegeart"))
+          (tu-eq "geruest/traeger-varianten-artikel" 0
+                 (tu-geruest-artikel-unvollstaendig
+                   (ssg-json-get _traeger "geometrie_varianten")))
+          (tu-true "geruest/traeger-layer"
+                   (geruest-variante-wert
+                     (car (ssg-json-get _traeger "geometrie_varianten"))
+                     _traeger "layer"))
+          (tu-eq "geruest/traeger-max" 6000
+                 (geruest-attr-feld nil _traeger "LAENGE" "max"))
+          (tu-eqf "geruest/traeger-querstrebe"
+                  '("dummy_Strebe_30x4.dwg" 30.0 25.0 500.0 100.0 250.0)
+                  (geruest-traeger-strebe-cfg nil _traeger))
+          ;; Muffen-Flag ausdruecklich je Variante: genau die "mit (2) Muffe(n)"
+          (setq _rec 0)
+          (foreach _v (ssg-json-get _traeger "geometrie_varianten")
+            (if (geruest-traeger-muffe-dummy _v _traeger) (setq _rec (1+ _rec))))
+          (tu-eq "geruest/traeger-muffen-varianten" 4 _rec)
+          ;; Jede Variante definiert Beschriftungstext UND -layer selbst - der
+          ;; Layer ist je Traegervariante verschieden, eine Vorgabe der
+          ;; Baugruppe gibt es dafuer bewusst nicht.
+          (setq _rec 0)
+          (foreach _v (ssg-json-get _traeger "geometrie_varianten")
+            (setq _cfg (geruest-traeger-beschr-cfg _v _traeger ""))
+            (if (and (geruest-obj-feld _v _traeger '("beschriftung") "text")
+                     (/= (cdr (assoc "text" _cfg)) "")
+                     (geruest-json-pfad-get _v '("beschriftung" "layer"))
+                     (geruest-ausrichtung-codes (cdr (assoc "ausrichtung" _cfg))))
+              (setq _rec (1+ _rec))))
+          (tu-eq "geruest/traeger-beschriftung-varianten"
+                 (length (ssg-json-get _traeger "geometrie_varianten")) _rec)
+          ;; VARIANTE gehoert zum Traeger-Schema (Grundlage fuer das Neubeschriften)
+          (tu-true "geruest/traeger-attrib-variante"
+                   (assoc "VARIANTE" *geruest-traeger-attrib-defs*))
+          ;; Beide Dummy-DWGs liegen unter data/geruest
+          (tu-true "geruest/traeger-strebe-dwg"
+                   (findfile (geruest-dummy-pfad "dummy_Strebe_30x4.dwg")))
+          (tu-true "geruest/traeger-muffe-dwg"
+                   (findfile (geruest-dummy-pfad "dummy_Muffe_1zoll.dwg")))
         )
       )