# RhinoPanel — Projektdokumentation für Claude

## Was ist das?

Ein React-Plugin für Rhino 8 (Mac) das als schwebendes Fenster läuft und Architektur-Workflows aus Vectorworks/ArchiCAD nachbildet. Die React-UI wird in Rhinos Eto.Forms WebView über `LoadHtml` (inline) eingebettet.

## Kommunikation React ↔ Python

**React → Python:** `document.title = "RHINOMSG::{json}"` (queue-basiert, 80ms delay)
**Python → React:** `webview.ExecuteScript("window.onRhinoMessage({...})")` 

Nachrichten-Typen:
- `APPLY` — Ebenen auf Rhino anwenden, GH triggern
- `LAYER_VISIBILITY` — Layer sofort ein/ausblenden
- `LAYER_LOCK` — Layer sperren/entsperren
- `SET_ACTIVE` — Aktiven Rhino-Layer setzen
- `STATE_SYNC` — Python → React, beim Panel-Start

## Datenmodell

```json
[
  {"id": "eg",  "name": "EG",  "type": "grundriss", "hoehe": 3.50, "schnitthoehe": 1.00, "okff": 0.00},
  {"id": "1og", "name": "1OG", "type": "grundriss", "hoehe": 3.00, "schnitthoehe": 1.00, "okff": 3.50},
  {"id": "saa", "name": "Schnitt A-A", "type": "schnitt"},
  {"id": "nor", "name": "Nordansicht", "type": "ansicht"}
]
```

Gespeichert in `doc.Strings["rhinopanel_ebenen"]` (JSON). OKFF wird nur für `type: "grundriss"` berechnet (kumulativ). Schnitt/Ansicht haben keine Höhenparameter.

## Rhino Layer-Hierarchie

```
10_GRUNDRISSE
  └── EG
      ├── 01_WAND          (schwarz,  lw 0.50)
      ├── 02_TUER_FENSTER  (blau,     lw 0.25)
      ├── 03_MOEBEL        (grau,     lw 0.13)
      ├── 04_TEXT          (hellgrau, lw 0.13)
      ├── 05_TREPPEN       (gold,     lw 0.35)
      └── 06_3D_VOLUMEN    (lila,     lw 0.25)
  └── 1OG (gleiche Sublayer)
20_SCHNITTE
  └── Schnitt A-A
      ├── 21_PROFIL  (rot,       lw 0.70)
      ├── 22_WAND    (orange,    lw 0.25)
      └── 23_TEXT    (hellgrau,  lw 0.13)
30_ANSICHTEN
  └── Nordansicht
      ├── 31_FASSADE (türkis, lw 0.35)
      └── 32_TEXT    (hellgrau, lw 0.13)
00_RASTER, 01_VERMESSUNG, 40_SITUATION, 90_REFERENZEN, 99_KONSTRUKTION
```

## Dateistruktur

```
rhino-panel/
├── src/
│   ├── App.jsx                      # Hauptkomponente, State-Management
│   ├── main.jsx                     # Entry point, window.onerror handler
│   ├── index.css                    # Dark theme, CSS-Variablen (Swiss minimal)
│   ├── lib/
│   │   └── rhinoBridge.js           # Kommunikation React↔Python
│   └── components/
│       ├── EbenenManager.jsx        # Zeichnungsebenen-Liste (GR/SC/AN Badges)
│       ├── EbenenDialog.jsx         # Dialog zum Bearbeiten der Ebenen
│       ├── LayerPanel.jsx           # Layer-Sichtbarkeit/Sperre togglen
│       ├── BottomBar.jsx            # "Auf Rhino anwenden" Button
│       └── Section.jsx              # Ausklappbarer Abschnitt
├── rhino/
│   ├── rhinopanel.py                # Panel starten, Bridge, LoadHtml-Inline
│   ├── layer_builder.py             # Rhino-Layer erstellen/aktualisieren
│   └── INSTALL.md                   # Setup-Anleitung inkl. GH
├── dist/                            # Gebaute App (npm run build)
└── vite.config.js                   # base: './' wichtig für file:// URLs
```

**Alte Dateien (nicht mehr aktiv, können gelöscht werden):**
- `src/components/GeschossManager.jsx` — ersetzt durch EbenenManager
- `src/components/GeschossDialog.jsx`  — ersetzt durch EbenenDialog

