Commit Graph
52 Commits
Author SHA1 Message Date
aiongg 9eeb3cc7a9 Suites leave out changes made by keys lent to a canvas session control
The key stage counts the lent keys session members take (keys::lent_taken).
The activation and drive suites read it around their input: a key the canvas
lent its session control is that control's, with no AccessKit twin on the
focused stop.
2026-11-12 14:32:40 +00:00
aiongg 54a0c063fa Canvas session controls take the canvas's Enter, Escape and arrows first
KeyUse::session marks an arena member that holds its arena's edit session.
While none of its parts has focus, the runtime lends it the Submit, Cancel and
nudge routed to its arena root and, with nothing focused, the window's; what
it leaves goes back before the canvas's tool reads them. With nothing focused
the key stage routes the arrows as window nudges, which the tool host also
offers to the tool.

CropOverlay, TransformBox, PerspectiveCropQuad and SymmetryHandles (in a
session) act on the whole frame, box, quad or centre when no part has focus.
The tool-side copies of those keys go: CropToolPass bundles the overlay's
nudges in take, TransformTool keeps Enter and Escape for the Warp phase only,
SymmetryTool and the quad's Submit and Cancel in PerspectiveCropTool go.
SymmetryTool spends a press away from the handles.
2026-11-12 14:32:40 +00:00
aiongg 446fcf0aa4 Full-window workspaces take Undo, Redo and the mask view keys themselves
Commands::take_step declares Undo and Redo on the instance around a body and takes the next one fired at it. Liquify, Filter Gallery, Select and Mask, Content-Aware Fill, Vanishing Point and Adaptive Wide Angle step their history from it in their own pass, cancelling an open stroke first; their public step methods go, and so does the shortcuts dialog's hand-written copy. Select and Mask runs MaskViewKeys in its body, and mask_view goes.
2026-11-12 14:32:40 +00:00
aiongg f64ed8da88 Lazy::settles: a settled child repaints its last run in place of running
A settling Lazy keeps its last real run: its paint, egui widget rects and
AccessKit nodes (egui's pass records, from the fork's
Context::pass_records_since), its focus transcript, and a journal of the
per-pass registrations the services take (pointer shapes and widgets,
reads, memory owners, wheel takers, drop targets, key nodes, command
instances, access emits, layout memory and lazy entries). While it is
settled it adds that run to the pass again instead of running, in view
or not, in a scroll area or not.

It runs when the pointer is over it or a press started on it, it holds
or held focus, an animation in it is off its end or a wake came, a bound
value it read was written this frame, its place, room, clip or scale
changed, its last run showed an overlay or painted on another layer, or
the frame or the one before had input other than pointer motion, an app
repaint request or a given-value edit.

The egui rev moves to aiongg/egui craft/pass-records (pass_mark,
pass_records_since, replay_pass_records on 4b93a86c5).
2026-11-12 14:32:40 +00:00
aiongg 5fded75c9b Shrinking rows: a body that does not fill the row is a unit too
A captioned field or a nested row in an unwrapped row now takes part in the
row's shrink step. Its least comes from a probe sweep that runs only when the
row is short: the content measures unbounded along x with every leaf at its
least, and it reads and leaves no layout records. The row's width for the body
becomes the room the body measures and shows in (mount_room).

A Stack body fits each leaf in flow to its room, down to the leaf's least, so
a select inside a capped field elides instead of running past its edge.

