Along a height its parent sizes from its content, a container that fills takes its content height, at most the
room it is offered. When the content is taller, the measuring run is taken back and the container is laid out as
given the room, so its list and the bar under it share it; a record of the content height lets later runs and kept
transcripts lay it out the same. room_height only offers a finite room inside a scroll: a gallery card is as tall as
its story's content, at most the view, as the old gallery's tiles were.
layout_memory::draft runs a measuring run whose hand-forwards can be taken back once its result is seen: records,
kept transcripts, the open transcript's items, leaves and inputs, and each contribution (Contribution::undo for
column widths, label control minimums and reads). steps::id::draft takes the Auto id ordinals back with it. The
shrinking row's least probe is a draft taken back that reads nothing from outside.
A scrolling collection that fills keeps to its measured height in the real run under a body sized from its content,
so a footer under it stays below its rows. The PlacesTree story keeps the old 380 pt box.
Each card sits in a settling Lazy inside its row: a settled frame of the
Overview runs no card. Lazy::settles notes that a settled reader needs a
binding that stays in place between frames.
Each row of the Overview's grid is a Lazy child of the scroll body, keyed by
its cards and the column count, so only the rows in view run their Grid and
cards. The per-card Lazy goes. A card's Panel takes its id from the card's
key, so a change of the column count keeps each card's state.
Trial: a settled pass of a short view runs as many Grids for the whole
Controls level as for a filter that lists the same cards in view.
StoryOutput::readout is a line a story words about what it shows or what last happened in it;
the gallery card shows it, muted, under the story in every layout. StoryData::note keeps what a
readout needs (last event, click count) outside the story's values, so drives and Reset compare
values only. The old readout lines come back for ColorWheel, ColorPicker, SwatchPalette and
SwatchTable, GradientPalette, TipEllipse, the symmetry canvas stories, LutPicker, ColorChoice,
Swatch, LayersPanel, MediaBin, ChannelsPanel, ToolRail, StrokeEditor and StrokeButton.
A pass that took a kept measurement, ran only the measuring run or held the story back
noted an empty start, so every value the story made counted as a change and Reset showed
at rest on most cards of a level (ToggleButton, TipEllipse, CompareTile, CurvesPanel, ...).
A Divider::vertical() is the bar's one section break: the connector,
shape and eyedropper bars, the about dialog's controls and the status
story place it where the old bars did. Hints use the faint shade.
BarHome and BarTool are the parts an options bar starts with. A
captioned control in a bar is a Field; BarCell goes.
inspect::record shows a region and records, in real runs, every component shown in it (box, box inside its padding,
depth, and the access facts step 16 wrote, named by their labels as a screen reader reads them), the sensing core's
hit areas of those components at their least size in tree order, and the focus stops numbered in Tab order: every
member of a roving group, whatever the platform's Tab setting. Inside a region nodes are reported whether or not
AccessKit runs. The record is kept as a value: a reader shown earlier in the pass (inspect::recorded,
inspect::pointed) reruns the pass when the record changes. Recording is on in fixture frames and inside an open
region; FrameInput.inspect and the focus state's all_controls go.
InspectOverlay (display) draws a record as the old gallery inspector did, cut to the region: padding bands, hit
areas with small ones flagged, numbered focus badges, and a marquee on the element the list points at.
Row, Stack and Grid take indent(levels), a start padding of space.pad.regular per level, and hover(), which gives
the root Sense::HOVER so its response reports the pointer. Text takes italic().
While the Inspect panel is in front of the components workspace and no Variants view is open, the selected card of
the Overview or of the selected component's tab shows each story as an inspected region with the overlay over it.
The Inspect panel lists the Padding, Hit areas and Focus order switches, the flag note, one section per story with a
row per element (number, role, name, value, actions, state, "no label"), indented by depth, whose hover marks the
element on the card, and the declared facts as the last section.
CollectionProps::type_ahead decides whether typed letters move the lead; the key role
reads it instead of turning type-ahead on for every collection, so a focused list leaves
single-letter tool keys to the app. Popup option lists, the hyperlink place list and the
gallery's component and token lists turn it on. The suite's type-ahead case runs where
the focused stop takes type-ahead.
A value control takes the wheel only while focused or armed, on the axes
it senses. WheelScope replaces the wheel_gated scope: Free lets the
sliders of an adjustment dialog take the wheel without focus, and Gated
(the Overview card) gates every taker and wins over a Free inside it.
Slider senses the vertical wheel only; RangeSlider and ThumbRow sense no
wheel bits; PointPicker and AngleDial sense both scroll axes.
Colours shows every semantic colour role of the card's theme by group, as a
swatch, its path and its hex value. EditPolicy binds a slider and a text
field to one of two documents under a write-through or on-commit policy,
logs their edit events, and its Undo and Switch document buttons cancel a
running gesture through cancel_all. Types of the gallery's foundations
module are Foundations, the first level listed.
Lazy::reveal asks its scroll body to glide until the child starts at the
view's start, run or not; the body follows the child's place on the motion
service's follow curve and a move of its own ends the glide. It replaces
Lazy::keep. The gallery's Overview passes the selected card's reveal in the
pass its cards follow the selection, in place of egui's scroll_to_rect,
which no scroll body reads.
overview_card builds an Overview card's Spec from the catalog alone and Spec::card turns it into the Card the
Overview shows; the Overview uses both. story-render --card renders one selected card per story group, the given
width wide, in a one-column grid row in a vertical scroll as the Overview holds its cards, inside the one shell the
bin runs everything in, with its dialogs open. --scale sets the images' pixels per point (1 matches the old gallery's
shots) and stories.tsv lists it. cl render passes both through.
DockConfig::native_windows is on by default. A float opens native where the
window host opens OS windows and reports their positions (ShellInfo::window_positions,
WindowHost::positions_reported: not on Wayland); a float never shown native opens
over its place in the main window. AppSpec::new takes the backend winit opens on.
The OS close of a native float is its Close action, taken when every panel in the
window may close; the group's open state belongs to the dock model. The gallery's
mock editor keeps its floats inside its preview.
The card runs each story in one Stack inside the view's embedded shell,
without a shell of its own per story. The shell counts the dialogs shown
in a pass (ShellCx::dialogs_shown), and the card reads the count around
its story, so a story's dialog opens over the view. AppShellOutput loses
its dialog flag, which only the card read. story-render shows a story in
an embedded shell of its own.
testing::last_pass_runs counts a pass's runs by component type; the
Overview trial asserts that the shell regions don't grow with the
stories in view.
The generator parsed crates/ui/src/lib.rs, which is a re-export facade over
the six library crates, so it found none of the shared modules. It parses
craft-ui-contract as craft_ui and craft-ui-widgets' layout_components, and
reads a path into any library crate as the craft_ui path the facade gives it.
A record of layout memory holds a measure or a text. emit_text hands a
text forward through the same transcript as emit_record: a body that
takes its kept measurement gives the text its measuring run found, where
the content that found it does not run, and a real run's text other than
the kept one shows the transcript changed. The gallery card emits each
story's value text in its shell and the form rows read it beside the
story, so a settled Slider card runs one pass per frame.
AppShell::content_height sizes an embedded shell from its body's measure,
which its body keeps while its inputs hold. The body pane is a pane at its
rect as tall as its content, taking its height in the scope's flow. The
gallery card drops its two measure_in runs and its detached shell record;
the value text and the dialog record come from the shell's real run, and a
story whose shell showed a dialog gets the card's whole room.
A Lazy child no pass showed yet takes the estimate its app gives
(`Lazy::new(key, estimate)`): that long along the axes its scroll area
scrolls, nothing across them, as a collection places rows it never built
by its item layout's estimate. The never-shown "always run" branch of
`lazy::decide` is gone. Gallery cards estimate their height from their
story rows.
A scroll position the framework holds is also named by content: the
first child at or after the view's start (`lazy::Anchor`, kept with the
offset in `ScrollState` and a collection's `Scrolled`). When extents
before it change, the offset follows the child and the pass runs again,
so the content in view does not move. Bound offsets keep no anchor.
Entries of the out-of-view store record their scroll area. A frame drops
only the entries an area that ran did not reach, so a hidden area (a tab
switched away) keeps its children's extents.
Trials: first show, shown again after a hide, content in view stays when
an estimate above it resolves, collection rows stay when a row above them
changes height; the gallery trial asserts each level first runs the cards
in view.