# VarioFoerderer / Gefaellestrecke — Eingabe-Inventar und Ablauf

Bestandsaufnahme aller Eingabemoeglichkeiten der Befehle `FOERDERANLAGE`
(`c:VarioFoerderer`, Typen Standard/Etage/Linienzug) und `GEFAELLESTRECKE`
(`c:GEFAELLESTRECKE`) — als Grundlage fuer eine GUI-Neugestaltung je Gruppe.
Stand: Code in `Lisp/vf_core.lsp`, `vf_standard.lsp`, `vf_etage.lsp`,
`vf_linienzug.lsp`, `Gefaellestrecke.lsp` und die zugehoerigen DCL-Dialoge
(`dcl/variofoerderer.dcl`, `dcl/gefaellestrecke.dcl`, `dcl/vfl_edit.dcl`,
`dcl/vf_linienzug_wizard.dcl`).

## Wizard-Status (Umsetzung des Entscheidungsbaums, Abschnitt 10)

Standard und Etage waren bereits DCL-Dialoge (Abschnitte 2-3). Der komplette
Linienzug-Hauptstrang (Blocke 31-46 in Abschnitt 10) laeuft jetzt ebenfalls
ueber DCL-Dialoge statt Konsole:
`dcl/vf_linienzug_wizard.dcl` stellt zwei generische Dialoge (Zahl-Eingabe,
Mehrfachauswahl) bereit, die von JEDER Konsolen-Frage in `vf_linienzug.lsp`
wiederverwendet werden (siehe dortiger Abschnitt "WIZARD-EINGABE"). Die
Original-Konsolen-Fragen (princ + getstring/getreal/getint, de/en ueber
`ssg-text`) bleiben unveraendert im Code stehen und sind die Grundlage der
Dialoge (Menue-Optionen = Popup-Liste). Die Dialog-Kopfzeile zeigt dabei NICHT
den generischen "Ihre Wahl (1/2/3)..."-Text, sondern die eigentliche, vorher
separat per princ ausgegebene Frage (z.B. "Ist der Endpunkt der Foerderer?"):
`vfl-menu`/`vfl-menu-int` nehmen dafuer einen eigenen `frage-key`-Parameter
(ssg-text-Schluessel der Frage), der ueber `*vflw-menu-frage*` bis zu
`vflw-wahl` durchgereicht wird - ohne das wuerde der Dialog nur die
Auswahlmoeglichkeiten zeigen, nie die Frage selbst. Bei Bedarf per Befehl
`VF_WIZARD_AUS` (zurueck: `VF_WIZARD_AN`) sofort wieder reine Konsole, ohne
Codeaenderung. Journal-Replay (Editieren bestehender
Ketten ueber Doppelklick, `vfl-edit-ent`) ist davon unberuehrt: es liefert
seine Werte aus dem gespeicherten Journal, bevor der Wizard-Zweig ueberhaupt
erreicht wird. Jeder Wizard-Dialogaufruf ist zusaetzlich per
`vl-catch-all-apply` abgesichert und faellt bei jedem Fehler (fehlendes DCL,
falscher `DXFM_DCL`-Pfad etc.) automatisch auf die Konsolen-Frage zurueck.

Linienzug Modus 2 (Pfad+Zielhoehe-Solver, Blocke 50-57) laeuft seit Kurzem
ebenfalls ueber `vfl-in-point`/`-real`/`-string`/`-value` UND eine neue
Objektauswahl-Wrapper-Funktion `vfl-in-selection` (fuer die Pfad-Objekte,
Block 50) - dadurch schreibt auch Modus 2 jetzt ein Eingabe-Journal als XDATA
(Marker `"linienzug2"`) und reagiert auf Doppelklick. Anders als Modus 1
NICHT abschnittsweise editierbar (keine Glied-Marker in der Klassifizierungs-
Schleife) - Doppelklick baut die Kette stattdessen 1:1 aus dem gespeicherten
Journal neu auf ("voller Reset", `vfl-edit-ent2`), danach normal weiter
bearbeitbar/loeschbar. Die Pfad-Objektauswahl wird dabei als Liste stabiler
Entity-Handles gespeichert (neue Journal-Art `"OBJS"`) und beim Reset wieder
aufgeloest; wurden die urspruenglichen Linien/Boegen zwischenzeitlich
geloescht, meldet das der Reset klar statt eine unvollstaendige Kette zu
bauen. `vfl-in-selection` zeigt bewusst KEINEN Wizard-Dialog (Objektauswahl
braucht wie Punktwahl die Zeichnung).

**Ansicht-Refresh vor jedem Folge-Punkt** (Modus 1): `vfl-neue-linie-messen` -
die einzige Stelle, ueber die JEDE Endpunkt-Abfrage fuer ein neues Glied
laeuft (Haupt-Menue UND VF-Einheit-Fortsetzung) - schaltet vor dem Pick per
`vfl-view-refresh` auf Grundriss-Ansicht (`_PLAN` `_World`) und zoomt auf
alles Sichtbare (`_ZOOM` `_Extents`), damit das zuletzt gebaute Stueck immer
sichtbar und der naechste Punkt treffsicher anwaehlbar ist. Aendert nur die
Ansicht, nicht das aktive BKS; rein kosmetisch und per `vl-catch-all-apply`
abgesichert.

Modus 2 (Pfad+Zielhoehe-Solver) UND Modus 3 (Vorwaerts-Nachbau) sind
inzwischen ebenfalls auf Wizard-Dialoge umgestellt: beide gehen die Kette
Segment fuer Segment durch und fassen die je Segment unmittelbar
aufeinanderfolgenden Fragen (Typ + ggf. Neigung/Vario-Winkel/Variante) in
EINEM Segment-Gruppen-Dialog zusammen (siehe Tabelle unten und Abschnitt
"Segment-Highlight"). Modus 3 nutzt zusaetzlich Kettenstart- und AS-Element-
Gruppen-Dialoge (Startpunkt+Hoehe bzw. AS-Winkel+Seite). Nur der Modus-3-Bau
selbst bleibt intern Konsolen-getrieben (die vfl-in-*-Wrapper konsumieren die
Dialog-Antworten aus `*vflw-pending*`). Weiterhin reine Konsole: die
Gefaellestrecke-Konsolenmodi 2/3. Punktwahl (`getpoint`) bleibt ausserhalb
von Gruppen-Dialogen unveraendert Konsole/Zeichnung - eine Maus-Punktauswahl
braucht keinen eigenen Dialog, das BricsCAD-Prompt an der Eingabezeile
leistet bereits die vom Nutzer gewuenschte "Punkt waehlen"-Statusmeldung.

