SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
History: delete a folder with its features, and suppress a whole folder (#7219) (#7220)
tr1pp404e4e72ea137
diff --git a/assets/locales/pending/history-folder-actions.json b/assets/locales/pending/history-folder-actions.jsonnew file mode 100644index 0000000000..cd01ce32eb--- /dev/null+++ b/assets/locales/pending/history-folder-actions.json@@ -0,0 +1,51 @@+{+ "en": {+ "Delete Folders and Features…": "Delete Folders and Features…",+ "Suppress Selected Folders": "Suppress Selected Folders",+ "Unsuppress Selected Folders": "Unsuppress Selected Folders",+ "timeline.delete_folders_with_features_tip": "Delete the folders with every feature in them and their nested folders",+ "timeline.suppress_folders_tip": "Suppress or unsuppress every feature in the folders and their nested folders"+ },+ "de": {+ "Delete Folders and Features…": "Ordner mit Features löschen…",+ "Suppress Selected Folders": "Ausgewählte Ordner unterdrücken",+ "Unsuppress Selected Folders": "Unterdrückung der ausgewählten Ordner aufheben",+ "timeline.delete_folders_with_features_tip": "Löscht die Ordner mit allen Features darin und ihren Unterordnern",+ "timeline.suppress_folders_tip": "Unterdrückt alle Features in den Ordnern und ihren Unterordnern oder hebt die Unterdrückung auf"+ },+ "ar": {+ "Delete Folders and Features…": "حذف المجلدات مع ميزاتها…",+ "Suppress Selected Folders": "تعطيل المجلدات المحددة",+ "Unsuppress Selected Folders": "إلغاء تعطيل المجلدات المحددة",+ "timeline.delete_folders_with_features_tip": "حذف المجلدات مع كل الميزات التي فيها والمجلدات المتداخلة فيها",+ "timeline.suppress_folders_tip": "تعطيل كل الميزات في المجلدات والمجلدات المتداخلة فيها أو إلغاء تعطيلها"+ },+ "he": {+ "Delete Folders and Features…": "מחיקת תיקיות עם הפיצ'רים שבהן…",+ "Suppress Selected Folders": "השבתת התיקיות שנבחרו",+ "Unsuppress Selected Folders": "ביטול השבתת התיקיות שנבחרו",+ "timeline.delete_folders_with_features_tip": "מחיקת התיקיות עם כל הפיצ'רים שבהן והתיקיות המקוננות בהן",+ "timeline.suppress_folders_tip": "השבתה או ביטול השבתה של כל הפיצ'רים בתיקיות ובתיקיות המקוננות בהן"+ },+ "ja": {+ "Delete Folders and Features…": "フォルダーとフィーチャーを削除…",+ "Suppress Selected Folders": "選択したフォルダーを抑制",+ "Unsuppress Selected Folders": "選択したフォルダーの抑制を解除",+ "timeline.delete_folders_with_features_tip": "フォルダーを、中のすべてのフィーチャーと入れ子のフォルダーごと削除します",+ "timeline.suppress_folders_tip": "フォルダーと入れ子のフォルダー内のすべてのフィーチャーを抑制、または抑制を解除します"+ },+ "vi": {+ "Delete Folders and Features…": "Xóa thư mục cùng các tính năng…",+ "Suppress Selected Folders": "Bỏ kích hoạt các thư mục đã chọn",+ "Unsuppress Selected Folders": "Kích hoạt lại các thư mục đã chọn",+ "timeline.delete_folders_with_features_tip": "Xóa các thư mục cùng mọi tính năng trong đó và các thư mục lồng bên trong",+ "timeline.suppress_folders_tip": "Bỏ kích hoạt hoặc kích hoạt lại mọi tính năng trong các thư mục và các thư mục lồng bên trong"+ },+ "zh": {+ "Delete Folders and Features…": "删除文件夹及其特征…",+ "Suppress Selected Folders": "抑制所选文件夹",+ "Unsuppress Selected Folders": "取消抑制所选文件夹",+ "timeline.delete_folders_with_features_tip": "删除文件夹及其中的所有特征和嵌套文件夹",+ "timeline.suppress_folders_tip": "抑制或取消抑制文件夹及其嵌套文件夹中的所有特征"+ }+}diff --git a/crates/engine/src/cmd/edit.rs b/crates/engine/src/cmd/edit.rsindex 9c677d1928..00d4871d66 100644--- a/crates/engine/src/cmd/edit.rs+++ b/crates/engine/src/cmd/edit.rs@@ -25,7 +25,7 @@ pub static COMMANDS: &[CommandSpec] = &[.at("SOLID", "MODIFY").icon("delete").key("Delete")- .params("feature: id|name | features: [id|name] (one undo step; a sketch takes its dependent features with it) → deleted: [ids]; failing?: [{feature, error}] (later features that worked and now fail)"),+ .params("feature: id|name | features: [id|name] | groups: [timeline folder ids] (a folder goes with all its features and nested folders; one undo step; a sketch takes its dependent features with it) → deleted: [ids]; groups?: [folder ids deleted]; failing?: [{feature, error}] (later features that worked and now fail)"),CommandSpec::new("timeline.rename", "Rename", rename).icon("rename").params("feature: id|name, name (references to it follow)"),CommandSpec::new("timeline.group", "New Feature Folder", group).icon("folder")@@ -55,8 +55,9 @@ pub static COMMANDS: &[CommandSpec] = &[.noundo().params("feature: id|name → features deleted with it, and features that would fail without it"),CommandSpec::new("timeline.suppress", "Suppress Feature", suppress).icon("suppress").params(- "feature: id|name | features: [id|name] (one undo step), suppressed?: bool (default toggles: several features are all \- suppressed unless all of them already are, then all are unsuppressed) → feature: id (or features: [ids]), suppressed",+ "feature: id|name | features: [id|name] | groups: [timeline folder ids] (every feature in those folders and their nested \+ folders; one undo step), suppressed?: bool (default toggles: several features are all \+ suppressed unless all of them already are, then all are unsuppressed) → feature: id (or features: [ids]; groups: [ids] when given), suppressed",),CommandSpec::new("timeline.edit", "Edit Feature", edit_feature).icon("edit").params("feature: id|name, set: {fields to change, merged into the feature's definition as timeline.inspect returns it, \@@ -162,9 +163,13 @@ fn delete(s: &mut Session, p: &Value) -> Result<Value> {_ => String::new(),});}- if keys.is_empty() {- return Err(bad(cmd, "`features` must list features"));+ let groups = group_ids(s, p, false, cmd)?;+ if keys.is_empty() && groups.is_empty() {+ return Err(bad(cmd, "`features` must list features, or `groups` timeline folders"));}+ // A folder goes with its features and nested folders, its features in timeline order.+ let (folders, contents) = group_tree(&s.doc, &groups);+ keys.extend(s.doc.features.iter().filter(|f| contents.contains(&f.id)).map(|f| f.id.to_string()));// Features that work now; any of them failing after the delete is reported (a later// feature that names a deleted body, #267).let worked: std::collections::BTreeSet<u64> = s.model.results.iter().filter(|r| r.error.is_none() && !r.skipped).map(|r| r.id).collect();@@ -178,6 +183,9 @@ fn delete(s: &mut Session, p: &Value) -> Result<Value> {};gone.extend(s.doc_mut().delete_feature(id)?);}+ if !folders.is_empty() {+ s.doc_mut().timeline_groups.retain(|group| !folders.contains(&group.id));+ }if s.active_sketch.is_some_and(|a| gone.contains(&a)) {s.active_sketch = None;}@@ -194,10 +202,14 @@ fn delete(s: &mut Session, p: &Value) -> Result<Value> {.filter(|r| worked.contains(&r.id)).filter_map(|r| r.error.as_ref().map(|e| json!({"feature": r.name, "error": e}))).collect();- if failing.is_empty() {- return Ok(json!({"deleted": gone}));+ let mut out = json!({"deleted": gone});+ if !folders.is_empty() {+ out["groups"] = json!(folders);}- Ok(json!({"deleted": gone, "failing": failing}))+ if !failing.is_empty() {+ out["failing"] = json!(failing);+ }+ Ok(out)}fn rename(s: &mut Session, p: &Value) -> Result<Value> {@@ -312,6 +324,11 @@ fn group_move_would_cycle(s: &Session, target: u64, sources: &[u64]) -> bool {}fn group_feature_ids(doc: &solidcraft_doc::Document, roots: &[u64]) -> std::collections::BTreeSet<u64> {+ group_tree(doc, roots).1+}++/// The timeline folders `roots` and every folder nested in them, and the features they hold.+fn group_tree(doc: &solidcraft_doc::Document, roots: &[u64]) -> (std::collections::BTreeSet<u64>, std::collections::BTreeSet<u64>) {let by_id: std::collections::BTreeMap<u64, &solidcraft_doc::TimelineGroup> = doc.timeline_groups.iter().map(|group| (group.id, group)).collect();let mut children = std::collections::BTreeMap::<u64, Vec<u64>>::new();for group in &doc.timeline_groups {@@ -331,7 +348,7 @@ fn group_feature_ids(doc: &solidcraft_doc::Document, roots: &[u64]) -> std::collpending.extend(children.get(&id).into_iter().flatten().copied());}}- features+ (visited, features)}fn sort_group_features(doc: &mut solidcraft_doc::Document) {@@ -620,7 +637,15 @@ fn counted_names_from(s: &Session, ids: &[u64]) -> Vec<(u64, Vec<String>)> {fn suppress(s: &mut Session, p: &Value) -> Result<Value> {let cmd = "timeline.suppress";- let ids = feature_ids(s, p, cmd)?;+ let groups = group_ids(s, p, false, cmd)?;+ let named = |key: &str| p.get(key).is_some_and(|v| !v.is_null());+ let mut ids = if groups.is_empty() || named("feature") || named("features") { feature_ids(s, p, cmd)? } else { Vec::new() };+ let contents = group_feature_ids(&s.doc, &groups);+ let more: Vec<u64> = s.doc.features.iter().map(|f| f.id).filter(|id| contents.contains(id) && !ids.contains(id)).collect();+ ids.extend(more);+ if ids.is_empty() {+ return Err(bad(cmd, "the timeline folders hold no features"));+ }let want = match bool_(p, "suppressed") {Some(b) => b,None if p.get("suppressed").is_some_and(|v| !v.is_null()) => return Err(bad(cmd, "`suppressed` must be true or false")),@@ -640,8 +665,9 @@ fn suppress(s: &mut Session, p: &Value) -> Result<Value> {f.suppressed = want;}match ids.as_slice() {- [id] if p.get("features").is_none_or(Value::is_null) => Ok(json!({"feature": id, "suppressed": want})),- _ => Ok(json!({"features": ids, "suppressed": want})),+ [id] if groups.is_empty() && p.get("features").is_none_or(Value::is_null) => Ok(json!({"feature": id, "suppressed": want})),+ _ if groups.is_empty() => Ok(json!({"features": ids, "suppressed": want})),+ _ => Ok(json!({"features": ids, "groups": groups, "suppressed": want})),}}diff --git a/crates/engine/src/cmd/edit_tests.rs b/crates/engine/src/cmd/edit_tests.rsindex ad75da6378..7c63ea7878 100644--- a/crates/engine/src/cmd/edit_tests.rs+++ b/crates/engine/src/cmd/edit_tests.rs@@ -680,6 +680,108 @@ fn timeline_folders_can_nest_and_reject_cycles() {assert_eq!(s.doc.timeline_groups.iter().find(|group| group.id == child).unwrap().parent, None, "deleting a folder promotes its children");}+/// Four separate boxes, `First`…`Fourth`, for the timeline folder tests.+fn four_boxes() -> Session {+ let mut s = Session::default();+ for (i, name) in ["First", "Second", "Third", "Fourth"].into_iter().enumerate() {+ let corner = [20 * i, 0, 0];+ run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": corner, "operation": "new_body", "name": name}));+ }+ s+}++fn feature_names(s: &Session) -> Vec<String> {+ s.doc.features.iter().map(|feature| feature.name.clone()).collect()+}++/// `timeline.delete {groups}` deletes a folder with its features and nested folders in one undo+/// step; other folders and features stay, and `timeline.ungroup` still keeps the features (#7219).+#[test]+fn timeline_delete_takes_a_folder_with_its_features_and_nested_folders() {+ let mut s = four_boxes();+ let outer = run(&mut s, "timeline.group", json!({"name": "Outer", "features": ["Second"]}))["group"].as_u64().unwrap();+ let inner = run(&mut s, "timeline.group", json!({"name": "Inner", "features": ["Third"], "parent": outer}))["group"].as_u64().unwrap();+ let keep = run(&mut s, "timeline.group", json!({"name": "Keep", "features": ["Fourth"]}))["group"].as_u64().unwrap();+ let before = s.doc.clone();++ let out = run(&mut s, "timeline.delete", json!({"groups": [outer]}));+ assert_eq!(feature_names(&s), ["First", "Fourth"]);+ assert_eq!(out["groups"], json!([outer, inner]), "{out}");+ assert_eq!(s.doc.timeline_groups.iter().map(|group| group.id).collect::<Vec<_>>(), [keep], "the nested folder goes too");+ assert_eq!(s.model.state().bodies.len(), 2);+ let reopened = solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap();+ assert_eq!(reopened.timeline_groups, s.doc.timeline_groups);++ run(&mut s, "edit.undo", json!({}));+ assert_eq!(s.doc.features, before.features, "one undo step brings the features back");+ assert_eq!(s.doc.timeline_groups, before.timeline_groups, "and the folders, nested as they were");+ run(&mut s, "edit.redo", json!({}));+ assert_eq!(feature_names(&s), ["First", "Fourth"]);+ run(&mut s, "edit.undo", json!({}));++ // A folder and a feature outside it in one delete; an empty folder goes on its own.+ run(&mut s, "timeline.delete", json!({"groups": [inner], "features": ["First"]}));+ assert_eq!(feature_names(&s), ["Second", "Fourth"]);+ assert_eq!(s.doc.timeline_groups.iter().map(|group| group.name.as_str()).collect::<Vec<_>>(), ["Outer", "Keep"]);+ let empty = run(&mut s, "timeline.group", json!({"name": "Empty"}))["group"].as_u64().unwrap();+ assert_eq!(run(&mut s, "timeline.delete", json!({"groups": [empty]}))["deleted"], json!([]));+ assert!(!s.doc.timeline_groups.iter().any(|group| group.id == empty));++ let before = s.doc.clone();+ for bad in [json!({"groups": [999_999]}), json!({"groups": ["Outer"]}), json!({"groups": 3}), json!({"groups": []})] {+ assert!(s.execute("timeline.delete", &bad).is_err(), "{bad}");+ assert_eq!(s.doc, before, "{bad}: a refused delete changes nothing");+ }+}++/// `timeline.suppress {groups}` suppresses every feature of a folder and its nested folders in+/// one undo step, toggles like several features do, and works with the marker inside the+/// folder (#7219).+#[test]+fn timeline_suppress_takes_a_folder_with_its_nested_folders() {+ let mut s = four_boxes();+ let outer = run(&mut s, "timeline.group", json!({"name": "Outer", "features": ["Second"]}))["group"].as_u64().unwrap();+ run(&mut s, "timeline.group", json!({"name": "Inner", "features": ["Third"], "parent": outer}));+ let suppressed = |s: &Session| s.doc.features.iter().filter(|feature| feature.suppressed).map(|feature| feature.name.clone()).collect::<Vec<_>>();++ let out = run(&mut s, "timeline.suppress", json!({"groups": [outer]}));+ assert_eq!(out["suppressed"], true);+ assert_eq!(out["groups"], json!([outer]));+ assert_eq!(suppressed(&s), ["Second", "Third"]);+ assert_eq!(s.model.state().bodies.len(), 2);+ let reopened = solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap();+ assert_eq!(reopened.features, s.doc.features);+ run(&mut s, "edit.undo", json!({}));+ assert!(suppressed(&s).is_empty(), "one undo step");+ run(&mut s, "edit.redo", json!({}));+ assert_eq!(suppressed(&s), ["Second", "Third"]);++ // Toggle: all suppressed, so all come back; with one of them active, all are suppressed.+ run(&mut s, "timeline.suppress", json!({"groups": [outer]}));+ assert!(suppressed(&s).is_empty());+ run(&mut s, "timeline.suppress", json!({"feature": "Third"}));+ run(&mut s, "timeline.suppress", json!({"groups": [outer]}));+ assert_eq!(suppressed(&s), ["Second", "Third"]);+ run(&mut s, "timeline.suppress", json!({"groups": [outer], "suppressed": false, "features": ["Fourth"]}));+ assert!(suppressed(&s).is_empty(), "an explicit state, with a feature outside the folder as well");++ // The marker between the folder's features: the folder is suppressed all the same, and the+ // marker stays where it was.+ run(&mut s, "timeline.roll_to", json!({"feature": "Second"}));+ assert_eq!(s.doc.marker, Some(2));+ run(&mut s, "timeline.suppress", json!({"groups": [outer], "suppressed": true}));+ assert_eq!(suppressed(&s), ["Second", "Third"]);+ assert_eq!(s.doc.marker, Some(2));+ assert_eq!(s.model.state().bodies.len(), 1, "only First is before the marker and not suppressed");++ let empty = run(&mut s, "timeline.group", json!({"name": "Empty"}))["group"].as_u64().unwrap();+ let before = s.doc.clone();+ for bad in [json!({"groups": [empty]}), json!({"groups": [999_999]}), json!({"groups": [outer], "suppressed": "yes"})] {+ assert!(s.execute("timeline.suppress", &bad).is_err(), "{bad}");+ assert_eq!(s.doc, before, "{bad}: a refused suppress changes nothing");+ }+}+/// A field the feature's definition doesn't have is refused with the fields it does have,/// instead of reporting success and changing nothing (#1491).#[test]diff --git a/crates/ui-egui/src/deferred.rs b/crates/ui-egui/src/deferred.rsindex 9de30f139c..d35f84781a 100644--- a/crates/ui-egui/src/deferred.rs+++ b/crates/ui-egui/src/deferred.rs@@ -73,8 +73,9 @@ pub struct DeleteCheck {/// What a delete does once its check is in.#[derive(Clone, Debug)]pub(crate) enum AfterCheck {- /// The timeline's Delete of these features (a `timeline.dependents` report for each).- Timeline(Vec<u64>),+ /// The timeline's Delete of these features (a `timeline.dependents` report for each), and+ /// of the timeline folders that go with them.+ Timeline { features: Vec<u64>, groups: Vec<u64> },/// Delete with these `selection.delete` parameters (the report of its dry run).Selection(Value),}@@ -83,9 +84,12 @@ impl AfterCheck {/// Check again, for the design as it is now.fn restart(self, app: &mut SolveApp) {match self {- AfterCheck::Timeline(ids) => {- let ids: Vec<u64> = ids.into_iter().filter(|id| app.session.doc.feature(*id).is_some()).collect();- if !ids.is_empty() {+ AfterCheck::Timeline { features, groups } => {+ let ids: Vec<u64> = features.into_iter().filter(|id| app.session.doc.feature(*id).is_some()).collect();+ let groups: Vec<u64> = groups.into_iter().filter(|id| app.session.doc.timeline_groups.iter().any(|g| g.id == *id)).collect();+ if !groups.is_empty() {+ crate::timeline::delete_folders(app, groups, ids);+ } else if !ids.is_empty() {crate::timeline::delete_features(app, ids);}}@@ -96,9 +100,9 @@ impl AfterCheck {/// Carry on with the check's replies.fn finish(self, app: &mut SolveApp, replies: Vec<Result<Value, String>>) {match self {- AfterCheck::Timeline(ids) => {+ AfterCheck::Timeline { features, groups } => {let reports: Vec<Value> = replies.into_iter().map(Result::unwrap_or_default).collect();- crate::timeline::delete_checked_features(app, ids, &reports);+ crate::timeline::delete_checked_features(app, features, groups, &reports);}AfterCheck::Selection(params) => {let report = replies.into_iter().next().unwrap_or_else(|| Err("the delete was not checked".into()));diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rsindex 398c7902c2..52bbf5b009 100644--- a/crates/ui-egui/src/dialogs.rs+++ b/crates/ui-egui/src/dialogs.rs@@ -345,6 +345,8 @@ crate::dialog_descriptor::dialog_descriptors! {/// Delete a feature that others depend on.ConfirmDelete {features: Vec<u64>,+ /// Timeline folders deleted with the features.+ groups: Vec<u64>,with: Vec<String>,fail: Vec<String>,},@@ -1132,11 +1134,11 @@ impl Dialog {#[cfg(test)]pub fn confirm_delete(feature: u64, with: Vec<String>, fail: Vec<String>) -> Dialog {- Dialog::confirm_delete_many(vec![feature], with, fail)+ Dialog::confirm_delete_many(vec![feature], Vec::new(), with, fail)}- pub fn confirm_delete_many(features: Vec<u64>, with: Vec<String>, fail: Vec<String>) -> Dialog {- Dialog::new(Kind::ConfirmDelete { features, with, fail }, vec![])+ pub fn confirm_delete_many(features: Vec<u64>, groups: Vec<u64>, with: Vec<String>, fail: Vec<String>) -> Dialog {+ Dialog::new(Kind::ConfirmDelete { features, groups, with, fail }, vec![])}pub fn edit_param(s: &Session, name: &str) -> Dialog {@@ -4489,7 +4491,7 @@ fn dialog_commands(app: &SolveApp, d: &Dialog) -> Result<Vec<(String, Value)>, S}Kind::EditParam { name, expr } => ("parameters.change", json!({"name": name, "expression": expr})),Kind::Rename { feature, name } => ("timeline.rename", json!({"feature": feature, "name": name})),- Kind::ConfirmDelete { features, .. } => ("timeline.delete", json!({ "features": features })),+ Kind::ConfirmDelete { features, groups, .. } => ("timeline.delete", crate::timeline::delete_params(features, groups)),Kind::Sketch | Kind::Measure { .. } => return Ok(Vec::new()),Kind::Assembly(k) => return crate::dialogs_assembly::commands(app, k, &d.inputs),Kind::Sheet(k) => return crate::dialogs_sheet::commands(app, k, &d.inputs, &d.extra),diff --git a/crates/ui-egui/src/timeline.rs b/crates/ui-egui/src/timeline.rsindex 4fa7dda6b0..909be62e1e 100644--- a/crates/ui-egui/src/timeline.rs+++ b/crates/ui-egui/src/timeline.rs@@ -202,11 +202,19 @@ pub(crate) fn delete_feature(app: &mut SolveApp, id: u64) {/// while, #2678), then delete them or ask first.pub(crate) fn delete_features(app: &mut SolveApp, ids: Vec<u64>) {let checks = ids.iter().map(|id| ("timeline.dependents".to_string(), json!({ "feature": id }))).collect();- app.check_delete(checks, crate::deferred::AfterCheck::Timeline(ids));+ app.check_delete(checks, crate::deferred::AfterCheck::Timeline { features: ids, groups: Vec::new() });}-/// [`delete_features`] once each feature's `timeline.dependents` report is in.-pub(crate) fn delete_checked_features(app: &mut SolveApp, ids: Vec<u64>, reports: &[Value]) {+/// Delete timeline folders with their features (`contents`, nested folders' included) after the+/// same check as [`delete_features`] (#7219).+pub(crate) fn delete_folders(app: &mut SolveApp, groups: Vec<u64>, contents: Vec<u64>) {+ let checks = contents.iter().map(|id| ("timeline.dependents".to_string(), json!({ "feature": id }))).collect();+ app.check_delete(checks, crate::deferred::AfterCheck::Timeline { features: contents, groups });+}++/// [`delete_features`] once each feature's `timeline.dependents` report is in; `groups` are+/// timeline folders deleted with them.+pub(crate) fn delete_checked_features(app: &mut SolveApp, ids: Vec<u64>, groups: Vec<u64>, reports: &[Value]) {// Each report is about one feature alone, so it names the others being deleted too: those// go anyway and are left out of the confirmation.let deleting: Vec<&str> = ids.iter().filter_map(|id| app.session.doc.feature(*id)).map(|f| f.name.as_str()).collect();@@ -226,12 +234,17 @@ pub(crate) fn delete_checked_features(app: &mut SolveApp, ids: Vec<u64>, reports}}if with.is_empty() && fail.is_empty() {- let _ = app.run_heavy("timeline.delete", json!({ "features": ids }));+ let _ = app.run_heavy("timeline.delete", delete_params(&ids, &groups));} else {- app.dialog = Some(crate::dialogs::Dialog::confirm_delete_many(ids, with.into_iter().collect(), fail.into_iter().collect()));+ app.dialog = Some(crate::dialogs::Dialog::confirm_delete_many(ids, groups, with.into_iter().collect(), fail.into_iter().collect()));}}+/// `timeline.delete`'s parameters for these features and timeline folders.+pub(crate) fn delete_params(features: &[u64], groups: &[u64]) -> Value {+ if groups.is_empty() { json!({ "features": features }) } else { json!({ "features": features, "groups": groups }) }+}+/// The selected timeline features, in timeline order.pub(crate) fn selected_feature_ids(app: &SolveApp) -> Vec<u64> {app.sessiondiff --git a/crates/ui-egui/src/timeline_left.rs b/crates/ui-egui/src/timeline_left.rsindex fef8b0eb7c..e07a3e6e32 100644--- a/crates/ui-egui/src/timeline_left.rs+++ b/crates/ui-egui/src/timeline_left.rs@@ -652,6 +652,26 @@ fn selection_actions(app: &mut SolveApp, ui: &mut egui::Ui, groups: &[solidcraftapp.tree.picked_timeline_groups.clear();ui.close();}+ // The folders' own features and those of nested folders, as `timeline.suppress` and+ // `timeline.delete` take them with `groups` (#7219).+ let contents = folder_features(app, &selected_groups);+ let all_suppressed = !contents.is_empty() && contents.iter().all(|id| app.session.doc.feature(*id).is_some_and(|f| f.suppressed));+ let label = if all_suppressed { "Unsuppress Selected Folders" } else { "Suppress Selected Folders" };+ if crate::context_menu::button_enabled(ui, label, "suppress", !contents.is_empty())+ .on_hover_text(crate::i18n::tr("timeline.suppress_folders_tip"))+ .clicked()+ {+ let _ = app.run_heavy("timeline.suppress", json!({"groups": selected_groups, "suppressed": !all_suppressed}));+ ui.close();+ }+ if crate::context_menu::button(ui, "Delete Folders and Features…", "delete")+ .on_hover_text(crate::i18n::tr("timeline.delete_folders_with_features_tip"))+ .clicked()+ {+ crate::timeline::delete_folders(app, selected_groups.clone(), contents);+ app.tree.picked_timeline_groups.clear();+ ui.close();+ }}if !features.is_empty() {ui.separator();@@ -693,6 +713,15 @@ pub fn reveal_feature(app: &mut SolveApp, feature: u64) {}}+/// The features of these folders and of the folders nested in them, in timeline order.+fn folder_features(app: &SolveApp, roots: &[u64]) -> Vec<u64> {+ let groups = &app.session.doc.timeline_groups;+ let inside = |feature: u64| {+ group_for(groups, feature).is_some_and(|group| roots.contains(&group) || roots.iter().any(|root| group_is_descendant(groups, group, *root)))+ };+ app.session.doc.features.iter().map(|feature| feature.id).filter(|feature| inside(*feature)).collect()+}+fn group_is_descendant(groups: &[solidcraft_engine::doc::TimelineGroup], group: u64, ancestor: u64) -> bool {let mut current = groups.iter().find(|candidate| candidate.id == group).and_then(|candidate| candidate.parent);let mut steps = 0usize;@@ -843,6 +872,7 @@ fn timeline_group_name(rect: Rect,offset: f32,names: bool,+ faint: bool,t: &Tokens,) -> bool {let editing =@@ -856,7 +886,7 @@ fn timeline_group_name(egui::Align2::LEFT_CENTER,&group.name,egui::FontId::proportional(crate::theme::Tokens::get().font_body),- t.text,+ if faint { t.text.gamma_multiply(0.42) } else { t.text },);return false;}@@ -926,9 +956,19 @@ fn vertical_group_row(let offset = if names { depth as f32 * 14.0 } else { 0.0 };let centre = pos2(rect.left() + 9.0 + offset, rect.center().y);crate::ui_kit::disclosure(ui.painter(), centre, open, t.text_dim);+ // A folder whose features are all suppressed looks like a suppressed feature.+ let contents = folder_features(app, &[group.id]);+ let suppressed = !contents.is_empty() && contents.iter().all(|id| app.session.doc.feature(*id).is_some_and(|f| f.suppressed));+ let mut painter = ui.painter().clone();+ if suppressed {+ painter.multiply_opacity(0.42);+ }let icon = Rect::from_center_size(pos2(rect.left() + 27.5 + offset, rect.center().y), vec2(17.0, 17.0));- icons::paint_icon(ui.painter(), icon, "folder", f32::from(t.icon.a()) / 255.0);- let renaming = timeline_group_name(app, ui, group, rect, offset, names, &t);+ icons::paint_icon(&painter, icon, "folder", f32::from(t.icon.a()) / 255.0);+ if suppressed {+ painter.line_segment([icon.left_bottom(), icon.right_top()], Stroke::new(1.5, t.text_dim));+ }+ let renaming = timeline_group_name(app, ui, group, rect, offset, names, suppressed, &t);crate::scenario::publish_handle(&format!("timeline-folder:{}", group.name), rect.center());let fold_rect = Rect::from_min_max(pos2(rect.left() + offset, rect.top()), pos2(rect.left() + offset + 18.0, rect.bottom()));crate::scenario::publish_handle(&format!("timeline-folder-fold:{}", group.name), fold_rect.center());@@ -2213,6 +2253,67 @@ mod tests {assert!(harness.app.session.doc.find_feature("Feature").is_some());}+ /// Right-click a folder and pick a menu entry.+ fn folder_menu(harness: &mut Harness, folder: &str, entry: &str) {+ harness.step(&json!({"click": {"handle": format!("timeline-folder:{folder}")}, "button": "right"})).unwrap();+ let [x, y] = harness.widget(entry).unwrap_or_else(|| panic!("`{entry}` is in the folder's menu"));+ harness.step(&json!({"click": [x, y]})).unwrap();+ harness.frames(4);+ }++ /// A folder's menu suppresses and unsuppresses every feature in it and in its nested folders,+ /// and deletes the folders with their features in one undo step (#7219).+ #[test]+ fn folder_menu_suppresses_and_deletes_the_folder_with_its_features() {+ let mut harness = Harness::new();+ harness.app.preferences.timeline_left = true;+ for (name, x) in [("Outside", 0), ("Inside", 20), ("Nested", 40)] {+ let params = json!({"length": 10, "width": 10, "height": 10, "corner": [x, 0, 0], "operation": "new_body", "name": name});+ harness.app.run("solid.box", params).unwrap();+ }+ let outer = harness.app.run("timeline.group", json!({"name": "Outer", "features": ["Inside"]})).unwrap()["group"].as_u64().unwrap();+ harness.app.run("timeline.group", json!({"name": "Inner", "features": ["Nested"], "parent": outer})).unwrap();+ harness.frames(4);+ let suppressed = |harness: &Harness| {+ harness.app.session.doc.features.iter().filter(|feature| feature.suppressed).map(|feature| feature.name.clone()).collect::<Vec<_>>()+ };++ folder_menu(&mut harness, "Outer", "Suppress Selected Folders");+ assert_eq!(suppressed(&harness), ["Inside", "Nested"]);+ folder_menu(&mut harness, "Outer", "Unsuppress Selected Folders");+ assert!(suppressed(&harness).is_empty(), "the menu offers to unsuppress a folder whose features all are");++ folder_menu(&mut harness, "Outer", "Delete Folders and Features…");+ let names: Vec<_> = harness.app.session.doc.features.iter().map(|feature| feature.name.as_str()).collect();+ assert_eq!(names, ["Outside"]);+ assert!(harness.app.session.doc.timeline_groups.is_empty(), "the nested folder goes too");+ assert!(harness.app.dialog.is_none(), "nothing outside the folder needed them: no question");+ harness.app.run("edit.undo", json!({})).unwrap();+ assert_eq!(harness.app.session.doc.features.len(), 3);+ assert_eq!(harness.app.session.doc.timeline_groups.len(), 2, "one undo step");+ }++ /// When a feature outside the folder needs one inside, the delete asks first, and its Delete+ /// takes the folder as well (#7219).+ #[test]+ fn deleting_a_folder_others_depend_on_asks_and_then_takes_the_folder() {+ let mut harness = Harness::new();+ harness.app.preferences.timeline_left = true;+ harness.app.run("solid.box", json!({"length": 10, "width": 10, "height": 10, "name": "Base"})).unwrap();+ harness.app.run("solid.fillet", json!({"edges": [[10, 5, 10]], "radius": 1, "name": "Round"})).unwrap();+ harness.app.run("timeline.group", json!({"name": "Stock", "features": ["Base"]})).unwrap();+ harness.frames(4);++ folder_menu(&mut harness, "Stock", "Delete Folders and Features…");+ assert!(harness.app.dialog.is_some(), "Round needs Base: the delete asks first");+ assert!(harness.app.session.doc.find_feature("Base").is_some());+ let [x, y] = harness.widget("Delete").expect("the confirmation's Delete button");+ harness.step(&json!({"click": [x, y]})).unwrap();+ harness.frames(4);+ assert!(harness.app.session.doc.find_feature("Base").is_none());+ assert!(harness.app.session.doc.timeline_groups.is_empty(), "the confirmed delete takes the folder too");+ }+#[test]fn collapsed_folder_stays_visible_while_its_contents_hide() {let mut harness = Harness::new();diff --git a/docs/book/src/reference/glossary.md b/docs/book/src/reference/glossary.mdindex 340a4b2e7f..300cc2d09b 100644--- a/docs/book/src/reference/glossary.md+++ b/docs/book/src/reference/glossary.md@@ -204,6 +204,7 @@ features are computed.- **In SolidCraft:** `browser.group`, `browser.ungroup`, `browser.rename_group`; `timeline.group`,`timeline.ungroup`, `timeline.rename_group`, `timeline.move_to_group`; the `group` parameter key;+ the `groups` parameter of `timeline.delete` and `timeline.suppress` (a group with all its features);the `browser_groups` and `timeline_groups` design-file keys.- **Don't use:** feature folder, folder (for a group).- **Elsewhere:** folder, group.