A body that fills along an axis its flow does not bound measures its content
there, as `sized` already shows it, instead of counting at zero.
2026-11-12 14:32:40 +00:00
aiongg 27e516f8cd A closed layer container runs no pipeline
A Layer, FullWindow or Viewport container that is closed, past its exit
fade and has no close waiting takes its id, forgets its layer and returns
its output's unshown form (Outcome::unshown) without running. Menu and
Popover outputs give one; a menu that did not run in the pass before drops
what its last open run left (letters, a typed row, a close or step).
2026-11-12 14:32:40 +00:00
aiongg c897f3faf3 Collection members: a collection's items can be members of its run, sensed in its arena and painted as faces; SwatchTable's cells are members, SwatchCell goes 2026-11-12 14:32:40 +00:00
aiongg 86f91ac95d The checkerboard is one textured shape from a repeating 2x2 texture, for every checkerboard (FW-151) 2026-11-12 14:32:40 +00:00
aiongg 0e9ca32073 Story readouts: a line under the story in the old stories' words
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.
2026-11-12 14:32:40 +00:00
aiongg 1fe1a44fc3 Compile the component pipeline once: erase the component type behind Erased and ErasedPass
run, run_in_host, pass, the measure path and the steps that read only a type's constants, the core or the style
are non-generic. Each component type instantiates only the forwarding in contract/run/typed.rs and the steps
that read or write its value type, so an edit to the pipeline recompiles craft-ui-contract alone.
2026-11-12 14:32:40 +00:00
aiongg 296adaa049 Panes: a container can rule the inner edge of the edge pane it sits in; the panel rail does
The env carries the window edge of the innermost edge pane, so the
panel rail draws the old hairline on its canvas side whichever edge the
shell docks it at, mirrored under right-to-left.
2026-11-12 14:32:40 +00:00
aiongg 8a99049ed8 Layout: a row in a horizontally scrolling body shrinks its leaves to the view before the body scrolls
A bar's members past the view were cut by the scroll's clip; selects and
elidable text now narrow to their least first, as the old bars' selects
elided.
2026-11-12 14:32:40 +00:00
aiongg 037df036e0 Gallery inspector: inspected regions, the Inspect panel and the overlay over the selected card
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.
2026-11-12 14:32:40 +00:00
aiongg 3f63b71b3a Collection keys: a command palette's arrows wrap at the ends
CollectionProps::arrows_wrap passes the navigation's wrap to the item step's moves; the
command palette's list turns it on.
2026-11-12 14:32:40 +00:00
aiongg 3ad4bdd55c Collection keys: arrows move the focus in tab strips and preset browsers
Where a collection's arrows leave the selection (arrows_select off), Enter selects the
lead before it activates it, as the setting promised. The tab strip and the preset
browser's list and grid turn arrows_select off: the arrows move the focus, and Space,
Enter or a click shows the tab or picks the preset.
2026-11-12 14:32:40 +00:00
aiongg 939a80c85a Collection keys: type-ahead is a collection setting, off for lists
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.
2026-11-12 14:32:39 +00:00
aiongg f74d963e8f Collection keys: Cmd+] and Cmd+[ move the selected items, Shift to the ends
The stacking keys replace Alt+Up and Alt+Down as the reorder keys of every reorderable
collection and section stack, from one table in the key table. ] moves toward the front:
the start of a vertical order, later in a horizontal strip. The keys move the selection
as a block (the lead alone when it is not selected), with the tree rule for into_groups;
the single-row nudge helpers go. Alt+Down is Open everywhere.
2026-11-12 14:32:39 +00:00
aiongg e64dd901d9 Tooltips: a control that paints no label shows its own label, and the hints and names the old controls showed
A control whose own label is not painted (an icon, a glyph label, a caption-less tile, a chip, the stroke button) shows that label as its tooltip inside a field too; one named only by its field label shows none. Restores the old tooltips of the ReferencePoint points, the list disclosure, the PeopleBar avatars, the recent files, Distribute Rows Evenly, a page that failed to render, the font class mark (ListRow::trailing_named) and the Character hints (SideLabel::tooltip).
2026-11-12 14:32:39 +00:00
aiongg d5074272e3 Reset dot: a ring at the default, the state layer and a tooltip
The label's reset mark shows a ring in text.disabled while the value is at its reset value, so the slot shows before
anything changes, and the filled dot while it differs. The dot part takes the state layer and the tooltip "Reset to
default" (common.resetToDefault).
2026-11-12 14:32:39 +00:00
aiongg 3a4cf8a8ba Muted ink for secondary glyphs and the menu bar's no-match line
VariantLook::muted: text.muted on a neutral outline or ghost button, the variant's text otherwise. SplitButton's
chevron reads it. The menu bar's "No matching commands" line is muted text.
2026-11-12 14:32:39 +00:00
aiongg 8b2e44fa98 State looks: one state layer, check indicator press and well, dropdown and field edges
- StyleCx::state_layer is the one hover and press fill; PartBuilder::state_layer declares a part whose look it is,
  and the paint step fills such parts under the component's paint (Rating stars, Breadcrumb crumbs, the reset dot).
  Button's local overlay goes.
- The paint step's surface shapes move into one function, which Draw::surface_look also paints for a part.
- Check box, radio and switch draw their well on the sunken surface (the bevel in bevelled themes), take the press
  fill while pressed and the accent's pressed shade while on and pressed.