## Kritische technische Details

### Warum LoadHtml statt file:// URL
Rhinos WKWebView blockiert `<script type="module">` bei `file://` URLs (CORS/module restrictions). Lösung: Python liest `dist/index.html`, inliniert CSS und JS, lädt via `webview.LoadHtml(html)`. JS wird in `DOMContentLoaded` eingewickelt damit `#root` existiert wenn React rendert.

### Warum Idle-Event für URL-Loading
`LoadHtml` in `__init__` läuft bevor der WebView in einem Fenster ist → React kann nicht in DOM rendern. Fix: `Rhino.RhinoApp.Idle` Event wartet bis Fenster sichtbar ist.

### Warum kein Docking
`RegisterPanel` schlägt fehl: `"constructor must accept uint, RhinoDoc or no params"`. IronPython `*args` befriedigt Rhinos .NET-Reflection nicht. Panel läuft daher als schwebendes `forms.Form`.

### IronPython 2 Limitierungen
- `# -*- coding: utf-8 -*-` Header in allen .py Dateien
- Keine Umlaute in Strings (ue/oe/ae statt ü/ö/ä)
- `e.Title` statt `webview.Title` im DocumentTitleChanged Handler

## Grasshopper-Anbindung

Wenn "Anwenden" gedrückt wird:
1. `layer_builder.build_layers()` erstellt/aktualisiert Rhino-Layer
2. JSON wird in `doc.Strings["rhinopanel_ebenen"]` gespeichert
3. `canvas.Document.NewSolution(True)` triggert GH-Neuberechnung

**GH Python-Komponente (eine Komponente, Output `a`):**
```python
import json, Rhino, Rhino.Geometry as rg
doc = Rhino.RhinoDoc.ActiveDoc
raw = doc.Strings.GetValue("rhinopanel_ebenen")
ebenen = json.loads(raw) if raw else []
a = []
for e in ebenen:
    if e.get("type") != "grundriss": continue
    idx = doc.Layers.FindByFullPath("10_GRUNDRISSE::{}::01_WAND".format(e["name"]), -1)
    if idx < 0: continue
    for obj in doc.Objects.FindByLayer(doc.Layers[idx]):
        crv = obj.Geometry
        if not isinstance(crv, rg.Curve): continue
        c = crv.DuplicateCurve()
        c.Transform(rg.Transform.Translation(0, 0, e.get("okff", 0)))
        ext = rg.Extrusion.Create(c, e["hoehe"], c.IsClosed)
        if ext: a.append(ext.ToBrep())
```
Für Live-Updates: GH `Timer` Komponente (1000ms) mit Python-Komponente verbinden.

## Design-System

Dark theme, Swiss minimal, inspiriert von rapport.kgva.ch.
CSS-Variablen in `index.css`. Wichtigste:
- `--bg-base: #1c1c1e` — Hintergrund
- `--accent: #5a9e5a` — Grün (Anwenden-Button)
- `--active: #3a5f8a` — Blau (aktive Ebene)
- `--font: 'Inter'` — via Google Fonts

Typ-Badges: GR=blau `#3a6fa8`, SC=orange `#c87050`, AN=türkis `#50c8a0`

## Workflow Panel starten

```bash
npm run build   # nach Code-Änderungen
```

In Rhino (bei Änderungen am Python-Code):
```python
import scriptcontext as sc
sc.sticky["rhinopanel_registered"] = False
sc.sticky["rhinopanel_form"] = None
```
→ `_RunPythonScript` → `rhinopanel.py`

## Nächste mögliche Schritte

- **Docking**: Rhino 8 RhinoCode (Python 3) statt IronPython verwenden — hat andere Panel-Registration API
- **Live-Vorschau**: Rhino `ObjectAdded`/`ObjectModified` Events in rhinopanel.py für automatischen GH-Trigger ohne Anwenden-Button
- **Schnittlinien**: Für SC-Ebenen Schnittlinie/Position als Parameter hinzufügen
- **Layerpanel dynamisch**: LayerPanel.jsx zeigt aktuell statische Layer-Gruppen — soll dynamisch aus `ebenen`-State kommen
- **2D-Fills**: Schraffuren/Füllungen für Wände (Vectorworks-ähnlich)
- **Viewport-Zuweisung**: Grundrisse/Schnitte/Ansichten einem Rhino-Detailbild zuweisen