SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Browser: allow nesting groups and re-ordering groups & components (#9109) (#9116)
Steven Waters4ba6a9744bf6
diff --git a/crates/doc/src/browser_tree.rs b/crates/doc/src/browser_tree.rsnew file mode 100644index 0000000000..5d10a4b391--- /dev/null+++ b/crates/doc/src/browser_tree.rs@@ -0,0 +1,182 @@+//! The browser's groups as a tree: how deep a group sits, who holds whom, and pruning what a+//! saved design says about the browser down to what still exists.+use crate::document::{BROWSER_FOLDERS, BrowserEntry, BrowserGroup, Document, MAX_GROUP_NESTING};+use std::collections::{BTreeMap, BTreeSet};++impl Document {+ pub fn browser_group(&self, id: u64) -> Option<&BrowserGroup> {+ self.browser_groups.iter().find(|g| g.id == id)+ }++ /// The level of a group: 1 for a top-level group, 2 for a child of one, and so on. A chain+ /// that loops or runs past the limit counts as one level too deep.+ pub fn group_level(&self, id: u64) -> usize {+ let mut level = 0;+ let mut at = Some(id);+ while let Some(g) = at {+ level += 1;+ if level > MAX_GROUP_NESTING {+ return level;+ }+ at = self.browser_group(g).and_then(|g| g.parent);+ }+ level+ }++ /// Whether `ancestor` is `id` or holds it, at any depth.+ pub fn group_within(&self, id: u64, ancestor: u64) -> bool {+ let mut at = Some(id);+ for _ in 0..=MAX_GROUP_NESTING {+ match at {+ Some(g) if g == ancestor => return true,+ Some(g) => at = self.browser_group(g).and_then(|g| g.parent),+ None => return false,+ }+ }+ false+ }++ /// How many levels the group and the groups under it take: 1 for a group with no child group.+ pub fn group_height(&self, id: u64) -> usize {+ fn height(d: &Document, id: u64, left: usize) -> usize {+ if left == 0 {+ return 1;+ }+ 1 + d.browser_groups.iter().filter(|g| g.parent == Some(id)).map(|g| height(d, g.id, left - 1)).max().unwrap_or(0)+ }+ height(self, id, MAX_GROUP_NESTING + 1)+ }++ /// The entries of a holder's list in display order: a group's contents, or the folder's top+ /// level when `holder` is `None`. Groups the list names come where it names them. The child+ /// groups it does not name (in creation order) go just after the last group it names, or+ /// first when it names none, so they sit above the items as they always have. Entries for+ /// groups that are not the holder's children are dropped.+ pub fn ordered_entries(&self, component: u64, folder: &str, holder: Option<u64>) -> Vec<BrowserEntry> {+ let listed: &[BrowserEntry] = match holder {+ Some(g) => self.browser_group(g).map_or(&[], |g| &g.items),+ None => self.browser_order.get(&format!("{component}/{folder}")).map_or(&[], Vec::as_slice),+ };+ let mine: Vec<u64> =+ self.browser_groups.iter().filter(|g| g.component == component && g.folder == folder && g.parent == holder).map(|g| g.id).collect();+ let mut out: Vec<BrowserEntry> = Vec::with_capacity(listed.len() + mine.len());+ for e in listed {+ match e {+ BrowserEntry::Group(id) if !mine.contains(id) || out.contains(e) => {}+ _ => out.push(e.clone()),+ }+ }+ let at = out.iter().rposition(|e| matches!(e, BrowserEntry::Group(_))).map_or(0, |i| i + 1);+ let unlisted: Vec<BrowserEntry> = mine.iter().map(|id| BrowserEntry::Group(*id)).filter(|e| !out.contains(e)).collect();+ out.splice(at..at, unlisted);+ out+ }++ /// The items in a group and in the groups inside it.+ pub fn group_item_keys(&self, id: u64) -> Vec<String> {+ let inside = self.browser_groups.iter().filter(|g| self.group_within(g.id, id));+ inside.flat_map(|g| g.item_keys().map(str::to_string)).collect()+ }++ /// The group holding the item directly, in a component's folder.+ pub fn group_of_item(&self, component: u64, folder: &str, key: &str) -> Option<&BrowserGroup> {+ self.browser_groups.iter().find(|g| g.component == component && g.folder == folder && g.has_item(key))+ }++ /// Only the browser's groups and order changed (a group made, nested, moved into, ordered):+ /// nothing is evaluated and no placement moves. The same whole-Document proof as+ /// [`Document::differs_only_in_render`]; `next_id` may differ, as a new group takes an id.+ pub fn differs_only_in_browser(&self, previous: &Document) -> bool {+ if self.browser_groups == previous.browser_groups && self.browser_order == previous.browser_order {+ return false;+ }+ let mut normalized = previous.clone();+ normalized.browser_groups.clone_from(&self.browser_groups);+ normalized.browser_order.clone_from(&self.browser_order);+ normalized.next_id = self.next_id;+ *self == normalized+ }++ /// What [`Document::browser_pruned`] depends on, cheaply: it can only find something to drop+ /// after a feature, placement, component or group was added or removed. Ids are never+ /// reused, so a removal followed by an addition still moves `next_id`.+ pub fn browser_stamp(&self) -> [u64; 6] {+ let n = |len: usize| u64::try_from(len).unwrap_or(u64::MAX);+ [+ self.next_id,+ n(self.features.len()),+ n(self.occurrences.len()),+ n(self.components.len()),+ n(self.browser_groups.len()),+ n(self.browser_order.len()),+ ]+ }++ /// The groups and order lists with what they name that is gone dropped, or `None` when+ /// nothing is: groups of a missing component or folder, a parent that is missing, elsewhere+ /// or loops, entries for groups and sketches, construction items and placements that no+ /// longer exist, repeats, and order lists of missing components. Body names are left alone:+ /// only an evaluated model knows them.+ pub fn browser_pruned(&self) -> Option<(Vec<BrowserGroup>, BTreeMap<String, Vec<BrowserEntry>>)> {+ if self.browser_groups.is_empty() && self.browser_order.is_empty() {+ return None;+ }+ let components: BTreeSet<u64> = self.components.iter().map(|c| c.id).collect();+ let features: BTreeSet<u64> = self.features.iter().map(|f| f.id).collect();+ let placed_in: BTreeMap<u64, u64> = self.occurrences.iter().map(|o| (o.id, o.parent)).collect();+ let component_exists = |c: u64| c == 0 || components.contains(&c);+ let placed = |component: u64, key: &str| key.parse::<u64>().ok().and_then(|o| placed_in.get(&o)) == Some(&component);+ // Body names cannot be checked here; the other folders hold feature ids.+ let item_exists = |folder: &str, component: u64, key: &str| match folder {+ "bodies" => true,+ "components" => placed(component, key),+ _ => key.parse::<u64>().is_ok_and(|id| features.contains(&id)),+ };+ let mut groups = self.browser_groups.clone();+ let mut order = self.browser_order.clone();+ groups.retain(|g| component_exists(g.component) && BROWSER_FOLDERS.contains(&g.folder.as_str()));+ let known: BTreeMap<u64, (u64, String)> = groups.iter().map(|g| (g.id, (g.component, g.folder.clone()))).collect();+ let parents: BTreeMap<u64, Option<u64>> = groups+ .iter()+ .map(|g| (g.id, g.parent.filter(|p| *p != g.id && known.get(p).is_some_and(|(c, f)| *c == g.component && *f == g.folder))))+ .collect();+ // A loop, or a chain too deep, is cut at the group that makes it.+ let too_deep = |id: u64| std::iter::successors(Some(id), |g| parents.get(g).copied().flatten()).nth(MAX_GROUP_NESTING).is_some();+ let kept: BTreeMap<u64, Option<u64>> = parents.iter().map(|(id, p)| (*id, if too_deep(*id) { None } else { *p })).collect();+ for g in &mut groups {+ g.parent = kept[&g.id];+ }+ let mut taken: BTreeSet<(u64, String, String)> = BTreeSet::new();+ for g in &mut groups {+ let (component, folder, id) = (g.component, g.folder.clone(), g.id);+ let mut seen = BTreeSet::new();+ g.items.retain(|e| match e {+ BrowserEntry::Group(c) => kept.get(c) == Some(&Some(id)) && seen.insert(*c),+ BrowserEntry::Item(k) => item_exists(&folder, component, k) && taken.insert((component, folder.clone(), k.clone())),+ });+ }+ let top = |c: u64, folder: &str, id: u64| kept.get(&id) == Some(&None) && known.get(&id).is_some_and(|(kc, kf)| *kc == c && kf == folder);+ order.retain(|key, list| {+ let Some((c, folder)) = key.split_once('/') else { return false };+ let Some(c) = c.parse::<u64>().ok().filter(|c| component_exists(*c)) else { return false };+ if !BROWSER_FOLDERS.contains(&folder) {+ return false;+ }+ let mut seen = BTreeSet::new();+ list.retain(|e| match e {+ BrowserEntry::Group(id) => top(c, folder, *id) && seen.insert(e.clone()),+ BrowserEntry::Item(k) => item_exists(folder, c, k) && seen.insert(e.clone()),+ });+ !list.is_empty()+ });+ (groups != self.browser_groups || order != self.browser_order).then_some((groups, order))+ }++ /// Put placements of one component in the order the browser shows them: the saved+ /// `components` order, then the rest as they were.+ pub fn sort_placements(&self, parent: u64, ids: &mut [u64]) {+ let Some(order) = self.browser_order.get(&format!("{parent}/components")) else { return };+ let rank: BTreeMap<&str, usize> = order.iter().enumerate().filter_map(|(i, e)| Some((e.as_item()?, i))).collect();+ ids.sort_by_cached_key(|id| rank.get(id.to_string().as_str()).copied().unwrap_or(usize::MAX));+ }+}diff --git a/crates/doc/src/document.rs b/crates/doc/src/document.rsindex fb24e12542..cff8ab07ac 100644--- a/crates/doc/src/document.rs+++ b/crates/doc/src/document.rs@@ -2759,9 +2759,11 @@ pub struct Document {/// order; feature ids remain the source of truth when features are renamed or reordered.#[serde(default, skip_serializing_if = "Vec::is_empty")]pub timeline_groups: Vec<TimelineGroup>,- /// Browser item order per component folder (`"<component>/<folder>"` → item keys).+ /// Browser order per component folder (`"<component>/<folder>"` → groups and item keys).+ /// The `components` folder orders a component's sub-components (by placement id); it is not+ /// drawn as a folder.#[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]- pub browser_order: std::collections::BTreeMap<String, Vec<String>>,+ pub browser_order: std::collections::BTreeMap<String, Vec<BrowserEntry>>,/// Named views: saved cameras.#[serde(default, skip_serializing_if = "Vec::is_empty")]pub named_views: Vec<NamedView>,@@ -2850,8 +2852,69 @@ pub struct BrowserGroup {#[serde(default)]pub component: u64,pub folder: String,+ /// The group that holds this one; `None` is the top level of its folder.+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub parent: Option<u64>,+ /// The group's items and child groups in display order. A child group missing here still+ /// belongs to it (its `parent` says so) and is listed after the ones that are here.#[serde(default)]- pub items: Vec<String>,+ pub items: Vec<BrowserEntry>,+}++/// One line of a browser order list: a group (a number in a saved design) or an item (a string:+/// an item key or body name, so a body named `"1"` never clashes with group 1).+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]+#[serde(untagged)]+pub enum BrowserEntry {+ Group(u64),+ Item(String),+}++impl From<&str> for BrowserEntry {+ fn from(key: &str) -> Self {+ BrowserEntry::Item(key.to_string())+ }+}++impl From<String> for BrowserEntry {+ fn from(key: String) -> Self {+ BrowserEntry::Item(key)+ }+}++impl BrowserEntry {+ pub fn item(key: &str) -> Self {+ BrowserEntry::Item(key.to_string())+ }++ pub fn as_item(&self) -> Option<&str> {+ match self {+ BrowserEntry::Item(k) => Some(k),+ BrowserEntry::Group(_) => None,+ }+ }++ pub fn is_item(&self, key: &str) -> bool {+ self.as_item() == Some(key)+ }+}++/// How many groups may sit inside one another (a top-level group is level 1).+pub const MAX_GROUP_NESTING: usize = 8;++/// The folders a browser group or order list can be for. `components` only orders sub-components.+pub const BROWSER_FOLDERS: [&str; 4] = ["bodies", "sketches", "construction", "components"];++impl BrowserGroup {+ /// The keys of the items directly in this group, in order.+ pub fn item_keys(&self) -> impl Iterator<Item = &str> {+ self.items.iter().filter_map(BrowserEntry::as_item)+ }++ /// Whether this group holds the item directly.+ pub fn has_item(&self, key: &str) -> bool {+ self.items.iter().any(|e| e.is_item(key))+ }}/// A saved history folder. Folders may nest; each feature or joint belongs to at most one folder.@@ -3047,15 +3110,16 @@ impl Document {if let Some(c) = self.body_components.remove(old) {self.body_components.insert(new.to_string(), c);}- for g in self.browser_groups.iter_mut().filter(|g| g.folder == "bodies") {- for k in g.items.iter_mut().filter(|k| *k == old) {- *k = new.to_string();+ let rename = |e: &mut BrowserEntry| {+ if e.is_item(old) {+ *e = BrowserEntry::item(new);}+ };+ for g in self.browser_groups.iter_mut().filter(|g| g.folder == "bodies") {+ g.items.iter_mut().for_each(rename);}for (_, v) in self.browser_order.iter_mut().filter(|(k, _)| k.ends_with("/bodies")) {- for k in v.iter_mut().filter(|k| *k == old) {- *k = new.to_string();- }+ v.iter_mut().for_each(rename);}}@@ -3374,10 +3438,14 @@ impl Document {/// Read a design file's JSON (any format this build knows; older ones are upgraded).pub fn from_json(s: &str) -> Result<Document> {crate::render_resources::check_json_budget(s)?;- let d = crate::format::read(s)?;+ let mut d = crate::format::read(s)?;if d.features.len() > MAX_FEATURES || d.params.len() > MAX_PARAMS {return Err(DocError::Invalid("document too large".into()));}+ // A design from elsewhere may nest groups too deep, loop, or name things that are gone.+ if let Some((groups, order)) = d.browser_pruned() {+ (d.browser_groups, d.browser_order) = (groups, order);+ }Ok(d)}pub fn to_json(&self) -> String {diff --git a/crates/doc/src/format/pending/browser-nested-groups.rs b/crates/doc/src/format/pending/browser-nested-groups.rsnew file mode 100644index 0000000000..13c98678e2--- /dev/null+++ b/crates/doc/src/format/pending/browser-nested-groups.rs@@ -0,0 +1,6 @@+//! Browser groups can nest and be ordered. A group saves its `parent` group (omitted at the top+//! level); a group's items and a folder's `browser_order` list may name groups as numbers beside+//! item keys as strings; and `browser_order` has a `"<component>/components"` list ordering a+//! component's sub-components by placement id. Older designs read unchanged: they have no+//! parents and no group entries. The last release refuses the newer format and asks for an+//! update instead of dropping the nesting and the order.diff --git a/crates/doc/src/lib.rs b/crates/doc/src/lib.rsindex 9fd2405d12..fbd94b407b 100644--- a/crates/doc/src/lib.rs+++ b/crates/doc/src/lib.rs@@ -10,6 +10,7 @@ pub mod appearance_pack;mod assembly;mod body_transfer;mod body_transfer_sheet;+mod browser_tree;pub mod pbr_appearance;pub use body_transfer::{valid_transfer_matrix, validate_body_transfer};pub mod canvas;diff --git a/crates/doc/src/tests.rs b/crates/doc/src/tests.rsindex 4a126f4831..e3051078a4 100644--- a/crates/doc/src/tests.rs+++ b/crates/doc/src/tests.rs@@ -741,3 +741,132 @@ fn a_sketch_too_large_to_search_whole_says_profiles_may_be_missing() {m.evaluate(&plate);assert!(m.result(plate_sketch).and_then(|r| r.warning.as_deref()).is_none());}++fn browser_group(id: u64, component: u64, folder: &str, parent: Option<u64>, items: &[BrowserEntry]) -> BrowserGroup {+ BrowserGroup { id, name: format!("G{id}"), component, folder: folder.into(), parent, items: items.to_vec() }+}++fn item(key: &str) -> BrowserEntry {+ BrowserEntry::item(key)+}++fn group(id: u64) -> BrowserEntry {+ BrowserEntry::Group(id)+}++/// The design with what `browser_pruned` drops gone (the design itself when nothing is).+fn pruned(doc: &Document) -> Document {+ let mut out = doc.clone();+ if let Some((groups, order)) = doc.browser_pruned() {+ (out.browser_groups, out.browser_order) = (groups, order);+ }+ out+}++/// Pruning keeps every group but cuts a parent that loops, is the group itself, is past the+/// nesting limit, or is in another component or folder, to the top level; and it drops entries+/// for deleted sketches and placements, repeats, and the lists of a missing component. Body names+/// are never judged.+#[test]+fn browser_pruning_cuts_bad_parents_and_drops_stale_and_repeated_entries() {+ let mut doc = Document::new("prune");+ let sketch = doc.add_feature(FeatureKind::Sketch { plane: PlaneRef::Origin { name: "XY".into() }, sketch: Sketch::new() }, None).unwrap();+ let key = sketch.to_string();+ doc.components.push(Component { id: 7, name: "Part".into(), ..Default::default() });+ doc.occurrences.push(Occurrence { id: 20, component: 7, parent: 0, name: "Part".into(), transform: IDENTITY, grounded: false });+ let deep = MAX_GROUP_NESTING as u64 + 2;+ doc.browser_groups = vec![+ browser_group(1, 0, "bodies", Some(2), &[]),+ browser_group(2, 0, "bodies", Some(1), &[]),+ browser_group(3, 0, "bodies", Some(3), &[]),+ browser_group(4, 7, "bodies", Some(5), &[]),+ browser_group(5, 0, "bodies", None, &[item("a"), group(7), group(7), item("a")]),+ browser_group(6, 0, "sketches", Some(5), &[item(&key), item("999")]),+ browser_group(7, 0, "bodies", Some(5), &[]),+ browser_group(8, 0, "bodies", None, &[item("a"), item("b")]),+ ];+ doc.browser_groups.extend((0..deep).map(|i| browser_group(100 + i, 0, "construction", i.checked_sub(1).map(|p| 100 + p), &[])));+ doc.browser_order.insert("0/bodies".into(), vec![item("Lid"), item("Ghost"), item("Lid"), group(5), group(5)]);+ doc.browser_order.insert("0/components".into(), vec![item("21"), item("20")]);+ doc.browser_order.insert("99/bodies".into(), vec![item("x")]);+ let after = pruned(&doc);+ let parent = |id| after.browser_group(id).unwrap().parent;+ assert_eq!(after.browser_groups.len(), doc.browser_groups.len(), "no group is dropped");+ assert_eq!([1, 2, 3, 4, 6].map(parent), [None; 5], "a loop, itself, another component, another folder");+ assert_eq!(parent(7), Some(5));+ for i in 0..deep {+ assert_eq!(parent(100 + i), (1..MAX_GROUP_NESTING as u64).contains(&i).then(|| 99 + i), "level {} of a chain {deep} deep", i + 1);+ }+ assert_eq!(after.browser_group(5).unwrap().items, [item("a"), group(7)]);+ assert_eq!(after.browser_group(8).unwrap().items, [item("b")], "an item stays in the first group that has it");+ assert_eq!(after.browser_group(6).unwrap().items, [item(&key)], "the deleted sketch goes");+ assert_eq!(after.browser_order["0/bodies"], [item("Lid"), item("Ghost"), group(5)], "body names stay; repeats go");+ assert_eq!(after.browser_order["0/components"], [item("20")], "the deleted placement goes");+ assert!(!after.browser_order.contains_key("99/bodies"));+ assert!(Document::new("clean").browser_pruned().is_none(), "nothing to prune is not a change");+}++/// Levels and ancestry follow the parents. Groups a list does not name go after the last one it+/// names, in creation order, or first when it names none: above the items, as a design saved+/// before groups could be ordered has always shown them.+#[test]+fn group_levels_and_the_order_of_groups_a_list_does_not_name() {+ let mut doc = Document::new("order");+ doc.browser_groups = vec![+ browser_group(1, 0, "bodies", None, &[item("x")]),+ browser_group(2, 0, "bodies", None, &[]),+ browser_group(3, 0, "bodies", None, &[]),+ browser_group(4, 0, "bodies", Some(1), &[]),+ browser_group(5, 0, "bodies", Some(4), &[]),+ ];+ assert_eq!([1, 2, 4, 5].map(|id| doc.group_level(id)), [1, 1, 2, 3]);+ assert!(doc.group_within(5, 1) && doc.group_within(5, 5) && !doc.group_within(1, 5) && !doc.group_within(2, 5));+ assert_eq!(doc.group_height(1), 3);+ let top = |doc: &Document| doc.ordered_entries(0, "bodies", None);+ assert_eq!(top(&doc), [group(1), group(2), group(3)], "no list: creation order");+ doc.browser_order.insert("0/bodies".into(), vec![item("a")]);+ assert_eq!(top(&doc), [group(1), group(2), group(3), item("a")], "a list of items only: groups above them");+ doc.browser_order.insert("0/bodies".into(), vec![item("a"), group(2), item("b"), group(2), group(9)]);+ assert_eq!(top(&doc), [item("a"), group(2), group(1), group(3), item("b")], "after the last listed; repeats and unknown ignored");+ assert_eq!(doc.ordered_entries(0, "bodies", Some(1)), [group(4), item("x")], "inside a group too");+}++/// Nested groups and a `components` order survive a save and a load, saved as numbers (groups) and+/// strings (items). A design from before groups could nest reads with the browser it always had:+/// no parents, groups in creation order above the items in their saved order, saved back as read.+#[test]+fn browser_data_survives_a_save_and_old_designs_read_unchanged() {+ let mut doc = Document::new("nested");+ doc.components.push(Component { id: 7, name: "Part".into(), ..Default::default() });+ for id in [20, 21] {+ doc.occurrences.push(Occurrence { id, component: 7, parent: 0, name: format!("P{id}"), transform: IDENTITY, grounded: false });+ }+ doc.browser_groups = vec![browser_group(2, 0, "bodies", None, &[item("Lid"), group(3)]), browser_group(3, 0, "bodies", Some(2), &[item("Base")])];+ doc.browser_order.insert("0/bodies".into(), vec![item("Cap"), group(2)]);+ doc.browser_order.insert("0/components".into(), vec![item("21"), item("20")]);+ let saved = doc.to_json();+ let value: serde_json::Value = serde_json::from_str(&saved).unwrap();+ assert_eq!(value["browser_order"]["0/bodies"], serde_json::json!(["Cap", 2]));+ assert_eq!((&value["browser_groups"][1]["parent"], value["browser_groups"][0].get("parent")), (&serde_json::json!(2), None));+ let loaded = Document::from_json(&saved).unwrap();+ assert_eq!((&loaded.browser_groups, &loaded.browser_order), (&doc.browser_groups, &doc.browser_order));+ let resaved: serde_json::Value = serde_json::from_str(&loaded.to_json()).unwrap();+ assert_eq!((&resaved["browser_groups"], &resaved["browser_order"]), (&value["browser_groups"], &value["browser_order"]));++ let groups = serde_json::json!([+ {"id": 3, "name": "Fasteners", "component": 0, "folder": "bodies", "items": ["Bolt", "Nut"]},+ {"id": 4, "name": "Plates", "component": 0, "folder": "bodies", "items": ["Plate"]},+ ]);+ for (order, top) in [+ (serde_json::json!({}), vec![group(3), group(4)]),+ (serde_json::json!({"0/bodies": ["Washer", "Bolt", "Cap"]}), vec![group(3), group(4), item("Washer"), item("Bolt"), item("Cap")]),+ ] {+ let mut old: serde_json::Value = serde_json::from_str(&Document::new("old").to_json()).unwrap();+ (old["browser_groups"], old["browser_order"]) = (groups.clone(), order.clone());+ let loaded = Document::from_json(&old.to_string()).unwrap();+ assert!(loaded.browser_groups.iter().all(|g| g.parent.is_none()), "{order}");+ assert_eq!(loaded.ordered_entries(0, "bodies", None), top, "{order}");+ let resaved: serde_json::Value = serde_json::from_str(&loaded.to_json()).unwrap();+ assert_eq!(resaved["browser_groups"], groups, "{order}");+ }+}diff --git a/crates/engine/src/cmd/browser.rs b/crates/engine/src/cmd/browser.rsindex 1ea32cb0ab..d588fd1471 100644--- a/crates/engine/src/cmd/browser.rs+++ b/crates/engine/src/cmd/browser.rs@@ -11,7 +11,7 @@ use std::collections::BTreeMap;use serde_json::{Value, json};-use solidcraft_doc::FeatureKind;+use solidcraft_doc::{BrowserEntry, FeatureKind, MAX_GROUP_NESTING};use super::CommandSpec;use crate::params::{bad, bool_, str_};@@ -24,11 +24,11 @@ pub static COMMANDS: &[CommandSpec] = &[.params("sketch: id or name; plane: as sketch.create; frame?: as sketch.create; author_path?: exact owner occurrence ids; explicitly rebinds or freezes the plane while preserving geometry and dimension names"),CommandSpec::new("browser.group", "New Group", group).icon("folder")- .params("folder: bodies|sketches|construction; component?: id (default 0); name?; items?: [keys] (they leave other groups)"),- CommandSpec::new("browser.ungroup", "Ungroup", ungroup).icon("folder").params("group: id (its items go back to the folder)"),+ .params("folder?: bodies|sketches|construction; component?: id (default 0); parent?: group id (the new group nests in it, taking its component and folder; at most 8 levels); name?; items?: [keys] (they leave other groups)"),+ CommandSpec::new("browser.ungroup", "Ungroup", ungroup).icon("folder").params("group: id (its items and child groups go up to the group that holds it, or the folder)"),CommandSpec::new("browser.rename_group", "Rename Group", rename_group).icon("rename").params("group: id, name"),CommandSpec::new("browser.move", "Move Browser Items", move_items).icon("reorder")- .params("folder, component?, items: [keys]; group?: id (into it; omit to take them out of groups); before?: key (position in the group)"),+ .params("folder, component?, items: [keys (strings) and group ids (numbers)]; group?: id (into it; omit for the folder's top level); before?: key or group id (position in it; default the end). A group cannot go into itself or past 8 levels"),CommandSpec::new("document.units", "Change Design Units", document_units).icon("settings").params("units: mm|cm|m|in|ft (display and unit-less parameters; values keep their meaning)"),@@ -41,7 +41,7 @@ pub static COMMANDS: &[CommandSpec] = &[CommandSpec::new("view.apply", "Restore Named View", view_apply).icon("camera").noundo().params("view?: front|back|top|bottom|left|right|iso|home (frames the model) | a named view's name; or camera?: {target: [x,y,z], yaw, pitch, distance, fov?, roll?} (radians, mm, about the up axis; yaw: heading of the line of sight, 0 along +Y (Front), π/2 along +X (Left), π (Back), −π/2 (Right); pitch: the eye's elevation, within ±π/2, π/2 = Top; roll defaults to 0, turns the picture clockwise, must be finite and is clamped to ±π; the View angles readout shows these in degrees; up is refused: the up axis comes from the design settings) → camera. The viewport (and the MCP screenshot) moves there. View state: not saved, not an undo step",),- CommandSpec::new("browser.order", "Order Browser Items", order).icon("reorder").params("folder, component?, order: [keys] (the folder's items in display order)"),+ CommandSpec::new("browser.order", "Order Browser Items", order).icon("reorder").params("folder: bodies|sketches|construction|components, component?, order: [keys (strings) and top-level group ids (numbers)] (display order; for `components`, the ids of the components placed in it)"),CommandSpec::new("browser.visibility", "Show/Hide", visibility).icon("eye").params("visible: bool; items?: [sketch id or name | body name | construction name | joint name | O|X|Y|Z|XY|XZ|YZ]; \or joints?: [joint id or name] (their glyphs; they still constrain and move parts); \@@ -98,11 +98,102 @@ fn group_id(s: &Session, p: &Value, cmd: &str) -> Result<u64> {if s.doc.browser_groups.iter().any(|g| g.id == id) { Ok(id) } else { Err(bad(cmd, format!("no group {id}"))) }}+/// A list of groups (numbers) and items (strings): a number is always a group.+fn entries(p: &Value, k: &str, cmd: &str) -> Result<Vec<BrowserEntry>> {+ let list = match p.get(k) {+ Some(Value::Array(a)) => a+ .iter()+ .map(|x| match x {+ Value::String(s) => Some(BrowserEntry::Item(s.clone())),+ _ => x.as_u64().map(BrowserEntry::Group),+ })+ .collect::<Option<Vec<_>>>(),+ None => Some(Vec::new()),+ _ => None,+ };+ let list = list.ok_or_else(|| bad(cmd, format!("`{k}` must be a list of item keys (strings) and group ids (numbers)")))?;+ if list.len() > 10_000 || list.iter().any(|e| e.as_item().is_some_and(|k| k.is_empty() || k.len() > 256)) {+ return Err(bad(cmd, format!("`{k}` has bad keys")));+ }+ Ok(list)+}++/// A number in a list of items or an order names a group; say so when there is none, as a sketch+/// or plane id passed as a number is the likely mistake (item keys are strings).+fn no_group(cmd: &str, id: u64) -> crate::EngineError {+ bad(cmd, format!("no group {id} (a number is a group id; pass item keys as strings)"))+}++/// The group a command names under `key`, if it names one (`null` or absent: none).+fn optional_group(s: &Session, p: &Value, key: &str, cmd: &str) -> Result<Option<u64>> {+ match p.get(key) {+ None | Some(Value::Null) => Ok(None),+ Some(v) => {+ let id = v.as_u64().ok_or_else(|| bad(cmd, format!("`{key}` must be a group id")))?;+ if s.doc.browser_group(id).is_some() { Ok(Some(id)) } else { Err(no_group(cmd, id)) }+ }+ }+}++/// The list a group's contents (or the folder's top level, `None`) are ordered by.+fn holder_list<'a>(d: &'a mut solidcraft_doc::Document, component: u64, folder: &str, holder: Option<u64>) -> Option<&'a mut Vec<BrowserEntry>> {+ match holder {+ Some(g) => d.browser_groups.iter_mut().find(|x| x.id == g).map(|g| &mut g.items),+ None => Some(d.browser_order.entry(format!("{component}/{folder}")).or_default()),+ }+}++/// Name every group under `holder` in its list, where they are drawn, so a position among them+/// can be found.+fn settle(d: &mut solidcraft_doc::Document, component: u64, folder: &str, holder: Option<u64>) {+ let all = d.ordered_entries(component, folder, holder);+ if let Some(list) = holder_list(d, component, folder, holder) {+ *list = all;+ }+}++/// Take entries out of every list of a component's folder: its groups' and the top level's.+fn take_out(d: &mut solidcraft_doc::Document, component: u64, folder: &str, gone: &[BrowserEntry]) {+ for g in d.browser_groups.iter_mut().filter(|g| g.component == component && g.folder == folder) {+ g.items.retain(|e| !gone.contains(e));+ }+ if let Some(list) = d.browser_order.get_mut(&format!("{component}/{folder}")) {+ list.retain(|e| !gone.contains(e));+ if list.is_empty() {+ d.browser_order.remove(&format!("{component}/{folder}"));+ }+ }+}+fn group(s: &mut Session, p: &Value) -> Result<Value> {let cmd = "browser.group";- let folder = folder_of(p, cmd)?;- let component = component_of(s, p, cmd)?;- let items = keys(p, "items", cmd)?;+ let parent = optional_group(s, p, "parent", cmd)?;+ let (mut component, mut folder) = (None, None);+ if let Some(g) = parent.and_then(|g| s.doc.browser_group(g)) {+ // Omitted, they come from the parent; given, they must agree with it.+ if p.get("component").is_some() && component_of(s, p, cmd)? != g.component {+ return Err(bad(cmd, "`parent` belongs to another component"));+ }+ if p.get("folder").is_some() && folder_of(p, cmd)? != g.folder {+ return Err(bad(cmd, "`parent` belongs to another folder"));+ }+ if s.doc.group_level(g.id) >= MAX_GROUP_NESTING {+ return Err(bad(cmd, format!("groups nest at most {MAX_GROUP_NESTING} levels")));+ }+ (component, folder) = (Some(g.component), Some(g.folder.clone()));+ }+ let folder = match folder {+ Some(f) => f,+ None => folder_of(p, cmd)?,+ };+ let component = match component {+ Some(c) => c,+ None => component_of(s, p, cmd)?,+ };+ let items = match entries(p, "items", cmd)?.into_iter().map(|e| e.as_item().map(str::to_string)).collect::<Option<Vec<_>>>() {+ Some(items) => items,+ None => return Err(bad(cmd, "`items` are item keys: move groups with browser.move")),+ };let d = s.doc_mut();let id = d.allocate_id()?;let name = match str_(p, "name").map(str::trim).filter(|n| !n.is_empty()) {@@ -110,16 +201,32 @@ fn group(s: &mut Session, p: &Value) -> Result<Value> {Some(_) => return Err(bad(cmd, "`name` is too long")),None => format!("Group{}", d.browser_groups.iter().filter(|g| g.folder == folder).count() + 1),};- for g in d.browser_groups.iter_mut().filter(|g| g.component == component && g.folder == folder) {- g.items.retain(|k| !items.contains(k));- }- d.browser_groups.push(solidcraft_doc::BrowserGroup { id, name: name.clone(), component, folder, items });- Ok(json!({ "group": id, "name": name }))+ let gone: Vec<BrowserEntry> = items.iter().map(|k| BrowserEntry::item(k)).collect();+ take_out(d, component, &folder, &gone);+ let items = gone;+ d.browser_groups.push(solidcraft_doc::BrowserGroup { id, name: name.clone(), component, folder, parent, items });+ Ok(json!({ "group": id, "name": name, "parent": parent }))}+/// A group's contents go up to the group that holds it (the folder's top level for a top-level+/// group), in the place the group had; so do its child groups. Its own entry goes.fn ungroup(s: &mut Session, p: &Value) -> Result<Value> {let id = group_id(s, p, "browser.ungroup")?;- s.doc_mut().browser_groups.retain(|g| g.id != id);+ let d = s.doc_mut();+ let Some(g) = d.browser_group(id).cloned() else { return Ok(json!({ "group": id })) };+ settle(d, g.component, &g.folder, Some(id));+ settle(d, g.component, &g.folder, g.parent);+ let inside = d.browser_group(id).map(|g| g.items.clone()).unwrap_or_default();+ for child in d.browser_groups.iter_mut().filter(|c| c.parent == Some(id)) {+ child.parent = g.parent;+ }+ if let Some(list) = holder_list(d, g.component, &g.folder, g.parent)+ && let Some(at) = list.iter().position(|e| *e == BrowserEntry::Group(id))+ {+ list.splice(at..=at, inside);+ }+ take_out(d, g.component, &g.folder, &[BrowserEntry::Group(id)]);+ d.browser_groups.retain(|x| x.id != id);Ok(json!({ "group": id }))}@@ -138,43 +245,91 @@ fn move_items(s: &mut Session, p: &Value) -> Result<Value> {let cmd = "browser.move";let folder = folder_of(p, cmd)?;let component = component_of(s, p, cmd)?;- let items = keys(p, "items", cmd)?;+ let items = entries(p, "items", cmd)?;if items.is_empty() {- return Err(bad(cmd, "`items` must list item keys"));+ return Err(bad(cmd, "`items` must list item keys or group ids"));}- let to = match p.get("group") {- Some(Value::Null) | None => None,- Some(_) => Some(group_id(s, p, cmd)?),- };+ let to = optional_group(s, p, "group", cmd)?;if let Some(g) = to&& !s.doc.browser_groups.iter().any(|x| x.id == g && x.component == component && x.folder == folder){return Err(bad(cmd, "that group is in another folder"));}- let before = str_(p, "before").map(str::to_string);- let d = s.doc_mut();- for g in d.browser_groups.iter_mut().filter(|g| g.component == component && g.folder == folder) {- g.items.retain(|k| !items.contains(k));- if Some(g.id) == to {- let at = before.as_ref().and_then(|b| g.items.iter().position(|k| k == b)).unwrap_or(g.items.len());- for (i, k) in items.iter().enumerate() {- g.items.insert(at + i, k.clone());+ let to_level = to.map_or(0, |g| s.doc.group_level(g));+ for e in &items {+ let BrowserEntry::Group(id) = e else { continue };+ let Some(g) = s.doc.browser_group(*id) else { return Err(no_group(cmd, *id)) };+ if g.component != component || g.folder != folder {+ return Err(bad(cmd, format!("group {id} is in another folder")));+ }+ if to.is_some_and(|t| s.doc.group_within(t, *id)) {+ return Err(bad(cmd, format!("group {id} cannot go inside itself")));+ }+ if to_level + s.doc.group_height(*id) > MAX_GROUP_NESTING {+ return Err(bad(cmd, format!("groups nest at most {MAX_GROUP_NESTING} levels")));+ }+ }+ let before = match p.get("before") {+ None | Some(Value::Null) => None,+ Some(Value::String(k)) => Some(BrowserEntry::Item(k.clone())),+ Some(v) => {+ let id = v.as_u64().ok_or_else(|| bad(cmd, "`before` must be an item key or a group id"))?;+ if s.doc.browser_group(id).is_none() {+ return Err(no_group(cmd, id));}+ Some(BrowserEntry::Group(id))+ }+ };+ let d = s.doc_mut();+ // Where a group list is silent about its child groups, the ones it names come first: name+ // them all, so `before` can be one of them.+ settle(d, component, &folder, to);+ take_out(d, component, &folder, &items);+ for e in &items {+ if let BrowserEntry::Group(id) = e+ && let Some(g) = d.browser_groups.iter_mut().find(|g| g.id == *id)+ {+ g.parent = to;}}+ if let Some(list) = holder_list(d, component, &folder, to) {+ let at = before.as_ref().and_then(|b| list.iter().position(|e| e == b)).unwrap_or(list.len());+ list.splice(at..at, items.iter().cloned());+ }Ok(json!({ "items": items, "group": to }))}fn order(s: &mut Session, p: &Value) -> Result<Value> {let cmd = "browser.order";- let folder = folder_of(p, cmd)?;let component = component_of(s, p, cmd)?;- let order = keys(p, "order", cmd)?;+ let components = str_(p, "folder") == Some("components");+ let folder = if components { "components".to_string() } else { folder_of(p, cmd)? };+ let order = entries(p, "order", cmd)?;+ for e in &order {+ match e {+ // Sub-components, by placement id, all of them placed in this component.+ BrowserEntry::Item(k) if components => {+ let placed = k.parse::<u64>().ok().is_some_and(|o| s.doc.occurrences.iter().any(|x| x.id == o && x.parent == component));+ if !placed {+ return Err(bad(cmd, "the `components` folder is ordered by the ids of the components placed in it"));+ }+ }+ BrowserEntry::Item(_) => {}+ BrowserEntry::Group(id) => match s.doc.browser_group(*id) {+ None => return Err(no_group(cmd, *id)),+ Some(g) if components || g.component != component || g.folder != folder || g.parent.is_some() => {+ return Err(bad(cmd, format!("group {id} is not a top-level group of this folder")));+ }+ Some(_) => {}+ },+ }+ }let key = format!("{component}/{folder}");let d = s.doc_mut();if order.is_empty() {d.browser_order.remove(&key);} else {+ // An item that sits in a group belongs to the group's list only.d.browser_order.insert(key, order);}Ok(json!({}))@@ -2022,17 +2177,17 @@ mod tests {let g = run(&mut s, "browser.group", json!({"folder": "bodies", "items": [a.clone()]}))["group"].as_u64().unwrap();assert_eq!(s.doc.browser_groups[0].name, "Group1");run(&mut s, "browser.move", json!({"folder": "bodies", "items": [b.clone()], "group": g, "before": a.clone()}));- assert_eq!(s.doc.browser_groups[0].items, vec![b.clone(), a.clone()]);+ assert_eq!(s.doc.browser_groups[0].items, vec![b.clone().into(), a.clone().into()]);run(&mut s, "browser.rename_group", json!({"group": g, "name": "Fasteners"}));run(&mut s, "body.rename", json!({"body": a, "name": "Bolt"}));- assert_eq!(s.doc.browser_groups[0].items, vec![b.clone(), "Bolt".to_string()]);+ assert_eq!(s.doc.browser_groups[0].items, vec![b.clone().into(), "Bolt".into()]);// Out of the group, then a folder order; saved with the design.run(&mut s, "browser.move", json!({"folder": "bodies", "items": [b.clone()]}));- assert_eq!(s.doc.browser_groups[0].items, vec!["Bolt".to_string()]);+ assert_eq!(s.doc.browser_groups[0].items, vec!["Bolt".into()]);run(&mut s, "browser.order", json!({"folder": "bodies", "order": [b.clone(), "Bolt"]}));let saved: solidcraft_doc::Document = serde_json::from_str(&serde_json::to_string(&*s.doc).unwrap()).unwrap();assert_eq!(saved.browser_groups, s.doc.browser_groups);- assert_eq!(saved.browser_order["0/bodies"], vec![b, "Bolt".to_string()]);+ assert_eq!(saved.browser_order["0/bodies"], vec![b.into(), "Bolt".into()]);run(&mut s, "browser.ungroup", json!({"group": g}));assert!(s.doc.browser_groups.is_empty());// Hostile input is refused.@@ -2215,4 +2370,107 @@ mod tests {let e = s.execute("browser.visibility", &json!({"visible": false, "features": ["Sphere1"], "path": [first]})).expect_err("other component");assert!(e.to_string().contains("component"), "{e}");}++ use solidcraft_doc::{BrowserEntry, MAX_GROUP_NESTING};++ fn three_bodies(s: &mut Session) {+ for (i, name) in ["A", "B", "C"].into_iter().enumerate() {+ run(s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": [i as f64 * 20.0, 0, 0], "body_name": name}));+ }+ }++ fn new_group(s: &mut Session, mut p: Value) -> u64 {+ p["folder"] = json!("bodies");+ run(s, "browser.group", p)["group"].as_u64().unwrap()+ }++ fn state(s: &Session) -> (Vec<solidcraft_doc::BrowserGroup>, std::collections::BTreeMap<String, Vec<BrowserEntry>>) {+ (s.doc.browser_groups.clone(), s.doc.browser_order.clone())+ }++ fn refused(s: &mut Session, id: &str, p: Value) {+ let before = s.doc.to_json();+ let r = s.execute(id, &p);+ assert!(matches!(r, Err(crate::EngineError::BadParams { .. })), "{id} {p}: {r:?}");+ assert_eq!(s.doc.to_json(), before, "{id} {p}: a refused command changes nothing");+ }++ /// Nest a group, order groups and components, ungroup; each step undoes and redoes, and none of+ /// it evaluates anything.+ #[test]+ fn groups_nest_reorder_and_ungroup_with_undo_redo_and_no_evaluation() {+ let mut s = Session::default();+ three_bodies(&mut s);+ let mut placed = Vec::new();+ for name in ["P", "Q"] {+ placed.push(run(&mut s, "component.create", json!({"name": name}))["occurrence"].as_u64().unwrap());+ run(&mut s, "component.activate", json!({"component": 0}));+ }+ let mut states = vec![state(&s)];+ s.evaluations = 0;+ let outer = new_group(&mut s, json!({"items": ["A"]}));+ states.push(state(&s));+ // The inner group takes its component and folder from the parent.+ let inner = run(&mut s, "browser.group", json!({"parent": outer, "items": ["B"]}))["group"].as_u64().unwrap();+ states.push(state(&s));+ let g = s.doc.browser_group(inner).unwrap();+ assert_eq!((g.parent, g.component, g.folder.as_str()), (Some(outer), 0, "bodies"));+ run(&mut s, "browser.order", json!({"folder": "components", "order": [placed[1].to_string(), placed[0].to_string()]}));+ states.push(state(&s));+ let mut shown = placed.clone();+ s.doc.sort_placements(0, &mut shown);+ assert_eq!(shown, [placed[1], placed[0]]);+ run(&mut s, "browser.order", json!({"folder": "bodies", "order": ["C", outer]}));+ states.push(state(&s));+ run(&mut s, "browser.move", json!({"folder": "bodies", "items": [inner], "before": "C"}));+ states.push(state(&s));+ assert_eq!(s.doc.ordered_entries(0, "bodies", None), [BrowserEntry::Group(inner), "C".into(), BrowserEntry::Group(outer)]);+ run(&mut s, "browser.ungroup", json!({"group": outer}));+ states.push(state(&s));+ // The group's items go where it was.+ assert_eq!(s.doc.browser_order["0/bodies"], [BrowserEntry::Group(inner), "C".into(), "A".into()]);+ for i in (0..states.len() - 1).rev() {+ run(&mut s, "edit.undo", json!({}));+ assert_eq!(state(&s), states[i], "undo to step {i}");+ }+ for (i, expected) in states.iter().enumerate().skip(1) {+ run(&mut s, "edit.redo", json!({}));+ assert_eq!(state(&s), *expected, "redo to step {i}");+ }+ assert_eq!(s.evaluations, 0, "changing only the browser evaluates nothing");+ }++ #[test]+ fn nesting_and_ordering_that_cannot_stand_are_refused() {+ let mut s = Session::default();+ three_bodies(&mut s);+ let part = run(&mut s, "component.create", json!({"name": "Part"}));+ run(&mut s, "component.activate", json!({"component": 0}));+ let outer = new_group(&mut s, json!({"items": ["A"]}));+ let inner = new_group(&mut s, json!({"parent": outer}));+ // A group inside itself or its own child.+ refused(&mut s, "browser.move", json!({"folder": "bodies", "items": [outer], "group": outer}));+ refused(&mut s, "browser.move", json!({"folder": "bodies", "items": [outer], "group": inner}));+ // Past eight levels, by a new group or by moving one with a child of its own.+ let mut chain = vec![new_group(&mut s, json!({}))];+ while chain.len() < MAX_GROUP_NESTING {+ chain.push(new_group(&mut s, json!({"parent": chain[chain.len() - 1]})));+ }+ refused(&mut s, "browser.group", json!({"folder": "bodies", "parent": chain[MAX_GROUP_NESTING - 1]}));+ let heavy = new_group(&mut s, json!({}));+ new_group(&mut s, json!({"parent": heavy}));+ refused(&mut s, "browser.move", json!({"folder": "bodies", "items": [heavy], "group": chain[MAX_GROUP_NESTING - 2]}));+ // A parent that is missing, or in another folder or component.+ refused(&mut s, "browser.group", json!({"folder": "bodies", "parent": 424242}));+ refused(&mut s, "browser.group", json!({"folder": "sketches", "parent": outer}));+ refused(&mut s, "browser.group", json!({"parent": outer, "component": part["component"]}));+ // Orders and moves naming a group that cannot be there; a number is a group, not an item key.+ refused(&mut s, "browser.order", json!({"folder": "bodies", "order": [inner]}));+ refused(&mut s, "browser.order", json!({"folder": "bodies", "order": [424242]}));+ refused(&mut s, "browser.move", json!({"folder": "bodies", "items": ["B"], "before": 424242}));+ refused(&mut s, "browser.group", json!({"folder": "bodies", "items": [12]}));+ // The components folder takes placements of that component, and nothing else.+ refused(&mut s, "browser.order", json!({"folder": "components", "order": ["424242"]}));+ refused(&mut s, "browser.order", json!({"folder": "components", "order": [outer]}));+ }}diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rsindex 029e920312..3b0380a78b 100644--- a/crates/engine/src/lib.rs+++ b/crates/engine/src/lib.rs@@ -431,6 +431,8 @@ pub struct Session {/// Revision increments caused only by visibility. Comparing both counters proves that/// every intervening increment left an editor's document and model untouched.visibility_revision: u64,+ /// [`Document::browser_stamp`] when the browser's groups and order were last checked.+ browser_stamp: [u64; 6],/// This open design's id for programs that follow it (`document.revision`, #6646): kept/// while it stays open, through saves and renames; another for each design started or opened.pub document_id: String,@@ -649,6 +651,7 @@ impl Session {log: Vec::new(),revision: 1,visibility_revision: 0,+ browser_stamp: [0; 6],document_id: cmd::inspect::new_document_id(),followed: None,auto_project: true,@@ -946,6 +949,15 @@ impl Session {}self.revision += 1;self.prune_occurrence_state();+ // Looked at only when what the groups can name has changed, not on every refresh.+ let stamp = self.doc.browser_stamp();+ if stamp != self.browser_stamp {+ if let Some((groups, order)) = self.doc.browser_pruned() {+ let d = self.doc_mut();+ (d.browser_groups, d.browser_order) = (groups, order);+ }+ self.browser_stamp = self.doc.browser_stamp();+ }// Joints follow the geometry their origins snap to.if !self.doc.assembly.joints.is_empty() {// A solve that moves parts changes what features reading where a part is placed@@ -1126,14 +1138,15 @@ impl Session {}}- /// Only persistent render intent, part properties or appearances changed. Never evaluate or- /// clear a stale model here.+ /// Only persistent render intent, part properties, appearances or the browser's groups changed.+ /// Never evaluate or clear a stale model here.fn render_only_change(&self, before: &Snapshot) -> bool {self.active_sketch == before.active_sketch&& self.pending_moves == before.pending_moves&& (self.doc.differs_only_in_render(&before.doc)|| self.doc.differs_only_in_part_properties(&before.doc)- || self.doc.differs_only_in_appearance(&before.doc))+ || self.doc.differs_only_in_appearance(&before.doc)+ || self.doc.differs_only_in_browser(&before.doc))}/// Only what is hidden or shown changed (`browser.visibility`): the document and the model@@ -1500,6 +1513,7 @@ impl Session {log: Vec::new(),revision: self.revision,visibility_revision: self.visibility_revision,+ browser_stamp: self.browser_stamp,document_id: self.document_id.clone(),followed: None,auto_project: self.auto_project,diff --git a/crates/engine/src/occurrences.rs b/crates/engine/src/occurrences.rsindex ec6a34d1b1..8d6ac6cc79 100644--- a/crates/engine/src/occurrences.rs+++ b/crates/engine/src/occurrences.rs@@ -582,8 +582,11 @@ impl Session {|| self.doc.browser_groups.iter().any(|g| {g.component == component&& g.folder == folder- && g.items.iter().any(|i| i == item)- && self.folder_hidden(&format!("{scope}/g{}", g.id))+ && g.has_item(item)+ // A hidden group hides the groups inside it.+ && std::iter::successors(Some(g.id), |id| self.doc.browser_group(*id).and_then(|g| g.parent))+ .take(solidcraft_doc::MAX_GROUP_NESTING + 1)+ .any(|id| self.folder_hidden(&format!("{scope}/g{id}")))})}diff --git a/crates/ui-egui/src/browser.rs b/crates/ui-egui/src/browser.rsindex edc15b4b20..afa33ccfd7 100644--- a/crates/ui-egui/src/browser.rs+++ b/crates/ui-egui/src/browser.rs@@ -58,8 +58,16 @@ pub(crate) fn reveal_body(app: &mut SolveApp, body: &str) {let scope = if path.is_empty() { format!("c{component}") } else { occurrence_key(&path) };app.tree.collapsed.remove(&scope);app.tree.collapsed.remove(&format!("{scope}/bodies"));- for g in app.session.doc.browser_groups.iter().filter(|g| g.component == component && g.folder == "bodies" && g.items.contains(&source)) {- app.tree.collapsed.remove(&format!("{scope}/g{}", g.id));+ open_group_chain(app, &scope, component, "bodies", &source);+}++/// Open the group holding an item, and the groups holding that one.+fn open_group_chain(app: &mut SolveApp, scope: &str, component: u64, folder: &str, key: &str) {+ let mut at = app.session.doc.group_of_item(component, folder, key).map(|g| g.id);+ for _ in 0..=solidcraft_engine::doc::MAX_GROUP_NESTING {+ let Some(id) = at else { return };+ app.tree.collapsed.remove(&if scope.is_empty() { format!("g{id}") } else { format!("{scope}/g{id}") });+ at = app.session.doc.browser_group(id).and_then(|g| g.parent);}}@@ -77,7 +85,7 @@ use std::sync::{Arc, Weak};use egui::{Color32, FontId, Pos2, Rect, Sense, Stroke, pos2, vec2};use serde_json::{Value, json};use solidcraft_engine::Sel;-use solidcraft_engine::doc::{Document, FeatureKind};+use solidcraft_engine::doc::{BrowserEntry, Document, FeatureKind};use crate::context_menu::{Item, Target};use crate::theme::Tokens;@@ -317,7 +325,7 @@ pub fn group_bodies(app: &SolveApp, id: u64) -> Vec<String> {let st = app.session.world_state();find_group(app, id).filter(|g| g.folder == "bodies")- .map(|g| g.items.iter().filter(|b| st.body(b).is_some()).cloned().collect())+ .map(|_| app.session.doc.group_item_keys(id).into_iter().filter(|b| st.body(b).is_some()).collect()).unwrap_or_default()}@@ -348,6 +356,10 @@ pub fn group_items(app: &SolveApp, id: u64, scope: &str) -> Vec<Item> {if g.folder == "bodies" || g.folder == "sketches" {v.push(paste_item(app, g.component, scope, &g.folder, Some(id)));}+ // A group inside this one, unless it is already as deep as groups go.+ if app.session.doc.group_level(id) < solidcraft_engine::doc::MAX_GROUP_NESTING {+ v.push(Item::action("ui.newGroup", "New Group", "folder").with(json!({ "component": g.component, "folder": g.folder, "parent": id })));+ }v.extend([Item::action("ui.rename", "Rename", "rename").with(json!({ "group": id })),Item::action("ui.ungroup", "Ungroup", "folder").with(json!({ "group": id })),@@ -374,10 +386,7 @@ pub fn folder_items(app: &SolveApp, component: u64, folder: &str, scope: &str) -if folder == "sketches" {v.push(paste_item(app, component, scope, folder, None));}- v.push(- Item::action("ui.newGroup", if folder == "sketches" { "New Sketch Group" } else { "New Group" }, "folder")- .with(json!({ "component": component, "folder": folder })),- );+ v.push(Item::action("ui.newGroup", "New Group", "folder").with(json!({ "component": component, "folder": folder })));if sel.len() > 1 {v.push(Item::action("ui.groupSelected", "Group Selected", "folder").with(json!({ "component": component, "folder": folder, "items": sel })));}@@ -471,9 +480,13 @@ pub fn group_action(app: &mut SolveApp, action: &str, p: &Value) {let folder = p.get("folder").and_then(Value::as_str).unwrap_or("bodies");let comp = p.get("component").and_then(Value::as_u64).unwrap_or(0);let items = p.get("items").cloned().unwrap_or(json!([]));- if let Ok(r) = app.run("browser.group", json!({ "component": comp, "folder": folder, "items": items }))+ let parent = p.get("parent").and_then(Value::as_u64);+ if let Ok(r) = app.run("browser.group", json!({ "component": comp, "folder": folder, "items": items, "parent": parent }))&& let Some(g) = r.get("group").and_then(Value::as_u64){+ if let Some(parent) = parent {+ app.tree.collapsed.remove(&format!("c{comp}/g{parent}"));+ }app.tree.collapsed.remove(&format!("c{comp}/{folder}"));app.tree.collapsed.remove(&format!("c{comp}/g{g}"));}@@ -1468,7 +1481,7 @@ fn component_rows_inner(}// Bodies and sketches dropped on a component move into it.if let Some(resp) = &r.resp- && let Some(d) = drop_target(ui, resp, |d: &Drag| d.comp != id && d.folder != "construction", DropMark::Box)+ && let Some(d) = drop_target(ui, resp, |d: &Drag| d.comp != id && d.folder != "construction" && d.groups.is_empty(), DropMark::Box){acts.drop = Some(DropAction::Component { to: id, folder: d.folder, keys: d.keys.clone() });}@@ -1654,14 +1667,33 @@ fn occurrence_rows_inner(acts.menu = Some((p, Target::Occurrence { path: path.to_vec() }));}if let Some(resp) = &r.resp- && let Some(d) = drop_target(ui, resp, |d: &Drag| d.comp != placement.component && d.folder != "construction", DropMark::Box)+ && let Some(d) =+ drop_target(ui, resp, |d: &Drag| d.comp != placement.component && d.folder != "construction" && d.groups.is_empty(), DropMark::Box){acts.drop = Some(DropAction::Component { to: placement.component, folder: d.folder, keys: d.keys.clone() });}+ // The top of a sibling's row puts the dragged placement before it; the rest of the row, and+ // any other row, moves the placement into this row's component.+ let top = r.resp.as_ref().is_some_and(|resp| pointer_in_top(ui, resp.rect));+ if let Some(resp) = &r.resp+ && top+ && let Some(d) = occurrence_reorder_target(ui, resp, |d| occurrence_sibling(app, d, placement.occurrence).is_some())+ && let Some(parent) = occurrence_sibling(app, &d, placement.occurrence)+ {+ let dragged = d.path.last().copied().unwrap_or(0);+ let mut order: Vec<u64> = app.session.doc.occurrences.iter().filter(|o| o.parent == parent && o.id != dragged).map(|o| o.id).collect();+ app.session.doc.sort_placements(parent, &mut order);+ let at = order.iter().position(|o| *o == placement.occurrence).unwrap_or(order.len());+ order.insert(at, dragged);+ let order: Vec<String> = order.iter().map(u64::to_string).collect();+ let _ = app.run("browser.order", json!({ "folder": "components", "component": parent, "order": order }));+ }// A placement row dropped on this one moves into this row's component.if let Some(resp) = &r.resp- && let Some(d) = occurrence_drop_target(ui, resp, |d| occurrence_can_land(app, d, placement.component))+ && let Some(d) = occurrence_drop_target(ui, resp, |d| {+ occurrence_can_land(app, d, placement.component) && !(top && occurrence_sibling(app, d, placement.occurrence).is_some())+ }){let occurrence = d.path.last().copied().unwrap_or(0);acts.drop = Some(DropAction::Reparent { occurrence, path: d.path.clone(), parent: placement.component, parent_path: Some(path.to_vec()) });@@ -2308,6 +2340,15 @@ struct Drag {comp: u64,folder: &'static str,keys: Vec<String>,+ /// Groups dragged by their rows (alone: a drag carries items or groups).+ groups: Vec<u64>,+}++impl Drag {+ /// What is dragged, as the browser commands name it.+ fn entries(&self) -> Vec<BrowserEntry> {+ self.keys.iter().map(|k| BrowserEntry::item(k)).chain(self.groups.iter().map(|g| BrowserEntry::Group(*g))).collect()+ }}/// A placement row dragged in the tree: the exact path it sits at, and the component it places.@@ -2344,34 +2385,56 @@ fn construction_sel(f: &solidcraft_engine::doc::Feature) -> Sel {}}-/// A folder's groups (with their items) and the items in no group, in browser order.-fn arrange<'a>(- doc: &'a solidcraft_engine::doc::Document,- comp: u64,- folder: &str,- all: Vec<Entry>,-) -> (Vec<(&'a solidcraft_engine::doc::BrowserGroup, Vec<Entry>)>, Vec<Entry>) {- let mut rest: Vec<Option<Entry>> = all.into_iter().map(Some).collect();- let mut take = |key: &str| rest.iter_mut().find(|e| e.as_ref().is_some_and(|e| e.key == key)).and_then(Option::take);- let grouped: Vec<_> = doc- .browser_groups- .iter()- .filter(|g| g.component == comp && g.folder == folder)- .map(|g| {- let items = g.items.iter().filter_map(|k| take(k)).collect();- (g, items)- })- .collect();- let mut loose: Vec<Entry> = rest.into_iter().flatten().collect();- if let Some(order) = doc.browser_order.get(&format!("{comp}/{folder}")) {- let mut positions = std::collections::HashMap::with_capacity(order.len());- for (i, key) in order.iter().enumerate() {- positions.entry(key.as_str()).or_insert(i);+/// A folder's rows in browser order (see `Document::ordered_entries`), then the items in no list+/// in their natural order. A group's rows are ordered the same way by its own list. `prefix` is+/// the scope the groups' tree keys start with.+fn arrange(doc: &solidcraft_engine::doc::Document, comp: u64, folder: &str, prefix: &str, all: Vec<Entry>) -> Vec<cache::Row> {+ use cache::Row;+ use solidcraft_engine::doc::BrowserEntry;+ let mut index: std::collections::HashMap<String, usize> = std::collections::HashMap::with_capacity(all.len());+ for (i, e) in all.iter().enumerate() {+ index.entry(e.key.clone()).or_insert(i);+ }+ let mut pool: Vec<Option<Entry>> = all.into_iter().map(Some).collect();+ let mut take = |key: &str| index.get(key).and_then(|i| pool[*i].take()).map(|e| Row::Item(Box::new(e)));+ fn build(+ doc: &solidcraft_engine::doc::Document,+ comp: u64,+ folder: &str,+ prefix: &str,+ id: u64,+ left: usize,+ take: &mut dyn FnMut(&str) -> Option<Row>,+ ) -> Option<cache::Group> {+ let g = doc.browser_group(id)?;+ let mut rows = Vec::new();+ for e in doc.ordered_entries(comp, folder, Some(id)) {+ match e {+ BrowserEntry::Item(k) => rows.extend(take(&k)),+ BrowserEntry::Group(c) if left > 0 => rows.extend(build(doc, comp, folder, prefix, c, left - 1, take).map(Row::Group)),+ BrowserEntry::Group(_) => {}+ }}- let pos = |k: &str| positions.get(k).copied().unwrap_or(usize::MAX);- loose.sort_by_key(|e| pos(&e.key));+ let count = rows.iter().map(Row::count).sum();+ Some(cache::Group { id, key: format!("{prefix}/g{id}"), label: format!("{} ({count})", g.name), count, rows })}- (grouped, loose)+ let order = doc.ordered_entries(comp, folder, None);+ // Groups first, so an item in a group is never also listed loose.+ let mut groups: std::collections::HashMap<u64, cache::Group> = std::collections::HashMap::new();+ for e in &order {+ if let BrowserEntry::Group(id) = e {+ groups.extend(build(doc, comp, folder, prefix, *id, solidcraft_engine::doc::MAX_GROUP_NESTING, &mut take).map(|g| (*id, g)));+ }+ }+ let mut rows = Vec::new();+ for e in order {+ match e {+ BrowserEntry::Group(id) => rows.extend(groups.remove(&id).map(Row::Group)),+ BrowserEntry::Item(k) => rows.extend(take(&k)),+ }+ }+ rows.extend(pool.into_iter().flatten().map(|e| Row::Item(Box::new(e))));+ rows}/// Show or hide items of a folder, through `browser.visibility` so each is an undo step (#2219).@@ -2452,14 +2515,12 @@ fn folder_rows_at({app.tree.collapsed.remove(key);app.tree.collapsed.remove(&format!("c{comp}"));- for g in app.session.doc.browser_groups.iter().filter(|g| g.items.contains(&e.key)) {- app.tree.collapsed.remove(&format!("g{}", g.id));- }+ open_group_chain(app, "", comp, "bodies", &e.key);}// A folded folder draws no row: its groups and items move up into its place, and their own// eyes, hover and drops do its jobs. It is always open, as nothing could open it again.let render = crate::render_workspace::active(app);- let folded = !render && folder == "bodies" && bodies_folded(app, comp, prefix, data.entries().count());+ let folded = !render && folder == "bodies" && bodies_folded(app, comp, prefix, data.count);// With the history in the browser the sketches are there too: their folder starts closed.let default_open = !(folder == "sketches" && app.preferences.history_in_browser);let open = folded || is_open(app, key, default_open);@@ -2483,7 +2544,7 @@ fn folder_rows_at(icon: "folder",label: folder_label(folder),dim: folder_faded,- mark: acts.lit.branch(app, data.entries()),+ mark: if acts.lit.any() { acts.lit.branch(app, data.entries()) } else { Mark::None },..Default::default()},)@@ -2512,10 +2573,21 @@ fn folder_rows_at(// from another component's folder move into this component, as a drop on its row does// (#3270: the Bodies folder looked like the place to drop a body, and took nothing).if let Some(resp) = &r.resp- && let Some(d) = drop_target(ui, resp, |d: &Drag| d.folder == fstatic && (d.comp == comp || d.folder != "construction"), DropMark::Box)+ && let Some(d) = drop_target(+ ui,+ resp,+ |d: &Drag| d.folder == fstatic && (d.comp == comp || (d.folder != "construction" && d.groups.is_empty())),+ DropMark::Box,+ ){acts.drop = Some(if d.comp == comp {- DropAction::Move { comp, folder: fstatic, keys: d.keys.clone(), group: None, before: None }+ DropAction::Order {+ comp,+ folder: fstatic,+ keys: d.keys.clone(),+ groups: d.groups.clone(),+ order: order_before(&data.top_order, &d.entries(), None),+ }} else {DropAction::Component { to: comp, folder: d.folder, keys: d.keys.clone() }});@@ -2524,28 +2596,56 @@ fn folder_rows_at(return;}}- let loose_keys = &data.loose_keys;- if render {- for e in &data.loose {- entry_row(app, ui, comp, path, fstatic, e, depth + 1, None, loose_keys, folder_faded, acts);- }- }- for group in &data.groups {- let (id, items, gkey) = (group.id, &group.items, &group.key);+ folder_level(app, ui, comp, path, fstatic, prefix, &data.rows, None, inner, &data.top_order, folder_faded, acts);+}++/// The rows of a folder's top level, or of one group (`holder`), at `depth`; groups draw their+/// own rows the same way one level deeper. `top` is the folder's top-level order as drawn.+#[allow(clippy::too_many_arguments)]+fn folder_level(+ app: &mut SolveApp,+ ui: &mut egui::Ui,+ comp: u64,+ path: Option<&[u64]>,+ fstatic: &'static str,+ prefix: &str,+ rows: &[cache::Row],+ holder: Option<u64>,+ depth: usize,+ top: &[BrowserEntry],+ faded: bool,+ acts: &mut Actions,+) {+ let render = crate::render_workspace::active(app);+ // The render workspace has always listed a folder's loose items above its groups.+ let items_first = render && holder.is_none();+ let rows = rows+ .iter()+ .filter(|r| items_first && matches!(r, cache::Row::Item(_)))+ .chain(rows.iter().filter(|r| !items_first || matches!(r, cache::Row::Group(_))));+ for row in rows {+ let group = match row {+ cache::Row::Item(e) => {+ entry_row(app, ui, comp, path, fstatic, e, depth, holder, top, faded, acts);+ continue;+ }+ cache::Row::Group(g) => g,+ };+ let (id, gkey) = (group.id, &group.key);let gopen = is_open(app, gkey, true);let gshown = !app.session.folder_hidden(gkey);- let group_faded = folder_faded || !gshown;+ let group_faded = faded || !gshown;let label = if render {app.session.doc.browser_groups.iter().find(|g| g.id == id).map_or(group.label.as_str(), |g| g.name.as_str())} else {&group.label};- let count = if render && !gopen { crate::i18n::format("render.tree_more", &[("count", &items.len().to_string())]) } else { String::new() };+ let count = if render && !gopen { crate::i18n::format("render.tree_more", &[("count", &group.count.to_string())]) } else { String::new() };let r = draw_row(ui,ui.id().with(gkey),&Row {- depth: inner,+ depth,fold: Some(gopen),eye: (!render || gopen).then_some(gshown),icon: if render { "" } else { "folder" },@@ -2553,14 +2653,14 @@ fn folder_rows_at(name: true,dim: group_faded || (render && !gopen),count: &count,- mark: acts.lit.branch(app, items),+ mark: if acts.lit.any() { acts.lit.branch(app, group.entries()) } else { Mark::None },..Default::default()},);if r.fold {toggle(app, gkey, true);} else if r.clicked {- let names: Vec<String> = items.iter().flat_map(|e| e.bodies.clone()).collect();+ let names: Vec<String> = group.entries().into_iter().flat_map(|e| e.bodies.clone()).collect();if !offer_bodies(app, &names, Take::Toggle) {pick_folder(app, gkey);toggle(app, gkey, true);@@ -2570,27 +2670,62 @@ fn folder_rows_at(toggle_folder(app, gkey);}if r.hovered {- acts.hover(items.iter().flat_map(|e| &e.bodies));+ acts.hover(group.entries().into_iter().flat_map(|e| &e.bodies));}if let Some(p) = r.secondary {acts.menu = Some((p, Target::Group { id, scope: prefix.to_owned() }));}- if let Some(resp) = &r.resp- && let Some(d) = drop_target(ui, resp, |d: &Drag| d.comp == comp && d.folder == fstatic, DropMark::Box)- {- acts.drop = Some(DropAction::Move { comp, folder: fstatic, keys: d.keys.clone(), group: Some(id), before: None });+ if let Some(resp) = &r.resp {+ // Dragging a group row moves the group; a press on its arrow or eye is not a drag.+ if resp.drag_started() && !r.on_control {+ resp.dnd_set_drag_payload(Drag { comp, folder: fstatic, keys: Vec::new(), groups: vec![id] });+ }+ // The top of the row puts the drop before the group; the rest puts it inside.+ let level = app.session.doc.group_level(id);+ let fits = |d: &Drag, parent_level: usize| {+ let doc = &app.session.doc;+ d.groups.iter().all(|g| !doc.group_within(id, *g) && parent_level + doc.group_height(*g) <= solidcraft_engine::doc::MAX_GROUP_NESTING)+ };+ if let Some((d, zone)) = drop_target_zone(ui, resp, |d: &Drag, zone| {+ d.comp == comp && d.folder == fstatic && fits(d, if zone == DropMark::Above { level - 1 } else { level })+ }) {+ let before = BrowserEntry::Group(id);+ acts.drop = Some(match (zone, holder) {+ (DropMark::Box, _) => {+ DropAction::Move { comp, folder: fstatic, keys: d.keys.clone(), groups: d.groups.clone(), group: Some(id), before: None }+ }+ (DropMark::Above, Some(h)) => DropAction::Move {+ comp,+ folder: fstatic,+ keys: d.keys.clone(),+ groups: d.groups.clone(),+ group: Some(h),+ before: Some(before),+ },+ (DropMark::Above, None) => DropAction::Order {+ comp,+ folder: fstatic,+ order: order_before(top, &d.entries(), Some(&before)),+ keys: d.keys.clone(),+ groups: d.groups.clone(),+ },+ });+ }}if gopen {- for e in items {- entry_row(app, ui, comp, path, fstatic, e, inner + 1, Some(id), loose_keys, group_faded, acts);- }+ folder_level(app, ui, comp, path, fstatic, prefix, &group.rows, Some(id), depth + 1, top, group_faded, acts);}}- if !render {- for e in &data.loose {- entry_row(app, ui, comp, path, fstatic, e, inner, None, loose_keys, folder_faded, acts);- }+}++/// `top` with the dragged entries moved to just before `before` (to the end without it).+fn order_before(top: &[BrowserEntry], dragged: &[BrowserEntry], before: Option<&BrowserEntry>) -> Vec<BrowserEntry> {+ let mut order: Vec<BrowserEntry> = top.iter().filter(|e| !dragged.contains(e)).cloned().collect();+ let at = before.and_then(|b| order.iter().position(|e| e == b)).unwrap_or(order.len());+ for (i, e) in dragged.iter().enumerate() {+ order.insert(at + i, e.clone());}+ order}/// The body's name edited in its row (started by a double-click): Enter or leaving the box keeps@@ -2638,7 +2773,7 @@ fn entry_row(e: &Entry,depth: usize,group: Option<u64>,- loose: &[String],+ top: &[BrowserEntry],// A placement or folder above is hidden: the row fades, its eye stays its own.parent_hidden: bool,acts: &mut Actions,@@ -2768,19 +2903,26 @@ fn entry_row(// Drag: the selected items of this folder when this one is selected, else just this one.if resp.drag_started() && !r.on_control {let keys: Vec<String> = if selected { selected_keys(app, comp, folder) } else { vec![e.key.clone()] };- resp.dnd_set_drag_payload(Drag { comp, folder, keys });+ resp.dnd_set_drag_payload(Drag { comp, folder, keys, groups: Vec::new() });}- if let Some(d) = drop_target(ui, resp, |d: &Drag| d.comp == comp && d.folder == folder && !d.keys.contains(&e.key), DropMark::Above) {+ let fits = |d: &Drag| {+ let doc = &app.session.doc;+ let level = group.map_or(0, |g| doc.group_level(g));+ d.groups+ .iter()+ .all(|g| group.is_none_or(|h| !doc.group_within(h, *g)) && level + doc.group_height(*g) <= solidcraft_engine::doc::MAX_GROUP_NESTING)+ };+ if let Some(d) = drop_target(ui, resp, |d: &Drag| d.comp == comp && d.folder == folder && !d.keys.contains(&e.key) && fits(d), DropMark::Above) {+ let before = BrowserEntry::item(&e.key);acts.drop = Some(match group {- Some(g) => DropAction::Move { comp, folder, keys: d.keys.clone(), group: Some(g), before: Some(e.key.clone()) },- None => {- let mut order: Vec<String> = loose.iter().filter(|k| !d.keys.contains(k)).cloned().collect();- let at = order.iter().position(|k| *k == e.key).unwrap_or(order.len());- for (i, k) in d.keys.iter().enumerate() {- order.insert(at + i, k.clone());- }- DropAction::Order { comp, folder, keys: d.keys.clone(), order }- }+ Some(g) => DropAction::Move { comp, folder, keys: d.keys.clone(), groups: d.groups.clone(), group: Some(g), before: Some(before) },+ None => DropAction::Order {+ comp,+ folder,+ order: order_before(top, &d.entries(), Some(&before)),+ keys: d.keys.clone(),+ groups: d.groups.clone(),+ },});}}@@ -2818,6 +2960,26 @@ fn drop_target(ui: &egui::Ui, resp: &egui::Response, accept: impl Fn(&Drag) -> bresp.dnd_release_payload::<Drag>().filter(|d| accept(d))}+/// Like [`drop_target`] for a row that takes a drop above it (its top part) or inside it.+fn drop_target_zone(ui: &egui::Ui, resp: &egui::Response, accept: impl Fn(&Drag, DropMark) -> bool) -> Option<(std::sync::Arc<Drag>, DropMark)> {+ let t = Tokens::get();+ let r = resp.rect;+ let at = ui.input(|i| i.pointer.hover_pos().or(i.pointer.latest_pos()));+ let zone = if at.is_some_and(|p| p.y < r.top() + r.height() * 0.3) { DropMark::Above } else { DropMark::Box };+ if resp.dnd_hover_payload::<Drag>().is_some_and(|d| accept(&d, zone)) {+ match zone {+ DropMark::Above => ui.painter().hline(r.x_range(), r.top(), Stroke::new(2.0, t.accent)),+ DropMark::Box => {+ ui.painter().rect_stroke(r.shrink(0.5), t.radius_sm.saturating_sub(1), Stroke::new(1.5, t.accent), egui::StrokeKind::Inside)+ }+ };+ }+ if !egui::DragAndDrop::has_payload_of_type::<Drag>(ui.ctx()) {+ return None;+ }+ resp.dnd_release_payload::<Drag>().filter(|d| accept(d, zone)).map(|d| (d, zone))+}+/// Whether a placement dragged from `d` may land in component `parent`: not where it already is,/// and not in itself or a component it holds. The command refuses those too; this keeps the row/// from showing a drop mark it would refuse.@@ -2832,6 +2994,35 @@ fn occurrence_can_land(app: &SolveApp, d: &OccurrenceDrag, parent: u64) -> boolo.parent != parent && !app.session.doc.inside_component(parent, d.component)}+/// Whether the pointer is over the top part of a row (where a drop goes before it).+fn pointer_in_top(ui: &egui::Ui, row: Rect) -> bool {+ ui.input(|i| i.pointer.hover_pos().or(i.pointer.latest_pos())).is_some_and(|p| p.y < row.top() + row.height() * 0.3)+}++/// The component a placement shares with the placement under it, when both sit in the same one+/// (and are two placements): the parent whose sub-components they are ordered among.+fn occurrence_sibling(app: &SolveApp, d: &OccurrenceDrag, target: u64) -> Option<u64> {+ let dragged = d.path.last().copied().filter(|o| *o != target)?;+ let occurrences = &app.session.doc.occurrences;+ let parent = occurrences.iter().find(|o| o.id == dragged)?.parent;+ occurrences.iter().any(|o| o.id == target && o.parent == parent).then_some(parent)+}++/// While a matching placement drag hovers the row, mark a drop before it; on release, the payload.+fn occurrence_reorder_target(+ ui: &egui::Ui,+ resp: &egui::Response,+ accept: impl Fn(&OccurrenceDrag) -> bool,+) -> Option<std::sync::Arc<OccurrenceDrag>> {+ if resp.dnd_hover_payload::<OccurrenceDrag>().is_some_and(|d| accept(&d)) {+ ui.painter().hline(resp.rect.x_range(), resp.rect.top(), Stroke::new(2.0, Tokens::get().accent));+ }+ if !egui::DragAndDrop::has_payload_of_type::<OccurrenceDrag>(ui.ctx()) {+ return None;+ }+ resp.dnd_release_payload::<OccurrenceDrag>().filter(|d| accept(d))+}+/// While a matching placement drag hovers the row, mark where it would land; on release, the payload.fn occurrence_drop_target(ui: &egui::Ui, resp: &egui::Response, accept: impl Fn(&OccurrenceDrag) -> bool) -> Option<std::sync::Arc<OccurrenceDrag>> {let t = Tokens::get();@@ -2850,22 +3041,37 @@ fn occurrence_drop_target(ui: &egui::Ui, resp: &egui::Response, accept: impl Fn(/// A drop, applied after the tree is drawn.enum DropAction {/// Into a group (before an item of it), or out of groups.- Move { comp: u64, folder: &'static str, keys: Vec<String>, group: Option<u64>, before: Option<String> },- /// Out of groups, in this order of the folder's loose items.- Order { comp: u64, folder: &'static str, keys: Vec<String>, order: Vec<String> },+ Move { comp: u64, folder: &'static str, keys: Vec<String>, groups: Vec<u64>, group: Option<u64>, before: Option<BrowserEntry> },+ /// Out of groups, in this order of the folder's top level.+ Order { comp: u64, folder: &'static str, keys: Vec<String>, groups: Vec<u64>, order: Vec<BrowserEntry> },/// Into another component (bodies and sketches).Component { to: u64, folder: &'static str, keys: Vec<String> },/// A placement moved into another component (or the design, `parent` 0).Reparent { occurrence: u64, path: Vec<u64>, parent: u64, parent_path: Option<Vec<u64>> },}+fn entry_json(e: &BrowserEntry) -> Value {+ match e {+ BrowserEntry::Group(id) => json!(id),+ BrowserEntry::Item(k) => json!(k),+ }+}++/// Items (strings) and groups (numbers), as the browser commands take them.+fn entries_json(keys: &[String], groups: &[u64]) -> Vec<Value> {+ keys.iter().map(|k| json!(k)).chain(groups.iter().map(|g| json!(g))).collect()+}+fn apply_drop(app: &mut SolveApp, d: DropAction) {match d {- DropAction::Move { comp, folder, keys, group, before } => {- let _ = app.run("browser.move", json!({ "component": comp, "folder": folder, "items": keys, "group": group, "before": before }));- }- DropAction::Order { comp, folder, keys, order } => {- let _ = app.run("browser.move", json!({ "component": comp, "folder": folder, "items": keys }));+ DropAction::Move { comp, folder, keys, groups, group, before } => {+ let items = entries_json(&keys, &groups);+ let before = before.map(|b| entry_json(&b));+ let _ = app.run("browser.move", json!({ "component": comp, "folder": folder, "items": items, "group": group, "before": before }));+ }+ DropAction::Order { comp, folder, keys, groups, order } => {+ let _ = app.run("browser.move", json!({ "component": comp, "folder": folder, "items": entries_json(&keys, &groups) }));+ let order: Vec<Value> = order.iter().map(entry_json).collect();let _ = app.run("browser.order", json!({ "component": comp, "folder": folder, "order": order }));}DropAction::Component { to, folder, keys } => {diff --git a/crates/ui-egui/src/browser_cache.rs b/crates/ui-egui/src/browser_cache.rsindex 50e2b96f4b..657343a183 100644--- a/crates/ui-egui/src/browser_cache.rs+++ b/crates/ui-egui/src/browser_cache.rs@@ -25,24 +25,63 @@ pub(super) struct Node {pub folders: [Option<Folder>; 3],}+/// A row of a folder or group: an item, or a group with its own rows.+pub(super) enum Row {+ Item(Box<Entry>),+ Group(Group),+}++impl Row {+ pub fn count(&self) -> usize {+ match self {+ Row::Item(_) => 1,+ Row::Group(g) => g.count,+ }+ }+}+pub(super) struct Group {pub id: u64,pub key: String,pub label: String,- pub items: Vec<Entry>,+ /// How many items it holds, groups inside it included.+ pub count: usize,+ pub rows: Vec<Row>,+}++fn collect<'a>(rows: &'a [Row], out: &mut Vec<&'a Entry>) {+ for r in rows {+ match r {+ Row::Item(e) => out.push(e),+ Row::Group(g) => collect(&g.rows, out),+ }+ }+}++impl Group {+ /// Everything in the group, groups inside it included, in display order.+ pub fn entries(&self) -> Vec<&Entry> {+ let mut all = Vec::new();+ collect(&self.rows, &mut all);+ all+ }}#[derive(Default)]pub(super) struct Folder {pub key: String,- pub groups: Vec<Group>,- pub loose: Vec<Entry>,- pub loose_keys: Vec<String>,+ pub rows: Vec<Row>,+ /// The top-level rows as drawn: the order a drop among them keeps.+ pub top_order: Vec<solidcraft_engine::doc::BrowserEntry>,+ /// How many items the folder holds, groups included.+ pub count: usize,}impl Folder {pub fn entries(&self) -> impl Iterator<Item = &Entry> {- self.groups.iter().flat_map(|g| &g.items).chain(&self.loose)+ let mut all = Vec::new();+ collect(&self.rows, &mut all);+ all.into_iter()}}@@ -190,16 +229,15 @@ impl Cache {if all.is_empty() {return Folder::default();}- let (groups, loose) = arrange(&doc, component, folder, all);- let loose_keys = loose.iter().map(|e| e.key.clone()).collect();- let groups = groups- .into_iter()- .map(|(group, items)| {- let key = format!("{prefix}/g{}", group.id);- let label = format!("{} ({})", group.name, items.len());- Group { id: group.id, key, label, items }+ let rows = arrange(&doc, component, folder, &prefix, all);+ let top_order = rows+ .iter()+ .map(|r| match r {+ Row::Item(e) => solidcraft_engine::doc::BrowserEntry::item(&e.key),+ Row::Group(g) => solidcraft_engine::doc::BrowserEntry::Group(g.id),}).collect();- Folder { key: format!("{prefix}/{folder}"), groups, loose, loose_keys }+ let count = rows.iter().map(Row::count).sum();+ Folder { key: format!("{prefix}/{folder}"), rows, top_order, count }}}diff --git a/crates/ui-egui/src/browser_card_tests.rs b/crates/ui-egui/src/browser_card_tests.rsindex 1d2f923c71..7a778c9223 100644--- a/crates/ui-egui/src/browser_card_tests.rs+++ b/crates/ui-egui/src/browser_card_tests.rs@@ -268,7 +268,7 @@ fn card_and_column_keep_body_eyes_menus_and_group_drops() {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:?}");+ assert!(group.has_item("Two"), "body drop into the folder failed in {mode:?}");}}@@ -797,3 +797,32 @@ fn an_eye_at_the_row_end_takes_its_click_from_the_scroll_bar() {assert_eq!(h.app.session.visibility.hidden_sketches.len(), 1, "the eye hides its sketch");assert_eq!(handle_at("row:Sketch3"), Some(row), "the list did not scroll");}++/// Dragging a group's row onto the middle of another group's row nests it; onto the top of a row+/// puts it before that group. A group cannot be dropped into one of its own groups.+#[test]+fn a_group_dragged_onto_another_group_nests_in_it_or_goes_before_it() {+ let mut h = Harness::new();+ let ids: Vec<u64> = ["Alpha", "Beta", "Gamma"]+ .into_iter()+ .enumerate()+ .map(|(i, name)| {+ h.app.run("solid.box", json!({"length":10,"width":10,"height":10,"corner":[i as f64 * 20.0,0,0],"body_name":name})).unwrap();+ h.app.run("browser.group", json!({"component":0,"folder":"bodies","items":[name],"name":name})).unwrap()["group"].as_u64().unwrap()+ })+ .collect();+ let (alpha, beta, gamma) = (ids[0], ids[1], ids[2]);+ h.settle();+ let drag = |h: &mut Harness, from: &str, to: &str, dy: f32| {+ let (from, to) = (handle_at(from).unwrap(), handle_at(to).unwrap());+ assert_eq!(h.call("ui.drag", json!({"x0":from.x,"y0":from.y,"x1":to.x,"y1":to.y + dy,"steps":12}))["ok"], true);+ h.settle();+ };+ let parent = |h: &Harness, id: u64| h.app.session.doc.browser_group(id).unwrap().parent;+ drag(&mut h, "row:Alpha (1)", "row:Beta (1)", 0.0);+ assert_eq!(parent(&h, alpha), Some(beta));+ drag(&mut h, "row:Beta (2)", "row:Alpha (1)", 0.0);+ assert_eq!(parent(&h, beta), None, "a group does not go into its own group");+ drag(&mut h, "row:Gamma (1)", "row:Beta (2)", -10.0);+ assert_eq!(h.app.session.doc.ordered_entries(0, "bodies", None), [BrowserEntry::Group(gamma), BrowserEntry::Group(beta)]);+}diff --git a/crates/ui-egui/src/browser_model.rs b/crates/ui-egui/src/browser_model.rsindex 1def459676..1ebd09261b 100644--- a/crates/ui-egui/src/browser_model.rs+++ b/crates/ui-egui/src/browser_model.rs@@ -49,6 +49,10 @@ impl Model {for occurrence in &session.doc.occurrences {children.entry(occurrence.parent).or_default().push(occurrence.id);}+ // Sub-components in the order the design saved for them; the rest follow in placement order.+ for (parent, ids) in &mut children {+ session.doc.sort_placements(*parent, ids);+ }Self {doc: session.doc.clone(),state,diff --git a/crates/ui-egui/src/browser_model_tests.rs b/crates/ui-egui/src/browser_model_tests.rsindex 9e69310237..4ecc11ca6b 100644--- a/crates/ui-egui/src/browser_model_tests.rs+++ b/crates/ui-egui/src/browser_model_tests.rs@@ -420,3 +420,45 @@ fn the_edited_sketch_is_marked_in_the_users_language() {let rows = super::entries(&h.app, 0, "sketches");assert_eq!(rows.iter().map(|r| r.label.as_str()).collect::<Vec<_>>(), ["スケッチ1 (編集中)"]);}++/// A design saved before groups could nest or be ordered shows the browser it always did: the+/// groups in creation order, each with its items, above the loose items, which follow the saved+/// order and leave the ones it does not name to the end. That layout is spelled out here and+/// compared with the rows drawn now, including a saved order that still names a grouped item.+#[test]+fn a_design_saved_before_nested_groups_keeps_its_browser_order() {+ use super::cache::Row;+ const BODIES: [&str; 5] = ["Plate", "Washer", "Bolt", "Nut", "Cap"];+ fn drawn(rows: &[Row]) -> Vec<String> {+ rows.iter()+ .map(|r| match r {+ Row::Item(e) => e.key.clone(),+ Row::Group(g) => format!("{{{}: {}}}", g.label, drawn(&g.rows).join(",")),+ })+ .collect()+ }+ let cases: [(&[(&str, &[&str])], &[&str]); 3] = [+ (&[("Fasteners", &["Bolt", "Nut"])], &[]),+ (&[("Fasteners", &["Bolt", "Nut"])], &["Washer", "Bolt", "Cap"]),+ (&[("Zeta", &["Plate"]), ("Alpha", &["Cap", "Washer"])], &["Cap", "Nut"]),+ ];+ for (groups, saved) in cases {+ let mut h = crate::scenario::Harness::new();+ for (i, name) in BODIES.iter().enumerate() {+ h.app.run("solid.box", json!({"length":10,"width":10,"height":10,"corner":[i as f64 * 20.0, 0, 0],"body_name":name})).unwrap();+ }+ for (name, items) in groups {+ h.app.run("browser.group", json!({"component":0,"folder":"bodies","name":name,"items":items})).unwrap();+ }+ if !saved.is_empty() {+ h.app.run("browser.order", json!({"folder":"bodies","order":saved})).unwrap();+ }+ // The old layout: groups in creation order, then the loose items by their saved place.+ let mut expected: Vec<String> = groups.iter().map(|(n, items)| format!("{{{n} ({}): {}}}", items.len(), items.join(","))).collect();+ let mut loose: Vec<&str> = BODIES.into_iter().filter(|b| !groups.iter().any(|(_, items)| items.contains(b))).collect();+ loose.sort_by_key(|b| saved.iter().position(|s| s == b).unwrap_or(usize::MAX));+ expected.extend(loose.into_iter().map(String::from));+ let rows = super::arrange(&h.app.session.doc, 0, "bodies", "c0", super::entries(&h.app, 0, "bodies"));+ assert_eq!(drawn(&rows), expected, "groups {groups:?}, saved order {saved:?}");+ }+}diff --git a/crates/ui-egui/src/edit_clipboard_tests.rs b/crates/ui-egui/src/edit_clipboard_tests.rsindex 609b5fa6f4..e37e8d7d92 100644--- a/crates/ui-egui/src/edit_clipboard_tests.rs+++ b/crates/ui-egui/src/edit_clipboard_tests.rs@@ -239,7 +239,7 @@ fn copied_sketch_survives_source_close_and_pastes_from_a_sketch_group_menu() {run_item(&mut h.app, &item, egui::Pos2::ZERO);let id = h.app.session.doc.find_feature("Sketch1").unwrap().id;assert_eq!(h.app.session.doc.sketch(id).unwrap().curves.len(), 4);- assert!(h.app.session.doc.browser_groups.iter().any(|g| g.id == group && g.items.contains(&id.to_string())));+ assert!(h.app.session.doc.browser_groups.iter().any(|g| g.id == group && g.has_item(&id.to_string())));// A later copy in this design replaces the cross-design snapshot everywhere.select(&mut h.app, json!({"type":"feature","id":id}));assert!(super::copy(&mut h.app));@@ -795,9 +795,7 @@ fn pasting_on_a_group_puts_the_copy_in_it() {assert!(item.enabled);run_item(app, &item, egui::Pos2::ZERO);};- let holds = |app: &crate::SolveApp, group: u64, key: &str| {- app.session.doc.browser_groups.iter().any(|g| g.id == group && g.items.iter().any(|k| k == key))- };+ let holds = |app: &crate::SolveApp, group: u64, key: &str| app.session.doc.browser_groups.iter().any(|g| g.id == group && g.has_item(key));select(&mut app, json!({"type": "body", "name": "Cube"}));assert!(super::copy(&mut app));paste_on(&mut app, bodies);diff --git a/crates/ui-egui/src/menu_tests.rs b/crates/ui-egui/src/menu_tests.rsindex d3c1b7cb76..f52ff5e95a 100644--- a/crates/ui-egui/src/menu_tests.rs+++ b/crates/ui-egui/src/menu_tests.rs@@ -587,9 +587,9 @@ fn folder_and_group_menus_make_rename_and_drop_groups() {act(&mut app, &t, "Show/Hide");assert!(app.session.visibility.hidden_bodies.is_empty());assert!(app.session.folder_hidden(&format!("c0/g{}", g.id)));- assert!(g.items.iter().all(|b| !app.session.body_visible(b)));+ assert!(g.item_keys().all(|b| !app.session.body_visible(b)));act(&mut app, &t, "Show/Hide");- assert!(g.items.iter().all(|b| app.session.body_visible(b)));+ assert!(g.item_keys().all(|b| app.session.body_visible(b)));act(&mut app, &t, "Ungroup");assert!(app.session.doc.browser_groups.is_empty());act(&mut app, &folder, "New Group");diff --git a/crates/ui-egui/src/occurrence_ui_tests.rs b/crates/ui-egui/src/occurrence_ui_tests.rsindex 165634eb5b..03abe02dd0 100644--- a/crates/ui-egui/src/occurrence_ui_tests.rs+++ b/crates/ui-egui/src/occurrence_ui_tests.rs@@ -493,7 +493,7 @@ fn a_folded_folders_menu_items_move_to_the_placements_menu() {let group = context_menu::items(&h.app, &target).into_iter().find(|i| i.id == "ui.groupSelected").unwrap();context_menu::run_item(&mut h.app, &group, egui::Pos2::ZERO);let made = h.app.session.doc.browser_groups.iter().find(|g| g.component == component).unwrap();- assert_eq!(made.items, ["Body1", "Second"]);+ assert_eq!(made.item_keys().collect::<Vec<_>>(), ["Body1", "Second"]);h.app.preferences.browser_bodies_folders = BodiesFolders::Always;assert!(!has(&h, "component.from_bodies"), "Always: on the folder's own menu");}@@ -538,3 +538,26 @@ fn dragging_an_occurrence_row_onto_another_moves_it_into_that_component() {let o = h.app.session.doc.occurrences.iter().find(|o| o.id == a_occ).unwrap();assert_eq!(o.parent, 0, "A's occurrence moved back out to the design");}++/// Dropping a placement row on the top of a sibling's row puts it before that sibling, in the+/// order saved with the design; the rows follow. (The middle of a row moves it into that+/// component, as above.)+#[test]+fn dragging_an_occurrence_row_onto_the_top_of_a_sibling_reorders_them() {+ let mut h = Harness::new();+ let mut placed = Vec::new();+ for name in ["A", "B", "C"] {+ placed.push(h.app.run("component.create", json!({"name":name})).unwrap()["occurrence"].as_u64().unwrap());+ h.app.run("component.activate", json!({"component":0})).unwrap();+ }+ let [a, b, c] = [placed[0], placed[1], placed[2]];+ h.frames(3);+ let row = |id: u64| crate::scenario::handle_at(&format!("row:occurrence:{id}")).unwrap();+ let (from, to) = (row(c), row(a));+ assert_eq!(h.call("ui.drag", json!({"x0":from.x,"y0":from.y,"x1":to.x,"y1":to.y - 10.0,"steps":12}))["ok"], true);+ h.frames(3);+ let saved = &h.app.session.doc.browser_order["0/components"];+ assert_eq!(*saved, [c, a, b].map(|id| solidcraft_engine::doc::BrowserEntry::item(&id.to_string())));+ assert!(row(c).y < row(a).y && row(a).y < row(b).y, "the rows follow the saved order");+ assert!(h.app.session.doc.occurrences.iter().all(|o| o.parent == 0), "none moved into another");+}