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, ...).
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.
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.
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.