### Segment-Highlight (Modus 2 + 3)

Vor jedem Segment-Gruppen-Dialog wird die zugehoerige Pfad-Entity (LINE/ARC)
in der Zeichnung per `(redraw ename 3)` hervorgehoben und danach per
`(redraw ename 0)` zurueckgesetzt (`vfl-seg-highlight` in `vf_linienzug.lsp`).
Die Zuordnung ist direkt: `segmente[i]` (aus `gf-analysiere-kette`) und
`kette[i]` (aus `gf-sortiere-objekte`) sind 1:1 in gleicher Reihenfolge, die
Entity ist `(car (nth i kette))` als VLA-Objekt (via `vlax-vla-object->ename`
in einen Ename gewandelt). Der Dialog-Kopf zeigt zusaetzlich immer
"Segment i/n ..." (wie die Konsolen-Frage), sodass der Nutzer sieht, zu
welchem Segment die Frage gehoert. Nur aktiv bei echtem Wizard-Live-Lauf
(`vfl-wizard-aktiv`); bei abgeschalteter GUI (Tests) faellt alles auf den
Konsolen-/Replay-Pfad zurueck (kein Highlight, keine Dialoge).

### Gruppen-Dialoge (mehrere Fragen in einem Bildschirm)

Fragen, die im Ablauf IMMER unmittelbar hintereinander kommen (kein
Zwischenschritt, keine Verzweigung dazwischen), werden nicht mehr einzeln
nacheinander abgefragt, sondern in EINEM Dialog gemeinsam erfasst. Sechs
Gruppen-Dialoge PLUS die beiden generischen Einzel-Dialoge (siehe
`dcl/vf_linienzug_wizard.dcl`, Abschnitte "GRUPPEN-DIALOGE"/oben):

| Gruppe | Felder in einem Bildschirm | Ersetzt (Einzel-Screens) |
|---|---|---|
| Kettenstart | Punkt (Button) + Starthoehe | Block 31 |
| AS-Element | Ja/Nein-Toggle + Winkel + Seite (Winkel/Seite deaktiviert, solange Toggle aus) | Block 32 (+33 bei Ja) |
| GF-Bogen | Winkel(30/60/90) + Seite | Block 35 |
| ES-Element (Kettenende) | Winkel(30/90) + Seite | Block 45 |
| Vario-Kurve | Winkel(90/60/30) + Seite + Variante(aussen/innen) | Teil von Block 46 |
| Gefaelle festlegen | Modus(Hoehe/Winkel) + EIN Wertfeld (Beschriftung wechselt mit dem Modus) | Teil von Block 36 |
| Ziel-Hoehe | Zielhoehe (generischer `vflw_zahl`-Dialog, an 4 Aufrufstellen wiederverwendet: Block 36 GF-Wechsel, 37, 41/vfl-body-abschluss, 42) | Je 1 Screen |
| Horizontales Stueck | Separator VOR + Separator NACH + Foerderer-Ende (3 Optionen) | Teil von Block 38 |
| Segment Gerade (Modus 2) | Typ (GF/VF) + GF-Neigung (nur bei GF aktiv) | 2 Konsolen-Fragen/Segment (`vflw_seg_linie_m2`) |
| Segment Gerade (Modus 3) | Typ (GF/VF-Ab/VF-Auf/VF-Hor) + kontextabh. Wertfeld (GF-Neigung / Vario-Winkel / bei Hor deaktiviert) | 2 Konsolen-Fragen/Segment (`vflw_seg_linie_m3`) |
| Segment Eck/Bogen (Modus 2+3) | Typ (GF-Bogen/Vario-Kurve) + Variante (nur bei Vario-Kurve aktiv; in Modus 3 nur im offenen VF-Lauf) | 2 Konsolen-Fragen/Segment (`vflw_seg_bogen`) |

**Punktwahl-Button nur bei "Kettenstart"** (bzw. bei Modus 2s Start-/
Endpunkt): `(getpoint)` direkt aus einem offenen `action_tile`-Callback
heraus funktioniert in BricsCAD NICHT (kein Fokuswechsel zur Zeichnung, per
Test bestaetigt) - stattdessen schliesst der Button den Dialog
(`done_dialog 2`), `getpoint` laeuft danach ganz normal auf der
Kommandozeile, der Dialog wird mit dem Ergebnis neu geoeffnet
(`vflw-gruppe-punkt-hoehe-impl`, `(while (not fertig) ...)`-Schleife um
`new_dialog`/`start_dialog`). Die uebrigen Gruppen-Dialoge (Gefaelle,
Ziel-Hoehe, Horizontal-Stueck) zeigen bewusst KEINEN Punkt-Button: ihr
Endpunkt (nur X/Y, fuer die Segmentlaenge) ist an der jeweiligen
Aufrufstelle bereits VOR der Gruppe ueber `vfl-neue-linie-messen` gepickt -
dessen Z wird nirgends verwendet, die dort abgefragte Hoehe ist ein davon
unabhaengiger Zahlenwert (siehe Kommentar bei `vfl-neue-linie-messen`).

Technisch: die zugrunde liegende Aufruf-Reihenfolge in `vf-linienzug-modus`/
`vfl-*` bleibt woertlich unveraendert (weiterhin ein `vfl-in-point`/`-string`/
`-real`/`-int`/`-value`-Aufruf pro Wert, Journal-Aufzeichnung inklusive) - ein
Gruppen-Dialog fuellt vor dieser Sequenz nur eine kleine Pending-Queue
(`*vflw-pending*`), aus der jeder einzelne Aufruf transparent seinen Wert
zieht, statt live zu fragen. Bricht der Nutzer einen Gruppen-Dialog ab,
bleibt die Queue leer - die betroffenen Fragen fallen dann automatisch auf
die bestehenden Einzel-Dialoge (`vflw_zahl`/`vflw_wahl`) zurueck, kein
Sonderfall noetig.

