Aus den Lisp Daten unter M:\ACADSST\MENU eine neue Standardlibrary mit Codedoku extrahiert

Lisp/README.md

@@ -0,0 +1,135 @@
+# Lisp – AutoLISP-Standardbibliotheken
+
+Allgemeingültige AutoLISP-Routinen für AutoCAD, destilliert aus den historischen ACADSST-Makros (Schönenberger Systeme GmbH). Die drei `ssg_`-Bibliotheken sind projektunabhängig einsetzbar.
+
+---
+
+## Ladereihenfolge
+
+```lisp
+(load "pfad/ssg_load.lsp")   ; lädt core → dialog → layer
+```
+
+Oder einzeln (Abhängigkeit beachten: `ssg_dialog` und `ssg_layer` setzen `ssg_core` voraus):
+
+```lisp
+(load "pfad/ssg_core.lsp")
+(load "pfad/ssg_dialog.lsp")
+(load "pfad/ssg_layer.lsp")
+```
+
+---
+
+## Dateien
+
+### `ssg_core.lsp` – Kernbibliothek
+
+Grundfunktionen für Umgebungssicherung, Benutzerinteraktion, Layer, Blöcke und Attribute.
+
+| Funktion | Beschreibung |
+|---|---|
+| `ssg-start titel vars` | Systemvariablen sichern, CMDECHO aus, Undo-Gruppe öffnen |
+| `ssg-end` | Systemvariablen wiederherstellen, Undo-Gruppe schließen |
+| `ssg-errhan em` | Fehlerhandler – räumt auf und ruft `ssg-end` auf |
+| `ssg-ques text defa` | Ja/Nein-Abfrage; `defa=T` → Default Ja, `nil` → Default Nein |
+| `ssg-emsg text` | Fehlermeldung mit optionalem Signalton (`ssg-bell`) |
+| `ssg-get-layer text` | Layer eines angeklickten Objektes ermitteln |
+| `ssg-layer-ss name typ` | Auswahlsatz aller Objekte eines Layers (optional nach Typ filtern) |
+| `ssg-make-layer name farbe aktiv` | Layer anlegen (falls nicht vorhanden) und optional aktivieren |
+| `ssg-ss-foreach ss func` | Iteration über Auswahlsatz – `func` wird für jeden Entity-Name aufgerufen |
+| `ssg-ss-redraw ss modus` | Alle Elemente eines Auswahlsatzes hervorheben (3), invertieren (4) oder normal (0) |
+| `ssg-ss-add src dest` | Auswahlsatz `src` zu `dest` hinzufügen (in-place, mit Highlight) |
+| `ssg-make-blockname pt` | Eindeutigen Blocknamen aus Einfügepunkt + Zeitstempel erzeugen |
+| `ssg-insert-block layer farbe pfad pt xs ys rot` | Layer anlegen und Block einfügen |
+| `ssg-make-block pt rotation ss` | Auswahlsatz als Block definieren und gleich einfügen; Name aus `ssg-make-blockname` |
+| `ssg-attrib-set tag wert ersetzen` | Ein Attribut der letzten Einfügung setzen oder anfügen |
+| `ssg-attrib-set-many alist` | Mehrere Attribute auf einmal setzen (`'(("TAG" . "Wert") ...)`) |
+| `ssg-attrib-by-handle handle tag wert ersetzen` | Attribut eines Blocks anhand seines Entity-Handles suchen und ändern |
+| `ssg-dialog-run dcl id init-fn accept-fn` | Generischer DCL-Dialog: laden, initialisieren, starten, entladen |
+| `ssg-zoom-save` | Aktuelle View-Größe merken |
+| `ssg-zoom-restore` | Auf gemerkte View-Größe zurückschalten (nur wenn verändert) |
+
+---
+
+### `ssg_dialog.lsp` – Dialog-Pattern für Modul-Einfüge-Makros
+
+Kapselt das wiederkehrende DCL-Muster: Dialog mit Vorschaubild, Radio-Auswahl, Block einfügen, Attribute setzen.
+
+| Funktion | Beschreibung |
+|---|---|
+| `ssg-dia-show-slide tile lib name` | Vorschau-Slide im image-Tile aktualisieren (Bibliothek + Slide-Name) |
+| `ssg-dia-update-preview tile idx lib liste` | Vorschau anhand Index-String aus Radio-/List-Tile aktualisieren |
+| `ssg-modul-dialog dcl id sel-tile start-val prev-tile lib slides extra-init extra-read` | Vollständiger Modul-Dialog: lädt DCL, setzt Tiles, verknüpft Vorschau, liefert gewählten Index zurück |
+| `ssg-insert-modul layer farbe pfad attribs rotation` | Standardsequenz: Layer anlegen → Punkt abfragen → Block einfügen → Attribute setzen |
+
+Die Datei enthält außerdem ein auskommentiertes **Template** für neue `c:BEFEHL`-Definitionen nach dem SSG-Muster.
+
+---
+
+### `ssg_layer.lsp` – Interaktive Layer-Verwaltung
+
+Benutzerfreundliche AutoCAD-Befehle für Layer-Operationen. Alle Befehle sichern die Umgebung über `ssg-start`/`ssg-end`.
+
+**Hilfsfunktionen (intern):**
+
+| Funktion | Beschreibung |
+|---|---|
+| `ssg-layer-list-all` | Alle Layernamen als Liste |
+| `ssg-layer-info-all` | Alle Layer als Assoziationslisten (Name, Farbe, Linientyp, Flags) |
+| `ssg-layer-visible-p name` | Sichtbarkeitsstatus prüfen (T = sichtbar) |
+| `ssg-layer-safe-p name gruppe` | Prüfen ob Layer ausgeschaltet werden darf (nicht aktiver Layer) |
+| `ssg-layer-group name` | Gruppen-Kennung aus Layernahme extrahieren (Position 2–3) |
+| `ssg-layer-rename-group name neu` | Neuen Layernamen mit geänderter Gruppen-Kennung berechnen |
+| `ssg-layer-group-move alt neu` | Alle Objekte einer Layergruppe auf neue Gruppen-Kennung verschieben |
+
+**AutoCAD-Befehle:**
+
+| Befehl | Beschreibung |
+|---|---|
+| `c:SSG-LayerSet` | Layer des angeklickten Objektes als aktiven Layer setzen |
+| `c:SSG-LayerInfo` | Layer des angeklickten Objektes anzeigen |
+| `c:SSG-LayerMove` | Auswahlsatz auf Layer eines anderen Objektes verschieben |
+| `c:SSG-LayerCopy` | Auswahlsatz kopieren und Kopie auf Ziel-Layer legen |
+| `c:SSG-LayerMoveType` | Alle Objekte des gleichen Typs auf dem gleichen Layer verschieben |
+| `c:SSG-LayerOff` | Layer durch Anklicken ausschalten (Schleife bis Enter) |
+| `c:SSG-LayerFreeze` | Layer durch Anklicken einfrieren (Schleife bis Enter) |
+| `c:SSG-FreezeAll` | Alle Layer außer einem einfrieren |
+| `c:SSG-ThawAll` | Alle Layer auftauen |
+| `c:SSG-LayerOnAll` | Alle ausgeschalteten Layer einschalten |
+| `c:SSG-LayerDelete` | Layer mit Sicherheitsabfrage löschen (Objekte + Layer) |
+
+---
+
+### `ssg_load.lsp` – Laderoutine
+
+Lädt alle drei Bibliotheken in der richtigen Reihenfolge. Ermittelt den Pfad automatisch über `findfile`.
+
+---
+
+### `SSG_LIB_Commands.lsp` – Dummy-Befehle für das SSG-Menü
+
+Platzhalter-Definitionen für alle Menüeinträge des SSG-Menüsystems (ILS-Module, Kurven, Gefällestrecken). Gibt beim Aufruf eine Meldung aus. Wird durch echte Implementierungen ersetzt sobald die jeweiligen Blöcke und DCL-Dialoge vorliegen.
+
+---
+
+### `ILSModulInsert.lsp` – ILS Kreisel-Modul-Einfügung
+
+Einfügen von ILS-Kreisel-Modulen mit Abstand- und Typ-Konfiguration (mit/ohne PIN). Enthält Smart-Connect-Logik für automatische Positionierung. Befehl: `c:KreiselInsert`.
+
+---
+
+### `OmniModulInsert.lsp` – Omni-Modul-Einfügung
+
+Einfügen von Omni-Modulen. Befehl analog zu `ILSModulInsert`.
+
+---
+
+### `VarioFoerderer.lsp` – Vario-Förderer
+
+Umfangreiche Routinen für den Vario-Förderer (Strecken, Kurven, Sonderelemente). Größte Einzeldatei im Projekt.
+
+---
+
+### `tests.lsp` – Testskript
+
+Manuelle Tests für die Bibliotheksfunktionen. Nicht für den Produktiveinsatz laden.

