SidebarLayout

RailLayout

Grundgerüst einer Anwendung: Kopfzeile oben, links eine schmale Leiste mit Symbolen, rechts der Inhalt. Für Anwendungen mit wenigen Hauptbereichen, deren Unterpunkte als Flyout aus der Leiste aufklappen. Ist das Layout schmaler als 48rem, wird die Leiste zur Schublade hinter einem Menüknopf. Die Komponente ist als äußerstes Element im MainLayout gedacht, deshalb wird sie hier als eigenes Layout gezeigt und nicht in der Seite eingebettet.

Live ansehen

Schaltet die Demo auf das Layout „RailLayout“ um (auch über den Layout-Umschalter oben). Fenster schmal ziehen, um den Menüknopf zu sehen.

Aktives Layout: SidebarComponentLayout

Aufbau im MainLayout

Brand und Actions in der Kopfzeile, Rail links, @Body in ChildContent. Für die Leiste passt ein vertikales FlyoutMenu mit IconOnly="true"; die Leiste scrollt nicht, damit Flyouts nach rechts aufklappen.

<RailLayout>
    <Brand>
        <SmartLink Href="/"><strong>Meine App</strong></SmartLink>
    </Brand>
    <Rail>
        <FlyoutMenu Items="_menue" IconOnly="true" OpenOnHover="true" />
    </Rail>
    <Actions>
        <Button Icon="add" Title="Neu" ButtonStyle="OoColorPalette.Neutral.Ghost" />
    </Actions>
    <ChildContent>@Body</ChildContent>
</RailLayout>
<Toaster />
<DialogHost />

Parameter & CSS-Variablen

@bind-RailOpen (optional), RailWidth (Standard 3rem), CloseOnNavigation (Standard true), MenuButtonTitle, DrawerWhenNarrow (Standard true; false blendet die Leiste schmal samt Menüknopf aus, wenn die Anwendung dort eine eigene Navigation hat, etwa eine Leiste unten), StickyHeader (Standard true; false lässt die Kopfzeile am Handy mit der Seite wegscrollen). Am Inhaltsbereich stehen --oo-rl-header-offset und --oo-rl-content-height für klebende Elemente und bildschirmfüllende Seiten bereit; --oo-rl-header-height setzt die Höhe der Kopfzeile (Standard 3rem).

<RailLayout @bind-RailOpen="_leisteOffen"
            RailWidth="3.5rem"
            CloseOnNavigation="false"
            style="--oo-rl-header-height: 3.5rem; --oo-rl-backdrop: rgb(0 0 0 / 0.4)">
    …
</RailLayout>

Bedienung & Barrierefreiheit

Im Layout „RailLayout“ bei schmalem Fenster ausprobieren.

  • Der Menüknopf links in der Kopfzeile schiebt die Leiste als Schublade über den Inhalt, meldet den Zustand per aria-expanded und setzt den Fokus hinein; ein zweiter Klick schließt sie.
  • Escape schließt die Schublade und gibt den Fokus an den Menüknopf zurück; ebenso schließt ein Klick auf den Schleier daneben.
  • Jede Navigation schließt sie, außer bei CloseOnNavigation="false".
  • Eingeklappt ist die Leiste unsichtbar und wird von Tab übersprungen.
  • Auf Touch-Geräten bis 48rem Breite oder im Querformat scrollt die Seite statt des Inhaltsbereichs; die Kopfzeile klebt oben.
SKILL.md – Raillayout
---
name: RailLayout
description: Onesown Blazor Komponente RailLayout (FlexGrid). Verwende diesen Skill wenn du die RailLayout-Komponente verwenden, konfigurieren oder debuggen moechtest.
---

# RailLayout

**Namespace:** `Onesown.Blazor.Components`  
**Kategorie:** FlexGrid  
**Basisklasse:** `OoComponentBase`  

