Documentation

A registered drawing: content version plus the op builder. The version participates in the draw-op cache key, so a builder whose output changes without its size changing must bump the version to invalidate.

Cached text-span layout for one arena node. Key fields are every input that changes the produced spans; sceSpans is the shared result. The whole cache is dropped on theme or font-scale changes.

A cacheable widget label is a single line (or absent for close buttons). Coordinates are relative to the node origin; paint translates them without rebuilding a list or invalidating the cache when a widget scrolls.

Explicit damage invalidation request queued during frame evaluation.

Rebuild draw ops when the content version or width/height change. A move only translates. An unversioned drawing (content 0) additionally drops its cache while the widget is animating, since it has no other invalidation signal; versioned drawings are invalidated by their content key alone.

Reuse a derived layout while envelope, font, content key, and caller layout match.

Drop cached ops for drawings that did not rebuild this frame.

Custom node measurement: font metrics and available (width, height) to the node's desired (width, height).

Draw ops for a custom widget's paint: the ops refreshCustomDrawingOps settled on this frame while every input still matches, translated if the widget only moved, else a fresh build.

Settle a custom widget's ops for this frame and cache them for paint, returning whether what it draws changed at an unchanged rect.

A widget that declares a content key is taken at its word, as a versioned drawing is: an unchanged key with unchanged size, interaction state and metrics neither rebuilds the ops nor repaints them, animating or not, so a drawing that reads an animated value has to fold it into its key. One that only moved keeps its ops too; paint translates them. Without a key (0) the build can read anything (a sort flag, a fraction), and nothing but building it shows that its output changed, so it is rebuilt and compared.

Whatever forced a rebuild, the ops it produced decide the damage, so a key bumped without a visible change repaints nothing and a rebuild the key never mentioned still repaints. A new, moved or resized widget reports no change: rect damage covers it.

Whether a versioned drawing's cached ops are for another version at the same rect. Paint rebuilds them; the pixels they covered must repaint too, and checking the version costs nothing next to building the ops here.

A registered custom drawing: its content key plus the op builder. A non-zero key is the author's promise that the ops follow it, so a frame whose key is unchanged neither rebuilds nor repaints them. Key 0 means the drawing carries no key and is rebuilt every frame and compared.

Replace the store with f of it, damaging the keys whose values changed and waking the loop when anything did.

Whether wid was declared inside a disabled scope. A widget asks before its node exists, while the scope it is declared in is still the arena's.

Start a view pass with no pushed themes. The first pass of a frame keeps last frame's themes to compare against; a rebuild pass keeps comparing against the same ones.

Add a scope drawn with theme, whose nested scopes modify raw and which is disabled or not, and return its theme index. A theme equal to last frame's at the same index keeps last frame's value.

Whether this frame's scopes look different from last frame's: a theme changed, scopes were added or dropped, or nodes moved between scopes.

A scope's theme before any disabled scope faded it.

The theme of the scope the view is declaring in.

The theme of wid's node, or of the current scope before it has one.

Move a scroller to an offset along its main axis. Cancels a glide in flight: whoever sets an offset outright owns it.

Move a scroller to an offset on both axes. Cancels a glide in flight.

How far one wheel notch scrolls, and how long a scroll takes to settle. One setting for the whole context; a single scroller can take its own step (see setScrollStep).

Wheel step and glide time for every scroller in this context.

Set the wheel step and glide time. Raising scrollWheelStep makes the wheel cover more ground per notch; a nonzero scrollSmoothTime turns every wheel notch and every ScrollSmooth command into a glide.

This scroller's own wheel step, or 0 when it follows the context's.

Give one scroller its own wheel step, in pixels per notch. 0 puts it back on the context's step. A list whose rows are a fixed height reads best at a whole number of rows per notch.

Pixels one wheel notch scrolls this scroller.

Which axes a scroller moves on, and how an offset in window axes (x rightwards, y downwards) maps onto its stored offset. A 1D row scroller keeps its offset in the main-axis slot, so its horizontal offset is the one that needs swapping.

What a scroller looked like on the frame it was last laid out on. Offsets and ranges are in window axes: x rightwards, y downwards, whichever way the scroller itself is built.

Geometry of the scroller wid, or Nothing before it has been laid out. Reads the last frame's layout, so it is safe to call while building the next one.

Record what the scroll pass measured, so the commands and the app can read it between frames. Writes nothing when nothing moved, and nothing at all for a second node sharing this one's widget id. A table's frozen pane and its body share theirs, and letting both publish would rewrite the store every frame and hand the commands a viewport that alternates between panes.

Start a frame's geometry pass: the first scroll node to publish under a widget id wins for that frame.

This scroller's offset in window axes.

Move a scroller to an offset in window axes, cancelling any glide. A 1D scroller ignores the axis it does not scroll on.

Whether a scroll lands on its target at once or glides onto it. ScrollSmooth still lands at once when the context's scrollSmoothTime is 0, so one setting turns smooth scrolling on for the whole app.

Where a widget ends up in the viewport once it is scrolled into view.

Scroll to an absolute offset, clamped to the scroller's range.

Scroll by a delta in pixels. Deltas accumulate onto a glide already in flight, so repeated calls keep up rather than fighting each other.

Scroll by whole viewports: V2 0 1 is one page down, V2 0 (-0.5) half a page up.

Scroll back to the top (and left).

Scroll to the end of the content.

Scroll target into the viewport of the scroller wid it is built inside. Both widgets are read from the last frame's layout, so a widget that was not built then, such as a row a virtualized list left out, cannot be found; scroll to its content rectangle with scrollRectIntoView instead.

Scroll a rectangle of the content into view. The rectangle is in content coordinates: the origin is where the content starts, which is where the viewport shows it at offset 0.

Send a scroller to an offset in window axes, gliding if the caller asked for it and the context is tuned for it. The target must already be clamped to the scroller's range.

Where the scroller is headed: the glide's target if one is in flight, and fallback (normally the current offset) if not. Deltas add onto this so that notches arriving mid-glide are not swallowed.

Hold an offset inside 0 and the scroller's range on each axis.

Advance every glide by dt seconds. Each one covers the same fraction of what is left every second, so a long throw starts fast and eases in, and at least a pixel a frame so a glide cannot stall on the pixel grid the offsets snap to.

GPU texture id shared by every packed image so draw cmds batch.

Called once before building a frame. Context configuration remains pure; cache invalidation happens at the IO boundary, including when alternating between differently configured Contexts that share their backing stores.

True when any node has a custom measure function, whose output is not captured by the arena descriptor comparison, so whole-layout reuse must be disabled for the frame.

Configure a context's theme. Goes through setTheme so a theme swapped between frames invalidates the caches keyed on it, drawing-op caches included, instead of leaving widgets painting the previous theme.

Set the device pixel scale used to snap geometry origins/endpoints to whole pixels. The SDL backend calls this when the window pixel density is synced.

Emit rounded shapes and AA strokes as flat, axis-aligned fills. Software framebuffer hosts enable this so every primitive is a solid quad.

Skip text quads in the draw buffer. Hosts that rasterize text from the collected text spans enable this.

Whether the focused widget shows its focus ring: focus moved by keyboard since the last pointer press.

Add wid to this frame's keyboard focus order, unless it is declared in a disabled scope.

Whether the frame loop has to keep drawing: an animation is running, or a scroller is still gliding onto its target.

Widget state for every widget, in maps by value type. Same-type fields that share a widget key use slotKey.

Every built-in slot.