- StyleCx::dropdown: the closed box of Select, TreePicker, PresetPicker and the stroke button takes the hover fill
  under the pointer and while open.
- A focused invalid field keeps its focus edge and draws the failure colour as a line inside it (SurfaceLook::inner).
- The selected segment keeps hover and press looks; the disclosure glyph lights under the pointer; the EdgePicker's
  hovered line widens in its own colour; the chip body wears an outline badge, so it takes the hover fill.
- SurfaceLook::kind_on: the kind a look takes while on.
2026-11-12 14:32:39 +00:00
aiongg 353579afd3 Docking: a new float opens at a height fitted to its content
A panel or group floated out of the dock opens at its docked width and at
the height its group measures at in a floating window's room, at most
size.float.height. Content that fills its body opens at that height.

- Proposal::Size measures a component as it is shown at a rect of that
  size, with no share of the parent body's room.
- drag::amend lets a host change a drag's payload in the frame the drag
  started. The dock area measures the dragged panel there and puts the
  size on PanelDrag::source / GroupDrag::source. The Float command and a
  tab torn out of the window measure where they run.
- DockGroupOutput::drag_started also reports tab drags.
- FloatSpace::size_of caps a panel's, group's or column's height at the
  default float height. FloatSpace::record and its contents are gone.
2026-11-12 14:32:39 +00:00
aiongg 306fef9a38 Value controls take the wheel only while focused or armed
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.
2026-11-12 14:32:39 +00:00
aiongg 264ad8cc53 Native windows: the macOS title-row move starts on the press
The tracked macOS move sent StartMove a pass after the pointer passed the
click distance. winit hands performWindowDragWithEvent the event AppKit is
handling when the command runs, and in that later pass it is often not the
press, or none, so the drag took only some of the time.

- StartMove goes out in the band's Down pass where the OS tracks moves. The
  move is reported (Begin, Update, Commit) once the system pointer has passed
  the click distance; a click on the row moves and docks nothing.
- A window whose move the app runs keeps AppKit's own movable flag: the band
  writes nothing for it and the end hook leaves it alone. AppKit moves such a
  window for the hand-off and resizes it from its edges only while it is
  movable.
2026-11-12 14:32:39 +00:00
aiongg 52cc593d40 Native windows: one writer of a window's place at a time
A viewport window's builder carried its caller's rect every pass, and egui sent
each change of it to the window. The caller's rect follows the window's own
reports a pass late (the dock model records the OS place, a saved window reads
its store), so every OS move or resize came back as a command of the place one
pass old. While AppKit moved or live-resized a window the two writers set it to
two places in turn, without end: the title-row drag jittered, and a live resize
stretched the content with black edges.

- The builder carries the place only until the window opens.
- Each window keeps its known place: what its own pass last saw, or what act
  last commanded. A caller's place goes out only where it differs from the
  known place, never while a move gesture runs or the window is minimized,
  maximized or full screen. Placements are recorded from the known place.
- A dock window is fitted to the monitors when it opens; an open one stays at
  the placement the model recorded.
- The windows fixture sends a child the changes of its builder as commands,
  as eframe does, so trials see what an integration would send.
2026-11-12 14:32:39 +00:00
aiongg 72a8204117 Gallery: the Foundations level with Colours and EditPolicy
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.
2026-11-12 14:32:39 +00:00
aiongg 543ab4236e Overview: selecting a component glides its card to the top
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.
2026-11-12 14:32:39 +00:00
aiongg 9c7f50d40c Story canvas: the story document's ground is document pixels
Every story document shows the old gallery's ground: white with grey squares of 40 document pixels,
composed under the story's picture, so the squares scale and turn with the view. The screen-fixed
transparency grid and Checker::PREFERENCE_DEFAULT no longer draw story documents. Pasteboard and
RotateView stories show the story document again.
2026-11-12 14:32:39 +00:00
aiongg c19abe8663 Dock a native window by dragging its title row
A floating dock group in its own OS window now moves through a window move
gesture the app runs, which reports Begin, Update, Commit and Cancel like a
layer's move, so the dock marks the target under the pointer and docks the
whole window on release.

