Skip to content

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.rs
new file mode 100644
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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) -> b
resp.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) -> bool
o.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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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");
+}