FindReplace, Hyperlink, Paragraph, Check Spelling, Marker, the Contour editor, ListManager
and ParamDialog with a preview put their buttons in the side column. FormDialog takes extra
footer buttons (ResetFooter::extra, ResetPick::Extra) in place of hand-made buttons in
footer_extra; ParamDialog's Preview check box sits under the buttons. FileListPicker's
buttons stand beside the list through Stack::footer_beside, one width.
Button::fill_width joins a button to the content-column fill; FooterBar::column stacks
the members at one width, Accept, Cancel, then the others on every platform; and
Dialog::side_buttons puts the footer at the top of a full-height end region with the
footer content under the buttons.
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.
BezierOverlay reports an insert halfway along the segment leaving the picked
anchor on Insert, and ArtboardOverlay adds a board on the right of the picked
one. The Menu key or Shift+F10 on the focused canvas reaches the background's
controls (BackgroundPress::context_key), so the pasteboard opens its menu at
the view's centre. While a guide is selected, Guides hold Delete and Backspace
on the focused canvas and remove it.
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.
PreviewZoom shows the zoom as a percent field; a typed value applies at once through PreviewView::zoomed_to, kept inside the view's zoom range. The parameter dialogs' preview row and Save for Web share it.
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.
Every full-window workspace pans with Space and zooms with Cmd+Space and Alt+Space: the canvas keeps its own Momentary set between passes. The opt-in builder and the copies in Fill and Vanishing Point go.
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).
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, ...).
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.
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.
TransformBar pins Reset warp, its rule and the mode switch after commit
and cancel. The annotation toolbar puts its colour and width on a second
row, and the crop bar shows Delete Cropped Pixels and Fill on the bar.
Bar::vertical goes: the vertical tool strip is a rail.
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.
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.
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.
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.
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).
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).
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.
on_surface draws a raised button pressed in while on; the selected segment takes the raised kind with its edge in
place of the flat one, so a bevelled theme shows the raised outline. Trials for the kinds, the field's inner line and
the dropdown fill.
- 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 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.
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.
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.
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.
story-render asked craft-ui for snapshot, which the runtime's testing already
includes, so every render built its own facade. cl doctor checks the
renderer's lines against the gallery's, and the new-build report keeps
check-only builds apart from full ones.
An edit to the runtime's 65k lines spent 35-90 s in opt-level 1 codegen before
its test binary linked. The hot pipeline is generic and compiles in the
dependants anyway; theme, behavior and proof stay at opt-level 1.
cargo unifies features only over the packages a command selects, so a framework
crate's tests, a domain crate's tests, the gallery and the story renderer each
built their own copy of the framework and of wgpu. feature-root carries the
gallery's dependencies with every domain crate; cl selects it beside every
command's package and names the crate's own targets, so nothing of it builds.
The per-crate feature anchors go; cl check also checks a crate's bins.