Keyboard focus: which widget receives key events. A base primitive with no styling of its own — a
focusable widget (e.g. crate::Input) requests focus on tap and consults it in on_event/view.
Wraps a child so its rendered output is clipped to the child’s own layout rect. When the child
collapses to a zero rect (e.g. a section hidden via display:none), the clip is empty, so nothing
inside draws — even a widget left with a stale rect or one that paints at fixed coordinates. Layout
is unchanged: layout_node passes through to the wrapped child.
A single-line editable text field bound to a RwSignal<String>. A base primitive: unstyled (no
border or background — wrap it in a box for the look) and keyboard-driven. It requests focus on
tap and, while focused, edits the bound signal from key events, drawing a caret at the insertion
point. Selection, clipboard, and IME composition are not yet supported (a single-caret MVP).
Line is designed for use inside Canvas closures where you control absolute coordinates. It does not implement LayoutItem because its p1/p2 points are absolute, not relative to a layout rect. To use Line in a layout context, embed it in a Canvas widget.
A line-number gutter for a code editor: the column “1\n2\n3…” drawn top-aligned with the same line height a
TextArea uses, so line n here sits exactly on line n of the editor. Place it beside
the editor inside the same scroll (so they scroll together) and give both the same font_size. It measures
its own width from the widest number and its height from the line count, re-measuring reactively as the
count changes. Toggle it by collapsing its node (set_display) inside a ClippedItem
so a hidden gutter both takes no width and draws nothing.
Path is designed for use inside Canvas closures where you control absolute coordinates. It does not implement LayoutItem because its path data uses absolute points, not relative to a layout rect. To use Path in a layout context, embed it in a Canvas widget.
A reactive list: for item in $items key id (or, keyless, for item in $items) in .rsx. Re-runs its
source reactively and reconciles the item widgets — reused keys/positions keep their node/widget, new
ones are built, gone ones are disposed, and the layout children are reordered — instead of rebuilding the
whole block on every change. new/with_gap reconcile by key (identity-stable); positional/
positional_with_gap reconcile by index (no key clause needed, cheap append/truncate).
A paragraph of mixed-style text: a sequence of TextRuns (bold, italic, coloured links) shaped and
wrapped as one, the multi-style counterpart of Text. The shared paragraph metrics — font
size, line height, wrapping, max_lines — come from a base TextStyle; each run overrides only weight,
slant, and colour.
A handle to the enclosing scroll area’s live viewport, handed to the content builder by
LayoutScrollArea::new_with. Because a scroll area lays its content out as its OWN layout root,
every descendant’s tracked rect is already in the same content-local space the scroll offset
indexes into — so visible is a plain rect overlap, no scroll-transform math.
The children a component receives from its call site, grouped by slot. A bare child lands in the
default slot (None); a child written with slot:"name" lands in that named slot. Inside the
component, the children placeholder drains the default slot and children name:"x" drains the
"x" slot — each in call-site order. Draining is one-shot: a slot placeholder consumes its
children, so referencing the same slot twice yields an empty list the second time.
Restores the previously-active surface world when dropped. The per-world guards each restore their own
(independent) thread-local; _prev_surface restores the reactive current-surface.
A backend-agnostic description of a secondary surface: where it sits, how big it is, and how it
behaves (scrim, outside-dismiss, auto-timeout). The intent lives here; a backend derives its own
surface config from it. Reusable by a windowed app (as an in-window portal) and by a shell (as a real
layer-shell surface) alike.
A full-viewport scaffold that positions a panel against a screen edge, optionally dims the area behind
it, and dismisses on a press outside the panel. It is the reusable body of a drawer/modal: a shell
mounts it as the root of a full-screen layer-shell surface, and a windowed app can mount it in-tree as
an in-window portal — both get the same positioning and dismiss behaviour.
The one progress value a surface’s arrival and departure share: 0 is off its edge and transparent, 1 is
settled. Opening runs it to 1; leave runs it back to 0, so the exit is the entrance
reversed rather than a second animation that has to be kept in step with the first.
A multi-line editable text area bound to a RwSignal<String> — the multi-line sibling of Input.
A base primitive: unstyled (wrap it in a box for a border/background), keyboard-driven, no soft-wrap (only
\n breaks lines, so long lines overflow horizontally). It requests focus on tap, positions the caret at
the click, edits the bound signal from key events (typing, Enter for a newline, Backspace/Delete joining
lines, arrows in all four directions, Home/End, Tab), and draws a caret. Its measured height grows with the
line count, so wrapping it in a LayoutScrollArea gives a scrolling editor.
Selection, clipboard, and IME are not yet supported (a single-caret MVP, like Input).
One child position in a container: a fixed widget, or a reactive fragment (built lazily once the host
node exists). Produced by ChildSlot::stat / fragment / fragment_positional.
What kind of secondary surface a placement describes. A backend maps the role to its own surface
primitives (a layer-shell backend picks a layer + namespace; a windowed backend a child window or an
in-window portal). Roles carry no behaviour of their own — the explicit SurfacePlacement fields do.
The default scrim wash: ~35 % black over the content behind a drawer/modal. Rendered as a fill (not an
opacity layer) so the panel above it stays fully opaque.
Imperative-state components re-render only when on_event returns EventResult::Handled; reactive-state components re-render automatically on signal change.
The node’s WINDOW-absolute rect (top-left from the top-level walk, size from its layout), or None if it
has not been laid out under a window root yet. Unlike track_layout, this is correct even for a node in a
sub-root computed separately (whose rect signal is root-local) — use it to anchor a portaled overlay to a
trigger, since the portal hoists out of ancestor transforms and needs absolute coordinates.
Builds the affine matrix for a box’s declarative rotate/scale/translate attributes, pivoting
rotation and scale on the box centre. Returns None when every component is identity, so an untransformed
box skips the extra transform node entirely.
Lays out root against the given space and reflects the result into each node’s rect signal.
Collects the (signal, rect) updates while holding the runtime borrow, then applies them in a batch
after releasing it — a rect .set() can flush effects, and one of those may itself touch the
layout runtime (a reactive list), which would re-enter the borrow.
A keyed reactive region with per-item spacing — for item in $items key <expr> gap:N. The gap is laid
out as a main-axis leading margin between consecutive items (see [reconcile_slot]), so the region
still flows transparently in the host’s direction (horizontal in a row) instead of a boxed list.
The current laid-out rects of every interactive widget on the active surface, dropping any not yet laid
out (zero-sized). Read without subscribing (peek), so the platform’s frame loop can call it outside a
reactive scope without accidentally tracking the layout signals.
Registers node as an interactive (press/drag) target, tracking its laid-out rect signal. A surface that
carves its input region from its content — a click-through overlay such as the notification popups — reads
interactive_rects to receive pointer input only where widgets actually respond. Idempotent per node.
Re-lays out every root that has been computed at least once, picking up any nodes a reactive change
dirtied since the last frame. Each compute_layout early-returns when its root is clean and the space
is unchanged, so this is cheap on a still frame. The runtime calls it once per redraw (after flushing
reactive effects, before rendering) so a data change deep in the tree — e.g. a reactive list adding an
item — is reflected in layout without the app shell knowing about it. Node dirtiness propagates up to
the root through taffy, so a dirtied list container makes its root recompute.
Detaches and frees node (a former list item) from the runtime: removes it from the layout tree and
drops its rect signal and bookkeeping. The caller must have removed it from its parent’s child list
(via set_children) first.
Resets the active surface’s layout runtime to a fresh, empty tree. The single-window app/preview harness
calls this at construction; a multi-surface runner instead gives each surface its own LayoutContext.
Replaces parent’s children with children, in order, marking parent dirty. Operates on the
thread-local runtime; parent must be a container already registered in the runtime.
Shows or hides a node in layout flow. A hidden node takes no space (and lays out none of its subtree); mark an ancestor dirty and recompute for the change to take effect. Used for responsive layouts (e.g. collapsing a sidebar on narrow windows).
Sets node’s minimum height to px after the initial layout (dirtying it, which propagates up), so a
content-measured leaf grows to at least px even when its content is shorter. A scrolling editor uses it
to fill its viewport so a click anywhere in the empty area — not just over the text — lands on the leaf.
Pins the overlay host to node — the app’s window-spanning root — so overlays always fill the viewport
even when the app computes several independent layout roots (e.g. a shell with a separate sidebar root
computed after the main one, which the auto-detection would otherwise pick as the host). Call it each
relayout with the current main root (it survives hot-reload rebuilds, which mint a new root node). Once
pinned, auto-detection no longer overrides the host.
Applies the full affine inverse of matrix to all pointer-coordinate events. Returns None for
non-pointer events or when matrix is degenerate (det ≈ 0), so callers fall back to the original.
Reactive read of the active direction — subscribes the caller, for the rare widget that has to mirror
something layout cannot flip on its own (a chevron glyph, a directional icon).