Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Browser tree: components with an activation radio (others drawn faded), ground pin, groups in Bodies/Sketches/Construction (new, from selection, rename, ungroup, kept in the design: browser.group/ungroup/rename_group/move/order), drag and drop to reorder, into and out of groups and into another component, Ctrl/Shift multi-select, hover lights the bodies, folds remembered; occurrence Move/Copy with a gizmo and Capture Position/Revert; the viewport shows bodies where their occurrences place them

bherbruck9a9caa651194
diff --git a/crates/doc/src/document.rs b/crates/doc/src/document.rs
index edd0719dbd..5be74627d0 100644
--- a/crates/doc/src/document.rs
+++ b/crates/doc/src/document.rs
@@ -807,6 +807,25 @@ pub struct Document {
/// Bodies moved into another component than their feature's (by body name).
#[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]
pub body_components: std::collections::BTreeMap<String, u64>,
+ /// Browser groups (folders of bodies, sketches or construction planes).
+ #[serde(default, skip_serializing_if = "Vec::is_empty")]
+ pub browser_groups: Vec<BrowserGroup>,
+ /// Browser item order per component folder (`"<component>/<folder>"` → item keys).
+ #[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]
+ pub browser_order: std::collections::BTreeMap<String, Vec<String>>,
+}
+
+/// A browser group: items of one folder (`bodies`, `sketches` or `construction`) of a
+/// component, by key (body name, or the feature id of a sketch or construction plane).
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+pub struct BrowserGroup {
+ pub id: u64,
+ pub name: String,
+ #[serde(default)]
+ pub component: u64,
+ pub folder: String,
+ #[serde(default)]
+ pub items: Vec<String>,
}
fn default_format() -> String {
@@ -839,6 +858,8 @@ impl Document {
materials: Default::default(),
favorites: Default::default(),
param_comments: Default::default(),
+ browser_groups: Vec::new(),
+ browser_order: Default::default(),
}
}
diff --git a/crates/engine/src/cmd/browser.rs b/crates/engine/src/cmd/browser.rs
index 13c81a29ea..1068a0c0f1 100644
--- a/crates/engine/src/cmd/browser.rs
+++ b/crates/engine/src/cmd/browser.rs
@@ -1,4 +1,8 @@
-//! Browser commands: renaming bodies, moving a sketch to another plane.
+//! Browser commands: renaming bodies, moving a sketch to another plane, and the browser's
+//! groups and item order (kept in the design, so they are saved and undone like features).
+//!
+//! Browser items are keyed per component folder (`bodies`, `sketches`, `construction`): a body
+//! by name, a sketch or construction plane by feature id.
use serde_json::{Value, json};
@@ -13,8 +17,149 @@ pub static COMMANDS: &[CommandSpec] = &[
CommandSpec::new("sketch.redefine", "Redefine Sketch Plane", redefine_sketch)
.icon("plane")
.params("sketch: id or name; plane: XY|XZ|YZ | construction plane name | {face: [x,y,z]} | {origin, normal} (the sketch keeps its geometry)"),
+ CommandSpec::new("browser.group", "New Group", group)
+ .icon("folder")
+ .params("folder: bodies|sketches|construction; component?: id (default 0); name?; items?: [keys] (they leave other groups)"),
+ CommandSpec::new("browser.ungroup", "Ungroup", ungroup).params("group: id (its items go back to the folder)"),
+ CommandSpec::new("browser.rename_group", "Rename Group", rename_group).params("group: id, name"),
+ CommandSpec::new("browser.move", "Move Browser Items", move_items)
+ .params("folder, component?, items: [keys]; group?: id (into it; omit to take them out of groups); before?: key (position in the group)"),
+ CommandSpec::new("browser.order", "Order Browser Items", order).params("folder, component?, order: [keys] (the folder's items in display order)"),
];
+const FOLDERS: [&str; 3] = ["bodies", "sketches", "construction"];
+
+fn folder_of(p: &Value, cmd: &str) -> Result<String> {
+ match str_(p, "folder") {
+ Some(f) if FOLDERS.contains(&f) => Ok(f.to_string()),
+ _ => Err(bad(cmd, "`folder` must be bodies, sketches or construction")),
+ }
+}
+
+fn component_of(s: &Session, p: &Value, cmd: &str) -> Result<u64> {
+ let c = p.get("component").and_then(Value::as_u64).unwrap_or(0);
+ if c != 0 && !s.doc.components.iter().any(|x| x.id == c) {
+ return Err(bad(cmd, format!("no component {c}")));
+ }
+ Ok(c)
+}
+
+fn keys(p: &Value, k: &str, cmd: &str) -> Result<Vec<String>> {
+ let v = match p.get(k) {
+ Some(Value::Array(a)) => {
+ a.iter().map(|x| x.as_str().map(str::to_string).or_else(|| x.as_u64().map(|n| n.to_string()))).collect::<Option<Vec<_>>>()
+ }
+ None => Some(Vec::new()),
+ _ => None,
+ };
+ let v = v.ok_or_else(|| bad(cmd, format!("`{k}` must be a list of item keys")))?;
+ if v.len() > 10_000 || v.iter().any(|x| x.is_empty() || x.len() > 256) {
+ return Err(bad(cmd, format!("`{k}` has bad keys")));
+ }
+ Ok(v)
+}
+
+fn group_id(s: &Session, p: &Value, cmd: &str) -> Result<u64> {
+ let id = p.get("group").and_then(Value::as_u64).ok_or_else(|| bad(cmd, "`group` must be a group id"))?;
+ if s.doc.browser_groups.iter().any(|g| g.id == id) { Ok(id) } else { Err(bad(cmd, format!("no group {id}"))) }
+}
+
+fn group(s: &mut Session, p: &Value) -> Result<Value> {
+ let cmd = "browser.group";
+ let folder = folder_of(p, cmd)?;
+ let component = component_of(s, p, cmd)?;
+ let items = keys(p, "items", cmd)?;
+ let d = s.doc_mut();
+ let id = d.browser_groups.iter().map(|g| g.id).max().unwrap_or(0) + 1;
+ let name = match str_(p, "name").map(str::trim).filter(|n| !n.is_empty()) {
+ Some(n) if n.len() <= 128 => n.to_string(),
+ Some(_) => return Err(bad(cmd, "`name` is too long")),
+ None => format!("Group{}", d.browser_groups.iter().filter(|g| g.folder == folder).count() + 1),
+ };
+ for g in d.browser_groups.iter_mut().filter(|g| g.component == component && g.folder == folder) {
+ g.items.retain(|k| !items.contains(k));
+ }
+ d.browser_groups.push(solvecraft_doc::BrowserGroup { id, name: name.clone(), component, folder, items });
+ Ok(json!({ "group": id, "name": name }))
+}
+
+fn ungroup(s: &mut Session, p: &Value) -> Result<Value> {
+ let id = group_id(s, p, "browser.ungroup")?;
+ s.doc_mut().browser_groups.retain(|g| g.id != id);
+ Ok(json!({ "group": id }))
+}
+
+fn rename_group(s: &mut Session, p: &Value) -> Result<Value> {
+ let cmd = "browser.rename_group";
+ let id = group_id(s, p, cmd)?;
+ let name =
+ str_(p, "name").map(str::trim).filter(|n| !n.is_empty() && n.len() <= 128).ok_or_else(|| bad(cmd, "`name` must be 1…128 characters"))?;
+ if let Some(g) = s.doc_mut().browser_groups.iter_mut().find(|g| g.id == id) {
+ g.name = name.to_string();
+ }
+ Ok(json!({ "group": id, "name": name }))
+}
+
+fn move_items(s: &mut Session, p: &Value) -> Result<Value> {
+ let cmd = "browser.move";
+ let folder = folder_of(p, cmd)?;
+ let component = component_of(s, p, cmd)?;
+ let items = keys(p, "items", cmd)?;
+ if items.is_empty() {
+ return Err(bad(cmd, "`items` must list item keys"));
+ }
+ let to = match p.get("group") {
+ Some(Value::Null) | None => None,
+ Some(_) => Some(group_id(s, p, cmd)?),
+ };
+ if let Some(g) = to
+ && !s.doc.browser_groups.iter().any(|x| x.id == g && x.component == component && x.folder == folder)
+ {
+ return Err(bad(cmd, "that group is in another folder"));
+ }
+ let before = str_(p, "before").map(str::to_string);
+ let d = s.doc_mut();
+ for g in d.browser_groups.iter_mut().filter(|g| g.component == component && g.folder == folder) {
+ g.items.retain(|k| !items.contains(k));
+ if Some(g.id) == to {
+ let at = before.as_ref().and_then(|b| g.items.iter().position(|k| k == b)).unwrap_or(g.items.len());
+ for (i, k) in items.iter().enumerate() {
+ g.items.insert(at + i, k.clone());
+ }
+ }
+ }
+ Ok(json!({ "items": items, "group": to }))
+}
+
+fn order(s: &mut Session, p: &Value) -> Result<Value> {
+ let cmd = "browser.order";
+ let folder = folder_of(p, cmd)?;
+ let component = component_of(s, p, cmd)?;
+ let order = keys(p, "order", cmd)?;
+ let key = format!("{component}/{folder}");
+ let d = s.doc_mut();
+ if order.is_empty() {
+ d.browser_order.remove(&key);
+ } else {
+ d.browser_order.insert(key, order);
+ }
+ Ok(json!({}))
+}
+
+/// Rename an item key in the browser's groups and orders of a folder.
+fn rename_key(d: &mut solvecraft_doc::Document, folder: &str, old: &str, new: &str) {
+ for g in d.browser_groups.iter_mut().filter(|g| g.folder == folder) {
+ for k in g.items.iter_mut().filter(|k| *k == old) {
+ *k = new.to_string();
+ }
+ }
+ for (_, v) in d.browser_order.iter_mut().filter(|(k, _)| k.ends_with(&format!("/{folder}"))) {
+ for k in v.iter_mut().filter(|k| *k == old) {
+ *k = new.to_string();
+ }
+ }
+}
+
/// Replace every string equal to `old` with `new`; true when something changed.
fn replace_str(v: &mut Value, old: &str, new: &str, depth: usize) -> bool {
if depth > 64 {
@@ -77,6 +222,7 @@ fn rename_body(s: &mut Session, p: &Value) -> Result<Value> {
if let Some(c) = d.body_components.remove(&old) {
d.body_components.insert(name.to_string(), c);
}
+ rename_key(d, "bodies", &old, name);
Ok(json!({"body": old, "name": name}))
}
@@ -153,4 +299,42 @@ mod tests {
assert!(s.execute("sketch.redefine", &json!({"sketch": sk, "plane": "nope"})).is_err());
assert!(s.execute("sketch.redefine", &json!({"sketch": 999, "plane": "XY"})).is_err());
}
+
+ #[test]
+ fn groups_hold_items_and_follow_renames() {
+ let mut s = Session::default();
+ run(&mut s, "PrimitiveBox", json!({"length": 10, "width": 10, "height": 10}));
+ run(&mut s, "PrimitiveBox", json!({"length": 10, "width": 10, "height": 10, "corner": [20, 0, 0]}));
+ let [a, b] = [names(&s)[0].clone(), names(&s)[1].clone()];
+ let g = run(&mut s, "browser.group", json!({"folder": "bodies", "items": [a.clone()]}))["group"].as_u64().unwrap();
+ assert_eq!(s.doc.browser_groups[0].name, "Group1");
+ run(&mut s, "browser.move", json!({"folder": "bodies", "items": [b.clone()], "group": g, "before": a.clone()}));
+ assert_eq!(s.doc.browser_groups[0].items, vec![b.clone(), a.clone()]);
+ run(&mut s, "browser.rename_group", json!({"group": g, "name": "Fasteners"}));
+ run(&mut s, "body.rename", json!({"body": a, "name": "Bolt"}));
+ assert_eq!(s.doc.browser_groups[0].items, vec![b.clone(), "Bolt".to_string()]);
+ // Out of the group, then a folder order; saved with the design.
+ run(&mut s, "browser.move", json!({"folder": "bodies", "items": [b.clone()]}));
+ assert_eq!(s.doc.browser_groups[0].items, vec!["Bolt".to_string()]);
+ run(&mut s, "browser.order", json!({"folder": "bodies", "order": [b.clone(), "Bolt"]}));
+ let saved: solvecraft_doc::Document = serde_json::from_str(&serde_json::to_string(&*s.doc).unwrap()).unwrap();
+ assert_eq!(saved.browser_groups, s.doc.browser_groups);
+ assert_eq!(saved.browser_order["0/bodies"], vec![b, "Bolt".to_string()]);
+ run(&mut s, "browser.ungroup", json!({"group": g}));
+ assert!(s.doc.browser_groups.is_empty());
+ // Hostile input is refused.
+ for (c, p) in [
+ ("browser.group", json!({"folder": "nope"})),
+ ("browser.group", json!({"folder": "bodies", "component": 99})),
+ ("browser.group", json!({"folder": "bodies", "items": "x"})),
+ ("browser.move", json!({"folder": "bodies", "items": []})),
+ ("browser.move", json!({"folder": "bodies", "items": ["x"], "group": 42})),
+ ("browser.ungroup", json!({"group": -1})),
+ ("browser.rename_group", json!({"group": g, "name": "x"})),
+ ] {
+ assert!(s.execute(c, &p).is_err(), "{c} {p}");
+ }
+ run(&mut s, "UndoCommand", json!({}));
+ assert_eq!(s.doc.browser_groups.len(), 1, "ungroup undoes");
+ }
}
diff --git a/crates/ui-egui/src/browser.rs b/crates/ui-egui/src/browser.rs
index 0d8712c5e9..daa453ec07 100644
--- a/crates/ui-egui/src/browser.rs
+++ b/crates/ui-egui/src/browser.rs
@@ -78,19 +78,97 @@ pub fn redefine_sketch(app: &mut SolveApp, id: u64) {
app.tree.redefine = Some(id);
}
-pub fn group_bodies(_app: &SolveApp, _id: u64) -> Vec<String> {
- Vec::new()
+fn find_group(app: &SolveApp, id: u64) -> Option<&solvecraft_engine::doc::BrowserGroup> {
+ app.session.doc.browser_groups.iter().find(|g| g.id == id)
}
-pub fn group_items(_app: &SolveApp, _id: u64) -> Vec<Item> {
- Vec::new()
+/// The bodies in a group (none for sketch and plane groups).
+pub fn group_bodies(app: &SolveApp, id: u64) -> Vec<String> {
+ let st = app.session.model.state();
+ find_group(app, id)
+ .filter(|g| g.folder == "bodies")
+ .map(|g| g.items.iter().filter(|b| st.body(b).is_some()).cloned().collect())
+ .unwrap_or_default()
}
-pub fn group_name(_app: &SolveApp, _id: u64) -> Option<String> {
- None
+pub fn group_name(app: &SolveApp, id: u64) -> Option<String> {
+ find_group(app, id).map(|g| g.name.clone())
+}
+
+/// The menu of a group row.
+pub fn group_items(app: &SolveApp, id: u64) -> Vec<Item> {
+ let Some(g) = find_group(app, id) else { return Vec::new() };
+ let mut v = vec![
+ Item::action("ui.rename", "Rename", "").with(json!({ "group": id })),
+ Item::action("ui.ungroup", "Ungroup", "folder").with(json!({ "group": id })),
+ ];
+ if g.folder == "bodies" {
+ let bodies = group_bodies(app, id);
+ let hidden = !bodies.is_empty() && bodies.iter().all(|b| app.ui.hidden_bodies.contains(b));
+ v.push(Item::sep());
+ v.push(
+ Item::action(if hidden { "ui.show" } else { "ui.hide" }, if hidden { "Show" } else { "Hide" }, "eye").with(json!({ "bodies": bodies })),
+ );
+ v.push(Item::action("ui.isolate", "Isolate", "").with(json!({ "bodies": bodies })));
+ }
+ v
+}
+
+/// The menu of a folder row (Bodies, Sketches, Construction).
+pub fn folder_items(app: &SolveApp, component: u64, folder: &str) -> Vec<Item> {
+ let sel: Vec<String> = selected_keys(app, component, folder);
+ let mut v = vec![Item::action("ui.newGroup", "New Group", "folder").with(json!({ "component": component, "folder": folder }))];
+ if sel.len() > 1 {
+ v.push(Item::action("ui.groupSelected", "Group Selected", "folder").with(json!({ "component": component, "folder": folder, "items": sel })));
+ }
+ if folder == "bodies" {
+ v.push(Item::sep());
+ v.push(Item::action("ui.showAll", "Show All Bodies", "eye"));
+ }
+ v
}
-pub fn group_action(_app: &mut SolveApp, _action: &str, _p: &Value) {}
+/// Selected browser items of the folder of a body or sketch, when more than one (for Group
+/// Selected in their menus).
+pub fn selection_group(app: &SolveApp, target: &Target) -> Option<Value> {
+ let (comp, folder) = match target {
+ Target::Body { name } => {
+ let st = app.session.model.state();
+ let b = st.body(name)?;
+ (app.session.doc.body_component(name, b.feature), "bodies")
+ }
+ Target::Sketch { id } => (app.session.doc.feature(*id)?.component, "sketches"),
+ _ => return None,
+ };
+ let sel = selected_keys(app, comp, folder);
+ (sel.len() > 1).then(|| json!({ "component": comp, "folder": folder, "items": sel }))
+}
+
+/// Group actions from the menus.
+pub fn group_action(app: &mut SolveApp, action: &str, p: &Value) {
+ match action {
+ "ui.newGroup" | "ui.groupSelected" => {
+ let folder = p.get("folder").and_then(Value::as_str).unwrap_or("bodies");
+ let comp = p.get("component").and_then(Value::as_u64).unwrap_or(0);
+ let items = p.get("items").cloned().unwrap_or(json!([]));
+ if let Ok(r) = app.run("browser.group", json!({ "component": comp, "folder": folder, "items": items }))
+ && let Some(g) = r.get("group").and_then(Value::as_u64)
+ {
+ app.tree.collapsed.remove(&format!("c{comp}/{folder}"));
+ app.tree.collapsed.remove(&format!("g{g}"));
+ }
+ }
+ "ui.ungroup" => {
+ if let Some(g) = p.get("group") {
+ let _ = app.run("browser.ungroup", json!({ "group": g }));
+ }
+ }
+ "ui.renameGroup" => {
+ let _ = app.run("browser.rename_group", p.clone());
+ }
+ _ => {}
+ }
+}
// ---------------------------------------------------------------------------------------------
// Drawing
@@ -129,11 +207,13 @@ struct RowResp {
eye: bool,
radio: bool,
hovered: bool,
+ /// The row's response (drag and drop).
+ resp: Option<egui::Response>,
}
fn draw_row(ui: &mut egui::Ui, id: egui::Id, row: &Row) -> RowResp {
let t = Tokens::get();
- let (r, resp) = ui.allocate_exact_size(vec2(ui.available_width(), ROW_H), Sense::click());
+ let (r, resp) = ui.allocate_exact_size(vec2(ui.available_width(), ROW_H), Sense::click_and_drag());
let mut out = RowResp { rect: Some(r), hovered: resp.hovered(), ..Default::default() };
if row.selected {
ui.painter().rect_filled(r, 3.0, t.accent_soft);
@@ -194,6 +274,7 @@ fn draw_row(ui: &mut egui::Ui, id: egui::Id, row: &Row) -> RowResp {
badge(ui.painter(), br, b, t.text_dim);
bx += 15.0;
}
+ out.resp = Some(resp.clone());
out.clicked = resp.clicked();
out.double = resp.double_clicked();
if resp.secondary_clicked() {
@@ -289,6 +370,7 @@ fn toggle(app: &mut SolveApp, key: &str, default: bool) {
struct Actions {
menu: Option<(Pos2, Target)>,
hover_bodies: Vec<String>,
+ drop: Option<DropAction>,
}
pub fn browser(app: &mut SolveApp, ui: &mut egui::Ui) {
@@ -302,12 +384,18 @@ pub fn browser(app: &mut SolveApp, ui: &mut egui::Ui) {
.show(ui, |ui| {
ui.label(RichText::new("BROWSER").size(11.0).strong().color(t.text_dim));
ui.add_space(4.0);
- egui::ScrollArea::vertical().auto_shrink([false, false]).show(ui, |ui| {
- ui.spacing_mut().item_spacing.y = 0.0;
- component_rows(app, ui, 0, 0, &mut acts);
- });
+ egui::ScrollArea::vertical()
+ .auto_shrink([false, false])
+ .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, &mut acts);
+ });
});
app.viewport.hover_bodies = acts.hover_bodies;
+ if let Some(d) = acts.drop {
+ apply_drop(app, d);
+ }
if let Some((at, target)) = acts.menu {
crate::context_menu::open_for(app, at, target);
}
@@ -383,6 +471,12 @@ fn component_rows(app: &mut SolveApp, ui: &mut egui::Ui, id: u64, depth: usize,
if let Some(p) = r.secondary {
acts.menu = Some((p, Target::Component { id }));
}
+ // Bodies and sketches dropped on a component move into it.
+ if let Some(resp) = &r.resp
+ && let Some(d) = drop_target(ui, resp, |d: &Drag| d.comp != id && d.folder != "construction", DropMark::Box)
+ {
+ acts.drop = Some(DropAction::Component { to: id, folder: d.folder, keys: d.keys.clone() });
+ }
if !open {
return;
}
@@ -392,9 +486,9 @@ fn component_rows(app: &mut SolveApp, ui: &mut egui::Ui, id: u64, depth: usize,
origin_rows(app, ui, d);
}
let _ = t;
- body_rows(app, ui, id, d, acts);
- sketch_rows(app, ui, id, d, acts);
- plane_rows(app, ui, id, d);
+ for folder in ["bodies", "sketches", "construction"] {
+ folder_rows(app, ui, id, folder, d, acts);
+ }
let children: Vec<u64> = app.session.doc.components.iter().filter(|c| c.parent == id).map(|c| c.id).collect();
for c in children {
component_rows(app, ui, c, d, acts);
@@ -491,176 +585,398 @@ fn pick_from_browser(app: &mut SolveApp, x: Sel) {
let _ = app.run("select.set", json!({ "items": [x] }));
}
-/// A folder row (Bodies, Sketches, Construction) with an eye for everything in it; true when
-/// it is open.
-fn folder(app: &mut SolveApp, ui: &mut egui::Ui, key: &str, label: &str, depth: usize, visible: Option<bool>) -> (bool, RowResp) {
- let open = is_open(app, key, true);
- let r = draw_row(ui, ui.id().with(key), &Row { depth, fold: Some(open), eye: visible, icon: "folder", label, ..Default::default() });
- if r.fold || r.clicked {
- toggle(app, key, true);
+/// One item of a component folder.
+struct Entry {
+ /// 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,
+ label: String,
+ icon: &'static str,
+ visible: bool,
+ selected: bool,
+ color: Option<Color32>,
+ locked: bool,
+ sel: Option<Sel>,
+ target: Option<Target>,
+ /// Bodies lit when the row is hovered.
+ bodies: Vec<String>,
+}
+
+/// What is being dragged in the tree: items of one component folder.
+#[derive(Clone, Debug)]
+struct Drag {
+ comp: u64,
+ folder: &'static str,
+ keys: Vec<String>,
+}
+
+/// 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;
+ match folder {
+ "bodies" => app
+ .session
+ .model
+ .state()
+ .bodies
+ .iter()
+ .filter(|b| doc.body_component(&b.name, b.feature) == comp)
+ .map(|b| Entry {
+ key: b.name.clone(),
+ row_key: format!("b:{}", b.name),
+ label: b.name.clone(),
+ icon: "body",
+ visible: !app.ui.hidden_bodies.contains(&b.name),
+ selected: sel.iter().any(|x| matches!(x, Sel::Body { name } if *name == b.name)),
+ color: None,
+ locked: app.ui.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" => doc
+ .features
+ .iter()
+ .filter(|f| f.component == comp && matches!(f.kind, FeatureKind::Sketch { .. }))
+ .map(|f| {
+ let active = app.session.active_sketch == Some(f.id);
+ Entry {
+ key: f.id.to_string(),
+ row_key: format!("s:{}", f.id),
+ label: 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: 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(),
+ _ => doc
+ .features
+ .iter()
+ .filter(|f| f.component == comp && matches!(f.kind, FeatureKind::ConstructionPlane { .. }))
+ .map(|f| Entry {
+ key: f.id.to_string(),
+ row_key: format!("p:{}", f.id),
+ label: f.name.clone(),
+ icon: "plane",
+ visible: !app.ui.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: None,
+ bodies: Vec::new(),
+ })
+ .collect(),
}
- (open, r)
}
-fn body_rows(app: &mut SolveApp, ui: &mut egui::Ui, comp: u64, depth: usize, acts: &mut Actions) {
- let st = app.session.model.state();
- let doc = app.session.doc.clone();
- let bodies: Vec<String> = st.bodies.iter().filter(|b| doc.body_component(&b.name, b.feature) == comp).map(|b| b.name.clone()).collect();
- if bodies.is_empty() {
+/// 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<(solvecraft_engine::doc::BrowserGroup, Vec<Entry>)>, Vec<Entry>) {
+ let doc = &app.session.doc;
+ let groups: Vec<solvecraft_engine::doc::BrowserGroup> =
+ doc.browser_groups.iter().filter(|g| g.component == comp && g.folder == folder).cloned().collect();
+ 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()
+ .map(|g| {
+ let items = g.items.iter().filter_map(|k| take(k)).collect();
+ (g, items)
+ })
+ .collect();
+ let mut loose: Vec<Entry> = rest.into_iter().flatten().collect();
+ if let Some(order) = doc.browser_order.get(&format!("{comp}/{folder}")) {
+ let pos = |k: &str| order.iter().position(|x| x == k).unwrap_or(usize::MAX);
+ loose.sort_by_key(|e| pos(&e.key));
+ }
+ (grouped, loose)
+}
+
+/// Show or hide items of a folder.
+fn set_visible(app: &mut SolveApp, folder: &str, items: &[&Entry], on: bool) {
+ for e in items {
+ match folder {
+ "bodies" => {
+ app.ui.hidden_bodies.retain(|b| *b != e.key);
+ if !on {
+ app.ui.hidden_bodies.push(e.key.clone());
+ }
+ }
+ "sketches" => {
+ if let Ok(id) = e.key.parse() {
+ set_sketch_visible(app, id, on);
+ }
+ }
+ _ => {
+ app.ui.hidden_origin.retain(|p| *p != e.label);
+ if !on {
+ app.ui.hidden_origin.push(e.label.clone());
+ }
+ }
+ }
+ }
+}
+
+fn folder_label(folder: &str) -> &'static str {
+ match folder {
+ "bodies" => "Bodies",
+ "sketches" => "Sketches",
+ _ => "Construction",
+ }
+}
+
+fn folder_static(folder: &str) -> &'static str {
+ match folder {
+ "bodies" => "bodies",
+ "sketches" => "sketches",
+ _ => "construction",
+ }
+}
+
+/// 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) {
+ let t = Tokens::get();
+ let all = entries(app, comp, folder);
+ if all.is_empty() {
return;
}
- let key = format!("c{comp}/bodies");
- let reveal = app.tree.reveal.as_ref().is_some_and(|b| bodies.contains(b));
- if reveal {
+ let fstatic = folder_static(folder);
+ let key = format!("c{comp}/{folder}");
+ if let Some(r) = app.tree.reveal.clone()
+ && folder == "bodies"
+ && all.iter().any(|e| e.key == r)
+ {
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(&r)) {
+ app.tree.collapsed.remove(&format!("g{}", g.id));
+ }
+ }
+ let open = is_open(app, &key, true);
+ let any_visible = if folder == "sketches" { app.ui.show_sketches } else { all.iter().any(|e| e.visible) };
+ let r = draw_row(
+ ui,
+ ui.id().with(&key),
+ &Row { depth, fold: Some(open), eye: Some(any_visible), icon: "folder", label: folder_label(folder), ..Default::default() },
+ );
+ if r.fold || r.clicked {
+ toggle(app, &key, true);
}
- let any_visible = bodies.iter().any(|b| !app.ui.hidden_bodies.contains(b));
- let (open, r) = folder(app, ui, &key, "Bodies", depth, Some(any_visible));
if r.eye {
- if any_visible {
- app.ui.hidden_bodies.extend(bodies.iter().filter(|b| !app.ui.hidden_bodies.contains(b)).cloned().collect::<Vec<_>>());
+ if folder == "sketches" {
+ app.ui.show_sketches = !app.ui.show_sketches;
} else {
- app.ui.hidden_bodies.retain(|b| !bodies.contains(b));
+ let refs: Vec<&Entry> = all.iter().collect();
+ set_visible(app, folder, &refs, !any_visible);
}
}
if r.hovered {
- acts.hover_bodies = bodies.clone();
+ acts.hover_bodies = all.iter().flat_map(|e| e.bodies.clone()).collect();
+ }
+ if let Some(p) = r.secondary {
+ acts.menu = Some((p, Target::Folder { component: comp, folder: fstatic.to_string() }));
+ }
+ // Dropping on the folder row takes items out of their groups, to the end.
+ 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: None, before: None });
}
if !open {
return;
}
- for b in &bodies {
- let visible = !app.ui.hidden_bodies.contains(b);
- let selected = app.session.selection.iter().any(|x| matches!(x, Sel::Body { name } if name == b));
- let locked = app.ui.locked_bodies.contains(b);
- let badges: &[&str] = if locked { &["lock"] } else { &[] };
- let key = format!("b:{b}");
- app.tree.order.push(key.clone());
+ 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!("g{}", g.id);
+ let gopen = is_open(app, &gkey, true);
+ let gvis = items.is_empty() || items.iter().any(|e| e.visible);
+ let label = format!("{} ({})", g.name, items.len());
let r = draw_row(
ui,
- ui.id().with(("body", b)),
- &Row { depth: depth + 1, eye: Some(visible), icon: "body", label: b, selected, dim: !visible, badges, ..Default::default() },
+ ui.id().with(&gkey),
+ &Row { depth: depth + 1, fold: Some(gopen), eye: Some(gvis), icon: "folder", label: &label, dim: !gvis, ..Default::default() },
);
- if app.tree.reveal.as_deref() == Some(b.as_str())
- && let Some(rect) = r.rect
- {
- ui.scroll_to_rect(rect, Some(egui::Align::Center));
- app.tree.reveal = None;
+ if r.fold || r.clicked {
+ toggle(app, &gkey, true);
}
if r.eye {
- if visible {
- app.ui.hidden_bodies.push(b.clone());
- } else {
- app.ui.hidden_bodies.retain(|n| n != b);
- }
- }
- if r.clicked {
- click_select(app, ui, key, Some(Sel::Body { name: b.clone() }));
+ let refs: Vec<&Entry> = items.iter().collect();
+ set_visible(app, folder, &refs, !gvis);
}
if r.hovered {
- acts.hover_bodies = vec![b.clone()];
+ acts.hover_bodies = items.iter().flat_map(|e| e.bodies.clone()).collect();
}
if let Some(p) = r.secondary {
- if !selected {
- let _ = app.run("select.set", json!({"items": [{"type": "body", "name": b}]}));
+ acts.menu = Some((p, Target::Group { id: g.id }));
+ }
+ 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 });
+ }
+ if gopen {
+ for e in items {
+ entry_row(app, ui, comp, fstatic, e, depth + 2, Some(g.id), &loose_keys, acts);
}
- acts.menu = Some((p, Target::Body { name: b.clone() }));
}
}
+ for e in &loose {
+ entry_row(app, ui, comp, fstatic, e, depth + 1, None, &loose_keys, acts);
+ }
+ let _ = t;
}
-fn sketch_rows(app: &mut SolveApp, ui: &mut egui::Ui, comp: u64, depth: usize, acts: &mut Actions) {
- let t = Tokens::get();
- let sketches: Vec<(u64, String)> = app
- .session
- .doc
- .features
- .iter()
- .filter(|f| f.component == comp && matches!(f.kind, FeatureKind::Sketch { .. }))
- .map(|f| (f.id, f.name.clone()))
- .collect();
- if sketches.is_empty() {
- return;
+/// One item row of a folder.
+#[allow(clippy::too_many_arguments)]
+fn entry_row(
+ app: &mut SolveApp,
+ ui: &mut egui::Ui,
+ comp: u64,
+ folder: &'static str,
+ e: &Entry,
+ depth: usize,
+ group: Option<u64>,
+ loose: &[String],
+ acts: &mut Actions,
+) {
+ app.tree.order.push(e.row_key.clone());
+ let badges: &[&str] = if e.locked { &["lock"] } else { &[] };
+ let r = draw_row(
+ ui,
+ ui.id().with(("item", &e.row_key)),
+ &Row {
+ depth,
+ eye: Some(e.visible),
+ icon: e.icon,
+ label: &e.label,
+ selected: e.selected,
+ dim: !e.visible,
+ color: e.color,
+ badges,
+ ..Default::default()
+ },
+ );
+ if folder == "bodies"
+ && app.tree.reveal.as_deref() == Some(e.key.as_str())
+ && let Some(rect) = r.rect
+ {
+ ui.scroll_to_rect(rect, Some(egui::Align::Center));
+ app.tree.reveal = None;
}
- let key = format!("c{comp}/sketches");
- let (open, r) = folder(app, ui, &key, "Sketches", depth, Some(app.ui.show_sketches));
if r.eye {
- app.ui.show_sketches = !app.ui.show_sketches;
+ set_visible(app, folder, &[e], !e.visible);
}
- if !open {
- return;
- }
- for (id, name) in sketches {
- let active = app.session.active_sketch == Some(id);
- let visible = sketch_visible(app, id);
- let selected = active || app.session.selection.iter().any(|x| matches!(x, Sel::Feature { id: f } if *f == id));
- let label = if active { format!("{name} (editing)") } else { name.clone() };
- let key = format!("s:{id}");
- app.tree.order.push(key.clone());
- let r = draw_row(
- ui,
- ui.id().with(("sketch", id)),
- &Row {
- depth: depth + 1,
- eye: Some(visible),
- icon: "sketch",
- label: &label,
- selected,
- dim: !visible,
- color: active.then_some(t.sketch_accent),
- ..Default::default()
- },
- );
- if r.eye {
- set_sketch_visible(app, id, !visible);
- }
- if r.double {
+ if r.double && folder == "sketches" {
+ if let Ok(id) = e.key.parse() {
app.edit_sketch(id);
- } else if r.clicked {
- click_select(app, ui, key, Some(Sel::Feature { id }));
}
- if let Some(p) = r.secondary {
- acts.menu = Some((p, Target::Sketch { id }));
+ } else if r.clicked {
+ if folder == "construction" {
+ if let Some(s) = e.sel.clone() {
+ pick_from_browser(app, s);
+ }
+ } else {
+ click_select(app, ui, e.row_key.clone(), e.sel.clone());
}
}
-}
-
-fn plane_rows(app: &mut SolveApp, ui: &mut egui::Ui, comp: u64, depth: usize) {
- let planes: Vec<String> = app
- .session
- .doc
- .features
- .iter()
- .filter(|f| f.component == comp && matches!(f.kind, FeatureKind::ConstructionPlane { .. }))
- .map(|f| f.name.clone())
- .collect();
- if planes.is_empty() {
- return;
+ if r.hovered && !e.bodies.is_empty() {
+ acts.hover_bodies = e.bodies.clone();
}
- let key = format!("c{comp}/construction");
- let (open, _) = folder(app, ui, &key, "Construction", depth, None);
- if !open {
- return;
+ if let Some(p) = r.secondary
+ && let Some(t) = e.target.clone()
+ {
+ if !e.selected
+ && let Some(s) = &e.sel
+ {
+ let _ = app.run("select.set", json!({ "items": [s] }));
+ }
+ acts.menu = Some((p, t));
}
- for p in planes {
- let visible = !app.ui.hidden_origin.contains(&p);
- let sel = Sel::Plane { name: p.clone() };
- let selected = app.session.selection.contains(&sel);
- let r = draw_row(
- ui,
- ui.id().with(("plane", &p)),
- &Row { depth: depth + 1, eye: Some(visible), icon: "plane", label: &p, selected, dim: !visible, ..Default::default() },
- );
- if r.eye {
- if visible {
- app.ui.hidden_origin.push(p.clone());
- } else {
- app.ui.hidden_origin.retain(|h| *h != p);
+ 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() {
+ let keys: Vec<String> = if e.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) {
+ acts.drop = Some(match group {
+ Some(g) => DropAction::Move { comp, folder, keys: d.keys.clone(), group: Some(g), before: Some(e.key.clone()) },
+ None => {
+ let mut order: Vec<String> = loose.iter().filter(|k| !d.keys.contains(k)).cloned().collect();
+ let at = order.iter().position(|k| *k == e.key).unwrap_or(order.len());
+ for (i, k) in d.keys.iter().enumerate() {
+ order.insert(at + i, k.clone());
+ }
+ DropAction::Order { comp, folder, keys: d.keys.clone(), order }
}
+ });
+ }
+}
+
+/// Keys of the selected items of a component folder.
+fn selected_keys(app: &SolveApp, comp: u64, folder: &str) -> Vec<String> {
+ entries(app, comp, folder).into_iter().filter(|e| e.selected).map(|e| e.key).collect()
+}
+
+#[derive(Clone, Copy, PartialEq)]
+enum DropMark {
+ /// A line above the row: the items go before it.
+ Above,
+ /// A box around the row: the items go into it.
+ Box,
+}
+
+/// While a matching payload hovers the row, mark where it would land; on release, the payload.
+fn drop_target(ui: &egui::Ui, resp: &egui::Response, accept: impl Fn(&Drag) -> bool, mark: DropMark) -> Option<std::sync::Arc<Drag>> {
+ let t = Tokens::get();
+ let hovering = resp.dnd_hover_payload::<Drag>().filter(|d| accept(d));
+ if hovering.is_some() {
+ let r = resp.rect;
+ match mark {
+ DropMark::Above => ui.painter().hline(r.x_range(), r.top(), Stroke::new(2.0, t.accent)),
+ DropMark::Box => ui.painter().rect_stroke(r.shrink(0.5), 3.0, Stroke::new(1.5, t.accent), egui::StrokeKind::Inside),
+ };
+ }
+ resp.dnd_release_payload::<Drag>().filter(|d| accept(d))
+}
+
+/// A drop, applied after the tree is drawn.
+enum DropAction {
+ /// Into a group (before an item of it), or out of groups.
+ Move { comp: u64, folder: &'static str, keys: Vec<String>, group: Option<u64>, before: Option<String> },
+ /// Out of groups, in this order of the folder's loose items.
+ Order { comp: u64, folder: &'static str, keys: Vec<String>, order: Vec<String> },
+ /// Into another component (bodies and sketches).
+ Component { to: u64, folder: &'static str, keys: Vec<String> },
+}
+
+fn apply_drop(app: &mut SolveApp, d: DropAction) {
+ match d {
+ DropAction::Move { comp, folder, keys, group, before } => {
+ let _ = app.run("browser.move", json!({ "component": comp, "folder": folder, "items": keys, "group": group, "before": before }));
+ }
+ DropAction::Order { comp, folder, keys, order } => {
+ let _ = app.run("browser.move", json!({ "component": comp, "folder": folder, "items": keys }));
+ let _ = app.run("browser.order", json!({ "component": comp, "folder": folder, "order": order }));
}
- if r.clicked {
- pick_from_browser(app, sel);
+ DropAction::Component { to, folder, keys } => {
+ let _ = match folder {
+ "bodies" => app.run("component.move_bodies", json!({ "bodies": keys, "component": to })),
+ "sketches" => app.run("component.move_sketches", json!({ "sketches": keys, "component": to })),
+ _ => Ok(serde_json::Value::Null),
+ };
}
}
}
@@ -676,29 +992,36 @@ fn occurrence_panel(app: &mut SolveApp, ctx: &egui::Context) {
let mut open = true;
let mut action: Option<&str> = None;
let before = (m.translate, m.angle_deg);
- egui::Window::new(format!("Move: {name}")).id(egui::Id::new("sc_occ_move")).open(&mut open).resizable(false).collapsible(false).show(ctx, |ui| {
- egui::Grid::new("sc_occ_grid").num_columns(2).spacing([12.0, 6.0]).show(ui, |ui| {
- for (k, axis) in ["X distance", "Y distance", "Z distance"].iter().enumerate() {
- ui.label(*axis);
- if let Some(v) = m.translate.get_mut(k) {
- ui.add(egui::DragValue::new(v).speed(0.5).suffix(" mm"));
+ egui::Window::new(format!("Move: {name}"))
+ .id(egui::Id::new("sc_occ_move"))
+ .default_pos(panel_pos(app))
+ .open(&mut open)
+ .resizable(false)
+ .collapsible(false)
+ .show(ctx, |ui| {
+ egui::Grid::new("sc_occ_grid").num_columns(2).spacing([12.0, 6.0]).show(ui, |ui| {
+ for (k, axis) in ["X distance", "Y distance", "Z distance"].iter().enumerate() {
+ ui.label(*axis);
+ if let Some(v) = m.translate.get_mut(k) {
+ ui.add(egui::DragValue::new(v).speed(0.5).suffix(" mm"));
+ }
+ ui.end_row();
}
+ ui.label("Z angle");
+ ui.add(egui::DragValue::new(&mut m.angle_deg).speed(1.0).suffix(" deg"));
ui.end_row();
- }
- ui.label("Z angle");
- ui.add(egui::DragValue::new(&mut m.angle_deg).speed(1.0).suffix(" deg"));
- ui.end_row();
- });
- ui.add_space(6.0);
- ui.horizontal(|ui| {
- if ui.button("Capture Position").clicked() {
- action = Some("capture");
- }
- if ui.button("Revert").clicked() {
- action = Some("revert");
- }
+ });
+ ui.add_space(6.0);
+ ui.horizontal(|ui| {
+ if ui.button("Capture Position").clicked() {
+ action = Some("capture");
+ }
+ if ui.button("Revert").clicked() {
+ action = Some("revert");
+ }
+ });
});
- });
+ gizmo(app, ctx, &mut m);
if (m.translate, m.angle_deg) != before {
// The pending move is the typed offset from where the occurrence is now.
let _ = app.session.execute("AsBuiltPositionsCmd", &json!({}));
@@ -724,6 +1047,78 @@ fn occurrence_panel(app: &mut SolveApp, ctx: &egui::Context) {
}
}
+/// Where the browser's panels open: the viewport's top left corner.
+fn panel_pos(app: &SolveApp) -> Pos2 {
+ app.viewport.rect.map(|r| r.left_top() + vec2(16.0, 16.0)).unwrap_or(pos2(270.0, 140.0))
+}
+
+/// Where an occurrence's origin is now (with its pending move).
+fn occurrence_origin(app: &SolveApp, occurrence: u64) -> Option<solvecraft_engine::geom::Vec3> {
+ let o = app.session.doc.occurrences.iter().find(|o| o.id == occurrence)?;
+ let parent = app.session.doc.component_transform(o.parent);
+ let own = app.session.pending_moves.get(&occurrence).copied().unwrap_or(o.transform);
+ Some(solvecraft_engine::doc::apply_point(&solvecraft_engine::doc::mat_mul(&parent, &own), solvecraft_engine::geom::Vec3::ZERO))
+}
+
+/// Screen length of the gizmo's arrows.
+const GIZMO_PX: f32 = 80.0;
+
+/// Arrows along X, Y and Z at the occurrence's origin: dragging one moves it along that axis.
+fn gizmo(app: &mut SolveApp, ctx: &egui::Context, m: &mut OccMove) {
+ use solvecraft_engine::geom::Vec3;
+ let t = Tokens::get();
+ let (Some(rect), Some(o)) = (app.viewport.rect, occurrence_origin(app, m.occurrence)) else { return };
+ let proj = crate::viewport::projection(app, rect);
+ let Some(p0) = proj.to_screen(o) else { return };
+ if !rect.contains(p0) {
+ return;
+ }
+ let axes = [(Vec3::X, t.axis_x), (Vec3::Y, t.axis_y), (Vec3::Z, t.axis_z)];
+ // Per axis: the screen direction and pixels per millimetre.
+ let mut arms = Vec::new();
+ for (k, (a, col)) in axes.iter().enumerate() {
+ let Some(p1) = proj.to_screen(o + *a) else { continue };
+ let d = p1 - p0;
+ let px_per_mm = d.length();
+ if px_per_mm < 1e-6 || !px_per_mm.is_finite() {
+ continue;
+ }
+ arms.push((k, d / px_per_mm, px_per_mm, *col));
+ }
+ let bbox = Rect::from_center_size(p0, vec2(2.0 * GIZMO_PX + 30.0, 2.0 * GIZMO_PX + 30.0)).intersect(rect);
+ egui::Area::new(egui::Id::new("sc_occ_gizmo")).fixed_pos(bbox.min).order(egui::Order::Middle).show(ctx, |ui| {
+ let (_, _) = ui.allocate_exact_size(bbox.size(), Sense::hover());
+ let painter = ui.painter_at(bbox);
+ for (k, dir, px_per_mm, col) in &arms {
+ // An axis seen end-on has no arrow to drag.
+ let len = GIZMO_PX * dir.length().min(1.0);
+ let tip = p0 + *dir * len;
+ let handle =
+ Rect::from_center_size(p0 + *dir * (len * 0.6), vec2(len * 0.8, len * 0.8)).intersect(Rect::from_two_pos(p0, tip).expand(9.0));
+ let resp = ui.interact(handle, ui.id().with(("arm", *k)), Sense::drag());
+ let lit = resp.hovered() || resp.dragged();
+ let w = if lit { 4.0 } else { 2.5 };
+ painter.line_segment([p0 + *dir * 10.0, tip], Stroke::new(w, *col));
+ let n = vec2(-dir.y, dir.x);
+ painter.add(egui::Shape::convex_polygon(vec![tip + *dir * 10.0, tip + n * 5.5, tip - n * 5.5], *col, Stroke::NONE));
+ if resp.dragged() {
+ let mm = resp.drag_delta().dot(*dir) / px_per_mm;
+ if let Some(v) = m.translate.get_mut(*k)
+ && mm.is_finite()
+ {
+ *v += f64::from(mm);
+ }
+ }
+ if resp.drag_stopped()
+ && let Some(v) = m.translate.get_mut(*k)
+ {
+ *v = (*v * 100.0).round() / 100.0;
+ }
+ }
+ painter.circle(p0, 6.0, t.panel, Stroke::new(1.5, t.accent));
+ });
+}
+
/// Redefine Sketch Plane: pick an origin or construction plane, or the selected planar face.
fn redefine_panel(app: &mut SolveApp, ctx: &egui::Context) {
let Some(id) = app.tree.redefine else { return };
@@ -735,6 +1130,7 @@ fn redefine_panel(app: &mut SolveApp, ctx: &egui::Context) {
let mut pick: Option<Value> = None;
egui::Window::new(format!("Redefine Sketch Plane: {name}"))
.id(egui::Id::new("sc_redefine"))
+ .default_pos(panel_pos(app))
.open(&mut open)
.resizable(false)
.collapsible(false)
diff --git a/crates/ui-egui/src/context_menu.rs b/crates/ui-egui/src/context_menu.rs
index ab38c08d8d..95fdf336a0 100644
--- a/crates/ui-egui/src/context_menu.rs
+++ b/crates/ui-egui/src/context_menu.rs
@@ -34,10 +34,15 @@ pub enum Target {
Component {
id: u64,
},
- /// A browser group (folder) of items.
+ /// A browser group of items.
Group {
id: u64,
},
+ /// A component's Bodies, Sketches or Construction folder.
+ Folder {
+ component: u64,
+ folder: String,
+ },
}
/// One menu entry: a command id (run with `params` when given, else started like a toolbar
@@ -54,7 +59,11 @@ pub struct Item {
}
impl Item {
- fn sep() -> Item {
+ /// A view action (`ui.*`).
+ pub fn action(id: &str, label: &str, icon: &str) -> Item {
+ act(id, label, icon)
+ }
+ pub fn sep() -> Item {
Item { id: "-".into(), label: String::new(), shortcut: String::new(), enabled: false, icon: String::new(), params: None }
}
fn heading(label: &str) -> Item {
@@ -66,7 +75,7 @@ impl Item {
fn is_heading(&self) -> bool {
self.id.starts_with('#')
}
- fn with(mut self, params: Value) -> Item {
+ pub fn with(mut self, params: Value) -> Item {
self.params = Some(params);
self
}
@@ -186,7 +195,7 @@ pub fn target_bodies(app: &SolveApp, target: &Target) -> Vec<String> {
Target::Body { name } => vec![name.clone()],
Target::Component { id } => component_bodies(app, *id),
Target::Group { id } => crate::browser::group_bodies(app, *id),
- Target::Sketch { .. } => Vec::new(),
+ Target::Sketch { .. } | Target::Folder { .. } => Vec::new(),
}
}
@@ -236,13 +245,20 @@ pub fn radial_items(app: &SolveApp) -> Vec<Item> {
/// The list of a menu (under the ring for the viewport).
pub fn items(app: &SolveApp, target: &Target) -> Vec<Item> {
- match target {
+ let mut v = match target {
Target::Viewport => viewport_items(app),
Target::Body { name } => body_items(app, std::slice::from_ref(name), true),
Target::Sketch { id } => sketch_items(app, *id),
Target::Component { id } => component_items(app, *id),
Target::Group { id } => crate::browser::group_items(app, *id),
+ Target::Folder { component, folder } => crate::browser::folder_items(app, *component, folder),
+ };
+ // Several items of the folder selected: they can be grouped.
+ if let Some(p) = crate::browser::selection_group(app, target) {
+ v.push(Item::sep());
+ v.push(act("ui.groupSelected", "Group Selected", "folder").with(p));
}
+ v
}
fn viewport_items(app: &SolveApp) -> Vec<Item> {
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index 204d17dd34..613c56aaa8 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -192,6 +192,8 @@ impl SolveApp {
"pick_bodies": self.ui.pick_bodies,
"auto_project": self.session.auto_project,
"visual_style": self.ui.visual_style,
+ "browser_collapsed": self.tree.collapsed,
+ "browser_expanded": self.tree.expanded,
})
.to_string()
}
@@ -218,6 +220,15 @@ impl SolveApp {
if let Some(s) = v.get("visual_style").and_then(Value::as_u64) {
self.ui.visual_style = u8::try_from(s.min(2)).unwrap_or(0);
}
+ // Browser folders the user opened or closed.
+ let keys = |k: &str| -> std::collections::BTreeSet<String> {
+ v.get(k)
+ .and_then(Value::as_array)
+ .map(|a| a.iter().take(10_000).filter_map(|x| x.as_str().map(str::to_string)).collect())
+ .unwrap_or_default()
+ };
+ self.tree.collapsed = keys("browser_collapsed");
+ self.tree.expanded = keys("browser_expanded");
}
pub fn with_control(mut self, rx: Receiver<ControlRequest>) -> Self {
diff --git a/crates/ui-egui/src/menu_tests.rs b/crates/ui-egui/src/menu_tests.rs
index 1238e2bfc8..beb9a49483 100644
--- a/crates/ui-egui/src/menu_tests.rs
+++ b/crates/ui-egui/src/menu_tests.rs
@@ -162,3 +162,39 @@ fn pick_runs_an_item_of_the_open_menu() {
assert!(app.viewport.context_menu.is_none(), "a pick closes the menu");
assert!(!app.ui.show_origin);
}
+
+#[test]
+fn folder_and_group_menus_make_rename_and_drop_groups() {
+ let mut app = sample_app();
+ app.run("PrimitiveBox", json!({"length": 5, "width": 5, "height": 5, "corner": [200, 0, 0]})).unwrap();
+ let names: Vec<String> = app.session.model.state().bodies.iter().map(|b| b.name.clone()).collect();
+ let items: Vec<_> = names.iter().map(|n| json!({"type": "body", "name": n})).collect();
+ app.run("select.set", json!({ "items": items })).unwrap();
+ let folder = Target::Folder { component: 0, folder: "bodies".into() };
+ act(&mut app, &folder, "Group Selected");
+ let g = app.session.doc.browser_groups[0].clone();
+ assert_eq!(g.items.len(), 2);
+ // A body's menu offers grouping too while several are selected.
+ assert!(context_menu::items(&app, &Target::Body { name: names[0].clone() }).iter().any(|i| i.label == "Group Selected"));
+ let t = Target::Group { id: g.id };
+ act(&mut app, &t, "Rename");
+ assert!(context_menu::finish_rename(&mut app, Some("Parts"), true));
+ assert_eq!(app.session.doc.browser_groups[0].name, "Parts");
+ act(&mut app, &t, "Hide");
+ assert_eq!(app.ui.hidden_bodies.len(), 2);
+ act(&mut app, &t, "Ungroup");
+ assert!(app.session.doc.browser_groups.is_empty());
+ act(&mut app, &folder, "New Group");
+ assert_eq!(app.session.doc.browser_groups[0].items.len(), 0);
+}
+
+#[test]
+fn browser_folds_are_kept_in_the_preferences() {
+ let mut app = sample_app();
+ app.tree.collapsed.insert("c0/sketches".into());
+ app.tree.expanded.insert("origin".into());
+ let prefs = app.prefs();
+ let mut other = sample_app();
+ other.load_prefs(&prefs);
+ assert!(other.tree.collapsed.contains("c0/sketches") && other.tree.expanded.contains("origin"));
+}
diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rs
index 42905c7b63..eedaa19e13 100644
--- a/crates/ui-egui/src/viewport.rs
+++ b/crates/ui-egui/src/viewport.rs
@@ -187,7 +187,8 @@ fn build_scene(app: &SolveApp) -> GpuScene {
let tk = Tokens::get();
let mut sc = GpuScene::default();
let s = &app.session;
- let st = s.model.state();
+ // Bodies where their occurrences place them.
+ let st = s.world_state();
if app.ui.show_grid {
let (minor, major) = grid_step(app.cam.half_height());
let ext = (app.cam.half_height() * 3.0 / major).ceil() * major;
@@ -301,7 +302,7 @@ pub fn construction_quads(app: &SolveApp) -> Vec<(String, Vec3, [Vec3; 4])> {
/// the surfaces along the ray (profiles, faces, planes) nearest first.
pub fn pick(app: &SolveApp, proj: &Proj, pos: Pos2) -> Vec<Hit> {
let s = &app.session;
- let st = s.model.state();
+ let st = s.world_state();
let mut hits = Vec::new();
let (o, d) = proj.ray(pos);
// Sketch points of the active sketch.
@@ -604,7 +605,7 @@ fn highlight_key(app: &SolveApp) -> u64 {
fn build_highlight(app: &SolveApp) -> GpuScene {
let t = Tokens::get();
let mut sc = GpuScene::default();
- let st = app.session.model.state();
+ let st = app.session.world_state();
let sel = app.highlighted();
let hover = app.viewport.hover.as_ref();
let size = origin_size(app.cam.half_height());
@@ -1106,7 +1107,7 @@ fn select(app: &mut SolveApp, sel: Option<Sel>, add: bool) {
/// active input takes (edges, faces or bodies), otherwise bodies.
fn box_select(app: &mut SolveApp, proj: &Proj, bx: BoxSel, add: bool) {
use crate::selection::{BODIES, EDGES, FACES, PROFILES};
- let st = app.session.model.state();
+ let st = app.session.world_state();
let mut out: Vec<Sel> = Vec::new();
let to2 = |pts: &[Vec3]| -> Vec<Pos2> { pts.iter().filter_map(|p| proj.to_screen(*p)).collect() };
if app.dialog.is_none()