use super::*; use crate::scenario::{Harness, handle_at, rect_of}; use crate::shell::{LayoutMode, SHELL_GAP}; #[test] fn browser_body_clicks_fill_and_toggle_save_mesh_inputs() { for mode in [LayoutMode::Floating, LayoutMode::Docked] { let mut h = Harness::new(); h.app.ui.layout = mode; for (name, x) in [("One", 0), ("Two", 20)] { h.app.run("solid.box", json!({"length":10,"width":10,"height":10,"corner":[x,0,0],"operation":"new_body","body_name":name})).unwrap(); } h.app.start("file.save_mesh"); h.settle(); for (clicked, expected) in [("One", vec!["One"]), ("Two", vec!["One", "Two"]), ("One", vec!["Two"])] { h.step(&json!({"click":{"handle":format!("row:{clicked}")}})).unwrap(); let d = h.app.dialog.as_ref().unwrap(); let crate::dialogs::Kind::SaveMesh(k) = &d.kind else { panic!("Save as Mesh is open") }; let commands = crate::dialogs_save_mesh::commands(k, &d.inputs).unwrap(); assert_eq!(commands[0].1["bodies"], json!(expected), "{mode:?}: clicked {clicked}"); assert!(crate::dialogs_save_mesh::ready(&d.inputs)); assert!(h.app.session.selection.is_empty(), "dialog picks do not change the global selection"); } h.step(&json!({"click":{"handle":"row:Two"}})).unwrap(); assert!(!crate::dialogs_save_mesh::ready(&h.app.dialog.as_ref().unwrap().inputs)); h.step(&json!({"key":"Escape"})).unwrap(); h.step(&json!({"click":{"handle":"row:One"}})).unwrap(); assert_eq!(h.app.session.selection, vec![Sel::Body { name: "One".into() }]); } } #[test] fn browser_body_clicks_respect_the_active_dialog_input() { let mut h = Harness::new(); for (name, x) in [("One", 0), ("Two", 20)] { h.app.run("solid.box", json!({"length":10,"width":10,"height":10,"corner":[x,0,0],"operation":"new_body","body_name":name})).unwrap(); } h.app.start("solid.combine"); h.app.dialog.as_mut().unwrap().preview_enabled = false; h.settle(); h.step(&json!({"click":{"handle":"row:One"}})).unwrap(); assert_eq!(h.app.dialog.as_ref().unwrap().active, 1, "a target pick advances to Tool Bodies"); h.step(&json!({"click":{"handle":"row:Two"}})).unwrap(); let d = h.app.dialog.as_ref().unwrap(); assert_eq!(d.inputs[0].items, vec![Sel::Body { name: "One".into() }]); assert_eq!(d.inputs[1].items, vec![Sel::Body { name: "Two".into() }]); h.call("ui.dialogInput", json!({"index":0})); h.step(&json!({"click":{"handle":"row:Two"}})).unwrap(); assert_eq!(h.app.dialog.as_ref().unwrap().inputs[0].items, vec![Sel::Body { name: "Two".into() }], "a single input replaces its pick"); h.step(&json!({"key":"Escape"})).unwrap(); h.app.start("solid.fillet"); h.settle(); h.step(&json!({"click":{"handle":"row:One"}})).unwrap(); assert!(h.app.dialog.as_ref().unwrap().inputs.iter().all(|i| i.items.is_empty()), "a body is not an edge"); assert!(h.app.session.selection.is_empty(), "an incompatible pick does not leak into the global selection"); } #[test] fn browser_card_shrinks_and_scrolls_without_covering_history() { let mut h = Harness::new(); h.call("ui.resize", json!({"width":1400,"height":900})); h.settle(); let short = rect_of("browser:card").unwrap(); let history = rect_of("history:card").unwrap(); assert_eq!(short.left(), SHELL_GAP); assert_eq!(short.width(), 250.0); assert_eq!(short.top(), rect_of("ribbon:card").unwrap().bottom() + SHELL_GAP); assert!(short.bottom() < history.top() - SHELL_GAP); assert!(drawn_rows().iter().all(|(_, rect, _, _)| rect.height() == 26.0)); for i in 0..35 { h.app.run("sketch.create", json!({"plane":"XY", "name":format!("Sketch{i}")})).unwrap(); h.app.run("sketch.finish", json!({})).unwrap(); } h.settle(); let tall = rect_of("browser:card").unwrap(); assert!(tall.height() > short.height()); assert!((tall.bottom() - (history.top() - SHELL_GAP)).abs() < 1.0, "{tall:?} {history:?}"); assert!(h.app.viewport.rect.unwrap().contains_rect(tall)); assert!(handle_at("row:Sketch34").is_none(), "last row starts below the scroll clip"); let camera = h.app.cam; h.call("ui.scroll", json!({"x":tall.center().x,"y":tall.center().y,"delta":-1800})); h.settle(); assert!(handle_at("row:Sketch34").is_some(), "scrolling must reveal the last row"); assert_eq!(h.app.cam, camera); assert_eq!(rect_of("browser:card").unwrap(), tall); h.call("ui.set", json!({"layout":"docked"})); h.settle(); assert_eq!(rect_of("browser:card").unwrap().left(), 0.0); assert_eq!(h.app.viewport.rect.unwrap().left(), 0.0); assert!(drawn_rows().iter().all(|(_, rect, _, _)| rect.height() == 26.0)); h.call("ui.set", json!({"layout":"floating"})); h.app.tree.collapsed.insert("c0".into()); h.settle(); assert!(rect_of("browser:card").unwrap().height() < short.height()); } #[test] fn selected_row_paints_tab_soft_fill_and_accent_text_in_both_layouts() { let previous = crate::theme::is_dark(); for dark in [false, true] { crate::theme::set_dark(dark); for mode in [LayoutMode::Floating, LayoutMode::Docked] { for tab in ["MODEL", "SKETCH", "SURFACE", "MESH", "FORM", "SHEET METAL", "RENDER"] { let ctx = crate::fonts::test_context(); let mut app = SolveApp::new(Default::default(), Default::default()); app.ui.layout = mode; app.ui.tab = tab.into(); crate::theme::TabAccent::publish(&app, &ctx); let accent = crate::theme::TabAccent::for_tab(&Tokens::get(), tab); let mut row_rect = Rect::NOTHING; let out = crate::test_support::frame(&ctx, egui::RawInput::default(), |ui| { let row = Row { selected: true, label: "Selected body", dim: true, color: Some(Tokens::get().error), ..Default::default() }; row_rect = draw_row(ui, egui::Id::new("selected-row"), &row).rect.unwrap(); }); assert_eq!(row_rect.height(), 26.0); assert!(out.shapes.iter().any(|s| matches!(&s.shape, egui::Shape::Rect(r) if r.rect == row_rect && r.fill == accent.soft))); assert!( out.shapes .iter() .any(|s| matches!(&s.shape, egui::Shape::Text(t) if t.galley.text() == "Selected body" && t.fallback_color == accent.ink)) ); } } } crate::theme::set_dark(previous); } #[test] fn card_and_column_keep_body_eyes_menus_and_group_drops() { for mode in [LayoutMode::Floating, LayoutMode::Docked] { let mut h = Harness::new(); h.app.ui.layout = mode; for (name, x) in [("One", 0), ("Two", 20)] { h.app.run("solid.box", json!({"length":10,"width":10,"height":10,"corner":[x,0,0],"operation":"new_body","body_name":name})).unwrap(); } let group = h.app.run("browser.group", json!({"component":0,"folder":"bodies","items":["One"],"name":"Group"})).unwrap()["group"].as_u64().unwrap(); h.settle(); h.step(&json!({"click":{"handle":"eye:Two"}})).unwrap(); assert!(h.app.session.visibility.hidden_bodies.iter().any(|name| name == "Two")); h.step(&json!({"click":{"handle":"eye:Two"}})).unwrap(); assert!(!h.app.session.visibility.hidden_bodies.iter().any(|name| name == "Two")); h.step(&json!({"click":{"handle":"row:Two"},"button":"right"})).unwrap(); assert!(matches!(&h.app.menu.target, crate::context_menu::Target::Body { name } if name == "Two")); h.step(&json!({"key":"Escape"})).unwrap(); h.step(&json!({"drag":[{"handle":"row:Two"},{"handle":"row:Group (1)"}]})).unwrap(); h.settle(); let group = h.app.session.doc.browser_groups.iter().find(|g| g.id == group).unwrap(); assert!(group.items.iter().any(|name| name == "Two"), "body drop into the folder failed in {mode:?}"); } } /// A second click on a Document Settings entry closes the window it opened, the way that /// window's own × does, and a third opens it again (#4150): the Units menu, Preferences (a change /// made there is put back), Parameters (a value typed but not applied is dropped) and Design /// Properties (nothing typed there is saved). #[test] fn a_second_click_on_a_document_settings_entry_closes_its_window() { for mode in [LayoutMode::Floating, LayoutMode::Docked] { let mut h = Harness::new(); h.app.ui.layout = mode; h.app.run("parameters.add", json!({"name":"width","expression":"10 mm"})).unwrap(); h.settle(); h.step(&json!({"click":{"chevron":"Document Settings"}})).unwrap(); h.settle(); // The Units, Precision and Parameters labels carry their values. let row = |start: &str| { let (_, rect, _, _) = drawn_rows().into_iter().find(|(label, ..)| label.starts_with(start)).unwrap(); json!({"click":[rect.center().x, rect.center().y]}) }; h.step(&row("Units")).unwrap(); assert!(h.app.viewport.context_menu.is_some() && h.app.menu.target == Target::Units, "{mode:?}: the first click opens the Units menu"); h.step(&row("Units")).unwrap(); h.frames(2); assert!(h.app.viewport.context_menu.is_none(), "{mode:?}: the second click closes it instead of reopening it"); h.step(&row("Units")).unwrap(); assert!(h.app.viewport.context_menu.is_some(), "{mode:?}: and a third opens it again"); h.step(&json!({"key":"Escape"})).unwrap(); h.step(&row("Precision")).unwrap(); h.frames(2); assert!(h.app.prefs_window.open, "{mode:?}: the first click opens Preferences"); let decimals = h.app.preferences.angle_decimals; h.app.preferences.angle_decimals = decimals + 2; h.step(&row("Precision")).unwrap(); h.frames(2); assert!(!h.app.prefs_window.open, "{mode:?}: the second click closes it"); assert_eq!(h.app.preferences.angle_decimals, decimals, "{mode:?}: and puts back what changed there, as × does"); h.step(&row("Precision")).unwrap(); h.frames(2); assert!(h.app.prefs_window.open, "{mode:?}: a third opens it again"); h.step(&json!({"key":"Escape"})).unwrap(); h.step(&row("Parameters")).unwrap(); h.frames(2); assert!(h.app.params.is_some(), "{mode:?}: the first click opens Parameters"); h.step(&json!({"click":{"handle":"param:width"}})).unwrap(); h.step(&json!({"key":"A","cmd":true})).unwrap(); h.step(&json!({"text":"25 mm"})).unwrap(); h.step(&row("Parameters")).unwrap(); h.frames(2); assert!(h.app.params.is_none(), "{mode:?}: the second click closes it"); assert_eq!(h.app.session.doc.param("width").unwrap().expr, "10 mm", "{mode:?}: and drops a value typed but not applied"); h.step(&row("Parameters")).unwrap(); assert!(h.app.params.is_some(), "{mode:?}: a third opens it again"); h.app.params = None; h.step(&row("Design Properties")).unwrap(); assert!(h.app.design_properties.is_some(), "{mode:?}: the first click opens Design Properties"); h.app.design_properties.as_mut().unwrap().fields[0] = "Typed".into(); h.frames(2); h.step(&row("Design Properties")).unwrap(); assert!(h.app.design_properties.is_none(), "{mode:?}: the second click closes it"); assert_eq!(h.app.session.doc.metadata.project(), None, "{mode:?}: and saves nothing typed there"); h.step(&row("Design Properties")).unwrap(); assert!(h.app.design_properties.is_some(), "{mode:?}: a third opens it again"); } } #[test] fn browser_header_folds_the_floating_card_to_its_header_and_back() { let mut h = Harness::new(); h.call("ui.resize", json!({"width":1400,"height":900})); h.settle(); let open = rect_of("browser:card").unwrap(); assert!(!h.app.tree.panel_collapsed); let at = handle_at("browser:header").unwrap(); h.call("ui.click", json!({"x":at.x,"y":at.y})); h.settle(); let folded = rect_of("browser:card").unwrap(); assert!(h.app.tree.panel_collapsed); assert!(folded.height() < 60.0 && folded.height() < open.height(), "{folded:?} {open:?}"); assert_eq!(folded.top(), open.top()); assert!(drawn_rows().is_empty() || handle_at("row:Plate").is_none()); h.call("ui.click", json!({"x":at.x,"y":at.y})); h.settle(); assert!(!h.app.tree.panel_collapsed); assert!((rect_of("browser:card").unwrap().height() - open.height()).abs() < 1.0); } /// Tiny or odd window sizes never panic: the cards leave out what cannot fit. #[test] fn tiny_floating_windows_never_panic() { for (w, h) in [(100, 60), (240, 90), (320, 140), (700, 150), (700, 300), (1400, 120), (180, 800)] { for scale in [1.0, 2.0] { let mut harness = Harness::new(); harness.call("ui.resize", json!({"width": w, "height": h})); harness.call("ui.prefs", json!({"ui_scale": scale})); harness.app.run("sketch.create", json!({"plane": "XY"})).unwrap(); harness.settle(); for mode in [LayoutMode::Floating, LayoutMode::Docked] { harness.app.ui.layout = mode; harness.settle(); } } } } /// Both shell layouts share one content-hugging tree and one saved width. /// The translucency preference never creates a second browser renderer. #[test] fn one_browser_keeps_its_resized_width_across_layouts_and_overlay_preferences() { let mut h = Harness::new(); h.call("ui.resize", json!({"width":1400,"height":900})); for mode in [LayoutMode::Floating, LayoutMode::Docked] { for overlay in [false, true] { h.app.ui.layout = mode; h.app.preferences.browser_float = overlay; h.app.preferences.browser_width = 310.0; h.settle(); assert!(rect_of("browser:card").is_some()); assert_eq!(crate::scenario::handles("browser:header").len(), 1, "only one browser header"); assert_eq!(drawn_rows().iter().filter(|(name, ..)| name == "Untitled").count(), 1, "only one tree"); assert!((rect_of("browser:card").unwrap().width() - 310.0).abs() < 1.0); assert_eq!(h.app.viewport.rect.unwrap().left(), 0.0); let rail = handle_at("left-browser-rail").unwrap(); h.call("ui.drag", json!({"x0":rail.x,"y0":rail.y,"x1":rail.x+60.0,"y1":rail.y,"steps":6})); h.settle(); let width = h.app.preferences.browser_width; assert!(width > 340.0 && width <= MAX_BROWSER_WIDTH, "{mode:?}, overlay={overlay}: {width}"); h.app.ui.layout = LayoutMode::Docked; h.app.preferences.browser_float = false; h.settle(); assert!((rect_of("browser:card").unwrap().width() - width).abs() < 1.0, "compact keeps the saved width"); } } } #[test] fn browser_title_uses_a_single_semibold_run() { let ctx = crate::fonts::test_context(); let mut app = SolveApp::new(Default::default(), Default::default()); let output = crate::test_support::frame(&ctx, egui::RawInput::default(), |ui| { ui.set_width(250.0); browser_header(&mut app, ui, true); }); let title = crate::i18n::tr("ui.browser_title"); let titles: Vec<_> = output .shapes .iter() .filter_map(|s| match &s.shape { egui::Shape::Text(text) if text.galley.text() == title => Some(text), _ => None, }) .collect(); assert_eq!(titles.len(), 1); assert_eq!(titles[0].galley.job.sections[0].format.font_id, crate::fonts::semibold(Tokens::get().font_heading)); } #[test] fn resizing_browser_card_and_column_persists_width_including_floating_preference() { for (mode, float, left_history) in [ (LayoutMode::Floating, false, false), (LayoutMode::Docked, false, false), (LayoutMode::Docked, true, false), (LayoutMode::Floating, true, true), (LayoutMode::Docked, true, true), ] { let mut h = Harness::new(); h.app.ui.layout = mode; h.app.preferences.browser_float = float; h.app.preferences.timeline_left = left_history; h.call("ui.resize", json!({"width":1400,"height":900})); h.settle(); let before = h.app.viewport.rect.unwrap(); let at = handle_at("left-browser-rail").unwrap(); h.call("ui.drag", json!({"x0":at.x,"y0":at.y,"x1":at.x+80.0,"y1":at.y,"steps":8})); h.settle(); let width = h.app.preferences.browser_width; assert!(width > crate::prefs::DEFAULT_BROWSER_WIDTH + 40.0, "{mode:?}, float={float}, width={width}"); assert!((rect_of("browser:card").unwrap().width() - width).abs() < 1.0); assert_eq!(h.app.viewport.rect.unwrap(), before, "browser resizing leaves the projection intact"); let mut restored = SolveApp::new(Default::default(), Default::default()); restored.load_prefs(&h.app.prefs()); assert_eq!(restored.preferences.browser_width, width); assert_eq!(restored.preferences.browser_float, float); } } #[test] fn browser_width_rejects_hostile_preferences_and_tiny_windows_still_fit() { for width in [f32::NAN, f32::INFINITY, f32::NEG_INFINITY] { assert_eq!(browser_width(width), crate::prefs::DEFAULT_BROWSER_WIDTH); } assert_eq!(browser_width(-100.0), MIN_BROWSER_WIDTH); assert_eq!(browser_width(f32::MAX), MAX_BROWSER_WIDTH); let available = Rect::from_min_size(Pos2::ZERO, vec2(100.0, 300.0)); for top_gap in [0.0, crate::shell::SHELL_GAP] { let bounds = panel_bounds(available, None, MAX_BROWSER_WIDTH, top_gap); assert!(available.contains_rect(bounds)); } } #[test] fn a_long_body_name_stays_inside_the_card_and_ends_in_an_ellipsis() { let mut h = Harness::new(); h.call("ui.resize", json!({"width":1400,"height":900})); let name = "W".repeat(200); h.app.run("solid.box", json!({"body_name":name, "operation":"new", "length":10, "width":10, "height":10})).unwrap(); h.settle(); let card = rect_of("browser:card").unwrap(); let label = rect_of(&format!("row_label:{name}")).expect("the body row is drawn"); assert!(label.right() <= card.right(), "{label:?} spills out of {card:?}"); assert!(label.width() > 100.0, "the name keeps the room it has: {label:?}"); } #[test] fn collapsed_rail_shares_header_hover_inset_and_expands_from_its_whole_card() { let previous = crate::theme::is_dark(); for dark in [false, true] { crate::theme::set_dark(dark); for collapsed in [false, true] { let ctx = crate::fonts::test_context(); ctx.global_style_mut(|style| style.animation_time = 0.0); let mut app = SolveApp::new(Default::default(), Default::default()); app.ui.tab = "SURFACE".into(); app.preferences.timeline_left = true; app.preferences.timeline_left_browser_collapsed = collapsed; crate::theme::TabAccent::publish(&app, &ctx); let bounds = Rect::from_min_size(Pos2::ZERO, vec2(600.0, 700.0)); let draw = |app: &mut SolveApp, events| { crate::test_support::frame(&ctx, egui::RawInput { screen_rect: Some(bounds), events, ..Default::default() }, |ui| { browser(app, ui); }) }; for _ in 0..3 { draw(&mut app, vec![]); } let card = rect_of("browser:card").unwrap(); let header = rect_of("browser:header").unwrap(); // Hover at the bottom margin, far away from the disclosure and rotated title. let at = if collapsed { card.center_bottom() - vec2(0.0, 2.0) } else { header.center() }; draw(&mut app, vec![egui::Event::PointerMoved(at)]); let output = draw(&mut app, vec![egui::Event::PointerMoved(at)]); assert_eq!(output.platform_output.cursor_icon, egui::CursorIcon::PointingHand); let accent = crate::theme::TabAccent::current(&ctx); let mut hover = None; for shape in &output.shapes { crate::test_support::each_shape(&shape.shape, &mut |shape| { if let egui::Shape::Rect(rect) = shape && rect.fill == accent.soft { hover = Some(rect.clone()); } }); } let hover = hover.unwrap_or_else(|| panic!("dark={dark}, collapsed={collapsed}, at={at:?}, accent={accent:?}, shapes={:?}", output.shapes)); let inset = CARD_INSET + 1.0; // shared frame's inner margin and border assert_eq!(hover.rect, if collapsed { card.shrink(inset) } else { header }); assert_eq!(hover.rect.left() - card.left(), inset); assert_eq!(card.right() - hover.rect.right(), inset); assert_eq!(hover.corner_radius, egui::CornerRadius::same(Tokens::get().radius_lg.saturating_sub(CARD_INSET as u8))); if collapsed { draw(&mut app, crate::test_support::pointer(at, true)); draw(&mut app, crate::test_support::pointer(at, false)); assert!(!app.preferences.timeline_left_browser_collapsed, "the bottom margin expands the rail"); } } } crate::theme::set_dark(previous); }