SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Cache assembly browser data between unchanged frames (#662) (#1610)
Luke Jonesece2a8693a96
diff --git a/crates/ui-egui/src/browser.rs b/crates/ui-egui/src/browser.rsindex 66b5de014e..6b7ce8900d 100644--- a/crates/ui-egui/src/browser.rs+++ b/crates/ui-egui/src/browser.rs@@ -7,6 +7,9 @@//! ([`crate::context_menu`]).use crate::ui_kit::{Container, Surface};++#[path = "browser_cache.rs"]+mod cache;#[cfg(test)]#[path = "occurrence_ui_tests.rs"]mod occurrence_ui_tests;@@ -145,6 +148,22 @@ pub struct TreeState {/// The previous frame's complete row order: a Shift click resolves its range here, since/// this frame's `order` does not yet hold the rows below the clicked one (#4991).order_prev: Vec<String>,+ order_len: usize,+ cache: Option<cache::Cache>,+}++impl TreeState {+ fn remember(&mut self, key: &str) {+ if let Some(slot) = self.order.get_mut(self.order_len) {+ if slot != key {+ slot.clear();+ slot.push_str(key);+ }+ } else {+ self.order.push(key.to_owned());+ }+ self.order_len += 1;+ }}/// Moving an occurrence: the offsets typed so far (pending until Capture Position).@@ -324,6 +343,10 @@ const INDENT: f32 = 14.0;/// Opacity of a dimmed row's icon (a hidden body, sketch, origin item, …).const DIM_ICON_OPACITY: f32 = 0.4;+fn row_rect(ui: &egui::Ui) -> Rect {+ Rect::from_min_size(ui.cursor().min, vec2(ui.available_width(), ROW_H))+}+/// One row's look.#[derive(Default)]pub(crate) struct Row<'a> {@@ -379,7 +402,7 @@ pub(crate) struct RowResp {pub(crate) fn draw_row(ui: &mut egui::Ui, id: egui::Id, row: &Row) -> RowResp {let t = Tokens::get();// Rows scrolled out of view only take their space: no widgets, no painting.- let r = Rect::from_min_size(ui.cursor().min, vec2(ui.available_width(), ROW_H));+ let r = row_rect(ui);if !ui.is_rect_visible(r) {ui.allocate_space(r.size());return RowResp { rect: Some(r), ..Default::default() };@@ -512,9 +535,10 @@ pub(crate) fn draw_row(ui: &mut egui::Ui, id: egui::Id, row: &Row) -> RowResp {fn click_select(app: &mut SolveApp, ui: &egui::Ui, key: String, sel: Option<Sel>) {let mods = ui.input(|i| i.modifiers);if mods.shift- && let Some(a) = app.tree.anchor.clone()+ && let Some(a) = app.tree.anchor.as_deref(){- let items = shift_range(&app.tree.order_prev, &a, &key).or_else(|| shift_range(&app.tree.order, &a, &key));+ let order = app.tree.order.get(..app.tree.order_len).unwrap_or(&[]);+ let items = shift_range(&app.tree.order_prev, a, &key).or_else(|| shift_range(order, a, &key));if let Some(items) = items {let _ = app.run("select.set", json!({ "items": items, "add": mods.command || mods.ctrl }));return;@@ -626,6 +650,7 @@ pub fn apply_fold(app: &mut SolveApp, open: bool, open_by_default: &[String], clstruct Actions {menu: Option<(Pos2, Target)>,hover_bodies: Vec<String>,+ hovered: bool,drop: Option<DropAction>,/// What the selection and the 3D view's pointer light in the tree.lit: Lit,@@ -721,25 +746,16 @@ impl Lit {(self.selected.contains(thing), self.hovered.as_ref() == Some(thing))}- /// The things a folder entry stands for.- fn entry_things(folder: &str, e: &Entry) -> Vec<Thing> {- match folder {- "bodies" => e.bodies.iter().cloned().map(Thing::Body).collect(),- "sketches" => e.key.parse().ok().map(Thing::Sketch).into_iter().collect(),- _ => vec![Thing::Plane(e.label.clone())],- }- }-/// Whether a folder entry is lit: (selected, under the pointer). Its own `selected` (picked/// in the tree, or the sketch being edited) counts as selected.- fn entry(&self, folder: &str, e: &Entry) -> (bool, bool) {- let things = Lit::entry_things(folder, e);- (e.selected || things.iter().any(|t| self.selected.contains(t)), things.iter().any(|t| self.hovered.as_ref() == Some(t)))+ fn entry(&self, app: &SolveApp, e: &Entry) -> (bool, bool) {+ let (selected, hovered) = self.thing(&e.thing);+ (e.is_selected(app) || selected, hovered)}/// The mark of a row holding these entries: a faint bar when any of them is lit.- fn branch<'e>(&self, folder: &str, entries: impl IntoIterator<Item = &'e Entry>) -> Mark {- if entries.into_iter().any(|e| self.entry(folder, e) != (false, false)) { Mark::Branch } else { Mark::None }+ fn branch<'e>(&self, app: &SolveApp, entries: impl IntoIterator<Item = &'e Entry>) -> Mark {+ if entries.into_iter().any(|e| self.entry(app, e) != (false, false)) { Mark::Branch } else { Mark::None }}/// The mark of a placement row: a faint bar when a lit body is placed in it or below it, or@@ -755,6 +771,24 @@ fn lit_row((selected, hovered): (bool, bool)) -> (bool, Mark) {(selected, if selected || hovered { Mark::Here } else { Mark::None })}+impl Actions {+ fn hover<'a>(&mut self, bodies: impl Iterator<Item = &'a String>) {+ let mut len = 0;+ for body in bodies {+ if let Some(slot) = self.hover_bodies.get_mut(len) {+ if slot != body {+ slot.clone_from(body);+ }+ } else {+ self.hover_bodies.push(body.clone());+ }+ len += 1;+ }+ self.hover_bodies.truncate(len);+ self.hovered = true;+ }+}+/// How narrow the browser sidebar may be dragged, and how wide (the viewport keeps the rest).const MIN_BROWSER_WIDTH: f32 = 170.0;const MAX_BROWSER_WIDTH: f32 = 620.0;@@ -785,10 +819,11 @@ pub(crate) fn resize_column(app: &mut SolveApp, ui: &egui::Ui, rect: Rect, widthpub fn browser(app: &mut SolveApp, ui: &mut egui::Ui) {let available = ui.available_rect_before_wrap();let t = Tokens::get();- app.tree.order_prev = std::mem::take(&mut app.tree.order);+ std::mem::swap(&mut app.tree.order_prev, &mut app.tree.order);+ app.tree.order_len = 0;DRAWN.with(|d| d.borrow_mut().clear());OCCURRENCES.with(|d| d.borrow_mut().clear());- let mut acts = Actions::default();+ let mut acts = Actions { hover_bodies: std::mem::take(&mut app.viewport.hover_bodies), ..Default::default() };let stacked = crate::timeline_left::stacked(app);let container =Container::new(ui.ctx(), Surface::Panel).joined(crate::ui_kit::DockEdges { left: true, top: true, bottom: stacked, ..Default::default() });@@ -969,6 +1004,7 @@ fn model_placement(app: &mut SolveApp, path: &[u64]) -> Option<std::sync::Arc<soapp.tree.model.as_mut()?.placement(&app.session, path)}+#[cfg(test)]fn model_children(app: &SolveApp, component: u64) -> Vec<u64> {match app.tree.model.as_ref().filter(|model| model.matches(&app.session)) {Some(model) => model.children.get(&component).cloned().unwrap_or_default(),@@ -1023,6 +1059,8 @@ fn browser_rows_hugging(app: &mut SolveApp, ui: &mut egui::Ui, acts: &mut Actionfn rows_scrolling(app: &mut SolveApp, ui: &mut egui::Ui, acts: &mut Actions, shrink_height: bool) {prepare_model(app);acts.lit = Lit::of(app);+ let mut cache = app.tree.cache.take().unwrap_or_default();+ cache.prepare(app);egui::ScrollArea::vertical()// The card may animate all the way down to its header..min_scrolled_height(0.0)@@ -1030,14 +1068,19 @@ fn rows_scrolling(app: &mut SolveApp, ui: &mut egui::Ui, acts: &mut Actions, shr.scroll_source(egui::scroll_area::ScrollSource { scroll_bar: true, mouse_wheel: true, ..egui::scroll_area::ScrollSource::NONE }).show(ui, |ui| {ui.spacing_mut().item_spacing.y = 0.0;- component_rows(app, ui, 0, 0, acts);+ component_rows(app, ui, 0, 0, acts, &mut cache);});// The row was reached and scrolled to, or isn't in the tree (a body a later feature removes):// either way the reveal is done.app.tree.reveal = None;+ app.tree.cache = Some(cache);}-fn finish_browser(app: &mut SolveApp, ui: &mut egui::Ui, acts: Actions) {+fn finish_browser(app: &mut SolveApp, ui: &mut egui::Ui, mut acts: Actions) {+ app.tree.order.truncate(app.tree.order_len);+ if !acts.hovered {+ acts.hover_bodies.clear();+ }app.viewport.hover_bodies = acts.hover_bodies;if let Some(d) = acts.drop {apply_drop(app, d);@@ -1062,28 +1105,40 @@ fn component_name(app: &SolveApp, id: u64) -> String {crate::dialogs_part_size::browser_label(app, id, &name)}-fn component_rows(app: &mut SolveApp, ui: &mut egui::Ui, id: u64, depth: usize, acts: &mut Actions) {- let t = Tokens::get();- let key = format!("c{id}");- let bodies = crate::context_menu::component_bodies(app, id);- if let Some(r) = app.tree.reveal.clone()- && (bodies.contains(&r) || model_children(app, id).into_iter().any(|o| reveals_in_occurrence(app, &[o])))+fn component_rows(app: &mut SolveApp, ui: &mut egui::Ui, id: u64, depth: usize, acts: &mut Actions, cache: &mut cache::Cache) {+ let mut root = std::mem::take(&mut cache.root);+ component_rows_inner(app, ui, id, depth, acts, cache, &mut root);+ cache.root = root;+}++fn component_rows_inner(+ app: &mut SolveApp,+ ui: &mut egui::Ui,+ id: u64,+ depth: usize,+ acts: &mut Actions,+ cache: &mut cache::Cache,+ root: &mut cache::Node,+) {+ let key = &root.key;+ if let Some(body) = app.tree.reveal.as_ref()+ && (cache.root_bodies.contains(body) || root.children.iter().any(|path| reveals_in_occurrence(app, path))){- app.tree.collapsed.remove(&key);+ app.tree.collapsed.remove(key);}- let open = is_open(app, &key, true);+ let open = is_open(app, key, true);let active = app.session.active_component == id;- let visible = bodies.is_empty() || bodies.iter().any(|b| !app.session.visibility.hidden_bodies.contains(b));- let grounded = app.session.doc.occurrence_of(id).is_some_and(|o| o.grounded);+ let bodies = &cache.root_bodies;+ let visible = id == 0 || bodies.is_empty() || bodies.iter().any(|b| !app.session.visibility.hidden_bodies.contains(b));let faded = app.session.active_component != 0 && !app.session.doc.component_within(id, app.session.active_component) && !active;- let name = component_name(app, id);- let badges: &[&str] = if grounded { &["pin"] } else { &[] };+ let name = &root.name;+ let badges: &[&str] = if root.grounded { &["pin"] } else { &[] };let row = Row {depth,fold: Some(open),eye: (id != 0).then_some(visible),icon: "component",- label: &name,+ label: name,name: true,selected: app.tree.picked_components.contains(&id),dim: faded,@@ -1095,7 +1150,7 @@ fn component_rows(app: &mut SolveApp, ui: &mut egui::Ui, id: u64, depth: usize,};let r = draw_row(ui, ui.id().with(("comp", id)), &row);if r.fold {- toggle(app, &key, true);+ toggle(app, key, true);}if r.radio {let _ = app.run("component.activate", json!({ "component": id }));@@ -1130,7 +1185,7 @@ fn component_rows(app: &mut SolveApp, ui: &mut egui::Ui, id: u64, depth: usize,}}if r.hovered {- acts.hover_bodies = bodies.clone();+ acts.hover(bodies.iter());}if let Some(p) = r.secondary {acts.menu = Some((p, Target::Component { id }));@@ -1152,64 +1207,83 @@ fn component_rows(app: &mut SolveApp, ui: &mut egui::Ui, id: u64, depth: usize,canvas_rows(app, ui, d, acts);analysis_rows(app, ui, d, acts);}- let _ = t;- for folder in ["bodies", "sketches", "construction"] {- folder_rows(app, ui, id, folder, d, acts);+ for (slot, folder) in root.folders.iter_mut().zip(["bodies", "sketches", "construction"]) {+ let data = slot.get_or_insert_with(|| cache.folder(app, id, None, folder));+ folder_rows_at(app, ui, id, None, folder, d, acts, data);}features::rows(app, ui, id, &[], d, acts);if id == 0 {crate::dialogs_assembly::browser_joints(app, ui, d);}- let children = model_children(app, id);- for occurrence in children {- occurrence_rows(app, ui, vec![occurrence], d, acts);+ for path in &root.children {+ occurrence_rows(app, ui, path, d, acts, cache);}}fn occurrence_key(path: &[u64]) -> String {- format!("o:{}", path.iter().map(u64::to_string).collect::<Vec<_>>().join("/"))+ use std::fmt::Write;+ let mut key = String::from("o:");+ for (i, id) in path.iter().enumerate() {+ if i != 0 {+ key.push('/');+ }+ let _ = write!(key, "{id}");+ }+ key}/// A placement, rather than a component definition: repeated child IDs remain distinct/// because their complete paths are the selection and row identity.-fn occurrence_rows(app: &mut SolveApp, ui: &mut egui::Ui, path: Vec<u64>, depth: usize, acts: &mut Actions) {- let Some(placement) = model_placement(app, &path) else { return };- let key = occurrence_key(&path);- if reveals_in_occurrence(app, &path) {- app.tree.collapsed.remove(&key);- }- let open = is_open(app, &key, true);- let active = app.session.active_occurrence_path.as_deref() == Some(path.as_slice())- || (app.session.active_occurrence_path.is_none()- && app.session.active_component == placement.component- && app.session.doc.first_path(placement.component) == path);- let visible = app.session.occurrence_visible(&path);- let own_visible = !app.session.occurrence_hidden(&path);- let selected = app.session.selection.contains(&Sel::Occurrence { path: path.clone() });- let faded = app.session.active_occurrence_path.as_ref().is_some_and(|p| !path.starts_with(p) && !p.starts_with(&path));+fn occurrence_rows(app: &mut SolveApp, ui: &mut egui::Ui, path: &[u64], depth: usize, acts: &mut Actions, cache: &mut cache::Cache) {+ // Own this cached row while drawing: children can populate the cache without copying it.+ let Some((path, mut placement)) = cache.take_occurrence(app, path) else { return };+ occurrence_rows_inner(app, ui, &path, depth, acts, cache, &mut placement);+ cache.occurrences.insert(path, placement);+}++fn occurrence_rows_inner(+ app: &mut SolveApp,+ ui: &mut egui::Ui,+ path: &[u64],+ depth: usize,+ acts: &mut Actions,+ cache: &mut cache::Cache,+ placement: &mut cache::Node,+) {+ let key = &placement.key;+ if reveals_in_occurrence(app, path) {+ app.tree.collapsed.remove(key);+ }+ let open = is_open(app, key, true);+ let on_screen = ui.is_rect_visible(row_rect(ui));+ let active = app.session.active_occurrence_path.as_deref() == Some(path)+ || (app.session.active_occurrence_path.is_none() && app.session.active_component == placement.component && placement.first);+ let visible = !on_screen || app.session.occurrence_visible(path);+ let own_visible = !on_screen || !app.session.occurrence_hidden(path);+ let selected = on_screen && app.session.selection.iter().any(|s| matches!(s, Sel::Occurrence { path: selected } if selected == path));+ let faded = app.session.active_occurrence_path.as_ref().is_some_and(|p| !path.starts_with(p) && !p.starts_with(path));let badges: &[&str] = if placement.grounded { &["pin"] } else { &[] };- let label = crate::dialogs_part_size::browser_label(app, placement.component, &placement.name);- app.tree.order.push(key.clone());+ app.tree.remember(key);let r = draw_row(ui,- ui.id().with(&key),+ ui.id().with(key),&Row {depth,fold: Some(open),eye: Some(own_visible),icon: "component",- label: &label,+ label: &placement.label,name: true,selected,dim: faded || !visible,radio: Some(active),badges,- mark: acts.lit.placement(&app.session.doc, &path, placement.component),+ mark: acts.lit.placement(&app.session.doc, path, placement.component),..Default::default()},);if let Some(rect) = r.rect.filter(|_| r.resp.is_some()) {- OCCURRENCES.with(|d| d.borrow_mut().push((path.clone(), placement.name.clone(), rect, open)));+ OCCURRENCES.with(|d| d.borrow_mut().push((path.to_vec(), placement.name.clone(), rect, open)));crate::scenario::publish_handle(&format!("row:occurrence:{}", key.trim_start_matches("o:")), pos2(rect.right() - 12.0, rect.center().y));let x = rect.left() + 2.0 + depth as f32 * INDENT;for (control, offset) in [("fold", 6.0), ("eye", 22.0), ("activate", 38.0)] {@@ -1217,24 +1291,19 @@ fn occurrence_rows(app: &mut SolveApp, ui: &mut egui::Ui, path: Vec<u64>, depth:}}if let Some(resp) = &r.resp {- let definition = app.session.doc.components.iter().find(|c| c.id == placement.component).map(|c| c.name.as_str()).unwrap_or("");- let location = path- .iter()- .filter_map(|id| app.session.doc.occurrences.iter().find(|o| o.id == *id))- .map(|o| o.name.as_str())- .collect::<Vec<_>>()- .join(" / ");let inherited = if own_visible && !visible { "\nHidden by a parent placement. Show the parent to reveal this instance." } else { "" };- resp.clone().on_hover_text(format!(- "Component: {definition}\nPlacement: {}\nGeometry edits apply to every instance of this component.{inherited}",- location- ));+ resp.clone().on_hover_ui(|ui| {+ ui.label(&placement.tooltip);+ if !inherited.is_empty() {+ ui.label(inherited.trim_start());+ }+ });}if r.fold {- toggle(app, &key, true);+ toggle(app, key, true);}if r.eye {- let _ = app.run("browser.visibility", json!({"visible": app.session.occurrence_hidden(&path), "paths": [path]}));+ let _ = app.run("browser.visibility", json!({"visible": app.session.occurrence_hidden(path), "paths": [path]}));}if r.radio || (r.double && !app.session.doc.parts.contains_key(&placement.component)) {let _ = app.run("component.activate", json!({"component": placement.component, "occurrence": placement.occurrence, "path": path}));@@ -1243,16 +1312,17 @@ fn occurrence_rows(app: &mut SolveApp, ui: &mut egui::Ui, path: Vec<u64>, depth:crate::dialogs_part_size::open(app, placement.component);}if r.clicked {- click_select(app, ui, key.clone(), Some(Sel::Occurrence { path: path.clone() }));+ click_select(app, ui, key.clone(), Some(Sel::Occurrence { path: path.to_vec() }));}if r.hovered {- acts.hover_bodies = app.session.occurrence_bodies(&path, true).unwrap_or_default();+ let bodies = placement.hover_bodies.get_or_insert_with(|| app.session.occurrence_bodies(path, true).unwrap_or_default());+ acts.hover(bodies.iter());}if let Some(p) = r.secondary {if !selected {- let _ = app.run("select.set", json!({"items": [Sel::Occurrence { path: path.clone() }]}));+ let _ = app.run("select.set", json!({"items": [Sel::Occurrence { path: path.to_vec() }]}));}- acts.menu = Some((p, Target::Occurrence { path: path.clone() }));+ 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)@@ -1262,16 +1332,14 @@ fn occurrence_rows(app: &mut SolveApp, ui: &mut egui::Ui, path: Vec<u64>, depth:if !open {return;}- for folder in ["bodies", "sketches", "construction"] {- occurrence_folder_rows(app, ui, placement.component, &path, folder, depth + 1, acts);+ for (slot, folder) in placement.folders.iter_mut().zip(["bodies", "sketches", "construction"]) {+ let data = slot.get_or_insert_with(|| cache.folder(app, placement.component, Some(path), folder));+ folder_rows_at(app, ui, placement.component, Some(path), folder, depth + 1, acts, data);}- features::rows(app, ui, placement.component, &path, depth + 1, acts);- let children = model_children(app, placement.component);+ features::rows(app, ui, placement.component, path, depth + 1, acts);if path.len() < 64 {- for occurrence in children {- let mut child = path.clone();- child.push(occurrence);- occurrence_rows(app, ui, child, depth + 1, acts);+ for child in &placement.children {+ occurrence_rows(app, ui, child, depth + 1, acts, cache);}}}@@ -1728,10 +1796,13 @@ fn pick_from_browser(app: &mut SolveApp, x: Sel) {/// One item of a component folder.struct Entry {+ /// The highlight lookup key, owned once with the cached row.+ thing: Thing,/// The browser key (body name, or the feature id of a sketch or plane).key: String,/// The key in [`TreeState`] row order (`b:`, `s:`, `p:`).row_key: String,+ patterns: Option<String>,label: String,icon: &'static str,visible: bool,@@ -1744,6 +1815,88 @@ struct Entry {bodies: Vec<String>,}+impl Entry {+ fn body(app: &SolveApp, b: &solidcraft_engine::doc::ModelBody, world: String) -> Self {+ Self {+ thing: Thing::Body(world.clone()),+ key: b.name.clone(),+ row_key: format!("b:{world}"),+ patterns: None,+ label: b.name.clone(),+ // An open shell is a surface body, not a solid.+ icon: if b.is_surface() { "surface" } else { "body" },+ visible: !app.session.visibility.hidden_bodies.contains(&world),+ selected: app.session.selection.iter().any(|s| matches!(s, Sel::Body { name } if name == &world)),+ color: None,+ locked: app.session.visibility.locked_bodies.contains(&world),+ sel: Some(Sel::Body { name: world.clone() }),+ target: Some(Target::Body { name: world.clone() }),+ bodies: vec![world],+ }+ }++ fn sketch(app: &SolveApp, f: &solidcraft_engine::doc::Feature) -> Self {+ let t = Tokens::get();+ let active = app.session.active_sketch == Some(f.id);+ let lost = app.session.model.result(f.id).is_some_and(|result| result.error.is_some())+ && matches!(app.session.doc.sketch_face_attachment(f.id, &app.session.model), solidcraft_engine::doc::FaceAttachmentStatus::Lost { .. });+ Self {+ key: f.id.to_string(),+ row_key: format!("s:{}", f.id),+ thing: Thing::Sketch(f.id),+ patterns: crate::sketch_pattern_tree::has_patterns(app, f.id).then(|| format!("s:{}/patterns", f.id)),+ label: if lost {+ format!("{} (attachment lost)", f.name)+ } else if active {+ format!("{} (editing)", f.name)+ } else {+ f.name.clone()+ },+ icon: "sketch",+ visible: sketch_visible(app, f.id),+ selected: active || app.session.selection.iter().any(|s| matches!(s, Sel::Feature { id } if *id == f.id)),+ color: if lost { Some(t.error) } else { active.then_some(t.sketch_accent) },+ locked: false,+ sel: Some(Sel::Feature { id: f.id }),+ target: Some(Target::Sketch { id: f.id }),+ bodies: Vec::new(),+ }+ }++ fn plane(app: &SolveApp, f: &solidcraft_engine::doc::Feature) -> Self {+ Self {+ key: f.id.to_string(),+ row_key: format!("p:{}", f.id),+ thing: Thing::Plane(f.name.clone()),+ patterns: None,+ label: f.name.clone(),+ icon: crate::timeline::icon_of(&f.kind),+ visible: !app.session.visibility.hidden_origin.contains(&f.name),+ selected: app.session.selection.iter().any(|s| matches!(s, Sel::Plane { name } if name == &f.name)),+ color: None,+ locked: false,+ sel: Some(Sel::Plane { name: f.name.clone() }),+ target: Some(Target::Plane { id: f.id }),+ bodies: Vec::new(),+ }+ }++ fn is_visible(&self, app: &SolveApp) -> bool {+ match &self.sel {+ Some(Sel::Body { name }) => !app.session.visibility.hidden_bodies.contains(name),+ Some(Sel::Feature { id }) => sketch_visible(app, *id),+ Some(Sel::Plane { name }) => !app.session.visibility.hidden_origin.contains(name),+ _ => self.visible,+ }+ }++ fn is_selected(&self, app: &SolveApp) -> bool {+ self.sel+ .as_ref()+ .is_some_and(|s| app.session.selection.contains(s) || matches!(s, Sel::Feature { id } if app.session.active_sketch == Some(*id)))+ }+}+/// What is being dragged in the tree: items of one component folder.#[derive(Clone, Debug)]struct Drag {@@ -1754,87 +1907,33 @@ struct Drag {/// The items of a component folder, in model order.fn entries(app: &SolveApp, comp: u64, folder: &str) -> Vec<Entry> {- let t = Tokens::get();let doc = &app.session.doc;- let sel = &app.session.selection;let state = app.session.model.state();match folder {"bodies" => model_body_indices(app, comp).into_iter().filter_map(|i| state.bodies.get(i)).filter(|b| !app.session.body_removed_later(&b.name))- .map(|b| Entry {- key: b.name.clone(),- row_key: format!("b:{}", b.name),- label: b.name.clone(),- // An open shell is a surface body, not a solid.- icon: if b.is_surface() { "surface" } else { "body" },- visible: !app.session.visibility.hidden_bodies.contains(&b.name),- selected: sel.iter().any(|x| matches!(x, Sel::Body { name } if *name == b.name)),- color: None,- locked: app.session.visibility.locked_bodies.contains(&b.name),- sel: Some(Sel::Body { name: b.name.clone() }),- target: Some(Target::Body { name: b.name.clone() }),- bodies: vec![b.name.clone()],- })- .collect(),- "sketches" => model_feature_indices(app, comp, true)- .into_iter()- .filter_map(|i| doc.features.get(i))- .map(|f| {- let active = app.session.active_sketch == Some(f.id);- let lost = app.session.model.result(f.id).is_some_and(|result| result.error.is_some())- && matches!(doc.sketch_face_attachment(f.id, &app.session.model), solidcraft_engine::doc::FaceAttachmentStatus::Lost { .. });- Entry {- key: f.id.to_string(),- row_key: format!("s:{}", f.id),- label: if lost {- format!("{} (attachment lost)", f.name)- } else if active {- format!("{} (editing)", f.name)- } else {- f.name.clone()- },- icon: "sketch",- visible: sketch_visible(app, f.id),- selected: active || sel.iter().any(|x| matches!(x, Sel::Feature { id } if *id == f.id)),- color: if lost { Some(t.error) } else { active.then_some(t.sketch_accent) },- locked: false,- sel: Some(Sel::Feature { id: f.id }),- target: Some(Target::Sketch { id: f.id }),- bodies: Vec::new(),- }- })- .collect(),- _ => model_feature_indices(app, comp, false)- .into_iter()- .filter_map(|i| doc.features.get(i))- .map(|f| Entry {- key: f.id.to_string(),- row_key: format!("p:{}", f.id),- label: f.name.clone(),- icon: crate::timeline::icon_of(&f.kind),- visible: !app.session.visibility.hidden_origin.contains(&f.name),- selected: sel.iter().any(|x| matches!(x, Sel::Plane { name } if *name == f.name)),- color: None,- locked: false,- sel: Some(Sel::Plane { name: f.name.clone() }),- target: Some(Target::Plane { id: f.id }),- bodies: Vec::new(),- })+ .map(|b| Entry::body(app, b, b.name.clone())).collect(),+ "sketches" => model_feature_indices(app, comp, true).into_iter().filter_map(|i| doc.features.get(i)).map(|f| Entry::sketch(app, f)).collect(),+ _ => model_feature_indices(app, comp, false).into_iter().filter_map(|i| doc.features.get(i)).map(|f| Entry::plane(app, f)).collect(),}}/// A folder's groups (with their items) and the items in no group, in browser order.-fn arrange(app: &SolveApp, comp: u64, folder: &str, all: Vec<Entry>) -> (Vec<(solidcraft_engine::doc::BrowserGroup, Vec<Entry>)>, Vec<Entry>) {- let doc = &app.session.doc;- let groups: Vec<solidcraft_engine::doc::BrowserGroup> =- doc.browser_groups.iter().filter(|g| g.component == comp && g.folder == folder).cloned().collect();+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<_> = groups- .into_iter()+ 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)@@ -1842,7 +1941,11 @@ fn arrange(app: &SolveApp, comp: u64, folder: &str, all: Vec<Entry>) -> (Vec<(so.collect();let mut loose: Vec<Entry> = rest.into_iter().flatten().collect();if let Some(order) = doc.browser_order.get(&format!("{comp}/{folder}")) {- let pos = |k: &str| order.iter().position(|x| x == k).unwrap_or(usize::MAX);+ 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);+ }+ let pos = |k: &str| positions.get(k).copied().unwrap_or(usize::MAX);loose.sort_by_key(|e| pos(&e.key));}(grouped, loose)@@ -1887,64 +1990,42 @@ fn folder_static(folder: &str) -> &'static str {/// A component's folder: its row, its groups and its items. Rows are drag sources; items,/// groups and the folder row are drop targets (reorder, into a group, out of groups).-fn folder_rows(app: &mut SolveApp, ui: &mut egui::Ui, comp: u64, folder: &str, depth: usize, acts: &mut Actions) {- folder_rows_at(app, ui, comp, None, folder, depth, acts);-}--fn occurrence_folder_rows(app: &mut SolveApp, ui: &mut egui::Ui, comp: u64, path: &[u64], folder: &str, depth: usize, acts: &mut Actions) {- folder_rows_at(app, ui, comp, Some(path), folder, depth, acts);-}--fn folder_rows_at(app: &mut SolveApp, ui: &mut egui::Ui, comp: u64, path: Option<&[u64]>, folder: &str, depth: usize, acts: &mut Actions) {- let t = Tokens::get();- let mut all = entries(app, comp, folder);- let prefix = path.map(occurrence_key).unwrap_or_else(|| format!("c{comp}"));- if let Some(path) = path {- let Some(placement) = model_placement(app, path) else { return };- // Each row's placed body by its definition's name (a search per row was quadratic in a- // component's bodies, every frame).- let mut placed: std::collections::HashMap<&str, &_> = std::collections::HashMap::with_capacity(placement.bodies.len());- for b in &placement.bodies {- placed.entry(b.source.as_str()).or_insert(b);- }- for e in &mut all {- if folder == "bodies" {- let Some(body) = placed.get(e.key.as_str()) else { continue };- e.sel = Some(Sel::Body { name: body.world.clone() });- e.target = Some(Target::Body { name: body.world.clone() });- e.bodies = vec![body.world.clone()];- e.visible = !app.session.visibility.hidden_bodies.contains(&body.world);- e.selected = app.session.selection.contains(&Sel::Body { name: body.world.clone() });- e.row_key = format!("b:{}", body.world);- } else {- e.row_key = format!("{prefix}/{}", e.row_key);- }- }- }- if all.is_empty() {+#[allow(clippy::too_many_arguments)]+fn folder_rows_at(+ app: &mut SolveApp,+ ui: &mut egui::Ui,+ comp: u64,+ path: Option<&[u64]>,+ folder: &str,+ depth: usize,+ acts: &mut Actions,+ data: &cache::Folder,+) {+ if data.key.is_empty() {return;}let fstatic = folder_static(folder);- let key = format!("{prefix}/{folder}");- if let Some(r) = app.tree.reveal.clone()+ let key = &data.key;+ let prefix = key.rsplit_once('/').map_or(key.as_str(), |(prefix, _)| prefix);+ if let Some(r) = app.tree.reveal.as_deref()&& folder == "bodies"- && let Some(e) = all.iter().find(|e| e.row_key == format!("b:{r}"))+ && let Some(e) = data.entries().find(|e| e.row_key.strip_prefix("b:") == Some(r)){- app.tree.collapsed.remove(&key);+ 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));}}- let open = is_open(app, &key, true);+ let open = is_open(app, key, true);// The folder's eye is its own: hiding it hides its items without changing theirs, and its// items never change it. It and everything in it fade while it or a placement above is// hidden, whatever their own eyes say.- let shown = !app.session.folder_hidden(&key);+ let shown = !app.session.folder_hidden(key);let folder_faded = !shown || path.is_some_and(|p| !app.session.occurrence_visible(p));let r = draw_row(ui,- ui.id().with(&key),+ ui.id().with(key),&Row {depth,fold: Some(open),@@ -1952,21 +2033,21 @@ fn folder_rows_at(app: &mut SolveApp, ui: &mut egui::Ui, comp: u64, path: Optionicon: "folder",label: folder_label(folder),dim: folder_faded,- mark: acts.lit.branch(folder, &all),+ mark: acts.lit.branch(app, data.entries()),..Default::default()},);if r.fold || r.clicked {- toggle(app, &key, true);+ toggle(app, key, true);}if r.eye {- toggle_folder(app, &key);+ toggle_folder(app, key);}if r.hovered {- acts.hover_bodies = all.iter().flat_map(|e| e.bodies.clone()).collect();+ acts.hover(data.entries().flat_map(|e| &e.bodies));}if let Some(p) = r.secondary {- acts.menu = Some((p, Target::Folder { component: comp, folder: fstatic.to_string(), scope: prefix.clone() }));+ acts.menu = Some((p, Target::Folder { component: comp, folder: fstatic.to_string(), scope: prefix.to_owned() }));}// Dropping on the folder row takes items out of their groups, to the end. Bodies or sketches// from another component's folder move into this component, as a drop on its row does@@ -1983,56 +2064,53 @@ fn folder_rows_at(app: &mut SolveApp, ui: &mut egui::Ui, comp: u64, path: Optionif !open {return;}- let (groups, loose) = arrange(app, comp, folder, all);- let loose_keys: Vec<String> = loose.iter().map(|e| e.key.clone()).collect();- for (g, items) in &groups {- let gkey = format!("{prefix}/g{}", g.id);- let gopen = is_open(app, &gkey, true);- let gshown = !app.session.folder_hidden(&gkey);+ let loose_keys = &data.loose_keys;+ for group in &data.groups {+ let (id, items, gkey) = (group.id, &group.items, &group.key);+ let gopen = is_open(app, gkey, true);+ let gshown = !app.session.folder_hidden(gkey);let group_faded = folder_faded || !gshown;- let label = format!("{} ({})", g.name, items.len());let r = draw_row(ui,- ui.id().with(&gkey),+ ui.id().with(gkey),&Row {depth: depth + 1,fold: Some(gopen),eye: Some(gshown),icon: "folder",- label: &label,+ label: &group.label,name: true,dim: group_faded,- mark: acts.lit.branch(folder, items),+ mark: acts.lit.branch(app, items),..Default::default()},);if r.fold || r.clicked {- toggle(app, &gkey, true);+ toggle(app, gkey, true);}if r.eye {- toggle_folder(app, &gkey);+ toggle_folder(app, gkey);}if r.hovered {- acts.hover_bodies = items.iter().flat_map(|e| e.bodies.clone()).collect();+ acts.hover(items.iter().flat_map(|e| &e.bodies));}if let Some(p) = r.secondary {- acts.menu = Some((p, Target::Group { id: g.id, scope: prefix.clone() }));+ 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(g.id), before: None });+ acts.drop = Some(DropAction::Move { comp, folder: fstatic, keys: d.keys.clone(), group: Some(id), before: None });}if gopen {for e in items {- entry_row(app, ui, comp, path, fstatic, e, depth + 2, Some(g.id), &loose_keys, group_faded, acts);+ entry_row(app, ui, comp, path, fstatic, e, depth + 2, Some(id), loose_keys, group_faded, acts);}}}- for e in &loose {- entry_row(app, ui, comp, path, fstatic, e, depth + 1, None, &loose_keys, folder_faded, acts);+ for e in &data.loose {+ entry_row(app, ui, comp, path, fstatic, e, depth + 1, None, loose_keys, folder_faded, acts);}- let _ = t;}/// The body's name edited in its row (started by a double-click): Enter or leaving the box keeps@@ -2087,33 +2165,43 @@ fn entry_row(parent_hidden: bool,acts: &mut Actions,) {- app.tree.order.push(e.row_key.clone());- let pattern_sketch =- (folder == "sketches").then(|| e.key.parse::<u64>().ok()).flatten().filter(|id| crate::sketch_pattern_tree::has_patterns(app, *id));- let pattern_key = format!("{}/patterns", e.row_key);- let patterns_open = is_open(app, &pattern_key, true);- let badges: &[&str] = if e.locked { &["lock"] } else { &[] };- let (selected, mark) = lit_row(acts.lit.entry(folder, e));+ app.tree.remember(&e.row_key);+ let pattern_key = e.patterns.as_deref();+ let patterns_open = pattern_key.is_some_and(|key| is_open(app, key, true));+ let rect = row_rect(ui);+ if !ui.is_rect_visible(rect) && !patterns_open && !(folder == "bodies" && app.tree.reveal.as_deref() == Some(e.key.as_str())) {+ ui.allocate_space(rect.size());+ return;+ }+ let (selected, mark) = lit_row(acts.lit.entry(app, e));+ let visible = e.is_visible(app);+ let locked = match &e.sel {+ Some(Sel::Body { name }) => app.session.visibility.locked_bodies.contains(name),+ _ => e.locked,+ };+ let badges: &[&str] = if locked { &["lock"] } else { &[] };let r = draw_row(ui,ui.id().with(("item", &e.row_key)),&Row {depth,- fold: pattern_sketch.map(|_| patterns_open),- eye: Some(e.visible),+ fold: pattern_key.map(|_| patterns_open),+ eye: Some(visible),icon: e.icon,label: &e.label,name: true,selected,- dim: !e.visible || parent_hidden,+ dim: !visible || parent_hidden,color: e.color,badges,mark,..Default::default()},);- if r.fold {- toggle(app, &pattern_key, true);+ if r.fold+ && let Some(key) = pattern_key+ {+ toggle(app, key, true);}if folder == "bodies"&& app.tree.reveal.as_ref().is_some_and(|b| e.row_key.strip_prefix("b:") == Some(b.as_str()))@@ -2123,7 +2211,7 @@ fn entry_row(app.tree.reveal = None;}if r.eye {- set_visible(app, folder, &[e], !e.visible);+ set_visible(app, folder, &[e], !visible);}if r.double && folder == "sketches" {if let Ok(id) = e.key.parse() {@@ -2158,25 +2246,23 @@ fn entry_row(inline_rename(app, ui, rect, e, depth);}if r.hovered && !e.bodies.is_empty() {- acts.hover_bodies = e.bodies.clone();+ acts.hover(e.bodies.iter());}if let Some(p) = r.secondary&& let Some(t) = e.target.clone(){- if !e.selected- && let Some(s) = &e.sel- {+ if !selected && let Some(s) = &e.sel {let _ = app.run("select.set", json!({ "items": [s] }));}acts.menu = Some((p, t));}- if let Some(sketch) = pattern_sketch.filter(|_| patterns_open) {- crate::sketch_pattern_tree::rows(app, ui, sketch, depth + 1, "browser", path.map(|path| (comp, path)), !e.visible || parent_hidden);+ if patterns_open && let Some(Sel::Feature { id }) = &e.sel {+ crate::sketch_pattern_tree::rows(app, ui, *id, depth + 1, "browser", path.map(|path| (comp, path)), !visible || parent_hidden);}let Some(resp) = &r.resp else { return };// 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 e.selected { selected_keys(app, comp, folder) } else { vec![e.key.clone()] };+ 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 });}if let Some(d) = drop_target(ui, resp, |d: &Drag| d.comp == comp && d.folder == folder && !d.keys.contains(&e.key), DropMark::Above) {diff --git a/crates/ui-egui/src/browser/features.rs b/crates/ui-egui/src/browser/features.rsindex 324b1906fd..5586864b5f 100644--- a/crates/ui-egui/src/browser/features.rs+++ b/crates/ui-egui/src/browser/features.rs@@ -75,7 +75,7 @@ pub(super) fn rows(app: &mut SolveApp, ui: &mut egui::Ui, component: u64, path:let Some(feature) = app.session.doc.features.get(index) else { continue };let (id, label, icon) = (feature.id, feature.name.clone(), crate::timeline::icon_of(&feature.kind));let selected = app.session.selection.contains(&Sel::Feature { id });- app.tree.order.push(format!("f:{id}"));+ app.tree.remember(&format!("f:{id}"));let r = draw_row(ui, ui.id().with(("browser_feature", id)), &Row { depth: depth + 1, icon, label: &label, selected, ..Default::default() });if let Some(rect) = r.rect {crate::scenario::publish_handle(&format!("row:browser-feature:{scope}:{id}"), rect.center());diff --git a/crates/ui-egui/src/browser_cache.rs b/crates/ui-egui/src/browser_cache.rsnew file mode 100644index 0000000000..50e2b96f4b--- /dev/null+++ b/crates/ui-egui/src/browser_cache.rs@@ -0,0 +1,205 @@+//! Stable browser data, indexed once for an evaluated document and borrowed on redraw.+use super::*;+use solidcraft_engine::doc::{Document, ModelState};+use std::collections::{BTreeMap, HashMap};+use std::sync::{Arc, Weak};++#[derive(Default)]+struct Component {+ definition: Option<usize>,+ first: Option<Vec<u64>>,+}++#[derive(Default)]+pub(super) struct Node {+ pub component: u64,+ pub occurrence: u64,+ pub name: String,+ pub label: String,+ pub key: String,+ pub tooltip: String,+ pub grounded: bool,+ pub first: bool,+ pub children: Vec<Vec<u64>>,+ pub hover_bodies: Option<Vec<String>>,+ pub folders: [Option<Folder>; 3],+}++pub(super) struct Group {+ pub id: u64,+ pub key: String,+ pub label: String,+ pub items: Vec<Entry>,+}++#[derive(Default)]+pub(super) struct Folder {+ pub key: String,+ pub groups: Vec<Group>,+ pub loose: Vec<Entry>,+ pub loose_keys: Vec<String>,+}++impl Folder {+ pub fn entries(&self) -> impl Iterator<Item = &Entry> {+ self.groups.iter().flat_map(|g| &g.items).chain(&self.loose)+ }+}++#[derive(Default)]+pub(super) struct Cache {+ doc: Weak<Document>,+ model: Weak<ModelState>,+ sketch: Option<u64>,+ colors: [Color32; 2],+ components: BTreeMap<u64, Component>,+ ids: BTreeMap<u64, usize>,+ scheduled: usize,+ pub root: Node,+ pub root_bodies: Vec<String>,+ pub occurrences: HashMap<Vec<u64>, Node>,+}++impl Cache {+ pub fn prepare(&mut self, app: &SolveApp) {+ let state = app.session.model.state();+ let t = Tokens::get();+ let colors = [t.error, t.sketch_accent];+ if std::ptr::eq(self.doc.as_ptr(), Arc::as_ptr(&app.session.doc))+ && std::ptr::eq(self.model.as_ptr(), Arc::as_ptr(&state))+ && self.sketch == app.session.active_sketch+ && self.colors == colors+ {+ return;+ }+ self.components.clear();+ self.ids.clear();+ self.occurrences.clear();+ for (i, component) in app.session.doc.components.iter().enumerate() {+ self.components.entry(component.id).or_default().definition = Some(i);+ }+ for (i, occurrence) in app.session.doc.occurrences.iter().enumerate() {+ self.ids.insert(occurrence.id, i);+ }+ self.root = Node {+ name: component_name(app, 0),+ key: "c0".into(),+ children: self.children(app, 0, &[], solidcraft_engine::doc::MAX_PLACEMENTS),+ ..Default::default()+ };+ self.scheduled = self.root.children.len();+ self.root_bodies = crate::context_menu::component_bodies(app, 0);+ // Weak snapshot identities catch replacement and reevaluation without retaining a+ // closed design's geometry while the browser is collapsed.+ self.doc = Arc::downgrade(&app.session.doc);+ self.model = Arc::downgrade(&state);+ self.sketch = app.session.active_sketch;+ self.colors = colors;+ }++ fn children(&self, app: &SolveApp, component: u64, path: &[u64], remaining: usize) -> Vec<Vec<u64>> {+ let Some(children) = app.tree.model.as_ref().and_then(|model| model.children.get(&component)) else { return Vec::new() };+ if path.len() >= 64 {+ return Vec::new();+ }+ children+ .iter()+ .filter(|id| !path.contains(id))+ .take(remaining)+ .map(|id| {+ let mut child = Vec::with_capacity(path.len() + 1);+ child.extend_from_slice(path);+ child.push(*id);+ child+ })+ .collect()+ }++ pub fn take_occurrence(&mut self, app: &mut SolveApp, path: &[u64]) -> Option<(Vec<u64>, Node)> {+ if let Some(cached) = self.occurrences.remove_entry(path) {+ return Some(cached);+ }+ if path.is_empty() || path.len() > 64 {+ return None;+ }+ let doc = self.doc.upgrade()?;+ let component = model_placement(app, path)?.component;+ let occurrence = doc.occurrences.get(*self.ids.get(path.last()?)?)?;+ let index = self.components.get_mut(&component)?;+ let definition = doc.components.get(index.definition?)?;+ let first = index.first.get_or_insert_with(|| doc.first_path(component)) == path;+ let mut tooltip = format!("Component: {}\nPlacement: ", definition.name);+ for (i, id) in path.iter().enumerate() {+ if i != 0 {+ tooltip.push_str(" / ");+ }+ tooltip.push_str(&doc.occurrences.get(*self.ids.get(id)?)?.name);+ }+ tooltip.push_str("\nGeometry edits apply to every instance of this component.");+ let children = self.children(app, component, path, solidcraft_engine::doc::MAX_PLACEMENTS.saturating_sub(self.scheduled));+ self.scheduled += children.len();+ Some((+ path.to_vec(),+ Node {+ component,+ occurrence: occurrence.id,+ name: occurrence.name.clone(),+ label: crate::dialogs_part_size::browser_label(app, component, &occurrence.name),+ key: occurrence_key(path),+ tooltip,+ grounded: occurrence.grounded,+ first,+ children,+ hover_bodies: None,+ folders: Default::default(),+ },+ ))+ }++ pub fn folder(&self, app: &SolveApp, component: u64, path: Option<&[u64]>, folder: &str) -> Folder {+ let Some(model) = &app.tree.model else { return Folder::default() };+ let Some(state) = self.model.upgrade() else { return Folder::default() };+ let Some(doc) = self.doc.upgrade() else { return Folder::default() };+ let prefix = path.map(occurrence_key).unwrap_or_else(|| format!("c{component}"));+ let indices = match folder {+ "bodies" => &model.bodies,+ "sketches" => &model.sketches,+ _ => &model.planes,+ };+ let Some(indices) = indices.get(&component) else { return Folder::default() };+ let mut all = Vec::with_capacity(indices.len());+ for i in indices {+ let entry = match folder {+ "bodies" => state.bodies.get(*i).filter(|b| !app.session.body_removed_later(&b.name)).map(|b| {+ let world = path.map_or_else(|| b.name.clone(), |p| doc.world_body_name(&state, &b.name, component, p));+ Entry::body(app, b, world)+ }),+ "sketches" => doc.features.get(*i).map(|f| Entry::sketch(app, f)),+ _ => doc.features.get(*i).map(|f| Entry::plane(app, f)),+ };+ if let Some(mut entry) = entry {+ if path.is_some() && folder != "bodies" {+ entry.row_key = format!("{prefix}/{}", entry.row_key);+ if let Some(key) = &mut entry.patterns {+ *key = format!("{prefix}/{key}");+ }+ }+ all.push(entry);+ }+ }+ 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 }+ })+ .collect();+ Folder { key: format!("{prefix}/{folder}"), groups, loose, loose_keys }+ }+}diff --git a/crates/ui-egui/src/occurrence_ui_tests.rs b/crates/ui-egui/src/occurrence_ui_tests.rsindex e6f6b96329..bd5e43c71d 100644--- a/crates/ui-egui/src/occurrence_ui_tests.rs+++ b/crates/ui-egui/src/occurrence_ui_tests.rs@@ -18,8 +18,10 @@ fn replaced_body_name_uses_evaluated_owner_in_browser_and_component_actions() {assert_eq!(h.app.session.doc.model_body_component(body), 0);assert_eq!(context_menu::component_bodies(&h.app, 0), ["Block"]);assert!(context_menu::component_bodies(&h.app, owner).is_empty());- assert_eq!(super::entries(&h.app, 0, "bodies").iter().map(|entry| entry.key.as_str()).collect::<Vec<_>>(), ["Block"]);- assert!(super::entries(&h.app, owner, "bodies").is_empty());+ let cache = h.app.tree.cache.as_ref().unwrap();+ assert_eq!(cache.root.folders[0].as_ref().unwrap().entries().map(|entry| entry.key.as_str()).collect::<Vec<_>>(), ["Block"]);+ let occurrence = h.app.session.doc.occurrence_of(owner).unwrap().id;+ assert!(cache.occurrences.get([occurrence].as_slice()).unwrap().folders[0].as_ref().unwrap().entries().next().is_none());let bounds = h.app.session.world_state().body("Block").unwrap().mesh().bounds();assert!((bounds.min.x - 30.0).abs() < 1e-9);assert!((bounds.max.x - 35.0).abs() < 1e-9);@@ -32,6 +34,39 @@ fn fixture() -> (Harness, u64, u64, u64) {(h, component, first, second)}+#[test]+fn browser_reuses_unchanged_rows_and_refreshes_live_state_and_replaced_documents() {+ let (mut h, _, first, second) = fixture();+ let second_body = h.app.session.occurrence_bodies(&[second], false).unwrap().pop().unwrap();+ let first_body = h.app.session.occurrence_bodies(&[first], false).unwrap().pop().unwrap();+ let row = |h: &Harness| {+ let cache = h.app.tree.cache.as_ref().unwrap();+ let entry = cache.occurrences.get([second].as_slice()).unwrap().folders[0].as_ref().unwrap().entries().next().unwrap();+ (entry.row_key.as_ptr(), entry.row_key.len())+ };+ let before = row(&h);+ assert_ne!(first_body, second_body);+ h.frames(3);+ assert_eq!(row(&h), before, "unchanged frames replaced cached row storage");+ h.app.run("select.set", json!({"items":[Sel::Body { name: second_body.clone() }]})).unwrap();+ h.app.session.visibility.hidden_bodies.push(second_body.clone());+ h.frames(2);+ let entry =+ h.app.tree.cache.as_ref().unwrap().occurrences.get([second].as_slice()).unwrap().folders[0].as_ref().unwrap().entries().next().unwrap();+ assert_eq!(entry.row_key.strip_prefix("b:"), Some(second_body.as_str()));+ assert!(entry.is_selected(&h.app));+ assert!(!entry.is_visible(&h.app));+ assert!(h.app.session.body_visible(&first_body));+ assert_eq!(row(&h), before, "selection or visibility rebuilt stable row data");++ let revision = h.app.session.revision;+ h.app.session = solidcraft_engine::Session::new(solidcraft_engine::doc::Document::new("Replacement"));+ h.app.session.revision = revision;+ h.frames(2);+ assert!(super::drawn_rows().iter().any(|row| row.0 == "Replacement"));+ assert!(super::drawn_occurrences().is_empty());+}+fn click(h: &mut Harness, path: &[u64], control: &str) {let point = h.call("ui.at", json!({"occurrence":path,"control":control}));assert_eq!(point["ok"], true, "{point}");