PartsCx::selectable_text declares a run as a selection part with a press-only
stop in no group; step 8b gives the focused one Select All and Copy; and
PaintUi::selectable_text shows it through the text widget with the run's own
galley, in the state's colours. Notice title and message, MetadataTable values
(ListRow::cell_selectable) and SelectableText use it. SelectableText loses its
Bind and Input::Text path and becomes a label whose value is its text. The
suite presses the focus registration's press-only stops when Tab reaches
nothing, instead of guessing from Input::Text and a read-only node.
A dialog starts on its first field, else its default button, else nothing. These trials' content is a plain focusable
leaf, and they test focus return and the sampler keeping key focus, so they ask for Initial::First.
`MeasureCx::picture_width`: a picture takes its column's room, between its
least and its most, and its least at `Proposal::Min`. CurveGraph's own rule
moves onto it. Band pictures (the point picker and the colour area, the
histogram, the vectorscope, the navigator preview, the preview pane, the
reading view) take the width at least `size.plot.width` and keep their
height; the colour wheel and disc are squares between `size.plot.height`
and `size.plot.width`.
ColorWheel, ScopePanel's plots and the ColorPicker area fill the card's
width as the old ones did.
A grid's measuring run measures each content column in the room the other
columns leave at their least. When the columns do not fit beside each other,
it asks every column for its least in a probe sweep (every leaf at its least,
no column bounded) and measures once more: a content column in the room the
others leave at their least, a fill column never below its least. Columns
whose leasts do not fit beside each other are laid out one under another
across the room, so no column is cut. The leasts and the stacked layout are
recorded for the real run.
A wrapped text's least is its widest word: a line breaks between words.
FontsPanelView's list column and ColorPicker Full's channel column no longer
collapse at card width.
`Metrics::least_width` is the floor a least measure takes in place of
`min_size`'s width. A field keeps its 96-point floor where it takes its own
width and, in a row that shrinks it, narrows to its padding and one glyph plus
what its content measure adds there (a select face's ellipsis and chevron, a
text field's adornments).
A short row takes its shortfall from every unit in proportion to what each can
give, so all reach their least together.
The editor of a text field ran in a scope of the parent Ui, which moved the
parent's cursor back to the end of the text part after the root had taken its
place: a member after a search field started inside the field's clear button.
An enabled link, check box, radio button, switch or colour well shows the
pointing hand over its own shape, label included, through Role::hover_cursor;
a hovered part's declared cursor comes first. A scrub's source (the field, or
the label that scrubs it) shows the horizontal resize cursor. Breadcrumb
segments declare the pointing hand and PointPicker's well the crosshair.
The leaf label step offers its label to a child that draws only its mark; the
child senses over mark, gap and label, so a press on the label hovers, presses
and activates it in the same pass. The queued next-pass activation goes. A label
after its control wraps with the control on its first line. BodyCx::labelled_with
shows content inside the label (LayersOptionsDialog's size samples).
A read-only text stop takes focus from a press only (Stop::press_only), so the user can select and copy it
while Tab and F6 pass over it, as selectable labels did. PropertiesDialog shows its read-only values with
SelectableText. The suite reaches read-only text with a press where Tab passes over it.
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.
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).
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.
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).
Neighbouring items of one section are a group the strip shows or moves
whole, as the old toolbar moved its groups. MoreMenu::Every lists every
item, as the old align bar's menu did. A vertical strip sets its groups
apart with space instead of a rule.
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.
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.
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.
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).
- 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.
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.
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.
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.
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.
A step over a closed control stops on the enabled, stepped entries only. A value on
none of them (mixed, or an entry only the open list offers) has no place: it reports
no number, so both steps are offered, and a step forward lands on the first stop and
a step back on the last. Select and ComboBox step with the shared step_stops and
step_stop.
LutPicker marks Load 3D LUT…, the folder files and the loaded LUT as not stepped, in
place of its filter on step events. The loaded LUT then offers both steps, which the
craft-color activation suite asks for.