Grundgerüst einer Anwendung mit Kopfzeile oben, einer schmalen Leiste (Rail) links und dem Inhalt rechts daneben – für Anwendungen mit wenigen Hauptbereichen, die als Symbole in der Leiste stehen und ihre Unterpunkte als Flyout zeigen. Der Inhalt füllt den Rest und scrollt. Ist das Layout schmal, wird die Leiste zur Schublade, die ein Menüknopf in der Kopfzeile öffnet.

**Live-Demo:** https://components.schini.com/demo/raillayout  

## Parameter

| Parameter | Typ | Standard | Beschreibung |
|---|---|---|---|
| ``Brand`` | ``RenderFragment`` |  | Links in der Kopfzeile, etwa Logo und Name der Anwendung als Link zur Startseite. Immer sichtbar. |
| ``Rail`` | ``RenderFragment`` |  | Inhalt der schmalen Leiste links, etwa ein vertikales FlyoutMenu mit IconOnly="true". Schmal als Schublade hinter dem Menüknopf. |
| ``Actions`` | ``RenderFragment`` |  | Knöpfe rechts in der Kopfzeile, etwa „Neu“, Einstellungen und Benutzermenü. Immer sichtbar. |
| ``ChildContent`` | ``RenderFragment`` |  | Inhalt rechts neben der Leiste, im MainLayout @Body. Füllt den Rest und scrollt, am Handy mit der Seite. |
| ``RailOpen`` | ``bool`` |  | Ob die Leiste in der schmalen Ansicht als Schublade eingeblendet ist. In der breiten Ansicht ohne Wirkung. Standard: false. |
| ``RailOpenChanged`` | ``EventCallback<bool>`` |  | Wird aufgerufen, wenn die Schublade geöffnet oder geschlossen wird (Menüknopf, Klick daneben, Navigation). Für @bind-RailOpen. |
| ``RailWidth`` | ``string`` |  | Breite der Leiste als CSS-Wert, etwa "3.5rem". Standard: 3rem. |
| ``MenuButtonTitle`` | ``string`` | ``"Menü anzeigen"`` | Tooltip und zugänglicher Name des Menüknopfs in der schmalen Ansicht. Standard: "Menü anzeigen". |
| ``CloseOnNavigation`` | ``bool`` | ``true`` | Ob jede Navigation die Schublade schließt, etwa nach der Wahl eines Eintrags. Standard: true. |
| ``DrawerWhenNarrow`` | ``bool`` | ``true`` | Ob die Leiste in der schmalen Ansicht als Schublade hinter dem Menüknopf erscheint. false: schmal weder Leiste noch Menüknopf – für Anwendungen, die dort eine eigene Navigation haben, etwa eine Leiste unten wie Apps am Handy. Standard: true. |
| ``StickyHeader`` | ``bool`` | ``true`` | Ob die Kopfzeile oben kleben bleibt, wenn auf dem Handy die Seite scrollt. false: Sie scrollt mit weg und lässt dem Inhalt mehr Platz; --oo-rl-header-offset ist dann 0. In der breiten Ansicht ohne Wirkung (dort scrollt nur der Inhalt). Standard: true. |

## Geerbte Parameter (OoComponentBase)

Alle nicht deklarierten HTML-Attribute (``class``, ``style``, ``data-*``, ``aria-*``, ...) werden an das Root-Element weitergereicht.

| Parameter | Typ | Standard | Beschreibung |
|---|---|---|---|
| ``Size`` | ``string`` |  | Größe der Komponente. Mögliche Werte: OoSize.Xs, OoSize.Sm, OoSize.Md, OoSize.Lg, OoSize.Xl. Wird als CSS-Klasse am Root-Element gesetzt. |

## Hinweise

