Merge branch 'master' of https://gitea.schoenenberger.de/Schoenenberger_Systeme_GmbH/dxfmakros

Lokaler Stand (Modus-3 Randwert-Solver, 30/90-AS/ES, Kreisel-Attribute)
mit dem Remote-Stand (Internationalisierung ssg-text, neue Bloecke,
Sivas-Export) vereint.

Konfliktaufloesung:
- vf_linienzug.lsp: Nicht-interaktive -block-Kerne (fuer Pfad-Modi) behalten,
  interaktive Abfragen (GF-Bogen, Vario-Kurve, ES-Seite) auf ssg-text
  umgestellt. Kein doppelter defun mehr.
- Gefaellestrecke.lsp: 30/90-Winkelabfrage mit den i18n-Seiten-Prompts
  kombiniert; gefaellestrecke-einfuegen-Aufruf mit as-/es-winkel.
- vf_core.lsp: vf-frage-element-winkel nimmt jetzt einen i18n-Header-Key
  (vf-winkel-aus-header / vf-winkel-ein-header) statt festem Text.
- lang/de_DE.json + en_GB.json: neue Keys vf-winkel-aus/ein-header,
  vf-winkel-90/30; gf-seite-Header ohne irrefuehrendes "_90_".
- export_sivas.py: ANZAHL_SEPARATOR/ANZAHL_SCANNER mit N_*-Fallback plus
  Remote-Umsortierung; doppelte "Kreiselart"-Zeile entfernt.
- AS_Element_30_links/rechts.dwg + Separator_SP.dwg (3D): Remote-Version
  (Attribut-Stand) uebernommen. Die KS_AUS-Geometrie-Korrektur der 30-Grad-
  AS-Elemente wird danach in BricsCAD nachgezogen.

Offen (Folge-Commit): die Modus-Treiber in vf_linienzug.lsp
(vf-linienzug-modus / -modus2 / -modus3) sind noch nicht i18n
(ca. 110 Strings).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

.gitignore

@@ -135,6 +135,7 @@ venv/
 ENV/
 env.bak/
 venv.bak/
+_setenv.bat
 
 # cui folder for briscad
 aiassist_next_command/

CLAUDE.md

@@ -67,11 +67,12 @@ Die `start_briscad.bat` ruft `setenv.bat` auf und startet BricsCAD.
 |---|---|---|
 | Kreisel-Module | `KreiselInsert` | KreiselInsert, KreiselConnect, KreiselEdit, ILS_Eckrad |
 | Zusatzmodul/Foerderer/Kurven | `SSG_LIB_Commands` | ILS_BTMT_*, ILS_ETF_*, ILS_K*_*, ILS_GK*_* |
-| VarioFoerderer | `VarioFoerderer` | FOERDERANLAGE |
+| VarioFoerderer | `VarioFoerderer` | FOERDERANLAGE, VARIOFOERDERER_EDIT |
-| Gefaellestrecke | `Gefaellestrecke` | GEFAELLESTRECKE |
+| Gefaellestrecke | `Gefaellestrecke` | GEFAELLESTRECKE, GEFAELLESTRECKE_EDIT |
 | Omniflo (komplett) | `OmniModulInsert` | OMNI_APB_*, OMNI_W*_*, OMNI_AP*, OMNI_TEF_*, OMNI_TV_*, OMNI_EDIT |
 | Export | `export` | EXPORTSIVAS, EXPORTCSV, CALLPYTHON |
-| Doppelklick/Kontextmenue | `SSG_LIB_Commands` | SSG_BLOCKEDIT |
+| Konfiguration | `SSG_LIB_Commands` | SSG_DIM_SWITCH, SSG_SPRACHE |
+| Doppelklick/Kontextmenue | `SSG_LIB_Commands` | SSG_BLOCKEDIT (dispatcht Kreisel->KreiselEdit, Omniflo->OMNI_EDIT, GF_*->GEFAELLESTRECKE_EDIT, VF_*->VARIOFOERDERER_EDIT) |
 
 ### Entfernte Legacy-Dateien
 
@@ -86,15 +87,16 @@ Detaillierte Dokumentation aller Funktionen und Befehle: siehe `Lisp/README.md`.
 | Datei | Befehle | Beschreibung |
 |---|---|---|
 | `ssg_core.lsp` | - | Kernel: ssg-start/ssg-end, ssg-cfg-or, ssg-attrib-read/write, Layer/Block-Ops |
+| `ssg_lang.lsp` | - | Sprachumschaltung Deutsch/Englisch (ssg-text, ssg-textf, *ssg-lang*) |
 | `ssg_dbg.lsp` | - | Debug-Logging (dbgopen, dbgmsg, dbgflush, dbgclose) |
 | `ssg_dialog.lsp` | - | DCL-Dialog-Vorlagen und Hilfsfunktionen |
 | `ssg_layer.lsp` | - | Layer-Verwaltung |
 | `KreiselInsert.lsp` | KreiselInsert, KreiselConnect, KreiselRedraw, KreiselQuick, KreiselEdit, KreiselParams, KreiselLabelSetup, KreiselLabelPos, KreiselLabelHoehe, ILS_Eckrad | ILS Kreisel und Eckrad komplett in AutoLISP |
-| `VarioFoerderer.lsp` | FOERDERANLAGE | Vario-Foerderanlagen Generator |
+| `VarioFoerderer.lsp` (Wrapper fuer `vf_core.lsp`/`vf_standard.lsp`/`vf_etage.lsp`/`vf_linienzug.lsp`) | FOERDERANLAGE, VARIOFOERDERER_EDIT | Vario-Foerderanlagen Generator (Typen Standard/Etage/Linienzug); Standardfall + Werteingabe per DCL-Dialog (`vfs-standard-dialog-ablauf` in vf_standard.lsp); Doppelklick auf VF_n-Block ruft VARIOFOERDERER_EDIT (nur fuer per Dialog erstellte Standard-Bloecke, erkannt an XDATA) |
-| `Gefaellestrecke.lsp` | GEFAELLESTRECKE | Gefaelle-Foerderanlage (AUS -> Staustrecke skaliert -> Separator -> EIN) |
+| `Gefaellestrecke.lsp` | GEFAELLESTRECKE, GEFAELLESTRECKE_EDIT | Gefaelle-Foerderanlage (AUS -> Staustrecke skaliert -> Separator -> EIN); Modus 1 per DCL-Dialog (Einfuegehoehe, Element-Winkel 30/90); Doppelklick auf GF_n-Block ruft GEFAELLESTRECKE_EDIT (Dialog vorbelegt, Neuaufbau) |
-| `export.lsp` | EXPORTSIVAS, EXPORTCSV, OMNI_EXPORT, OMNI_UPDATE_ATTRIBS | JSON-Sammlung und Export (Python-Aufruf oder LISP-nativ) |
+| `export.lsp` | EXPORTSIVAS, EXPORTCSV, OMNI_UPDATE_ATTRIBS | JSON-Sammlung und Python-Export (Omniflo-Merkmale/Sum-Zeile via lib/export_csv.py) |
 | `OmniModulInsert.lsp` | OMNI_LOAD, OMNI_APB_*, OMNI_W*_*, OMNI_AP60/AP110, OMNI_TEF_*, OMNI_TV_*, OMNI_APBW_*, OMNI_EDIT | Omniflo-Komponenten: Boegen, Weichen, Verbinder, Transferwagen, Edit-Dialog |
-| `SSG_LIB_Commands.lsp` | ILS_BTMT_*, ILS_ETF_*, ILS_K*_*, ILS_GK*_*, SSG_BLOCKEDIT | Dummy-Befehle fuer Menue + Doppelklick/Kontextmenue-Dispatcher |
+| `SSG_LIB_Commands.lsp` | ILS_BTMT_*, ILS_ETF_*, ILS_K*_*, ILS_GK*_*, SSG_BLOCKEDIT, SSG_DIM_SWITCH, SSG_SPRACHE | Dummy-Befehle fuer Menue + Doppelklick/Kontextmenue-Dispatcher + Konfiguration (2D/3D, Sprache) |
 | `menu-inventory.lsp` | MenuInventory | BricsCAD Diagnostik (Menuegruppen, Plugins, Startdateien) |
 
 ## DCL-Dialoge
@@ -102,15 +104,18 @@ Detaillierte Dokumentation aller Funktionen und Befehle: siehe `Lisp/README.md`.
 | Datei | Verwendet von |
 |---|---|
 | `kreisel_edit.dcl` | KreiselEdit (KreiselInsert.lsp) |
+| `gefaellestrecke.dcl` | GEFAELLESTRECKE Modus 1 (Gefaellestrecke.lsp, `gf-dialog-eingabe`) |
+| `variofoerderer.dcl` | FOERDERANLAGE Standardfall + Werteingabe (vf_standard.lsp, `vfs-dialog-eingabe-basis`/`vfs-dialog-winkel-verteilung`) |
 | `omniflo_boegen.dcl` | OMNI_APB_* (OmniModulInsert.lsp) |
 | `omniflo_weichen.dcl` | OMNI_W*_* (OmniModulInsert.lsp) |
+| `sprache.dcl` | SSG_SPRACHE (SSG_LIB_Commands.lsp) |
 
 ## Menue (SSG_LIB.mnu + SSG_LIB.mnl)
 
 - `SSG_LIB.mnu` - Menuedefinition mit Lazy-Loading (`(ssg-ensure "Modul") Befehl`)
 - `SSG_LIB.mnl` - Automatisch geladen mit dem Menue, definiert `ssg-ensure` Loader
 - `***MENUGROUP=SSG_LIB` - Menuegruppenname
-- `***POP1` - Hauptmenue (ILS, Omniflo, Export)
+- `***POP1` - Hauptmenue (ILS, Omniflo, Export, Konfiguration)
 - `***DOUBLECLICK` - Doppelklick auf INSERT-Bloecke ruft SSG_BLOCKEDIT auf
 - `***POP501` - Rechtsklick-Kontextmenue (KreiselEdit, OMNI_EDIT, SSG_BLOCKEDIT)
 
@@ -124,6 +129,7 @@ Werden via `bin/setenv.bat` gesetzt. Wichtigste:
 - `DXFM_LOG` - Log-Verzeichnis
 - `DXFM_DCL` - Pfad zu DCL-Dialogdateien
 - `DXFM_CFG` - Konfigurationsverzeichnis
+- `DXFM_LANG` - Aktive Sprache (`de_DE`/`en_GB`), persistiert von `SSG_SPRACHE`; Default `de_DE`
 
 ## Konventionen
 

Lisp/EtageVarioFoerderer.lsp

@@ -18,5 +18,5 @@
 )
 (if *vf-core-datei*
   (load *vf-core-datei*)
-  (princ "\n[EtageVarioFoerderer] WARNUNG: vf_core.lsp nicht gefunden - Befehle nicht verfuegbar.")
+  (princ (ssg-text "vfstart-etage-core-nicht-gefunden"))
 )

Lisp/KreiselInsert.lsp

