Cairn.UI.Node

A soft shadow under a box's shape, as SwiftUI's shadow(color:radius:x:y:): the shape's silhouette in color, blurred by radius points and moved by (x, y). With no offset it is a glow.

Pixels the host draws: the shader registered under shader fills the box, fed with these numbers (what they mean is the shader's contract) and with the host's clock, as milliseconds since origin (a time on the runtime's monotonic clock), so it can move between frames.

Host-drawn pixels from a loaded image: the host paints the image it holds for source into the box as fit says. width and height are its size in pixels, as the load answered (Reply.image); Lean places it from them (Frame.imageDest), so the host only scales.

A row whose height is known: it was laid at that height.

The row the reader is at: the first row showing at the offset offset, whose top in the list's content was top in the heights it was recorded with. A row the clamp kept from its place within a batch is held: the place to keep it at is hold points below where it is (VList.anchorAt), until the batch's frame is shown (Known.letGo).

What the runtime knows of one list (UI.lists), recorded after every layout: the heights of the rows it has laid, sorted by index, at the width they were laid at; the box's length; and the anchor.

What a laid virtual list says of itself (Style.rows), for the runtime to record and the fuzzer to check: what the view read, the heights it laid out by, and the window it laid.

A node that performs a move.

A keyboard shortcut shown on a menu item (⌘Q). A status item's and a control's menu honour it only while open; an item in the app's menu bar (Surface.menuBar) has it whenever the app is active (a key equivalent).

A control's menu (docs/surfaces.md, "Menus on controls"): a native menu the runtime opens over the control, built like a status item's. The secondary click on the control (or on anything inside it that has no menu of its own), the context-menu key (Shift-F10) while it has focus and VoiceOver's Show Menu open it; with button, the control is a menu button (⋯) and a primary click, Space or Return open it too, instead of pressing it. Choosing an item is a press of that item's control (Event.menuSelect with the window's place); opening and closing reach no update. A menu with no items is no menu.

What a text field shows. Indices are Unicode scalar positions into text. The editing model that produces this lives in Cairn.Text.

How a wrapped text (Node.para) is sized and broken into lines. The rules are in docs/layout.md ("Wrapped text") and Cairn.Text.Wrap.

An image on screen (Node.image): where its pixels come from (a file path, ~/ for the home folder, or an http/https URL; the host loads it for Request.loadImage), the box it takes in logical points, and what is known of it so far. The box is the same in every state, so nothing moves when the pixels arrive or fail (Layout.measure_image).

row and column lay children out along an axis; stack puts them on top of each other, later children on top.

fill shares the parent's leftover main-axis space equally among fill children, and takes the parent's full cross-axis size.

How a rounded box's corners turn: a circular arc, or Apple's continuous curve (SwiftUI's RoundedRectangle(style: .continuous)), which starts further along the edge and has no jump in curvature.

How an image's pixels fill its box: stretched to it (fill), scaled to fit inside it with the aspect ratio kept (contain, centred, leaving bands), or scaled to cover it with the aspect ratio kept (cover, centred, cut by the box).

One entry of a native menu: a status item's, a control's (ControlMenu) or the app's own in the menu bar (docs/surfaces.md). The host builds a real NSMenu from it.

Which lines a wrapped text keeps when it has more than maxLines: the first ones, or the last ones (a growing transcript that shows its end).

A laid-out node. clip is the region this node may paint in (the intersection of every clipping ancestor), so the visible part of a node is rect.inter clip.

What an app knows of an image so far: not loaded yet, loaded (its size in pixels, from Reply.image), or failed (from Reply.failed).

What is known once a frame is shown: a held anchor is let go, so the row is kept where it now shows.

What the accessibility mirror says of a menu: some true a menu button, some false a context menu, none no menu (or one with no items).

The menu of the node's control (Style.menu), if it has items.

The words a failed image shows.

The image's box: fixed at its size in every state, clipping; the placeholder colour while loading, the pixels once loaded, a bordered box with the fault's words when failed.

What a failed image says, centred in its box (clipped to it); nothing otherwise.

An image node. A box of the image's size whatever its state, so layout knows its size before the pixels exist; it has no control (an image is not a move) and paints, from back to front, its state's background, the host's pixels once loaded (Style.image), and a failure's words.