- Natives HTML-Attribut class wird automatisch an das Root-Element weitergegeben
- Natives HTML-Attribut style wird automatisch an das Root-Element weitergegeben
- Alle weiteren nicht deklarierten Attribute (data-*, aria-*, id, tabindex, …) werden ebenfalls weitergereicht
- Größe der Komponente via Size mit OoSize-Konstanten steuern (OoSize.Xs bis OoSize.Xl)
- Einsatz im MainLayout als äußerstes Element: Logo und Name in <c>Brand</c>, Symbolnavigation in <c>Rail</c> (etwa ein vertikales FlyoutMenu mit <c>IconOnly="true"</c>), Knöpfe rechts in <c>Actions</c>, <c>@Body</c> in <c>ChildContent</c>; Toaster und DialogHost daneben.
- Die Leiste scrollt nicht und schneidet nichts ab, damit Flyouts nach rechts über den Inhalt aufklappen können; sie ist für wenige Einträge gedacht.
- <c>Brand</c> und <c>Actions</c> bleiben immer sichtbar, auch in der schmalen Ansicht; dort gehören nur wenige, kleine Knöpfe hinein.
- Schmal heißt: das Layout selbst ist höchstens 48rem breit (Container-Abfrage, nicht die Fensterbreite). Dann zeigt die Kopfzeile links den Menüknopf; die Leiste liegt außerhalb und schiebt sich geöffnet über den Inhalt.
- Es scrollt nur der Inhalt (<c>.oo-rl__main</c>), nie die Seite. Ausnahme: Touch-Geräte bis 48rem Breite oder im Querformat (bis 30rem Höhe und 60rem Breite); dort scrollt die Seite, die Kopfzeile klebt oben und die Leiste ist immer eingeklappt. Nur so klappt der Browser die Adressleiste ein und hält das fokussierte Eingabefeld über der Tastatur.
- Für Inhalte, die sich danach richten müssen, setzt das Layout am Inhaltsbereich zwei CSS-Variablen: <c>--oo-rl-header-offset</c> (Höhe der klebenden Kopfzeile, wenn die Seite scrollt, sonst 0; etwa für <c>top</c> klebender Elemente) und <c>--oo-rl-content-height</c> (sichtbare Höhe des Inhalts; für <c>height</c> oder <c>min-height</c> einer Seite, die den Bildschirm füllen soll).
- Mit <c>StickyHeader="false"</c> scrollt die Kopfzeile auf dem Handy mit der Seite weg, statt oben zu kleben; <c>--oo-rl-header-offset</c> ist dann 0, und eine geöffnete Schublade reicht bis ganz oben.
- Mit <c>DrawerWhenNarrow="false"</c> gibt es schmal weder Schublade noch Menüknopf, die Leiste ist dann ausgeblendet – die Anwendung bringt dort ihre eigene Navigation mit (etwa eine Leiste unten). Gleiche Grenzen wie oben, auch für das Handy im Querformat.
- Jede Navigation schließt die Schublade (abschaltbar mit <c>CloseOnNavigation="false"</c>), ebenso ein Klick daneben und Escape, solange der Fokus in der Leiste steht.
- Barrierefreiheit: Der Menüknopf meldet den Zustand über <c>aria-expanded</c> und verweist mit <c>aria-controls</c> auf die Leiste. Öffnet er sie, springt der Fokus hinein; Escape schließt sie und gibt den Fokus an den Menüknopf zurück.
- <c>RailOpen</c> ist optional bindbar (<c>@bind-RailOpen</c>); ohne Bindung verwaltet das Layout den Zustand selbst.
- Farben wie beim SidebarLayout: Kopfzeile und Leiste im Hintergrund (<c>--oo-color-background</c>, leicht grau), Inhalt auf der Fläche (<c>--oo-color-surface</c>, weiß).
- Breite der Leiste über <c>RailWidth</c> (Standard 3rem), Höhe der Kopfzeile über die CSS-Variable <c>--oo-rl-header-height</c> (Standard 3rem).


Die Verbindung zum Server ist unterbrochen. Verbinde neu …

Neu verbinden hat nicht geklappt. Nächster Versuch in Sekunden.

Keine Verbindung zum Server. Bitte erneut versuchen oder die Seite neu laden.

Der Server hat die Sitzung angehalten.

Die Sitzung ließ sich nicht fortsetzen. Bitte erneut versuchen oder die Seite neu laden.