diff --git a/CLAUDE.md b/CLAUDE.md index 4a592fa..6e3ebf6 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -77,7 +77,7 @@ Die `start_briscad.bat` ruft `setenv.bat` auf und startet BricsCAD. | Omniflo (komplett) | `OmniModulInsert` | OMNI_APB_*, OMNI_W*_*, OMNI_AP*, OMNI_TEF_*, OMNI_TV_*, OMNI_EDIT | | Connections | `Connection_Edit` + `SSG_LIB_Commands` | CONNECTION_INSERT, CONNECTION_EDIT, ILS_EINGANG_INSERT, ILS_AUSGANG_INSERT | | Export | `export` | EXPORTSIVAS, EXPORTCSV, CALLPYTHON | -| Konfiguration | `SSG_LIB_Commands` | SSG_DIM_SWITCH, SSG_SPRACHE | +| Konfiguration | `SSG_LIB_Commands` + `DrawPlanquadrate` | SSG_DIM_SWITCH, SSG_SPRACHE, PLANQUADRATE_TOGGLE (DRAW_PLANQUADRATE/DELETE_PLANQUADRATE) | | Doppelklick/Kontextmenue | `SSG_LIB_Commands` | SSG_BLOCKEDIT (dispatcht Kreisel->KreiselEdit, Omniflo->OMNI_EDIT, GF_*->GEFAELLESTRECKE_EDIT, VF_*->VARIOFOERDERER_EDIT) | ### Entfernte Legacy-Dateien @@ -107,6 +107,7 @@ Detaillierte Dokumentation aller Funktionen und Befehle: siehe `Lisp/README.md`. | `SSG_LIB_Commands.lsp` | ILS_BTMT_Beladung, ILS_BTMT_Entladung, ILS_SCANNER_INSERT, ILS_SEPARATOR_INSERT, ILS_EINGANG_INSERT, ILS_AUSGANG_INSERT, ILS_ETF_*, ILS_GK*_*, SSG_BLOCKEDIT, SSG_DIM_SWITCH, SSG_SPRACHE | BTMT Be-/Entladung (`ils-insert-station`: wiederholtes Einfuegen von `BTMT-Beladung` bzw. `SC_Entladung`, Drehung interaktiv, Layer aus `LAYER`-Attribut, Dimension via `ssg-ils-block-laden`) + Sensoren (`ils-insert-sensor`) + Eingang-/Ausgang-Symbol (frei platzierbar wie BTMT Be-/Entladung, ueber `ils-insert-station` mit den Rohnamen `Eingang`/`Ausgang`, Bloecke `Eingang_.dwg`/`Ausgang_.dwg` in data/ils) + Dummy-Befehle fuer Menue + Doppelklick/Kontextmenue-Dispatcher + Konfiguration (2D/3D, Sprache) | | `Tro_Edit.lsp` | TRO_INSERT, TRO_EDIT | TRO-Marker (Block `TRO_SYM_`) fuer sps_skel (lib/tro_annotate.py): TRO_INSERT fuegt eine bestehende Blockdefinition an einem gewaehlten Punkt ein und setzt ID/TYPE (bricht ab, wenn der Typ noch keine Blockdefinition in der Zeichnung hat - die entsteht nur ueber tro_annotate.py); TRO_EDIT aendert ID/TYPE eines bestehenden Markers per Dialog. Typliste aus `tro_types.lsp` (von `tro_annotate.py --emit-lisp` nach DXFM_LISP geschrieben). Der Dispatcher SSG_BLOCKEDIT leitet Blocknamen `TRO_*` zu TRO_EDIT. | | `menu-inventory.lsp` | MenuInventory | BricsCAD Diagnostik (Menuegruppen, Plugins, Startdateien) | +| `DrawPlanquadrate.lsp` | DRAW_PLANQUADRATE, DELETE_PLANQUADRATE, PLANQUADRATE_TOGGLE | Zeichnet auf Z=0 ein Planquadrat-Linienraster (senkrecht/waagerecht) ueber die aktuellen Zeichnungs-Extents, im Abstand/Zaehlschema der aktiven `[Planquadrate]`-Konfiguration aus `cfg/export.cfg` (dieselbe Quelle wie `lib/export_planquadrat.py` fuer den CSV-Export) - Ursprung (Index 1) aus `x_origin`/`y_origin` bzw. Fallback EXTMIN. Spalten-/Zeilenzahl wird IMMER aufgerundet auf volle Rasterschritte (nicht auf die exakte Extent-Grenze), damit alle senkrechten Linien auf der letzten waagerechten enden und umgekehrt - das Raster bildet immer ein geschlossenes Rechteck. Zaehlung (alphabetisch/numerisch je Achse) als Text am linken/unteren Rand. Das fertige Raster (Linien+Texte) wird per `_.-BLOCK`/`_.INSERT` zu einem einzigen Block `ZZ_PLANQUADRATE` bei (0,0,0) zusammengefasst. Layer aus `cfg/layer.cfg` (`[allgemein]` Key `planquadrate`, Fallback `ZZ_Planquadrate`). DRAW_PLANQUADRATE entfernt vor dem Neuaufbau zuerst einen evtl. vorhandenen Block (`plq-block-entfernen`: INSERTs loeschen + `_-PURGE _B`), DELETE_PLANQUADRATE ruft nur diese Entfernung auf. PLANQUADRATE_TOGGLE ("Planquadrate an/aus", Menue: Konfiguration) prueft per `tblsearch`/`ssget "X"`, ob der Block existiert, und dispatcht auf Zeichnen bzw. Loeschen. Lazy geladen ueber `(ssg-ensure "DrawPlanquadrate")`, nicht in der Core-Ladereihenfolge. | ## DCL-Dialoge diff --git a/Lisp/DrawPlanquadrate.lsp b/Lisp/DrawPlanquadrate.lsp new file mode 100644 index 0000000..381b39a --- /dev/null +++ b/Lisp/DrawPlanquadrate.lsp @@ -0,0 +1,276 @@ +;; ============================================================ +;; DrawPlanquadrate.lsp - Planquadrat-Raster in die Zeichnung zeichnen +;; +;; Zeichnet auf Hoehe Z=0 senkrechte Linien (konstantes X) und waagerechte +;; Linien (konstantes Y) im Abstand der aktiven Planquadrat-Konfiguration aus +;; cfg/export.cfg ([Planquadrate] section=... -> [Planquadrate_AN] o.ae., +;; siehe export:cfg/export:load-cfg in export.lsp) - dieselbe Konfiguration, +;; nach der export_planquadrat.py (lib/) das Planquadrat eines Bauteils fuer +;; den CSV-Export berechnet. Am linken Rand steht je Zeile, am unteren Rand +;; je Spalte die zugehoerige Zaehlung (alphabetisch oder numerisch, je nach +;; x_description/y_description). +;; +;; Bereich: die aktuellen Zeichnungs-Extents (EXTMIN/EXTMAX), aber IMMER auf +;; ein ganzzahliges Vielfaches der Schrittweite ab dem Ursprung aufgerundet - +;; das Raster bildet also stets ein GESCHLOSSENES Rechteck: jede senkrechte +;; Linie endet exakt auf der letzten waagerechten und umgekehrt (kein +;; "Ueberstand" einzelner Linien ueber die letzte volle Zeile/Spalte hinaus). +;; x_origin/y_origin aus [Planquadrate] legen die Koordinate von Index 1 fest +;; (wie im CSV-Export); sind sie leer, faellt der Ursprung auf EXTMIN zurueck +;; (= kleinstes X/Y der Zeichnung, analog zur Auto-Ermittlung in +;; export_planquadrat.resolve_origins). +;; +;; Das fertige Raster (Linien + Beschriftungstexte) wird zu EINEM Block +;; (*plq-blockname*) zusammengefasst und bei (0,0,0) eingefuegt - dadurch +;; laesst sich das gesamte Planquadrat mit einem Klick auswaehlen/loeschen. +;; Bei jedem Aufruf wird ein evtl. vorhandener Planquadrat-Block zuerst +;; entfernt (DELETE_PLANQUADRATE-Logik) und danach neu gezeichnet - +;; wiederholte Aufrufe erzeugen also keine Dubletten. +;; +;; Befehle: +;; DRAW_PLANQUADRATE - Raster zeichnen/neu aufbauen +;; DELETE_PLANQUADRATE - Raster-Block entfernen (inkl. Blockdefinition) +;; PLANQUADRATE_TOGGLE - "Planquadrate an/aus": zeichnet, falls noch kein +;; Block in der Zeichnung ist, sonst loescht es ihn +;; (Menue: Konfiguration) +;; ============================================================ + +(vl-load-com) + +;; Name der zusammenfassenden Blockdefinition. Fest (keine laufende Nummer): +;; es gibt je Zeichnung immer hoechstens ein Planquadrat-Raster. +(setq *plq-blockname* "ZZ_PLANQUADRATE") + +;; --- Layer fuer das Planquadrat-Raster --- +;; cfg/layer.cfg [allgemein] Key "planquadrate"; ohne Eintrag Fallback-Name. +(defun plq-layer ( / lay) + (setq lay (ssg-layer-anlegen "planquadrate" T)) + (if (null lay) + (progn + (setq lay "ZZ_Planquadrate") + (ssg-make-layer lay "8" T) + ) + ) + lay +) + +;; Alle INSERTs des Planquadrat-Blocks in der Zeichnung loeschen und die +;; Blockdefinition entfernen (PURGE) - macht die Zeichnung frei fuer einen +;; sauberen Neuaufbau bzw. ist die komplette Logik von DELETE_PLANQUADRATE. +;; Rueckgabe: Anzahl geloeschter INSERTs. +(defun plq-block-entfernen ( / ss i n) + (setq n 0) + (if (tblsearch "BLOCK" *plq-blockname*) + (progn + (setq ss (ssget "X" (list (cons 0 "INSERT") (cons 2 *plq-blockname*)))) + (if ss + (progn + (setq i 0) + (while (< i (sslength ss)) + (entdel (ssname ss i)) + (setq i (1+ i)) + (setq n (1+ n)) + ) + ) + ) + (command "_-PURGE" "_B" *plq-blockname* "_N") + ) + ) + n +) + +;; 1-basierten Index in eine Buchstaben-Bezeichnung wandeln (1=A, 26=Z, +;; 27=AA, ... wie Excel-Spalten) - Gegenstueck zu _index_to_alpha in +;; lib/export_planquadrat.py. +(defun plq-index-alpha (n / result rest) + (setq result "") + (while (> n 0) + (setq rest (rem (1- n) 26)) + (setq result (strcat (chr (+ 65 rest)) result)) + (setq n (/ (- n 1 rest) 26)) + ) + result +) + +;; Label fuer einen 1-basierten Index, alpha-p = T -> Buchstaben, sonst Zahl. +(defun plq-label (n alpha-p) + (if alpha-p (plq-index-alpha n) (itoa n)) +) + +;; Inline-Kommentar (" # ...") von einem Config-Wert abschneiden. Der +;; gemeinsame INI-Parser (ssg-ini-get/ssg-load-ini, ssg_core.lsp) behandelt +;; nur ganze Zeilen ab "#" als Kommentar - die [Planquadrate_*]-Sektionen in +;; cfg/export.cfg nutzen aber INLINE-Kommentare hinter x_description/ +;; y_description (z.B. "alphabetisch # Buchstaben, ..."), analog zu +;; lib/export_blockpatterns.py (configparser mit inline_comment_prefixes). +(defun plq-strip-comment (s / pos) + (setq pos (vl-string-search "#" s)) + (if pos (vl-string-trim " \t" (substr s 1 pos)) (vl-string-trim " \t" s)) +) + +;; Zeichnet eine Linie auf dem aktuellen Layer. +(defun plq-line (p1 p2) + (entmake (list + '(0 . "LINE") + (cons 10 p1) + (cons 11 p2) + )) +) + +;; Zeichnet einen zentrierten Text an insertPoint. +(defun plq-text (str insertPoint hoehe) + (entmake (list + '(0 . "TEXT") + (cons 10 insertPoint) + (cons 40 hoehe) + (cons 1 str) + (cons 50 0.0) + '(72 . 1) + '(73 . 2) + (cons 11 insertPoint) + )) +) + +;; ============================================================ +;; DRAW_PLANQUADRATE - Raster zeichnen/neu aufbauen +;; ============================================================ +(defun c:DRAW_PLANQUADRATE ( / section x-step x-alpha y-step y-alpha + ext-min ext-max x-origin y-origin + x0 y0 x1 y1 lay hoehe n-x n-y i x y + label textabstand lastEnt ss e) + (ssg-start "DRAW_PLANQUADRATE" '(("OSMODE"))) + (setvar "OSMODE" 0) + + (if (null *export-cfg*) (export:load-cfg)) + (setq section (export:cfg "Planquadrate" "section" "")) + + (if (or (null section) (= section "")) + (princ (ssg-text "plq-keine-konfiguration")) + (progn + (setq x-step (* 1000.0 (atof (export:cfg section "x_step" "1")))) + (setq y-step (* 1000.0 (atof (export:cfg section "y_step" "1")))) + (setq x-alpha (wcmatch (strcase (substr (plq-strip-comment (export:cfg section "x_description" "numerisch")) 1 5)) "ALPHA*")) + (setq y-alpha (wcmatch (strcase (substr (plq-strip-comment (export:cfg section "y_description" "numerisch")) 1 5)) "ALPHA*")) + + (if (or (<= x-step 0.0) (<= y-step 0.0)) + (princ (ssg-text "plq-ungueltige-schrittweite")) + (progn + ;; Vorhandenes Raster zuerst entfernen (Block + Definition) - + ;; wiederholte Aufrufe erzeugen so keine Dubletten. + (plq-block-entfernen) + + (setq ext-min (getvar "EXTMIN")) + (setq ext-max (getvar "EXTMAX")) + + (setq x-origin (export:cfg "Planquadrate" "x_origin" "")) + (setq x-origin (if (and x-origin (/= x-origin "")) (* 1000.0 (atof x-origin)) (car ext-min))) + (setq y-origin (export:cfg "Planquadrate" "y_origin" "")) + (setq y-origin (if (and y-origin (/= y-origin "")) (* 1000.0 (atof y-origin)) (cadr ext-min))) + + (setq x0 x-origin) + (setq y0 y-origin) + + ;; Anzahl Spalten/Zeilen: mind. 1, sonst so viele volle Schritte, + ;; bis die Zeichnungs-Extents (mind.) abgedeckt sind - AUFGERUNDET, + ;; damit x1/y1 exakt auf einem Rasterschritt liegen. Damit endet + ;; JEDE senkrechte Linie exakt auf der letzten waagerechten (bei + ;; y1) und jede waagerechte exakt auf der letzten senkrechten (bei + ;; x1) - das Raster bildet immer ein geschlossenes Rechteck. + (setq n-x (max 1 (fix (+ 0.999999 (/ (- (car ext-max) x0) x-step))))) + (setq n-y (max 1 (fix (+ 0.999999 (/ (- (cadr ext-max) y0) y-step))))) + + (setq x1 (+ x0 (* n-x x-step))) + (setq y1 (+ y0 (* n-y y-step))) + + (setq lay (plq-layer)) + + (setq hoehe (atof (export:cfg "Planquadrate" "text_hoehe_mm" "300"))) + (setq textabstand (* hoehe 1.5)) + + ;; Letztes Entity VOR dem Zeichnen merken, um danach per entnext + ;; genau die neu erzeugten Objekte einzusammeln (wie + ;; kreisel-make-label/draw-module in KreiselInsert.lsp). + (setq lastEnt (entlast)) + + ;; Senkrechte Linien (konstantes X) + Spalten-Beschriftung unten. + (setq i 0) + (while (<= i n-x) + (setq x (+ x0 (* i x-step))) + (plq-line (list x y0 0.0) (list x y1 0.0)) + (if (< i n-x) + (progn + (setq label (plq-label (1+ i) x-alpha)) + (plq-text label (list (+ x (/ x-step 2.0)) (- y0 textabstand) 0.0) hoehe) + ) + ) + (setq i (1+ i)) + ) + + ;; Waagerechte Linien (konstantes Y) + Zeilen-Beschriftung links. + (setq i 0) + (while (<= i n-y) + (setq y (+ y0 (* i y-step))) + (plq-line (list x0 y 0.0) (list x1 y 0.0)) + (if (< i n-y) + (progn + (setq label (plq-label (1+ i) y-alpha)) + (plq-text label (list (- x0 textabstand) (+ y (/ y-step 2.0)) 0.0) hoehe) + ) + ) + (setq i (1+ i)) + ) + + ;; --- Neu erzeugte Entities einsammeln und zu einem Block zusammenfassen --- + (setq ss (ssadd)) + (if (null lastEnt) (setq e (entnext)) (setq e (entnext lastEnt))) + (while e + (ssadd e ss) + (setq e (entnext e)) + ) + (if (> (sslength ss) 0) + (progn + (command "_.-BLOCK" *plq-blockname* (list 0.0 0.0 0.0) ss "") + (command "_.INSERT" *plq-blockname* (list 0.0 0.0 0.0) 1 1 0) + ) + ) + + (princ (ssg-textf "plq-fertig" (list (itoa n-x) (itoa n-y) lay))) + ) + ) + ) + ) + + (ssg-end) + (princ) +) + +;; ============================================================ +;; DELETE_PLANQUADRATE - Raster-Block entfernen +;; ============================================================ +(defun c:DELETE_PLANQUADRATE ( / n) + (ssg-start "DELETE_PLANQUADRATE" nil) + (setq n (plq-block-entfernen)) + (if (> n 0) + (princ (ssg-textf "plq-geloescht" (list (itoa n)))) + (princ (ssg-text "plq-nichts-zu-loeschen")) + ) + (ssg-end) + (princ) +) + +;; ============================================================ +;; PLANQUADRATE_TOGGLE - "Planquadrate an/aus": zeichnet das Raster, falls +;; noch keines in der Zeichnung existiert, sonst entfernt es das bestehende. +;; ============================================================ +(defun c:PLANQUADRATE_TOGGLE ( / vorhanden) + (setq vorhanden (and (tblsearch "BLOCK" *plq-blockname*) + (ssget "X" (list (cons 0 "INSERT") (cons 2 *plq-blockname*))))) + (if vorhanden + (c:DELETE_PLANQUADRATE) + (c:DRAW_PLANQUADRATE) + ) + (princ) +) + +(princ "\n>>> DrawPlanquadrate.lsp geladen. Befehle: DRAW_PLANQUADRATE, DELETE_PLANQUADRATE, PLANQUADRATE_TOGGLE") +(princ) diff --git a/cfg/export.cfg b/cfg/export.cfg index 325a949..712bde3 100644 --- a/cfg/export.cfg +++ b/cfg/export.cfg @@ -78,6 +78,12 @@ section=Planquadrate_AN x_origin= y_origin= +# Texthoehe (mm) der Zaehlungs-Beschriftung am linken/unteren Rand des +# Planquadrat-Rasters, siehe Lisp/DrawPlanquadrate.lsp (DRAW_PLANQUADRATE). +# Nur fuer diesen Lisp-Befehl relevant, nicht fuer den CSV-/Sivas-Export. +# Default 300, falls nicht gesetzt. +text_hoehe_mm=300 + # hier kann man im csv Export aus den Koordinaten der Bauteile die Planquadrate berechnen lassen, in denen sie liegen # Zählung ist numerisch oder Alphabetisch möglich, Schrittweite in m (z.B. 2m pro Spalte, 4m pro Zeile) # liegt man im ersten Quadrat, ist diese A/1, oder 1/1 oder 1/A, je nach Formatierung. Die Zählung beginnt immer bei 1 diff --git a/cfg/layer.cfg b/cfg/layer.cfg index aabaa9b..6a208ae 100644 --- a/cfg/layer.cfg +++ b/cfg/layer.cfg @@ -152,6 +152,10 @@ vf_beschriftung = VF_Beschriftung, 7 # Beschriftungstext der Gefaellestrecke. gf_beschriftung = GF_Beschriftung, 7 +# Planquadrat-Raster (Linien + Zaehlungs-Beschriftung), siehe +# Lisp/DrawPlanquadrate.lsp (DRAW_PLANQUADRATE). +planquadrate = ZZ_Planquadrate, 8 + # ============================================================ # Farben fuer Layer OHNE Baugruppen-Key diff --git a/lang/de_DE.json b/lang/de_DE.json index bf9079f..bd1e8df 100644 --- a/lang/de_DE.json +++ b/lang/de_DE.json @@ -566,6 +566,11 @@ "core-blockname-exists": "Blockname '%1' existiert bereits - wird uebersprungen.", "core-dwg-not-found": "\nFEHLER: Block nicht gefunden: %1", "exp-cfg-not-found": "\n[export] WARNUNG: %1 nicht gefunden/leer, verwende Vorgaben.", + "plq-keine-konfiguration": "\n[DRAW_PLANQUADRATE] WARNUNG: Keine [Planquadrate]-Konfiguration in cfg/export.cfg gefunden - Abbruch.", + "plq-ungueltige-schrittweite": "\n[DRAW_PLANQUADRATE] WARNUNG: x_step/y_step muessen groesser 0 sein - Abbruch.", + "plq-fertig": "\n[DRAW_PLANQUADRATE] Raster gezeichnet: %1 Spalten x %2 Zeilen auf Layer '%3'.", + "plq-geloescht": "\n[DELETE_PLANQUADRATE] Planquadrat-Raster entfernt (%1 Einfuegung(en)).", + "plq-nichts-zu-loeschen": "\n[DELETE_PLANQUADRATE] Kein Planquadrat-Raster in der Zeichnung vorhanden.", "exp-check-ids": "\n[%1] Pruefe und vergebe IDs...", "exp-sep-proxy-fehler": "\n[EXPORT] WARNUNG: Kopie des verpackten Separators '%1' aus Block '%2' fehlgeschlagen (%3) - dieser Separator fehlt im Export.", "exp-sep-zuordnung": "\n[%1] verpackte Separator-Kopie(n): ZUORDNUNG aus der ID des Wrapper-Blocks gesetzt.", diff --git a/lang/en_GB.json b/lang/en_GB.json index b6c3011..b564d06 100644 --- a/lang/en_GB.json +++ b/lang/en_GB.json @@ -566,6 +566,11 @@ "core-blockname-exists": "Block name '%1' already exists - skipping.", "core-dwg-not-found": "\nERROR: Block not found: %1", "exp-cfg-not-found": "\n[export] WARNING: %1 not found/empty, using defaults.", + "plq-keine-konfiguration": "\n[DRAW_PLANQUADRATE] WARNING: no [Planquadrate] configuration found in cfg/export.cfg - aborting.", + "plq-ungueltige-schrittweite": "\n[DRAW_PLANQUADRATE] WARNING: x_step/y_step must be greater than 0 - aborting.", + "plq-fertig": "\n[DRAW_PLANQUADRATE] Grid drawn: %1 columns x %2 rows on layer '%3'.", + "plq-geloescht": "\n[DELETE_PLANQUADRATE] Planquadrat grid removed (%1 insertion(s)).", + "plq-nichts-zu-loeschen": "\n[DELETE_PLANQUADRATE] No Planquadrat grid found in the drawing.", "exp-check-ids": "\n[%1] Checking and assigning IDs...", "exp-sep-proxy-fehler": "\n[EXPORT] WARNING: copying the packed separator '%1' out of block '%2' failed (%3) - this separator is missing from the export.", "exp-sep-zuordnung": "\n[%1] packed separator copy/copies: ZUORDNUNG set from the wrapper block ID.", diff --git a/lib/export_sivas.py b/lib/export_sivas.py index 6b63fa7..9aff485 100644 --- a/lib/export_sivas.py +++ b/lib/export_sivas.py @@ -303,15 +303,11 @@ SEP_SCANNER_PATTERNS = ( ) # Sivas-Nummern und Bezeichnungen je ILS-Elementtyp -# Hinweis: "ils_kurve", sind aktuell nur -# Typnamen-Platzhalter - die zugehoerigen Menuebefehle sind noch Dummies -# (siehe Lisp/README.md), es gibt noch keine Block-Erkennung dafuer. ILS_SIVASNR = { "kreisel": ("6200", "ILS 2.0 Kreisel"), "eckrad": ("6210", "ILS 2.0 Eckrad"), "zusatzmodul": ("6215", "ILS 2.0 Zusatzmodul"), "ils_weiche": ("6216", "ILS 2.0 Weiche"), - "ils_kurve": ("", "ILS 2.0 Kurve"), "strecke": ("6220", "ILS 2.0 Strecke"), "gefaellestrecke": ("6220", "ILS 2.0 Gefaellestrecke"), "bt_beladung": ("6215", "BT - Beladung (mit Vereinzeler, ohne Separator)"), diff --git a/menu/SSG_LIB.cui b/menu/SSG_LIB.cui index a15dafc..eeacf5c 100644 --- a/menu/SSG_LIB.cui +++ b/menu/SSG_LIB.cui @@ -614,115 +614,121 @@ ^C^C(ssg-ensure "SSG_LIB_Commands") SSG_SPRACHE - + + + Planquadrate an/aus + ^C^C(ssg-ensure "DrawPlanquadrate") PLANQUADRATE_TOGGLE + + + alle Tests ausfuehren und exportieren ^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_run_all.lsp")) SSG_RUN_ALL_TESTS_EXPORT - + Tests ausfuehren und stehen lassen ^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_run_all.lsp")) SSG_RUN_ALL_TESTS_OFFEN - + Export CSV/Sivas ALL ^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_export_all.lsp")) TEST_EXPORT_ALL - + Kreisel ^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_kreisel.lsp")) TEST_KREISEL - + Foerderer ^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_foerderer.lsp")) TEST_FOERDERER - + Foerderer-Linienzug ^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_linienzug.lsp")) TEST_LINIENZUG - + Omniflo ^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_omniflo.lsp")) TEST_OMNIFLO - + Omniflo Strecke ^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_omniflo_strecke.lsp")) TEST_OMNIFLO_STRECKE - + Gefaellestrecke ^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_gefaellestrecke.lsp")) TEST_GEFAELLESTRECKE - + Mubea Gesamtmodell ^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_mubea.lsp")) TEST_MUBEA - + HundM05 Kreisel-Abschnitt ^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_hundm05.lsp")) TEST_HUNDM05 - + KS 2D/3D pruefen (CSV) ^C^C(load (strcat (getenv "DXFMAKRO") "/Lisp/ks_pruefung.lsp")) KS_PRUEFEN - + Kreisel bearbeiten (ssg-ensure "KreiselInsert") KreiselEdit - + Omniflo Element bearbeiten (ssg-ensure "OmniModulInsert") OMNI_EDIT - + Gefaellestrecke bearbeiten (ssg-ensure "Gefaellestrecke") GEFAELLESTRECKE_EDIT - + VarioFoerderer bearbeiten (ssg-ensure "VarioFoerderer") VARIOFOERDERER_EDIT - + TRO-Marker bearbeiten (ssg-ensure "Tro_Edit") TRO_EDIT - + Verbindung bearbeiten (ssg-ensure "Connection_Edit") CONNECTION_EDIT - + SSG Bearbeiten (Auto) (ssg-ensure "SSG_LIB_Commands") SSG_BLOCKEDIT @@ -742,7 +748,7 @@ - + ILS @@ -1441,6 +1447,12 @@ + + Planquadrate an/aus + + + + Konfiguration Schliessen @@ -1448,126 +1460,126 @@ - + Tests alle Tests ausfuehren und exportieren - - - - - - Tests ausfuehren und stehen lassen - Export CSV/Sivas ALL + Tests ausfuehren und stehen lassen + + Export CSV/Sivas ALL + + + + Kreisel - + Foerderer - + Foerderer-Linienzug - + Omniflo - + Omniflo Strecke - + Gefaellestrecke - + Mubea Gesamtmodell - + HundM05 Kreisel-Abschnitt - + KS 2D/3D pruefen (CSV) - + - + POP501 SSG_LIB Edit Context Kreisel bearbeiten - + Omniflo Element bearbeiten - + Gefaellestrecke bearbeiten - + VarioFoerderer bearbeiten - + TRO-Marker bearbeiten - + Verbindung bearbeiten - + SSG Bearbeiten (Auto) - + diff --git a/menu/SSG_LIB.mnu b/menu/SSG_LIB.mnu index 1a1fc47..bb2688e 100644 --- a/menu/SSG_LIB.mnu +++ b/menu/SSG_LIB.mnu @@ -130,6 +130,7 @@ [Alle Bloecke auf 2D]^C^C(ssg-ensure "SSG_LIB_Commands") SSG_DIM_ALL_2D [Alle Bloecke auf 3D]^C^C(ssg-ensure "SSG_LIB_Commands") SSG_DIM_ALL_3D [Sprache]^C^C(ssg-ensure "SSG_LIB_Commands") SSG_SPRACHE +[Planquadrate an/aus]^C^C(ssg-ensure "DrawPlanquadrate") PLANQUADRATE_TOGGLE [<-Konfiguration Schliessen]^C^C [->Tests] [alle Tests ausfuehren und exportieren]^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_run_all.lsp")) SSG_RUN_ALL_TESTS_EXPORT