From 6255a10e806333cc87fac43cb8d51828db132afe Mon Sep 17 00:00:00 2001 From: Nathan Dane Date: Thu, 29 Oct 2026 17:11:34 +0000 Subject: [PATCH] Viewport status item: engine list of what is on (#8545) (#8554) * claim: #8545 * Declare ordered viewport status items (#8545) * Keep legacy surface analysis coexistence behind a preference (#8545) --- .../pending/single-surface-analysis.json | 34 ++ .../pending/viewport-status-query.json | 26 ++ crates/engine/src/cmd/section.rs | 2 + crates/engine/src/cmd/surface_analysis.rs | 326 +++++++++++++++++- crates/engine/src/cmd/view_navigation.rs | 14 + crates/engine/src/control_pending.rs | 2 + crates/engine/src/lib.rs | 13 + crates/engine/src/schema/view_navigation.rs | 5 + .../src/schema/view_navigation_tests.rs | 48 +++ crates/engine/src/status_items.rs | 233 +++++++++++++ crates/ui-egui/src/documents.rs | 1 + crates/ui-egui/src/lib.rs | 1 + crates/ui-egui/src/prefs.rs | 145 ++++++++ crates/ui-egui/src/prefs/graphics.rs | 6 + docs/control-protocol.md | 35 ++ 15 files changed, 890 insertions(+), 1 deletion(-) create mode 100644 assets/locales/pending/single-surface-analysis.json create mode 100644 assets/locales/pending/viewport-status-query.json create mode 100644 crates/engine/src/status_items.rs diff --git a/assets/locales/pending/single-surface-analysis.json b/assets/locales/pending/single-surface-analysis.json new file mode 100644 index 000000000..ca735272b --- /dev/null +++ b/assets/locales/pending/single-surface-analysis.json @@ -0,0 +1,34 @@ +{ + "ar": { + "prefs.single_surface_analysis": "استخدام تحليل سطح واحد", + "prefs.single_surface_analysis_help": "عند إيقاف هذا الخيار، يمكن إبقاء تظليل السطح وتحليل الاستمرارية مفعّلين معًا. عند تشغيله، يبقى آخر تحليل تم بدؤه أو تغييره فقط." + }, + "de": { + "prefs.single_surface_analysis": "Nur eine Flächenanalyse verwenden", + "prefs.single_surface_analysis_help": "Wenn deaktiviert, können Flächenschattierung und Stetigkeitsanalyse gleichzeitig aktiv bleiben. Beim Aktivieren bleibt die zuletzt gestartete oder geänderte Analyse erhalten." + }, + "en": { + "prefs.single_surface_analysis": "Use a single surface analysis", + "prefs.single_surface_analysis_help": "When off, surface shading and Continuity can stay on together. Turning this on keeps the last analysis started or changed." + }, + "he": { + "prefs.single_surface_analysis": "שימוש בניתוח משטח יחיד", + "prefs.single_surface_analysis_help": "כשהאפשרות כבויה, הצללת המשטח וניתוח הרציפות יכולים להישאר פעילים יחד. הפעלתה משאירה רק את הניתוח האחרון שהופעל או שונה." + }, + "ja": { + "prefs.single_surface_analysis": "サーフェス解析を1つだけ使用", + "prefs.single_surface_analysis_help": "オフの場合、サーフェスのシェーディングと連続性解析を同時に有効にできます。オンにすると、最後に開始または変更した解析が残ります。" + }, + "ko": { + "prefs.single_surface_analysis": "표면 분석 하나만 사용", + "prefs.single_surface_analysis_help": "끄면 표면 음영 분석과 연속성 분석을 함께 유지할 수 있습니다. 켜면 마지막으로 시작하거나 변경한 분석만 유지됩니다." + }, + "vi": { + "prefs.single_surface_analysis": "Chỉ dùng một phân tích bề mặt", + "prefs.single_surface_analysis_help": "Khi tắt, phân tích tô bóng bề mặt và phân tích tính liên tục có thể cùng hoạt động. Khi bật, chỉ giữ phân tích được bắt đầu hoặc thay đổi gần nhất." + }, + "zh": { + "prefs.single_surface_analysis": "仅使用一个曲面分析", + "prefs.single_surface_analysis_help": "关闭时,曲面着色分析和连续性分析可以同时保持启用。开启时,仅保留最后启动或修改的分析。" + } +} diff --git a/assets/locales/pending/viewport-status-query.json b/assets/locales/pending/viewport-status-query.json new file mode 100644 index 000000000..3ea8b191f --- /dev/null +++ b/assets/locales/pending/viewport-status-query.json @@ -0,0 +1,26 @@ +{ + "ar": { + "cmd.view.status_items": "عناصر حالة منفذ العرض" + }, + "de": { + "cmd.view.status_items": "Ansichtsstatus-Elemente" + }, + "en": { + "cmd.view.status_items": "Viewport Status Items" + }, + "he": { + "cmd.view.status_items": "פריטי מצב תצוגה" + }, + "ja": { + "cmd.view.status_items": "ビューポートの状態項目" + }, + "ko": { + "cmd.view.status_items": "뷰포트 상태 항목" + }, + "vi": { + "cmd.view.status_items": "Các mục trạng thái khung nhìn" + }, + "zh": { + "cmd.view.status_items": "视口状态项" + } +} diff --git a/crates/engine/src/cmd/section.rs b/crates/engine/src/cmd/section.rs index 4cc15f3e1..42258fe9a 100644 --- a/crates/engine/src/cmd/section.rs +++ b/crates/engine/src/cmd/section.rs @@ -19,6 +19,7 @@ fn section(s: &mut Session, p: &Value) -> Result { let cmd = "inspect.section"; if bool_(p, "clear").unwrap_or(false) { s.section = None; + s.status_slot(crate::status_items::StatusId::Section, false); s.revision += 1; return Ok(json!({"section": null})); } @@ -75,6 +76,7 @@ fn section(s: &mut Session, p: &Value) -> Result { let origin = origin + normal * offset * if bool_(p, "flip").unwrap_or(false) { -1.0 } else { 1.0 }; s.section = Some((origin, normal)); s.section_hatch = bool_(p, "hatch").unwrap_or(true); + s.status_slot(crate::status_items::StatusId::Section, true); s.revision += 1; let mut section = json!({"origin": origin, "normal": normal, "hatch": s.section_hatch}); if let Some(i) = axis { diff --git a/crates/engine/src/cmd/surface_analysis.rs b/crates/engine/src/cmd/surface_analysis.rs index 9753f8d92..7c52cb649 100644 --- a/crates/engine/src/cmd/surface_analysis.rs +++ b/crates/engine/src/cmd/surface_analysis.rs @@ -62,6 +62,7 @@ fn set(s: &mut Session, p: &Value, a: SurfaceAnalysis) -> Result { } else { s.analysis = Some(a); } + s.status_analysis_changed((!bool_(p, "clear").unwrap_or(false)).then_some(crate::status_items::StatusId::SurfaceAnalysis)); s.revision += 1; Ok(json!({ "analysis": s.analysis })) } @@ -117,6 +118,7 @@ fn continuity(s: &mut Session, p: &Value) -> Result { let cmd = "inspect.continuity"; if bool_(p, "clear").unwrap_or(false) { s.continuity.clear(); + s.status_analysis_changed(None); s.revision += 1; return Ok(json!({ "analysis": "continuity", "cleared": true })); } @@ -205,6 +207,7 @@ fn continuity(s: &mut Session, p: &Value) -> Result { } else { s.continuity = seams; } + s.status_analysis_changed(Some(crate::status_items::StatusId::Continuity)); s.revision += 1; Ok(json!({ "analysis": "continuity", @@ -313,6 +316,327 @@ mod tests { s.execute("solid.box", &json!({"length": size, "width": size, "height": size})).unwrap(); } + fn status(s: &mut Session) -> Vec { + serde_json::from_value::(s.execute("view.status_items", &json!({})).unwrap()).unwrap().items + } + + #[test] + fn status_items_zero_seam_continuity_never_leaves_a_phantom_winner() { + use crate::status_items::StatusId; + for single in [false, true] { + let mut empty = Session::default(); + empty.set_single_surface_analysis(single); + empty.execute("inspect.zebra", &json!({"stripes":14.5})).unwrap(); + let before = (status(&mut empty), empty.latest_analysis, empty.revision); + assert!(empty.execute("inspect.continuity", &json!({})).is_err()); + assert_eq!((status(&mut empty), empty.latest_analysis, empty.revision), before, "empty-model failure is atomic"); + for had_continuity in [false, true] { + let mut s = Session::default(); + s.set_single_surface_analysis(single); + boxed(&mut s, 10.0); + for (command, params) in [ + ("sketch.create", json!({"plane":"XY","name":"Boundary"})), + ("sketch.rectangle.two_point", json!({"p0":[20,20],"p1":[30,30]})), + ("sketch.finish", json!({})), + ("surface.patch", json!({"sketch":"Boundary","body_name":"Sheet"})), + ("inspect.zebra", json!({"stripes":14.5})), + ("inspect.section", json!({"plane":"XY"})), + ] { + s.execute(command, ¶ms).unwrap(); + } + if had_continuity { + s.execute("inspect.continuity", &json!({"body":"Body1","edges":[[5,0,0]],"samples":5})).unwrap(); + assert_eq!(s.continuity.len(), 1); + if single { + s.execute("inspect.zebra", &json!({"stripes":14.5})).unwrap(); + } + } + s.mark_saved(); + let doc = s.doc.clone(); + let undo = s.undo.len(); + let result = s.execute("inspect.continuity", &json!({"body":"Sheet","samples":5})).unwrap(); + assert_eq!(result["summary"]["edges"], 0); + assert_eq!(result["summary"]["skipped"], 4, "an actual one-face sheet has four open boundaries"); + assert!(s.continuity.is_empty()); + assert_eq!(s.latest_analysis, if single { None } else { Some(StatusId::SurfaceAnalysis) }); + if single { + assert_eq!(s.analysis, None, "single-mode successful zero-result replacement retains its existing clear semantics"); + } else { + assert_eq!(s.analysis, Some(SurfaceAnalysis::Zebra { stripes: 14.5 }), "legacy zero result preserves shading"); + } + let expected = if single { vec![StatusId::Section] } else { vec![StatusId::SurfaceAnalysis, StatusId::Section] }; + for policy in [true, false, true] { + s.set_single_surface_analysis(policy); + assert_eq!(status(&mut s).iter().map(|item| item.id).collect::>(), expected); + } + assert!(std::sync::Arc::ptr_eq(&doc, &s.doc)); + assert!(!s.is_dirty()); + assert_eq!(s.undo.len(), undo); + } + } + } + + #[test] + fn status_items_legacy_policy_keeps_independent_effects_and_clears_in_both_orders() { + use crate::status_items::StatusId::{Continuity, Section, SurfaceAnalysis}; + for continuity_first in [false, true] { + let mut s = Session::default(); + boxed(&mut s, 10.0); + s.mark_saved(); + let doc = s.doc.clone(); + let undo = s.undo.len(); + s.set_single_surface_analysis(false); + let shading = ("inspect.zebra", json!({"stripes": 14.5})); + let continuity = ("inspect.continuity", json!({"edges": [[5, 0, 0]], "samples": 5})); + for (command, params) in if continuity_first { [continuity, shading] } else { [shading, continuity] } { + s.execute(command, ¶ms).unwrap(); + } + s.execute("inspect.section", &json!({"plane": "XY"})).unwrap(); + let items = status(&mut s); + let expected = if continuity_first { vec![Continuity, SurfaceAnalysis, Section] } else { vec![SurfaceAnalysis, Continuity, Section] }; + assert_eq!(items.iter().map(|item| item.id).collect::>(), expected); + assert_eq!(s.analysis, Some(crate::SurfaceAnalysis::Zebra { stripes: 14.5 })); + assert_eq!(s.continuity.len(), 1); + let before = (items.clone(), s.status_order.clone(), s.latest_analysis, s.revision, s.continuity.clone()); + for (command, params) in [ + ("inspect.continuity", json!({"body": "missing"})), + ("inspect.draft", json!({"pull": [0, 0, 0]})), + ("inspect.zebra", json!({"stripes": -2})), + ] { + assert!(s.execute(command, ¶ms).is_err()); + assert_eq!((status(&mut s), s.status_order.clone(), s.latest_analysis, s.revision, s.continuity.clone()), before); + } + // The legacy generic shading clear still ends Zebra, never Continuity or Section. + s.execute("inspect.curvature_map", &json!({"clear": true})).unwrap(); + assert_eq!(status(&mut s).iter().map(|item| item.id).collect::>(), vec![Continuity, Section]); + let clear = items.iter().find(|item| item.id == Continuity).unwrap().clear.clone(); + for _ in 0..2 { + s.execute(&clear.command, &serde_json::to_value(&clear.params).unwrap()).unwrap(); + assert_eq!(status(&mut s).iter().map(|item| item.id).collect::>(), vec![Section]); + } + // Clear in the opposite direction leaves the shading active too. + s.execute("inspect.zebra", &json!({})).unwrap(); + s.execute("inspect.continuity", &json!({"edges": [[5, 0, 0]]})).unwrap(); + s.execute("inspect.continuity", &json!({"clear": true})).unwrap(); + assert!(s.analysis.is_some()); + assert!(s.section.is_some()); + assert!(std::sync::Arc::ptr_eq(&doc, &s.doc)); + assert!(!s.is_dirty()); + assert_eq!(s.undo.len(), undo); + } + } + + #[test] + fn status_items_policy_switch_keeps_latest_replacement_at_oldest_group_position() { + use crate::status_items::{StatusId, StatusSetting}; + for continuity_first in [false, true] { + for latest_continuity in [false, true] { + let mut s = Session::default(); + boxed(&mut s, 10.0); + s.mark_saved(); + let doc = s.doc.clone(); + let undo = s.undo.len(); + s.set_single_surface_analysis(false); + let shading = ("inspect.zebra", json!({})); + let continuity = ("inspect.continuity", json!({"edges": [[5, 0, 0]], "samples": 5})); + let (first, last) = if continuity_first { (continuity, shading) } else { (shading, continuity) }; + s.execute(first.0, &first.1).unwrap(); + s.execute("inspect.section", &json!({"plane": "XY"})).unwrap(); + s.execute(last.0, &last.1).unwrap(); + // Replacement does not move the slot, but determines the policy-switch winner. + if latest_continuity { + s.execute("inspect.continuity", &json!({"edges": [[0, 5, 0]], "add": true})).unwrap(); + } else { + s.execute("inspect.draft", &json!({"angle": 7.5})).unwrap(); + } + let before = status(&mut s); + for _ in 0..3 { + assert_eq!(status(&mut s), before); + } + s.set_single_surface_analysis(true); + let items = status(&mut s); + assert_eq!(items.iter().map(|item| item.id).collect::>(), vec![StatusId::SurfaceAnalysis, StatusId::Section]); + assert_eq!(items[0].command, if latest_continuity { "inspect.continuity" } else { "inspect.draft" }); + if latest_continuity { + assert_eq!(s.analysis, None); + assert_eq!(items[0].setting, StatusSetting::Continuity { edge_count: 2 }); + } else { + assert!(s.continuity.is_empty()); + assert!(matches!(s.analysis, Some(SurfaceAnalysis::Draft { angle, .. }) if angle == 7.5)); + } + let revision = s.revision; + s.set_single_surface_analysis(true); + assert_eq!(s.revision, revision, "idempotent policy application"); + s.set_single_surface_analysis(false); + assert_eq!(status(&mut s)[0].id, if latest_continuity { StatusId::Continuity } else { StatusId::SurfaceAnalysis }); + assert!(std::sync::Arc::ptr_eq(&doc, &s.doc)); + assert!(!s.is_dirty()); + assert_eq!(s.undo.len(), undo); + assert!(!s.scratch().single_surface_analysis()); + s.execute("file.new", &json!({})).unwrap(); + assert!(!s.single_surface_analysis(), "new/open retain SDK session configuration"); + assert!(status(&mut s).is_empty()); + } + } + } + + #[test] + fn status_items_describe_every_effect_and_execute_their_own_clear() { + use crate::status_items::{StatusId, StatusKind, StatusSetting}; + let mut s = Session::default(); + assert!(status(&mut s).is_empty()); + for (command, params, setting, has_key) in [ + ("inspect.zebra", json!({"stripes": 12.5}), StatusSetting::Zebra { stripes: 12.5 }, false), + ("inspect.draft", json!({"pull": [0, -2, 0], "angle": 3.25}), StatusSetting::Draft { pull: [0.0, -1.0, 0.0], angle_deg: 3.25 }, true), + ("inspect.environment_map", json!({}), StatusSetting::Environment, false), + ("inspect.accessibility", json!({"direction": [-3, 0, 0]}), StatusSetting::Accessibility { direction: [-1.0, 0.0, 0.0] }, true), + ("inspect.curvature_map", json!({"radius": 2.75}), StatusSetting::Curvature { radius_mm: 2.75 }, true), + ] { + s.execute(command, ¶ms).unwrap(); + let items = status(&mut s); + assert_eq!(items.len(), 1); + let item = &items[0]; + assert_eq!(item.id, StatusId::SurfaceAnalysis); + assert_eq!(item.kind, StatusKind::Mode); + assert_eq!(item.command, command); + assert_eq!(item.setting, setting); + assert_eq!(item.has_key, has_key); + assert_eq!(item.clear.command, command); + let params = serde_json::to_value(&item.clear.params).unwrap(); + for _ in 0..2 { + s.execute(&item.clear.command, ¶ms).unwrap(); + assert!(status(&mut s).is_empty()); + } + } + for (params, origin, normal, hatch) in [ + (json!({"plane": "XY", "at": 20, "hatch": false}), [0.0, 0.0, 20.0], [0.0, 0.0, 1.0], false), + (json!({"plane": {"origin": [1, 2, 3], "normal": [0, 3, 4]}}), [1.0, 2.0, 3.0], [0.0, 0.6, 0.8], true), + ] { + s.execute("inspect.section", ¶ms).unwrap(); + let item = status(&mut s).remove(0); + assert_eq!(item.id, StatusId::Section); + assert_eq!(item.kind, StatusKind::Mode); + assert_eq!(item.command, "inspect.section"); + assert_eq!(item.setting, StatusSetting::Section { origin_mm: origin, normal, hatch }); + assert!(!item.has_key); + s.execute(&item.clear.command, &serde_json::to_value(item.clear.params).unwrap()).unwrap(); + assert!(status(&mut s).is_empty()); + } + } + + #[test] + fn status_items_order_slots_by_activation_and_retain_replacement_position() { + use crate::status_items::StatusId::{Section, SurfaceAnalysis}; + for section_first in [false, true] { + let mut s = Session::default(); + let section = ("inspect.section", json!({"plane": "XY"})); + let zebra = ("inspect.zebra", json!({})); + for (command, params) in if section_first { [section, zebra] } else { [zebra, section] } { + s.execute(command, ¶ms).unwrap(); + } + let expected = if section_first { vec![Section, SurfaceAnalysis] } else { vec![SurfaceAnalysis, Section] }; + assert_eq!(status(&mut s).iter().map(|item| item.id).collect::>(), expected); + s.execute("inspect.draft", &json!({"angle": 7})).unwrap(); + s.execute("inspect.section", &json!({"plane": "YZ", "at": 9})).unwrap(); + assert_eq!( + status(&mut s).iter().map(|item| item.id).collect::>(), + expected, + "analysis and Section replacements retain their slots" + ); + s.execute("inspect.draft", &json!({"clear": true})).unwrap(); + assert_eq!(status(&mut s).iter().map(|item| item.id).collect::>(), vec![Section]); + s.execute("inspect.zebra", &json!({})).unwrap(); + assert_eq!(status(&mut s).iter().map(|item| item.id).collect::>(), vec![Section, SurfaceAnalysis]); + s.execute("inspect.section", &json!({"clear": true})).unwrap(); + assert_eq!(status(&mut s).len(), 1); + s.execute("inspect.section", &json!({"plane": "XZ"})).unwrap(); + assert_eq!(status(&mut s).iter().map(|item| item.id).collect::>(), vec![SurfaceAnalysis, Section]); + } + } + + #[test] + fn status_items_continuity_shares_the_analysis_slot_and_failures_keep_effects() { + use crate::status_items::{StatusId, StatusSetting}; + let mut s = Session::default(); + boxed(&mut s, 10.0); + s.execute("inspect.zebra", &json!({})).unwrap(); + s.execute("inspect.section", &json!({"plane": "XY"})).unwrap(); + s.execute("inspect.continuity", &json!({"edges": [[5, 0, 0]]})).unwrap(); + assert_eq!(s.analysis, None); + let continuity = status(&mut s)[0].clone(); + assert_eq!(continuity.id, StatusId::SurfaceAnalysis); + assert_eq!(continuity.command, "inspect.continuity"); + assert_eq!(continuity.setting, StatusSetting::Continuity { edge_count: 1 }); + assert!(!continuity.has_key); + s.execute("inspect.continuity", &json!({"edges": [[0, 5, 0]], "add": true})).unwrap(); + assert_eq!(status(&mut s)[0].setting, StatusSetting::Continuity { edge_count: 2 }); + let before = status(&mut s); + let order = s.status_order.clone(); + let effects = (s.analysis, s.continuity.clone(), s.section, s.section_hatch, s.revision); + for (command, params) in [ + ("inspect.continuity", json!({"body": "missing"})), + ("inspect.continuity", json!({"samples": 2})), + ("inspect.draft", json!({"pull": [0, 0, 0]})), + ("inspect.zebra", json!({"stripes": -1})), + ("inspect.section", json!({"plane": {"normal": [0, 0, 0]}})), + ] { + assert!(s.execute(command, ¶ms).is_err()); + assert_eq!(status(&mut s), before); + assert_eq!(s.status_order, order); + assert_eq!((s.analysis, s.continuity.clone(), s.section, s.section_hatch, s.revision), effects); + } + s.execute("inspect.draft", &json!({})).unwrap(); + assert!(s.continuity.is_empty()); + let before = status(&mut s); + assert!(s.execute("inspect.continuity", &json!({"body": "missing"})).is_err()); + assert_eq!(status(&mut s), before, "failed Continuity activation keeps surface shading and ordering"); + s.execute(&continuity.clear.command, &serde_json::to_value(continuity.clear.params).unwrap()).unwrap(); + assert_eq!(status(&mut s)[0].command, "inspect.draft", "stale continuity clear keeps replacement"); + s.execute("inspect.continuity", &json!({"edges": [[5, 0, 0]]})).unwrap(); + let item = status(&mut s).remove(0); + s.execute(&item.clear.command, &serde_json::to_value(item.clear.params).unwrap()).unwrap(); + assert_eq!(status(&mut s).len(), 1); + assert_eq!(status(&mut s)[0].id, StatusId::Section); + } + + #[test] + fn status_items_queries_are_read_only_even_during_a_stale_live_drag() { + use std::sync::Arc; + let mut s = Session::default(); + for (command, params) in [ + ("sketch.create", json!({"plane":"XY"})), + ("sketch.rectangle.two_point", json!({"p0":[5,5],"p1":[25,20]})), + ("sketch.dimension", json!({"entities":["l1"],"value":20})), + ("sketch.dimension", json!({"entities":["l2"],"value":15})), + ("sketch.finish", json!({})), + ("solid.extrude", json!({"distance":5})), + ("inspect.zebra", json!({"stripes": 10.5})), + ("inspect.section", json!({"plane":"XY", "at": 2})), + ("sketch.edit", json!({"sketch":"Sketch1"})), + ] { + s.execute(command, ¶ms).unwrap(); + } + let effects = status(&mut s); + s.execute("sketch.drag", &json!({"entity":"l1.start","from":[5,5],"to":[4,5],"live":true})).unwrap(); + assert!(s.model.is_stale()); + let doc = s.doc.clone(); + let model = s.model.state(); + let selection = s.selection.clone(); + let before = (s.revision, s.undo.len(), s.redo.len(), s.is_dirty(), s.evaluations, s.status_order.clone()); + for _ in 0..3 { + assert_eq!(status(&mut s), effects); + } + assert!(Arc::ptr_eq(&doc, &s.doc)); + assert!(Arc::ptr_eq(&model, &s.model.state())); + assert!(s.model.is_stale()); + assert_eq!(s.selection, selection); + assert_eq!((s.revision, s.undo.len(), s.redo.len(), s.is_dirty(), s.evaluations, s.status_order.clone()), before); + assert!(s.scratch().status_items().is_empty(), "scratch sessions have no persistent view effects"); + s.execute("file.new", &json!({})).unwrap(); + assert!(status(&mut s).is_empty()); + assert!(s.status_order.is_empty(), "new design resets transient chronology"); + } + /// The edges of the first body of a continuity reply. fn edges(v: &Value) -> &Vec { v["bodies"][0]["edges"].as_array().unwrap_or_else(|| panic!("no edges in {v}")) @@ -376,7 +700,7 @@ mod tests { assert_eq!(v["summary"]["worst"], json!("sharp")); assert_eq!(s.continuity.len(), 12, "the seams are kept for the viewport"); assert_eq!(s.undo.len(), undo, "no undo step"); - assert_eq!(s.analysis, None, "the other analyses are left alone"); + assert_eq!(s.analysis, None, "only the Continuity analysis is active"); } /// A rolling-ball fillet is tangent to the faces it joins but not curvature continuous: its diff --git a/crates/engine/src/cmd/view_navigation.rs b/crates/engine/src/cmd/view_navigation.rs index cd74ba5cb..4e34336d1 100644 --- a/crates/engine/src/cmd/view_navigation.rs +++ b/crates/engine/src/cmd/view_navigation.rs @@ -32,8 +32,13 @@ struct RenderBrowserControls { } const RENDER_SELECT: TypedContract = TypedContract::new(); +const STATUS_ITEMS_CONTRACT: TypedContract = TypedContract::new(); pub static COMMANDS: &[CommandSpec] = &[ +CommandSpec::new("view.status_items", "Viewport Status Items", crate::checked!("view.status_items", status_items)) + .icon("list").noundo().doc_only() + .contract(&STATUS_ITEMS_CONTRACT).output(output_schema_for::) + .params("no parameters → {items}; persistent viewport effects, oldest slot first, with structured settings and executable clear requests; read-only, no model evaluation"), CommandSpec::new("view.fit", "Fit", fit) .icon("fit").key("F6").noundo().doc_only().params("no parameters → frame the active canvas or selection; display only"), CommandSpec::new("view.home", "Home view", home) @@ -270,6 +275,15 @@ fn navigation_bar(_s: &mut Session, p: &Value) -> Result { view_toggle(p, "view.navigation_bar", "visible") } +fn status_items(s: &mut Session, p: &Value) -> Result { + if !p.is_object() { + return Err(bad("view.status_items", "parameters must be an empty object")); + } + let _: crate::schema::view_navigation::StatusItemsParams = + serde_json::from_value(p.clone()).map_err(|e| bad("view.status_items", e.to_string()))?; + Ok(json!(crate::status_items::StatusItems { items: s.status_items() })) +} + fn render_focus(_s: &mut Session, p: &Value) -> Result { let request: RenderFocus = serde_json::from_value(p.clone()).map_err(|e| bad("view.render_focus", e.to_string()))?; Ok(json!(request)) diff --git a/crates/engine/src/control_pending.rs b/crates/engine/src/control_pending.rs index 86dcfa4b2..1579fc834 100644 --- a/crates/engine/src/control_pending.rs +++ b/crates/engine/src/control_pending.rs @@ -57,6 +57,7 @@ pub fn command_reads_only(id: &str) -> bool { || id.ends_with(".inspect") || id.ends_with(".list") || id == "document.revision" + || id == "view.status_items" || matches!(id, "document.inspect" | "engine.commands" | "render.status" | "render.backends" | "render.settings.get" | "file.slicers") } @@ -120,6 +121,7 @@ mod tests { ("ui.screenshot", json!({})), ("document.inspect", json!({"measure": true})), ("engine.execute", json!({"command": "sketch.inspect"})), + ("engine.execute", json!({"command": "view.status_items", "params": {}})), ("engine.execute", json!({"command": "inspect.measure"})), ("engine.execute", json!({"command": "model.edges", "params": {"body": "Body1"}})), ("engine.execute", json!({"command": "parameters.export", "params": {"format": "csv"}})), diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs index 797142b7e..52060a039 100644 --- a/crates/engine/src/lib.rs +++ b/crates/engine/src/lib.rs @@ -33,6 +33,7 @@ pub mod slicer_files; mod slicer_icon; pub mod slicers; pub mod snap; +pub mod status_items; pub mod timing; pub mod view; @@ -470,6 +471,10 @@ pub struct Session { /// The seams `inspect.continuity` last measured, for the viewport to shade. View state: not /// part of the design and not an undo step. pub continuity: Vec, + /// Transient activation order only; effect settings remain in their existing fields. + status_order: Vec, + single_surface_analysis: bool, + latest_analysis: Option, /// What is hidden or shown in the view (`browser.visibility`): saved with the design and an /// undo step of its own ([`Snapshot::visibility`]). A design brings its saved visibility when /// it opens (`Session::new`). @@ -649,6 +654,9 @@ impl Session { colored_components: None, analysis: None, continuity: Vec::new(), + status_order: Vec::new(), + single_surface_analysis: true, + latest_analysis: None, checkpoints: Vec::new(), next_checkpoint: 1, replacements: 0, @@ -672,6 +680,7 @@ impl Session { /// checkpoint keeps, not the replaced session's file path (docs/mcp.md). pub fn replace_design(&mut self, fresh: Session) { let auto_project = self.auto_project; + let single_surface_analysis = self.single_surface_analysis; let param_check = self.param_check; let easyprint_upload = self.easyprint_upload.take(); let render_viewport = self.render_viewport.clone(); @@ -685,6 +694,7 @@ impl Session { *self = fresh; self.crash_journal = crash_journal; self.auto_project = auto_project; + self.set_single_surface_analysis(single_surface_analysis); self.param_check = param_check; self.easyprint_upload = easyprint_upload; self.render_viewport = render_viewport; @@ -1493,6 +1503,9 @@ impl Session { colored_components: None, analysis: None, continuity: Vec::new(), + status_order: Vec::new(), + single_surface_analysis: self.single_surface_analysis, + latest_analysis: None, checkpoints: Vec::new(), next_checkpoint: 1, replacements: 0, diff --git a/crates/engine/src/schema/view_navigation.rs b/crates/engine/src/schema/view_navigation.rs index f3a7d7491..978e96760 100644 --- a/crates/engine/src/schema/view_navigation.rs +++ b/crates/engine/src/schema/view_navigation.rs @@ -39,6 +39,11 @@ pub struct RenderBrowser { pub open: bool, } +/// Empty input for the read-only viewport effect query. +#[derive(Debug, Deserialize, Serialize, JsonSchema)] +#[serde(deny_unknown_fields)] +pub struct StatusItemsParams {} + /// Show or hide the View angles readout under the orientation gizmo (#6032): the view's pitch, yaw /// and roll in degrees (the angles of `view.apply`'s camera, which takes them in radians) and Ortho /// or Persp for the projection. A display setting the app keeps: not saved with the design, not an diff --git a/crates/engine/src/schema/view_navigation_tests.rs b/crates/engine/src/schema/view_navigation_tests.rs index b8f7917ac..7ef13a61c 100644 --- a/crates/engine/src/schema/view_navigation_tests.rs +++ b/crates/engine/src/schema/view_navigation_tests.rs @@ -10,6 +10,54 @@ fn schemas_and_the_key_check_agree() { assert_keys(input_schema_for::(), &["enabled"]); } +#[test] +fn status_items_has_strict_empty_input_and_a_typed_output_schema() { + use crate::status_items::StatusItems; + assert_keys(input_schema_for::(), &[]); + let schema = output_schema_for::(); + let schema = schema.as_value(); + let mut s = Session::default(); + let described = s.execute("engine.describe", &json!({"command": "view.status_items"})).unwrap(); + assert_eq!(described["input"]["type"], "object"); + assert_eq!(described["input"]["additionalProperties"], false); + assert_eq!(described["output"]["properties"]["items"]["type"], "array"); + let spec = crate::find_command("view.status_items").unwrap(); + assert!(!spec.undoable && !spec.reads_model); + for mode in [ParamCheck::Off, ParamCheck::Warn, ParamCheck::Strict] { + s.param_check = mode; + for input in [json!({}), Value::Null] { + let reply = s.execute("view.status_items", &input).unwrap(); + assert!(conforms(schema, schema, &reply), "{reply} doesn't match {schema}"); + } + for input in [json!({"extra": true}), json!({"clear": true}), json!([]), json!(false), json!(42), json!("status")] { + assert!(s.execute("view.status_items", &input).is_err(), "accepted {input} in {mode:?}"); + } + } + for (command, params) in [ + ("inspect.zebra", json!({"stripes": 13.5})), + ("inspect.draft", json!({"angle": 4.5})), + ("inspect.environment_map", json!({})), + ("inspect.accessibility", json!({})), + ("inspect.curvature_map", json!({"radius": 2})), + ("inspect.section", json!({"plane": "XY", "hatch": false})), + ] { + s.execute(command, ¶ms).unwrap(); + let reply = s.execute("view.status_items", &json!({})).unwrap(); + assert!(conforms(schema, schema, &reply), "{reply} doesn't match {schema}"); + let typed: StatusItems = serde_json::from_value(reply.clone()).unwrap(); + assert_eq!(serde_json::to_value(typed).unwrap(), reply); + } + s.set_single_surface_analysis(false); + s.execute("solid.box", &json!({"length":10,"width":10,"height":10})).unwrap(); + s.execute("inspect.continuity", &json!({"edges":[[5,0,0]],"samples":5})).unwrap(); + let reply = s.execute("view.status_items", &json!({})).unwrap(); + assert!(conforms(schema, schema, &reply), "legacy reply {reply} doesn't match {schema}"); + assert_eq!(reply["items"].as_array().unwrap().len(), 3); + assert!(reply["items"].as_array().unwrap().iter().any(|item| item["id"] == "continuity")); + let typed: StatusItems = serde_json::from_value(reply.clone()).unwrap(); + assert_eq!(serde_json::to_value(typed).unwrap(), reply); +} + #[test] fn strict_keeps_todays_errors() { assert_strict_keeps_todays_errors(&[ diff --git a/crates/engine/src/status_items.rs b/crates/engine/src/status_items.rs new file mode 100644 index 000000000..e95a7cb5f --- /dev/null +++ b/crates/engine/src/status_items.rs @@ -0,0 +1,233 @@ +//! A read-only declaration of persistent viewport effects. Settings remain in the session's +//! existing effect fields; only activation order is recorded separately, never in a design. + +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; + +use crate::{Session, SurfaceAnalysis}; + +/// Stable identity of an effect slot, retained when its analysis is replaced. +#[derive(Clone, Copy, Debug, Deserialize, Eq, JsonSchema, PartialEq, Serialize)] +#[serde(rename_all = "snake_case")] +pub enum StatusId { + SurfaceAnalysis, + /// Independent Continuity slot when the compatibility policy is enabled. + Continuity, + Section, +} + +#[derive(Clone, Copy, Debug, Deserialize, Eq, JsonSchema, PartialEq, Serialize)] +#[serde(rename_all = "snake_case")] +pub enum StatusKind { + Mode, + Result, + Attention, +} + +/// Structured settings, without unit formatting or translated text. +#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Serialize)] +#[serde(tag = "type", rename_all = "snake_case", deny_unknown_fields)] +pub enum StatusSetting { + Zebra { + stripes: f64, + }, + Draft { + /// Normalised pull direction. + pull: [f64; 3], + /// The stored Draft threshold is in degrees. + angle_deg: f64, + }, + Environment, + Accessibility { + /// Normalised direction from which the tool approaches. + direction: [f64; 3], + }, + Curvature { + radius_mm: f64, + }, + Continuity { + /// Number of persistent seam records currently shaded. + edge_count: usize, + }, + Section { + origin_mm: [f64; 3], + /// Normalised world-space plane normal. + normal: [f64; 3], + hatch: bool, + }, +} + +/// An executable request that ends this effect, through the same command as other clients. +#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Serialize)] +#[serde(deny_unknown_fields)] +pub struct StatusClear { + pub command: String, + pub params: StatusClearParams, +} + +#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Serialize)] +#[serde(deny_unknown_fields)] +pub struct StatusClearParams { + pub clear: bool, +} + +#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Serialize)] +#[serde(deny_unknown_fields)] +pub struct StatusItem { + pub id: StatusId, + pub kind: StatusKind, + /// Source command ID, whose catalog label consumers can translate. + pub command: String, + pub setting: StatusSetting, + pub has_key: bool, + pub clear: StatusClear, +} + +#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Serialize)] +#[serde(deny_unknown_fields)] +pub struct StatusItems { + /// Oldest active slot first; replacing an analysis retains its position. + pub items: Vec, +} + +impl Session { + /// Whether shading and Continuity share one slot (the default). This is session + /// configuration, never design data; SDK clients may choose the legacy independent policy. + pub fn single_surface_analysis(&self) -> bool { + self.single_surface_analysis + } + + /// Change the analysis policy without changing the design or undo history. Enabling a + /// single slot keeps the latest successful analysis activation/replacement and retains the + /// oldest analysis-group position relative to Section. Queries never perform this transition. + pub fn set_single_surface_analysis(&mut self, single: bool) { + if self.single_surface_analysis == single { + return; + } + let before = self.status_items(); + if single && self.analysis.is_some() && !self.continuity.is_empty() { + if self.latest_analysis == Some(StatusId::Continuity) { + self.analysis = None; + } else { + self.continuity.clear(); + } + } + self.single_surface_analysis = single; + self.status_order.clear(); + for item in &before { + let id = match item.id { + StatusId::SurfaceAnalysis | StatusId::Continuity if single => StatusId::SurfaceAnalysis, + StatusId::SurfaceAnalysis if self.analysis.is_none() => StatusId::Continuity, + id => id, + }; + let active = match id { + StatusId::SurfaceAnalysis => self.analysis.is_some() || (single && !self.continuity.is_empty()), + StatusId::Continuity => !self.continuity.is_empty(), + StatusId::Section => self.section.is_some(), + }; + self.status_slot(id, active); + } + if self.status_items() != before { + self.revision += 1; + } + } + + /// After a successful activation, or a clear (`None`), reconcile only chronology and the + /// explicitly configured sharing policy. No duplicate effect settings are kept here. + pub(crate) fn status_analysis_changed(&mut self, activated: Option) { + if let Some(source) = activated + && self.single_surface_analysis + { + match source { + StatusId::SurfaceAnalysis => self.continuity.clear(), + StatusId::Continuity => self.analysis = None, + StatusId::Section => {} + } + } + // A successful Continuity measurement may find only open boundaries and no seams. + // An ended/empty effect cannot become the winning source on the next policy change. + let shading = self.analysis.is_some(); + let continuity = !self.continuity.is_empty(); + let active = |source: &StatusId| match source { + StatusId::SurfaceAnalysis => shading, + StatusId::Continuity => continuity, + StatusId::Section => false, + }; + let remaining = if shading { + Some(StatusId::SurfaceAnalysis) + } else if continuity { + Some(StatusId::Continuity) + } else { + None + }; + self.latest_analysis = activated.filter(active).or(self.latest_analysis.filter(active)).or(remaining); + self.status_slot(StatusId::SurfaceAnalysis, self.analysis.is_some() || (self.single_surface_analysis && !self.continuity.is_empty())); + self.status_slot(StatusId::Continuity, !self.single_surface_analysis && !self.continuity.is_empty()); + } + + /// Current effects, derived without evaluating the model or changing any session state. + pub fn status_items(&self) -> Vec { + let analysis = self + .analysis + .map(|a| match a { + SurfaceAnalysis::Zebra { stripes } => ("inspect.zebra", StatusSetting::Zebra { stripes }, false), + SurfaceAnalysis::Draft { pull, angle } => ("inspect.draft", StatusSetting::Draft { pull: pull.into(), angle_deg: angle }, true), + SurfaceAnalysis::Environment => ("inspect.environment_map", StatusSetting::Environment, false), + SurfaceAnalysis::Access { dir } => ("inspect.accessibility", StatusSetting::Accessibility { direction: dir.into() }, true), + SurfaceAnalysis::Curvature { radius } => ("inspect.curvature_map", StatusSetting::Curvature { radius_mm: radius }, true), + }) + .or_else(|| { + (self.single_surface_analysis && !self.continuity.is_empty()).then_some(( + "inspect.continuity", + StatusSetting::Continuity { edge_count: self.continuity.len() }, + false, + )) + }); + let analysis = analysis.map(|(command, setting, has_key)| item(StatusId::SurfaceAnalysis, command, setting, has_key)); + let continuity = (!self.single_surface_analysis && !self.continuity.is_empty()) + .then(|| item(StatusId::Continuity, "inspect.continuity", StatusSetting::Continuity { edge_count: self.continuity.len() }, false)); + let section = self.section.map(|(origin, normal)| { + item( + StatusId::Section, + "inspect.section", + StatusSetting::Section { origin_mm: origin.into(), normal: normal.into(), hatch: self.section_hatch }, + false, + ) + }); + // Public effect fields can also be populated by embedders without command chronology. + // Include those effects after recorded slots, without inventing or storing timestamps. + let mut items = Vec::new(); + for id in self.status_order.iter().chain([StatusId::SurfaceAnalysis, StatusId::Continuity, StatusId::Section].iter()) { + let effect = match id { + StatusId::SurfaceAnalysis => &analysis, + StatusId::Continuity => &continuity, + StatusId::Section => §ion, + }; + if let Some(effect) = effect + && !items.iter().any(|item: &StatusItem| item.id == *id) + { + items.push(effect.clone()); + } + } + items + } + + pub(crate) fn status_slot(&mut self, id: StatusId, active: bool) { + if !active { + self.status_order.retain(|slot| *slot != id); + } else if !self.status_order.contains(&id) { + self.status_order.push(id); + } + } +} + +fn item(id: StatusId, command: &str, setting: StatusSetting, has_key: bool) -> StatusItem { + StatusItem { + id, + kind: StatusKind::Mode, + command: command.into(), + setting, + has_key, + clear: StatusClear { command: command.into(), params: StatusClearParams { clear: true } }, + } +} diff --git a/crates/ui-egui/src/documents.rs b/crates/ui-egui/src/documents.rs index ca041f85c..cb41fdfd3 100644 --- a/crates/ui-egui/src/documents.rs +++ b/crates/ui-egui/src/documents.rs @@ -182,6 +182,7 @@ fn swap_in(app: &mut SolveApp, mut slot: DocSlot) -> DocSlot { app.tree.picked_components.clear(); // Preferences the session holds go with the user, not the tab (#680). app.session.auto_project = out.session.auto_project; + app.session.set_single_surface_analysis(app.preferences.single_surface_analysis); // Views cache by revision: the incoming design must not look unchanged. let before = app.session.revision; app.session.invalidate_view(out_rev); diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs index 1680d5080..eb34a618d 100644 --- a/crates/ui-egui/src/lib.rs +++ b/crates/ui-egui/src/lib.rs @@ -1014,6 +1014,7 @@ impl SolveApp { self.preferences = p; } // Before a design given at start opens: its paths follow the network preferences. + prefs::sync_surface_analysis(self); prefs::apply_network(&self.preferences); // Before a file given at start opens: the largest file it may be (#4086). prefs::apply_file_limits(&self.preferences); diff --git a/crates/ui-egui/src/prefs.rs b/crates/ui-egui/src/prefs.rs index be7ae1bc0..4d3c1eb09 100644 --- a/crates/ui-egui/src/prefs.rs +++ b/crates/ui-egui/src/prefs.rs @@ -920,6 +920,8 @@ preference_settings! { nav_bridge_port: u16 = 8765, PAGE_NAVIGATION; /// Anti-aliasing samples (applies on restart). msaa: u32 = 4, PAGE_GRAPHICS; + /// Share shading and Continuity; false preserves their independent legacy behavior. + single_surface_analysis: bool = true, PAGE_GRAPHICS => check_id("prefs.single_surface_analysis"); /// Linux: the window system the app opens with at its next start (#3083): `auto` (XWayland /// whenever there is an X display, native Wayland on niri), `wayland` or `x11`. window_system: String = "auto".into(), PAGE_GRAPHICS; @@ -1455,6 +1457,7 @@ impl Snapshot { // Update bookkeeping isn't a setting: a check that finished while the dialog was open stays. let update = std::mem::take(&mut app.preferences.update); app.preferences = self.prefs; + sync_surface_analysis(app); app.preferences.update = update; if units_changed { default_units_changed(app); @@ -1746,6 +1749,7 @@ fn defaults(app: &mut SolveApp, page: usize) { let (msaa, window_system, adapter) = (app.preferences.msaa, app.preferences.window_system.clone(), app.preferences.graphics_adapter.clone()); let units = app.preferences.default_units.clone(); reset_preferences(&mut app.preferences, page); + sync_surface_analysis(app); if app.preferences.default_units != units { default_units_changed(app); } @@ -1784,6 +1788,7 @@ fn defaults(app: &mut SolveApp, page: usize) { /// Settings that follow the preferences every frame: the theme when it follows the system, and /// the interface scale. pub fn apply(app: &mut SolveApp, ctx: &egui::Context) { + sync_surface_analysis(app); apply_network(&app.preferences); apply_file_limits(&app.preferences); // The viewport's display quality (an unknown saved value draws at Normal). @@ -1835,6 +1840,15 @@ pub fn apply(app: &mut SolveApp, ctx: &egui::Context) { } } +/// The user's analysis policy applies immediately to every open design, without document edits. +pub(crate) fn sync_surface_analysis(app: &mut SolveApp) { + let single = app.preferences.single_surface_analysis; + app.session.set_single_surface_analysis(single); + for slot in app.docs.background_mut() { + slot.session.set_single_surface_analysis(single); + } +} + /// The network locations the files a design names may be on follow the preferences. pub fn apply_network(p: &Prefs) { solidcraft_engine::io::vfs::set_network_policy(solidcraft_engine::io::vfs::NetworkPolicy { @@ -3305,6 +3319,7 @@ pub fn set(app: &mut SolveApp, p: &serde_json::Value) -> Result solidcraft_engine::Session { + let mut s = solidcraft_engine::Session::default(); + s.set_single_surface_analysis(false); + s.execute("solid.box", &json!({"length":10,"width":10,"height":10})).unwrap(); + s.execute("inspect.zebra", &json!({"stripes":14.5})).unwrap(); + s.execute("inspect.section", &json!({"plane":"XY"})).unwrap(); + s.execute("inspect.continuity", &json!({"edges":[[5,0,0]],"samples":5})).unwrap(); + s.mark_saved(); + s + } + let mut app = SolveApp::new(Default::default(), Default::default()); + super::set(&mut app, &json!({"single_surface_analysis":false})).unwrap(); + app.session = legacy_session(); + crate::documents::open_tab(&mut app, legacy_session()).unwrap(); + assert_eq!(app.docs.count(), 2); + assert!(!app.session.single_surface_analysis()); + assert_eq!(app.session.status_items().len(), 3); + assert!(app.docs.background().all(|s| !s.single_surface_analysis() && s.status_items().len() == 3)); + let doc = app.session.doc.clone(); + let undo = app.session.undo.len(); + let declarations = app.session.status_items(); + let revision = app.session.revision; + app.preferences.single_surface_analysis = true; + app.run("view.status_items", json!({})).unwrap(); + assert!(!app.session.single_surface_analysis(), "a raw query cannot apply a desynchronised preference"); + assert_eq!(app.session.status_items(), declarations); + assert_eq!(app.session.revision, revision); + assert!(app.session.analysis.is_some() && !app.session.continuity.is_empty()); + assert!(app.docs.background().all(|s| !s.single_surface_analysis() && s.status_items().len() == 3)); + app.preferences.single_surface_analysis = false; + super::defaults(&mut app, super::PAGE_GENERAL); + assert!(!app.session.single_surface_analysis(), "another page leaves the policy alone"); + super::defaults(&mut app, super::PAGE_GRAPHICS); + for s in std::iter::once(&app.session).chain(app.docs.background()) { + assert!(s.single_surface_analysis()); + assert_eq!(s.analysis, None, "latest Continuity wins on reset"); + assert_eq!(s.continuity.len(), 1); + assert_eq!(s.status_items().len(), 2); + assert_eq!(s.status_items()[0].command, "inspect.continuity"); + assert!(s.section.is_some()); + assert!(!s.is_dirty()); + } + assert!(std::sync::Arc::ptr_eq(&doc, &app.session.doc)); + assert_eq!(app.session.undo.len(), undo); + // Query entry never applies a pending policy change; the explicit frame hook does. + app.preferences.single_surface_analysis = false; + app.run("view.status_items", json!({})).unwrap(); + assert!(app.session.single_surface_analysis()); + super::apply(&mut app, &egui::Context::default()); + assert!(!app.session.single_surface_analysis()); + assert!(app.docs.background().all(|s| !s.single_surface_analysis())); + app.preferences.single_surface_analysis = true; + super::apply(&mut app, &egui::Context::default()); + assert!(app.session.single_surface_analysis()); + assert!(app.docs.background().all(|s| s.single_surface_analysis())); + } + #[test] fn cosmetic_threads_default_off_and_follow_preferences_transactions() { assert!(!Prefs::default().cosmetic_threads); diff --git a/crates/ui-egui/src/prefs/graphics.rs b/crates/ui-egui/src/prefs/graphics.rs index c6d65f67f..92b82c783 100644 --- a/crates/ui-egui/src/prefs/graphics.rs +++ b/crates/ui-egui/src/prefs/graphics.rs @@ -151,6 +151,12 @@ pub(super) fn show(app: &mut SolveApp, ui: &mut egui::Ui) { ui_kit::text(ui, app.tr("prefs.contact_shading_note"), ui_kit::Text::Hint("ao")); }); ui_kit::settings_section(ui, "viewport", app.tr("prefs.viewport"), |ui| { + let analysis_policy = setting::single_surface_analysis(app, ui).on_hover_text(app.tr("prefs.single_surface_analysis_help")); + crate::scenario::publish_target("prefs:single_surface_analysis", analysis_policy.rect); + if analysis_policy.changed() { + sync_surface_analysis(app); + } + let response = ui_kit::checkbox(ui, app.tr("ui.cosmetic_thread_markings"), &mut app.preferences.cosmetic_threads) .on_hover_text(app.tr("ui.cosmetic_thread_markings_help")); crate::scenario::publish_handle("prefs:cosmetic_threads", response.rect.center()); diff --git a/docs/control-protocol.md b/docs/control-protocol.md index 1db7cd15a..fcd43615b 100644 --- a/docs/control-protocol.md +++ b/docs/control-protocol.md @@ -182,6 +182,41 @@ changed it meanwhile. Compare both values, and export when either differs from t answer. The same answer comes from `engine.execute` `document.revision` (and so from scripts and MCP `execute`), which waits its turn behind design changes like any command. +`engine.execute` with `view.status_items` and `{}` reads the persistent viewport effects without +evaluating the model or changing the design, undo history or view revision. It returns +`{items: [...]}` in oldest activation order. Each item contains a stable slot `id` +(`surface_analysis`, `section`, or the legacy independent `continuity`), `kind`, source `command`, structured `setting`, `has_key` +and a `clear: {command, params}` request that can be executed unchanged. Settings retain numbers: +lengths use millimetres, Draft's `angle_deg` uses degrees, directions are normalised, and +Continuity's `edge_count` counts the seams currently kept for shading. Labels and units are +formatted by clients. `engine.describe {command: "view.status_items"}` exposes both schemas. + +By default, surface analyses, including Continuity, share one slot; successful replacement keeps that +slot's position and ends the previous analysis. Section stacks independently. Clearing and +re-enabling a slot makes it newest. Ordering metadata belongs only to the running session; +effects and ordering are not saved in the design. Existing analysis clear semantics apply: +any surface-shading command with `{clear: true}` clears the active surface shading, whereas +Continuity clears its seam records. Section clear never clears an analysis. + +The standard **Graphics → Viewport → Use a single surface analysis** preference is +`single_surface_analysis` (default `true`). `ui.prefs {"single_surface_analysis": false}` restores +the legacy behavior: surface shading and Continuity remain independently active and clearable, +and `view.status_items` faithfully lists both, using a separate stable `continuity` ID. Together +with Section there are at most three slots. Turning the preference back on keeps the last +successfully started or changed analysis at the oldest analysis-group position beside Section. +Queries never normalize state. Graphics Restore Defaults restores `true`; other page resets +leave it alone. It applies immediately to all open designs without document edits or undo. +Cancel restores the opening preference value, but does not restart an analysis already stopped +by switching to single mode. Run that analysis again to restore coexistence after cancelling. +Successful Continuity measurements with no seams create no item: legacy mode keeps existing +surface shading; single mode ends the previous analysis as for other successful replacements. + +Headless SDK clients use `Session::set_single_surface_analysis(bool)` and +`Session::single_surface_analysis()`. Configuration survives scratch/new/open session lifecycle; +effects and chronology still follow their existing transient lifecycle. The policy is an +application preference/session setting, never saved design-format data. Policy changes update +the view revision only when visible effects or their declarations change. + A client need not ask again and again: after `control.subscribe` on its connection, the app sends it a line whenever the active design changes (#6985):