- Story suite: a text run counts as shown by an open layer only when its clip lies
in that layer; PaintedText records the clip.
- Place::flipping_across: only submenus open upward from a low row; rail and dock
flyouts slide as PhotoCraft's tool flyouts do.
- Only modal and window layers in an embedded shell's region take the whole
region; a popup kept in a PopupRegion keeps its cap.
- Strips scroll at rows per second of a control's height and show in the pass
whose measured content first overflows.
- Trials: a bar menu reopened after scrolling to its end shows one level from
its first row; a dropdown in a bar menu keeps its cap; a low tool's flyout slides.
The text-size case counted only the story's own area as shown, so a scrolled
popup's rows, cut only by its view, read as leaving their part once a density
change moved them past that area. What the story shows is its area and the
layers it has open.
PopupRegion is the screen rect the popups opened in an env stay inside;
overlay::region_for returns it for popups, through the path an embedded shell's
modals take, and the measuring room keeps to it. MenuBar sets it below itself
(OverlayUi::contain_popups_below), so a submenu taller than the room under the
bar scrolls instead of covering the titles. The overflowing-menu story goes: the
story suite's room is shorter than the window a menu fills.
Scroll gets a strip indicator: arrows above and below the view that scroll while
the pointer rests on them, taking height from the view and never width. Menu and
inline menus use it, so every menu layer, the menu bar's included, scrolls in the
room it has. overlay::place opens a side overlay that runs past the bounds the
other way when it fits there, so a tall submenu of a low row opens upward.
The registry keeps the dialog's part and the host's part apart: the
host's gestures join the reach only while a modal body keeps the same
canvas, whatever order the two are made in, so a modal that keeps
nothing (an alert) leaves the canvas blocked. Trials: the host's gesture
lapses when the dialog stops keeping the canvas; under a dialog that
keeps nothing it passes no press and no wheel.
Also: the BlockingOverlay story's drive opens it; rows.rs doc wrapped;
api-map TonePickerRow note names pass_canvas_gesture.
A control's registration belongs to the modal whose body makes it and
is dropped outside every modal body, so a picker armed in a panel passes
no press under a modal that opens later. The canvas's host passes its
running tool's gestures with runtime::sampler::pass_tool_gesture, which
belongs to the top modal. Trials: a panel picker passes nothing under a
dialog; the host's tool gesture passes and lapses with the dialog.
The Dialog and BlockingOverlay stories bind their open state to an
opener button; the close-box drive opens the dialog first. The story
overlay without a card closes with Escape.
The tool host runs the canvas's tool outside the dialog's body; its
registration holds for the top modal layer, here or in another viewport,
and lapses with it. Trial: a gesture the canvas passes itself reaches it
under the open dialog and lapses when the dialog closes.
The canvas a modal dialog keeps open (runtime::sampler) passes the view
navigation and, beside it, only the presses the dialog names: a
CanvasGesture is a button with the modifiers it needs held, its drag
included. Sampler::pass_canvas_gesture replaces arm_sampler; the
eyedropper rows, the Color Picker and the tone pickers name a primary
press, Curves names its Cmd-click, and every other press stays blocked.
Trials: the kept view passes the wheel (scroll and zoom) and the middle
pan and blocks the primary press; a modifier gesture passes only with
its modifier. Story: Canvas "under a dialog", a live region under an
open modal.
StandardPrompt and UnsavedChangesDialog build their buttons, their choice
check and their programmatic OK from one offered list; a choice without an
enabled button is refused. HostedParamDialog opens its values once (remembered
values, defaults) before its first show, OK or set, through the helper the
first pass uses; OK builds its result through one helper; set refuses rows
that are hidden or disabled and reads the value as its row's kind.
set_json_field takes the Context. Automation lists dialog ids as decimal
strings, takes a string or a number, and names only the host's dialogs.
StackDialog gains json_fields and set_json_field; DialogHost lists its open
dialogs with their fields, sets one by id, and confirms or cancels by id
whatever the type. HostedParamDialog (values by parameter row, with a
programmatic OK), StandardPrompt and UnsavedChangesDialog (their choice)
implement them. craft_automation::dialogs runs ui.dialog.set/confirm/cancel
on a host and lists its dialogs for ui.inspect.
A letter typed into an open Select list went to the list's type-ahead and also
stayed in egui's input, where an app's own dispatcher ran it as a tool key. The
strip links each press to the text it typed, the begin hook records which texts a
component took, and a widget or popup holds a press whose text it took, as it
holds the presses its routing takes: the press leaves egui's input and the
runtime's shortcuts.
overlay::close_popups closes the running viewport's popup layers. An app whose
dispatcher reads its shortcuts from egui calls it when a shortcut runs; only the
app knows that a press matched one of its bindings.
keys::focus_holds names whether the focused component holds a chord: claimed, or
held by routing as owned_shortcuts decides. route_press splits into a decision
that reads state only (press_route) and the step that acts on it (apply_press),
so the query and the key stage share one decision and one held predicate.
key_reorder takes the rows acted_on names, so a stacking key on a selected sub-row moves that sub-row and not its
row. While a press holds a release for a later pass, sensing asks for a repaint, so the release goes out in the next
frame without new input.
A sub-row belongs to the row above it, so a gesture on one acts on the selected rows of its own kind. The Layers
panel keeps a Smart Filter row selected beside its layer; a drag of that row carried the layer too, and the drop
rule refused the mixed set.
A release in a pass that still owes the press's Down or DragStart is held for the next pass, with its click
state taken when the button went up. Two clicks in one frame, which the one-press rule splits into
[P1], [R1, P2], [R2], report Down and Activate for both clicks.
Every craft text control (TextField, NumberField, ChipField, AltTextField, DateField, ComboBox) shows the
EditMenu in a context menu on a right click in its text, the Menu key or Shift+F10. The open menu holds the
focus without ending the text part's typing run or losing its selection, so Escape closes the menu and the
field keeps editing, and a picked row acts on the field's selection once the focus is back. Rows run their
EditCommands through the command board, the same route an app's Edit menu uses.
- record_context counts a secondary release on a component's text widget
- a secondary press inside the selection keeps the selection
- EditCommand::Delete: the Delete command run from a menu deletes a text part's selection; the Delete and
Backspace keys stay the text part's own deletion, and editors leave the command to the app
- TextField/NumberField::own_context_menu for a caller that hangs its own context menu on the field
(the transform fields' unit menu)
A host-drawn region (focus::host_canvas) reads its keys from egui, so a key it
keeps (Tab) must stay there. Stop::host marks it, and the key stage withdraws held
presses only for framework components.
The strip left Cmd chords and arrows in egui's input and also routed them, so a
focused list row's stacking move and the app's own egui-reading shortcut both ran
on one press. Routing's held-by-the-focused-widget fact, which already filters the
runtime's shortcut list, now also withdraws those presses (and their key-down
state) from the pass's egui input; their releases follow through the strip's
consumed list.
The Lock row's five buttons are small (ControlSize::Sm) and touch, as Photoshop's, so Fill and its
field stay on the row at a panel's width instead of wrapping below it. The Kind filter toggles are
small too.
LayerInfo::thumb_badge is a ThumbBadge (SmartObject, Shape) that craft-layers paints: a window glyph,
or a path with an anchor on each corner. Kind and mask badges share one badge box, a field well at
the small icon size in the thumbnail's corner.
A tooltip shown from a field's control recorded its text line in the
field's label scope, so the side label lined up with the tooltip and
dropped under the next row. The overlay host now runs a layer's body
outside the open label and merge scopes.
A given value has no read record, so the edit reruns nothing: the component
shows the edit itself, and the app's other views show it in the next frame.
A drag on a given value (the Layers Opacity and Fill sliders) ran two passes
every frame.
Dividers fall between rows (RowState::last), so a list's last row no longer
draws a rule beside the footer bar's. Photoshop's Effects header shows only its
eye and label; the mock sets no icon and SubRow::icon no longer names one.
A list row paints a trailing drag handle's icon face as a mark, not an icon
button: a handle has no node of its own (the row's description names it), and a
button face would add an unnamed button.