From 57b52d8a49bd57b3b15aa73d1dc7d88bdb9a2c80 Mon Sep 17 00:00:00 2001 From: N3MI-DG <129717180+N3MI-DG@users.noreply.github.com> Date: Mon, 19 Oct 2026 23:56:28 +0000 Subject: [PATCH] Browser: light the rows of what is selected or hovered in the 3D view (#3009) * Browser model: find the placement a body is in Model::body_path maps a placed body (by its world name) to the occurrence path of the placement holding it, as the browser's occurrence rows nest. Every placement is walked once per model, from the placements the browser already caches, so asking it every frame stays cheap. The next commits use it to mark the rows leading to a body. Co-Authored-By: Claude Opus 5.5 * Browser: rows can carry a mark for a lit item and its branch A row's Mark draws a bar down its left edge: a solid one on a lit item's own row (which also takes the hover colour unless it is selected), and a thinner, fainter one on each row leading to it, so the bars trace the item's branch through the tree. Nothing sets a mark yet. Co-Authored-By: Claude Opus 5.5 * Browser: light the rows of what is selected or hovered in the 3D view The tree now follows the 3D view. Whatever is selected (in the tree or in the view) or under the pointer in the view lights its row: the selection colour when selected, the hover colour when hovered, with a solid bar; each row leading to it gets a faint bar, also when the folders are closed. - A body lights for itself and for a selected or hovered face, edge or vertex of it. - A sketch lights for its curves, points and profiles, including those of the sketch being edited. - Construction planes, and the origin planes and axes, light their rows; the Origin folder carries the faint bar. - The rows leading to an item are the design, the placements above it (by the placement path of a body; for a sketch or plane, every placement of its component), its folder and its group. A row's own selected flag, which drag and the context menu go by, is unchanged: the selection colour for things picked in the view is drawn separately. Co-Authored-By: Claude Opus 5.5 --------- Co-authored-by: Claude Opus 5.5 --- crates/ui-egui/src/browser.rs | 204 +++++++++++++++++++++++++--- crates/ui-egui/src/browser_model.rs | 33 +++++ 2 files changed, 220 insertions(+), 17 deletions(-) diff --git a/crates/ui-egui/src/browser.rs b/crates/ui-egui/src/browser.rs index 7e666d2e7..40f19acae 100644 --- a/crates/ui-egui/src/browser.rs +++ b/crates/ui-egui/src/browser.rs @@ -291,6 +291,19 @@ pub(crate) struct Row<'a> { pub(crate) radio: Option, /// Trailing badges: "lock", "pin". pub(crate) badges: &'a [&'a str], + /// Lit by the selection or the 3D view's pointer: the item's own row, or a row leading to it. + pub(crate) mark: Mark, +} + +/// How a row relates to what the selection and the 3D view's pointer light. +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] +pub(crate) enum Mark { + #[default] + None, + /// A row a lit item is inside (its component, placement, folder or group): a faint bar. + Branch, + /// A lit item's own row: a solid bar, and the hover colour unless it is selected. + Here, } /// What happened on a row. @@ -328,9 +341,19 @@ pub(crate) fn draw_row(ui: &mut egui::Ui, id: egui::Id, row: &Row) -> RowResp { let mut out = RowResp { rect: Some(r), hovered: resp.hovered() || dragged_over, ..Default::default() }; if row.selected { ui.painter().rect_filled(r, 3.0, t.accent_soft); - } else if resp.hovered() { + } else if resp.hovered() || row.mark == Mark::Here { ui.painter().rect_filled(r, 3.0, t.hover); } + // A lit item (selected, or under the pointer in the 3D view): a bar down the left of its row, + // and a fainter, thinner one on each row leading to it, so the bars trace its branch. + let bar = match row.mark { + Mark::None => None, + Mark::Branch => Some((2.0, t.accent.gamma_multiply(0.4))), + Mark::Here => Some((3.0, t.accent)), + }; + if let Some((w, colour)) = bar { + ui.painter().rect_filled(Rect::from_min_size(r.left_top() + vec2(0.0, 2.0), vec2(w, r.height() - 4.0)), 1.0, colour); + } let mut x = r.left() + 2.0 + row.depth as f32 * INDENT; let cy = r.center().y; // The row is one widget: where a click lands decides what it does (the fold arrow with @@ -491,6 +514,128 @@ struct Actions { menu: Option<(Pos2, Target)>, hover_bodies: Vec, drop: Option, + /// What the selection and the 3D view's pointer light in the tree. + lit: Lit, +} + +/// Something in the 3D view with a row in the tree. +#[derive(Clone, Debug, PartialEq, Eq, Hash)] +enum Thing { + Body(String), + /// A sketch, by feature id. + Sketch(u64), + /// An origin or construction plane, by name. + Plane(String), + /// An origin axis. + Axis(String), +} + +/// What the tree lights for the selection and the 3D view's pointer: each lit item's row (in +/// the selection colour when selected, the hover colour when under the pointer, with a bar +/// down its left), and a faint bar on each row leading to it. +#[derive(Default)] +struct Lit { + /// Selected, or part of something selected: a body for its faces, edges and vertices, a + /// sketch for its curves, points and profiles. + selected: std::collections::HashSet, + /// Under the pointer in the 3D view. + hovered: Option, + /// The placements holding a lit body, and the components holding a lit sketch or plane. + paths: Vec>, + components: Vec, +} + +impl Lit { + fn of(app: &mut SolveApp) -> Lit { + use crate::viewport::Hit; + let mut selected = std::collections::HashSet::new(); + for s in &app.session.selection { + selected.insert(match s { + Sel::Body { name } | Sel::Face { body: name, .. } | Sel::Edge { body: name, .. } | Sel::Vertex { body: name, .. } => { + Thing::Body(name.clone()) + } + Sel::Feature { id } => Thing::Sketch(*id), + Sel::Profile { sketch, .. } | Sel::ExternalSketchCurve { sketch, .. } | Sel::ExternalSketchPoint { sketch, .. } => { + Thing::Sketch(*sketch) + } + Sel::SketchCurve { .. } | Sel::SketchPoint { .. } | Sel::SketchConstraint { .. } => match app.session.active_sketch { + Some(id) => Thing::Sketch(id), + None => continue, + }, + Sel::Plane { name } => Thing::Plane(name.clone()), + Sel::Axis { name } => Thing::Axis(name.clone()), + Sel::Occurrence { .. } => continue, + }); + } + let hovered = match &app.viewport.hover { + Some(Hit::Face { body, .. } | Hit::Edge { body, .. } | Hit::Vertex { body, .. }) => Some(Thing::Body(body.clone())), + Some(Hit::SketchPoint { sketch, .. } | Hit::SketchCurve { sketch, .. } | Hit::Profile { sketch, .. }) => Some(Thing::Sketch(*sketch)), + Some(Hit::Plane { name, .. }) => Some(Thing::Plane(name.clone())), + Some(Hit::Axis { name }) => Some(Thing::Axis(name.clone())), + None => None, + }; + let doc = app.session.doc.clone(); + let (mut paths, mut components) = (Vec::new(), Vec::new()); + for thing in selected.iter().chain(&hovered) { + match thing { + Thing::Body(b) => { + if let Some(path) = app.tree.model.as_mut().and_then(|model| model.body_path(&app.session, b)) { + paths.push(path); + } + } + Thing::Sketch(id) => { + components.extend(doc.features.iter().find(|f| f.id == *id && matches!(f.kind, FeatureKind::Sketch { .. })).map(|f| f.component)) + } + Thing::Plane(name) => components.extend( + doc.features.iter().find(|f| f.name == *name && matches!(f.kind, FeatureKind::ConstructionPlane { .. })).map(|f| f.component), + ), + Thing::Axis(_) => {} + } + } + Lit { selected, hovered, paths, components } + } + + fn any(&self) -> bool { + !self.selected.is_empty() || self.hovered.is_some() + } + + /// Whether `thing` is lit: (selected, under the pointer). + fn thing(&self, thing: &Thing) -> (bool, bool) { + (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))) + } + + /// 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 } + } + + /// The mark of a placement row: a faint bar when a lit body is placed in it or below it, or + /// a lit sketch or plane belongs to its component or one inside it. + fn placement(&self, doc: &solidcraft_engine::doc::Document, path: &[u64], component: u64) -> Mark { + let below = self.paths.iter().any(|p| p.starts_with(path)) || self.components.iter().any(|c| doc.component_within(*c, component)); + if below { Mark::Branch } else { Mark::None } + } +} + +/// A lit row's look: `(selected, under the pointer)` to the row's selection flag and mark. +fn lit_row((selected, hovered): (bool, bool)) -> (bool, Mark) { + (selected, if selected || hovered { Mark::Here } else { Mark::None }) } pub fn browser(app: &mut SolveApp, ui: &mut egui::Ui) { @@ -682,6 +827,7 @@ 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); egui::ScrollArea::vertical() .auto_shrink([false, shrink_height]) .scroll_source(egui::scroll_area::ScrollSource { scroll_bar: true, mouse_wheel: true, ..egui::scroll_area::ScrollSource::NONE }) @@ -739,6 +885,8 @@ fn component_rows(app: &mut SolveApp, ui: &mut egui::Ui, id: u64, depth: usize, dim: faded, radio: Some(active), badges, + // The design holds everything the tree lists. + mark: if id == 0 && acts.lit.any() { Mark::Branch } else { Mark::None }, ..Default::default() }; let r = draw_row(ui, ui.id().with(("comp", id)), &row); @@ -796,7 +944,7 @@ fn component_rows(app: &mut SolveApp, ui: &mut egui::Ui, id: u64, depth: usize, if id == 0 { doc_settings(app, ui, d); named_view_rows(app, ui, d, acts); - origin_rows(app, ui, d); + origin_rows(app, ui, d, acts); canvas_rows(app, ui, d, acts); analysis_rows(app, ui, d, acts); } @@ -848,6 +996,7 @@ fn occurrence_rows(app: &mut SolveApp, ui: &mut egui::Ui, path: Vec, depth: dim: faded || !visible, radio: Some(active), badges, + mark: acts.lit.placement(&app.session.doc, &path, placement.component), ..Default::default() }, ); @@ -953,9 +1102,25 @@ fn doc_settings(app: &mut SolveApp, ui: &mut egui::Ui, depth: usize) { } } -fn origin_rows(app: &mut SolveApp, ui: &mut egui::Ui, depth: usize) { +/// The origin point, axes and planes, as `(key, icon, thing lit for it)`. +fn origin_things() -> [(&'static str, &'static str, Option); 7] { + let (axis, plane) = (|k: &str| Some(Thing::Axis(k.into())), |k: &str| Some(Thing::Plane(k.into()))); + [ + ("O", "point", None), + ("X", "axis", axis("X")), + ("Y", "axis", axis("Y")), + ("Z", "axis", axis("Z")), + ("XY", "plane", plane("XY")), + ("XZ", "plane", plane("XZ")), + ("YZ", "plane", plane("YZ")), + ] +} + +fn origin_rows(app: &mut SolveApp, ui: &mut egui::Ui, depth: usize, acts: &Actions) { let key = "origin"; let open = is_open(app, key, false); + let lit = |thing: &Option| thing.as_ref().map_or((false, false), |t| acts.lit.thing(t)); + let items = origin_things(); let r = draw_row( ui, ui.id().with(key), @@ -966,6 +1131,7 @@ fn origin_rows(app: &mut SolveApp, ui: &mut egui::Ui, depth: usize) { icon: "origin", label: "Origin", dim: !app.ui.show_origin, + mark: if items.iter().any(|(_, _, thing)| lit(thing) != (false, false)) { Mark::Branch } else { Mark::None }, ..Default::default() }, ); @@ -981,28 +1147,20 @@ fn origin_rows(app: &mut SolveApp, ui: &mut egui::Ui, depth: usize) { if !open { return; } - let items = [ - ("O", "point", "O"), - ("X", "axis", "X"), - ("Y", "axis", "Y"), - ("Z", "axis", "Z"), - ("XY", "plane", "XY"), - ("XZ", "plane", "XZ"), - ("YZ", "plane", "YZ"), - ]; - for (k, icon, label) in items { + for (k, icon, thing) in items { + let label = k; let visible = !app.session.visibility.hidden_origin.iter().any(|h| h == k); let sel = match icon { "plane" => Some(Sel::Plane { name: k.into() }), "axis" => Some(Sel::Axis { name: k.into() }), _ => None, }; - let selected = sel.as_ref().is_some_and(|x| app.session.selection.contains(x)); + let (selected, mark) = lit_row(lit(&thing)); let r = draw_row( ui, ui.id().with(("o", k)), // Faded when hidden itself or with the whole Origin. - &Row { depth: depth + 1, eye: Some(visible), icon, label, selected, dim: !visible || !app.ui.show_origin, ..Default::default() }, + &Row { depth: depth + 1, eye: Some(visible), icon, label, selected, dim: !visible || !app.ui.show_origin, mark, ..Default::default() }, ); if r.eye { if visible { @@ -1629,7 +1787,16 @@ fn folder_rows_at(app: &mut SolveApp, ui: &mut egui::Ui, comp: u64, path: Option let r = draw_row( ui, ui.id().with(&key), - &Row { depth, fold: Some(open), eye: Some(shown), icon: "folder", label: folder_label(folder), dim: folder_faded, ..Default::default() }, + &Row { + depth, + fold: Some(open), + eye: Some(shown), + icon: "folder", + label: folder_label(folder), + dim: folder_faded, + mark: acts.lit.branch(folder, &all), + ..Default::default() + }, ); if r.fold || r.clicked { toggle(app, &key, true); @@ -1671,6 +1838,7 @@ fn folder_rows_at(app: &mut SolveApp, ui: &mut egui::Ui, comp: u64, path: Option label: &label, name: true, dim: group_faded, + mark: acts.lit.branch(folder, items), ..Default::default() }, ); @@ -1725,6 +1893,7 @@ fn entry_row( 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)); let r = draw_row( ui, ui.id().with(("item", &e.row_key)), @@ -1735,10 +1904,11 @@ fn entry_row( icon: e.icon, label: &e.label, name: true, - selected: e.selected, + selected, dim: !e.visible || parent_hidden, color: e.color, badges, + mark, ..Default::default() }, ); diff --git a/crates/ui-egui/src/browser_model.rs b/crates/ui-egui/src/browser_model.rs index 5505d8175..b1316dfa3 100644 --- a/crates/ui-egui/src/browser_model.rs +++ b/crates/ui-egui/src/browser_model.rs @@ -19,6 +19,8 @@ pub(super) struct Model { pub planes: HashMap>, pub children: HashMap>, placements: HashMap, Option>>, + /// Each placed body's placement path, by the body's world name (built on first use). + body_paths: Option>>, } impl Model { @@ -51,6 +53,7 @@ impl Model { planes, children, placements: HashMap::new(), + body_paths: None, } } @@ -61,4 +64,34 @@ impl Model { pub fn placement(&mut self, session: &Session, path: &[u64]) -> Option> { self.placements.entry(path.to_vec()).or_insert_with(|| session.occurrence_placement(path).ok().map(Arc::new)).clone() } + + /// The placement a placed body (by its world name) belongs to, as the browser's occurrence + /// rows nest; `None` for a body of the top-level design. Every placement is walked once per + /// model, as deep and as far as the browser draws them. + pub fn body_path(&mut self, session: &Session, body: &str) -> Option> { + if self.body_paths.is_none() { + let mut paths: HashMap> = HashMap::new(); + let mut stack: Vec> = self.children.get(&0).into_iter().flatten().map(|o| vec![*o]).collect(); + let mut walked = 0; + while let Some(path) = stack.pop() { + walked += 1; + if walked > 100_000 { + break; + } + let Some(placement) = self.placement(session, &path) else { continue }; + for b in &placement.bodies { + paths.entry(b.world.clone()).or_insert_with(|| path.clone()); + } + if path.len() < 64 { + for child in self.children.get(&placement.component).into_iter().flatten() { + let mut next = path.clone(); + next.push(*child); + stack.push(next); + } + } + } + self.body_paths = Some(paths); + } + self.body_paths.as_ref()?.get(body).cloned() + } }