- macOS (Caps::OS_MOVES_TRACKED): the OS moves the window (StartMove), and the
  app follows the system pointer, button and Cmd through SystemWindows, the
  running platform's WindowSystem in craft-window. The hand-off ends when the
  system reports the button up.
- X11 and Windows: the app moves the window with SetOuterPosition so the
  pressed point stays under the pointer; Escape puts it back.
- A drag started by a container shown in its own OS window follows that
  window's pointer, not its parent's.
- The runtime's end hook sets NSWindow.movable for every window; a window
  whose move the app runs is never moved by AppKit from its band.
2026-11-12 14:32:39 +00:00
aiongg 97d56c2964 Floats open at their docked size, and the floating drag bar shows no title
A native float's OS window opens at its placed rect; the measured size applies
only to a window sized by its content. A tab, group or window drag carries the
size it left where it started, and a float command the size of the group it
runs from: the float takes it (with the drag bar above), after a panel's own
float size and before the default. FloatSpace's never-filled group and column
records go.

A floating window's drag bar carries no title: the tabs below name the panels.
2026-11-12 14:32:39 +00:00
aiongg e9c1a3a776 Popup lists: one popup padding and the listbox option rows
Every popup pads its content by POPUP_PAD (space.pad.control, the old menu
margin): OverlayUi::show insets its body, and PopupList, Popover and Menu
take it as their pad; Menu::inline has no pad of its own. Option rows of a
listbox have their own form: rounded, the chosen row in state.selected with
an accent.text outline, the lead row in state.hover with a line.control_edge
outline. ListRow::check gives a value list's rows a mark column with the
check glyph on the chosen one; Select, ComboBox, the number presets, the
tree picker and the font picker set it.
2026-11-12 14:32:39 +00:00
aiongg 31948854ad A native dock window's own title row is its only title bar
A tool window's frame comes from policy::tool_frame, whatever frame the main
window has: Inset with the traffic lights hidden on macOS, undecorated with no
caption buttons elsewhere. The installed decision applies to the other kinds.
2026-11-12 14:32:39 +00:00
aiongg 0799bc7588 Open floating dock windows as OS windows where the host reports window positions
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.
2026-11-12 14:32:39 +00:00
aiongg 100843bcf4 Popups shown from an overlay hook sit on the popup surface
OverlayUi::show paints the Popup surface (fill, edge, elevation.popup
shadow) under its body, through the same window-clipped surface slot the
container step uses (SurfaceSlot). Select, ComboBox, completions, the
number field and date popups and the domain pickers drew their bodies
with no fill or shadow. Menu::inline no longer carries its own surface,
so the popup_in_layer clip special case goes.
2026-11-12 14:32:39 +00:00
aiongg 47d26b9813 Keep layer and window mounts out of their parent's fill share
A container on a layer, a full-window layer or an OS window takes no room in
its parent's flow, but step 5 sized it in the parent's Ui and counted it among
the children that share a Stack or Row body's room. A dock area's floating
window was a second fill child of the dock root, so the docked tree took half
the window's height.
2026-11-12 14:32:39 +00:00
aiongg 624b4f5a1d ui-contract: pass facts read once per run
PassFacts carries the frame number beside the viewport, pass number and
clock; the begin hook reads them once. Moment::of, pass::frame_nr and
register_owner read the running pass's facts instead of egui's counters and
the context's viewport, and frame::facts gives the same facts outside a pass.
The measuring-run depth is a pass-local field instead of a context-data slot,
so measure::active takes no data lock.
2026-11-12 14:32:39 +00:00
aiongg dd0666065e ui-contract: pass-local service state
The services the pipeline touches on every run live in one PassState with a
RefCell field each. The begin hook of a context's outermost pass on a thread
moves it out of context data into the thread; the end hook moves it back.
Inside a pass a service access is a borrow of a plain field: no TypeId map
probe, no Arc handle, no mutex. Access outside a pass holds the state for
that one call.

PerViewport types say where their records live through the Stored trait:
a context service by default, a PassState field for the pass-local ones.

The thread-local handle map (HANDLES, ContextToken, open_handles) goes;
Service::run is a context-data lookup for the services that stay there.
A testing counter of those lookups backs a trial: a settled pass of forty
leaves makes as many lookups as one of ten.
2026-11-12 14:32:39 +00:00
aiongg c6b9f48bc5 A story runs in its view's shell, in one body
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.
2026-11-12 14:32:39 +00:00
aiongg df2b2aa490 contract: one read and one props clone per body run, props compared by value, shared inherited env
- pass_extent builds the measuring run's hooks from the run's own read instead of reading again on a peek stage;
  the measuring run of a real pass now sees the kept scroll extent and anchor, as a sizing pass's does.