Steuerelement-Kuerzel in den Tabellen:

| Kuerzel | Bedeutung |
|---|---|
| Dropdown | Combobox/Popup-Liste mit fester Werteliste |
| Zahl | Zahlenfeld (mm oder Grad) |
| Text | Freitextfeld |
| Toggle | Checkbox/Toggle |
| Punktwahl | Mausklick in der Zeichnung (`getpoint`/`entsel`) — laesst sich nicht durch ein reines Formularfeld ersetzen |
| Button | Aktions-Button innerhalb eines Dialogs |
| Legacy | Nur noch ueber die Kommandozeile erreichbar, kein DCL-Dialog |

---

## 1. Anlagen-Typ-Wahl (`FOERDERANLAGE`)

`c:VarioFoerderer` fragt zuerst den Typ ab, sofern keine Vorauswahl
(`*vf-vorauswahl-typ*`) gesetzt ist.

| Feld | Steuerelement | Werte | Default |
|---|---|---|---|
| Typ | Dropdown | Standard / Etage / Linienzug | Standard |

---

## 2. VF Standard (`dcl/variofoerderer.dcl`)

Zwei Dialoge nacheinander: erst Geometrie/Ausrichtung/Geruest (Dialog 1), danach
Winkel und Staustrecken-Verteilung (Dialog 2) — Dialog 2 wird erst nach der
Winkelberechnung befuellt, da seine Optionsliste von Dialog 1 abhaengt.

### Dialog 1 — Basis (`variofoerderer_basis`)