Lisp/ssg_core.lsp

@@ -0,0 +1,363 @@
+;; ============================================================
+;; SSG_CORE.LSP - Kernbibliothek: Umgebung, Fehler, Dialog
+;; Allgemeingueltige Hilfsfunktionen fuer AutoCAD-LISP Makros
+;; Ursprung: ACADSST/MENU/ssg.lsp, pu1pu2.lsp (Schoenenberger)
+;; Bereinigt und verallgemeinert: 2025
+;; ============================================================
+
+
+;; ------------------------------------------------------------
+;; UMGEBUNGSSICHERUNG
+;; Sichert Systemvariablen vor Makroausfuehrung und stellt
+;; sie danach wieder her. Wird immer als Paar verwendet:
+;;   (ssg-start "Titel" '(("OSMODE") ("ORTHOMODE")))
+;;   ... Makrocode ...
+;;   (ssg-end)
+;; ------------------------------------------------------------
+
+(defun ssg-start (titel zusatz-vars / xlen xpos xvar)
+  ;; titel      - Anzeigename des Makros
+  ;; zusatz-vars - Liste zusaetzlicher Variablen z.B. '(("OSMODE")("ORTHOMODE"))
+  ;;               Immer CLAYER und CMDECHO werden automatisch gesichert.
+  (setq _ssg-olderr *error*
+        *error*     (function ssg-errhan)
+        _ssg-cavar  (append '(("CLAYER") ("CMDECHO")) zusatz-vars)
+        xlen        (length _ssg-cavar)
+        xpos        0
+  )
+  (repeat xlen
+    (setq xvar       (car (nth xpos _ssg-cavar))
+          _ssg-cavar (subst (cons xvar (getvar xvar))
+                            (nth xpos _ssg-cavar) _ssg-cavar)
+          xpos       (1+ xpos)
+    )
+  )
+  (setvar "CMDECHO" 0)
+  (command "_undo" "_G")
+  (graphscr)
+  (if titel (prompt (strcat "\n***** " titel " *****\n")))
+  (princ)
+)
+
+(defun ssg-end (/ xpos xlen xvar)
+  (if _ssg-cavar
+    (progn
+      (command)
+      (command "_undo" "_E")
+      (setq xpos 1
+            xlen (length _ssg-cavar)
+      )
+      (if (/= (getvar "CLAYER") (caar _ssg-cavar))
+        (command "_LAYER" "_SE" (cdar _ssg-cavar) "")
+      )
+      (repeat (1- xlen)
+        (setq xvar (nth xpos _ssg-cavar)
+              xpos (1+ xpos)
+        )
+        (setvar (car xvar) (cdr xvar))
+      )
+    )
+  )
+  (if _ssg-olderr (setq *error* _ssg-olderr))
+  (princ)
+)
+
+(defun ssg-errhan (em)
+  (if (= em "Function cancelled")
+    (princ)
+    (progn (princ "\nFehler: ") (princ em))
+  )
+  (command)
+  (command)
+  (ssg-end)
+)
+
+
+;; ------------------------------------------------------------
+;; BENUTZER-ABFRAGEN
+;; ------------------------------------------------------------
+
+;; Ja/Nein-Abfrage mit konfigurierbarem Default
+;; defa = T  -> Default ist "Yes" (Eingabe noetig um "No" zu waehlen)
+;; defa = nil -> Default ist "No"
+;; Rueckgabe: T wenn "No" gewaehlt (also Ablehnung), nil wenn "Yes"
+(defun ssg-ques (prompt-text defa)
+  (if defa
+    (progn
+      (initget 1 "Yes No  Yes")
+      (= (getkword (strcat "\n" prompt-text " Y/N <Y>: ")) "No")
+    )
+    (progn
+      (initget 1 "Yes No  No")
+      (= (getkword (strcat "\n" prompt-text " Y/N <N>: ")) "Yes")
+    )
+  )
+)
+
+;; Fehlermeldung mit optionalem Signalton
+;; ssg-bell = T -> kein Ton; nil -> Ton ausgeben
+(defun ssg-emsg (text)
+  (if (not ssg-bell) (prompt "\007"))
+  (terpri)
+  (prompt text)
+  (terpri)
+)
+
+
+;; ------------------------------------------------------------
+;; LAYER-HILFSFUNKTIONEN
+;; ------------------------------------------------------------
+
+;; Layer eines angeklickten Objektes ermitteln
+;; txt = Prompt-Text fuer Objektauswahl
+;; Rueckgabe: Layername als String, nil wenn Abbruch
+(defun ssg-get-layer (txt / sel)
+  (if (setq sel (entsel txt))
+    (cdr (assoc 8 (entget (car sel))))
+  )
+)
+
+;; Alle Objekte eines bestimmten Layers als Auswahlsatz liefern
+;; lay-name = Layername; ent-typ = Entitaetstyp z.B. "LINE" (nil = alle)
+(defun ssg-layer-ss (lay-name ent-typ)
+  (if ent-typ
+    (ssget "X" (list (cons 0 ent-typ) (cons 8 lay-name)))
+    (ssget "X" (list (cons 8 lay-name)))
+  )
+)
+
+;; Layer anlegen (falls nicht vorhanden) und optional setzen
+;; lay-name = Name; color = Farbnummer als String z.B. "2"; set-aktiv = T/nil
+(defun ssg-make-layer (lay-name color set-aktiv)
+  (if set-aktiv
+    (command "_LAYER" "_M" lay-name "_CO" color lay-name "")
+    (command "_LAYER" "_N" lay-name "_CO" color lay-name "")
+  )
+)
+
+;; Auswahlsatz-Iteration: Funktion fuer jedes Element aufrufen
+;; ss = Auswahlsatz; func = Funktion mit einem Parameter (entity-name)
+(defun ssg-ss-foreach (ss func / i ename)
+  (if ss
+    (progn
+      (setq i 0)
+      (while (setq ename (ssname ss i))
+        (func ename)
+        (setq i (1+ i))
+      )
+    )
+  )
+)
+
+;; Alle Elemente eines Auswahlsatzes hervorheben/zuruecksetzen
+;; ss = Auswahlsatz; modus = 3 (hervorheben) / 4 (invertiert) / 0 (normal)
+(defun ssg-ss-redraw (ss modus / i ename)
+  (if ss
+    (progn
+      (setq i 0)
+      (while (setq ename (ssname ss i))
+        (redraw ename modus)
+        (setq i (1+ i))
+      )
+    )
+  )
+)
+
+;; Auswahlsatz zu einem anderen Auswahlsatz hinzufuegen (in-place)
+;; src-ss = Quell-Auswahlsatz; dest-ss = Ziel-Auswahlsatz (wird modifiziert)
+(defun ssg-ss-add (src-ss dest-ss / i ename)
+  (if (null dest-ss) (setq dest-ss (ssadd)))
+  (setq i 0)
+  (while (setq ename (ssname src-ss i))
+    (ssadd ename dest-ss)
+    (redraw ename 3)
+    (setq i (1+ i))
+  )
+  dest-ss
+)
+
+
+;; ------------------------------------------------------------
+;; BLOCK-OPERATIONEN
+;; ------------------------------------------------------------
+
+;; Eindeutigen Blocknamen aus Einfuegepunkt + Zeitstempel erzeugen
+;; pt = Einfuegepunkt (Liste); Rueckgabe: Blockname als String
+(defun ssg-make-blockname (pt / k1 k2)
+  (setq k1 (strcat (itoa (abs (fix (car pt))))
+                   (itoa (abs (fix (cadr pt))))
+                   (itoa (abs (fix (caddr pt)))))
+        k2 (substr (rtos (getvar "cdate") 2 9) 10 9)
+  )
+  (strcat k1 k2)
+)
+
+;; Einzel-Block einfuegen mit Layer anlegen
+;; lay-name  = Ziel-Layer; color = Layerfarbe
+;; blk-pfad  = vollstaendiger Blockpfad (ohne Erweiterung)
+;; pt        = Einfuegepunkt; xscale yscale = Skalierung ("" = 1)
+;; rotation  = Drehwinkel als String oder pause fuer interaktiv
+(defun ssg-insert-block (lay-name color blk-pfad pt xscale yscale rotation)
+  (ssg-make-layer lay-name color T)
+  (command "_insert" blk-pfad pt xscale yscale rotation)
+)
+
+;; Block aus Auswahlsatz erstellen und gleich wieder einfuegen
+;; pt         = Origin; rotation = Drehwinkel als String
+;; ss         = Auswahlsatz der Elemente
+;; Rueckgabe: Blockname (String)
+(defun ssg-make-block (pt rotation ss / bname gefunden)
+  (setq bname   (ssg-make-blockname pt)
+        gefunden (tblsearch "block" bname)
+  )
+  (if (not gefunden)
+    (progn
+      (command "_block" bname pt ss "")
+      (command "_insert" bname pt "" "" rotation)
+    )
+    (progn
+      (alert (strcat "Blockname '" bname "' existiert bereits - wird uebersprungen."))
+      (setq bname (strcat "x" bname))
+      (command "_block" bname pt ss "")
+      (command "_insert" bname pt "" "" rotation)
+    )
+  )
+  bname
+)
+
+
+;; ------------------------------------------------------------
+;; ATTRIBUT-OPERATIONEN
+;; ------------------------------------------------------------
+
+;; Attribut eines Blocks (letzte Einfuegung) aendern
+;; tag     = Attributbezeichner (z.B. "ARTINR")
+;; wert    = neuer Wert
+;; ersetzen = T -> vollstaendiger Ersatz; nil -> Anfuegen
+(defun ssg-attrib-set (tag wert ersetzen / obj typ attr-tag attr-wert)
+  (setq obj (entlast))
+  (while (not (equal (cdr (assoc 0 (entget obj))) "SEQEND"))
+    (setq typ (cdr (assoc 0 (entget obj))))
+    (if (equal typ "ATTRIB")
+      (progn
+        (setq attr-tag  (cdr (assoc 2 (entget obj)))
+              attr-wert (cdr (assoc 1 (entget obj)))
+        )
+        (if (equal attr-tag tag)
+          (if ersetzen
+            (entmod (subst (cons 1 wert)
+                           (assoc 1 (entget obj)) (entget obj)))
+            (entmod (subst (cons 1 (strcat attr-wert wert))
+                           (assoc 1 (entget obj)) (entget obj)))
+          )
+        )
+      )
+    )
+    (setq obj (entnext obj))
+  )
+)
+
+;; Mehrere Attribute eines Blocks auf einmal setzen
+;; attrib-alist = Assoziationsliste '(("TAG1" . "Wert1") ("TAG2" . "Wert2") ...)
+(defun ssg-attrib-set-many (attrib-alist / obj typ tag wert)
+  (setq obj (entlast))
+  (while (not (equal (cdr (assoc 0 (entget obj))) "SEQEND"))
+    (setq typ (cdr (assoc 0 (entget obj))))
+    (if (equal typ "ATTRIB")
+      (progn
+        (setq tag (cdr (assoc 2 (entget obj))))
+        (setq wert (cdr (assoc tag attrib-alist)))
+        (if (and wert (> (strlen wert) 0))
+          (entmod (subst (cons 1 wert)
+                         (assoc 1 (entget obj)) (entget obj)))
+        )
+      )
+    )
+    (setq obj (entnext obj))
+  )
+)
+
+;; Attribut eines Blocks anhand seines Handle suchen und aendern
+;; handle     = Entity-Handle (String) des INSERT
+;; tag        = Attributbezeichner
+;; wert       = neuer Wert
+;; ersetzen   = T -> ersetzen; nil -> anhaengen
+(defun ssg-attrib-by-handle (handle tag wert ersetzen / e typ blk-tag blk-wert fertig)
+  (setq e      (entnext)
+        fertig nil
+  )
+  (while (and e (not fertig))
+    (setq typ (cdr (assoc 0 (entget e))))
+    (if (and (equal (cdr (assoc 5 (entget e))) handle)
+             (equal typ "INSERT")
+             (equal (cdr (assoc 66 (entget e))) 1)
+        )
+      (progn
+        (while (not (= (cdr (assoc 0 (entget e))) "SEQEND"))
+          (if (equal (cdr (assoc 0 (entget e))) "ATTRIB")
+            (progn
+              (setq blk-tag  (cdr (assoc 2 (entget e)))
+                    blk-wert (cdr (assoc 1 (entget e)))
+              )
+              (if (equal blk-tag tag)
+                (if ersetzen
+                  (entmod (subst (cons 1 wert)
+                                 (assoc 1 (entget e)) (entget e)))
+                  (entmod (subst (cons 1 (strcat blk-wert wert))
+                                 (assoc 1 (entget e)) (entget e)))
+                )
+              )
+            )
+          )
+          (setq e (entnext e))
+        )
+        (setq fertig T)
+      )
+    )
+    (setq e (entnext e))
+  )
+)
+
+
+;; ------------------------------------------------------------
+;; DIALOG-STANDARD-PATTERN
+;; Vorlage fuer DCL-Dialoge: laden, initialisieren, starten
+;; Verwendung:
+;;   (ssg-dialog-run "pfad/dialog.dcl" "dialog-name" init-fn accept-fn)
+;;
+;;   init-fn   = Funktion ohne Parameter, setzt Tiles und Actions
+;;   accept-fn = Funktion ohne Parameter, liest Tiles aus
+;; ------------------------------------------------------------
+
+(defun ssg-dialog-run (dcl-pfad dialog-name init-fn accept-fn / dat)
+  (setq dat (load_dialog dcl-pfad))
+  (if (not (new_dialog dialog-name dat))
+    (progn (alert "Dialog konnte nicht geladen werden.") (exit))
+  )
+  (if init-fn (init-fn))
+  (action_tile "accept" "(if accept-fn (accept-fn)) (done_dialog 1)")
+  (action_tile "cancel" "(done_dialog 0)")
+  (start_dialog)
+  (unload_dialog dat)
+)
+
+
+;; ------------------------------------------------------------
+;; ZOOM-HILFSFUNKTIONEN
+;; ------------------------------------------------------------
+
+;; Aktuelle View-Groesse merken
+(defun ssg-zoom-save ()
+  (setq _ssg-view-size (getvar "VIEWSIZE"))
+)
+
+;; Auf gespeicherte View-Groesse zurueckschalten (wenn veraendert)
+(defun ssg-zoom-restore ()
+  (if (and _ssg-view-size (/= (getvar "VIEWSIZE") _ssg-view-size))
+    (command "_ZOOM" "_P")
+  )
+)
+
+
+(prompt "\nssg_core.lsp geladen.")
+(princ)

Lisp/ssg_dialog.lsp

@@ -0,0 +1,165 @@
+;; ============================================================
+;; SSG_DIALOG.LSP - Standard-Pattern fuer Modul-Einfuege-Dialoge
+;; Kapselt das wiederkehrende Muster aus den ACADSST-Makros:
+;;   - DCL-Dialog mit Vorschaubild
+;;   - Radio-/List-Auswahl -> Blockname + Parameter setzen
+;;   - Block einfuegen + Attribute befuellen
+;;
+;; Setzt ssg_core.lsp voraus.
+;; Ursprung: ILS2100/*.lsp, HFS/hfs_mod.lsp (Schoenenberger)
+;; Bereinigt und verallgemeinert: 2025
+;; ============================================================
+
+
+;; ------------------------------------------------------------
+;; VORSCHAU-BILD im Dialog aktualisieren
+;; tile-name  = Name des image-Tiles im DCL (z.B. "anzeige")
+;; slide-lib  = Pfad zur .slb-Datei ohne Erweiterung (z.B. "m:/acadsst/ils2100")
+;; slide-name = Name des Slides in der Bibliothek
+;; Hintergrundfarbe -18 = AutoCAD-Grafik-Hintergrund
+;; ------------------------------------------------------------
+(defun ssg-dia-show-slide (tile-name slide-lib slide-name / breite hoehe)
+  (setq breite (dimx_tile tile-name)
+        hoehe  (dimy_tile tile-name)
+  )
+  (start_image tile-name)
+  (fill_image 0 0 breite hoehe -18)
+  (slide_image 0 0 breite hoehe (strcat slide-lib "(" slide-name ")"))
+  (end_image)
+)
+
+;; Vorschau mit Index-basierter Auswahl aktualisieren
+;; tile-name  = image-Tile-Name
+;; idx-str    = aktueller Auswahlindex als String (wie get_tile liefert)
+;; slide-lib  = Pfad zur Slide-Bibliothek
+;; slide-list = Liste der Slide-Namen, Index entspricht dem Radio-Index
+(defun ssg-dia-update-preview (tile-name idx-str slide-lib slide-list / idx)
+  (setq idx (atoi idx-str))
+  (if (and (>= idx 0) (< idx (length slide-list)))
+    (ssg-dia-show-slide tile-name slide-lib (nth idx slide-list))
+  )
+)
+
+
+;; ------------------------------------------------------------
+;; GENERISCHER MODUL-DIALOG
+;; Vereinfacht das haeufige Muster:
+;;   1. DCL laden, Tiles initialisieren
+;;   2. ACTION_TILE fuer Auswahl-Tile (aktualisiert Vorschau)
+;;   3. accept/cancel
+;;   4. Rueckgabe: ausgewaehlter Index oder nil bei Abbruch
+;;
+;; dcl-pfad   = vollstaendiger Pfad zur .dcl-Datei
+;; dialog-id  = Name des Dialogs in der .dcl
+;; select-tile= Name des List/Radio-Tiles fuer die Auswahl
+;; start-val  = Start-Auswahl als String (z.B. "0")
+;; preview-tile= Name des image-Tiles (nil = kein Vorschaubild)
+;; slide-lib  = Pfad der Slide-Bibliothek (nil = kein Vorschaubild)
+;; slide-list = Liste der Slide-Namen entsprechend Auswahl-Index
+;; extra-init = Funktion fuer weitere Tile-Initialisierungen (nil = keine)
+;; extra-read = Funktion zum Auslesen weiterer Tiles bei accept (nil = keine)
+;; ------------------------------------------------------------
+(defun ssg-modul-dialog (dcl-pfad dialog-id select-tile start-val
+                          preview-tile slide-lib slide-list
+                          extra-init extra-read
+                          / dat ergebnis aktuell)
+  (setq dat     (load_dialog dcl-pfad)
+        aktuell start-val
+  )
+  (if (not (new_dialog dialog-id dat))
+    (progn (alert "Dialog nicht verfuegbar.") (exit))
+  )
+  (set_tile select-tile start-val)
+  (if (and preview-tile slide-lib slide-list)
+    (ssg-dia-update-preview preview-tile start-val slide-lib slide-list)
+  )
+  (if extra-init (extra-init))
+  (action_tile select-tile
+    (strcat
+      "(setq aktuell (get_tile \"" select-tile "\"))"
+      (if (and preview-tile slide-lib slide-list)
+        (strcat "(ssg-dia-update-preview \"" preview-tile "\" aktuell \""
+                slide-lib "\" slide-list)")
+        ""
+      )
+    )
+  )
+  (action_tile "accept"
+    (strcat
+      "(setq ergebnis aktuell)"
+      (if extra-read "(extra-read)" "")
+      "(done_dialog 1)"
+    )
+  )
+  (action_tile "cancel" "(done_dialog 0)")
+  (start_dialog)
+  (unload_dialog dat)
+  ergebnis
+)
+
+
+;; ------------------------------------------------------------
+;; BLOCK-MODUL EINFUEGEN - Standardsequenz
+;; Kapselt das immer gleiche Muster:
+;;   1. Layer anlegen
+;;   2. Einfuegepunkt abfragen
+;;   3. Block-Kennung (eindeutiger Name) erstellen
+;;   4. Block einfuegen (mit Winkel-Abfrage oder fest)
+;;   5. Attribute setzen
+;;
+;; lay-name    = Ziel-Layer
+;; lay-color   = Layerfarbe als String
+;; blk-pfad    = vollstaendiger Blockpfad (Laufwerk + Verzeichnis + Dateiname)
+;; attrib-alist= Assoziationsliste der Attribute '(("TAG" . "Wert") ...)
+;; rotation    = Drehwinkel als String oder pause fuer Benutzerabfrage
+;; Rueckgabe   = Einfuegepunkt
+;; ------------------------------------------------------------
+(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: "))
+  (command "_insert" blk-pfad pt "" "" rotation)
+  (if attrib-alist
+    (ssg-attrib-set-many attrib-alist)
+  )
+  pt
+)
+
+
+;; ------------------------------------------------------------
+;; HAUPT-MAKRO TEMPLATE
+;; Vorlage fuer c:BEFEHL-Definitionen nach dem SSG-Muster.
+;; Kopieren und anpassen.
+;;
+;; Beispiel-Aufruf eines konkreten Moduls (nicht ausfuehren):
+;;
+;; (defun c:MEIN_MODUL ( / pt ergebnis)
+;;   (ssg-start "MEIN MODUL" '(("OSMODE")))
+;;   (setq ergebnis
+;;     (ssg-modul-dialog
+;;       (strcat lw "/acadsst/pfad/mein_dialog.dcl")
+;;       "DIALOG_NAME"
+;;       "DWG_NAME"        ; Radio/List-Tile
+;;       (if (null m_DWG_NAME) "0" m_DWG_NAME)
+;;       "anzeige"         ; Vorschau-Tile
+;;       (strcat lw "/acadsst/pfad/slb_bibliothek")
+;;       '("slide0" "slide1" "slide2")
+;;       nil               ; extra-init
+;;       nil               ; extra-read
+;;     )
+;;   )
+;;   (if ergebnis
+;;     (progn
+;;       (setq m_DWG_NAME ergebnis)
+;;       (setq pt (ssg-insert-modul "LAYER-NAME" "3"
+;;                  (strcat lw "/acadsst/pfad/block_" ergebnis)
+;;                  (list (cons "GRUPPE" "G1") (cons "ARTINR" "123456"))
+;;                  pause))
+;;     )
+;;   )
+;;   (ssg-end)
+;; )
+;; ------------------------------------------------------------
+
+
+(prompt "\nssg_dialog.lsp geladen.")
+(princ)

Lisp/ssg_layer.lsp

@@ -0,0 +1,315 @@
+;; ============================================================
+;; SSG_LAYER.LSP - Layer-Verwaltungsroutinen
+;; Interaktive Layer-Operationen: verschieben, ein/ausschalten,
+;; einfrieren, Gruppen-Management.
+;; Ursprung: ACADSST/MENU/laymr14.lsp (Schoenenberger)
+;; Bereinigt und verallgemeinert: 2025
+;; Setzt ssg_core.lsp voraus.
+;; ============================================================
+
+
+;; ------------------------------------------------------------
+;; LAYER-INFORMATION
+;; ------------------------------------------------------------
+
+;; Alle Layer als Liste von Layernamen liefern
+;; Rueckgabe: Liste von Strings
+(defun ssg-layer-list-all (/ result entry first)
+  (setq result nil
+        first  T
+  )
+  (while (setq entry (tblnext "LAYER" first))
+    (setq result (cons (cdr (assoc 2 entry)) result)
+          first  nil
+    )
+  )
+  (reverse result)
+)
+
+;; Layer-Infos als Assoziationsliste liefern
+;; Rueckgabe: Liste von (name . layer-alist) Paaren
+(defun ssg-layer-info-all (/ result entry first)
+  (setq result nil
+        first  T
+  )
+  (while (setq entry (tblnext "LAYER" first))
+    (setq result (cons (cons (cdr (assoc 2 entry)) (cdr entry)) result)
+          first  nil
+    )
+  )
+  (reverse result)
+)
+
+;; Layer-Sichtbarkeitsstatus pruefen
+;; lay-name = Layername; Rueckgabe: T wenn sichtbar, nil wenn aus/gefroren
+(defun ssg-layer-visible-p (lay-name / entry flags color)
+  (setq entry (tblsearch "LAYER" lay-name))
+  (if entry
+    (progn
+      (setq flags (cdr (assoc 70 entry))
+            color (cdr (assoc 62 entry))
+      )
+      (and (not (minusp color))      ; nicht ausgeschaltet (negativ = aus)
+           (= (logand flags 1) 0)    ; nicht gefroren (bit 0)
+      )
+    )
+  )
+)
+
+;; Pruefen ob Objekt-Layer der aktive Layer ist (Schutz vor Ausschalten)
+;; lay-name = zu pruefender Layer; ist-gruppe = T wenn Gruppen-Layer
+;; Rueckgabe: T wenn sicher (nicht aktiver Layer), nil wenn Problem
+(defun ssg-layer-safe-p (lay-name ist-gruppe)
+  (if ist-gruppe
+    (/= (substr (getvar "CLAYER") 2 2) lay-name)
+    (/= (getvar "CLAYER") lay-name)
+  )
+)
+
+
+;; ------------------------------------------------------------
+;; EINFACHE LAYER-OPERATIONEN
+;; ------------------------------------------------------------
+
+;; Layer eines angeklickten Objektes ermitteln und setzen (aktiv machen)
+;; 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: "))
+    (progn
+      (command "_LAYER" "_SET" lay "")
+      (prompt (strcat "\nAktiver Layer: " lay))
+    )
+    (ssg-emsg "Kein Objekt gewaehlt.")
+  )
+  (ssg-end)
+  lay
+)
+
+;; Layer eines Objektes anzeigen
+(defun c:SSG-LayerInfo (/ sel lay)
+  (ssg-start "Layer-Info" nil)
+  (if (setq lay (ssg-get-layer "\nObjekt waehlen: "))
+    (prompt (strcat "\nObjekt liegt auf Layer: " lay))
+    (ssg-emsg "Kein Objekt gewaehlt.")
+  )
+  (ssg-end)
+  lay
+)
+
+;; Objekte auf einen anderen Layer verschieben (interaktiv)
+(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: "))
+      (command "_CHANGE" elem "" "_PROP" "_LA" ziel-lay "")
+      (ssg-emsg "Kein Ziel-Layer gewaehlt.")
+    )
+    (ssg-emsg "Kein Objekt gewaehlt.")
+  )
+  (ssg-end)
+)
+
+;; Objekte auf einen anderen Layer kopieren und dort ablegen
+(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: "))
+      (command "_COPY" elem "" "@" "@" "_CHANGE" elem "" "_PROP" "_LA" ziel-lay "")
+      (ssg-emsg "Kein Ziel-Layer gewaehlt.")
+    )
+    (ssg-emsg "Kein Objekt gewaehlt.")
+  )
+  (ssg-end)
+)
+
+;; Alle Objekte eines Typs auf dem gleichen Layer auf neuen Layer verschieben
+;; (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): "))
+    (progn
+      (setq ref-sel (entsel "\nNochmals fuer Typ-Ermittlung anklicken: "))
+      (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: "))
+              (progn
+                (ssg-zoom-save)
+                (ssg-ss-redraw ss 3)
+                (if (not (ssg-ques (strcat "Layer dieser " ref-typ "-Objekte wechseln?") nil))
+                  (command "_CHANGE" ss "" "_PROP" "_LA" ziel-lay "")
+                  (ssg-ss-redraw ss 4)
+                )
+                (ssg-zoom-restore)
+              )
+              (ssg-emsg "Kein Ziel-Layer.")
+            )
+            (ssg-emsg "Keine passenden Objekte gefunden.")
+          )
+        )
+        (ssg-emsg "Abgebrochen.")
+      )
+    )
+    (ssg-emsg "Kein Referenz-Objekt gewaehlt.")
+  )
+  (ssg-end)
+)
+
+
+;; ------------------------------------------------------------
+;; LAYER EIN-/AUSSCHALTEN UND EINFRIEREN
+;; ------------------------------------------------------------
+
+;; 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): "))
+    (if (ssg-layer-safe-p lay nil)
+      (command "_LAYER" "_OFF" lay "")
+      (ssg-emsg "Aktiven Layer nicht ausschalten!")
+    )
+  )
+  (ssg-end)
+)
+
+;; 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): "))
+    (if (ssg-layer-safe-p lay nil)
+      (command "_LAYER" "_FR" lay "")
+      (ssg-emsg "Aktiven Layer nicht einfrieren!")
+    )
+  )
+  (ssg-end)
+)
+
+;; 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: "))
+  (if aktiv
+    (progn
+      (command "_LAYER" "_SET" aktiv "_FR" "*" "")
+      (prompt (strcat "\nNur Layer '" aktiv "' ist sichtbar."))
+    )
+    (ssg-emsg "Abgebrochen.")
+  )
+  (ssg-end)
+)
+
+;; Alle ausgefrorenen Layer wieder auftauen
+(defun c:SSG-ThawAll ()
+  (ssg-start "Alle Layer auftauen" nil)
+  (command "_LAYER" "_T" "*" "")
+  (ssg-end)
+)
+
+;; Alle ausgeschalteten Layer einschalten
+(defun c:SSG-LayerOnAll ()
+  (ssg-start "Alle Layer einschalten" nil)
+  (command "_LAYER" "_ON" "*" "")
+  (ssg-end)
+)
+
+
+;; ------------------------------------------------------------
+;; LAYER UMBENENNEN / VERSCHIEBEN (Gruppenkonzept)
+;; Im Schoenenberger-System haben Layer die Form "X-XX-Name"
+;; wobei Position 2-3 die Gruppe identifiziert.
+;; Diese Funktionen erlauben das Umbenennen der Gruppen-Kennung.
+;; ------------------------------------------------------------
+
+;; Gruppen-Buchstaben aus Layernamen extrahieren (Position 2-3)
+(defun ssg-layer-group (lay-name)
+  (substr lay-name 2 2)
+)
+
+;; Neuen Layernamen mit geaenderter Gruppen-Kennung erzeugen
+;; lay-name = original; new-grp = neue Gruppen-Kennung (2 Zeichen)
+(defun ssg-layer-rename-group (lay-name new-grp)
+  (strcat (substr lay-name 1 1) new-grp (substr lay-name 4))
+)
+
+;; Alle Objekte eines Gruppen-Layers auf neuen Gruppen-Layer verschieben
+;; old-grp = alte Gruppen-Kennung; new-grp = neue Gruppen-Kennung
+(defun ssg-layer-group-move (old-grp new-grp / all-layers entry lay-info new-name
+                                              lay-color lay-ltyp c ss i e ed)
+  (setq all-layers (ssg-layer-info-all))
+  (foreach entry all-layers
+    (if (= (ssg-layer-group (car entry)) old-grp)
+      (progn
+        (setq lay-info  (cdr entry)
+              new-name  (ssg-layer-rename-group (car entry) new-grp)
+              c         (cdr (assoc 62 lay-info))
+              lay-color (if (minusp c) (abs c) c)
+              lay-ltyp  (cdr (assoc 6 lay-info))
+        )
+        (if (not (tblsearch "LAYER" new-name))
+          (command "_LAYER" "_N" new-name "_CO" (itoa lay-color) new-name
+                   "LT" lay-ltyp new-name "")
+        )
+        (setq ss (ssg-layer-ss (car entry) nil))
+        (if ss
+          (progn
+            (setq i 0)
+            (while (setq e (ssname ss i))
+              (setq ed (entget e))
+              (entmod (subst (cons 8 new-name) (assoc 8 ed) ed))
+              (setq i (1+ i))
+            )
+          )
+        )
+      )
+    )
+  )
+)
+
+
+;; ------------------------------------------------------------
+;; LAYER LOESCHEN (mit Sicherheitsabfrage)
+;; Loescht alle Objekte auf einem Layer und danach den Layer selbst.
+;; Nur interaktiv verwenden!
+;; ------------------------------------------------------------
+(defun c:SSG-LayerDelete (/ lay ss)
+  (ssg-start "Layer loeschen" nil)
+  (initget 1)
+  (setq lay (getstring "\nLayername zum 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))
+            (progn
+              (command "_ERASE" ss "")
+              (command "_LAYER" "_OFF" lay "")
+              (command "_PURGE" "_LA" lay "N")
+              (prompt (strcat "\nLayer '" lay "' geloescht."))
+            )
+            (progn
+              (ssg-ss-redraw ss 0)
+              (prompt "\nAbgebrochen.")
+            )
+          )
+        )
+        (progn
+          (command "_LAYER" "_OFF" lay "")
+          (command "_PURGE" "_LA" lay "N")
+          (prompt (strcat "\nLeerer Layer '" lay "' geloescht."))
+        )
+      )
+    )
+    (ssg-emsg (strcat "Layer '" lay "' existiert nicht."))
+  )
+  (ssg-end)
+)
+
+
+(prompt "\nssg_layer.lsp geladen.")
+(princ)

Lisp/ssg_load.lsp

@@ -0,0 +1,30 @@
+;; ============================================================
+;; SSG_LOAD.LSP - Laderoutine fuer die SSG-Standardbibliotheken
+;;
+;; Laedt alle SSG-Kernbibliotheken in der richtigen Reihenfolge.
+;; In acad.lsp oder manuell aufrufen:
+;;   (load "pfad/ssg_load.lsp")
+;;
+;; Alternativ nur einzelne Bibliotheken laden:
+;;   (load "pfad/ssg_core.lsp")
+;;   (load "pfad/ssg_layer.lsp")
+;;   (load "pfad/ssg_dialog.lsp")
+;; ============================================================
+
+(defun ssg-load-libs (/ base-path)
+  ;; Pfad dieser Datei als Basis verwenden (AutoCAD 2000+)
+  (setq base-path
+    (if (findfile "ssg_core.lsp")
+      (substr (findfile "ssg_core.lsp") 1
+              (- (strlen (findfile "ssg_core.lsp")) (strlen "ssg_core.lsp")))
+      (strcat (getvar "DWGPREFIX"))
+    )
+  )
+  (load (strcat base-path "ssg_core.lsp")   "ssg_core.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")
+  (prompt "\nSSG-Bibliotheken geladen: ssg_core, ssg_dialog, ssg_layer")
+  (princ)
+)
+
+(ssg-load-libs)