Schoenenberger_Systeme_GmbH/dxfmakros
7
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

[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

Browse Source
This commit is contained in:
Simon Hensch
2026-10-02 14:46:12 +02:00
parent b56fc58cf6
commit 6ec85905d4
13 changed files with 1564 additions and 180 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CLAUDE.md
+3 -2
View File
File diff suppressed because one or more lines are too long
Lisp/GeruestInsert.lsp
+873 -32
View File
@@ -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.
(defun geruest-dlg-farbwert ( / idx)
(setq idx (atoi *geruest-dlg-farbe*))
;; Farbliste des Dialogs aus der TEILEFARBE-Definition aufbauen: Optionen +
;; freie Option ans Listenende; deren Index merkt sich der Callback, um das
;; 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 farb-opts (if attr (ssg-json-get attr "Teilefarbe")))
(setq laenge-def (if attr (ssg-json-get attr "LAENGE")))
(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
;; 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)))
)
)
)
)
(geruest-farb-liste-setzen farb-opts)
(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 pause)
(command "_.INSERT" bname pt 1 1 (if rot rot pause))
;; Laufende Einfuegung sicher beenden (z.B. ESC waehrend der Drehung)
(if (> (getvar "CMDACTIVE") 0) (command))
(if (> (getvar "CMDACTIVE") 0) (command))
@@ -1214,8 +1262,6 @@
)
)
)
)
)
;; ============================================================
@@ -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/geruest/R2-Saeule_dummy.dwg
BIN
View File
Binary file not shown.
data/geruest/dummy_Muffe_1zoll.dwg
BIN
View File
Binary file not shown.
data/geruest/dummy_Strebe_30x4.dwg
BIN
View File
Binary file not shown.
data/json/geruest.json
+196 -4
View File
@@ -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
+39
View File
@@ -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
+18 -1
View File
@@ -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
+18 -1
View File
@@ -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
+14 -5
View File
@@ -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
als Rest-Attribute in der Merkmale-JSON-Spalte - so wie bei Separator/
Scanner/BTMT bereits ueblich."""
bezeichnung ueben in process_blocks unten), TEILEART/TEILEFARBE/LAYER
bleiben als Rest-Attribute in der Merkmale-JSON-Spalte - so wie bei
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
+119 -97
View File
@@ -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_00132"/>
<PopMenuRef pUID="PM_00135"/>
<PopMenuRef pUID="PM_00142"/>
<PopMenuRef pUID="PM_00122"/>
<PopMenuRef pUID="PM_00134"/>
<PopMenuRef pUID="PM_00137"/>
<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_00125"/>
<PopMenuRef pUID="PM_00123"/>
<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>
<MenuItem>
<MacroRef MenuMacroID="MM_00137"/>
</MenuItem>
</PopMenuItem>
<PopMenuItem>
<NameRef>Alle Bloecke auf 3D</NameRef>
<NameRef>Umschalten 2D und 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
+4 -2
View File
@@ -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
+249 -5
View File
@@ -754,9 +754,9 @@
(if (findfile _datei)
(progn
(setq _daten (ssg-json-laden _datei))
;; Drei Bereiche: Rohrabhaenger, Saeulen (1 und 2 Zoll zusammengefuehrt),
;; Wandbefestigung
(tu-eq "json/geruest-baugruppen" 3 (length _daten))
;; Vier Baugruppen: Rohrabhaenger, Saeulen (1 und 2 Zoll
;; zusammengefuehrt), Wandbefestigung, Rohr-Geruest-Traeger
(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")))
)
)