@@ -19,8 +19,9 @@
 ;; DXFM_DIM sicher lesen (type-Guard gegen nicht-String Rueckgabewerte)
 (setq *ki-dxfm-dim* (getenv "DXFM_DIM"))
 (if (not (= (type *ki-dxfm-dim*) 'STR)) (setq *ki-dxfm-dim* "3D"))
-;; Block-Pfad: primaer aus DXFMAKRO + DXFM_DIM, dann *ssg-lisp-pfad*-Heuristik
+;; Modul-eigener Block-Pfad (nicht in globalem block-pfad speichern,
-(setq block-pfad
+;; da GF/VF stets 3D-Pfad benoetigen, KI aber DXFM_DIM-abhaengig)
+(setq *block-path*
   (cond
     ((and (getenv "DXFMAKRO") (= (type (getenv "DXFMAKRO")) 'STR))
      (strcat (vl-string-right-trim "/" (vl-string-translate "\\" "/" (getenv "DXFMAKRO")))
@@ -30,11 +31,10 @@
      (strcat (substr *ssg-lisp-pfad* 1 (vl-string-search "/Lisp" *ssg-lisp-pfad*))
              "/data/ils/" *ki-dxfm-dim* "/"))
     (t
-     (princ "\n[KreiselInsert] WARNUNG: Block-Pfad nicht ermittelbar!")
+     (princ (ssg-text "kreisel-warn-blockpfad"))
      nil)
   )
 )
-(setq *block-path* block-pfad)
 
 ;; ssg_core laden falls noch nicht geschehen (Schutz bei direktem Laden ohne ssg-ensure)
 (if (null (car (atoms-family 1 '("SSG-CFG-OR"))))
@@ -58,7 +58,7 @@
         (defun ssg-cfg-or (sektion schluessel standard) standard)
         (defun ssg-cfg   (sektion schluessel) nil)
         (defun ssg-load-config () nil)
-        (princ "\n[KreiselInsert] WARNUNG: ssg_core.lsp nicht gefunden - Standardwerte.")
+        (princ (ssg-text "kreisel-warn-core-fehlt"))
       )
     )
   )
@@ -73,11 +73,11 @@
 ;; Attribut-Definitionen: ((TAG DEFAULT) ...)
 (setq *kreisel-attrib-defs*
   '(("NAME"           "")
-    ("DREHRICHTUNG"  "UZS")
+    ("DREHRICHTUNG"     "UZS")
-    ("N_SEPARATOREN" "2")
+    ("ANZAHL_SEPARATOR" "2")
-    ("KREISELART"    "STANDARD")
+    ("KREISELART"       "STANDARD")
-    ("N_SCANNER"     "0")
+    ("ANZAHL_SCANNER"   "0")
-    ("N_RAMPEN"      "0")
+    ("N_RAMPEN"         "0")
     ("DREHUNG"       "0")
     ("ABSTAND"       "2300")
     ("NUMMER"        "0")
@@ -122,7 +122,7 @@
     (progn
       ;; Neuen Textstil mit Arial erstellen
       (command "_.STYLE" style-name "Arial" 0 1 0 "N" "N" "N")
-      (princ (strcat "\n-> Textstil '" style-name "' mit Arial erstellt"))
+      (princ (ssg-textf "kreisel-textstil-erstellt" (list style-name)))
     )
   )
   
@@ -222,7 +222,7 @@
     (cons 11 insertPoint)                 ;; Ausrichtungspunkt
   ))
   
-  (princ (strcat "\n-> Beschriftung: " textStr " (Höhe=" (rtos textHoehe 2 0) "mm, Arial, zentriert)"))
+  (princ (ssg-textf "kreisel-beschriftung-erzeugt" (list textStr (rtos textHoehe 2 0))))
   textStr
 )
 
@@ -230,9 +230,9 @@
 
 ;; Kreiselart abfragen. Rueckgabe: "PIN" oder "STANDARD"
 (defun kreisel-ask-typ ( / typNum typ)
-  (princ "\n[1] STANDARD (ohne PIN)")
+  (princ (ssg-text "kreisel-typ-opt-standard"))
-  (princ "\n[2] PIN")
+  (princ (ssg-text "kreisel-typ-opt-pin"))
-  (princ (strcat "\nBitte waehlen <" (if (= #Kreisel_Typ "PIN") "2" "1") ">: "))
+  (princ (ssg-textf "kreisel-typ-prompt" (list (if (= #Kreisel_Typ "PIN") "2" "1"))))
   (setq typNum (getstring ""))
   (cond
     ((= typNum "2") (setq typ "PIN"))
@@ -337,7 +337,7 @@
     (progn
       (setq z-hoehe (caddr basePoint))
       (setq block-hoehe (rtos z-hoehe 2 0))
-      (princ (strcat "\n-> Höhe aus Basispunkt übernommen: " block-hoehe))
+      (princ (ssg-textf "kreisel-hoehe-aus-basispunkt" (list block-hoehe)))
     )
     (progn
       ;; Höhe aus Attributen lesen
@@ -401,10 +401,10 @@
       )
 
       ;; AN8 Kreis (Antriebsstation) bei (radius, 0)
-      (command "_.INSERT" (strcat block-pfad "AN8.dwg") (list radius 0.0 0.0) 1 1 0)
+      (command "_.INSERT" (strcat *block-path* "AN8.dwg") (list radius 0.0 0.0) 1 1 0)
 
       ;; SP8 Kreis (Spannstation) bei (radius+abstand, 0)
-      (command "_.INSERT" (strcat block-pfad "SP8.dwg") (list (+ radius abstand) 0.0 0.0) 1 1 0)
+      (command "_.INSERT" (strcat *block-path* "SP8.dwg") (list (+ radius abstand) 0.0 0.0) 1 1 0)
 
       ;; Tangenten auf Layer S_LP
       (ssg-make-layer "S_LP" "7" T)
@@ -454,12 +454,12 @@
       ;; --- Block erzeugen (Entities werden aus Zeichnung entfernt) ---
       (if (> (sslength ss) 0)
         (command "_.-BLOCK" bname (list 0.0 0.0 0.0) ss "")
-        (princ "\nFehler: Keine Entities zum Block erstellen!")
+        (princ (ssg-text "kreisel-fehler-keine-entities"))
       )
-      
+
-      (princ (strcat "\n-> Neue Blockdefinition: " bname))
+      (princ (ssg-textf "kreisel-neue-blockdef" (list bname)))
     )
-    (princ (strcat "\n-> Verwende bestehende Blockdefinition: " bname))
+    (princ (ssg-textf "kreisel-bestehende-blockdef" (list bname)))
   )
 
   ;; --- Block am Zielpunkt einfuegen (ohne Attribut-Dialog) ---
@@ -495,8 +495,7 @@
   (if (atoms-family 1 '("ssg-id-generate"))
     (ssg-id-generate block-ent)
   )
-  (princ (strcat "\n-> Kreisel #" (itoa kreisel-nummer) " eingefügt: " bname
+  (princ (ssg-textf "kreisel-eingefuegt" (list (itoa kreisel-nummer) bname block-hoehe)))
-                 " (Höhe=" block-hoehe ")"))
   (entlast)
 )
 
@@ -514,19 +513,19 @@
 ;; --------------------------------------------
 (defun c:KreiselInsert ( / pt abstand typ rotation rotStr hoehe 
                            selectedEnt blockAttribs oldOsmode)
-  (ssg-start "Kreisel Modul einfuegen" '(("OSMODE") ("CECOLOR")))
+  (ssg-start (ssg-text "kreisel-start-insert") '(("OSMODE") ("CECOLOR")))
   
   ;; Temporär Osnap für Blockerkennung setzen
   (setq oldOsmode (getvar "OSMODE"))
   (setvar "OSMODE" (logior oldOsmode 512))  ;; 512 = INS (Block-Einfügepunkt)
   
   ;; 1. Einfuegepunkt
-  (setq pt (getpoint "\nBasispunkt (AN-Seite): "))
+  (setq pt (getpoint (ssg-text "kreisel-prompt-basispunkt")))
-  (if (null pt) 
+  (if (null pt)
-    (progn 
+    (progn
       (setvar "OSMODE" oldOsmode)
-      (ssg-end) 
+      (ssg-end)
-      (princ "\nBefehl abgebrochen.")
+      (princ (ssg-text "kreisel-abbruch-befehl"))
       (princ)
       (return)
     )
@@ -546,41 +545,39 @@
           (setq blockAttribs (ssg-attrib-read selectedEnt))
           (assoc "HOEHE" blockAttribs))
      (setq hoehe (atof (cdr (assoc "HOEHE" blockAttribs))))
-     (princ (strcat "\n-> Höhe von bestehendem Kreisel übernommen: " (rtos hoehe 2 0)))
+     (princ (ssg-textf "kreisel-hoehe-von-bestehendem" (list (rtos hoehe 2 0))))
     )
     ;; Fall 2: Punkt hat Z-Koordinate > 0
     ((and (> (length pt) 2) (> (caddr pt) 0))
      (setq hoehe (caddr pt))
-     (princ (strcat "\n-> Höhe aus 3D-Punkt übernommen: " (rtos hoehe 2 0)))
+     (princ (ssg-textf "kreisel-hoehe-aus-3dpunkt" (list (rtos hoehe 2 0))))
     )
     ;; Fall 3: Sonst separat abfragen
     (t
-     (setq hoehe (getreal (strcat "\nHöhe (Z-Koordinate) <" (rtos *kreisel-default-hoehe* 2 0) ">: ")))
+     (setq hoehe (getreal (ssg-textf "kreisel-prompt-hoehe-z" (list (rtos *kreisel-default-hoehe* 2 0)))))
      (if (null hoehe) (setq hoehe *kreisel-default-hoehe*))
     )
   )
 
   ;; 3. Abstand
   (initget 6)
-  (setq abstand (getdist (list (car pt) (cadr pt)) 
+  (setq abstand (getdist (list (car pt) (cadr pt))
-                         (strcat "\nAbstand (Tangentenlaenge) <"
+                         (ssg-textf "kreisel-prompt-abstand" (list (rtos *kreisel-default-laenge* 2 0)))))
-                                 (rtos *kreisel-default-laenge* 2 0) ">: ")))
   (if (null abstand) (setq abstand *kreisel-default-laenge*))
-  (princ (strcat "\n-> Abstand: " (rtos abstand 2 0) " mm"))
+  (princ (ssg-textf "kreisel-abstand-ausgabe" (list (rtos abstand 2 0))))
-  
+
   ;; 4. Rotation
-  (setq rotStr (getstring "\nRotation in Grad <0>: "))
+  (setq rotStr (getstring (ssg-text "kreisel-prompt-rotation")))
   (if (= rotStr "")
     (setq rotation 0.0)
     (setq rotation (atof rotStr))
   )
-  
+
   ;; 5. Kreiselart
   (setq typ (kreisel-ask-typ))
 
-  (princ (strcat "\n-> Rotation: " (rtos rotation 2 1)
+  (princ (ssg-textf "kreisel-insert-zusammenfassung"
-                 "  Höhe: " (rtos hoehe 2 0)
+                     (list (rtos rotation 2 1) (rtos hoehe 2 0) typ)))
-                 "  Kreiselart: " typ))
 
   ;; 6. Modul einfuegen
   (draw-module (list (car pt) (cadr pt) hoehe) abstand rotation
@@ -590,7 +587,7 @@
   ;; KEIN weiteres (setvar "OSMODE" ...) mehr nötig!
   ;; ssg-end stellt nur CLAYER und CMDECHO wieder her, nicht OSMODE
   
-  (princ "\nKreisel Modul eingefuegt.")
+  (princ (ssg-text "kreisel-insert-fertig"))
   (ssg-end)
 )
 
@@ -607,20 +604,20 @@
 ;; -----------------------------------------------
 (defun c:KreiselConnect ( / ptStart ptEnd dx dy dist abstand rotation typ hoehe)
 
-  (ssg-start "Kreisel Smart Connect" '(("OSMODE") ("CECOLOR")))
+  (ssg-start (ssg-text "kreisel-start-connect") '(("OSMODE") ("CECOLOR")))
 
-  (princ "\n--- Kreisel durch Linie definieren (AN -> SP) ---")
+  (princ (ssg-text "kreisel-connect-header"))
 
   ;; 1. Startpunkt (aeusserster Punkt AN-Seite)
-  (setq ptStart (getpoint "\nStartpunkt (AN-Seite aussen): "))
+  (setq ptStart (getpoint (ssg-text "kreisel-prompt-startpunkt")))
   (if (null ptStart)
-    (progn (ssg-end) (princ "\nAbgebrochen.") (princ) (exit))
+    (progn (ssg-end) (princ (ssg-text "kreisel-abgebrochen")) (princ) (exit))
   )
 
   ;; 2. Endpunkt (aeusserster Punkt SP-Seite) mit Gummiband
-  (setq ptEnd (getpoint ptStart "\nEndpunkt (SP-Seite aussen): "))
+  (setq ptEnd (getpoint ptStart (ssg-text "kreisel-prompt-endpunkt")))
   (if (null ptEnd)
-    (progn (ssg-end) (princ "\nAbgebrochen.") (princ) (exit))
+    (progn (ssg-end) (princ (ssg-text "kreisel-abgebrochen")) (princ) (exit))
   )
 
   ;; 3. Geometrie berechnen
@@ -631,8 +628,8 @@
 
   (if (<= abstand 0.0)
     (progn
-      (ssg-emsg (strcat "Distanz zu klein! ("
+      (ssg-emsg (ssg-textf "kreisel-emsg-distanz-klein"
-                        (rtos dist 2 0) " < " (rtos *kreisel-durchmesser* 2 0) ")"))
+                        (list (rtos dist 2 0) (rtos *kreisel-durchmesser* 2 0))))
       (ssg-end)
       (exit)
     )
@@ -648,26 +645,24 @@
   )
   (if (<= hoehe 0.0)
     (progn
-      (setq hoehe (getreal (strcat "\nHoehe (Z-Koordinate) <" (rtos *kreisel-default-hoehe* 2 0) ">: ")))
+      (setq hoehe (getreal (ssg-textf "kreisel-prompt-hoehe-z" (list (rtos *kreisel-default-hoehe* 2 0)))))
       (if (null hoehe) (setq hoehe *kreisel-default-hoehe*))
     )
-    (princ (strcat "\n-> Hoehe aus Startpunkt uebernommen: " (rtos hoehe 2 0)))
+    (princ (ssg-textf "kreisel-hoehe-aus-startpunkt" (list (rtos hoehe 2 0))))
   )
 
   ;; 6. Kreiselart abfragen
   (setq typ (kreisel-ask-typ))
 
-  (princ (strcat "\n-> Abstand: " (rtos abstand 2 0) " mm"
+  (princ (ssg-textf "kreisel-connect-zusammenfassung"
-                 "  Rotation: " (rtos rotation 2 1) " Grad"
+                     (list (rtos abstand 2 0) (rtos rotation 2 1) (rtos hoehe 2 0) typ)))
-                 "  Hoehe: " (rtos hoehe 2 0)
-                 "  Kreiselart: " typ))
 
   ;; 7. Modul einfuegen
   (draw-module (list (car ptStart) (cadr ptStart) hoehe) abstand rotation
               (list (cons "KREISELART" typ)
                     (cons "HOEHE" (rtos hoehe 2 0))))
 
-  (princ "\nKreisel Connect erfolgreich!")
+  (princ (ssg-text "kreisel-connect-erfolgreich"))
   (ssg-end)
 )
 
@@ -684,7 +679,7 @@
 ;; hoehe    : Hoehe in mm (oder nil fuer Z aus pt)
 ;; Rueckgabe: Entity-Name des erzeugten Blocks oder nil
 (defun kreisel-insert-script (pt abstand rotation typ hoehe / z blockEnt)
-  (ssg-start "Kreisel Script Insert" '(("OSMODE") ("CECOLOR")))
+  (ssg-start (ssg-text "kreisel-start-script-insert") '(("OSMODE") ("CECOLOR")))
   (if (null typ) (setq typ "STANDARD"))
   (setq z (if hoehe hoehe
             (if (and pt (caddr pt)) (caddr pt) *kreisel-default-hoehe*)))
@@ -703,14 +698,14 @@
 ;; hoehe    : Hoehe in mm (oder nil fuer Z aus ptStart)
 ;; Rueckgabe: Entity-Name des erzeugten Blocks oder nil
 (defun kreisel-connect-script (ptStart ptEnd typ hoehe / dx dy dist abstand rotation z blockEnt)
-  (ssg-start "Kreisel Script Connect" '(("OSMODE") ("CECOLOR")))
+  (ssg-start (ssg-text "kreisel-start-script-connect") '(("OSMODE") ("CECOLOR")))
   (if (null typ) (setq typ "STANDARD"))
   (setq dx (- (car ptEnd) (car ptStart))
         dy (- (cadr ptEnd) (cadr ptStart)))
   (setq dist (sqrt (+ (* dx dx) (* dy dy))))
   (setq abstand (- dist *kreisel-durchmesser*))
   (if (<= abstand 0.0)
-    (progn (princ (strcat "\n[Connect] Distanz zu klein: " (rtos dist 2 0)))
+    (progn (princ (ssg-textf "kreisel-script-distanz-klein" (list (rtos dist 2 0))))
            (ssg-end) nil)
     (progn
       (setq rotation (* (/ 180.0 pi) (atan dy dx)))
@@ -727,19 +722,19 @@
 
 ;; Neue Befehle für Beschriftungs-Einstellungen
 (defun c:KreiselLabelPos ( / dx dy)
-  (setq dx (getreal (strcat "\nX-Abstand von AN8-Mitte <" (rtos *kreisel-beschriftung-abstand-x* 2 0) ">: ")))
+  (setq dx (getreal (ssg-textf "kreisel-prompt-x-abstand" (list (rtos *kreisel-beschriftung-abstand-x* 2 0)))))
   (if dx (setq *kreisel-beschriftung-abstand-x* dx))
-  (setq dy (getreal (strcat "\nY-Abstand von AN8-Mitte <" (rtos *kreisel-beschriftung-abstand-y* 2 0) ">: ")))
+  (setq dy (getreal (ssg-textf "kreisel-prompt-y-abstand" (list (rtos *kreisel-beschriftung-abstand-y* 2 0)))))
   (if dy (setq *kreisel-beschriftung-abstand-y* dy))
-  (princ (strcat "\nNeue Beschriftungsposition: X=" (rtos *kreisel-beschriftung-abstand-x* 2 0)
+  (princ (ssg-textf "kreisel-neue-beschriftungsposition"
-                 " Y=" (rtos *kreisel-beschriftung-abstand-y* 2 0)))
+                     (list (rtos *kreisel-beschriftung-abstand-x* 2 0) (rtos *kreisel-beschriftung-abstand-y* 2 0))))
   (princ)
 )
 
 (defun c:KreiselLabelHoehe ( / h)
-  (setq h (getreal (strcat "\nTexthöhe <" (rtos *kreisel-beschriftung-hoehe* 2 0) ">: ")))
+  (setq h (getreal (ssg-textf "kreisel-prompt-texthoehe" (list (rtos *kreisel-beschriftung-hoehe* 2 0)))))
   (if h (setq *kreisel-beschriftung-hoehe* h))
-  (princ (strcat "\nNeue Texthöhe: " (rtos *kreisel-beschriftung-hoehe* 2 0)))
+  (princ (ssg-textf "kreisel-neue-texthoehe" (list (rtos *kreisel-beschriftung-hoehe* 2 0))))
   (princ)
 )
 
@@ -753,17 +748,17 @@
 ;; -----------------------------------------------
 (defun c:KreiselRedraw ( / sel ent ed attribs basePoint rotation newAbstand)
 
-  (ssg-start "Kreisel Neu Zeichnen" '(("CECOLOR")))
+  (ssg-start (ssg-text "kreisel-start-redraw") '(("CECOLOR")))
 
   ;; 1. Bestehenden Kreisel-Block auswaehlen
-  (setq sel (entsel "\nKreisel-Block auswaehlen: "))
+  (setq sel (entsel (ssg-text "kreisel-prompt-block-auswaehlen")))
   (if (null sel) (exit))
   (setq ent (car sel))
   (setq ed (entget ent))
 
   ;; Pruefen ob INSERT
   (if (/= (cdr (assoc 0 ed)) "INSERT")
-    (progn (ssg-emsg "Kein Block ausgewaehlt!") (exit))
+    (progn (ssg-emsg (ssg-text "kreisel-emsg-kein-block")) (exit))
   )
 
   ;; 2. Bestehende Werte auslesen
@@ -772,19 +767,20 @@
   (setq rotation  (* (/ 180.0 pi) (cdr (assoc 50 ed))))
 
   ;; NEU - Höhe aus Attributen lesen und anzeigen:
-  (princ (strcat "\n-> Bestehend: Abstand=" (cdr (assoc "ABSTAND" attribs))
+  (princ (ssg-textf "kreisel-redraw-bestehend"
-               "  Drehung=" (cdr (assoc "DREHUNG" attribs))
+               (list (cdr (assoc "ABSTAND" attribs))
-               "  Höhe=" (cdr (assoc "HOEHE" attribs))  ;; <-- NEU
+                     (cdr (assoc "DREHUNG" attribs))
-               "  Art=" (cdr (assoc "KREISELART" attribs))))
+                     (cdr (assoc "HOEHE" attribs))
+                     (cdr (assoc "KREISELART" attribs)))))
 
   ;; 3. Neuen Abstand abfragen (Enter = beibehalten)
   (initget 6)
-  (setq newAbstand (getdist (strcat "\nNeuer Abstand <" (cdr (assoc "ABSTAND" attribs)) ">: ")))
+  (setq newAbstand (getdist (ssg-textf "kreisel-prompt-neuer-abstand" (list (cdr (assoc "ABSTAND" attribs))))))
   (if (null newAbstand)
     (setq newAbstand (atof (cdr (assoc "ABSTAND" attribs))))
   )
   ;; NEU - Neue Höhe abfragen:
-  (setq newHoehe (getreal (strcat "\nNeue Höhe <" (cdr (assoc "HOEHE" attribs)) ">: ")))
+  (setq newHoehe (getreal (ssg-textf "kreisel-prompt-neue-hoehe" (list (cdr (assoc "HOEHE" attribs))))))
   (if (null newHoehe)
     (setq newHoehe (atof (cdr (assoc "HOEHE" attribs))))
   )
@@ -795,7 +791,7 @@
   (draw-module (list (car basePoint) (cadr basePoint) newHoehe)
              newAbstand rotation attribs)
 
-  (princ (strcat "\nKreisel neu gezeichnet. Abstand=" (rtos newAbstand 2 0)))
+  (princ (ssg-textf "kreisel-redraw-fertig" (list (rtos newAbstand 2 0))))
   (ssg-end)
 )
 
@@ -804,17 +800,17 @@
 ;; KreiselQuick: Schnell mit Defaults (horizontal)
 ;; --------------------------------------------
 (defun c:KreiselQuick ( / pt)
-  (ssg-start "Kreisel Schnell Einfuegen" '(("CECOLOR")))
+  (ssg-start (ssg-text "kreisel-start-quick") '(("CECOLOR")))
-  (setq pt (getpoint "\nBasispunkt (AN-Seite): "))
+  (setq pt (getpoint (ssg-text "kreisel-prompt-basispunkt")))
   ;; NEU - Höhe abfragen:
-  (setq hoehe (getreal (strcat "\nHöhe (Z-Koordinate) <0>: ")))
+  (setq hoehe (getreal (ssg-textf "kreisel-prompt-hoehe-z" (list "0"))))
   (if (null hoehe) (setq hoehe 0.0))
   (if pt
     ;; NEU - Höhe im Aufruf übergeben:
-    (draw-module (list (car pt) (cadr pt) hoehe) *kreisel-default-laenge* 0.0 
+    (draw-module (list (car pt) (cadr pt) hoehe) *kreisel-default-laenge* 0.0
                 (list (cons "HOEHE" (rtos hoehe 2 0))))
   )
-  (princ "\nSchnell Einfuegen fertig.")
+  (princ (ssg-text "kreisel-quick-fertig"))
   (ssg-end)
 )
 
@@ -870,13 +866,13 @@
     (setq ent (ssname ss 0))
   )
 
-  (ssg-start "Kreisel bearbeiten" '(("OSMODE") ("CECOLOR") ("ATTREQ") ("ATTDIA")))
+  (ssg-start (ssg-text "kreisel-start-edit") '(("OSMODE") ("CECOLOR") ("ATTREQ") ("ATTDIA")))
   (setvar "OSMODE" 0)
 
   ;; 1. Block auswaehlen (falls nicht vorselektiert)
   (if (null ent)
     (progn
-      (setq sel (entsel "\nKreisel-Block auswaehlen: "))
+      (setq sel (entsel (ssg-text "kreisel-prompt-block-auswaehlen")))
       (if sel (setq ent (car sel)))
     )
   )
@@ -884,7 +880,7 @@
 
   (setq ed (entget ent))
   (if (/= (cdr (assoc 0 ed)) "INSERT")
-    (progn (ssg-emsg "Kein Block ausgewaehlt!") (ssg-end) (exit))
+    (progn (ssg-emsg (ssg-text "kreisel-emsg-kein-block")) (ssg-end) (exit))
   )
 
   ;; 2. Bestehende Werte auslesen
@@ -895,7 +891,7 @@
   ;; Pruefen ob Block Kreisel-Attribute hat (mindestens ABSTAND)
   (if (null (assoc "ABSTAND" attribs))
     (progn
-      (ssg-emsg "Kein Kreisel-Block! (Attribut ABSTAND fehlt)")
+      (ssg-emsg (ssg-text "kreisel-emsg-kein-kreisel-block"))
       (ssg-end)
       (exit)
     )
@@ -912,15 +908,14 @@
   (setq attribs (subst (cons "HOEHE" (rtos (if (caddr basePoint) (caddr basePoint) 0.0) 2 1))
                         (assoc "HOEHE" attribs) attribs))
 
-  (princ (strcat "\n-> Bestehend: Abstand=" (cdr (assoc "ABSTAND" attribs))
+  (princ (ssg-textf "kreisel-edit-bestehend"
-                 "  Drehung=" (rtos rotation 2 1)
+                     (list (cdr (assoc "ABSTAND" attribs)) (rtos rotation 2 1) (cdr (assoc "KREISELART" attribs)))))
-                 "  Art=" (cdr (assoc "KREISELART" attribs))))
 
   ;; 3. DCL-Dialog laden
   (setq dcl-pfad (strcat (getenv "DXFM_DCL") "/kreisel_edit.dcl"))
   (setq dat (load_dialog dcl-pfad))
   (if (not (new_dialog "kreisel_edit" dat))
-    (progn (alert (strcat "Dialog nicht verfuegbar: " dcl-pfad)) (ssg-end) (exit))
+    (progn (alert (ssg-textf "kreisel-edit-dialog-fehlt" (list dcl-pfad))) (ssg-end) (exit))
   )
 
   ;; Ausrichtungs-Labels fuer popup_list aufbauen
@@ -999,13 +994,10 @@
       (draw-module (list (car basePoint) (cadr basePoint) (atof dlg-hoehe))
                    newAbstand newRotation attribs)
 
-      (princ (strcat "\nKreisel aktualisiert: "
+      (princ (ssg-textf "kreisel-edit-aktualisiert"
-                     "Name=" dlg-name
+                     (list dlg-name (rtos newAbstand 2 0) dlg-hoehe (rtos newRotation 2 1))))
-                     "  Abstand=" (rtos newAbstand 2 0)
-                     "  Hoehe=" dlg-hoehe
-                     "  Rotation=" (rtos newRotation 2 1)))
     )
-    (princ "\nAbgebrochen.")
+    (princ (ssg-text "kreisel-abgebrochen"))
   )
 
   (ssg-end)
@@ -1016,13 +1008,13 @@
 ;; KreiselParams: Aktuelle Parameter anzeigen
 ;; --------------------------------------------
 (defun c:KreiselParams ()
-  (princ "\n=== Kreisel Parameter ===")
+  (princ (ssg-text "kreisel-params-header"))
-  (princ (strcat "\nKreiselart: " #Kreisel_Typ))
+  (princ (ssg-textf "kreisel-params-typ" (list #Kreisel_Typ)))
-  (princ (strcat "\nDurchmesser: " (rtos *kreisel-durchmesser* 2 0)))
+  (princ (ssg-textf "kreisel-params-durchmesser" (list (rtos *kreisel-durchmesser* 2 0))))
-  (princ (strcat "\nDefault-Laenge: " (rtos *kreisel-default-laenge* 2 0)))
+  (princ (ssg-textf "kreisel-params-default-laenge" (list (rtos *kreisel-default-laenge* 2 0))))
   ;; NEU - Default-Höhe anzeigen:
-  (princ (strcat "\nDefault-Höhe: " (rtos *kreisel-default-hoehe* 2 0)))
+  (princ (ssg-textf "kreisel-params-default-hoehe" (list (rtos *kreisel-default-hoehe* 2 0))))
-  (princ "\nAttribute im Block:")
+  (princ (ssg-text "kreisel-params-attribute-header"))
   (foreach def *kreisel-attrib-defs*
     (princ (strcat "\n  " (car def) " = " (cadr def)))
   )
@@ -1045,12 +1037,12 @@
   (dbgf "c:ILS_Eckrad")
 
   ;; 1. Beruehrpunkt (Tangentenpunkt)
-  (setq ptTangent (getpoint "\nBeruehrpunkt Eckrad (Tangente): "))
+  (setq ptTangent (getpoint (ssg-text "kreisel-eckrad-beruehrpunkt")))
   (if (null ptTangent) (progn (dbgreturn nil) (exit)))
   (dbg 'ptTangent)
 
   ;; 2. Richtungspunkt (Gummiband vom Beruehrpunkt)
-  (setq ptDir (getpoint ptTangent "\nRichtung zum Kreismittelpunkt: "))
+  (setq ptDir (getpoint ptTangent (ssg-text "kreisel-eckrad-richtung")))
   (if (null ptDir) (progn (dbgreturn nil) (exit)))
   (dbg 'ptDir)
 
@@ -1061,7 +1053,7 @@
 
   (if (<= dist (ssg-cfg-or "kreisel" "toleranz_min_distanz" 0.001))
     (progn
-      (princ "\nFehler: Beruehr- und Richtungspunkt sind identisch!")
+      (princ (ssg-text "kreisel-eckrad-fehler-identisch"))
       (dbgreturn nil)
       (exit)
     )
@@ -1087,10 +1079,10 @@
   (if (and (> (length ptTangent) 2) (caddr ptTangent) (> (caddr ptTangent) 0))
     (progn
       (setq hoehe (caddr ptTangent))
-      (princ (strcat "\n-> Hoehe aus 3D-Punkt uebernommen: " (rtos hoehe 2 0)))
+      (princ (ssg-textf "kreisel-hoehe-aus-3dpunkt" (list (rtos hoehe 2 0))))
     )
     (progn
-      (setq hoehe (getreal (strcat "\nHoehe (Z-Koordinate) <" (rtos *eckrad-default-hoehe* 2 0) ">: ")))
+      (setq hoehe (getreal (ssg-textf "kreisel-prompt-hoehe-z" (list (rtos *eckrad-default-hoehe* 2 0)))))
       (if (null hoehe) (setq hoehe *eckrad-default-hoehe*))
     )
   )
@@ -1118,7 +1110,7 @@
   (dbg 'pt)
   (dbg 'rotation)
 
-  (ssg-start "Eckrad einfuegen" '(("ATTREQ") ("ATTDIA") ("OSMODE") ("CECOLOR")))
+  (ssg-start (ssg-text "kreisel-start-eckrad") '(("ATTREQ") ("ATTDIA") ("OSMODE") ("CECOLOR")))
 
   ;; Attribute vorbereiten
   (setq attribs (ssg-attrib-merge attribs *eckrad-attrib-defs*))
@@ -1215,14 +1207,14 @@
           (dbgp (strcat "Blockdefinition erzeugt: " bname))
         )
         (progn
-          (princ "\nFehler: Keine Entities zum Block erstellen!")
+          (princ (ssg-text "kreisel-fehler-keine-entities"))
           (dbgp "FEHLER: Keine Entities fuer Block!")
         )
       )
-      (princ (strcat "\n-> Neue Blockdefinition: " bname))
+      (princ (ssg-textf "kreisel-neue-blockdef" (list bname)))
     )
     (progn
-      (princ (strcat "\n-> Verwende bestehende Blockdefinition: " bname))
+      (princ (ssg-textf "kreisel-bestehende-blockdef" (list bname)))
       (dbgp (strcat "Verwende bestehende Blockdefinition: " bname))
     )
   )
@@ -1259,35 +1251,34 @@
   )
   (entupd block-ent)
 
-  (princ (strcat "\n-> Eckrad #" (itoa eckrad-nummer) " eingefuegt: " bname
+  (princ (ssg-textf "kreisel-eckrad-eingefuegt"
-                 " bei " (rtos (car pt) 2 1) "," (rtos (cadr pt) 2 1)
+                 (list (itoa eckrad-nummer) bname (rtos (car pt) 2 1) (rtos (cadr pt) 2 1)
-                 " Rotation=" (rtos rotation 2 1)
+                       (rtos rotation 2 1) block-hoehe)))
-                 " Hoehe=" block-hoehe))
   (ssg-end)
   (dbgreturn (entlast))
 )
 
 ;; NEU: KreiselLabelSetup - Hier einfügen!
 (defun c:KreiselLabelSetup ( / hoehe farbe abstand schriftart)
-  (setq hoehe (getreal (strcat "\nSchrifthöhe <" (rtos *kreisel-beschriftung-hoehe* 2 0) ">: ")))
+  (setq hoehe (getreal (ssg-textf "kreisel-prompt-schrifthoehe" (list (rtos *kreisel-beschriftung-hoehe* 2 0)))))
   (if hoehe (setq *kreisel-beschriftung-hoehe* hoehe))
-  
+
-  (setq farbe (getint (strcat "\nSchriftfarbe (1=Rot,2=Gelb,3=Grün,4=Cyan,5=Blau,6=Magenta,7=Weiß) <" (itoa *kreisel-beschriftung-farbe*) ">: ")))
+  (setq farbe (getint (ssg-textf "kreisel-prompt-schriftfarbe" (list (itoa *kreisel-beschriftung-farbe*)))))
   (if farbe (setq *kreisel-beschriftung-farbe* farbe))
-  
+
-  (setq abstand (getreal (strcat "\nAbstand über Kreisel-Mitte <" (rtos *kreisel-beschriftung-abstand-oben* 2 0) ">: ")))
+  (setq abstand (getreal (ssg-textf "kreisel-prompt-abstand-oben" (list (rtos *kreisel-beschriftung-abstand-oben* 2 0)))))
   (if abstand (setq *kreisel-beschriftung-abstand-oben* abstand))
-  
+
-  (princ (strcat "\nNeue Einstellungen: Höhe=" (rtos *kreisel-beschriftung-hoehe* 2 0)
+  (princ (ssg-textf "kreisel-labelsetup-fertig"
-                 ", Farbe=" (itoa *kreisel-beschriftung-farbe*)
+                 (list (rtos *kreisel-beschriftung-hoehe* 2 0)
-                 ", Y-Versatz=" (rtos *kreisel-beschriftung-abstand-oben* 2 0)
+                       (itoa *kreisel-beschriftung-farbe*)
-                 ", Schriftart=Arial"))
+                       (rtos *kreisel-beschriftung-abstand-oben* 2 0))))
   (princ)
 )
 
 (princ "\n>>> KREISELINSERT v7.0 geladen <<<")
 (princ "\n>>> Befehle: KreiselInsert, KreiselConnect, KreiselRedraw,")
 (princ "\n             KreiselEdit, KreiselQuick, KreiselParams, ILS_Eckrad")
-(if block-pfad (princ (strcat "\n    Block-Pfad: " block-pfad)))
+(if *block-path* (princ (strcat "\n    Block-Pfad: " *block-path*)))
 (princ "\n=========================================")
 (princ)

Lisp/OmniModulInsert.lsp

@@ -15,129 +15,11 @@
 ;; ============================================================
 
 
-;; --- Datei zeilenweise einlesen ---
-(defun omni:read-file-lines (datei / f zeile ergebnis)
-  (setq f (open datei "r"))
-  (if (null f)
-    (progn
-      (princ (strcat "\n[OMNI] FEHLER: Datei nicht gefunden: " datei))
-      nil
-    )
-    (progn
-      (setq ergebnis nil)
-      (while (setq zeile (read-line f))
-        (setq ergebnis (cons zeile ergebnis))
-      )
-      (close f)
-      (reverse ergebnis)
-    )
-  )
-)
-
-
-;; --- Whitespace und Komma am Ende einer Zeile entfernen ---
-(defun omni:trim (s / len ch)
-  (setq s (vl-string-trim " \t\r\n" s))
-  (setq len (strlen s))
-  (if (and (> len 0) (= (substr s len 1) ","))
-    (setq s (substr s 1 (1- len)))
-  )
-  (vl-string-trim " \t\r\n" s)
-)
-
-
-;; --- JSON-Wert parsen (String, Zahl, null) ---
-(defun omni:parse-value (val-str / len)
-  (setq val-str (omni:trim val-str))
-  (cond
-    ((= val-str "null") nil)
-    ((= (substr val-str 1 1) "\"")
-      ;; String: Anfuehrungszeichen entfernen
-      (setq len (strlen val-str))
-      (if (and (> len 1) (= (substr val-str len 1) "\""))
-        (substr val-str 2 (- len 2))
-        val-str
-      )
-    )
-    (T
-      ;; Zahl
-      (if (vl-string-search "." val-str)
-        (atof val-str)
-        (atoi val-str)
-      )
-    )
-  )
-)
-
-
-;; --- Eine Key-Value-Zeile parsen -> dotted pair oder nil ---
-(defun omni:parse-kv-line (zeile / pos key rest val)
-  (setq zeile (omni:trim zeile))
-  ;; Muss mit " beginnen (Key)
-  (if (and (> (strlen zeile) 0) (= (substr zeile 1 1) "\""))
-    (progn
-      ;; Key extrahieren: zweites Anfuehrungszeichen finden
-      ;; vl-string-search ist 0-basiert, substr ist 1-basiert
-      (setq pos (vl-string-search "\"" zeile 1))
-      (if pos
-        (progn
-          (setq key (substr zeile 2 (1- pos)))
-          ;; Rest nach dem schliessenden " extrahieren
-          (setq rest (substr zeile (+ pos 2)))
-          ;; ":" im Rest finden
-          (setq pos (vl-string-search ":" rest))
-          (if pos
-            (progn
-              (setq val (substr rest (+ pos 2)))
-              (cons key (omni:parse-value val))
-            )
-          )
-        )
-      )
-    )
-  )
-)
-
-
-;; --- JSON-Array von flachen Objekten parsen ---
-(defun omni:parse-json-array (zeilen / in-obj obj ergebnis zeile kv trimmed)
-  (setq in-obj nil
-        obj    nil
-        ergebnis nil
-  )
-  (foreach zeile zeilen
-    (setq trimmed (omni:trim zeile))
-    (cond
-      ;; Objekt-Start
-      ((= trimmed "{")
-        (setq in-obj T
-              obj    nil
-        )
-      )
-      ;; Objekt-Ende
-      ((or (= trimmed "}") (= trimmed "},"))
-        (if (and in-obj obj)
-          (setq ergebnis (cons (reverse obj) ergebnis))
-        )
-        (setq in-obj nil)
-      )
-      ;; Key-Value-Zeile innerhalb eines Objekts
-      (in-obj
-        (setq kv (omni:parse-kv-line zeile))
-        (if kv (setq obj (cons kv obj)))
-      )
-    )
-  )
-  (reverse ergebnis)
-)
-
-
 ;; --- JSON-Datei laden und als Liste von Alists zurueckgeben ---
-(defun omni:load-json (datei / zeilen)
+;; Duenner Wrapper um den zentralen JSON-Parser aus ssg_core.lsp
-  (setq zeilen (omni:read-file-lines datei))
+;; (ssg-load-json), damit fuer alle Module derselbe Parser-Standard gilt.
-  (if zeilen
+(defun omni:load-json (datei)
-    (omni:parse-json-array zeilen)
+  (ssg-load-json datei)
-  )
 )
 
 
@@ -146,7 +28,7 @@
   (setq data-pfad (getenv "DXFM_DATA"))
   (if (null data-pfad)
     (progn
-      (princ "\n[OMNI] FEHLER: DXFM_DATA nicht gesetzt!")
+      (princ (ssg-text "omni-fehler-dxfm-data"))
       nil
     )
     (progn
@@ -245,8 +127,10 @@
 ;; eintrag = Assoziationsliste (Rueckgabe von omni:get-bogen etc.)
 ;; key     = Schluesselname z.B. "Radius"
 ;; Beispiel: (omni:val (omni:get-bogen 821104025) "Radius") -> 550
+;; Duenner Wrapper um ssg-val (ssg_core.lsp), damit fuer alle Module
+;; derselbe Alist-Zugriffsstandard gilt.
 (defun omni:val (eintrag key)
-  (cdr (assoc key eintrag))
+  (ssg-val eintrag key)
 )
 
 
@@ -358,21 +242,21 @@
 ;; --- BricsCAD-Befehl: Bogen-Info anzeigen ---
 (defun c:OMNI_INFO_BOGEN ( / id eintrag)
   (if (null *OMNI-BOEGEN*) (omni:load-data))
-  (setq id (getstring T "\nSivasId des Bogens eingeben: "))
+  (setq id (getstring T (ssg-text "omni-info-bogen-prompt")))
-  (if (= id "") (princ "\nAbgebrochen.")
+  (if (= id "") (princ (ssg-text "omni-abbruch"))
     (progn
       ;; Versuch als Zahl, dann als String
       (setq eintrag (omni:get-bogen (if (/= (atoi id) 0) (atoi id) id)))
       (if eintrag
         (progn
-          (princ (strcat "\n  ProfilTyp:    " (omni:sivasid-to-str (omni:val eintrag "ProfilTyp"))))
+          (princ (ssg-textf "omni-bogen-info-profiltyp" (list (omni:sivasid-to-str (omni:val eintrag "ProfilTyp")))))
-          (princ (strcat "\n  Radius:       " (itoa (fix (omni:val eintrag "Radius")))))
+          (princ (ssg-textf "omni-bogen-info-radius" (list (itoa (fix (omni:val eintrag "Radius"))))))
-          (princ (strcat "\n  KurvenWinkel: " (rtos (omni:val eintrag "KurvenWinkel") 2 1)))
+          (princ (ssg-textf "omni-bogen-info-kurvenwinkel" (list (rtos (omni:val eintrag "KurvenWinkel") 2 1))))
-          (princ (strcat "\n  Breite:       " (itoa (fix (omni:val eintrag "Breite")))))
+          (princ (ssg-textf "omni-bogen-info-breite" (list (itoa (fix (omni:val eintrag "Breite"))))))
-          (princ (strcat "\n  Laenge:       " (itoa (fix (omni:val eintrag "Länge")))))
+          (princ (ssg-textf "omni-bogen-info-laenge" (list (itoa (fix (omni:val eintrag "Länge"))))))
-          (princ (strcat "\n  Antriebsart:  " (itoa (fix (omni:val eintrag "Antriebsart")))))
+          (princ (ssg-textf "omni-bogen-info-antriebsart" (list (itoa (fix (omni:val eintrag "Antriebsart"))))))
         )
-        (princ (strcat "\nKein Bogen mit SivasId '" id "' gefunden."))
+        (princ (ssg-textf "omni-bogen-nicht-gefunden" (list id)))
       )
     )
   )
@@ -383,25 +267,25 @@
 ;; --- BricsCAD-Befehl: Weichen-Info anzeigen ---
 (defun c:OMNI_INFO_WEICHE ( / id eintrag wkl)
   (if (null *OMNI-WEICHEN*) (omni:load-data))
-  (setq id (getstring T "\nSivasId der Weiche eingeben: "))
+  (setq id (getstring T (ssg-text "omni-info-weiche-prompt")))
-  (if (= id "") (princ "\nAbgebrochen.")
+  (if (= id "") (princ (ssg-text "omni-abbruch"))
     (progn
       (setq eintrag (omni:get-weiche (if (/= (atoi id) 0) (atoi id) id)))
       (if eintrag
         (progn
-          (princ (strcat "\n  ProfilTyp:      " (omni:sivasid-to-str (omni:val eintrag "ProfilTyp"))))
+          (princ (ssg-textf "omni-weiche-info-profiltyp" (list (omni:sivasid-to-str (omni:val eintrag "ProfilTyp")))))
-          (princ (strcat "\n  WeichenTyp:     " (omni:sivasid-to-str (omni:val eintrag "WeichenTyp"))))
+          (princ (ssg-textf "omni-weiche-info-weichentyp" (list (omni:sivasid-to-str (omni:val eintrag "WeichenTyp")))))
           (setq wkl (omni:val eintrag "KurvenWinkel"))
-          (princ (strcat "\n  KurvenWinkel:   " (if (= (type wkl) 'INT) (itoa wkl) (rtos wkl 2 1))))
+          (princ (ssg-textf "omni-weiche-info-kurvenwinkel" (list (if (= (type wkl) 'INT) (itoa wkl) (rtos wkl 2 1)))))
-          (princ (strcat "\n  Schaltungstyp:  " (omni:sivasid-to-str (omni:val eintrag "Schaltungstyp"))))
+          (princ (ssg-textf "omni-weiche-info-schaltungstyp" (list (omni:sivasid-to-str (omni:val eintrag "Schaltungstyp")))))
-          (princ (strcat "\n  Breite:         " (itoa (fix (omni:val eintrag "Breite")))))
+          (princ (ssg-textf "omni-weiche-info-breite" (list (itoa (fix (omni:val eintrag "Breite"))))))
-          (princ (strcat "\n  Laenge:         " (itoa (fix (omni:val eintrag "Länge")))))
+          (princ (ssg-textf "omni-weiche-info-laenge" (list (itoa (fix (omni:val eintrag "Länge"))))))
-          (princ (strcat "\n  KurvenRichtung: " (itoa (fix (omni:val eintrag "KurvenRichtung")))))
+          (princ (ssg-textf "omni-weiche-info-kurvenrichtung" (list (itoa (fix (omni:val eintrag "KurvenRichtung"))))))
           (if (omni:val eintrag "WeichenkörperLänge")
-            (princ (strcat "\n  WK-Laenge:      " (rtos (omni:val eintrag "WeichenkörperLänge") 2 1)))
+            (princ (ssg-textf "omni-weiche-info-wklaenge" (list (rtos (omni:val eintrag "WeichenkörperLänge") 2 1))))
           )
         )
-        (princ (strcat "\nKeine Weiche mit SivasId '" id "' gefunden."))
+        (princ (ssg-textf "omni-weiche-nicht-gefunden" (list id)))
       )
     )
   )
@@ -442,11 +326,13 @@
 
 
 ;; --- Bogen-Auswahl-Dialog oeffnen ---
-;; winkel = KurvenWinkel (90, 67.5, 45, 22.5, 180)
+;; winkel      = KurvenWinkel (90, 67.5, 45, 22.5, 180)
 ;; init-hoehe / init-drehung = Vorbelegung (optional, fuer Edit-Modus)
+;; profiltyp   = optionales Praefix zum Filtern des ProfilTyp-Textes,
+;;               z.B. "APB 60" oder "APB 110" (nil = keine Einschraenkung)
 ;; Rueckgabe: (eintrag hoehe drehung) oder nil bei Abbruch
-(defun omni:bogen-dialog (winkel init-hoehe init-drehung / dcl-pfad dat boegen-liste
+(defun omni:bogen-dialog (winkel init-hoehe init-drehung profiltyp / dcl-pfad dat boegen-liste
-                           profil-liste ergebnis dlg-hoehe dlg-drehung)
+                           profil-liste ergebnis dlg-hoehe dlg-drehung profil)
   (if (null *OMNI-BOEGEN*) (omni:load-data))
 
   ;; Defaults
@@ -455,11 +341,31 @@
 
   ;; Boegen nach Winkel filtern
   (setq boegen-liste (omni:filter *OMNI-BOEGEN* "KurvenWinkel" winkel))
+
+  ;; Optional zusaetzlich nach ProfilTyp-Praefix filtern (z.B. "APB 60")
+  (if profiltyp
+    (setq boegen-liste
+      (vl-remove-if-not
+        '(lambda (e)
+           (setq profil (cdr (assoc "ProfilTyp" e)))
+           (and profil (= (vl-string-search profiltyp profil) 0))
+         )
+        boegen-liste
+      )
+    )
+  )
+
   (if (null boegen-liste)
     (progn
-      (alert (strcat "Keine Boegen fuer "
+      (alert (ssg-textf "omni-bogen-keine-gefunden"
-        (if (= (type winkel) 'INT) (itoa winkel) (rtos winkel 2 1))
+        (list
-        " Grad gefunden."))
+          (strcat
+            (if (= (type winkel) 'INT) (itoa winkel) (rtos winkel 2 1))
+            (ssg-text "omni-grad")
+          )
+          (if profiltyp (strcat " (" profiltyp ")") "")
+        )
+      ))
       nil
     )
     (progn
@@ -474,7 +380,7 @@
       (setq dcl-pfad (strcat (getenv "DXFM_DCL") "/omniflo_boegen.dcl"))
       (setq dat (load_dialog dcl-pfad))
       (if (not (new_dialog "omniflo_boegen" dat))
-        (progn (alert "Bogen-Dialog konnte nicht geladen werden.") nil)
+        (progn (alert (ssg-text "omni-bogen-dialog-ladefehler")) nil)
         (progn
           ;; Dropdown befuellen
           (start_list "bogenart")
@@ -521,47 +427,57 @@
 ;; ============================================================
 
 ;; --- Omniflo / Boegen ---
-(defun c:OMNI_APB_630_90 ( / dlg-result)
+(defun c:OMNI_APB60_90 ( / dlg-result)
-  (setq dlg-result (omni:bogen-dialog 90 nil nil))
+  (setq dlg-result (omni:bogen-dialog 90 nil nil "APB 60"))
   (if dlg-result
     (omni:insert-from-entry dlg-result)
-    (princ "\n[BOGEN] Abgebrochen.")
+    (princ (ssg-text "omni-abbruch-bogen"))
+  )
+  (princ)
+)
+
+
+(defun c:OMNI_APB_630_90 ( / dlg-result)
+  (setq dlg-result (omni:bogen-dialog 90 nil nil "APB 110"))
+  (if dlg-result
+    (omni:insert-from-entry dlg-result)
+    (princ (ssg-text "omni-abbruch-bogen"))
   )
   (princ)
 )
 
 (defun c:OMNI_APB_550_675 ( / dlg-result)
-  (setq dlg-result (omni:bogen-dialog 67.5 nil nil))
+  (setq dlg-result (omni:bogen-dialog 67.5 nil nil nil))
   (if dlg-result
     (omni:insert-from-entry dlg-result)
-    (princ "\n[BOGEN] Abgebrochen.")
+    (princ (ssg-text "omni-abbruch-bogen"))
   )
   (princ)
 )
 
 (defun c:OMNI_APB_630_45 ( / dlg-result)
-  (setq dlg-result (omni:bogen-dialog 45 nil nil))
+  (setq dlg-result (omni:bogen-dialog 45 nil nil nil))
   (if dlg-result
     (omni:insert-from-entry dlg-result)
-    (princ "\n[BOGEN] Abgebrochen.")
+    (princ (ssg-text "omni-abbruch-bogen"))
   )
   (princ)
 )
 
 (defun c:OMNI_APB_550_225 ( / dlg-result)
-  (setq dlg-result (omni:bogen-dialog 22.5 nil nil))
+  (setq dlg-result (omni:bogen-dialog 22.5 nil nil nil))
   (if dlg-result
     (omni:insert-from-entry dlg-result)
-    (princ "\n[BOGEN] Abgebrochen.")
+    (princ (ssg-text "omni-abbruch-bogen"))
   )
   (princ)
 )
 
 (defun c:OMNI_APB_650_180 ( / dlg-result)
-  (setq dlg-result (omni:bogen-dialog 180 nil nil))
+  (setq dlg-result (omni:bogen-dialog 180 nil nil nil))
   (if dlg-result
     (omni:insert-from-entry dlg-result)
-    (princ "\n[BOGEN] Abgebrochen.")
+    (princ (ssg-text "omni-abbruch-bogen"))
   )
   (princ)
 )
@@ -601,7 +517,7 @@
     (setq srcAttribs (append srcAttribs (list (cons "ID" ""))))
   )
   (if (null srcAttribs)
-    (progn (princ "\n[OMNI] Keine Attribute im Quell-Block gefunden.") nil)
+    (progn (princ (ssg-text "omni-insert-keine-attribute")) nil)
     (progn
       ;; LAENGEMAX aus Quell-Attribut lesen (falls vorhanden), sonst Parameter
       (if (and (assoc "LAENGEMAX" srcAttribs)
@@ -609,9 +525,9 @@
         (setq laengemax (atof (cdr (assoc "LAENGEMAX" srcAttribs))))
       )
 
-      (setq pt (getpoint "\nEinfuegepunkt waehlen: "))
+      (setq pt (getpoint (ssg-text "omni-prompt-einfuegepunkt")))
       (if (null pt)
-        (progn (princ "\n[OMNI] Abgebrochen.") nil)
+        (progn (princ (ssg-text "omni-abbruch-omni")) nil)
         (progn
           (ssg-start "OMNI Aluprofil" '(("OSMODE") ("ATTREQ") ("ATTDIA")))
           ;; ATTREQ/ATTDIA auf 0 setzen (werden durch ssg-end wiederhergestellt)
@@ -631,22 +547,20 @@
           ;; 2. Endpunkt fuer Fahrstrecke abfragen (Schleife bei Ueberschreitung)
           (setq ok nil)
           (while (not ok)
-            (setq pt2 (getpoint pt "\nEndpunkt der Fahrstrecke waehlen: "))
+            (setq pt2 (getpoint pt (ssg-text "omni-prompt-endpunkt-fahrstrecke")))
             (if (null pt2)
               (progn
                 ;; Abbruch: Text loeschen
                 (command "_.ERASE" textEnt "")
-                (princ "\n[OMNI] Abgebrochen.")
+                (princ (ssg-text "omni-abbruch-omni"))
                 (setq ok T pt nil)
               )
               (progn
                 (setq laenge (distance (list (car pt) (cadr pt))
                                        (list (car pt2) (cadr pt2))))
                 (if (> laenge laengemax)
-                  (alert (strcat "Die gewuenschte Fahrstreckenlaenge von "
+                  (alert (ssg-textf "omni-laenge-ueberschritten"
-                                 (rtos laenge 2 0) " mm ueberschreitet die Maximallaenge von "
+                           (list (rtos laenge 2 0) (rtos laengemax 2 0))))
-                                 (rtos laengemax 2 0) " mm des Fahrstreckenprofils.\n"
-                                 "Bitte neu definieren!"))
                   (progn
                     (setq laengeStr (rtos laenge 2 0))
                     (setq dx (- (car pt2) (car pt))
@@ -720,7 +634,7 @@
                       (ssg-id-generate blockEnt)
                     )
 
-                    (princ (strcat "\n[OMNI] " bname " eingefuegt. Laenge=" laengeStr " mm"))
+                    (princ (ssg-textf "omni-insert-block-eingefuegt" (list bname laengeStr)))
                     (setq ok T)
                   )
                 )
@@ -872,14 +786,16 @@
 
   (if (null basis-liste)
     (progn
-      (alert (strcat "Keine Weichen fuer "
+      (alert (ssg-textf "omni-weiche-keine-gefunden"
-        (cond
+        (list
-          ((null winkel) "alle Winkel")
+          (cond
-          ((= (type winkel) 'INT) (strcat (itoa winkel) " Grad"))
+            ((null winkel) (ssg-text "omni-alle-winkel"))
-          (T (strcat (rtos winkel 2 1) " Grad"))
+            ((= (type winkel) 'INT) (strcat (itoa winkel) (ssg-text "omni-grad")))
+            (T (strcat (rtos winkel 2 1) (ssg-text "omni-grad")))
+          )
+          (if weichentyp (strcat " / " weichentyp) "")
         )
-        (if weichentyp (strcat " / " weichentyp) "")
+      ))
-        " gefunden."))
       nil
     )
     (progn
@@ -895,7 +811,7 @@
       (setq dcl-pfad (strcat (getenv "DXFM_DCL") "/omniflo_weichen.dcl"))
       (setq dat (load_dialog dcl-pfad))
       (if (not (new_dialog "omniflo_weichen" dat))
-        (progn (alert "Weichen-Dialog konnte nicht geladen werden.") nil)
+        (progn (alert (ssg-text "omni-weiche-dialog-ladefehler")) nil)
         (progn
           ;; Dropdown befuellen
           (start_list "profiltyp")
@@ -956,31 +872,41 @@
 ;; hoehe       = Hoehe in mm als String (wird als HOEHE-Attribut gesetzt)
 ;; drehung     = Drehwinkel in Grad als String (Block-Rotation)
 ;; Rueckgabe: Einfuegepunkt oder nil bei Abbruch
-(defun omni:insert-dxf (sivasnr-str hoehe drehung / dxf-pfad omniflo-pfad pt angleDeg blockEnt attribs layer-name)
+(defun omni:insert-dxf (sivasnr-str hoehe drehung / dxf-pfad omniflo-pfad pt angleDeg winkel-rad drehung-anzeige blockEnt attribs layer-name)
   (setq omniflo-pfad (getenv "DXFM_OMNIFLO"))
   (if (null omniflo-pfad)
     (progn
-      (princ "\n[OMNI] FEHLER: DXFM_OMNIFLO nicht gesetzt!")
+      (princ (ssg-text "omni-fehler-dxfm-omniflo"))
       nil
     )
     (progn
       (setq dxf-pfad (strcat omniflo-pfad "/" sivasnr-str ".dxf"))
       (if (not (findfile dxf-pfad))
         (progn
-          (princ (strcat "\n[OMNI] FEHLER: DXF nicht gefunden: " dxf-pfad))
+          (princ (ssg-textf "omni-fehler-dxf-nicht-gefunden" (list dxf-pfad)))
           nil
         )
         (progn
-          (setq pt (getpoint "\nEinfuegepunkt waehlen: "))
+          (setq pt (getpoint (ssg-text "omni-prompt-einfuegepunkt")))
           (if (null pt)
-            (progn (princ "\n[OMNI] Abgebrochen.") nil)
+            (progn (princ (ssg-text "omni-abbruch-omni")) nil)
             (progn
               (ssg-start "OMNI DXF Insert" '(("OSMODE") ("ATTREQ") ("ATTDIA")))
               (setvar "ATTREQ" 0)
               (setvar "ATTDIA" 0)
 
-              ;; Drehwinkel aus Dialog verwenden
+              ;; Drehwinkel aus Dialog uebernehmen, sonst interaktiv am Einfuegepunkt abfragen
-              (setq angleDeg (if drehung (atof drehung) 0.0))
+              (if drehung
+                (progn
+                  (setq angleDeg (atof drehung))
+                  (setq drehung-anzeige drehung)
+                )
+                (progn
+                  (setq winkel-rad (getangle pt (ssg-text "omni-prompt-drehwinkel")))
+                  (setq angleDeg (if winkel-rad (* winkel-rad (/ 180.0 pi)) 0.0))
+                  (setq drehung-anzeige (rtos angleDeg 2 1))
+                )
+              )
 
               ;; Hoehe als Z-Koordinate auf den Einfuegepunkt anwenden
               (if (and hoehe (/= hoehe ""))
@@ -1000,7 +926,7 @@
                   ;; HOEHE und DREHUNG Attribute setzen
                   (ssg-attrib-set-on blockEnt
                     (list (cons "HOEHE" (if hoehe hoehe (ssg-cfg-or "omniflo" "default_hoehe" "2000")))
-                          (cons "DREHUNG" (if drehung drehung (ssg-cfg-or "omniflo" "default_drehung" "0")))))
+                          (cons "DREHUNG" drehung-anzeige)))
 
                   ;; Layer aus LAYER-Attribut lesen und Block verschieben
                   (setq attribs (ssg-attrib-read blockEnt))
@@ -1020,10 +946,13 @@
                 (ssg-id-generate blockEnt)
               )
 
-              (princ (strcat "\n[OMNI] " sivasnr-str " eingefuegt."
+              (princ (ssg-textf "omni-dxf-eingefuegt"
-                             " Hoehe=" (if hoehe hoehe (ssg-cfg-or "omniflo" "default_hoehe" "2000"))
+                       (list
-                             " Drehung=" (if drehung drehung (ssg-cfg-or "omniflo" "default_drehung" "0"))
+                         sivasnr-str
-                             (if layer-name (strcat " Layer=" layer-name) "")))
+                         (if hoehe hoehe (ssg-cfg-or "omniflo" "default_hoehe" "2000"))
+                         drehung-anzeige
+                         (if layer-name (strcat " Layer=" layer-name) "")
+                       )))
               (ssg-end)
               pt
             )
@@ -1044,8 +973,8 @@
       (setq hoehe   (cadr dlg-result))
       (setq drehung (caddr dlg-result))
       (setq sivasnr-str (omni:sivasid-to-str (omni:val eintrag "Sivasnr")))
-      (princ (strcat "\n[OMNI] Einfuegen: "
+      (princ (ssg-textf "omni-einfuegen-info"
-        (omni:val eintrag "ProfilTyp") " (" sivasnr-str ")"))
+        (list (omni:val eintrag "ProfilTyp") sivasnr-str)))
       (omni:insert-dxf sivasnr-str hoehe drehung)
     )
   )
@@ -1061,7 +990,7 @@
   (setq dlg-result (omni:weichen-dialog 90 "Einzelweiche" nil nil))
   (if dlg-result
     (omni:insert-from-entry dlg-result)
-    (princ "\n[WEICHE] Abgebrochen.")
+    (princ (ssg-text "omni-abbruch-weiche"))
   )
   (princ)
 )
@@ -1070,7 +999,7 @@
   (setq dlg-result (omni:weichen-dialog 90 "Doppelweiche" nil nil))
   (if dlg-result
     (omni:insert-from-entry dlg-result)
-    (princ "\n[WEICHE] Abgebrochen.")
+    (princ (ssg-text "omni-abbruch-weiche"))
   )
   (princ)
 )
@@ -1079,7 +1008,7 @@
   (setq dlg-result (omni:weichen-dialog 90 "Dreiwegeweiche" nil nil))
   (if dlg-result
     (omni:insert-from-entry dlg-result)
-    (princ "\n[WEICHE] Abgebrochen.")
+    (princ (ssg-text "omni-abbruch-weiche"))
   )
   (princ)
 )
@@ -1089,7 +1018,7 @@
   (setq dlg-result (omni:weichen-dialog 45 "Einzelweiche" nil nil))
   (if dlg-result
     (omni:insert-from-entry dlg-result)
-    (princ "\n[WEICHE] Abgebrochen.")
+    (princ (ssg-text "omni-abbruch-weiche"))
   )
   (princ)
 )
@@ -1098,7 +1027,7 @@
   (setq dlg-result (omni:weichen-dialog 45 "Doppelweiche" nil nil))
   (if dlg-result
     (omni:insert-from-entry dlg-result)
-    (princ "\n[WEICHE] Abgebrochen.")
+    (princ (ssg-text "omni-abbruch-weiche"))
   )
   (princ)
 )
@@ -1107,7 +1036,7 @@
   (setq dlg-result (omni:weichen-dialog 45 "Dreiwegeweiche" nil nil))
   (if dlg-result
     (omni:insert-from-entry dlg-result)
-    (princ "\n[WEICHE] Abgebrochen.")
+    (princ (ssg-text "omni-abbruch-weiche"))
   )
   (princ)
 )
@@ -1117,7 +1046,7 @@
   (setq dlg-result (omni:weichen-dialog 0 "Einzelweiche" nil nil))
   (if dlg-result
     (omni:insert-from-entry dlg-result)
-    (princ "\n[WEICHE] Abgebrochen.")
+    (princ (ssg-text "omni-abbruch-weiche"))
   )
   (princ)
 )
@@ -1126,7 +1055,7 @@
   (setq dlg-result (omni:weichen-dialog 0 "Doppelweiche" nil nil))
   (if dlg-result
     (omni:insert-from-entry dlg-result)
-    (princ "\n[WEICHE] Abgebrochen.")
+    (princ (ssg-text "omni-abbruch-weiche"))
   )
   (princ)
 )
@@ -1135,7 +1064,7 @@
   (setq dlg-result (omni:weichen-dialog 0 "Dreiwegeweiche" nil nil))
   (if dlg-result
     (omni:insert-from-entry dlg-result)
-    (princ "\n[WEICHE] Abgebrochen.")
+    (princ (ssg-text "omni-abbruch-weiche"))
   )
   (princ)
 )
@@ -1145,7 +1074,7 @@
   (setq dlg-result (omni:weichen-dialog 22.5 "Einzelweiche" nil nil))
   (if dlg-result
     (omni:insert-from-entry dlg-result)
-    (princ "\n[WEICHE] Abgebrochen.")
+    (princ (ssg-text "omni-abbruch-weiche"))
   )
   (princ)
 )
@@ -1154,7 +1083,7 @@
   (setq dlg-result (omni:weichen-dialog 22.5 "Doppelweiche" nil nil))
   (if dlg-result
     (omni:insert-from-entry dlg-result)
-    (princ "\n[WEICHE] Abgebrochen.")
+    (princ (ssg-text "omni-abbruch-weiche"))
   )
   (princ)
 )
@@ -1163,7 +1092,7 @@
   (setq dlg-result (omni:weichen-dialog 22.5 "Dreiwegeweiche" nil nil))
   (if dlg-result
     (omni:insert-from-entry dlg-result)
-    (princ "\n[WEICHE] Abgebrochen.")
+    (princ (ssg-text "omni-abbruch-weiche"))
   )
   (princ)
 )
@@ -1173,7 +1102,7 @@
   (setq dlg-result (omni:weichen-dialog nil "Deltaweiche" nil nil))
   (if dlg-result
     (omni:insert-from-entry dlg-result)
-    (princ "\n[WEICHE] Abgebrochen.")
+    (princ (ssg-text "omni-abbruch-weiche"))
   )
   (princ)
 )
@@ -1182,7 +1111,7 @@
   (setq dlg-result (omni:weichen-dialog nil "Sternweiche" nil nil))
   (if dlg-result
     (omni:insert-from-entry dlg-result)
-    (princ "\n[WEICHE] Abgebrochen.")
+    (princ (ssg-text "omni-abbruch-weiche"))
   )
   (princ)
 )
@@ -1212,7 +1141,7 @@
   ;; 1. Block auswaehlen (falls nicht vorselektiert)
   (if (null ent)
     (progn
-      (setq sel (entsel "\nOmniflo-Element auswaehlen: "))
+      (setq sel (entsel (ssg-text "omni-edit-prompt-auswahl")))
       (if sel (setq ent (car sel)))
     )
   )
@@ -1220,7 +1149,7 @@
 
   (setq ed (entget ent))
   (if (/= (cdr (assoc 0 ed)) "INSERT")
-    (progn (ssg-emsg "Kein Block ausgewaehlt!") (ssg-end) (exit))
+    (progn (ssg-emsg (ssg-text "omni-edit-kein-block")) (ssg-end) (exit))
   )
 
   ;; 2. Bestehende Attribute lesen
@@ -1276,7 +1205,7 @@
 
   (if (null eintrag)
     (progn
-      (ssg-emsg "Kein Omniflo-Element erkannt! (ARTINR/Blockname nicht im Katalog)")
+      (ssg-emsg (ssg-text "omni-edit-kein-element"))
       (ssg-end)
       (exit)
     )
@@ -1287,7 +1216,7 @@
   (if (= typ "bogen")
     (progn
       (setq winkel (cdr (assoc "KurvenWinkel" eintrag)))
-      (setq dlg-result (omni:bogen-dialog winkel hoehe drehung))
+      (setq dlg-result (omni:bogen-dialog winkel hoehe drehung nil))
     )
     (progn
       (setq winkel     (cdr (assoc "KurvenWinkel" eintrag)))
@@ -1297,7 +1226,7 @@
   )
 
   (if (null dlg-result)
-    (progn (princ "\nAbgebrochen.") (ssg-end) (exit))
+    (progn (princ (ssg-text "omni-abbruch")) (ssg-end) (exit))
   )
 
   ;; 5. Neuen Eintrag und Werte extrahieren
@@ -1310,7 +1239,7 @@
   (setq dxf-pfad (strcat (getenv "DXFM_OMNIFLO") "/" sivasnr-str ".dxf"))
   (if (not (findfile dxf-pfad))
     (progn
-      (ssg-emsg (strcat "DXF nicht gefunden: " dxf-pfad))
+      (ssg-emsg (ssg-textf "omni-edit-dxf-nicht-gefunden" (list dxf-pfad)))
       (ssg-end)
       (exit)
     )
@@ -1339,9 +1268,12 @@
             (cons "DREHUNG" (if new-drehung new-drehung (ssg-cfg-or "omniflo" "default_drehung" "0")))))
   )
 
-  (princ (strcat "\n[OMNI] Element aktualisiert: " sivasnr-str
+  (princ (ssg-textf "omni-edit-aktualisiert"
-                 " Hoehe=" (if new-hoehe new-hoehe (ssg-cfg-or "omniflo" "default_hoehe" "2000"))
+           (list
-                 " Drehung=" (if new-drehung new-drehung (ssg-cfg-or "omniflo" "default_drehung" "0"))))
+             sivasnr-str
+             (if new-hoehe new-hoehe (ssg-cfg-or "omniflo" "default_hoehe" "2000"))
+             (if new-drehung new-drehung (ssg-cfg-or "omniflo" "default_drehung" "0"))
+           )))
 
   (ssg-end)
   (princ)
@@ -1349,28 +1281,30 @@
 
 
 ;; --- Omniflo / TEF Elemente ---
+;; Feste TEF-Bauteile ohne Sivas-Auswahl: Datei liegt direkt unter DXFM_OMNIFLO,
+;; wird per omni:insert-dxf am gewaehlten Einfuegepunkt ohne Drehung eingefuegt.
 (defun c:OMNI_TEF_UmlenkR ()
-  (princ "\n[DUMMY] Umlenkspannst. rechts fuer TEF links")
+  (omni:insert-dxf "Umlenkspannst_TEF_rechts" nil nil)
   (princ)
 )
 
 (defun c:OMNI_TEF_UmlenkL ()
-  (princ "\n[DUMMY] Umlenkspannst. links fuer TEF rechts")
+  (omni:insert-dxf "Umlenkspannst_TEF_links" nil nil)
   (princ)
 )
 
 (defun c:OMNI_TEF_AntriebL ()
-  (princ "\n[DUMMY] Antriebst. links fuer TEF links")
+  (omni:insert-dxf "0_B10010" nil nil)
   (princ)
 )
 
 (defun c:OMNI_TEF_AntriebR ()
-  (princ "\n[DUMMY] Antriebst. rechts fuer TEF rechts")
+  (omni:insert-dxf "0_B10020" nil nil)
   (princ)
 )
 
 (defun c:OMNI_TEF_Gerade ()
-  (princ "\n[DUMMY] TEF Gerade")
+  (omni:insert-dxf "0_B10030" nil nil)
   (princ)
 )
 

Lisp/README.md

@@ -15,7 +15,7 @@ _MENULOAD   →  menu/SSG_LIB.mnu auswaehlen
 ```
 
 BricsCAD laedt daraufhin automatisch `SSG_LIB.mnl`, welches alle Module
-per `ssg-ensure` initialisiert (Kern: ssg_core/dbg/dialog/layer, dann
+per `ssg-ensure` initialisiert (Kern: ssg_core/lang/dbg/dialog/layer, dann
 alle Feature-Module). Details: siehe `../CLAUDE.md` Abschnitt "Lademechanismus".
 
 **Manuell laden (Notfall / Entwicklung):**
@@ -26,6 +26,28 @@ alle Feature-Module). Details: siehe `../CLAUDE.md` Abschnitt "Lademechanismus".
 
 ---
 
+## Status: noch offene Menueintraege (im Menue ausgegraut)
+
+Die folgenden Menueintraege rufen aktuell nur eine Dummy-Funktion auf (Meldung
+`[DUMMY]`, keine Geometrie). Sie sind in `menu/SSG_LIB.mnu` mit `~` **ausgegraut**
+und werden erst bei echter Implementierung wieder aktiviert. Der `~`-Marker steht
+am Label-Anfang, bei Submenue-Schliessern hinter dem `<-` (`[<-~Label]`).
+
+| Menuebereich | Eintraege | Definiert in |
+| --- | --- | --- |
+| ILS ▸ Zusatzmodul | BTMT-Beladung, BTMT-Entladung | `SSG_LIB_Commands.lsp` |
+| ILS ▸ Foerderer | Durch TEF angetriebene Strecke; Kurven 90/60/30 links/rechts angetrieben Aussen + Innen (12) | `SSG_LIB_Commands.lsp` |
+| ILS ▸ Gefaellestrecke | Kurven 90/60/30 links/rechts Gefaellestrecke (6) | `SSG_LIB_Commands.lsp` |
+| Omniflo ▸ TEF Elemente | UmlenkR/L, AntriebL/R, TEF Gerade, KettenFoerderer (6) | `OmniModulInsert.lsp` |
+| Omniflo ▸ Verbinder | alle `OMNI_TV_*` (18) | `OmniModulInsert.lsp` |
+| Omniflo ▸ Boegen fuer Weichen | alle `OMNI_APBW_*` (14) | `OmniModulInsert.lsp` |
+
+Aktiv (implementiert) sind u.a.: Kreisel, Eckrad, VarioFoerderer, EtageVarioFoerderer,
+Gefaellestrecke, Omniflo Boegen (APB), Aluprofil-Geraden (AP), alle Weichen
+(W90/W45/WP/WK/WKomb), Export (Sivas/CSV) und die Tests.
+
+---
+
 ## Dateien
 
 ### `ssg_core.lsp` – Kernbibliothek
@@ -111,6 +133,20 @@ Interne Parser-Funktionen (nicht direkt aufrufen):
 
 ---
 
+### `ssg_lang.lsp` – Sprachumschaltung (Deutsch/Englisch)
+
+Zentrale Textverwaltung fuer benutzersichtbare Meldungen. Kern-Modul, wird direkt nach `ssg_core` geladen. Wird schrittweise auf weitere Module ausgerollt (siehe `doc/translate.md`).
+
+| Funktion | Beschreibung |
+| --- | --- |
+| `ssg-text key` | Liefert Text zu `key` in `*ssg-lang*`, Fallback `de_DE`, dann Key selbst |
+| `ssg-textf key werte` | Wie `ssg-text`, ersetzt Platzhalter `%1 %2 ...` durch `werte` (Liste) |
+
+Sprache umschalten: Befehl `SSG_SPRACHE` (Menue → Konfiguration → Sprache) setzt `*ssg-lang*`
+live und persistiert via `(setenv "DXFM_LANG" ...)`. Default ohne `DXFM_LANG` ist `"de_DE"`.
+
+---
+
 ### `ssg_dbg.lsp` – Debug-Logging
 
 Dateibasiertes Debug-Log mit gepuffertem Schreiben. `dbgf`/`dbg`/`dbgmsg` puffern im Speicher, `dbgreturn` flusht auf die Platte (open/append/close).
@@ -197,9 +233,30 @@ Lädt alle Module in der richtigen Reihenfolge. Ermittelt den Pfad automatisch
 
 ### `VarioFoerderer.lsp` – Vario-Förderer
 
-Parametrischer Generator für ILS Vario-Förderanlagen. Liest Block-Geometrie aus einer DWG-Bibliothek (`DXFM_BLOCKS`). Alle Konstanten (Abstände, Winkel, Skalierung) werden via `ssg-cfg-or` aus `component_defaults.json` (Sektion `vario`) gelesen.
+Kompatibilitäts-Wrapper, der `vf_core.lsp` lädt (Plugin-Dispatcher-Architektur; lädt seinerseits `vf_standard.lsp`, `vf_etage.lsp`, `vf_linienzug.lsp`). Parametrischer Generator für ILS Vario-Förderanlagen. Liest Block-Geometrie aus einer DWG-Bibliothek (`DXFM_BLOCKS`). Alle Konstanten (Abstände, Winkel, Skalierung) werden via `ssg-cfg-or` aus `component_defaults.json` (Sektion `vario`) gelesen.
 
-**Befehl:** `c:FOERDERANLAGE`
+**Befehl:** `c:FOERDERANLAGE` / `c:VarioFoerderer` – wählt zuerst den Anlagen-Typ (Standard/Etage/Linienzug):
+
+- **Typ „standard“ + Werteingabe:** läuft über den DCL-Dialog
+  [`dcl/variofoerderer.dcl`](../dcl/variofoerderer.dcl) (zwei Dialoge, `vfs-standard-dialog-ablauf`
+  in `vf_standard.lsp`): Dialog 1 (`vfs-dialog-eingabe-basis`) erfasst deltaL, deltaH,
+  Förderrichtung (Auf/Ab), Einfügehöhe, Fahrtrichtung und Seite; anschließend berechnet
+  `berechne-standard` die gültigen Winkel-Varianten, und Dialog 2
+  (`vfs-dialog-winkel-verteilung`) lässt Winkel und L_GF-Verteilung (vorne/hinten) wählen.
+  Startpunkt (X/Y) wird wie bei der Gefällestrecke vorher in der Zeichnung gepickt.
+- **Typ „standard“ + 3D-Linie**, sowie **Typ „etage“** und **„linienzug“** bleiben
+  vollständig interaktiv (Kommandozeile), unverändert gegenüber dem bisherigen Ablauf.
+
+**Bearbeiten (`c:VARIOFOERDERER_EDIT`):** Doppelklick auf einen `VF_n`-Block – bzw.
+Rechtsklick-Kontextmenü/`SSG_BLOCKEDIT` – öffnet dieselben Dialoge, vorbelegt mit den
+aktuellen Parametern, und baut die Strecke bei OK am selben Startpunkt neu auf (neue
+`VF_n`-Nummer). Da `VF_n`-Blöcke auch von Etage- und Linienzug-Anlagen erzeugt werden
+(deren komplexere Geometrie ein einfacher Neuaufbau zerstören würde), markiert
+`vfs-xdata-schreiben` nur per Standard-Dialog erstellte Blöcke mit XDATA (App
+`SSG_VF_EDIT`, Fahrtrichtung `hz`); Blöcke ohne diese Markierung weist
+`c:VARIOFOERDERER_EDIT` mit einer Meldung ab, statt sie zu verändern. Winkel und L_GF1
+werden aus den Sivas-Attributen (`VF_WINKEL`, `L_GF_m`) vorbelegt (Verteilung stets als
+„Eigene Werte“ mit dem exakten aktuellen L_GF1).
 
 **Wichtige interne Funktionen** (werden auch von `Gefaellestrecke.lsp` genutzt):
 
@@ -224,10 +281,36 @@ Setzt `VarioFoerderer.lsp` voraus (nutzt dessen `init-bibliothek`, `insert-block
 
 **Befehl:** `c:GEFAELLESTRECKE`
 
-Zwei Modi:
+Drei Modi:
 
-- **Modus 1:** Startpunkt + ΔL (Horizontalabstand) interaktiv abfragen
+- **Modus 1:** Startpunkt (X/Y) picken, restliche Parameter über den DCL-Dialog
-- **Modus 2:** Bestehende 3D-Linie wählen (ΔL und Winkel werden daraus berechnet)
+  [`dcl/gefaellestrecke.dcl`](../dcl/gefaellestrecke.dcl) eingeben (ΔL, Einfügehöhe Z,
+  Gefällewinkel, Fahrtrichtung, AUS-/EIN-Element je Winkel 30/90 und Seite links/rechts).
+  Die Einfügehöhe aus dem Dialog setzt die Z-Koordinate des Startpunkts.
+- **Modus 2:** Bestehende 3D-Linie wählen (ΔL und Fahrtrichtung werden daraus berechnet),
+  restliche Parameter interaktiv über die Kommandozeile.
+- **Modus 3:** Linienzug aus LINE-/ARC-Objekten; ARC-Segmente werden durch
+  Gefällebogen-Blöcke ersetzt, Winkel aus ΔH und Geometrie berechnet.
+
+**Dialog-Hilfsfunktionen:** `gf-dialog-eingabe` (lädt/liest den DCL-Dialog, liefert
+`(deltaL winkel hz-winkel as-seite es-seite einfuegehoehe as-winkel es-winkel)` oder `nil`
+bei Abbruch) und `gf-modus12-abschluss` (gemeinsamer Abschluss für Modus 1+2: setzt die
+Element-Masse per `vf-set-as-masse`/`vf-set-es-masse`, berechnet die Staustreckenlänge,
+zeigt die Zusammenfassung und ruft `gefaellestrecke-einfuegen`).
+
+Die AUS-/EIN-Element-Varianten (30/90 Grad, links/rechts) liegen als DWG-Blöcke
+`AS_Element_<30|90>_<links|rechts>` bzw. `ES_Element_…` in `data/ils/2D|3D/`; ihre Maße
+werden direkt aus dem Block gemessen (`vf-element-masse`), es gibt dafür keine JSON-Tabelle.
+
+**Bearbeiten (`c:GEFAELLESTRECKE_EDIT`):** Doppelklick auf einen Gefällestrecken-Block
+(`GF_n`) – bzw. Rechtsklick-Kontextmenü/`SSG_BLOCKEDIT` – öffnet denselben DCL-Dialog,
+vorbelegt mit den aktuellen Parametern, und baut die Strecke bei OK am selben Startpunkt
+neu auf. Damit Fahrtrichtung und Element-Winkel (30/90) verlustfrei rekonstruiert werden,
+schreibt `gefaellestrecke-einfuegen` diese beim Erstellen als XDATA (App `SSG_GF_EDIT`,
+Helfer `gf-xdata-schreiben`/`gf-xdata-lesen`) auf das `GF_n`-INSERT – bewusst **nicht** in
+den Sivas-Attributsatz, damit der Export unverändert bleibt. Ältere Blöcke ohne XDATA
+werden aus den Attributen vorbelegt (Fahrtrichtung 0°, Element-Winkel 90° als Vorgabe).
+Der Neuaufbau läuft über `gf-rebuild` (nicht-interaktiv, ohne Konsolen-Rückfrage).
 
 ---
 
@@ -238,16 +321,30 @@ Sammelt INSERT-Blöcke aus der Zeichnung und exportiert sie als JSON oder ruft P
 | Befehl / Funktion | Beschreibung |
 | --- | --- |
 | `c:EXPORTSIVAS` | Alle Blöcke als JSON sammeln und `export_sivas.py` aufrufen (Sivas-CSV) |
-| `c:EXPORTCSV` | Alle Blöcke als JSON sammeln und `export_csv.py` aufrufen (einfache Item-Liste) |
+| `c:EXPORTCSV` | Alle Blöcke als JSON sammeln und `export_csv.py` aufrufen (einfache Item-Liste, inkl. Omniflo Bogen/Weiche/Gerade und abschließender "Omniflo Sum"-Zeile) |
-| `c:OMNI_EXPORT` | LISP-basierter Omniflo-Export: Blöcke direkt in CSV schreiben (ohne Python) |
 | `csv:collect-export-blocks` | Alle INSERT-Blöcke der Zeichnung als JSON-Array sammeln |
 | `csv:run-export py-skript json-datei output-csv` | Python-Skript mit gesammelten Daten aufrufen |
 | `csv:read-attribs ename` | Attribute eines INSERT als JSON-Objekt lesen |
-| `csv:omni-bogen-merkmale ename rot` | Omniflo-Bogen-Merkmale als JSON-String |
+| `c:OMNI_UPDATE_ATTRIBS` | HOEHE/DREHUNG aller Omniflo-Elemente aus der Zeichnung aktualisieren |
-| `csv:omni-weiche-merkmale ename rot` | Omniflo-Weichen-Merkmale als JSON-String |
-| `csv:omni-gerade-merkmale ename rot` | Omniflo-Gerade-Merkmale als JSON-String (Länge via `infrastruktur/mm_pro_meter`) |
 
-Default-Werte (HOEHE, DREHUNG, Längen) kommen via `ssg-cfg-or` aus Config-Sektion `omniflo`.
+Der Omniflo-CSV-Export (Bogen/Weiche/Gerade, inkl. Merkmale-Aufbau und Sum-Zeile) läuft
+seit Entfernung von `c:OMNI_EXPORT` ausschließlich über `c:EXPORTCSV` → `lib/export_csv.py`
+(`build_bogen_merkmale`, `build_weiche_merkmale`, `build_gerade_merkmale`, `build_omni_sum_merkmale`).
+
+**Ausgabeordner:** `c:EXPORTSIVAS`/`c:EXPORTCSV` schreiben immer nach `DXFM_RESULTS`.
+`TEST_EXPORT_ALL` (siehe `tests/test_export_all.lsp`) leitet waehrend des Testlaufs stattdessen
+nach `DXFM_TESTOUT` um, über die reine Lisp-Sitzungsvariable `*export-test-override*` (wird von
+`csv:run-export` zusaetzlich zu `DXFM_RESULTS` abgefragt und danach garantiert wieder auf `nil`
+zurueckgesetzt, auch bei einem Fehler, ueber `vl-catch-all-apply`).
+
+**Wichtig:** Der Umweg über `*export-test-override*` ist bewusst gewaehlt und **kein**
+`(setenv "DXFM_RESULTS" ...)`. In BricsCAD/AutoCAD schreibt `(setenv ...)` nicht nur in den
+Windows-Prozess, sondern dauerhaft in die Profil-Registry der Anwendung – der Wert überlebt
+damit jeden Neustart und jedes `setenv.bat`, bis er erneut per `(setenv)` überschrieben wird.
+Ein einziger `(setenv "DXFM_RESULTS" ...)`-Aufruf (z. B. ein frueherer, unvollstaendiger
+Testlauf) würde `DXFM_RESULTS` für alle künftigen Sitzungen unwiderruflich auf den Testordner
+umbiegen. Falls das bereits passiert ist, hilft nur ein manuelles
+`(setenv "DXFM_RESULTS" "<richtiger Pfad>")` in BricsCAD, um den Profil-Wert zu korrigieren.
 
 ---
 
@@ -290,9 +387,9 @@ AutoLISP-Implementierung fuer alle Omniflo-Komponenten: Boegen, Weichen, Verbind
 | Boegen | `OMNI_APB_630_90`, `OMNI_APB_550_675`, `OMNI_APB_630_45`, `OMNI_APB_550_225`, `OMNI_APB_650_180` | Omniflo-Boegen ueber DCL-Dialog einfuegen |
 | Weichen | `OMNI_W90_*`, `OMNI_W45_*`, `OMNI_WP_*`, `OMNI_WK_*`, `OMNI_WKomb_*` | Omniflo-Weichen (Einfach/Doppel/Dreiwege, Delta, Stern) |
 | Geraden | `OMNI_AP60`, `OMNI_AP110`, `OMNI_APG110` | Omniflo-Geradenstuecke |
-| TEF | `OMNI_TEF_UmlenkR/L`, `OMNI_TEF_AntriebL/R`, `OMNI_TEF_Gerade` | Omniflo-TEF-Elemente |
+| TEF ⚠️ | `OMNI_TEF_UmlenkR/L`, `OMNI_TEF_AntriebL/R`, `OMNI_TEF_Gerade`, `OMNI_KettenFoerderer` | **Dummy** (noch nicht implementiert, im Menue ausgegraut) |
-| Transferwagen | `OMNI_TV_*` | Transferwagen-Komponenten und Schaltwerke |
+| Transferwagen ⚠️ | `OMNI_TV_*` | **Dummy** (noch nicht implementiert, im Menue ausgegraut) |
-| Bogenweichen | `OMNI_APBW_*` | Omniflo-Bogenweichen (diverse Radien/Winkel) |
+| Bogenweichen ⚠️ | `OMNI_APBW_*` | **Dummy** (noch nicht implementiert, im Menue ausgegraut) |
 | Bearbeiten | `OMNI_EDIT` | Omniflo-Block selektieren und Attribute bearbeiten |
 
 ---
@@ -300,6 +397,8 @@ AutoLISP-Implementierung fuer alle Omniflo-Komponenten: Boegen, Weichen, Verbind
 ### `SSG_LIB_Commands.lsp` – Dummy-Befehle und SSG_BLOCKEDIT
 
 Platzhalter-Definitionen fuer noch nicht implementierte Menueintraege. Gibt beim Aufruf eine Meldung aus.
+Alle zugehoerigen Menueintraege sind in `menu/SSG_LIB.mnu` mit `~` ausgegraut (siehe
+Abschnitt ["Status: noch offene Menueintraege"](#status-noch-offene-menueintraege-im-menue-ausgegraut)).
 
 Registrierte Dummy-Befehle:
 
@@ -312,6 +411,13 @@ Registrierte Dummy-Befehle:
 
 > `FOERDERANLAGE` ist nicht hier definiert – dieser Befehl ist in `VarioFoerderer.lsp` implementiert.
 
+**Konfigurationsbefehle** (Menue → Konfiguration):
+
+| Befehl | Beschreibung |
+| --- | --- |
+| `SSG_DIM_SWITCH` | Schaltet zwischen 2D/3D-Bloecken um (setzt `DXFM_DIM`, `DXFM_BLOCKS`, `DXFM_OMNIFLO`) |
+| `SSG_SPRACHE` | Oeffnet Dialog `sprache.dcl`, setzt `*ssg-lang*` und persistiert via `DXFM_LANG` (siehe [`ssg_lang.lsp`](#ssg_langlsp--sprachumschaltung-deutschenglisch)) |
+
 **SSG_BLOCKEDIT** – Doppelklick/Kontextmenue-Dispatcher:
 
 Erkennt den Blocktyp des selektierten INSERT-Blocks und ruft den passenden Bearbeitungsbefehl auf:

Lisp/SSG_LIB_Commands.lsp

@@ -15,12 +15,48 @@
   (princ)
 )
 
-;; --- ILS / Foerderer ---
+;; --- ILS / Zusatzmodul: Sensoren (Scanner / Separator) einfuegen ---
-(defun c:ILS_ETF_Etagenfoerderer ()
+
-  (princ "\n[DUMMY] ILS_ETF_Etagenfoerderer aufgerufen")
+;; Ermittelt den Pfad zu einer Sensor-Blockdatei. Die Sensor-Bloecke
+;; werden fest aus data/ils/3D geladen (unabhaengig von der
+;; 2D/3D-Umschaltung).
+(defun ils-sensor-pfad (fname / p)
+  (setq p (strcat (getenv "DXFMAKRO") "\\data\\ils\\3D\\" fname ".dwg"))
+  (if (findfile p) p nil)
+)
+
+;; Fuegt einen Sensor-Block wiederholt ein, bis der Benutzer mit
+;; ENTER oder ESC abbricht. Rotation je Einfuegung interaktiv.
+(defun ils-insert-sensor (fname / pfad pt oldattreq n)
+  (setq pfad (ils-sensor-pfad fname))
+  (if (null pfad)
+    (princ (strcat "\n>>> FEHLER: Blockdatei '" fname ".dwg' nicht gefunden."
+                   " (in data/ils/3D pruefen)"))
+    (progn
+      (setq oldattreq (getvar "ATTREQ"))
+      (setvar "ATTREQ" 0)
+      (setq n 0)
+      (while (setq pt (getpoint (strcat "\nEinfuegepunkt fuer " fname
+                                        " [ENTER=Ende]: ")))
+        (command "_.INSERT" pfad pt "" "" pause)
+        (setq n (1+ n))
+      )
+      (setvar "ATTREQ" oldattreq)
+      (princ (strcat "\n>>> " (itoa n) " x " fname " eingefuegt."))
+    )
+  )
   (princ)
 )
 
+(defun c:ILS_SCANNER_INSERT ()
+  (ils-insert-sensor "Scanner")
+)
+
+(defun c:ILS_SEPARATOR_INSERT ()
+  (ils-insert-sensor "Separator_SP")
+)
+
+;; --- ILS / Foerderer ---
 (defun c:ILS_TEF_Strecke ()
   (princ "\n[DUMMY] ILS_TEF_Strecke aufgerufen")
   (princ)
@@ -137,9 +173,41 @@
   (setenv "DXFM_DIM"    dim-neu)
   (setenv "DXFM_BLOCKS" (strcat basis "\\data\\ils\\" dim-neu))
   (setenv "DXFM_OMNIFLO" (strcat basis "\\data\\omniflo\\" dim-neu))
-  (princ (strcat "\nModus umgeschaltet auf: " dim-neu))
+  (princ (ssg-textf "dim-switch-modus" (list dim-neu)))
-  (princ (strcat "\n  DXFM_BLOCKS  = " (getenv "DXFM_BLOCKS")))
+  (princ (ssg-textf "dim-switch-blocks" (list (getenv "DXFM_BLOCKS"))))
-  (princ (strcat "\n  DXFM_OMNIFLO = " (getenv "DXFM_OMNIFLO")))
+  (princ (ssg-textf "dim-switch-omniflo" (list (getenv "DXFM_OMNIFLO"))))
+  (princ)
+)
+
+;; ============================================================
+;; SSG_SPRACHE - Sprache umschalten (Deutsch/Englisch)
+;; Setzt *ssg-lang* live und persistiert ueber DXFM_LANG
+;; ============================================================
+
+(defun ssg-sprache-init ( / idx)
+  (start_list "sprache")
+  (add_list "Deutsch")
+  (add_list "Englisch")
+  (end_list)
+  (setq idx (if (= *ssg-lang* "en_GB") "1" "0"))
+  (set_tile "sprache" idx)
+)
+
+(defun ssg-sprache-accept ( / idx neu)
+  (setq idx (get_tile "sprache"))
+  (setq neu (if (= idx "1") "en_GB" "de_DE"))
+  (setq *ssg-lang* neu)
+  (setenv "DXFM_LANG" neu)
+)
+
+(defun c:SSG_SPRACHE ()
+  (ssg-dialog-run
+    (strcat (getenv "DXFM_DCL") "/sprache.dcl")
+    "sprache"
+    'ssg-sprache-init
+    'ssg-sprache-accept
+  )
+  (princ (ssg-textf "sprache-gewechselt" (list *ssg-lang*)))
   (princ)
 )
 
@@ -154,13 +222,13 @@
   (setq ss (ssget "I"))
   (if (or (null ss) (/= (sslength ss) 1))
     (progn
-      (princ "\nBlock auswaehlen: ")
+      (princ (ssg-text "cmd-block-auswaehlen"))
       (setq ss (ssget ":S" '((0 . "INSERT"))))
     )
   )
   (if (null ss)
     (progn
-      (princ "\nKein Block ausgewaehlt.")
+      (princ (ssg-text "cmd-kein-block-ausgewaehlt"))
       (princ)
       (exit)
     )
@@ -171,7 +239,7 @@
 
   (if (/= (cdr (assoc 0 ed)) "INSERT")
     (progn
-      (princ "\nKein Block ausgewaehlt.")
+      (princ (ssg-text "cmd-kein-block-ausgewaehlt"))
       (princ)
       (exit)
     )
@@ -182,16 +250,30 @@
   (cond
     ;; Kreisel-Bloecke -> KreiselEdit
     ((wcmatch bname "KREISEL_*")
-      (princ (strcat "\nKreisel bearbeiten: " bname))
+      (princ (ssg-textf "cmd-kreisel-bearbeiten" (list bname)))
       (c:KreiselEdit)
     )
 
     ;; Eckrad-Bloecke -> BEDIT (kein eigener Edit-Dialog in LISP)
     ((wcmatch bname "ECKRAD_*")
-      (princ (strcat "\nEckrad bearbeiten: " bname))
+      (princ (ssg-textf "cmd-eckrad-bearbeiten" (list bname)))
       (command "_.BEDIT" bname)
     )
 
+    ;; Gefaellestrecke-Bloecke (GF_n) -> GEFAELLESTRECKE_EDIT (DCL-Dialog)
+    ((wcmatch bname "GF_*")
+      (princ (ssg-textf "cmd-gefaelle-bearbeiten" (list bname)))
+      (c:GEFAELLESTRECKE_EDIT)
+    )
+
+    ;; VarioFoerderer-Bloecke (VF_n) -> VARIOFOERDERER_EDIT (DCL-Dialog);
+    ;; weist Bloecke ohne SSG_VF_EDIT-XDATA (Etage/Linienzug/Altbestand)
+    ;; intern selbst ab, siehe c:VARIOFOERDERER_EDIT in vf_standard.lsp.
+    ((wcmatch bname "VF_*")
+      (princ (ssg-textf "cmd-variofoerderer-bearbeiten" (list bname)))
+      (c:VARIOFOERDERER_EDIT)
+    )
+
     ;; Omniflo-Bloecke -> OMNI_EDIT
     ;; Erkennung: TEILEART-Attribut vorhanden, AP110-Blockname oder rein numerisch
     ((progn
@@ -203,13 +285,13 @@
          (wcmatch bname "#*")
        )
      )
-      (princ (strcat "\nOmniflo Element bearbeiten: " bname))
+      (princ (ssg-textf "cmd-omniflo-bearbeiten" (list bname)))
       (c:OMNI_EDIT)
     )
 
     ;; Unbekannter Blocktyp -> natives EATTEDIT (Attribut-Editor)
     (t
-      (princ (strcat "\nAttribute bearbeiten: " bname))
+      (princ (ssg-textf "cmd-attribute-bearbeiten" (list bname)))
       (command "_.EATTEDIT")
     )
   )

Lisp/VarioFoerderer.lsp

@@ -17,5 +17,5 @@
 )
 (if *vf-core-datei*
   (load *vf-core-datei*)
-  (princ "\n[VarioFoerderer] WARNUNG: vf_core.lsp nicht gefunden - Befehle nicht verfuegbar.")
+  (princ (ssg-text "vfstart-core-nicht-gefunden"))
 )

Lisp/addattribute.lsp

@@ -0,0 +1,272 @@
+;; ============================================================
+;; addattribute.lisp
+;; Synchronisiert ATTDEF-Attribute in den ILS-Block-DWGs mit den
+;; Werten aus allocations.json.
+;;
+;; Es wird zwischen data/ils/2D und data/ils/3D unterschieden: nach
+;; Auswahl des Verzeichnisses wird die dortige allocations.json
+;; gelesen (data/ils/<2D|3D>/allocations.json) und anschliessend
+;; werden ausschliesslich die DWGs in genau diesem Verzeichnis
+;; bearbeitet.
+;;
+;; Ablauf je JSON-Eintrag  "Blockname": {"TAG": "Wert", ...}:
+;;   - <Blockname>.dwg im selben Verzeichnis wie die JSON oeffnen
+;;   - je Attribut (TAG/Wert):
+;;       - ATTDEF mit diesem Tag existiert nicht  -> neu anlegen,
+;;         Vorgabewert = JSON-Wert (auch wenn dieser leer ist)
+;;       - ATTDEF existiert, ist aber leer        -> mit JSON-Wert befuellen
+;;       - ATTDEF existiert und ist bereits befuellt
+;;                                                 -> NUR ueberschreiben,
+;;         wenn der JSON-Wert NICHT leer ("") ist. Ein leerer JSON-Wert
+;;         loescht also nie einen bereits vorhandenen Wert.
+;;   - DWG nur dann speichern, wenn sich mindestens ein Attributwert
+;;     geaendert hat oder neu angelegt wurde (bessere Nachverfolgbarkeit
+;;     im Versionsvergleich). Falls durch dieses Skript geoeffnet, wird
+;;     die DWG anschliessend wieder geschlossen. War die DWG schon vorher
+;;     offen, bleibt sie offen.
+;;
+;; Voraussetzung: DXFM_DATA ist gesetzt (siehe bin/setenv.bat).
+;;
+;; Aufruf in BricsCAD:
+;;   (load "C:/.../data/ils/2D/addattribute.lisp")
+;;   ILS_ATTR_SYNC
+;; ============================================================
+
+(vl-load-com)
+
+;; ssg_core.lsp (JSON-Parser ssg-cfg-parse-nested) sicherstellen,
+;; falls das Menue/die Kern-Module noch nicht geladen wurden.
+(if (not (car (atoms-family 1 '("SSG-CFG-PARSE-NESTED"))))
+  (if (getenv "DXFM_LISP")
+    (load (strcat (vl-string-translate "\\" "/" (getenv "DXFM_LISP")) "/ssg_core.lsp"))
+  )
+)
+
+;; ------------------------------------------------------------
+;; Bereits offenes Dokument mit gegebenem Pfad suchen (oder nil)
+;; ------------------------------------------------------------
+(defun iad-find-open-doc (dwg-pfad / docs anzahl i doc full treffer)
+  (setq docs   (vla-get-Documents (vlax-get-acad-object))
+        anzahl (vla-get-Count docs)
+        i      0
+        treffer nil
+        dwg-pfad (strcase (vl-string-translate "\\" "/" dwg-pfad))
+  )
+  (while (and (< i anzahl) (not treffer))
+    (setq doc (vla-item docs i))
+    (setq full (strcase (vl-string-translate "\\" "/" (vla-get-FullName doc))))
+    (if (= full dwg-pfad) (setq treffer doc))
+    (setq i (1+ i))
+  )
+  treffer
+)
+
+;; ------------------------------------------------------------
+;; Ein einzelnes ATTDEF aktualisieren (Ueberschreib-Regel)
+;; Rueckgabe: t, wenn der Wert tatsaechlich geaendert wurde
+;; ------------------------------------------------------------
+(defun iad-update-attdef (ent jsonwert / ed altwert)
+  (setq ed      (entget ent)
+        altwert (cdr (assoc 1 ed))
+  )
+  (if (null altwert) (setq altwert ""))
+  (cond
+    ((equal altwert jsonwert)
+     (princ (strcat "\n    = " (cdr (assoc 2 ed)) " = '" altwert "' (unveraendert)"))
+     nil
+    )
+    ((or (= (strlen altwert) 0) (> (strlen jsonwert) 0))
+     (entmod (subst (cons 1 jsonwert) (assoc 1 ed) ed))
+     (princ (strcat "\n    - " (cdr (assoc 2 ed)) " = '" jsonwert "'"))
+     t
+    )
+    (t
+     (princ (strcat "\n    = " (cdr (assoc 2 ed)) " = '" altwert "' (unveraendert, JSON-Wert leer)"))
+     nil
+    )
+  )
+)
+
+;; ------------------------------------------------------------
+;; Neues (unsichtbares) ATTDEF anlegen
+;; ------------------------------------------------------------
+(defun iad-create-attdef (tag wert ypos texthoehe layer)
+  (entmake (list
+    '(0 . "ATTDEF")
+    (cons 8 layer)
+    (cons 10 (list 0.0 ypos 0.0))
+    (cons 40 texthoehe)
+    (cons 1 wert)
+    (cons 3 tag)
+    (cons 2 tag)
+    '(70 . 1)
+  ))
+  (princ (strcat "\n    + " tag " = '" wert "' (neu angelegt)"))
+)
+
+;; ------------------------------------------------------------
+;; Alle Attribute eines JSON-Eintrags im aktiven Dokument abgleichen
+;; attribs = (("TAG" . "Wert") ...)
+;; Rueckgabe: t, wenn mindestens ein Attribut geaendert/neu angelegt wurde
+;; ------------------------------------------------------------
+(defun iad-sync-attribs-in-current-doc (attribs / texthoehe layer ss anzahl i ent ed
+                                          tag wert pt vorhandene ypos gefunden paar geaendert)
+  (setq texthoehe (ssg-cfg-or "ils_attribut" "texthoehe" 50.0)
+        layer     (ssg-cfg-or "ils_attribut" "layer" "0")
+        vorhandene nil
+        ypos       0.0
+        geaendert  nil
+  )
+  ;; Vorhandene ATTDEFs einsammeln (Tag -> Entity) und tiefsten Y-Wert merken
+  (setq ss (ssget "X" '((0 . "ATTDEF"))))
+  (if ss
+    (progn
+      (setq i 0 anzahl (sslength ss))
+      (while (< i anzahl)
+        (setq ent (ssname ss i)
+              ed  (entget ent)
+              tag (cdr (assoc 2 ed))
+              pt  (cdr (assoc 10 ed))
+        )
+        (setq vorhandene (cons (cons tag ent) vorhandene))
+        (if (and pt (< (cadr pt) ypos)) (setq ypos (cadr pt)))
+        (setq i (1+ i))
+      )
+    )
+  )
+  (setq ypos (- ypos (* texthoehe 2.0)))
+
+  (foreach paar attribs
+    (setq tag  (car paar)
+          wert (cdr paar)
+    )
+    (if (null wert) (setq wert ""))
+    (setq gefunden (cdr (assoc tag vorhandene)))
+    (if gefunden
+      (if (iad-update-attdef gefunden wert) (setq geaendert t))
+      (progn
+        (iad-create-attdef tag wert ypos texthoehe layer)
+        (setq ypos (- ypos (* texthoehe 2.0)))
+        (setq geaendert t)
+      )
+    )
+  )
+  geaendert
+)
+
+;; ------------------------------------------------------------
+;; Hauptbefehl
+;; ------------------------------------------------------------
+(defun c:ILS_ATTR_SYNC ( / data-dir json-pfad dwg-dir dwg-unterverz daten orig-doc anzahl-aktualisiert
+                          anzahl-unveraendert anzahl-fehler anzahl-fehlt eintrag blockname attribs
+                          dwg-pfad bereits-offen fehler fehlende-liste name)
+  (setq data-dir (getenv "DXFM_DATA"))
+  (if (not data-dir)
+    (progn
+      (alert "DXFM_DATA ist nicht gesetzt.\nBitte zuerst bin/setenv.bat ausfuehren.")
+      (exit)
+    )
+  )
+  (setq data-dir (vl-string-translate "\\" "/" data-dir))
+
+  (initget "2D 3D")
+  (setq dwg-unterverz (getkword "\nDWG-Verzeichnis waehlen [2D/3D] <2D>: "))
+  (if (not dwg-unterverz) (setq dwg-unterverz "2D"))
+  (setq dwg-dir   (strcat data-dir "/ils/" dwg-unterverz)
+        json-pfad (strcat dwg-dir "/allocations.json")
+  )
+  (if (not (findfile json-pfad))
+    (progn
+      (alert (strcat "JSON nicht gefunden:\n" json-pfad))
+      (exit)
+    )
+  )
+
+  (setq daten (ssg-cfg-parse-nested (ssg-read-file-lines json-pfad)))
+  (if (not daten)
+    (progn
+      (alert "JSON konnte nicht gelesen werden oder ist leer.")
+      (exit)
+    )
+  )
+
+  (setq orig-doc          (vla-get-ActiveDocument (vlax-get-acad-object))
+        anzahl-aktualisiert 0
+        anzahl-unveraendert 0
+        anzahl-fehler       0
+        anzahl-fehlt        0
+        fehlende-liste      nil
+  )
+
+  (foreach eintrag daten
+    (setq blockname (car eintrag)
+          attribs   (cdr eintrag)
+          dwg-pfad  (strcat dwg-dir "/" blockname ".dwg")
+    )
+    (if (findfile dwg-pfad)
+      (progn
+        (princ (strcat "\n[ATTR-SYNC] Bearbeite " blockname ".dwg ..."))
+        (setq bereits-offen (iad-find-open-doc dwg-pfad))
+        (setq fehler
+          (vl-catch-all-apply
+            (function
+              (lambda ( / geaendert)
+                (if bereits-offen
+                  (progn
+                    (vlax-put-property (vlax-get-acad-object) 'ActiveDocument bereits-offen)
+                    (setq geaendert (iad-sync-attribs-in-current-doc attribs))
+                  )
+                  (progn
+                    (command "_.OPEN" dwg-pfad)
+                    (setq geaendert (iad-sync-attribs-in-current-doc attribs))
+                  )
+                )
+                (if geaendert
+                  (command "_.QSAVE")
+                  (princ "\n    (keine Aenderungen, DWG nicht gespeichert)")
+                )
+                (if (not bereits-offen) (command "_.CLOSE"))
+                geaendert
+              )
+            )
+            nil
+          )
+        )
+        (if (vl-catch-all-error-p fehler)
+          (progn
+            (princ (strcat "\n[ATTR-SYNC] FEHLER bei " blockname ".dwg: "
+                           (vl-catch-all-error-message fehler)))
+            (setq anzahl-fehler (1+ anzahl-fehler))
+          )
+          (if fehler
+            (setq anzahl-aktualisiert (1+ anzahl-aktualisiert))
+            (setq anzahl-unveraendert (1+ anzahl-unveraendert))
+          )
+        )
+      )
+      (progn
+        (setq anzahl-fehlt (1+ anzahl-fehlt))
+        (setq fehlende-liste (cons (strcat blockname ".dwg") fehlende-liste))
+      )
+    )
+  )
+
+  (vlax-put-property (vlax-get-acad-object) 'ActiveDocument orig-doc)
+
+  (princ (strcat "\n[ATTR-SYNC] Fertig: " (itoa anzahl-aktualisiert) " DWG(s) aktualisiert, "
+                 (itoa anzahl-unveraendert) " ueberprueft (keine Aenderungen), "
+                 (itoa anzahl-fehler) " Fehler, "
+                 (itoa anzahl-fehlt) " nicht gefunden."))
+  (if fehlende-liste
+    (progn
+      (princ "\n[ATTR-SYNC] WARNUNG: DWG nicht gefunden fuer:")
+      (foreach name (reverse fehlende-liste)
+        (princ (strcat "\n    - " name))
+      )
+    )
+  )
+  (princ)
+)
+
+(princ "\naddattribute.lisp geladen. Befehl: ILS_ATTR_SYNC")
+(princ)

Lisp/collect_attributes.lsp

@@ -0,0 +1,243 @@
+;; ============================================================
+;; collect_attributes.lsp
+;; Sammelt die aktuellen ATTDEF-Werte aller Bloecke (DWG-Dateien)
+;; eines Verzeichnisses und schreibt sie als JSON-Datei
+;; "allocations_collected.json" - im selben Format wie
+;; allocations.json (siehe addattribute.lsp):
+;;   {"Blockname": {"TAG1": "Wert1", "TAG2": "Wert2", ...}, ...}
+;;
+;; Wird zunaechst fuer data/ils/2D und data/ils/3D ausgefuehrt -
+;; je Verzeichnis entsteht eine eigene allocations_collected.json,
+;; direkt im jeweiligen Verzeichnis abgelegt.
+;;
+;; Voraussetzung: DXFM_DATA ist gesetzt (siehe bin/setenv.bat).
+;;
+;; Aufruf in BricsCAD:
+;;   (load "C:/.../Lisp/collect_attributes.lsp")
+;;   ILS_ATTR_COLLECT
+;; ============================================================
+
+(vl-load-com)
+
+;; ------------------------------------------------------------
+;; Bereits offenes Dokument mit gegebenem Pfad suchen (oder nil)
+;; ------------------------------------------------------------
+(defun cac-find-open-doc (dwg-pfad / docs anzahl i doc full treffer)
+  (setq docs   (vla-get-Documents (vlax-get-acad-object))
+        anzahl (vla-get-Count docs)
+        i      0
+        treffer nil
+        dwg-pfad (strcase (vl-string-translate "\\" "/" dwg-pfad))
+  )
+  (while (and (< i anzahl) (not treffer))
+    (setq doc (vla-item docs i))
+    (setq full (strcase (vl-string-translate "\\" "/" (vla-get-FullName doc))))
+    (if (= full dwg-pfad) (setq treffer doc))
+    (setq i (1+ i))
+  )
+  treffer
+)
+
+;; ------------------------------------------------------------
+;; String fuer JSON escapen (Anfuehrungszeichen/Backslash)
+;; ------------------------------------------------------------
+(defun cac-json-escape (s)
+  (if (null s) (setq s ""))
+  (setq s (vl-string-subst "\\\\" "\\" s))
+  (vl-string-subst "\\\"" "\"" s)
+)
+
+;; ------------------------------------------------------------
+;; Alle ATTDEFs im aktiven Dokument einsammeln (alphabetisch nach
+;; Tag sortiert, fuer reproduzierbare Ausgabe) -> (("TAG" . "Wert") ...)
+;; ------------------------------------------------------------
+(defun cac-collect-attdefs-in-current-doc ( / ss anzahl i ent ed tag wert ergebnis)
+  (setq ss (ssget "X" '((0 . "ATTDEF"))))
+  (setq ergebnis nil)
+  (if ss
+    (progn
+      (setq i 0 anzahl (sslength ss))
+      (while (< i anzahl)
+        (setq ent  (ssname ss i)
+              ed   (entget ent)
+              tag  (cdr (assoc 2 ed))
+              wert (cdr (assoc 1 ed))
+        )
+        (if (null wert) (setq wert ""))
+        (setq ergebnis (cons (cons tag wert) ergebnis))
+        (setq i (1+ i))
+      )
+    )
+  )
+  (vl-sort ergebnis (function (lambda (a b) (< (strcase (car a)) (strcase (car b))))))
+)
+
+;; ------------------------------------------------------------
+;; Attribut-Alist ((TAG . Wert) ...) als eingerueckten JSON-Objekt-
+;; Text formatieren, z.B.:
+;;   {
+;;     "TAG1": "Wert1",
+;;     "TAG2": "Wert2"
+;;   }
+;; einruecken = Einrueckung der schliessenden Klammer
+;; ------------------------------------------------------------
+(defun cac-attribs-to-json (attribs einruecken / innen zeilen)
+  (if (null attribs)
+    "{}"
+    (progn
+      (setq innen (strcat einruecken "  "))
+      (setq zeilen
+        (mapcar
+          (function (lambda (paar)
+            (strcat innen "\"" (cac-json-escape (car paar)) "\": \""
+                    (cac-json-escape (cdr paar)) "\"")
+          ))
+          attribs
+        )
+      )
+      (strcat "{\n"
+              (car zeilen)
+              (apply 'strcat (mapcar (function (lambda (z) (strcat ",\n" z))) (cdr zeilen)))
+              "\n" einruecken "}"
+      )
+    )
+  )
+)
+
+;; ------------------------------------------------------------
+;; Eine DWG-Datei oeffnen (falls noetig), ATTDEFs einsammeln und
+;; die Datei wieder schliessen (falls durch diese Funktion geoeffnet).
+;; Rueckgabe: ('ok . (("TAG" . "Wert") ...)) oder ('fehler . meldung)
+;; ------------------------------------------------------------
+(defun cac-collect-dwg (dwg-pfad / bereits-offen ergebnis fehler)
+  (setq bereits-offen (cac-find-open-doc dwg-pfad))
+  (setq ergebnis nil)
+  (setq fehler
+    (vl-catch-all-apply
+      (function
+        (lambda ()
+          (if bereits-offen
+            (vlax-put-property (vlax-get-acad-object) 'ActiveDocument bereits-offen)
+            (command "_.OPEN" dwg-pfad)
+          )
+          (setq ergebnis (cac-collect-attdefs-in-current-doc))
+          (if (not bereits-offen) (command "_.CLOSE"))
+        )
+      )
+      nil
+    )
+  )
+  (if (vl-catch-all-error-p fehler)
+    (cons 'fehler (vl-catch-all-error-message fehler))
+    (cons 'ok ergebnis)
+  )
+)
+
+;; ------------------------------------------------------------
+;; Alle *.dwg eines Verzeichnisses einlesen und als
+;; allocations_collected.json (json-pfad) schreiben.
+;; ------------------------------------------------------------
+(defun cac-collect-directory (dwg-dir json-pfad / dateien datei dwg-pfad orig-doc
+                               blockname ergebnis anzahl-ok anzahl-fehler
+                               fehler-liste eintraege fh erste paar)
+  (setq dwg-dir (vl-string-right-trim "/" (vl-string-translate "\\" "/" dwg-dir)))
+  (if (not (findfile dwg-dir))
+    (princ (strcat "\n[ATTR-COLLECT] Verzeichnis nicht gefunden, uebersprungen: " dwg-dir))
+    (progn
+      (setq dateien (vl-directory-files dwg-dir "*.dwg" 1))
+      (if (not dateien)
+        (princ (strcat "\n[ATTR-COLLECT] Keine DWG-Dateien in: " dwg-dir))
+        (progn
+          (setq orig-doc      (vla-get-ActiveDocument (vlax-get-acad-object))
+                anzahl-ok     0
+                anzahl-fehler 0
+                fehler-liste  nil
+                eintraege     nil
+          )
+          (foreach datei dateien
+            (setq blockname (vl-filename-base datei)
+                  dwg-pfad  (strcat dwg-dir "/" datei)
+            )
+            (princ (strcat "\n[ATTR-COLLECT] Lese " datei " ..."))
+            (setq ergebnis (cac-collect-dwg dwg-pfad))
+            (if (equal (car ergebnis) 'fehler)
+              (progn
+                (princ (strcat "\n[ATTR-COLLECT] FEHLER bei " datei ": " (cdr ergebnis)))
+                (setq anzahl-fehler (1+ anzahl-fehler))
+                (setq fehler-liste (cons datei fehler-liste))
+              )
+              (progn
+                (setq eintraege (cons (cons blockname (cdr ergebnis)) eintraege))
+                (setq anzahl-ok (1+ anzahl-ok))
+              )
+            )
+          )
+          (vlax-put-property (vlax-get-acad-object) 'ActiveDocument orig-doc)
+          (setq eintraege (reverse eintraege))
+
+          ;; JSON schreiben
+          (setq fh (open json-pfad "w"))
+          (if (null fh)
+            (princ (strcat "\n[ATTR-COLLECT] FEHLER: Datei kann nicht geschrieben werden: " json-pfad))
+            (progn
+              (write-line "{" fh)
+              (setq erste T)
+              (foreach paar eintraege
+                (if (not erste) (write-line "," fh))
+                (write-line (strcat "  \"" (cac-json-escape (car paar)) "\": "
+                                    (cac-attribs-to-json (cdr paar) "  "))
+                            fh)
+                (setq erste nil)
+              )
+              (write-line "}" fh)
+              (close fh)
+              (princ (strcat "\n[ATTR-COLLECT] " json-pfad " geschrieben ("
+                             (itoa anzahl-ok) " Bloecke)."))
+            )
+          )
+
+          (princ (strcat "\n[ATTR-COLLECT] " dwg-dir " fertig: "
+                         (itoa anzahl-ok) " gelesen, "
+                         (itoa anzahl-fehler) " Fehler."))
+          (if fehler-liste
+            (progn
+              (princ "\n[ATTR-COLLECT] WARNUNG: Fehler bei:")
+              (foreach datei (reverse fehler-liste)
+                (princ (strcat "\n    - " datei))
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+  (princ)
+)
+
+;; ------------------------------------------------------------
+;; Hauptbefehl - verarbeitet DXFM_DATA/ils/2D und DXFM_DATA/ils/3D
+;; ------------------------------------------------------------
+(defun c:ILS_ATTR_COLLECT ( / data-dir basis-dir subverz dwg-dir json-pfad)
+  (setq data-dir (getenv "DXFM_DATA"))
+  (if (not data-dir)
+    (progn
+      (alert "DXFM_DATA ist nicht gesetzt.\nBitte zuerst bin/setenv.bat ausfuehren.")
+      (exit)
+    )
+  )
+  (setq data-dir  (vl-string-translate "\\" "/" data-dir)
+        basis-dir (strcat data-dir "/ils")
+  )
+
+  (foreach subverz '("2D" "3D")
+    (setq dwg-dir   (strcat basis-dir "/" subverz)
+          json-pfad (strcat dwg-dir "/allocations_collected.json")
+    )
+    (princ (strcat "\n[ATTR-COLLECT] === " subverz " ==="))
+    (cac-collect-directory dwg-dir json-pfad)
+  )
+  (princ)
+)
+
+(princ "\ncollect_attributes.lsp geladen. Befehl: ILS_ATTR_COLLECT")
+(princ)

Lisp/count_sep_scan.lsp

@@ -0,0 +1,356 @@
+;;; ============================================================
+;;; count_sep_scan.lsp  -  Eigenstaendiges Zaehl-Werkzeug
+;;; ------------------------------------------------------------
+;;; Zaehlt die manuell platzierten Bloecke "Scanner" und
+;;; "Separator_SP" je ILS-Block (Kreisel / VarioFoerderer /
+;;; Gefaellestrecke) und schreibt die Anzahlen in die Attribute
+;;; des jeweiligen ILS-Blocks. Anschliessend QSAVE.
+;;;
+;;; Zuordnung eines Sensors zu einem ILS-Block:
+;;;   - Der geometrische Mittelpunkt (X/Y) des Sensors (Zentrum
+;;;     seiner eigenen Bounding-Box, unabhaengig vom $INSBASE)
+;;;     muss in der achsparallelen Bounding-Box des ILS-Blocks
+;;;     liegen (Z wird ignoriert).
+;;;   - Liegt der Punkt in mehreren Boxen (Ueberlappung), wird
+;;;     der ILS-Block mit dem naechstgelegenen Box-Zentrum gewaehlt.
+;;;   - Ein optionaler Toleranzrand (*senstol*) vergroessert die
+;;;     Box, damit Sensoren knapp am Rand noch erfasst werden.
+;;;
+;;; Aufruf:  ZAEHLE_SEP_SCAN
+;;; Laden:   per APPLOAD oder (load "count_sep_scan")
+;;; ============================================================
+
+(vl-load-com)
+
+;;; ------------------------------------------------------------
+;;; KONFIGURATION (bei Bedarf anpassen)
+;;; ------------------------------------------------------------
+
+;; Toleranzrand um die ILS-Block-Box in Zeichnungseinheiten (mm).
+;; 0.0 = exakte Box. Groesserer Wert = Sensoren knapp ausserhalb
+;; werden noch dem ILS-Block zugerechnet.
+(if (null *senstol*) (setq *senstol* 0.0))
+
+;; Blockname-Muster (wcmatch, Grossschreibung) fuer die manuell
+;; platzierten Sensoren.
+(setq *scanner-pattern*   "SCANNER,SCANNER_*")
+(setq *separator-pattern* "SEPARATOR_SP,SEPARATOR_SP_*")
+
+;; Blockname-Muster fuer die INTERN im ILS-Block (in der Kette)
+;; gezeichneten Separatoren. Diese bilden die Basis fuer
+;; ANZAHL_SEPARATOR und werden bei jedem Lauf frisch gezaehlt.
+(setq *intern-separator-pattern* "STAUSTRECKE_SEPARATOR_SP*")
+
+;;; ------------------------------------------------------------
+;;; ILS-Block-Erkennung und zugehoerige Attribut-Tags
+;;;   Alle ILS-Bloecke (Kreisel / VF / GF) verwenden einheitlich
+;;;   ANZAHL_SCANNER und ANZAHL_SEPARATOR.
+;;;   Rueckgabe: (scanner-tag  separator-tag)  oder nil
+;;; ------------------------------------------------------------
+(defun cs-carrier-tags (nm / up)
+  (setq up (strcase nm))
+  (if (or (wcmatch up "KREISEL_*")
+          (wcmatch up "VF_*")
+          (wcmatch up "GF_*"))
+    (list "ANZAHL_SCANNER" "ANZAHL_SEPARATOR")
+    nil
+  )
+)
+
+;;; ------------------------------------------------------------
+;;; Sensor-Erkennung
+;;;   Rueckgabe: 'scanner | 'separator | nil
+;;; ------------------------------------------------------------
+(defun cs-sensor-kind (nm / up)
+  (setq up (strcase nm))
+  (cond
+    ((wcmatch up *scanner-pattern*)   'scanner)
+    ((wcmatch up *separator-pattern*) 'separator)
+    (t nil)
+  )
+)
+
+;;; ------------------------------------------------------------
+;;; Punkt-Rueckgabe von vla-getboundingbox in eine Liste wandeln.
+;;;   BricsCAD liefert ein Safearray, AutoCAD ein Variant mit
+;;;   Safearray - beide Faelle werden hier abgedeckt.
+;;; ------------------------------------------------------------
+(defun cs-pt->list (v)
+  (cond
+    ((= (type v) 'variant)   (vlax-safearray->list (vlax-variant-value v)))
+    ((= (type v) 'safearray) (vlax-safearray->list v))
+    ((listp v)               v)
+    (t                       nil)
+  )
+)
+
+;;; ------------------------------------------------------------
+;;; Bounding-Box eines INSERT holen (WCS, achsparallel).
+;;;   Erzwingt vorher ein vla-update (Regen des Objekts), da
+;;;   vla-getboundingbox sonst auf nicht-regenerierten oder auf
+;;;   eingefrorenen Layern liegenden Bloecken scheitert.
+;;;   Rueckgabe: (minx miny maxx maxy)  oder nil bei Fehler.
+;;;   *cs-last-error* enthaelt bei Fehler den echten COM-Fehlertext.
+;;; ------------------------------------------------------------
+(defun cs-bbox (ent / obj res)
+  (setq *cs-last-error* nil)
+  (setq obj (vlax-ename->vla-object ent))
+  ;; Objekt regenerieren (Fehler ignorieren)
+  (vl-catch-all-apply 'vla-update (list obj))
+  (setq res
+    (vl-catch-all-apply
+      '(lambda ( / ll ur)
+         (vla-getboundingbox obj 'll 'ur)
+         (list (cs-pt->list ll) (cs-pt->list ur)))))
+  (if (vl-catch-all-error-p res)
+    (progn
+      (setq *cs-last-error* (vl-catch-all-error-message res))
+      nil)
+    (list (car  (car res)) (cadr (car res))    ;; minx miny
+          (car  (cadr res)) (cadr (cadr res))) ;; maxx maxy
+  )
+)
+
+;;; ------------------------------------------------------------
+;;; Referenzpunkt eines Sensors: geometrischer Mittelpunkt seiner
+;;; eigenen Bounding-Box (X/Y). Unabhaengig vom $INSBASE der
+;;; Sensor-DWG. Fallback auf den Einfuegepunkt, falls die Box
+;;; nicht ermittelbar ist.
+;;; ------------------------------------------------------------
+(defun cs-sensor-point (ent ed / bb)
+  (setq bb (cs-bbox ent))
+  (if bb
+    (list (/ (+ (nth 0 bb) (nth 2 bb)) 2.0)
+          (/ (+ (nth 1 bb) (nth 3 bb)) 2.0))
+    (cdr (assoc 10 ed))
+  )
+)
+
+;;; ------------------------------------------------------------
+;;; Liegt Punkt pt (X/Y) in ILS-Block-Record rec (mit Toleranz)?
+;;;   rec = (ename tagScan tagSep minx miny maxx maxy cx cy)
+;;; ------------------------------------------------------------
+(defun cs-in-box (pt rec / x y)
+  (setq x (car pt) y (cadr pt))
+  (and (>= x (- (nth 3 rec) *senstol*))
+       (<= x (+ (nth 5 rec) *senstol*))
+       (>= y (- (nth 4 rec) *senstol*))
+       (<= y (+ (nth 6 rec) *senstol*)))
+)
+
+;;; ------------------------------------------------------------
+;;; Sensor-Punkt einem ILS-Block zuordnen.
+;;;   Rueckgabe: ILS-Block-Record oder nil (keine Zuordnung).
+;;;   Bei mehreren Treffern: naechstes Box-Zentrum (X/Y).
+;;; ------------------------------------------------------------
+(defun cs-assign (pt carriers / matches best bestd d)
+  (setq matches nil)
+  (foreach rec carriers
+    (if (cs-in-box pt rec) (setq matches (cons rec matches))))
+  (cond
+    ((null matches) nil)
+    ((= (length matches) 1) (car matches))
+    (t
+      (setq best nil bestd nil)
+      (foreach rec matches
+        (setq d (distance (list (car pt) (cadr pt))
+                          (list (nth 7 rec) (nth 8 rec))))
+        (if (or (null bestd) (< d bestd))
+          (setq bestd d  best rec)))
+      best)
+  )
+)
+
+;;; ------------------------------------------------------------
+;;; Zaehler in einer Assoc-Liste (Schluessel = ename) erhoehen.
+;;; ------------------------------------------------------------
+(defun cs-bump (alist key / pair)
+  (setq pair (assoc key alist))
+  (if pair
+    (subst (cons key (1+ (cdr pair))) pair alist)
+    (cons (cons key 1) alist))
+)
+
+;;; ------------------------------------------------------------
+;;; Attributwert an einem INSERT setzen (Tag ohne Gross/Klein).
+;;;   Rueckgabe: T wenn Tag gefunden und gesetzt, sonst nil.
+;;; ------------------------------------------------------------
+(defun cs-set-att (ins tag val / e ed done ok)
+  (setq e (entnext ins) done nil ok nil)
+  (while (and e (not done))
+    (setq ed (entget e))
+    (cond
+      ((= (cdr (assoc 0 ed)) "ATTRIB")
+        (if (= (strcase (cdr (assoc 2 ed))) (strcase tag))
+          (progn
+            (entmod (subst (cons 1 val) (assoc 1 ed) ed))
+            (entupd e)
+            (setq ok t))))
+      ((= (cdr (assoc 0 ed)) "SEQEND") (setq done t))
+    )
+    (setq e (entnext e))
+  )
+  ok
+)
+
+;;; ------------------------------------------------------------
+;;; Zaehlt rekursiv, wie oft ein Block (Muster pat) in der
+;;; Definition des Blocks bname verwendet wird - inklusive
+;;; verschachtelter Unterbloecke. Damit wird die interne Anzahl
+;;; der Kette-Separatoren aus der Geometrie ermittelt.
+;;; ------------------------------------------------------------
+(defun cs-count-nested (bname pat / e ed nm n stop)
+  (setq n 0 stop nil)
+  (setq e (tblobjname "BLOCK" bname))
+  (if e
+    (progn
+      (setq e (entnext e))
+      (while (and e (not stop))
+        (setq ed (entget e))
+        (cond
+          ((= (cdr (assoc 0 ed)) "ENDBLK") (setq stop t))
+          ((= (cdr (assoc 0 ed)) "INSERT")
+            (setq nm (cdr (assoc 2 ed)))
+            (if (wcmatch (strcase nm) pat)
+              (setq n (1+ n))
+              (setq n (+ n (cs-count-nested nm pat)))))
+        )
+        (if (not stop) (setq e (entnext e)))
+      )
+    )
+  )
+  n
+)
+
+;;; ============================================================
+;;; HAUPTBEFEHL
+;;; ============================================================
+(defun c:ZAEHLE_SEP_SCAN ( / ss i ent ed nm tags bb cx cy
+                             carriers scanpts seppts kind pt
+                             scanCounts sepCounts
+                             rec en nm2 ns nsep internSep newS newP
+                             n-scan-unassigned n-sep-unassigned
+                             okS okP)
+  (setq carriers nil scanpts nil seppts nil)
+
+  ;; Vor der Extents-Berechnung einmal regenerieren, damit
+  ;; vla-getboundingbox verlaessliche Werte liefert.
+  (vl-catch-all-apply '(lambda () (command "_.REGEN")))
+
+  ;; --- 1. Alle INSERTs sammeln und klassifizieren ---
+  (setq ss (ssget "_X" '((0 . "INSERT"))))
+  (if (null ss)
+    (progn (princ "\n>>> Keine Bloecke in der Zeichnung gefunden.") (princ))
+    (progn
+      (setq i 0)
+      (while (< i (sslength ss))
+        (setq ent (ssname ss i))
+        (setq ed  (entget ent))
+        (setq nm  (cdr (assoc 2 ed)))
+        (setq tags (cs-carrier-tags nm))
+        (cond
+          ;; --- ILS-Block ---
+          (tags
+            (setq bb (cs-bbox ent))
+            (if bb
+              (progn
+                (setq cx (/ (+ (nth 0 bb) (nth 2 bb)) 2.0))
+                (setq cy (/ (+ (nth 1 bb) (nth 3 bb)) 2.0))
+                (setq carriers
+                  (cons (list ent (car tags) (cadr tags)
+                              (nth 0 bb) (nth 1 bb) (nth 2 bb) (nth 3 bb)
+                              cx cy)
+                        carriers)))
+              (princ (strcat "\n! Bounding-Box fehlgeschlagen fuer ILS-Block '" nm "'"
+                             (if *cs-last-error*
+                               (strcat " (" *cs-last-error* ")") "")))
+            )
+          )
+          ;; --- Sensor ---
+          (t
+            (setq kind (cs-sensor-kind nm))
+            (if kind
+              (progn
+                (setq pt (cs-sensor-point ent ed))
+                (if (eq kind 'scanner)
+                  (setq scanpts (cons pt scanpts))
+                  (setq seppts  (cons pt seppts)))))
+          )
+        )
+        (setq i (1+ i))
+      )
+
+      ;; --- 2. Sensoren den ILS-Bloecken zuordnen ---
+      (setq scanCounts nil sepCounts nil
+            n-scan-unassigned 0 n-sep-unassigned 0)
+
+      (foreach pt scanpts
+        (setq rec (cs-assign pt carriers))
+        (if rec
+          (setq scanCounts (cs-bump scanCounts (car rec)))
+          (setq n-scan-unassigned (1+ n-scan-unassigned))))
+
+      (foreach pt seppts
+        (setq rec (cs-assign pt carriers))
+        (if rec
+          (setq sepCounts (cs-bump sepCounts (car rec)))
+          (setq n-sep-unassigned (1+ n-sep-unassigned))))
+
+      ;; --- 3. Attribute setzen und Bericht ausgeben ---
+      (princ "\n============================================")
+      (princ "\n  Sensor-Zaehlung je ILS-Block")
+      (princ "\n============================================")
+      (if (null carriers)
+        (princ "\n  (Keine ILS-Bloecke KREISEL_/VF_/GF_ gefunden)")
+        (foreach rec carriers
+          (setq en   (car rec))
+          (setq nm2  (cdr (assoc 2 (entget en))))
+          (setq ns   (cond ((assoc en scanCounts) (cdr (assoc en scanCounts))) (t 0)))
+          (setq nsep (cond ((assoc en sepCounts)  (cdr (assoc en sepCounts)))  (t 0)))
+          ;; interne Kette-Separatoren frisch aus der Blockdefinition zaehlen
+          (setq internSep (cs-count-nested nm2 *intern-separator-pattern*))
+          ;; Scanner  = nur neu zugeordnete
+          ;; Separator = interne Kette-Separatoren + neu zugeordnete
+          (setq newS ns)
+          (setq newP (+ internSep nsep))
+          ;; gefundene Anzahlen melden
+          (princ (strcat "\n  " nm2
+                         ": Scanner(neu)=" (itoa ns)
+                         ", Separator intern=" (itoa internSep)
+                         " + manuell=" (itoa nsep)))
+          ;; Werte schreiben und Ergebnis bestaetigen
+          (setq okS (cs-set-att en (nth 1 rec) (itoa newS)))
+          (setq okP (cs-set-att en (nth 2 rec) (itoa newP)))
+          (if (and okS okP)
+            (princ (strcat "\n     -> geschrieben: "
+                           "ANZAHL_SCANNER=" (itoa newS)
+                           ", ANZAHL_SEPARATOR=" (itoa newP)))
+            (princ (strcat "\n     -> FEHLER beim Schreiben: "
+                           (if okS "" "ANZAHL_SCANNER fehlt  ")
+                           (if okP "" "ANZAHL_SEPARATOR fehlt"))))
+        )
+      )
+      (princ (strcat "\n--------------------------------------------"
+                     "\n  ILS-Bloecke gesamt: " (itoa (length carriers))
+                     "\n  Scanner gesamt:     " (itoa (length scanpts))
+                     " (nicht zugeordnet: " (itoa n-scan-unassigned) ")"
+                     "\n  Separator gesamt:   " (itoa (length seppts))
+                     " (nicht zugeordnet: " (itoa n-sep-unassigned) ")"))
+      (if (or (> n-scan-unassigned 0) (> n-sep-unassigned 0))
+        (princ (strcat "\n  Hinweis: Nicht zugeordnete Sensoren liegen"
+                       "\n  ausserhalb aller ILS-Block-Boxen. Ggf. *senstol*"
+                       "\n  erhoehen oder Platzierung pruefen.")))
+
+      ;; --- 4. Zeichnung speichern ---
+      (princ "\n--------------------------------------------")
+      (princ "\n  Speichere Zeichnung (QSAVE) ...")
+      (command "_.QSAVE")
+      (princ "\n>>> Fertig.")
+      (princ)
+    )
+  )
+  (princ)
+)
+
+(princ "\n>>> count_sep_scan.lsp geladen. Befehl: ZAEHLE_SEP_SCAN")
+(princ)

Lisp/export.lsp

@@ -4,10 +4,69 @@
 ;; Enthaelt:
 ;;   - JSON-Sammler (csv:collect-export-blocks, csv:run-export)
 ;;   - Python-basierter Export: EXPORTSIVAS, EXPORTCSV
-;;   - LISP-basierter Omniflo-Export: OMNI_EXPORT
+;;
+;; Alle Blockname-Muster dieses Moduls sind zentral in cfg/export.cfg
+;; (INI-Style, Abschnitt [blockpattern]) deklariert und werden beim
+;; Laden des Moduls einmalig eingelesen (export:load-cfg).
+;; Datei-/Skriptnamen sind fest im Code hinterlegt (*export-filenames*).
 ;; ============================================================
 
 
+;; --- Export-Konfiguration aus cfg/export.cfg laden ---
+;; Nutzt den zentralen INI-Parser aus ssg_core.lsp (ssg-load-ini / ssg-ini-get /
+;; ssg-ini-list), damit fuer alle Module derselbe .cfg-Standard gilt.
+(defun export:load-cfg ( / cfg-pfad)
+  (setq cfg-pfad (strcat (getenv "DXFM_CFG") "/export.cfg"))
+  (setq *export-cfg* (ssg-load-ini cfg-pfad))
+  (if (null *export-cfg*)
+    (princ (ssg-textf "exp-cfg-not-found" (list cfg-pfad)))
+  )
+  (princ)
+)
+
+;; --- Einzelwert aus *export-cfg* lesen, mit Fallback ---
+;; section = "blockpattern"
+(defun export:cfg (section key default)
+  (ssg-ini-get *export-cfg* section key default)
+)
+
+;; --- Muster aus [blockpattern] als normalisierter wcmatch-String ---
+;; key         = Config-Key, z.B. "pattern_kreisel"
+;; default-str = Fallback-Wert als kommagetrennter String, falls Config fehlt
+;; Rueckgabe: kommagetrennter String ohne Leerzeichen, z.B. "KR_*,KREISEL_*"
+(defun export:pattern (key default-str)
+  (ssg-ini-list *export-cfg* "blockpattern" key default-str)
+)
+
+;; Beim Laden des Moduls einmalig einlesen (Lazy-Loading via ssg-ensure "export")
+(export:load-cfg)
+
+;; --- Test-Override fuer den Ausgabeordner (nur Lisp-Sitzungsspeicher) ---
+;; Wird ausschliesslich von TEST_EXPORT_ALL (tests/test_export_all.lsp)
+;; waehrend des Testlaufs auf DXFM_TESTOUT gesetzt und danach garantiert
+;; wieder auf nil zurueckgesetzt. Bewusst KEIN (setenv "DXFM_RESULTS" ...):
+;; (setenv ...) schreibt in BricsCAD dauerhaft in die Profil-Registry und
+;; ueberlebt damit jeden Neustart.
+(setq *export-test-override* nil)
+
+
+;; --- Feste Datei-/Skriptnamen dieses Moduls (keine Config, direkt im Code) ---
+(setq *export-filenames*
+  (list
+    (cons "raw_json_datei" "export_raw.json")
+    (cons "sivas_script"   "export_sivas.py")
+    (cons "sivas_csv"      "export_sivas.csv")
+    (cons "csv_script"     "export_csv.py")
+    (cons "csv_csv"        "export.csv")
+  )
+)
+
+;; --- Dateinamen aus *export-filenames* lesen ---
+(defun export:filename (key)
+  (cdr (assoc key *export-filenames*))
+)
+
+
 ;; --- String fuer JSON escapen (Anfuehrungszeichen/Backslash) ---
 ;; Konvertiert nicht-String-Werte (z.B. T, nil, Zahlen) defensiv in String.
 (defun csv:json-escape (s)
@@ -60,10 +119,7 @@
   (setq rotation  (cdr (assoc 50 ed)))
   (setq handle    (cdr (assoc 5 ed)))
   (if (null rotation) (setq rotation 0.0))
-  (if (cdr (assoc 66 ed))
+  (setq attribs (csv:read-attribs ename))
-    (setq attribs (csv:read-attribs ename))
-    (setq attribs "{}")
-  )
   (strcat
     "  {\"block_name\":\"" (csv:json-escape blk-name) "\""
     ",\"layer\":\"" (csv:json-escape layer) "\""
@@ -84,6 +140,7 @@
 ;;   AP110*   = Omniflo Geraden
 ;;   Omniflo Boegen/Weichen = rein numerische Blocknamen (SivasNr)
 ;;   Vario*   = VarioFoerderer-Bloecke
+;;   GF_*     = Gefaellestrecke Compound-Bloecke
 ;; Gibt Auswahlsatz zurueck oder nil.
 (defun csv:collect-export-blocks ( / ss-all ss-out i ename ed bname)
   (setq ss-all (ssget "X" (list (cons 0 "INSERT"))))
@@ -95,10 +152,14 @@
         (setq ed (entget ename))
         (setq bname (cdr (assoc 2 ed)))
         (if (or
-              (wcmatch bname "KR_*,KREISEL_*,ECKRAD_*")
+              (wcmatch bname (export:pattern "pattern_kreisel" "KR_*,KREISEL_*,ECKRAD_*"))
-              (wcmatch (strcase bname) "AP110*,AP_110*")
+              (wcmatch (strcase bname) (export:pattern "pattern_gerade" "AP110*,AP_110*"))
-              (wcmatch bname "Vario*,Staustrecke*,AUS_Element*,EIN_Element*")
+              (wcmatch bname (export:pattern "pattern_strecke"
+                "Vario*,Staustrecke*,AUS_Element*,EIN_Element*,VF_*,GF_*"))
               ;; Rein numerische Namen = Omniflo SivasNr (Boegen/Weichen)
+              ;; Rein LISP-intern (Python klassifiziert Omniflo stattdessen
+              ;; ueber exakten Katalog-Match), daher fest im Code statt in
+              ;; cfg/export.cfg.
               (wcmatch bname "#*")
             )
           (ssadd ename ss-out)
@@ -124,7 +185,7 @@
         (setq bname (cdr (assoc 2 ed)))
         (setq teileart (csv:get-attrib ename "TEILEART"))
         (if (or teileart
-                (wcmatch (strcase bname) "AP110*,AP_110*"))
+                (wcmatch (strcase bname) (export:pattern "pattern_gerade" "AP110*,AP_110*")))
           (progn
             (omni:set-hoehe-attrib ename)
             (omni:set-drehung-attrib ename)
@@ -143,31 +204,46 @@
 ;; py-name = Python-Skript-Name (z.B. "export_csv.py")
 ;; csv-name = Ergebnis-CSV-Name (z.B. "export.csv")
 (defun csv:run-export (label py-name csv-name / ss i ename fh out-pfad
-                        py-skript ergebnis-pfad cmd first-block count)
+                        py-skript ergebnis-pfad cmd first-block count out-dir)
   ;; Vor dem Export: IDs aller Bloecke sicherstellen und Duplikate korrigieren
-  (princ (strcat "\n[" label "] Pruefe und vergebe IDs..."))
+  (princ (ssg-textf "exp-check-ids" (list label)))
   (ssg-id-check-all)
   ;; Vor dem Export HOEHE/DREHUNG aller Omniflo-Elemente aktualisieren
-  (princ (strcat "\n[" label "] Aktualisiere Hoehe/Drehung..."))
+  (princ (ssg-textf "exp-update-hoehe-drehung" (list label)))
   (omni:update-all-attribs)
-  (princ (strcat "\n[" label "] Sammle relevante Bloecke..."))
+  (princ (ssg-textf "exp-collect-blocks" (list label)))
 
   (setq ss (csv:collect-export-blocks))
   (if (null ss)
     (progn
-      (princ (strcat "\n[" label "] Keine relevanten Bloecke gefunden."))
+      (princ (ssg-textf "exp-no-blocks-found" (list label)))
       (princ)
     )
     (progn
       (setq count (sslength ss))
-      (princ (strcat "\n[" label "] " (itoa count) " Bloecke gefunden."))
+      (princ (ssg-textf "exp-blocks-found" (list label count)))
+
+      ;; Ausgabeordner: DXFM_RESULTS, ausser *export-test-override* ist gesetzt
+      ;; (nur waehrend TEST_EXPORT_ALL, siehe tests/test_export_all.lsp).
+      ;; WICHTIG: Hier bewusst KEIN (setenv "DXFM_RESULTS" ...) verwenden!
+      ;; (setenv ...) schreibt in BricsCAD dauerhaft in die Profil-Registry
+      ;; und ueberlebt damit jeden Neustart - ein einziger Testlauf wuerde
+      ;; DXFM_RESULTS fuer alle zukuenftigen Sitzungen unwiderruflich auf den
+      ;; Testordner umbiegen. *export-test-override* ist eine reine
+      ;; Lisp-Variable (nur Prozess-/Sitzungsspeicher) und daher sicher.
+      (setq out-dir (if *export-test-override*
+                       *export-test-override*
+                       (getenv "DXFM_RESULTS")))
+      (if (not (vl-file-directory-p out-dir)) (vl-mkdir out-dir))
+      (princ (ssg-textf "exp-output-dir" (list label out-dir)))
 
       ;; JSON-Datei zusammenbauen
-      (setq out-pfad (strcat (getenv "DXFM_RESULTS") "/export_raw.json"))
+      (setq out-pfad (strcat out-dir "/"
+                              (export:filename "raw_json_datei")))
       (setq fh (open out-pfad "w"))
       (if (null fh)
         (progn
-          (princ (strcat "\n[" label "] FEHLER: Kann Datei nicht oeffnen: " out-pfad))
+          (princ (ssg-textf "exp-file-open-error" (list label out-pfad)))
           (princ)
         )
         (progn
@@ -184,22 +260,22 @@
           )
           (write-line "]" fh)
           (close fh)
-          (princ (strcat "\n[" label "] JSON geschrieben: " out-pfad))
+          (princ (ssg-textf "exp-json-written" (list label out-pfad)))
 
           ;; Python-Skript aufrufen
           (setq py-skript (strcat (getenv "DXFM_LIB") "/" py-name))
           (if (findfile py-skript)
             (progn
-              (setq ergebnis-pfad (strcat (getenv "DXFM_RESULTS") "/" csv-name))
+              (setq ergebnis-pfad (strcat out-dir "/" csv-name))
               (setq cmd (strcat "python \"" py-skript "\""
                                 " \"" out-pfad "\""
                                 " \"" (getenv "DXFM_DATA") "\""
                                 " \"" ergebnis-pfad "\""))
-              (princ (strcat "\n[" label "] Rufe Python auf..."))
+              (princ (ssg-textf "exp-calling-python" (list label)))
               (startapp "cmd" (strcat "/c " cmd))
-              (princ (strcat "\n[" label "] Export gestartet: " ergebnis-pfad))
+              (princ (ssg-textf "exp-export-started" (list label ergebnis-pfad)))
             )
-            (princ (strcat "\n[" label "] FEHLER: Python-Skript nicht gefunden: " py-skript))
+            (princ (ssg-textf "exp-python-not-found" (list label py-skript)))
           )
         )
       )
@@ -211,22 +287,21 @@
 
 ;; --- EXPORTSIVAS: Sivas-spezifischer CSV-Export mit Summierungszeilen ---
 (defun c:EXPORTSIVAS ()
-  (csv:run-export "EXPORTSIVAS" "export_sivas.py" "export_sivas.csv")
+  (csv:run-export "EXPORTSIVAS"
+    (export:filename "sivas_script")
+    (export:filename "sivas_csv"))
 )
 
 ;; --- EXPORTCSV: Einfache Item-Liste aller Bloecke (ohne Summierung) ---
 (defun c:EXPORTCSV ()
-  (csv:run-export "EXPORTCSV" "export_csv.py" "export.csv")
+  (csv:run-export "EXPORTCSV"
+    (export:filename "csv_script")
+    (export:filename "csv_csv"))
 )
 
 
 ;; ============================================================
-;; LISP-basierter Omniflo-Export (ohne Python)
+;; OMNIFLO HOEHE/DREHUNG AKTUALISIEREN
-;;
-;; Erkennt Omniflo Bloecke anhand Attribute:
-;;   TEILEART = "Omniflo Kurve"  -> Bogen
-;;   TEILEART = "Omniflo Weiche" -> Weiche
-;;   Blockname AP110*            -> Gerade
 ;; ============================================================
 
 ;; --- Attribut-Wert eines INSERT-Blocks nach Tag lesen ---
@@ -249,249 +324,6 @@
   atag
 )
 
-
-;; --- Omniflo-Block klassifizieren ---
-;; Gibt "bogen", "weiche", "gerade" oder nil zurueck
-(defun csv:omni-classify (ename bname / teileart)
-  (setq teileart (csv:get-attrib ename "TEILEART"))
-  (cond
-    ((and teileart (= teileart "Omniflo Kurve"))   "bogen")
-    ((and teileart (= teileart "Omniflo Weiche"))  "weiche")
-    ((wcmatch (strcase bname) "AP110*,AP_110*")    "gerade")
-    (t nil)
-  )
-)
-
-
-;; --- Weichen-Subtyp fuer Omniflo Sum Zaehlung bestimmen ---
-(defun csv:omni-weichensubtyp (ename / wtyp beschr)
-  (setq wtyp (csv:get-attrib ename "WEICHENTYP"))
-  (setq beschr (csv:get-attrib ename "BESCHR"))
-  (if (null wtyp) (setq wtyp ""))
-  (if (null beschr) (setq beschr ""))
-  (cond
-    ((vl-string-search "WEICHENK" (strcase beschr))  "weichenkoerper")
-    ((= wtyp "Einzelweiche")     "einzelweiche")
-    ((= wtyp "Doppelweiche")     "doppelweiche")
-    ((= wtyp "Dreiwegeweiche")   "dreiwegeweiche")
-    ((= wtyp "Deltaweiche")      "deltaweiche")
-    ((= wtyp "Dreifachweiche")   "deltaweiche")
-    ((= wtyp "Sternweiche")      "sternweiche")
-    ((vl-string-search "DELTA" (strcase beschr))  "deltaweiche")
-    ((vl-string-search "STAR"  (strcase beschr))  "sternweiche")
-    (t "einzelweiche")
-  )
-)
-
-
-;; --- Merkmale-JSON fuer einen Bogen bauen ---
-(defun csv:omni-bogen-merkmale (ename rotation / winkel radius sivasnr hoehe drehung)
-  (setq winkel  (or (csv:get-attrib ename "WINKEL")  "0"))
-  (setq radius  (or (csv:get-attrib ename "RADIUS")  "0"))
-  (setq sivasnr (or (csv:get-attrib ename "ARTINR")  ""))
-  (setq hoehe   (or (csv:get-attrib ename "HOEHE")   (ssg-cfg-or "omniflo" "default_hoehe" "2000")))
-  (setq drehung (or (csv:get-attrib ename "DREHUNG") (rtos rotation 2 1)))
-  (strcat "{\"Kurvenwinkel\":" winkel
-          ",\"Radius\":" radius
-          ",\"H\\u00f6he\":\"" (csv:json-escape hoehe) "\""
-          ",\"Drehung\":" drehung
-          ",\"SivasNummer\":\"" (csv:json-escape sivasnr) "\"}")
-)
-
-
-;; --- Merkmale-JSON fuer eine Weiche bauen ---
-(defun csv:omni-weiche-merkmale (ename rotation / wtyp winkel sivasnr tef-str hoehe drehung)
-  (setq wtyp    (or (csv:get-attrib ename "WEICHENTYP") "Einzelweiche"))
-  (setq winkel  (or (csv:get-attrib ename "WINKEL")     "0"))
-  (setq sivasnr (or (csv:get-attrib ename "ARTINR")     ""))
-  (setq tef-str (csv:get-attrib ename "SIVASNR_TEF"))
-  (setq hoehe   (or (csv:get-attrib ename "HOEHE")      (ssg-cfg-or "omniflo" "default_hoehe" "2000")))
-  (setq drehung (or (csv:get-attrib ename "DREHUNG")    (rtos rotation 2 1)))
-  (strcat "{\"Weichentyp\":\"" (csv:json-escape wtyp) "\""
-          ",\"Richtung\":\"False\""
-          ",\"Weichenwinkel\":" winkel
-          ",\"H\\u00f6he\":\"" (csv:json-escape hoehe) "\""
-          ",\"Drehung\":" drehung
-          ",\"Antrieb Kurve\":" (if (and tef-str (> (strlen tef-str) 0)) "true" "false")
-          ",\"SivasNummer\":\"" (csv:json-escape sivasnr) "\"}")
-)
-
-
-;; --- Merkmale-JSON fuer eine Gerade bauen ---
-(defun csv:omni-gerade-merkmale (ename rotation / laenge hoehe drehung)
-  (setq laenge (csv:get-attrib ename "LAENGE"))
-  (if (null laenge) (setq laenge (csv:get-attrib ename "A")))
-  (if (null laenge) (setq laenge (ssg-cfg-or "omniflo" "default_gerade_laenge" "2000")))
-  (setq hoehe   (or (csv:get-attrib ename "HOEHE")   (ssg-cfg-or "omniflo" "default_hoehe" "2000")))
-  (setq drehung (or (csv:get-attrib ename "DREHUNG") (rtos rotation 2 1)))
-  (strcat "{\"Anzahl der Separatoren\":\"0\""
-          ",\"L\\u00e4nge in Meter\":\"" (csv:json-escape (rtos (/ (atof laenge) (ssg-cfg-or "infrastruktur" "mm_pro_meter" 1000.0)) 2 2)) "\""
-          ",\"Winkel\":\"0\""
-          ",\"Anzahl der Scanner\":0"
-          ",\"H\\u00f6he oben\":\"" (csv:json-escape hoehe) "\""
-          ",\"H\\u00f6he unten\":\"" (csv:json-escape hoehe) "\""
-          ",\"Drehung\":" drehung
-          ",\"SivasNummer\":\"\"}")
-)
-
-
-;; --- Omniflo Sum Zeile bauen ---
-(defun csv:omni-sum-zeile (elem-nr cnt-boegen cnt-wk cnt-einzel cnt-delta cnt-doppel cnt-stern len-ap110 len-ap60)
-  (strcat (itoa elem-nr)
-          ";\"Omniflo Sum\";\"autogenerated_of_json\";\"Omniflo sum\";1;"
-          "{\"Anzahl B\\u00f6gen\":" (itoa cnt-boegen)
-          ",\"Anzahl Weichengrundk\\u00f6rper\":" (itoa cnt-wk)
-          ",\"Anzahl Einwegweichen\":" (itoa cnt-einzel)
-          ",\"Anzahl Deltaweichen\":" (itoa cnt-delta)
-          ",\"Anzahl Doppelweichen und Dreiwegeweichen\":" (itoa cnt-doppel)
-          ",\"Anzahl Sternweichen\":" (itoa cnt-stern)
-          ",\"Gesamtl\\u00e4nge AP110\":" (rtos len-ap110 2 1)
-          ",\"Gesamtl\\u00e4nge AP60\":" (rtos len-ap60 2 1)
-          "}")
-)
-
-
-
-;; ============================================================
-;; C:OMNI_EXPORT - Omniflo-Elemente zaehlen und als CSV exportieren
-;; Rein LISP-basiert, kein Python noetig.
-;; ============================================================
-(defun c:OMNI_EXPORT ( / ss-all i ename ed bname rotation typ
-                         elem-nr cnt-boegen cnt-weichen cnt-geraden
-                         cnt-wk cnt-einzel cnt-delta cnt-doppel cnt-stern
-                         len-ap110 len-ap60 laenge-str
-                         fh out-pfad lines subtyp merkmale)
-
-  ;; Vor dem Export: IDs aller Bloecke sicherstellen und Duplikate korrigieren
-  (princ "\n[OMNI_EXPORT] Pruefe und vergebe IDs...")
-  (ssg-id-check-all)
-  ;; Vor dem Export HOEHE/DREHUNG aller Omniflo-Elemente aktualisieren
-  (princ "\n[OMNI_EXPORT] Aktualisiere Hoehe/Drehung...")
-  (omni:update-all-attribs)
-  (princ "\n[OMNI_EXPORT] Sammle Omniflo-Elemente...")
-  (setq ss-all (ssget "X" (list (cons 0 "INSERT"))))
-  (if (null ss-all)
-    (progn (princ "\n[OMNI_EXPORT] Keine INSERT-Bloecke in der Zeichnung.") (princ))
-    (progn
-      (setq elem-nr 0)
-      (setq cnt-boegen 0  cnt-weichen 0  cnt-geraden 0)
-      (setq cnt-wk 0  cnt-einzel 0  cnt-delta 0  cnt-doppel 0  cnt-stern 0)
-      (setq len-ap110 0.0  len-ap60 0.0)
-      (setq lines '())
-
-      (setq i 0)
-      (while (setq ename (ssname ss-all i))
-        (setq ed (entget ename))
-        (setq bname (cdr (assoc 2 ed)))
-        (setq rotation (cdr (assoc 50 ed)))
-        (if (null rotation) (setq rotation 0.0))
-        (setq rotation (* (/ rotation pi) 180.0))
-
-        (setq typ (csv:omni-classify ename bname))
-
-        (cond
-          ((= typ "bogen")
-           (setq elem-nr (1+ elem-nr))
-           (setq cnt-boegen (1+ cnt-boegen))
-           (setq merkmale (csv:omni-bogen-merkmale ename rotation))
-           (setq lines (cons
-             (strcat (itoa elem-nr)
-                     ";\"Omniflo Kurve\""
-                     ";\"" (or (csv:get-attrib ename "ID") "0000") "\""
-                     ";\"" (strcat "OFBogen :" (itoa cnt-boegen)) "\""
-                     ";1"
-                     ";" merkmale)
-             lines))
-          )
-
-          ((= typ "weiche")
-           (setq elem-nr (1+ elem-nr))
-           (setq cnt-weichen (1+ cnt-weichen))
-           (setq subtyp (csv:omni-weichensubtyp ename))
-           (cond
-             ((= subtyp "weichenkoerper")  (setq cnt-wk     (1+ cnt-wk)))
-             ((= subtyp "einzelweiche")    (setq cnt-einzel  (1+ cnt-einzel)))
-             ((= subtyp "deltaweiche")     (setq cnt-delta   (1+ cnt-delta)))
-             ((= subtyp "sternweiche")     (setq cnt-stern   (1+ cnt-stern)))
-             (t                            (setq cnt-doppel  (1+ cnt-doppel)))
-           )
-           (setq merkmale (csv:omni-weiche-merkmale ename rotation))
-           (setq lines (cons
-             (strcat (itoa elem-nr)
-                     ";\"Omniflo Weiche\""
-                     ";\"" (or (csv:get-attrib ename "ID") "0000") "\""
-                     ";\"" (strcat "OFWeiche :" (itoa cnt-weichen)) "\""
-                     ";1"
-                     ";" merkmale)
-             lines))
-          )
-
-          ((= typ "gerade")
-           (setq elem-nr (1+ elem-nr))
-           (setq cnt-geraden (1+ cnt-geraden))
-           (setq laenge-str (csv:get-attrib ename "LAENGE"))
-           (if (null laenge-str) (setq laenge-str (csv:get-attrib ename "A")))
-           (if (and laenge-str (> (strlen laenge-str) 0))
-             (setq len-ap110 (+ len-ap110 (atof laenge-str)))
-             (setq len-ap110 (+ len-ap110 (float (atoi (ssg-cfg-or "omniflo" "default_gerade_laenge" "2000")))))
-           )
-           (setq merkmale (csv:omni-gerade-merkmale ename rotation))
-           (setq lines (cons
-             (strcat (itoa elem-nr)
-                     ";\"Omniflo Gerade\""
-                     ";\"" (or (csv:get-attrib ename "ID") "0000") "\""
-                     ";\"" (strcat "OFGerade :" (itoa cnt-geraden)) "\""
-                     ";1"
-                     ";" merkmale)
-             lines))
-          )
-        )
-
-        (setq i (1+ i))
-      )
-
-      (princ (strcat "\n[OMNI_EXPORT] Gefunden: "
-                     (itoa cnt-boegen) " Boegen, "
-                     (itoa cnt-weichen) " Weichen, "
-                     (itoa cnt-geraden) " Geraden"))
-
-      (if (= elem-nr 0)
-        (princ "\n[OMNI_EXPORT] Keine Omniflo-Elemente gefunden.")
-        (progn
-          (setq out-pfad (strcat (getenv "DXFM_RESULTS") "/omniflo_export.csv"))
-          (setq fh (open out-pfad "w"))
-          (if (null fh)
-            (princ (strcat "\n[OMNI_EXPORT] FEHLER: Kann Datei nicht oeffnen: " out-pfad))
-            (progn
-              (write-line "Elementnummer;TeileArt;TeileId;Bezeichnung;Anzahl;Merkmale" fh)
-              (foreach ln (reverse lines)
-                (write-line ln fh)
-              )
-              (write-line
-                (csv:omni-sum-zeile (1+ elem-nr)
-                  cnt-boegen cnt-wk cnt-einzel cnt-delta cnt-doppel cnt-stern
-                  len-ap110 len-ap60)
-                fh)
-              (close fh)
-              (princ (strcat "\n[OMNI_EXPORT] CSV geschrieben: " out-pfad))
-              (princ (strcat "\n[OMNI_EXPORT] Omniflo Sum: "
-                             (itoa cnt-boegen) " Boegen, "
-                             (itoa (+ cnt-einzel cnt-doppel cnt-delta cnt-stern cnt-wk)) " Weichen, "
-                             (rtos len-ap110 2 0) " mm AP110"))
-            )
-          )
-        )
-      )
-    )
-  )
-  (princ)
-)
-
-
-;; ============================================================
-;; OMNIFLO HOEHE/DREHUNG AKTUALISIEREN
-;; ============================================================
-
 ;; --- Hoehe eines Omniflo-Blocks aus der Zeichnung ermitteln ---
 ;; Liest z-Koordinate des Einfuegepunkts.
 ;; Falls der Block KS_EIN, KS_AUS oder K1-K4 enthaelt,
@@ -512,7 +344,8 @@
         (if (= (cdr (assoc 0 sub-ed)) "INSERT")
           (progn
             (setq sub-bname (strcase (cdr (assoc 2 sub-ed))))
-            (if (wcmatch sub-bname "KS_EIN,KS_AUS,K1,K2,K3,K4")
+            (if (wcmatch sub-bname
+                  (export:pattern "pattern_ks_subblocks" "KS_EIN,KS_AUS,K1,K2,K3,K4"))
               (progn
                 (setq sub-pt (cdr (assoc 10 sub-ed)))
                 (setq z-list (cons (if (caddr sub-pt) (caddr sub-pt) 0.0) z-list))
@@ -566,7 +399,7 @@
 (defun c:OMNI_UPDATE_ATTRIBS ( / ss i ename ed bname teileart count)
   (setq ss (ssget "X" (list (cons 0 "INSERT"))))
   (if (null ss)
-    (princ "\n[OMNI_UPDATE] Keine INSERT-Bloecke in der Zeichnung.")
+    (princ (ssg-text "exp-omni-no-inserts"))
     (progn
       (setq count 0)
       (setq i 0)
@@ -576,7 +409,7 @@
         ;; Nur Omniflo-Elemente (erkennbar an TEILEART-Attribut oder AP110-Blockname)
         (setq teileart (csv:get-attrib ename "TEILEART"))
         (if (or teileart
-                (wcmatch (strcase bname) "AP110*,AP_110*"))
+                (wcmatch (strcase bname) (export:pattern "pattern_gerade" "AP110*,AP_110*")))
           (progn
             (omni:set-hoehe-attrib ename)
             (omni:set-drehung-attrib ename)
@@ -585,7 +418,7 @@
         )
         (setq i (1+ i))
       )
-      (princ (strcat "\n[OMNI_UPDATE] " (itoa count) " Elemente aktualisiert (HOEHE, DREHUNG)."))
+      (princ (ssg-textf "exp-omni-updated" (list count)))
     )
   )
   (princ)

Lisp/external_call.lsp

@@ -17,12 +17,12 @@
           (setq fh (open return-datei "r"))
           (setq zeile (read-line fh))
           (close fh)
-          (princ (strcat "\n[SSG_LIB] Python Rueckgabe: " zeile))
+          (princ (ssg-textf "extcall-python-rueckgabe" (list zeile)))
         )
-        (princ "\n[SSG_LIB] WARNUNG: Keine Rueckgabe von Python erhalten.")
+        (princ (ssg-text "extcall-keine-rueckgabe"))
       )
     )
-    (princ (strcat "\n[SSG_LIB] FEHLER: " py-skript " nicht gefunden!"))
+    (princ (ssg-textf "extcall-skript-nicht-gefunden" (list py-skript)))
   )
   (princ)
 )

Lisp/ssg_core.lsp

@@ -35,7 +35,7 @@
   (setvar "CMDECHO" 0)
   (command "_undo" "_G")
   (graphscr)
-  (if titel (prompt (strcat "\n***** " titel " *****\n")))
+  (if titel (prompt (ssg-textf "core-start-titel" (list titel))))
   (princ)
 )
 
@@ -65,7 +65,7 @@
 (defun ssg-errhan (em)
   (if (= em "Function cancelled")
     (princ)
-    (progn (princ "\nFehler: ") (princ em))
+    (progn (princ (ssg-text "core-errhan-fehler")) (princ em))
   )
   (command)
   (command)
@@ -85,11 +85,11 @@
   (if defa
     (progn
       (initget 1 "Yes No  Yes")
-      (= (getkword (strcat "\n" prompt-text " Y/N <Y>: ")) "No")
+      (= (getkword (strcat "\n" prompt-text (ssg-text "ques-yn-default-yes"))) "No")
     )
     (progn
       (initget 1 "Yes No  No")
-      (= (getkword (strcat "\n" prompt-text " Y/N <N>: ")) "Yes")
+      (= (getkword (strcat "\n" prompt-text (ssg-text "ques-yn-default-no"))) "Yes")
     )
   )
 )
@@ -126,12 +126,17 @@
   )
 )
 
-;; Layer anlegen (falls nicht vorhanden) und optional setzen
+;; Layer anlegen (falls nicht vorhanden) und optional aktivieren
 ;; lay-name = Name; color = Farbnummer als String z.B. "2"; set-aktiv = T/nil
-(defun ssg-make-layer (lay-name color set-aktiv)
+;; Farbe wird nur bei Neuanlage gesetzt, bestehende Layer bleiben unveraendert
+(defun ssg-make-layer (lay-name color set-aktiv / neu)
+  (setq neu (not (tblsearch "LAYER" lay-name)))
   (if set-aktiv
-    (command "_LAYER" "_M" lay-name "_CO" color lay-name "")
+    (command "_LAYER" "_M" lay-name "")
-    (command "_LAYER" "_N" lay-name "_CO" color lay-name "")
+    (command "_LAYER" "_N" lay-name "")
+  )
+  (if neu
+    (command "_LAYER" "_CO" color lay-name "")
   )
 )
 
@@ -225,7 +230,7 @@
       (command "_insert" bname pt "" "" rotation)
     )
     (progn
-      (alert (strcat "Blockname '" bname "' existiert bereits - wird uebersprungen."))
+      (alert (ssg-textf "core-blockname-exists" (list bname)))
       (setq bname (strcat "x" bname))
       (command "_block" bname pt ss "")
       (command "_insert" bname pt "" "" rotation)
@@ -370,7 +375,7 @@
           (progn
             (setq tag (cdr (assoc 2 ed)))
             (setq wert (cdr (assoc tag attrib-alist)))
-            (if (and wert (> (strlen wert) 0))
+            (if (and wert (= (type wert) 'STR) (> (strlen wert) 0))
               (progn
                 (entmod (subst (cons 1 wert) (assoc 1 ed) ed))
                 (entupd obj)
@@ -384,6 +389,66 @@
   )
 )
 
+;; ============================================================
+;; GEMEINSAMES ATTRIBUT-SCHEMA FUER STRECKEN-BLOECKE
+;; (Gefaellestrecke + VarioFoerderer, feste Reihenfolge)
+;; ============================================================
+;; Vorderteil (immer vorhanden). Bezeichnung = Blockname (GF_n/VF_n),
+;; Artinr. fest 6220 (alle GF/VF). TYP-Wert wird zur Laufzeit gesetzt.
+;; ID zuerst (global, jeder eingefuegte Baustein - Kreisel/GF/VF - erhaelt eine
+;; neue ID), danach Bezeichnung (= Blockname). Hoehen/Delta mit Einheit _mm.
+(setq *strecke-attr-front*
+  '(("ID"                   "")
+    ("Bezeichnung"          "")
+    ("Artinr."              "6220")
+    ("MONTAGEHOEHE_m"       "0.000")
+    ("HOEHE_VON_mm"         "0")
+    ("HOEHE_BIS_mm"         "0")
+    ("DELTA_H_mm"           "0")
+    ("DELTA_L_mm"           "0")
+    ("TYP"                  "Streckengruppe")
+    ("SEITE_AS"             "rechts")
+    ("SEITE_ES"             "rechts")
+    ("ANZAHL_GF"            "0")
+    ("L_GF_m"               "0.000")
+    ("GF_WINKEL"            "0.0")))
+
+;; Mittelteil - nur fuer TYP "Streckengruppe" (mehrsegmentig/mit Bogen bzw. VF).
+;; Eine einsegmentige Gefaellestrecke ohne Bogen ("Gefaellestrecke") bekommt
+;; diese Attribute NICHT.
+(setq *strecke-attr-gruppe*
+  '(("GF_Bogen_L_90"        "0")
+    ("GF_Bogen_L_60"        "0")
+    ("GF_Bogen_L_30"        "0")
+    ("GF_Bogen_R_90"        "0")
+    ("GF_Bogen_R_60"        "0")
+    ("GF_Bogen_R_30"        "0")
+    ("ANZAHL_VF"            "0")
+    ("MOTORSEITE"           "")
+    ("L_VF_m"               "0.000")
+    ("ANTRIEBFAHRTRICHTUNG" "Auf")
+    ("VF_WINKEL"            "0")
+    ("VF_Bogen_A_90"        "0")
+    ("VF_Bogen_A_60"        "0")
+    ("VF_Bogen_A_30"        "0")
+    ("VF_Bogen_I_90"        "0")
+    ("VF_Bogen_I_60"        "0")
+    ("VF_Bogen_I_30"        "0")))
+
+;; Hinterteil (immer vorhanden). ANZAHL_SEPARATOR-Wert wird zur Laufzeit gesetzt
+;; (einsegmentige Gefaellestrecke: 1; Streckengruppe: gezaehlt).
+(setq *strecke-attr-hinten*
+  '(("ANZAHL_SEPARATOR"     "1")
+    ("ANZAHL_SCANNER"       "0")))
+
+;; Geordnete ATTDEF-Definitionsliste fuer einen Strecken-Block-Typ.
+;;   typ "Gefaellestrecke" -> Vorderteil + Hinterteil (reduziert)
+;;   sonst ("Streckengruppe") -> Vorderteil + Mittelteil + Hinterteil (voll)
+(defun ssg-strecke-attrib-defs (typ)
+  (if (= typ "Gefaellestrecke")
+    (append *strecke-attr-front* *strecke-attr-hinten*)
+    (append *strecke-attr-front* *strecke-attr-gruppe* *strecke-attr-hinten*)))
+
 ;; Assoziationsliste in ATTDEF-Definitionsliste konvertieren.
 ;; alist = (("TAG" . "Wert") ...) -> ((TAG Wert) ...)
 ;; Passend fuer ssg-attrib-make-defs.
@@ -400,7 +465,7 @@
 (defun ssg-attrib-read-dwg (dwg-pfad / tmpEnt srcAttribs oldAttreq oldAttdia)
   (if (not (findfile dwg-pfad))
     (progn
-      (princ (strcat "\nFEHLER: Block nicht gefunden: " dwg-pfad))
+      (princ (ssg-textf "core-dwg-not-found" (list dwg-pfad)))
       nil
     )
     (progn
@@ -476,8 +541,8 @@
   (if (not (new_dialog dialog-name dat))
     (progn (alert "Dialog konnte nicht geladen werden.") (exit))
   )
-  (if init-fn (init-fn))
+  (if init-fn (apply init-fn nil))
-  (action_tile "accept" "(if accept-fn (accept-fn)) (done_dialog 1)")
+  (action_tile "accept" "(if accept-fn (apply accept-fn nil)) (done_dialog 1)")
   (action_tile "cancel" "(done_dialog 0)")
   (start_dialog)
   (unload_dialog dat)
@@ -673,6 +738,17 @@
       ((and (not in-section) (= trimmed "{")) nil)
       ((and (not in-section) (= trimmed "}")) nil)
 
+      ;; Leere Section auf einer Zeile: "name": {}
+      ;; (Section-Start und -Ende zugleich - json.dump schreibt leere
+      ;; Objekte immer inline, unabhaengig von der Einrueckung.)
+      ((and (not in-inner)
+            (>= (strlen trimmed) 2)
+            (= (substr trimmed (1- (strlen trimmed)) 2) "{}"))
+        (setq section (substr trimmed 2
+          (1- (vl-string-search "\"" trimmed 1))))
+        (setq ergebnis (cons (cons section nil) ergebnis))
+      )
+
       ;; Section-Start: "name": {
       ((and (not in-inner) (vl-string-search ": {" trimmed))
         (setq kv (ssg-cfg-parse-kv
@@ -750,5 +826,85 @@
 )
 
 
+;; ============================================================
+;; INI-STYLE CONFIG-PARSER (Standard fuer alle cfg/*.cfg-Dateien)
+;;
+;; Format:
+;;   [Abschnitt]
+;;   Key = Wert                 (einzelner Wert)
+;;   Key = Wert1, Wert2, Wert3  (kommagetrennte Liste, z.B. fuer wcmatch)
+;;   # Kommentar / Leerzeile werden ignoriert
+;;
+;; Verwendung:
+;;   (setq cfg (ssg-load-ini pfad))
+;;   (ssg-ini-get  cfg "sektion" "key" "default")
+;;   (ssg-ini-list cfg "sektion" "key" "a,b,c")   ; normalisiert zu "a,b,c" (wcmatch-tauglich)
+;; ============================================================
+
+;; Zeilen einer .cfg-Datei in verschachtelte Alist parsen.
+;; Rueckgabe: (("sektion" ("key" . "wert") ...) ...)
+(defun ssg-ini-parse-lines (zeilen / ergebnis section sec-data trimmed pos key val)
+  (setq ergebnis nil  section nil  sec-data nil)
+  (foreach zeile zeilen
+    (setq trimmed (vl-string-trim " \t\r\n" zeile))
+    (cond
+      ;; Leerzeile oder Kommentar
+      ((or (= trimmed "") (= (substr trimmed 1 1) "#")) nil)
+      ;; Abschnitt: [name]
+      ((and (= (substr trimmed 1 1) "[")
+            (= (substr trimmed (strlen trimmed) 1) "]"))
+        (if section
+          (setq ergebnis (cons (cons section (reverse sec-data)) ergebnis)))
+        (setq section (substr trimmed 2 (- (strlen trimmed) 2)))
+        (setq sec-data nil)
+      )
+      ;; Key=Wert
+      ((and section (setq pos (vl-string-search "=" trimmed)))
+        (setq key (vl-string-trim " \t" (substr trimmed 1 pos)))
+        (setq val (vl-string-trim " \t" (substr trimmed (+ pos 2))))
+        (setq sec-data (cons (cons key val) sec-data))
+      )
+    )
+  )
+  (if section
+    (setq ergebnis (cons (cons section (reverse sec-data)) ergebnis)))
+  (reverse ergebnis)
+)
+
+;; .cfg-Datei laden und als verschachtelte Alist zurueckgeben, oder nil.
+(defun ssg-load-ini (cfg-datei / zeilen)
+  (setq zeilen (ssg-read-file-lines cfg-datei))
+  (if zeilen (ssg-ini-parse-lines zeilen))
+)
+
+;; Einzelwert aus geladener INI-Alist lesen, mit Fallback.
+;; ini-data = Rueckgabe von ssg-load-ini
+(defun ssg-ini-get (ini-data section key default / sec-data val)
+  (setq sec-data (cdr (assoc section ini-data)))
+  (setq val (if sec-data (cdr (assoc key sec-data))))
+  (if (and val (> (strlen val) 0)) val default)
+)
+
+;; Kommagetrennten Wert aus geladener INI-Alist lesen und normalisieren
+;; (Leerzeichen um Kommas entfernen, leere Teile verwerfen).
+;; default-str = Fallback als kommagetrennter String, falls Config/Key fehlt.
+;; Rueckgabe: kommagetrennter String, z.B. "KR_*,KREISEL_*" (wcmatch-tauglich)
+(defun ssg-ini-list (ini-data section key default-str / raw teile ergebnis item first)
+  (setq raw (ssg-ini-get ini-data section key default-str))
+  (setq teile (ssg-cfg-split-comma raw))
+  (setq ergebnis ""  first T)
+  (foreach item teile
+    (setq item (vl-string-trim " \t" item))
+    (if (> (strlen item) 0)
+      (progn
+        (setq ergebnis (if first item (strcat ergebnis "," item)))
+        (setq first nil)
+      )
+    )
+  )
+  ergebnis
+)
+
+
 (prompt "\nssg_core.lsp geladen.")
 (princ)

Lisp/ssg_dialog.lsp

@@ -67,7 +67,7 @@
         aktuell start-val
   )
   (if (not (new_dialog dialog-id dat))
-    (progn (alert "Dialog nicht verfuegbar.") (exit))
+    (progn (alert (ssg-text "dialog-nicht-verfuegbar")) (exit))
   )
   (set_tile select-tile start-val)
   (if (and preview-tile slide-lib slide-list)
@@ -116,7 +116,7 @@
 ;; ------------------------------------------------------------
 (defun ssg-insert-modul (lay-name lay-color blk-pfad attrib-alist rotation / pt)
   (ssg-make-layer lay-name lay-color T)
-  (setq pt (getpoint "\nEinfuegepunkt waehlen: "))
+  (setq pt (getpoint (ssg-text "dialog-einfuegepunkt-waehlen")))
   (command "_insert" blk-pfad pt "" "" rotation)
   (if attrib-alist
     (ssg-attrib-set-many attrib-alist)

Lisp/ssg_id.lsp

@@ -42,7 +42,7 @@
         (if (or
               (wcmatch bname "KR_*,KREISEL_*,ECKRAD_*")
               (wcmatch (strcase bname) "AP110*,AP_110*,AP60*,AP_60*,APG110*")
-              (wcmatch bname "Vario*,Staustrecke*,AUS_Element*,EIN_Element*")
+              (wcmatch bname "Vario*,Staustrecke*,AUS_Element*,EIN_Element*,VF_*,GF_*")
               (wcmatch bname "#*")
             )
           (ssadd ename ss-out)
@@ -93,11 +93,11 @@
       (setq new-id (1+ max-id))
       (setq new-id-str (ssg-id-format new-id))
       (ssg-attrib-set-on ent (list (cons "ID" new-id-str)))
-      (princ (strcat "\n[ID] Neue ID zugewiesen: " new-id-str))
+      (princ (ssg-textf "id-new-assigned" (list new-id-str)))
       new-id-str
     )
     (progn
-      (princ "\n[ID] FEHLER: Kein gueltiger INSERT-Block!")
+      (princ (ssg-text "id-invalid-block"))
       nil
     )
   )
@@ -113,7 +113,7 @@
   (setq ss (ssg-id-collect-blocks))
   (if (null ss)
     (progn
-      (princ "\n[IDSCHECK] Keine relevanten Bloecke gefunden.")
+      (princ (ssg-text "id-check-no-blocks"))
       0
     )
     (progn
@@ -141,8 +141,8 @@
             (setq max-id (1+ max-id))
             (setq new-id-str (ssg-id-format max-id))
             (ssg-attrib-set-on ename (list (cons "ID" new-id-str)))
-            (princ (strcat "\n[IDSCHECK] Fehlende ID gesetzt: " new-id-str
+            (princ (ssg-textf "id-check-missing-set"
-                           " (Block " (cdr (assoc 2 (entget ename))) ")"))
+                     (list new-id-str (cdr (assoc 2 (entget ename))))))
           )
         )
         (setq i (1+ i))
@@ -158,16 +158,16 @@
               (setq max-id (1+ max-id))
               (setq new-id-str (ssg-id-format max-id))
               (ssg-attrib-set-on ename (list (cons "ID" new-id-str)))
-              (princ (strcat "\n[IDSCHECK] Duplikat ID " (ssg-id-format (car entry))
+              (princ (ssg-textf "id-check-duplicate"
-                             " -> neue ID " new-id-str
+                       (list (ssg-id-format (car entry)) new-id-str
-                             " (Block " (cdr (assoc 2 (entget ename))) ")"))
+                             (cdr (assoc 2 (entget ename))))))
               (setq fixed-count (1+ fixed-count))
             )
           )
         )
       )
 
-      (princ (strcat "\n[IDSCHECK] Fertig. " (itoa fixed-count) " Duplikate korrigiert."))
+      (princ (ssg-textf "id-check-done" (list fixed-count)))
       fixed-count
     )
   )
@@ -179,7 +179,7 @@
 (defun c:IDSCHECK ( / count)
   (ssg-start "IDSCHECK" nil)
   (setq count (ssg-id-check-all))
-  (princ (strcat "\n[IDSCHECK] " (itoa count) " IDs korrigiert."))
+  (princ (ssg-textf "id-check-corrected" (list count)))
   (ssg-end)
   (princ)
 )
@@ -188,10 +188,10 @@
 ;; Fordert den Benutzer auf, einen Block zu waehlen und weist eine neue ID zu.
 (defun c:IDGENERATE ( / ent ed)
   (ssg-start "IDGENERATE" nil)
-  (setq ent (car (entsel "\nBlock waehlen: ")))
+  (setq ent (car (entsel (ssg-text "id-select-block-prompt"))))
   (if (and ent (= (cdr (assoc 0 (entget ent))) "INSERT"))
     (ssg-id-generate ent)
-    (princ "\n[IDGENERATE] Kein gueltiger Block gewaehlt.")
+    (princ (ssg-text "id-generate-invalid"))
   )
   (ssg-end)
   (princ)

Lisp/ssg_lang.lsp

@@ -0,0 +1,148 @@
+;; ============================================================
+;; SSG_LANG.LSP - Sprachumschaltung (Deutsch/Englisch)
+;; Zentrale Textverwaltung fuer benutzersichtbare Meldungen.
+;; Kern-Modul, wird direkt nach ssg_core geladen.
+;;
+;; Die Texte liegen extern in lang/de_DE.json und lang/en_GB.json.
+;; Diese Datei ist reiner Lade-/Zugriffscode. Beim Laden wird
+;; *ssg-texts* aus den JSON-Dateien befuellt - Format wie bisher:
+;;   (key (cons "de_DE" wert) (cons "en_GB" wert))
+;; Die JSON-Dateien werden aus Lisp/ssg_lang.lsp einmalig per
+;; tools/migrate_lang_to_json.py erzeugt und danach direkt gepflegt.
+;; ============================================================
+
+
+;; ------------------------------------------------------------
+;; Alle Vorkommen von alt in str durch neu ersetzen.
+;; Frueh definiert, da ssg-lang-unescape es beim Laden braucht.
+;; ------------------------------------------------------------
+(defun ssg-str-replace-all (neu alt str / pos ergebnis)
+  (setq ergebnis "")
+  (while (setq pos (vl-string-search alt str))
+    (setq ergebnis (strcat ergebnis (substr str 1 pos) neu))
+    (setq str (substr str (+ pos 1 (strlen alt))))
+  )
+  (strcat ergebnis str)
+)
+
+;; ------------------------------------------------------------
+;; Sprachordner ermitteln: 1) DXFMAKRO env, 2) *ssg-lisp-pfad*, 3) nil.
+;; Gleiches Fallback-Muster wie in Gefaellestrecke.lsp/KreiselInsert.lsp.
+;; DXFM_LANG bleibt der Sprachcode und wird hier NICHT als Pfad genutzt.
+;; ------------------------------------------------------------
+(defun ssg-lang-dir ( / )
+  (cond
+    ((and (getenv "DXFMAKRO") (= (type (getenv "DXFMAKRO")) 'STR)
+          (> (strlen (getenv "DXFMAKRO")) 0))
+     (strcat (vl-string-right-trim "/" (vl-string-translate "\\" "/" (getenv "DXFMAKRO")))
+             "/lang"))
+    ((and (boundp '*ssg-lisp-pfad*) (= (type *ssg-lisp-pfad*) 'STR)
+          (vl-string-search "/Lisp" *ssg-lisp-pfad*))
+     (strcat (substr *ssg-lisp-pfad* 1 (vl-string-search "/Lisp" *ssg-lisp-pfad*))
+             "/lang"))
+    (t nil)
+  )
+)
+
+;; ------------------------------------------------------------
+;; Escapes aus einem JSON-Rohwert aufloesen: \n -> Zeilenumbruch.
+;; Der JSON-Parser (ssg-cfg-parse-nested) liefert \n als literale
+;; 2-Zeichen-Folge (Backslash + n) zurueck; hier wird sie in einen
+;; echten Zeilenumbruch gewandelt. Suchmuster ist "\\n" (= die zwei
+;; Zeichen Backslash+n); "\n" waere bereits ein Zeilenumbruch.
+;; Andere Escapes kommen in den Sprachdateien nicht vor.
+;; ------------------------------------------------------------
+(defun ssg-lang-unescape (wert)
+  (if wert
+    (ssg-str-replace-all (chr 10) "\\n" wert)
+  )
+)
+
+;; ------------------------------------------------------------
+;; Beide Sprachdateien laden und *ssg-texts* im bisherigen Format
+;; befuellen: (key (cons "de_DE" ...) (cons "en_GB" ...)).
+;; Fehlt eine Datei oder ein Key, bleibt der jeweilige Wert nil -
+;; die Fallback-Kette in ssg-text greift dann automatisch
+;; (en_GB -> de_DE -> Key). BricsCAD startet in jedem Fall.
+;; ------------------------------------------------------------
+(defun ssg-lang-load ( / dir de-datei en-datei de-sec en-sec
+                         key wert-de wert-en ergebnis)
+  (setq *ssg-texts* nil)
+  (setq dir (ssg-lang-dir))
+  (if (null dir)
+    (princ "\n[LANG] WARNUNG: Sprachordner nicht ermittelbar (DXFMAKRO nicht gesetzt).")
+    (progn
+      (setq de-datei (strcat dir "/de_DE.json")
+            en-datei (strcat dir "/en_GB.json"))
+      (if (findfile de-datei)
+        (setq de-sec (cdr (assoc "texts"
+                       (ssg-cfg-parse-nested (ssg-read-file-lines de-datei)))))
+        (princ (strcat "\n[LANG] WARNUNG: " de-datei " nicht gefunden."))
+      )
+      (if (findfile en-datei)
+        (setq en-sec (cdr (assoc "texts"
+                       (ssg-cfg-parse-nested (ssg-read-file-lines en-datei)))))
+        (princ (strcat "\n[LANG] WARNUNG: " en-datei " nicht gefunden."))
+      )
+      (foreach paar de-sec
+        (setq key     (car paar)
+              wert-de (ssg-lang-unescape (cdr paar))
+              wert-en (ssg-lang-unescape (cdr (assoc key en-sec))))
+        (setq ergebnis
+          (cons (list key (cons "de_DE" wert-de) (cons "en_GB" wert-en)) ergebnis))
+      )
+      (setq *ssg-texts* (reverse ergebnis))
+      (princ (strcat "\n[LANG] " (itoa (length *ssg-texts*)) " Texte geladen."))
+    )
+  )
+  (princ)
+)
+
+
+;; ------------------------------------------------------------
+;; AKTUELLE SPRACHE
+;; Default de_DE, Init aus DXFM_LANG. Ein erneutes Laden dieses
+;; Moduls ueberschreibt eine zur Laufzeit gesetzte Sprache nicht.
+;; ------------------------------------------------------------
+(if (null *ssg-lang*)
+  (setq *ssg-lang* (getenv "DXFM_LANG"))
+)
+(if (or (null *ssg-lang*) (= *ssg-lang* ""))
+  (setq *ssg-lang* "de_DE")
+)
+
+;; Texttabelle aus den JSON-Sprachdateien befuellen
+(ssg-lang-load)
+
+
+;; ------------------------------------------------------------
+;; ssg-text - Text zu einem Key in der aktuellen Sprache liefern
+;; Fallback-Kette: *ssg-lang* -> de_DE -> Key selbst
+;; ------------------------------------------------------------
+(defun ssg-text (key / eintrag wert)
+  (setq eintrag (assoc key *ssg-texts*))
+  (if eintrag
+    (progn
+      (setq wert (cdr (assoc *ssg-lang* (cdr eintrag))))
+      (if (null wert)
+        (setq wert (cdr (assoc "de_DE" (cdr eintrag))))
+      )
+      (if (null wert) key wert)
+    )
+    key
+  )
+)
+
+;; ssg-textf - Text mit Platzhaltern %1 %2 ... aus einer Werteliste fuellen
+(defun ssg-textf (key werte / txt i platzhalter)
+  (setq txt (ssg-text key))
+  (setq i 1)
+  (foreach w werte
+    (setq platzhalter (strcat "%" (itoa i)))
+    (setq txt (ssg-str-replace-all (vl-princ-to-string w) platzhalter txt))
+    (setq i (1+ i))
+  )
+  txt
+)
+
+(princ)

Lisp/ssg_layer.lsp

@@ -75,12 +75,12 @@
 ;; Rueckgabe: neuer Layername oder nil bei Abbruch
 (defun c:SSG-LayerSet (/ sel lay)
   (ssg-start "Layer setzen" nil)
-  (if (setq lay (ssg-get-layer "\nObjekt auf dem Ziel-Layer waehlen: "))
+  (if (setq lay (ssg-get-layer (ssg-text "layer-prompt-ziel-layer")))
     (progn
       (command "_LAYER" "_SET" lay "")
-      (prompt (strcat "\nAktiver Layer: " lay))
+      (prompt (ssg-textf "layer-aktiver-layer" (list lay)))
     )
-    (ssg-emsg "Kein Objekt gewaehlt.")
+    (ssg-emsg (ssg-text "layer-err-kein-objekt"))
   )
   (ssg-end)
   lay
@@ -89,9 +89,9 @@
 ;; Layer eines Objektes anzeigen
 (defun c:SSG-LayerInfo (/ sel lay)
   (ssg-start "Layer-Info" nil)
-  (if (setq lay (ssg-get-layer "\nObjekt waehlen: "))
+  (if (setq lay (ssg-get-layer (ssg-text "layer-prompt-objekt")))
-    (prompt (strcat "\nObjekt liegt auf Layer: " lay))
+    (prompt (ssg-textf "layer-objekt-auf-layer" (list lay)))
-    (ssg-emsg "Kein Objekt gewaehlt.")
+    (ssg-emsg (ssg-text "layer-err-kein-objekt"))
   )
   (ssg-end)
   lay
@@ -101,11 +101,11 @@
 (defun c:SSG-LayerMove (/ elem ziel-lay)
   (ssg-start "Layer wechseln" nil)
   (if (setq elem (ssget))
-    (if (setq ziel-lay (ssg-get-layer "\nObjekt auf dem Ziel-Layer waehlen: "))
+    (if (setq ziel-lay (ssg-get-layer (ssg-text "layer-prompt-ziel-layer")))
       (command "_CHANGE" elem "" "_PROP" "_LA" ziel-lay "")
-      (ssg-emsg "Kein Ziel-Layer gewaehlt.")
+      (ssg-emsg (ssg-text "layer-err-kein-ziel-layer"))
     )
-    (ssg-emsg "Kein Objekt gewaehlt.")
+    (ssg-emsg (ssg-text "layer-err-kein-objekt"))
   )
   (ssg-end)
 )
@@ -114,11 +114,11 @@
 (defun c:SSG-LayerCopy (/ elem ziel-lay)
   (ssg-start "Layer-Kopie" nil)
   (if (setq elem (ssget))
-    (if (setq ziel-lay (ssg-get-layer "\nObjekt auf dem Ziel-Layer waehlen: "))
+    (if (setq ziel-lay (ssg-get-layer (ssg-text "layer-prompt-ziel-layer")))
       (command "_COPY" elem "" "@" "@" "_CHANGE" elem "" "_PROP" "_LA" ziel-lay "")
-      (ssg-emsg "Kein Ziel-Layer gewaehlt.")
+      (ssg-emsg (ssg-text "layer-err-kein-ziel-layer"))
     )
-    (ssg-emsg "Kein Objekt gewaehlt.")
+    (ssg-emsg (ssg-text "layer-err-kein-objekt"))
   )
   (ssg-end)
 )
@@ -127,34 +127,34 @@
 ;; (nach Auswahl eines Referenz-Objektes dieses Typs)
 (defun c:SSG-LayerMoveType (/ ref-lay ref-typ elem ziel-lay ss ref-sel)
   (ssg-start "Layer-Typ verschieben" nil)
-  (if (setq ref-lay (ssg-get-layer "\nReferenz-Objekt waehlen (bestimmt Typ und Layer): "))
+  (if (setq ref-lay (ssg-get-layer (ssg-text "layer-prompt-referenz-objekt")))
     (progn
-      (setq ref-sel (entsel "\nNochmals fuer Typ-Ermittlung anklicken: "))
+      (setq ref-sel (entsel (ssg-text "layer-prompt-typ-ermittlung")))
       (if ref-sel
         (progn
           (setq ref-typ (cdr (assoc 0 (entget (car ref-sel))))
                 ss      (ssg-layer-ss ref-lay ref-typ)
           )
           (if ss
-            (if (setq ziel-lay (ssg-get-layer "\nObjekt auf dem Ziel-Layer waehlen: "))
+            (if (setq ziel-lay (ssg-get-layer (ssg-text "layer-prompt-ziel-layer")))
               (progn
                 (ssg-zoom-save)
                 (ssg-ss-redraw ss 3)
-                (if (not (ssg-ques (strcat "Layer dieser " ref-typ "-Objekte wechseln?") nil))
+                (if (not (ssg-ques (ssg-textf "layer-ques-typ-wechseln" (list ref-typ)) nil))
                   (command "_CHANGE" ss "" "_PROP" "_LA" ziel-lay "")
                   (ssg-ss-redraw ss 4)
                 )
                 (ssg-zoom-restore)
               )
-              (ssg-emsg "Kein Ziel-Layer.")
+              (ssg-emsg (ssg-text "layer-err-kein-ziel-layer-kurz"))
             )
-            (ssg-emsg "Keine passenden Objekte gefunden.")
+            (ssg-emsg (ssg-text "layer-err-keine-passenden-objekte"))
           )
         )
-        (ssg-emsg "Abgebrochen.")
+        (ssg-emsg (ssg-text "layer-abgebrochen"))
       )
     )
-    (ssg-emsg "Kein Referenz-Objekt gewaehlt.")
+    (ssg-emsg (ssg-text "layer-err-kein-referenz-objekt"))
   )
   (ssg-end)
 )
@@ -167,10 +167,10 @@
 ;; Layer durch Anklicken ausschalten
 (defun c:SSG-LayerOff (/ lay)
   (ssg-start "Layer ausschalten" nil)
-  (while (setq lay (ssg-get-layer "\nLayer zum Ausblenden anklicken (Enter=Ende): "))
+  (while (setq lay (ssg-get-layer (ssg-text "layer-prompt-ausblenden")))
     (if (ssg-layer-safe-p lay nil)
       (command "_LAYER" "_OFF" lay "")
-      (ssg-emsg "Aktiven Layer nicht ausschalten!")
+      (ssg-emsg (ssg-text "layer-err-aktiv-nicht-ausschalten"))
     )
   )
   (ssg-end)
@@ -179,10 +179,10 @@
 ;; Layer durch Anklicken einfrieren
 (defun c:SSG-LayerFreeze (/ lay)
   (ssg-start "Layer einfrieren" nil)
-  (while (setq lay (ssg-get-layer "\nLayer zum Einfrieren anklicken (Enter=Ende): "))
+  (while (setq lay (ssg-get-layer (ssg-text "layer-prompt-einfrieren")))
     (if (ssg-layer-safe-p lay nil)
       (command "_LAYER" "_FR" lay "")
-      (ssg-emsg "Aktiven Layer nicht einfrieren!")
+      (ssg-emsg (ssg-text "layer-err-aktiv-nicht-einfrieren"))
     )
   )
   (ssg-end)
@@ -191,13 +191,13 @@
 ;; Alle Layer ausser dem aktiven einfrieren
 (defun c:SSG-FreezeAll (/ aktiv)
   (ssg-start "Alle anderen Layer einfrieren" nil)
-  (setq aktiv (ssg-get-layer "\nObjekt auf dem Layer waehlen, der AKTIV bleibt: "))
+  (setq aktiv (ssg-get-layer (ssg-text "layer-prompt-aktiv-bleibt")))
   (if aktiv
     (progn
       (command "_LAYER" "_SET" aktiv "_FR" "*" "")
-      (prompt (strcat "\nNur Layer '" aktiv "' ist sichtbar."))
+      (prompt (ssg-textf "layer-nur-layer-sichtbar" (list aktiv)))
     )
-    (ssg-emsg "Abgebrochen.")
+    (ssg-emsg (ssg-text "layer-abgebrochen"))
   )
   (ssg-end)
 )
@@ -278,34 +278,34 @@
 (defun c:SSG-LayerDelete (/ lay ss)
   (ssg-start "Layer loeschen" nil)
   (initget 1)
-  (setq lay (getstring "\nLayername zum Loeschen: "))
+  (setq lay (getstring (ssg-text "layer-prompt-name-loeschen")))
   (if (tblsearch "LAYER" lay)
     (progn
       (setq ss (ssg-layer-ss lay nil))
       (if ss
         (progn
           (ssg-ss-redraw ss 4)
-          (if (not (ssg-ques (strcat "Alle Objekte auf Layer '" lay "' loeschen?") nil))
+          (if (not (ssg-ques (ssg-textf "layer-ques-alle-loeschen" (list lay)) nil))
             (progn
               (command "_ERASE" ss "")
               (command "_LAYER" "_OFF" lay "")
               (command "_PURGE" "_LA" lay "N")
-              (prompt (strcat "\nLayer '" lay "' geloescht."))
+              (prompt (ssg-textf "layer-geloescht" (list lay)))
             )
             (progn
               (ssg-ss-redraw ss 0)
-              (prompt "\nAbgebrochen.")
+              (prompt (strcat "\n" (ssg-text "layer-abgebrochen")))
             )
           )
         )
         (progn
           (command "_LAYER" "_OFF" lay "")
           (command "_PURGE" "_LA" lay "N")
-          (prompt (strcat "\nLeerer Layer '" lay "' geloescht."))
+          (prompt (ssg-textf "layer-leerer-geloescht" (list lay)))
         )
       )
     )
-    (ssg-emsg (strcat "Layer '" lay "' existiert nicht."))
+    (ssg-emsg (ssg-textf "layer-existiert-nicht" (list lay)))
   )
   (ssg-end)
 )

Lisp/ssg_load.lsp

@@ -24,6 +24,7 @@
   )
   (load (strcat base-path "ssg_core.lsp")   "ssg_core.lsp nicht gefunden")
   (ssg-load-config)
+  (load (strcat base-path "ssg_lang.lsp")   "ssg_lang.lsp nicht gefunden")
   (load (strcat base-path "ssg_dbg.lsp")    "ssg_dbg.lsp nicht gefunden")
   (load (strcat base-path "ssg_dialog.lsp") "ssg_dialog.lsp nicht gefunden")
   (load (strcat base-path "ssg_layer.lsp")  "ssg_layer.lsp nicht gefunden")
@@ -34,7 +35,7 @@
   (load (strcat base-path "tests.lsp")            "tests.lsp nicht gefunden")
   (load (strcat base-path "OmniModulInsert.lsp")  "OmniModulInsert.lsp nicht gefunden")
   (load (strcat base-path "SSG_LIB_Commands.lsp")  "SSG_LIB_Commands.lsp nicht gefunden")
-  (prompt "\nSSG-Bibliotheken geladen: ssg_core, ssg_dbg, ssg_dialog, ssg_layer, KreiselInsert, VarioFoerderer, Gefaellestrecke, export, tests, OmniModulInsert, SSG_LIB_Commands")
+  (prompt "\nSSG-Bibliotheken geladen: ssg_core, ssg_lang, ssg_dbg, ssg_dialog, ssg_layer, KreiselInsert, VarioFoerderer, Gefaellestrecke, export, tests, OmniModulInsert, SSG_LIB_Commands")
   (princ)
 )
 

Lisp/vf_etage.lsp

@@ -21,7 +21,7 @@
     (if *vf-etage-core-pfad*
       (load (strcat *vf-etage-core-pfad* "/vf_core.lsp"))
       (progn
-        (princ "\n[vf_etage] WARNUNG: Lisp-Pfad nicht ermittelbar - vf_core.lsp nicht ladbar!")
+        (princ (ssg-text "vfe-warn-lisp-pfad"))
         (exit)
       )
     )
@@ -50,9 +50,9 @@
   (if (and *etage-lib-initialized* (not (tblsearch "BLOCK" "AS_Element_30_rechts")))
     (setq *etage-lib-initialized* nil))
   (if *etage-lib-initialized*
-    (progn (princ "\n  Etage-Bibliothek bereits initialisiert.") t)
+    (progn (princ (ssg-text "vfe-bib-bereits-init")) t)
     (progn
-      (princ "\n  Initialisiere Etage-Bibliothek...")
+      (princ (ssg-text "vfe-bib-initialisiere"))
 
       ;; Standard-Bogen-Daten laden (bogen-auf/bogen-ab benoetigt)
       (if (not *lib-initialized*)
@@ -60,7 +60,7 @@
       )
 
       ;; AS_30_rechts Masse extrahieren
-      (princ "\n  Extrahiere AS_30_rechts Masse...")
+      (princ (ssg-text "vfe-extrahiere-as30"))
       (ensure-block-loaded "AS_Element_30_rechts")
       (ensure-block-loaded "AS_Element_30_links")
       (if (tblsearch "BLOCK" "AS_Element_30_rechts")
@@ -79,23 +79,22 @@
             (progn
               (setq etage-aus-dx (- (caar ks-aus-pos) (caar ks-ein-pos)))
               (setq etage-aus-dz (- (caddr (car ks-aus-pos)) (caddr (car ks-ein-pos))))
-              (princ (strcat "\n    AS_30_rechts: dx=" (rtos etage-aus-dx 2 1)
+              (princ (ssg-textf "vfe-as30-mass" (list (rtos etage-aus-dx 2 1) (rtos etage-aus-dz 2 1))))
-                             " mm, dz=" (rtos etage-aus-dz 2 1) " mm"))
             )
             (progn
-              (princ "\n    WARNUNG: KS fehlt - Standardwerte")
+              (princ (ssg-text "vfe-warn-ks-fehlt-standard"))
               (setq etage-aus-dx 525.8  etage-aus-dz -72.9)
             )
           )
         )
         (progn
-          (princ "\n    WARNUNG: Block AS_Element_30_rechts fehlt - Standardwerte")
+          (princ (ssg-text "vfe-warn-block-as30-fehlt"))
           (setq etage-aus-dx 525.8  etage-aus-dz -72.9)
         )
       )
 
       ;; ES_30_rechts Masse extrahieren
-      (princ "\n  Extrahiere ES_30_rechts Masse...")
+      (princ (ssg-text "vfe-extrahiere-es30"))
       (ensure-block-loaded "ES_Element_30_rechts")
       (ensure-block-loaded "ES_Element_30_links")
       (if (tblsearch "BLOCK" "ES_Element_30_rechts")
@@ -114,24 +113,23 @@
             (progn
               (setq etage-ein-dx (- (caar ks-aus-pos) (caar ks-ein-pos)))
               (setq etage-ein-dz (- (caddr (car ks-aus-pos)) (caddr (car ks-ein-pos))))
-              (princ (strcat "\n    ES_30_rechts: dx=" (rtos etage-ein-dx 2 1)
+              (princ (ssg-textf "vfe-es30-mass" (list (rtos etage-ein-dx 2 1) (rtos etage-ein-dz 2 1))))
-                             " mm, dz=" (rtos etage-ein-dz 2 1) " mm"))
             )
             (progn
-              (princ "\n    WARNUNG: KS fehlt - Standardwerte")
+              (princ (ssg-text "vfe-warn-ks-fehlt-standard"))
               (setq etage-ein-dx 576.2  etage-ein-dz -54.6)
             )
           )
         )
         (progn
-          (princ "\n    WARNUNG: Block ES_Element_30_rechts fehlt - Standardwerte")
+          (princ (ssg-text "vfe-warn-block-es30-fehlt"))
           (setq etage-ein-dx 576.2  etage-ein-dz -54.6)
         )
       )
 
       ;; Gefaellebogen_links_60 Masse extrahieren
       (setq gefaelle-blockname "Gefaellebogen_links_60_R500")
-      (princ (strcat "\n  Extrahiere " gefaelle-blockname " Masse..."))
+      (princ (ssg-textf "vfe-extrahiere-block-mass" (list gefaelle-blockname)))
       (ensure-block-loaded gefaelle-blockname)
       (if (tblsearch "BLOCK" gefaelle-blockname)
         (progn
@@ -150,22 +148,21 @@
               (setq etage-gef-dz-links (- (caddr (car ks-aus-pos)) (caddr (car ks-ein-pos))))
             )
             (progn
-              (princ "\n    WARNUNG: kein KS - Standardwerte (links)")
+              (princ (ssg-text "vfe-warn-kein-ks-links"))
               (setq etage-gef-dx-links 0.0  etage-gef-dz-links -10.0)
             )
           )
         )
         (progn
-          (princ "\n    WARNUNG: Block fehlt - Standardwerte (links)")
+          (princ (ssg-text "vfe-warn-block-fehlt-links"))
           (setq etage-gef-dx-links 0.0  etage-gef-dz-links -10.0)
         )
       )
-      (princ (strcat "\n    Gefaellebogen links: dx=" (rtos etage-gef-dx-links 2 2)
+      (princ (ssg-textf "vfe-gefaellebogen-links-mass" (list (rtos etage-gef-dx-links 2 2) (rtos etage-gef-dz-links 2 2))))
-                     " dz=" (rtos etage-gef-dz-links 2 2) " mm"))
 
       ;; Gefaellebogen_rechts_60 Masse extrahieren
       (setq gefaelle-blockname "Gefaellebogen_rechts_60_R500")
-      (princ (strcat "\n  Extrahiere " gefaelle-blockname " Masse..."))
+      (princ (ssg-textf "vfe-extrahiere-block-mass" (list gefaelle-blockname)))
       (ensure-block-loaded gefaelle-blockname)
       (if (tblsearch "BLOCK" gefaelle-blockname)
         (progn
@@ -184,21 +181,20 @@
               (setq etage-gef-dz-rechts (- (caddr (car ks-aus-pos)) (caddr (car ks-ein-pos))))
             )
             (progn
-              (princ "\n    WARNUNG: kein KS - Standardwerte (rechts)")
+              (princ (ssg-text "vfe-warn-kein-ks-rechts"))
               (setq etage-gef-dx-rechts 0.0  etage-gef-dz-rechts -10.0)
             )
           )
         )
         (progn
-          (princ "\n    WARNUNG: Block fehlt - Standardwerte (rechts)")
+          (princ (ssg-text "vfe-warn-block-fehlt-rechts"))
           (setq etage-gef-dx-rechts 0.0  etage-gef-dz-rechts -10.0)
         )
       )
-      (princ (strcat "\n    Gefaellebogen rechts: dx=" (rtos etage-gef-dx-rechts 2 2)
+      (princ (ssg-textf "vfe-gefaellebogen-rechts-mass" (list (rtos etage-gef-dx-rechts 2 2) (rtos etage-gef-dz-rechts 2 2))))
-                     " dz=" (rtos etage-gef-dz-rechts 2 2) " mm"))
 
       (setq *etage-lib-initialized* t)
-      (princ "\n  Etage-Bibliothek erfolgreich initialisiert.")
+      (princ (ssg-text "vfe-bib-init-erfolg"))
       t
     )
   )
@@ -223,7 +219,7 @@
   (ensure-block-loaded blockname)
   (if (not (tblsearch "BLOCK" blockname))
     (progn
-      (princ (strcat "\n  FEHLER: Block '" blockname "' nicht in Bibliothek - abgebrochen"))
+      (princ (ssg-textf "vfe-block-fehlt-abbruch" (list blockname)))
       (exit)
     )
   )
@@ -241,10 +237,11 @@
     (+ (car startpunkt)   (* laenge chz cv))
     (+ (cadr startpunkt)  (* laenge shz cv))
     (+ (caddr startpunkt) (* (- sv) laenge))))
-  (princ (strcat "\n    HzIncl " blockname " L=" (rtos laenge 2 0)
+  (princ (ssg-textf "vfe-hz-incl-status"
-                 " hz=" (rtos hz-winkel 2 0) (chr 176)
+    (list blockname (rtos laenge 2 0)
-                 " v=" (rtos vert-winkel 2 0) (chr 176)
+          (strcat (rtos hz-winkel 2 0) (chr 176))
-                 " -> Z=" (rtos (caddr endpunkt) 2 1)))
+          (strcat (rtos vert-winkel 2 0) (chr 176))
+          (rtos (caddr endpunkt) 2 1))))
   endpunkt
 )
 
@@ -258,7 +255,7 @@
   (ensure-block-loaded blockname)
   (if (not (tblsearch "BLOCK" blockname))
     (progn
-      (princ (strcat "\n  FEHLER: Block '" blockname "' nicht in Bibliothek - abgebrochen"))
+      (princ (ssg-textf "vfe-block-fehlt-abbruch" (list blockname)))
       (exit)
     )
   )
@@ -276,10 +273,11 @@
     (+ (car startpunkt)   (+ (* block-dx chz cv) (* block-dz chz sv)))
     (+ (cadr startpunkt)  (+ (* block-dx shz cv) (* block-dz shz sv)))
     (+ (caddr startpunkt) (+ (* (- sv) block-dx) (* cv block-dz)))))
-  (princ (strcat "\n    HzRot " blockname
+  (princ (ssg-textf "vfe-hz-rot-status"
-                 " hz=" (rtos hz-winkel 2 0) (chr 176)
+    (list blockname
-                 " v=" (rtos vert-winkel 2 0) (chr 176)
+          (strcat (rtos hz-winkel 2 0) (chr 176))
-                 " -> Z=" (rtos (caddr endpunkt) 2 1)))
+          (strcat (rtos vert-winkel 2 0) (chr 176))
+          (rtos (caddr endpunkt) 2 1))))
   endpunkt
 )
 
@@ -291,7 +289,7 @@
   (ensure-block-loaded blockname)
   (if (not (tblsearch "BLOCK" blockname))
     (progn
-      (princ (strcat "\n  FEHLER: Block '" blockname "' nicht in Bibliothek - abgebrochen"))
+      (princ (ssg-textf "vfe-block-fehlt-abbruch" (list blockname)))
       (exit)
     )
   )
@@ -335,13 +333,14 @@
       (setq ausgang (list (+ (car p-aus-rot)   (car offset))
                           (+ (cadr p-aus-rot)  (cadr offset))
                           (+ (caddr p-aus-rot) (caddr offset))))
-      (princ (strcat "\n    HzRotKS " blockname
+      (princ (ssg-textf "vfe-hz-rotks-status"
-                     " hz=" (rtos hz-winkel 2 0) (chr 176)
+        (list blockname
-                     " -> Z=" (rtos (caddr ausgang) 2 1)))
+              (strcat (rtos hz-winkel 2 0) (chr 176))
+              (rtos (caddr ausgang) 2 1))))
       ausgang
     )
     (progn
-      (princ (strcat "\n  WARNUNG: KS fehlt in '" blockname "' - verwende Startpunkt"))
+      (princ (ssg-textf "vfe-ks-fehlt-startpunkt" (list blockname)))
       startpunkt
     )
   )
@@ -355,7 +354,7 @@
   (ensure-block-loaded blockname)
   (if (not (tblsearch "BLOCK" blockname))
     (progn
-      (princ (strcat "\n  FEHLER: Block '" blockname "' nicht in Bibliothek - abgebrochen"))
+      (princ (ssg-textf "vfe-block-fehlt-abbruch" (list blockname)))
       (exit)
     )
   )
@@ -403,14 +402,14 @@
       (setq ausgang (list (+ (car p-aus-rot)   (car offset))
                           (+ (cadr p-aus-rot)  (cadr offset))
                           (+ (caddr p-aus-rot) (caddr offset))))
-      (princ (strcat "\n    HzScaleKS " blockname
+      (princ (ssg-textf "vfe-hz-scaleks-status"
-                     " " (rtos laenge 2 0) "mm"
+        (list blockname (rtos laenge 2 0)
-                     " hz=" (rtos hz-winkel 2 0) (chr 176)
+              (strcat (rtos hz-winkel 2 0) (chr 176))
-                     " -> Z=" (rtos (caddr ausgang) 2 1)))
+              (rtos (caddr ausgang) 2 1))))
       ausgang
     )
     (progn
-      (princ (strcat "\n  WARNUNG: KS fehlt in '" blockname "' - verwende Startpunkt"))
+      (princ (ssg-textf "vfe-ks-fehlt-startpunkt" (list blockname)))
       startpunkt
     )
   )
@@ -432,7 +431,7 @@
 
   (if (not *etage-lib-initialized*)
     (progn
-      (alert "Etage-Bibliothek nicht initialisiert!")
+      (alert (ssg-text "vfe-alert-bib-nicht-init"))
       (exit)
     )
   )
@@ -452,11 +451,9 @@
   (setq schraeg-cos  (* (cos schraeg-hz-rad) cos3))
 
   (princ "\n\n=========================================")
-  (princ "\n  ETAGE-BERECHNUNG FUER ALLE WINKEL")
+  (princ (ssg-text "vfe-berechnung-header"))
   (princ "\n=========================================")
-  (princ (strcat "\n△L=" (rtos deltaL 2 2) " mm"
+  (princ (ssg-textf "vfe-delta-info" (list (rtos deltaL 2 2) (rtos deltaH 2 2) richtung)))
-                 "  △H=" (rtos deltaH 2 2) " mm"
-                 "  Richtung=" richtung))
 
   (foreach winkel winkel-list
     (if (= richtung "Auf")
@@ -471,7 +468,7 @@
     )
     (if (or (null mass1) (null mass2))
       (progn
-        (princ (strcat "\n  " (itoa winkel) (chr 176) " -> Bogen nicht vorhanden"))
+        (princ (ssg-textf "vfe-bogen-nicht-vorhanden" (list (strcat (itoa winkel) (chr 176)))))
         (setq ergebnis-liste (cons (list winkel nil nil nil) ergebnis-liste))
       )
       (progn
@@ -540,9 +537,9 @@
   (setq ergebnis-liste (reverse ergebnis-liste))
 
   (princ "\n\n=================================================================================")
-  (princ "\n  ERGEBNISTABELLE  (L_GF = gesamt beider GF-Strecken)")
+  (princ (ssg-text "vfe-ergebnistabelle-header"))
   (princ "\n=================================================================================")
-  (princ "\n  Winkel     L_GF (mm)        L_VF (mm)        Status")
+  (princ (ssg-text "vfe-tabelle-spalten"))
   (princ "\n=================================================================================")
 
   (setq best-winkel nil best-L_GF nil best-L_VF nil)
@@ -553,26 +550,25 @@
           gueltig (cadddr item))
     (if (and (numberp L_GF) (numberp L_VF))
       (progn
-        (princ (strcat "\n  " (itoa winkel) (chr 176)
+        (princ (ssg-textf "vfe-tabelle-zeile"
-                       "       " (fmt L_GF) " mm     " (fmt L_VF) " mm     "))
+          (list (strcat (itoa winkel) (chr 176)) (fmt L_GF) (fmt L_VF))))
         (if gueltig
           (progn
-            (princ "GUELTIG")
+            (princ (ssg-text "vfe-status-gueltig"))
             (if (or (null best-winkel) (< winkel best-winkel))
               (setq best-winkel winkel best-L_GF L_GF best-L_VF L_VF)
             )
           )
-          (princ "UNGUELTIG (negative Laenge)")
+          (princ (ssg-text "vfe-status-ungueltig"))
         )
       )
-      (princ (strcat "\n  " (itoa winkel) (chr 176)
+      (princ (ssg-textf "vfe-tabelle-zeile-fehler" (list (strcat (itoa winkel) (chr 176)))))
-                     "       ---              ---              FEHLER"))
     )
   )
   (princ "\n=================================================================================")
   (if best-winkel
-    (princ (strcat "\n>>> Empfohlener Winkel: " (itoa best-winkel) (chr 176)))
+    (princ (ssg-textf "vfe-empfohlener-winkel" (list (strcat (itoa best-winkel) (chr 176)))))
-    (princ "\n>>> KEIN passender Winkel gefunden!")
+    (princ (ssg-text "vfe-kein-winkel-gefunden"))
   )
   (list best-winkel best-L_GF best-L_VF ergebnis-liste)
 )
@@ -592,8 +588,7 @@
       (setq etage-gef-dx etage-gef-dx-links)
       (setq etage-gef-dz etage-gef-dz-links))
   )
-  (princ (strcat "\n  Gefaellebogen " seite
+  (princ (ssg-textf "vfe-gefaellebogen-seite-dx" (list seite (rtos etage-gef-dx 2 2))))
-                 ": dx=" (rtos etage-gef-dx 2 2) " mm"))
   (berechne-winkel-etage deltaL deltaH richtung)
 )
 
@@ -602,9 +597,14 @@
 ;; ============================================================
 ;; Gibt endpunkt zurueck.
 ;; VF_*-Block-Erstellung erfolgt zentral im Dispatcher (vf_core.lsp).
+;; hz: Parameter fuer Registry-Kompatibilitaet mit variofoerderer-einfuegen
+;; (siehe c:VarioFoerderer) - wird hier NICHT verwendet: die Etage-Anlage hat
+;; bereits eine eigene, fest verdrahtete horizontale Geometrie (hz-anfang/
+;; hz-ende fuer den 60-Grad-Uebereinander-Versatz) und unterstuetzt aktuell
+;; keine zusaetzliche globale Fahrtrichtung.
 (defun etage-foerderanlage-einfuegen (deltaL deltaH richtung
                                        best-winkel L_GF1 L_GF2 L_VF
-                                       startpunkt seite
+                                       startpunkt seite hz
                                        / aktueller-punkt bogen-name endpunkt
                                          bogen-mass bogen-dx bogen-dz
                                          as-block es-block gefaelle-blockname
@@ -629,43 +629,40 @@
   (if (not *etage-lib-initialized*) (init-bibliothek-etage))
 
   ;; 1. AS_30
-  (princ (strcat "\n\n1/15: " as-block " (0 Grad)"))
+  (princ (ssg-textf "vfe-step1-as30" (list as-block)))
-  (setq aktueller-punkt (insert-block-by-ks as-block aktueller-punkt))
+  (setq aktueller-punkt (insert-block-by-ks as-block aktueller-punkt 0.0))
 
   ;; 2. Staustrecke 400mm (hz-anfang, 3 Grad vert, KS_EIN)
-  (princ (strcat "\n\n2/15: Staustrecke 400mm ("
+  (princ (ssg-textf "vfe-step2" (list (itoa hz-anfang))))
-                 (itoa hz-anfang) " Grad hz, 3 Grad vert, KS_EIN)"))
   (setq aktueller-punkt
     (insert-hz-scaled-block-by-ks "Staustrecke_SP_1000_mm" aktueller-punkt
       400 hz-anfang 3))
 
   ;; 3. Separator (hz-anfang, 3 Grad vert)
-  (princ (strcat "\n\n3/15: Separator (300mm, "
+  (princ (ssg-textf "vfe-step3" (list (itoa hz-anfang))))
-                 (itoa hz-anfang) " Grad hz, 3 Grad vert)"))
   (setq aktueller-punkt
     (insert-hz-rotated-block-with-ks "Staustrecke_Separator_SP_300_mm" aktueller-punkt
       hz-anfang 3 300 0))
 
   ;; 4. Gefaellebogen Anfang (hz-anfang, 0 Grad vert, KS_EIN)
-  (princ (strcat "\n\n4/15: " gefaelle-blockname
+  (princ (ssg-textf "vfe-step4" (list gefaelle-blockname (itoa hz-anfang))))
-                 " (Anfang, " (itoa hz-anfang) " Grad hz, 0 Grad vert, KS_EIN)"))
   (setq aktueller-punkt
     (insert-hz-rotated-block-by-ks gefaelle-blockname aktueller-punkt hz-anfang 0))
 
   ;; 5. L_GF1 (3 Grad geneigt)
   (if (> L_GF1 0.1)
     (progn
-      (princ (strcat "\n\n5/15: Gefaellestrecke (3 Grad, L=" (rtos L_GF1 2 2) " mm)"))
+      (princ (ssg-textf "vfe-step5-strecke" (list (rtos L_GF1 2 2))))
       (setq aktueller-punkt
-        (insert-inclined-scaled-block "Staustrecke_SP_1000_mm" aktueller-punkt L_GF1 3))
+        (insert-inclined-scaled-block "Staustrecke_SP_1000_mm" aktueller-punkt L_GF1 3 0.0))
     )
-    (princ "\n\n5/15: L_GF1 (uebersprungen)")
+    (princ (ssg-text "vfe-step5-skip"))
   )
 
   ;; 6. Umlenkstation (3 Grad geneigt)
-  (princ "\n\n6/15: Umlenkstation (500mm, 3 Grad geneigt)")
+  (princ (ssg-text "vfe-step6"))
   (setq aktueller-punkt
-    (insert-rotated-block-with-ks "Vario_Umlenkstation_500mm" aktueller-punkt 3 500 0))
+    (insert-rotated-block-with-ks "Vario_Umlenkstation_500mm" aktueller-punkt 3 500 0 0.0))
 
   ;; 7. 1. Vertikalbogen (3 Grad geneigt)
   (if (= richtung "Auf")
@@ -679,31 +676,29 @@
     )
   )
   (setq bogen-dx (car bogen-mass) bogen-dz (caddr bogen-mass))
-  (princ (strcat "\n\n7/15: " bogen-name " (3 Grad geneigt)"))
+  (princ (ssg-textf "vfe-step7" (list bogen-name)))
   (setq aktueller-punkt
-    (insert-rotated-block-with-ks bogen-name aktueller-punkt 3 bogen-dx bogen-dz))
+    (insert-rotated-block-with-ks bogen-name aktueller-punkt 3 bogen-dx bogen-dz 0.0))
 
   ;; 8. Variable Strecke L_VF
   (if (> L_VF 0.1)
     (progn
       (if (= richtung "Auf")
         (progn
-          (princ (strcat "\n\n8/15: Steigungsstrecke ("
+          (princ (ssg-textf "vfe-step8-auf" (list (itoa (- (- best-winkel 3))) (rtos L_VF 2 2))))
-                         (itoa (- (- best-winkel 3))) " Grad, L=" (rtos L_VF 2 2) " mm)"))
           (setq aktueller-punkt
             (insert-inclined-scaled-block "Staustrecke_SP_1000_mm" aktueller-punkt
-              L_VF (- (- best-winkel 3))))
+              L_VF (- (- best-winkel 3)) 0.0))
         )
         (progn
-          (princ (strcat "\n\n8/15: Gefaellestrecke ("
+          (princ (ssg-textf "vfe-step8-ab" (list (itoa (+ best-winkel 3)) (rtos L_VF 2 2))))
-                         (itoa (+ best-winkel 3)) " Grad, L=" (rtos L_VF 2 2) " mm)"))
           (setq aktueller-punkt
             (insert-inclined-scaled-block "Staustrecke_SP_1000_mm" aktueller-punkt
-              L_VF (+ best-winkel 3)))
+              L_VF (+ best-winkel 3) 0.0))
         )
       )
     )
-    (princ "\n\n8/15: L_VF (uebersprungen)")
+    (princ (ssg-text "vfe-step8-skip"))
   )
 
   ;; 9. 2. Vertikalbogen
@@ -724,35 +719,35 @@
                      " (" (itoa (- 3 best-winkel)) " Grad geneigt)"))
       (setq aktueller-punkt
         (insert-rotated-block-with-ks bogen-name aktueller-punkt
-          (- 3 best-winkel) bogen-dx bogen-dz))
+          (- 3 best-winkel) bogen-dx bogen-dz 0.0))
     )
     (progn
       (princ (strcat "\n\n9/15: " bogen-name
                      " (" (itoa (+ best-winkel 3)) " Grad geneigt)"))
       (setq aktueller-punkt
         (insert-rotated-block-with-ks bogen-name aktueller-punkt
-          (+ best-winkel 3) bogen-dx bogen-dz))
+          (+ best-winkel 3) bogen-dx bogen-dz 0.0))
     )
   )
 
   ;; 10. Motorstation (3 Grad geneigt)
   (princ "\n\n10/15: Motorstation (500mm, 3 Grad geneigt)")
   (setq aktueller-punkt
-    (insert-rotated-block-with-ks "Vario_Motorstation_500mm" aktueller-punkt 3 500 0))
+    (insert-rotated-block-with-ks "Vario_Motorstation_500mm" aktueller-punkt 3 500 0 0.0))
 
   ;; 11. L_GF2 (3 Grad geneigt)
   (if (> L_GF2 0.1)
     (progn
       (princ (strcat "\n\n11/15: Gefaellestrecke (3 Grad, L=" (rtos L_GF2 2 2) " mm)"))
       (setq aktueller-punkt
-        (insert-inclined-scaled-block "Staustrecke_SP_1000_mm" aktueller-punkt L_GF2 3))
+        (insert-inclined-scaled-block "Staustrecke_SP_1000_mm" aktueller-punkt L_GF2 3 0.0))
     )
     (princ "\n\n11/15: L_GF2 (uebersprungen)")
   )
 
   ;; 12. Gefaellebogen Ende (via KS_EIN, 0 Grad vert)
   (princ (strcat "\n\n12/15: " gefaelle-blockname " (Ende, KS_EIN)"))
-  (setq aktueller-punkt (insert-block-by-ks gefaelle-blockname aktueller-punkt))
+  (setq aktueller-punkt (insert-block-by-ks gefaelle-blockname aktueller-punkt 0.0))
 
   ;; 13. Separator Ende (hz-ende, 3 Grad vert)
   (princ (strcat "\n\n13/15: Separator (300mm, "

README.md

@@ -16,7 +16,6 @@ SSG_LIB
 │   │   ├── BTMT-Beladung          → ILS_BTMT_Beladung
 │   │   └── BTMT-Entladung         → ILS_BTMT_Entladung
 │   ├── Foerderer
-│   │   ├── ETF Etagenfoerderer    → ILS_ETF_Etagenfoerderer
 │   │   ├── TEF Strecke            → ILS_TEF_Strecke
 │   │   ├── VarioFoerderer         → FOERDERANLAGE
 │   │   ├── Kurven angetr. Aussen  → ILS_K{90,60,30}{LA,RA}
@@ -60,6 +59,9 @@ SSG_LIB
 │   │   ├── Antriebst. rechts      → OMNI_TEF_AntriebR
 │   │   └── TEF Gerade             → OMNI_TEF_Gerade
 │   └── KettenFoerderer            → OMNI_KettenFoerderer
+├── Konfiguration
+│   ├── Umschalten 2D und 3D        → SSG_DIM_SWITCH
+│   └── Sprache                     → SSG_SPRACHE
 └── External
     ├── Call Python                → CALLPYTHON
     ├── Export Sivas               → EXPORTSIVAS
@@ -128,6 +130,13 @@ Unterstuetzte Bogenwinkel: 3, 9, 12, 15, 24, 36, 48 Grad
 | `SSG-LayerOnAll` | Alle ausgeschalteten Layer einschalten |
 | `SSG-LayerDelete` | Layer und alle Objekte darauf loeschen (mit Bestaetigung) |
 
+### SSG_LIB_Commands.lsp - Konfiguration
+
+| Befehl | Beschreibung |
+| --- | --- |
+| `SSG_DIM_SWITCH` | Schaltet zwischen 2D- und 3D-Bloecken um |
+| `SSG_SPRACHE` | Sprache umschalten (Deutsch/Englisch), persistiert ueber `DXFM_LANG` |
+
 ### tests.lsp - Export und Python-Integration
 
 | Befehl | Beschreibung |
@@ -141,6 +150,7 @@ Unterstuetzte Bogenwinkel: 3, 9, 12, 15, 24, 36, 48 Grad
 | Datei | Beschreibung |
 | --- | --- |
 | `ssg_core.lsp` | Kernel: Umgebung, Layer-Ops, Block-Ops, Attribut-Ops, Fehlerbehandlung |
+| `ssg_lang.lsp` | Sprachumschaltung Deutsch/Englisch (`ssg-text`, `ssg-textf`, `*ssg-lang*`) |
 | `ssg_dialog.lsp` | Dialog-Vorlagen: Slide-Preview, Modul-Dialog, Block-Einfuegesequenz |
 | `ssg_layer.lsp` | Layer-Verwaltungsbefehle |
 | `ssg_load.lsp` | Loader: Laedt alle SSG-Bibliotheken in korrekter Reihenfolge |
@@ -181,6 +191,7 @@ dxfmakros/
 | `DXFM_CFG` | Konfigurationsdateien |
 | `DXFM_TESTS` | Testverzeichnis |
 | `DXFM_DATA` | Datenverzeichnis |
+| `DXFM_LANG` | Aktive Sprache (`de_DE`/`en_GB`), persistiert von `SSG_SPRACHE`; Default `de_DE` |
 | `BRICSCAD` | Pfad zur BricsCAD-Executable |
 
 ## Einrichtung

bin/setenv.bat

@@ -15,6 +15,7 @@ REM Pfade fuer verschiedene Komponenten
 set "DXFM_BIN=%DXFMAKRO%\bin"
 set "DXFM_LIB=%DXFMAKRO%\lib"
 set "DXFM_DATA=%DXFMAKRO%\data"
+set "DXFM_LANG=%DXFMAKRO%\lang"
 set "DXFM_TESTS=%DXFMAKRO%\tests"
 set "DXFM_TESTDATA=%DXFM_TESTS%\testdata"
 set "DXFM_TESTOUT=%DXFM_TESTS%\output"
@@ -60,6 +61,7 @@ if not exist "%DXFM_BIN%" mkdir "%DXFM_BIN%"
 if not exist "%DXFM_CFG%" mkdir "%DXFM_CFG%"
 if not exist "%DXFM_LIB%" mkdir "%DXFM_LIB%"
 if not exist "%DXFM_DATA%" mkdir "%DXFM_DATA%"
+if not exist "%DXFM_LANG%" mkdir "%DXFM_LANG%"
 if not exist "%DXFM_BLOCKS%" mkdir "%DXFM_BLOCKS%"
 if not exist "%DXFM_OMNIFLO%" mkdir "%DXFM_OMNIFLO%"
 if not exist "%DXFM_LISP%" mkdir "%DXFM_LISP%"
@@ -77,6 +79,7 @@ if /i "%1"=="--persist" (
     setx DXFMAKRO    "%DXFMAKRO%"   >nul
     setx DXFM_LISP   "%DXFM_LISP%"  >nul
     setx DXFM_DATA   "%DXFM_DATA%"  >nul
+    setx DXFM_LANG   "%DXFM_LANG%"  >nul
     setx DXFM_DCL    "%DXFM_DCL%"   >nul
     setx DXFM_CFG    "%DXFM_CFG%"   >nul
     setx DXFM_LOG    "%DXFM_LOG%"   >nul

cfg/attradd.cfg

@@ -32,9 +32,31 @@ weiche_45           = "A-2"
 # Weichenbatterien / Parallel (KurvenWinkel=0)
 weichenbatterie     = "A-2"
 # Weichenkombinationen (Deltaweiche, Sternweiche, Dreifachweiche)
-weichenkombination  = "L-2"
+weichenkombination  = "A-2"
 # Weichenkoerper (KurvenWinkel=22.5)
-weichenkoerper      = "L-2"
+weichenkoerper      = "A-2"
+# Kreuzungsweichen (800, 300) - Layer L für Stahlstrecke (alt)
+kreuzungsweiche     = "L-2"
+
+# PNEUMATISCH GESCHALTET
+# Weichen pneumatisch 90 Grad (Einzelweiche/Doppelweiche/Dreiwegeweiche, KurvenWinkel=90)
+weiche_pn_90           = "A-3"
+# Weichen 45 Grad (Einzelweiche/Doppelweiche/Dreiwegeweiche, KurvenWinkel=45)
+weiche_pn_45           = "A-3"
+# Weichenbatterien / Parallel (KurvenWinkel=0)
+weichenbatterie_pn     = "A-3"
+# Weichenkombinationen (Deltaweiche, Sternweiche, Dreifachweiche)
+weichenkombination_pn  = "A-3"
+# Weichenkoerper (KurvenWinkel=22.5)
+weichenkoerper_pn      = "A-3"
+# Kreuzungsweichen (300) - Layer L für Stahlstrecke (alt)
+kreuzungsweiche_pn        = "L-3"
+
+# TEF Förderer
+TEF_gerade                = "F-1"
+TEF_bogen                 = "F-1"
+TEF_antriebstation        = "F-1"
+TEF_umlenkspannstation    = "F-1"
 
 [bogen]
 BESCHR    = ProfilTyp
@@ -74,3 +96,10 @@ LAYER     = "A-2"
 HOEHE     = ""
 DREHUNG   = ""
 
+
+[container]
+0_BG071090 = 0_B10071, 0_B10090, 0_B10090
+0_BG080090 = 0_B10080, 0_B10090,
+0_BG081090 = 0_B10081, 0_B10090,
+0_BG090090 = 0_B10090, 0_B10090,
+0_BG190090 = 0_B10090, 0_B10090

cfg/export.cfg

@@ -0,0 +1,29 @@
+# ============================================================
+# export.cfg - Konfiguration fuer Lisp/export.lsp UND lib/export_csv.py,
+# lib/export_sivas.py (gemeinsame Blockname-Muster, siehe
+# lib/export_blockpatterns.py)
+#
+# Format: INI-Style
+#   [ABSCHNITT]
+#   Key = Wert                 (einzelner Wert)
+#   Key = Wert1, Wert2, Wert3  (Musterliste fuer wcmatch/fnmatch, kommagetrennt)
+#
+# Zeilen mit # sind Kommentare. Leerzeilen werden ignoriert.
+#
+# pattern_kreisel/pattern_strecke sind fuer Lisp's Block-SAMMLUNG grob
+# gehalten (nur "gehoert das ueberhaupt zum Export"). Die uebrigen
+# pattern_eckrad/pattern_variofoerderer/pattern_gefaellestrecke/
+# pattern_strecke_module-Keys sind Teilmengen davon fuer die feinere
+# TeileArt-KLASSIFIKATION in Python (eigene Zeile je Teileart) -
+# Aenderungen an Blocknamen bitte in beiden Stellen nachziehen.
+# ============================================================
+
+[blockpattern]
+pattern_kreisel=           KR_*, KREISEL_*, ECKRAD_*
+pattern_eckrad=            ECKRAD_*
+pattern_gerade=            AP110*, AP_110*
+pattern_strecke=           Vario*, Staustrecke*, AUS_Element*, EIN_Element*, VF_*, GF_*
+pattern_variofoerderer=    VF_*
+pattern_gefaellestrecke=   GF_*
+pattern_strecke_module=    Vario*, Staustrecke*, AUS_Element*, EIN_Element*
+pattern_ks_subblocks=      KS_EIN, KS_AUS, K1, K2, K3, K4