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.
A source marks a sub-row with its indent steps (ItemSource::sub_row). The row is
compact, its eye column empty, and its toggle cells sit in its content at that
indent (sub_row_cells): one step past the layer for the header, two for an item.
Presses flip them there and a sweep down the eye column passes them by. No divider
falls between a row and the sub-rows that continue it (RowState::continued).
The mock's Effects header carries the sparkles icon.
A child placed on an unwrapped row's line reports how far below its top
the centre of its first line lies: half a control's height, a row body's
line, or a container's first child's first line (its header's, else its
body's), which its measuring run records. A child whose first line lies
at half its height is one line (a control, a row of one-line children, a
field with its label beside its control) and sits with its centre on the
row's line, so a side-labelled field holding smaller controls centres
them. A child of more than one line (a column, a field with its label
above or a help line below) sits at the row's top, as does one with no
line of its own (a collection whose rows run along Y), so columns beside
each other share their tops. The row's line is the lowest centre of its
one-line children, or of the line it shares with its container's inline
regions; the row records the line's centre and its height, and takes
that height in its measuring run.
Replaces the line/block split, where every container sat at the row's top.
The header is the stack's first row and the footer its last, so the gap
between the stack's children also separates them from the body. A gap set
after the header or footer keeps them in step; footer_gap still sets the
footer's own.
A collection kept its offset in session memory but the last pass's extent in
shown memory. While another document showed, the hidden list's shown memory was
evicted, the extent read back as 0, and the read step clamped the offset to 0.
Every later step already clamps against this pass's content, so the read-step
clamp and View.extent go.
Divider and edge rules take the thin stroke (1 pt, whole physical
pixels) instead of one physical pixel; grid rules over the document stay
one physical pixel.
The rules between a container's regions (above and under the header,
beside a ruled footer, before a ruled end region) each get a band in the
region layout, so no rule lies over a region's content at any scale.
Rules drawn along a rect's edge (footer bar, tile grid tail, timeline
graph bar, docked scroll bar, layer row toggle cells) are edge rules on
the side the rule belongs to, so the second pixel at 2x stays off the
neighbour. The split button's divider reads the divider rule's width.
The samples beside the thumbnail size choices of a panel's options dialog (Layers, Channels, Paths) are larger than the
panel's own thumbnails, so the three choices read apart. They take `size.thumb.sample.{sm,md,lg}`: 36, 48 and 96 in
Compact, 36, 68 and 96 in Comfortable (twice the row thumbnails, as the old dialog drew them; PhotoCraft draws 38, 68
and 96). A Picture shows one through `PictureSize::Sample`, and the Layers options dialog's samples use it.
A group header is a section row of the table's collection, which takes its press, keys and AccessKit heading node
but builds no row for it. The table declares a sense-less part over each header in view and one over its disclosure
column, and paints a heading ListRow and a triangle Disclosure as their faces, inside the rows' view; the faces have
no nodes of their own. The header shows the lead while the table has focus.
ListRow::disclosure_by_host and disclosure_at are public for hosts outside the widgets crate, and Cx::collection_lead
gives a collection the lead's position (tile grids read it there too).
A single-line edit takes its text's own font for egui's row and runs in a rect
one row tall centred on the part, so a text row taller than the part no longer
grows down from the part's top and sets the text low. Side labels follow the
baseline.
The digits take the mono type role, as the timecode field does. The unit is a
smaller faint caption pinned at the end of the value area with the inline gap,
so the number centres in the room before it and stacked fields line their
units up. Units::suffix goes; callers pass the unit's symbol.
Component::fills defaults to the width when the caller set Sizing::FillWidth,
and the sizing stays on the component after step 1 so the layout hooks read
it. Button, TextField and Slider lose their fill_width props and Swatch and
GradientSwatch their fill flags; callers set Sizing::FillWidth. The blend
select in BlendRows takes the room before Opacity, as in PhotoCraft.
A contract trial checks that a FillWidth leaf takes the row's room and a
Content leaf does not.
BlendRows, LayerFilterBar, the scopes refresh button and the wide-angle Add
constraint button no longer fix the small size, so they show at the size
their scope gives (Md in a panel), as PhotoCraft's header controls do.
Groups::Open opens the layer's closed groups and scrolls its row into view; Groups::Keep opens
nothing and scrolls to the row of its outermost closed group, the row that stands for the layer
(PhotoCraft's Move tool pick with "expand group on click" off).
A reveal (requested, key move, page switch, type-ahead, rename) scrolled by the item layout's
extents, in which rows no pass built yet have the estimate. The rows the pass then built took
their measured heights and pushed an auto row taller than the estimate out of view. The List
now aims the reveal in the content step, before it builds the rows: it builds and measures the
auto rows that will share the view with the revealed row, up to it, that have no kept height,
and aims again until the row is placed by measured heights. The build takes those measures and
does not measure the rows again, and the frame runs once. The per-row measure is shared with the
widest-row measure.
LayersPanel no longer compares the active layer with the last pass's (Session.seen_active and
the auto-reveal go): the app calls reveal(layer) in the pass its active layer changes.
LayersPanel::document(key) keys the rows List per document, so each document keeps its scroll
position and lead.
Trials: ui-widgets List reveal past unbuilt taller rows (one pass, no row measured twice);
craft-layers panel_reveal (reveal with Open, row in view, per-document scroll, counts).
craft-ui testing part_rect_of_node reads a part's rect from the shape record by the owner's
AccessKit node, the lookup Fixture::part_rect makes by id. ThumbTarget::part and TrailingPart::part
name a row's thumbnail and trailing parts; the row declares its parts through them.
LayerInfo::thumb maps a layer part to the thumbnail that shows it, over the order the panel
reads thumbnail clicks by, and craft-layers testing thumb_rect and fx_badge_rect give a host test
the rect of a layer row's thumbnail or fx badge. The drag, menu and frame trials find thumbnails
and the badge this way.
ComparePair::divider gives the segment in the middle of the gap between the panes, as LightCraft's Compare view draws
a line there; the pair story shows a vertical Divider on it.
Each shortcut of a row is a chip that shows its chord through Kbd's keycap form, the framework's one look for a
chord, and asks to record over it on a click, Enter or Space. The chips no longer take a full-height button.
The filter button and the error tag share one cell button look (table ui/cell_button.rs): a raised box with
shape.radius.control corners and a size.icon.sm glyph, so a filter button fits inside its header cell instead of
a pill that covers the heading. The sheet stories' rows are a line of body text high, as a spreadsheet's default
row, under the 20 pt headers.
The well fills its row's width after its siblings (Component::fills) instead of measuring the whole room, so fields
beside it stay in view (ParamRows' point row showed them past the edge). The cross is size.icon.md long. The Default
story shows the picker with its X and Y fields, as a dialog's point row does.
A card's padding is space.pad.regular; the icon, the first line of the text and the dismiss button share one centre
line; a card's rows (head, bullet lines, the "and n more" line, actions) are space.gap.stack apart, an inline
notice's lines stay together; and the actions start at the content's start edge under the icon, as the bullet lines
do.
follow_lead_source moves the lead to the row now in its place and no longer
selects that row: a row that was deleted or filtered out is not replaced by its
neighbour. LayerFilter::deselect_hidden is the one rule for a newly applied
filter (Photoshop #10879); the panel reports it as a Select on its filter bar's
edit, and an app that sets the filter itself calls it there.
SCC, MCC and EBU STL labels go through TimecodeFields with timecode::{frames_to_fields, fields_to_frames}. FrameRate, Tick and TICKS_PER_SECOND stay re-exported at the crate root; the re-export of craft-timeline's time module goes, since frame rates and timecode live in rates and timecode.
ale, build, edl, fx, path, rate and report are modules of the crate again, fcp7 and fcpxml behind the xml feature, otio behind otio, as storytold had them. The format list, the import and export options and the interchange error sit in interchange beside the neutral document and are re-exported at the crate root. The formats read and write time through rates, time and timecode: ALE rows through parse_time, an EDL timecode holds TimecodeFields, FCPXML format names use FrameRate's Display. Serde is always on, so the interchange types derive it unconditionally; the formats keep storytold's no-panic lints.
storytold's interchange tests run as trials of the lib's one test executable: the modules' own tests always, tests/it/{fcp7,fcpxml,otio} with the xml and otio features.