Each egui_kittest wgpu renderer creates its own Vulkan instance and
device. When one test uses its device while a test on another thread
creates or destroys one, the Vulkan loader now and then crashes the test
binary with SIGSEGV. The previous commit serialized the four rendering
tests in tests/visual_regression.rs; the craft-ui unit test binary has
the same pattern in two tests:
combo::tests::the_button_and_menu_look_like_eguis and
tabs::dialog::tests::selected_tab_erases_a_baseline_centered_on_its_bottom_edge.
Both now take crate::gpu_test_lock() before building their harness and
hold it until the harness is dropped. The comment on the lock in
visual_regression.rs now names the loader race instead of concurrent
rendering alone.
The visual_regression test binary crashed with SIGSEGV now and then on
the Ubuntu CI runner, where wgpu uses Vulkan (WGPU_BACKEND=vulkan) with
Mesa's software driver. Four of its tests each create a
WgpuTestRenderer, which creates its own Vulkan instance and device, and
the test harness runs them on parallel threads. When one test uses its
device while another creates or destroys one, the Vulkan loader can
read a device entry that is being freed.
Each of those tests now takes a shared lock before it creates its
renderer and holds it until the renderer is dropped. A poisoned lock is
taken over, so a failed test does not block the others.
* docking: fade a dragged native window only when the drag can dock
* docking: narrow the outer edge band to the canvas column and add DockStyle::drop_edges
* docking: drop_edges defaults to all sides; the docking profile's outer band takes only its top and bottom
* panes: preview the slot a dragged pane docks in, also while floating
* docking: a drop that changes only sizes is a no-op; a lone floating group's header drag looks through its window
* docking: a drop beside a frame too narrow to halve takes the room from beyond its divider
* panes: the dock preview counts a pane its drop reveals, and a side pane stays inside the host
With SidePolicy::OneSlot a drop can reveal a pane the frame hides, so the landing slot is
worked out from every open pane. A side pane is no wider than the room the panes outside it
leave, as the preview assumes; egui placed a wider one partly beyond the host's edge.
* docking: anchor an outer edge drop on the area it shows
The edge band and window.panel.dock to an outer edge anchor on the canvas only where the edge area narrows to the canvas column, else on a panel that is not protected, so tree order no longer decides the frame. The renderer tries the drop and offers the band only when it wraps the panels the band shows. A top (bottom) edge also narrows a split of rows to its first (last) row when only that row holds the canvas. to_actions takes the permissions, and FloatSpace records side_edge_zones.
* docking: a sized split gives the new frame its minimum or saved width
* docking: keep a native window opaque during a float-only drag
* docking: DockCommand::to_actions keeps its signature; to_actions_with takes the permissions
FilmCraft calls to_actions. Without permissions no panel is protected, so an outer edge dock
wraps the part between the docks, as before.
* craft-ui: match guard for a stack's hit test (clippy 1.95 collapsible_match)
* Update egui to 0.37
egui 0.37 replaces WidgetType with accesskit's Role and renames a few
methods. Mapped per egui's own table (WidgetType docs): Checkbox is
CheckBox, SelectableLabel is Button, Other is Unknown; UiBuilder::id and
Ui::id are scope_id; Id::new is Id::unique (the same hash). No behaviour
change.
egui's test harness now panics on a glyph no installed font has, and its
bundled fonts dropped U+22EE, so the docking fixture's group header draws
an ellipsis instead of a vertical ellipsis.
* craft-ui: README says egui 0.37
---------
Co-authored-by: Davis Brief <davisbrief@gmail.com>
- Permissions::accepts_splits; PROTECTED takes no side splits, so a
group dropped on a protected canvas floats.
- A press of any pointer button in a panel body, stripless panels
included, reports the panel in DockOutput::focused.
- Right to left, tab strips, their header and drag bar, insertion slots
(DropTarget::right_to_left), accordion headers and chrome::TitleBar
(ChromeStyle::right_to_left) mirror. TitleBar truncates galley titles
like tab labels.
- DockStyle::close_menu_items and close_button hide the built-in close
controls without changing Permissions::closable.
- Menu labels say what moves: Move Panel to Group (move_panel_to_label)
and Move Group to (move_group_to_label).
- The column bar's button has its own accessibility labels
(collapse_column_label, expand_column_label).
- Placement::for_zone maps zones onto what the anchor's container takes;
DockCommand uses it and takes right_to_left.
- Layout::apply, apply_with_permissions and apply_all return the closed
panels.
- Placement::Group takes an optional preferred height.
docs/ui-docking.md covers the Dock and Frame profiles, the model and
actions, Workspace, the renderer and DockContent, gestures, DockCommand,
DockStyle::localized, hit rects and the DockDriver test driver, and links
the task-pane guide.
Also: ui.dock open, close and activate map in one place, the command tests
build as a cfg(test) module, the hit-kind table gets a type alias, the
testing example uses public API, and rustfmt.
DockCommand<P> deserializes a control command's params, with its id under
"command", and maps it to layout actions applied all or none. It covers the
window.panel.* and window.workspace.* ids, the raw {action} form, and the
ui.dock {operation, …} shape of LightCraft, PDFCraft, CADCraft and
SoundCraft (open, close, activate, float, moveFloating, move, setStackOpen,
resizeStack, resizeSplit), so their parsers can go without a protocol change.
Named workspaces and Reset stay with the application.
tests/docking_workflows.rs loads every v1 fixture, docks groups by their bars
into a new dock, a bottom band and a seam, collapses and expands the column,
floats it by command, drags it back, and checks the layout reads back as
written.
Group, column and window moves, close and restore round trips, dock validation, Lock Workspace, reconcile and reset, the random action sequence over dock layouts, and one v1 fixture per app shape that must parse and write back unchanged.
Node::Dock holds columns of groups on a logical window edge (Side::Start
or Side::End). Floating windows hold a stack of groups and an optional
native rect; the v1 {panels, active, rect} shape still parses, and a
window with one plain group writes it. Placement gains Group and Column,
Target names where a group, column or window goes, and the new actions
move, close, minimize, collapse and resize groups, columns and windows
atomically. Location records group and column state so a panel closed
from a dock or floating stack restores to the same group, seam, column
or dock. Layout gains apply_all, closed_by and panel_state; Permissions
gains locked. Node, Action, Placement and DockError are non_exhaustive.
The renderer draws each floating window's groups stacked and a dock's
columns side by side until the dock and floating-stack profiles land.