diff --git a/crates/ui-egui/src/browser.rs b/crates/ui-egui/src/browser.rs index 66b5de014..6b7ce8900 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, + order_len: usize, + cache: Option, +} + +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) { 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], cl struct Actions { menu: Option<(Pos2, Target)>, hover_bodies: Vec, + hovered: bool, drop: Option, /// 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 { - 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) -> 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) -> 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) { + 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, width pub 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 Vec { 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 Action fn 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::>().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, 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); +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 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)); + 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, 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::>() - .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, 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, 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, label: String, icon: &'static str, visible: bool, @@ -1744,6 +1815,88 @@ struct Entry { bodies: Vec, } +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 { - 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) -> (Vec<(solidcraft_engine::doc::BrowserGroup, Vec)>, Vec) { - let doc = &app.session.doc; - let groups: Vec = - 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, +) -> (Vec<(&'a solidcraft_engine::doc::BrowserGroup, Vec)>, Vec) { let mut rest: Vec> = 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) -> (Vec<(so .collect(); let mut loose: Vec = 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: Option icon: "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: Option if !open { return; } - let (groups, loose) = arrange(app, comp, folder, all); - let loose_keys: Vec = 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::().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 = if e.selected { selected_keys(app, comp, folder) } else { vec![e.key.clone()] }; + let keys: Vec = 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.rs index 324b1906f..5586864b5 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.rs new file mode 100644 index 000000000..50e2b96f4 --- /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, + first: Option>, +} + +#[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>, + pub hover_bodies: Option>, + pub folders: [Option; 3], +} + +pub(super) struct Group { + pub id: u64, + pub key: String, + pub label: String, + pub items: Vec, +} + +#[derive(Default)] +pub(super) struct Folder { + pub key: String, + pub groups: Vec, + pub loose: Vec, + pub loose_keys: Vec, +} + +impl Folder { + pub fn entries(&self) -> impl Iterator { + self.groups.iter().flat_map(|g| &g.items).chain(&self.loose) + } +} + +#[derive(Default)] +pub(super) struct Cache { + doc: Weak, + model: Weak, + sketch: Option, + colors: [Color32; 2], + components: BTreeMap, + ids: BTreeMap, + scheduled: usize, + pub root: Node, + pub root_bodies: Vec, + pub occurrences: HashMap, 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> { + 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, 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.rs index e6f6b9632..bd5e43c71 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::>(), ["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::>(), ["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}");