Files
solidcraft/crates/ui-egui/src/shell_tests.rs
T
Nathan Dane 90d9c6488a Panels: add columns, stacks and tabs with exact drag previews (#11305) (#11608)
* claim: #11305

* Panels: add columns, stacks and tabs with exact drag previews (#11305)
2026-11-05 18:38:54 +00:00

2571 lines
141 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
use super::*;
use crate::scenario::{Harness, rect_of};
use serde_json::json;
use solidcraft_engine::panels::ActionSink as _;
/// Inspect existing caches; never warm/evaluate geometry as part of an assertion.
fn assert_panel_host_preserves_design(h: &mut Harness, exercise: impl FnOnce(&mut Harness)) {
let document = h.app.session.doc.clone();
let model = h.app.session.model.state();
let cache = h.app.session.model.cache.clone();
let meshes = model.bodies.iter().map(|body| body.cached_mesh()).collect::<Vec<_>>();
let revision = h.app.session.revision;
let undo = h.app.session.undo.len();
let dirty = h.app.session.is_dirty();
let recomputed = h.app.session.model.recomputed;
let camera = h.app.cam;
let render_domain = h.app.viewport.rect;
let sample_points = [solidcore_record::Vec3::ZERO, solidcore_record::Vec3::new(1.0, 2.0, 3.0)];
let screen_points = render_domain.map(|domain| sample_points.map(|point| crate::viewport::projection(&h.app, domain).to_screen(point)));
let preferences = serde_json::to_value(&h.app.preferences).unwrap();
exercise(h);
assert!(std::sync::Arc::ptr_eq(&document, &h.app.session.doc), "panel chrome must retain document identity");
let after = h.app.session.model.state();
assert!(std::sync::Arc::ptr_eq(&model, &after), "panel chrome must retain model identity");
assert!(std::sync::Arc::ptr_eq(&cache, &h.app.session.model.cache), "panel chrome must retain evaluation cache identity");
assert_eq!(h.app.session.revision, revision);
assert_eq!(h.app.session.undo.len(), undo);
assert_eq!(h.app.session.is_dirty(), dirty);
assert_eq!(h.app.session.model.recomputed, recomputed);
assert_eq!(h.app.cam, camera);
if render_domain.is_some() {
assert_eq!(h.app.viewport.rect, render_domain, "ordinary panel work preserves the full render projection");
assert_eq!(
h.app.viewport.rect.map(|domain| sample_points.map(|point| crate::viewport::projection(&h.app, domain).to_screen(point))),
screen_points,
"panel layout never changes the model's screen position or framing offset"
);
}
assert_eq!(serde_json::to_value(&h.app.preferences).unwrap(), preferences);
for (body, mesh) in after.bodies.iter().zip(meshes) {
match (mesh, body.cached_mesh()) {
(Some(before), Some(after)) => assert!(std::sync::Arc::ptr_eq(&before, &after), "panel chrome must retain cached mesh identity"),
(None, None) => {}
_ => panic!("panel chrome changed mesh cache population"),
}
}
}
#[test]
fn universal_panel_host_is_opt_in_and_each_specimen_preserves_design_and_preferences() {
for preset in ["docks", "tabs", "collapsed", "floating", "overflow", "pinned"] {
let mut h = Harness::new();
h.app.home.open = false;
h.app.run("solid.box", json!({"length":40,"width":30,"height":20})).unwrap();
h.settle();
assert!(h.app.panel_runtime().is_none());
assert!(h.app.universal_panel_frame().is_none());
let legacy_browser = rect_of("browser:card");
assert!(legacy_browser.is_some(), "default still mounts legacy Browser");
assert_panel_host_preserves_design(&mut h, |h| {
crate::panel_runtime::enable_host_specimen(&mut h.app, preset).unwrap();
h.frames(4);
assert!(h.app.universal_panel_frame().is_some(), "actual workspace host: {preset}");
let runtime = h.app.panel_runtime().unwrap();
for spec in runtime.layout().registry().specs() {
assert!(!spec.header_actions.iter().any(|action| action.id.0 == "pulse"), "native specimens have no debug action");
}
assert!(!h.app.universal_panel_frame().unwrap().controls.iter().any(|control| matches!(&control.target,
crate::panel_runtime::HostControlTarget::Pointer(crate::panel_runtime::HostPointerTarget::HeaderAction { action, .. }) if action.0 == "pulse")));
assert!(rect_of("browser:card").is_none(), "legacy placement must be suppressed: {preset}");
h.app.disable_universal_panel_host().unwrap();
h.frames(3);
assert!(h.app.universal_panel_frame().is_none());
assert!(rect_of("browser:card").is_some(), "legacy placement returns when opt-in ends");
});
}
}
#[test]
fn specimen_rejects_unknown_presets_and_cannot_take_over_an_existing_runtime() {
let mut h = Harness::new();
h.app.home.open = false;
assert_panel_host_preserves_design(&mut h, |h| {
assert!(crate::panel_runtime::enable_host_specimen(&mut h.app, "unbounded-user-input").is_err());
assert!(h.app.panel_runtime().is_none());
assert!(h.app.universal_panel_frame().is_none());
crate::panel_runtime::enable_host_specimen(&mut h.app, "tabs").unwrap();
h.frames(3);
let before = h.app.panel_runtime().unwrap().layout().inspect();
let controllers = h.app.panel_runtime().unwrap().controller_count();
assert!(crate::panel_runtime::enable_host_specimen(&mut h.app, "docks").is_err());
assert_eq!(h.app.panel_runtime().unwrap().layout().inspect(), before);
assert_eq!(h.app.panel_runtime().unwrap().controller_count(), controllers);
h.frames(2);
assert_eq!(h.app.panel_runtime().unwrap().layout().inspect(), before);
});
}
fn assert_host_legacy_window(h: &Harness, bounds: egui::Rect) {
use crate::panel_runtime::logical_rect;
assert_eq!(h.app.viewport.host_windows.as_deref(), Some([bounds].as_slice()), "only the actual legacy window reserves space");
let usable = crate::shell::host_usable(&h.app).unwrap();
assert!(usable.obstacles.contains(&logical_rect(bounds)));
let controls = h.app.viewport.layout.as_ref().unwrap();
assert!(controls.usable.as_ref().unwrap().obstacles.contains(&logical_rect(bounds)));
for control in [controls.navigation, controls.axis_view] {
if control.is_positive() {
assert!(!control.intersect(bounds).is_positive(), "same-pass controls avoid the real editor");
}
}
}
fn assert_host_legacy_windows_closed(h: &Harness) {
assert_eq!(h.app.viewport.host_windows.as_deref(), Some([].as_slice()));
assert!(rect_of("dialog:window").is_none() && rect_of("dialog:outer").is_none());
assert_eq!(crate::shell::host_usable(&h.app).unwrap(), h.app.universal_panel_frame().unwrap().layout.usable);
}
#[test]
fn host_retains_one_legacy_move_editor_and_the_pending_capture_question() {
let (mut h, _, occurrence) = crate::test_support::component_box();
h.app.home.open = false;
h.app.preferences.language = "en".into();
h.app.run("occurrence.move", json!({"occurrence":occurrence,"translate":[10,0,0],"capture":false})).unwrap();
h.settle();
let pending = h.app.session.pending_moves.clone();
h.app.tree.occurrence_move = Some(crate::browser::OccMove::new(occurrence));
h.frames(3);
let baseline = h.app.tree.occurrence_move.as_ref().unwrap().baseline;
assert!(baseline.is_some());
assert_panel_host_preserves_design(&mut h, |h| {
crate::panel_runtime::enable_host_specimen(&mut h.app, "tabs").unwrap();
h.frames(4);
let draft = h.app.tree.occurrence_move.as_ref().unwrap();
assert_eq!(draft.baseline, baseline);
assert!(draft.had_pending);
assert_eq!(draft.translate, [0.0; 3]);
assert_eq!(crate::scenario::handles("occurrence-move:distance:0").len(), 1);
assert_host_legacy_window(h, rect_of("dialog:window").unwrap());
assert_eq!(h.app.session.pending_moves, pending);
});
// Cancel must restore the opening baseline, including the earlier pending move.
h.step(&json!({"click":{"handle":"dialog:cancel"}})).unwrap();
h.frames(2);
assert!(h.app.tree.occurrence_move.is_none());
assert_eq!(h.app.session.pending_moves, pending);
assert_host_legacy_windows_closed(&h);
assert_panel_host_preserves_design(&mut h, |h| {
h.app.start("sketch.create");
h.frames(3);
assert_eq!(h.app.tree.capture_prompt.as_deref(), Some("sketch.create"));
assert!(h.app.dialog.is_none(), "the guarded command still waits for its existing question");
assert!(h.widget("Capture Position").is_some() && h.widget("Revert").is_some());
assert_host_legacy_window(h, rect_of("dialog:window").unwrap());
h.step(&json!({"click":{"handle":"dialog:cancel"}})).unwrap();
h.frames(2);
assert!(h.app.tree.capture_prompt.is_none() && h.app.dialog.is_none());
assert_eq!(h.app.session.pending_moves, pending);
assert_host_legacy_windows_closed(h);
});
}
#[test]
fn host_keeps_legacy_canvas_cloud_and_attachment_drafts_with_only_visible_footprints() {
let mut h = Harness::new();
h.app.home.open = false;
h.app.preferences.language = "en".into();
let mut png = b"\x89PNG\r\n\x1a\n\0\0\0\rIHDR".to_vec();
png.extend(400u32.to_be_bytes());
png.extend(200u32.to_be_bytes());
png.extend([8, 6, 0, 0, 0, 0, 0, 0, 0]);
let data = solidcraft_engine::doc::canvas::base64_encode(&png);
let canvas = h.app.run("canvas.insert", json!({"data":data,"plane":"XY","width":80})).unwrap()["canvas"].as_u64().unwrap();
let path = h.dir.join("legacy-editor.xyz");
std::fs::write(&path, "0 0 0 255 0 0\n1 0 0 0 255 0\n").unwrap();
let cloud = h.app.run("pointcloud.insert", json!({"path":path.to_string_lossy()})).unwrap()["cloud"].as_u64().unwrap();
h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();
let sketch = h.app.session.active_sketch.unwrap();
h.app.run("sketch.finish", json!({})).unwrap();
h.settle();
crate::panel_runtime::enable_host_specimen(&mut h.app, "tabs").unwrap();
h.frames(4);
h.ctx.options_mut(|options| options.max_passes = 1.try_into().unwrap());
for editor in ["canvas", "cloud", "attachment"] {
assert_panel_host_preserves_design(&mut h, |h| {
match editor {
"canvas" => {
let mut draft = crate::browser::CanvasPanel::new(&h.app, canvas, true);
draft.a = [3.0, 4.0];
draft.distance = 73.0;
h.app.tree.canvas_panel = Some(draft);
}
"cloud" => h.app.tree.cloud_panel = Some(crate::browser::CloudPanel::new(&h.app, cloud)),
_ => {
h.app.tree.redefine = Some(sketch);
let mut draft = crate::sketch_attachment_ui::Draft::new(&h.app, sketch);
draft.label = "retained plane draft".into();
draft.error = Some("retained draft error".into());
h.app.tree.redefine_draft = Some(draft);
}
}
h.frame();
assert_eq!(h.app.viewport.host_windows.as_deref(), Some([].as_slice()), "{editor}: invisible sizing cannot reserve a window");
h.frames(3);
let name = if editor == "attachment" { "dialog:outer" } else { "dialog:window" };
assert_eq!(crate::scenario::rects(name).iter().filter(|(key, _)| key == name).count(), 1, "{editor}: one legacy producer");
assert_host_legacy_window(h, rect_of(name).unwrap());
match editor {
"canvas" => {
let draft = h.app.tree.canvas_panel.as_ref().unwrap();
assert_eq!((draft.a, draft.distance), ([3.0, 4.0], 73.0));
}
"cloud" => assert_eq!(h.app.tree.cloud_panel.as_ref().unwrap().cloud, cloud),
_ => {
let draft = h.app.tree.redefine_draft.as_ref().unwrap();
assert_eq!(draft.label, "retained plane draft");
assert_eq!(draft.error.as_deref(), Some("retained draft error"));
}
}
h.step(&json!({"click":{"handle":"dialog:cancel"}})).unwrap();
h.frames(2);
assert!(h.app.tree.canvas_panel.is_none() && h.app.tree.cloud_panel.is_none() && h.app.tree.redefine_draft.is_none());
assert_host_legacy_windows_closed(h);
});
}
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn host_clears_suppressed_assistant_geometry_without_losing_chat_or_tool_width() {
let mut h = Harness::new();
h.app.home.open = false;
h.app.ui.layout = LayoutMode::Floating;
h.call("ui.agent_chat", json!({"open":true,"side":"right","width":440,"picker":false}));
h.frames(3);
h.app.agent_chat.input = "retained unsent draft".into();
h.app.agent_chat.items.push(crate::agent_chat::Item::Agent { thought: false, text: "retained conversation".into() });
let items = crate::agent_chat::status(&h.app)["items"].clone();
let stale = h.app.agent_chat.panel_rect.unwrap();
let viewport = h.app.viewport.rect.unwrap();
assert!(crate::agent_chat::tool_space(&h.app, viewport).width() < viewport.width());
assert_panel_host_preserves_design(&mut h, |h| {
crate::panel_runtime::enable_host_specimen(&mut h.app, "tabs").unwrap();
h.frame();
assert!(h.app.agent_chat.panel_rect.is_none() && h.app.agent_chat.drop_rect.is_none() && h.app.agent_chat.dock_space.is_none());
assert!(rect_of("agent_chat:panel").is_none());
let domain = h.app.viewport.rect.unwrap();
assert_eq!(crate::agent_chat::tool_space(&h.app, domain), domain);
assert_eq!(crate::shell::tool_drag_rect(&h.app, domain).x_range(), domain.x_range());
assert!(!crate::shell::host_usable(&h.app).unwrap().obstacles.contains(&crate::panel_runtime::logical_rect(stale)));
assert!(h.app.agent_chat.open);
assert_eq!(h.app.agent_chat.input, "retained unsent draft");
assert_eq!(crate::agent_chat::status(&h.app)["items"], items);
h.app.disable_universal_panel_host().unwrap();
h.frames(3);
assert!(h.app.agent_chat.panel_rect.is_some() && h.app.agent_chat.drop_rect.is_some());
assert_eq!(h.app.agent_chat.input, "retained unsent draft");
assert_eq!(crate::agent_chat::status(&h.app)["items"], items);
});
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn host_retains_the_existing_popped_assistant_window_path() {
// Harness uses egui's embedded native-window fallback; this is not OS-window evidence.
let mut h = Harness::new();
h.app.home.open = false;
let saved_place = Some([120.0, 80.0, 520.0, 700.0]);
h.app.preferences.agent_chat_window = saved_place;
h.call("ui.agent_chat", json!({"open":true,"popped":true,"picker":false}));
h.frames(3);
assert!(rect_of("agent_chat:window").is_some() && h.app.agent_chat.window_placed);
h.app.agent_chat.input = "native window draft".into();
assert_panel_host_preserves_design(&mut h, |h| {
crate::panel_runtime::enable_host_specimen(&mut h.app, "tabs").unwrap();
h.frames(4);
assert!(rect_of("agent_chat:window").is_some(), "host enablement must still invoke the existing native-window producer");
assert!(rect_of("agent_chat:panel").is_none());
assert!(h.app.agent_chat.window_placed && h.app.agent_chat.open && h.app.preferences.agent_chat_popped);
assert_eq!(h.app.agent_chat.input, "native window draft");
let domain = h.app.viewport.rect.unwrap();
assert_eq!(crate::agent_chat::tool_space(&h.app, domain), domain);
h.step(&json!({"click":{"handle":"agent_chat:dock"}})).unwrap();
h.frames(2);
assert!(!h.app.preferences.agent_chat_popped && !h.app.agent_chat.window_placed);
assert!(rect_of("agent_chat:window").is_none());
assert!(h.app.agent_chat.panel_rect.is_none() && h.app.agent_chat.drop_rect.is_none() && h.app.agent_chat.dock_space.is_none());
assert_eq!(h.app.preferences.agent_chat_window, saved_place, "Dock retains the saved opening position and size");
assert!(h.app.agent_chat.open);
assert_eq!(h.app.agent_chat.input, "native window draft");
h.call("ui.agent_chat", json!({"popped":true}));
h.frames(3);
assert!(rect_of("agent_chat:window").is_some() && h.app.agent_chat.window_placed);
assert_eq!(h.app.preferences.agent_chat_window, saved_place);
h.app.agent_chat.items.push(crate::agent_chat::Item::Agent { thought: false, text: "Retained transcript before New Chat".into() });
h.app.agent_chat.pending.push(crate::agent_chat::Pending {
text: "Retained queued message".into(),
image: false,
context: Default::default(),
files: Vec::new(),
});
h.frames(2);
let pending = h.app.agent_chat.pending.clone();
let transcript = rect_of("agent_chat:msg:0").expect("the real transcript publishes its message footprint").center();
assert!(h.app.agent_chat.panel_rect.unwrap().contains(transcript));
let composer = egui::Id::unique("sc_agent_chat_input");
h.ctx.memory_mut(|memory| memory.surrender_focus(composer));
assert!(!h.ctx.memory(|memory| memory.has_focus(composer)));
assert!(crate::agent_chat::new_chat_needs_confirm(&h.app));
assert!(!h.app.agent_chat.confirm_new);
// Existing New Chat is Command/Ctrl+Shift+L, including transcript hover.
h.frame_with(vec![
egui::Event::PointerMoved(transcript),
egui::Event::Key {
key: egui::Key::L,
physical_key: Some(egui::Key::L),
pressed: true,
repeat: false,
modifiers: egui::Modifiers::COMMAND.plus(egui::Modifiers::SHIFT),
},
]);
assert!(h.app.agent_chat.confirm_new, "hover routes New Chat without composer focus");
assert_eq!(h.app.agent_chat.pending, pending, "the existing guard keeps queued work until confirmation");
assert!(
matches!(h.app.agent_chat.items.as_slice(), [crate::agent_chat::Item::Agent { text, .. }] if text == "Retained transcript before New Chat")
);
assert_eq!(h.app.agent_chat.input, "native window draft");
h.frame_with(vec![egui::Event::Key {
key: egui::Key::L,
physical_key: Some(egui::Key::L),
pressed: false,
repeat: false,
modifiers: egui::Modifiers::COMMAND.plus(egui::Modifiers::SHIFT),
}]);
h.step(&json!({"click":{"handle":"agent_chat:new_confirm"}})).unwrap();
h.frames(2);
assert!(!h.app.agent_chat.confirm_new && !crate::agent_chat::new_chat_needs_confirm(&h.app));
assert!(h.app.agent_chat.items.is_empty() && h.app.agent_chat.pending.is_empty());
assert_eq!(h.app.agent_chat.input, "native window draft", "existing New Chat leaves the unsent composer draft intact");
h.app.disable_universal_panel_host().unwrap();
h.frames(3);
assert!(rect_of("agent_chat:window").is_some() && h.app.agent_chat.window_placed);
assert_eq!(h.app.agent_chat.input, "native window draft");
});
}
fn panel_host_point(h: &Harness, target: crate::panel_runtime::HostPointerTarget) -> egui::Pos2 {
let bounds =
h.app.universal_panel_frame().unwrap().layout.control(&target).unwrap_or_else(|| panic!("missing actual host control {target:?}")).bounds;
egui::pos2(bounds.origin.x + bounds.size.width * 0.5, bounds.origin.y + bounds.size.height * 0.5)
}
fn panel_host_drop_point(
h: &Harness,
instance: &solidcraft_engine::panels::InstanceId,
target: &crate::panel_runtime::HostDropTargetId,
) -> egui::Pos2 {
let frame = h.app.universal_panel_frame().unwrap();
let targets = crate::panel_runtime::host_drop_targets(h.app.panel_runtime().unwrap().layout(), &frame.layout, instance).unwrap();
let bounds =
targets.iter().rev().find(|candidate| candidate.id == *target).unwrap_or_else(|| panic!("missing explicit landing {target:?}")).bounds;
egui::pos2(bounds.origin.x + bounds.size.width / 2.0, bounds.origin.y + bounds.size.height / 2.0)
}
fn panel_host_pointer(h: &mut Harness, at: egui::Pos2, pressed: bool) {
h.frame_with(vec![
egui::Event::PointerMoved(at),
egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE },
]);
}
fn panel_host_click(h: &mut Harness, at: egui::Pos2) {
h.frame_with(vec![egui::Event::PointerMoved(at)]);
panel_host_pointer(h, at, true);
panel_host_pointer(h, at, false);
}
fn panel_host_key(h: &mut Harness, key: egui::Key) {
h.frame_with(vec![egui::Event::Key { key, physical_key: Some(key), pressed: true, repeat: false, modifiers: egui::Modifiers::NONE }]);
h.frame_with(vec![egui::Event::Key { key, physical_key: Some(key), pressed: false, repeat: false, modifiers: egui::Modifiers::NONE }]);
}
fn panel_host_semantic_click(h: &mut Harness, target: crate::panel_runtime::HostControlTarget) {
let bounds = h
.app
.universal_panel_frame()
.unwrap()
.controls
.iter()
.find(|control| control.target == target)
.unwrap_or_else(|| panic!("missing actual action {target:?}"))
.bounds;
panel_host_click(h, egui::pos2(bounds.origin.x + bounds.size.width / 2.0, bounds.origin.y + bounds.size.height / 2.0));
h.frames(2);
}
fn assert_panel_host_landing(h: &Harness, shown: &crate::panel_runtime::HostLayout) {
let committed = &h.app.universal_panel_frame().unwrap().layout;
assert_eq!(committed.sections, shown.sections, "paint the exact admitted slots and neighbours");
assert_eq!(committed.resolved.panels, shown.resolved.panels);
assert_eq!(committed.extent, shown.extent);
assert_eq!(committed.allocation_environment.scroll, shown.allocation_environment.scroll);
assert_eq!(committed.render_domain, shown.render_domain);
}
fn warm_empty_universal_canvas_before_cold_cards(h: &mut Harness) {
use solidcraft_engine::panels::{Layout, LayoutAction};
if h.app.universal_panel_frame().is_none() {
let capacity = crate::panel_runtime::logical_rect(h.ctx.content_rect());
let app = &mut h.app;
app.panel_runtime.as_mut().unwrap().prepare_host(&app.session, capacity).unwrap();
}
let saved = h.app.panel_runtime().unwrap().layout().layout().clone();
h.app.dispatch_panel_layout(LayoutAction::Replace { expected_revision: None, layout: Layout::empty(saved.workspace.clone()) }).unwrap();
// The universal canvas has a distinct egui identity. Establish its actual
// hit rectangle without creating floating Area sizing state.
h.frames(2);
let empty = h.app.universal_panel_frame().unwrap();
assert!(empty.layout.sections.is_empty());
assert!(empty.layout.painted.is_empty() && empty.layout.input.is_empty());
assert!(h.app.viewport.rect.is_some());
h.app.dispatch_panel_layout(LayoutAction::Replace { expected_revision: None, layout: saved }).unwrap();
}
#[test]
fn actual_tabs_preset_raw_widget_drag_retains_the_inactive_editor_identity_and_draft() {
use crate::panel_runtime::{HostControlTarget, HostEvent, HostPointerTarget, enable_host_specimen, inspect_host_specimen};
use solidcraft_engine::panels::{Destination, InstanceId, Point, SectionId};
fn editor_probe(observation: &serde_json::Value) -> &serde_json::Value {
observation["runtime"]["probe"]["controllers"].as_array().unwrap().iter().find(|controller| controller["instance"] == "specimen-0").unwrap()
}
fn assert_inactive_editor_has_not_rendered(h: &mut Harness, before: &serde_json::Value) {
let observation = inspect_host_specimen(&mut h.app).unwrap();
let editor = editor_probe(&observation);
assert_eq!(editor["state"]["presented"], false);
assert_eq!(editor["renders"], before["renders"], "press, preview and cancellation cannot render the inactive editor");
}
for scale in [1.0, 2.0] {
let mut h = Harness::new();
h.app.home.open = false;
h.ctx.set_pixels_per_point(scale);
enable_host_specimen(&mut h.app, "tabs").unwrap();
h.frames(3);
let editor = InstanceId::new("specimen-0").unwrap();
let source_id = SectionId::new("specimen-section-0").unwrap();
let destination_id = SectionId::new("specimen-section-1").unwrap();
let body = h.app.universal_panel_frame().unwrap().layout.sections.iter().find(|section| section.instance == editor).unwrap().body.unwrap();
let draft_label = h.app.tr("ui.panel_fixture.draft").to_string();
let mut edit_at = None;
for _ in 0..8 {
let nodes = &h.output.accesskit_update.as_ref().unwrap().nodes;
edit_at = nodes
.iter()
.filter(|(_, node)| {
node.role() == egui::accesskit::Role::MultilineTextInput
&& nodes.iter().any(|(id, label)| {
node.labelled_by().contains(id)
&& label.role() == egui::accesskit::Role::Label
&& label.value() == Some(draft_label.as_str())
})
})
.find_map(|(_, node)| {
let bounds = node.bounds()?;
let at = Point { x: ((bounds.x0 + bounds.x1) / 2.0) as f32, y: ((bounds.y0 + bounds.y1) / 2.0) as f32 };
body.contains(at).then_some(egui::pos2(at.x, at.y))
});
if edit_at.is_some() {
break;
}
let at = egui::pos2(body.origin.x + body.size.width / 2.0, body.origin.y + body.size.height / 2.0);
h.frame_with(vec![
egui::Event::PointerMoved(at),
egui::Event::MouseWheel {
source: egui::MouseWheelSource::Unknown,
unit: egui::MouseWheelUnit::Point,
delta: egui::vec2(0.0, -64.0),
modifiers: egui::Modifiers::NONE,
phase: egui::TouchPhase::Move,
},
]);
h.frames(8);
}
let edit_at = edit_at.expect("the actual specimen editor has a reachable accessible text input inside its body");
panel_host_click(&mut h, edit_at);
h.frame_with(vec![egui::Event::Text("Draft entered through the specimen text field".into())]);
panel_host_semantic_click(&mut h, HostControlTarget::Pointer(HostPointerTarget::Tab { instance: InstanceId::new("specimen-2").unwrap() }));
let observation = inspect_host_specimen(&mut h.app).unwrap();
let before_editor = editor_probe(&observation).clone();
assert_eq!(before_editor["draft"], "Draft entered through the specimen text field");
assert_eq!(before_editor["state"]["presented"], false);
assert_panel_host_preserves_design(&mut h, |h| {
let before = h.app.panel_runtime().unwrap().layout().inspect();
let target = HostControlTarget::Pointer(HostPointerTarget::Tab { instance: editor.clone() });
let control = h.app.universal_panel_frame().unwrap().controls.iter().find(|control| control.target == target).unwrap();
assert!(
h.output
.accesskit_update
.as_ref()
.unwrap()
.nodes
.iter()
.any(|(_, node)| node.role() == egui::accesskit::Role::Button && node.label() == Some(control.accessible_name.as_str())),
"use an actual accessible Tab widget, not a reducer-only target"
);
let bounds = control.bounds;
let card = h.app.universal_panel_frame().unwrap().layout.sections.iter().find(|card| card.section == source_id).unwrap();
assert_eq!(bounds.origin.y, card.header.origin.y);
assert_eq!(bounds.size.height, card.header.size.height);
assert!(!crate::panel_runtime::egui_rect(card.title.unwrap()).intersect(crate::panel_runtime::egui_rect(bounds)).is_positive());
let start = egui::pos2(bounds.origin.x + bounds.size.width / 2.0, bounds.origin.y + bounds.size.height / 2.0);
h.frame_with(vec![egui::Event::PointerMoved(start)]);
panel_host_pointer(h, start, true);
assert_inactive_editor_has_not_rendered(h, &before_editor);
h.frame_with(vec![egui::Event::PointerMoved(start + egui::vec2(5.99, 0.0))]);
assert!(h.app.universal_panel_frame().unwrap().preview.is_none());
assert_eq!(h.app.panel_runtime().unwrap().layout().inspect(), before);
assert_inactive_editor_has_not_rendered(h, &before_editor);
h.frame_with(vec![egui::Event::PointerMoved(start + egui::vec2(6.0, 0.0))]);
assert!(h.app.universal_panel_frame().unwrap().preview.is_some());
assert_eq!(h.app.panel_runtime().unwrap().layout().inspect(), before);
assert_inactive_editor_has_not_rendered(h, &before_editor);
let end =
panel_host_drop_point(h, &editor, &crate::panel_runtime::HostDropTargetId::Tab { section: destination_id.clone(), before: None });
h.frame_with(vec![egui::Event::PointerMoved(end)]);
let preview = h.app.universal_panel_frame().unwrap().preview.as_ref().unwrap();
assert_eq!(preview.destination, Some(Destination::JoinTab { section: destination_id.clone(), index: 2 }));
assert!(preview.rejection.is_none());
let candidate = preview.projected.clone().expect("the preview includes the exact landing and affected neighbours");
assert!(preview.tab_marker.is_some());
assert_eq!(h.app.panel_runtime().unwrap().layout().inspect(), before);
assert_inactive_editor_has_not_rendered(h, &before_editor);
panel_host_key(h, egui::Key::Escape);
panel_host_pointer(h, start + egui::vec2(6.0, 0.0), false);
h.frames(2);
assert_eq!(
h.app.panel_runtime().unwrap().layout().inspect(),
before,
"Escape and the eventual real Tab release cannot activate the inactive editor"
);
assert!(h.app.universal_panel_frame().unwrap().preview.is_none());
assert!(!h.app.panel_runtime_mut().unwrap().host().unwrap().interaction().is_captured());
assert_inactive_editor_has_not_rendered(h, &before_editor);
// A fresh accepted drag activates the retained editor only as part
// of the same Move+Activate transaction that makes its landing visible.
let start = panel_host_point(h, HostPointerTarget::Tab { instance: editor.clone() });
panel_host_pointer(h, start, true);
h.frame_with(vec![egui::Event::PointerMoved(end)]);
let preview = h.app.universal_panel_frame().unwrap().preview.as_ref().unwrap();
assert_eq!(preview.destination, Some(Destination::JoinTab { section: destination_id.clone(), index: 2 }));
assert!(preview.rejection.is_none() && preview.tab_marker.is_some());
assert_eq!(preview.projected.as_ref(), Some(&candidate));
let projected = preview.projected.clone().unwrap();
assert_inactive_editor_has_not_rendered(h, &before_editor);
panel_host_pointer(h, end, false);
let release = h.app.universal_panel_frame().unwrap();
let commits = release
.events
.iter()
.filter_map(|event| match event {
HostEvent::PreparedCommitted { reply } => Some(reply),
_ => None,
})
.collect::<Vec<_>>();
assert_eq!(commits.len(), 1, "consume the shown candidate exactly once");
assert_eq!(commits[0].revision, before.revision + 1);
h.frames(2);
let layout = h.app.panel_runtime().unwrap().layout().layout();
assert_eq!(layout.section(&source_id).unwrap().tabs, vec![InstanceId::new("specimen-2").unwrap()]);
assert_eq!(layout.section(&source_id).unwrap().active, InstanceId::new("specimen-2").unwrap());
let destination = layout.section(&destination_id).unwrap();
assert_eq!(destination.tabs, vec![InstanceId::new("specimen-1").unwrap(), InstanceId::new("specimen-3").unwrap(), editor.clone()]);
assert_eq!(destination.active, editor.clone(), "the dragged retained editor is the visible landing tab");
assert_eq!(layout.sections.len(), 2);
assert_eq!(h.app.panel_runtime().unwrap().layout().inspect().revision, before.revision + 1);
assert_panel_host_landing(h, &projected);
});
let after = inspect_host_specimen(&mut h.app).unwrap();
let retained = editor_probe(&after);
for field in ["controller_identity", "draft", "transaction_live", "applies", "cancels", "finishes", "reopens", "destroys"] {
assert_eq!(retained[field], before_editor[field], "retained editor state survives its actual Tab drag: {field}");
}
assert_eq!(retained["state"]["presented"], true);
assert!(
retained["renders"].as_u64().unwrap() > before_editor["renders"].as_u64().unwrap(),
"the accepted active landing must actually render the editor"
);
assert_eq!(retained["reparents"].as_u64().unwrap(), before_editor["reparents"].as_u64().unwrap() + 1);
assert!(retained["updates"].as_u64().unwrap() > before_editor["updates"].as_u64().unwrap());
assert_eq!(after["runtime"]["controller_count"], observation["runtime"]["controller_count"]);
assert_eq!(after["runtime"]["probe"]["content_command_calls"], 0);
}
}
#[test]
fn actual_clamped_floating_resize_preserves_session_provider_controller_and_camera_invariants() {
use crate::panel_runtime::{HostEvent, HostPointerTarget, HostResizeEdge, enable_host_specimen, inspect_host_specimen};
use solidcraft_engine::panels::{LayoutAction, Mutation, Point, SectionId, Size};
for scale in [1.0, 2.0] {
let mut h = Harness::new();
h.app.home.open = false;
h.app.run("solid.box", json!({"length":40,"width":30,"height":20})).unwrap();
h.settle();
h.call("ui.resize", json!({"width":800,"height":800}));
h.ctx.set_pixels_per_point(scale);
enable_host_specimen(&mut h.app, "floating").unwrap();
h.frames(3);
let section_id = SectionId::new("specimen-section-0").unwrap();
h.app
.dispatch_panel_layout(LayoutAction::Apply {
expected_revision: None,
mutations: vec![Mutation::SetFloatingRect {
section: section_id.clone(),
origin: Point { x: 1000.0, y: 0.0 },
size: Size { width: 280.0, height: 240.0 },
}],
})
.unwrap();
h.frames(3);
let observations = inspect_host_specimen(&mut h.app).unwrap();
assert_panel_host_preserves_design(&mut h, |h| {
let before = h.app.panel_runtime().unwrap().layout().inspect();
let layout = &h.app.universal_panel_frame().unwrap().layout;
let gap = crate::ui_kit::Container::new(&h.ctx, crate::ui_kit::Surface::Panel).gap();
assert_eq!(layout.capacity.size.width, layout.render_domain.size.width - 2.0 * gap);
let outer = layout.sections.iter().find(|section| section.section == section_id).unwrap().outer;
assert_eq!(outer.origin.x, layout.capacity.origin.x + layout.capacity.size.width - 280.0 - layout.allocation_environment.scroll.x);
assert_eq!(outer.size, Size { width: 280.0, height: 240.0 });
let expected = solidcraft_engine::panels::LogicalRect { origin: outer.origin, size: Size { width: 250.0, height: 240.0 } };
let start = panel_host_point(h, HostPointerTarget::Resize { section: section_id.clone(), edge: HostResizeEdge::BottomRight });
h.frame_with(vec![egui::Event::PointerMoved(start)]);
panel_host_pointer(h, start, true);
let end = start - egui::vec2(30.0, 0.0);
h.frame_with(vec![egui::Event::PointerMoved(end)]);
let preview = h.app.universal_panel_frame().unwrap().preview.as_ref().unwrap().clone();
assert_eq!(preview.bounds, expected);
assert!(preview.rejection.is_none());
assert_eq!(h.app.panel_runtime().unwrap().layout().inspect(), before);
panel_host_pointer(h, end, false);
let actions = h
.app
.universal_panel_frame()
.unwrap()
.events
.iter()
.filter_map(|event| if let HostEvent::PreparedCommitted { reply } = event { Some(reply) } else { None })
.collect::<Vec<_>>();
assert_eq!(actions.len(), 1);
assert_eq!(actions[0].revision, before.revision + 1);
h.frames(2);
assert_eq!(
h.app.universal_panel_frame().unwrap().layout.sections.iter().find(|section| section.section == section_id).unwrap().outer,
expected
);
assert_eq!(h.app.panel_runtime().unwrap().layout().inspect().revision, before.revision + 1);
});
let after = inspect_host_specimen(&mut h.app).unwrap();
assert_eq!(after["runtime"]["controller_count"], observations["runtime"]["controller_count"]);
assert_eq!(after["runtime"]["probe"]["content_command_calls"], 0);
for before in observations["runtime"]["probe"]["controllers"].as_array().unwrap() {
let retained = after["runtime"]["probe"]["controllers"]
.as_array()
.unwrap()
.iter()
.find(|controller| controller["instance"] == before["instance"] && controller["owner"] == before["owner"])
.unwrap();
for field in ["controller_identity", "draft", "transaction_live", "reparents", "applies", "cancels", "finishes", "destroys"] {
assert_eq!(retained[field], before[field], "rect-only application resize must retain its controller/provider state: {field}");
}
}
}
}
#[test]
fn actual_host_raw_pointer_threshold_preview_escape_and_drop_preserve_the_design_at_both_scales() {
use crate::panel_runtime::HostPointerTarget;
use solidcraft_engine::panels::{InstanceId, Zone};
for scale in [1.0, 2.0] {
for zone in [Zone::Left, Zone::Right, Zone::Bottom] {
let mut h = Harness::new();
h.app.home.open = false;
h.app.run("solid.box", json!({"length":40,"width":30,"height":20})).unwrap();
h.call("ui.resize", json!({"width":1280,"height":800}));
h.ctx.set_pixels_per_point(scale);
crate::panel_runtime::enable_host_specimen(&mut h.app, "docks").unwrap();
h.frames(4);
assert_panel_host_preserves_design(&mut h, |h| {
let before = h.app.panel_runtime().unwrap().layout().inspect();
let projection = h.app.viewport.rect;
let target = HostPointerTarget::Header { instance: InstanceId::new("specimen-0").unwrap() };
let start = panel_host_point(h, target.clone());
panel_host_pointer(h, start, true);
h.frame_with(vec![egui::Event::PointerMoved(start + egui::vec2(5.99, 0.0))]);
assert!(h.app.universal_panel_frame().unwrap().preview.is_none());
h.frame_with(vec![egui::Event::PointerMoved(start + egui::vec2(6.0, 0.0))]);
assert!(h.app.universal_panel_frame().unwrap().preview.is_some(), "six logical points, including 12 physical pixels at 200%");
assert_eq!(h.app.panel_runtime().unwrap().layout().inspect(), before);
assert_eq!(h.app.viewport.rect, projection, "preview must not move camera projection");
panel_host_key(h, egui::Key::Escape);
panel_host_pointer(h, start, false);
assert_eq!(h.app.panel_runtime().unwrap().layout().inspect(), before);
assert!(h.app.universal_panel_frame().unwrap().preview.is_none());
let capacity = h.app.universal_panel_frame().unwrap().layout.capacity;
let x0 = capacity.origin.x;
let y0 = capacity.origin.y;
let w = capacity.size.width;
let height = capacity.size.height;
let drop = match zone {
Zone::Left => egui::pos2(x0 + 1.0, y0 + height * 0.5),
Zone::Right => egui::pos2(x0 + w - 1.0, y0 + height * 0.5),
Zone::Bottom => egui::pos2(x0 + w * 0.5, y0 + height - 1.0),
_ => egui::pos2(x0 + w * 0.5, y0 + height * 0.5),
};
let start = panel_host_point(h, target);
panel_host_pointer(h, start, true);
h.frame_with(vec![egui::Event::PointerMoved(start + egui::vec2(8.0, 0.0))]);
h.frame_with(vec![egui::Event::PointerMoved(drop)]);
let landing = h.app.universal_panel_frame().unwrap().preview.as_ref().unwrap();
assert!(landing.rejection.is_none());
let projected = landing.projected.clone().expect("explicit target resolves final affected geometry");
assert_eq!(h.app.panel_runtime().unwrap().layout().inspect(), before);
panel_host_pointer(h, drop, false);
h.frames(3);
let reply = h.app.panel_runtime().unwrap().layout().inspect();
assert_eq!(reply.revision, before.revision + 1, "one release commits once at scale {scale}: {zone:?}");
assert_eq!(reply.layout.containing(&InstanceId::new("specimen-0").unwrap()).unwrap().location.zone(), zone);
assert_eq!(h.app.universal_panel_frame().unwrap().reply, reply, "published frame must describe committed state");
assert_panel_host_landing(h, &projected);
});
}
}
}
#[test]
fn host_full_canvas_and_same_pass_controls_follow_actual_sizing_footprints_without_moving_the_model() {
use crate::panel_runtime::{enable_host_specimen, logical_rect};
use solidcraft_engine::panels::{LayoutAction, Mutation, Point, Size};
for scale in [1.0, 2.0] {
for mode in [LayoutMode::Docked, LayoutMode::Floating] {
for preset in ["docks", "floating", "collapsed"] {
let mut h = Harness::new();
h.app.home.open = false;
h.app.ui.layout = mode;
h.call("ui.resize", json!({"width":1400,"height":1000}));
h.app.run("solid.box", json!({"length":40,"width":30,"height":20})).unwrap();
h.settle();
h.ctx.set_pixels_per_point(scale);
h.ctx.options_mut(|options| options.max_passes = 1.try_into().unwrap());
h.app.preferences.navigation_bar.position = match preset {
"docks" => crate::navigation_bar::Position::Centre,
"floating" => crate::navigation_bar::Position::Left,
_ => crate::navigation_bar::Position::Right,
};
let camera = h.app.cam;
enable_host_specimen(&mut h.app, preset).unwrap();
warm_empty_universal_canvas_before_cold_cards(&mut h);
if preset == "floating" {
let sections =
h.app.panel_runtime().unwrap().layout().layout().sections.iter().map(|section| section.id.clone()).collect::<Vec<_>>();
let origins =
[Point { x: 500.0, y: 300.0 }, Point { x: 40.0, y: 220.0 }, Point { x: 40.0, y: 560.0 }, Point { x: 400.0, y: 650.0 }];
h.app
.dispatch_panel_layout(LayoutAction::Apply {
expected_revision: None,
mutations: sections
.into_iter()
.zip(origins)
.map(|(section, origin)| Mutation::SetFloatingRect { section, origin, size: Size { width: 280.0, height: 240.0 } })
.collect(),
})
.unwrap();
}
let pointer = egui::pos2(640.0, 420.0);
let mut first_projection = None;
for visible_pass in [false, true] {
h.frame_with(vec![egui::Event::PointerMoved(pointer)]);
let frame = h.app.universal_panel_frame().unwrap();
let domain = h.app.viewport.rect.unwrap();
assert_eq!(domain, egui::Rect::from_min_max(egui::pos2(0.0, toolbar::APP_BAR_HEIGHT), h.ctx.content_rect().max));
assert_eq!(frame.layout.render_domain, logical_rect(domain));
assert_eq!(frame.layout.viewport, Some(logical_rect(domain)));
assert_eq!(h.app.cam, camera);
let model_points = [solidcore_record::Vec3::ZERO, solidcore_record::Vec3::new(40.0, 30.0, 20.0)]
.map(|point| crate::viewport::projection(&h.app, domain).to_screen(point));
if let Some(first) = first_projection {
assert_eq!(model_points, first, "the newly visible panel cannot shift model pixels or framing");
} else {
first_projection = Some(model_points);
}
let controls = h.app.viewport.layout.as_ref().unwrap();
assert_eq!(controls.viewport, domain);
for (name, bounds) in [("nav:outer", controls.navigation), ("axis_view:outer", controls.axis_view)] {
if bounds.is_positive() {
assert_eq!(rect_of(name), Some(bounds), "the published control and final same-pass metadata agree");
assert!(frame.layout.usable.contains_rect(logical_rect(bounds)));
assert!(frame.layout.usable.obstacles.iter().all(|obstacle| {
!bounds
.expand(crate::theme::Tokens::get().space_4)
.intersect(crate::panel_runtime::egui_rect(*obstacle))
.is_positive()
}));
} else {
assert!(rect_of(name).is_none());
}
}
assert!(controls.navigation.is_positive(), "the measured navbar remains accessible in ample usable space");
assert!(!controls.navigation.intersect(controls.axis_view).is_positive());
if preset == "floating" {
let inside = Point { x: pointer.x, y: pointer.y };
assert_eq!(frame.layout.consumes_pointer(inside), visible_pass);
assert_eq!(
h.app.viewport.mouse,
if visible_pass { None } else { Some(pointer) },
"first invisible sizing reaches navigation; the next actual card shields it"
);
}
}
}
}
}
}
#[test]
fn first_invisible_host_sizing_pass_allows_real_wheel_navigation_and_the_visible_card_blocks_it() {
use solidcraft_engine::panels::{LayoutAction, Mutation, Point, Size};
for scale in [1.0, 2.0] {
for mode in [LayoutMode::Docked, LayoutMode::Floating] {
let mut h = Harness::new();
h.app.home.open = false;
h.app.ui.layout = mode;
h.call("ui.resize", json!({"width":1400,"height":1000}));
h.app.run("solid.box", json!({"length":40,"width":30,"height":20})).unwrap();
h.settle();
h.ctx.set_pixels_per_point(scale);
h.ctx.options_mut(|options| options.max_passes = 1.try_into().unwrap());
crate::panel_runtime::enable_host_specimen(&mut h.app, "floating").unwrap();
warm_empty_universal_canvas_before_cold_cards(&mut h);
let sections = h.app.panel_runtime().unwrap().layout().layout().sections.iter().map(|section| section.id.clone()).collect::<Vec<_>>();
let origins = [Point { x: 500.0, y: 300.0 }, Point { x: 40.0, y: 220.0 }, Point { x: 40.0, y: 560.0 }, Point { x: 400.0, y: 650.0 }];
h.app
.dispatch_panel_layout(LayoutAction::Apply {
expected_revision: None,
mutations: sections
.into_iter()
.zip(origins)
.map(|(section, origin)| Mutation::SetFloatingRect { section, origin, size: Size { width: 280.0, height: 240.0 } })
.collect(),
})
.unwrap();
let at = egui::pos2(640.0, 420.0);
let wheel = || {
vec![
egui::Event::PointerMoved(at),
egui::Event::MouseWheel {
source: egui::MouseWheelSource::Unknown,
unit: egui::MouseWheelUnit::Point,
delta: egui::vec2(0.0, 120.0),
modifiers: egui::Modifiers::NONE,
phase: egui::TouchPhase::Move,
},
]
};
let before = h.app.cam;
h.frame_with(wheel());
assert!(!h.app.universal_panel_frame().unwrap().layout.consumes_pointer(Point { x: at.x, y: at.y }));
assert_eq!(h.app.viewport.mouse, Some(at));
assert_ne!(h.app.cam.distance.to_bits(), before.distance.to_bits(), "the real first-pass wheel reaches the existing navigation path");
let navigated = h.app.cam;
h.frame_with(wheel());
assert!(h.app.universal_panel_frame().unwrap().layout.consumes_pointer(Point { x: at.x, y: at.y }));
assert!(h.app.viewport.mouse.is_none());
assert_eq!(h.app.cam, navigated, "an actual visible card shields the next wheel without moving projection");
h.frames(3);
assert_eq!(h.app.cam, navigated, "blocked input cannot leave delayed navigation behind");
}
}
}
#[test]
fn actual_host_fit_and_centring_respect_the_measured_sketch_palette_at_both_scales() {
use crate::panel_runtime::{HostControlTarget, HostPointerTarget, egui_rect, enable_host_specimen, logical_rect};
use solidcore_record::Vec3;
use solidcraft_engine::geom::{Aabb3, Vec3Geom as _};
use solidcraft_engine::panels::{InstanceId, LayoutAction, Mutation};
fn projected_extent(h: &Harness, bounds: Aabb3) -> egui::Rect {
let domain = h.app.viewport.rect.unwrap();
let projection = crate::viewport::projection(&h.app, domain);
let mut extent = egui::Rect::NOTHING;
for x in [bounds.min.x, bounds.max.x] {
for y in [bounds.min.y, bounds.max.y] {
for z in [bounds.min.z, bounds.max.z] {
extent.extend_with(projection.to_screen(Vec3::new(x, y, z)).expect("every actual sketch-bound corner must project"));
}
}
}
extent
}
fn assert_palette_and_controls(h: &Harness, palette: egui::Rect) {
let frame = h.app.universal_panel_frame().unwrap();
let layout = h.app.viewport.layout.as_ref().unwrap();
let usable = layout.usable.as_ref().unwrap();
let effective = crate::shell::host_usable(&h.app).unwrap();
assert_eq!(rect_of("sketch_palette:outer"), Some(palette));
assert!(crate::shell::fit_rects(&h.app).contains(&palette), "the palette must be an actual persistent footprint");
assert!(usable.obstacles.contains(&logical_rect(palette)));
assert!(usable.free.iter().all(|piece| !egui_rect(*piece).intersect(palette).is_positive()));
for (name, control) in [("nav:outer", layout.navigation), ("axis_view:outer", layout.axis_view)] {
if control.is_positive() {
assert_eq!(rect_of(name), Some(control), "published controls must match the actual same-pass footprint");
assert!(!control.expand(crate::theme::Tokens::get().space_4).intersect(palette).is_positive());
assert!(effective.contains_rect(logical_rect(control)));
assert!(frame.layout.usable.obstacles.iter().all(|obstacle| !control.intersect(egui_rect(*obstacle)).is_positive()));
} else {
assert!(rect_of(name).is_none());
}
}
}
for scale in [1.0, 2.0] {
for mode in [LayoutMode::Docked, LayoutMode::Floating] {
let mut h = Harness::new();
h.app.home.open = false;
h.app.ui.layout = mode;
h.app.preferences.look_at_anim = false;
h.app.preferences.navigator_fit = false;
h.app.preferences.home_fit_size = 1.0;
h.call("ui.resize", json!({"width":1400,"height":1000}));
h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();
h.app.run("sketch.line", json!({"points":[[0,0],[100,0]],"infer":false,"connect":false})).unwrap();
h.settle();
h.ctx.set_pixels_per_point(scale);
enable_host_specimen(&mut h.app, "docks").unwrap();
h.frames(4);
let sketch = h.app.session.active_sketch.expect("the real sketch palette requires an active sketch");
let palette = h.app.viewport.palette_rect.expect("the actual sketch palette must paint beside the host");
let domain = h.app.viewport.rect.unwrap();
assert_eq!(domain, egui::Rect::from_min_max(egui::pos2(0.0, toolbar::APP_BAR_HEIGHT), h.ctx.content_rect().max));
assert!(domain.contains_rect(palette));
assert!(
h.app.universal_panel_frame().unwrap().layout.usable.free.iter().any(|piece| egui_rect(*piece).intersect(palette).is_positive()),
"the palette must cover space beyond host-only footprints, so this exercises the missing union"
);
assert_palette_and_controls(&h, palette);
let bounds = crate::viewport::view_bounds(&h.app);
assert!((bounds.max.x - bounds.min.x - 100.0).abs() < 1e-8);
h.app.fit_view();
h.settle();
assert_eq!(h.app.viewport.rect, Some(domain), "explicit fitting preserves the full render domain");
let footprint = projected_extent(&h, bounds);
let padded = footprint.expand(crate::theme::Tokens::get().space_8 - 0.01);
assert!(
h.app.viewport.layout.as_ref().unwrap().usable.as_ref().unwrap().contains_rect(logical_rect(padded)),
"{scale}x {mode:?}: the full 100 mm line and its clearance must avoid the palette, host and controls: {padded:?}"
);
for endpoint in [Vec3::ZERO, Vec3::new(100.0, 0.0, 0.0)] {
let point = crate::viewport::projection(&h.app, domain).to_screen(endpoint).unwrap();
assert!(domain.contains(point) && !palette.contains(point));
}
let fitted = h.app.cam;
let contour = h.app.viewport.layout.as_ref().unwrap().usable.clone();
let editor = InstanceId::new("specimen-0").unwrap();
panel_host_semantic_click(&mut h, HostControlTarget::Pointer(HostPointerTarget::Menu { instance: editor.clone() }));
assert!(h.app.universal_panel_frame().unwrap().menu_bounds.is_some());
assert_eq!(h.app.viewport.layout.as_ref().unwrap().usable, contour, "transient host menus cannot change the fitting/control contour");
h.app.fit_view();
h.settle();
assert_eq!(h.app.cam, fitted);
panel_host_key(&mut h, egui::Key::Escape);
h.app.cam.distance = 2.0;
h.app.cam.yaw = 1.0;
h.app.cam.pitch = 0.2;
let distance = h.app.cam.distance.to_bits();
let lens = h.app.cam.fov.to_bits();
let look_at = crate::scenario::handle_at("sketch_palette:look_at").unwrap();
assert!(palette.contains(look_at));
panel_host_click(&mut h, look_at);
h.settle();
assert_eq!(h.app.cam.distance.to_bits(), distance, "explicit palette Look At must not zoom out to fit an oversized line");
assert_eq!(h.app.cam.fov.to_bits(), lens);
assert!(h.app.cam.back().dist(Vec3::Z) < 1e-6);
let focus = crate::viewport::projection(&h.app, domain).to_screen(Vec3::new(50.0, 0.0, 0.0)).unwrap();
assert!(h.app.viewport.layout.as_ref().unwrap().usable.as_ref().unwrap().free.iter().any(|piece| egui_rect(*piece).contains(focus)));
h.app.run("select.set", json!({"items":[{"type":"plane","name":"XY"}]})).unwrap();
let selection = h.app.session.selection.clone();
h.app.start("view.normal_to");
h.settle();
assert_eq!(h.app.cam.distance.to_bits(), distance);
assert_eq!(h.app.cam.fov.to_bits(), lens);
assert!(h.app.cam.back().dist(-Vec3::Z) < 1e-6, "normal-to retains its existing second-invocation flip semantics");
assert_eq!(h.app.session.selection, selection);
assert_eq!(h.app.viewport.rect, Some(domain));
let focus = crate::viewport::projection(&h.app, domain).to_screen(Vec3::ZERO).unwrap();
assert!(h.app.viewport.layout.as_ref().unwrap().usable.as_ref().unwrap().free.iter().any(|piece| egui_rect(*piece).contains(focus)));
assert_panel_host_preserves_design(&mut h, |h| {
let section = h.app.panel_runtime().unwrap().layout().layout().containing(&editor).unwrap().id.clone();
h.app
.dispatch_panel_layout(LayoutAction::Apply {
expected_revision: None,
mutations: vec![Mutation::Collapse { section, collapsed: true }],
})
.unwrap();
h.frames(3);
assert_eq!(h.app.session.active_sketch, Some(sketch));
});
assert_palette_and_controls(&h, h.app.viewport.palette_rect.unwrap());
h.app.run("sketch.finish", json!({})).unwrap();
h.settle();
assert!(h.app.viewport.palette_rect.is_none());
assert!(rect_of("sketch_palette:outer").is_none());
assert!(
!h.app.viewport.layout.as_ref().unwrap().usable.as_ref().unwrap().obstacles.contains(&logical_rect(palette)),
"a closed palette cannot leave a phantom reservation"
);
}
}
}
#[test]
fn actual_host_full_header_restore_preserves_weights_and_leaves_gaps_for_navigation() {
use crate::panel_runtime::HostPointerTarget;
use solidcraft_engine::panels::{InstanceId, Point};
for scale in [1.0, 2.0] {
let mut h = Harness::new();
h.app.home.open = false;
h.ctx.set_pixels_per_point(scale);
crate::panel_runtime::enable_host_specimen(&mut h.app, "collapsed").unwrap();
h.frames(4);
let desired = h.app.panel_runtime().unwrap().layout().layout().clone();
let camera = serde_json::to_value(&h.app.cam).unwrap();
for index in [0, 1] {
let instance = InstanceId::new(format!("specimen-{index}")).unwrap();
let at = panel_host_point(&h, HostPointerTarget::Collapse { instance: instance.clone() });
panel_host_click(&mut h, at);
h.frames(2);
assert!(!h.app.panel_runtime().unwrap().layout().layout().containing(&instance).unwrap().collapsed);
assert!(
h.app.universal_panel_frame().unwrap().layout.sections.iter().find(|section| section.instance == instance).unwrap().body.is_some()
);
assert!(h.app.universal_panel_frame().unwrap().layout.resolved.rails.is_empty());
let at = panel_host_point(&h, HostPointerTarget::Collapse { instance });
panel_host_click(&mut h, at);
h.frames(2);
}
assert_eq!(h.app.panel_runtime().unwrap().layout().layout(), &desired);
assert_eq!(serde_json::to_value(&h.app.cam).unwrap(), camera);
let frame = h.app.universal_panel_frame().unwrap();
let left = frame.layout.sections.iter().find(|section| section.instance.0 == "specimen-0").unwrap();
let outside = egui::pos2(left.outer.origin.x + left.outer.size.width * 0.5, frame.layout.capacity.origin.y + 160.0);
assert!(!frame.layout.consumes_pointer(Point { x: outside.x, y: outside.y }));
h.frame_with(vec![egui::Event::PointerMoved(outside)]);
assert_eq!(h.app.viewport.mouse, Some(outside), "uncovered gaps reach the existing navigation path");
assert_eq!(serde_json::to_value(&h.app.cam).unwrap(), camera);
}
}
#[test]
fn actual_host_document_switch_and_lost_pointer_cancel_pending_drag() {
use crate::panel_runtime::HostPointerTarget;
use solidcraft_engine::panels::InstanceId;
for switch_document in [false, true] {
let mut h = Harness::new();
h.app.home.open = false;
crate::panel_runtime::enable_host_specimen(&mut h.app, "docks").unwrap();
h.frames(3);
let before = h.app.panel_runtime().unwrap().layout().layout().clone();
let start = panel_host_point(&h, HostPointerTarget::Header { instance: InstanceId::new("specimen-0").unwrap() });
panel_host_pointer(&mut h, start, true);
let drop = start + egui::vec2(500.0, 200.0);
h.frame_with(vec![egui::Event::PointerMoved(drop)]);
assert!(h.app.universal_panel_frame().unwrap().preview.is_some());
if switch_document {
crate::documents::open_tab(&mut h.app, solidcraft_engine::Session::default()).unwrap();
h.app.home.open = false;
h.frames(2);
} else {
h.frame_with(vec![egui::Event::PointerGone]);
}
panel_host_pointer(&mut h, drop, false);
h.frames(2);
assert!(h.app.universal_panel_frame().unwrap().preview.is_none());
assert_eq!(h.app.panel_runtime().unwrap().layout().layout(), &before);
}
}
#[derive(Default)]
struct ShellPanelServices {
commands: crate::panel_runtime::FakeContentCommands,
local: crate::panel_runtime::FakeLocalServices,
models: crate::panel_runtime::FakeModels,
}
impl crate::panel_runtime::AppPanelServices for ShellPanelServices {
fn refresh_read_only(&mut self, _: &solidcraft_engine::Session) -> solidcraft_engine::panels::PanelResult<()> {
Ok(())
}
fn services(&mut self) -> crate::panel_runtime::ContentServices<'_> {
crate::panel_runtime::ContentServices { models: &self.models, commands: &mut self.commands, local: &mut self.local }
}
}
#[test]
fn enabling_generic_runtime_alone_keeps_legacy_workspace_placement_until_host_enablement() {
use crate::panel_runtime::*;
use solidcraft_engine::panels::*;
let mut h = Harness::new();
h.app.home.open = false;
h.frames(3);
let legacy_browser = rect_of("browser:card").unwrap();
assert_panel_host_preserves_design(&mut h, |h| {
let mut fixture = PanelMountHarness::new(false).unwrap();
fixture.dispatch(vec![fixture_open("fixture.log", "log", "log", Zone::Left, 0).unwrap()]).unwrap();
h.app.enable_panel_runtime(fixture.runtime, Box::<ShellPanelServices>::default()).unwrap();
h.frames(3);
assert!(!h.app.universal_panel_host_enabled());
assert!(h.app.universal_panel_frame().is_none());
assert_eq!(rect_of("browser:card"), Some(legacy_browser));
let before = h.app.panel_runtime().unwrap().layout().inspect();
let count = h.app.panel_runtime().unwrap().controller_count();
let mut invalid = HostOptions::default();
invalid.metrics.header_height = f32::NAN;
assert!(h.app.enable_universal_panel_host(invalid).is_err());
assert_eq!(h.app.panel_runtime().unwrap().layout().inspect(), before);
assert_eq!(h.app.panel_runtime().unwrap().controller_count(), count);
assert!(!h.app.universal_panel_host_enabled());
h.app.enable_universal_panel_host(HostOptions::default()).unwrap();
h.frames(3);
assert!(rect_of("browser:card").is_none());
h.app.disable_universal_panel_host().unwrap();
h.frames(3);
assert_eq!(rect_of("browser:card"), Some(legacy_browser));
assert_eq!(h.app.panel_runtime().unwrap().controller_count(), count, "host lifetime does not recreate controllers");
});
}
#[test]
fn universal_host_scenarios_drive_real_shared_actions_and_leave_the_fixture_disabled() {
for (name, source) in [
("shared actions", include_str!("../tests/scenarios/universal_panel_host_shared_actions.json")),
("collapsed", include_str!("../tests/scenarios/universal_panel_host_collapsed.json")),
("columns and inline", include_str!("../tests/scenarios/universal_panel_host_columns_inline.json")),
("overflow and scale", include_str!("../tests/scenarios/universal_panel_host_overflow_scale.json")),
] {
let mut h = Harness::new();
h.app.home.open = false;
let before = h.app.session.doc.clone();
let steps: serde_json::Value = serde_json::from_str(source).unwrap();
for (index, step) in steps.as_array().unwrap().iter().enumerate() {
let action_before =
(step["params"]["command"] == "panel.action").then(|| crate::panel_runtime::inspect_host_specimen(&mut h.app).unwrap());
h.step(step).unwrap_or_else(|reason| panic!("{name}: step {index}: {reason}"));
if let Some(action_before) = action_before {
let after = crate::panel_runtime::inspect_host_specimen(&mut h.app).unwrap();
let applies = |value: &serde_json::Value| {
value["runtime"]["probe"]["controllers"]
.as_array()
.unwrap()
.iter()
.find(|controller| controller["instance"] == "specimen-0")
.unwrap()["applies"]
.as_u64()
.unwrap()
};
assert_eq!(applies(&after), applies(&action_before) + 1, "the scenario must invoke the editor's Apply binding");
assert_eq!(after["session"], action_before["session"], "synthetic Apply leaves the Session unchanged");
}
}
assert!(h.app.panel_runtime().is_none());
assert!(!h.app.universal_panel_host_enabled());
assert!(std::sync::Arc::ptr_eq(&before, &h.app.session.doc));
assert_eq!(h.app.session.undo.len(), 0);
assert!(rect_of("browser:card").is_some());
}
}
#[test]
fn actual_host_resize_reset_header_collapse_restore_and_tab_join_preserve_document_cache_and_camera() {
use crate::panel_runtime::{HostControlTarget, HostPointerTarget, HostSharedAction};
use solidcraft_engine::panels::InstanceId;
let mut h = Harness::new();
h.app.home.open = false;
h.app.run("solid.box", json!({"length":40,"width":30,"height":20})).unwrap();
h.settle();
crate::panel_runtime::enable_host_specimen(&mut h.app, "docks").unwrap();
h.frames(3);
assert_panel_host_preserves_design(&mut h, |h| {
let sash = h
.app
.universal_panel_frame()
.unwrap()
.layout
.controls
.iter()
.find(|control| matches!(control.target, HostPointerTarget::Sash { .. }))
.unwrap()
.target
.clone();
let start = panel_host_point(h, sash.clone());
panel_host_pointer(h, start, true);
h.frame_with(vec![egui::Event::PointerMoved(start + egui::vec2(0.0, 30.0))]);
panel_host_pointer(h, start + egui::vec2(0.0, 30.0), false);
h.frames(2);
let at = panel_host_point(h, sash);
panel_host_click(h, at);
panel_host_click(h, at);
h.frames(2);
let editor = InstanceId::new("specimen-0").unwrap();
panel_host_semantic_click(h, HostControlTarget::Pointer(HostPointerTarget::Menu { instance: editor.clone() }));
panel_host_semantic_click(h, HostControlTarget::Shared { instance: editor.clone(), action: HostSharedAction::Collapse });
panel_host_semantic_click(h, HostControlTarget::Pointer(HostPointerTarget::Collapse { instance: editor.clone() }));
assert!(h.app.panel_runtime().unwrap().layout().interaction().peek.is_none());
assert!(!h.app.panel_runtime().unwrap().layout().layout().containing(&editor).unwrap().collapsed);
let start = panel_host_point(h, HostPointerTarget::Header { instance: editor.clone() });
let destination = h.app.panel_runtime().unwrap().layout().layout().containing(&InstanceId::new("specimen-1").unwrap()).unwrap();
let destination_id = destination.id.clone();
let insertion = destination.tabs.len();
let end = panel_host_drop_point(h, &editor, &crate::panel_runtime::HostDropTargetId::Tab { section: destination_id.clone(), before: None });
panel_host_pointer(h, start, true);
h.frame_with(vec![egui::Event::PointerMoved(end)]);
let shown = h.app.universal_panel_frame().unwrap().preview.as_ref().unwrap();
assert!(shown.rejection.is_none());
let Some(solidcraft_engine::panels::LayoutAction::Apply { mutations, .. }) = shown.action.as_ref() else {
panic!("the actual tab append must show a prepared atomic landing");
};
assert_eq!(
mutations,
&vec![
solidcraft_engine::panels::Mutation::Move {
instance: editor.clone(),
destination: solidcraft_engine::panels::Destination::JoinTab { section: destination_id.clone(), index: insertion },
},
solidcraft_engine::panels::Mutation::Activate { instance: editor.clone() },
]
);
let projected = shown.projected.clone().unwrap();
panel_host_pointer(h, end, false);
h.frames(2);
let joined = h.app.panel_runtime().unwrap().layout().layout().containing(&editor).unwrap();
assert_eq!(joined.tabs.len(), 2);
assert_eq!(joined.id, destination_id);
assert_eq!(joined.tabs[insertion], editor);
assert_eq!(joined.active, editor);
assert_panel_host_landing(h, &projected);
});
}
#[test]
fn modes_are_transient_and_available_to_control_and_scenarios() {
let mut h = Harness::new();
assert_eq!(h.app.ui.layout, LayoutMode::Floating);
let prefs = serde_json::to_value(&h.app.preferences).unwrap();
let doc = h.app.session.doc.to_json();
h.step(&json!({"call":"ui.set", "params":{"layout":"docked"}})).unwrap();
assert_eq!(h.app.ui.layout, LayoutMode::Docked);
h.step(&json!({"call":"ui.set", "params":{"layout":"invalid"},"fail":true})).unwrap();
assert_eq!(h.app.ui.layout, LayoutMode::Docked);
h.call("ui.set", json!({"layout":"floating"}));
assert_eq!(h.app.ui.layout, LayoutMode::Floating);
assert_eq!(h.app.session.doc.to_json(), doc);
assert_eq!(serde_json::to_value(&h.app.preferences).unwrap(), prefs);
}
#[test]
fn both_modes_keep_their_geometry_and_fit_clear_of_covered_rects() {
for mode in [LayoutMode::Docked, LayoutMode::Floating] {
let mut h = Harness::new();
h.call("ui.resize", json!({"width":1400,"height":900}));
h.call("ui.set", json!({"layout":mode}));
h.app.run("solid.box", json!({"length":40,"width":30,"height":20})).unwrap();
h.settle();
let viewport = h.app.viewport.rect.unwrap();
let workspace = rect_of("ribbon:workspace").unwrap();
let toolbar = rect_of("toolbar").unwrap();
if mode == LayoutMode::Floating {
let ribbon = rect_of("ribbon:card").unwrap();
assert_eq!(viewport.left(), 0.0);
assert_eq!(viewport.top(), toolbar::APP_BAR_HEIGHT);
assert_eq!(workspace.left(), SHELL_GAP);
assert_eq!(workspace.top(), viewport.top() + SHELL_GAP);
assert_eq!(ribbon.left() - workspace.right(), SHELL_GAP);
assert_eq!(ribbon.right(), viewport.right() - SHELL_GAP);
assert!(!covered(&h.app, pos2(4.0, workspace.center().y)));
assert!(!covered(&h.app, pos2(workspace.right() + 2.0, workspace.center().y)));
assert!(covered(&h.app, workspace.center()));
assert!(covered(&h.app, ribbon.center()));
} else {
assert_eq!(toolbar.top(), toolbar::APP_BAR_HEIGHT);
assert_eq!(viewport.top(), toolbar.bottom());
assert_eq!(toolbar.height(), toolbar::RIBBON_HEIGHT);
assert_eq!(workspace.left(), 0.0);
assert_eq!(covered_rects(&h.app), vec![h.app.shell.history.unwrap(), rect_of("browser:card").unwrap()]);
}
h.app.fit_view();
h.settle();
let layout = h.app.viewport.layout.as_ref().unwrap();
for covered in covered_rects(&h.app) {
assert!(!layout.drawable.intersect(covered).is_positive(), "{layout:?} {covered:?}");
}
let projection = crate::viewport::projection(&h.app, viewport);
for point in [solidcore_record::Vec3::ZERO, solidcore_record::Vec3::new(40.0, 30.0, 20.0)] {
assert!(layout.drawable.contains(projection.to_screen(point).unwrap()));
}
h.app.start("solid.extrude");
h.settle();
if mode == LayoutMode::Floating {
assert!(h.app.viewport.dialog_rect.unwrap().top() >= h.app.viewport.layout.as_ref().unwrap().axis_view.bottom());
}
}
}
#[test]
fn cards_block_model_hover_wheel_and_drag_but_the_gap_remains_viewport() {
let mut h = Harness::new();
h.app.run("solid.box", json!({"length":40,"width":30,"height":20})).unwrap();
h.settle();
let ribbon = rect_of("ribbon:card").unwrap();
// Blank space at the right, away from the search and command buttons.
let at = pos2(ribbon.right() - 12.0, ribbon.bottom() - 28.0);
let camera = h.app.cam;
let doc = h.app.session.doc.to_json();
h.call("ui.move", json!({"x":at.x,"y":at.y}));
assert!(h.app.viewport.hover.is_none());
assert!(h.app.viewport.mouse.is_none());
h.call("ui.scroll", json!({"x":at.x,"y":at.y,"delta":120}));
h.call("ui.drag", json!({"x0":at.x,"y0":at.y,"x1":at.x-30.0,"y1":at.y+15.0,"button":"middle","steps":6}));
assert_eq!(h.app.cam, camera);
assert!(h.app.viewport.boxsel.is_none());
assert_eq!(h.app.session.doc.to_json(), doc);
let gap = pos2(4.0, ribbon.center().y);
h.call("ui.move", json!({"x":gap.x,"y":gap.y}));
assert_eq!(h.app.viewport.mouse, Some(gap));
}
#[test]
fn floating_sketch_palette_and_compass_share_measured_clearance() {
for style in crate::prefs::NavigatorStyle::ALL {
for (width, height, scale) in [(1400.0, 900.0, 1.0), (700.0, 720.0, 2.0)] {
let mut h = Harness::new();
h.app.preferences.navigator_style = style;
h.call("ui.resize", json!({"width":width,"height":height}));
h.call("ui.prefs", json!({"ui_scale":scale}));
h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();
h.app.run("sketch.line", json!({"points":[[0,0],[20,0]]})).unwrap();
h.settle();
h.app.fit_view();
h.settle();
let layout = h.app.viewport.layout.as_ref().unwrap();
let palette = h.app.viewport.palette_rect.unwrap();
assert!(palette.top() >= layout.axis_view.bottom(), "{style:?} {palette:?} {layout:?}");
assert!(layout.viewport.expand(1.0).contains_rect(palette), "{palette:?} {layout:?}");
assert!(palette.contains(crate::scenario::handle_at("sketch_palette:look_at").unwrap()));
let proj = crate::viewport::projection(&h.app, layout.viewport);
for point in [solidcore_record::Vec3::ZERO, solidcore_record::Vec3::new(20.0, 0.0, 0.0)] {
assert!(layout.drawable.contains(proj.to_screen(point).unwrap()), "{layout:?}");
}
if width > 1000.0 {
let content = layout.content;
h.app.start("construct.plane.offset");
h.settle();
let dialog = h.app.viewport.dialog_rect.unwrap();
let expected_top = (content.top() + crate::viewport::AXIS_VIEW_CLEARANCE).min((content.bottom() - 360.0).max(content.top()));
assert!((dialog.left() - content.left()).abs() < 1.0);
assert!((dialog.top() - expected_top).abs() < 1.0, "left dialogs retain their existing top: {dialog:?}");
}
}
}
}
#[test]
fn short_floating_palette_stays_in_viewport() {
for style in crate::prefs::NavigatorStyle::ALL {
for height in [475, 385, 300] {
let mut h = Harness::new();
h.app.preferences.navigator_style = style;
h.call("ui.resize", json!({"width":700,"height":height}));
h.call("ui.prefs", json!({"ui_scale":2.0}));
h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();
// Main's open/untied-end feedback also consumes footer space.
for points in [[[0, 0], [10, 0]], [[10, 0], [10, 10]], [[10, 10], [0, 10]], [[0, 10], [0, 0]], [[20, 0], [30, 5]]] {
h.app.run("sketch.line", json!({"points":points,"infer":false,"connect":false})).unwrap();
}
// Include the extra Feature Options section in the tiny-height case.
if height == 300 {
h.app.start("sketch.rectangle.two_point");
}
h.settle();
let viewport = h.app.viewport.rect.unwrap();
let palette = h.app.viewport.palette_rect.unwrap();
assert!(
viewport.contains_rect(palette),
"{style:?}, height={height}: {palette:?} extends beyond {viewport:?}, right={:.9}, bottom={:.9}",
palette.right(),
palette.bottom()
);
let compass = h.app.viewport.layout.as_ref().unwrap().axis_view;
if compass.is_positive() {
assert!(palette.top() < compass.bottom(), "short panels reclaim compass space");
}
let action = crate::scenario::handle_at("sketch_palette:look_at").unwrap();
if !palette.contains(action) {
// Once reclaiming is insufficient, the whole palette scrolls to its footer.
h.call("ui.scroll", json!({"x":palette.center().x,"y":palette.center().y,"delta":-1200}));
h.frames(20);
}
let action = crate::scenario::handle_at("sketch_palette:look_at").unwrap();
assert!(palette.contains(action), "footer must be reachable: {style:?}, height={height}, {action:?} in {palette:?}");
let finish = crate::scenario::handle_at("sketch_palette:finish").unwrap();
h.call("ui.click", json!({"x":finish.x,"y":finish.y}));
assert!(h.app.session.active_sketch.is_none(), "Finish Sketch must work after scrolling");
}
}
}
#[test]
fn selection_drag_released_over_a_card_leaves_no_rubber_band() {
let mut h = Harness::new();
h.call("ui.resize", json!({"width":1400,"height":900}));
h.settle();
let ribbon = rect_of("ribbon:card").unwrap();
let viewport = h.app.viewport.rect.unwrap();
h.call(
"ui.drag",
json!({"x0":viewport.right()-20.0,"y0":viewport.bottom()-100.0,
"x1":ribbon.right()-12.0,"y1":ribbon.bottom()-28.0,"steps":12}),
);
assert!(h.app.viewport.boxsel.is_none());
assert!(h.app.session.selection.is_empty());
}
#[test]
fn floating_browser_clears_cards_shields_input_and_can_dock_again() {
for mode in [LayoutMode::Floating, LayoutMode::Docked] {
for timeline_left in [false, true] {
let mut h = Harness::new();
h.call("ui.set", json!({"layout":mode}));
h.app.preferences.timeline_left = timeline_left;
h.app.preferences.browser_float = true;
h.app.run("solid.box", json!({"length":40,"width":30,"height":20})).unwrap();
h.settle();
let browser = rect_of("browser:float").unwrap();
let toolbar = rect_of("toolbar").unwrap();
assert!(browser.top() >= toolbar.bottom(), "{mode:?}: {browser:?} must clear {toolbar:?}");
assert!(crate::scenario::handle_at("row:Untitled").is_some());
assert!(crate::scenario::handle_at("left-browser-rail").is_some());
assert!(covered(&h.app, browser.center()));
let viewport = h.app.viewport.rect.unwrap();
// A left-side history still takes a column in Docked mode.
if mode == LayoutMode::Floating || !timeline_left {
assert_eq!(viewport.left(), 0.0);
} else {
assert!(viewport.left() > 0.0);
}
if mode == LayoutMode::Floating {
assert_eq!(viewport.top(), toolbar::APP_BAR_HEIGHT);
assert!(!browser.intersect(rect_of("ribbon:card").unwrap()).is_positive());
}
h.app.fit_view();
h.settle();
assert!(!h.app.viewport.layout.as_ref().unwrap().drawable.intersect(browser).is_positive());
let camera = h.app.cam;
let doc = h.app.session.doc.to_json();
let at = browser.center();
h.call("ui.move", json!({"x":at.x,"y":at.y}));
assert!(h.app.viewport.hover.is_none());
assert!(h.app.viewport.mouse.is_none());
h.call("ui.scroll", json!({"x":at.x,"y":at.y,"delta":120}));
h.call("ui.drag", json!({"x0":at.x,"y0":at.y,"x1":at.x+20.0,"y1":at.y+10.0,"button":"middle","steps":6}));
assert_eq!(h.app.cam, camera);
assert_eq!(h.app.session.doc.to_json(), doc);
// The browser remains interactive above the shielded viewport.
h.step(&json!({"click":{"chevron":"Origin"}})).unwrap();
assert!(crate::browser::drawn_rows().iter().any(|(name, _, _, open)| name == "Origin" && *open == Some(true)));
h.app.preferences.browser_float = false;
h.settle();
assert!(h.app.shell.browser.is_some());
assert!(rect_of("browser:float").is_none());
assert!(rect_of("browser:card").is_some());
// The saved width follows both the floating card and the docked column.
let rail = crate::scenario::handle_at("left-browser-rail").unwrap();
let width = h.app.preferences.browser_width;
h.call("ui.drag", json!({"x0":rail.x,"y0":rail.y,"x1":rail.x+60.0,"y1":rail.y,"steps":6}));
assert!(h.app.preferences.browser_width > width + 30.0);
}
}
}
#[test]
fn browser_and_history_cards_block_input_while_their_gaps_and_space_below_browser_do_not() {
let mut h = Harness::new();
h.call("ui.resize", json!({"width":1400,"height":900}));
h.app.run("solid.box", json!({"length":40,"width":30,"height":20})).unwrap();
h.settle();
let browser = rect_of("browser:card").unwrap();
let history = rect_of("history:card").unwrap();
let viewport = h.app.viewport.rect.unwrap();
assert_eq!(history.left(), viewport.left() + SHELL_GAP);
assert_eq!(history.right(), viewport.right() - SHELL_GAP);
assert_eq!(history.bottom(), viewport.bottom() - SHELL_GAP);
let layout = h.app.viewport.layout.as_ref().unwrap();
assert!(layout.navigation.bottom() < history.top());
assert!(layout.axis_view.top() >= rect_of("ribbon:card").unwrap().bottom());
for r in [browser, history] {
assert!(covered(&h.app, r.center()));
assert!(!layout.drawable.intersect(r).is_positive());
}
for at in [pos2(browser.left() + 2.0, browser.top() + 2.0), pos2(history.right() - 30.0, history.center().y)] {
let camera = h.app.cam;
h.call("ui.move", json!({"x":at.x,"y":at.y}));
assert!(h.app.viewport.mouse.is_none());
assert!(h.app.viewport.hover.is_none());
h.call("ui.scroll", json!({"x":at.x,"y":at.y,"delta":120}));
h.call("ui.drag", json!({"x0":at.x,"y0":at.y,"x1":at.x+10.0,"y1":at.y+2.0,"button":"middle","steps":6}));
assert_eq!(h.app.cam, camera);
}
for at in [pos2(3.0, browser.center().y), pos2(browser.center().x, browser.bottom() + SHELL_GAP), pos2(3.0, history.center().y)] {
assert!(!covered(&h.app, at));
h.call("ui.move", json!({"x":at.x,"y":at.y}));
assert_eq!(h.app.viewport.mouse, Some(at));
}
h.app.ui.show_browser = false;
h.app.ui.show_timeline = false;
h.settle();
assert!(h.app.shell.browser.is_none() && h.app.shell.history.is_none());
assert!(!covered(&h.app, browser.center()));
assert!(!covered(&h.app, history.center()));
}
#[test]
fn left_history_and_browser_share_the_left_edge_without_moving_right_controls() {
for mode in [LayoutMode::Floating, LayoutMode::Docked] {
let mut h = Harness::new();
h.app.ui.layout = mode;
h.app.preferences.timeline_left = true;
h.app.run("solid.box", json!({"length":10,"width":10,"height":10,"name":"First"})).unwrap();
h.settle();
assert!(rect_of("history:card").is_none());
let history = rect_of("history:vertical").unwrap();
let browser = rect_of("browser:card").unwrap();
assert!((browser.left() - history.right() - Container::for_layout(mode, Surface::Panel).gap()).abs() < 1.0);
assert!(crate::scenario::handle_at("timeline:First").is_some());
let viewport = h.app.viewport.rect.unwrap();
let content = content_rect(&h.app, viewport);
assert_eq!(viewport.left(), if mode == LayoutMode::Floating { 0.0 } else { crate::ui_kit::history_width(true) });
assert_eq!(content.left(), browser.right() + Container::for_layout(mode, Surface::Panel).gap());
assert_eq!(content.bottom(), viewport.bottom());
if mode == LayoutMode::Floating {
assert!(covered(&h.app, history.center()));
assert!(covered(&h.app, browser.center()));
let gap_x = (history.right() + browser.left()) / 2.0;
assert!(covered(&h.app, pos2(gap_x, history.center().y)), "the seam pill shields viewport input");
assert!(!covered(&h.app, pos2(gap_x, history.top() + 4.0)), "the rest of the shell gap remains available");
}
}
}
#[test]
fn assistant_floats_without_changing_projection_and_shields_the_model() {
for dark in [false, true] {
for side in ["left", "right"] {
let mut h = crate::scenario::Harness::new();
h.app.home.open = false;
h.call("ui.resize", serde_json::json!({"width":1400,"height":1000}));
h.call("ui.set", serde_json::json!({"dark":dark,"layout":"floating"}));
h.frames(4);
let projection = h.app.viewport.rect.expect("viewport");
let original_controls = h.app.viewport.layout.clone().expect("layout");
h.call("ui.agent_chat", serde_json::json!({"open":true,"picker":false,"side":side,"width":440}));
h.frames(6);
let card = crate::scenario::rect_of("agent_chat:panel").expect("floating Assistant");
assert_eq!(h.app.viewport.rect, Some(projection), "opening the card preserves projection");
assert!(card.left() > projection.left() && card.right() < projection.right());
assert!(card.bottom() < projection.bottom());
let content = h.app.shell.content.expect("content");
assert!((card.top() - content.top()).abs() < 1.0, "full-height top: {card:?} {content:?}");
assert!((card.bottom() - content.bottom()).abs() < 1.0, "full-height bottom: {card:?} {content:?}");
assert!(covered(&h.app, card.center()), "chat shields viewport input");
if side == "right" {
let layout = h.app.viewport.layout.as_ref().expect("layout");
assert!(!card.intersect(layout.axis_view).is_positive(), "card clears compass");
assert!(!card.intersect(layout.navigation).is_positive(), "card clears navigation");
assert!(layout.axis_view.right() < original_controls.axis_view.right(), "compass moves left");
assert!(layout.navigation.center().x < original_controls.navigation.center().x, "navigation moves left");
} else {
let browser = h.app.shell.browser.expect("browser card");
assert!(card.right() < browser.left(), "left Assistant precedes browser");
assert!((card.top() - browser.top()).abs() < 1.0, "Assistant and browser share the top margin");
}
let camera = h.app.cam;
let at = card.center();
h.call("ui.move", json!({"x":at.x,"y":at.y}));
h.call("ui.scroll", json!({"x":at.x,"y":at.y,"delta":120}));
h.call("ui.drag", json!({"x0":at.x,"y0":at.y,"x1":at.x-30.0,"y1":at.y+15.0,"button":"middle","steps":6}));
assert_eq!(h.app.cam, camera, "chat consumes wheel and orbit input");
assert!(h.app.viewport.boxsel.is_none());
h.app.start("solid.extrude");
h.frames(5);
let feature = h.app.viewport.dialog_rect.expect("feature panel");
let beside = crate::scenario::rect_of("agent_chat:panel").expect("Assistant beside feature");
assert!(!beside.intersect(feature).is_positive(), "feature and Assistant coexist: {beside:?} {feature:?}");
assert!(
(beside.min - card.min).length() < 1.0 && (beside.max - card.max).length() < 1.0,
"opening a tool must not move Assistant: {card:?} -> {beside:?}"
);
if side == "right" {
assert!(feature.right() + SHELL_GAP <= beside.left() + 1.0, "tool stays inside Assistant's rail");
}
h.app.dialog = None;
h.app.tool = None;
h.frames(3);
h.call("ui.agent_chat", serde_json::json!({"minimized":true}));
h.frames(4);
let folded = crate::scenario::rect_of("agent_chat:panel").expect("floating folded card");
assert!(folded.width() < 60.0 && folded.height() < 120.0);
assert!(covered(&h.app, folded.center()));
assert_eq!(h.app.viewport.rect, Some(projection));
let folded_controls = h.app.viewport.layout.as_ref().expect("layout");
assert_eq!(folded_controls.axis_view, original_controls.axis_view);
if side == "right" {
assert_eq!(folded_controls.navigation, original_controls.navigation);
} else {
let shift = (folded.width() + SHELL_GAP) / 2.0;
assert!((folded_controls.navigation.center().x - original_controls.navigation.center().x - shift).abs() < 1.0);
}
h.call("ui.agent_chat", serde_json::json!({"open":false}));
h.frames(3);
assert!(!covered(&h.app, card.center()), "closed chat leaves no stale obstruction");
}
}
}
#[test]
fn assistant_left_dock_precedes_history_and_drag_hints_match_the_result() {
for layout in ["floating", "docked"] {
for (names, stacked) in [(false, false), (true, false), (true, true)] {
let mut h = Harness::new();
h.app.home.open = false;
h.app.preferences.timeline_left = true;
h.app.preferences.timeline_under_browser = stacked;
h.app.preferences.timeline_left_width = crate::ui_kit::history_width(names);
h.call("ui.resize", json!({"width":1600,"height":1000}));
h.call("ui.set", json!({"layout":layout}));
h.call("ui.agent_chat", json!({"open":true,"side":"right","width":440,"picker":false}));
h.frames(6);
let projection = h.app.viewport.rect;
for left in [true, false] {
let grip = crate::scenario::handle_at("agent_chat:grip").expect("drag grip");
let target = pos2(if left { 100.0 } else { 1500.0 }, grip.y);
h.app.synthetic.push(egui::Event::PointerMoved(grip));
h.frame();
h.app.synthetic.push(egui::Event::PointerButton {
pos: grip,
button: egui::PointerButton::Primary,
pressed: true,
modifiers: egui::Modifiers::NONE,
});
h.frame();
h.app.synthetic.push(egui::Event::PointerMoved(target));
h.frames(2);
let hint = rect_of("agent_chat:dock_hint").expect("visible dock target");
h.app.synthetic.push(egui::Event::PointerButton {
pos: target,
button: egui::PointerButton::Primary,
pressed: false,
modifiers: egui::Modifiers::NONE,
});
h.frames(6);
let card = h.app.agent_chat.panel_rect.expect("docked Assistant");
assert_eq!(h.app.preferences.agent_chat_side, if left { "left" } else { "right" });
assert!((hint.min - card.min).length() < 1.0 && (hint.max - card.max).length() < 1.0, "{layout} preview {hint:?} matches {card:?}");
if layout == "floating" {
assert_eq!(h.app.viewport.rect, projection, "docking keeps model projection");
}
if left {
let history = h.app.shell.history.expect("vertical history");
let browser = h.app.shell.browser.expect("browser");
assert!(card.right() <= history.left(), "Assistant precedes history: {card:?} {history:?}");
if stacked {
assert!((history.left() - browser.left()).abs() < 1.0);
assert!((history.width() - browser.width()).abs() < 1.0);
assert!(browser.bottom() <= history.top(), "History stays below Browser");
} else {
assert!(history.right() <= browser.left(), "history precedes browser");
}
}
}
h.call("ui.agent_chat", json!({"side":"left","minimized":true}));
h.frames(6);
let strip = h.app.agent_chat.drop_rect.expect("minimized Assistant");
assert!(strip.right() <= h.app.shell.history.expect("history").left());
h.call("ui.agent_chat", json!({"open":false}));
h.frames(6);
assert!(h.app.shell.history.expect("history returns to outer edge").left() < strip.right());
}
}
}
#[test]
fn assistant_right_edge_survives_palette_tool_resize_and_minimize() {
for layout in ["floating", "docked"] {
let mut h = Harness::new();
h.app.home.open = false;
h.call("ui.resize", json!({"width":1800,"height":1000}));
h.call("ui.set", json!({"layout":layout}));
h.call("ui.agent_chat", json!({"open":true,"side":"right","width":380,"picker":false}));
h.frames(5);
let right = h.app.agent_chat.panel_rect.unwrap().right();
h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();
h.frames(6);
for width in [380.0, 480.0] {
h.call("ui.agent_chat", json!({"width":width}));
h.frames(6);
let chat = h.app.agent_chat.panel_rect.unwrap();
let palette = h.app.viewport.palette_rect.unwrap();
assert!((chat.right() - right).abs() < 1.0, "{layout}: Assistant stays outside the palette");
assert!(
palette.right() + Container::for_layout(h.app.ui.layout, Surface::Panel).gap() <= chat.left() + 1.0,
"{layout}: {palette:?}, {chat:?}"
);
}
h.call("ui.agent_chat", json!({"minimized":true}));
h.frames(5);
let strip = h.app.agent_chat.drop_rect.unwrap();
let palette = h.app.viewport.palette_rect.unwrap();
assert!((strip.right() - right).abs() < 1.0);
assert!(palette.right() <= strip.left(), "palette clears the minimized Assistant too");
h.call("ui.agent_chat", json!({"open":false}));
h.frames(5);
assert!(h.app.viewport.palette_rect.unwrap().right() > palette.right(), "closing Assistant reclaims its rail");
}
}
#[test]
fn tool_sheets_drag_over_browser_and_history_but_clear_protected_panels() {
for side in ["left", "right"] {
let mut h = Harness::new();
h.app.home.open = false;
h.call("ui.resize", json!({"width":1800,"height":1000}));
h.call("ui.set", json!({"layout":"floating"}));
h.call("ui.agent_chat", json!({"open":true,"side":side,"width":380,"picker":false}));
h.frames(5);
h.app.start("sketch.create");
h.frames(5);
let chat = h.app.agent_chat.panel_rect.unwrap();
let browser = h.app.shell.browser.unwrap();
let history = h.app.shell.history.unwrap();
let ribbon = h.app.shell.cards[1];
let workspace = h.app.shell.cards[0];
for target in [browser.center(), history.center(), ribbon.center(), workspace.center(), egui::pos2(-1000.0, 400.0), egui::pos2(3000.0, 400.0)]
{
let title = crate::scenario::handle_at("dialog:title").unwrap();
h.call("ui.drag", json!({"x0":title.x,"y0":title.y,"x1":target.x,"y1":target.y,"steps":10}));
h.frames(4);
let sheet = h.app.viewport.dialog_rect.unwrap();
assert!(!sheet.intersect(chat).is_positive(), "{side}: {sheet:?} overlaps Assistant {chat:?}");
assert!(!sheet.intersect(ribbon).is_positive(), "sheet clears ribbon");
assert!(!sheet.intersect(workspace).is_positive(), "sheet clears workspace selector");
if target == browser.center() {
assert!(sheet.intersect(browser).is_positive(), "sheet can cover Browser");
let layer = h.ctx.layer_id_at(sheet.intersect(browser).center()).unwrap();
assert_eq!(layer.id, egui::Id::unique(("sc_dialog", "CREATE SKETCH")), "sheet receives input above Browser");
} else if target == history.center() {
assert!(sheet.intersect(history).is_positive(), "sheet can cover History");
}
}
h.step(&json!({"widget":"Cancel"})).unwrap();
assert!(h.app.dialog.is_none(), "dragged sheet remains interactive");
}
}
#[test]
fn tool_sheets_stay_above_browser_and_history_after_panel_clicks() {
for dock in ["bottom", "left", "under_browser"] {
let mut h = Harness::new();
h.app.home.open = false;
h.call("ui.resize", json!({"width":1800,"height":1000}));
h.call("ui.set", json!({"layout":"floating"}));
h.app.run("view.history_layout", json!({"dock":dock})).unwrap();
h.app.start("solid.extrude");
h.settle();
for panel in [h.app.shell.browser.unwrap(), h.app.shell.history.unwrap()] {
let title = crate::scenario::handle_at("dialog:title").unwrap();
let target = panel.center();
h.call("ui.drag", json!({"x0":title.x,"y0":title.y,"x1":target.x,"y1":target.y,"steps":10}));
let sheet = h.app.viewport.dialog_rect.unwrap();
let overlap = sheet.intersect(panel);
assert!(overlap.is_positive(), "{dock}: the dialog overlaps the panel");
let exposed = panel.left_top() + egui::vec2(10.0, 10.0);
assert!(!sheet.contains(exposed), "the panel click is outside the dialog");
h.call("ui.click", json!({"x":exposed.x,"y":exposed.y}));
let layer = h.ctx.layer_id_at(overlap.center()).unwrap();
assert_eq!(layer.id, egui::Id::unique(("sc_dialog", "EXTRUDE")), "{dock}: clicking a panel must not cover the dialog");
let panel_layer = h.ctx.layer_id_at(exposed).unwrap();
h.call("ui.click", json!({"x":1700,"y":500}));
assert_eq!(h.ctx.layer_id_at(exposed), Some(panel_layer), "clicking the model view must not cover the panel");
}
h.step(&json!({"widget":"Cancel"})).unwrap();
assert!(h.app.dialog.is_none(), "{dock}: the overlapping dialog remains clickable");
}
}
#[test]
fn tool_sheet_dropdowns_and_preferences_still_open_above_the_sheet() {
for layout in ["floating", "compact"] {
let mut h = Harness::new();
h.app.home.open = false;
h.call("ui.resize", json!({"width":1400,"height":900}));
h.call("ui.set", json!({"layout":layout}));
h.app.start("solid.extrude");
h.settle();
let title = crate::scenario::handle_at("dialog:title").unwrap();
h.call("ui.drag", json!({"x0":title.x,"y0":title.y,"x1":700,"y1":350,"steps":10}));
h.step(&json!({"widget":"One Side"})).unwrap();
h.step(&json!({"widget":"Symmetric"})).unwrap();
assert!(matches!(h.app.dialog.as_ref().unwrap().kind, crate::dialogs::Kind::Extrude { direction: 2, .. }));
let sheet = h.app.viewport.dialog_rect.unwrap();
h.call("ui.prefs", json!({"open":"General"}));
let preferences = rect_of("dialog:window").unwrap();
let overlap = sheet.intersect(preferences);
assert!(overlap.is_positive(), "Preferences overlaps the feature dialog");
assert_eq!(h.ctx.layer_id_at(overlap.center()).unwrap().id, egui::Id::unique("sc_prefs"), "Preferences receives input above the sheet");
let cancel = rect_of("prefs:cancel").expect("Preferences Cancel");
assert_eq!(h.ctx.layer_id_at(cancel.center()).unwrap().id, egui::Id::unique("sc_prefs"), "Preferences owns its Cancel target");
h.step(&json!({"click":{"handle":"prefs:cancel"}})).unwrap();
assert!(!h.app.prefs_window.open && h.app.dialog.is_some(), "Cancel closes Preferences, leaving the feature dialog open");
h.step(&json!({"widget":"Cancel"})).unwrap();
assert!(h.app.dialog.is_none());
}
}
#[test]
fn compact_layout_is_saved_and_survives_cancel_apply_defaults_and_bad_input() {
let mut h = Harness::new();
h.app.run("solid.box", json!({"length":10,"width":10,"height":10})).unwrap();
h.app.start("solid.extrude");
h.settle();
let design = h.app.session.doc.to_json();
let undo = h.app.session.undo.len();
let camera = h.app.cam;
h.call("ui.prefs", json!({"open":"Layout"}));
crate::prefs::reveal_preference(&mut h, "dialog:Workspace:Compact");
h.step(&json!({"click":{"handle":"dialog:Workspace:Compact"}})).unwrap();
h.call("ui.prefs", json!({"button":"ok"}));
h.settle();
assert!(h.app.dialog.is_some(), "changing layout keeps the active tool");
assert_eq!(h.app.preferences.layout, LayoutMode::Docked);
assert_eq!(h.app.ui.layout, LayoutMode::Docked);
assert_eq!(h.app.cam, camera);
h.call("engine.execute", json!({"command":"view.layout", "params":{"mode":"compact"}}));
assert_eq!(h.app.cam, camera, "programmatic layout changes never auto-fit");
assert_eq!(h.app.session.doc.to_json(), design);
assert_eq!(h.app.session.undo.len(), undo);
let mut restored = crate::SolveApp::new(Default::default(), Default::default());
restored.load_prefs(&h.app.prefs());
assert_eq!(restored.ui.layout, LayoutMode::Docked);
assert_eq!(restored.preferences.layout, LayoutMode::Docked);
h.call("ui.prefs", json!({"open":"Layout","layout":"floating"}));
h.call("ui.prefs", json!({"button":"cancel"}));
assert_eq!(h.app.ui.layout, LayoutMode::Docked);
h.call("ui.prefs", json!({"open":"Layout","layout":"floating"}));
h.call("ui.prefs", json!({"button":"apply"}));
h.call("ui.prefs", json!({"layout":"compact"}));
h.call("ui.prefs", json!({"button":"cancel"}));
assert_eq!(h.app.ui.layout, LayoutMode::Floating);
h.call("ui.prefs", json!({"open":"Layout","layout":"compact"}));
h.call("ui.prefs", json!({"button":"defaults"}));
assert_eq!(h.app.ui.layout, LayoutMode::Floating);
assert_eq!(h.app.preferences.layout, LayoutMode::Floating);
h.call("ui.prefs", json!({"button":"ok"}));
assert!(crate::prefs::set(&mut h.app, &json!({"layout":"invalid"})).is_err());
assert_eq!(h.app.ui.layout, LayoutMode::Floating);
restored.load_prefs(r#"{"preferences":{"layout":"invalid","default_units":"in"}}"#);
assert_eq!(restored.ui.layout, LayoutMode::Floating);
assert_eq!(restored.preferences.default_units, "in");
assert_eq!(crate::prefs::lenient(&json!({})).layout, LayoutMode::Floating);
}
#[test]
fn compact_chrome_is_flush_and_browser_hugs_content_in_both_themes() {
for dark in [false, true] {
let mut h = Harness::new();
h.call("ui.resize", json!({"width":1400,"height":900}));
h.call("ui.prefs", json!({"layout":"compact"}));
h.call("ui.set", json!({"dark":dark}));
h.settle();
let bar = rect_of("toolbar").unwrap();
let browser = rect_of("browser:card").unwrap();
let workspace = rect_of("ribbon:workspace").unwrap();
assert_eq!(workspace.left(), bar.left());
assert_eq!(workspace.top(), bar.top());
assert_eq!(h.app.shell.cards.get(1).unwrap().left(), workspace.right(), "one joined top bar");
assert_eq!(browser.left(), 0.0);
assert_eq!(browser.top(), bar.bottom(), "square, flush Browser/ribbon join");
assert!(browser.height() < h.app.viewport.rect.unwrap().height() / 2.0, "Browser hugs its contents");
let compact = crate::ui_kit::Container::new(&h.ctx, crate::ui_kit::Surface::Panel);
assert_eq!(compact.gap(), 0.0);
let frame = compact.frame(&h.ctx, crate::theme::Tokens::get().panel, crate::frame::Side::Left);
assert_eq!(frame.shadow, egui::Shadow::NONE);
assert_eq!(frame.corner_radius, egui::CornerRadius::ZERO);
h.app.start("solid.extrude");
h.settle();
let dialog = h.app.viewport.dialog_rect.unwrap();
assert!((dialog.right() - h.app.viewport.rect.unwrap().right()).abs() < 1.0, "{dialog:?}");
let before = dialog;
h.step(&json!({"drag":[{"handle":"dialog:title"},[700,300]],"steps":6})).unwrap();
h.settle();
let moved = h.app.viewport.dialog_rect.unwrap();
assert!(moved.right() < before.right() - 100.0, "compact tool sheets detach from the right edge");
let feature = crate::ui_kit::Container::new(&h.ctx, crate::ui_kit::Surface::Feature);
assert_eq!(feature.frame(&h.ctx, crate::theme::Tokens::get().dialog_body, crate::frame::Side::Right).shadow, egui::Shadow::NONE);
h.app.run("view.layout", json!({"mode":"floating"})).unwrap();
h.settle();
assert_eq!(rect_of("browser:card").unwrap().left(), SHELL_GAP);
assert!(h.app.dialog.is_some());
}
}
#[test]
fn two_collapsed_compact_headers_leave_live_viewport_below_their_column() {
for dark in [false, true] {
let mut h = Harness::new();
h.call("ui.resize", json!({"width":1400,"height":900}));
h.call("ui.prefs", json!({"layout":"compact"}));
h.call("ui.set", json!({"dark":dark}));
h.app.run("view.history_layout", json!({"dock":"under_browser"})).unwrap();
h.app.preferences.timeline_left_browser_collapsed = true;
h.app.preferences.timeline_collapsed = true;
h.frames(12);
let browser = h.app.shell.browser.unwrap();
let history = h.app.shell.history.unwrap();
let below = egui::pos2(browser.center().x, history.bottom() + 40.0);
assert!(h.app.viewport.rect.unwrap().contains(below));
assert!(!covered(&h.app, below));
assert!(covered(&h.app, browser.center()));
assert!(covered(&h.app, history.center()));
h.call("ui.move", json!({"x":below.x,"y":below.y}));
assert_eq!(h.app.viewport.mouse, Some(below), "the vacated column remains live viewport");
}
}
#[test]
fn ribbon_labels_are_saved_independently_and_icon_only_commands_remain_reachable() {
for mode in [LayoutMode::Floating, LayoutMode::Docked] {
let mut h = Harness::new();
h.call("ui.resize", json!({"width":1400,"height":900}));
h.call("ui.prefs", json!({"layout":mode}));
h.settle();
let labelled = rect_of("toolbar").unwrap();
h.call("ui.prefs", json!({"ribbon_labels":false}));
h.settle();
let icons = rect_of("toolbar").unwrap();
assert!(icons.height() < labelled.height());
assert_eq!(h.app.ui.layout, mode);
let command = rect_of("button:sketch.create").unwrap();
assert!(icons.contains_rect(command));
h.step(&json!({"click":{"handle":"button:sketch.create"}})).unwrap();
assert!(h.app.dialog.is_some(), "the icon still starts Create Sketch");
let mut restored = crate::SolveApp::new(Default::default(), Default::default());
restored.load_prefs(&h.app.prefs());
assert!(!restored.preferences.ribbon_labels);
assert_eq!(restored.ui.layout, mode);
h.call("ui.prefs", json!({"open":"Interface","ribbon_labels":true}));
h.call("ui.prefs", json!({"button":"cancel"}));
assert!(!h.app.preferences.ribbon_labels);
}
assert!(crate::prefs::lenient(&json!({})).ribbon_labels);
}
#[test]
fn embed_keeps_model_panels_without_application_chrome() {
let mut h = Harness::new();
h.app.embedded = true;
h.app.home.show(h.app.session.revision);
h.app.ui.show_browser = false;
h.app.ui.show_timeline = false;
h.app.run("solid.box", json!({"length":40,"width":30,"height":20})).unwrap();
h.settle();
assert!(!h.app.home.open);
assert_eq!(h.app.ui.layout, LayoutMode::Docked);
assert!(h.app.ui.show_browser && h.app.ui.show_timeline);
assert!(rect_of("toolbar").is_none());
assert!(rect_of("ribbon:workspace").is_none());
assert!(rect_of("browser:card").is_some());
assert!(h.app.viewport.rect.is_some());
}
#[test]
fn embed_editor_keeps_the_ribbon_and_leaves_files_to_the_host() {
let mut h = Harness::new();
h.settle();
assert!(rect_of("appbar:home").is_some(), "the full app has its application bar");
h.app.embed_editor = true;
h.app.home.show(h.app.session.revision);
h.settle();
assert!(!h.app.home.open, "the host shows the design, never the start page");
assert_eq!(h.app.ui.layout, LayoutMode::Docked);
assert!(rect_of("appbar:home").is_none() && rect_of("titlebar:report").is_none(), "no application bar");
assert!(rect_of("button:sketch.create").is_some() && rect_of("browser:card").is_some(), "the modelling surface stays");
// With no bar to hold it, command search stays in the ribbon whatever the host's header layout.
h.app.header = crate::toolbar::HeaderLayout::COMPACT;
h.settle();
assert!(rect_of("ribbon:search").is_some() && rect_of("titlebar:search").is_none());
h.step(&json!({"click":{"handle":"button:sketch.create"}})).unwrap();
assert!(h.app.dialog.is_some(), "and its commands work");
h.step(&json!({"key":"Escape"})).unwrap();
// New, Open, Save, Close and Preferences belong to the host page.
let (docs, revision) = (h.app.docs.count(), h.app.session.revision);
for key in ["N", "O", "S", "W", "Comma"] {
h.step(&json!({"key":key,"cmd":true})).unwrap();
}
h.settle();
assert_eq!((h.app.docs.count(), h.app.session.revision), (docs, revision));
assert!(!h.app.file_picker_busy() && !h.app.prefs_window.open, "{}", h.call("ui.inspect", json!({})));
// Undo stays the design's own.
h.app.run("solid.box", json!({"length":40,"width":30,"height":20})).unwrap();
h.settle();
h.step(&json!({"key":"Z","cmd":true})).unwrap();
assert!(h.app.session.doc.features.is_empty(), "Ctrl+Z undoes in the embed too");
}
/// A design with a finished sketch nothing uses yet, so Extrude opens ready for OK.
fn sketched(h: &mut Harness) {
h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();
h.app.run("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[40,30]})).unwrap();
h.app.run("sketch.finish", json!({})).unwrap();
}
#[test]
fn a_host_keeps_the_design_and_gives_it_back_with_its_timeline() {
let mut h = Harness::new();
h.app.embed_editor = true;
sketched(&mut h);
h.app.run("solid.box", json!({"length":40,"width":30,"height":20})).unwrap();
h.settle();
let kept = h.call("document.export", json!({}));
assert_eq!(kept["ok"], true, "{kept}");
let kept = &kept["result"];
assert_eq!((kept["format"].as_str(), kept["dirty"].as_bool()), (Some("json"), Some(true)));
assert_eq!(kept["revision"], h.call("document.revision", json!({}))["result"]["revision"], "the revision that follows the design");
let text = kept["text"].as_str().unwrap().to_string();
let timeline = |h: &Harness| h.app.session.doc.features.iter().map(|f| f.name.clone()).collect::<Vec<_>>();
let before = timeline(&h);
assert!(before.len() >= 2, "{before:?}");
// The host says it saved: the design is saved from there, until the next change.
let at = kept["revision"].as_u64().unwrap();
assert_eq!(h.call("document.saved", json!({"revision": at}))["result"]["dirty"], false);
assert!(!h.app.session.is_dirty());
assert_eq!(h.call("document.saved", json!({"revision": at + 7}))["ok"], false, "another revision is refused");
// Something else is drawn and left open; the kept design comes back in its place, saved,
// timeline and all, and what was going on in the other leaves with it.
h.app.run("solid.box", json!({"length":10,"width":10,"height":10})).unwrap();
assert_eq!(h.call("document.saved", json!({"revision": at}))["ok"], false, "the design changed since");
h.call("ui.start", json!({"command":"sketch.create"}));
h.settle();
assert!(h.app.dialog.is_some(), "{}", h.call("ui.inspect", json!({})));
let (docs, id) = (h.app.docs.count(), h.app.session.document_id.clone());
let back = h.call("document.import", json!({"text": text, "name": "Bracket"}));
assert_eq!(back["ok"], true, "{back}");
assert_eq!(back["result"]["errors"], 0);
assert_eq!(back["result"]["revision"], h.call("document.revision", json!({}))["result"]["revision"]);
assert_eq!(timeline(&h), before);
assert_eq!((h.app.session.doc.name.as_str(), h.app.session.is_dirty(), h.app.docs.count()), ("Bracket", false, docs));
assert_ne!(h.app.session.document_id, id, "another design, as one opened is");
assert!(h.app.session.undo.is_empty(), "the undo history is the opened design's own");
assert!(h.app.dialog.is_none() && h.app.tool.is_none());
h.settle();
for bad in [json!({}), json!({"text": "{"}), json!({"text": "not a design"})] {
assert_eq!(h.call("document.import", bad.clone())["ok"], false, "{bad}");
assert_eq!(timeline(&h), before, "a refused import leaves the design as it was");
}
}
/// Dialogs › In the left column (#6707): Extrude takes the place of the browser and the History
/// at the left, at the column's width and never narrower than its card, in both layouts and
/// every History dock. The view keeps its size, the dialog is covered, the content area starts
/// beside it, and OK, Cancel or Esc bring the column back exactly as it was.
#[test]
fn a_dialog_in_the_left_column_takes_the_place_of_browser_and_history() {
let card = crate::theme::Tokens::get().form_card_width;
for mode in [LayoutMode::Floating, LayoutMode::Docked] {
for (dock, close) in [("bottom", "Cancel"), ("left", "Escape"), ("under_browser", "OK")] {
let what = format!("{mode:?}, History {dock}, {close}");
let mut h = Harness::new();
h.call("ui.resize", json!({"width":1400,"height":900}));
h.call("ui.set", json!({"layout":mode}));
h.call("ui.prefs", json!({"dialog_place":"left_column"}));
h.app.run("view.history_layout", json!({"dock":dock})).unwrap();
sketched(&mut h);
h.settle();
let browser = h.app.shell.browser.expect("browser");
let history = h.app.shell.history.expect("history");
let viewport = h.app.viewport.rect.unwrap();
let prefs = serde_json::to_value(&h.app.preferences).unwrap();
let column = if dock == "bottom" { browser } else { browser.union(history) };
h.step(&json!({"start":"solid.extrude"})).unwrap();
h.settle();
let dialog = h.app.viewport.dialog_rect.expect("dialog");
assert_eq!(rect_of("dialog:outer"), Some(dialog), "{what}");
let place = rect_of("dialog:column").expect("the column is published");
assert!((dialog.left() - column.left()).abs() <= 1.0 && (place.left() - column.left()).abs() <= 1.0, "{what}: {dialog:?} {column:?}");
assert!((dialog.top() - column.top()).abs() <= 1.0, "{what}: {dialog:?} {column:?}");
// The card's outline lies outside its response rect, one stroke at each side.
assert!((dialog.width() - column.width().max(card)).abs() <= 2.5, "{what}: {dialog:?} {column:?}");
assert!(dialog.bottom() <= place.bottom() + 1.0, "{what}: {dialog:?} {place:?}");
assert!(rect_of("browser:card").is_none() && h.app.shell.browser.is_none(), "{what}: the browser is not drawn");
if dock == "bottom" {
assert_eq!(h.app.shell.history, Some(history), "{what}: the bottom strip stays");
assert!(dialog.bottom() < history.top(), "{what}");
} else {
assert!(rect_of("history:vertical").is_none(), "{what}: the History is not drawn");
}
assert_eq!(h.app.viewport.rect, Some(viewport), "{what}: the view keeps its size");
assert!(covered(&h.app, dialog.center()), "{what}");
assert!(content_rect(&h.app, viewport).left() >= dialog.right(), "{what}");
assert!(h.widget("Distance").is_some(), "{what}: the inputs are there");
match close {
"Escape" => h.step(&json!({"key":"Escape"})).unwrap(),
other => h.step(&json!({"widget":other})).unwrap(),
}
h.settle();
assert!(h.app.dialog.is_none(), "{what}");
assert_eq!(h.app.session.doc.features.len(), if close == "OK" { 2 } else { 1 }, "{what}: OK adds the extrude");
let back = h.app.shell.browser.expect("the browser is back");
assert_eq!((back.x_range(), back.top()), (browser.x_range(), browser.top()), "{what}");
assert_eq!(h.app.shell.history, Some(history), "{what}: the History is back as it was");
assert_eq!(serde_json::to_value(&h.app.preferences).unwrap(), prefs, "{what}: no width or fold changed");
assert!(rect_of("dialog:column").is_none(), "{what}");
}
}
}
/// With no column at the left (the browser hidden, or translucent over the view) a dialog in
/// the left column docks at the left edge at its own width, above the bottom History strip.
#[test]
fn without_a_left_column_a_dialog_docks_at_the_left_edge_at_its_own_width() {
let card = crate::theme::Tokens::get().form_card_width;
for (mode, browser) in [(LayoutMode::Floating, "hidden"), (LayoutMode::Docked, "hidden"), (LayoutMode::Floating, "translucent")] {
let what = format!("{mode:?}, browser {browser}");
let mut h = Harness::new();
h.call("ui.resize", json!({"width":1400,"height":900}));
h.call("ui.set", json!({"layout":mode}));
h.call("ui.prefs", json!({"dialog_place":"left_column","browser_float":browser == "translucent"}));
h.app.ui.show_browser = browser != "hidden";
sketched(&mut h);
h.settle();
let history = h.app.shell.history.expect("history");
let viewport = h.app.viewport.rect.unwrap();
h.step(&json!({"start":"solid.extrude"})).unwrap();
h.settle();
let dialog = h.app.viewport.dialog_rect.expect("dialog");
let gap = Container::for_layout(mode, Surface::Panel).gap();
assert!((dialog.left() - (viewport.left() + gap)).abs() <= 1.0, "{what}: {dialog:?} {viewport:?}");
assert!((dialog.width() - card).abs() <= 2.5, "{what}: {dialog:?}");
assert!(dialog.bottom() < history.top(), "{what}");
assert!(rect_of("browser:card").is_none(), "{what}");
h.step(&json!({"widget":"Cancel"})).unwrap();
h.settle();
assert_eq!(rect_of("browser:card").is_some(), browser == "translucent", "{what}");
}
}
/// The Assistant docked on the left keeps the outside edge: the column starts beside it, where
/// the browser was.
#[test]
fn a_dialog_in_the_left_column_starts_beside_the_assistant() {
let mut h = Harness::new();
h.app.home.open = false;
h.call("ui.resize", json!({"width":1800,"height":1000}));
h.call("ui.set", json!({"layout":"floating"}));
h.call("ui.prefs", json!({"dialog_place":"left_column"}));
h.call("ui.agent_chat", json!({"open":true,"side":"left","width":380,"picker":false}));
h.frames(5);
let browser = h.app.shell.browser.unwrap();
h.app.start("sketch.create");
h.frames(5);
let chat = h.app.agent_chat.panel_rect.unwrap();
let dialog = h.app.viewport.dialog_rect.unwrap();
assert!((dialog.left() - browser.left()).abs() <= 1.0, "{dialog:?} {browser:?}");
assert!(!dialog.intersect(chat).is_positive(), "{dialog:?} {chat:?}");
let title = crate::scenario::handle_at("dialog:title").unwrap();
h.call("ui.drag", json!({"x0":title.x,"y0":title.y,"x1":title.x + 300.0,"y1":title.y + 200.0,"steps":10}));
h.frames(4);
assert_eq!(h.app.viewport.dialog_rect, Some(dialog), "a dialog in the column stays in its place");
}
/// The Sketch Palette keeps the right edge while a sketch dialog holds the left column, also on
/// a view too narrow for both side by side; editing a feature reopens its dialog in the column
/// and Cancel rolls the marker back.
#[test]
fn the_sketch_palette_stays_and_editing_a_feature_opens_in_the_left_column() {
for width in [1400.0, 900.0] {
let mut h = Harness::new();
h.call("ui.resize", json!({"width":width,"height":900}));
h.call("ui.prefs", json!({"dialog_place":"left_column"}));
h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();
h.app.run("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[40,30]})).unwrap();
h.settle();
let palette = rect_of("sketch_palette:outer").expect("palette");
let browser = h.app.shell.browser.unwrap();
h.step(&json!({"start":"inspect.measure"})).unwrap();
h.settle();
let dialog = h.app.viewport.dialog_rect.expect("measure");
let kept = rect_of("sketch_palette:outer").expect("the palette stays on screen");
assert!((kept.right() - palette.right()).abs() <= 1.0 && (kept.top() - palette.top()).abs() <= 1.0, "width {width}: {kept:?} {palette:?}");
assert!((dialog.left() - browser.left()).abs() <= 1.0 && !dialog.intersect(palette).is_positive(), "width {width}: {dialog:?}");
h.step(&json!({"widget":"Close"})).unwrap();
h.app.run("sketch.finish", json!({})).unwrap();
h.app.run("solid.extrude", json!({"distance":10})).unwrap();
h.settle();
let extrude = h.app.session.doc.features.last().unwrap().id;
let marker = h.app.session.doc.marker;
h.app.edit_feature(extrude);
h.settle();
assert!(h.app.dialog.as_ref().is_some_and(|d| d.editing.is_some()));
assert_ne!(h.app.session.doc.marker, marker, "editing rolls the marker to the feature");
let edit = h.app.viewport.dialog_rect.expect("edit dialog");
assert!((edit.left() - browser.left()).abs() <= 1.0, "width {width}: {edit:?}");
assert!(h.app.shell.browser.is_none());
h.step(&json!({"widget":"Cancel"})).unwrap();
h.settle();
assert_eq!(h.app.session.doc.marker, marker);
assert!(h.app.shell.browser.is_some());
}
}
/// OK and Cancel in the view's corner (#6709) with a dialog in the left column: the pair keeps
/// the view's top right, beside the column's content area and clear of the dialog; its check
/// applies the dialog and its cross cancels, and either way the column comes back.
#[test]
fn the_view_corner_answers_a_dialog_in_the_left_column() {
for how in ["ok", "cancel"] {
let mut h = Harness::new();
h.call("ui.resize", json!({"width":1400,"height":900}));
h.call("ui.prefs", json!({"dialog_place":"left_column","view_confirm_corner":true}));
sketched(&mut h);
h.settle();
let browser = h.app.shell.browser.expect("browser");
h.step(&json!({"start":"solid.extrude"})).unwrap();
h.settle();
let dialog = h.app.viewport.dialog_rect.expect("dialog");
let pair = rect_of("view:confirm").expect("the pair in the view's corner");
let content = content_rect(&h.app, h.app.viewport.rect.unwrap());
assert!((dialog.left() - browser.left()).abs() <= 1.0, "{how}: the dialog holds the column: {dialog:?}");
assert!(content.contains_rect(pair) && pair.left() > content.center().x, "{how}: {pair:?} in the top right of {content:?}");
assert!(!pair.intersects(dialog), "{how}: {pair:?} {dialog:?}");
assert!(covered(&h.app, pair.center()), "{how}");
assert_eq!(crate::scenario::count_of("view:confirm:ok:enabled"), Some(1.0), "{how}");
h.step(&json!({"click":{"handle":format!("view:confirm:{how}")}})).unwrap();
h.settle();
assert!(h.app.dialog.is_none(), "{how}: the dialog closes");
assert_eq!(h.app.session.doc.features.len(), if how == "ok" { 2 } else { 1 }, "{how}: the check makes the extrude");
assert!(h.app.shell.browser.is_some_and(|b| b.x_range() == browser.x_range()), "{how}: the column comes back");
}
}
/// Dialogs is a Layout preference: set from the page or the control channel, saved,
/// refused when unknown, and Cancel and Restore Defaults put it back. A dialog already open
/// moves with it.
#[test]
fn dialog_place_is_saved_and_survives_cancel_defaults_and_bad_input() {
use crate::dialog_column::DialogPlace;
let mut h = Harness::new();
sketched(&mut h);
h.step(&json!({"start":"solid.extrude"})).unwrap();
h.settle();
let right = h.app.viewport.dialog_rect.unwrap();
assert_eq!(h.app.preferences.dialog_place, DialogPlace::Edge);
h.call("ui.prefs", json!({"open":"Layout"}));
crate::prefs::reveal_preference(&mut h, "dialog:Dialogs:In the left column");
h.step(&json!({"click":{"handle":"dialog:Dialogs:In the left column"}})).unwrap();
assert_eq!(h.app.preferences.dialog_place, DialogPlace::LeftColumn);
h.call("ui.prefs", json!({"button":"ok"}));
h.settle();
let left = h.app.viewport.dialog_rect.unwrap();
assert!(left.left() < right.left() && h.app.shell.browser.is_none(), "the open dialog moves to the column: {left:?}");
let mut restored = crate::SolveApp::new(Default::default(), Default::default());
restored.load_prefs(&h.app.prefs());
assert_eq!(restored.preferences.dialog_place, DialogPlace::LeftColumn);
h.call("ui.prefs", json!({"open":"Layout","dialog_place":"edge"}));
h.call("ui.prefs", json!({"button":"cancel"}));
assert_eq!(h.app.preferences.dialog_place, DialogPlace::LeftColumn);
h.call("ui.prefs", json!({"open":"Layout"}));
h.call("ui.prefs", json!({"button":"defaults"}));
assert_eq!(h.app.preferences.dialog_place, DialogPlace::Edge);
h.call("ui.prefs", json!({"button":"ok"}));
assert!(crate::prefs::set(&mut h.app, &json!({"dialog_place":"top"})).is_err());
assert_eq!(h.app.preferences.dialog_place, DialogPlace::Edge);
restored.load_prefs(r#"{"preferences":{"dialog_place":"top","default_units":"in"}}"#);
assert_eq!(restored.preferences.dialog_place, DialogPlace::Edge);
assert_eq!(restored.preferences.default_units, "in");
}
/// Every text the last frame painted.
fn painted_texts(h: &Harness) -> Vec<String> {
fn walk(shape: &egui::Shape, out: &mut Vec<String>) {
match shape {
egui::Shape::Text(t) => out.push(t.galley.text().to_string()),
egui::Shape::Vec(shapes) => shapes.iter().for_each(|s| walk(s, out)),
_ => {}
}
}
let mut out = Vec::new();
h.shapes.iter().for_each(|s| walk(&s.shape, &mut out));
out
}
#[test]
fn status_bar_spans_the_window_below_history_in_both_layouts_and_is_covered() {
for mode in [LayoutMode::Docked, LayoutMode::Floating] {
let mut h = Harness::new();
h.call("ui.resize", json!({"width":1400,"height":900}));
h.call("ui.set", json!({"layout":mode}));
h.app.run("solid.box", json!({"length":40,"width":30,"height":20})).unwrap();
h.settle();
assert!(rect_of("status:bar").is_none() && h.app.shell.status_bar.is_none(), "off by default");
let viewport_without = h.app.viewport.rect.unwrap();
let covered_without = covered_rects(&h.app);
h.call("ui.prefs", json!({"status_bar": true}));
h.settle();
let bar = rect_of("status:bar").unwrap();
assert_eq!(h.app.shell.status_bar, Some(bar));
assert_eq!((bar.left(), bar.right(), bar.bottom()), (0.0, 1400.0, 900.0), "{mode:?}: full width at the window's bottom: {bar:?}");
assert_eq!(bar.height(), crate::status_bar::HEIGHT);
let viewport = h.app.viewport.rect.unwrap();
assert!(viewport.bottom() <= bar.top() + 0.5, "{mode:?}: the view ends above the bar: {viewport:?} {bar:?}");
assert_eq!(viewport.bottom(), viewport_without.bottom() - bar.height(), "{mode:?}: the view gives up only the bar's height");
let history = h.app.shell.history.unwrap();
assert!(history.bottom() <= bar.top() + 0.5, "{mode:?}: History sits above the bar: {history:?} {bar:?}");
let rects = covered_rects(&h.app);
assert!(rects.contains(&bar), "{mode:?}: the bar is covered: {rects:?}");
assert_eq!(rects.len(), covered_without.len() + 1, "{mode:?}: {rects:?} {covered_without:?}");
assert!(covered(&h.app, bar.center()));
h.call("ui.prefs", json!({"status_bar": false}));
h.settle();
assert!(rect_of("status:bar").is_none() && h.app.shell.status_bar.is_none());
assert_eq!(h.app.viewport.rect.unwrap(), viewport_without);
}
}
#[test]
fn viewport_sketch_status_distinguishes_empty_and_constrained_geometry() {
for mode in [LayoutMode::Docked, LayoutMode::Floating] {
let mut h = Harness::new();
h.call("ui.set", json!({"layout":mode}));
let corner = |h: &Harness| painted_texts(h).into_iter().filter(|t| t.starts_with("Sketch1 — ")).collect::<Vec<_>>();
h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();
h.settle();
assert_eq!(corner(&h), ["Sketch1 — No geometry yet"], "{mode:?}: an empty sketch is not fully constrained");
assert!(h.widget("No geometry yet").is_some(), "the palette agrees with the viewport");
let rectangle = h.app.run("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[40,30]})).unwrap();
h.settle();
assert_eq!(corner(&h), ["Sketch1 — 2 degrees of freedom"], "the rectangle's width and height are free");
h.app.run("sketch.constraint.fix", json!({"entities":rectangle["curves"]})).unwrap();
h.settle();
assert_eq!(corner(&h), ["Sketch1 — fully constrained"], "drawn geometry can be fully constrained");
h.app.run("edit.undo", json!({})).unwrap();
h.settle();
assert_eq!(corner(&h), ["Sketch1 — 2 degrees of freedom"]);
h.app.run("edit.undo", json!({})).unwrap();
h.settle();
assert_eq!(corner(&h), ["Sketch1 — No geometry yet"], "undoing the geometry restores the empty status");
}
}
#[test]
fn status_bar_names_what_is_edited_and_the_sketch_state_and_replaces_the_views_corner_text() {
use crate::status_bar::SketchState;
let mut h = Harness::new();
let corner = |h: &Harness| painted_texts(h).into_iter().filter(|t| t.starts_with("Sketch1 — ")).collect::<Vec<_>>();
h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();
h.settle();
assert_eq!(corner(&h), ["Sketch1 — No geometry yet"], "without the bar the state stays in the view's corner");
h.call("ui.prefs", json!({"status_bar": true}));
h.settle();
let contents = crate::status_bar::contents(&h.app);
assert_eq!(contents.editing.as_deref(), Some("Editing Sketch1"));
assert_eq!(contents.sketch, Some(SketchState::Empty), "a blank sketch is not called fully constrained");
let rectangle = h.app.run("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[40,30]})).unwrap();
h.settle();
let contents = crate::status_bar::contents(&h.app);
let Some(SketchState::Under(dof)) = contents.sketch else { panic!("{contents:?}") };
assert!(dof > 0);
let texts = painted_texts(&h);
assert!(corner(&h).is_empty(), "with the bar on, the view's corner shows no state: {texts:?}");
assert!(texts.contains(&format!("Under constrained ({dof} degrees of freedom)")), "{texts:?}");
assert!(texts.iter().any(|t| t == "Editing Sketch1") && texts.iter().any(|t| t == "mm"), "{texts:?}");
assert!(crate::scenario::handle_at("status:editing").unwrap().x < crate::scenario::handle_at("status:sketch").unwrap().x);
assert!(crate::scenario::handle_at("status:sketch").unwrap().x < crate::scenario::handle_at("status:units").unwrap().x);
// Fully constrained: the rectangle fixed in place.
h.app.run("sketch.constraint.fix", json!({"entities": rectangle["curves"]})).unwrap();
h.settle();
assert_eq!(crate::status_bar::contents(&h.app).sketch, Some(SketchState::Full));
h.app.run("sketch.finish", json!({})).unwrap();
h.app.run("solid.extrude", json!({"distance":10})).unwrap();
h.settle();
let idle = crate::status_bar::contents(&h.app);
assert_eq!((idle.editing, idle.sketch, idle.units.as_str()), (None, None, "mm"), "idle: only the units");
assert!(crate::scenario::handle_at("status:editing").is_none() && crate::scenario::handle_at("status:sketch").is_none());
// A feature's dialog, editing it.
let extrude = h.app.session.doc.features.iter().find(|f| f.name == "Extrude1").map(|f| f.id).unwrap();
h.app.edit_feature(extrude);
h.settle();
assert!(h.app.dialog.as_ref().is_some_and(|d| d.editing.is_some()));
assert_eq!(crate::status_bar::contents(&h.app).editing.as_deref(), Some("Editing Extrude1"));
// In another language the text is translated, and so is a default feature name.
let _ja = crate::i18n::scope("ja");
assert_eq!(crate::status_bar::contents(&h.app).editing, Some(format!("編集中: {}", crate::i18n::tr_name("Extrude1"))));
assert_eq!(crate::i18n::tr_name("Sketch1"), "スケッチ1");
}
#[test]
fn status_bar_units_open_the_units_menu_above_the_bar_and_change_units_in_one_undo_step() {
let mut h = Harness::new();
h.call("ui.resize", json!({"width":1400,"height":900}));
h.call("ui.prefs", json!({"status_bar": true}));
h.app.run("solid.box", json!({"length":40,"width":30,"height":20})).unwrap();
h.settle();
let undo = h.app.session.undo.len();
let button = rect_of("status:units").unwrap();
assert!(rect_of("status:bar").unwrap().contains_rect(button));
h.step(&json!({"click":{"handle":"status:units"}})).unwrap();
h.settle();
assert_eq!(h.app.menu.target, crate::context_menu::Target::Units);
let at = h.app.viewport.context_menu.unwrap();
assert_eq!(at, button.right_top());
let menu = crate::context_menu::describe(&h.app);
let labels: Vec<_> = menu["items"].as_array().unwrap().iter().map(|i| i["label"].as_str().unwrap().to_string()).collect();
assert_eq!(labels, crate::prefs::UNITS);
// The list opens above the bar, inside the window.
let list = h.ctx.memory(|m| m.area_rect(egui::Id::unique("sc_context_menu"))).unwrap();
assert!(list.bottom() <= button.top() + 0.5 && list.top() >= 0.0, "{list:?} {button:?}");
assert_eq!(h.app.session.undo.len(), undo, "opening the menu changes nothing");
h.call("ui.menuPick", json!({"item":"in"}));
h.settle();
assert_eq!(h.app.session.doc.units, "in");
assert_eq!(h.app.session.undo.len(), undo + 1);
assert!(h.app.viewport.context_menu.is_none());
assert_eq!(crate::status_bar::contents(&h.app).units, "in");
h.app.run("edit.undo", json!({})).unwrap();
h.settle();
assert_eq!(h.app.session.doc.units, "mm");
// A second click on the button closes the menu it opened.
h.step(&json!({"click":{"handle":"status:units"}})).unwrap();
h.settle();
assert!(h.app.viewport.context_menu.is_some());
h.step(&json!({"click":{"handle":"status:units"}})).unwrap();
h.settle();
assert!(h.app.viewport.context_menu.is_none());
}
#[test]
fn status_bar_mouse_mapping_opens_the_mappings_and_picks_one_as_the_preferences_page_does() {
use crate::context_menu::Target;
let mut h = Harness::new();
h.call("ui.resize", json!({"width":1400,"height":900}));
h.call("ui.prefs", json!({"status_bar": true}));
h.app.run("solid.box", json!({"length":40,"width":30,"height":20})).unwrap();
h.settle();
let doc = h.app.session.doc.to_json();
let undo = h.app.session.undo.len();
let button = rect_of("status:navigation").unwrap();
assert!(rect_of("status:bar").unwrap().contains_rect(button));
assert!(button.right() < rect_of("status:units").unwrap().left(), "the mapping sits left of the units");
assert_eq!(crate::status_bar::contents(&h.app).navigation, "Fusion");
assert!(painted_texts(&h).iter().any(|t| t == "Fusion"));
h.step(&json!({"click":{"handle":"status:navigation"}})).unwrap();
h.settle();
assert_eq!(h.app.menu.target, Target::Navigation);
assert_eq!(h.app.viewport.context_menu, Some(button.right_top()));
let menu = crate::context_menu::items(&h.app, &Target::Navigation);
let labels: Vec<_> = menu.iter().map(|item| item.label.as_str()).collect();
assert_eq!(labels, crate::prefs::NAV_PRESETS.iter().map(|preset| preset.translated_label()).collect::<Vec<_>>());
assert_eq!(menu.iter().filter(|item| item.shortcut == "current").map(|item| item.label.as_str()).collect::<Vec<_>>(), ["Fusion"]);
let list = h.ctx.memory(|m| m.area_rect(egui::Id::unique("sc_context_menu"))).unwrap();
assert!(list.bottom() <= button.top() + 0.5 && list.top() >= 0.0, "{list:?} {button:?}");
// Each mapping, picked from the menu, sets what Preferences › Navigation sets for it.
for preset in crate::prefs::NAV_PRESETS {
let mut expected = h.app.preferences.clone();
crate::prefs::choose_nav_preset(&mut expected, preset);
if h.app.viewport.context_menu.is_none() {
h.step(&json!({"click":{"handle":"status:navigation"}})).unwrap();
h.settle();
}
h.call("ui.menuPick", json!({"item": preset.translated_label()}));
h.settle();
assert_eq!(serde_json::to_value(&h.app.preferences).unwrap(), serde_json::to_value(&expected).unwrap(), "{}", preset.id);
assert!(h.app.viewport.context_menu.is_none());
assert_eq!(crate::status_bar::contents(&h.app).navigation, preset.translated_label());
}
assert_eq!(h.app.session.doc.to_json(), doc, "a preference, not a design edit");
assert_eq!(h.app.session.undo.len(), undo);
// An unknown mapping changes nothing.
let before = serde_json::to_value(&h.app.preferences).unwrap();
let hostile = crate::context_menu::Item::action("ui.navPreset", "Nope", "").with(json!({"preset": "nope"}));
crate::context_menu::run_item(&mut h.app, &hostile, egui::pos2(0.0, 0.0));
assert_eq!(serde_json::to_value(&h.app.preferences).unwrap(), before);
// A second click on the button closes the menu it opened.
h.step(&json!({"click":{"handle":"status:navigation"}})).unwrap();
h.settle();
assert!(h.app.viewport.context_menu.is_some());
h.step(&json!({"click":{"handle":"status:navigation"}})).unwrap();
h.settle();
assert!(h.app.viewport.context_menu.is_none());
}
#[test]
fn status_bar_stays_out_of_the_embed() {
let mut h = Harness::new();
h.app.embedded = true;
h.app.preferences.status_bar = true;
h.settle();
assert!(!crate::status_bar::shown(&h.app));
assert!(rect_of("status:bar").is_none() && h.app.shell.status_bar.is_none());
}
/// Content kept from an earlier frame that lies outside the viewport now (the window shrank, the
/// scale grew) gave an inside-out content rect, min past max, and the Render workspace's frame
/// overlay panicked clamping into it: `min > max, or either was NaN. min = 1004.0, max = 937.8125`.
/// The viewport stands in for such content, and the space left beside cards never panics.
#[test]
fn content_outside_a_shrunk_viewport_gives_way_to_the_viewport() {
let mut h = Harness::new();
let viewport = Rect::from_min_max(pos2(0.0, 0.0), pos2(800.0, 600.0));
h.app.shell.content = Some(Rect::from_min_max(pos2(900.0, 650.0), pos2(1600.0, 1000.0)));
assert_eq!(content_rect(&h.app, viewport), viewport);
// A rect already turned inside out, with History and Browser cards at its edges.
let inside_out = Rect::from_min_max(pos2(500.0, 1004.0), pos2(300.0, 938.0));
h.app.shell.history = Some(Rect::from_min_max(pos2(0.0, 900.0), pos2(800.0, 1000.0)));
h.app.shell.browser = Some(Rect::from_min_max(pos2(0.0, 0.0), pos2(200.0, 800.0)));
for left in [false, true] {
h.app.preferences.timeline_left = left;
let free = workspace_content(&h.app, inside_out);
assert!(free.min.x.is_finite() && free.min.y.is_finite(), "{free:?}");
}
}
/// The interface scale raised after a click at the top of a narrow window (found by a UI fuzzer
/// and shrunk to these three steps): the content kept from the frame before lay outside the new
/// viewport, and the next frame's layout panicked clamping into it (`min = 264.0, max =
/// 165.28125`).
#[test]
fn a_larger_interface_scale_in_a_narrow_window_keeps_drawing() {
let mut h = Harness::new();
for step in [
json!({"call": "ui.resize", "params": {"width": 330.5693343218654, "height": 1445.8773151935186}}),
json!({"click": [206.1875, 17.0]}),
json!({"call": "ui.prefs", "params": {"ui_scale": 2.0}}),
] {
h.step(&step).unwrap();
}
h.frames(3);
assert!(h.app.viewport.rect.unwrap().is_positive());
}
#[test]
fn docked_assistant_beside_an_inverted_view_area_does_not_panic() {
// A surface reconfigure can leave the view area inside out, its left past its right (#9492).
for side in ["right", "left"] {
let mut h = Harness::new();
h.app.home.open = false;
h.call("ui.set", json!({"layout":"floating"}));
h.call("ui.agent_chat", json!({"open":true,"side":side,"width":380,"picker":false}));
h.frames(5);
assert!(h.app.agent_chat.panel_rect.is_some(), "{side}: docked Assistant");
h.app.viewport.rect = Some(Rect::from_min_max(pos2(264.1875, 30.0), pos2(159.0, 20.0)));
let ctx = h.ctx.clone();
crate::viewport::refresh_layout(&mut h.app, &ctx);
assert!(h.app.viewport.layout.is_some(), "{side}: a layout for the next frame");
}
}