- BodyHooks holds the container's props in one Arc for the run; the measure key keeps that Arc and compares the
  fields a body's measure reads (ContainerProps::measures_like), replacing the Debug-text fingerprint. Glyph is Sync
  so the props can live in layout memory.
- Scoped keeps the per-scope fields and shares the rarely changed ones (tokens, platform, words, formats, app
  values, commands) in an Arc<Inherited> read through Deref; writers go through inherited_mut/extend_values.
  ItemFacts sits behind an Arc.
- The line env derives only when it changes something; run_body, run_body_measured and run_sharing take the body's
  env instead of looking it up again.
2026-11-12 14:32:39 +00:00
aiongg 635c732488 Fewer allocations per run: borrowed part declarations, inline samples and part lists, reused arena buffers
Step 8 borrows the declared parts instead of copying them: Decls keeps the
sensing core's PartDecls beside their extras. sense_root records its shapes
from an iterator and moves its widget list into the arena. The arena swaps
and clears its per-pass lists. Member decls and shapes, read samples and the
value and reset part lists sit inline. A real read takes no copy of the open
measuring runs.

Adds a trial: a control whose size follows its value reruns the frame after
its own edit.
2026-11-12 14:32:39 +00:00
aiongg d4da861dad Check a kept transcript's leaf calls against the leaf's own answers
A real run under a kept transcript compared each kept measure call by asking
the component again, though step 5 had just asked it the same call. The check
now takes the calls the leaf's run made: a kept call at the same proposal and
room that read no inputs compares with that answer, and only other calls are
asked again. The check reads the transcript's calls in place instead of
cloning them and their inputs per leaf, and a leaf hands its ideal and minimum
calls over in one leaf_call.
2026-11-12 14:32:39 +00:00
aiongg 65f67985fc Count trial: a settled memory stage records no slot again 2026-11-12 14:32:39 +00:00
aiongg 51c7fc3117 A component's shown copy, last drawn pass, last state and state tweens are one shown slot 2026-11-12 14:32:39 +00:00
aiongg 5835939df3 Memory write-back records only what the registry lacks 2026-11-12 14:32:39 +00:00
aiongg 9bc147affd Level tables key every type of the library under craft_ui
The surface and story layout tables name the library's types under
craft_ui, but since the split a type's crate target is the crate that
declares it, so no library row matched: Slider's value groups lost their
form rows and every library type sat on the panel surface. The table key
reads a type of any library crate as craft_ui, as the level rows already
read a library module path. The stale-row check runs in the craft-ui
facade's trials, where every crate of the library is linked, and checks
the library's rows whenever one of its crates is.
2026-11-12 14:32:38 +00:00
aiongg 16b43d84a5 A kept measurement serves the value text its run found
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.
2026-11-12 14:32:38 +00:00
aiongg 9305448598 Gallery cards run each story once: an embedded shell as tall as its content
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.
2026-11-12 14:32:38 +00:00
aiongg 64e3e6f4e5 A scroll body keeps its content extent with its offset
The extent that bounds a body's offset lived in shown memory (`BodyView`),
which is evicted soon after a body stops showing, while the offset and its
anchor live in session memory (`ScrollState`). A body shown again after a
longer hide clamped its kept offset against an extent of 0 and came back
at the top. The extent now lives in `ScrollState` beside the offset, with
the same lifetime; `BodyView` keeps the view rect.

The anchor rule runs only in the run that lays the content out for the
view: a measure run places no Lazy children, so it would clear the anchor.
2026-11-12 14:32:38 +00:00
aiongg e872978edc Overview first show runs only the cards in view
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.
2026-11-12 14:32:38 +00:00
aiongg 78193f81b6 Activation suite: a step is the one the control took, declared before the key
An arrow's step is read from the focused node's number: Increment when it rose,
Decrement when it fell, and the arrow's own direction only when the node reports no
number on both sides of the key. The step counts only when it was declared before
the key, the state an AccessKit user acts from. A Select holding its first entry
(story select_first) steps forward on ArrowDown, which is its Increment.
2026-11-12 14:32:38 +00:00