Cache assembly browser data between unchanged frames (#662) (#1610)

* Cache assembly browser data between unchanged frames

Extend #1762's cached component membership, placements and viewport hover
feedback with cached occurrence labels, folder entries, row keys and
tooltips. Skip offscreen row work and reuse browser hover buffers while
reading selection, visibility and locking live. Cache #2681's standard-part
configuration labels with the document snapshot instead of formatting
them on every redraw. Preserve #3009's live selection and hover marks
with highlight keys owned once by cached entries, and retain #2431's
feature rows in the reusable drawing order.

Related to:
- tangency-labs/solidcraft#662
- tangency-labs/solidcraft#1762
- tangency-labs/solidcraft#2681
- tangency-labs/solidcraft#3009
- tangency-labs/solidcraft#2431

Co-authored-by: Codex <noreply@openai.com>

* Browser cache: lock state moved to the session visibility

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Browser cache: reveal a placement's body by its row, and drop a needless borrow

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Codex <noreply@openai.com>
Co-authored-by: bherbruck <brennen.herbruck@gmail.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Luke Jones
2026-10-26 02:51:32 +00:00
committed by GitHub
parent 0f77199449
commit ece2a8693a
4 changed files with 571 additions and 245 deletions
+328 -242
View File
@@ -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], cl
struct 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, 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<std::sync::Arc<so
app.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 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::<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);
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<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: 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<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) {
+1 -1
View File
@@ -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());
+205
View File
@@ -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 }
}
}
+37 -2
View File
@@ -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}");