| Feld | Tile-Key | Steuerelement | Werte | Default |
|---|---|---|---|---|
| Horiz. Distanz DeltaL | `deltal` | Zahl (mm) | frei | 15000 |
| Hoehenunterschied DeltaH | `deltah` | Zahl (mm) | frei | 3000 |
| Foerderrichtung | `richtung` | Dropdown | Auf / Ab | Auf |
| Einfuegehoehe | `einfuegehoehe` | Zahl (mm) | frei | 0 |
| Fahrtrichtung | `fahrtrichtung` | Dropdown | 0 Grad (X+, Ost) / 90 Grad (Y+, Nord) / 180 Grad (X-, West) / 270 Grad (Y-, Sued) | 0 Grad |
| Seite | `seite` | Dropdown | Rechts / Links | Rechts |
| Motorseite | `motorseite` | Dropdown | Rechts / Links | Rechts |
| Darstellung | `dimension` | Dropdown | 3D / 2D | aktueller Modus |
| Geruest Einzelmodul | `geruest_einzelmodul` | Toggle | an / aus | an |
| Geruestoption | `geruest_typ` | Dropdown | siehe [Geruestoptionen](#9-wiederverwendete-bausteine) (4 Werte) | Schoenenberger Geruest |

### Dialog 2 — Winkel/Verteilung (`variofoerderer_winkel`)

| Feld | Tile-Key | Steuerelement | Werte | Default |
|---|---|---|---|---|
| Winkel | `winkel` | Dropdown | dynamisch berechnete, geometrisch gueltige Varianten (z.B. 3/6/.../horizontal), je mit L_GF/L_VF-Vorschau | kleinster gueltiger Winkel |
| Verteilung Staustrecken | `verteilung` | Dropdown | Gleichmaessig (L_GF1=L_GF2) / Vorne Minimum, hinten Rest / Hinten Minimum, vorne Rest / Eigene Werte | Gleichmaessig |
| L_GF1 vorne (manuell) | `lgf1_manuell` | Zahl (mm) | nur aktiv bei Verteilung "Eigene Werte" | L_GF / 2 |

Vorgelagert (Konsole, vor Dialog 1): Eingabemodus-Frage "3D-Linie" vs. "Werte
manuell" — nur bei Wahl "2" oeffnen sich obige Dialoge, sonst laeuft der
komplette [Legacy-Konsolen-Pfad](#8-legacy-konsolen-pfad). Direkt vor Dialog 1
wird zusaetzlich der Startpunkt (X/Y) per Punktwahl gewaehlt
(`vfs-standard-dialog-ablauf`, `Lisp/vf_standard.lsp:1069`); die Z-Hoehe kommt
aus dem Feld "Einfuegehoehe".

---

## 3. VF Etage

Nutzt exakt dieselben Dialoge wie VF Standard (`variofoerderer_basis` und
`variofoerderer_winkel`, siehe Abschnitt 2) — nur die interne
Geometrieberechnung unterscheidet sich (Etagen-Boegen statt gerader AS/ES-
Elemente). Vorgelagert:

| Feld | Steuerelement | Werte | Default |
|---|---|---|---|
| Startpunkt (X/Y) | Punktwahl | Klick in der Zeichnung | 0,0,0 |

Die Hoehe (Z) des Startpunkts kommt wie bei Standard aus dem Feld
"Einfuegehoehe" von Dialog 1 (`vfe-etage-dialog-ablauf`,
`Lisp/vf_etage.lsp:894`).

---

## 4. Gefaellestrecke (GF) (`dcl/gefaellestrecke.dcl`)

Ein Dialog fuer den manuellen Modus 1 (analog Kreisel-Dialog).

### Dialog — Gefaellestrecke (`gefaellestrecke`)

| Feld | Tile-Key | Steuerelement | Werte | Default |
|---|---|---|---|---|
| Abstand DeltaL | `deltal` | Zahl (mm) | frei | - |
| Einfuegehoehe | `einfuegehoehe` | Zahl (mm) | frei | - |
| Gefaellewinkel | `winkel` | Zahl (Grad) | 0 < Winkel <= 3 Grad | - |
| Fahrtrichtung | `fahrtrichtung` | Dropdown | 0 / 90 / 180 / 270 Grad | 0 Grad |
| Darstellung | `dimension` | Dropdown | 3D / 2D | aktueller Modus |
| AUS-Element — Winkel | `aus_winkel` | Dropdown | 90 Grad / 30 Grad | 90 Grad |
| AUS-Element — Seite | `aus_seite` | Dropdown | Links / Rechts | Links |
| EIN-Element — Winkel | `ein_winkel` | Dropdown | 90 Grad / 30 Grad | 90 Grad |
| EIN-Element — Seite | `ein_seite` | Dropdown | Links / Rechts | Links |
| Geruest Einzelmodul | `geruest_einzelmodul` | Toggle | an / aus | an |
| Geruestoption | `geruest_typ` | Dropdown | 4 Werte, siehe [unten](#9-wiederverwendete-bausteine) | Schoenenberger Geruest |
| VarioFoerderer daneben bauen | `build_vf` | Button | baut parallel 2000 mm VF, gegenlaeufig, steigend — keine Zusatzwerte | - |

Das Winkel/Seite-Paar (`aus_winkel`/`aus_seite`, `ein_winkel`/`ein_seite`)
taucht identisch auch im Linienzug als AS-/ES-Element-Baustein auf (siehe
Abschnitt 5.2).

Zusaetzlich als Legacy-Konsole vorhanden (kein Dialog):

- **Modus 2** — Startpunkt/Endpunkt waehlen: 2x Punktwahl + Gefaellewinkel
  (Zahl, aus DeltaH automatisch vorgeschlagen).
- **Modus 3** — Bestehenden Linienzug (Linien/Boegen) auswaehlen: Objektauswahl,
  Winkel wird aus der Geometrie vorgeschlagen und kann per j/n bestaetigt oder
  ueberschrieben werden.

---

## 5. VF Linienzug — Kette (Modus 1, frei zeichnend)

Kein Formular, sondern eine Serie von Konsolen-Abfragen, verzahnt mit
Punktwahl in der Zeichnung — der Nutzer baut die Kette Segment fuer Segment.
Enthaelt die Option "VF mit horizontalem Anfang". Fuer eine GUI heisst das: ein
Assistent/Wizard mit Zeichnungs-Interaktion, kein einmaliges Werteformular.

### 5.1 Ablauf

1. **Start**: Startpunkt der Kette (Punktwahl), Starthoehe (Zahl, Default = Z
   des Punkts).
2. **AS-Element setzen?** Ja/Nein — bei Ja: Winkel (30/90 Grad) + Seite
   (links/rechts), siehe Baustein 5.2.
3. **Naechstes Element waehlen** (wiederholt sich pro Segment), Menue mit bis
   zu 5 Optionen:
   - GF-Bogen (horizontale Kurve) -> Winkel 30/60/90 Grad + Seite links/rechts
   - Neue Linie: GF (Gefaellestrecke) -> Endpunkt (Punktwahl), dann Zielhoehe
     *oder* Neigungswinkel (siehe Baustein 5.2)
   - Neue Linie: Ab/Auf VF (VarioFoerderer-Einheit) -> Endpunkt (Punktwahl) +
     Zielhoehe (Zahl)
   - Neue VF mit horizontalem Anfang (Horizontal-Stueck) -> Endpunkt
     (Punktwahl) entlang der aktuellen Fahrtrichtung, danach Separator-vor/
     -nach-Fragen
   - Neue Linie BIS Kettenende (danach automatisch Separator + ES-Element)
4. **Innerhalb einer VF-Einheit** (nach dem ersten Koerper) wird pro
   weiterem Teilstueck erneut gefragt: *Ist der Endpunkt der Foerderer?*
   - Ja, nur Motorstation
   - Nein, weiterbauen -> als naechstes: horizontaler Foerderer / Vario-Kurve
     (30/60/90 Grad + Seite + aussen/innen) / Auf-Ab-Foerderer
   - Ja, Motorstation + Kettenende -> ES-Element setzen? Ja/Nein
5. **Separator-Fragen** (bei horizontalem Stueck): zusaetzlichen Separator
   VOR? Ja/Nein · NACH? Ja/Nein.
6. **Ist das Kettenende?** nach jedem GF-Segment: Ja (ES-Element) / Ja (ohne
   ES) / Nein, weiterbauen.
7. **Kettenende**: ES-Element setzen? Bei Ja: Winkel 30/90 Grad + Seite
   links/rechts (gleicher Baustein wie AS-Element).

Groessenlimits, die als Validierung statt als Eingabe wirken: VF-Einheit
< 1000 mm wird abgelehnt ("Umlenk + Motor"), Gesamtlaenge > 25 m wird
abgelehnt, GF-Neigung > 3 Grad wird abgelehnt bzw. auf 3 Grad begrenzt.

### 5.2 Wiederkehrende Bausteine

Diese vier Eingabegruppen tauchen mehrfach in der Kette auf (und teils auch in
GF/Standard) — lohnt sich als eigene GUI-Komponente.

**AS-/ES-Element**

| Feld | Steuerelement | Werte |
|---|---|---|
| Winkel | Dropdown | 90 Grad / 30 Grad |
| Seite | Dropdown | links / rechts |

**GF-Bogen**

| Feld | Steuerelement | Werte |
|---|---|---|
| Winkel | Dropdown | 30 / 60 / 90 Grad |
| Seite | Dropdown | links / rechts |

**Vario-Kurve**

| Feld | Steuerelement | Werte |
|---|---|---|
| Winkel | Dropdown | 90 / 60 / 30 Grad |
| Seite | Dropdown | links / rechts |
| Variante | Dropdown | Aussen / Innen |

**Gefaelle festlegen (Linie "GF")**

| Feld | Steuerelement | Werte |
|---|---|---|
| Endpunkt | Punktwahl | entlang Fahrtrichtung |
| Modus | Dropdown | Gegebene Zielhoehe / Neigungswinkel eingeben |
| -> Zielhoehe | Zahl (mm) | bei Modus "Zielhoehe" |
| -> Neigungswinkel | Zahl (Grad) | 0 < Winkel <= 3 Grad, bei Modus "Winkel" |

---

## 6. VF Linienzug — Modus 2 und 3 (fortgeschritten / Legacy)

Zwei alternative Einstiege in `c:VarioFoerderer` -> Typ "Linienzug". Beide
arbeiten auf bereits in der Zeichnung vorhandener Geometrie statt auf freier
Klick-Eingabe — fuer eine GUI eher Import/Solver-Werkzeuge als klassische
Formulare.

### Modus 2 — Pfad + Zielhoehe (Solver)

| Feld | Steuerelement | Werte |
|---|---|---|
| Pfad-Objekte | Objektauswahl | Linien + Boegen der geplanten Trasse |
| Startpunkt + Hoehe | Punktwahl + Zahl | hoehere Seite der Kette |
| Endpunkt + Zielhoehe | Punktwahl + Zahl | Ziel der Kette |
| Je gerades Segment: Typ | Dropdown | GF (Eingabe-Winkel) / VF (Bruecke) |
| -> GF-Neigung | Zahl (Grad) | Default 3 Grad, Maximum 3 Grad |
| Je Bogen-Segment: Typ | Dropdown | GF-Bogen / Vario-Kurve |
| -> Vario-Kurve-Variante | Dropdown | Aussen / Innen |
| GF-Verteilung | Dropdown | alles am Einlauf (GF1) / 1/2 GF1 + 1/2 GF2 |

### Modus 3 — Vorwaerts-Nachbau (Legacy, wird umgebaut)

| Feld | Steuerelement | Werte |
|---|---|---|
| Startpunkt (3D) | Punktwahl | KS_EIN AUS-Element / Kettenanfang |
| Gefaellewinkel | Zahl (Grad) | wird auch aus 2 gewaehlten 3D-Punkten vorgeschlagen |
| AUS-Element Seite | Dropdown | links / rechts |
| Separator vor EIN? | Dropdown | Ja/Nein |
| Einfuegen bestaetigen | Dropdown | Ja/Nein |

---

## 7. Editieren / Fortsetzen / Zusammenfuegen

**Linienzug editieren** (`dcl/vfl_edit.dcl`)

| Feld | Steuerelement | Werte |
|---|---|---|
| Zuruecksetzen zu Sektion | Dropdown | jedes Journal-Glied der Kette (GF-Bogen, GF, VF, horizontal-VF, Linie bis Ende, offen) |

Kuerzt die Kette stumm auf die gewaehlte Sektion, danach laeuft der normale
interaktive Linienzug-Ablauf weiter (Abschnitt 5).

**Vario_Kette_Merge**

| Feld | Steuerelement | Werte |
|---|---|---|
| Start-Block der Kette | Objektauswahl | ein VF_n/GF_n-Block, ab dem ueber KS_AUS->KS_EIN-Nachbarschaft zusammengefuehrt wird |

Einzige Eingabe — Rest laeuft automatisch (Attribute aggregiert, Luecken
werden gemeldet).

**VF_SEKTION_RESTORE — lose Kette aus der Zeichnung wiederherstellen**

| Feld | Steuerelement | Werte |
|---|---|---|
| Lose Linienzug-Geometrie | Objektauswahl (`ssget`) | die Einzelteile der Kette (Bloecke, Linien, Boegen) |
| Startpunkt / Starthoehe / AS | nur bei Altbestand ohne Praeambel-XDATA | `getpoint` / `getreal` / Ja-Nein + Winkel + Seite |

Wofuer: bleibt eine Kette als **lose Geometrie ohne `VF_n`-Block** liegen (der
Block war beim Editieren schon per `entdel` weg, der Neuaufbau brach ab und
konnte nicht gewickelt werden), ist sie nicht mehr per Doppelklick editierbar.
Die Eingaben stecken aber weiterhin in der Zeichnung:

| XDATA-App | Traeger | Inhalt |
|---|---|---|
| `SSG_VF_EDIT` | `VF_n`-Block | volles Ketten-Journal (Marker `linienzug`/`linienzug2`) |
| `SSG_VF_EDIT_SEG` | jedes Entity | Journal-Abschnitt **der Iteration**, in der es entstand, indiziert mit dem **ersten** Glied-Index darin |
| `SSG_VF_EDIT_PRE` | Entities des ersten Gliedes | Praeambel (Startpunkt, Starthoehe, AS ja/nein + Winkel/Seite) |

`VF_SEKTION_RESTORE` liest die Sektionen der Auswahl, haengt sie
lueckenlos ab Glied 1 aneinander (ein Sektions-Record kann **mehrere** Glieder
enthalten — eine VF-Einheit mit eingebetteten Vario-Kurven legt pro Kurve ein
eigenes STEP ab, der naechste erwartete Index ist daher
`erster Index + Anzahl Glieder im Record`), spielt das Journal stumm ab und
baut danach normal weiter. Die alte Geometrie wird **erst nach erfolgreichem**
Neuaufbau geloescht — bricht der Bau ab, bleibt sie samt XDATA stehen und der
Versuch ist wiederholbar.

Grenzen: nur Modus 1 (Modus 2 schreibt keine Sektions-XDATA); bei einer Luecke
wird nur der lueckenlose Anfang wiederhergestellt und die fehlende Sektion
gemeldet. Ketten, die vor der Umstellung auf Iterations-Abschnitte gebaut
wurden, haben unvollstaendige Sektions-XDATA (eine VF-Einheit hinterliess nur
die Slice ihrer letzten Vario-Kurve) und sind daher nur bis zur ersten Luecke
wiederherstellbar.

Die `.dbg`-Dateien sind **reine Ausgabe** und werden von keinem Befehl
gelesen — sie werden bei jedem Lauf neu angelegt (`dbgopen` oeffnet mit `"w"`).
Wiederherstellungs-Daten gehoeren ausschliesslich in die XDATA der Zeichnung.

---

## 8. Legacy-Konsolen-Pfad

Wird bei Standard/Etage durchlaufen, wenn auf die Eingabemodus-Frage *nicht*
"2" getippt wird (Enter/leer faellt ebenfalls hierher zurueck) — also aktuell
noch der Vorgabe-Pfad. Zwei Untermodi:

**3D-Linie auswaehlen**

| Feld | Steuerelement | Werte |
|---|---|---|
| Linie/Polylinie | Objektauswahl | liefert DeltaL, DeltaH, Fahrtrichtung automatisch aus der Geometrie |

**Werte manuell eingeben**

| Feld | Steuerelement | Werte |
|---|---|---|
| DeltaL / DeltaH | Zahl (mm) | Defaults 15000 / 3000 |
| Foerderrichtung | Dropdown | Auf/Ab |
| Startpunkt | Punktwahl | - |
| Fahrtrichtung | Dropdown | 0 / 90 / 180 / 270 Grad |

Danach identisch fuer beide Untermodi: Seite (rechts/links) -> Winkelwahl,
falls mehrere gueltig sind (nummerierte Liste) -> Staustrecken-Verteilung (4
Optionen, bei "Eigene Werte" zusaetzlich L_GF1 als Zahl) -> Bestaetigung
"Einfuegen? Ja/Nein".

---

## 8b. Nicht-interaktiver Betrieb (Headless)

Fuer Tests, Batch-Nachbau und den geplanten Spec-Bau (Fahrplan:
`doc/TODO-plan-vf-interactive.md`) muss eine Kette **ohne** Dialog und ohne
Konsolenfrage laufen. Drei Schalter greifen dabei ineinander:

| Schalter | Datei | Wirkung |
|---|---|---|
| `*ssg-gui-aus*` (`ssg-gui-aus`/`-an`/`ssg-gui-p`) | `ssg_core.lsp` | DCL-/Wizard-Dialoge aus, Module fallen auf ihren Konsolen-/`get*`-Pfad zurueck |
| `*vfl-wizard-mode*` (`VF_WIZARD_AUS`) | `vf_linienzug.lsp` | Linienzug-Assistent aus (die `vflw-*`-Dialoge) |
| `*vfl-headless*` (`vfl-headless-p`) | `vf_linienzug.lsp` | **keine Live-Eingabe mehr**: eine erschoepfte Replay-Queue wird zum harten Abbruch statt zum stillen Rueckfall auf `getpoint`/`getreal` |

Der dritte Schalter ist der entscheidende. Ein Replay
(`vfl-journal-replay-start`) liefert die Werte nur so lange, wie die Queue
reicht; danach fragten die `vfl-in-*`-Wrapper bisher **stillschweigend** live
weiter - im Batch ein Haenger ohne Hinweis, wo der Ablauf von den Daten
abgewichen ist. Mit `*vfl-headless*` = T bricht statt dessen
`vfl-headless-abbruch` ab und legt in `*vfl-headless-fehler*` die Fundstelle
ab (Art der Eingabe, Glied-Nummer, Eingabe-Nummer). Eingebaut ist der Riegel
an den vier Eingabe-Engstellen: `vfl-in-value`, `vfl-in-value-p` (deckt
`vfl-in-point`/`-string`/`-real`/`-int` und alle `vfl-menu*` ab),
`vfl-in-selection` (Objektauswahl: auch eine unvollstaendige Handle-Aufloesung
bricht ab - eine Teilauswahl wuerde die Fragenzahl des Modus-2-Ablaufs still
verschieben) und `vfl-in-abstand` (eigene Zwei-Eintrags-Logik: DL, und beim
ersten Segment die Richtung).

Optional darf `*vfl-headless-antwort-fn*` eine Rueckfrage doch noch
beantworten (`(fn was ort)` -> Wert). Gedacht fuer die eine nicht
vorhersagbare Frage: `vfl-waehle-winkel` fragt nur dann, wenn mehrere
Winkel-Kandidaten geometrisch gueltig sind, was von der real gemessenen
Restlaenge abhaengt. Jede so gelieferte Antwort wird protokolliert, damit ein
solcher Lauf nicht als "sauber" durchgeht.

**Meldungen statt Alerts**: die Bau-Pfade melden abgewiesene Sektionen jetzt
ueber `vfl-meldung` (Text nach `*vfl-meldungen*` + `dbgmsg`, dann `alert` nur
bei erlaubter GUI, sonst `princ`). Interaktiv sieht das unveraendert aus; im
Batch blockiert nichts mehr und der Text - die einzige Auskunft, *welche*
Sektion warum nicht baubar war - bleibt erhalten. Die reinen Interaktiv-Alerts
(fehlende DCL-Datei, "Glied nicht editierbar", "kein Journal") sind bewusst
`alert` geblieben. `vfl-journal-reset` loescht `*vfl-meldungen*` und
`*vfl-headless-fehler*` mit: beides gehoert zum einzelnen Lauf.

### Spec-Pfad: Kette aus Eingabedaten (`VF_SPEC_BAU`)

Auf dem Headless-Rahmen sitzt `Lisp/vf_spec.lsp`. Eine **Spec** beschreibt
eine Kette in Domaenenwerten statt in Menue-Codes:

```json
{ "spec_id": "VF_spec_LZ_01", "modus": 1,
  "start_punkt": [4912.2, 1230.9, 2154.0], "start_hoehe": 2154.0,
  "as": 1, "as_winkel": "90", "as_seite": "links" }
{ "glied": "Linie-GF", "nr": 1, "dl": 2249.3, "hz": 90.0,
  "gefaelle": "winkel", "winkel": 3.0, "ende": "nein" }
{ "glied": "Horizontal-VF", "nr": 2, "dl": 3256.9,
  "gf_verteilung": "einlauf", "vf_sep_vor": 0, "vf_sep_nach": 0,
  "vf_ende": "nein", "vf_separator": 0 }
{ "sub": "vario-kurve", "winkel": 90, "seite": "rechts", "variante": "innen" }
{ "sub": "motorstation" }
{ "glied": "ES", "winkel": "90", "seite": "links" }
```

Flach, weil `ssg-load-json` zeilenweise liest; Wahrheitswerte als `1`/`0`.
`vsp-journal` uebersetzt das in ein Eingabe-Journal, `vsp-bau-aus-spec`
spielt es per `vfl-journal-replay-start` durch den **unveraenderten**
`vf-linienzug-modus`. Der fertige Block traegt danach dasselbe
`SSG_VF_EDIT`-Journal wie eine handgebaute Kette.

Drei Regeln, die der Uebersetzer besitzen muss (sie sind der Grund, warum die
Spec nicht einfach "die Antworten" ist):

1. **Der Menue-Code haengt am Frame.** Nur die erste Sektion laeuft ohne
   Frame und bekommt 4 Optionen (kein GF-Bogen - es gibt noch keine Richtung,
   an die er anschliessen koennte), jede spaetere 5. `Linie-GF` ist also in
   Sektion 1 der Code `"1"`, ab Sektion 2 der Code `"2"`.
2. **`hz` steht genau einmal im Journal**, beim allerersten Segment
   (`vfl-in-abstand` journalisiert die gesnappte Richtung nur bei freier
   Richtungswahl). Ein `hz` an spaeterer Stelle verschiebt die ganze
   Replay-Queue - darum ein harter Spec-Fehler.
3. **Der erste Koerper einer VF-Einheit** stellt nur dann Separator- und
   Endpunktfragen vorab, wenn er HORIZONTAL ist (`winkel1 = 0` in
   `vfl-vf-einheit` laeuft durch `vfl-baue-horizontal-koerper`). Ein
   gewinkelter Erstkoerper (`Linie-VF`, `Linie` -> VF) wird ohne jede Frage
   gebaut.

Nicht vorhersagbar bleibt die Winkelwahl: `vfl-waehle-winkel` fragt nur, wenn
mehrere Kandidaten geometrisch gueltig sind, was von der real gemessenen
Restlaenge abhaengt. Dafuer das optionale Feld `winkel_idx`; fehlt es und der
Bau braucht die Antwort, greift der Headless-Riegel und nennt Glied und
Eingabe-Nummer. Geraten wird nichts.

Ergebnis je Kette als Record (`tests/output/vf_spec_results.json`): `status`
(`executed`/`warnung`/`desync`/`abbruch`/`spec-fehler`), Block, Handle,
Einfuegepunkt, Attribute, `eingaben_offen`, `prompts` (muss 0 sein),
`glieder_soll` gegen `glieder_ist` und die gesammelten `meldungen`. Der
Glied-Vergleich ist der Desync-Detektor, der auch dann greift, wenn die Queue
aufgeht: eine geometrisch abgewiesene Sektion wirft keinen Fehler, sie
verbraucht nur weniger Eintraege.

Gegenstueck in Python: `lib/vf_spec_export.py` enthaelt denselben Emitter
PLUS die Umkehrung und erzeugt daraus die Spec-Testdaten. Der Rundlauf
`Journal -> Spec -> Journal` laeuft in `tests/test_vf_spec.py` gegen die 5
echten HundM-Ketten - er beweist, dass die Spec das Journal verlustfrei
abbildet. Modus 2 und 3 haben noch keinen Uebersetzer (Modus 2 braucht erst
echte `"linienzug2"`-Journale als Referenz).

Beispiel: `tests/test_hm_recformat.lsp` (5 echte Ketten aus `data/polylines.dxf`)
setzt alle drei Schalter mit Save/Restore, ersetzt `getpoint`/`getstring`/
`getint`/`getreal`/`alert` zusaetzlich durch **zaehlende** Stubs (Netz fuer
Prompts ausserhalb der Wrapper) und schreibt `prompts`, `headless_fehler` und
`meldungen` in `tests/output/hm_recformat_results.json`. Noch nicht umgestellt:
`vfl-konvertiere-ent` (Batch-2D/3D-Konvertierung) laeuft weiter ohne
`*vfl-headless*` - dort ist eine Live-Rueckfrage bisher gewolltes Verhalten.

---

## 9. Wiederverwendete Bausteine

**Geruestoptionen** (`*ssg-geruest-optionen*` in `ssg_core.lsp`, auch bei
Kreisel/Eckrad verwendet)

| Feld | Steuerelement | Werte | Default |
|---|---|---|---|
| Geruest fuer Einzelmodul | Toggle | an / aus | an |
| Geruestoption | Dropdown | IPE-Geruest abgestuft / Obergeruest oben / Schoenenberger Geruest / nur Doppelrohrtraeger | Schoenenberger Geruest |

---

## 10. Entscheidungsbaum

Jeder Block ist ein moeglicher Wizard-Screen. "Weiter mit" listet die
Blocknummer(n), zu denen von hier aus verzweigt werden kann. Rueckverweise auf
eine bereits genannte, kleinere Nummer (z.B. 34 -> 35 -> 34) sind Schleifen
(iteratives Weiterbauen), keine Fehler in der Nummerierung.

### Baum A — Befehl `FOERDERANLAGE`

| Nr | Block | Eingaben | Weiter mit |
|---|---|---|---|
| 1 | Befehl waehlen | FOERDERANLAGE / GEFAELLESTRECKE | 2, 40 |
| 2 | Anlagen-Typ | Standard / Etage / Linienzug | 3, 3, 30 |
| 3 | Eingabemodus (nur Standard/Etage) | Konsole / Dialog | 4, 10 |
| 4 | Startpunkt waehlen | Punktwahl | 5 |
| 5 | Dialog "Basis" | DeltaL, DeltaH, Auf/Ab, Einfuegehoehe, Fahrtrichtung, Seite, Motorseite, 2D/3D, Geruest | 6 |
| 6 | Winkelberechnung (automatisch) | - | 7 |
| 7 | Dialog "Winkel/Verteilung" | Winkel, Verteilung, ggf. L_GF1 | 8 |
| 8 | Bau (automatisch) | - | ENDE |
| 10 | Eingabemodus Konsole | 3D-Linie / Werte | 11, 12 |
| 11 | 3D-Linie waehlen | Objektwahl -> DeltaL/DeltaH/Fahrtrichtung automatisch | 13 |
| 12 | Werte eingeben | DeltaL, DeltaH, Auf/Ab, Startpunkt, Fahrtrichtung | 13 |
| 13 | Seite waehlen | rechts/links | 14 |
| 14 | Winkel waehlen | automatisch bei 1 Treffer, sonst Liste | 16 |
| 16 | Staustrecken-Verteilung | 4 Optionen, ggf. L_GF1 manuell | 17 |
| 17 | Bestaetigung "Einfuegen?" | Ja/Nein | 8 |
| 30 | Linienzug-Modus | Manuell / Pfad+Zielhoehe / Vorwaerts-Nachbau | 31, 50, 55 |
| 31 | Startpunkt + Starthoehe | Punktwahl + Zahl | 32 |
| 32 | AS-Element setzen? | Ja/Nein | 33, 34 |
| 33 | AS-Element | Winkel 30/90, Seite | 34 |
| 34 | Naechstes Element waehlen | 5 Optionen | 35, 36, 37, 38, 39 |
| 35 | GF-Bogen | Winkel 30/60/90, Seite | 34 (Schleife) |
| 36 | GF | Endpunkt, Zielhoehe/Neigungswinkel | 41 |
| 37 | Auf/Ab-VF starten | Endpunkt, Zielhoehe | 42 |
| 38 | Horizontal-VF starten | Endpunkt (+ Separator vor/nach inline) | 42 |
| 39 | Bis Kettenende | Endpunkt | 45 |
| 41 | Kettenende-Frage (nach GF) | Ja+ES / Ja ohne ES / Nein | 45, ENDE, 34 (Schleife) |
| 42 | Ist Endpunkt der Foerderer? | nur Motor / weiterbauen / +Kettenende | 34, 46, 45 |
| 45 | ES-Element setzen | Winkel 30/90, Seite | ENDE |
| 46 | Sub-Element in VF-Einheit | horizontal / Vario-Kurve / Auf-Ab | 42 (Schleife) |
| 50 | Pfad-Objekte waehlen | Linien + Boegen | 51 |
| 51 | Startpunkt + Starthoehe | Punktwahl + Zahl | 52 |
| 52 | Endpunkt + Zielhoehe | Punktwahl + Zahl | 53 |
| 53 | je gerades Segment: Typ | GF/VF (+GF-Neigung) | 54 |
| 54 | je Bogen-Segment: Typ | GF-Bogen/Vario-Kurve (+aussen/innen) | 56 |
| 56 | GF-Verteilung | 2 Optionen | 57 |
| 57 | Bau (automatisch) | - | ENDE |
| 55 | Startpunkt | Punktwahl | 58 |
| 58 | Gefaellewinkel | Zahl, Vorschlag aus 2 Punkten | 59 |
| 59 | AUS-Element Seite | links/rechts | 60 |
| 60 | Separator vor EIN? | Ja/Nein | 61 |
| 61 | Bestaetigung "Einfuegen?" | Ja/Nein | ENDE |

### Baum B — Befehl `GEFAELLESTRECKE`

| Nr | Block | Eingaben | Weiter mit |
|---|---|---|---|
| 40 | GF-Modus | Dialog / Start+Endpunkt / Bestehenden Linienzug | 70, 75, 80 |
| 70 | Dialog "Gefaellestrecke" | DeltaL, Hoehe, Winkel, AUS/EIN Winkel+Seite, Geruest, Button "VF daneben bauen" | 71 |
| 71 | Bau (automatisch) | - | ENDE |
| 75 | Startpunkt | Punktwahl | 76 |
| 76 | Endpunkt | Punktwahl | 77 |
| 77 | AUS-Element | Winkel/Seite | 78 |
| 78 | EIN-Element | Winkel/Seite | 79 |
| 79 | Bestaetigung "Einfuegen?" | Ja/Nein | ENDE |
| 80 | Pfad-Objekte waehlen | Objektauswahl | 81 |
| 81 | Berechneten Winkel uebernehmen? | j/n (n -> Winkel-Zahl) | 82 |
| 82 | AUS-Element | Winkel/Seite | 83 |
| 83 | EIN-Element | Winkel/Seite | 84 |
| 84 | Bestaetigung "Einfuegen?" | Ja/Nein | ENDE |

### Beispiel-Abfolgen

- Standard, Dialog-Pfad: `1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8`
- Standard, Legacy-Konsole mit 3D-Linie: `1 -> 2 -> 3 -> 10 -> 11 -> 13 -> 14 -> 16 -> 17 -> 8`
- Etage, Dialog-Pfad: `1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8`
- Linienzug — AS-Element, GF, Auf/Ab-VF mit Zwischenkurve, Kettenende:
  `1 -> 2 -> 30 -> 31 -> 32 -> 33 -> 34 -> 36 -> 41 -> 34 -> 37 -> 42 -> 46 -> 42 -> 45`
- Linienzug — horizontaler Anfang direkt bis Kettenende:
  `1 -> 2 -> 30 -> 31 -> 32 -> 34 -> 38 -> 42 -> 45`
- Gefaellestrecke per Dialog: `1 -> 40 -> 70 -> 71`
- Gefaellestrecke ueber Start-/Endpunkt: `1 -> 40 -> 75 -> 76 -> 77 -> 78 -> 79`

---

## 11. GUI-Konzept-Empfehlung (Assistent + Punktwahl)

- Ein einziger schrittweiser Assistent ist sinnvoll — die Blocknummern in
  Abschnitt 10 sind bereits fast 1:1 die Wizard-Screens. Verzweigungen/
  Schleifen (z.B. Linienzug 34<->35, 42<->46) werden zu bedingten Spruengen
  zum passenden Screen statt einer starren linearen Abfolge. **Umgesetzt**
  fuer den Linienzug-Hauptstrang (Blocke 31-46) — siehe "Wizard-Status" oben
  und `dcl/vf_linienzug_wizard.dcl`.
- **Punktwahl-Integration**: ein Button pro Punkt-Feld, der im Ruhezustand
  leer ist und nach Auswahl X/Y/Z daneben anzeigt. Klick aktiviert einen
  "Punktwahl-Modus" mit Statuszeile/Hinweis am unteren Rand ("Punkt
  waehlen..."), bis der Benutzer in die Zeichnung klickt — danach zurueck ins
  Formular. Dieses Muster deckt alle "Punktwahl"-Felder im Entscheidungsbaum
  ab. **Umsetzung:** bewusst NICHT als eigener DCL-Dialog gebaut — BricsCAD
  zeigt den `getpoint`-Prompt bereits direkt am Fadenkreuz/an der
  Befehlszeile, was exakt die gewuenschte "Punkt waehlen"-Statusmeldung ist;
  ein zusaetzlicher Dialog wuerde hier nur im Weg stehen (siehe naechster
  Punkt).
- **Einschraenkung**: Solange BricsCAD synchron auf `getpoint`/`entsel`
  wartet, kann die Formular-Oberflaeche waehrend der Punktwahl nicht
  gleichzeitig bedienbar sein — die Statuszeile ersetzt den heutigen
  Konsolen-Prompt, das Formular selbst bleibt aber bis zur Auswahl gesperrt
  (modal), genau wie heute die Kommandozeile blockiert.